(self)
Do the configuration.
Do the configuration.
Do the configuration .
def configure(self):
        """Do the configuration."""

        config = self.config
        if 'version' not in config:
            raise ValueError("dictionary doesn't specify a version")
        if config['version'] != 1:
            raise ValueError("Unsupported version: %s" % config['version'])
        incremental = config.pop('incremental', False)
        EMPTY_DICT = {}
        logging._acquireLock()
        try:
            if incremental:
                handlers = config.get('handlers', EMPTY_DICT)
                for name in handlers:
                    if name not in logging._handlers:
                        raise ValueError('No handler found with '
                                         'name %r'  % name)
                    else:
                        try:
                            handler = logging._handlers[name]
                            handler_config = handlers[name]
                            level = handler_config.get('level', None)
                            if level:
                                handler.setLevel(logging._checkLevel(level))
                        except StandardError, e:
                            raise ValueError('Unable to configure handler '
                                             '%r: %s' % (name, e))
                loggers = config.get('loggers', EMPTY_DICT)
                for name in loggers:
                    try:
                        self.configure_logger(name, loggers[name], True)
                    except StandardError, e:
                        raise ValueError('Unable to configure logger '
                                         '%r: %s' % (name, e))
                root = config.get('root', None)
                if root:
                    try:
                        self.configure_root(root, True)
                    except StandardError, e:
                        raise ValueError('Unable to configure root '
                                         'logger: %s' % e)
            else:
                disable_existing = config.pop('disable_existing_loggers', True)

                logging._handlers.clear()
                del logging._handlerList[:]

                # Do formatters first - they don't refer to anything else
                formatters = config.get('formatters', EMPTY_DICT)
                for name in formatters:
                    try:
                        formatters[name] = self.configure_formatter(
                                                            formatters[name])
                    except StandardError, e:
                        raise ValueError('Unable to configure '
                                         'formatter %r: %s' % (name, e))
                # Next, do filters - they don't refer to anything else, either
                filters = config.get('filters', EMPTY_DICT)
                for name in filters:
                    try:
                        filters[name] = self.configure_filter(filters[name])
                    except StandardError, e:
                        raise ValueError('Unable to configure '
                                         'filter %r: %s' % (name, e))

                # Next, do handlers - they refer to formatters and filters
                # As handlers can refer to other handlers, sort the keys
                # to allow a deterministic order of configuration
                handlers = config.get('handlers', EMPTY_DICT)
                for name in sorted(handlers):
                    try:
                        handler = self.configure_handler(handlers[name])
                        handler.name = name
                        handlers[name] = handler
                    except StandardError, e:
                        raise ValueError('Unable to configure handler '
                                         '%r: %s' % (name, e))
                # Next, do loggers - they refer to handlers and filters

                #we don't want to lose the existing loggers,
                #since other threads may have pointers to them.
                #existing is set to contain all existing loggers,
                #and as we go through the new configuration we
                #remove any which are configured. At the end,
                #what's left in existing is the set of loggers
                #which were in the previous configuration but
                #which are not in the new configuration.
                root = logging.root
                existing = root.manager.loggerDict.keys()
                #The list needs to be sorted so that we can
                #avoid disabling child loggers of explicitly
                #named loggers. With a sorted list it is easier
                #to find the child loggers.
                existing.sort(key=_encoded)
                #We'll keep the list of existing loggers
                #which are children of named loggers here...
                child_loggers = []
                #now set up the new ones...
                loggers = config.get('loggers', EMPTY_DICT)
                for name in loggers:
                    if name in existing:
                        i = existing.index(name)
                        prefixed = name + "."
                        pflen = len(prefixed)
                        num_existing = len(existing)
                        i = i + 1 # look at the entry after name
                        while (i < num_existing) and\
                              (existing[i][:pflen] == prefixed):
                            child_loggers.append(existing[i])
                            i = i + 1
                        existing.remove(name)
                    try:
                        self.configure_logger(name, loggers[name])
                    except StandardError, e:
                        raise ValueError('Unable to configure logger '
                                         '%r: %s' % (name, e))

                #Disable any old loggers. There's no point deleting
                #them as other threads may continue to hold references
                #and by disabling them, you stop them doing any logging.
                #However, don't disable children of named loggers, as that's
                #probably not what was intended by the user.
                for log in existing:
                    logger = root.manager.loggerDict[log]
                    if log in child_loggers:
                        logger.level = logging.NOTSET
                        logger.handlers = []
                        logger.propagate = True
                    elif disable_existing:
                        logger.disabled = True

                # And finally, do the root logger
                root = config.get('root', None)
                if root:
                    try:
                        self.configure_root(root)
                    except StandardError, e:
                        raise ValueError('Unable to configure root '
                                         'logger: %s' % e)
        finally:
            logging._releaseLock()
def configure ( self ) : config = self . config if 'version' not in config : raise ValueError ( "dictionary doesn't specify a version" ) if config [ 'version' ] != 1 : raise ValueError ( "Unsupported version: %s" % config [ 'version' ] ) incremental = config . pop ( 'incremental' , False ) EMPTY_DICT = { } logging . _acquireLock ( ) try : if incremental : handlers = config . get ( 'handlers' , EMPTY_DICT ) for name in handlers : if name not in logging . _handlers : raise ValueError ( 'No handler found with ' 'name %r' % name ) else : try : handler = logging . _handlers [ name ] handler_config = handlers [ name ] level = handler_config . get ( 'level' , None ) if level : handler . setLevel ( logging . _checkLevel ( level ) ) except StandardError , e : raise ValueError ( 'Unable to configure handler ' '%r: %s' % ( name , e ) ) loggers = config . get ( 'loggers' , EMPTY_DICT ) for name in loggers : try : self . configure_logger ( name , loggers [ name ] , True ) except StandardError , e : raise ValueError ( 'Unable to configure logger ' '%r: %s' % ( name , e ) ) root = config . get ( 'root' , None ) if root : try : self . configure_root ( root , True ) except StandardError , e : raise ValueError ( 'Unable to configure root ' 'logger: %s' % e ) else : disable_existing = config . pop ( 'disable_existing_loggers' , True ) logging . _handlers . clear ( ) del logging . _handlerList [ : ] # Do formatters first - they don't refer to anything else formatters = config . get ( 'formatters' , EMPTY_DICT ) for name in formatters : try : formatters [ name ] = self . configure_formatter ( formatters [ name ] ) except StandardError , e : raise ValueError ( 'Unable to configure ' 'formatter %r: %s' % ( name , e ) ) # Next, do filters - they don't refer to anything else, either filters = config . get ( 'filters' , EMPTY_DICT ) for name in filters : try : filters [ name ] = self . configure_filter ( filters [ name ] ) except StandardError , e : raise ValueError ( 'Unable to configure ' 'filter %r: %s' % ( name , e ) ) # Next, do handlers - they refer to formatters and filters # As handlers can refer to other handlers, sort the keys # to allow a deterministic order of configuration handlers = config . get ( 'handlers' , EMPTY_DICT ) for name in sorted ( handlers ) : try : handler = self . configure_handler ( handlers [ name ] ) handler . name = name handlers [ name ] = handler except StandardError , e : raise ValueError ( 'Unable to configure handler ' '%r: %s' % ( name , e ) ) # Next, do loggers - they refer to handlers and filters #we don't want to lose the existing loggers, #since other threads may have pointers to them. #existing is set to contain all existing loggers, #and as we go through the new configuration we #remove any which are configured. At the end, #what's left in existing is the set of loggers #which were in the previous configuration but #which are not in the new configuration. root = logging . root existing = root . manager . loggerDict . keys ( ) #The list needs to be sorted so that we can #avoid disabling child loggers of explicitly #named loggers. With a sorted list it is easier #to find the child loggers. existing . sort ( key = _encoded ) #We'll keep the list of existing loggers #which are children of named loggers here... child_loggers = [ ] #now set up the new ones... loggers = config . get ( 'loggers' , EMPTY_DICT ) for name in loggers : if name in existing : i = existing . index ( name ) prefixed = name + "." pflen = len ( prefixed ) num_existing = len ( existing ) i = i + 1 # look at the entry after name while ( i < num_existing ) and ( existing [ i ] [ : pflen ] == prefixed ) : child_loggers . append ( existing [ i ] ) i = i + 1 existing . remove ( name ) try : self . configure_logger ( name , loggers [ name ] ) except StandardError , e : raise ValueError ( 'Unable to configure logger ' '%r: %s' % ( name , e ) ) #Disable any old loggers. There's no point deleting #them as other threads may continue to hold references #and by disabling them, you stop them doing any logging. #However, don't disable children of named loggers, as that's #probably not what was intended by the user. for log in existing : logger = root . manager . loggerDict [ log ] if log in child_loggers : logger . level = logging . NOTSET logger . handlers = [ ] logger . propagate = True elif disable_existing : logger . disabled = True # And finally, do the root logger root = config . get ( 'root' , None ) if root : try : self . configure_root ( root ) except StandardError , e : raise ValueError ( 'Unable to configure root ' 'logger: %s' % e ) finally : logging . _releaseLock ( )