# Copyright 2001-2017 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-2017 Vinay Sajip. All Rights Reserved.

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

"""

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

from string import Template

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

import threading

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

__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 zero

#

logThreads = True

#

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

#

logMultiprocessing = True

#

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

#

logProcesses = 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 getLevelName(level):

"""

Return the textual 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.

Otherwise, 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(3)

else: #pragma: no cover

def currentframe():

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

try:

raise Exception

except Exception:

return sys.exc_info()[2].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().

# To provide compatibility with older versions of Python, set _srcfile

# to None if _getframe() is not available; this value will prevent

# findCaller() from being called. You can also do this if you want to avoid

# the overhead of fetching caller information, even when _getframe() is

# available.

#if not hasattr(sys, '_getframe'):

# _srcfile = None

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()

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

# 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 = (ct - int(ct)) * 1000

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

def __str__(self):

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

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

__repr__ = __str__

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

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

class PercentStyle(object):

default_format = '%(message)s'

asctime_format = '%(asctime)s'

asctime_search = '%(asctime)'

def __init__(self, fmt):

self._fmt = fmt or self.default_format

def usesTime(self):

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

def format(self, record):

return self._fmt % record.__dict__

class StrFormatStyle(PercentStyle):

default_format = '{message}'

asctime_format = '{asctime}'

asctime_search = '{asctime'

def format(self, record):

return self._fmt.format(**record.__dict__)

class StringTemplateStyle(PercentStyle):

default_format = '${message}'

asctime_format = '${asctime}'

asctime_search = '${asctime}'

def __init__(self, fmt):

self._fmt = fmt or self.default_format

self._tpl = Template(self._fmt)

def usesTime(self):

fmt = self._fmt

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

def format(self, record):

return self._tpl.substitute(**record.__dict__)

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

default value of "%s(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)

%(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='%'):

"""

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 omitted, you get the ISO8601 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)

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, the ISO8601 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:

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

s = self.default_msec_format % (t, 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.

Is the specified record to be logged? Returns 0 for no, nonzero for

yes. 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 and the record is then dropped. Returns a zero value if a record

is to be dropped, else non-zero.

.. versionchanged:: 3.2

Allow filters to be just callables.

"""

rv = True

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:

rv = False

break

return rv

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

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

if wr in handlers:

handlers.remove(wr)

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()

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

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

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)

def emit(self, record):

"""

Do whatever it takes to actually log the specified logging record.

This version is intended to be implemented by subclasses and so

raises a NotImplementedError.

"""

raise NotImplementedError('emit must be implemented '

'by Handler subclasses')

def handle(self, record):

"""

Conditionally emit the specified logging record.

Emission depends on filters which may have been added to the handler.

Wrap the actual emission of the record with acquisition/release of

the I/O thread lock. Returns whether the filter passed the record for

emission.

"""

rv = self.filter(record)

if rv:

self.acquire()

try:

self.emit(record)

finally:

self.release()

return rv

def setFormatter(self, fmt):

"""

Set the formatter for this handler.

"""

self.formatter = fmt

def flush(self):

"""

Ensure all logging output has been flushed.

This version does nothing and is intended to be implemented by

subclasses.

"""

pass

def close(self):

"""

Tidy up any resources used by the handler.

This version removes the handler from an internal map of handlers,

_handlers, which is used for handler lookup by name. Subclasses

should ensure that this gets called from overridden close()

methods.

"""

#get the module data lock, as we're updating a shared structure.

_acquireLock()

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

if self._name and self._name in _handlers:

del _handlers[self._name]

finally:

_releaseLock()

def handleError(self, record):

"""

Handle errors which occur during an emit() call.

This method should be called from handlers when an exception is

encountered during an emit() call. If raiseExceptions is false,

exceptions get silently ignored. This is what is mostly wanted

for a logging system - most users will not care about errors in

the logging system, they are more interested in application errors.

You could, however, replace this with a custom handler if you wish.

The record which was being processed is passed in to this method.

"""

if raiseExceptions and sys.stderr: # see issue 13807

t, v, tb = sys.exc_info()

try:

sys.stderr.write('--- Logging error ---\n')

traceback.print_exception(t, v, tb, None, sys.stderr)

sys.stderr.write('Call stack:\n')

# Walk the stack frame up until we're out of logging,

# so as to print the calling context.

frame = tb.tb_frame

while (frame and os.path.dirname(frame.f_code.co_filename) ==

__path__[0]):

frame = frame.f_back

if frame:

traceback.print_stack(frame, file=sys.stderr)

else:

# couldn't find the right stack frame, for some reason

sys.stderr.write('Logged from file %s, line %s\n' % (

record.filename, record.lineno))

# Issue 18671: output logging message and arguments

try:

sys.stderr.write('Message: %r\n'

'Arguments: %s\n' % (record.msg,

record.args))

except Exception:

sys.stderr.write('Unable to print the message and arguments'

' - possible formatting error.\nUse the'

' traceback above to help find the error.\n'

)

except OSError: #pragma: no cover

pass # see issue 5971

finally:

del t, v, tb

def __repr__(self):

level = getLevelName(self.level)

return '<%s (%s)>' % (self.__class__.__name__, level)

class StreamHandler(Handler):

"""

A handler class which writes logging records, appropriately formatted,

to a stream. Note that this class does not close the stream, as

sys.stdout or sys.stderr may be used.

"""

terminator = '\n'

def __init__(self, stream=None):

"""

Initialize the handler.

If stream is not specified, sys.stderr is used.

"""

Handler.__init__(self)

if stream is None:

stream = sys.stderr

self.stream = stream

def flush(self):

"""

Flushes the stream.

"""

self.acquire()

try:

if self.stream and hasattr(self.stream, "flush"):

self.stream.flush()

finally:

self.release()

def emit(self, record):

"""

Emit a record.

If a formatter is specified, it is used to format the record.

The record is then written to the stream with a trailing newline. If

exception information is present, it is formatted using

traceback.print_exception and appended to the stream. If the stream

has an 'encoding' attribute, it is used to determine how to do the

output to the stream.

"""

try:

msg = self.format(record)

stream = self.stream

stream.write(msg)

stream.write(self.terminator)

self.flush()

except Exception:

self.handleError(record)

def setStream(self, stream):

"""

Sets the StreamHandler's stream to the specified value,

if it is different.

Returns the old stream, if the stream was changed, or None

if it wasn't.

"""

if stream is self.stream:

result = None

else: