Introduction to Django’s Logging Framework

In this article, we will briefly explain, how to use logging in Django.

Introduction

Logs play a crucial role in application development. We track the logs file to understand our unwanted results. Sometimes Python developers prefer to use just print statements instead of using a logging framework. We can use print statements for simple debugging and quick output during development, but for more complex and structured logging, especially in production code, it's best to use the logging framework. By using the logging framework, we can easily control the log level, redirect output to various sources, and ensure proper formatting and management of logs.

Key reasons to use logging

1. Debugging: Logging helps identify errors, exceptions, and unexpected behavior, making it easier to debug issues in the codebase.
2. Error Tracking: Logs provide valuable information about errors and exceptions occurring in your application, enabling you to pinpoint the root cause quickly.
3. Security: Logging can be used to detect and respond to security threats or suspicious activities in your application.
4. Auditing and Compliance: Logging helps in meeting auditing requirements and ensures compliance with data protection regulations.

Setting Up Logging in Django

Django uses Python's built-in logging library.

Django’s logging mechanism can be broken down into four main parts:

• Loggers: Loggers are used to define different sections of your application or modules that generate log messages.
• Handlers: Handlers determine how log messages are handled once they are generated. Handlers can specify where the logs should be stored, such as in a file, or sent to external services like email or logging servers.
• Formatters: Formatters define the structure and format of the log messages.
• Filters: A filter is used to provide additional control over which log records are passed from the logger to the handler.

To get started logging in the Django, initially, we need to set up logging in settings.py

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    "formatters": {
        "verbose": {
            "format": "%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s",
        },
    },
    'handlers': {
        'file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'filename': 'logfile.log',
            'formatter': 'verbose',
        },
    },
    'loggers': {
        "root": {"level": "DEBUG", "handlers": ["file"]},
    },
}

In this example, we configure a file-based logging handler that writes log messages with a level of DEBUG or higher to the specified log file.

There are five standard logging levels, each representing a different severity of the log message:

• debug: Detailed information, typically used for debugging purposes.
• info: General information about the application’s operation.
• warning: Indicates potential issues or unexpected behavior that is not necessarily an error.
• error: information about major problems but the application can recover itself.
• critical: Indicates critical errors that may lead to application failure.

Now we can use logging in our code.

import logging

# Create a logger instance
logger = logging.getLogger("root")

def my_view(request):
    logger.debug('This is a debug message')
    logger.info('This is an info message')
    logger.warning('This is a warning message')
    logger.error('This is an error message')
    logger.critical('This is a critical message')

This is the result:

In the end, I want to inform you that log files can quickly grow in size, so proper handling and maintenance are essential to ensure they don’t consume excessive disk space and become unwieldy.

We can use custom Django management commands to remove old log files.

Conclusion

In this article, we have made a short introduction to the logging mechanism in Django. We described the main 4 parts of logging and show a real-world example that how you can use logging in your next app.

Thanks for reading. I hope you enjoyed it ❤. If you found the article useful don’t forget to clap and follow me.

This is my #27/52 story in 2023, I’m on a challenge to write 52 stories in 2023.

Keep Learning..!

Some other related articles you should go check out!

Maintaining Clean Codebase in Django: The Power of pre-commit

The Walrus Operator in Python

5 Best PyCharm Plugins for 2023