Inheritance diagram for compat_logging.Handler:

Public Member Functions
def	__init__ (self, level=NOTSET)

def	createLock (self)

def	acquire (self)

def	release (self)

def	setLevel (self, level)

def	format (self, record)

def	emit (self, record)

def	handle (self, record)

def	setFormatter (self, fmt)

def	flush (self)

def	close (self)

def	handleError (self, record)

Public Member Functions inherited from compat_logging.Filterer
def	__init__ (self)

def	addFilter (self, filter)

def	removeFilter (self, filter)

def	filter (self, record)

Public Attributes
	level

	formatter

	lock

Public Attributes inherited from compat_logging.Filterer
	filters

Detailed Description

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.

Constructor & Destructor Documentation

◆ init()

def compat_logging.Handler.__init__	(	self,
		level = `NOTSET`
	)

Initializes the instance - basically setting the formatter to None
and the filter list to empty.

Member Function Documentation

◆ acquire()

def compat_logging.Handler.acquire ( self )

Acquire the I/O thread lock.

◆ close()

def compat_logging.Handler.close ( self )

Tidy up any resources used by the handler.

This version does nothing and is intended to be implemented by
subclasses.

◆ createLock()

def compat_logging.Handler.createLock ( self )

Acquire a thread lock for serializing access to the underlying I/O.

◆ emit()

def compat_logging.Handler.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()

def compat_logging.Handler.flush ( self )

Ensure all logging output has been flushed.

This version does nothing and is intended to be implemented by
subclasses.

◆ format()

def compat_logging.Handler.format	(	self,
		record
	)

Format the specified record.

If a formatter is set, use it. Otherwise, use the default formatter
for the module.

◆ handle()

def compat_logging.Handler.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()

def compat_logging.Handler.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()

def compat_logging.Handler.release ( self )

Release the I/O thread lock.

◆ setFormatter()

def compat_logging.Handler.setFormatter	(	self,
		fmt
	)

Set the formatter for this handler.

◆ setLevel()

def compat_logging.Handler.setLevel	(	self,
		level
	)

Set the logging level of this handler.

Member Data Documentation

◆ formatter

compat_logging.Handler.formatter

◆ level

compat_logging.Handler.level

◆ lock

compat_logging.Handler.lock

The documentation for this class was generated from the following file:

Websites/planet.webkit.org/planet/planet/compat_logging/__init__.py

Public Member Functions

Public Attributes