logging-exceptions 0.1.8

Self-logging exceptions

Attach a log message to an exception:

import logging
import logging_exceptions as exlog

e = ValueError("Wrong value")
logger = logging.getLogger(__name__)
with exlog.log_to_exception(logger, e):
    logger.critical("This is a %s log mressage", "long")
raise e # The exception can also be raised inside the with statement

If the error is not caught, the log message will be displayed upon program termination.

Catch the error and display the log message at a costum log-level:

import logging_exceptions as exlog
import logging
try:
    e = ValueError("Wrong value")
    logger = logging.getLogger(__name__)
    with exlog.log_to_exception(logger, e):
        logger.critical("This is a %s log mressage", "long")
        raise e
except ValueError as err:
    exlog.log(err, level=logging.DEBUG, with_stacktrace=False)

Here, exlog.log is a synonym for exlog.log_exception

Logging from a different function name and line number

The code in log_exception calls the _log function of a Logger object. To avoid recording the function name and line number of log_to_exception, logging_exception calls logging.setLoggerClass(ExlogLogger) to set the class for all loggers created after import of logging_exception to ExlogLogger.

ExlogLogger is a subclass of logging.Logger defined by this module. It overrides findCaller to have more control over the recorded caller. In addition to ignoring functions defined inside logging_exceptions, ExlogLogger classes have the public attribute ignored_functions.

By adding function names to ignored_functions, it is possible to record matching function’s parents instead of matching functions as the caller.

In particular, the context manager logging_exceptions.log_at_caller can be used in helper functions to temporarily update a logger’s ignored_functions in order to record a function’s caller instead of the function.

The following code will emit a log message with the function name set to foo, not helper_function:

import logging_exceptions as exlog
logger = logging.get_logger(__name__)
def helper_function():
   with exlog.log_at_caller(logger):
     logger.log("This is a log message")
def foo():
   helper_function()

Commandline convenience functions

The following convenience functions are not directly related to exceptions, but useful if you use argparse.

Add the ‘–verbose’, ‘–debug’ and ‘–quiet’ options to an argparse.Argumentparser instance.

import argparse
import logging_exceptions as exlog

parser=argparse.ArgumentParser("Some help text")
exlog.update_parser(parser)
args = parser.parse_args()

logging.basicConfig()
# The following call updates the log levels of the root logger
# and potential some other loggers.
exlog.config_from_args(args)

Now the script can be used from the commandline like this:

# Set the log-level for the loggers with the names `path.to.module1`
# and `path.to.module2` to DEBUG.
python script.py --debug path.to.module1,path.to.module2