twisted.logger.Logger

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.

Undocumented

Emit a log event at log level LogLevel.critical.

Emit a log event at log level LogLevel.debug.

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

Emit a log event at log level LogLevel.error.

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 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. 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.

For performance-sensitive frameworks that needs to handle potential failures from frequently-called application code, and do not need to include detailed structured information about the failure nor inspect the result of the operation, this method returns a context manager that will log exceptions and continue, that can be shared across multiple invocations. It should be instantiated at module scope to avoid additional object creations.

For example:

    log = Logger(...)
    ignoringFrobErrors = log.failureHandler("while frobbing:")

    def hotLoop() -> None:
        with ignoringFrobErrors:
            frob()

This method is meant to capture unexpected exceptions from application 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.

Run some application code, logging a failure and emitting a traceback in the event that any of it fails, but continuing on. For example:

    log = Logger(...)

    def frameworkCode() -> None:
        with log.failuresHandled("While frobbing {knob}:", knob=knob) as op:
            frob(knob)
        if op.succeeded:
            log.info("frobbed {knob} successfully", knob=knob)

This method is meant to capture unexpected exceptions from application 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. 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.

Emit a log event at log level LogLevel.info.

Emit a log event at log level LogLevel.warn.