Let's study Python

Python Logging: Track, record, and monitor events in your applications with ease.

# Python Logging

Logging is a crucial aspect of any software development process. It allows developers to track and record events that occur during the execution of a program. Python provides a built-in logging module that makes it easy to incorporate logging into your applications.

## Basic Usage

The `logging` module provides several functions for logging messages at different severity levels. One of the most commonly used functions is `logging.info()`. This function is used to log informational messages. Here’s a basic example of how to use `logging.info()`:

“`python
import logging

logging.basicConfig(level=logging.INFO)
logging.info(“This is an informational message”)
“`

In this example, we first import the `logging` module. We then call `logging.basicConfig()` to configure the logging system to display messages with a severity level of `INFO` or higher. Finally, we call `logging.info()` to log an informational message.

## Configuration

The `basicConfig()` function allows you to configure the logging system in various ways. You can specify the format of log messages, the target output stream (e.g., console or file), the logging level, and more. Here’s an example that demonstrates some common configuration options:

“`python
import logging

logging.basicConfig(
filename=’app.log’,
filemode=’w’,
format=’%(asctime)s – %(name)s – %(levelname)s – %(message)s’,
level=logging.INFO
)

logging.info(“This message will be written to app.log”)
“`

In this example, we configure the logging system to write messages to a file named `app.log` in write mode. We also specify a custom log message format that includes the timestamp, logger name, log level, and message.

## Log Levels

The `logging` module defines several log levels that allow you to categorize log messages based on their severity. The following are the log levels supported by the module, in increasing order of severity:

– `DEBUG`
– `INFO`
– `WARNING`
– `ERROR`
– `CRITICAL`

You can use these log levels to control which messages get displayed based on their severity. For example, if you set the logging level to `WARNING`, only messages with a level of `WARNING`, `ERROR`, or `CRITICAL` will be displayed.

## Logging to Multiple Destinations

In addition to writing log messages to a file, you can also log messages to multiple destinations simultaneously. This can be useful if you want to log messages to both the console and a file. Here’s an example that demonstrates how to log messages to both the console and a file:

“`python
import logging

# Create a file handler
file_handler = logging.FileHandler(‘app.log’)
file_handler.setLevel(logging.INFO)

# Create a console handler
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)

# Create a formatter
formatter = logging.Formatter(‘%(asctime)s – %(name)s – %(levelname)s – %(message)s’)

# Set the formatter for the handlers
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# Get the root logger
logger = logging.getLogger()
logger.setLevel(logging.INFO)

# Add the handlers to the logger
logger.addHandler(file_handler)
logger.addHandler(console_handler)

# Log a message
logger.info(“This message will be written to both app.log and the console”)
“`

In this example, we create a file handler and a console handler, each configured to log messages with a severity level of `INFO` or higher. We then create a formatter that specifies the format of log messages. Finally, we get the root logger, set its logging level to `INFO`, and add the handlers to it.

## Conclusion

Logging is an essential tool for monitoring the behavior of your Python applications. By using the `logging` module, you can easily incorporate logging into your programs and gain insight into how they are performing. Experiment with different configuration options and log levels to find the setup that works best for your specific use case.