logger.py

HADOOP 0.18.0安装源代码头文件

                syslogData = "%s:%s" % (address[0], address[1])
                self.__add_to_handlers('syslog', loggerName, syslogHandler,
                    syslogData, loggingLevel)

        if addToLoggerNames:
            for loggerName in addToLoggerNames:
                add_syslog_handler(loggerName)
        else:
            for loggerName in self.__loggerNames:
                add_syslog_handler(loggerName)      
      

    def add_smtp(self, mailHost, fromAddress, toAddresses,
        level=defaultSmtpLevel, addToLoggerNames=None):
        """Adds an SMTP handler to all defined loggers or a specified set of
           loggers.

           mailHost         - SMTP server to used when sending mail
           fromAddress      - email address to use as the from address when
                              sending mail
           toAdresses       - comma seperated list of email address to which
                              mail will be sent
           level            - cluster management log level
           addToLoggerNames - tupple of logger names to which smtp handling
                              will be added"""

        def add_email_handler(loggerName):
            if not self.__logObjs['smtp'].has_key(loggerName):
                loggingLevel = self.__get_logging_level(level,
                    defaultSmtpLevel)

                subject = loggerName
                if   loggingLevel == 50:
                    subject = "%s - a critical error has occured." % subject
                elif loggingLevel == 40:
                    subject = "%s - an error has occured."         % subject
                elif loggingLevel == 30:
                    subject = "%s - warning message."              % subject
                elif loggingLevel == 20:
                    subject = "%s - information message."          % subject
                elif loggingLevel == 10:
                    subject = "%s - debugging message."            % subject

                mailHostTuple = get_address_tuple(mailHost)
                emailHandler = logging.handlers.SMTPHandler(mailHostTuple,
                    fromAddress, toAddresses, subject)

                emailHandler.setFormatter(smtpFormater)
                emailHandler.setLevel(loggingLevel)

                loggingLoggerName = self.__get_logging_logger_name(loggerName)
                aLogger = logging.getLogger(loggingLoggerName)
                aLogger.addHandler(emailHandler)

                emailData = "%s from %s" % (mailHost, fromAddress)
                self.__add_to_handlers('smtp', loggerName, emailHandler,
                    emailData, loggingLevel)

        if addToLoggerNames:
            for loggerName in addToLoggerNames:
                add_email_handler(loggerName)
        else:
            for loggerName in self.__loggerNames:
                add_email_handler(loggerName)

    def status(self):
        statusStruct = {}
        for loggerName in self.__loggerNames.keys():
            statusStruct[loggerName] = []
            for handlerClass in self.__logObjs.keys():
                loggerDict = {}
                try:
                    level = self.__logObjs[handlerClass][loggerName]['level']
                    level = rehodLogLevelMap[level]

                    loggerDict['handler'] = handlerClass
                    loggerDict['level'] = level
                    loggerDict['data'] = \
                        self.__logObjs[handlerClass][loggerName]['data']
                except:
                    pass
                else:
                    statusStruct[loggerName].append(loggerDict)

        return statusStruct

    def lock_handlers(self):
        for handlerClass in self.__logObjs.keys():
            for loggerName in self.__logObjs[handlerClass].keys():
                self.__logObjs[handlerClass][loggerName]['handler'].acquire()

    def release_handlers(self):
        for handlerClass in self.__logObjs.keys():
            for loggerName in self.__logObjs[handlerClass].keys():
                self.__logObjs[handlerClass][loggerName]['handler'].release()

    def get_level(self, handler, loggerName):
        return rehodLogLevelMap[self.__logObjs[handler][loggerName]['level']]

    def set_level(self, handler, loggerName, level):
        """Sets the logging level of a particular logger and logger handler.

           handler    - handler (smtp, file, or stream)
           loggerName - logger to set level on
           level      - level to set logger
        """

        level = self.__get_logging_level(level, defaultFileLevel)
        self.__logObjs[handler][loggerName]['handler'].setLevel(level)
        self.__logObjs[handler][loggerName]['level'] = level
        
        if handler == 'stream':
            self.__logObjs[handler][loggerName]['handler'].setFormatter(
                hodStreamFormatMap[int(level)])

    def set_logger_level(self, loggerName, level):
        status = 0
        for handlerClass in self.__logObjs.keys():
            if self.__logObjs[handlerClass].has_key(loggerName):
                self.set_level(handlerClass, loggerName, level)
            else:
                status = 1
        
        return status

    def rollover(self, loggerName):
        status = 0 
        if self.__logObjs['file'].has_key(loggerName):
            if self.__logObjs['file'][loggerName]['handler'].shouldRollover():
                self.__logObjs['file'][loggerName]['handler'].doRollover()
        else:
            status = 1
            
        return status
        
    def set_max_bytes(self, maxBytes):
        status = 0
        if self.__logObjs.has_key('file'):
            for loggerName in self.__logObjs['file'].keys():
                self.__logObjs['file'][loggerName]['handler'].maxBytes = 0
        else:
            status = 1
            
        return status

    def get_logger(self, loggerName):
        """ Returns a hodLogger object for a logger by name. """

        loggingLoggerName = self.__get_logging_logger_name(loggerName)
        return hodLogger(self.__appName, loggingLoggerName)

    def critical(self, loggerName, msg):
        """Logs a critical message and flushes log buffers.  This method really
           should only be called upon a catastrophic failure.

           loggerName - logger to use
           msg        - message to be logged"""

        loggingLoggerName = self.__get_logging_logger_name(loggerName)
        logger = logging.getLogger(loggingLoggerName)
        logger.critical(msg)
        self.flush()

    def error(self, loggerName, msg):
        """Logs an error message and flushes log buffers.

           loggerName - logger to use
           msg        - message to be logged"""

        loggingLoggerName = self.__get_logging_logger_name(loggerName)
        logger = logging.getLogger(loggingLoggerName)
        logger.error(msg)
        self.flush()

    def warn(self, loggerName, msg):
        """Logs a warning message.

           loggerName - logger to use
           msg        - message to be logged"""

        loggingLoggerName = self.__get_logging_logger_name(loggerName)
        logger = logging.getLogger(loggingLoggerName)
        logger.warn(msg)

    def info(self, loggerName, msg):
        """Logs an information message.

           loggerName - logger to use
           msg        - message to be logged"""

        loggingLoggerName = self.__get_logging_logger_name(loggerName)
        logger = logging.getLogger(loggingLoggerName)
        logger.info(msg)

    def debug(self, loggerName, msg):
        """Logs a debugging message.

           loggerName - logger to use
           msg        - message to be logged"""

        loggingLoggerName = self.__get_logging_logger_name(loggerName)
        logger = logging.getLogger(loggingLoggerName)
        logger.debug(msg)

    def flush(self):
        """Flush all log handlers."""

        for handlerClass in self.__logObjs.keys():
            for loggerName in self.__logObjs[handlerClass].keys():
                self.__logObjs[handlerClass][loggerName]['handler'].flush()

    def shutdown(self):
        """Shutdown all logging, flushing all buffers."""

        for handlerClass in self.__logObjs.keys():
            for loggerName in self.__logObjs[handlerClass].keys():
                self.__logObjs[handlerClass][loggerName]['handler'].flush()
                # Causes famous 'ValueError: I/O operation on closed file'
                # self.__logObjs[handlerClass][loggerName]['handler'].close()

class hodLogger:
    """ Encapsulates a particular logger from a hodLog object. """
    def __init__(self, appName, loggingLoggerName):
        """Constructs a hodLogger object (a particular logger in a hodLog
           object).

           loggingLoggerName - name of a logger in hodLog object"""

        self.__appName = appName
        self.__loggerName = loggingLoggerName
        self.__logger = logging.getLogger(self.__loggerName)

    def __repr__(self):
        """Returns a string representation of a hodComponentLog object."""

        return "%s hodLog" % self.__loggerName

    def __call__(self):
        pass

    def set_logger_level(self, loggerName, level):
        
        return hodLogs[self.__appName].set_logger_level(loggerName, level)
        
    def set_max_bytes(self, maxBytes):
            
        return hodLogs[self.__appName].set_max_bytes(maxBytes)

    def rollover(self):
        return hodLogs[self.__appName].rollover(self.__loggerName)

    def get_level(self, handler, loggerName):
    
        return hodLogs[self.__appName].get_level(handler, loggerName)
        
    def critical(self, msg):
        """Logs a critical message and calls sys.exit(1).

           msg     - message to be logged"""

        self.__logger.critical(msg)

    def error(self, msg):
        """Logs an error message.

           msg     - message to be logged"""

        self.__logger.error(msg)

    def warn(self, msg):
        """Logs a warning message.

           msg     - message to be logged"""

        self.__logger.warn(msg)

    def info(self, msg):
        """Logs an information message.

           msg     - message to be logged"""

        self.__logger.info(msg)

    def debug(self, msg):
        """Logs a debugging message.

           msg     - message to be logged"""

        self.__logger.debug(msg)

class hodDummyLogger:
    """ Dummy hodLogger class.  Other hod classes requiring a hodLogger default
        to this hodLogger if no logger is passed."""

    def __init__(self):
        """pass"""

        pass

    def __repr__(self):
        return "dummy hodLogger"

    def __call__(self):
        """pass"""

        pass

    def set_logger_level(self, loggerName, level):
        
        return 0
        
    def set_max_bytes(self, loggerName, maxBytes):
            
        return 0

    def get_level(self, handler, loggerName):
        
        return 4

    def rollover(self):
        
        return 0

    def critical(self, msg):
        """pass"""

        pass

    def error(self, msg):
        """pass"""

        pass

    def warn(self, msg):
        """pass"""

        pass

    def info(self, msg):
        """pass"""

        pass

    def debug(self, msg):
        """pass"""

        pass

def ensureLogDir(logDir):
  """Verify that the passed in log directory exists, and if it doesn't
  create it."""
  if not os.path.exists(logDir):
    try:
      old_mask = os.umask(0)
      os.makedirs(logDir, 01777)
      os.umask(old_mask)
    except Exception, e:
      print >>sys.stderr, "Could not create log directories %s. Exception: %s. Stack Trace: %s" % (logDir, get_exception_error_string(), get_exception_string())
      raise e

def getLogger(cfg, logName):
  if cfg['debug'] > 0:
    user = cfg['userid']
    baseLogger = hodLog(logName)
    log = baseLogger.add_logger('main')

    if cfg.has_key('log-dir'):
      serviceId = os.getenv('PBS_JOBID')
      if serviceId:
        logDir = os.path.join(cfg['log-dir'], "%s.%s" % (user, serviceId))
      else:
        logDir = os.path.join(cfg['log-dir'], user) 
      if not os.path.exists(logDir):
        os.mkdir(logDir)

      baseLogger.add_file(logDirectory=logDir, level=cfg['debug'], 
               addToLoggerNames=('main',))

    try:
      if cfg.has_key('stream') and cfg['stream']:
        baseLogger.add_stream(level=cfg['debug'], addToLoggerNames=('main',))

      if cfg.has_key('syslog-address'):
        baseLogger.add_syslog(cfg['syslog-address'], 
          level=cfg['debug'], addToLoggerNames=('main',))
    except Exception,e:
      # Caught an exception while initialising logger
      log.critical("%s Logger failed to initialise. Reason : %s" % (logName, e))
      pass
    return log