logging.Handler - pydoc - phpman

Help on class Handler in logging:

logging.Handler = class Handler(Filterer)
 |  logging.Handler(level=0)
 |
 |  Handler instances dispatch logging events to specific destinations.
 |
 |  The base handler class. Acts as a placeholder which defines the Handler
 |  interface. Handlers can optionally use Formatter instances to format
 |  records as desired. By default, no formatter is specified; in this case,
 |  the 'raw' message as determined by record.message is logged.
 |
 |  Method resolution order:
 |      Handler
 |      Filterer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, level=0)
 |      Initializes the instance - basically setting the formatter to None
 |      and the filter list to empty.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  acquire(self)
 |      Acquire the I/O thread lock.
 |
 |  close(self)
 |      Tidy up any resources used by the handler.
 |
 |      This version removes the handler from an internal map of handlers,
 |      _handlers, which is used for handler lookup by name. Subclasses
 |      should ensure that this gets called from overridden close()
 |      methods.
 |
 |  createLock(self)
 |      Acquire a thread lock for serializing access to the underlying I/O.
 |
 |  emit(self, 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 NotImplementedError.
 |
 |  flush(self)
 |      Ensure all logging output has been flushed.
 |
 |      This version does nothing and is intended to be implemented by
 |      subclasses.
 |
 |  format(self, record)
 |      Format the specified record.
 |
 |      If a formatter is set, use it. Otherwise, use the default formatter
 |      for the module.
 |
 |  get_name(self)
 |
 |  handle(self, record)
 |      Conditionally emit the specified logging record.
 |
 |      Emission depends on filters which may have been added to the handler.
 |      Wrap the actual emission of the record with acquisition/release of
 |      the I/O thread lock. Returns whether the filter passed the record for
 |      emission.
 |
 |  handleError(self, record)
 |      Handle errors which occur during an emit() call.
 |
 |      This method should be called from handlers when an exception is
 |      encountered during an emit() call. If 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 record which was being processed is passed in to this method.
 |
 |  release(self)
 |      Release the I/O thread lock.
 |
 |  setFormatter(self, fmt)
 |      Set the formatter for this handler.
 |
 |  setLevel(self, level)
 |      Set the logging level of this handler.  level must be an int or a str.
 |
 |  set_name(self, name)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  name
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Filterer:
 |
 |  addFilter(self, filter)
 |      Add the specified filter to this handler.
 |
 |  filter(self, record)
 |      Determine if a record is loggable by consulting all the filters.
 |
 |      The default is to allow the record to be logged; any filter can veto
 |      this and the record is then dropped. Returns a zero value if a record
 |      is to be dropped, else non-zero.
 |
 |      .. versionchanged:: 3.2
 |
 |         Allow filters to be just callables.
 |
 |  removeFilter(self, filter)
 |      Remove the specified filter from this handler.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Filterer:
 |
 |  __dict__
 |      dictionary for instance variables (if defined)
 |
 |  __weakref__
 |      list of weak references to the object (if defined)