Django+Logging: Logging Configuration and Usage

Introduction

Logging is indispensable in program development. Through logs, we can analyze where errors occur and what exceptions there are. It is very useful in production environments. In Java development, third-party components such as log4j and logback are commonly used. So how is logging handled in Django? Django uses the logging module provided by Python, but to use logging in Django, there are certain configuration rules that need to be set in settings.

Logging Module

The logging module provides applications with a flexible means of recording events, errors, warnings, and debug information. This information can be collected, filtered, written to files, sent to the system log, and even sent over the network to a remote computer.

First, Here Is My Logging Configuration

LOGGING = {
    'version': 1,
    'disable_existing_loggers': True,
    'formatters': {
        'standard': {
            'format': '%(asctime)s [%(name)s:%(lineno)d] [%(module)s:%(funcName)s] [%(levelname)s] %(message)s'}
        # 日志格式
    },
    'filters': {
    },
    'handlers': {
        'mail_admins': {
            'level': 'ERROR',
            'class': 'django.utils.log.AdminEmailHandler',
            'include_html': True,
        },
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',
            'filename': '{}/Log/QWebFX_{}.log'.format(BASE_DIR, datetime.datetime.now().date()),  # 日志输出文件
            'maxBytes': 1024 * 1024 * 5,  # 文件大小
            'backupCount': 5,  # 备份份数
            'formatter': 'standard',  # 使用哪种formatters日志格式
        },
        'error': {
            'level': 'ERROR',
            'class': 'logging.handlers.RotatingFileHandler',
            'filename': '{}/Log/Error/QWebFX_Error_{}.log'.format(BASE_DIR, datetime.datetime.now().date()),
            'maxBytes': 1024 * 1024 * 5,
            'backupCount': 5,
            'formatter': 'standard',
        },
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
            'formatter': 'standard'
        },
        'request_handler': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',
            'filename': '{}/Log/Request/QWebFX_Request_{}.log'.format(BASE_DIR, datetime.datetime.now().date()),
            'maxBytes': 1024 * 1024 * 5,
            'backupCount': 5,
            'formatter': 'standard',
        },
        'scripts_handler': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',
            'filename': '{}/Log/Script/QWebFX_Script_{}.log'.format(BASE_DIR, datetime.datetime.now().date()),
            'maxBytes': 1024 * 1024 * 5,
            'backupCount': 5,
            'formatter': 'standard',
        }
    },
    'loggers': {
        'django': {
            'handlers': ['default'],
            'level': 'DEBUG',
            'propagate': False
        },
        'django.request': {
            'handlers': ['request_handler'],
            'level': 'DEBUG',
            'propagate': False,
        },
        'scripts': {
            'handlers': ['scripts_handler'],
            'level': 'INFO',
            'propagate': False
        },
        'console': {
            'handlers': ['console'],
            'level': 'DEBUG',
            'propagate': True
        },
        # API/Views 模块的日志处理
        'views': {
            'handlers': ['default', 'error'],
            'level': 'DEBUG',
            'propagate': True
        },
        'util': {
            'handlers': ['error'],
            'level': 'ERROR',
            'propagate': True
        },
    }
}

Explanation:

1. formatters: Configure the log print format
2. handler: Used to define how logs are specifically processed. Multiple handlers can be defined. "default" is the default method, and "console" is the method that prints to the console.
3. loggers: Used to configure which handlers to use to process logs, for example when you need to output logs to both a file and the console.

Note:

1. A logger of type "django" will handle all types of logs.
2. sourceDns.webdns.views the application's py file

How to Record Logs

See the code example:

import logging

logger = logging.getLogger("console")

def index(request):
    logger.debug("hello")

Note: The name used with getLogger is the logger we defined above in loggers.

Next, some parameters will be introduced and explained.

Logging Level Level

The focus of the logging module is generating and processing log messages. Each message consists of some text and an associated level indicating its severity. Levels include a symbolic name and a numeric value.

Logger Logger

The logger is responsible for managing the default behavior of log messages, including the logging level, output destination, message format, and other basic details.

Keyword arguments:

• filename Append log messages to a file with the specified filename
• filemode Specify the mode used to open the file
• format Format string used to generate log messages
• datefmt Format string used to output the date and time
• level Set the logger's level
• stream Provide an open file used to send log messages to a file.

Log Message Format format

• %(name)s Logger name
• %(levelno)s Numeric logging level
• %(levelname)s Text name of the logging level
• %(filename)s Filename of the source file that made the logging call
• %(pathname)s Pathname of the source file that made the logging call
• %(funcName)s Function name that made the logging call
• %(module)s Module name that made the logging call
• %(lineno)s Line number that made the logging call
• %(created)s Time when the logging call was made
• %(asctime)s Date and time
• %(msecs)s Millisecond portion
• %(thread)d Thread ID
• %(threadName)s Thread name
• %(process)d Process ID
• %(message)s The logged message

Built-in Handlers handler

The logging module provides some handlers that can process log messages in various ways. Use the addHandler() method to add these handlers to a Logger object. You can also configure each handler with its own filtering and level.

• handlers.DatagramHandler(host，port): Send log messages to a UDP server at the specified host and port.
• handlers.FileHandler(filename): Write log messages to the file filename.
• handlers.HTTPHandler(host, url): Upload log messages to an HTTP server using HTTP GET or POST methods.
• handlers.RotatingFileHandler(filename): Write log messages to the file filename. If the file size exceeds the value specified by maxBytes, it will be backed up as filename1.

There are many more built-in handlers. If you want to learn more in depth, you can check the official manual.

Now that you roughly understand how to use logging, you can combine it with the previous examples.