handlers.py

# 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!
"""

importlogging, socket, os, pickle, struct, time, re
fromstatimportST_DEV, ST_INO, ST_MTIME
importqueue
importthreading
importcopy

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

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

defemit(self, record):
"""
 Emit a record.

 Output the record to the file, catering for rollover as described
 in doRollover().
 """
try:
ifself.shouldRollover(record):
self.doRollover()
logging.FileHandler.emit(self, record)
exceptException:
self.handleError(record)

defrotation_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.
 """
ifnotcallable(self.namer):
result=default_name
else:
result=self.namer(default_name)
returnresult

defrotate(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'.
 """
ifnotcallable(self.rotator):
# Issue 18940: A file may not have been created if delay is True.
ifos.path.exists(source):
os.rename(source, dest)
else:
self.rotator(source, dest)

classRotatingFileHandler(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.
ifmaxBytes>0:
mode='a'
BaseRotatingHandler.__init__(self, filename, mode, encoding, delay)
self.maxBytes=maxBytes
self.backupCount=backupCount

defdoRollover(self):
"""
 Do a rollover, as described in __init__().
 """
ifself.stream:
self.stream.close()
self.stream=None
ifself.backupCount>0:
foriinrange(self.backupCount-1, 0, -1):
sfn=self.rotation_filename("%s.%d"% (self.baseFilename, i))
dfn=self.rotation_filename("%s.%d"% (self.baseFilename,
i+1))
ifos.path.exists(sfn):
ifos.path.exists(dfn):
os.remove(dfn)
os.rename(sfn, dfn)
dfn=self.rotation_filename(self.baseFilename+".1")
ifos.path.exists(dfn):
os.remove(dfn)
self.rotate(self.baseFilename, dfn)
ifnotself.delay:
self.stream=self._open()

defshouldRollover(self, record):
"""
 Determine if rollover should occur.

 Basically, see if the supplied record would cause the file to exceed
 the size limit we have.
 """
ifself.streamisNone: # delay was set...
self.stream=self._open()
ifself.maxBytes>0: # are we rolling over?
msg="%s\n"%self.format(record)
self.stream.seek(0, 2) #due to non-posix-compliant Windows feature
ifself.stream.tell() +len(msg) >=self.maxBytes:
return1
return0

classTimedRotatingFileHandler(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.
ifself.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+)?$"
elifself.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+)?$"
elifself.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+)?$"
elifself.when=='D'orself.when=='MIDNIGHT':
self.interval=60*60*24# one day
self.suffix="%Y-%m-%d"
self.extMatch=r"^\d{4}-\d{2}-\d{2}(\.\w+)?$"
elifself.when.startswith('W'):
self.interval=60*60*24*7# one week
iflen(self.when) !=2:
raiseValueError("You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s"%self.when)
ifself.when[1] <'0'orself.when[1] >'6':
raiseValueError("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:
raiseValueError("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
ifos.path.exists(filename):
t=os.stat(filename)[ST_MTIME]
else:
t=int(time.time())
self.rolloverAt=self.computeRollover(t)

defcomputeRollover(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. :)
ifself.when=='MIDNIGHT'orself.when.startswith('W'):
# This could be done with less code, but I wanted it to be clear
ifself.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
ifself.atTimeisNone:
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)
ifr<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.
ifself.when.startswith('W'):
day=currentDay# 0 is Monday
ifday!=self.dayOfWeek:
ifday<self.dayOfWeek:
daysToWait=self.dayOfWeek-day
else:
daysToWait=6-day+self.dayOfWeek+1
newRolloverAt=result+ (daysToWait* (60*60*24))
ifnotself.utc:
dstNow=t[-1]
dstAtRollover=time.localtime(newRolloverAt)[-1]
ifdstNow!=dstAtRollover:
ifnotdstNow: # 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
returnresult

defshouldRollover(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())
ift>=self.rolloverAt:
return1
return0

defgetFilesToDelete(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)
forfileNameinfileNames:
iffileName[:plen] ==prefix:
suffix=fileName[plen:]
ifself.extMatch.match(suffix):
result.append(os.path.join(dirName, fileName))
iflen(result) <self.backupCount:
result= []
else:
result.sort()
result=result[:len(result) -self.backupCount]
returnresult

defdoRollover(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.
 """
ifself.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
ifself.utc:
timeTuple=time.gmtime(t)
else:
timeTuple=time.localtime(t)
dstThen=timeTuple[-1]
ifdstNow!=dstThen:
ifdstNow:
addend=3600
else:
addend=-3600
timeTuple=time.localtime(t+addend)
dfn=self.rotation_filename(self.baseFilename+"."+
time.strftime(self.suffix, timeTuple))
ifos.path.exists(dfn):
os.remove(dfn)
self.rotate(self.baseFilename, dfn)
ifself.backupCount>0:
forsinself.getFilesToDelete():
os.remove(s)
ifnotself.delay:
self.stream=self._open()
newRolloverAt=self.computeRollover(currentTime)
whilenewRolloverAt<=currentTime:
newRolloverAt=newRolloverAt+self.interval
#If DST changes and midnight or weekly rollover, adjust for this.
if (self.when=='MIDNIGHT'orself.when.startswith('W')) andnotself.utc:
dstAtRollover=time.localtime(newRolloverAt)[-1]
ifdstNow!=dstAtRollover:
ifnotdstNow: # 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

classWatchedFileHandler(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):
ifself.stream:
sres=os.fstat(self.stream.fileno())
self.dev, self.ino=sres[ST_DEV], sres[ST_INO]

defreopenIfNeeded(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)
exceptFileNotFoundError:
sres=None
# compare file system stat with that of our stream file handle
ifnotsresorsres[ST_DEV] !=self.devorsres[ST_INO] !=self.ino:
ifself.streamisnotNone:
# 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()

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


classSocketHandler(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
ifportisNone:
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

defmakeSocket(self, timeout=1):
"""
 A factory method which allows subclasses to define the precise
 type of socket they want.
 """
ifself.portisnotNone:
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)
exceptOSError:
result.close() # Issue 19182
raise
returnresult

defcreateSocket(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.
ifself.retryTimeisNone:
attempt=True
else:
attempt= (now>=self.retryTime)
ifattempt:
try:
self.sock=self.makeSocket()
self.retryTime=None# next time, no delay before trying
exceptOSError:
#Creation failed, so set the retry time and return.
ifself.retryTimeisNone:
self.retryPeriod=self.retryStart
else:
self.retryPeriod=self.retryPeriod*self.retryFactor
ifself.retryPeriod>self.retryMax:
self.retryPeriod=self.retryMax
self.retryTime=now+self.retryPeriod

defsend(self, s):
"""
 Send a pickled string to the socket.

 This function allows for partial sends which can happen when the
 network is busy.
 """
ifself.sockisNone:
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.
ifself.sock:
try:
self.sock.sendall(s)
exceptOSError: #pragma: no cover
self.sock.close()
self.sock=None# so we can call createSocket next time

defmakePickle(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
ifei:
# 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))
returnslen+s

defhandleError(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.
 """
ifself.closeOnErrorandself.sock:
self.sock.close()
self.sock=None#try to reconnect next time
else:
logging.Handler.handleError(self, record)

defemit(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)
exceptException:
self.handleError(record)

defclose(self):
"""
 Closes the socket.
 """
self.acquire()
try:
sock=self.sock
ifsock:
self.sock=None
sock.close()
logging.Handler.close(self)
finally:
self.release()

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

defmakeSocket(self):
"""
 The factory method of SocketHandler is here overridden to create
 a UDP socket (SOCK_DGRAM).
 """
ifself.portisNone:
family=socket.AF_UNIX
else:
family=socket.AF_INET
s=socket.socket(family, socket.SOCK_DGRAM)
returns

defsend(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.
 """
ifself.sockisNone:
self.createSocket()
self.sock.sendto(s, self.address)

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

ifisinstance(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)
exceptOSError:
pass
else:
self.unixsocket=False
ifsocktypeisNone:
socktype=socket.SOCK_DGRAM
host, port=address
ress=socket.getaddrinfo(host, port, 0, socktype)
ifnotress:
raiseOSError("getaddrinfo returns an empty list")
forresinress:
af, socktype, proto, _, sa=res
err=sock=None
try:
sock=socket.socket(af, socktype, proto)
ifsocktype==socket.SOCK_STREAM:
sock.connect(sa)
break
exceptOSErrorasexc:
err=exc
ifsockisnotNone:
sock.close()
iferrisnotNone:
raiseerr
self.socket=sock
self.socktype=socktype

def_connect_unixsocket(self, address):
use_socktype=self.socktype
ifuse_socktypeisNone:
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
exceptOSError:
self.socket.close()
ifself.socktypeisnotNone:
# 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
exceptOSError:
self.socket.close()
raise

defencodePriority(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.
 """
ifisinstance(facility, str):
facility=self.facility_names[facility]
ifisinstance(priority, str):
priority=self.priority_names[priority]
return (facility<<3) |priority

defclose(self):
"""
 Closes the socket.
 """
self.acquire()
try:
self.socket.close()
logging.Handler.close(self)
finally:
self.release()

defmapPriority(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).
 """
returnself.priority_map.get(levelName, "warning")

ident=''# prepended to all messages
append_nul=True# some old syslog daemons expect a NUL terminator

defemit(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)
ifself.ident:
msg=self.ident+msg
ifself.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
ifself.unixsocket:
try:
self.socket.send(msg)
exceptOSError:
self.socket.close()
self._connect_unixsocket(self.address)
self.socket.send(msg)
elifself.socktype==socket.SOCK_DGRAM:
self.socket.sendto(msg, self.address)
else:
self.socket.sendall(msg)
exceptException:
self.handleError(record)

classSMTPHandler(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)
ifisinstance(mailhost, (list, tuple)):
self.mailhost, self.mailport=mailhost
else:
self.mailhost, self.mailport=mailhost, None
ifisinstance(credentials, (list, tuple)):
self.username, self.password=credentials
else:
self.username=None
self.fromaddr=fromaddr
ifisinstance(toaddrs, str):
toaddrs= [toaddrs]
self.toaddrs=toaddrs
self.subject=subject
self.secure=secure
self.timeout=timeout

defgetSubject(self, record):
"""
 Determine the subject for the email.

 If you want to specify a subject line which is record-dependent,
 override this method.
 """
returnself.subject

defemit(self, record):
"""
 Emit a record.

 Format the record and send it to the specified addressees.
 """
try: