lsst.log.log.logContinued.Log Class Reference

Public Member Functions
	usePythonLogging (cls)
	doNotUsePythonLogging (cls)
	name (self)
	level (self)
	parent (self)
	trace (self, fmt, *args)
	debug (self, fmt, *args)
	info (self, fmt, *args)
	warn (self, fmt, *args)
	warning (self, fmt, *args)
	error (self, fmt, *args)
	fatal (self, fmt, *args)
	critical (self, fmt, *args)
	__reduce__ (self)
	__repr__ (self)

Public Attributes
	UsePythonLogging

Static Public Attributes
bool	UsePythonLogging = False
	CRITICAL = CRITICAL
	WARNING = WARNING

Protected Member Functions
	_log (self, level, use_format, fmt, *args, **kwargs)

Detailed Description

Definition at line 56 of file logContinued.py.

Member Function Documentation

__reduce__()

lsst.log.log.logContinued.Log.__reduce__

(

self

)

Implement pickle support.

Definition at line 161 of file logContinued.py.

    def __reduce__(self):
        """Implement pickle support.
        """
        args = (self.getName(), )
        # method has to be module-level, not class method
        return (getLogger, args)
 

__repr__()

lsst.log.log.logContinued.Log.__repr__

(

self

)

Definition at line 168 of file logContinued.py.

    def __repr__(self):
        # Match python logging style.
        cls = type(self)
        class_name = f"{cls.__module__}.{cls.__qualname__}"
        prefix = "lsst.log.log.log"
        if class_name.startswith(prefix):
            class_name = class_name.replace(prefix, "lsst.log")
        return f"<{class_name} '{self.name}' ({getLevelName(self.getEffectiveLevel())})>"
 
 

_log()

lsst.log.log.logContinued.Log._log ( self, level, use_format, fmt, * args, ** kwargs )

protected

Definition at line 134 of file logContinued.py.

    def _log(self, level, use_format, fmt, *args, **kwargs):
        if self.isEnabledFor(level):
            frame = inspect.currentframe().f_back    # calling method
            frame = frame.f_back    # original log location
            filename = os.path.split(frame.f_code.co_filename)[1]
            funcname = frame.f_code.co_name
            if use_format:
                msg = fmt.format(*args, **kwargs) if args or kwargs else fmt
            else:
                msg = fmt % args if args else fmt
            if self.UsePythonLogging:
                levelno = LevelTranslator.lsstLog2logging(level)
                levelName = logging.getLevelName(levelno)
 
                pylog = logging.getLogger(self.getName())
                record = logging.makeLogRecord(dict(name=self.getName(),
                                                    levelno=levelno,
                                                    levelname=levelName,
                                                    msg=msg,
                                                    funcName=funcname,
                                                    filename=filename,
                                                    pathname=frame.f_code.co_filename,
                                                    lineno=frame.f_lineno))
                pylog.handle(record)
            else:
                self.logMsg(level, filename, funcname, frame.f_lineno, msg)
 

critical()

lsst.log.log.logContinued.Log.critical	(		self,
			fmt,
		*	args )

Definition at line 129 of file logContinued.py.

    def critical(self, fmt, *args):
        # Do not call fatal() because that will result in an incorrect
        # line number in the log.
        self._log(Log.FATAL, False, fmt, *args)
 

debug()

lsst.log.log.logContinued.Log.debug	(		self,
			fmt,
		*	args )

Definition at line 109 of file logContinued.py.

    def debug(self, fmt, *args):
        self._log(Log.DEBUG, False, fmt, *args)
 

doNotUsePythonLogging()

lsst.log.log.logContinued.Log.doNotUsePythonLogging

(

cls

)

Forward log messages to LSST logging system.

Notes
-----
This is the default state.

Definition at line 79 of file logContinued.py.

    def doNotUsePythonLogging(cls):
        """Forward log messages to LSST logging system.
 
        Notes
        -----
        This is the default state.
        """
        cls.UsePythonLogging = False
 

error()

lsst.log.log.logContinued.Log.error	(		self,
			fmt,
		*	args )

Definition at line 123 of file logContinued.py.

    def error(self, fmt, *args):
        self._log(Log.ERROR, False, fmt, *args)
 

fatal()

lsst.log.log.logContinued.Log.fatal	(		self,
			fmt,
		*	args )

Definition at line 126 of file logContinued.py.

    def fatal(self, fmt, *args):
        self._log(Log.FATAL, False, fmt, *args)
 

info()

lsst.log.log.logContinued.Log.info	(		self,
			fmt,
		*	args )

Definition at line 112 of file logContinued.py.

    def info(self, fmt, *args):
        self._log(Log.INFO, False, fmt, *args)
 

level()

lsst.log.log.logContinued.Log.level

(

self

)

Definition at line 93 of file logContinued.py.

    def level(self):
        return self.getLevel()
 

name()

lsst.log.log.logContinued.Log.name

(

self

)

Definition at line 89 of file logContinued.py.

    def name(self):
        return self.getName()
 

parent()

lsst.log.log.logContinued.Log.parent

(

self

)

Returns the parent logger, or None if this is the root logger.

Definition at line 97 of file logContinued.py.

    def parent(self):
        """Returns the parent logger, or None if this is the root logger."""
        if not self.name:
            return None
        parent_name = self.name.rpartition(".")[0]
        if not parent_name:
            return self.getDefaultLogger()
        return self.getLogger(parent_name)
 

trace()

lsst.log.log.logContinued.Log.trace	(		self,
			fmt,
		*	args )

Definition at line 106 of file logContinued.py.

    def trace(self, fmt, *args):
        self._log(Log.TRACE, False, fmt, *args)
 

usePythonLogging()

lsst.log.log.logContinued.Log.usePythonLogging

(

cls

)

Forward log messages to Python `logging`

Notes
-----
This is useful for unit testing when you want to ensure
that log messages are captured by the testing environment
as distinct from standard output.

This state only affects messages sent to the `lsst.log`
package from Python.

Definition at line 64 of file logContinued.py.

    def usePythonLogging(cls):
        """Forward log messages to Python `logging`
 
        Notes
        -----
        This is useful for unit testing when you want to ensure
        that log messages are captured by the testing environment
        as distinct from standard output.
 
        This state only affects messages sent to the `lsst.log`
        package from Python.
        """
        cls.UsePythonLogging = True
 

warn()

lsst.log.log.logContinued.Log.warn	(		self,
			fmt,
		*	args )

Definition at line 115 of file logContinued.py.

    def warn(self, fmt, *args):
        self._log(Log.WARN, False, fmt, *args)
 

warning()

lsst.log.log.logContinued.Log.warning	(		self,
			fmt,
		*	args )

Definition at line 118 of file logContinued.py.

    def warning(self, fmt, *args):
        # Do not call warn() because that will result in an incorrect
        # line number in the log.
        self._log(Log.WARN, False, fmt, *args)
 

Member Data Documentation

CRITICAL

lsst.log.log.logContinued.Log.CRITICAL = CRITICAL

static

Definition at line 60 of file logContinued.py.

UsePythonLogging [1/2]

bool lsst.log.log.logContinued.Log.UsePythonLogging = False

static

Definition at line 57 of file logContinued.py.

UsePythonLogging [2/2]

lsst.log.log.logContinued.Log.UsePythonLogging

Definition at line 76 of file logContinued.py.

WARNING

lsst.log.log.logContinued.Log.WARNING = WARNING

static

Definition at line 61 of file logContinued.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/log/g2079a07aa2+86d27d4dc4/python/lsst/log/log/logContinued.py