.. attribute:: Logger.propagate
- If this evaluates to true, events logged to this logger will be passed to the
- handlers of higher level (ancestor) loggers, in addition to any handlers
- attached to this logger. Messages are passed directly to the ancestor
- loggers' handlers - neither the level nor filters of the ancestor loggers in
- question are considered.
+ If this attribute evaluates to true, events logged to this logger will be
+ passed to the handlers of higher level (ancestor) loggers, in addition to
+ any handlers attached to this logger. Messages are passed directly to the
+ ancestor loggers' handlers - neither the level nor filters of the ancestor
+ loggers in question are considered.
If this evaluates to false, logging messages are not passed to the handlers
of ancestor loggers.
subclasses. However, the :meth:`__init__` method in subclasses needs to call
:meth:`Handler.__init__`.
+.. class:: Handler
-.. method:: Handler.__init__(level=NOTSET)
+ .. method:: Handler.__init__(level=NOTSET)
- Initializes the :class:`Handler` instance by setting its level, setting the list
- of filters to the empty list and creating a lock (using :meth:`createLock`) for
- serializing access to an I/O mechanism.
+ Initializes the :class:`Handler` instance by setting its level, setting the list
+ of filters to the empty list and creating a lock (using :meth:`createLock`) for
+ serializing access to an I/O mechanism.
-.. method:: Handler.createLock()
+ .. method:: Handler.createLock()
- Initializes a thread lock which can be used to serialize access to underlying
- I/O functionality which may not be threadsafe.
+ Initializes a thread lock which can be used to serialize access to underlying
+ I/O functionality which may not be threadsafe.
-.. method:: Handler.acquire()
+ .. method:: Handler.acquire()
- Acquires the thread lock created with :meth:`createLock`.
+ Acquires the thread lock created with :meth:`createLock`.
-.. method:: Handler.release()
+ .. method:: Handler.release()
- Releases the thread lock acquired with :meth:`acquire`.
+ Releases the thread lock acquired with :meth:`acquire`.
-.. method:: Handler.setLevel(lvl)
+ .. method:: Handler.setLevel(lvl)
- Sets the threshold for this handler to *lvl*. Logging messages which are less
- severe than *lvl* will be ignored. When a handler is created, the level is set
- to :const:`NOTSET` (which causes all messages to be processed).
+ Sets the threshold for this handler to *lvl*. Logging messages which are less
+ severe than *lvl* will be ignored. When a handler is created, the level is set
+ to :const:`NOTSET` (which causes all messages to be processed).
- See :ref:`levels` for a list of levels.
+ See :ref:`levels` for a list of levels.
- .. versionchanged:: 3.2
- The *lvl* parameter now accepts a string representation of the
- level such as 'INFO' as an alternative to the integer constants
- such as :const:`INFO`.
+ .. versionchanged:: 3.2
+ The *lvl* parameter now accepts a string representation of the
+ level such as 'INFO' as an alternative to the integer constants
+ such as :const:`INFO`.
-.. method:: Handler.setFormatter(form)
+ .. method:: Handler.setFormatter(form)
- Sets the :class:`Formatter` for this handler to *form*.
+ Sets the :class:`Formatter` for this handler to *form*.
-.. method:: Handler.addFilter(filt)
+ .. method:: Handler.addFilter(filt)
- Adds the specified filter *filt* to this handler.
+ Adds the specified filter *filt* to this handler.
-.. method:: Handler.removeFilter(filt)
+ .. method:: Handler.removeFilter(filt)
- Removes the specified filter *filt* from this handler.
+ Removes the specified filter *filt* from this handler.
-.. method:: Handler.filter(record)
+ .. method:: Handler.filter(record)
- Applies this handler's filters to the record and returns a true value if the
- record is to be processed. The filters are consulted in turn, until one of
- them returns a false value. If none of them return a false value, the record
- will be emitted. If one returns a false value, the handler will not emit the
- record.
+ Applies this handler's filters to the record and returns a true value if the
+ record is to be processed. The filters are consulted in turn, until one of
+ them returns a false value. If none of them return a false value, the record
+ will be emitted. If one returns a false value, the handler will not emit the
+ record.
-.. method:: Handler.flush()
+ .. method:: Handler.flush()
- Ensure all logging output has been flushed. This version does nothing and is
- intended to be implemented by subclasses.
+ Ensure all logging output has been flushed. This version does nothing and is
+ intended to be implemented by subclasses.
-.. method:: Handler.close()
+ .. method:: Handler.close()
- Tidy up any resources used by the handler. This version does no output but
- removes the handler from an internal list of handlers which is closed when
- :func:`shutdown` is called. Subclasses should ensure that this gets called
- from overridden :meth:`close` methods.
+ Tidy up any resources used by the handler. This version does no output but
+ removes the handler from an internal list of handlers which is closed when
+ :func:`shutdown` is called. Subclasses should ensure that this gets called
+ from overridden :meth:`close` methods.
-.. method:: Handler.handle(record)
+ .. method:: Handler.handle(record)
- Conditionally emits the specified logging record, depending on filters which may
- have been added to the handler. Wraps the actual emission of the record with
- acquisition/release of the I/O thread lock.
+ Conditionally emits the specified logging record, depending on filters which may
+ have been added to the handler. Wraps the actual emission of the record with
+ acquisition/release of the I/O thread lock.
-.. method:: Handler.handleError(record)
+ .. method:: Handler.handleError(record)
- This method should be called from handlers when an exception is encountered
- during an :meth:`emit` call. If the module-level attribute
- ``raiseExceptions`` is ``False``, exceptions get silently ignored. This is
- what is mostly wanted for a logging system - most users will not care about
- errors in the logging system, they are more interested in application
- errors. You could, however, replace this with a custom handler if you wish.
- The specified record is the one which was being processed when the exception
- occurred. (The default value of ``raiseExceptions`` is ``True``, as that is
- more useful during development).
+ This method should be called from handlers when an exception is encountered
+ during an :meth:`emit` call. If the module-level attribute
+ ``raiseExceptions`` is ``False``, exceptions get silently ignored. This is
+ what is mostly wanted for a logging system - most users will not care about
+ errors in the logging system, they are more interested in application
+ errors. You could, however, replace this with a custom handler if you wish.
+ The specified record is the one which was being processed when the exception
+ occurred. (The default value of ``raiseExceptions`` is ``True``, as that is
+ more useful during development).
-.. method:: Handler.format(record)
+ .. method:: Handler.format(record)
- Do formatting for a record - if a formatter is set, use it. Otherwise, use the
- default formatter for the module.
+ Do formatting for a record - if a formatter is set, use it. Otherwise, use the
+ default formatter for the module.
-.. method:: Handler.emit(record)
+ .. method:: Handler.emit(record)
- Do whatever it takes to actually log the specified logging record. This version
- is intended to be implemented by subclasses and so raises a
- :exc:`NotImplementedError`.
+ Do whatever it takes to actually log the specified logging record. This version
+ is intended to be implemented by subclasses and so raises a
+ :exc:`NotImplementedError`.
For a list of handlers included as standard, see :mod:`logging.handlers`.
projects / python / commitdiff