--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/python-win32-2.6.1/lib/logging/handlers.py Fri Jul 31 15:01:17 2009 +0100
@@ -0,0 +1,1138 @@
+# Copyright 2001-2007 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, and influenced by
+Apache's log4j system.
+
+Should work under Python versions >= 1.5.2, except that source line
+information is not available unless 'sys._getframe()' is.
+
+Copyright (C) 2001-2008 Vinay Sajip. All Rights Reserved.
+
+To use, simply 'import logging' and log away!
+"""
+
+import logging, socket, types, os, string, cPickle, struct, time, re
+from stat import ST_DEV, ST_INO
+
+try:
+ import codecs
+except ImportError:
+ codecs = None
+
+#
+# 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
+
+_MIDNIGHT = 24 * 60 * 60 # number of seconds in a day
+
+class BaseRotatingHandler(logging.FileHandler):
+ """
+ Base class for handlers that rotate log files at a certain point.
+ Not meant to be instantiated directly. Instead, use RotatingFileHandler
+ or TimedRotatingFileHandler.
+ """
+ def __init__(self, filename, mode, encoding=None, delay=0):
+ """
+ Use the specified filename for streamed logging
+ """
+ if codecs is None:
+ encoding = None
+ logging.FileHandler.__init__(self, filename, mode, encoding, delay)
+ self.mode = mode
+ self.encoding = encoding
+
+ 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 (KeyboardInterrupt, SystemExit):
+ raise
+ except:
+ self.handleError(record)
+
+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=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.
+ """
+ if maxBytes > 0:
+ mode = 'a' # doesn't make sense otherwise!
+ BaseRotatingHandler.__init__(self, filename, mode, encoding, delay)
+ self.maxBytes = maxBytes
+ self.backupCount = backupCount
+
+ 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.mode = 'w'
+ 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.maxBytes > 0: # are we rolling over?
+ msg = "%s\n" % self.format(record)
+ self.stream.seek(0, 2) #due to non-posix-compliant Windows feature
+ if self.stream.tell() + len(msg) >= self.maxBytes:
+ return 1
+ return 0
+
+class TimedRotatingFileHandler(BaseRotatingHandler):
+ """
+ Handler for logging to a file, rotating the log file at certain timed
+ intervals.
+
+ If backupCount is > 0, when rollover is done, no more than backupCount
+ files are kept - the oldest ones are deleted.
+ """
+ def __init__(self, filename, when='h', interval=1, backupCount=0, encoding=None, delay=0, utc=0):
+ BaseRotatingHandler.__init__(self, filename, 'a', encoding, delay)
+ self.when = string.upper(when)
+ self.backupCount = backupCount
+ self.utc = utc
+ # 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.
+ currentTime = int(time.time())
+ if self.when == 'S':
+ self.interval = 1 # one second
+ self.suffix = "%Y-%m-%d_%H-%M-%S"
+ self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}$"
+ elif self.when == 'M':
+ self.interval = 60 # one minute
+ self.suffix = "%Y-%m-%d_%H-%M"
+ self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}$"
+ elif self.when == 'H':
+ self.interval = 60 * 60 # one hour
+ self.suffix = "%Y-%m-%d_%H"
+ self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}$"
+ elif self.when == 'D' or self.when == 'MIDNIGHT':
+ self.interval = 60 * 60 * 24 # one day
+ self.suffix = "%Y-%m-%d"
+ self.extMatch = r"^\d{4}-\d{2}-\d{2}$"
+ elif self.when.startswith('W'):
+ self.interval = 60 * 60 * 24 * 7 # one week
+ if len(self.when) != 2:
+ raise ValueError("You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s" % self.when)
+ if self.when[1] < '0' or self.when[1] > '6':
+ raise ValueError("Invalid day specified for weekly rollover: %s" % self.when)
+ self.dayOfWeek = int(self.when[1])
+ self.suffix = "%Y-%m-%d"
+ self.extMatch = r"^\d{4}-\d{2}-\d{2}$"
+ else:
+ raise ValueError("Invalid rollover interval specified: %s" % self.when)
+
+ self.extMatch = re.compile(self.extMatch)
+ self.interval = self.interval * interval # multiply by units requested
+ self.rolloverAt = 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 utc:
+ t = time.gmtime(currentTime)
+ else:
+ t = time.localtime(currentTime)
+ currentHour = t[3]
+ currentMinute = t[4]
+ currentSecond = t[5]
+ # r is the number of seconds left between now and midnight
+ r = _MIDNIGHT - ((currentHour * 60 + currentMinute) * 60 +
+ currentSecond)
+ self.rolloverAt = 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 when.startswith('W'):
+ day = t[6] # 0 is Monday
+ if day != self.dayOfWeek:
+ if day < self.dayOfWeek:
+ daysToWait = self.dayOfWeek - day
+ else:
+ daysToWait = 6 - day + self.dayOfWeek + 1
+ newRolloverAt = self.rolloverAt + (daysToWait * (60 * 60 * 24))
+ if not utc:
+ dstNow = t[-1]
+ dstAtRollover = time.localtime(newRolloverAt)[-1]
+ if dstNow != dstAtRollover:
+ if not dstNow: # DST kicks in before next rollover, so we need to deduct an hour
+ newRolloverAt = newRolloverAt - 3600
+ else: # DST bows out before next rollover, so we need to add an hour
+ newRolloverAt = newRolloverAt + 3600
+ self.rolloverAt = newRolloverAt
+
+ #print "Will rollover at %d, %d seconds from now" % (self.rolloverAt, self.rolloverAt - currentTime)
+
+ def shouldRollover(self, record):
+ """
+ Determine if rollover should occur.
+
+ record is not used, as we are just comparing times, but it is needed so
+ the method signatures are the same
+ """
+ t = int(time.time())
+ if t >= self.rolloverAt:
+ return 1
+ #print "No need to rollover: %d, %d" % (t, self.rolloverAt)
+ return 0
+
+ def getFilesToDelete(self):
+ """
+ Determine the files to delete when rolling over.
+
+ More specific than the earlier method, which just used glob.glob().
+ """
+ dirName, baseName = os.path.split(self.baseFilename)
+ fileNames = os.listdir(dirName)
+ result = []
+ prefix = baseName + "."
+ plen = len(prefix)
+ for fileName in fileNames:
+ if fileName[:plen] == prefix:
+ suffix = fileName[plen:]
+ if self.extMatch.match(suffix):
+ result.append(os.path.join(dirName, fileName))
+ result.sort()
+ if len(result) < self.backupCount:
+ result = []
+ else:
+ 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.
+ """
+ self.stream.close()
+ # get the time that this sequence started at and make it a TimeTuple
+ t = self.rolloverAt - self.interval
+ if self.utc:
+ timeTuple = time.gmtime(t)
+ else:
+ timeTuple = time.localtime(t)
+ dfn = self.baseFilename + "." + time.strftime(self.suffix, timeTuple)
+ if os.path.exists(dfn):
+ os.remove(dfn)
+ os.rename(self.baseFilename, dfn)
+ if self.backupCount > 0:
+ # find the oldest log file and delete it
+ #s = glob.glob(self.baseFilename + ".20*")
+ #if len(s) > self.backupCount:
+ # s.sort()
+ # os.remove(s[0])
+ for s in self.getFilesToDelete():
+ os.remove(s)
+ #print "%s -> %s" % (self.baseFilename, dfn)
+ self.mode = 'w'
+ self.stream = self._open()
+ newRolloverAt = self.rolloverAt + self.interval
+ currentTime = int(time.time())
+ while newRolloverAt <= currentTime:
+ newRolloverAt = newRolloverAt + self.interval
+ #If DST changes and midnight or weekly rollover, adjust for this.
+ if (self.when == 'MIDNIGHT' or self.when.startswith('W')) and not self.utc:
+ dstNow = time.localtime(currentTime)[-1]
+ dstAtRollover = time.localtime(newRolloverAt)[-1]
+ if dstNow != dstAtRollover:
+ if not dstNow: # DST kicks in before next rollover, so we need to deduct an hour
+ newRolloverAt = newRolloverAt - 3600
+ else: # DST bows out before next rollover, so we need to add an hour
+ newRolloverAt = newRolloverAt + 3600
+ self.rolloverAt = newRolloverAt
+
+class WatchedFileHandler(logging.FileHandler):
+ """
+ A handler for logging to a file, which watches the file
+ to see if it has changed while in use. This can happen because of
+ usage of programs such as newsyslog and logrotate which perform
+ log file rotation. This handler, intended for use under Unix,
+ watches the file to see if it has changed since the last emit.
+ (A file has changed if its device or inode have changed.)
+ If it has changed, the old file stream is closed, and the file
+ opened to get a new stream.
+
+ This handler is not appropriate for use under Windows, because
+ under Windows open files cannot be moved or renamed - logging
+ opens the files with exclusive locks - and so there is no need
+ for such a handler. Furthermore, ST_INO is not supported under
+ Windows; stat always returns zero for this value.
+
+ This handler is based on a suggestion and patch by Chad J.
+ Schroeder.
+ """
+ def __init__(self, filename, mode='a', encoding=None, delay=0):
+ logging.FileHandler.__init__(self, filename, mode, encoding, delay)
+ if not os.path.exists(self.baseFilename):
+ self.dev, self.ino = -1, -1
+ else:
+ stat = os.stat(self.baseFilename)
+ self.dev, self.ino = stat[ST_DEV], stat[ST_INO]
+
+ def emit(self, record):
+ """
+ Emit a record.
+
+ First check if the underlying file has changed, and if it
+ has, close the old stream and reopen the file to get the
+ current stream.
+ """
+ if not os.path.exists(self.baseFilename):
+ stat = None
+ changed = 1
+ else:
+ stat = os.stat(self.baseFilename)
+ changed = (stat[ST_DEV] != self.dev) or (stat[ST_INO] != self.ino)
+ if changed and self.stream is not None:
+ self.stream.flush()
+ self.stream.close()
+ self.stream = self._open()
+ if stat is None:
+ stat = os.stat(self.baseFilename)
+ self.dev, self.ino = stat[ST_DEV], stat[ST_INO]
+ 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.
+
+ 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
+ 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.
+ """
+ s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ if hasattr(s, 'settimeout'):
+ s.settimeout(timeout)
+ s.connect((self.host, self.port))
+ return s
+
+ 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 = 1
+ else:
+ attempt = (now >= self.retryTime)
+ if attempt:
+ try:
+ self.sock = self.makeSocket()
+ self.retryTime = None # next time, no delay before trying
+ except socket.error:
+ #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:
+ if hasattr(self.sock, "sendall"):
+ 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
+ except socket.error:
+ 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:
+ dummy = self.format(record) # just to get traceback text into record.exc_text
+ record.exc_info = None # to avoid Unpickleable error
+ s = cPickle.dumps(record.__dict__, 1)
+ if ei:
+ record.exc_info = ei # for next handler
+ 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 (KeyboardInterrupt, SystemExit):
+ raise
+ except:
+ self.handleError(record)
+
+ def close(self):
+ """
+ Closes the socket.
+ """
+ if self.sock:
+ self.sock.close()
+ self.sock = None
+ logging.Handler.close(self)
+
+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 = 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.
+ """
+ if self.sock is None:
+ self.createSocket()
+ 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,
+ }
+
+ #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):
+ """
+ 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.
+ """
+ logging.Handler.__init__(self)
+
+ self.address = address
+ self.facility = facility
+ if type(address) == types.StringType:
+ self.unixsocket = 1
+ self._connect_unixsocket(address)
+ else:
+ self.unixsocket = 0
+ self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+
+ self.formatter = None
+
+ def _connect_unixsocket(self, address):
+ self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
+ # syslog may require either DGRAM or STREAM sockets
+ try:
+ self.socket.connect(address)
+ except socket.error:
+ self.socket.close()
+ self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+ self.socket.connect(address)
+
+ # 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()
+ logging.Handler.close(self)
+
+ 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")
+
+ 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,
+ self.mapPriority(record.levelname)),
+ msg)
+ try:
+ if self.unixsocket:
+ try:
+ self.socket.send(msg)
+ except socket.error:
+ self._connect_unixsocket(self.address)
+ self.socket.send(msg)
+ else:
+ self.socket.sendto(msg, self.address)
+ except (KeyboardInterrupt, SystemExit):
+ raise
+ except:
+ self.handleError(record)
+
+class SMTPHandler(logging.Handler):
+ """
+ A handler class which sends an SMTP email for each logging event.
+ """
+ def __init__(self, mailhost, fromaddr, toaddrs, subject, credentials=None):
+ """
+ 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.
+ """
+ logging.Handler.__init__(self)
+ if type(mailhost) == types.TupleType:
+ self.mailhost, self.mailport = mailhost
+ else:
+ self.mailhost, self.mailport = mailhost, None
+ if type(credentials) == types.TupleType:
+ self.username, self.password = credentials
+ else:
+ self.username = None
+ self.fromaddr = fromaddr
+ if type(toaddrs) == types.StringType:
+ toaddrs = [toaddrs]
+ 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
+
+ weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+
+ monthname = [None,
+ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+ 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+
+ def date_time(self):
+ """
+ Return the current date and time formatted for a MIME header.
+ Needed for Python 1.5.2 (no email package available)
+ """
+ year, month, day, hh, mm, ss, wd, y, z = time.gmtime(time.time())
+ s = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
+ self.weekdayname[wd],
+ day, self.monthname[month], year,
+ hh, mm, ss)
+ return s
+
+ def emit(self, record):
+ """
+ Emit a record.
+
+ Format the record and send it to the specified addressees.
+ """
+ try:
+ import smtplib
+ try:
+ from email.utils import formatdate
+ except ImportError:
+ formatdate = self.date_time
+ 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\nDate: %s\r\n\r\n%s" % (
+ self.fromaddr,
+ string.join(self.toaddrs, ","),
+ self.getSubject(record),
+ formatdate(), msg)
+ if self.username:
+ smtp.login(self.username, self.password)
+ smtp.sendmail(self.fromaddr, self.toaddrs, msg)
+ smtp.quit()
+ except (KeyboardInterrupt, SystemExit):
+ raise
+ except:
+ self.handleError(record)
+
+class NTEventLogHandler(logging.Handler):
+ """
+ A handler class which sends events to the NT Event Log. Adds a
+ registry entry for the specified application name. If no dllname is
+ provided, win32service.pyd (which contains some basic message
+ placeholders) is used. Note that use of these placeholders will make
+ your event logs big, as the entire message source is held in the log.
+ If you want slimmer logs, you have to pass in the name of your own DLL
+ which contains the message definitions you want to use in the event log.
+ """
+ def __init__(self, appname, dllname=None, logtype="Application"):
+ logging.Handler.__init__(self)
+ try:
+ import win32evtlogutil, win32evtlog
+ self.appname = appname
+ self._welu = win32evtlogutil
+ if not dllname:
+ dllname = os.path.split(self._welu.__file__)
+ dllname = os.path.split(dllname[0])
+ dllname = os.path.join(dllname[0], r'win32service.pyd')
+ self.dllname = dllname
+ self.logtype = logtype
+ self._welu.AddSourceToRegistry(appname, dllname, logtype)
+ self.deftype = win32evtlog.EVENTLOG_ERROR_TYPE
+ self.typemap = {
+ logging.DEBUG : win32evtlog.EVENTLOG_INFORMATION_TYPE,
+ logging.INFO : win32evtlog.EVENTLOG_INFORMATION_TYPE,
+ logging.WARNING : win32evtlog.EVENTLOG_WARNING_TYPE,
+ logging.ERROR : win32evtlog.EVENTLOG_ERROR_TYPE,
+ logging.CRITICAL: win32evtlog.EVENTLOG_ERROR_TYPE,
+ }
+ except ImportError:
+ print "The Python Win32 extensions for NT (service, event "\
+ "logging) appear not to be available."
+ self._welu = None
+
+ def getMessageID(self, record):
+ """
+ Return the message ID for the event record. If you are using your
+ own messages, you could do this by having the msg passed to the
+ logger being an ID rather than a formatting string. Then, in here,
+ you could use a dictionary lookup to get the message ID. This
+ version returns 1, which is the base message ID in win32service.pyd.
+ """
+ return 1
+
+ def getEventCategory(self, record):
+ """
+ Return the event category for the record.
+
+ Override this if you want to specify your own categories. This version
+ returns 0.
+ """
+ return 0
+
+ def getEventType(self, record):
+ """
+ Return the event type for the record.
+
+ Override this if you want to specify your own types. This version does
+ a mapping using the handler's typemap attribute, which is set up in
+ __init__() to a dictionary which contains mappings for DEBUG, INFO,
+ WARNING, ERROR and CRITICAL. If you are using your own levels you will
+ either need to override this method or place a suitable dictionary in
+ the handler's typemap attribute.
+ """
+ return self.typemap.get(record.levelno, self.deftype)
+
+ def emit(self, record):
+ """
+ Emit a record.
+
+ Determine the message ID, event category and event type. Then
+ log the message in the NT event log.
+ """
+ if self._welu:
+ try:
+ id = self.getMessageID(record)
+ cat = self.getEventCategory(record)
+ type = self.getEventType(record)
+ msg = self.format(record)
+ self._welu.ReportEvent(self.appname, id, cat, type, [msg])
+ except (KeyboardInterrupt, SystemExit):
+ raise
+ except:
+ self.handleError(record)
+
+ def close(self):
+ """
+ Clean up this handler.
+
+ You can remove the application name from the registry as a
+ source of event log entries. However, if you do this, you will
+ not be able to see the events as you intended in the Event Log
+ Viewer - it needs to be able to access the registry to get the
+ DLL name.
+ """
+ #self._welu.RemoveSourceFromRegistry(self.appname, self.logtype)
+ logging.Handler.close(self)
+
+class HTTPHandler(logging.Handler):
+ """
+ A class which sends records to a Web server, using either GET or
+ POST semantics.
+ """
+ def __init__(self, host, url, method="GET"):
+ """
+ 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 mapLogRecord(self, record):
+ """
+ Default implementation of mapping the log record into a dict
+ that is sent as the CGI data. Overwrite in your class.
+ Contributed by Franz Glasner.
+ """
+ return record.__dict__
+
+ def emit(self, record):
+ """
+ Emit a record.
+
+ Send the record to the Web server as an URL-encoded dictionary
+ """
+ try:
+ import httplib, urllib
+ host = self.host
+ h = httplib.HTTP(host)
+ url = self.url
+ data = urllib.urlencode(self.mapLogRecord(record))
+ if self.method == "GET":
+ if (string.find(url, '?') >= 0):
+ sep = '&'
+ else:
+ sep = '?'
+ url = url + "%c%s" % (sep, data)
+ h.putrequest(self.method, url)
+ # support multiple hosts on one IP address...
+ # need to strip optional :port from host, if present
+ i = string.find(host, ":")
+ if i >= 0:
+ host = host[:i]
+ h.putheader("Host", host)
+ if self.method == "POST":
+ h.putheader("Content-type",
+ "application/x-www-form-urlencoded")
+ 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 (KeyboardInterrupt, SystemExit):
+ raise
+ except:
+ self.handleError(record)
+
+class BufferingHandler(logging.Handler):
+ """
+ A handler class which buffers logging records in memory. Whenever each
+ record is added to the buffer, a check is made to see if the buffer should
+ be flushed. If it should, then flush() is expected to do what's needed.
+ """
+ def __init__(self, capacity):
+ """
+ Initialize the handler with the buffer size.
+ """
+ logging.Handler.__init__(self)
+ self.capacity = capacity
+ self.buffer = []
+
+ def shouldFlush(self, record):
+ """
+ Should the handler flush its buffer?
+
+ Returns true if the buffer is up to capacity. This method can be
+ overridden to implement custom flushing strategies.
+ """
+ return (len(self.buffer) >= self.capacity)
+
+ def emit(self, record):
+ """
+ Emit a record.
+
+ Append the record. If shouldFlush() tells us to, call flush() to process
+ the buffer.
+ """
+ self.buffer.append(record)
+ if self.shouldFlush(record):
+ self.flush()
+
+ def flush(self):
+ """
+ Override to implement custom flushing behaviour.
+
+ This version just zaps the buffer to empty.
+ """
+ self.buffer = []
+
+ def close(self):
+ """
+ Close the handler.
+
+ This version just flushes and chains to the parent class' close().
+ """
+ self.flush()
+ logging.Handler.close(self)
+
+class MemoryHandler(BufferingHandler):
+ """
+ A handler class which buffers logging records in memory, periodically
+ flushing them to a target handler. Flushing occurs whenever the buffer
+ is full, or when an event of a certain severity or greater is seen.
+ """
+ def __init__(self, capacity, flushLevel=logging.ERROR, target=None):
+ """
+ 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
+ BufferingHandler.close(self)