# Copyright 2001-2022 by Vinay Sajip. All Rights Reserved.

#

# 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

comp.lang.python.

Copyright (C) 2001-2022 Vinay Sajip. All Rights Reserved.

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

"""

import sys, os, time, io, re, traceback, warnings, weakref, collections.abc

from types import GenericAlias

from string import Template

from string import Formatter as StrFormatter

__all__ = ['BASIC_FORMAT', 'BufferingFormatter', 'CRITICAL', 'DEBUG', 'ERROR',

'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']

import threading

__author__ = "Vinay Sajip <vinay_sajip@red-dove.com>"

__status__ = "production"

# The following module attributes are no longer updated.

__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

#

raiseExceptions = True

#

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

#

logThreads = True

#

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

#

logMultiprocessing = True

#

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

#

logProcesses = True

#

# 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,

'FATAL': FATAL,

'ERROR': ERROR,

'WARN': WARNING,

'WARNING': WARNING,

'INFO': INFO,

'DEBUG': DEBUG,

'NOTSET': NOTSET,

}

def getLevelNamesMapping():

return _nameToLevel.copy()

def getLevelName(level):

"""

Return the textual or numeric representation of logging level 'level'.

If the level is one of the predefined levels (CRITICAL, ERROR, WARNING,

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:

if level not in _nameToLevel:

raise ValueError("Unknown level: %r" % level)

rv = _nameToLevel[level]

else:

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.

#

_lock = threading.RLock()

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.

def _register_at_fork_reinit_lock(instance):

pass # no-op when os.register_at_fork does not exist.

else:

# A collection of instances with a _at_fork_reinit method (logging.Handler)

# to be called in the child after forking. The weakref avoids us keeping

# discarded Handler instances alive.

_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:

handler._at_fork_reinit()

# _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

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

class LogRecord(object):

"""

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.

"""

def __init__(self, name, level, pathname, lineno,

msg, args, exc_info, func=None, sinfo=None, **kwargs):

"""

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

# is done. For example, logger.warning('Value is %d', 0) would log

# '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)

and args[0]):

args = args[0]

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]

except (TypeError, ValueError, AttributeError):

self.filename = pathname

self.module = "Unknown module"

self.exc_info = exc_info

self.exc_text = None # used to cache the traceback text

self.stack_info = sinfo

self.lineno = lineno

self.funcName = func

self.created = ct

self.msecs = int((ct - int(ct)) * 1000) + 0.0 # see gh-89047

self.relativeCreated = (self.created - _startTime) * 1000

if logThreads:

self.thread = threading.get_ident()

self.threadName = threading.current_thread().name

else: # pragma: no cover

self.thread = None

self.threadName = None

if not logMultiprocessing: # pragma: no cover

self.processName = None

else:

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

except Exception: #pragma: no cover

pass

if logProcesses and hasattr(os, 'getpid'):

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

def __repr__(self):

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.

"""

msg = str(self.msg)

if self.args:

msg = msg % self.args

return msg

#

# Determine which class to use when instantiating log records.

#

_logRecordFactory = LogRecord

def setLogRecordFactory(factory):

"""

Set the factory to be used when instantiating a log record.

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

a log record.

"""

global _logRecordFactory

_logRecordFactory = factory

def getLogRecordFactory():

"""

Return the factory to be used when instantiating a log record.

"""

return _logRecordFactory

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 = _logRecordFactory(None, None, "", 0, "", (), None, None)

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'

asctime_search = '%(asctime)'

validation_pattern = re.compile(r'%\(\w+\)[#0+ -]*(\*|\d+)?(\.(\*|\d+))?[diouxefgcrsa%]', re.I)

def __init__(self, fmt, *, defaults=None):

self._fmt = fmt or self.default_format

self._defaults = defaults

def usesTime(self):

return self._fmt.find(self.asctime_search) >= 0

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}'

asctime_search = '{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}'

asctime_search = '${asctime}'

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

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

self._tpl = Template(self._fmt)

def usesTime(self):

fmt = self._fmt

return fmt.find('$asctime') >= 0 or fmt.find(self.asctime_search) >= 0

def validate(self):

pattern = Template.pattern

fields = set()

for m in pattern.finditer(self._fmt):

d = m.groupdict()

if d['named']:

fields.add(d['named'])

elif d['braced']:

fields.add(d['braced'])

elif m.group(0) == '$':

raise ValueError('invalid format: bare \'$\' not allowed')

if not fields:

raise ValueError('invalid format: no fields')

def _format(self, record):

if defaults := self._defaults:

values = defaults | record.__dict__

else:

values = record.__dict__

return self._tpl.substitute(**values)

BASIC_FORMAT = "%(levelname)s:%(name)s:%(message)s"

_STYLES = {

'%': (PercentStyle, BASIC_FORMAT),

'{': (StrFormatStyle, '{levelname}:{name}:{message}'),

'$': (StringTemplateStyle, '${levelname}:${name}:${message}'),

}

class Formatter(object):

"""

Formatter instances are used to convert a LogRecord to text.

Formatters need to know how a LogRecord is constructed. They are

responsible for converting a LogRecord to (usually) a string which can

be interpreted by either a human or an external system. The base Formatter

allows a formatting string to be specified. If none is supplied, the

style-dependent default value, "%(message)s", "{message}", or

"${message}", is used.

The Formatter can be initialized with a format string which makes use of

knowledge of the LogRecord attributes - e.g. the default value mentioned

above makes use of the fact that the user's message and arguments are pre-

formatted into a LogRecord's message attribute. Currently, the useful

attributes in a LogRecord are described by:

%(name)s Name of the logger (logging channel)

%(levelno)s Numeric logging level for the message (DEBUG, INFO,

WARNING, ERROR, CRITICAL)

%(levelname)s Text logging level for the message ("DEBUG", "INFO",

"WARNING", "ERROR", "CRITICAL")

%(pathname)s Full pathname of the source file where the logging

call was issued (if available)

%(filename)s Filename portion of pathname

%(module)s Module (name portion of filename)

%(lineno)d Source line number where the logging call was issued

(if available)

%(funcName)s Function name

%(created)f Time when the LogRecord was created (time.time()

return value)

%(asctime)s Textual time when the LogRecord was created

%(msecs)d Millisecond portion of the creation time

%(relativeCreated)d Time in milliseconds when the LogRecord was created,

relative to the time the logging module was loaded

(typically at application startup time)

%(thread)d Thread ID (if available)

%(threadName)s Thread name (if available)

%(taskName)s Task name (if available)

%(process)d Process ID (if available)

%(message)s The result of record.getMessage(), computed just as

the record is emitted

"""

converter = time.localtime

def __init__(self, fmt=None, datefmt=None, style='%', validate=True, *,

defaults=None):

"""

Initialize the formatter with specified format strings.

Initialize the formatter either with the specified format string, or a

default as described above. Allow for specialized date formatting with

the optional datefmt argument. If datefmt is omitted, you get an

ISO8601-like (or RFC 3339-like) format.

Use a style parameter of '%', '{' or '$' to specify that you want to

use one of %-formatting, :meth:`str.format` (``{}``) formatting or

:class:`string.Template` formatting in your format string.

.. versionchanged:: 3.2

Added the ``style`` parameter.

"""

if style not in _STYLES:

raise ValueError('Style must be one of: %s' % ','.join(

_STYLES.keys()))

self._style = _STYLES[style][0](fmt, defaults=defaults)

if validate:

self._style.validate()

self._fmt = self._style._fmt

self.datefmt = datefmt

default_time_format = '%Y-%m-%d %H:%M:%S'

default_msec_format = '%s,%03d'

def formatTime(self, record, datefmt=None):

"""

Return the creation time of the specified LogRecord as formatted text.

This method should be called from format() by a formatter which

wants to make use of a formatted time. This method can be overridden

in formatters to provide for any specific requirement, but the

basic behaviour is as follows: if datefmt (a string) is specified,

it is used with time.strftime() to format the creation time of the

record. Otherwise, an ISO8601-like (or RFC 3339-like) format is used.

The resulting string is returned. This function uses a user-configurable

function to convert the creation time to a tuple. By default,

time.localtime() is used; to change this for a particular formatter

instance, set the 'converter' attribute to a function with the same

signature as time.localtime() or time.gmtime(). To change it for all

formatters, for example if you want all logging times to be shown in GMT,

set the 'converter' attribute in the Formatter class.

"""

ct = self.converter(record.created)

if datefmt:

s = time.strftime(datefmt, ct)

else:

s = time.strftime(self.default_time_format, ct)

if self.default_msec_format:

s = self.default_msec_format % (s, record.msecs)

return s

def formatException(self, ei):

"""

Format and return the specified exception information as a string.

This default implementation just uses

traceback.print_exception()

"""

sio = io.StringIO()

tb = ei[2]

# See issues #9427, #1553375. Commented out for now.

#if getattr(self, 'fullstack', False):

# traceback.print_stack(tb.tb_frame.f_back, file=sio)

traceback.print_exception(ei[0], ei[1], tb, None, sio)

s = sio.getvalue()

sio.close()

if s[-1:] == "\n":

s = s[:-1]

return s

def usesTime(self):

"""

Check if the format uses the creation time of the record.

"""

return self._style.usesTime()

def formatMessage(self, record):

return self._style.format(record)

def formatStack(self, stack_info):

"""

This method is provided as an extension point for specialized

formatting of stack information.

The input data is a string as returned from a call to

:func:`traceback.print_stack`, but with the last trailing newline

removed.

The base implementation just returns the value passed in.

"""

return stack_info

def format(self, record):

"""

Format the specified record as text.

The record's attribute dictionary is used as the operand to a

string formatting operation which yields the returned string.

Before formatting the dictionary, a couple of preparatory steps

are carried out. The message attribute of the record is computed

using LogRecord.getMessage(). If the formatting string uses the

time (as determined by a call to usesTime(), formatTime() is

called to format the event time. If there is exception information,

it is formatted using formatException() and appended to the message.

"""

record.message = record.getMessage()

if self.usesTime():

record.asctime = self.formatTime(record, self.datefmt)

s = self.formatMessage(record)

if record.exc_info:

# Cache the traceback text to avoid converting it multiple times

# (it's constant anyway)

if not record.exc_text:

record.exc_text = self.formatException(record.exc_info)

if record.exc_text:

if s[-1:] != "\n":

s = s + "\n"

s = s + record.exc_text

if record.stack_info:

if s[-1:] != "\n":

s = s + "\n"

s = s + self.formatStack(record.stack_info)

return s

#

# The default formatter to use when no other is specified

#

_defaultFormatter = Formatter()

class BufferingFormatter(object):

"""

A formatter suitable for formatting a number of records.

"""

def __init__(self, linefmt=None):

"""

Optionally specify a formatter which will be used to format each

individual record.

"""

if linefmt:

self.linefmt = linefmt

else:

self.linefmt = _defaultFormatter

def formatHeader(self, records):

"""

Return the header string for the specified records.

"""

return ""

def formatFooter(self, records):

"""

Return the footer string for the specified records.

"""

return ""

def format(self, records):

"""

Format the specified records and return the result as a string.

"""

rv = ""

if len(records) > 0:

rv = rv + self.formatHeader(records)

for record in records:

rv = rv + self.linefmt.format(record)

rv = rv + self.formatFooter(records)

return rv

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

# Filter classes and functions

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

class Filter(object):

"""

Filter instances are used to perform arbitrary filtering of LogRecords.

Loggers and Handlers can optionally use Filter instances to filter

records as desired. The base filter class only allows events which are

below a certain point in the logger hierarchy. For example, a filter

initialized with "A.B" will allow events logged by loggers "A.B",

"A.B.C", "A.B.C.D", "A.B.D" etc. but not "A.BB", "B.A.B" etc. If

initialized with the empty string, all events are passed.

"""

def __init__(self, name=''):

"""

Initialize a filter.

Initialize with the name of the logger which, together with its

children, will have its events allowed through the filter. If no

name is specified, allow every event.

"""

self.name = name

self.nlen = len(name)

def filter(self, record):

"""

Determine if the specified record is to be logged.

Returns True if the record should be logged, or False otherwise.

If deemed appropriate, the record may be modified in-place.

"""

if self.nlen == 0:

return True

elif self.name == record.name:

return True

elif record.name.find(self.name, 0, self.nlen) != 0:

return False

return (record.name[self.nlen] == ".")

class Filterer(object):

"""

A base class for loggers and handlers which allows them to share

common code.

"""

def __init__(self):

"""

Initialize the list of filters to be an empty list.

"""

self.filters = []

def addFilter(self, filter):

"""

Add the specified filter to this handler.

"""

if not (filter in self.filters):

self.filters.append(filter)

def removeFilter(self, filter):

"""

Remove the specified filter from this handler.

"""

if filter in self.filters:

self.filters.remove(filter)

def filter(self, record):

"""

Determine if a record is loggable by consulting all the filters.

The default is to allow the record to be logged; any filter can veto

this by returning a false value.

If a filter attached to a handler returns a log record instance,

then that instance is used in place of the original log record in

any further processing of the event by that handler.

If a filter returns any other true value, the original log record

is used in any further processing of the event by that handler.

If none of the filters return false values, this method returns

a log record.

If any of the filters return a false value, this method returns

a false value.

.. versionchanged:: 3.2

Allow filters to be just callables.

.. versionchanged:: 3.12

Allow filters to return a LogRecord instead of

modifying it in place.

"""

for f in self.filters:

if hasattr(f, 'filter'):

result = f.filter(record)

else:

result = f(record) # assume callable - will raise if not

if not result:

return False

if isinstance(result, LogRecord):

record = result

return record

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

# Handler classes and functions

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

_handlers = weakref.WeakValueDictionary() #map of handler names to handlers

_handlerList = [] # added to allow handlers to be removed in reverse of order initialized

def _removeHandlerRef(wr):

"""

Remove a handler reference from the internal cleanup list.

"""

# This function can be called during module teardown, when globals are

# set to None. It can also be called from another thread. So we need to

# pre-emptively grab the necessary globals and check if they're None,

# to prevent race conditions and failures during interpreter shutdown.

acquire, release, handlers = _acquireLock, _releaseLock, _handlerList

if acquire and release and handlers:

acquire()

try:

handlers.remove(wr)

except ValueError:

pass

finally:

release()

def _addHandlerRef(handler):

"""

Add a handler to the internal cleanup list using a weak reference.

"""

_acquireLock()

try:

_handlerList.append(weakref.ref(handler, _removeHandlerRef))

finally:

_releaseLock()

def getHandlerByName(name):

"""

Get a handler with the specified *name*, or None if there isn't one with

that name.

"""

return _handlers.get(name)

def getHandlerNames():

"""

Return all known handler names as an immutable set.

"""

result = set(_handlers.keys())

return frozenset(result)

class Handler(Filterer):

"""

Handler instances dispatch logging events to specific destinations.

The base handler class. Acts as a placeholder which defines the Handler

interface. Handlers can optionally use Formatter instances to format

records as desired. By default, no formatter is specified; in this case,

the 'raw' message as determined by record.message is logged.

"""

def __init__(self, level=NOTSET):

"""

Initializes the instance - basically setting the formatter to None

and the filter list to empty.

"""

Filterer.__init__(self)

self._name = None

self.level = _checkLevel(level)

self.formatter = None

self._closed = False

# Add the handler to the global _handlerList (for cleanup on shutdown)

_addHandlerRef(self)

self.createLock()

def get_name(self):

return self._name

def set_name(self, name):

_acquireLock()

try:

if self._name in _handlers:

del _handlers[self._name]

self._name = name

if name:

_handlers[name] = self

finally:

_releaseLock()

name = property(get_name, set_name)

def createLock(self):

"""

Acquire a thread lock for serializing access to the underlying I/O.

"""

self.lock = threading.RLock()

_register_at_fork_reinit_lock(self)

def _at_fork_reinit(self):

self.lock._at_fork_reinit()

def acquire(self):

"""

Acquire the I/O thread lock.

"""

if self.lock:

self.lock.acquire()

def release(self):

"""

Release the I/O thread lock.

"""

if self.lock:

self.lock.release()

def setLevel(self, level):

"""

Set the logging level of this handler. level must be an int or a str.

"""

self.level = _checkLevel(level)

def format(self, record):

"""

Format the specified record.

If a formatter is set, use it. Otherwise, use the default formatter

for the module.

"""

if self.formatter:

fmt = self.formatter

else:

fmt = _defaultFormatter

return fmt.format(record)