lsst.log.log.logContinued.LogHandler Class Reference

Inheritance diagram for lsst.log.log.logContinued.LogHandler:

Public Member Functions
def	__init__ (self, level=logging.NOTSET)
def	handle (self, record)
def	emit (self, record)

Public Attributes
	formatter

Detailed Description

Handler for Python logging module that emits to LSST logging.

Parameters
----------
level : `int`
    Level at which to set the this handler.

Notes
-----
If this handler is enabled and `lsst.log` has been configured to use
Python `logging`, the handler will do nothing itself if any other
handler has been registered with the Python logger.  If it does not
think that anything else is handling the message it will attempt to
send the message via a default `~logging.StreamHandler`.  The safest
approach is to configure the logger with an additional handler
(possibly the ROOT logger) if `lsst.log` is to be configured to use
Python logging.

Definition at line 479 of file logContinued.py.

Constructor & Destructor Documentation

__init__()

def lsst.log.log.logContinued.LogHandler.__init__	(		self,
			level = logging.NOTSET
	)

Definition at line 499 of file logContinued.py.

    def __init__(self, level=logging.NOTSET):
        logging.Handler.__init__(self, level=level)
        # Format as a simple message because lsst.log will format the
        # message a second time.
        self.formatter = logging.Formatter(fmt="%(message)s")
 

Member Function Documentation

emit()

def lsst.log.log.logContinued.LogHandler.emit	(		self,
			record
	)

Definition at line 510 of file logContinued.py.

    def emit(self, record):
        if Log.UsePythonLogging:
            # Do not forward this message to lsst.log since this may cause
            # a logging loop.
 
            # Work out whether any other handler is going to be invoked
            # for this logger.
            pylgr = logging.getLogger(record.name)
 
            # If another handler is registered that is not LogHandler
            # we ignore this request
            if any(not isinstance(h, self.__class__) for h in pylgr.handlers):
                return
 
            # If the parent has handlers and propagation is enabled
            # we punt as well (and if a LogHandler is involved then we will
            # ask the same question when we get to it).
            if pylgr.parent and pylgr.parent.hasHandlers() and pylgr.propagate:
                return
 
            # Force this message to appear somewhere.
            # If something else should happen then the caller should add a
            # second Handler.
            stream = logging.StreamHandler()
            stream.setFormatter(logging.Formatter(fmt="%(name)s %(levelname)s (fallback): %(message)s"))
            stream.handle(record)
            return
 
        logger = Log.getLogger(record.name)
        # Use standard formatting class to format message part of the record
        message = self.formatter.format(record)
 
        logger.logMsg(LevelTranslator.logging2lsstLog(record.levelno),
                      record.filename, record.funcName,
                      record.lineno, message)

handle()

def lsst.log.log.logContinued.LogHandler.handle	(		self,
			record
	)

Definition at line 505 of file logContinued.py.

    def handle(self, record):
        logger = Log.getLogger(record.name)
        if logger.isEnabledFor(LevelTranslator.logging2lsstLog(record.levelno)):
            logging.Handler.handle(self, record)
 

Member Data Documentation

formatter

lsst.log.log.logContinued.LogHandler.formatter

Definition at line 503 of file logContinued.py.

---

The documentation for this class was generated from the following file:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/log/22.0.1-8-ge5750ce+85460ae5f3/python/lsst/log/log/logContinued.py