#

# Permission to use, copy, modify, and distribute this software and its

# documentation for any purpose and without fee is hereby granted,

# provided that the above copyright notice appear in all copies and that

# both that copyright notice and this permission notice appear in

# supporting documentation, and that the name of Vinay Sajip

# not be used in advertising or publicity pertaining to distribution

# of the software without specific, written prior permission.

# VINAY SAJIP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

# ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL

# VINAY SAJIP BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

# ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER

# IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT

# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

"""

Logging package for Python. Based on PEP 282 and comments thereto in

To use, simply 'import logging' and log away!

"""

from string import Formatter as StrFormatter

'FATAL', 'FileHandler', 'Filter', 'Formatter', 'Handler', 'INFO',

'LogRecord', 'Logger', 'LoggerAdapter', 'NOTSET', 'NullHandler',

'StreamHandler', 'WARN', 'WARNING', 'addLevelName', 'basicConfig',

'captureWarnings', 'critical', 'debug', 'disable', 'error',

'exception', 'fatal', 'getLevelName', 'getLogger', 'getLoggerClass',

'info', 'log', 'makeLogRecord', 'setLoggerClass', 'shutdown',

'warn', 'warning', 'getLogRecordFactory', 'setLogRecordFactory',

'lastResort', 'raiseExceptions', 'getLevelNamesMapping',

'getHandlerByName', 'getHandlerNames']

__author__ = "Vinay Sajip <[email protected]>"

__version__ = "0.5.1.2"

__date__ = "07 February 2010"

#---------------------------------------------------------------------------

# Miscellaneous module data

#---------------------------------------------------------------------------

#

#_startTime is used as the base when calculating the relative time of events

#

_startTime = time.time()

#

#raiseExceptions is used to see if exceptions during handling should be

#propagated

#

#

# If you don't want asyncio task information in the log, set this to False

#

logAsyncioTasks = True

#---------------------------------------------------------------------------

# Level related stuff

#---------------------------------------------------------------------------

#

# Default levels and level names, these can be replaced with any positive set

# of values having corresponding names. There is a pseudo-level, NOTSET, which

# is only really there as a lower limit for user-defined levels. Handlers and

# loggers are initialized with NOTSET so that they will log all messages, even

# at user-defined levels.

#

CRITICAL = 50

FATAL = CRITICAL

ERROR = 40

WARNING = 30

WARN = WARNING

INFO = 20

DEBUG = 10

NOTSET = 0

_levelToName = {

CRITICAL: 'CRITICAL',

ERROR: 'ERROR',

WARNING: 'WARNING',

INFO: 'INFO',

DEBUG: 'DEBUG',

NOTSET: 'NOTSET',

}

_nameToLevel = {

'CRITICAL': CRITICAL,

'ERROR': ERROR,

'WARN': WARNING,

'WARNING': WARNING,

'INFO': INFO,

'DEBUG': DEBUG,

'NOTSET': NOTSET,

}

def getLevelNamesMapping():

return _nameToLevel.copy()

def getLevelName(level):

"""

INFO, DEBUG) then you get the corresponding string. If you have

associated levels with names using addLevelName then the name you have

associated with 'level' is returned.

If a numeric value corresponding to one of the defined levels is passed

in, the corresponding string representation is returned.

If a string representation of the level is passed in, the corresponding

numeric value is returned.

If no matching numeric or string value is passed in, the string

'Level %s' % level is returned.

# See Issues #22386, #27937 and #29220 for why it's this way

result = _levelToName.get(level)

if result is not None:

return result

result = _nameToLevel.get(level)

if result is not None:

return result

return "Level %s" % level

def addLevelName(level, levelName):

"""

Associate 'levelName' with 'level'.

This is used when converting levels to text during message formatting.

"""

_acquireLock()

try: #unlikely to cause an exception, but you never know...

_levelToName[level] = levelName

_nameToLevel[levelName] = level

finally:

_releaseLock()

if hasattr(sys, "_getframe"):

currentframe = lambda: sys._getframe(1)

else: #pragma: no cover

def currentframe():

"""Return the frame object for the caller's stack frame."""

try:

raise Exception

except Exception as exc:

return exc.__traceback__.tb_frame.f_back

#

# _srcfile is used when walking the stack to check when we've got the first

# caller stack frame, by skipping frames whose filename is that of this

# module's source. It therefore should contain the filename of this module's

# source file.

#

# Ordinarily we would use __file__ for this, but frozen modules don't always

# have __file__ set, for some reason (see Issue #21736). Thus, we get the

# filename from a handy code object from a function defined in this module.

# (There's no particular reason for picking addLevelName.)

#

_srcfile = os.path.normcase(addLevelName.__code__.co_filename)

# _srcfile is only used in conjunction with sys._getframe().

# Setting _srcfile to None will prevent findCaller() from being called. This

# way, you can avoid the overhead of fetching caller information.

# The following is based on warnings._is_internal_frame. It makes sure that

# frames of the import mechanism are skipped when logging at module level and

# using a stacklevel value greater than one.

def _is_internal_frame(frame):

"""Signal whether the frame is a CPython or logging module internal."""

filename = os.path.normcase(frame.f_code.co_filename)

return filename == _srcfile or (

"importlib" in filename and "_bootstrap" in filename

)

def _checkLevel(level):

if isinstance(level, int):

rv = level

elif str(level) == level:

raise TypeError("Level not an integer or a valid string: %r"

% (level,))

return rv

#---------------------------------------------------------------------------

# Thread-related stuff

#---------------------------------------------------------------------------

#

#_lock is used to serialize access to shared data structures in this module.

#This needs to be an RLock because fileConfig() creates and configures

#Handlers, and so might arbitrary user threads. Since Handler code updates the

#shared dictionary _handlers, it needs to acquire the lock. But if configuring,

#the lock would already have been acquired - so we need an RLock.

#The same argument applies to Loggers and Manager.loggerDict.

#

def _acquireLock():

"""

Acquire the module-level lock for serializing access to shared data.

This should be released with _releaseLock().

"""

if _lock:

_lock.acquire()

def _releaseLock():

"""

Release the module-level lock acquired by calling _acquireLock().

"""

if _lock:

_lock.release()

# Prevent a held logging lock from blocking a child from logging.

if not hasattr(os, 'register_at_fork'): # Windows and friends.

_at_fork_reinit_lock_weakset = weakref.WeakSet()

def _register_at_fork_reinit_lock(instance):

_acquireLock()

try:

_at_fork_reinit_lock_weakset.add(instance)

finally:

_releaseLock()

def _after_at_fork_child_reinit_locks():

for handler in _at_fork_reinit_lock_weakset:

# _acquireLock() was called in the parent before forking.

# The lock is reinitialized to unlocked state.

_lock._at_fork_reinit()

os.register_at_fork(before=_acquireLock,

after_in_child=_after_at_fork_child_reinit_locks,

after_in_parent=_releaseLock)

#---------------------------------------------------------------------------

# The logging record

#---------------------------------------------------------------------------

"""

A LogRecord instance represents an event being logged.

LogRecord instances are created every time something is logged. They

contain all the information pertinent to the event being logged. The

main information passed in is in msg and args, which are combined

using str(msg) % args to create the message field of the record. The

record also includes information such as when the record was created,

the source line where the logging call was made, and any exception

information to be logged.

"""

"""

Initialize a logging record with interesting information.

"""

ct = time.time()

self.name = name

self.msg = msg

#

# The following statement allows passing of a dictionary as a sole

# argument, so that you can do something like

# logging.debug("a %(a)d b %(b)s", {'a':1, 'b':2})

# Suggested by Stefan Behnel.

# Note that without the test for args[0], we get a problem because

# during formatting, we test to see if the arg is present using

# 'if self.args:'. If the event being logged is e.g. 'Value is %d'

# and if the passed arg fails 'if self.args:' then no formatting

# 'Value is %d' instead of 'Value is 0'.

# For the use case of passing a dictionary, this should not be a

# problem.

# Issue #21172: a request was made to relax the isinstance check

# to hasattr(args[0], '__getitem__'). However, the docs on string

# formatting still seem to suggest a mapping object is required.

# Thus, while not removing the isinstance check, it does now look

# for collections.abc.Mapping rather than, as before, dict.

if (args and len(args) == 1 and isinstance(args[0], collections.abc.Mapping)

self.args = args

self.levelname = getLevelName(level)

self.levelno = level

self.pathname = pathname

try:

self.filename = os.path.basename(pathname)

self.module = os.path.splitext(self.filename)[0]

self.filename = pathname

self.module = "Unknown module"

self.exc_info = exc_info

self.processName = 'MainProcess'

mp = sys.modules.get('multiprocessing')

if mp is not None:

# Errors may occur if multiprocessing has not finished loading

# yet - e.g. if a custom import hook causes third-party code

# to run when multiprocessing calls import. See issue 8200

# for an example

try:

self.processName = mp.current_process().name

self.process = os.getpid()

else:

self.process = None

self.taskName = None

if logAsyncioTasks:

asyncio = sys.modules.get('asyncio')

if asyncio:

try:

self.taskName = asyncio.current_task().get_name()

except Exception:

pass

return '<LogRecord: %s, %s, %s, %s, "%s">'%(self.name, self.levelno,

self.pathname, self.lineno, self.msg)

def getMessage(self):

"""

Return the message for this LogRecord.

Return the message for this LogRecord after merging any user-supplied

arguments with the message.

"""

if self.args:

msg = msg % self.args

return msg

#

# Determine which class to use when instantiating log records.

#

:param factory: A callable which will be called to instantiate

a log record.

global _logRecordFactory

_logRecordFactory = factory

"""

def makeLogRecord(dict):

"""

Make a LogRecord whose attributes are defined by the specified dictionary,

This function is useful for converting a logging event received over

a socket connection (which is sent as a dictionary) into a LogRecord

instance.

"""

rv.__dict__.update(dict)

return rv

#---------------------------------------------------------------------------

# Formatter classes and functions

#---------------------------------------------------------------------------

_str_formatter = StrFormatter()

del StrFormatter

class PercentStyle(object):

default_format = '%(message)s'

asctime_format = '%(asctime)s'

def usesTime(self):

def validate(self):

"""Validate the input format, ensure it matches the correct style"""

if not self.validation_pattern.search(self._fmt):

raise ValueError("Invalid format '%s' for '%s' style" % (self._fmt, self.default_format[0]))

def _format(self, record):

if defaults := self._defaults:

values = defaults | record.__dict__

else:

values = record.__dict__

return self._fmt % values

def format(self, record):

try:

return self._format(record)

except KeyError as e:

raise ValueError('Formatting field not found in record: %s' % e)

class StrFormatStyle(PercentStyle):

default_format = '{message}'

asctime_format = '{asctime}'

fmt_spec = re.compile(r'^(.?[<>=^])?[+ -]?#?0?(\d+|{\w+})?[,_]?(\.(\d+|{\w+}))?[bcdefgnosx%]?$', re.I)

field_spec = re.compile(r'^(\d+|\w+)(\.\w+|\[[^]]+\])*$')

def _format(self, record):

if defaults := self._defaults:

values = defaults | record.__dict__

else:

values = record.__dict__

return self._fmt.format(**values)

def validate(self):

"""Validate the input format, ensure it is the correct string formatting style"""

fields = set()

try:

for _, fieldname, spec, conversion in _str_formatter.parse(self._fmt):

if fieldname:

if not self.field_spec.match(fieldname):

raise ValueError('invalid field name/expression: %r' % fieldname)

fields.add(fieldname)

if conversion and conversion not in 'rsa':

raise ValueError('invalid conversion: %r' % conversion)

if spec and not self.fmt_spec.match(spec):

raise ValueError('bad specifier: %r' % spec)

except ValueError as e:

raise ValueError('invalid format: %s' % e)

if not fields:

raise ValueError('invalid format: no fields')

class StringTemplateStyle(PercentStyle):

default_format = '${message}'

asctime_format = '${asctime}'

def __init__(self, *args, **kwargs):

super().__init__(*args, **kwargs)

self._tpl = Template(self._fmt)

def usesTime(self):

fmt = self._fmt