Coverage for ipapython/ipa_log_manager : 66%

# Authors: John Dennis <jdennis@redhat.com> 

# 

# Copyright (C) 2011  Red Hat 

# see file 'COPYING' for use and warranty information 

# 

# This program is free software; you can redistribute it and/or modify 

# it under the terms of the GNU General Public License as published by 

# the Free Software Foundation, either version 3 of the License, or 

# (at your option) any later version. 

# 

# This program is distributed in the hope that it will be useful, 

# but WITHOUT ANY WARRANTY; without even the implied warranty of 

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 

# GNU General Public License for more details. 

# 

# You should have received a copy of the GNU General Public License 

# along with this program.  If not, see <http://www.gnu.org/licenses/>. 

#------------------------------------------------------------------------------- 

# Module exports 

__all__ = ['log_mgr', 'root_logger', 'standard_logging_setup', 

           'IPA_ROOT_LOGGER_NAME', 'ISO8601_UTC_DATETIME_FMT', 

           'LOGGING_FORMAT_STDERR', 'LOGGING_FORMAT_STDOUT', 'LOGGING_FORMAT_FILE'] 

#------------------------------------------------------------------------------- 

import sys 

import re 

import copy 

from log_manager import LogManager, parse_log_level 

#------------------------------------------------------------------------------- 

# Our root logger, all loggers will be descendents of this. 

IPA_ROOT_LOGGER_NAME = 'ipa' 

# Format string for time.strftime() to produce a ISO 8601 date time 

# formatted string in the UTC time zone. 

ISO8601_UTC_DATETIME_FMT = '%Y-%m-%dT%H:%M:%SZ' 

# Logging format string for use with logging stderr handlers 

LOGGING_FORMAT_STDERR = 'ipa: %(levelname)s: %(message)s' 

# Logging format string for use with logging stdout handlers 

LOGGING_FORMAT_STDOUT = '[%(asctime)s %(name)s] <%(levelname)s>: %(message)s' 

# Logging format string for use with logging file handlers 

LOGGING_FORMAT_FILE = '\t'.join([ 

    '%(asctime)s', 

    '%(process)d', 

    '%(threadName)s', 

    '%(name)s', 

    '%(levelname)s', 

    '%(message)s', 

]) 

# Used by standard_logging_setup() for console message 

LOGGING_FORMAT_STANDARD_CONSOLE = '%(name)-12s: %(levelname)-8s %(message)s' 

# Used by standard_logging_setup() for file message 

LOGGING_FORMAT_STANDARD_FILE = '%(asctime)s %(levelname)s %(message)s' 

#------------------------------------------------------------------------------- 

class IPALogManager(LogManager): 

    ''' 

    Subclass the LogManager to enforce some IPA specfic logging 

    conventions. 

    * Default to timestamps in UTC. 

    * Default to ISO 8601 timestamp format. 

    * Default the message format. 

    ''' 

    log_logger_level_config_re = re.compile(r'^log_logger_level_(debug|info|warn|warning|error|critical|\d+)$') 

    def __init__(self, configure_state=None): 

        ''' 

        :parameters: 

          configure_state 

            Used by clients of the log manager to track the 

            configuration state, may be any object. 

        ''' 

        super(IPALogManager, self).__init__(IPA_ROOT_LOGGER_NAME, configure_state) 

    def configure_from_env(self, env, configure_state=None): 

        ''' 

        Read the loggger configuration from the Env config. The 

        following items may be configured: 

        Logger Levels 

          *log_logger_XXX = comma separated list of regexps* 

          Logger levels can be explicitly specified for specific loggers as 

          opposed to a global logging level. Specific loggers are indiciated 

          by a list of regular expressions bound to a level. If a logger's 

          name matches the regexp then it is assigned that level. The keys 

          in the Env config must begin with "log_logger_level\_" and then be 

          followed by a symbolic or numeric log level, for example:: 

            log_logger_level_debug = ipalib\.dn\..* 

            log_logger_level_35 = ipalib\.plugins\.dogtag 

          The first line says any logger belonging to the ipalib.dn module 

          will have it's level configured to debug. 

          The second line say the ipa.plugins.dogtag logger will be 

          configured to level 35. 

          Note: logger names are a dot ('.') separated list forming a path 

          in the logger tree.  The dot character is also a regular 

          expression metacharacter (matches any character) therefore you 

          will usually need to escape the dot in the logger names by 

          preceeding it with a backslash. 

        The return value of this function is a dict with the following 

        format: 

        logger_regexps 

          List of (regexp, level) tuples 

        :parameters: 

          env 

            Env object configuration values are read from. 

          configure_state 

            If other than None update the log manger's configure_state 

            variable to this object. Clients of the log manager can 

            use configure_state to track the state of the log manager. 

        ''' 

        logger_regexps = [] 

        config = {'logger_regexps' : logger_regexps, 

                 } 

        for attr in ('debug', 'verbose'): 

            value = getattr(env, attr, None) 

            if value is not None: 

                config[attr] = value 

        for attr in list(env): 

            # Get logger level configuration 

            match = IPALogManager.log_logger_level_config_re.search(attr) 

            if match: 

                value = match.group(1) 

                level = parse_log_level(value) 

                value = getattr(env, attr) 

                regexps = re.split('\s*,\s*', value) 

                # Add the regexp, it maps to the configured level 

                for regexp in regexps: 

                    logger_regexps.append((regexp, level)) 

                continue 

        self.configure(config, configure_state) 

        return config 

    def create_log_handlers(self, configs, logger=None, configure_state=None): 

        'Enforce some IPA specific configurations' 

        configs = copy.copy(configs) 

        for cfg in configs: 

            if not 'time_zone_converter' in cfg: 

                cfg['time_zone_converter'] = 'utc' 

            if not 'datefmt' in cfg: 

                cfg['datefmt'] = ISO8601_UTC_DATETIME_FMT 

            if not 'format' in cfg: 

                cfg['format'] = LOGGING_FORMAT_STDOUT 

        return super(IPALogManager, self).create_log_handlers(configs, logger, configure_state) 

#------------------------------------------------------------------------------- 

def standard_logging_setup(filename=None, verbose=False, debug=False, filemode='w'): 

    handlers = [] 

    # File output is always logged at debug level 

    if filename is not None: 

        file_handler = dict(name='file', 

                            filename=filename, 

                            filemode=filemode, 

                            permission=0600, 

                            level='debug', 

                            format=LOGGING_FORMAT_STANDARD_FILE) 

        handlers.append(file_handler) 

    if log_mgr.handlers.has_key('console'): 

        log_mgr.remove_handler('console') 

    level = 'error' 

    if verbose: 

        level = 'info' 

    if debug: 

        level = 'debug' 

    console_handler = dict(name='console', 

                           stream=sys.stderr, 

                           level=level, 

                           format=LOGGING_FORMAT_STANDARD_CONSOLE) 

    handlers.append(console_handler) 

    # default_level must be debug becuase we want the file handler to 

    # always log at the debug level. 

    log_mgr.configure(dict(default_level='debug', 

                           handlers=handlers), 

                      configure_state='standard') 

    return log_mgr.root_logger 

#------------------------------------------------------------------------------- 

# Single shared instance of log manager 

# 

# By default always starts with stderr console handler at error level 

# so messages generated before logging is fully configured have some 

# place to got and won't get lost. 

log_mgr = IPALogManager() 

log_mgr.configure(dict(default_level='error', 

                       handlers=[dict(name='console', 

                                      stream=sys.stderr)]), 

                  configure_state='default') 

root_logger = log_mgr.root_logger