twisted.logger.Logger

namespace =

the namespace for this logger (type: str)

source =

The object which is emitting events via this logger (type: object)

observer =

The observer that this logger will send events to.

@staticmethod
def _namespaceFromCallingContext():

Derive a namespace from the module containing the caller's caller.

Returns the fully qualified python name of a module. (type: str (native string))

def __init__(self, namespace=None, source=None, observer=None):

Parameters	namespace	The namespace for this logger. Uses a dotted notation, as used by python modules. If not `None`, then the name of the module of the caller is used. (type: `str` (native string))
	source	The object which is emitting events via this logger; this is automatically set on instances of a class if this `Logger` is an attribute of that class. (type: `object`)
	observer	The observer that this logger will send events to. If `None`, use the `global log publisher`. (type: `ILogObserver`)

def __get__(self, oself, type=None):

When used as a descriptor, i.e.:

   # File: athing.py
   class Something(object):
       log = Logger()
       def hello(self):
           self.log.info("Hello")

a Logger's namespace will be set to the name of the class it is declared on. In the above example, the namespace would be athing.Something.

Additionally, its source will be set to the actual object referring to the Logger. In the above example, Something.log.source would be Something, and Something().log.source would be an instance of Something.

def __repr__(self):

Undocumented

def emit(self, level, format=None, **kwargs):

overridden in twisted.logger.test.test_logger.TestLogger

Emit a log event to all log observers at the given level.

Parameters	level	a `LogLevel`
	format	a message format using new-style (PEP 3101) formatting. The logging event (which is a `dict`) is used to render this format string.
	kwargs	additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution.

def failure(self, format, failure=None, level=LogLevel.critical, **kwargs):

Log a failure and emit a traceback.

For example:

   try:
       frob(knob)
   except Exception:
       log.failure("While frobbing {knob}", knob=knob)

or:

   d = deferredFrob(knob)
   d.addErrback(lambda f: log.failure("While frobbing {knob}",
                                      f, knob=knob))

This method is generally meant to capture unexpected exceptions in code; an exception that is caught and handled somehow should be logged, if appropriate, via Logger.error instead. If some unknown exception occurs and your code doesn't know how to handle it, as in the above example, then this method provides a means to describe the failure in nerd-speak. This is done at LogLevel.critical by default, since no corrective guidance can be offered to an user/administrator, and the impact of the condition is unknown.

Parameters	format	a message format using new-style (PEP 3101) formatting. The logging event (which is a `dict`) is used to render this format string.
	failure	a `Failure` to log. If `None`, a `Failure` is created from the exception in flight.
	level	a `LogLevel` to use.
	kwargs	additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution.

def debug(self, format=None, **kwargs):

Emit a log event at log level LogLevel.debug.

Parameters	format	a message format using new-style (PEP 3101) formatting. The logging event (which is a `dict`) is used to render this format string.
	kwargs	additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution.

def info(self, format=None, **kwargs):

Emit a log event at log level LogLevel.info.

Parameters	format	a message format using new-style (PEP 3101) formatting. The logging event (which is a `dict`) is used to render this format string.
	kwargs	additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution.

def warn(self, format=None, **kwargs):

Emit a log event at log level LogLevel.warn.

Parameters	format	a message format using new-style (PEP 3101) formatting. The logging event (which is a `dict`) is used to render this format string.
	kwargs	additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution.

def error(self, format=None, **kwargs):

Emit a log event at log level LogLevel.error.

Parameters	format	a message format using new-style (PEP 3101) formatting. The logging event (which is a `dict`) is used to render this format string.
	kwargs	additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution.

def critical(self, format=None, **kwargs):

Emit a log event at log level LogLevel.critical.

Parameters	format	a message format using new-style (PEP 3101) formatting. The logging event (which is a `dict`) is used to render this format string.
	kwargs	additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution.

Instance Variable	namespace	the namespace for this logger (type: `str`)
Instance Variable	source	The object which is emitting events via this logger (type: `object`)
Instance Variable	observer	The observer that this logger will send events to.
Method	__init__	No summary
Method	__get__	When used as a descriptor, i.e.:
Method	__repr__	Undocumented
Method	emit	Emit a log event to all log observers at the given level.
Method	failure	Log a failure and emit a traceback.
Method	debug	Emit a log event at log level `LogLevel.debug`.
Method	info	Emit a log event at log level `LogLevel.info`.
Method	warn	Emit a log event at log level `LogLevel.warn`.
Method	error	Emit a log event at log level `LogLevel.error`.
Method	critical	Emit a log event at log level `LogLevel.critical`.
Static Method	_namespaceFromCallingContext	Derive a namespace from the module containing the caller's caller.

twisted.logger.Logger(object) class documentation

`twisted.logger.Logger(object)` class documentation