Thursday, August 11, 2022

Logging in Python

Final Up to date on Might 20, 2022

Logging is a method to retailer details about your script and monitor occasions that happen. When writing any complicated script in Python, logging is crucial for debugging software program as you develop it. With out logging, discovering the supply of an issue in your code could also be extraordinarily time consuming.

After finishing this tutorial, you’ll know:

  • Why we wish to use the logging module
  • The best way to use the logging module
  • The best way to customise the logging mechanism

Let’s get began.

Logging in Python
Picture by ilaria88. Some rights reserved.

Tutorial Overview

This tutorial is split into 4 components; they’re:

  • The advantages of logging
  • Primary logging
  • Superior configuration to logging
  • An instance of using logging

Advantages of Logging

It’s possible you’ll ask: “Why not simply use printing?”

If you run an algorithm and need to affirm it’s doing what you anticipated, it’s pure so as to add some print() statements at strategic places to point out this system’s state. Printing can assist debug less complicated scripts, however as your code will get increasingly more complicated, printing lacks the pliability and robustness that logging has.

With logging, you’ll be able to pinpoint the place a logging name got here from, differentiate severity between messages, and write info to a file, which printing can not do. For instance, we are able to activate and off the message from a selected module of a bigger program. We will additionally enhance or lower the verbosity of the logging messages with out altering a whole lot of code.

Primary Logging

Python has a built-in library, logging, for this goal. It’s easy to create a “logger” to log messages or info that you just wish to see.

The logging system in Python operates underneath a hierarchical namespace and completely different ranges of severity. The Python script can create a logger underneath a namespace, and each time a message is logged, the script should specify its severity. The logged message can go to completely different locations relying on the handler we arrange for the namespace. The commonest handler is to easily print on the display screen, like the ever-present print() perform. After we begin this system, we could register a brand new handler and arrange the extent of severity to which the handler will react.

There are 5 completely different logging ranges that point out the severity of the logs, proven in rising severity:

  1. DEBUG
  2. INFO
  4. ERROR

A quite simple instance of logging is proven beneath, utilizing the default logger or the foundation logger:

These will emit log messages of various severity. Whereas there are 5 strains of logging, you might even see solely three strains of output in case you run this script, as follows:

It is because the foundation logger, by default, solely prints the log messages of a severity degree of WARNING or above. Nevertheless, utilizing the foundation logger this fashion is just not a lot completely different from utilizing the print() perform.

The settings for the foundation logger usually are not set in stone. We will configure the foundation logger to output to a selected file, change its default severity degree, and format the output. Right here’s an instance:

Working this script will produce no output to the display screen however may have the next within the newly created file file.log:

The decision to logging.basicConfig() is to change the foundation logger. In our instance, we set the handler to output to a file as an alternative of the display screen, modify the logging degree such that every one log messages of degree DEBUG or above are dealt with, and in addition change the format of the log message output to incorporate the time.

Observe that now all 5 messages have been output, so the default degree that the foundation logger logs is now “DEBUG.” The log report attributes (equivalent to %(asctime)s) that can be utilized to format the output might be discovered within the logging documentation.

Though there’s a default logger, we often need to make and use different loggers that may be configured individually. It is because we could need a completely different severity degree or format for various loggers. A brand new logger might be created with:

Internally, the loggers are organized in a hierarchy. A logger created with:

might be a baby logger created underneath the logger with the title “mum or dad,” which, in flip, is underneath the foundation logger. Utilizing a dot within the string signifies that the kid logger is a baby of the mum or dad logger. Within the above case, a logger with the title “mum or dad.youngster” is created in addition to one with the title "mum or dad" implicitly.

Upon creation, a baby logger has all of the properties of its mum or dad logger till reconfigured. We will display this with the next instance:

This code snippet will output just one line:

which is created by the StreamHandler object with the custom-made format string. It occurs solely after we reconfigured the logger for mum or dad as a result of in any other case, the foundation logger’s configuration prevails, and no messages at degree INFO might be printed.

Superior Configuration to Logging

As we noticed within the final instance, we are able to configure the loggers we made.

Threshold of Stage

Like the fundamental configuration of the foundation logger, we are able to additionally configure the output vacation spot, severity degree, and formatting of a logger. The next is how we are able to set the threshold of the extent of a logger to INFO:

Now instructions with severity degree INFO and better might be logged by the parent_logger. But when that is all you probably did, you’ll not see something from parent_logger.information("messages") as a result of there are not any handlers assigned for this logger. Actually, there are not any handlers for root logger as nicely except you arrange one with logging.basicConfig().

Log Handlers

We will configure the output vacation spot of our logger with handlers. Handlers are chargeable for sending the log messages to the proper vacation spot. There are a number of sorts of handlers; the most typical ones are StreamHandler and FileHandler. With StreamHandler, the logger will output to the terminal, whereas with FileHandler, the logger will output to a selected file.

Right here’s an instance of utilizing StreamHandler to output logs to the terminal:

Within the code above, there are two handlers created: A FileHandler created by logging.basicConfig() for the foundation logger and a StreamHandler created for the mum or dad logger.

Observe that despite the fact that there’s a StreamHandler that sends the logs to the terminal, logs from the mum or dad logger are nonetheless being despatched to file.log since it’s a youngster of the foundation logger, and the foundation logger’s handler can be energetic for the kid’s log messages. We will see that the logs to the terminal embody INFO degree messages and above:

However the output to the terminal is just not formatted, as we’ve not used a Formatter but. The log to file.log, nonetheless, has a Formatter arrange, and it is going to be like the next:

Alternatively, we are able to use FileHandler within the above instance of parent_logger:

The instance above demonstrated that you may additionally set the extent of a handler. The extent of parent_fhandler filters out logs that aren’t WARNING degree or greater. Nevertheless, in case you set the handler’s degree to DEBUG, that might be the identical as not setting the extent as a result of DEBUG logs would already be filtered out by the logger’s degree, which is INFO.

On this case, the output to mum or dad.log is:

whereas that of file.log is identical as earlier than. In abstract, when a log message is recorded by a logger,

  1. The logger’s degree will decide if the message is extreme sufficient to be dealt with. If the logger’s degree is just not set, the extent of its mum or dad (and in the end the foundation logger) might be used for this consideration.
  2. If the log message might be dealt with, all handlers ever added alongside the logger hierarchy as much as the foundation logger will obtain a duplicate of the message. Every handler’s degree will decide if this explicit handler ought to honor this message.


To configure the format of the logger, we use a Formatter. It permits us to set the format of the log, equally to how we did so within the root logger’s basicConfig(). That is how we are able to add a formatter to our handler:

First, we create a formatter, then set our handler to make use of that formatter. If we needed to, we might make a number of completely different loggers, handlers, and formatters in order that we might combine and match based mostly on our preferences.

On this instance, the mum or dad.log may have:

and the file.log related to the handler at root logger may have:

Beneath is the visualization of the circulate of loggers, handlers, and formatters from the documentation of the logging module:

Circulation chart of loggers and handlers within the logging module

An Instance of the Use of Logging

Let’s take into account the Nadam algorithm for instance:

The only use case is to make use of logging to switch the print() perform. We will make the next change: First, create a logger with the title nadam earlier than we run any code and assign a StreamHandler:

We should assign a handler as a result of we by no means configured the foundation logger, and this is able to be the one handler ever created. Then, within the perform nadam(), we re-create a logger nadam, however because it has already been arrange, the extent and handlers continued. On the finish of every outer for-loop in nadam(), we changed the print() perform with logger.information() so the message might be dealt with by the logging system:

If we have an interest within the deeper mechanics of the Nadam algorithm, we could add extra logs. The next is the entire code:

We ready two degree of loggers, nadam and nadam.iter, and set them in several ranges. Within the interior loop of nadam(), we use the kid logger to print some inner variables. If you run this script, it would print the next:

Setting completely different loggers not solely permits us to set a distinct degree or handlers, however it additionally lets us differentiate the place the log message comes from by trying on the logger’s title from the message printed.

Actually, one useful trick is to create a logging decorator and apply the decorator to some capabilities. We will maintain monitor of each time that perform is known as. For instance, we created a decorator beneath and utilized it to the capabilities goal() and spinoff():

Then we’ll see the next within the log:

the place we are able to see the parameters and return values of every name to these two capabilities within the message logged by the nadam.perform logger.

As we get increasingly more log messages, the terminal display screen will grow to be very busy. One method to make it simpler to look at for points is to spotlight the logs in colour with the colorama module. It’s worthwhile to have the module put in first:

Right here’s an instance of how you need to use the colorama module with the logging module to vary your log colours and textual content brightness:

From the terminal, you’d see the next:

the place the Fore, Again, and Type from the colorama module management the foreground, background, and brightness fashion of the textual content printed. That is leveraging the ANSI escape characters and works solely on ANSI-supported terminals. Therefore this isn’t appropriate for logging to a textual content file.

Actually, we could derive the Formatter class with:

and use this as an alternative of logging.Formatter. The next is how we are able to additional modify the Nadam instance so as to add colour:

If we run it on a supporting terminal, we’ll see the next output:

Observe that the colourful output can assist us spot any irregular habits simpler. Logging helps with debugging and in addition permits us to simply management how a lot element we need to see by altering just a few strains of code.

Additional Studying

This part offers extra assets on the subject if you’re trying to go deeper.




On this tutorial, you realized learn how to implement logging methods in your scripts.

Particularly, you realized:

  • Primary and superior logging methods
  • The best way to apply logging to a script and the advantages of doing so


Please enter your comment!
Please enter your name here

Most Popular

Recent Comments