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

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

"""

import io, logging, socket, os, pickle, struct, time, re

from stat import ST_DEV, ST_INO, ST_MTIME

import queue

import threading

import copy

#

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

"""

namer = None

rotator = None

def __init__(self, filename, mode, encoding=None, delay=False, errors=None):

"""

Use the specified filename for streamed logging

"""

logging.FileHandler.__init__(self, filename, mode=mode,

encoding=encoding, delay=delay,

errors=errors)

self.mode = mode

self.encoding = encoding

self.errors = errors

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, errors=None):

"""

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'

if "b" not in mode:

encoding = io.text_encoding(encoding)

BaseRotatingHandler.__init__(self, filename, mode, encoding=encoding,

delay=delay, errors=errors)

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?

pos = self.stream.tell()

if not pos:

# gh-116263: Never rollover an empty file

return False

msg = "%s\n" % self.format(record)

if pos + len(msg) >= self.maxBytes:

# See bpo-45401: Never rollover anything other than regular files

if os.path.exists(self.baseFilename) and not os.path.isfile(self.baseFilename):

return False

return True

return False

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,

errors=None):

encoding = io.text_encoding(encoding)

BaseRotatingHandler.__init__(self, filename, 'a', encoding=encoding,

delay=delay, errors=errors)

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"

extMatch = r"(?<!\d)\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}(?!\d)"

elif self.when == 'M':

self.interval = 60 # one minute

self.suffix = "%Y-%m-%d_%H-%M"

extMatch = r"(?<!\d)\d{4}-\d{2}-\d{2}_\d{2}-\d{2}(?!\d)"

elif self.when == 'H':

self.interval = 60 * 60 # one hour

self.suffix = "%Y-%m-%d_%H"

extMatch = r"(?<!\d)\d{4}-\d{2}-\d{2}_\d{2}(?!\d)"

elif self.when == 'D' or self.when == 'MIDNIGHT':

self.interval = 60 * 60 * 24 # one day

self.suffix = "%Y-%m-%d"

extMatch = r"(?<!\d)\d{4}-\d{2}-\d{2}(?!\d)"

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"

extMatch = r"(?<!\d)\d{4}-\d{2}-\d{2}(?!\d)"

else:

raise ValueError("Invalid rollover interval specified: %s" % self.when)

# extMatch is a pattern for matching a datetime suffix in a file name.

# After custom naming, it is no longer guaranteed to be separated by

# periods from other parts of the filename. The lookup statements

# (?<!\d) and (?!\d) ensure that the datetime suffix (which itself

# starts and ends with digits) is not preceded or followed by digits.

# This reduces the number of false matches and improves performance.

self.extMatch = re.compile(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

result += daysToWait * _MIDNIGHT

result += self.interval - _MIDNIGHT * 7

else:

result += self.interval - _MIDNIGHT

if not self.utc:

dstNow = t[-1]

dstAtRollover = time.localtime(result)[-1]

if dstNow != dstAtRollover:

if not dstNow: # DST kicks in before next rollover, so we need to deduct an hour

addend = -3600

if not time.localtime(result-3600)[-1]:

addend = 0

else: # DST bows out before next rollover, so we need to add an hour

addend = 3600

result += addend

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:

# See #89564: Never rollover anything other than regular files

if os.path.exists(self.baseFilename) and not os.path.isfile(self.baseFilename):

# The file is not a regular file, so do not rollover, but do

# set the next rollover time to avoid repeated checks.

self.rolloverAt = self.computeRollover(t)

return False

return True

return False

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 = []

if self.namer is None:

prefix = baseName + '.'

plen = len(prefix)

for fileName in fileNames:

if fileName[:plen] == prefix:

suffix = fileName[plen:]

if self.extMatch.fullmatch(suffix):

result.append(os.path.join(dirName, fileName))

else:

for fileName in fileNames:

# Our files could be just about anything after custom naming,

# but they should contain the datetime suffix.

# Try to find the datetime suffix in the file name and verify

# that the file name can be generated by this handler.

m = self.extMatch.search(fileName)

while m:

dfn = self.namer(self.baseFilename + "." + m[0])

if os.path.basename(dfn) == fileName:

result.append(os.path.join(dirName, fileName))

break

m = self.extMatch.search(fileName, m.start() + 1)

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.

"""

# get the time that this sequence started at and make it a TimeTuple

currentTime = int(time.time())

t = self.rolloverAt - self.interval

if self.utc:

timeTuple = time.gmtime(t)

else:

timeTuple = time.localtime(t)

dstNow = time.localtime(currentTime)[-1]

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

# Already rolled over.

return

if self.stream:

self.stream.close()

self.stream = None

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

self.rolloverAt = self.computeRollover(currentTime)

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,

errors=None):

if "b" not in mode:

encoding = io.text_encoding(encoding)

logging.FileHandler.__init__(self, filename, mode=mode,

encoding=encoding, delay=delay,

errors=errors)

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

LOG_NTP = 12 # NTP subsystem

LOG_SECURITY = 13 # Log audit

LOG_CONSOLE = 14 # Log alert

LOG_SOLCRON = 15 # Scheduling daemon (Solaris)

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

"console": LOG_CONSOLE,

"cron": LOG_CRON,

"daemon": LOG_DAEMON,

"ftp": LOG_FTP,

"kern": LOG_KERN,

"lpr": LOG_LPR,

"mail": LOG_MAIL,

"news": LOG_NEWS,

"ntp": LOG_NTP,

"security": LOG_SECURITY,

"solaris-cron": LOG_SOLCRON,

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

}

# Originally added to work around GH-43683. Unnecessary since GH-50043 but kept

# for backwards compatibility.

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

self.socket = None

self.createSocket()

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 createSocket(self):

"""

Try to create a socket and, if it's not a datagram socket, connect it

to the other end. This method is called during handler initialization,

but it's not regarded as an error if the other end isn't listening yet

--- the method will be called again when emitting an event,

if there is no socket at that point.

"""

address = self.address

socktype = self.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's 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 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:

sock = self.socket

if sock:

self.socket = None

sock.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 not self.socket:

self.createSocket()