blob: 00868086f44150a699b4e812feb5badaa9c00df7 [file] [log] [blame]
Vinay Sajipdb81c4c2010-02-25 23:13:06 +00001# Copyright 2001-2010 by Vinay Sajip. All Rights Reserved.
Guido van Rossum57102f82002-11-13 16:15:58 +00002#
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.
Guido van Rossum57102f82002-11-13 16:15:58 +000016
17"""
Vinay Sajip3f742842004-02-28 16:07:46 +000018Additional handlers for the logging package for Python. The core package is
19based on PEP 282 and comments thereto in comp.lang.python, and influenced by
20Apache's log4j system.
Guido van Rossum57102f82002-11-13 16:15:58 +000021
Vinay Sajipdb81c4c2010-02-25 23:13:06 +000022Copyright (C) 2001-2010 Vinay Sajip. All Rights Reserved.
Guido van Rossum57102f82002-11-13 16:15:58 +000023
Vinay Sajip6268cbc2009-01-21 00:19:28 +000024To use, simply 'import logging.handlers' and log away!
Guido van Rossum57102f82002-11-13 16:15:58 +000025"""
26
Benjamin Petersonad9d48d2008-04-02 21:49:44 +000027import logging, socket, os, pickle, struct, time, re
Benjamin Peterson9451a1c2010-03-13 22:30:34 +000028from stat import ST_DEV, ST_INO, ST_MTIME
Vinay Sajipe723e962011-04-15 22:27:17 +010029import queue
Victor Stinnercafa2ef2011-05-02 16:11:28 +020030try:
31 import threading
Vinay Sajip0372e102011-05-05 12:59:14 +010032except ImportError: #pragma: no cover
Victor Stinnercafa2ef2011-05-02 16:11:28 +020033 threading = None
Guido van Rossum57102f82002-11-13 16:15:58 +000034
Vinay Sajip4600f112005-03-13 09:56:36 +000035try:
36 import codecs
Vinay Sajip985ef872011-04-26 19:34:04 +010037except ImportError: #pragma: no cover
Vinay Sajip4600f112005-03-13 09:56:36 +000038 codecs = None
39
Guido van Rossum57102f82002-11-13 16:15:58 +000040#
41# Some constants...
42#
43
44DEFAULT_TCP_LOGGING_PORT = 9020
45DEFAULT_UDP_LOGGING_PORT = 9021
46DEFAULT_HTTP_LOGGING_PORT = 9022
47DEFAULT_SOAP_LOGGING_PORT = 9023
48SYSLOG_UDP_PORT = 514
Vinay Sajipcbabd7e2009-10-10 20:32:36 +000049SYSLOG_TCP_PORT = 514
Guido van Rossum57102f82002-11-13 16:15:58 +000050
Thomas Wouters477c8d52006-05-27 19:21:47 +000051_MIDNIGHT = 24 * 60 * 60 # number of seconds in a day
52
Vinay Sajip17c52d82004-07-03 11:48:34 +000053class BaseRotatingHandler(logging.FileHandler):
54 """
55 Base class for handlers that rotate log files at a certain point.
56 Not meant to be instantiated directly. Instead, use RotatingFileHandler
57 or TimedRotatingFileHandler.
58 """
Christian Heimese7a15bb2008-01-24 16:21:45 +000059 def __init__(self, filename, mode, encoding=None, delay=0):
Vinay Sajip17c52d82004-07-03 11:48:34 +000060 """
61 Use the specified filename for streamed logging
62 """
Vinay Sajip985ef872011-04-26 19:34:04 +010063 if codecs is None: #pragma: no cover
Vinay Sajip4600f112005-03-13 09:56:36 +000064 encoding = None
Christian Heimese7a15bb2008-01-24 16:21:45 +000065 logging.FileHandler.__init__(self, filename, mode, encoding, delay)
Vinay Sajip4600f112005-03-13 09:56:36 +000066 self.mode = mode
67 self.encoding = encoding
Guido van Rossum57102f82002-11-13 16:15:58 +000068
Vinay Sajip17c52d82004-07-03 11:48:34 +000069 def emit(self, record):
70 """
71 Emit a record.
72
73 Output the record to the file, catering for rollover as described
74 in doRollover().
75 """
Vinay Sajip3970c112004-07-08 10:24:04 +000076 try:
77 if self.shouldRollover(record):
78 self.doRollover()
79 logging.FileHandler.emit(self, record)
Vinay Sajip985ef872011-04-26 19:34:04 +010080 except (KeyboardInterrupt, SystemExit): #pragma: no cover
Vinay Sajip85c19092005-10-31 13:14:19 +000081 raise
Vinay Sajip3970c112004-07-08 10:24:04 +000082 except:
83 self.handleError(record)
Vinay Sajip17c52d82004-07-03 11:48:34 +000084
85class RotatingFileHandler(BaseRotatingHandler):
86 """
87 Handler for logging to a set of files, which switches from one file
88 to the next when the current file reaches a certain size.
89 """
Christian Heimese7a15bb2008-01-24 16:21:45 +000090 def __init__(self, filename, mode='a', maxBytes=0, backupCount=0, encoding=None, delay=0):
Guido van Rossum57102f82002-11-13 16:15:58 +000091 """
92 Open the specified file and use it as the stream for logging.
93
94 By default, the file grows indefinitely. You can specify particular
95 values of maxBytes and backupCount to allow the file to rollover at
96 a predetermined size.
97
98 Rollover occurs whenever the current log file is nearly maxBytes in
99 length. If backupCount is >= 1, the system will successively create
100 new files with the same pathname as the base file, but with extensions
101 ".1", ".2" etc. appended to it. For example, with a backupCount of 5
102 and a base file name of "app.log", you would get "app.log",
103 "app.log.1", "app.log.2", ... through to "app.log.5". The file being
104 written to is always "app.log" - when it gets filled up, it is closed
105 and renamed to "app.log.1", and if files "app.log.1", "app.log.2" etc.
106 exist, then they are renamed to "app.log.2", "app.log.3" etc.
107 respectively.
108
109 If maxBytes is zero, rollover never occurs.
110 """
Vinay Sajip89994b22010-08-22 18:11:02 +0000111 # If rotation/rollover is wanted, it doesn't make sense to use another
112 # mode. If for example 'w' were specified, then if there were multiple
113 # runs of the calling application, the logs from previous runs would be
114 # lost if the 'w' is respected, because the log file would be truncated
115 # on each run.
Vinay Sajip17c52d82004-07-03 11:48:34 +0000116 if maxBytes > 0:
Vinay Sajip89994b22010-08-22 18:11:02 +0000117 mode = 'a'
Christian Heimese7a15bb2008-01-24 16:21:45 +0000118 BaseRotatingHandler.__init__(self, filename, mode, encoding, delay)
Guido van Rossum57102f82002-11-13 16:15:58 +0000119 self.maxBytes = maxBytes
120 self.backupCount = backupCount
Guido van Rossum57102f82002-11-13 16:15:58 +0000121
122 def doRollover(self):
123 """
124 Do a rollover, as described in __init__().
125 """
Vinay Sajip6268cbc2009-01-21 00:19:28 +0000126 if self.stream:
127 self.stream.close()
Vinay Sajip01241d62011-01-21 23:35:57 +0000128 self.stream = None
Guido van Rossum57102f82002-11-13 16:15:58 +0000129 if self.backupCount > 0:
130 for i in range(self.backupCount - 1, 0, -1):
131 sfn = "%s.%d" % (self.baseFilename, i)
132 dfn = "%s.%d" % (self.baseFilename, i + 1)
133 if os.path.exists(sfn):
Guido van Rossum57102f82002-11-13 16:15:58 +0000134 if os.path.exists(dfn):
135 os.remove(dfn)
136 os.rename(sfn, dfn)
137 dfn = self.baseFilename + ".1"
138 if os.path.exists(dfn):
139 os.remove(dfn)
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000140 os.rename(self.baseFilename, dfn)
Thomas Woutersb2137042007-02-01 18:02:27 +0000141 self.mode = 'w'
142 self.stream = self._open()
Guido van Rossum57102f82002-11-13 16:15:58 +0000143
Vinay Sajip17c52d82004-07-03 11:48:34 +0000144 def shouldRollover(self, record):
Guido van Rossum57102f82002-11-13 16:15:58 +0000145 """
Vinay Sajip17c52d82004-07-03 11:48:34 +0000146 Determine if rollover should occur.
Guido van Rossum57102f82002-11-13 16:15:58 +0000147
Vinay Sajip17c52d82004-07-03 11:48:34 +0000148 Basically, see if the supplied record would cause the file to exceed
149 the size limit we have.
Guido van Rossum57102f82002-11-13 16:15:58 +0000150 """
Vinay Sajip6268cbc2009-01-21 00:19:28 +0000151 if self.stream is None: # delay was set...
152 self.stream = self._open()
Guido van Rossum57102f82002-11-13 16:15:58 +0000153 if self.maxBytes > 0: # are we rolling over?
154 msg = "%s\n" % self.format(record)
Neal Norwitz6fa635d2003-02-18 14:20:07 +0000155 self.stream.seek(0, 2) #due to non-posix-compliant Windows feature
Guido van Rossum57102f82002-11-13 16:15:58 +0000156 if self.stream.tell() + len(msg) >= self.maxBytes:
Vinay Sajip17c52d82004-07-03 11:48:34 +0000157 return 1
158 return 0
Guido van Rossum57102f82002-11-13 16:15:58 +0000159
Vinay Sajip17c52d82004-07-03 11:48:34 +0000160class TimedRotatingFileHandler(BaseRotatingHandler):
161 """
162 Handler for logging to a file, rotating the log file at certain timed
163 intervals.
164
165 If backupCount is > 0, when rollover is done, no more than backupCount
166 files are kept - the oldest ones are deleted.
167 """
Vinay Sajipcbabd7e2009-10-10 20:32:36 +0000168 def __init__(self, filename, when='h', interval=1, backupCount=0, encoding=None, delay=False, utc=False):
Christian Heimese7a15bb2008-01-24 16:21:45 +0000169 BaseRotatingHandler.__init__(self, filename, 'a', encoding, delay)
Neal Norwitz9d72bb42007-04-17 08:48:32 +0000170 self.when = when.upper()
Vinay Sajip17c52d82004-07-03 11:48:34 +0000171 self.backupCount = backupCount
Benjamin Petersona37cfc62008-05-26 13:48:34 +0000172 self.utc = utc
Vinay Sajip17c52d82004-07-03 11:48:34 +0000173 # Calculate the real rollover interval, which is just the number of
174 # seconds between rollovers. Also set the filename suffix used when
175 # a rollover occurs. Current 'when' events supported:
176 # S - Seconds
177 # M - Minutes
178 # H - Hours
179 # D - Days
180 # midnight - roll over at midnight
181 # W{0-6} - roll over on a certain day; 0 - Monday
182 #
183 # Case of the 'when' specifier is not important; lower or upper case
184 # will work.
Vinay Sajip17c52d82004-07-03 11:48:34 +0000185 if self.when == 'S':
186 self.interval = 1 # one second
187 self.suffix = "%Y-%m-%d_%H-%M-%S"
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000188 self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}$"
Vinay Sajip17c52d82004-07-03 11:48:34 +0000189 elif self.when == 'M':
190 self.interval = 60 # one minute
191 self.suffix = "%Y-%m-%d_%H-%M"
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000192 self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}$"
Vinay Sajip17c52d82004-07-03 11:48:34 +0000193 elif self.when == 'H':
194 self.interval = 60 * 60 # one hour
195 self.suffix = "%Y-%m-%d_%H"
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000196 self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}$"
Vinay Sajip17c52d82004-07-03 11:48:34 +0000197 elif self.when == 'D' or self.when == 'MIDNIGHT':
198 self.interval = 60 * 60 * 24 # one day
199 self.suffix = "%Y-%m-%d"
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000200 self.extMatch = r"^\d{4}-\d{2}-\d{2}$"
Vinay Sajip17c52d82004-07-03 11:48:34 +0000201 elif self.when.startswith('W'):
202 self.interval = 60 * 60 * 24 * 7 # one week
203 if len(self.when) != 2:
204 raise ValueError("You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s" % self.when)
205 if self.when[1] < '0' or self.when[1] > '6':
206 raise ValueError("Invalid day specified for weekly rollover: %s" % self.when)
207 self.dayOfWeek = int(self.when[1])
208 self.suffix = "%Y-%m-%d"
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000209 self.extMatch = r"^\d{4}-\d{2}-\d{2}$"
Vinay Sajip17c52d82004-07-03 11:48:34 +0000210 else:
211 raise ValueError("Invalid rollover interval specified: %s" % self.when)
212
Antoine Pitroufd036452008-08-19 17:56:33 +0000213 self.extMatch = re.compile(self.extMatch, re.ASCII)
Vinay Sajipe7d40662004-10-03 19:12:07 +0000214 self.interval = self.interval * interval # multiply by units requested
Benjamin Peterson9451a1c2010-03-13 22:30:34 +0000215 if os.path.exists(filename):
216 t = os.stat(filename)[ST_MTIME]
217 else:
218 t = int(time.time())
219 self.rolloverAt = self.computeRollover(t)
Vinay Sajip17c52d82004-07-03 11:48:34 +0000220
Vinay Sajipaffbd872009-06-11 10:11:47 +0000221 def computeRollover(self, currentTime):
222 """
223 Work out the rollover time based on the specified time.
224 """
225 result = currentTime + self.interval
Vinay Sajip17c52d82004-07-03 11:48:34 +0000226 # If we are rolling over at midnight or weekly, then the interval is already known.
227 # What we need to figure out is WHEN the next interval is. In other words,
228 # if you are rolling over at midnight, then your base interval is 1 day,
229 # but you want to start that one day clock at midnight, not now. So, we
230 # have to fudge the rolloverAt value in order to trigger the first rollover
231 # at the right time. After that, the regular interval will take care of
232 # the rest. Note that this code doesn't care about leap seconds. :)
233 if self.when == 'MIDNIGHT' or self.when.startswith('W'):
234 # This could be done with less code, but I wanted it to be clear
Vinay Sajipaffbd872009-06-11 10:11:47 +0000235 if self.utc:
Benjamin Petersona37cfc62008-05-26 13:48:34 +0000236 t = time.gmtime(currentTime)
237 else:
238 t = time.localtime(currentTime)
Vinay Sajip17c52d82004-07-03 11:48:34 +0000239 currentHour = t[3]
240 currentMinute = t[4]
241 currentSecond = t[5]
242 # r is the number of seconds left between now and midnight
Thomas Wouters477c8d52006-05-27 19:21:47 +0000243 r = _MIDNIGHT - ((currentHour * 60 + currentMinute) * 60 +
244 currentSecond)
Vinay Sajipaffbd872009-06-11 10:11:47 +0000245 result = currentTime + r
Vinay Sajip17c52d82004-07-03 11:48:34 +0000246 # If we are rolling over on a certain day, add in the number of days until
247 # the next rollover, but offset by 1 since we just calculated the time
248 # until the next day starts. There are three cases:
249 # Case 1) The day to rollover is today; in this case, do nothing
250 # Case 2) The day to rollover is further in the interval (i.e., today is
251 # day 2 (Wednesday) and rollover is on day 6 (Sunday). Days to
252 # next rollover is simply 6 - 2 - 1, or 3.
253 # Case 3) The day to rollover is behind us in the interval (i.e., today
254 # is day 5 (Saturday) and rollover is on day 3 (Thursday).
255 # Days to rollover is 6 - 5 + 3, or 4. In this case, it's the
256 # number of days left in the current week (1) plus the number
257 # of days in the next week until the rollover day (3).
Georg Brandl86def6c2008-01-21 20:36:10 +0000258 # The calculations described in 2) and 3) above need to have a day added.
259 # This is because the above time calculation takes us to midnight on this
260 # day, i.e. the start of the next day.
Vinay Sajipaffbd872009-06-11 10:11:47 +0000261 if self.when.startswith('W'):
Vinay Sajip17c52d82004-07-03 11:48:34 +0000262 day = t[6] # 0 is Monday
Guido van Rossum8ce8a782007-11-01 19:42:39 +0000263 if day != self.dayOfWeek:
264 if day < self.dayOfWeek:
Georg Brandl86def6c2008-01-21 20:36:10 +0000265 daysToWait = self.dayOfWeek - day
Guido van Rossum8ce8a782007-11-01 19:42:39 +0000266 else:
Georg Brandl86def6c2008-01-21 20:36:10 +0000267 daysToWait = 6 - day + self.dayOfWeek + 1
Vinay Sajipaffbd872009-06-11 10:11:47 +0000268 newRolloverAt = result + (daysToWait * (60 * 60 * 24))
269 if not self.utc:
Benjamin Petersona37cfc62008-05-26 13:48:34 +0000270 dstNow = t[-1]
271 dstAtRollover = time.localtime(newRolloverAt)[-1]
272 if dstNow != dstAtRollover:
273 if not dstNow: # DST kicks in before next rollover, so we need to deduct an hour
274 newRolloverAt = newRolloverAt - 3600
275 else: # DST bows out before next rollover, so we need to add an hour
276 newRolloverAt = newRolloverAt + 3600
Vinay Sajipaffbd872009-06-11 10:11:47 +0000277 result = newRolloverAt
278 return result
Vinay Sajip17c52d82004-07-03 11:48:34 +0000279
280 def shouldRollover(self, record):
281 """
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000282 Determine if rollover should occur.
Vinay Sajip17c52d82004-07-03 11:48:34 +0000283
284 record is not used, as we are just comparing times, but it is needed so
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000285 the method signatures are the same
Vinay Sajip17c52d82004-07-03 11:48:34 +0000286 """
287 t = int(time.time())
288 if t >= self.rolloverAt:
289 return 1
Vinay Sajip17c52d82004-07-03 11:48:34 +0000290 return 0
291
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000292 def getFilesToDelete(self):
293 """
294 Determine the files to delete when rolling over.
295
296 More specific than the earlier method, which just used glob.glob().
297 """
298 dirName, baseName = os.path.split(self.baseFilename)
299 fileNames = os.listdir(dirName)
300 result = []
301 prefix = baseName + "."
302 plen = len(prefix)
303 for fileName in fileNames:
304 if fileName[:plen] == prefix:
305 suffix = fileName[plen:]
306 if self.extMatch.match(suffix):
Benjamin Petersona37cfc62008-05-26 13:48:34 +0000307 result.append(os.path.join(dirName, fileName))
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000308 result.sort()
309 if len(result) < self.backupCount:
310 result = []
311 else:
312 result = result[:len(result) - self.backupCount]
313 return result
314
Vinay Sajip17c52d82004-07-03 11:48:34 +0000315 def doRollover(self):
316 """
317 do a rollover; in this case, a date/time stamp is appended to the filename
318 when the rollover happens. However, you want the file to be named for the
319 start of the interval, not the current time. If there is a backup count,
320 then we have to get a list of matching filenames, sort them and remove
321 the one with the oldest suffix.
322 """
Vinay Sajip6268cbc2009-01-21 00:19:28 +0000323 if self.stream:
324 self.stream.close()
Vinay Sajip01241d62011-01-21 23:35:57 +0000325 self.stream = None
Vinay Sajip17c52d82004-07-03 11:48:34 +0000326 # get the time that this sequence started at and make it a TimeTuple
327 t = self.rolloverAt - self.interval
Benjamin Petersona37cfc62008-05-26 13:48:34 +0000328 if self.utc:
329 timeTuple = time.gmtime(t)
330 else:
331 timeTuple = time.localtime(t)
Vinay Sajip17c52d82004-07-03 11:48:34 +0000332 dfn = self.baseFilename + "." + time.strftime(self.suffix, timeTuple)
333 if os.path.exists(dfn):
334 os.remove(dfn)
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000335 os.rename(self.baseFilename, dfn)
Vinay Sajip17c52d82004-07-03 11:48:34 +0000336 if self.backupCount > 0:
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000337 for s in self.getFilesToDelete():
338 os.remove(s)
Thomas Woutersb2137042007-02-01 18:02:27 +0000339 self.mode = 'w'
340 self.stream = self._open()
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000341 currentTime = int(time.time())
Vinay Sajipaffbd872009-06-11 10:11:47 +0000342 newRolloverAt = self.computeRollover(currentTime)
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000343 while newRolloverAt <= currentTime:
344 newRolloverAt = newRolloverAt + self.interval
345 #If DST changes and midnight or weekly rollover, adjust for this.
Benjamin Petersona37cfc62008-05-26 13:48:34 +0000346 if (self.when == 'MIDNIGHT' or self.when.startswith('W')) and not self.utc:
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000347 dstNow = time.localtime(currentTime)[-1]
348 dstAtRollover = time.localtime(newRolloverAt)[-1]
349 if dstNow != dstAtRollover:
350 if not dstNow: # DST kicks in before next rollover, so we need to deduct an hour
351 newRolloverAt = newRolloverAt - 3600
352 else: # DST bows out before next rollover, so we need to add an hour
353 newRolloverAt = newRolloverAt + 3600
354 self.rolloverAt = newRolloverAt
Guido van Rossum57102f82002-11-13 16:15:58 +0000355
Thomas Woutersfc7bb8c2007-01-15 15:49:28 +0000356class WatchedFileHandler(logging.FileHandler):
357 """
358 A handler for logging to a file, which watches the file
359 to see if it has changed while in use. This can happen because of
360 usage of programs such as newsyslog and logrotate which perform
361 log file rotation. This handler, intended for use under Unix,
362 watches the file to see if it has changed since the last emit.
363 (A file has changed if its device or inode have changed.)
364 If it has changed, the old file stream is closed, and the file
365 opened to get a new stream.
366
367 This handler is not appropriate for use under Windows, because
368 under Windows open files cannot be moved or renamed - logging
369 opens the files with exclusive locks - and so there is no need
370 for such a handler. Furthermore, ST_INO is not supported under
371 Windows; stat always returns zero for this value.
372
373 This handler is based on a suggestion and patch by Chad J.
374 Schroeder.
375 """
Christian Heimese7a15bb2008-01-24 16:21:45 +0000376 def __init__(self, filename, mode='a', encoding=None, delay=0):
377 logging.FileHandler.__init__(self, filename, mode, encoding, delay)
378 if not os.path.exists(self.baseFilename):
379 self.dev, self.ino = -1, -1
380 else:
381 stat = os.stat(self.baseFilename)
382 self.dev, self.ino = stat[ST_DEV], stat[ST_INO]
Thomas Woutersfc7bb8c2007-01-15 15:49:28 +0000383
384 def emit(self, record):
385 """
386 Emit a record.
387
388 First check if the underlying file has changed, and if it
389 has, close the old stream and reopen the file to get the
390 current stream.
391 """
392 if not os.path.exists(self.baseFilename):
393 stat = None
Vinay Sajipde19e082011-04-30 21:52:26 +0100394 changed = True
Thomas Woutersfc7bb8c2007-01-15 15:49:28 +0000395 else:
396 stat = os.stat(self.baseFilename)
397 changed = (stat[ST_DEV] != self.dev) or (stat[ST_INO] != self.ino)
Christian Heimese7a15bb2008-01-24 16:21:45 +0000398 if changed and self.stream is not None:
Thomas Woutersfc7bb8c2007-01-15 15:49:28 +0000399 self.stream.flush()
400 self.stream.close()
401 self.stream = self._open()
402 if stat is None:
403 stat = os.stat(self.baseFilename)
404 self.dev, self.ino = stat[ST_DEV], stat[ST_INO]
405 logging.FileHandler.emit(self, record)
406
Guido van Rossum57102f82002-11-13 16:15:58 +0000407class SocketHandler(logging.Handler):
408 """
409 A handler class which writes logging records, in pickle format, to
410 a streaming socket. The socket is kept open across logging calls.
411 If the peer resets it, an attempt is made to reconnect on the next call.
Raymond Hettinger6f3eaa62003-06-27 21:43:39 +0000412 The pickle which is sent is that of the LogRecord's attribute dictionary
413 (__dict__), so that the receiver does not need to have the logging module
414 installed in order to process the logging event.
415
416 To unpickle the record at the receiving end into a LogRecord, use the
417 makeLogRecord function.
Guido van Rossum57102f82002-11-13 16:15:58 +0000418 """
419
420 def __init__(self, host, port):
421 """
422 Initializes the handler with a specific host address and port.
423
Vinay Sajipde19e082011-04-30 21:52:26 +0100424 When the attribute *closeOnError* is set to True - if a socket error
425 occurs, the socket is silently closed and then reopened on the next
426 logging call.
Guido van Rossum57102f82002-11-13 16:15:58 +0000427 """
428 logging.Handler.__init__(self)
429 self.host = host
430 self.port = port
431 self.sock = None
Vinay Sajipde19e082011-04-30 21:52:26 +0100432 self.closeOnError = False
Vinay Sajip48cfe382004-02-20 13:17:27 +0000433 self.retryTime = None
434 #
435 # Exponential backoff parameters.
436 #
437 self.retryStart = 1.0
438 self.retryMax = 30.0
439 self.retryFactor = 2.0
Guido van Rossum57102f82002-11-13 16:15:58 +0000440
Guido van Rossumd8faa362007-04-27 19:54:29 +0000441 def makeSocket(self, timeout=1):
Guido van Rossum57102f82002-11-13 16:15:58 +0000442 """
443 A factory method which allows subclasses to define the precise
444 type of socket they want.
445 """
446 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Guido van Rossumd8faa362007-04-27 19:54:29 +0000447 if hasattr(s, 'settimeout'):
448 s.settimeout(timeout)
Guido van Rossum57102f82002-11-13 16:15:58 +0000449 s.connect((self.host, self.port))
450 return s
451
Vinay Sajip48cfe382004-02-20 13:17:27 +0000452 def createSocket(self):
453 """
454 Try to create a socket, using an exponential backoff with
455 a max retry time. Thanks to Robert Olson for the original patch
456 (SF #815911) which has been slightly refactored.
457 """
458 now = time.time()
459 # Either retryTime is None, in which case this
460 # is the first time back after a disconnect, or
461 # we've waited long enough.
462 if self.retryTime is None:
Vinay Sajipde19e082011-04-30 21:52:26 +0100463 attempt = True
Vinay Sajip48cfe382004-02-20 13:17:27 +0000464 else:
Tim Peters4e0e1b62004-07-07 20:54:48 +0000465 attempt = (now >= self.retryTime)
Vinay Sajip48cfe382004-02-20 13:17:27 +0000466 if attempt:
467 try:
468 self.sock = self.makeSocket()
469 self.retryTime = None # next time, no delay before trying
Thomas Wouters902d6eb2007-01-09 23:18:33 +0000470 except socket.error:
Vinay Sajip48cfe382004-02-20 13:17:27 +0000471 #Creation failed, so set the retry time and return.
472 if self.retryTime is None:
473 self.retryPeriod = self.retryStart
474 else:
475 self.retryPeriod = self.retryPeriod * self.retryFactor
476 if self.retryPeriod > self.retryMax:
477 self.retryPeriod = self.retryMax
478 self.retryTime = now + self.retryPeriod
479
Guido van Rossum57102f82002-11-13 16:15:58 +0000480 def send(self, s):
481 """
482 Send a pickled string to the socket.
483
484 This function allows for partial sends which can happen when the
485 network is busy.
486 """
Vinay Sajip48cfe382004-02-20 13:17:27 +0000487 if self.sock is None:
488 self.createSocket()
489 #self.sock can be None either because we haven't reached the retry
490 #time yet, or because we have reached the retry time and retried,
491 #but are still unable to connect.
492 if self.sock:
493 try:
494 if hasattr(self.sock, "sendall"):
495 self.sock.sendall(s)
Vinay Sajip7fe1d512011-04-28 12:04:58 +0100496 else: #pragma: no cover
Vinay Sajip48cfe382004-02-20 13:17:27 +0000497 sentsofar = 0
498 left = len(s)
499 while left > 0:
500 sent = self.sock.send(s[sentsofar:])
501 sentsofar = sentsofar + sent
502 left = left - sent
Vinay Sajip7fe1d512011-04-28 12:04:58 +0100503 except socket.error: #pragma: no cover
Vinay Sajip48cfe382004-02-20 13:17:27 +0000504 self.sock.close()
505 self.sock = None # so we can call createSocket next time
Guido van Rossum57102f82002-11-13 16:15:58 +0000506
507 def makePickle(self, record):
508 """
509 Pickles the record in binary format with a length prefix, and
510 returns it ready for transmission across the socket.
511 """
Vinay Sajip48cfe382004-02-20 13:17:27 +0000512 ei = record.exc_info
513 if ei:
Tim Peters4e0e1b62004-07-07 20:54:48 +0000514 dummy = self.format(record) # just to get traceback text into record.exc_text
515 record.exc_info = None # to avoid Unpickleable error
Guido van Rossumba205d62006-08-17 08:57:26 +0000516 s = pickle.dumps(record.__dict__, 1)
Vinay Sajip48cfe382004-02-20 13:17:27 +0000517 if ei:
Tim Peters4e0e1b62004-07-07 20:54:48 +0000518 record.exc_info = ei # for next handler
Guido van Rossum57102f82002-11-13 16:15:58 +0000519 slen = struct.pack(">L", len(s))
520 return slen + s
521
Neal Norwitz6fa635d2003-02-18 14:20:07 +0000522 def handleError(self, record):
Guido van Rossum57102f82002-11-13 16:15:58 +0000523 """
524 Handle an error during logging.
525
526 An error has occurred during logging. Most likely cause -
527 connection lost. Close the socket so that we can retry on the
528 next event.
529 """
530 if self.closeOnError and self.sock:
531 self.sock.close()
532 self.sock = None #try to reconnect next time
533 else:
Neal Norwitz6fa635d2003-02-18 14:20:07 +0000534 logging.Handler.handleError(self, record)
Guido van Rossum57102f82002-11-13 16:15:58 +0000535
536 def emit(self, record):
537 """
538 Emit a record.
539
540 Pickles the record and writes it to the socket in binary format.
541 If there is an error with the socket, silently drop the packet.
542 If there was a problem with the socket, re-establishes the
543 socket.
544 """
545 try:
546 s = self.makePickle(record)
Guido van Rossum57102f82002-11-13 16:15:58 +0000547 self.send(s)
Vinay Sajip985ef872011-04-26 19:34:04 +0100548 except (KeyboardInterrupt, SystemExit): #pragma: no cover
Vinay Sajip85c19092005-10-31 13:14:19 +0000549 raise
Guido van Rossum57102f82002-11-13 16:15:58 +0000550 except:
Neal Norwitz6fa635d2003-02-18 14:20:07 +0000551 self.handleError(record)
Guido van Rossum57102f82002-11-13 16:15:58 +0000552
553 def close(self):
554 """
555 Closes the socket.
556 """
557 if self.sock:
558 self.sock.close()
559 self.sock = None
Vinay Sajip48cfe382004-02-20 13:17:27 +0000560 logging.Handler.close(self)
Guido van Rossum57102f82002-11-13 16:15:58 +0000561
562class DatagramHandler(SocketHandler):
563 """
564 A handler class which writes logging records, in pickle format, to
Raymond Hettinger6f3eaa62003-06-27 21:43:39 +0000565 a datagram socket. The pickle which is sent is that of the LogRecord's
566 attribute dictionary (__dict__), so that the receiver does not need to
567 have the logging module installed in order to process the logging event.
568
569 To unpickle the record at the receiving end into a LogRecord, use the
570 makeLogRecord function.
Guido van Rossum57102f82002-11-13 16:15:58 +0000571
572 """
573 def __init__(self, host, port):
574 """
575 Initializes the handler with a specific host address and port.
576 """
577 SocketHandler.__init__(self, host, port)
Vinay Sajipde19e082011-04-30 21:52:26 +0100578 self.closeOnError = False
Guido van Rossum57102f82002-11-13 16:15:58 +0000579
580 def makeSocket(self):
581 """
582 The factory method of SocketHandler is here overridden to create
583 a UDP socket (SOCK_DGRAM).
584 """
585 s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
586 return s
587
588 def send(self, s):
589 """
590 Send a pickled string to a socket.
591
592 This function no longer allows for partial sends which can happen
593 when the network is busy - UDP does not guarantee delivery and
594 can deliver packets out of sequence.
595 """
Vinay Sajipfb154172004-08-24 09:36:23 +0000596 if self.sock is None:
597 self.createSocket()
Guido van Rossum57102f82002-11-13 16:15:58 +0000598 self.sock.sendto(s, (self.host, self.port))
599
600class SysLogHandler(logging.Handler):
601 """
602 A handler class which sends formatted logging records to a syslog
603 server. Based on Sam Rushing's syslog module:
604 http://www.nightmare.com/squirl/python-ext/misc/syslog.py
605 Contributed by Nicolas Untz (after which minor refactoring changes
606 have been made).
607 """
608
609 # from <linux/sys/syslog.h>:
610 # ======================================================================
611 # priorities/facilities are encoded into a single 32-bit quantity, where
612 # the bottom 3 bits are the priority (0-7) and the top 28 bits are the
613 # facility (0-big number). Both the priorities and the facilities map
614 # roughly one-to-one to strings in the syslogd(8) source code. This
615 # mapping is included in this file.
616 #
617 # priorities (these are ordered)
618
619 LOG_EMERG = 0 # system is unusable
620 LOG_ALERT = 1 # action must be taken immediately
621 LOG_CRIT = 2 # critical conditions
622 LOG_ERR = 3 # error conditions
623 LOG_WARNING = 4 # warning conditions
624 LOG_NOTICE = 5 # normal but significant condition
625 LOG_INFO = 6 # informational
626 LOG_DEBUG = 7 # debug-level messages
627
628 # facility codes
629 LOG_KERN = 0 # kernel messages
630 LOG_USER = 1 # random user-level messages
631 LOG_MAIL = 2 # mail system
632 LOG_DAEMON = 3 # system daemons
633 LOG_AUTH = 4 # security/authorization messages
634 LOG_SYSLOG = 5 # messages generated internally by syslogd
635 LOG_LPR = 6 # line printer subsystem
636 LOG_NEWS = 7 # network news subsystem
637 LOG_UUCP = 8 # UUCP subsystem
638 LOG_CRON = 9 # clock daemon
Benjamin Peterson22005fc2010-04-11 16:25:06 +0000639 LOG_AUTHPRIV = 10 # security/authorization messages (private)
640 LOG_FTP = 11 # FTP daemon
Guido van Rossum57102f82002-11-13 16:15:58 +0000641
642 # other codes through 15 reserved for system use
643 LOG_LOCAL0 = 16 # reserved for local use
644 LOG_LOCAL1 = 17 # reserved for local use
645 LOG_LOCAL2 = 18 # reserved for local use
646 LOG_LOCAL3 = 19 # reserved for local use
647 LOG_LOCAL4 = 20 # reserved for local use
648 LOG_LOCAL5 = 21 # reserved for local use
649 LOG_LOCAL6 = 22 # reserved for local use
650 LOG_LOCAL7 = 23 # reserved for local use
651
652 priority_names = {
653 "alert": LOG_ALERT,
654 "crit": LOG_CRIT,
655 "critical": LOG_CRIT,
656 "debug": LOG_DEBUG,
657 "emerg": LOG_EMERG,
658 "err": LOG_ERR,
659 "error": LOG_ERR, # DEPRECATED
660 "info": LOG_INFO,
661 "notice": LOG_NOTICE,
662 "panic": LOG_EMERG, # DEPRECATED
663 "warn": LOG_WARNING, # DEPRECATED
664 "warning": LOG_WARNING,
665 }
666
667 facility_names = {
668 "auth": LOG_AUTH,
669 "authpriv": LOG_AUTHPRIV,
670 "cron": LOG_CRON,
671 "daemon": LOG_DAEMON,
Benjamin Peterson22005fc2010-04-11 16:25:06 +0000672 "ftp": LOG_FTP,
Guido van Rossum57102f82002-11-13 16:15:58 +0000673 "kern": LOG_KERN,
674 "lpr": LOG_LPR,
675 "mail": LOG_MAIL,
676 "news": LOG_NEWS,
677 "security": LOG_AUTH, # DEPRECATED
678 "syslog": LOG_SYSLOG,
679 "user": LOG_USER,
680 "uucp": LOG_UUCP,
681 "local0": LOG_LOCAL0,
682 "local1": LOG_LOCAL1,
683 "local2": LOG_LOCAL2,
684 "local3": LOG_LOCAL3,
685 "local4": LOG_LOCAL4,
686 "local5": LOG_LOCAL5,
687 "local6": LOG_LOCAL6,
688 "local7": LOG_LOCAL7,
689 }
690
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000691 #The map below appears to be trivially lowercasing the key. However,
692 #there's more to it than meets the eye - in some locales, lowercasing
693 #gives unexpected results. See SF #1524081: in the Turkish locale,
694 #"INFO".lower() != "info"
695 priority_map = {
696 "DEBUG" : "debug",
697 "INFO" : "info",
698 "WARNING" : "warning",
699 "ERROR" : "error",
700 "CRITICAL" : "critical"
701 }
702
Vinay Sajipcbabd7e2009-10-10 20:32:36 +0000703 def __init__(self, address=('localhost', SYSLOG_UDP_PORT),
704 facility=LOG_USER, socktype=socket.SOCK_DGRAM):
Guido van Rossum57102f82002-11-13 16:15:58 +0000705 """
706 Initialize a handler.
707
Guido van Rossume7ba4952007-06-06 23:52:48 +0000708 If address is specified as a string, a UNIX socket is used. To log to a
709 local syslogd, "SysLogHandler(address="/dev/log")" can be used.
Guido van Rossum57102f82002-11-13 16:15:58 +0000710 If facility is not specified, LOG_USER is used.
711 """
712 logging.Handler.__init__(self)
713
714 self.address = address
715 self.facility = facility
Vinay Sajipcbabd7e2009-10-10 20:32:36 +0000716 self.socktype = socktype
717
Guido van Rossum13257902007-06-07 23:15:56 +0000718 if isinstance(address, str):
Vinay Sajip5a35b062011-04-27 11:31:14 +0100719 self.unixsocket = True
Thomas Wouters89f507f2006-12-13 04:49:30 +0000720 self._connect_unixsocket(address)
Guido van Rossum57102f82002-11-13 16:15:58 +0000721 else:
Vinay Sajip5a35b062011-04-27 11:31:14 +0100722 self.unixsocket = False
Vinay Sajipcbabd7e2009-10-10 20:32:36 +0000723 self.socket = socket.socket(socket.AF_INET, socktype)
724 if socktype == socket.SOCK_STREAM:
725 self.socket.connect(address)
Guido van Rossum57102f82002-11-13 16:15:58 +0000726 self.formatter = None
727
Vinay Sajipa1974c12005-01-13 08:23:56 +0000728 def _connect_unixsocket(self, address):
729 self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
730 # syslog may require either DGRAM or STREAM sockets
731 try:
732 self.socket.connect(address)
733 except socket.error:
734 self.socket.close()
735 self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
Vinay Sajip8b6b53f2005-11-09 13:55:13 +0000736 self.socket.connect(address)
Vinay Sajipa1974c12005-01-13 08:23:56 +0000737
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000738 def encodePriority(self, facility, priority):
Guido van Rossum57102f82002-11-13 16:15:58 +0000739 """
740 Encode the facility and priority. You can pass in strings or
741 integers - if strings are passed, the facility_names and
742 priority_names mapping dictionaries are used to convert them to
743 integers.
744 """
Guido van Rossum13257902007-06-07 23:15:56 +0000745 if isinstance(facility, str):
Guido van Rossum57102f82002-11-13 16:15:58 +0000746 facility = self.facility_names[facility]
Guido van Rossum13257902007-06-07 23:15:56 +0000747 if isinstance(priority, str):
Guido van Rossum57102f82002-11-13 16:15:58 +0000748 priority = self.priority_names[priority]
749 return (facility << 3) | priority
750
751 def close (self):
752 """
753 Closes the socket.
754 """
755 if self.unixsocket:
756 self.socket.close()
Vinay Sajip48cfe382004-02-20 13:17:27 +0000757 logging.Handler.close(self)
Guido van Rossum57102f82002-11-13 16:15:58 +0000758
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000759 def mapPriority(self, levelName):
760 """
761 Map a logging level name to a key in the priority_names map.
762 This is useful in two scenarios: when custom levels are being
763 used, and in the case where you can't do a straightforward
764 mapping by lowercasing the logging level name because of locale-
765 specific issues (see SF #1524081).
766 """
767 return self.priority_map.get(levelName, "warning")
768
Guido van Rossum57102f82002-11-13 16:15:58 +0000769 def emit(self, record):
770 """
771 Emit a record.
772
773 The record is formatted, and then sent to the syslog server. If
774 exception information is present, it is NOT sent to the server.
775 """
Vinay Sajip89d8f822010-08-20 08:43:22 +0000776 msg = self.format(record) + '\000'
Guido van Rossum57102f82002-11-13 16:15:58 +0000777 """
778 We need to convert record level to lowercase, maybe this will
779 change in the future.
780 """
Vinay Sajip467d12f2010-08-19 22:20:22 +0000781 prio = '<%d>' % self.encodePriority(self.facility,
782 self.mapPriority(record.levelname))
783 prio = prio.encode('utf-8')
Vinay Sajip609364a2010-08-30 18:31:13 +0000784 # Message is a string. Convert to bytes as required by RFC 5424
Vinay Sajip42ead482009-10-21 20:22:14 +0000785 msg = msg.encode('utf-8')
786 if codecs:
787 msg = codecs.BOM_UTF8 + msg
Vinay Sajip467d12f2010-08-19 22:20:22 +0000788 msg = prio + msg
Guido van Rossum57102f82002-11-13 16:15:58 +0000789 try:
790 if self.unixsocket:
Vinay Sajipa1974c12005-01-13 08:23:56 +0000791 try:
792 self.socket.send(msg)
793 except socket.error:
794 self._connect_unixsocket(self.address)
795 self.socket.send(msg)
Vinay Sajipcbabd7e2009-10-10 20:32:36 +0000796 elif self.socktype == socket.SOCK_DGRAM:
Guido van Rossum57102f82002-11-13 16:15:58 +0000797 self.socket.sendto(msg, self.address)
Vinay Sajipcbabd7e2009-10-10 20:32:36 +0000798 else:
799 self.socket.sendall(msg)
Vinay Sajip985ef872011-04-26 19:34:04 +0100800 except (KeyboardInterrupt, SystemExit): #pragma: no cover
Vinay Sajip85c19092005-10-31 13:14:19 +0000801 raise
Guido van Rossum57102f82002-11-13 16:15:58 +0000802 except:
Neal Norwitz6fa635d2003-02-18 14:20:07 +0000803 self.handleError(record)
Guido van Rossum57102f82002-11-13 16:15:58 +0000804
805class SMTPHandler(logging.Handler):
806 """
807 A handler class which sends an SMTP email for each logging event.
808 """
Vinay Sajip540f2152009-12-06 17:57:11 +0000809 def __init__(self, mailhost, fromaddr, toaddrs, subject,
Vinay Sajip25fcd222009-12-06 18:05:04 +0000810 credentials=None, secure=None):
Guido van Rossum57102f82002-11-13 16:15:58 +0000811 """
812 Initialize the handler.
813
814 Initialize the instance with the from and to addresses and subject
815 line of the email. To specify a non-standard SMTP port, use the
Guido van Rossum360e4b82007-05-14 22:51:27 +0000816 (host, port) tuple format for the mailhost argument. To specify
817 authentication credentials, supply a (username, password) tuple
Vinay Sajip25fcd222009-12-06 18:05:04 +0000818 for the credentials argument. To specify the use of a secure
819 protocol (TLS), pass in a tuple for the secure argument. This will
820 only be used when authentication credentials are supplied. The tuple
821 will be either an empty tuple, or a single-value tuple with the name
822 of a keyfile, or a 2-value tuple with the names of the keyfile and
823 certificate file. (This tuple is passed to the `starttls` method).
Guido van Rossum57102f82002-11-13 16:15:58 +0000824 """
825 logging.Handler.__init__(self)
Guido van Rossum13257902007-06-07 23:15:56 +0000826 if isinstance(mailhost, tuple):
Guido van Rossum360e4b82007-05-14 22:51:27 +0000827 self.mailhost, self.mailport = mailhost
Guido van Rossum57102f82002-11-13 16:15:58 +0000828 else:
Guido van Rossum360e4b82007-05-14 22:51:27 +0000829 self.mailhost, self.mailport = mailhost, None
Guido van Rossum13257902007-06-07 23:15:56 +0000830 if isinstance(credentials, tuple):
Guido van Rossum360e4b82007-05-14 22:51:27 +0000831 self.username, self.password = credentials
832 else:
833 self.username = None
Guido van Rossum57102f82002-11-13 16:15:58 +0000834 self.fromaddr = fromaddr
Guido van Rossum13257902007-06-07 23:15:56 +0000835 if isinstance(toaddrs, str):
Neal Norwitz6fa635d2003-02-18 14:20:07 +0000836 toaddrs = [toaddrs]
Guido van Rossum57102f82002-11-13 16:15:58 +0000837 self.toaddrs = toaddrs
838 self.subject = subject
Vinay Sajip540f2152009-12-06 17:57:11 +0000839 self.secure = secure
Guido van Rossum57102f82002-11-13 16:15:58 +0000840
841 def getSubject(self, record):
842 """
843 Determine the subject for the email.
844
845 If you want to specify a subject line which is record-dependent,
846 override this method.
847 """
848 return self.subject
849
850 def emit(self, record):
851 """
852 Emit a record.
853
854 Format the record and send it to the specified addressees.
855 """
856 try:
857 import smtplib
Vinay Sajipdb81c4c2010-02-25 23:13:06 +0000858 from email.utils import formatdate
Guido van Rossum57102f82002-11-13 16:15:58 +0000859 port = self.mailport
860 if not port:
861 port = smtplib.SMTP_PORT
862 smtp = smtplib.SMTP(self.mailhost, port)
863 msg = self.format(record)
Neal Norwitzf297bd12003-04-23 03:49:43 +0000864 msg = "From: %s\r\nTo: %s\r\nSubject: %s\r\nDate: %s\r\n\r\n%s" % (
Guido van Rossum57102f82002-11-13 16:15:58 +0000865 self.fromaddr,
Neal Norwitz9d72bb42007-04-17 08:48:32 +0000866 ",".join(self.toaddrs),
Neal Norwitzf297bd12003-04-23 03:49:43 +0000867 self.getSubject(record),
Martin v. Löwis318a12e2004-08-18 12:27:40 +0000868 formatdate(), msg)
Guido van Rossum360e4b82007-05-14 22:51:27 +0000869 if self.username:
Vinay Sajip25fcd222009-12-06 18:05:04 +0000870 if self.secure is not None:
Vinay Sajip540f2152009-12-06 17:57:11 +0000871 smtp.ehlo()
Vinay Sajip25fcd222009-12-06 18:05:04 +0000872 smtp.starttls(*self.secure)
Vinay Sajip540f2152009-12-06 17:57:11 +0000873 smtp.ehlo()
Guido van Rossum360e4b82007-05-14 22:51:27 +0000874 smtp.login(self.username, self.password)
Guido van Rossum57102f82002-11-13 16:15:58 +0000875 smtp.sendmail(self.fromaddr, self.toaddrs, msg)
876 smtp.quit()
Vinay Sajip985ef872011-04-26 19:34:04 +0100877 except (KeyboardInterrupt, SystemExit): #pragma: no cover
Vinay Sajip245a5ab2005-10-31 14:27:01 +0000878 raise
Guido van Rossum57102f82002-11-13 16:15:58 +0000879 except:
Neal Norwitz6fa635d2003-02-18 14:20:07 +0000880 self.handleError(record)
Guido van Rossum57102f82002-11-13 16:15:58 +0000881
882class NTEventLogHandler(logging.Handler):
883 """
884 A handler class which sends events to the NT Event Log. Adds a
885 registry entry for the specified application name. If no dllname is
886 provided, win32service.pyd (which contains some basic message
887 placeholders) is used. Note that use of these placeholders will make
888 your event logs big, as the entire message source is held in the log.
889 If you want slimmer logs, you have to pass in the name of your own DLL
890 which contains the message definitions you want to use in the event log.
891 """
892 def __init__(self, appname, dllname=None, logtype="Application"):
893 logging.Handler.__init__(self)
894 try:
895 import win32evtlogutil, win32evtlog
896 self.appname = appname
897 self._welu = win32evtlogutil
898 if not dllname:
899 dllname = os.path.split(self._welu.__file__)
900 dllname = os.path.split(dllname[0])
901 dllname = os.path.join(dllname[0], r'win32service.pyd')
902 self.dllname = dllname
903 self.logtype = logtype
904 self._welu.AddSourceToRegistry(appname, dllname, logtype)
905 self.deftype = win32evtlog.EVENTLOG_ERROR_TYPE
906 self.typemap = {
907 logging.DEBUG : win32evtlog.EVENTLOG_INFORMATION_TYPE,
908 logging.INFO : win32evtlog.EVENTLOG_INFORMATION_TYPE,
Neal Norwitz6fa635d2003-02-18 14:20:07 +0000909 logging.WARNING : win32evtlog.EVENTLOG_WARNING_TYPE,
Guido van Rossum57102f82002-11-13 16:15:58 +0000910 logging.ERROR : win32evtlog.EVENTLOG_ERROR_TYPE,
911 logging.CRITICAL: win32evtlog.EVENTLOG_ERROR_TYPE,
912 }
913 except ImportError:
Guido van Rossumbe19ed72007-02-09 05:37:30 +0000914 print("The Python Win32 extensions for NT (service, event "\
915 "logging) appear not to be available.")
Guido van Rossum57102f82002-11-13 16:15:58 +0000916 self._welu = None
917
918 def getMessageID(self, record):
919 """
920 Return the message ID for the event record. If you are using your
921 own messages, you could do this by having the msg passed to the
922 logger being an ID rather than a formatting string. Then, in here,
923 you could use a dictionary lookup to get the message ID. This
924 version returns 1, which is the base message ID in win32service.pyd.
925 """
926 return 1
927
928 def getEventCategory(self, record):
929 """
930 Return the event category for the record.
931
932 Override this if you want to specify your own categories. This version
933 returns 0.
934 """
935 return 0
936
937 def getEventType(self, record):
938 """
939 Return the event type for the record.
940
941 Override this if you want to specify your own types. This version does
942 a mapping using the handler's typemap attribute, which is set up in
943 __init__() to a dictionary which contains mappings for DEBUG, INFO,
Neal Norwitz6fa635d2003-02-18 14:20:07 +0000944 WARNING, ERROR and CRITICAL. If you are using your own levels you will
Guido van Rossum57102f82002-11-13 16:15:58 +0000945 either need to override this method or place a suitable dictionary in
946 the handler's typemap attribute.
947 """
948 return self.typemap.get(record.levelno, self.deftype)
949
950 def emit(self, record):
951 """
952 Emit a record.
953
954 Determine the message ID, event category and event type. Then
955 log the message in the NT event log.
956 """
957 if self._welu:
958 try:
959 id = self.getMessageID(record)
960 cat = self.getEventCategory(record)
961 type = self.getEventType(record)
962 msg = self.format(record)
963 self._welu.ReportEvent(self.appname, id, cat, type, [msg])
Vinay Sajip985ef872011-04-26 19:34:04 +0100964 except (KeyboardInterrupt, SystemExit): #pragma: no cover
Vinay Sajip245a5ab2005-10-31 14:27:01 +0000965 raise
Guido van Rossum57102f82002-11-13 16:15:58 +0000966 except:
Neal Norwitz6fa635d2003-02-18 14:20:07 +0000967 self.handleError(record)
Guido van Rossum57102f82002-11-13 16:15:58 +0000968
969 def close(self):
970 """
971 Clean up this handler.
972
973 You can remove the application name from the registry as a
974 source of event log entries. However, if you do this, you will
975 not be able to see the events as you intended in the Event Log
976 Viewer - it needs to be able to access the registry to get the
977 DLL name.
978 """
979 #self._welu.RemoveSourceFromRegistry(self.appname, self.logtype)
Vinay Sajip48cfe382004-02-20 13:17:27 +0000980 logging.Handler.close(self)
Guido van Rossum57102f82002-11-13 16:15:58 +0000981
982class HTTPHandler(logging.Handler):
983 """
984 A class which sends records to a Web server, using either GET or
985 POST semantics.
986 """
Vinay Sajipaf9d10a2010-09-13 20:40:30 +0000987 def __init__(self, host, url, method="GET", secure=False, credentials=None):
Guido van Rossum57102f82002-11-13 16:15:58 +0000988 """
989 Initialize the instance with the host, the request URL, and the method
990 ("GET" or "POST")
991 """
992 logging.Handler.__init__(self)
Neal Norwitz9d72bb42007-04-17 08:48:32 +0000993 method = method.upper()
Guido van Rossum57102f82002-11-13 16:15:58 +0000994 if method not in ["GET", "POST"]:
Collin Winterce36ad82007-08-30 01:19:48 +0000995 raise ValueError("method must be GET or POST")
Guido van Rossum57102f82002-11-13 16:15:58 +0000996 self.host = host
997 self.url = url
998 self.method = method
Vinay Sajipaf9d10a2010-09-13 20:40:30 +0000999 self.secure = secure
1000 self.credentials = credentials
Guido van Rossum57102f82002-11-13 16:15:58 +00001001
Neal Norwitzf297bd12003-04-23 03:49:43 +00001002 def mapLogRecord(self, record):
1003 """
1004 Default implementation of mapping the log record into a dict
Vinay Sajip48cfe382004-02-20 13:17:27 +00001005 that is sent as the CGI data. Overwrite in your class.
Vinay Sajipaf9d10a2010-09-13 20:40:30 +00001006 Contributed by Franz Glasner.
Neal Norwitzf297bd12003-04-23 03:49:43 +00001007 """
1008 return record.__dict__
1009
Guido van Rossum57102f82002-11-13 16:15:58 +00001010 def emit(self, record):
1011 """
1012 Emit a record.
1013
Senthil Kumaran30e86a42010-08-09 20:01:35 +00001014 Send the record to the Web server as a percent-encoded dictionary
Guido van Rossum57102f82002-11-13 16:15:58 +00001015 """
1016 try:
Georg Brandl029986a2008-06-23 11:44:14 +00001017 import http.client, urllib.parse
Vinay Sajipb7935062005-10-11 13:15:31 +00001018 host = self.host
Vinay Sajipaf9d10a2010-09-13 20:40:30 +00001019 if self.secure:
1020 h = http.client.HTTPSConnection(host)
1021 else:
1022 h = http.client.HTTPConnection(host)
Guido van Rossum57102f82002-11-13 16:15:58 +00001023 url = self.url
Georg Brandl029986a2008-06-23 11:44:14 +00001024 data = urllib.parse.urlencode(self.mapLogRecord(record))
Guido van Rossum57102f82002-11-13 16:15:58 +00001025 if self.method == "GET":
Neal Norwitz9d72bb42007-04-17 08:48:32 +00001026 if (url.find('?') >= 0):
Guido van Rossum57102f82002-11-13 16:15:58 +00001027 sep = '&'
1028 else:
1029 sep = '?'
1030 url = url + "%c%s" % (sep, data)
1031 h.putrequest(self.method, url)
Vinay Sajipb7935062005-10-11 13:15:31 +00001032 # support multiple hosts on one IP address...
1033 # need to strip optional :port from host, if present
Neal Norwitz9d72bb42007-04-17 08:48:32 +00001034 i = host.find(":")
Vinay Sajipb7935062005-10-11 13:15:31 +00001035 if i >= 0:
1036 host = host[:i]
1037 h.putheader("Host", host)
Guido van Rossum57102f82002-11-13 16:15:58 +00001038 if self.method == "POST":
Vinay Sajipb7935062005-10-11 13:15:31 +00001039 h.putheader("Content-type",
1040 "application/x-www-form-urlencoded")
Guido van Rossum57102f82002-11-13 16:15:58 +00001041 h.putheader("Content-length", str(len(data)))
Vinay Sajipaf9d10a2010-09-13 20:40:30 +00001042 if self.credentials:
1043 import base64
1044 s = ('u%s:%s' % self.credentials).encode('utf-8')
1045 s = 'Basic ' + base64.b64encode(s).strip()
1046 h.putheader('Authorization', s)
Vinay Sajip0372e102011-05-05 12:59:14 +01001047 h.endheaders()
1048 if self.method == "POST":
1049 h.send(data.encode('utf-8'))
Vinay Sajipaf9d10a2010-09-13 20:40:30 +00001050 h.getresponse() #can't do anything with the result
Vinay Sajip985ef872011-04-26 19:34:04 +01001051 except (KeyboardInterrupt, SystemExit): #pragma: no cover
Vinay Sajip245a5ab2005-10-31 14:27:01 +00001052 raise
Guido van Rossum57102f82002-11-13 16:15:58 +00001053 except:
Neal Norwitz6fa635d2003-02-18 14:20:07 +00001054 self.handleError(record)
Guido van Rossum57102f82002-11-13 16:15:58 +00001055
1056class BufferingHandler(logging.Handler):
1057 """
1058 A handler class which buffers logging records in memory. Whenever each
1059 record is added to the buffer, a check is made to see if the buffer should
1060 be flushed. If it should, then flush() is expected to do what's needed.
1061 """
1062 def __init__(self, capacity):
1063 """
1064 Initialize the handler with the buffer size.
1065 """
1066 logging.Handler.__init__(self)
1067 self.capacity = capacity
1068 self.buffer = []
1069
1070 def shouldFlush(self, record):
1071 """
1072 Should the handler flush its buffer?
1073
1074 Returns true if the buffer is up to capacity. This method can be
1075 overridden to implement custom flushing strategies.
1076 """
1077 return (len(self.buffer) >= self.capacity)
1078
1079 def emit(self, record):
1080 """
1081 Emit a record.
1082
1083 Append the record. If shouldFlush() tells us to, call flush() to process
1084 the buffer.
1085 """
1086 self.buffer.append(record)
1087 if self.shouldFlush(record):
1088 self.flush()
1089
1090 def flush(self):
1091 """
1092 Override to implement custom flushing behaviour.
1093
1094 This version just zaps the buffer to empty.
1095 """
1096 self.buffer = []
1097
Vinay Sajipf42d95e2004-02-21 22:14:34 +00001098 def close(self):
1099 """
1100 Close the handler.
1101
1102 This version just flushes and chains to the parent class' close().
1103 """
1104 self.flush()
1105 logging.Handler.close(self)
1106
Guido van Rossum57102f82002-11-13 16:15:58 +00001107class MemoryHandler(BufferingHandler):
1108 """
1109 A handler class which buffers logging records in memory, periodically
1110 flushing them to a target handler. Flushing occurs whenever the buffer
1111 is full, or when an event of a certain severity or greater is seen.
1112 """
1113 def __init__(self, capacity, flushLevel=logging.ERROR, target=None):
1114 """
1115 Initialize the handler with the buffer size, the level at which
1116 flushing should occur and an optional target.
1117
1118 Note that without a target being set either here or via setTarget(),
1119 a MemoryHandler is no use to anyone!
1120 """
1121 BufferingHandler.__init__(self, capacity)
1122 self.flushLevel = flushLevel
1123 self.target = target
1124
1125 def shouldFlush(self, record):
1126 """
1127 Check for buffer full or a record at the flushLevel or higher.
1128 """
1129 return (len(self.buffer) >= self.capacity) or \
1130 (record.levelno >= self.flushLevel)
1131
1132 def setTarget(self, target):
1133 """
1134 Set the target handler for this handler.
1135 """
1136 self.target = target
1137
1138 def flush(self):
1139 """
1140 For a MemoryHandler, flushing means just sending the buffered
1141 records to the target, if there is one. Override if you want
1142 different behaviour.
Vinay Sajipc84f0162010-09-21 11:25:39 +00001143
1144 The record buffer is also cleared by this operation.
Guido van Rossum57102f82002-11-13 16:15:58 +00001145 """
1146 if self.target:
1147 for record in self.buffer:
1148 self.target.handle(record)
1149 self.buffer = []
1150
1151 def close(self):
1152 """
1153 Flush, set the target to None and lose the buffer.
1154 """
1155 self.flush()
1156 self.target = None
Vinay Sajip48cfe382004-02-20 13:17:27 +00001157 BufferingHandler.close(self)
Vinay Sajip121a1c42010-09-08 10:46:15 +00001158
1159
1160class QueueHandler(logging.Handler):
1161 """
1162 This handler sends events to a queue. Typically, it would be used together
1163 with a multiprocessing Queue to centralise logging to file in one process
1164 (in a multi-process application), so as to avoid file write contention
1165 between processes.
1166
1167 This code is new in Python 3.2, but this class can be copy pasted into
1168 user code for use with earlier Python versions.
1169 """
1170
1171 def __init__(self, queue):
1172 """
1173 Initialise an instance, using the passed queue.
1174 """
1175 logging.Handler.__init__(self)
1176 self.queue = queue
1177
1178 def enqueue(self, record):
1179 """
1180 Enqueue a record.
1181
1182 The base implementation uses put_nowait. You may want to override
1183 this method if you want to use blocking, timeouts or custom queue
1184 implementations.
1185 """
1186 self.queue.put_nowait(record)
1187
Vinay Sajip0258ce82010-09-22 20:34:53 +00001188 def prepare(self, record):
1189 """
Vinay Sajip0637d492010-09-23 08:15:54 +00001190 Prepares a record for queuing. The object returned by this method is
1191 enqueued.
Vinay Sajip0258ce82010-09-22 20:34:53 +00001192
1193 The base implementation formats the record to merge the message
1194 and arguments, and removes unpickleable items from the record
1195 in-place.
1196
1197 You might want to override this method if you want to convert
1198 the record to a dict or JSON string, or send a modified copy
1199 of the record while leaving the original intact.
1200 """
1201 # The format operation gets traceback text into record.exc_text
1202 # (if there's exception data), and also puts the message into
1203 # record.message. We can then use this to replace the original
1204 # msg + args, as these might be unpickleable. We also zap the
1205 # exc_info attribute, as it's no longer needed and, if not None,
1206 # will typically not be pickleable.
1207 self.format(record)
1208 record.msg = record.message
1209 record.args = None
1210 record.exc_info = None
1211 return record
1212
Vinay Sajip121a1c42010-09-08 10:46:15 +00001213 def emit(self, record):
1214 """
1215 Emit a record.
1216
Vinay Sajip0637d492010-09-23 08:15:54 +00001217 Writes the LogRecord to the queue, preparing it for pickling first.
Vinay Sajip121a1c42010-09-08 10:46:15 +00001218 """
1219 try:
Vinay Sajip0258ce82010-09-22 20:34:53 +00001220 self.enqueue(self.prepare(record))
Vinay Sajip985ef872011-04-26 19:34:04 +01001221 except (KeyboardInterrupt, SystemExit): #pragma: no cover
Vinay Sajip121a1c42010-09-08 10:46:15 +00001222 raise
1223 except:
1224 self.handleError(record)
Vinay Sajip0637d492010-09-23 08:15:54 +00001225
Victor Stinnercafa2ef2011-05-02 16:11:28 +02001226if threading:
1227 class QueueListener(object):
1228 """
1229 This class implements an internal threaded listener which watches for
1230 LogRecords being added to a queue, removes them and passes them to a
1231 list of handlers for processing.
1232 """
1233 _sentinel = None
Vinay Sajip0637d492010-09-23 08:15:54 +00001234
Victor Stinnercafa2ef2011-05-02 16:11:28 +02001235 def __init__(self, queue, *handlers):
1236 """
1237 Initialise an instance with the specified queue and
1238 handlers.
1239 """
1240 self.queue = queue
1241 self.handlers = handlers
1242 self._stop = threading.Event()
1243 self._thread = None
Vinay Sajip0637d492010-09-23 08:15:54 +00001244
Victor Stinnercafa2ef2011-05-02 16:11:28 +02001245 def dequeue(self, block):
1246 """
1247 Dequeue a record and return it, optionally blocking.
Vinay Sajip0637d492010-09-23 08:15:54 +00001248
Victor Stinnercafa2ef2011-05-02 16:11:28 +02001249 The base implementation uses get. You may want to override this method
1250 if you want to use timeouts or work with custom queue implementations.
1251 """
1252 return self.queue.get(block)
Vinay Sajip0637d492010-09-23 08:15:54 +00001253
Victor Stinnercafa2ef2011-05-02 16:11:28 +02001254 def start(self):
1255 """
1256 Start the listener.
Vinay Sajip0637d492010-09-23 08:15:54 +00001257
Victor Stinnercafa2ef2011-05-02 16:11:28 +02001258 This starts up a background thread to monitor the queue for
1259 LogRecords to process.
1260 """
1261 self._thread = t = threading.Thread(target=self._monitor)
1262 t.setDaemon(True)
1263 t.start()
Vinay Sajip0637d492010-09-23 08:15:54 +00001264
Victor Stinnercafa2ef2011-05-02 16:11:28 +02001265 def prepare(self , record):
1266 """
1267 Prepare a record for handling.
Vinay Sajip0637d492010-09-23 08:15:54 +00001268
Victor Stinnercafa2ef2011-05-02 16:11:28 +02001269 This method just returns the passed-in record. You may want to
1270 override this method if you need to do any custom marshalling or
1271 manipulation of the record before passing it to the handlers.
1272 """
1273 return record
Vinay Sajip0637d492010-09-23 08:15:54 +00001274
Victor Stinnercafa2ef2011-05-02 16:11:28 +02001275 def handle(self, record):
1276 """
1277 Handle a record.
Vinay Sajip0637d492010-09-23 08:15:54 +00001278
Victor Stinnercafa2ef2011-05-02 16:11:28 +02001279 This just loops through the handlers offering them the record
1280 to handle.
1281 """
1282 record = self.prepare(record)
1283 for handler in self.handlers:
1284 handler.handle(record)
Vinay Sajip0637d492010-09-23 08:15:54 +00001285
Victor Stinnercafa2ef2011-05-02 16:11:28 +02001286 def _monitor(self):
1287 """
1288 Monitor the queue for records, and ask the handler
1289 to deal with them.
Vinay Sajip0637d492010-09-23 08:15:54 +00001290
Victor Stinnercafa2ef2011-05-02 16:11:28 +02001291 This method runs on a separate, internal thread.
1292 The thread will terminate if it sees a sentinel object in the queue.
1293 """
1294 q = self.queue
1295 has_task_done = hasattr(q, 'task_done')
1296 while not self._stop.isSet():
1297 try:
1298 record = self.dequeue(True)
1299 if record is self._sentinel:
1300 break
1301 self.handle(record)
1302 if has_task_done:
1303 q.task_done()
1304 except queue.Empty:
1305 pass
1306 # There might still be records in the queue.
1307 while True:
1308 try:
1309 record = self.dequeue(False)
1310 if record is self._sentinel:
1311 break
1312 self.handle(record)
1313 if has_task_done:
1314 q.task_done()
1315 except queue.Empty:
Vinay Sajip0637d492010-09-23 08:15:54 +00001316 break
Vinay Sajip0637d492010-09-23 08:15:54 +00001317
Victor Stinner59bec362011-05-02 16:14:16 +02001318 def enqueue_sentinel(self):
1319 """
1320 This is used to enqueue the sentinel record.
Vinay Sajipaa7c1792011-02-25 15:56:55 +00001321
Victor Stinner59bec362011-05-02 16:14:16 +02001322 The base implementation uses put_nowait. You may want to override this
1323 method if you want to use timeouts or work with custom queue
1324 implementations.
1325 """
1326 self.queue.put_nowait(self._sentinel)
Vinay Sajipaa7c1792011-02-25 15:56:55 +00001327
Victor Stinnercafa2ef2011-05-02 16:11:28 +02001328 def stop(self):
1329 """
1330 Stop the listener.
Vinay Sajip0637d492010-09-23 08:15:54 +00001331
Victor Stinnercafa2ef2011-05-02 16:11:28 +02001332 This asks the thread to terminate, and then waits for it to do so.
1333 Note that if you don't call this before your application exits, there
1334 may be some records still left on the queue, which won't be processed.
1335 """
1336 self._stop.set()
Victor Stinner59bec362011-05-02 16:14:16 +02001337 self.enqueue_sentinel()
Victor Stinnercafa2ef2011-05-02 16:11:28 +02001338 self._thread.join()
1339 self._thread = None