Analyse des Protokollierungsmoduls in Python (Codebeispiel)

Der Inhalt dieses Artikels befasst sich mit der Analyse des Protokollierungsmoduls in Python (Codebeispiele). Ich hoffe, dass er für Sie hilfreich ist.

1. Protokollierungsstufen

1. Debug: Priorität 10, zeichnet Debugging-Details auf, nur während des Debuggens aktiviert

2. Info: Priorität 20, normale Nachrichten protokollieren, Fehler und Warnungen melden und warten.

3. Warnung: Priorität 30, zeichnet relevante Warninformationen auf.

4. Fehler: Priorität 40, Fehlerinformationen aufzeichnen, Programmabsturz

5. kritisch: Priorität 50, Fehlerinformationen aufzeichnen

Wenn nicht festgelegt, ist die Standardeinstellung iwarning

2. Die Hauptstruktur des Protokollierungsmoduls

Wenn wir uns den Quellcode der Protokollierung ansehen, können wir sehen, dass es vier Hauptstrukturen gibt Klassen zum Implementieren von Funktionen:

1. Logger: Stellen Schnittstellen zur direkten Verwendung durch das Programm bereit, z. B. zugehörige Konfigurationseinstellungen

2. Handler: Übertragen Sie die Protokolle von Loggern am angegebenen Speicherort generiert und die Protokolle festgelegt Speicherort;

3. Filter: Filtern Sie das Ausgabeprotokoll

4. Formatierer: Steuern Sie die Ausgabe Format des Protokolls

Formatters

Das Formatters-Objekt definiert das Protokollausgabeformat und verfügt über eine Vielzahl optionaler Parameter.

参数	含义
%(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	用户输出的信息

Beispiel:

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='%')

Handler-Protokollprozessor

Der Protokollprozessor wird verwendet, um den spezifischen Protokollfluss zu verarbeiten, unabhängig davon, ob er in eine Datei oder als Standardausgabe ausgegeben wird usw. Es besteht die Möglichkeit, den Formatierer festzulegen, um das Ausgabeformat zu steuern, und Filter hinzuzufügen, um die Protokolle zu filtern.

Es gibt zwei häufig verwendete Prozessoren

1. StreamHandler: Wird zum Drucken von Protokollen auf der Konsole verwendet

2. FileHandler: Wird zum Drucken von Protokollen in Protokolldateien verwendet

Andere Handler

名称	详细位置	说明
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-Protokollobjekt

Logger verwaltet alle Protokollierungsmethoden.

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. Grundlegende Verwendung des Loggers

Beispiel:

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')

4 Logischer Aufrufprozess der Aufzeichnung

Zeichnen Sie Protokolle durch Aufrufen von logger.debug und anderen Methoden auf
Bestimmen Sie zunächst, ob die Protokollebene von Dieser Datensatz ist größer als die festgelegte Ebene. Wenn nicht, wird er direkt übergeben und nicht mehr ausgeführt.
Verwenden Sie die Protokollinformationen als Parameter, um ein LogRecord-Protokollierungsobjekt zu erstellen
Filtern Sie das LogRecord-Objekt durch den Logger-Filter. Wenn es gefiltert wird, übergeben Sie es
Das Protokolldatensatzobjekt wird durch den Filter des Handler-Prozessors gefiltert
zur Beurteilung Ist die Protokollstufe dieses Datensatzes größer als die vom Handler-Prozessor festgelegte Stufe? Wenn nicht, direkt übergeben und nicht mehr ausführen Rufen Sie die Emit-Methode des Prozessors auf, um den Protokolldatensatz zu verarbeiten.
5. Konfigurieren Sie den Logger Code, hauptsächlich über die getLogger-Methode, aber nicht einfach zu ändern
Erreicht durch die basicConfig-Methode, die schnell, aber nicht hierarchisch genug ist

Über logging.config.fileConfig(filepath), Dateikonfiguration

1. Konfigurieren Sie über den Wörterbuchmodus von dictConfig, einer neuen Konfigurationsmethode, die in der py3.2-Version eingeführt wurde

2. Dateimoduskonfiguration verwenden

3. 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

   Hinweis: Sie können sehen, dass sowohl Logger als auch Handler die Protokollebene festlegen können und die Protokollausgabe die höchste Ebene annimmt.
   Wörterbuch-Formularkonfiguration verwenden

4. Die Wörterbuch-Formularkonfiguration ist leistungsfähiger und flexibler. Über die Funktion dictConfig können wir Konfigurationsdateien in anderen Formaten in Wörterbücher wie JSON, YAML usw. konvertieren.

Beispiel:

#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

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)

6. Auf Logger-Konfigurationsänderungen hören

Die Funktion logging.config.listen(port) ermöglicht es englischen Programmen, auf neue Logger zu hören Ein Socket mit Konfigurationsinformationen, um den Zweck zu erreichen, die Konfiguration zur Laufzeit zu ändern, ohne die Anwendung neu zu starten.

#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]]

Das obige ist der detaillierte Inhalt vonAnalyse des Protokollierungsmoduls in Python (Codebeispiel). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!