Django日志器的使用

Logging Mudel

A quick logging primer

Django uses Python’s builtin logging module to perform system logging. The usage of this module is discussed in detail in Python’s own documentation. However, if you’ve never used Python’s logging framework (or even if you have), here’s a quick primer.

The cast of players

A Python logging configuration consists of four parts:

• Loggers
• Handlers
• Filters
• Formatters

Loggers
A logger is the entry point into the logging system. Each logger is a named bucket to which messages can be written for processing.
A logger is configured to have a log level. This log level describes the severity of the messages that the logger will handle. Python defines the following log levels:
DEBUG: Low level system information for debugging purposes
INFO: General system information
WARNING: Information describing a minor problem that has occurred.
ERROR: Information describing a major problem that has occurred.
CRITICAL: Information describing a critical problem that has occurred.
Each message that is written to the logger is a Log Record. Each log record also has a log level indicating the severity of that specific message. A log record can also contain useful metadata that describes the event that is being logged. This can include details such as a stack trace or an error code.
When a message is given to the logger, the log level of the message is compared to the log level of the logger. If the log level of the message meets or exceeds the log level of the logger itself, the message will undergo further processing. If it doesn’t, the message will be ignored.
Once a logger has determined that a message needs to be processed, it is passed to a Handler.

Handlers

The handler is the engine that determines what happens to each message in a logger. It describes a particular logging behavior, such as writing a message to the screen, to a file, or to a network socket.
Like loggers, handlers also have a log level. If the log level of a log record doesn’t meet or exceed the level of the handler, the handler will ignore the message.
A logger can have multiple handlers, and each handler can have a different log level. In this way, it is possible to provide different forms of notification depending on the importance of a message. For example, you could install one handler that forwards ERROR and CRITICALmessages to a paging service, while a second handler logs all messages (including ERROR and CRITICAL messages) to a file for later analysis.

Filters

A filter is used to provide additional control over which log records are passed from logger to handler.
By default, any log message that meets log level requirements will be handled. However, by installing a filter, you can place additional criteria on the logging process. For example, you could install a filter that only allows ERROR messages from a particular source to be emitted.
Filters can also be used to modify the logging record prior to being emitted. For example, you could write a filter that downgrades ERROR log records to WARNING records if a particular set of criteria are met.
Filters can be installed on loggers or on handlers; multiple filters can be used in a chain to perform multiple filtering actions.

Formatters

Ultimately, a log record needs to be rendered as text. Formatters describe the exact format of that text. A formatter usually consists of a Python formatting string containing LogRecord attributes; however, you can also write custom formatters to implement specific formatting behavior.

源码示例：

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'verbose': {
            'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'
        },
        'simple': {
            'format': '%(levelname)s %(message)s'
        },
    },
    'filters': {
        'special': {
            '()': 'project.logging.SpecialFilter',
            'foo': 'bar',
        },
        'require_debug_true': {
            '()': 'django.utils.log.RequireDebugTrue',
        },
    },
    'handlers': {
        'console': {
            'level': 'INFO',
            'filters': ['require_debug_true'],
            'class': 'logging.StreamHandler',
            'formatter': 'simple'
        },
        'mail_admins': {
            'level': 'ERROR',
            'class': 'django.utils.log.AdminEmailHandler',
            'filters': ['special']
        }
    },
    'loggers': {
        'django': {
            'handlers': ['console'],
            'propagate': True,
        },
        'django.request': {
            'handlers': ['mail_admins'],
            'level': 'ERROR',
            'propagate': False,
        },
        'myproject.custom': {
            'handlers': ['console', 'mail_admins'],
            'level': 'INFO',
            'filters': ['special']
        }
    }
}

解析：

Identifies the configuration as being in ‘dictConfig version 1’ format. At present, this is the only dictConfig format version.

Defines two formatters:

simple, that just outputs the log level name (e.g., DEBUG) and the log message.

The format string is a normal Python formatting string describing the details that are to be output on each logging line. The full list of detail that can be output can be found in Formatter Objects.

verbose, that outputs the log level name, the log message, plus the time, process, thread and module that generate the log message.

Defines two filters:

project.logging.SpecialFilter, using the alias special. If this filter required additional arguments, they can be provided as additional keys in the filter configuration dictionary. In this case, the argument foo will be given a value of bar when instantiating SpecialFilter.
django.utils.log.RequireDebugTrue, which passes on records when DEBUG is True.
Defines two handlers:

console, a StreamHandler, which will print any INFO (or higher) message to stderr. This handler uses the simple output format.
mail_admins, an AdminEmailHandler, which will email any ERROR (or higher) message to the site admins. This handler uses the special filter.
Configures three loggers:

django, which passes all messages to the console handler.
django.request, which passes all ERROR messages to the mail_admins handler. In addition, this logger is marked to not propagate messages. This means that log messages written to django.request will not be handled by the django logger.
myproject.custom, which passes all messages at INFO or higher that also pass the special filter to two handlers – the console, and mail_admins. This means that all INFO level messages (or higher) will be printed to the console; ERROR and CRITICAL messages will also be output via email.

使用方式：

import logging
logger = logging.getLogger("django") # 为loggers中定义的名称
logger.info("some info...")

运行测试：

LOGGING = {
	'version': 1,
	'disable_existing_loggers': False,
	'formatters': {
		'standard': {
			'format': '%(asctime)s [%(threadName)s:%(thread)d] [%(name)s:%(lineno)d] [%(module)s:%(funcName)s] [%(levelname)s]- %(message)s'}
		# 日志格式
	},
	'filters': {
	},
	'handlers': {
		'default': {  # 默认
			'level': 'DEBUG',
			'class': 'logging.handlers.RotatingFileHandler',
			'filename': 'log/all.log',  # 日志输出文件
			'maxBytes': 1024 * 1024 * 5,  # 文件大小
			'backupCount': 5,  # 备份份数
			'formatter': 'standard',  # 使用哪种formatters日志格式
		},
		'error': {  # 错误
			'level': 'ERROR',
			'class': 'logging.handlers.RotatingFileHandler',
			'filename': 'log/error.log',
			'maxBytes': 1024 * 1024 * 5,
			'backupCount': 5,
			'formatter': 'standard',
		},
		'console': {  # 控制台
			'level': 'DEBUG',
			'class': 'logging.StreamHandler',
			'formatter': 'standard'
		},
		'mail_admins': {
			'level': 'ERROR',
			'class': 'django.utils.log.AdminEmailHandler',
			'include_html': True,
		},
		'request_handler': {  # request请求
			'level': 'DEBUG',
			'class': 'logging.handlers.RotatingFileHandler',
			'filename': 'log/script.log',
			'maxBytes': 1024 * 1024 * 5,
			'backupCount': 5,
			'formatter': 'standard',
		},
		'scprits_handler': {  # script请求
			'level': 'DEBUG',
			'class': 'logging.handlers.RotatingFileHandler',
			'filename': 'log/script.log',
			'maxBytes': 1024 * 1024 * 5,
			'backupCount': 5,
			'formatter': 'standard',
		}
	},
	'loggers': {
		'django': {
			'handlers': ['default', 'console'],
			'level': 'DEBUG',
			'propagate': False
		},
		'django.request': {
			'handlers': ['request_handler'],
			'level': 'DEBUG',
			'propagate': False,
		},
		'scripts': {
			'handlers': ['scprits_handler'],
			'level': 'INFO',
			'propagate': False
		},
		'blog.views': {
			'handlers': ['default', 'error','console'],
			'level': 'DEBUG',
			'propagate': True
		},
	}
}

views.py:

# -*- coding: utf-8 -*-
from django.shortcuts import render
import logging

logger = logging.getLogger('blog.views')  # 使用自定义的logger

def index(request):
	try:
		raise Exception
	except Exception as e:
		logger.debug('views.index()....')
	return render(request, 'index.html', {})

运行

官方文档（https://docs.djangoproject.com/en/dev/topics/logging/#topic-logging-parts-loggers）