Python logging.PlaceHolder() Examples

def set_logger_levels(debug=False):
    """Set all of the logger levels

    Args:
        debug (bool): True to enable debug logging, False otherwise
    """
    for name, logger in logging.Logger.manager.loggerDict.items():
        if isinstance(logger, logging.PlaceHolder):
            continue

        if debug and name.startswith('streamalert'):
            logger.setLevel(logging.DEBUG if debug else logging.INFO)
        elif name.startswith(__package__):
            logger.setLevel(logging.INFO)
        else:
            logger.disabled = True  # disable this logger if it's not one of ours 

def _handle_existing_loggers(existing, child_loggers, disable_existing):
    """
    When (re)configuring logging, handle loggers which were in the previous
    configuration but are not in the new configuration. There's no point
    deleting them as other threads may continue to hold references to them;
    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. Also, allow existing loggers to NOT be
    disabled if disable_existing is false.
    """
    root = logging.root
    for log in existing:
        logger = root.manager.loggerDict[log]
        if log in child_loggers:
            if not isinstance(logger, logging.PlaceHolder):
                logger.setLevel(logging.NOTSET)
                logger.handlers = []
                logger.propagate = True
        else:
            logger.disabled = disable_existing 

def setOverrideLogLevel(lvl):
    """
    Override all logger filter levels to include lvl and above.


    - Set root logger level
    - iterates all existing loggers and sets their log level to ``NOTSET``.

    Args:
        lvl (string): Log level name.
    """
    if lvl is None:
        return
    logging.info('Overriding log level globally to %s', lvl)
    lvl = getLevelName(lvl)
    global _overrideLogLevel # pylint: disable=global-statement
    _overrideLogLevel = lvl
    logging.getLogger('').setLevel(lvl)
    for loggerName in logging.Logger.manager.loggerDict:
        logger = logging.Logger.manager.loggerDict[loggerName]
        if isinstance(logger, logging.PlaceHolder):
            continue
        logger.setLevel(logging.NOTSET) 

def __build_ref_lists(self):
        """
        Build up easy-to-use lists of loggers and handlers.
        """
        ll = {}
        hl = {}
        loggers = dict(logging.Logger.manager.loggerDict)
        loggers[''] = logging.getLogger('')
        loggers['root'] = logging.getLogger('')
        for lg_name, lg_obj in loggers.items():
            if not isinstance(lg_obj, logging.PlaceHolder):
                ll[lg_name] = lg_obj
                for handler in lg_obj.handlers:
                    hl[handler.get_name()] = handler
        self.__loggers_by_name = ll
        self.__handlers_by_name = hl 

def print_all_logging_handlers():
    for k, v in logging.Logger.manager.loggerDict.items():
        print("+ [%s] {%s} " % (str.ljust(k, 20), str(v.__class__)[8:-2]))
        if not isinstance(v, logging.PlaceHolder):
            for h in v.handlers:
                print("     +++", str(h.__class__)[8:-2]) 

def configure(config_string=None, log_json=False, log_file=None):
    if not config_string:
        config_string = ":{}".format(DEFAULT_LOGLEVEL)

    if log_json:
        SLogger.manager.log_json = True
        log_format = JSON_FORMAT
    else:
        SLogger.manager.log_json = False
        log_format = PRINT_FORMAT

    if len(rootLogger.handlers) == 0:
        #handler = StreamHandler()
        handler = StreamHandler(sys.stdout)
        #formatter = Formatter(log_format)
        formatter = QKCLogFormatter()
        handler.setFormatter(formatter)
        rootLogger.addHandler(handler)
    if log_file:
        if not any(isinstance(hndlr, FileHandler)
                   for hndlr in rootLogger.handlers):
            handler = FileHandler(log_file)
            formatter = Formatter("{} {}".format(FILE_PREFIX, log_format))
            handler.setFormatter(formatter)
            rootLogger.addHandler(handler)

    # Reset logging levels before applying new config below
    for name, logger in SLogger.manager.loggerDict.items():
        if hasattr(logger, 'setLevel'):
            # Guard against `logging.PlaceHolder` instances
            logger.setLevel(logging.NOTSET)
            if config_string == ":{}".format(DEFAULT_LOGLEVEL):
                logger.propagate = True
            else:
                logger.propagate = True

    for name_levels in config_string.split(','):
        name, _, level = name_levels.partition(':')
        logger = getLogger(name)
        logger.setLevel(level.upper())
        logger.propagate = True 

def _iter_loggers():
    """Iterate on existing loggers."""

    # Sadly, Logger.manager and Manager.loggerDict are not documented,
    # but there is no logging public function to iterate on all loggers.

    # The root logger is not part of loggerDict.
    yield logging.getLogger()

    manager = logging.Logger.manager
    for logger in manager.loggerDict.values():
        if isinstance(logger, logging.PlaceHolder):
            continue
        yield logger 

def _iter_loggers():
    """Iterate on existing loggers."""

    # Sadly, Logger.manager and Manager.loggerDict are not documented,
    # but there is no logging public function to iterate on all loggers.

    # The root logger is not part of loggerDict.
    yield logging.getLogger()

    manager = logging.Logger.manager
    for logger in manager.loggerDict.values():
        if isinstance(logger, logging.PlaceHolder):
            continue
        yield logger 

def terminate():
        for _, logger in logging.Logger.manager.loggerDict.items():
            if isinstance(logger, logging.PlaceHolder):
                continue
            for handler in logger.handlers:
                if isinstance(handler, logging.FileHandler):
                    handler.close()

    # TODO: These are suboptimal as they getLogger each time. Any real performance hit here?
    # TODO: Consider finding all newlines in the msg and ensuring the log prefix is added for each
    # newline. Would improve formatting for certain stuff. 

def update_loggers(self):
        loggers = deepcopy(self._config.get('loggers') or {})
        for name, logger in self._root_logger.manager.loggerDict.items():
            if not isinstance(logger, logging.PlaceHolder):
                level = loggers.pop(name, logging.NOTSET)
                logger.setLevel(level)

        for name, level in loggers.items():
            logger = self._root_logger.manager.getLogger(name)
            logger.setLevel(level) 

def __recurse_list(self, indent, logger, detail):
        """
        Print the passed in logger, its handlers, and then recurse on other
        loggers under its space.
        """
        indent_txt = ' ' * indent
        print >>sys.stderr, 'L{0}{1}: level={2}'.format(indent_txt, logger.name, logger.level)
        for handler in logger.handlers:
            self.__display_handler(indent + 1, handler, detail)
        for lg_name, lg_obj in logging.Logger.manager.loggerDict.items():
            if isinstance(lg_obj, logging.PlaceHolder):
                continue
            if lg_obj.parent == logger:
                self.__recurse_list(indent + 3, lg_obj, detail) 

def initLogging(logLevel=logging.INFO):

	global LOGGING_INITIALIZED
	if LOGGING_INITIALIZED:

		print("ERROR - Logging initialized twice!")
		try:
			print(traceback.format_exc())
			return
		except Exception:
			pass

	LOGGING_INITIALIZED = True

	print("Setting up loggers....")

	if not os.path.exists(os.path.join("./logs")):
		os.mkdir(os.path.join("./logs"))

	mainLogger = logging.getLogger()			# Main logger
	mainLogger.setLevel(logLevel)

	ch = ColourHandler()
	mainLogger.addHandler(ch)

	logName	= "log - %s.txt" % (time.strftime("%Y-%m-%d %H;%M;%S", time.gmtime()))

	errLogHandler = RobustFileHandler(os.path.join("./logs", logName))
	errLogHandler.setLevel(logging.INFO)
	# formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
	# errLogHandler.setFormatter(formatter)

	# mainLogger.addHandler(errLogHandler)

	# Install override for excepthook, to catch all errors
	sys.excepthook = exceptHook

	logtst = logging.getLogger("Main.Test")
	logtst.info("Logging Active")

	print("done")


	# print("Enumerating loggers:")
	# for k,v in  logging.Logger.manager.loggerDict.items()  :
	# 	print('+ [%s] {%s} ' % (str.ljust( k, 20)  , str(v.__class__)[8:-2]) )
	# 	if not isinstance(v, logging.PlaceHolder):
	# 		for h in v.handlers:
	# 			print('     +++',str(h.__class__)[8:-2] )
	# print("Done listing")