In my project, I use the Python logging module for log service and log to the terminal using a stream handler.
My setup looks like the following:
import logging logger = logging.getLogger('demo project') formatter = logging.Formatter( "[%(asctime)s][%(name)s][%(levelname)s] %(message)s", "%Y-%m-%d %H:%M:%S" ) stream_handler = logging.StreamHandler() stream_handler.setFormatter(formatter) stream_handler.setLevel(logging.INFO) # stream_handler.setLevel(logging.DEBUG) logger.addHandler(stream_handler) logger.setLevel(logging.INFO) logger.info("info message")
Missing log message
This works well when I show info messages. Later, I want to show some debug
messages via my logger. So I set the logger’s logging level to
logger.debug() to print the debug message:
logger.setLevel(logging.DEBUG) logger.debug("some debug info")
Unfortunately, this does not work as intended. When I run my code, no debugging message is shown. Why?
Separate logging levels: logger vs handler
It has something to do how the logging messages are actually logged. Remember that in our first code snippet, we set the level both for the logger and the handler (in this case, a stream handler).
The level setup we use for logger and the handler together decide which message can be logged and which should be rejected. The logger’s level is like the first gate or filter, and the handler’s level is like the second filter.
When a logging message comes, it first passes the logger, and then the handler. If the logging message’s level is no less than the logger’s level, it then goes to the handler. If its level is also no less than handler’s level, the message got logged.
Take the snippet in the second code snippet as an example, the logger’s level
DEBUG, and the handler’s level is
INFO. When we want to log some debug
messages, it has the same level as logger’s level. However, its level is below
the handler’s level (DEBUG vs INFO), so it gets rejected by the handler (i.e.,
the handler will not log it, we see nothing on the terminal output). On the
other hand, if we use a high level for logger, for example
ERROR, and use a
low level for handler, e.g.,
DEBUG, only error loggings will be logged, since
all other logging messages will be rejected by the logger.
The Python doc also has a nice diagram showing the workflow of logging processing, which is much more detailed.
The usefulness of separate logging levels
What is the use of separating the logging level of logger and handler? With this, we can achieve flexible logging plans. For example, we may want to log all messages on the stream handler, but only want to log error messages on the file handler to save space.
stream_handler = logging.StreamHandler() stream_handler.setFormatter(formatter) stream_handler.setLevel(logging.DEBUG) logger.addHandler(stream_handler) file_handler = logging.FileHandler('demo-project.log') file_handler.setFormatter(formatter) file_handler.setLevel(logging.ERROR) logger.addHandler(file_handler) logger.setLevel(logging.DEBUG) logger.debug("debug message") logger.info("info message") logger.warning("warning message") logger.error("error message")
If we run the above code, we can see that all logging messages are shown on the
terminal, but only the error message is logged in
License CC BY-NC-ND 4.0