Log Level Of File Handler Vs. That Of Logger

To set up logging in Python without basicConfig we would go through the steps: Set up a file handler. Set the logging level of the file handler. Set up a formatter. Point the file

Solution 1:

Okay, so here is a small bit of code to work out:

import logging


# Declare a function to log all 5 levels with different informationdeflog_all_levels(logger):
    logger.debug("Debug from logger {}".format(logger.name))
    logger.info("Info from logger {}".format(logger.name))
    logger.warning("Warning from logger {}".format(logger.name))
    logger.error("Error from logger {}".format(logger.name))
    logger.critical("Fatal from logger {}".format(logger.name))


# This file handler will track errors from all loggers
all_errors_handler = logging.FileHandler('errors.log')
all_errors_handler.setLevel(logging.ERROR)

# This file handler will only be used in a specific region of code
foo_info_handler = logging.FileHandler('foo_info.log')
foo_info_handler.setLevel(logging.INFO)
foo_info_handler.addFilter(lambda r: r.levelno == logging.INFO)

# The following loggers will be used in the main execution
foo_logger = logging.getLogger("Foo")
nameless_logger = logging.getLogger("nameless")
foo_logger.setLevel(logging.INFO)
nameless_logger.setLevel(logging.DEBUG)
loggers = (foo_logger, nameless_logger)

# Set each logger up to use the file handlers# Each logger can have many handlers, each handler can be used by many loggersfor logger in loggers:
    logger.addHandler(all_errors_handler)
    debug_file_handler = logging.FileHandler('{}.log'.format(logger.name))
    debug_file_handler.setLevel(logging.DEBUG)
    logger.addHandler(debug_file_handler)
    if logger.name == "Foo":
        logger.addHandler(foo_info_handler)


# Let's run some logging operationsfor logger in loggers:
    log_all_levels(logger)

There are 2 loggers - foo_logger set to the info level and nameless_logger set to the debug level. Both of them use the errors and debug handlers, however only the foo_logger uses the foo_file_handler. There are now loggers and file handlers with different levels, connected together in a many-to-many relationship.

As you can find out:

1. errors.log will contain errors from both loggers. Quite self-explanatory for a real life scenario - reading through logs containing just the errors helps debugging the code.
2. Foo.log and nameless.log will contain everything possible about those loggers, respecting their levels. So the former will contain info and greater, whereas the latter will track debug and greater levels. Logging per object will potentially create a lot of files, but it might be crucial when trying to detect some object-specific errors.
3. foo_info is a very special file handler and it only allows info level from the associated logger. Such files can be a life saver when you enter a potentially unsafe or untested area of code and would like to see what exactly is happening within that code block, without having to browse through all your program log.

There are many other things you can do with logging - set up your own logging rules, make a logging hierarchy, create a logger factory - possibilities are endless. Logging should allow flexibility - for example by allowing logger objects and file handlers to have different and separate logging levels, and letting the programmer combine them together as needed.

I hope the small code exercise alongside with my explanations cleared any further doubts - but I do recommend to have a look at Logging Cookbook or the docs if you still need more examples.