Analyse du module de journalisation en Python (exemple de code)

Le contenu de cet article concerne l'analyse du module de journalisation en Python (exemples de code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

1. Niveaux de journalisation

1. débogage : priorité 10, enregistre les détails du débogage, activé uniquement pendant le débogage

2. info : Priorité 20, enregistrez les messages ordinaires, signalez les erreurs et les avertissements et attendez.

3. avertissement : priorité 30, enregistre les informations d'avertissement pertinentes.

4. erreur : priorité 40, enregistrer les informations d'erreur, crash du programme

5. critique : priorité 50, enregistrer les informations d'erreur

S'il n'est pas défini, la valeur par défaut est iwarning

2. La structure principale du module de journalisation

En regardant le code source de la journalisation, nous pouvons voir qu'il y a quatre principaux classes pour implémenter des fonctions :

1. Loggers : fournissent des interfaces pour une utilisation directe par le programme, telles que les paramètres de configuration associés

2. Gestionnaires : transmettent les journaux généré par les enregistreurs à l'emplacement spécifié et définissez l'emplacement d'enregistrement des journaux

3. Filtres : filtrez le journal de sortie

4. Formateurs : contrôlez la sortie ; format du journal

Formatters

L'objet Formatters définit le format de sortie du journal et possède une variété de paramètres facultatifs.

参数	含义
%(name)s	Logger的名字
%(levellno)s	数字形式的日志级别
%(levelname)s	文本形式的日志级别
%(pathname)s	调用日志输出函数的模块的完整路径名，可能没有
%(filename)s	调用日志输出函数的模块的文件名
%(module)s	调用日志输出函数的模块名
%(funcName)s	调用日志输出函数的函数名
%(lineno)d	调用日志输出函数的语句所在的代码行
%(created)f	当前时间，用unix标表示的时间浮点表示
%(relativeCreated)d	输出日志信息时，自Logger创建以来的毫秒数
%(asctime)s	字符串形式的当前时间，默认格式是‘2018-11-22 16：49：45，896’，逗号后面是毫秒
%(thread)d	线程ID，可能没有
%(threadName)s	线程名，可能没有
%(process)d	进程ID，可能没有
%(message)s	用户输出的信息

Exemple :

import logging

#fmt:定义输出的日志信息的格式
#datefmt：定义时间信息的格式，默认为：%Y-%m-%d %H:%M:%S
#style:定义格式化输出的占位符，默认是%(name)格式，可选{}或$格式
formatter=logging.Formatter(fmt='%(asctime)s    %(levelname)s:  %(message)s'
                            ,datefmt='%Y-%m-%d %H:%M:%S',style='%')

Processeur de journaux des gestionnaires

Le processeur de journaux est utilisé pour traiter le sens de flux spécifique du journal, qu'il soit sorti vers un fichier ou sortie standard, etc. Il contrôle le format de sortie en définissant Formatter et ajoute des filtres pour filtrer les journaux.

Il existe deux processeurs couramment utilisés

1. StreamHandler : utilisé pour imprimer les journaux sur la console

2. FileHandler : utilisé pour imprimer des journaux dans des fichiers journaux

Autres processeurs

名称	详细位置	说明
RotatingHandler	logging.handlers.RotatingHandler	日志回滚方式，支持日志文件最大数量和日志文件回滚
TimeRotatingHandler	logging.handlers.TimeRotatingHandler	日志回滚方式，在一定时间区域内回滚日志文件
SocketHandler	logging.handlers.SocketHandler	远程输出日志到TCP/IP sockets
DatagramHandler	logging.handlers.DatagramHandler	远程输出日志到UDP sockets
SMTPHandler	logging.handlers.SMTPHandler	远程输出日志到邮件地址
SysLogHandler	logging.handlers.SysLogHandler	日志输出到syslog
NTEventLogHandler	logging.handlers.NTEventLogHandler	远程输出日志到Windows NT/2000/xp的事件日志
MemoryHandler	logging.handlers.MemoryHandler	日志输出到内存中的指定buffer
HTTPHandler	logging.handlers.HTTPHandler	通过“GET”或者“POST”远程输出到HTTP服务器

from logging import Handler

#所有日志处理器的父类
handler=Handler()

print('处理日志的等级：',handler.level)
print('处理日志的名字：',handler.name)
print('处理器的日志过滤器：：',handler.filters)
print('日志的格式：：',handler.filters)

#一些常用方法：
handler.get_name()
handler.set_name('')
handler.createLock()#创建线程锁
handler.acquire()#获取线程锁
handler.release()#释放线程锁
handler.setLevel('info') #设置日志处理器的记录级别
handler.setFormatter(fmt='')#设置日志的输出格式
handler.addFilter('')#往处理器中添加过滤器
handler.removeFilter('')#往处理器中移除过滤器
handler.emit('')#日志记录的处理逻辑，由子类实现

Logger log L'objet

Logger gère toutes les méthodes de journalisation.

from logging import error, debug, warning, info, fatal, critical, getLogger

#返回一个Logger实例
#以'root'为名字的日志对象在Logger对象中只有一个实例
logger=getLogger('root')

print('获取根日志对象',logger.root)
print('获取manager',logger.manager)
print('获取根日志对象的名字',logger.name)
print('获取根日志对象记录水平',logger.level)
print('获取根日志对象过滤器列表',logger.filters)
print('获取根日志对象处理器列表',logger.handlers)
print('获取根日志对象',logger.disabled)

#设置日志记录水平
logger.setLevel('info')

#输出日志信息，格式化输出
logger.info('this is %s','info',exc_info=1)
#记录warning信息
logger.warning('')
#记录error信息
logger.error('')
#等价于logger.error('',exc_info=1)
logger.exception('')
#记录debug信息
logger.debug('')
#记录critical信息
logger.critical('')
#直接指定级别
logger.log('info','')

#添加处理器
logger.addHandler()
#移除处理器
logger.removeHandler()
#判是否有处理器
logger.hasHandlers()

3. Utilisation de base de l'enregistreur

Exemple :

import logging
import sys

def my_get_logger(appname):
    #获取logger实例，如果参数为空则返回root logger
    logger=logging.getLogger(appname)
    #创建日志输出格式
    formatter=logging.Formatter('%(asctime)s    %(levelname)s:  %(message)s')

    #指定输出的文件路径
    file_handler=logging.FileHandler('test.log')
    # 设置文件处理器，加载处理器格式
    file_handler.setFormatter(formatter)

    #控制台日志
    console_handler=logging.StreamHandler(sys.stdout)
    console_handler.formatter=formatter

    #为logger添加的日志处理器
    logger.addHandler(file_handler)
    logger.addHandler(console_handler)

    #指定日志的最低输出级别，默认为warn级别
    logger.setLevel(logging.INFO)
    return logger

if __name__ == '__main__':
    logger=my_get_logger('test')
    logger.debug('this is debug info')
    logger.info('this is information')
    logger.warning('this is warning message')
    logger.error('this is error message')
    logger.fatal('this is fatal message,it is same ad logger.critical')
    logger.critical('this is critical message')

Résultat :

2018-11-22 16:31:34,023 INFO: this is information
2018-11-22 16:31:34,023 WARNING: this is warning message
2018-11-22 16:31:34,023 ERROR: this is error message
2018-11-22 16:31:34,024 CRITICAL: this is fatal message,it is same ad logger.critical
2018-11-22 16:31:34,024 CRITICAL: this is critical message

4. Le processus d'appel logique de la journalisation du logger

1. Enregistrez les journaux en appelant logger.debug et d'autres méthodes

2. D'abord ; déterminer Le niveau de journalisation de cet enregistrement est-il supérieur au niveau défini ? Sinon, passez directement et ne plus exécuter

3. Créez un objet LogRecord en utilisant les informations du journal comme paramètre

4. Filtrez l'objet LogRecord via le filtre du logger S'il est filtré, passez

5. L'objet d'enregistrement du journal est filtré par le filtre du processeur Handler.

6. Déterminez si le niveau de journalisation de cet enregistrement est supérieur au niveau défini par le processeur Handler. Sinon, passez directement et ne plus exécuter

7. .

   Enfin, appelez la méthode d'émission du processeur pour le traitement de la journalisation

5. Configurer l'enregistreur

1. Terminé ; configuration par code, principalement via la méthode getLogger, mais il est difficile de modifier

2. via la méthode basicConfig, qui est rapide mais pas assez hiérarchique

3. via logging.config.fileConfig(filepath) , la configuration des fichiers

4. est configurée via le dictionnaire de dictConfig, qui est une nouvelle méthode de configuration introduite dans la version py3.2

est utilisé Configuration du mode fichier

#logging.cong

[loggers]
#定义日志的对象名称是什么，注意必须定义root，否则报错
keys=root,main

[handlers]
#定义处理器的名字是什么，可以有多个，用逗号隔开
keys=consoleHandler

[formatters]
#定义输出格式对象的名字，可以有多个，用逗号隔开
keys=simpleFormatter

[logger_root]
#配置root对象的日志记录级别和使用的处理器
level=INFO
handlers=consoleHandler

[logger_main]
#配置main对象的日志记录级别和使用的处理器，qualname值得就是日志对象的名字
level=INFO
handlers=consoleHandler
qualname=main
#logger对象把日志传递给所有相关的handler的时候，会逐级向上寻找这个logger和它所有的父logger的全部handler，
#propagate=1表示会继续向上搜寻；
#propagate=0表示停止搜寻，这个参数涉及重复打印的坑。
propagate=0

[handler_consoleHandler]
#配置处理器consoleHandler
class=StreamHandler
level=WARNING
formatter=simpleFormatter
args=(sys,)

[formatter_simpleFormatter]
#配置输出格式过滤器simpleFormatter
format=%(asctime)-%(name)s-%(levelname)s-%(message)s

Remarque : vous pouvez voir que l'enregistreur et le gestionnaire peuvent définir le niveau de journalisation et que la sortie du journal prend le niveau le plus élevé.

Utiliser la configuration du formulaire de dictionnaire

La configuration du formulaire de dictionnaire est plus puissante et flexible. Grâce à la fonction dictConfig, nous pouvons convertir des fichiers de configuration dans d'autres formats en dictionnaires, tels que json, YAML, etc.

Exemple :

import yaml
from logging.config import dictConfig
import os
filename=os.path.dirname(os.path.abspath(__file__))
with  open(filename+'/logging.yaml','r') as f:
    log=yaml.load(f.read())
    dictConfig(log)

#logging.yaml
#注意：yaml格式严格，:后面一定要带空格
version: 1
formatters:
    simple:
          format: '%(asctime)s-%(name)s-%(levelname)s-%(message)s'
handlers:
    console:
          class: logging.StreamHandler
          level: DEBUG
          formatter: simple
          stream: ext://sys.stdout
    console_err:
          class: logging.StreamHandler
          level: DEBUG
          formatter: simple
          stream: ext://sys.stderr
loggers:
    simpleExample:
          level: DEBUG
          handlers: [console]
          propagate: no
root:
    level: DEBUG
    handlers: [console_err]]

6. Écoute des modifications de configuration de l'enregistreur

La fonction logging.config.listen(port) permet aux programmes anglais de Surveillez les nouvelles informations de configuration sur le socket pour modifier la configuration au moment de l'exécution sans redémarrer l'application.

import logging.config
import logging
logging.config.fileConfig("logging.conf")
logger=logging.getLogger('test.listen')

#监听端口号9999
t=logging.config.listen(9999)
t.setDaemon(True)
t.start()

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!