Adding Vinay Sajip's logging package.
This commit is contained in:
parent
2c184e7eea
commit
57102f861d
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,300 @@
|
||||||
|
#! /usr/bin/env python
|
||||||
|
#
|
||||||
|
# Copyright 2001-2002 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.
|
||||||
|
#
|
||||||
|
# For the change history, see README.txt in the distribution.
|
||||||
|
#
|
||||||
|
# This file is part of the Python logging distribution. See
|
||||||
|
# http://www.red-dove.com/python_logging.html
|
||||||
|
#
|
||||||
|
|
||||||
|
"""
|
||||||
|
Logging package for Python. Based on PEP 282 and comments thereto in
|
||||||
|
comp.lang.python, and influenced by Apache's log4j system.
|
||||||
|
|
||||||
|
Should work under Python versions >= 1.5.2, except that source line
|
||||||
|
information is not available unless 'inspect' is.
|
||||||
|
|
||||||
|
Copyright (C) 2001-2002 Vinay Sajip. All Rights Reserved.
|
||||||
|
|
||||||
|
To use, simply 'import logging' and log away!
|
||||||
|
"""
|
||||||
|
|
||||||
|
import sys, logging, logging.handlers, string, thread, threading, socket, struct, os
|
||||||
|
|
||||||
|
from SocketServer import ThreadingTCPServer, StreamRequestHandler
|
||||||
|
|
||||||
|
|
||||||
|
DEFAULT_LOGGING_CONFIG_PORT = 9030
|
||||||
|
|
||||||
|
#
|
||||||
|
# The following code implements a socket listener for on-the-fly
|
||||||
|
# reconfiguration of logging.
|
||||||
|
#
|
||||||
|
# _listener holds the server object doing the listening
|
||||||
|
_listener = None
|
||||||
|
|
||||||
|
def fileConfig(fname):
|
||||||
|
"""
|
||||||
|
Read the logging configuration from a ConfigParser-format file.
|
||||||
|
|
||||||
|
This can be called several times from an application, allowing an end user
|
||||||
|
the ability to select from various pre-canned configurations (if the
|
||||||
|
developer provides a mechanism to present the choices and load the chosen
|
||||||
|
configuration).
|
||||||
|
In versions of ConfigParser which have the readfp method [typically
|
||||||
|
shipped in 2.x versions of Python], you can pass in a file-like object
|
||||||
|
rather than a filename, in which case the file-like object will be read
|
||||||
|
using readfp.
|
||||||
|
"""
|
||||||
|
import ConfigParser
|
||||||
|
|
||||||
|
cp = ConfigParser.ConfigParser()
|
||||||
|
if hasattr(cp, 'readfp') and hasattr(fname, 'readline'):
|
||||||
|
cp.readfp(fname)
|
||||||
|
else:
|
||||||
|
cp.read(fname)
|
||||||
|
#first, do the formatters...
|
||||||
|
flist = cp.get("formatters", "keys")
|
||||||
|
if len(flist):
|
||||||
|
flist = string.split(flist, ",")
|
||||||
|
formatters = {}
|
||||||
|
for form in flist:
|
||||||
|
sectname = "formatter_%s" % form
|
||||||
|
opts = cp.options(sectname)
|
||||||
|
if "format" in opts:
|
||||||
|
fs = cp.get(sectname, "format", 1)
|
||||||
|
else:
|
||||||
|
fs = None
|
||||||
|
if "datefmt" in opts:
|
||||||
|
dfs = cp.get(sectname, "datefmt", 1)
|
||||||
|
else:
|
||||||
|
dfs = None
|
||||||
|
f = logging.Formatter(fs, dfs)
|
||||||
|
formatters[form] = f
|
||||||
|
#next, do the handlers...
|
||||||
|
#critical section...
|
||||||
|
logging._acquireLock()
|
||||||
|
try:
|
||||||
|
try:
|
||||||
|
#first, lose the existing handlers...
|
||||||
|
logging._handlers.clear()
|
||||||
|
#now set up the new ones...
|
||||||
|
hlist = cp.get("handlers", "keys")
|
||||||
|
if len(hlist):
|
||||||
|
hlist = string.split(hlist, ",")
|
||||||
|
handlers = {}
|
||||||
|
fixups = [] #for inter-handler references
|
||||||
|
for hand in hlist:
|
||||||
|
sectname = "handler_%s" % hand
|
||||||
|
klass = cp.get(sectname, "class")
|
||||||
|
opts = cp.options(sectname)
|
||||||
|
if "formatter" in opts:
|
||||||
|
fmt = cp.get(sectname, "formatter")
|
||||||
|
else:
|
||||||
|
fmt = ""
|
||||||
|
klass = eval(klass, vars(logging))
|
||||||
|
args = cp.get(sectname, "args")
|
||||||
|
args = eval(args, vars(logging))
|
||||||
|
h = apply(klass, args)
|
||||||
|
if "level" in opts:
|
||||||
|
level = cp.get(sectname, "level")
|
||||||
|
h.setLevel(logging._levelNames[level])
|
||||||
|
if len(fmt):
|
||||||
|
h.setFormatter(formatters[fmt])
|
||||||
|
#temporary hack for FileHandler and MemoryHandler.
|
||||||
|
if klass == logging.handlers.MemoryHandler:
|
||||||
|
if "target" in opts:
|
||||||
|
target = cp.get(sectname,"target")
|
||||||
|
else:
|
||||||
|
target = ""
|
||||||
|
if len(target): #the target handler may not be loaded yet, so keep for later...
|
||||||
|
fixups.append((h, target))
|
||||||
|
handlers[hand] = h
|
||||||
|
#now all handlers are loaded, fixup inter-handler references...
|
||||||
|
for fixup in fixups:
|
||||||
|
h = fixup[0]
|
||||||
|
t = fixup[1]
|
||||||
|
h.setTarget(handlers[t])
|
||||||
|
#at last, the loggers...first the root...
|
||||||
|
llist = cp.get("loggers", "keys")
|
||||||
|
llist = string.split(llist, ",")
|
||||||
|
llist.remove("root")
|
||||||
|
sectname = "logger_root"
|
||||||
|
root = logging.root
|
||||||
|
log = root
|
||||||
|
opts = cp.options(sectname)
|
||||||
|
if "level" in opts:
|
||||||
|
level = cp.get(sectname, "level")
|
||||||
|
log.setLevel(logging._levelNames[level])
|
||||||
|
for h in root.handlers:
|
||||||
|
root.removeHandler(h)
|
||||||
|
hlist = cp.get(sectname, "handlers")
|
||||||
|
if len(hlist):
|
||||||
|
hlist = string.split(hlist, ",")
|
||||||
|
for hand in hlist:
|
||||||
|
log.addHandler(handlers[hand])
|
||||||
|
#and now the others...
|
||||||
|
#we don't want to lose the existing loggers,
|
||||||
|
#since other threads may have pointers to them.
|
||||||
|
#existing is set to contain all existing loggers,
|
||||||
|
#and as we go through the new configuration we
|
||||||
|
#remove any which are configured. At the end,
|
||||||
|
#what's left in existing is the set of loggers
|
||||||
|
#which were in the previous configuration but
|
||||||
|
#which are not in the new configuration.
|
||||||
|
existing = root.manager.loggerDict.keys()
|
||||||
|
#now set up the new ones...
|
||||||
|
for log in llist:
|
||||||
|
sectname = "logger_%s" % log
|
||||||
|
qn = cp.get(sectname, "qualname")
|
||||||
|
opts = cp.options(sectname)
|
||||||
|
if "propagate" in opts:
|
||||||
|
propagate = cp.getint(sectname, "propagate")
|
||||||
|
else:
|
||||||
|
propagate = 1
|
||||||
|
logger = logging.getLogger(qn)
|
||||||
|
if qn in existing:
|
||||||
|
existing.remove(qn)
|
||||||
|
if "level" in opts:
|
||||||
|
level = cp.get(sectname, "level")
|
||||||
|
logger.setLevel(logging._levelNames[level])
|
||||||
|
for h in logger.handlers:
|
||||||
|
logger.removeHandler(h)
|
||||||
|
logger.propagate = propagate
|
||||||
|
logger.disabled = 0
|
||||||
|
hlist = cp.get(sectname, "handlers")
|
||||||
|
if len(hlist):
|
||||||
|
hlist = string.split(hlist, ",")
|
||||||
|
for hand in hlist:
|
||||||
|
logger.addHandler(handlers[hand])
|
||||||
|
#Disable any old loggers. There's no point deleting
|
||||||
|
#them as other threads may continue to hold references
|
||||||
|
#and by disabling them, you stop them doing any logging.
|
||||||
|
for log in existing:
|
||||||
|
root.manager.loggerDict[log].disabled = 1
|
||||||
|
except:
|
||||||
|
import traceback
|
||||||
|
ei = sys.exc_info()
|
||||||
|
traceback.print_exception(ei[0], ei[1], ei[2], None, sys.stderr)
|
||||||
|
del ei
|
||||||
|
finally:
|
||||||
|
logging._releaseLock()
|
||||||
|
|
||||||
|
def listen(port=DEFAULT_LOGGING_CONFIG_PORT):
|
||||||
|
"""
|
||||||
|
Start up a socket server on the specified port, and listen for new
|
||||||
|
configurations.
|
||||||
|
|
||||||
|
These will be sent as a file suitable for processing by fileConfig().
|
||||||
|
Returns a Thread object on which you can call start() to start the server,
|
||||||
|
and which you can join() when appropriate. To stop the server, call
|
||||||
|
stopListening().
|
||||||
|
"""
|
||||||
|
if not thread:
|
||||||
|
raise NotImplementedError, "listen() needs threading to work"
|
||||||
|
|
||||||
|
class ConfigStreamHandler(StreamRequestHandler):
|
||||||
|
"""
|
||||||
|
Handler for a logging configuration request.
|
||||||
|
|
||||||
|
It expects a completely new logging configuration and uses fileConfig
|
||||||
|
to install it.
|
||||||
|
"""
|
||||||
|
def handle(self):
|
||||||
|
"""
|
||||||
|
Handle a request.
|
||||||
|
|
||||||
|
Each request is expected to be a 4-byte length,
|
||||||
|
followed by the config file. Uses fileConfig() to do the
|
||||||
|
grunt work.
|
||||||
|
"""
|
||||||
|
import tempfile
|
||||||
|
try:
|
||||||
|
conn = self.connection
|
||||||
|
chunk = conn.recv(4)
|
||||||
|
if len(chunk) == 4:
|
||||||
|
slen = struct.unpack(">L", chunk)[0]
|
||||||
|
chunk = self.connection.recv(slen)
|
||||||
|
while len(chunk) < slen:
|
||||||
|
chunk = chunk + conn.recv(slen - len(chunk))
|
||||||
|
#Apply new configuration. We'd like to be able to
|
||||||
|
#create a StringIO and pass that in, but unfortunately
|
||||||
|
#1.5.2 ConfigParser does not support reading file
|
||||||
|
#objects, only actual files. So we create a temporary
|
||||||
|
#file and remove it later.
|
||||||
|
file = tempfile.mktemp(".ini")
|
||||||
|
f = open(file, "w")
|
||||||
|
f.write(chunk)
|
||||||
|
f.close()
|
||||||
|
fileConfig(file)
|
||||||
|
os.remove(file)
|
||||||
|
except socket.error, e:
|
||||||
|
if type(e.args) != types.TupleType:
|
||||||
|
raise
|
||||||
|
else:
|
||||||
|
errcode = e.args[0]
|
||||||
|
if errcode != RESET_ERROR:
|
||||||
|
raise
|
||||||
|
|
||||||
|
class ConfigSocketReceiver(ThreadingTCPServer):
|
||||||
|
"""
|
||||||
|
A simple TCP socket-based logging config receiver.
|
||||||
|
"""
|
||||||
|
|
||||||
|
allow_reuse_address = 1
|
||||||
|
|
||||||
|
def __init__(self, host='localhost', port=DEFAULT_LOGGING_CONFIG_PORT,
|
||||||
|
handler=None):
|
||||||
|
ThreadingTCPServer.__init__(self, (host, port), handler)
|
||||||
|
logging._acquireLock()
|
||||||
|
self.abort = 0
|
||||||
|
logging._releaseLock()
|
||||||
|
self.timeout = 1
|
||||||
|
|
||||||
|
def serve_until_stopped(self):
|
||||||
|
import select
|
||||||
|
abort = 0
|
||||||
|
while not abort:
|
||||||
|
rd, wr, ex = select.select([self.socket.fileno()],
|
||||||
|
[], [],
|
||||||
|
self.timeout)
|
||||||
|
if rd:
|
||||||
|
self.handle_request()
|
||||||
|
logging._acquireLock()
|
||||||
|
abort = self.abort
|
||||||
|
logging._releaseLock()
|
||||||
|
|
||||||
|
def serve(rcvr, hdlr):
|
||||||
|
server = rcvr(handler=hdlr)
|
||||||
|
global _listener
|
||||||
|
logging._acquireLock()
|
||||||
|
_listener = server
|
||||||
|
logging._releaseLock()
|
||||||
|
server.serve_until_stopped()
|
||||||
|
|
||||||
|
return threading.Thread(target=serve, args=(ConfigSocketReceiver, ConfigStreamHandler))
|
||||||
|
|
||||||
|
def stopListening():
|
||||||
|
"""
|
||||||
|
Stop the listening server which was created with a call to listen().
|
||||||
|
"""
|
||||||
|
if _listener:
|
||||||
|
logging._acquireLock()
|
||||||
|
_listener.abort = 1
|
||||||
|
_listener = None
|
||||||
|
logging._releaseLock()
|
|
@ -0,0 +1,707 @@
|
||||||
|
#! /usr/bin/env python
|
||||||
|
#
|
||||||
|
# Copyright 2001-2002 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.
|
||||||
|
#
|
||||||
|
# For the change history, see README.txt in the distribution.
|
||||||
|
#
|
||||||
|
# This file is part of the Python logging distribution. See
|
||||||
|
# http://www.red-dove.com/python_logging.html
|
||||||
|
#
|
||||||
|
|
||||||
|
"""
|
||||||
|
Logging package for Python. Based on PEP 282 and comments thereto in
|
||||||
|
comp.lang.python, and influenced by Apache's log4j system.
|
||||||
|
|
||||||
|
Should work under Python versions >= 1.5.2, except that source line
|
||||||
|
information is not available unless 'inspect' is.
|
||||||
|
|
||||||
|
Copyright (C) 2001-2002 Vinay Sajip. All Rights Reserved.
|
||||||
|
|
||||||
|
To use, simply 'import logging' and log away!
|
||||||
|
"""
|
||||||
|
|
||||||
|
import sys, logging, socket, types, os, string, cPickle, struct
|
||||||
|
|
||||||
|
from SocketServer import ThreadingTCPServer, StreamRequestHandler
|
||||||
|
|
||||||
|
#
|
||||||
|
# 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
|
||||||
|
|
||||||
|
|
||||||
|
class RotatingFileHandler(logging.FileHandler):
|
||||||
|
def __init__(self, filename, mode="a", maxBytes=0, backupCount=0):
|
||||||
|
"""
|
||||||
|
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.
|
||||||
|
"""
|
||||||
|
logging.FileHandler.__init__(self, filename, mode)
|
||||||
|
self.maxBytes = maxBytes
|
||||||
|
self.backupCount = backupCount
|
||||||
|
if maxBytes > 0:
|
||||||
|
self.mode = "a"
|
||||||
|
|
||||||
|
def doRollover(self):
|
||||||
|
"""
|
||||||
|
Do a rollover, as described in __init__().
|
||||||
|
"""
|
||||||
|
|
||||||
|
self.stream.close()
|
||||||
|
if self.backupCount > 0:
|
||||||
|
for i in range(self.backupCount - 1, 0, -1):
|
||||||
|
sfn = "%s.%d" % (self.baseFilename, i)
|
||||||
|
dfn = "%s.%d" % (self.baseFilename, i + 1)
|
||||||
|
if os.path.exists(sfn):
|
||||||
|
#print "%s -> %s" % (sfn, dfn)
|
||||||
|
if os.path.exists(dfn):
|
||||||
|
os.remove(dfn)
|
||||||
|
os.rename(sfn, dfn)
|
||||||
|
dfn = self.baseFilename + ".1"
|
||||||
|
if os.path.exists(dfn):
|
||||||
|
os.remove(dfn)
|
||||||
|
os.rename(self.baseFilename, dfn)
|
||||||
|
#print "%s -> %s" % (self.baseFilename, dfn)
|
||||||
|
self.stream = open(self.baseFilename, "w")
|
||||||
|
|
||||||
|
def emit(self, record):
|
||||||
|
"""
|
||||||
|
Emit a record.
|
||||||
|
|
||||||
|
Output the record to the file, catering for rollover as described
|
||||||
|
in setRollover().
|
||||||
|
"""
|
||||||
|
if self.maxBytes > 0: # are we rolling over?
|
||||||
|
msg = "%s\n" % self.format(record)
|
||||||
|
#print msg
|
||||||
|
if self.stream.tell() + len(msg) >= self.maxBytes:
|
||||||
|
self.doRollover()
|
||||||
|
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.
|
||||||
|
Note that the very simple wire protocol used means that packet sizes
|
||||||
|
are expected to be encodable within 16 bits (i.e. < 32767 bytes).
|
||||||
|
"""
|
||||||
|
|
||||||
|
def __init__(self, host, port):
|
||||||
|
"""
|
||||||
|
Initializes the handler with a specific host address and port.
|
||||||
|
|
||||||
|
The attribute 'closeOnError' is set to 1 - which means that 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
|
||||||
|
self.sock = None
|
||||||
|
self.closeOnError = 0
|
||||||
|
|
||||||
|
def makeSocket(self):
|
||||||
|
"""
|
||||||
|
A factory method which allows subclasses to define the precise
|
||||||
|
type of socket they want.
|
||||||
|
"""
|
||||||
|
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||||
|
s.connect((self.host, self.port))
|
||||||
|
return s
|
||||||
|
|
||||||
|
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.
|
||||||
|
"""
|
||||||
|
v = sys.version_info
|
||||||
|
if v[0] >= 2 and v[1] >= 2:
|
||||||
|
self.sock.sendall(s)
|
||||||
|
else:
|
||||||
|
sentsofar = 0
|
||||||
|
left = len(s)
|
||||||
|
while left > 0:
|
||||||
|
sent = self.sock.send(s[sentsofar:])
|
||||||
|
sentsofar = sentsofar + sent
|
||||||
|
left = left - sent
|
||||||
|
|
||||||
|
def makePickle(self, record):
|
||||||
|
"""
|
||||||
|
Pickles the record in binary format with a length prefix, and
|
||||||
|
returns it ready for transmission across the socket.
|
||||||
|
"""
|
||||||
|
s = cPickle.dumps(record.__dict__, 1)
|
||||||
|
#n = len(s)
|
||||||
|
#slen = "%c%c" % ((n >> 8) & 0xFF, n & 0xFF)
|
||||||
|
slen = struct.pack(">L", len(s))
|
||||||
|
return slen + s
|
||||||
|
|
||||||
|
def handleError(self):
|
||||||
|
"""
|
||||||
|
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)
|
||||||
|
|
||||||
|
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)
|
||||||
|
if not self.sock:
|
||||||
|
self.sock = self.makeSocket()
|
||||||
|
self.send(s)
|
||||||
|
except:
|
||||||
|
self.handleError()
|
||||||
|
|
||||||
|
def close(self):
|
||||||
|
"""
|
||||||
|
Closes the socket.
|
||||||
|
"""
|
||||||
|
if self.sock:
|
||||||
|
self.sock.close()
|
||||||
|
self.sock = None
|
||||||
|
|
||||||
|
class DatagramHandler(SocketHandler):
|
||||||
|
"""
|
||||||
|
A handler class which writes logging records, in pickle format, to
|
||||||
|
a datagram socket. Note that the very simple wire protocol used means
|
||||||
|
that packet sizes are expected to be encodable within 16 bits
|
||||||
|
(i.e. < 32767 bytes).
|
||||||
|
|
||||||
|
"""
|
||||||
|
def __init__(self, host, port):
|
||||||
|
"""
|
||||||
|
Initializes the handler with a specific host address and port.
|
||||||
|
"""
|
||||||
|
SocketHandler.__init__(self, host, port)
|
||||||
|
self.closeOnError = 0
|
||||||
|
|
||||||
|
def makeSocket(self):
|
||||||
|
"""
|
||||||
|
The factory method of SocketHandler is here overridden to create
|
||||||
|
a UDP socket (SOCK_DGRAM).
|
||||||
|
"""
|
||||||
|
s = socket.socket(socket.AF_INET, 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.
|
||||||
|
"""
|
||||||
|
#old code
|
||||||
|
#sentsofar = 0
|
||||||
|
#left = len(s)
|
||||||
|
#addr = (self.host, self.port)
|
||||||
|
#while left > 0:
|
||||||
|
# sent = self.sock.sendto(s[sentsofar:], addr)
|
||||||
|
# sentsofar = sentsofar + sent
|
||||||
|
# left = left - sent
|
||||||
|
self.sock.sendto(s, (self.host, self.port))
|
||||||
|
|
||||||
|
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)
|
||||||
|
|
||||||
|
# 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,
|
||||||
|
"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,
|
||||||
|
}
|
||||||
|
|
||||||
|
def __init__(self, address=('localhost', SYSLOG_UDP_PORT), facility=LOG_USER):
|
||||||
|
"""
|
||||||
|
Initialize a handler.
|
||||||
|
|
||||||
|
If address is specified as a string, UNIX socket is used.
|
||||||
|
If facility is not specified, LOG_USER is used.
|
||||||
|
"""
|
||||||
|
logging.Handler.__init__(self)
|
||||||
|
|
||||||
|
self.address = address
|
||||||
|
self.facility = facility
|
||||||
|
if type(address) == types.StringType:
|
||||||
|
self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
|
||||||
|
self.socket.connect(address)
|
||||||
|
self.unixsocket = 1
|
||||||
|
else:
|
||||||
|
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||||||
|
self.unixsocket = 0
|
||||||
|
|
||||||
|
self.formatter = None
|
||||||
|
|
||||||
|
# curious: when talking to the unix-domain '/dev/log' socket, a
|
||||||
|
# zero-terminator seems to be required. this string is placed
|
||||||
|
# into a class variable so that it can be overridden if
|
||||||
|
# necessary.
|
||||||
|
log_format_string = '<%d>%s\000'
|
||||||
|
|
||||||
|
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 type(facility) == types.StringType:
|
||||||
|
facility = self.facility_names[facility]
|
||||||
|
if type(priority) == types.StringType:
|
||||||
|
priority = self.priority_names[priority]
|
||||||
|
return (facility << 3) | priority
|
||||||
|
|
||||||
|
def close (self):
|
||||||
|
"""
|
||||||
|
Closes the socket.
|
||||||
|
"""
|
||||||
|
if self.unixsocket:
|
||||||
|
self.socket.close()
|
||||||
|
|
||||||
|
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.
|
||||||
|
"""
|
||||||
|
msg = self.format(record)
|
||||||
|
"""
|
||||||
|
We need to convert record level to lowercase, maybe this will
|
||||||
|
change in the future.
|
||||||
|
"""
|
||||||
|
msg = self.log_format_string % (
|
||||||
|
self.encodePriority(self.facility,
|
||||||
|
string.lower(record.levelname)),
|
||||||
|
msg)
|
||||||
|
try:
|
||||||
|
if self.unixsocket:
|
||||||
|
self.socket.send(msg)
|
||||||
|
else:
|
||||||
|
self.socket.sendto(msg, self.address)
|
||||||
|
except:
|
||||||
|
self.handleError()
|
||||||
|
|
||||||
|
class SMTPHandler(logging.Handler):
|
||||||
|
"""
|
||||||
|
A handler class which sends an SMTP email for each logging event.
|
||||||
|
"""
|
||||||
|
def __init__(self, mailhost, fromaddr, toaddrs, subject):
|
||||||
|
"""
|
||||||
|
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.
|
||||||
|
"""
|
||||||
|
logging.Handler.__init__(self)
|
||||||
|
if type(mailhost) == types.TupleType:
|
||||||
|
host, port = mailhost
|
||||||
|
self.mailhost = host
|
||||||
|
self.mailport = port
|
||||||
|
else:
|
||||||
|
self.mailhost = mailhost
|
||||||
|
self.mailport = None
|
||||||
|
self.fromaddr = fromaddr
|
||||||
|
self.toaddrs = toaddrs
|
||||||
|
self.subject = subject
|
||||||
|
|
||||||
|
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
|
||||||
|
port = self.mailport
|
||||||
|
if not port:
|
||||||
|
port = smtplib.SMTP_PORT
|
||||||
|
smtp = smtplib.SMTP(self.mailhost, port)
|
||||||
|
msg = self.format(record)
|
||||||
|
msg = "From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n%s" % (
|
||||||
|
self.fromaddr,
|
||||||
|
string.join(self.toaddrs, ","),
|
||||||
|
self.getSubject(record), msg
|
||||||
|
)
|
||||||
|
smtp.sendmail(self.fromaddr, self.toaddrs, msg)
|
||||||
|
smtp.quit()
|
||||||
|
except:
|
||||||
|
self.handleError()
|
||||||
|
|
||||||
|
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.WARN : 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,
|
||||||
|
WARN, 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:
|
||||||
|
self.handleError()
|
||||||
|
|
||||||
|
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)
|
||||||
|
pass
|
||||||
|
|
||||||
|
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"):
|
||||||
|
"""
|
||||||
|
Initialize the instance with the host, the request URL, and the method
|
||||||
|
("GET" or "POST")
|
||||||
|
"""
|
||||||
|
logging.Handler.__init__(self)
|
||||||
|
method = string.upper(method)
|
||||||
|
if method not in ["GET", "POST"]:
|
||||||
|
raise ValueError, "method must be GET or POST"
|
||||||
|
self.host = host
|
||||||
|
self.url = url
|
||||||
|
self.method = method
|
||||||
|
|
||||||
|
def emit(self, record):
|
||||||
|
"""
|
||||||
|
Emit a record.
|
||||||
|
|
||||||
|
Send the record to the Web server as an URL-encoded dictionary
|
||||||
|
"""
|
||||||
|
try:
|
||||||
|
import httplib, urllib
|
||||||
|
h = httplib.HTTP(self.host)
|
||||||
|
url = self.url
|
||||||
|
data = urllib.urlencode(record.__dict__)
|
||||||
|
if self.method == "GET":
|
||||||
|
if (string.find(url, '?') >= 0):
|
||||||
|
sep = '&'
|
||||||
|
else:
|
||||||
|
sep = '?'
|
||||||
|
url = url + "%c%s" % (sep, data)
|
||||||
|
h.putrequest(self.method, url)
|
||||||
|
if self.method == "POST":
|
||||||
|
h.putheader("Content-length", str(len(data)))
|
||||||
|
h.endheaders()
|
||||||
|
if self.method == "POST":
|
||||||
|
h.send(data)
|
||||||
|
h.getreply() #can't do anything with the result
|
||||||
|
except:
|
||||||
|
self.handleError()
|
||||||
|
|
||||||
|
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.buffer = []
|
||||||
|
|
||||||
|
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):
|
||||||
|
"""
|
||||||
|
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!
|
||||||
|
"""
|
||||||
|
BufferingHandler.__init__(self, capacity)
|
||||||
|
self.flushLevel = flushLevel
|
||||||
|
self.target = target
|
||||||
|
|
||||||
|
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.
|
||||||
|
"""
|
||||||
|
if self.target:
|
||||||
|
for record in self.buffer:
|
||||||
|
self.target.handle(record)
|
||||||
|
self.buffer = []
|
||||||
|
|
||||||
|
def close(self):
|
||||||
|
"""
|
||||||
|
Flush, set the target to None and lose the buffer.
|
||||||
|
"""
|
||||||
|
self.flush()
|
||||||
|
self.target = None
|
||||||
|
self.buffer = []
|
Loading…
Reference in New Issue