Go to the latest version of this document.
search in docstrings

Search bar offers the following options:

- Term presence. The below example searches for documents that must contain “foo”, might contain “bar” and must not contain “baz”: `+foo bar -baz`
- Wildcards. The below example searches for documents with words beginning with “foo”: `foo*`
- Search in specific fields. The following search matches all objects in "twisted.mail" that matches “search”: `+qname:twisted.mail.* +search`

  Possible fields: 'name', 'qname' (fully qualified name), 'docstring', and 'kind'. Last two fields are only applicable if "search in docstrings" is enabled.

- Fuzzy matches. The following search matches all documents that have a word within 1 edit distance of “foo”: `foo~1`

Results provided by Lunr.js

# ``twisted`.`logger`.`Logger``

class documentation

`class Logger: (source)`

View In Hierarchy

A `Logger` emits log messages to an observer. You should instantiate it as a class or module attribute, as documented in `this module's documentation`.

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

def __get__(self, instance, owner=None): (source)

When used as a descriptor, i.e.:

        # File: athing.py
        class Something:
            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`.

Parameters
instance:`object` | Undocumented
owner:`Optional[type]` | Undocumented
Returns
`Logger` | Undocumented

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

Parameters
namespace:`Optional[str]` | 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.
source:`Optional[object]` | 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.
observer:`Optional[ILogObserver]` | The observer that this logger will send events to. If `None`, use the `global log publisher`.

def __repr__(self): (source)

Undocumented

Returns
`str` | Undocumented

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

Emit a log event at log level `LogLevel.critical`.

Parameters
format:`Optional[str]` | a message format using new-style (PEP 3101) formatting. The logging event (which is a `dict`) is used to render this format string.
**kwargs:`object` | 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): (source)

Emit a log event at log level `LogLevel.debug`.

Parameters
format:`Optional[str]` | a message format using new-style (PEP 3101) formatting. The logging event (which is a `dict`) is used to render this format string.
**kwargs:`object` | 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 emit(self, level, format=None, **kwargs): (source)

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

Parameters
level:`LogLevel` | a `LogLevel`
format:`Optional[str]` | a message format using new-style (PEP 3101) formatting. The logging event (which is a `dict`) is used to render this format string.
**kwargs:`object` | 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): (source)

Emit a log event at log level `LogLevel.error`.

Parameters
format:`Optional[str]` | a message format using new-style (PEP 3101) formatting. The logging event (which is a `dict`) is used to render this format string.
**kwargs:`object` | 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): (source)

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:`str` | a message format using new-style (PEP 3101) formatting. The logging event (which is a `dict`) is used to render this format string.
failure:`Optional[Failure]` | a `Failure` to log. If `None`, a `Failure` is created from the exception in flight.
level:`LogLevel` | a `LogLevel` to use.
**kwargs:`object` | 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): (source)

Emit a log event at log level `LogLevel.info`.

Parameters
format:`Optional[str]` | a message format using new-style (PEP 3101) formatting. The logging event (which is a `dict`) is used to render this format string.
**kwargs:`object` | 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): (source)

Emit a log event at log level `LogLevel.warn`.

Parameters
format:`Optional[str]` | a message format using new-style (PEP 3101) formatting. The logging event (which is a `dict`) is used to render this format string.
**kwargs:`object` | 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.

namespace = (source)

the namespace for this logger

observer: `ILogObserver` = (source)

The observer that this logger will send events to.

source = (source)

The object which is emitting events via this logger

@staticmethod
def _namespaceFromCallingContext(): (source)

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

Returns
`str` | the fully qualified python name of a module.