1 # Copyright 2001-2005 by Vinay Sajip. All Rights Reserved.
3 # Permission to use, copy, modify, and distribute this software and its
4 # documentation for any purpose and without fee is hereby granted,
5 # provided that the above copyright notice appear in all copies and that
6 # both that copyright notice and this permission notice appear in
7 # supporting documentation, and that the name of Vinay Sajip
8 # not be used in advertising or publicity pertaining to distribution
9 # of the software without specific, written prior permission.
10 # VINAY SAJIP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
11 # ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
12 # VINAY SAJIP BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
13 # ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
14 # IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
15 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 Additional handlers for the logging package for Python. The core package is
19 based on PEP 282 and comments thereto in comp.lang.python, and influenced by
20 Apache's log4j system.
22 Should work under Python versions >= 1.5.2, except that source line
23 information is not available unless 'sys._getframe()' is.
25 Copyright (C) 2001-2004 Vinay Sajip. All Rights Reserved.
27 To use, simply 'import logging' and log away!
30 import sys
, logging
, socket
, types
, os
, string
, cPickle
, struct
, time
, glob
41 DEFAULT_TCP_LOGGING_PORT
= 9020
42 DEFAULT_UDP_LOGGING_PORT
= 9021
43 DEFAULT_HTTP_LOGGING_PORT
= 9022
44 DEFAULT_SOAP_LOGGING_PORT
= 9023
47 _MIDNIGHT
= 24 * 60 * 60 # number of seconds in a day
49 class BaseRotatingHandler(logging
.FileHandler
):
51 Base class for handlers that rotate log files at a certain point.
52 Not meant to be instantiated directly. Instead, use RotatingFileHandler
53 or TimedRotatingFileHandler.
55 def __init__(self
, filename
, mode
, encoding
=None):
57 Use the specified filename for streamed logging
61 logging
.FileHandler
.__init
__(self
, filename
, mode
, encoding
)
63 self
.encoding
= encoding
65 def emit(self
, record
):
69 Output the record to the file, catering for rollover as described
73 if self
.shouldRollover(record
):
75 logging
.FileHandler
.emit(self
, record
)
76 except (KeyboardInterrupt, SystemExit):
79 self
.handleError(record
)
81 class RotatingFileHandler(BaseRotatingHandler
):
83 Handler for logging to a set of files, which switches from one file
84 to the next when the current file reaches a certain size.
86 def __init__(self
, filename
, mode
='a', maxBytes
=0, backupCount
=0, encoding
=None):
88 Open the specified file and use it as the stream for logging.
90 By default, the file grows indefinitely. You can specify particular
91 values of maxBytes and backupCount to allow the file to rollover at
94 Rollover occurs whenever the current log file is nearly maxBytes in
95 length. If backupCount is >= 1, the system will successively create
96 new files with the same pathname as the base file, but with extensions
97 ".1", ".2" etc. appended to it. For example, with a backupCount of 5
98 and a base file name of "app.log", you would get "app.log",
99 "app.log.1", "app.log.2", ... through to "app.log.5". The file being
100 written to is always "app.log" - when it gets filled up, it is closed
101 and renamed to "app.log.1", and if files "app.log.1", "app.log.2" etc.
102 exist, then they are renamed to "app.log.2", "app.log.3" etc.
105 If maxBytes is zero, rollover never occurs.
108 mode
= 'a' # doesn't make sense otherwise!
109 BaseRotatingHandler
.__init
__(self
, filename
, mode
, encoding
)
110 self
.maxBytes
= maxBytes
111 self
.backupCount
= backupCount
113 def doRollover(self
):
115 Do a rollover, as described in __init__().
119 if self
.backupCount
> 0:
120 for i
in range(self
.backupCount
- 1, 0, -1):
121 sfn
= "%s.%d" % (self
.baseFilename
, i
)
122 dfn
= "%s.%d" % (self
.baseFilename
, i
+ 1)
123 if os
.path
.exists(sfn
):
124 #print "%s -> %s" % (sfn, dfn)
125 if os
.path
.exists(dfn
):
128 dfn
= self
.baseFilename
+ ".1"
129 if os
.path
.exists(dfn
):
132 os
.rename(self
.baseFilename
, dfn
)
133 except (KeyboardInterrupt, SystemExit):
136 self
.handleError(record
)
137 #print "%s -> %s" % (self.baseFilename, dfn)
139 self
.stream
= codecs
.open(self
.baseFilename
, 'w', self
.encoding
)
141 self
.stream
= open(self
.baseFilename
, 'w')
143 def shouldRollover(self
, record
):
145 Determine if rollover should occur.
147 Basically, see if the supplied record would cause the file to exceed
148 the size limit we have.
150 if self
.maxBytes
> 0: # are we rolling over?
151 msg
= "%s\n" % self
.format(record
)
152 self
.stream
.seek(0, 2) #due to non-posix-compliant Windows feature
153 if self
.stream
.tell() + len(msg
) >= self
.maxBytes
:
157 class TimedRotatingFileHandler(BaseRotatingHandler
):
159 Handler for logging to a file, rotating the log file at certain timed
162 If backupCount is > 0, when rollover is done, no more than backupCount
163 files are kept - the oldest ones are deleted.
165 def __init__(self
, filename
, when
='h', interval
=1, backupCount
=0, encoding
=None):
166 BaseRotatingHandler
.__init
__(self
, filename
, 'a', encoding
)
167 self
.when
= string
.upper(when
)
168 self
.backupCount
= backupCount
169 # Calculate the real rollover interval, which is just the number of
170 # seconds between rollovers. Also set the filename suffix used when
171 # a rollover occurs. Current 'when' events supported:
176 # midnight - roll over at midnight
177 # W{0-6} - roll over on a certain day; 0 - Monday
179 # Case of the 'when' specifier is not important; lower or upper case
181 currentTime
= int(time
.time())
183 self
.interval
= 1 # one second
184 self
.suffix
= "%Y-%m-%d_%H-%M-%S"
185 elif self
.when
== 'M':
186 self
.interval
= 60 # one minute
187 self
.suffix
= "%Y-%m-%d_%H-%M"
188 elif self
.when
== 'H':
189 self
.interval
= 60 * 60 # one hour
190 self
.suffix
= "%Y-%m-%d_%H"
191 elif self
.when
== 'D' or self
.when
== 'MIDNIGHT':
192 self
.interval
= 60 * 60 * 24 # one day
193 self
.suffix
= "%Y-%m-%d"
194 elif self
.when
.startswith('W'):
195 self
.interval
= 60 * 60 * 24 * 7 # one week
196 if len(self
.when
) != 2:
197 raise ValueError("You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s" % self
.when
)
198 if self
.when
[1] < '0' or self
.when
[1] > '6':
199 raise ValueError("Invalid day specified for weekly rollover: %s" % self
.when
)
200 self
.dayOfWeek
= int(self
.when
[1])
201 self
.suffix
= "%Y-%m-%d"
203 raise ValueError("Invalid rollover interval specified: %s" % self
.when
)
205 self
.interval
= self
.interval
* interval
# multiply by units requested
206 self
.rolloverAt
= currentTime
+ self
.interval
208 # If we are rolling over at midnight or weekly, then the interval is already known.
209 # What we need to figure out is WHEN the next interval is. In other words,
210 # if you are rolling over at midnight, then your base interval is 1 day,
211 # but you want to start that one day clock at midnight, not now. So, we
212 # have to fudge the rolloverAt value in order to trigger the first rollover
213 # at the right time. After that, the regular interval will take care of
214 # the rest. Note that this code doesn't care about leap seconds. :)
215 if self
.when
== 'MIDNIGHT' or self
.when
.startswith('W'):
216 # This could be done with less code, but I wanted it to be clear
217 t
= time
.localtime(currentTime
)
221 # r is the number of seconds left between now and midnight
222 r
= _MIDNIGHT
- ((currentHour
* 60 + currentMinute
) * 60 +
224 self
.rolloverAt
= currentTime
+ r
225 # If we are rolling over on a certain day, add in the number of days until
226 # the next rollover, but offset by 1 since we just calculated the time
227 # until the next day starts. There are three cases:
228 # Case 1) The day to rollover is today; in this case, do nothing
229 # Case 2) The day to rollover is further in the interval (i.e., today is
230 # day 2 (Wednesday) and rollover is on day 6 (Sunday). Days to
231 # next rollover is simply 6 - 2 - 1, or 3.
232 # Case 3) The day to rollover is behind us in the interval (i.e., today
233 # is day 5 (Saturday) and rollover is on day 3 (Thursday).
234 # Days to rollover is 6 - 5 + 3, or 4. In this case, it's the
235 # number of days left in the current week (1) plus the number
236 # of days in the next week until the rollover day (3).
237 if when
.startswith('W'):
238 day
= t
[6] # 0 is Monday
239 if day
> self
.dayOfWeek
:
240 daysToWait
= (day
- self
.dayOfWeek
) - 1
241 self
.rolloverAt
= self
.rolloverAt
+ (daysToWait
* (60 * 60 * 24))
242 if day
< self
.dayOfWeek
:
243 daysToWait
= (6 - self
.dayOfWeek
) + day
244 self
.rolloverAt
= self
.rolloverAt
+ (daysToWait
* (60 * 60 * 24))
246 #print "Will rollover at %d, %d seconds from now" % (self.rolloverAt, self.rolloverAt - currentTime)
248 def shouldRollover(self
, record
):
250 Determine if rollover should occur
252 record is not used, as we are just comparing times, but it is needed so
253 the method siguratures are the same
256 if t
>= self
.rolloverAt
:
258 #print "No need to rollover: %d, %d" % (t, self.rolloverAt)
261 def doRollover(self
):
263 do a rollover; in this case, a date/time stamp is appended to the filename
264 when the rollover happens. However, you want the file to be named for the
265 start of the interval, not the current time. If there is a backup count,
266 then we have to get a list of matching filenames, sort them and remove
267 the one with the oldest suffix.
270 # get the time that this sequence started at and make it a TimeTuple
271 t
= self
.rolloverAt
- self
.interval
272 timeTuple
= time
.localtime(t
)
273 dfn
= self
.baseFilename
+ "." + time
.strftime(self
.suffix
, timeTuple
)
274 if os
.path
.exists(dfn
):
277 os
.rename(self
.baseFilename
, dfn
)
278 except (KeyboardInterrupt, SystemExit):
281 self
.handleError(record
)
282 if self
.backupCount
> 0:
283 # find the oldest log file and delete it
284 s
= glob
.glob(self
.baseFilename
+ ".20*")
285 if len(s
) > self
.backupCount
:
288 #print "%s -> %s" % (self.baseFilename, dfn)
290 self
.stream
= codecs
.open(self
.baseFilename
, 'w', self
.encoding
)
292 self
.stream
= open(self
.baseFilename
, 'w')
293 self
.rolloverAt
= self
.rolloverAt
+ self
.interval
295 class SocketHandler(logging
.Handler
):
297 A handler class which writes logging records, in pickle format, to
298 a streaming socket. The socket is kept open across logging calls.
299 If the peer resets it, an attempt is made to reconnect on the next call.
300 The pickle which is sent is that of the LogRecord's attribute dictionary
301 (__dict__), so that the receiver does not need to have the logging module
302 installed in order to process the logging event.
304 To unpickle the record at the receiving end into a LogRecord, use the
305 makeLogRecord function.
308 def __init__(self
, host
, port
):
310 Initializes the handler with a specific host address and port.
312 The attribute 'closeOnError' is set to 1 - which means that if
313 a socket error occurs, the socket is silently closed and then
314 reopened on the next logging call.
316 logging
.Handler
.__init
__(self
)
320 self
.closeOnError
= 0
321 self
.retryTime
= None
323 # Exponential backoff parameters.
325 self
.retryStart
= 1.0
327 self
.retryFactor
= 2.0
329 def makeSocket(self
):
331 A factory method which allows subclasses to define the precise
332 type of socket they want.
334 s
= socket
.socket(socket
.AF_INET
, socket
.SOCK_STREAM
)
335 s
.connect((self
.host
, self
.port
))
338 def createSocket(self
):
340 Try to create a socket, using an exponential backoff with
341 a max retry time. Thanks to Robert Olson for the original patch
342 (SF #815911) which has been slightly refactored.
345 # Either retryTime is None, in which case this
346 # is the first time back after a disconnect, or
347 # we've waited long enough.
348 if self
.retryTime
is None:
351 attempt
= (now
>= self
.retryTime
)
354 self
.sock
= self
.makeSocket()
355 self
.retryTime
= None # next time, no delay before trying
357 #Creation failed, so set the retry time and return.
358 if self
.retryTime
is None:
359 self
.retryPeriod
= self
.retryStart
361 self
.retryPeriod
= self
.retryPeriod
* self
.retryFactor
362 if self
.retryPeriod
> self
.retryMax
:
363 self
.retryPeriod
= self
.retryMax
364 self
.retryTime
= now
+ self
.retryPeriod
368 Send a pickled string to the socket.
370 This function allows for partial sends which can happen when the
373 if self
.sock
is None:
375 #self.sock can be None either because we haven't reached the retry
376 #time yet, or because we have reached the retry time and retried,
377 #but are still unable to connect.
380 if hasattr(self
.sock
, "sendall"):
386 sent
= self
.sock
.send(s
[sentsofar
:])
387 sentsofar
= sentsofar
+ sent
391 self
.sock
= None # so we can call createSocket next time
393 def makePickle(self
, record
):
395 Pickles the record in binary format with a length prefix, and
396 returns it ready for transmission across the socket.
400 dummy
= self
.format(record
) # just to get traceback text into record.exc_text
401 record
.exc_info
= None # to avoid Unpickleable error
402 s
= cPickle
.dumps(record
.__dict
__, 1)
404 record
.exc_info
= ei
# for next handler
405 slen
= struct
.pack(">L", len(s
))
408 def handleError(self
, record
):
410 Handle an error during logging.
412 An error has occurred during logging. Most likely cause -
413 connection lost. Close the socket so that we can retry on the
416 if self
.closeOnError
and self
.sock
:
418 self
.sock
= None #try to reconnect next time
420 logging
.Handler
.handleError(self
, record
)
422 def emit(self
, record
):
426 Pickles the record and writes it to the socket in binary format.
427 If there is an error with the socket, silently drop the packet.
428 If there was a problem with the socket, re-establishes the
432 s
= self
.makePickle(record
)
434 except (KeyboardInterrupt, SystemExit):
437 self
.handleError(record
)
446 logging
.Handler
.close(self
)
448 class DatagramHandler(SocketHandler
):
450 A handler class which writes logging records, in pickle format, to
451 a datagram socket. The pickle which is sent is that of the LogRecord's
452 attribute dictionary (__dict__), so that the receiver does not need to
453 have the logging module installed in order to process the logging event.
455 To unpickle the record at the receiving end into a LogRecord, use the
456 makeLogRecord function.
459 def __init__(self
, host
, port
):
461 Initializes the handler with a specific host address and port.
463 SocketHandler
.__init
__(self
, host
, port
)
464 self
.closeOnError
= 0
466 def makeSocket(self
):
468 The factory method of SocketHandler is here overridden to create
469 a UDP socket (SOCK_DGRAM).
471 s
= socket
.socket(socket
.AF_INET
, socket
.SOCK_DGRAM
)
476 Send a pickled string to a socket.
478 This function no longer allows for partial sends which can happen
479 when the network is busy - UDP does not guarantee delivery and
480 can deliver packets out of sequence.
482 if self
.sock
is None:
484 self
.sock
.sendto(s
, (self
.host
, self
.port
))
486 class SysLogHandler(logging
.Handler
):
488 A handler class which sends formatted logging records to a syslog
489 server. Based on Sam Rushing's syslog module:
490 http://www.nightmare.com/squirl/python-ext/misc/syslog.py
491 Contributed by Nicolas Untz (after which minor refactoring changes
495 # from <linux/sys/syslog.h>:
496 # ======================================================================
497 # priorities/facilities are encoded into a single 32-bit quantity, where
498 # the bottom 3 bits are the priority (0-7) and the top 28 bits are the
499 # facility (0-big number). Both the priorities and the facilities map
500 # roughly one-to-one to strings in the syslogd(8) source code. This
501 # mapping is included in this file.
503 # priorities (these are ordered)
505 LOG_EMERG
= 0 # system is unusable
506 LOG_ALERT
= 1 # action must be taken immediately
507 LOG_CRIT
= 2 # critical conditions
508 LOG_ERR
= 3 # error conditions
509 LOG_WARNING
= 4 # warning conditions
510 LOG_NOTICE
= 5 # normal but significant condition
511 LOG_INFO
= 6 # informational
512 LOG_DEBUG
= 7 # debug-level messages
515 LOG_KERN
= 0 # kernel messages
516 LOG_USER
= 1 # random user-level messages
517 LOG_MAIL
= 2 # mail system
518 LOG_DAEMON
= 3 # system daemons
519 LOG_AUTH
= 4 # security/authorization messages
520 LOG_SYSLOG
= 5 # messages generated internally by syslogd
521 LOG_LPR
= 6 # line printer subsystem
522 LOG_NEWS
= 7 # network news subsystem
523 LOG_UUCP
= 8 # UUCP subsystem
524 LOG_CRON
= 9 # clock daemon
525 LOG_AUTHPRIV
= 10 # security/authorization messages (private)
527 # other codes through 15 reserved for system use
528 LOG_LOCAL0
= 16 # reserved for local use
529 LOG_LOCAL1
= 17 # reserved for local use
530 LOG_LOCAL2
= 18 # reserved for local use
531 LOG_LOCAL3
= 19 # reserved for local use
532 LOG_LOCAL4
= 20 # reserved for local use
533 LOG_LOCAL5
= 21 # reserved for local use
534 LOG_LOCAL6
= 22 # reserved for local use
535 LOG_LOCAL7
= 23 # reserved for local use
540 "critical": LOG_CRIT
,
544 "error": LOG_ERR
, # DEPRECATED
546 "notice": LOG_NOTICE
,
547 "panic": LOG_EMERG
, # DEPRECATED
548 "warn": LOG_WARNING
, # DEPRECATED
549 "warning": LOG_WARNING
,
554 "authpriv": LOG_AUTHPRIV
,
556 "daemon": LOG_DAEMON
,
561 "security": LOG_AUTH
, # DEPRECATED
562 "syslog": LOG_SYSLOG
,
565 "local0": LOG_LOCAL0
,
566 "local1": LOG_LOCAL1
,
567 "local2": LOG_LOCAL2
,
568 "local3": LOG_LOCAL3
,
569 "local4": LOG_LOCAL4
,
570 "local5": LOG_LOCAL5
,
571 "local6": LOG_LOCAL6
,
572 "local7": LOG_LOCAL7
,
575 def __init__(self
, address
=('localhost', SYSLOG_UDP_PORT
), facility
=LOG_USER
):
577 Initialize a handler.
579 If address is specified as a string, UNIX socket is used.
580 If facility is not specified, LOG_USER is used.
582 logging
.Handler
.__init
__(self
)
584 self
.address
= address
585 self
.facility
= facility
586 if type(address
) == types
.StringType
:
587 self
._connect
_unixsocket
(address
)
590 self
.socket
= socket
.socket(socket
.AF_INET
, socket
.SOCK_DGRAM
)
593 self
.formatter
= None
595 def _connect_unixsocket(self
, address
):
596 self
.socket
= socket
.socket(socket
.AF_UNIX
, socket
.SOCK_DGRAM
)
597 # syslog may require either DGRAM or STREAM sockets
599 self
.socket
.connect(address
)
602 self
.socket
= socket
.socket(socket
.AF_UNIX
, socket
.SOCK_STREAM
)
603 self
.socket
.connect(address
)
605 # curious: when talking to the unix-domain '/dev/log' socket, a
606 # zero-terminator seems to be required. this string is placed
607 # into a class variable so that it can be overridden if
609 log_format_string
= '<%d>%s\000'
611 def encodePriority (self
, facility
, priority
):
613 Encode the facility and priority. You can pass in strings or
614 integers - if strings are passed, the facility_names and
615 priority_names mapping dictionaries are used to convert them to
618 if type(facility
) == types
.StringType
:
619 facility
= self
.facility_names
[facility
]
620 if type(priority
) == types
.StringType
:
621 priority
= self
.priority_names
[priority
]
622 return (facility
<< 3) | priority
630 logging
.Handler
.close(self
)
632 def emit(self
, record
):
636 The record is formatted, and then sent to the syslog server. If
637 exception information is present, it is NOT sent to the server.
639 msg
= self
.format(record
)
641 We need to convert record level to lowercase, maybe this will
642 change in the future.
644 msg
= self
.log_format_string
% (
645 self
.encodePriority(self
.facility
,
646 string
.lower(record
.levelname
)),
651 self
.socket
.send(msg
)
653 self
._connect
_unixsocket
(self
.address
)
654 self
.socket
.send(msg
)
656 self
.socket
.sendto(msg
, self
.address
)
657 except (KeyboardInterrupt, SystemExit):
660 self
.handleError(record
)
662 class SMTPHandler(logging
.Handler
):
664 A handler class which sends an SMTP email for each logging event.
666 def __init__(self
, mailhost
, fromaddr
, toaddrs
, subject
):
668 Initialize the handler.
670 Initialize the instance with the from and to addresses and subject
671 line of the email. To specify a non-standard SMTP port, use the
672 (host, port) tuple format for the mailhost argument.
674 logging
.Handler
.__init
__(self
)
675 if type(mailhost
) == types
.TupleType
:
676 host
, port
= mailhost
680 self
.mailhost
= mailhost
682 self
.fromaddr
= fromaddr
683 if type(toaddrs
) == types
.StringType
:
685 self
.toaddrs
= toaddrs
686 self
.subject
= subject
688 def getSubject(self
, record
):
690 Determine the subject for the email.
692 If you want to specify a subject line which is record-dependent,
693 override this method.
697 weekdayname
= ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
700 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
701 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
705 Return the current date and time formatted for a MIME header.
706 Needed for Python 1.5.2 (no email package available)
708 year
, month
, day
, hh
, mm
, ss
, wd
, y
, z
= time
.gmtime(time
.time())
709 s
= "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
710 self
.weekdayname
[wd
],
711 day
, self
.monthname
[month
], year
,
715 def emit(self
, record
):
719 Format the record and send it to the specified addressees.
724 from email
.Utils
import formatdate
726 formatdate
= self
.date_time
729 port
= smtplib
.SMTP_PORT
730 smtp
= smtplib
.SMTP(self
.mailhost
, port
)
731 msg
= self
.format(record
)
732 msg
= "From: %s\r\nTo: %s\r\nSubject: %s\r\nDate: %s\r\n\r\n%s" % (
734 string
.join(self
.toaddrs
, ","),
735 self
.getSubject(record
),
737 smtp
.sendmail(self
.fromaddr
, self
.toaddrs
, msg
)
739 except (KeyboardInterrupt, SystemExit):
742 self
.handleError(record
)
744 class NTEventLogHandler(logging
.Handler
):
746 A handler class which sends events to the NT Event Log. Adds a
747 registry entry for the specified application name. If no dllname is
748 provided, win32service.pyd (which contains some basic message
749 placeholders) is used. Note that use of these placeholders will make
750 your event logs big, as the entire message source is held in the log.
751 If you want slimmer logs, you have to pass in the name of your own DLL
752 which contains the message definitions you want to use in the event log.
754 def __init__(self
, appname
, dllname
=None, logtype
="Application"):
755 logging
.Handler
.__init
__(self
)
757 import win32evtlogutil
, win32evtlog
758 self
.appname
= appname
759 self
._welu
= win32evtlogutil
761 dllname
= os
.path
.split(self
._welu
.__file
__)
762 dllname
= os
.path
.split(dllname
[0])
763 dllname
= os
.path
.join(dllname
[0], r
'win32service.pyd')
764 self
.dllname
= dllname
765 self
.logtype
= logtype
766 self
._welu
.AddSourceToRegistry(appname
, dllname
, logtype
)
767 self
.deftype
= win32evtlog
.EVENTLOG_ERROR_TYPE
769 logging
.DEBUG
: win32evtlog
.EVENTLOG_INFORMATION_TYPE
,
770 logging
.INFO
: win32evtlog
.EVENTLOG_INFORMATION_TYPE
,
771 logging
.WARNING
: win32evtlog
.EVENTLOG_WARNING_TYPE
,
772 logging
.ERROR
: win32evtlog
.EVENTLOG_ERROR_TYPE
,
773 logging
.CRITICAL
: win32evtlog
.EVENTLOG_ERROR_TYPE
,
776 print "The Python Win32 extensions for NT (service, event "\
777 "logging) appear not to be available."
780 def getMessageID(self
, record
):
782 Return the message ID for the event record. If you are using your
783 own messages, you could do this by having the msg passed to the
784 logger being an ID rather than a formatting string. Then, in here,
785 you could use a dictionary lookup to get the message ID. This
786 version returns 1, which is the base message ID in win32service.pyd.
790 def getEventCategory(self
, record
):
792 Return the event category for the record.
794 Override this if you want to specify your own categories. This version
799 def getEventType(self
, record
):
801 Return the event type for the record.
803 Override this if you want to specify your own types. This version does
804 a mapping using the handler's typemap attribute, which is set up in
805 __init__() to a dictionary which contains mappings for DEBUG, INFO,
806 WARNING, ERROR and CRITICAL. If you are using your own levels you will
807 either need to override this method or place a suitable dictionary in
808 the handler's typemap attribute.
810 return self
.typemap
.get(record
.levelno
, self
.deftype
)
812 def emit(self
, record
):
816 Determine the message ID, event category and event type. Then
817 log the message in the NT event log.
821 id = self
.getMessageID(record
)
822 cat
= self
.getEventCategory(record
)
823 type = self
.getEventType(record
)
824 msg
= self
.format(record
)
825 self
._welu
.ReportEvent(self
.appname
, id, cat
, type, [msg
])
826 except (KeyboardInterrupt, SystemExit):
829 self
.handleError(record
)
833 Clean up this handler.
835 You can remove the application name from the registry as a
836 source of event log entries. However, if you do this, you will
837 not be able to see the events as you intended in the Event Log
838 Viewer - it needs to be able to access the registry to get the
841 #self._welu.RemoveSourceFromRegistry(self.appname, self.logtype)
842 logging
.Handler
.close(self
)
844 class HTTPHandler(logging
.Handler
):
846 A class which sends records to a Web server, using either GET or
849 def __init__(self
, host
, url
, method
="GET"):
851 Initialize the instance with the host, the request URL, and the method
854 logging
.Handler
.__init
__(self
)
855 method
= string
.upper(method
)
856 if method
not in ["GET", "POST"]:
857 raise ValueError, "method must be GET or POST"
862 def mapLogRecord(self
, record
):
864 Default implementation of mapping the log record into a dict
865 that is sent as the CGI data. Overwrite in your class.
866 Contributed by Franz Glasner.
868 return record
.__dict
__
870 def emit(self
, record
):
874 Send the record to the Web server as an URL-encoded dictionary
877 import httplib
, urllib
879 h
= httplib
.HTTP(host
)
881 data
= urllib
.urlencode(self
.mapLogRecord(record
))
882 if self
.method
== "GET":
883 if (string
.find(url
, '?') >= 0):
887 url
= url
+ "%c%s" % (sep
, data
)
888 h
.putrequest(self
.method
, url
)
889 # support multiple hosts on one IP address...
890 # need to strip optional :port from host, if present
891 i
= string
.find(host
, ":")
894 h
.putheader("Host", host
)
895 if self
.method
== "POST":
896 h
.putheader("Content-type",
897 "application/x-www-form-urlencoded")
898 h
.putheader("Content-length", str(len(data
)))
900 if self
.method
== "POST":
902 h
.getreply() #can't do anything with the result
903 except (KeyboardInterrupt, SystemExit):
906 self
.handleError(record
)
908 class BufferingHandler(logging
.Handler
):
910 A handler class which buffers logging records in memory. Whenever each
911 record is added to the buffer, a check is made to see if the buffer should
912 be flushed. If it should, then flush() is expected to do what's needed.
914 def __init__(self
, capacity
):
916 Initialize the handler with the buffer size.
918 logging
.Handler
.__init
__(self
)
919 self
.capacity
= capacity
922 def shouldFlush(self
, record
):
924 Should the handler flush its buffer?
926 Returns true if the buffer is up to capacity. This method can be
927 overridden to implement custom flushing strategies.
929 return (len(self
.buffer) >= self
.capacity
)
931 def emit(self
, record
):
935 Append the record. If shouldFlush() tells us to, call flush() to process
938 self
.buffer.append(record
)
939 if self
.shouldFlush(record
):
944 Override to implement custom flushing behaviour.
946 This version just zaps the buffer to empty.
954 This version just flushes and chains to the parent class' close().
957 logging
.Handler
.close(self
)
959 class MemoryHandler(BufferingHandler
):
961 A handler class which buffers logging records in memory, periodically
962 flushing them to a target handler. Flushing occurs whenever the buffer
963 is full, or when an event of a certain severity or greater is seen.
965 def __init__(self
, capacity
, flushLevel
=logging
.ERROR
, target
=None):
967 Initialize the handler with the buffer size, the level at which
968 flushing should occur and an optional target.
970 Note that without a target being set either here or via setTarget(),
971 a MemoryHandler is no use to anyone!
973 BufferingHandler
.__init
__(self
, capacity
)
974 self
.flushLevel
= flushLevel
977 def shouldFlush(self
, record
):
979 Check for buffer full or a record at the flushLevel or higher.
981 return (len(self
.buffer) >= self
.capacity
) or \
982 (record
.levelno
>= self
.flushLevel
)
984 def setTarget(self
, target
):
986 Set the target handler for this handler.
992 For a MemoryHandler, flushing means just sending the buffered
993 records to the target, if there is one. Override if you want
997 for record
in self
.buffer:
998 self
.target
.handle(record
)
1003 Flush, set the target to None and lose the buffer.
1007 BufferingHandler
.close(self
)