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 class BaseRotatingHandler(logging
.FileHandler
):
49 Base class for handlers that rotate log files at a certain point.
50 Not meant to be instantiated directly. Instead, use RotatingFileHandler
51 or TimedRotatingFileHandler.
53 def __init__(self
, filename
, mode
, encoding
=None):
55 Use the specified filename for streamed logging
59 logging
.FileHandler
.__init
__(self
, filename
, mode
, encoding
)
61 self
.encoding
= encoding
63 def emit(self
, record
):
67 Output the record to the file, catering for rollover as described
71 if self
.shouldRollover(record
):
73 logging
.FileHandler
.emit(self
, record
)
74 except (KeyboardInterrupt, SystemExit):
77 self
.handleError(record
)
79 class RotatingFileHandler(BaseRotatingHandler
):
81 Handler for logging to a set of files, which switches from one file
82 to the next when the current file reaches a certain size.
84 def __init__(self
, filename
, mode
='a', maxBytes
=0, backupCount
=0, encoding
=None):
86 Open the specified file and use it as the stream for logging.
88 By default, the file grows indefinitely. You can specify particular
89 values of maxBytes and backupCount to allow the file to rollover at
92 Rollover occurs whenever the current log file is nearly maxBytes in
93 length. If backupCount is >= 1, the system will successively create
94 new files with the same pathname as the base file, but with extensions
95 ".1", ".2" etc. appended to it. For example, with a backupCount of 5
96 and a base file name of "app.log", you would get "app.log",
97 "app.log.1", "app.log.2", ... through to "app.log.5". The file being
98 written to is always "app.log" - when it gets filled up, it is closed
99 and renamed to "app.log.1", and if files "app.log.1", "app.log.2" etc.
100 exist, then they are renamed to "app.log.2", "app.log.3" etc.
103 If maxBytes is zero, rollover never occurs.
106 mode
= 'a' # doesn't make sense otherwise!
107 BaseRotatingHandler
.__init
__(self
, filename
, mode
, encoding
)
108 self
.maxBytes
= maxBytes
109 self
.backupCount
= backupCount
111 def doRollover(self
):
113 Do a rollover, as described in __init__().
117 if self
.backupCount
> 0:
118 for i
in range(self
.backupCount
- 1, 0, -1):
119 sfn
= "%s.%d" % (self
.baseFilename
, i
)
120 dfn
= "%s.%d" % (self
.baseFilename
, i
+ 1)
121 if os
.path
.exists(sfn
):
122 #print "%s -> %s" % (sfn, dfn)
123 if os
.path
.exists(dfn
):
126 dfn
= self
.baseFilename
+ ".1"
127 if os
.path
.exists(dfn
):
130 os
.rename(self
.baseFilename
, dfn
)
131 except (KeyboardInterrupt, SystemExit):
134 self
.handleError(record
)
135 #print "%s -> %s" % (self.baseFilename, dfn)
137 self
.stream
= codecs
.open(self
.baseFilename
, 'w', self
.encoding
)
139 self
.stream
= open(self
.baseFilename
, 'w')
141 def shouldRollover(self
, record
):
143 Determine if rollover should occur.
145 Basically, see if the supplied record would cause the file to exceed
146 the size limit we have.
148 if self
.maxBytes
> 0: # are we rolling over?
149 msg
= "%s\n" % self
.format(record
)
150 self
.stream
.seek(0, 2) #due to non-posix-compliant Windows feature
151 if self
.stream
.tell() + len(msg
) >= self
.maxBytes
:
155 class TimedRotatingFileHandler(BaseRotatingHandler
):
157 Handler for logging to a file, rotating the log file at certain timed
160 If backupCount is > 0, when rollover is done, no more than backupCount
161 files are kept - the oldest ones are deleted.
163 def __init__(self
, filename
, when
='h', interval
=1, backupCount
=0, encoding
=None):
164 BaseRotatingHandler
.__init
__(self
, filename
, 'a', encoding
)
165 self
.when
= string
.upper(when
)
166 self
.backupCount
= backupCount
167 # Calculate the real rollover interval, which is just the number of
168 # seconds between rollovers. Also set the filename suffix used when
169 # a rollover occurs. Current 'when' events supported:
174 # midnight - roll over at midnight
175 # W{0-6} - roll over on a certain day; 0 - Monday
177 # Case of the 'when' specifier is not important; lower or upper case
179 currentTime
= int(time
.time())
181 self
.interval
= 1 # one second
182 self
.suffix
= "%Y-%m-%d_%H-%M-%S"
183 elif self
.when
== 'M':
184 self
.interval
= 60 # one minute
185 self
.suffix
= "%Y-%m-%d_%H-%M"
186 elif self
.when
== 'H':
187 self
.interval
= 60 * 60 # one hour
188 self
.suffix
= "%Y-%m-%d_%H"
189 elif self
.when
== 'D' or self
.when
== 'MIDNIGHT':
190 self
.interval
= 60 * 60 * 24 # one day
191 self
.suffix
= "%Y-%m-%d"
192 elif self
.when
.startswith('W'):
193 self
.interval
= 60 * 60 * 24 * 7 # one week
194 if len(self
.when
) != 2:
195 raise ValueError("You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s" % self
.when
)
196 if self
.when
[1] < '0' or self
.when
[1] > '6':
197 raise ValueError("Invalid day specified for weekly rollover: %s" % self
.when
)
198 self
.dayOfWeek
= int(self
.when
[1])
199 self
.suffix
= "%Y-%m-%d"
201 raise ValueError("Invalid rollover interval specified: %s" % self
.when
)
203 self
.interval
= self
.interval
* interval
# multiply by units requested
204 self
.rolloverAt
= currentTime
+ self
.interval
206 # If we are rolling over at midnight or weekly, then the interval is already known.
207 # What we need to figure out is WHEN the next interval is. In other words,
208 # if you are rolling over at midnight, then your base interval is 1 day,
209 # but you want to start that one day clock at midnight, not now. So, we
210 # have to fudge the rolloverAt value in order to trigger the first rollover
211 # at the right time. After that, the regular interval will take care of
212 # the rest. Note that this code doesn't care about leap seconds. :)
213 if self
.when
== 'MIDNIGHT' or self
.when
.startswith('W'):
214 # This could be done with less code, but I wanted it to be clear
215 t
= time
.localtime(currentTime
)
219 # r is the number of seconds left between now and midnight
220 if (currentMinute
== 0) and (currentSecond
== 0):
221 r
= (24 - currentHour
) * 60 * 60 # number of hours in seconds
223 r
= (23 - currentHour
) * 60 * 60
224 r
= r
+ (59 - currentMinute
) * 60 # plus the number of minutes (in secs)
225 r
= r
+ (60 - currentSecond
) # plus the number of seconds
226 self
.rolloverAt
= currentTime
+ r
227 # If we are rolling over on a certain day, add in the number of days until
228 # the next rollover, but offset by 1 since we just calculated the time
229 # until the next day starts. There are three cases:
230 # Case 1) The day to rollover is today; in this case, do nothing
231 # Case 2) The day to rollover is further in the interval (i.e., today is
232 # day 2 (Wednesday) and rollover is on day 6 (Sunday). Days to
233 # next rollover is simply 6 - 2 - 1, or 3.
234 # Case 3) The day to rollover is behind us in the interval (i.e., today
235 # is day 5 (Saturday) and rollover is on day 3 (Thursday).
236 # Days to rollover is 6 - 5 + 3, or 4. In this case, it's the
237 # number of days left in the current week (1) plus the number
238 # of days in the next week until the rollover day (3).
239 if when
.startswith('W'):
240 day
= t
[6] # 0 is Monday
241 if day
> self
.dayOfWeek
:
242 daysToWait
= (day
- self
.dayOfWeek
) - 1
243 self
.rolloverAt
= self
.rolloverAt
+ (daysToWait
* (60 * 60 * 24))
244 if day
< self
.dayOfWeek
:
245 daysToWait
= (6 - self
.dayOfWeek
) + day
246 self
.rolloverAt
= self
.rolloverAt
+ (daysToWait
* (60 * 60 * 24))
248 #print "Will rollover at %d, %d seconds from now" % (self.rolloverAt, self.rolloverAt - currentTime)
250 def shouldRollover(self
, record
):
252 Determine if rollover should occur
254 record is not used, as we are just comparing times, but it is needed so
255 the method siguratures are the same
258 if t
>= self
.rolloverAt
:
260 #print "No need to rollover: %d, %d" % (t, self.rolloverAt)
263 def doRollover(self
):
265 do a rollover; in this case, a date/time stamp is appended to the filename
266 when the rollover happens. However, you want the file to be named for the
267 start of the interval, not the current time. If there is a backup count,
268 then we have to get a list of matching filenames, sort them and remove
269 the one with the oldest suffix.
272 # get the time that this sequence started at and make it a TimeTuple
273 t
= self
.rolloverAt
- self
.interval
274 timeTuple
= time
.localtime(t
)
275 dfn
= self
.baseFilename
+ "." + time
.strftime(self
.suffix
, timeTuple
)
276 if os
.path
.exists(dfn
):
279 os
.rename(self
.baseFilename
, dfn
)
280 except (KeyboardInterrupt, SystemExit):
283 self
.handleError(record
)
284 if self
.backupCount
> 0:
285 # find the oldest log file and delete it
286 s
= glob
.glob(self
.baseFilename
+ ".20*")
287 if len(s
) > self
.backupCount
:
290 #print "%s -> %s" % (self.baseFilename, dfn)
292 self
.stream
= codecs
.open(self
.baseFilename
, 'w', self
.encoding
)
294 self
.stream
= open(self
.baseFilename
, 'w')
295 self
.rolloverAt
= self
.rolloverAt
+ self
.interval
297 class SocketHandler(logging
.Handler
):
299 A handler class which writes logging records, in pickle format, to
300 a streaming socket. The socket is kept open across logging calls.
301 If the peer resets it, an attempt is made to reconnect on the next call.
302 The pickle which is sent is that of the LogRecord's attribute dictionary
303 (__dict__), so that the receiver does not need to have the logging module
304 installed in order to process the logging event.
306 To unpickle the record at the receiving end into a LogRecord, use the
307 makeLogRecord function.
310 def __init__(self
, host
, port
):
312 Initializes the handler with a specific host address and port.
314 The attribute 'closeOnError' is set to 1 - which means that if
315 a socket error occurs, the socket is silently closed and then
316 reopened on the next logging call.
318 logging
.Handler
.__init
__(self
)
322 self
.closeOnError
= 0
323 self
.retryTime
= None
325 # Exponential backoff parameters.
327 self
.retryStart
= 1.0
329 self
.retryFactor
= 2.0
331 def makeSocket(self
):
333 A factory method which allows subclasses to define the precise
334 type of socket they want.
336 s
= socket
.socket(socket
.AF_INET
, socket
.SOCK_STREAM
)
337 s
.connect((self
.host
, self
.port
))
340 def createSocket(self
):
342 Try to create a socket, using an exponential backoff with
343 a max retry time. Thanks to Robert Olson for the original patch
344 (SF #815911) which has been slightly refactored.
347 # Either retryTime is None, in which case this
348 # is the first time back after a disconnect, or
349 # we've waited long enough.
350 if self
.retryTime
is None:
353 attempt
= (now
>= self
.retryTime
)
356 self
.sock
= self
.makeSocket()
357 self
.retryTime
= None # next time, no delay before trying
359 #Creation failed, so set the retry time and return.
360 if self
.retryTime
is None:
361 self
.retryPeriod
= self
.retryStart
363 self
.retryPeriod
= self
.retryPeriod
* self
.retryFactor
364 if self
.retryPeriod
> self
.retryMax
:
365 self
.retryPeriod
= self
.retryMax
366 self
.retryTime
= now
+ self
.retryPeriod
370 Send a pickled string to the socket.
372 This function allows for partial sends which can happen when the
375 if self
.sock
is None:
377 #self.sock can be None either because we haven't reached the retry
378 #time yet, or because we have reached the retry time and retried,
379 #but are still unable to connect.
382 if hasattr(self
.sock
, "sendall"):
388 sent
= self
.sock
.send(s
[sentsofar
:])
389 sentsofar
= sentsofar
+ sent
393 self
.sock
= None # so we can call createSocket next time
395 def makePickle(self
, record
):
397 Pickles the record in binary format with a length prefix, and
398 returns it ready for transmission across the socket.
402 dummy
= self
.format(record
) # just to get traceback text into record.exc_text
403 record
.exc_info
= None # to avoid Unpickleable error
404 s
= cPickle
.dumps(record
.__dict
__, 1)
406 record
.exc_info
= ei
# for next handler
407 slen
= struct
.pack(">L", len(s
))
410 def handleError(self
, record
):
412 Handle an error during logging.
414 An error has occurred during logging. Most likely cause -
415 connection lost. Close the socket so that we can retry on the
418 if self
.closeOnError
and self
.sock
:
420 self
.sock
= None #try to reconnect next time
422 logging
.Handler
.handleError(self
, record
)
424 def emit(self
, record
):
428 Pickles the record and writes it to the socket in binary format.
429 If there is an error with the socket, silently drop the packet.
430 If there was a problem with the socket, re-establishes the
434 s
= self
.makePickle(record
)
436 except (KeyboardInterrupt, SystemExit):
439 self
.handleError(record
)
448 logging
.Handler
.close(self
)
450 class DatagramHandler(SocketHandler
):
452 A handler class which writes logging records, in pickle format, to
453 a datagram socket. The pickle which is sent is that of the LogRecord's
454 attribute dictionary (__dict__), so that the receiver does not need to
455 have the logging module installed in order to process the logging event.
457 To unpickle the record at the receiving end into a LogRecord, use the
458 makeLogRecord function.
461 def __init__(self
, host
, port
):
463 Initializes the handler with a specific host address and port.
465 SocketHandler
.__init
__(self
, host
, port
)
466 self
.closeOnError
= 0
468 def makeSocket(self
):
470 The factory method of SocketHandler is here overridden to create
471 a UDP socket (SOCK_DGRAM).
473 s
= socket
.socket(socket
.AF_INET
, socket
.SOCK_DGRAM
)
478 Send a pickled string to a socket.
480 This function no longer allows for partial sends which can happen
481 when the network is busy - UDP does not guarantee delivery and
482 can deliver packets out of sequence.
484 if self
.sock
is None:
486 self
.sock
.sendto(s
, (self
.host
, self
.port
))
488 class SysLogHandler(logging
.Handler
):
490 A handler class which sends formatted logging records to a syslog
491 server. Based on Sam Rushing's syslog module:
492 http://www.nightmare.com/squirl/python-ext/misc/syslog.py
493 Contributed by Nicolas Untz (after which minor refactoring changes
497 # from <linux/sys/syslog.h>:
498 # ======================================================================
499 # priorities/facilities are encoded into a single 32-bit quantity, where
500 # the bottom 3 bits are the priority (0-7) and the top 28 bits are the
501 # facility (0-big number). Both the priorities and the facilities map
502 # roughly one-to-one to strings in the syslogd(8) source code. This
503 # mapping is included in this file.
505 # priorities (these are ordered)
507 LOG_EMERG
= 0 # system is unusable
508 LOG_ALERT
= 1 # action must be taken immediately
509 LOG_CRIT
= 2 # critical conditions
510 LOG_ERR
= 3 # error conditions
511 LOG_WARNING
= 4 # warning conditions
512 LOG_NOTICE
= 5 # normal but significant condition
513 LOG_INFO
= 6 # informational
514 LOG_DEBUG
= 7 # debug-level messages
517 LOG_KERN
= 0 # kernel messages
518 LOG_USER
= 1 # random user-level messages
519 LOG_MAIL
= 2 # mail system
520 LOG_DAEMON
= 3 # system daemons
521 LOG_AUTH
= 4 # security/authorization messages
522 LOG_SYSLOG
= 5 # messages generated internally by syslogd
523 LOG_LPR
= 6 # line printer subsystem
524 LOG_NEWS
= 7 # network news subsystem
525 LOG_UUCP
= 8 # UUCP subsystem
526 LOG_CRON
= 9 # clock daemon
527 LOG_AUTHPRIV
= 10 # security/authorization messages (private)
529 # other codes through 15 reserved for system use
530 LOG_LOCAL0
= 16 # reserved for local use
531 LOG_LOCAL1
= 17 # reserved for local use
532 LOG_LOCAL2
= 18 # reserved for local use
533 LOG_LOCAL3
= 19 # reserved for local use
534 LOG_LOCAL4
= 20 # reserved for local use
535 LOG_LOCAL5
= 21 # reserved for local use
536 LOG_LOCAL6
= 22 # reserved for local use
537 LOG_LOCAL7
= 23 # reserved for local use
542 "critical": LOG_CRIT
,
546 "error": LOG_ERR
, # DEPRECATED
548 "notice": LOG_NOTICE
,
549 "panic": LOG_EMERG
, # DEPRECATED
550 "warn": LOG_WARNING
, # DEPRECATED
551 "warning": LOG_WARNING
,
556 "authpriv": LOG_AUTHPRIV
,
558 "daemon": LOG_DAEMON
,
563 "security": LOG_AUTH
, # DEPRECATED
564 "syslog": LOG_SYSLOG
,
567 "local0": LOG_LOCAL0
,
568 "local1": LOG_LOCAL1
,
569 "local2": LOG_LOCAL2
,
570 "local3": LOG_LOCAL3
,
571 "local4": LOG_LOCAL4
,
572 "local5": LOG_LOCAL5
,
573 "local6": LOG_LOCAL6
,
574 "local7": LOG_LOCAL7
,
577 def __init__(self
, address
=('localhost', SYSLOG_UDP_PORT
), facility
=LOG_USER
):
579 Initialize a handler.
581 If address is specified as a string, UNIX socket is used.
582 If facility is not specified, LOG_USER is used.
584 logging
.Handler
.__init
__(self
)
586 self
.address
= address
587 self
.facility
= facility
588 if type(address
) == types
.StringType
:
589 self
._connect
_unixsocket
(address
)
592 self
.socket
= socket
.socket(socket
.AF_INET
, socket
.SOCK_DGRAM
)
595 self
.formatter
= None
597 def _connect_unixsocket(self
, address
):
598 self
.socket
= socket
.socket(socket
.AF_UNIX
, socket
.SOCK_DGRAM
)
599 # syslog may require either DGRAM or STREAM sockets
601 self
.socket
.connect(address
)
604 self
.socket
= socket
.socket(socket
.AF_UNIX
, socket
.SOCK_STREAM
)
605 self
.socket
.connect(address
)
607 # curious: when talking to the unix-domain '/dev/log' socket, a
608 # zero-terminator seems to be required. this string is placed
609 # into a class variable so that it can be overridden if
611 log_format_string
= '<%d>%s\000'
613 def encodePriority (self
, facility
, priority
):
615 Encode the facility and priority. You can pass in strings or
616 integers - if strings are passed, the facility_names and
617 priority_names mapping dictionaries are used to convert them to
620 if type(facility
) == types
.StringType
:
621 facility
= self
.facility_names
[facility
]
622 if type(priority
) == types
.StringType
:
623 priority
= self
.priority_names
[priority
]
624 return (facility
<< 3) | priority
632 logging
.Handler
.close(self
)
634 def emit(self
, record
):
638 The record is formatted, and then sent to the syslog server. If
639 exception information is present, it is NOT sent to the server.
641 msg
= self
.format(record
)
643 We need to convert record level to lowercase, maybe this will
644 change in the future.
646 msg
= self
.log_format_string
% (
647 self
.encodePriority(self
.facility
,
648 string
.lower(record
.levelname
)),
653 self
.socket
.send(msg
)
655 self
._connect
_unixsocket
(self
.address
)
656 self
.socket
.send(msg
)
658 self
.socket
.sendto(msg
, self
.address
)
659 except (KeyboardInterrupt, SystemExit):
662 self
.handleError(record
)
664 class SMTPHandler(logging
.Handler
):
666 A handler class which sends an SMTP email for each logging event.
668 def __init__(self
, mailhost
, fromaddr
, toaddrs
, subject
):
670 Initialize the handler.
672 Initialize the instance with the from and to addresses and subject
673 line of the email. To specify a non-standard SMTP port, use the
674 (host, port) tuple format for the mailhost argument.
676 logging
.Handler
.__init
__(self
)
677 if type(mailhost
) == types
.TupleType
:
678 host
, port
= mailhost
682 self
.mailhost
= mailhost
684 self
.fromaddr
= fromaddr
685 if type(toaddrs
) == types
.StringType
:
687 self
.toaddrs
= toaddrs
688 self
.subject
= subject
690 def getSubject(self
, record
):
692 Determine the subject for the email.
694 If you want to specify a subject line which is record-dependent,
695 override this method.
699 weekdayname
= ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
702 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
703 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
707 Return the current date and time formatted for a MIME header.
708 Needed for Python 1.5.2 (no email package available)
710 year
, month
, day
, hh
, mm
, ss
, wd
, y
, z
= time
.gmtime(time
.time())
711 s
= "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
712 self
.weekdayname
[wd
],
713 day
, self
.monthname
[month
], year
,
717 def emit(self
, record
):
721 Format the record and send it to the specified addressees.
726 from email
.Utils
import formatdate
728 formatdate
= self
.date_time
731 port
= smtplib
.SMTP_PORT
732 smtp
= smtplib
.SMTP(self
.mailhost
, port
)
733 msg
= self
.format(record
)
734 msg
= "From: %s\r\nTo: %s\r\nSubject: %s\r\nDate: %s\r\n\r\n%s" % (
736 string
.join(self
.toaddrs
, ","),
737 self
.getSubject(record
),
739 smtp
.sendmail(self
.fromaddr
, self
.toaddrs
, msg
)
741 except (KeyboardInterrupt, SystemExit):
744 self
.handleError(record
)
746 class NTEventLogHandler(logging
.Handler
):
748 A handler class which sends events to the NT Event Log. Adds a
749 registry entry for the specified application name. If no dllname is
750 provided, win32service.pyd (which contains some basic message
751 placeholders) is used. Note that use of these placeholders will make
752 your event logs big, as the entire message source is held in the log.
753 If you want slimmer logs, you have to pass in the name of your own DLL
754 which contains the message definitions you want to use in the event log.
756 def __init__(self
, appname
, dllname
=None, logtype
="Application"):
757 logging
.Handler
.__init
__(self
)
759 import win32evtlogutil
, win32evtlog
760 self
.appname
= appname
761 self
._welu
= win32evtlogutil
763 dllname
= os
.path
.split(self
._welu
.__file
__)
764 dllname
= os
.path
.split(dllname
[0])
765 dllname
= os
.path
.join(dllname
[0], r
'win32service.pyd')
766 self
.dllname
= dllname
767 self
.logtype
= logtype
768 self
._welu
.AddSourceToRegistry(appname
, dllname
, logtype
)
769 self
.deftype
= win32evtlog
.EVENTLOG_ERROR_TYPE
771 logging
.DEBUG
: win32evtlog
.EVENTLOG_INFORMATION_TYPE
,
772 logging
.INFO
: win32evtlog
.EVENTLOG_INFORMATION_TYPE
,
773 logging
.WARNING
: win32evtlog
.EVENTLOG_WARNING_TYPE
,
774 logging
.ERROR
: win32evtlog
.EVENTLOG_ERROR_TYPE
,
775 logging
.CRITICAL
: win32evtlog
.EVENTLOG_ERROR_TYPE
,
778 print "The Python Win32 extensions for NT (service, event "\
779 "logging) appear not to be available."
782 def getMessageID(self
, record
):
784 Return the message ID for the event record. If you are using your
785 own messages, you could do this by having the msg passed to the
786 logger being an ID rather than a formatting string. Then, in here,
787 you could use a dictionary lookup to get the message ID. This
788 version returns 1, which is the base message ID in win32service.pyd.
792 def getEventCategory(self
, record
):
794 Return the event category for the record.
796 Override this if you want to specify your own categories. This version
801 def getEventType(self
, record
):
803 Return the event type for the record.
805 Override this if you want to specify your own types. This version does
806 a mapping using the handler's typemap attribute, which is set up in
807 __init__() to a dictionary which contains mappings for DEBUG, INFO,
808 WARNING, ERROR and CRITICAL. If you are using your own levels you will
809 either need to override this method or place a suitable dictionary in
810 the handler's typemap attribute.
812 return self
.typemap
.get(record
.levelno
, self
.deftype
)
814 def emit(self
, record
):
818 Determine the message ID, event category and event type. Then
819 log the message in the NT event log.
823 id = self
.getMessageID(record
)
824 cat
= self
.getEventCategory(record
)
825 type = self
.getEventType(record
)
826 msg
= self
.format(record
)
827 self
._welu
.ReportEvent(self
.appname
, id, cat
, type, [msg
])
828 except (KeyboardInterrupt, SystemExit):
831 self
.handleError(record
)
835 Clean up this handler.
837 You can remove the application name from the registry as a
838 source of event log entries. However, if you do this, you will
839 not be able to see the events as you intended in the Event Log
840 Viewer - it needs to be able to access the registry to get the
843 #self._welu.RemoveSourceFromRegistry(self.appname, self.logtype)
844 logging
.Handler
.close(self
)
846 class HTTPHandler(logging
.Handler
):
848 A class which sends records to a Web server, using either GET or
851 def __init__(self
, host
, url
, method
="GET"):
853 Initialize the instance with the host, the request URL, and the method
856 logging
.Handler
.__init
__(self
)
857 method
= string
.upper(method
)
858 if method
not in ["GET", "POST"]:
859 raise ValueError, "method must be GET or POST"
864 def mapLogRecord(self
, record
):
866 Default implementation of mapping the log record into a dict
867 that is sent as the CGI data. Overwrite in your class.
868 Contributed by Franz Glasner.
870 return record
.__dict
__
872 def emit(self
, record
):
876 Send the record to the Web server as an URL-encoded dictionary
879 import httplib
, urllib
881 h
= httplib
.HTTP(host
)
883 data
= urllib
.urlencode(self
.mapLogRecord(record
))
884 if self
.method
== "GET":
885 if (string
.find(url
, '?') >= 0):
889 url
= url
+ "%c%s" % (sep
, data
)
890 h
.putrequest(self
.method
, url
)
891 # support multiple hosts on one IP address...
892 # need to strip optional :port from host, if present
893 i
= string
.find(host
, ":")
896 h
.putheader("Host", host
)
897 if self
.method
== "POST":
898 h
.putheader("Content-type",
899 "application/x-www-form-urlencoded")
900 h
.putheader("Content-length", str(len(data
)))
902 if self
.method
== "POST":
904 h
.getreply() #can't do anything with the result
905 except (KeyboardInterrupt, SystemExit):
908 self
.handleError(record
)
910 class BufferingHandler(logging
.Handler
):
912 A handler class which buffers logging records in memory. Whenever each
913 record is added to the buffer, a check is made to see if the buffer should
914 be flushed. If it should, then flush() is expected to do what's needed.
916 def __init__(self
, capacity
):
918 Initialize the handler with the buffer size.
920 logging
.Handler
.__init
__(self
)
921 self
.capacity
= capacity
924 def shouldFlush(self
, record
):
926 Should the handler flush its buffer?
928 Returns true if the buffer is up to capacity. This method can be
929 overridden to implement custom flushing strategies.
931 return (len(self
.buffer) >= self
.capacity
)
933 def emit(self
, record
):
937 Append the record. If shouldFlush() tells us to, call flush() to process
940 self
.buffer.append(record
)
941 if self
.shouldFlush(record
):
946 Override to implement custom flushing behaviour.
948 This version just zaps the buffer to empty.
956 This version just flushes and chains to the parent class' close().
959 logging
.Handler
.close(self
)
961 class MemoryHandler(BufferingHandler
):
963 A handler class which buffers logging records in memory, periodically
964 flushing them to a target handler. Flushing occurs whenever the buffer
965 is full, or when an event of a certain severity or greater is seen.
967 def __init__(self
, capacity
, flushLevel
=logging
.ERROR
, target
=None):
969 Initialize the handler with the buffer size, the level at which
970 flushing should occur and an optional target.
972 Note that without a target being set either here or via setTarget(),
973 a MemoryHandler is no use to anyone!
975 BufferingHandler
.__init
__(self
, capacity
)
976 self
.flushLevel
= flushLevel
979 def shouldFlush(self
, record
):
981 Check for buffer full or a record at the flushLevel or higher.
983 return (len(self
.buffer) >= self
.capacity
) or \
984 (record
.levelno
>= self
.flushLevel
)
986 def setTarget(self
, target
):
988 Set the target handler for this handler.
994 For a MemoryHandler, flushing means just sending the buffered
995 records to the target, if there is one. Override if you want
999 for record
in self
.buffer:
1000 self
.target
.handle(record
)
1005 Flush, set the target to None and lose the buffer.
1009 BufferingHandler
.close(self
)