| # Copyright 2001-2016 by Vinay Sajip. All Rights Reserved. |
| # |
| # Permission to use, copy, modify, and distribute this software and its |
| # documentation for any purpose and without fee is hereby granted, |
| # provided that the above copyright notice appear in all copies and that |
| # both that copyright notice and this permission notice appear in |
| # supporting documentation, and that the name of Vinay Sajip |
| # not be used in advertising or publicity pertaining to distribution |
| # of the software without specific, written prior permission. |
| # VINAY SAJIP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING |
| # ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL |
| # VINAY SAJIP BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR |
| # ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER |
| # IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT |
| # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| |
| """ |
| Additional handlers for the logging package for Python. The core package is |
| based on PEP 282 and comments thereto in comp.lang.python. |
| |
| Copyright (C) 2001-2016 Vinay Sajip. All Rights Reserved. |
| |
| To use, simply 'import logging.handlers' and log away! |
| """ |
| |
| import logging, socket, os, pickle, struct, time, re |
| from stat import ST_DEV, ST_INO, ST_MTIME |
| import queue |
| import threading |
| |
| # |
| # Some constants... |
| # |
| |
| DEFAULT_TCP_LOGGING_PORT = 9020 |
| DEFAULT_UDP_LOGGING_PORT = 9021 |
| DEFAULT_HTTP_LOGGING_PORT = 9022 |
| DEFAULT_SOAP_LOGGING_PORT = 9023 |
| SYSLOG_UDP_PORT = 514 |
| SYSLOG_TCP_PORT = 514 |
| |
| _MIDNIGHT = 24 * 60 * 60 # number of seconds in a day |
| |
| class BaseRotatingHandler(logging.FileHandler): |
| """ |
| Base class for handlers that rotate log files at a certain point. |
| Not meant to be instantiated directly. Instead, use RotatingFileHandler |
| or TimedRotatingFileHandler. |
| """ |
| def __init__(self, filename, mode, encoding=None, delay=False): |
| """ |
| Use the specified filename for streamed logging |
| """ |
| logging.FileHandler.__init__(self, filename, mode, encoding, delay) |
| self.mode = mode |
| self.encoding = encoding |
| self.namer = None |
| self.rotator = None |
| |
| def emit(self, record): |
| """ |
| Emit a record. |
| |
| Output the record to the file, catering for rollover as described |
| in doRollover(). |
| """ |
| try: |
| if self.shouldRollover(record): |
| self.doRollover() |
| logging.FileHandler.emit(self, record) |
| except Exception: |
| self.handleError(record) |
| |
| def rotation_filename(self, default_name): |
| """ |
| Modify the filename of a log file when rotating. |
| |
| This is provided so that a custom filename can be provided. |
| |
| The default implementation calls the 'namer' attribute of the |
| handler, if it's callable, passing the default name to |
| it. If the attribute isn't callable (the default is None), the name |
| is returned unchanged. |
| |
| :param default_name: The default name for the log file. |
| """ |
| if not callable(self.namer): |
| result = default_name |
| else: |
| result = self.namer(default_name) |
| return result |
| |
| def rotate(self, source, dest): |
| """ |
| When rotating, rotate the current log. |
| |
| The default implementation calls the 'rotator' attribute of the |
| handler, if it's callable, passing the source and dest arguments to |
| it. If the attribute isn't callable (the default is None), the source |
| is simply renamed to the destination. |
| |
| :param source: The source filename. This is normally the base |
| filename, e.g. 'test.log' |
| :param dest: The destination filename. This is normally |
| what the source is rotated to, e.g. 'test.log.1'. |
| """ |
| if not callable(self.rotator): |
| # Issue 18940: A file may not have been created if delay is True. |
| if os.path.exists(source): |
| os.rename(source, dest) |
| else: |
| self.rotator(source, dest) |
| |
| class RotatingFileHandler(BaseRotatingHandler): |
| """ |
| Handler for logging to a set of files, which switches from one file |
| to the next when the current file reaches a certain size. |
| """ |
| def __init__(self, filename, mode='a', maxBytes=0, backupCount=0, encoding=None, delay=False): |
| """ |
| Open the specified file and use it as the stream for logging. |
| |
| By default, the file grows indefinitely. You can specify particular |
| values of maxBytes and backupCount to allow the file to rollover at |
| a predetermined size. |
| |
| Rollover occurs whenever the current log file is nearly maxBytes in |
| length. If backupCount is >= 1, the system will successively create |
| new files with the same pathname as the base file, but with extensions |
| ".1", ".2" etc. appended to it. For example, with a backupCount of 5 |
| and a base file name of "app.log", you would get "app.log", |
| "app.log.1", "app.log.2", ... through to "app.log.5". The file being |
| written to is always "app.log" - when it gets filled up, it is closed |
| and renamed to "app.log.1", and if files "app.log.1", "app.log.2" etc. |
| exist, then they are renamed to "app.log.2", "app.log.3" etc. |
| respectively. |
| |
| If maxBytes is zero, rollover never occurs. |
| """ |
| # If rotation/rollover is wanted, it doesn't make sense to use another |
| # mode. If for example 'w' were specified, then if there were multiple |
| # runs of the calling application, the logs from previous runs would be |
| # lost if the 'w' is respected, because the log file would be truncated |
| # on each run. |
| if maxBytes > 0: |
| mode = 'a' |
| BaseRotatingHandler.__init__(self, filename, mode, encoding, delay) |
| self.maxBytes = maxBytes |
| self.backupCount = backupCount |
| |
| def doRollover(self): |
| """ |
| Do a rollover, as described in __init__(). |
| """ |
| if self.stream: |
| self.stream.close() |
| self.stream = None |
| if self.backupCount > 0: |
| for i in range(self.backupCount - 1, 0, -1): |
| sfn = self.rotation_filename("%s.%d" % (self.baseFilename, i)) |
| dfn = self.rotation_filename("%s.%d" % (self.baseFilename, |
| i + 1)) |
| if os.path.exists(sfn): |
| if os.path.exists(dfn): |
| os.remove(dfn) |
| os.rename(sfn, dfn) |
| dfn = self.rotation_filename(self.baseFilename + ".1") |
| if os.path.exists(dfn): |
| os.remove(dfn) |
| self.rotate(self.baseFilename, dfn) |
| if not self.delay: |
| self.stream = self._open() |
| |
| def shouldRollover(self, record): |
| """ |
| Determine if rollover should occur. |
| |
| Basically, see if the supplied record would cause the file to exceed |
| the size limit we have. |
| """ |
| if self.stream is None: # delay was set... |
| self.stream = self._open() |
| if self.maxBytes > 0: # are we rolling over? |
| msg = "%s\n" % self.format(record) |
| self.stream.seek(0, 2) #due to non-posix-compliant Windows feature |
| if self.stream.tell() + len(msg) >= self.maxBytes: |
| return 1 |
| return 0 |
| |
| class TimedRotatingFileHandler(BaseRotatingHandler): |
| """ |
| Handler for logging to a file, rotating the log file at certain timed |
| intervals. |
| |
| If backupCount is > 0, when rollover is done, no more than backupCount |
| files are kept - the oldest ones are deleted. |
| """ |
| def __init__(self, filename, when='h', interval=1, backupCount=0, encoding=None, delay=False, utc=False, atTime=None): |
| BaseRotatingHandler.__init__(self, filename, 'a', encoding, delay) |
| self.when = when.upper() |
| self.backupCount = backupCount |
| self.utc = utc |
| self.atTime = atTime |
| # Calculate the real rollover interval, which is just the number of |
| # seconds between rollovers. Also set the filename suffix used when |
| # a rollover occurs. Current 'when' events supported: |
| # S - Seconds |
| # M - Minutes |
| # H - Hours |
| # D - Days |
| # midnight - roll over at midnight |
| # W{0-6} - roll over on a certain day; 0 - Monday |
| # |
| # Case of the 'when' specifier is not important; lower or upper case |
| # will work. |
| if self.when == 'S': |
| self.interval = 1 # one second |
| self.suffix = "%Y-%m-%d_%H-%M-%S" |
| self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}(\.\w+)?$" |
| elif self.when == 'M': |
| self.interval = 60 # one minute |
| self.suffix = "%Y-%m-%d_%H-%M" |
| self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}(\.\w+)?$" |
| elif self.when == 'H': |
| self.interval = 60 * 60 # one hour |
| self.suffix = "%Y-%m-%d_%H" |
| self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}(\.\w+)?$" |
| elif self.when == 'D' or self.when == 'MIDNIGHT': |
| self.interval = 60 * 60 * 24 # one day |
| self.suffix = "%Y-%m-%d" |
| self.extMatch = r"^\d{4}-\d{2}-\d{2}(\.\w+)?$" |
| elif self.when.startswith('W'): |
| self.interval = 60 * 60 * 24 * 7 # one week |
| if len(self.when) != 2: |
| raise ValueError("You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s" % self.when) |
| if self.when[1] < '0' or self.when[1] > '6': |
| raise ValueError("Invalid day specified for weekly rollover: %s" % self.when) |
| self.dayOfWeek = int(self.when[1]) |
| self.suffix = "%Y-%m-%d" |
| self.extMatch = r"^\d{4}-\d{2}-\d{2}(\.\w+)?$" |
| else: |
| raise ValueError("Invalid rollover interval specified: %s" % self.when) |
| |
| self.extMatch = re.compile(self.extMatch, re.ASCII) |
| self.interval = self.interval * interval # multiply by units requested |
| # The following line added because the filename passed in could be a |
| # path object (see Issue #27493), but self.baseFilename will be a string |
| filename = self.baseFilename |
| if os.path.exists(filename): |
| t = os.stat(filename)[ST_MTIME] |
| else: |
| t = int(time.time()) |
| self.rolloverAt = self.computeRollover(t) |
| |
| def computeRollover(self, currentTime): |
| """ |
| Work out the rollover time based on the specified time. |
| """ |
| result = currentTime + self.interval |
| # If we are rolling over at midnight or weekly, then the interval is already known. |
| # What we need to figure out is WHEN the next interval is. In other words, |
| # if you are rolling over at midnight, then your base interval is 1 day, |
| # but you want to start that one day clock at midnight, not now. So, we |
| # have to fudge the rolloverAt value in order to trigger the first rollover |
| # at the right time. After that, the regular interval will take care of |
| # the rest. Note that this code doesn't care about leap seconds. :) |
| if self.when == 'MIDNIGHT' or self.when.startswith('W'): |
| # This could be done with less code, but I wanted it to be clear |
| if self.utc: |
| t = time.gmtime(currentTime) |
| else: |
| t = time.localtime(currentTime) |
| currentHour = t[3] |
| currentMinute = t[4] |
| currentSecond = t[5] |
| currentDay = t[6] |
| # r is the number of seconds left between now and the next rotation |
| if self.atTime is None: |
| rotate_ts = _MIDNIGHT |
| else: |
| rotate_ts = ((self.atTime.hour * 60 + self.atTime.minute)*60 + |
| self.atTime.second) |
| |
| r = rotate_ts - ((currentHour * 60 + currentMinute) * 60 + |
| currentSecond) |
| if r < 0: |
| # Rotate time is before the current time (for example when |
| # self.rotateAt is 13:45 and it now 14:15), rotation is |
| # tomorrow. |
| r += _MIDNIGHT |
| currentDay = (currentDay + 1) % 7 |
| result = currentTime + r |
| # If we are rolling over on a certain day, add in the number of days until |
| # the next rollover, but offset by 1 since we just calculated the time |
| # until the next day starts. There are three cases: |
| # Case 1) The day to rollover is today; in this case, do nothing |
| # Case 2) The day to rollover is further in the interval (i.e., today is |
| # day 2 (Wednesday) and rollover is on day 6 (Sunday). Days to |
| # next rollover is simply 6 - 2 - 1, or 3. |
| # Case 3) The day to rollover is behind us in the interval (i.e., today |
| # is day 5 (Saturday) and rollover is on day 3 (Thursday). |
| # Days to rollover is 6 - 5 + 3, or 4. In this case, it's the |
| # number of days left in the current week (1) plus the number |
| # of days in the next week until the rollover day (3). |
| # The calculations described in 2) and 3) above need to have a day added. |
| # This is because the above time calculation takes us to midnight on this |
| # day, i.e. the start of the next day. |
| if self.when.startswith('W'): |
| day = currentDay # 0 is Monday |
| if day != self.dayOfWeek: |
| if day < self.dayOfWeek: |
| daysToWait = self.dayOfWeek - day |
| else: |
| daysToWait = 6 - day + self.dayOfWeek + 1 |
| newRolloverAt = result + (daysToWait * (60 * 60 * 24)) |
| if not self.utc: |
| dstNow = t[-1] |
| dstAtRollover = time.localtime(newRolloverAt)[-1] |
| if dstNow != dstAtRollover: |
| if not dstNow: # DST kicks in before next rollover, so we need to deduct an hour |
| addend = -3600 |
| else: # DST bows out before next rollover, so we need to add an hour |
| addend = 3600 |
| newRolloverAt += addend |
| result = newRolloverAt |
| return result |
| |
| def shouldRollover(self, record): |
| """ |
| Determine if rollover should occur. |
| |
| record is not used, as we are just comparing times, but it is needed so |
| the method signatures are the same |
| """ |
| t = int(time.time()) |
| if t >= self.rolloverAt: |
| return 1 |
| return 0 |
| |
| def getFilesToDelete(self): |
| """ |
| Determine the files to delete when rolling over. |
| |
| More specific than the earlier method, which just used glob.glob(). |
| """ |
| dirName, baseName = os.path.split(self.baseFilename) |
| fileNames = os.listdir(dirName) |
| result = [] |
| prefix = baseName + "." |
| plen = len(prefix) |
| for fileName in fileNames: |
| if fileName[:plen] == prefix: |
| suffix = fileName[plen:] |
| if self.extMatch.match(suffix): |
| result.append(os.path.join(dirName, fileName)) |
| if len(result) < self.backupCount: |
| result = [] |
| else: |
| result.sort() |
| result = result[:len(result) - self.backupCount] |
| return result |
| |
| def doRollover(self): |
| """ |
| do a rollover; in this case, a date/time stamp is appended to the filename |
| when the rollover happens. However, you want the file to be named for the |
| start of the interval, not the current time. If there is a backup count, |
| then we have to get a list of matching filenames, sort them and remove |
| the one with the oldest suffix. |
| """ |
| if self.stream: |
| self.stream.close() |
| self.stream = None |
| # get the time that this sequence started at and make it a TimeTuple |
| currentTime = int(time.time()) |
| dstNow = time.localtime(currentTime)[-1] |
| t = self.rolloverAt - self.interval |
| if self.utc: |
| timeTuple = time.gmtime(t) |
| else: |
| timeTuple = time.localtime(t) |
| dstThen = timeTuple[-1] |
| if dstNow != dstThen: |
| if dstNow: |
| addend = 3600 |
| else: |
| addend = -3600 |
| timeTuple = time.localtime(t + addend) |
| dfn = self.rotation_filename(self.baseFilename + "." + |
| time.strftime(self.suffix, timeTuple)) |
| if os.path.exists(dfn): |
| os.remove(dfn) |
| self.rotate(self.baseFilename, dfn) |
| if self.backupCount > 0: |
| for s in self.getFilesToDelete(): |
| os.remove(s) |
| if not self.delay: |
| self.stream = self._open() |
| newRolloverAt = self.computeRollover(currentTime) |
| while newRolloverAt <= currentTime: |
| newRolloverAt = newRolloverAt + self.interval |
| #If DST changes and midnight or weekly rollover, adjust for this. |
| if (self.when == 'MIDNIGHT' or self.when.startswith('W')) and not self.utc: |
| dstAtRollover = time.localtime(newRolloverAt)[-1] |
| if dstNow != dstAtRollover: |
| if not dstNow: # DST kicks in before next rollover, so we need to deduct an hour |
| addend = -3600 |
| else: # DST bows out before next rollover, so we need to add an hour |
| addend = 3600 |
| newRolloverAt += addend |
| self.rolloverAt = newRolloverAt |
| |
| class WatchedFileHandler(logging.FileHandler): |
| """ |
| A handler for logging to a file, which watches the file |
| to see if it has changed while in use. This can happen because of |
| usage of programs such as newsyslog and logrotate which perform |
| log file rotation. This handler, intended for use under Unix, |
| watches the file to see if it has changed since the last emit. |
| (A file has changed if its device or inode have changed.) |
| If it has changed, the old file stream is closed, and the file |
| opened to get a new stream. |
| |
| This handler is not appropriate for use under Windows, because |
| under Windows open files cannot be moved or renamed - logging |
| opens the files with exclusive locks - and so there is no need |
| for such a handler. Furthermore, ST_INO is not supported under |
| Windows; stat always returns zero for this value. |
| |
| This handler is based on a suggestion and patch by Chad J. |
| Schroeder. |
| """ |
| def __init__(self, filename, mode='a', encoding=None, delay=False): |
| logging.FileHandler.__init__(self, filename, mode, encoding, delay) |
| self.dev, self.ino = -1, -1 |
| self._statstream() |
| |
| def _statstream(self): |
| if self.stream: |
| sres = os.fstat(self.stream.fileno()) |
| self.dev, self.ino = sres[ST_DEV], sres[ST_INO] |
| |
| def reopenIfNeeded(self): |
| """ |
| Reopen log file if needed. |
| |
| Checks if the underlying file has changed, and if it |
| has, close the old stream and reopen the file to get the |
| current stream. |
| """ |
| # Reduce the chance of race conditions by stat'ing by path only |
| # once and then fstat'ing our new fd if we opened a new log stream. |
| # See issue #14632: Thanks to John Mulligan for the problem report |
| # and patch. |
| try: |
| # stat the file by path, checking for existence |
| sres = os.stat(self.baseFilename) |
| except FileNotFoundError: |
| sres = None |
| # compare file system stat with that of our stream file handle |
| if not sres or sres[ST_DEV] != self.dev or sres[ST_INO] != self.ino: |
| if self.stream is not None: |
| # we have an open file handle, clean it up |
| self.stream.flush() |
| self.stream.close() |
| self.stream = None # See Issue #21742: _open () might fail. |
| # open a new file handle and get new stat info from that fd |
| self.stream = self._open() |
| self._statstream() |
| |
| def emit(self, record): |
| """ |
| Emit a record. |
| |
| If underlying file has changed, reopen the file before emitting the |
| record to it. |
| """ |
| self.reopenIfNeeded() |
| logging.FileHandler.emit(self, record) |
| |
| |
| class SocketHandler(logging.Handler): |
| """ |
| A handler class which writes logging records, in pickle format, to |
| a streaming socket. The socket is kept open across logging calls. |
| If the peer resets it, an attempt is made to reconnect on the next call. |
| The pickle which is sent is that of the LogRecord's attribute dictionary |
| (__dict__), so that the receiver does not need to have the logging module |
| installed in order to process the logging event. |
| |
| To unpickle the record at the receiving end into a LogRecord, use the |
| makeLogRecord function. |
| """ |
| |
| def __init__(self, host, port): |
| """ |
| Initializes the handler with a specific host address and port. |
| |
| When the attribute *closeOnError* is set to True - if a socket error |
| occurs, the socket is silently closed and then reopened on the next |
| logging call. |
| """ |
| logging.Handler.__init__(self) |
| self.host = host |
| self.port = port |
| if port is None: |
| self.address = host |
| else: |
| self.address = (host, port) |
| self.sock = None |
| self.closeOnError = False |
| self.retryTime = None |
| # |
| # Exponential backoff parameters. |
| # |
| self.retryStart = 1.0 |
| self.retryMax = 30.0 |
| self.retryFactor = 2.0 |
| |
| def makeSocket(self, timeout=1): |
| """ |
| A factory method which allows subclasses to define the precise |
| type of socket they want. |
| """ |
| if self.port is not None: |
| result = socket.create_connection(self.address, timeout=timeout) |
| else: |
| result = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) |
| result.settimeout(timeout) |
| try: |
| result.connect(self.address) |
| except OSError: |
| result.close() # Issue 19182 |
| raise |
| return result |
| |
| def createSocket(self): |
| """ |
| Try to create a socket, using an exponential backoff with |
| a max retry time. Thanks to Robert Olson for the original patch |
| (SF #815911) which has been slightly refactored. |
| """ |
| now = time.time() |
| # Either retryTime is None, in which case this |
| # is the first time back after a disconnect, or |
| # we've waited long enough. |
| if self.retryTime is None: |
| attempt = True |
| else: |
| attempt = (now >= self.retryTime) |
| if attempt: |
| try: |
| self.sock = self.makeSocket() |
| self.retryTime = None # next time, no delay before trying |
| except OSError: |
| #Creation failed, so set the retry time and return. |
| if self.retryTime is None: |
| self.retryPeriod = self.retryStart |
| else: |
| self.retryPeriod = self.retryPeriod * self.retryFactor |
| if self.retryPeriod > self.retryMax: |
| self.retryPeriod = self.retryMax |
| self.retryTime = now + self.retryPeriod |
| |
| def send(self, s): |
| """ |
| Send a pickled string to the socket. |
| |
| This function allows for partial sends which can happen when the |
| network is busy. |
| """ |
| if self.sock is None: |
| self.createSocket() |
| #self.sock can be None either because we haven't reached the retry |
| #time yet, or because we have reached the retry time and retried, |
| #but are still unable to connect. |
| if self.sock: |
| try: |
| self.sock.sendall(s) |
| except OSError: #pragma: no cover |
| self.sock.close() |
| self.sock = None # so we can call createSocket next time |
| |
| def makePickle(self, record): |
| """ |
| Pickles the record in binary format with a length prefix, and |
| returns it ready for transmission across the socket. |
| """ |
| ei = record.exc_info |
| if ei: |
| # just to get traceback text into record.exc_text ... |
| dummy = self.format(record) |
| # See issue #14436: If msg or args are objects, they may not be |
| # available on the receiving end. So we convert the msg % args |
| # to a string, save it as msg and zap the args. |
| d = dict(record.__dict__) |
| d['msg'] = record.getMessage() |
| d['args'] = None |
| d['exc_info'] = None |
| # Issue #25685: delete 'message' if present: redundant with 'msg' |
| d.pop('message', None) |
| s = pickle.dumps(d, 1) |
| slen = struct.pack(">L", len(s)) |
| return slen + s |
| |
| def handleError(self, record): |
| """ |
| Handle an error during logging. |
| |
| An error has occurred during logging. Most likely cause - |
| connection lost. Close the socket so that we can retry on the |
| next event. |
| """ |
| if self.closeOnError and self.sock: |
| self.sock.close() |
| self.sock = None #try to reconnect next time |
| else: |
| logging.Handler.handleError(self, record) |
| |
| def emit(self, record): |
| """ |
| Emit a record. |
| |
| Pickles the record and writes it to the socket in binary format. |
| If there is an error with the socket, silently drop the packet. |
| If there was a problem with the socket, re-establishes the |
| socket. |
| """ |
| try: |
| s = self.makePickle(record) |
| self.send(s) |
| except Exception: |
| self.handleError(record) |
| |
| def close(self): |
| """ |
| Closes the socket. |
| """ |
| self.acquire() |
| try: |
| sock = self.sock |
| if sock: |
| self.sock = None |
| sock.close() |
| logging.Handler.close(self) |
| finally: |
| self.release() |
| |
| class DatagramHandler(SocketHandler): |
| """ |
| A handler class which writes logging records, in pickle format, to |
| a datagram socket. The pickle which is sent is that of the LogRecord's |
| attribute dictionary (__dict__), so that the receiver does not need to |
| have the logging module installed in order to process the logging event. |
| |
| To unpickle the record at the receiving end into a LogRecord, use the |
| makeLogRecord function. |
| |
| """ |
| def __init__(self, host, port): |
| """ |
| Initializes the handler with a specific host address and port. |
| """ |
| SocketHandler.__init__(self, host, port) |
| self.closeOnError = False |
| |
| def makeSocket(self): |
| """ |
| The factory method of SocketHandler is here overridden to create |
| a UDP socket (SOCK_DGRAM). |
| """ |
| if self.port is None: |
| family = socket.AF_UNIX |
| else: |
| family = socket.AF_INET |
| s = socket.socket(family, socket.SOCK_DGRAM) |
| return s |
| |
| def send(self, s): |
| """ |
| Send a pickled string to a socket. |
| |
| This function no longer allows for partial sends which can happen |
| when the network is busy - UDP does not guarantee delivery and |
| can deliver packets out of sequence. |
| """ |
| if self.sock is None: |
| self.createSocket() |
| self.sock.sendto(s, self.address) |
| |
| class SysLogHandler(logging.Handler): |
| """ |
| A handler class which sends formatted logging records to a syslog |
| server. Based on Sam Rushing's syslog module: |
| http://www.nightmare.com/squirl/python-ext/misc/syslog.py |
| Contributed by Nicolas Untz (after which minor refactoring changes |
| have been made). |
| """ |
| |
| # from <linux/sys/syslog.h>: |
| # ====================================================================== |
| # priorities/facilities are encoded into a single 32-bit quantity, where |
| # the bottom 3 bits are the priority (0-7) and the top 28 bits are the |
| # facility (0-big number). Both the priorities and the facilities map |
| # roughly one-to-one to strings in the syslogd(8) source code. This |
| # mapping is included in this file. |
| # |
| # priorities (these are ordered) |
| |
| LOG_EMERG = 0 # system is unusable |
| LOG_ALERT = 1 # action must be taken immediately |
| LOG_CRIT = 2 # critical conditions |
| LOG_ERR = 3 # error conditions |
| LOG_WARNING = 4 # warning conditions |
| LOG_NOTICE = 5 # normal but significant condition |
| LOG_INFO = 6 # informational |
| LOG_DEBUG = 7 # debug-level messages |
| |
| # facility codes |
| LOG_KERN = 0 # kernel messages |
| LOG_USER = 1 # random user-level messages |
| LOG_MAIL = 2 # mail system |
| LOG_DAEMON = 3 # system daemons |
| LOG_AUTH = 4 # security/authorization messages |
| LOG_SYSLOG = 5 # messages generated internally by syslogd |
| LOG_LPR = 6 # line printer subsystem |
| LOG_NEWS = 7 # network news subsystem |
| LOG_UUCP = 8 # UUCP subsystem |
| LOG_CRON = 9 # clock daemon |
| LOG_AUTHPRIV = 10 # security/authorization messages (private) |
| LOG_FTP = 11 # FTP daemon |
| |
| # other codes through 15 reserved for system use |
| LOG_LOCAL0 = 16 # reserved for local use |
| LOG_LOCAL1 = 17 # reserved for local use |
| LOG_LOCAL2 = 18 # reserved for local use |
| LOG_LOCAL3 = 19 # reserved for local use |
| LOG_LOCAL4 = 20 # reserved for local use |
| LOG_LOCAL5 = 21 # reserved for local use |
| LOG_LOCAL6 = 22 # reserved for local use |
| LOG_LOCAL7 = 23 # reserved for local use |
| |
| priority_names = { |
| "alert": LOG_ALERT, |
| "crit": LOG_CRIT, |
| "critical": LOG_CRIT, |
| "debug": LOG_DEBUG, |
| "emerg": LOG_EMERG, |
| "err": LOG_ERR, |
| "error": LOG_ERR, # DEPRECATED |
| "info": LOG_INFO, |
| "notice": LOG_NOTICE, |
| "panic": LOG_EMERG, # DEPRECATED |
| "warn": LOG_WARNING, # DEPRECATED |
| "warning": LOG_WARNING, |
| } |
| |
| facility_names = { |
| "auth": LOG_AUTH, |
| "authpriv": LOG_AUTHPRIV, |
| "cron": LOG_CRON, |
| "daemon": LOG_DAEMON, |
| "ftp": LOG_FTP, |
| "kern": LOG_KERN, |
| "lpr": LOG_LPR, |
| "mail": LOG_MAIL, |
| "news": LOG_NEWS, |
| "security": LOG_AUTH, # DEPRECATED |
| "syslog": LOG_SYSLOG, |
| "user": LOG_USER, |
| "uucp": LOG_UUCP, |
| "local0": LOG_LOCAL0, |
| "local1": LOG_LOCAL1, |
| "local2": LOG_LOCAL2, |
| "local3": LOG_LOCAL3, |
| "local4": LOG_LOCAL4, |
| "local5": LOG_LOCAL5, |
| "local6": LOG_LOCAL6, |
| "local7": LOG_LOCAL7, |
| } |
| |
| #The map below appears to be trivially lowercasing the key. However, |
| #there's more to it than meets the eye - in some locales, lowercasing |
| #gives unexpected results. See SF #1524081: in the Turkish locale, |
| #"INFO".lower() != "info" |
| priority_map = { |
| "DEBUG" : "debug", |
| "INFO" : "info", |
| "WARNING" : "warning", |
| "ERROR" : "error", |
| "CRITICAL" : "critical" |
| } |
| |
| def __init__(self, address=('localhost', SYSLOG_UDP_PORT), |
| facility=LOG_USER, socktype=None): |
| """ |
| Initialize a handler. |
| |
| If address is specified as a string, a UNIX socket is used. To log to a |
| local syslogd, "SysLogHandler(address="/dev/log")" can be used. |
| If facility is not specified, LOG_USER is used. If socktype is |
| specified as socket.SOCK_DGRAM or socket.SOCK_STREAM, that specific |
| socket type will be used. For Unix sockets, you can also specify a |
| socktype of None, in which case socket.SOCK_DGRAM will be used, falling |
| back to socket.SOCK_STREAM. |
| """ |
| logging.Handler.__init__(self) |
| |
| self.address = address |
| self.facility = facility |
| self.socktype = socktype |
| |
| if isinstance(address, str): |
| self.unixsocket = True |
| # Syslog server may be unavailable during handler initialisation. |
| # C's openlog() function also ignores connection errors. |
| # Moreover, we ignore these errors while logging, so it not worse |
| # to ignore it also here. |
| try: |
| self._connect_unixsocket(address) |
| except OSError: |
| pass |
| else: |
| self.unixsocket = False |
| if socktype is None: |
| socktype = socket.SOCK_DGRAM |
| host, port = address |
| ress = socket.getaddrinfo(host, port, 0, socktype) |
| if not ress: |
| raise OSError("getaddrinfo returns an empty list") |
| for res in ress: |
| af, socktype, proto, _, sa = res |
| err = sock = None |
| try: |
| sock = socket.socket(af, socktype, proto) |
| if socktype == socket.SOCK_STREAM: |
| sock.connect(sa) |
| break |
| except OSError as exc: |
| err = exc |
| if sock is not None: |
| sock.close() |
| if err is not None: |
| raise err |
| self.socket = sock |
| self.socktype = socktype |
| |
| def _connect_unixsocket(self, address): |
| use_socktype = self.socktype |
| if use_socktype is None: |
| use_socktype = socket.SOCK_DGRAM |
| self.socket = socket.socket(socket.AF_UNIX, use_socktype) |
| try: |
| self.socket.connect(address) |
| # it worked, so set self.socktype to the used type |
| self.socktype = use_socktype |
| except OSError: |
| self.socket.close() |
| if self.socktype is not None: |
| # user didn't specify falling back, so fail |
| raise |
| use_socktype = socket.SOCK_STREAM |
| self.socket = socket.socket(socket.AF_UNIX, use_socktype) |
| try: |
| self.socket.connect(address) |
| # it worked, so set self.socktype to the used type |
| self.socktype = use_socktype |
| except OSError: |
| self.socket.close() |
| raise |
| |
| def encodePriority(self, facility, priority): |
| """ |
| Encode the facility and priority. You can pass in strings or |
| integers - if strings are passed, the facility_names and |
| priority_names mapping dictionaries are used to convert them to |
| integers. |
| """ |
| if isinstance(facility, str): |
| facility = self.facility_names[facility] |
| if isinstance(priority, str): |
| priority = self.priority_names[priority] |
| return (facility << 3) | priority |
| |
| def close(self): |
| """ |
| Closes the socket. |
| """ |
| self.acquire() |
| try: |
| self.socket.close() |
| logging.Handler.close(self) |
| finally: |
| self.release() |
| |
| def mapPriority(self, levelName): |
| """ |
| Map a logging level name to a key in the priority_names map. |
| This is useful in two scenarios: when custom levels are being |
| used, and in the case where you can't do a straightforward |
| mapping by lowercasing the logging level name because of locale- |
| specific issues (see SF #1524081). |
| """ |
| return self.priority_map.get(levelName, "warning") |
| |
| ident = '' # prepended to all messages |
| append_nul = True # some old syslog daemons expect a NUL terminator |
| |
| def emit(self, record): |
| """ |
| Emit a record. |
| |
| The record is formatted, and then sent to the syslog server. If |
| exception information is present, it is NOT sent to the server. |
| """ |
| try: |
| msg = self.format(record) |
| if self.ident: |
| msg = self.ident + msg |
| if self.append_nul: |
| msg += '\000' |
| |
| # We need to convert record level to lowercase, maybe this will |
| # change in the future. |
| prio = '<%d>' % self.encodePriority(self.facility, |
| self.mapPriority(record.levelname)) |
| prio = prio.encode('utf-8') |
| # Message is a string. Convert to bytes as required by RFC 5424 |
| msg = msg.encode('utf-8') |
| msg = prio + msg |
| if self.unixsocket: |
| try: |
| self.socket.send(msg) |
| except OSError: |
| self.socket.close() |
| self._connect_unixsocket(self.address) |
| self.socket.send(msg) |
| elif self.socktype == socket.SOCK_DGRAM: |
| self.socket.sendto(msg, self.address) |
| else: |
| self.socket.sendall(msg) |
| except Exception: |
| self.handleError(record) |
| |
| class SMTPHandler(logging.Handler): |
| """ |
| A handler class which sends an SMTP email for each logging event. |
| """ |
| def __init__(self, mailhost, fromaddr, toaddrs, subject, |
| credentials=None, secure=None, timeout=5.0): |
| """ |
| Initialize the handler. |
| |
| Initialize the instance with the from and to addresses and subject |
| line of the email. To specify a non-standard SMTP port, use the |
| (host, port) tuple format for the mailhost argument. To specify |
| authentication credentials, supply a (username, password) tuple |
| for the credentials argument. To specify the use of a secure |
| protocol (TLS), pass in a tuple for the secure argument. This will |
| only be used when authentication credentials are supplied. The tuple |
| will be either an empty tuple, or a single-value tuple with the name |
| of a keyfile, or a 2-value tuple with the names of the keyfile and |
| certificate file. (This tuple is passed to the `starttls` method). |
| A timeout in seconds can be specified for the SMTP connection (the |
| default is one second). |
| """ |
| logging.Handler.__init__(self) |
| if isinstance(mailhost, (list, tuple)): |
| self.mailhost, self.mailport = mailhost |
| else: |
| self.mailhost, self.mailport = mailhost, None |
| if isinstance(credentials, (list, tuple)): |
| self.username, self.password = credentials |
| else: |
| self.username = None |
| self.fromaddr = fromaddr |
| if isinstance(toaddrs, str): |
| toaddrs = [toaddrs] |
| self.toaddrs = toaddrs |
| self.subject = subject |
| self.secure = secure |
| self.timeout = timeout |
| |
| def getSubject(self, record): |
| """ |
| Determine the subject for the email. |
| |
| If you want to specify a subject line which is record-dependent, |
| override this method. |
| """ |
| return self.subject |
| |
| def emit(self, record): |
| """ |
| Emit a record. |
| |
| Format the record and send it to the specified addressees. |
| """ |
| try: |
| import smtplib |
| from email.message import EmailMessage |
| import email.utils |
| |
| port = self.mailport |
| if not port: |
| port = smtplib.SMTP_PORT |
| smtp = smtplib.SMTP(self.mailhost, port, timeout=self.timeout) |
| msg = EmailMessage() |
| msg['From'] = self.fromaddr |
| msg['To'] = ','.join(self.toaddrs) |
| msg['Subject'] = self.getSubject(record) |
| msg['Date'] = email.utils.localtime() |
| msg.set_content(self.format(record)) |
| if self.username: |
| if self.secure is not None: |
| smtp.ehlo() |
| smtp.starttls(*self.secure) |
| smtp.ehlo() |
| smtp.login(self.username, self.password) |
| smtp.send_message(msg) |
| smtp.quit() |
| except Exception: |
| self.handleError(record) |
| |
| class NTEventLogHandler(logging.Handler): |
| """ |
| A handler class which sends events to the NT Event Log. Adds a |
| registry entry for the specified application name. If no dllname is |
| provided, win32service.pyd (which contains some basic message |
| placeholders) is used. Note that use of these placeholders will make |
| your event logs big, as the entire message source is held in the log. |
| If you want slimmer logs, you have to pass in the name of your own DLL |
| which contains the message definitions you want to use in the event log. |
| """ |
| def __init__(self, appname, dllname=None, logtype="Application"): |
| logging.Handler.__init__(self) |
| try: |
| import win32evtlogutil, win32evtlog |
| self.appname = appname |
| self._welu = win32evtlogutil |
| if not dllname: |
| dllname = os.path.split(self._welu.__file__) |
| dllname = os.path.split(dllname[0]) |
| dllname = os.path.join(dllname[0], r'win32service.pyd') |
| self.dllname = dllname |
| self.logtype = logtype |
| self._welu.AddSourceToRegistry(appname, dllname, logtype) |
| self.deftype = win32evtlog.EVENTLOG_ERROR_TYPE |
| self.typemap = { |
| logging.DEBUG : win32evtlog.EVENTLOG_INFORMATION_TYPE, |
| logging.INFO : win32evtlog.EVENTLOG_INFORMATION_TYPE, |
| logging.WARNING : win32evtlog.EVENTLOG_WARNING_TYPE, |
| logging.ERROR : win32evtlog.EVENTLOG_ERROR_TYPE, |
| logging.CRITICAL: win32evtlog.EVENTLOG_ERROR_TYPE, |
| } |
| except ImportError: |
| print("The Python Win32 extensions for NT (service, event "\ |
| "logging) appear not to be available.") |
| self._welu = None |
| |
| def getMessageID(self, record): |
| """ |
| Return the message ID for the event record. If you are using your |
| own messages, you could do this by having the msg passed to the |
| logger being an ID rather than a formatting string. Then, in here, |
| you could use a dictionary lookup to get the message ID. This |
| version returns 1, which is the base message ID in win32service.pyd. |
| """ |
| return 1 |
| |
| def getEventCategory(self, record): |
| """ |
| Return the event category for the record. |
| |
| Override this if you want to specify your own categories. This version |
| returns 0. |
| """ |
| return 0 |
| |
| def getEventType(self, record): |
| """ |
| Return the event type for the record. |
| |
| Override this if you want to specify your own types. This version does |
| a mapping using the handler's typemap attribute, which is set up in |
| __init__() to a dictionary which contains mappings for DEBUG, INFO, |
| WARNING, ERROR and CRITICAL. If you are using your own levels you will |
| either need to override this method or place a suitable dictionary in |
| the handler's typemap attribute. |
| """ |
| return self.typemap.get(record.levelno, self.deftype) |
| |
| def emit(self, record): |
| """ |
| Emit a record. |
| |
| Determine the message ID, event category and event type. Then |
| log the message in the NT event log. |
| """ |
| if self._welu: |
| try: |
| id = self.getMessageID(record) |
| cat = self.getEventCategory(record) |
| type = self.getEventType(record) |
| msg = self.format(record) |
| self._welu.ReportEvent(self.appname, id, cat, type, [msg]) |
| except Exception: |
| self.handleError(record) |
| |
| def close(self): |
| """ |
| Clean up this handler. |
| |
| You can remove the application name from the registry as a |
| source of event log entries. However, if you do this, you will |
| not be able to see the events as you intended in the Event Log |
| Viewer - it needs to be able to access the registry to get the |
| DLL name. |
| """ |
| #self._welu.RemoveSourceFromRegistry(self.appname, self.logtype) |
| logging.Handler.close(self) |
| |
| class HTTPHandler(logging.Handler): |
| """ |
| A class which sends records to a Web server, using either GET or |
| POST semantics. |
| """ |
| def __init__(self, host, url, method="GET", secure=False, credentials=None, |
| context=None): |
| """ |
| Initialize the instance with the host, the request URL, and the method |
| ("GET" or "POST") |
| """ |
| logging.Handler.__init__(self) |
| method = method.upper() |
| if method not in ["GET", "POST"]: |
| raise ValueError("method must be GET or POST") |
| if not secure and context is not None: |
| raise ValueError("context parameter only makes sense " |
| "with secure=True") |
| self.host = host |
| self.url = url |
| self.method = method |
| self.secure = secure |
| self.credentials = credentials |
| self.context = context |
| |
| def mapLogRecord(self, record): |
| """ |
| Default implementation of mapping the log record into a dict |
| that is sent as the CGI data. Overwrite in your class. |
| Contributed by Franz Glasner. |
| """ |
| return record.__dict__ |
| |
| def emit(self, record): |
| """ |
| Emit a record. |
| |
| Send the record to the Web server as a percent-encoded dictionary |
| """ |
| try: |
| import http.client, urllib.parse |
| host = self.host |
| if self.secure: |
| h = http.client.HTTPSConnection(host, context=self.context) |
| else: |
| h = http.client.HTTPConnection(host) |
| url = self.url |
| data = urllib.parse.urlencode(self.mapLogRecord(record)) |
| if self.method == "GET": |
| if (url.find('?') >= 0): |
| sep = '&' |
| else: |
| sep = '?' |
| url = url + "%c%s" % (sep, data) |
| h.putrequest(self.method, url) |
| # support multiple hosts on one IP address... |
| # need to strip optional :port from host, if present |
| i = host.find(":") |
| if i >= 0: |
| host = host[:i] |
| # See issue #30904: putrequest call above already adds this header |
| # on Python 3.x. |
| # h.putheader("Host", host) |
| if self.method == "POST": |
| h.putheader("Content-type", |
| "application/x-www-form-urlencoded") |
| h.putheader("Content-length", str(len(data))) |
| if self.credentials: |
| import base64 |
| s = ('%s:%s' % self.credentials).encode('utf-8') |
| s = 'Basic ' + base64.b64encode(s).strip().decode('ascii') |
| h.putheader('Authorization', s) |
| h.endheaders() |
| if self.method == "POST": |
| h.send(data.encode('utf-8')) |
| h.getresponse() #can't do anything with the result |
| except Exception: |
| self.handleError(record) |
| |
| class BufferingHandler(logging.Handler): |
| """ |
| A handler class which buffers logging records in memory. Whenever each |
| record is added to the buffer, a check is made to see if the buffer should |
| be flushed. If it should, then flush() is expected to do what's needed. |
| """ |
| def __init__(self, capacity): |
| """ |
| Initialize the handler with the buffer size. |
| """ |
| logging.Handler.__init__(self) |
| self.capacity = capacity |
| self.buffer = [] |
| |
| def shouldFlush(self, record): |
| """ |
| Should the handler flush its buffer? |
| |
| Returns true if the buffer is up to capacity. This method can be |
| overridden to implement custom flushing strategies. |
| """ |
| return (len(self.buffer) >= self.capacity) |
| |
| def emit(self, record): |
| """ |
| Emit a record. |
| |
| Append the record. If shouldFlush() tells us to, call flush() to process |
| the buffer. |
| """ |
| self.buffer.append(record) |
| if self.shouldFlush(record): |
| self.flush() |
| |
| def flush(self): |
| """ |
| Override to implement custom flushing behaviour. |
| |
| This version just zaps the buffer to empty. |
| """ |
| self.acquire() |
| try: |
| self.buffer = [] |
| finally: |
| self.release() |
| |
| def close(self): |
| """ |
| Close the handler. |
| |
| This version just flushes and chains to the parent class' close(). |
| """ |
| try: |
| self.flush() |
| finally: |
| logging.Handler.close(self) |
| |
| class MemoryHandler(BufferingHandler): |
| """ |
| A handler class which buffers logging records in memory, periodically |
| flushing them to a target handler. Flushing occurs whenever the buffer |
| is full, or when an event of a certain severity or greater is seen. |
| """ |
| def __init__(self, capacity, flushLevel=logging.ERROR, target=None, |
| flushOnClose=True): |
| """ |
| Initialize the handler with the buffer size, the level at which |
| flushing should occur and an optional target. |
| |
| Note that without a target being set either here or via setTarget(), |
| a MemoryHandler is no use to anyone! |
| |
| The ``flushOnClose`` argument is ``True`` for backward compatibility |
| reasons - the old behaviour is that when the handler is closed, the |
| buffer is flushed, even if the flush level hasn't been exceeded nor the |
| capacity exceeded. To prevent this, set ``flushOnClose`` to ``False``. |
| """ |
| BufferingHandler.__init__(self, capacity) |
| self.flushLevel = flushLevel |
| self.target = target |
| # See Issue #26559 for why this has been added |
| self.flushOnClose = flushOnClose |
| |
| def shouldFlush(self, record): |
| """ |
| Check for buffer full or a record at the flushLevel or higher. |
| """ |
| return (len(self.buffer) >= self.capacity) or \ |
| (record.levelno >= self.flushLevel) |
| |
| def setTarget(self, target): |
| """ |
| Set the target handler for this handler. |
| """ |
| self.target = target |
| |
| def flush(self): |
| """ |
| For a MemoryHandler, flushing means just sending the buffered |
| records to the target, if there is one. Override if you want |
| different behaviour. |
| |
| The record buffer is also cleared by this operation. |
| """ |
| self.acquire() |
| try: |
| if self.target: |
| for record in self.buffer: |
| self.target.handle(record) |
| self.buffer = [] |
| finally: |
| self.release() |
| |
| def close(self): |
| """ |
| Flush, if appropriately configured, set the target to None and lose the |
| buffer. |
| """ |
| try: |
| if self.flushOnClose: |
| self.flush() |
| finally: |
| self.acquire() |
| try: |
| self.target = None |
| BufferingHandler.close(self) |
| finally: |
| self.release() |
| |
| |
| class QueueHandler(logging.Handler): |
| """ |
| This handler sends events to a queue. Typically, it would be used together |
| with a multiprocessing Queue to centralise logging to file in one process |
| (in a multi-process application), so as to avoid file write contention |
| between processes. |
| |
| This code is new in Python 3.2, but this class can be copy pasted into |
| user code for use with earlier Python versions. |
| """ |
| |
| def __init__(self, queue): |
| """ |
| Initialise an instance, using the passed queue. |
| """ |
| logging.Handler.__init__(self) |
| self.queue = queue |
| |
| def enqueue(self, record): |
| """ |
| Enqueue a record. |
| |
| The base implementation uses put_nowait. You may want to override |
| this method if you want to use blocking, timeouts or custom queue |
| implementations. |
| """ |
| self.queue.put_nowait(record) |
| |
| def prepare(self, record): |
| """ |
| Prepares a record for queuing. The object returned by this method is |
| enqueued. |
| |
| The base implementation formats the record to merge the message |
| and arguments, and removes unpickleable items from the record |
| in-place. |
| |
| You might want to override this method if you want to convert |
| the record to a dict or JSON string, or send a modified copy |
| of the record while leaving the original intact. |
| """ |
| # The format operation gets traceback text into record.exc_text |
| # (if there's exception data), and also returns the formatted |
| # message. We can then use this to replace the original |
| # msg + args, as these might be unpickleable. We also zap the |
| # exc_info attribute, as it's no longer needed and, if not None, |
| # will typically not be pickleable. |
| msg = self.format(record) |
| record.message = msg |
| record.msg = msg |
| record.args = None |
| record.exc_info = None |
| return record |
| |
| def emit(self, record): |
| """ |
| Emit a record. |
| |
| Writes the LogRecord to the queue, preparing it for pickling first. |
| """ |
| try: |
| self.enqueue(self.prepare(record)) |
| except Exception: |
| self.handleError(record) |
| |
| |
| class QueueListener(object): |
| """ |
| This class implements an internal threaded listener which watches for |
| LogRecords being added to a queue, removes them and passes them to a |
| list of handlers for processing. |
| """ |
| _sentinel = None |
| |
| def __init__(self, queue, *handlers, respect_handler_level=False): |
| """ |
| Initialise an instance with the specified queue and |
| handlers. |
| """ |
| self.queue = queue |
| self.handlers = handlers |
| self._thread = None |
| self.respect_handler_level = respect_handler_level |
| |
| def dequeue(self, block): |
| """ |
| Dequeue a record and return it, optionally blocking. |
| |
| The base implementation uses get. You may want to override this method |
| if you want to use timeouts or work with custom queue implementations. |
| """ |
| return self.queue.get(block) |
| |
| def start(self): |
| """ |
| Start the listener. |
| |
| This starts up a background thread to monitor the queue for |
| LogRecords to process. |
| """ |
| self._thread = t = threading.Thread(target=self._monitor) |
| t.daemon = True |
| t.start() |
| |
| def prepare(self , record): |
| """ |
| Prepare a record for handling. |
| |
| This method just returns the passed-in record. You may want to |
| override this method if you need to do any custom marshalling or |
| manipulation of the record before passing it to the handlers. |
| """ |
| return record |
| |
| def handle(self, record): |
| """ |
| Handle a record. |
| |
| This just loops through the handlers offering them the record |
| to handle. |
| """ |
| record = self.prepare(record) |
| for handler in self.handlers: |
| if not self.respect_handler_level: |
| process = True |
| else: |
| process = record.levelno >= handler.level |
| if process: |
| handler.handle(record) |
| |
| def _monitor(self): |
| """ |
| Monitor the queue for records, and ask the handler |
| to deal with them. |
| |
| This method runs on a separate, internal thread. |
| The thread will terminate if it sees a sentinel object in the queue. |
| """ |
| q = self.queue |
| has_task_done = hasattr(q, 'task_done') |
| while True: |
| try: |
| record = self.dequeue(True) |
| if record is self._sentinel: |
| break |
| self.handle(record) |
| if has_task_done: |
| q.task_done() |
| except queue.Empty: |
| break |
| |
| def enqueue_sentinel(self): |
| """ |
| This is used to enqueue the sentinel record. |
| |
| The base implementation uses put_nowait. You may want to override this |
| method if you want to use timeouts or work with custom queue |
| implementations. |
| """ |
| self.queue.put_nowait(self._sentinel) |
| |
| def stop(self): |
| """ |
| Stop the listener. |
| |
| This asks the thread to terminate, and then waits for it to do so. |
| Note that if you don't call this before your application exits, there |
| may be some records still left on the queue, which won't be processed. |
| """ |
| self.enqueue_sentinel() |
| self._thread.join() |
| self._thread = None |