lsst.log.log.logContinued Namespace Reference

Classes
class	Log
class	MDCDict
class	UsePythonLogging
class	LevelTranslator
class	LogHandler

Functions
def	configure (*args)
def	configure_prop (properties)
def	configure_pylog_MDC (str level, Optional[type] MDC_class=MDCDict)
def	getDefaultLogger ()
def	getLogger (loggername)
def	MDC (key, value)
def	MDCRemove (key)
def	MDCRegisterInit (func)
def	setLevel (loggername, level)
def	getLevel (loggername)
def	getEffectiveLevel (loggername)
def	isEnabledFor (loggername, level)
def	log (loggername, level, fmt, *args, **kwargs)
def	trace (fmt, *args)
def	debug (fmt, *args)
def	info (fmt, *args)
def	warn (fmt, *args)
def	warning (fmt, *args)
def	error (fmt, *args)
def	fatal (fmt, *args)
def	critical (fmt, *args)
def	logf (loggername, level, fmt, *args, **kwargs)
def	tracef (fmt, *args, **kwargs)
def	debugf (fmt, *args, **kwargs)
def	infof (fmt, *args, **kwargs)
def	warnf (fmt, *args, **kwargs)
def	errorf (fmt, *args, **kwargs)
def	fatalf (fmt, *args, **kwargs)
def	lwpID ()
def	getLevelName (level)
def	usePythonLogging ()
def	doNotUsePythonLogging ()

Variables
int	TRACE = 5000
int	DEBUG = 10000
int	INFO = 20000
int	WARN = 30000
int	ERROR = 40000
int	FATAL = 50000
int	CRITICAL = FATAL
int	WARNING = WARN

Function Documentation

configure()

def lsst.log.log.logContinued.configure

(

*

args

)

Definition at line 241 of file logContinued.py.

def configure(*args):
    Log.configure(*args)
 
 

configure_prop()

def lsst.log.log.logContinued.configure_prop

(

properties

)

Definition at line 245 of file logContinued.py.

def configure_prop(properties):
    Log.configure_prop(properties)
 
 

configure_pylog_MDC()

def lsst.log.log.logContinued.configure_pylog_MDC	(	str	level,
		Optional[type]	MDC_class = MDCDict
	)

Configure log4cxx to send messages to Python logging, with MDC support.

Parameters
----------
level : `str`
    Name of the logging level for root log4cxx logger.
MDC_class : `type`, optional
    Type of dictionary which is added to `logging.LogRecord` as an ``MDC``
    attribute. Any dictionary or ``defaultdict``-like class can be used as
    a type. If `None` the `logging.LogRecord` will not be augmented.

Notes
-----
This method does two things:

- Configures log4cxx with a given logging level and a ``PyLogAppender``
  appender class which forwards all messages to Python `logging`.
- Installs a record factory for Python `logging` that adds ``MDC``
  attribute to every `logging.LogRecord` object (instance of
  ``MDC_class``). This will happen by default but can be disabled
  by setting the ``MDC_class`` parameter to `None`.

Definition at line 249 of file logContinued.py.

def configure_pylog_MDC(level: str, MDC_class: Optional[type] = MDCDict):
    """Configure log4cxx to send messages to Python logging, with MDC support.
 
    Parameters
    ----------
    level : `str`
        Name of the logging level for root log4cxx logger.
    MDC_class : `type`, optional
        Type of dictionary which is added to `logging.LogRecord` as an ``MDC``
        attribute. Any dictionary or ``defaultdict``-like class can be used as
        a type. If `None` the `logging.LogRecord` will not be augmented.
 
    Notes
    -----
    This method does two things:
 
    - Configures log4cxx with a given logging level and a ``PyLogAppender``
      appender class which forwards all messages to Python `logging`.
    - Installs a record factory for Python `logging` that adds ``MDC``
      attribute to every `logging.LogRecord` object (instance of
      ``MDC_class``). This will happen by default but can be disabled
      by setting the ``MDC_class`` parameter to `None`.
    """
    if MDC_class is not None:
        old_factory = logging.getLogRecordFactory()
 
        def record_factory(*args, **kwargs):
            record = old_factory(*args, **kwargs)
            record.MDC = MDC_class()
            return record
 
        logging.setLogRecordFactory(record_factory)
 
    properties = """\
log4j.rootLogger = {}, PyLog
log4j.appender.PyLog = PyLogAppender
""".format(level)
    configure_prop(properties)
 
 

critical()

def lsst.log.log.logContinued.critical	(		fmt,
		*	args
	)

Definition at line 360 of file logContinued.py.

def critical(fmt, *args):
    fatal(fmt, *args)
 
 

debug()

def lsst.log.log.logContinued.debug	(		fmt,
		*	args
	)

Definition at line 336 of file logContinued.py.

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

debugf()

def lsst.log.log.logContinued.debugf	(		fmt,
		*	args,
		**	kwargs
	)

Definition at line 372 of file logContinued.py.

def debugf(fmt, *args, **kwargs):
    Log.getDefaultLogger()._log(DEBUG, True, fmt, *args, **kwargs)
 
 

doNotUsePythonLogging()

def lsst.log.log.logContinued.doNotUsePythonLogging

(

)

Definition at line 417 of file logContinued.py.

def doNotUsePythonLogging():
    Log.doNotUsePythonLogging()
 
 

error()

def lsst.log.log.logContinued.error	(		fmt,
		*	args
	)

Definition at line 352 of file logContinued.py.

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

errorf()

def lsst.log.log.logContinued.errorf	(		fmt,
		*	args,
		**	kwargs
	)

Definition at line 384 of file logContinued.py.

def errorf(fmt, *args, **kwargs):
    Log.getDefaultLogger()._log(ERROR, True, fmt, *args, **kwargs)
 
 

fatal()

def lsst.log.log.logContinued.fatal	(		fmt,
		*	args
	)

Definition at line 356 of file logContinued.py.

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

fatalf()

def lsst.log.log.logContinued.fatalf	(		fmt,
		*	args,
		**	kwargs
	)

Definition at line 388 of file logContinued.py.

def fatalf(fmt, *args, **kwargs):
    Log.getDefaultLogger()._log(FATAL, True, fmt, *args, **kwargs)
 
 

getDefaultLogger()

def lsst.log.log.logContinued.getDefaultLogger

(

)

Definition at line 289 of file logContinued.py.

def getDefaultLogger():
    return Log.getDefaultLogger()
 
 

getEffectiveLevel()

def lsst.log.log.logContinued.getEffectiveLevel

(

loggername

)

Definition at line 317 of file logContinued.py.

def getEffectiveLevel(loggername):
    return Log.getLogger(loggername).getEffectiveLevel()
 
 

getLevel()

def lsst.log.log.logContinued.getLevel

(

loggername

)

Definition at line 313 of file logContinued.py.

def getLevel(loggername):
    return Log.getLogger(loggername).getLevel()
 
 

getLevelName()

def lsst.log.log.logContinued.getLevelName

(

level

)

Return the name associated with this logging level.

Returns "Level %d" if no name can be found.

Definition at line 396 of file logContinued.py.

def getLevelName(level):
    """Return the name associated with this logging level.
 
    Returns "Level %d" if no name can be found.
    """
    names = ("DEBUG", "TRACE", "WARNING", "FATAL", "INFO", "ERROR")
    for name in names:
        test_level = getattr(Log, name)
        if test_level == level:
            return name
    return f"Level {level}"
 
 
# This will cause a warning in Sphinx documentation due to confusion between
# UsePythonLogging and usePythonLogging.
# https://github.com/astropy/sphinx-automodapi/issues/73 (but note that this
# does not seem to be Mac-only).

getLogger()

def lsst.log.log.logContinued.getLogger

(

loggername

)

Definition at line 293 of file logContinued.py.

def getLogger(loggername):
    return Log.getLogger(loggername)
 
 

info()

def lsst.log.log.logContinued.info	(		fmt,
		*	args
	)

Definition at line 340 of file logContinued.py.

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

infof()

def lsst.log.log.logContinued.infof	(		fmt,
		*	args,
		**	kwargs
	)

Definition at line 376 of file logContinued.py.

def infof(fmt, *args, **kwargs):
    Log.getDefaultLogger()._log(INFO, True, fmt, *args, **kwargs)
 
 

isEnabledFor()

def lsst.log.log.logContinued.isEnabledFor	(		loggername,
			level
	)

Definition at line 321 of file logContinued.py.

def isEnabledFor(loggername, level):
    return Log.getLogger(loggername).isEnabledFor(level)
 
 
# This will cause a warning in Sphinx documentation due to confusion between
# Log and log. https://github.com/astropy/sphinx-automodapi/issues/73 (but
# note that this does not seem to be Mac-only).

log()

def lsst.log.log.logContinued.log	(		loggername,
			level,
			fmt,
		*	args,
		**	kwargs
	)

Definition at line 328 of file logContinued.py.

def log(loggername, level, fmt, *args, **kwargs):
    Log.getLogger(loggername)._log(level, False, fmt, *args)
 
 

logf()

def lsst.log.log.logContinued.logf	(		loggername,
			level,
			fmt,
		*	args,
		**	kwargs
	)

Definition at line 364 of file logContinued.py.

def logf(loggername, level, fmt, *args, **kwargs):
    Log.getLogger(loggername)._log(level, True, fmt, *args, **kwargs)
 
 

lwpID()

def lsst.log.log.logContinued.lwpID

(

)

Definition at line 392 of file logContinued.py.

def lwpID():
    return Log.lwpID
 
 

MDC()

def lsst.log.log.logContinued.MDC	(		key,
			value
	)

Definition at line 297 of file logContinued.py.

def MDC(key, value):
    return Log.MDC(key, str(value))
 
 

MDCRegisterInit()

def lsst.log.log.logContinued.MDCRegisterInit

(

func

)

Definition at line 305 of file logContinued.py.

def MDCRegisterInit(func):
    Log.MDCRegisterInit(func)
 
 

MDCRemove()

def lsst.log.log.logContinued.MDCRemove

(

key

)

Definition at line 301 of file logContinued.py.

def MDCRemove(key):
    Log.MDCRemove(key)
 
 

setLevel()

def lsst.log.log.logContinued.setLevel	(		loggername,
			level
	)

Definition at line 309 of file logContinued.py.

def setLevel(loggername, level):
    Log.getLogger(loggername).setLevel(level)
 
 

trace()

def lsst.log.log.logContinued.trace	(		fmt,
		*	args
	)

Definition at line 332 of file logContinued.py.

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

tracef()

def lsst.log.log.logContinued.tracef	(		fmt,
		*	args,
		**	kwargs
	)

Definition at line 368 of file logContinued.py.

def tracef(fmt, *args, **kwargs):
    Log.getDefaultLogger()._log(TRACE, True, fmt, *args, **kwargs)
 
 

usePythonLogging()

def lsst.log.log.logContinued.usePythonLogging

(

)

Definition at line 413 of file logContinued.py.

def usePythonLogging():
    Log.usePythonLogging()
 
 

warn()

def lsst.log.log.logContinued.warn	(		fmt,
		*	args
	)

Definition at line 344 of file logContinued.py.

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

warnf()

def lsst.log.log.logContinued.warnf	(		fmt,
		*	args,
		**	kwargs
	)

Definition at line 380 of file logContinued.py.

def warnf(fmt, *args, **kwargs):
    Log.getDefaultLogger()._log(WARN, True, fmt, *args, **kwargs)
 
 

warning()

def lsst.log.log.logContinued.warning	(		fmt,
		*	args
	)

Definition at line 348 of file logContinued.py.

def warning(fmt, *args):
    warn(fmt, *args)
 
 

Variable Documentation

CRITICAL

int lsst.log.log.logContinued.CRITICAL = FATAL

Definition at line 52 of file logContinued.py.

DEBUG

int lsst.log.log.logContinued.DEBUG = 10000

Definition at line 45 of file logContinued.py.

ERROR

int lsst.log.log.logContinued.ERROR = 40000

Definition at line 48 of file logContinued.py.

FATAL

int lsst.log.log.logContinued.FATAL = 50000

Definition at line 49 of file logContinued.py.

INFO

int lsst.log.log.logContinued.INFO = 20000

Definition at line 46 of file logContinued.py.

TRACE

int lsst.log.log.logContinued.TRACE = 5000

Definition at line 44 of file logContinued.py.

WARN

int lsst.log.log.logContinued.WARN = 30000

Definition at line 47 of file logContinued.py.

WARNING

int lsst.log.log.logContinued.WARNING = WARN

Definition at line 53 of file logContinued.py.