1504 lines
56 KiB
Python
1504 lines
56 KiB
Python
# Copyright 2001-2016 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.
|
|
|
|
"""
|
|
Additional handlers for the logging package for Python. The core package is
|
|
based on PEP 282 and comments thereto in comp.lang.python.
|
|
|
|
Copyright (C) 2001-2016 Vinay Sajip. All Rights Reserved.
|
|
|
|
To use, simply 'import logging.handlers' and log away!
|
|
"""
|
|
|
|
import logging, socket, os, pickle, struct, time, re
|
|
from stat import ST_DEV, ST_INO, ST_MTIME
|
|
import queue
|
|
import threading
|
|
|
|
#
|
|
# Some constants...
|
|
#
|
|
|
|
DEFAULT_TCP_LOGGING_PORT = 9020
|
|
DEFAULT_UDP_LOGGING_PORT = 9021
|
|
DEFAULT_HTTP_LOGGING_PORT = 9022
|
|
DEFAULT_SOAP_LOGGING_PORT = 9023
|
|
SYSLOG_UDP_PORT = 514
|
|
SYSLOG_TCP_PORT = 514
|
|
|
|
_MIDNIGHT = 24 * 60 * 60 # number of seconds in a day
|
|
|
|
class BaseRotatingHandler(logging.FileHandler):
|
|
"""
|
|
Base class for handlers that rotate log files at a certain point.
|
|
Not meant to be instantiated directly. Instead, use RotatingFileHandler
|
|
or TimedRotatingFileHandler.
|
|
"""
|
|
def __init__(self, filename, mode, encoding=None, delay=False):
|
|
"""
|
|
Use the specified filename for streamed logging
|
|
"""
|
|
logging.FileHandler.__init__(self, filename, mode, encoding, delay)
|
|
self.mode = mode
|
|
self.encoding = encoding
|
|
self.namer = None
|
|
self.rotator = None
|
|
|
|
def emit(self, record):
|
|
"""
|
|
Emit a record.
|
|
|
|
Output the record to the file, catering for rollover as described
|
|
in doRollover().
|
|
"""
|
|
try:
|
|
if self.shouldRollover(record):
|
|
self.doRollover()
|
|
logging.FileHandler.emit(self, record)
|
|
except Exception:
|
|
self.handleError(record)
|
|
|
|
def rotation_filename(self, default_name):
|
|
"""
|
|
Modify the filename of a log file when rotating.
|
|
|
|
This is provided so that a custom filename can be provided.
|
|
|
|
The default implementation calls the 'namer' attribute of the
|
|
handler, if it's callable, passing the default name to
|
|
it. If the attribute isn't callable (the default is None), the name
|
|
is returned unchanged.
|
|
|
|
:param default_name: The default name for the log file.
|
|
"""
|
|
if not callable(self.namer):
|
|
result = default_name
|
|
else:
|
|
result = self.namer(default_name)
|
|
return result
|
|
|
|
def rotate(self, source, dest):
|
|
"""
|
|
When rotating, rotate the current log.
|
|
|
|
The default implementation calls the 'rotator' attribute of the
|
|
handler, if it's callable, passing the source and dest arguments to
|
|
it. If the attribute isn't callable (the default is None), the source
|
|
is simply renamed to the destination.
|
|
|
|
:param source: The source filename. This is normally the base
|
|
filename, e.g. 'test.log'
|
|
:param dest: The destination filename. This is normally
|
|
what the source is rotated to, e.g. 'test.log.1'.
|
|
"""
|
|
if not callable(self.rotator):
|
|
# Issue 18940: A file may not have been created if delay is True.
|
|
if os.path.exists(source):
|
|
os.rename(source, dest)
|
|
else:
|
|
self.rotator(source, dest)
|
|
|
|
class RotatingFileHandler(BaseRotatingHandler):
|
|
"""
|
|
Handler for logging to a set of files, which switches from one file
|
|
to the next when the current file reaches a certain size.
|
|
"""
|
|
def __init__(self, filename, mode='a', maxBytes=0, backupCount=0, encoding=None, delay=False):
|
|
"""
|
|
Open the specified file and use it as the stream for logging.
|
|
|
|
By default, the file grows indefinitely. You can specify particular
|
|
values of maxBytes and backupCount to allow the file to rollover at
|
|
a predetermined size.
|
|
|
|
Rollover occurs whenever the current log file is nearly maxBytes in
|
|
length. If backupCount is >= 1, the system will successively create
|
|
new files with the same pathname as the base file, but with extensions
|
|
".1", ".2" etc. appended to it. For example, with a backupCount of 5
|
|
and a base file name of "app.log", you would get "app.log",
|
|
"app.log.1", "app.log.2", ... through to "app.log.5". The file being
|
|
written to is always "app.log" - when it gets filled up, it is closed
|
|
and renamed to "app.log.1", and if files "app.log.1", "app.log.2" etc.
|
|
exist, then they are renamed to "app.log.2", "app.log.3" etc.
|
|
respectively.
|
|
|
|
If maxBytes is zero, rollover never occurs.
|
|
"""
|
|
# If rotation/rollover is wanted, it doesn't make sense to use another
|
|
# mode. If for example 'w' were specified, then if there were multiple
|
|
# runs of the calling application, the logs from previous runs would be
|
|
# lost if the 'w' is respected, because the log file would be truncated
|
|
# on each run.
|
|
if maxBytes > 0:
|
|
mode = 'a'
|
|
BaseRotatingHandler.__init__(self, filename, mode, encoding, delay)
|
|
self.maxBytes = maxBytes
|
|
self.backupCount = backupCount
|
|
|
|
def doRollover(self):
|
|
"""
|
|
Do a rollover, as described in __init__().
|
|
"""
|
|
if self.stream:
|
|
self.stream.close()
|
|
self.stream = None
|
|
if self.backupCount > 0:
|
|
for i in range(self.backupCount - 1, 0, -1):
|
|
sfn = self.rotation_filename("%s.%d" % (self.baseFilename, i))
|
|
dfn = self.rotation_filename("%s.%d" % (self.baseFilename,
|
|
i + 1))
|
|
if os.path.exists(sfn):
|
|
if os.path.exists(dfn):
|
|
os.remove(dfn)
|
|
os.rename(sfn, dfn)
|
|
dfn = self.rotation_filename(self.baseFilename + ".1")
|
|
if os.path.exists(dfn):
|
|
os.remove(dfn)
|
|
self.rotate(self.baseFilename, dfn)
|
|
if not self.delay:
|
|
self.stream = self._open()
|
|
|
|
def shouldRollover(self, record):
|
|
"""
|
|
Determine if rollover should occur.
|
|
|
|
Basically, see if the supplied record would cause the file to exceed
|
|
the size limit we have.
|
|
"""
|
|
if self.stream is None: # delay was set...
|
|
self.stream = self._open()
|
|
if self.maxBytes > 0: # are we rolling over?
|
|
msg = "%s\n" % self.format(record)
|
|
self.stream.seek(0, 2) #due to non-posix-compliant Windows feature
|
|
if self.stream.tell() + len(msg) >= self.maxBytes:
|
|
return 1
|
|
return 0
|
|
|
|
class TimedRotatingFileHandler(BaseRotatingHandler):
|
|
"""
|
|
Handler for logging to a file, rotating the log file at certain timed
|
|
intervals.
|
|
|
|
If backupCount is > 0, when rollover is done, no more than backupCount
|
|
files are kept - the oldest ones are deleted.
|
|
"""
|
|
def __init__(self, filename, when='h', interval=1, backupCount=0, encoding=None, delay=False, utc=False, atTime=None):
|
|
BaseRotatingHandler.__init__(self, filename, 'a', encoding, delay)
|
|
self.when = when.upper()
|
|
self.backupCount = backupCount
|
|
self.utc = utc
|
|
self.atTime = atTime
|
|
# Calculate the real rollover interval, which is just the number of
|
|
# seconds between rollovers. Also set the filename suffix used when
|
|
# a rollover occurs. Current 'when' events supported:
|
|
# S - Seconds
|
|
# M - Minutes
|
|
# H - Hours
|
|
# D - Days
|
|
# midnight - roll over at midnight
|
|
# W{0-6} - roll over on a certain day; 0 - Monday
|
|
#
|
|
# Case of the 'when' specifier is not important; lower or upper case
|
|
# will work.
|
|
if self.when == 'S':
|
|
self.interval = 1 # one second
|
|
self.suffix = "%Y-%m-%d_%H-%M-%S"
|
|
self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}(\.\w+)?$"
|
|
elif self.when == 'M':
|
|
self.interval = 60 # one minute
|
|
self.suffix = "%Y-%m-%d_%H-%M"
|
|
self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}(\.\w+)?$"
|
|
elif self.when == 'H':
|
|
self.interval = 60 * 60 # one hour
|
|
self.suffix = "%Y-%m-%d_%H"
|
|
self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}(\.\w+)?$"
|
|
elif self.when == 'D' or self.when == 'MIDNIGHT':
|
|
self.interval = 60 * 60 * 24 # one day
|
|
self.suffix = "%Y-%m-%d"
|
|
self.extMatch = r"^\d{4}-\d{2}-\d{2}(\.\w+)?$"
|
|
elif self.when.startswith('W'):
|
|
self.interval = 60 * 60 * 24 * 7 # one week
|
|
if len(self.when) != 2:
|
|
raise ValueError("You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s" % self.when)
|
|
if self.when[1] < '0' or self.when[1] > '6':
|
|
raise ValueError("Invalid day specified for weekly rollover: %s" % self.when)
|
|
self.dayOfWeek = int(self.when[1])
|
|
self.suffix = "%Y-%m-%d"
|
|
self.extMatch = r"^\d{4}-\d{2}-\d{2}(\.\w+)?$"
|
|
else:
|
|
raise ValueError("Invalid rollover interval specified: %s" % self.when)
|
|
|
|
self.extMatch = re.compile(self.extMatch, re.ASCII)
|
|
self.interval = self.interval * interval # multiply by units requested
|
|
# The following line added because the filename passed in could be a
|
|
# path object (see Issue #27493), but self.baseFilename will be a string
|
|
filename = self.baseFilename
|
|
if os.path.exists(filename):
|
|
t = os.stat(filename)[ST_MTIME]
|
|
else:
|
|
t = int(time.time())
|
|
self.rolloverAt = self.computeRollover(t)
|
|
|
|
def computeRollover(self, currentTime):
|
|
"""
|
|
Work out the rollover time based on the specified time.
|
|
"""
|
|
result = currentTime + self.interval
|
|
# If we are rolling over at midnight or weekly, then the interval is already known.
|
|
# What we need to figure out is WHEN the next interval is. In other words,
|
|
# if you are rolling over at midnight, then your base interval is 1 day,
|
|
# but you want to start that one day clock at midnight, not now. So, we
|
|
# have to fudge the rolloverAt value in order to trigger the first rollover
|
|
# at the right time. After that, the regular interval will take care of
|
|
# the rest. Note that this code doesn't care about leap seconds. :)
|
|
if self.when == 'MIDNIGHT' or self.when.startswith('W'):
|
|
# This could be done with less code, but I wanted it to be clear
|
|
if self.utc:
|
|
t = time.gmtime(currentTime)
|
|
else:
|
|
t = time.localtime(currentTime)
|
|
currentHour = t[3]
|
|
currentMinute = t[4]
|
|
currentSecond = t[5]
|
|
currentDay = t[6]
|
|
# r is the number of seconds left between now and the next rotation
|
|
if self.atTime is None:
|
|
rotate_ts = _MIDNIGHT
|
|
else:
|
|
rotate_ts = ((self.atTime.hour * 60 + self.atTime.minute)*60 +
|
|
self.atTime.second)
|
|
|
|
r = rotate_ts - ((currentHour * 60 + currentMinute) * 60 +
|
|
currentSecond)
|
|
if r < 0:
|
|
# Rotate time is before the current time (for example when
|
|
# self.rotateAt is 13:45 and it now 14:15), rotation is
|
|
# tomorrow.
|
|
r += _MIDNIGHT
|
|
currentDay = (currentDay + 1) % 7
|
|
result = currentTime + r
|
|
# If we are rolling over on a certain day, add in the number of days until
|
|
# the next rollover, but offset by 1 since we just calculated the time
|
|
# until the next day starts. There are three cases:
|
|
# Case 1) The day to rollover is today; in this case, do nothing
|
|
# Case 2) The day to rollover is further in the interval (i.e., today is
|
|
# day 2 (Wednesday) and rollover is on day 6 (Sunday). Days to
|
|
# next rollover is simply 6 - 2 - 1, or 3.
|
|
# Case 3) The day to rollover is behind us in the interval (i.e., today
|
|
# is day 5 (Saturday) and rollover is on day 3 (Thursday).
|
|
# Days to rollover is 6 - 5 + 3, or 4. In this case, it's the
|
|
# number of days left in the current week (1) plus the number
|
|
# of days in the next week until the rollover day (3).
|
|
# The calculations described in 2) and 3) above need to have a day added.
|
|
# This is because the above time calculation takes us to midnight on this
|
|
# day, i.e. the start of the next day.
|
|
if self.when.startswith('W'):
|
|
day = currentDay # 0 is Monday
|
|
if day != self.dayOfWeek:
|
|
if day < self.dayOfWeek:
|
|
daysToWait = self.dayOfWeek - day
|
|
else:
|
|
daysToWait = 6 - day + self.dayOfWeek + 1
|
|
newRolloverAt = result + (daysToWait * (60 * 60 * 24))
|
|
if not self.utc:
|
|
dstNow = t[-1]
|
|
dstAtRollover = time.localtime(newRolloverAt)[-1]
|
|
if dstNow != dstAtRollover:
|
|
if not dstNow: # DST kicks in before next rollover, so we need to deduct an hour
|
|
addend = -3600
|
|
else: # DST bows out before next rollover, so we need to add an hour
|
|
addend = 3600
|
|
newRolloverAt += addend
|
|
result = newRolloverAt
|
|
return result
|
|
|
|
def shouldRollover(self, record):
|
|
"""
|
|
Determine if rollover should occur.
|
|
|
|
record is not used, as we are just comparing times, but it is needed so
|
|
the method signatures are the same
|
|
"""
|
|
t = int(time.time())
|
|
if t >= self.rolloverAt:
|
|
return 1
|
|
return 0
|
|
|
|
def getFilesToDelete(self):
|
|
"""
|
|
Determine the files to delete when rolling over.
|
|
|
|
More specific than the earlier method, which just used glob.glob().
|
|
"""
|
|
dirName, baseName = os.path.split(self.baseFilename)
|
|
fileNames = os.listdir(dirName)
|
|
result = []
|
|
prefix = baseName + "."
|
|
plen = len(prefix)
|
|
for fileName in fileNames:
|
|
if fileName[:plen] == prefix:
|
|
suffix = fileName[plen:]
|
|
if self.extMatch.match(suffix):
|
|
result.append(os.path.join(dirName, fileName))
|
|
if len(result) < self.backupCount:
|
|
result = []
|
|
else:
|
|
result.sort()
|
|
result = result[:len(result) - self.backupCount]
|
|
return result
|
|
|
|
def doRollover(self):
|
|
"""
|
|
do a rollover; in this case, a date/time stamp is appended to the filename
|
|
when the rollover happens. However, you want the file to be named for the
|
|
start of the interval, not the current time. If there is a backup count,
|
|
then we have to get a list of matching filenames, sort them and remove
|
|
the one with the oldest suffix.
|
|
"""
|
|
if self.stream:
|
|
self.stream.close()
|
|
self.stream = None
|
|
# get the time that this sequence started at and make it a TimeTuple
|
|
currentTime = int(time.time())
|
|
dstNow = time.localtime(currentTime)[-1]
|
|
t = self.rolloverAt - self.interval
|
|
if self.utc:
|
|
timeTuple = time.gmtime(t)
|
|
else:
|
|
timeTuple = time.localtime(t)
|
|
dstThen = timeTuple[-1]
|
|
if dstNow != dstThen:
|
|
if dstNow:
|
|
addend = 3600
|
|
else:
|
|
addend = -3600
|
|
timeTuple = time.localtime(t + addend)
|
|
dfn = self.rotation_filename(self.baseFilename + "." +
|
|
time.strftime(self.suffix, timeTuple))
|
|
if os.path.exists(dfn):
|
|
os.remove(dfn)
|
|
self.rotate(self.baseFilename, dfn)
|
|
if self.backupCount > 0:
|
|
for s in self.getFilesToDelete():
|
|
os.remove(s)
|
|
if not self.delay:
|
|
self.stream = self._open()
|
|
newRolloverAt = self.computeRollover(currentTime)
|
|
while newRolloverAt <= currentTime:
|
|
newRolloverAt = newRolloverAt + self.interval
|
|
#If DST changes and midnight or weekly rollover, adjust for this.
|
|
if (self.when == 'MIDNIGHT' or self.when.startswith('W')) and not self.utc:
|
|
dstAtRollover = time.localtime(newRolloverAt)[-1]
|
|
if dstNow != dstAtRollover:
|
|
if not dstNow: # DST kicks in before next rollover, so we need to deduct an hour
|
|
addend = -3600
|
|
else: # DST bows out before next rollover, so we need to add an hour
|
|
addend = 3600
|
|
newRolloverAt += addend
|
|
self.rolloverAt = newRolloverAt
|
|
|
|
class WatchedFileHandler(logging.FileHandler):
|
|
"""
|
|
A handler for logging to a file, which watches the file
|
|
to see if it has changed while in use. This can happen because of
|
|
usage of programs such as newsyslog and logrotate which perform
|
|
log file rotation. This handler, intended for use under Unix,
|
|
watches the file to see if it has changed since the last emit.
|
|
(A file has changed if its device or inode have changed.)
|
|
If it has changed, the old file stream is closed, and the file
|
|
opened to get a new stream.
|
|
|
|
This handler is not appropriate for use under Windows, because
|
|
under Windows open files cannot be moved or renamed - logging
|
|
opens the files with exclusive locks - and so there is no need
|
|
for such a handler. Furthermore, ST_INO is not supported under
|
|
Windows; stat always returns zero for this value.
|
|
|
|
This handler is based on a suggestion and patch by Chad J.
|
|
Schroeder.
|
|
"""
|
|
def __init__(self, filename, mode='a', encoding=None, delay=False):
|
|
logging.FileHandler.__init__(self, filename, mode, encoding, delay)
|
|
self.dev, self.ino = -1, -1
|
|
self._statstream()
|
|
|
|
def _statstream(self):
|
|
if self.stream:
|
|
sres = os.fstat(self.stream.fileno())
|
|
self.dev, self.ino = sres[ST_DEV], sres[ST_INO]
|
|
|
|
def reopenIfNeeded(self):
|
|
"""
|
|
Reopen log file if needed.
|
|
|
|
Checks if the underlying file has changed, and if it
|
|
has, close the old stream and reopen the file to get the
|
|
current stream.
|
|
"""
|
|
# Reduce the chance of race conditions by stat'ing by path only
|
|
# once and then fstat'ing our new fd if we opened a new log stream.
|
|
# See issue #14632: Thanks to John Mulligan for the problem report
|
|
# and patch.
|
|
try:
|
|
# stat the file by path, checking for existence
|
|
sres = os.stat(self.baseFilename)
|
|
except FileNotFoundError:
|
|
sres = None
|
|
# compare file system stat with that of our stream file handle
|
|
if not sres or sres[ST_DEV] != self.dev or sres[ST_INO] != self.ino:
|
|
if self.stream is not None:
|
|
# we have an open file handle, clean it up
|
|
self.stream.flush()
|
|
self.stream.close()
|
|
self.stream = None # See Issue #21742: _open () might fail.
|
|
# open a new file handle and get new stat info from that fd
|
|
self.stream = self._open()
|
|
self._statstream()
|
|
|
|
def emit(self, record):
|
|
"""
|
|
Emit a record.
|
|
|
|
If underlying file has changed, reopen the file before emitting the
|
|
record to it.
|
|
"""
|
|
self.reopenIfNeeded()
|
|
logging.FileHandler.emit(self, record)
|
|
|
|
|
|
class SocketHandler(logging.Handler):
|
|
"""
|
|
A handler class which writes logging records, in pickle format, to
|
|
a streaming socket. The socket is kept open across logging calls.
|
|
If the peer resets it, an attempt is made to reconnect on the next call.
|
|
The pickle which is sent is that of the LogRecord's attribute dictionary
|
|
(__dict__), so that the receiver does not need to have the logging module
|
|
installed in order to process the logging event.
|
|
|
|
To unpickle the record at the receiving end into a LogRecord, use the
|
|
makeLogRecord function.
|
|
"""
|
|
|
|
def __init__(self, host, port):
|
|
"""
|
|
Initializes the handler with a specific host address and port.
|
|
|
|
When the attribute *closeOnError* is set to True - if a socket error
|
|
occurs, the socket is silently closed and then reopened on the next
|
|
logging call.
|
|
"""
|
|
logging.Handler.__init__(self)
|
|
self.host = host
|
|
self.port = port
|
|
if port is None:
|
|
self.address = host
|
|
else:
|
|
self.address = (host, port)
|
|
self.sock = None
|
|
self.closeOnError = False
|
|
self.retryTime = None
|
|
#
|
|
# Exponential backoff parameters.
|
|
#
|
|
self.retryStart = 1.0
|
|
self.retryMax = 30.0
|
|
self.retryFactor = 2.0
|
|
|
|
def makeSocket(self, timeout=1):
|
|
"""
|
|
A factory method which allows subclasses to define the precise
|
|
type of socket they want.
|
|
"""
|
|
if self.port is not None:
|
|
result = socket.create_connection(self.address, timeout=timeout)
|
|
else:
|
|
result = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
|
|
result.settimeout(timeout)
|
|
try:
|
|
result.connect(self.address)
|
|
except OSError:
|
|
result.close() # Issue 19182
|
|
raise
|
|
return result
|
|
|
|
def createSocket(self):
|
|
"""
|
|
Try to create a socket, using an exponential backoff with
|
|
a max retry time. Thanks to Robert Olson for the original patch
|
|
(SF #815911) which has been slightly refactored.
|
|
"""
|
|
now = time.time()
|
|
# Either retryTime is None, in which case this
|
|
# is the first time back after a disconnect, or
|
|
# we've waited long enough.
|
|
if self.retryTime is None:
|
|
attempt = True
|
|
else:
|
|
attempt = (now >= self.retryTime)
|
|
if attempt:
|
|
try:
|
|
self.sock = self.makeSocket()
|
|
self.retryTime = None # next time, no delay before trying
|
|
except OSError:
|
|
#Creation failed, so set the retry time and return.
|
|
if self.retryTime is None:
|
|
self.retryPeriod = self.retryStart
|
|
else:
|
|
self.retryPeriod = self.retryPeriod * self.retryFactor
|
|
if self.retryPeriod > self.retryMax:
|
|
self.retryPeriod = self.retryMax
|
|
self.retryTime = now + self.retryPeriod
|
|
|
|
def send(self, s):
|
|
"""
|
|
Send a pickled string to the socket.
|
|
|
|
This function allows for partial sends which can happen when the
|
|
network is busy.
|
|
"""
|
|
if self.sock is None:
|
|
self.createSocket()
|
|
#self.sock can be None either because we haven't reached the retry
|
|
#time yet, or because we have reached the retry time and retried,
|
|
#but are still unable to connect.
|
|
if self.sock:
|
|
try:
|
|
self.sock.sendall(s)
|
|
except OSError: #pragma: no cover
|
|
self.sock.close()
|
|
self.sock = None # so we can call createSocket next time
|
|
|
|
def makePickle(self, record):
|
|
"""
|
|
Pickles the record in binary format with a length prefix, and
|
|
returns it ready for transmission across the socket.
|
|
"""
|
|
ei = record.exc_info
|
|
if ei:
|
|
# just to get traceback text into record.exc_text ...
|
|
dummy = self.format(record)
|
|
# See issue #14436: If msg or args are objects, they may not be
|
|
# available on the receiving end. So we convert the msg % args
|
|
# to a string, save it as msg and zap the args.
|
|
d = dict(record.__dict__)
|
|
d['msg'] = record.getMessage()
|
|
d['args'] = None
|
|
d['exc_info'] = None
|
|
# Issue #25685: delete 'message' if present: redundant with 'msg'
|
|
d.pop('message', None)
|
|
s = pickle.dumps(d, 1)
|
|
slen = struct.pack(">L", len(s))
|
|
return slen + s
|
|
|
|
def handleError(self, record):
|
|
"""
|
|
Handle an error during logging.
|
|
|
|
An error has occurred during logging. Most likely cause -
|
|
connection lost. Close the socket so that we can retry on the
|
|
next event.
|
|
"""
|
|
if self.closeOnError and self.sock:
|
|
self.sock.close()
|
|
self.sock = None #try to reconnect next time
|
|
else:
|
|
logging.Handler.handleError(self, record)
|
|
|
|
def emit(self, record):
|
|
"""
|
|
Emit a record.
|
|
|
|
Pickles the record and writes it to the socket in binary format.
|
|
If there is an error with the socket, silently drop the packet.
|
|
If there was a problem with the socket, re-establishes the
|
|
socket.
|
|
"""
|
|
try:
|
|
s = self.makePickle(record)
|
|
self.send(s)
|
|
except Exception:
|
|
self.handleError(record)
|
|
|
|
def close(self):
|
|
"""
|
|
Closes the socket.
|
|
"""
|
|
self.acquire()
|
|
try:
|
|
sock = self.sock
|
|
if sock:
|
|
self.sock = None
|
|
sock.close()
|
|
logging.Handler.close(self)
|
|
finally:
|
|
self.release()
|
|
|
|
class DatagramHandler(SocketHandler):
|
|
"""
|
|
A handler class which writes logging records, in pickle format, to
|
|
a datagram socket. The pickle which is sent is that of the LogRecord's
|
|
attribute dictionary (__dict__), so that the receiver does not need to
|
|
have the logging module installed in order to process the logging event.
|
|
|
|
To unpickle the record at the receiving end into a LogRecord, use the
|
|
makeLogRecord function.
|
|
|
|
"""
|
|
def __init__(self, host, port):
|
|
"""
|
|
Initializes the handler with a specific host address and port.
|
|
"""
|
|
SocketHandler.__init__(self, host, port)
|
|
self.closeOnError = False
|
|
|
|
def makeSocket(self):
|
|
"""
|
|
The factory method of SocketHandler is here overridden to create
|
|
a UDP socket (SOCK_DGRAM).
|
|
"""
|
|
if self.port is None:
|
|
family = socket.AF_UNIX
|
|
else:
|
|
family = socket.AF_INET
|
|
s = socket.socket(family, socket.SOCK_DGRAM)
|
|
return s
|
|
|
|
def send(self, s):
|
|
"""
|
|
Send a pickled string to a socket.
|
|
|
|
This function no longer allows for partial sends which can happen
|
|
when the network is busy - UDP does not guarantee delivery and
|
|
can deliver packets out of sequence.
|
|
"""
|
|
if self.sock is None:
|
|
self.createSocket()
|
|
self.sock.sendto(s, self.address)
|
|
|
|
class SysLogHandler(logging.Handler):
|
|
"""
|
|
A handler class which sends formatted logging records to a syslog
|
|
server. Based on Sam Rushing's syslog module:
|
|
http://www.nightmare.com/squirl/python-ext/misc/syslog.py
|
|
Contributed by Nicolas Untz (after which minor refactoring changes
|
|
have been made).
|
|
"""
|
|
|
|
# from <linux/sys/syslog.h>:
|
|
# ======================================================================
|
|
# priorities/facilities are encoded into a single 32-bit quantity, where
|
|
# the bottom 3 bits are the priority (0-7) and the top 28 bits are the
|
|
# facility (0-big number). Both the priorities and the facilities map
|
|
# roughly one-to-one to strings in the syslogd(8) source code. This
|
|
# mapping is included in this file.
|
|
#
|
|
# priorities (these are ordered)
|
|
|
|
LOG_EMERG = 0 # system is unusable
|
|
LOG_ALERT = 1 # action must be taken immediately
|
|
LOG_CRIT = 2 # critical conditions
|
|
LOG_ERR = 3 # error conditions
|
|
LOG_WARNING = 4 # warning conditions
|
|
LOG_NOTICE = 5 # normal but significant condition
|
|
LOG_INFO = 6 # informational
|
|
LOG_DEBUG = 7 # debug-level messages
|
|
|
|
# facility codes
|
|
LOG_KERN = 0 # kernel messages
|
|
LOG_USER = 1 # random user-level messages
|
|
LOG_MAIL = 2 # mail system
|
|
LOG_DAEMON = 3 # system daemons
|
|
LOG_AUTH = 4 # security/authorization messages
|
|
LOG_SYSLOG = 5 # messages generated internally by syslogd
|
|
LOG_LPR = 6 # line printer subsystem
|
|
LOG_NEWS = 7 # network news subsystem
|
|
LOG_UUCP = 8 # UUCP subsystem
|
|
LOG_CRON = 9 # clock daemon
|
|
LOG_AUTHPRIV = 10 # security/authorization messages (private)
|
|
LOG_FTP = 11 # FTP daemon
|
|
|
|
# other codes through 15 reserved for system use
|
|
LOG_LOCAL0 = 16 # reserved for local use
|
|
LOG_LOCAL1 = 17 # reserved for local use
|
|
LOG_LOCAL2 = 18 # reserved for local use
|
|
LOG_LOCAL3 = 19 # reserved for local use
|
|
LOG_LOCAL4 = 20 # reserved for local use
|
|
LOG_LOCAL5 = 21 # reserved for local use
|
|
LOG_LOCAL6 = 22 # reserved for local use
|
|
LOG_LOCAL7 = 23 # reserved for local use
|
|
|
|
priority_names = {
|
|
"alert": LOG_ALERT,
|
|
"crit": LOG_CRIT,
|
|
"critical": LOG_CRIT,
|
|
"debug": LOG_DEBUG,
|
|
"emerg": LOG_EMERG,
|
|
"err": LOG_ERR,
|
|
"error": LOG_ERR, # DEPRECATED
|
|
"info": LOG_INFO,
|
|
"notice": LOG_NOTICE,
|
|
"panic": LOG_EMERG, # DEPRECATED
|
|
"warn": LOG_WARNING, # DEPRECATED
|
|
"warning": LOG_WARNING,
|
|
}
|
|
|
|
facility_names = {
|
|
"auth": LOG_AUTH,
|
|
"authpriv": LOG_AUTHPRIV,
|
|
"cron": LOG_CRON,
|
|
"daemon": LOG_DAEMON,
|
|
"ftp": LOG_FTP,
|
|
"kern": LOG_KERN,
|
|
"lpr": LOG_LPR,
|
|
"mail": LOG_MAIL,
|
|
"news": LOG_NEWS,
|
|
"security": LOG_AUTH, # DEPRECATED
|
|
"syslog": LOG_SYSLOG,
|
|
"user": LOG_USER,
|
|
"uucp": LOG_UUCP,
|
|
"local0": LOG_LOCAL0,
|
|
"local1": LOG_LOCAL1,
|
|
"local2": LOG_LOCAL2,
|
|
"local3": LOG_LOCAL3,
|
|
"local4": LOG_LOCAL4,
|
|
"local5": LOG_LOCAL5,
|
|
"local6": LOG_LOCAL6,
|
|
"local7": LOG_LOCAL7,
|
|
}
|
|
|
|
#The map below appears to be trivially lowercasing the key. However,
|
|
#there's more to it than meets the eye - in some locales, lowercasing
|
|
#gives unexpected results. See SF #1524081: in the Turkish locale,
|
|
#"INFO".lower() != "info"
|
|
priority_map = {
|
|
"DEBUG" : "debug",
|
|
"INFO" : "info",
|
|
"WARNING" : "warning",
|
|
"ERROR" : "error",
|
|
"CRITICAL" : "critical"
|
|
}
|
|
|
|
def __init__(self, address=('localhost', SYSLOG_UDP_PORT),
|
|
facility=LOG_USER, socktype=None):
|
|
"""
|
|
Initialize a handler.
|
|
|
|
If address is specified as a string, a UNIX socket is used. To log to a
|
|
local syslogd, "SysLogHandler(address="/dev/log")" can be used.
|
|
If facility is not specified, LOG_USER is used. If socktype is
|
|
specified as socket.SOCK_DGRAM or socket.SOCK_STREAM, that specific
|
|
socket type will be used. For Unix sockets, you can also specify a
|
|
socktype of None, in which case socket.SOCK_DGRAM will be used, falling
|
|
back to socket.SOCK_STREAM.
|
|
"""
|
|
logging.Handler.__init__(self)
|
|
|
|
self.address = address
|
|
self.facility = facility
|
|
self.socktype = socktype
|
|
|
|
if isinstance(address, str):
|
|
self.unixsocket = True
|
|
# Syslog server may be unavailable during handler initialisation.
|
|
# C's openlog() function also ignores connection errors.
|
|
# Moreover, we ignore these errors while logging, so it not worse
|
|
# to ignore it also here.
|
|
try:
|
|
self._connect_unixsocket(address)
|
|
except OSError:
|
|
pass
|
|
else:
|
|
self.unixsocket = False
|
|
if socktype is None:
|
|
socktype = socket.SOCK_DGRAM
|
|
host, port = address
|
|
ress = socket.getaddrinfo(host, port, 0, socktype)
|
|
if not ress:
|
|
raise OSError("getaddrinfo returns an empty list")
|
|
for res in ress:
|
|
af, socktype, proto, _, sa = res
|
|
err = sock = None
|
|
try:
|
|
sock = socket.socket(af, socktype, proto)
|
|
if socktype == socket.SOCK_STREAM:
|
|
sock.connect(sa)
|
|
break
|
|
except OSError as exc:
|
|
err = exc
|
|
if sock is not None:
|
|
sock.close()
|
|
if err is not None:
|
|
raise err
|
|
self.socket = sock
|
|
self.socktype = socktype
|
|
|
|
def _connect_unixsocket(self, address):
|
|
use_socktype = self.socktype
|
|
if use_socktype is None:
|
|
use_socktype = socket.SOCK_DGRAM
|
|
self.socket = socket.socket(socket.AF_UNIX, use_socktype)
|
|
try:
|
|
self.socket.connect(address)
|
|
# it worked, so set self.socktype to the used type
|
|
self.socktype = use_socktype
|
|
except OSError:
|
|
self.socket.close()
|
|
if self.socktype is not None:
|
|
# user didn't specify falling back, so fail
|
|
raise
|
|
use_socktype = socket.SOCK_STREAM
|
|
self.socket = socket.socket(socket.AF_UNIX, use_socktype)
|
|
try:
|
|
self.socket.connect(address)
|
|
# it worked, so set self.socktype to the used type
|
|
self.socktype = use_socktype
|
|
except OSError:
|
|
self.socket.close()
|
|
raise
|
|
|
|
def encodePriority(self, facility, priority):
|
|
"""
|
|
Encode the facility and priority. You can pass in strings or
|
|
integers - if strings are passed, the facility_names and
|
|
priority_names mapping dictionaries are used to convert them to
|
|
integers.
|
|
"""
|
|
if isinstance(facility, str):
|
|
facility = self.facility_names[facility]
|
|
if isinstance(priority, str):
|
|
priority = self.priority_names[priority]
|
|
return (facility << 3) | priority
|
|
|
|
def close(self):
|
|
"""
|
|
Closes the socket.
|
|
"""
|
|
self.acquire()
|
|
try:
|
|
self.socket.close()
|
|
logging.Handler.close(self)
|
|
finally:
|
|
self.release()
|
|
|
|
def mapPriority(self, levelName):
|
|
"""
|
|
Map a logging level name to a key in the priority_names map.
|
|
This is useful in two scenarios: when custom levels are being
|
|
used, and in the case where you can't do a straightforward
|
|
mapping by lowercasing the logging level name because of locale-
|
|
specific issues (see SF #1524081).
|
|
"""
|
|
return self.priority_map.get(levelName, "warning")
|
|
|
|
ident = '' # prepended to all messages
|
|
append_nul = True # some old syslog daemons expect a NUL terminator
|
|
|
|
def emit(self, record):
|
|
"""
|
|
Emit a record.
|
|
|
|
The record is formatted, and then sent to the syslog server. If
|
|
exception information is present, it is NOT sent to the server.
|
|
"""
|
|
try:
|
|
msg = self.format(record)
|
|
if self.ident:
|
|
msg = self.ident + msg
|
|
if self.append_nul:
|
|
msg += '\000'
|
|
|
|
# We need to convert record level to lowercase, maybe this will
|
|
# change in the future.
|
|
prio = '<%d>' % self.encodePriority(self.facility,
|
|
self.mapPriority(record.levelname))
|
|
prio = prio.encode('utf-8')
|
|
# Message is a string. Convert to bytes as required by RFC 5424
|
|
msg = msg.encode('utf-8')
|
|
msg = prio + msg
|
|
if self.unixsocket:
|
|
try:
|
|
self.socket.send(msg)
|
|
except OSError:
|
|
self.socket.close()
|
|
self._connect_unixsocket(self.address)
|
|
self.socket.send(msg)
|
|
elif self.socktype == socket.SOCK_DGRAM:
|
|
self.socket.sendto(msg, self.address)
|
|
else:
|
|
self.socket.sendall(msg)
|
|
except Exception:
|
|
self.handleError(record)
|
|
|
|
class SMTPHandler(logging.Handler):
|
|
"""
|
|
A handler class which sends an SMTP email for each logging event.
|
|
"""
|
|
def __init__(self, mailhost, fromaddr, toaddrs, subject,
|
|
credentials=None, secure=None, timeout=5.0):
|
|
"""
|
|
Initialize the handler.
|
|
|
|
Initialize the instance with the from and to addresses and subject
|
|
line of the email. To specify a non-standard SMTP port, use the
|
|
(host, port) tuple format for the mailhost argument. To specify
|
|
authentication credentials, supply a (username, password) tuple
|
|
for the credentials argument. To specify the use of a secure
|
|
protocol (TLS), pass in a tuple for the secure argument. This will
|
|
only be used when authentication credentials are supplied. The tuple
|
|
will be either an empty tuple, or a single-value tuple with the name
|
|
of a keyfile, or a 2-value tuple with the names of the keyfile and
|
|
certificate file. (This tuple is passed to the `starttls` method).
|
|
A timeout in seconds can be specified for the SMTP connection (the
|
|
default is one second).
|
|
"""
|
|
logging.Handler.__init__(self)
|
|
if isinstance(mailhost, (list, tuple)):
|
|
self.mailhost, self.mailport = mailhost
|
|
else:
|
|
self.mailhost, self.mailport = mailhost, None
|
|
if isinstance(credentials, (list, tuple)):
|
|
self.username, self.password = credentials
|
|
else:
|
|
self.username = None
|
|
self.fromaddr = fromaddr
|
|
if isinstance(toaddrs, str):
|
|
toaddrs = [toaddrs]
|
|
self.toaddrs = toaddrs
|
|
self.subject = subject
|
|
self.secure = secure
|
|
self.timeout = timeout
|
|
|
|
def getSubject(self, record):
|
|
"""
|
|
Determine the subject for the email.
|
|
|
|
If you want to specify a subject line which is record-dependent,
|
|
override this method.
|
|
"""
|
|
return self.subject
|
|
|
|
def emit(self, record):
|
|
"""
|
|
Emit a record.
|
|
|
|
Format the record and send it to the specified addressees.
|
|
"""
|
|
try:
|
|
import smtplib
|
|
from email.message import EmailMessage
|
|
import email.utils
|
|
|
|
port = self.mailport
|
|
if not port:
|
|
port = smtplib.SMTP_PORT
|
|
smtp = smtplib.SMTP(self.mailhost, port, timeout=self.timeout)
|
|
msg = EmailMessage()
|
|
msg['From'] = self.fromaddr
|
|
msg['To'] = ','.join(self.toaddrs)
|
|
msg['Subject'] = self.getSubject(record)
|
|
msg['Date'] = email.utils.localtime()
|
|
msg.set_content(self.format(record))
|
|
if self.username:
|
|
if self.secure is not None:
|
|
smtp.ehlo()
|
|
smtp.starttls(*self.secure)
|
|
smtp.ehlo()
|
|
smtp.login(self.username, self.password)
|
|
smtp.send_message(msg)
|
|
smtp.quit()
|
|
except Exception:
|
|
self.handleError(record)
|
|
|
|
class NTEventLogHandler(logging.Handler):
|
|
"""
|
|
A handler class which sends events to the NT Event Log. Adds a
|
|
registry entry for the specified application name. If no dllname is
|
|
provided, win32service.pyd (which contains some basic message
|
|
placeholders) is used. Note that use of these placeholders will make
|
|
your event logs big, as the entire message source is held in the log.
|
|
If you want slimmer logs, you have to pass in the name of your own DLL
|
|
which contains the message definitions you want to use in the event log.
|
|
"""
|
|
def __init__(self, appname, dllname=None, logtype="Application"):
|
|
logging.Handler.__init__(self)
|
|
try:
|
|
import win32evtlogutil, win32evtlog
|
|
self.appname = appname
|
|
self._welu = win32evtlogutil
|
|
if not dllname:
|
|
dllname = os.path.split(self._welu.__file__)
|
|
dllname = os.path.split(dllname[0])
|
|
dllname = os.path.join(dllname[0], r'win32service.pyd')
|
|
self.dllname = dllname
|
|
self.logtype = logtype
|
|
self._welu.AddSourceToRegistry(appname, dllname, logtype)
|
|
self.deftype = win32evtlog.EVENTLOG_ERROR_TYPE
|
|
self.typemap = {
|
|
logging.DEBUG : win32evtlog.EVENTLOG_INFORMATION_TYPE,
|
|
logging.INFO : win32evtlog.EVENTLOG_INFORMATION_TYPE,
|
|
logging.WARNING : win32evtlog.EVENTLOG_WARNING_TYPE,
|
|
logging.ERROR : win32evtlog.EVENTLOG_ERROR_TYPE,
|
|
logging.CRITICAL: win32evtlog.EVENTLOG_ERROR_TYPE,
|
|
}
|
|
except ImportError:
|
|
print("The Python Win32 extensions for NT (service, event "\
|
|
"logging) appear not to be available.")
|
|
self._welu = None
|
|
|
|
def getMessageID(self, record):
|
|
"""
|
|
Return the message ID for the event record. If you are using your
|
|
own messages, you could do this by having the msg passed to the
|
|
logger being an ID rather than a formatting string. Then, in here,
|
|
you could use a dictionary lookup to get the message ID. This
|
|
version returns 1, which is the base message ID in win32service.pyd.
|
|
"""
|
|
return 1
|
|
|
|
def getEventCategory(self, record):
|
|
"""
|
|
Return the event category for the record.
|
|
|
|
Override this if you want to specify your own categories. This version
|
|
returns 0.
|
|
"""
|
|
return 0
|
|
|
|
def getEventType(self, record):
|
|
"""
|
|
Return the event type for the record.
|
|
|
|
Override this if you want to specify your own types. This version does
|
|
a mapping using the handler's typemap attribute, which is set up in
|
|
__init__() to a dictionary which contains mappings for DEBUG, INFO,
|
|
WARNING, ERROR and CRITICAL. If you are using your own levels you will
|
|
either need to override this method or place a suitable dictionary in
|
|
the handler's typemap attribute.
|
|
"""
|
|
return self.typemap.get(record.levelno, self.deftype)
|
|
|
|
def emit(self, record):
|
|
"""
|
|
Emit a record.
|
|
|
|
Determine the message ID, event category and event type. Then
|
|
log the message in the NT event log.
|
|
"""
|
|
if self._welu:
|
|
try:
|
|
id = self.getMessageID(record)
|
|
cat = self.getEventCategory(record)
|
|
type = self.getEventType(record)
|
|
msg = self.format(record)
|
|
self._welu.ReportEvent(self.appname, id, cat, type, [msg])
|
|
except Exception:
|
|
self.handleError(record)
|
|
|
|
def close(self):
|
|
"""
|
|
Clean up this handler.
|
|
|
|
You can remove the application name from the registry as a
|
|
source of event log entries. However, if you do this, you will
|
|
not be able to see the events as you intended in the Event Log
|
|
Viewer - it needs to be able to access the registry to get the
|
|
DLL name.
|
|
"""
|
|
#self._welu.RemoveSourceFromRegistry(self.appname, self.logtype)
|
|
logging.Handler.close(self)
|
|
|
|
class HTTPHandler(logging.Handler):
|
|
"""
|
|
A class which sends records to a Web server, using either GET or
|
|
POST semantics.
|
|
"""
|
|
def __init__(self, host, url, method="GET", secure=False, credentials=None,
|
|
context=None):
|
|
"""
|
|
Initialize the instance with the host, the request URL, and the method
|
|
("GET" or "POST")
|
|
"""
|
|
logging.Handler.__init__(self)
|
|
method = method.upper()
|
|
if method not in ["GET", "POST"]:
|
|
raise ValueError("method must be GET or POST")
|
|
if not secure and context is not None:
|
|
raise ValueError("context parameter only makes sense "
|
|
"with secure=True")
|
|
self.host = host
|
|
self.url = url
|
|
self.method = method
|
|
self.secure = secure
|
|
self.credentials = credentials
|
|
self.context = context
|
|
|
|
def mapLogRecord(self, record):
|
|
"""
|
|
Default implementation of mapping the log record into a dict
|
|
that is sent as the CGI data. Overwrite in your class.
|
|
Contributed by Franz Glasner.
|
|
"""
|
|
return record.__dict__
|
|
|
|
def emit(self, record):
|
|
"""
|
|
Emit a record.
|
|
|
|
Send the record to the Web server as a percent-encoded dictionary
|
|
"""
|
|
try:
|
|
import http.client, urllib.parse
|
|
host = self.host
|
|
if self.secure:
|
|
h = http.client.HTTPSConnection(host, context=self.context)
|
|
else:
|
|
h = http.client.HTTPConnection(host)
|
|
url = self.url
|
|
data = urllib.parse.urlencode(self.mapLogRecord(record))
|
|
if self.method == "GET":
|
|
if (url.find('?') >= 0):
|
|
sep = '&'
|
|
else:
|
|
sep = '?'
|
|
url = url + "%c%s" % (sep, data)
|
|
h.putrequest(self.method, url)
|
|
# support multiple hosts on one IP address...
|
|
# need to strip optional :port from host, if present
|
|
i = host.find(":")
|
|
if i >= 0:
|
|
host = host[:i]
|
|
# See issue #30904: putrequest call above already adds this header
|
|
# on Python 3.x.
|
|
# h.putheader("Host", host)
|
|
if self.method == "POST":
|
|
h.putheader("Content-type",
|
|
"application/x-www-form-urlencoded")
|
|
h.putheader("Content-length", str(len(data)))
|
|
if self.credentials:
|
|
import base64
|
|
s = ('%s:%s' % self.credentials).encode('utf-8')
|
|
s = 'Basic ' + base64.b64encode(s).strip().decode('ascii')
|
|
h.putheader('Authorization', s)
|
|
h.endheaders()
|
|
if self.method == "POST":
|
|
h.send(data.encode('utf-8'))
|
|
h.getresponse() #can't do anything with the result
|
|
except Exception:
|
|
self.handleError(record)
|
|
|
|
class BufferingHandler(logging.Handler):
|
|
"""
|
|
A handler class which buffers logging records in memory. Whenever each
|
|
record is added to the buffer, a check is made to see if the buffer should
|
|
be flushed. If it should, then flush() is expected to do what's needed.
|
|
"""
|
|
def __init__(self, capacity):
|
|
"""
|
|
Initialize the handler with the buffer size.
|
|
"""
|
|
logging.Handler.__init__(self)
|
|
self.capacity = capacity
|
|
self.buffer = []
|
|
|
|
def shouldFlush(self, record):
|
|
"""
|
|
Should the handler flush its buffer?
|
|
|
|
Returns true if the buffer is up to capacity. This method can be
|
|
overridden to implement custom flushing strategies.
|
|
"""
|
|
return (len(self.buffer) >= self.capacity)
|
|
|
|
def emit(self, record):
|
|
"""
|
|
Emit a record.
|
|
|
|
Append the record. If shouldFlush() tells us to, call flush() to process
|
|
the buffer.
|
|
"""
|
|
self.buffer.append(record)
|
|
if self.shouldFlush(record):
|
|
self.flush()
|
|
|
|
def flush(self):
|
|
"""
|
|
Override to implement custom flushing behaviour.
|
|
|
|
This version just zaps the buffer to empty.
|
|
"""
|
|
self.acquire()
|
|
try:
|
|
self.buffer = []
|
|
finally:
|
|
self.release()
|
|
|
|
def close(self):
|
|
"""
|
|
Close the handler.
|
|
|
|
This version just flushes and chains to the parent class' close().
|
|
"""
|
|
try:
|
|
self.flush()
|
|
finally:
|
|
logging.Handler.close(self)
|
|
|
|
class MemoryHandler(BufferingHandler):
|
|
"""
|
|
A handler class which buffers logging records in memory, periodically
|
|
flushing them to a target handler. Flushing occurs whenever the buffer
|
|
is full, or when an event of a certain severity or greater is seen.
|
|
"""
|
|
def __init__(self, capacity, flushLevel=logging.ERROR, target=None,
|
|
flushOnClose=True):
|
|
"""
|
|
Initialize the handler with the buffer size, the level at which
|
|
flushing should occur and an optional target.
|
|
|
|
Note that without a target being set either here or via setTarget(),
|
|
a MemoryHandler is no use to anyone!
|
|
|
|
The ``flushOnClose`` argument is ``True`` for backward compatibility
|
|
reasons - the old behaviour is that when the handler is closed, the
|
|
buffer is flushed, even if the flush level hasn't been exceeded nor the
|
|
capacity exceeded. To prevent this, set ``flushOnClose`` to ``False``.
|
|
"""
|
|
BufferingHandler.__init__(self, capacity)
|
|
self.flushLevel = flushLevel
|
|
self.target = target
|
|
# See Issue #26559 for why this has been added
|
|
self.flushOnClose = flushOnClose
|
|
|
|
def shouldFlush(self, record):
|
|
"""
|
|
Check for buffer full or a record at the flushLevel or higher.
|
|
"""
|
|
return (len(self.buffer) >= self.capacity) or \
|
|
(record.levelno >= self.flushLevel)
|
|
|
|
def setTarget(self, target):
|
|
"""
|
|
Set the target handler for this handler.
|
|
"""
|
|
self.target = target
|
|
|
|
def flush(self):
|
|
"""
|
|
For a MemoryHandler, flushing means just sending the buffered
|
|
records to the target, if there is one. Override if you want
|
|
different behaviour.
|
|
|
|
The record buffer is also cleared by this operation.
|
|
"""
|
|
self.acquire()
|
|
try:
|
|
if self.target:
|
|
for record in self.buffer:
|
|
self.target.handle(record)
|
|
self.buffer = []
|
|
finally:
|
|
self.release()
|
|
|
|
def close(self):
|
|
"""
|
|
Flush, if appropriately configured, set the target to None and lose the
|
|
buffer.
|
|
"""
|
|
try:
|
|
if self.flushOnClose:
|
|
self.flush()
|
|
finally:
|
|
self.acquire()
|
|
try:
|
|
self.target = None
|
|
BufferingHandler.close(self)
|
|
finally:
|
|
self.release()
|
|
|
|
|
|
class QueueHandler(logging.Handler):
|
|
"""
|
|
This handler sends events to a queue. Typically, it would be used together
|
|
with a multiprocessing Queue to centralise logging to file in one process
|
|
(in a multi-process application), so as to avoid file write contention
|
|
between processes.
|
|
|
|
This code is new in Python 3.2, but this class can be copy pasted into
|
|
user code for use with earlier Python versions.
|
|
"""
|
|
|
|
def __init__(self, queue):
|
|
"""
|
|
Initialise an instance, using the passed queue.
|
|
"""
|
|
logging.Handler.__init__(self)
|
|
self.queue = queue
|
|
|
|
def enqueue(self, record):
|
|
"""
|
|
Enqueue a record.
|
|
|
|
The base implementation uses put_nowait. You may want to override
|
|
this method if you want to use blocking, timeouts or custom queue
|
|
implementations.
|
|
"""
|
|
self.queue.put_nowait(record)
|
|
|
|
def prepare(self, record):
|
|
"""
|
|
Prepares a record for queuing. The object returned by this method is
|
|
enqueued.
|
|
|
|
The base implementation formats the record to merge the message
|
|
and arguments, and removes unpickleable items from the record
|
|
in-place.
|
|
|
|
You might want to override this method if you want to convert
|
|
the record to a dict or JSON string, or send a modified copy
|
|
of the record while leaving the original intact.
|
|
"""
|
|
# The format operation gets traceback text into record.exc_text
|
|
# (if there's exception data), and also returns the formatted
|
|
# message. We can then use this to replace the original
|
|
# msg + args, as these might be unpickleable. We also zap the
|
|
# exc_info and exc_text attributes, as they are no longer
|
|
# needed and, if not None, will typically not be pickleable.
|
|
msg = self.format(record)
|
|
record.message = msg
|
|
record.msg = msg
|
|
record.args = None
|
|
record.exc_info = None
|
|
record.exc_text = None
|
|
return record
|
|
|
|
def emit(self, record):
|
|
"""
|
|
Emit a record.
|
|
|
|
Writes the LogRecord to the queue, preparing it for pickling first.
|
|
"""
|
|
try:
|
|
self.enqueue(self.prepare(record))
|
|
except Exception:
|
|
self.handleError(record)
|
|
|
|
|
|
class QueueListener(object):
|
|
"""
|
|
This class implements an internal threaded listener which watches for
|
|
LogRecords being added to a queue, removes them and passes them to a
|
|
list of handlers for processing.
|
|
"""
|
|
_sentinel = None
|
|
|
|
def __init__(self, queue, *handlers, respect_handler_level=False):
|
|
"""
|
|
Initialise an instance with the specified queue and
|
|
handlers.
|
|
"""
|
|
self.queue = queue
|
|
self.handlers = handlers
|
|
self._thread = None
|
|
self.respect_handler_level = respect_handler_level
|
|
|
|
def dequeue(self, block):
|
|
"""
|
|
Dequeue a record and return it, optionally blocking.
|
|
|
|
The base implementation uses get. You may want to override this method
|
|
if you want to use timeouts or work with custom queue implementations.
|
|
"""
|
|
return self.queue.get(block)
|
|
|
|
def start(self):
|
|
"""
|
|
Start the listener.
|
|
|
|
This starts up a background thread to monitor the queue for
|
|
LogRecords to process.
|
|
"""
|
|
self._thread = t = threading.Thread(target=self._monitor)
|
|
t.daemon = True
|
|
t.start()
|
|
|
|
def prepare(self , record):
|
|
"""
|
|
Prepare a record for handling.
|
|
|
|
This method just returns the passed-in record. You may want to
|
|
override this method if you need to do any custom marshalling or
|
|
manipulation of the record before passing it to the handlers.
|
|
"""
|
|
return record
|
|
|
|
def handle(self, record):
|
|
"""
|
|
Handle a record.
|
|
|
|
This just loops through the handlers offering them the record
|
|
to handle.
|
|
"""
|
|
record = self.prepare(record)
|
|
for handler in self.handlers:
|
|
if not self.respect_handler_level:
|
|
process = True
|
|
else:
|
|
process = record.levelno >= handler.level
|
|
if process:
|
|
handler.handle(record)
|
|
|
|
def _monitor(self):
|
|
"""
|
|
Monitor the queue for records, and ask the handler
|
|
to deal with them.
|
|
|
|
This method runs on a separate, internal thread.
|
|
The thread will terminate if it sees a sentinel object in the queue.
|
|
"""
|
|
q = self.queue
|
|
has_task_done = hasattr(q, 'task_done')
|
|
while True:
|
|
try:
|
|
record = self.dequeue(True)
|
|
if record is self._sentinel:
|
|
break
|
|
self.handle(record)
|
|
if has_task_done:
|
|
q.task_done()
|
|
except queue.Empty:
|
|
break
|
|
|
|
def enqueue_sentinel(self):
|
|
"""
|
|
This is used to enqueue the sentinel record.
|
|
|
|
The base implementation uses put_nowait. You may want to override this
|
|
method if you want to use timeouts or work with custom queue
|
|
implementations.
|
|
"""
|
|
self.queue.put_nowait(self._sentinel)
|
|
|
|
def stop(self):
|
|
"""
|
|
Stop the listener.
|
|
|
|
This asks the thread to terminate, and then waits for it to do so.
|
|
Note that if you don't call this before your application exits, there
|
|
may be some records still left on the queue, which won't be processed.
|
|
"""
|
|
self.enqueue_sentinel()
|
|
self._thread.join()
|
|
self._thread = None
|