ActiveState Code

#------------------------------------------------------------------------------
# Copyright (c) 2009  Alex Omoto
# 
#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
#  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
#  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
#  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
#  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
#  THE SOFTWARE.
#
#------------------------------------------------------------------------------
""" 
rt_logging - A run-time configurable extension to Python's 'logging' module.
Features: 
- logging configuration is re-loaded whenever settings file is modified
- logging configuration is persistent over python sessions
- transparent in usage (other than import)
Usage:
>>> # Usage is the same except we import rt_logging instead
>>> from rt_logging import *
>>>
>>> # Create a log config
>>> root = getLogger('root')
>>> log1 = getLogger('log1')
>>> log2 = getLogger('log1.log2')
>>>
>>> # Modify the level, handler, or format of log2 while this runs...
>>> # Default configuration file is logconf.ini
>>> for i in range(1000):
>>>     log2.info('testing')
>>>     import time; time.sleep(1)
>>>     
"""
# Python modules
import os
import sys
from logging import *
from ConfigParser import ConfigParser
#-------------------------------------------------------------
#  Global
#-------------------------------------------------------------
_logconf = os.path.join(os.path.dirname(__file__), 'logconf.ini')
#-------------------------------------------------------------
#  Run-Time Classes
#-------------------------------------------------------------
class RtLogger(Logger):
    """ Run-Time Logger class """  
    
    def __init__(self, *args, **kwargs):
        """ Initialize Logger Config file and settings """
        
        # Run Base Logger init
        ret = Logger.__init__(self, *args, **kwargs)
        
        # Setup a default logging config
        handler = StreamHandler()  
        handler.setFormatter(Formatter('%(asctime)-s %(module)-15s %(levelname)-8s %(message)s'))        
        handler.stream = sys.stdout
        handler.level  = DEBUG
        self.addHandler(handler)
        self.level     = DEBUG
        self.propagate = False
        
        # Set the logging config file and keep timestamp to compare later
        self.config = _logconf
        self.config_mtime = os.path.getmtime(self.config)        
        
        return ret
        
    
    def _log(self, *args, **kwargs):
        """ Check if we should re-load config file before logging """
        
        # Re-load if config file was modified 
        if os.path.getmtime(self.config) != self.config_mtime:                        
            try:                 
                loadConfig(self.config)
            except Exception:  
                saveConfig(self.config) # Overwrite if failed to load
                self.warning('Cannot load logging configuration %s' % self.config)
                                
            self.config_mtime = os.path.getmtime(self.config)
        
        return Logger._log(self, *args, **kwargs)
class RtLogManager(Manager):
    """ Run-Time Log Manager """
    
    def getLogger(self, name, saveconfig=1):
        """ Save the config whenever we create a new Logger """        
        logexists = int(name in self.loggerDict)
        
        ret = Manager.getLogger(self, name)        
        self.config = ret.config
        
        if saveconfig and not logexists:  
            saveConfig(ret.config)        
        
        return ret
#-------------------------------------------------------------
#  Local functions
#-------------------------------------------------------------
def loadConfig(fname):
    """ Loads a logging configuration from file """
        
    # Read Config file
    cp = ConfigParser()
    cp.read(fname)
    
    handlers   = {}
    formatters = {}    
    lognames   = cp.get('loggers', 'keys').split(',')
    handnames  = cp.get('handlers', 'keys').split(',')
    formnames  = cp.get('formatters', 'keys').split(',')        
    
    # Populate Manager w/ logging configuration (formats, handlers, loggers)
    for key in formnames:
        sec  = 'formatter_' + key        
        formatter = Formatter()
        formatter._fmt    = cp.get(sec, 'format', raw=1)
        formatter.datefmt = cp.get(sec, 'datefmt')
        formatters[key] = formatter
                      
    for key in handnames:
        sec  = 'handler_' + key        
        handler = eval(cp.get(sec, 'class'))()        
        props = dict(cp.items(sec))
        props.pop('class')
        props.pop('level')
        _setHandlerProps(handler, props)
        handler.level     = eval(cp.get(sec, 'level'))
        handler.formatter = formatters[cp.get(sec, 'formatter')]
        handlers[key] = handler
            
    for key in lognames:    
        sec = 'logger_' + key        
        if key in root.manager.loggerDict:
            logger = root.manager.loggerDict[key]
        else:
            logger = root.manager.getLogger(key, saveconfig=0)            
        logger.level     = eval(cp.get(sec, 'level'))
        logger.propagate = eval(cp.get(sec, 'propagate'))
        logger.handlers  = [handlers[h] for h in cp.get(sec, 'handlers').split(',')]
        #logger.channel   = cp.get(sec, 'channel')
        #logger.parent    = cp.get(sec, 'parent')
                   
    
def saveConfig(fname):
    """ Saves logging configuration to enable persistence """
    
    # Retrieve loggers, handlers, formatters
    loggers    = root.manager.loggerDict    
    handlers   = {}
    formatters = {}
    
    for logger in loggers.values():
        for n, handler in enumerate(logger.handlers):
            handlers[logger.name + '.hand%02d' % n] = handler                 
            formatters[logger.name + '.form%02d' % n] = handler.formatter
                  
    # Setup config file by imitating output from logconf.py
    cp = ConfigParser()
 
    cp.add_section('loggers')
    cp.add_section('handlers')
    cp.add_section('formatters')
    
    cp.set('loggers', 'keys', ','.join(sorted(loggers.keys())))
    cp.set('handlers', 'keys', ','.join(sorted(handlers.keys())))
    cp.set('formatters', 'keys', ','.join(sorted(formatters.keys())))
    
    for key, logger in loggers.items():    
        sec  = 'logger_' + key
        cp.add_section(sec)
        cp.set(sec, 'level', _getLevelName(logger.level))
        cp.set(sec, 'propagate', bool(logger.propagate))
        cp.set(sec, 'qualname', logger.name)
        cp.set(sec, 'handlers', ','.join(sorted([k for k, handler in handlers.items() if handler in logger.handlers])))
        cp.set(sec, 'channel', logger.name.split('.')[-1])        
        cp.set(sec, 'parent', (logger.parent.name == 'root') and '(root)' or logger.parent.name)
        
    for key, handler in handlers.items():
        sec  = 'handler_' + key
        cp.add_section(sec)
        cp.set(sec, 'class', str(handler.__class__).split('.')[-1])
        cp.set(sec, 'level', _getLevelName(handler.level))
        cp.set(sec, 'formatter', key.replace('hand', 'form'))        
        for prop, val in _getHandlerProps(handler).items():            
            cp.set(sec, prop, val)
        
    for key, formatter in formatters.items():
        sec  = 'formatter_' + key
        cp.add_section(sec)
        cp.set(sec, 'format', formatter._fmt)
        cp.set(sec, 'datefmt', formatter.datefmt)
                
    # Output to file
    fh = open(fname, 'w')
    cp.write(fh)
    fh.close()
def _getLoggerParent(parent):
    """ Finds parent in list of loggers """
    
    for key, logger in root.manager.loggerDict.items(): 
        if parent == logger:    
            return key
            
    return 'root'
def _getLevelName(val):
    """ Returns Log Level Name from a Log value """
    try:
        return {
           str(NOTSET)   : 'NOTSET',
           str(INFO)     : 'INFO',
           str(DEBUG)    : 'DEBUG',
           str(WARNING)  : 'WARNING',
           str(CRITICAL) : 'CRITICAL',
           str(ERROR)    : 'ERROR',
          }[str(val)]          
    except Exception, e:
        return val
def _getHandlerProps(handler):
    """ Returns dictionary of handler properties and values """
    
    if isinstance(handler, StreamHandler):
        if 'stdout' in str(handler.stream):    
            props = { 'stream' : 'sys.stdout' }
        else:    
            props = { 'stream' : 'sys.stderr' }
            
    elif isinstance(handler, FileHandler):
        props = { 
                    'filename' : handler.baseFilename,
                    'mode'     : handler.mode,
                 }
    else:  
        raise Exception('Handler props unknown for class %s' % handler)
    
    return props
   
def _setHandlerProps(handler, props):
    """ Sets properties for handler """
   
    if isinstance(handler, StreamHandler):
        if props['stream'] == 'sys.stdout':  
            handler.stream = sys.stdout        
        else:                    
            handler.stream = sys.stderr
            
    elif isinstance(handler, FileHandler):
        handler.baseFilename = props['filename']
        handler.mode = props['mode']
        
    else:  
        raise Exception('Handler props unknown for class %s' % handler)
    
    return props
 
#-------------------------------------------------------------
#  Update module attributes that are provided by 'logging' module
#-------------------------------------------------------------
 
def setLoggerConfig(fname):
    _logconf = fname
   
def clearLoggers():
    root.manager.loggerDict.clear()
    saveConfig(_logconf)
   
# Set Loggers to use our RtLogManager Class         
root = RtLogger(WARNING)
Logger.root = root
Logger.manager = RtLogManager(Logger.root)        
   
# Set Loggers to use our RtLogger class
setLoggerClass(RtLogger)
# Load the Config on startup
loadConfig(_logconf)