#Licensed to the Apache Software Foundation (ASF) under one #or more contributor license agreements. See the NOTICE file #distributed with this work for additional information #regarding copyright ownership. The ASF licenses this file #to you under the Apache License, Version 2.0 (the #"License"); you may not use this file except in compliance #with the License. You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0 #Unless required by applicable law or agreed to in writing, software #distributed under the License is distributed on an "AS IS" BASIS, #WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #See the License for the specific language governing permissions and #limitations under the License. """hodLogger provides a customized interface to Python's core logging package. """ import sys, os, re, logging, logging.handlers, inspect, pprint, types from tcp import get_address_tuple fileFormatString = '[%(asctime)s] %(levelname)s/%(levelno)s \ %(module)s:%(lineno)s - %(message)s' streamFormatString = '%(levelname)s - %(message)s' debugStreamFormatString = '[%(asctime)s] %(levelname)s/%(levelno)s \ %(module)s:%(lineno)s - %(message)s' syslogFormatString = '(%(process)d) %(levelname)s/%(levelno)s \ %(module)s:%(lineno)s - %(message)s' smtpFormatString = '[%(asctime)s] %(levelname)s/%(levelno)s \ %(module)s:%(lineno)s\n\n%(message)s' fileFormater = logging.Formatter(fileFormatString) streamFormater = logging.Formatter(streamFormatString) debugStreamFormater = logging.Formatter(debugStreamFormatString) syslogFormater = logging.Formatter(syslogFormatString) smtpFormater = logging.Formatter(smtpFormatString) defaultFileLevel = 3 defaultStreamLevel = 4 defaultSyslogLevel = 3 defaultSmtpLevel = 0 hodLogLevelMap = { 0 : logging.CRITICAL, 1 : logging.ERROR, 2 : logging.WARNING, 3 : logging.INFO, 4 : logging.DEBUG } hodStreamFormatMap = { 0 : streamFormater, 1 : streamFormater, 2 : streamFormater, 3 : streamFormater, 4 : debugStreamFormater } rehodLogLevelMap = {} for key in hodLogLevelMap.keys(): rehodLogLevelMap[hodLogLevelMap[key]] = key reModule = re.compile("^(.*)\..*$") hodLogs = {} class hodRotatingFileHandler(logging.handlers.RotatingFileHandler): """ This class needs to be used in place of RotatingFileHandler when the 2.4.0 Python interpreter is used.""" def emit(self, record): """ Emit a record. If a formatter is specified, it is used to format the record. The record is then written to the stream with a trailing newline [N.B. this may be removed depending on feedback]. If exception information is present, it is formatted using traceback.print_exception and appended to the stream. ***** THIS IS A HACK, when instances of hodLogger get passed to the child of a child thread for some reason self.stream gets closed. This version of emit re-opens self.stream if it is closed. After testing it appears that self.stream is only closed once after the second thread is initialized so there is not performance penalty to this hack. This problem only exists in python 2.4. ***** """ try: if self.shouldRollover(record): self.doRollover() try: msg = self.format(record) fs = "%s\n" if not hasattr(types, "UnicodeType"): #if no unicode support... self.stream.write(fs % msg) else: try: self.stream.write(fs % msg) except UnicodeError: self.stream.write(fs % msg.encode("UTF-8")) except ValueError: self.stream = open(self.baseFilename, self.mode) self.stream.write(fs % msg) self.flush() except: self.handleError(record) except: self.handleError(record) def shouldRollover(self, record): """ Determine if rollover should occur. Basically, see if the supplied record would cause the file to exceed the size limit we have. ***** THIS IS A HACK, when instances of hodLogger get passed to the child of a child thread for some reason self.stream gets closed. This version of emit re-opens self.stream if it is closed. After testing it appears that self.stream is only closed once after the second thread is initialized so there is not performance penalty to this hack. This problem only exists in python 2.4. ***** """ if self.maxBytes > 0: # are we rolling over? msg = "%s\n" % self.format(record) try: #due to non-posix-compliant Windows feature self.stream.seek(0, 2) except ValueError: self.stream = open(self.baseFilename, self.mode) self.stream.seek(0, 2) if self.stream.tell() + len(msg) >= self.maxBytes: return 1 return 0 class hodCustomLoggingLogger(logging.Logger): """ Slight extension of the logging.Logger class used by the hodLog class. """ def findCaller(self): """ findCaller() is supposed to return the callers file name and line number of the caller. This was broken when the logging package was wrapped by hodLog. We should return much more relevant info now. """ callerModule = '' callerLine = 0 currentModule = os.path.basename(__file__) currentModule = reModule.sub("\g<1>", currentModule) frames = inspect.stack() for i in range(len(frames)): frameModule = os.path.basename(frames[i][1]) frameModule = reModule.sub("\g<1>", frameModule) if frameModule == currentModule: previousFrameModule = os.path.basename(frames[i+1][1]) previousFrameModule = reModule.sub("\g<1>", previousFrameModule) callerFile = frames[i+1][1] callerLine = frames[i+1][2] continue returnValues = (callerFile, callerLine) if sys.version.startswith('2.4.4') or sys.version.startswith('2.5'): returnValues = (callerFile, callerLine, None) return returnValues class hodLog: """ Cluster management logging class. logging levels: 0 - log only critical messages 1 - log critical and error messages 2 - log critical, error, and warning messages 3 - log critical, error, warning, and info messages 4 - log critical, error, warning, info, and debug messages""" def __init__(self, appName): """Constructs a hodLogger object. appName - name of logging application, log filenames will be prepended with this name""" self.__appName = appName # initialize a dictionary to hold loggerNames self.__loggerNames = {} # initialize a dictionary to track log handlers and handler classes self.__logObjs = { 'file' : {}, 'smtp' : {}, 'syslog' : {}, 'strm' : {} } # use a custom logging.Logger class logging.setLoggerClass(hodCustomLoggingLogger) # get the root app logger self.__logger = logging.getLogger(appName) self.__logger.setLevel(logging.DEBUG) hodLogs[self.__appName] = self def __attr__(self, attrname): """loggerNames - list of defined logger names""" if attrname == "loggerNames": return self.__loggerNames.keys() else: raise AttributeError, attrname def __repr__(self): """Returns a string representation of a hodLog object of the form: LOG_NAME file: FILENAME (level LEVEL) smtp: SMTP_SERVER from FROM_ADDRESS (level LEVEL) strm: STRM_OBJECT (level LEVEL) ... """ hodLogString = "hodLog: %s\n\n" % self.__appName for loggerName in self.__loggerNames.keys(): hodLogString = "%s logger: %s\n" % (hodLogString, loggerName) handlerClasses = self.__logObjs.keys() handlerClasses.sort() for handlerClass in handlerClasses: try: loggerLevelName = logging.getLevelName( self.__logObjs[handlerClass][loggerName]['level']) hodLogString = "%s %s: %s (level %s)\n" % ( hodLogString, handlerClass, self.__logObjs[handlerClass][loggerName]['data'], loggerLevelName) except: hodLogString = "%s %s: none\n" % ( hodLogString, handlerClass) hodLogString = "%s\n" % hodLogString return hodLogString # 'private' method which adds handlers to self.__logObjs def __add_to_handlers(self, handlerClass, loggerName, handler, data, level): self.__logObjs[handlerClass][loggerName] = {} self.__logObjs[handlerClass][loggerName]['handler'] = handler self.__logObjs[handlerClass][loggerName]['data'] = data self.__logObjs[handlerClass][loggerName]['level'] = level # 'private' method which determines whether a hod log level is valid and # returns a valid logging.Logger level def __get_logging_level(self, level, defaultLevel): loggingLevel = '' try: loggingLevel = hodLogLevelMap[int(level)] except: loggingLevel = hodLogLevelMap[defaultLevel] return loggingLevel # make a logging.logger name rootLogger.childLogger in our case the # appName.componentName def __get_logging_logger_name(self, loggerName): return "%s.%s" % (self.__appName, loggerName) def add_logger(self, loggerName): """Adds a logger of name loggerName. loggerName - name of component of a given application doing the logging Returns a hodLogger object for the just added logger.""" try: self.__loggerNames[loggerName] except: loggingLoggerName = self.__get_logging_logger_name(loggerName) logging.getLogger(loggingLoggerName) self.__loggerNames[loggerName] = 1 return hodLogger(self.__appName, loggingLoggerName) def add_file(self, logDirectory, maxBytes=0, backupCount=0, level=defaultFileLevel, addToLoggerNames=None): """Adds a file handler to all defined loggers or a specified set of loggers. Each log file will be located in logDirectory and have a name of the form appName-loggerName.log. logDirectory - logging directory maxBytes - maximum log size to write in bytes before rotate backupCount - number of rotated logs to keep level - cluster management log level addToLoggerNames - list of logger names to which stream handling will be added""" def add_file_handler(loggerName): if not self.__logObjs['file'].has_key(loggerName): loggingLevel = self.__get_logging_level(level, defaultFileLevel) logFile = os.path.join(logDirectory, "%s-%s.log" % ( self.__appName, loggerName)) logFilePresent = False if(os.path.exists(logFile)): logFilePresent = True if sys.version.startswith('2.4'): fileHandler = hodRotatingFileHandler(logFile, maxBytes=maxBytes, backupCount=backupCount) else: fileHandler = logging.handlers.RotatingFileHandler(logFile, maxBytes=maxBytes, backupCount=backupCount) if logFilePresent and backupCount: fileHandler.doRollover() fileHandler.setLevel(loggingLevel) fileHandler.setFormatter(fileFormater) loggingLoggerName = self.__get_logging_logger_name(loggerName) aLogger = logging.getLogger(loggingLoggerName) aLogger.addHandler(fileHandler) fileData = "%s" % logFile self.__add_to_handlers('file', loggerName, fileHandler, fileData, loggingLevel) if addToLoggerNames: for loggerName in addToLoggerNames: add_file_handler(loggerName) else: for loggerName in self.__loggerNames: add_file_handler(loggerName) def add_stream(self, stream=sys.stderr, level=defaultStreamLevel, addToLoggerNames=None): """Adds a stream handler to all defined loggers or a specified set of loggers. stream - a stream such as sys.stderr or sys.stdout level - cluster management log level addToLoggerNames - tupple of logger names to which stream handling will be added""" def add_stream_handler(loggerName): if not self.__logObjs['strm'].has_key(loggerName): loggingLevel = self.__get_logging_level(level, defaultStreamLevel) streamHandler = logging.StreamHandler(stream) streamHandler.setLevel(loggingLevel) streamHandler.setFormatter(hodStreamFormatMap[int(level)]) loggingLoggerName = self.__get_logging_logger_name(loggerName) aLogger = logging.getLogger(loggingLoggerName) aLogger.addHandler(streamHandler) streamData = "%s" % stream self.__add_to_handlers('strm', loggerName, streamHandler, streamData, loggingLevel) if addToLoggerNames: for loggerName in addToLoggerNames: add_stream_handler(loggerName) else: for loggerName in self.__loggerNames: add_stream_handler(loggerName) def add_syslog(self, address, level=defaultSyslogLevel, addToLoggerNames=None): def add_syslog_handler(loggerName): if not self.__logObjs['syslog'].has_key(loggerName): loggingLevel = self.__get_logging_level(level, defaultSyslogLevel) address[1] = int(address[1]) syslogHandler = logging.handlers.SysLogHandler(tuple(address), 9) syslogHandler.setLevel(loggingLevel) syslogHandler.setFormatter(syslogFormater) loggingLoggerName = self.__get_logging_logger_name(loggerName) aLogger = logging.getLogger(loggingLoggerName) aLogger.addHandler(syslogHandler) 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