class documentation

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: object, owner: Optional[type] = None) -> Logger: (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.

def __init__(self, namespace: Optional[str] = None, source: Optional[object] = None, observer: Optional[ILogObserver] = 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) -> str: (source)

Undocumented

def critical(self, format: Optional[str] = None, **kwargs: object): (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:objectadditional 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: Optional[str] = None, **kwargs: object): (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:objectadditional 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: LogLevel, format: Optional[str] = None, **kwargs: object): (source)

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

Parameters
level:LogLevela 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:objectadditional 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: Optional[str] = None, **kwargs: object): (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:objectadditional 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: str, failure: Optional[Failure] = None, level: LogLevel = LogLevel.critical, **kwargs: object): (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:stra 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:LogLevela LogLevel to use.
**kwargs:objectadditional 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: Optional[str] = None, **kwargs: object): (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:objectadditional 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: Optional[str] = None, **kwargs: object): (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:objectadditional 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.

The object which is emitting events via this logger

@staticmethod
def _namespaceFromCallingContext() -> str: (source)

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

Returns
strthe fully qualified python name of a module.