Python Logging Basic – What You Need To Know

Share on facebook
Share on twitter
Share on linkedin
Share on email

Logging is an important part of building an application, especially today when there are multiple fronts involved in making a single solution. As the development complexities increase, effective management is the key to ensure the intended results. 

Using logs while building a solution helps with debugging and sorting out the application issues while keeping a check on its performance throughout the development cycle. Python comes with a logging module with some of the most-used logging features making it easier for developers to record the workings of the development cycle. 

Here’s a detailed excerpt on python logging, its features, and its implementation. 

What is Python Logging?

Python Logging represents an event tracking mechanism while an application or software runs. Developers use logging to identify the underlying cause of a problem in case the program or software crashes. 

Without logging, locating the cause of a crash or bug is not easy. Logging helps you follow a trail of crashes and issues that lead to the main issue causing crashes and other performance errors in the application or software. 

Not using Python logging complicates finding any sort of bugs or errors in the developed solution. 

Every event recorded and described via logging contains variable data. This data is potentially different for each log created, and it’s connected to the event occurrence. Furthermore, in Python, the developers can also prescribe each logged event with a level or severity of the case. 

How do you log in Python?

Python has an in-built logging module available in the Python Standard library accessible to the developers. To log to a console, program, or file, you need to write the basic command with logging.basicConfig(). 

Within the brackets, you need to fill the level and the message, which will be visible at the console and readable by anyone looking at the logs at a later time. 

For logging, you need loggers, which are basically entities that a developer can create and configure to record the log messages in different formats. 

Loggers help organize the logging reports as they can be edited to send reports to a file with a different logging level connected to a specific module. It’s the person working with the Python logging format who needs to understand the module and logging level. 

The Logging Module

The Python logging module is an all-powerful tool catering to the logging needs of beginners and that of enterprises. A logging module can be integrated with third-party Python libraries. 

Since there isn’t one third-party integration, the logging module collaborates the logs from all of them to create a common log for the entire application. 

It makes identifying the errors, causes, and other essential events in the solution simpler, faster, and more efficient. 

Getting the module onboard is done by a simple code fragment import logging

Once the logging module is imported, you can use the logger to create and record messages readable by others on the team. 

Adding events on the logger is generally oriented under five levels indicating their severity. The Python logging levels are DEBUG, INFO, WARNING, ERROR, and CRITICAL. The names of these levels are self-explanatory, and the intended reader is supposed to work on the part of the code script, which has been added along with the level. 

To understand it better, follow the Python logging example below;

Import logging

Logging.debug( ‘debug xyz’ )

Logging.info( ‘working as expected’ )

Logging.warning( ‘disk space low’ )

Logging.error( ‘carousel not performing’ )

Logging.critical( ‘login function unresponsive’ )

The output of the above Python logging format will look like this;

DEBUG:root: debug xyz

INFO:root: working as expected

WARNING:root: disk space low

ERROR:root: carousel not performing

CRITICAL:root: login function unresponsive

From Debug to Critical, each level’s severity increases subsequently, and the developers accessing the logs must work to resolve the critical logs first and then moving upwards to Debug. 

Basic Configurations

Let’s see about a couple of configurations in Python logging. The purpose of configuring the log messages is to ensure that they go to their intended place or target. 

The Python logging module that we just talked about above gives you plenty of ways to do this, so rest assured that the configuration is simple. 

The severity level functions debug, info, error, warning, and critical will automatically call basicConfig() if they have an undefined handler in their logger. 

Basic configurations are executed under some common parameters, including level, filename, filemode, and format. 

The level is severity level (talked about above), and the filename is the file to which the message is logged. Filemode tells in which mode the file will open (by default, it’s an append). 

Lastly, the format is meant to show the format of the log message. 

Here’s an example of how the basic configuration will look like with a severity level added. 

logging.basicConfig(level=logging.DEBUG)

logging.debug( ‘This will be logged’ )

Formatting the output

There are no limitations to adding a string from the existing application you are building to relay a message to the logs. Having said that, some basic elements have already been added to LogRecord, and they can be used within the output format you are creating for the Python logging message board. 

Another thing to note here is the formatter is already set to continue to use; if not, you can always use the default formatter for the output. 

Here is what the default formatter goes like;

BASIC_FORMAT = “%(levelname)s:%(name)s:%message)s”

While this is the default string, the log recorder can take any sort of string compatible with LogRecord. You will find the entire list of usable attributes here (start looking from 1640).

Classes and Functions

Classes and Functions in Python logging are present if there are multiple modules of the application, which normally is the case almost every time. So, identifying these classes and functions as well as their importance is essential. 

The root logger is the default string used in python logging format, but you must make an effort to define your logger with additional classes and functions. 

Here are some common strings you will need to build appropriate record logs. 

  • Logger: Used directly to call the functions in the application code. 
  • LogRecord:  The good thing here is that the Python loggers will automatically create LogRecord objects. They will do so provided that the loggers has everything about the event that is being logged. 
  • Handler: The Handler is used to direct the LogRecord to its desired direction or output. It can be a console or a file. Handler is the base from which you can take out subclasses of strings, including StreamHandler, FileHandler, HTTPHandler, etc. 
  • Formatter: The Formatter is self-explanatory. You will use this function to set the Python logging format or specify a string to take a specified format. 

How is Python Logger Implemented?

Implementing a Python logger means using the strings and commands given above with the help of the logger module. Implementing it shows the sequential process of making a log and then ensuring its intended output. 

You start with creating a logger with logger=logging.getlogger(nm), here ‘nm’ is the filename. Next, you need to read the log-level from the properties file, which goes in a .txt format, and you must also set the levels here. 

Next up, set the format with the Formatter function followed by creating Handlers and then adding the Formatters to those Handlers. The process completes by adding Handlers to the logger. 

How do you create a Log File in Python?

To create a log file in Python, you need to use the import string and add additional strings according to your requirements. Python developers don’t use the log file much as of today as they create Syslog to write messages to a specific file. 

Making a log file means that you need to write the strings in a manner that makes detection of the file and the messages easy. For additional help, you can use logrotate or WatchedFileHandler for better event tracking and rotating the log files. 

Conclusion

Python logging is a simple and standard exercise practised by every kind of Python developer. It has a robust logging framework along with a well-established library of strings that can be used to create a Python console log. 

While using the Python logger, you need to learn how to simplify it and make it more understandable for everyone on the team. 

FAQs