Python3 Loguru 출력 로그 도구를 사용하는 방법

1. 소개

Python 로깅 모듈은 애플리케이션과 라이브러리에 대한 유연한 이벤트 로깅을 구현하는 함수와 클래스를 정의합니다.

프로그램 개발 과정에서 많은 프로그램은 로그를 기록해야 하며 로그에 포함된 정보에는 일반 프로그램 액세스 로그가 포함되며 오류, 경고 및 기타 정보 출력도 포함될 수 있습니다. Python의 로깅 모듈은 표준 로그 인터페이스를 제공합니다. 다양한 형태로 로그를 저장하며, 로깅은 간단한 로깅 사용을 위한 편의 기능 세트를 제공합니다.

Python 로깅 모듈을 사용하는 주요 이점은 모든 Python 모듈이 로깅에 참여할 수 있다는 것입니다. 로깅 모듈은 다양한 유연한 기능을 제공합니다.

loguru를 사용하는 이유는 무엇입니까?

필요한 로그 정보를 출력하는 데 도움이 되는 것은 간단하고 편리합니다.

Python을 사용하여 프로그램이나 스크립트를 작성할 때 일반적인 문제는 로그를 삭제해야 한다는 것입니다. 한편으로는 프로그램에 문제가 있을 때 문제를 해결하는 데 도움이 될 수 있고, 다른 한편으로는 주의가 필요한 정보를 기록하는 데 도움이 될 수 있습니다.
그러나 내장된 로깅 모듈을 사용하는 경우에는 다른 초기화 및 기타 관련 작업을 수행해야 합니다. 이 모듈에 익숙하지 않은 학생들에게는 Handler/Formatter 설정 등의 설정이 필요한 등 여전히 다소 어렵습니다. 비즈니스가 복잡해짐에 따라 로그 분류, 파일 저장, 비동기 쓰기, 사용자 정의 유형 등과 같은 로그 수집에 대한 요구 사항이 높아집니다.

loguru는 Python의 간단하고 강력한 타사 로깅 라이브러리입니다. 표준 로거의 문제점을 해결하는 다양한 유용한 기능을 추가하여 Python 로깅을 덜 고통스럽게 만드는 것을 목표로 합니다.

2. loguru를 우아하게 사용하세요

1. loguru 설치

pip install loguru

2. 기능 및 특징 소개

많은 장점이 있지만, 다음은 더 중요한 것입니다:

• 즉시 사용할 수 있습니다. 준비가 필요하지 않습니다

• 초기화가 필요하지 않으며 가져온 기능을 사용할 수 있습니다.

• 보다 쉬운 파일 로깅 및 덤프/보존/압축 방법

• 더욱 우아한 문자열 형식의 출력

• 스레드 또는 스레드에서 사용할 수 있습니다. main 스레드의 Catch 예외

• 다양한 수준의 로깅 스타일을 설정할 수 있습니다

• 비동기, 스레드 및 다중 프로세스 안전 지원

• 지연 계산 지원

• 스크립트 및 라이브러리에 적합

• 표준 로깅과 완벽하게 호환

• 더 나은 날짜 및 시간 처리

3. 즉시 사용할 수 있으며 준비가 필요하지 않습니다.

from loguru import logger  
logger.debug("That's it, beautiful and simple logging!")

초기화할 필요 없이 사용할 기능을 가져오기만 하면 됩니다. 문제를 해결하는 방법을 물어봐야 합니다.

• 핸들러를 추가하는 방법은 무엇입니까?

• 로그 형식을 어떻게 설정하나요?

• 메시지를 필터링하는 방법은 무엇입니까?

• 로그 수준을 어떻게 설정하나요?

# add  
logger.add(sys.stderr, \  
    format="{time} {level} {message}",\  
    filter="my_module",\  
    level="INFO")

정말 쉽지 않나요~

4. 더 간편해진 파일 로깅 및 덤프/보존/압축 방법

# 日志文件记录  
logger.add("file_{time}.log")  
# 日志文件转存  
logger.add("file_{time}.log", rotation="500 MB")  
logger.add("file_{time}.log", rotation="12:00")  
logger.add("file_{time}.log", rotation="1 week")  
# 多次时间之后清理  
logger.add("file_X.log", retention="10 days")  
# 使用zip文件格式保存  
logger.add("file_Y.log", compression="zip")

5. 더 우아한 문자열 형식의 출력

logger.info(  
    "If you're using Python {}, prefer {feature} of course!",  
    3.10, feature="f-strings")

6. 메인 스레드

@logger.catch  
def my_function(x, y, z):  
    # An error? It's caught anyway!  
    return 1 / (x + y + z)  
my_function(0, 0, 0)

7 다양한 수준의 로깅 스타일을 설정할 수 있습니다

Loguru는 다양한 로그 수준을 구별하기 위해 자동으로 다양한 색상을 추가하고 사용자 정의 색상도 지원합니다~

logger.add(sys.stdout,  
    colorize=True,  
    format="<green>{time}</green> <level>{message}</level>")  
logger.add(&#39;logs/z_{time}.log&#39;,  
           level=&#39;DEBUG&#39;,  
           format=&#39;{time:YYYY-MM-DD :mm:ss} - {level} - {file} - {line} - {message}&#39;,  
           rotation="10 MB")

8 비동기 및 스레드 및 다중 프로세스 안전성을 지원합니다.

• 기본적으로 로거에 추가된 로그 정보는 스레드로부터 안전합니다. 하지만 이는 다중 프로세스에 안전하지 않으므로 enqueue 매개변수를 추가하여 로그 무결성을 보장할 수 있습니다.

• 비동기 작업에서 로깅을 사용하려는 경우 동일한 매개변수를 사용하여 이를 보장할 수도 있습니다. 그리고 Complete()를 통해 실행이 완료될 때까지 기다립니다.

# 异步写入  
logger.add("some_file.log", enqueue=True)

잘 읽으셨습니다. 단지

비동기적으로 실행될 수 있습니다. enqueue=True

9. 예외에 대한 완전한 설명

은 전체 스택 추적을 표시할 수 있도록 허용하여 코드에서 발생하는 예외의 버그 추적을 기록하는 데 사용됩니다( 변수 값 포함) 문제를 식별하는 데 도움이 됩니다

logger.add("out.log", backtrace=True, diagnose=True)  
def func(a, b):  
    return a / b  
def nested(c):  
    try:  
        func(5, c)  
    except ZeroDivisionError:  
        logger.exception("What?!")  
nested(0)

10. 구조적 로깅

• 데이터 구조를 더 쉽게 구문 분석하거나 전달할 수 있도록 로그를 직렬화하고, 구성된 수신기에 각 로그 메시지를 보내기 전에 직렬화 매개변수를 사용하세요. JSON 문자열로 변환하기 전에.

• 또한, 바인딩() 메서드를 사용하면 추가 레코드 속성을 수정하여 로거 메시지를 컨텍스트에 넣을 수 있습니다. 또한 바인딩()과 필터를 결합하여 로깅을 보다 세밀하게 제어할 수 있습니다.

• 마지막으로 patch() 메소드를 사용하면 각각의 새 메시지에 대한 레코드 사전에 동적 값을 추가할 수 있습니다.

# 序列化为json格式  
logger.add(custom_sink_function, serialize=True)  
# bind方法的用处  
logger.add("file.log", format="{extra[ip]} {extra[user]} {message}")  
context_logger = logger.bind(ip="192.168.2.174", user="someone")  
context_logger.info("Contextualize your logger easily")  
context_logger.bind(user="someone_else").info("Inline binding of extra attribute")  
context_logger.info("Use kwargs to add context during formatting: {user}", user="anybody")  
# 粒度控制  
logger.add("special.log", filter=lambda record: "special" in record["extra"])  
logger.debug("This message is not logged to the file")  
logger.bind(special=True).info("This message, though, is logged to the file!")  
# patch()方法的用处  
logger.add(sys.stderr, format="{extra[utc]} {message}")  
loggerlogger = logger.patch(lambda record: record["extra"].update(utc=datetime.utcnow()))

11. 게으른 평가

때때로 성능에 영향을 주지 않고 프로덕션 환경에서 세부 정보를 기록하려는 경우 opt() 메서드를 사용하면 됩니다.

logger.opt(lazy=True).debug("If sink level <= DEBUG: {x}", x=lambda: expensive_function(2**64))  
# By the way, "opt()" serves many usages  
logger.opt(exception=True).info("Error stacktrace added to the log message (tuple accepted too)")  
logger.opt(colors=True).info("Per message <blue>colors</blue>")  
logger.opt(record=True).info("Display values from the record (eg. {record[thread]})")  
logger.opt(raw=True).info("Bypass sink formatting\n")  
logger.opt(depth=1).info("Use parent stack context (useful within wrapped functions)")  
logger.opt(capture=False).info("Keyword arguments not added to {dest} dict", dest="extra")

12. 사용자 정의 가능한 레벨

new_level = logger.level("SNAKY", no=38, color="<yellow>", icon="????")  
logger.log("SNAKY", "Here we go!")

13. 스크립트 및 라이브러리와 함께 작동합니다.

# For scripts  
config = {  
    "handlers": [  
        {"sink": sys.stdout, "format": "{time} - {message}"},  
        {"sink": "file.log", "serialize": True},  
    ],  
    "extra": {"user": "someone"}  
}  
logger.configure(**config)  
# For libraries  
logger.disable("my_library")  
logger.info("No matter added sinks, this message is not displayed")  
logger.enable("my_library")  
logger.info("This message however is propagated to the sinks")

14. 표준 로깅과 완벽하게 호환됩니다.

• Loguru를 내장 로그 처리기로 사용하고 싶으십니까?

• Loguru 메시지를 표준 로그로 변환해야 합니까?

• 표준 로그 메시지를 가로채서 Loguru로 요약하고 싶으신가요?

handler = logging.handlers.SysLogHandler(address=('localhost', 514)) 
logger.add(handler)  
class PropagateHandler(logging.Handler):  
    def emit(self, record):  
        logging.getLogger(record.name).handle(record)  
logger.add(PropagateHandler(), format="{message}")  
class InterceptHandler(logging.Handler):  
    def emit(self, record):  
        # Get corresponding Loguru level if it exists  
        try:  
            level = logger.level(record.levelname).name  
        except ValueError:  
            level = record.levelno  
        # Find caller from where originated the logged message  
        frame, depth = logging.currentframe(), 2  
        while frame.f_code.co_filename == logging.__file__:  
            frameframe = frame.f_back  
            depth += 1  
        logger.opt(depthdepth=depth, exception=record.exc_info).log(level, record.getMessage())  
logging.basicConfig(handlers=[InterceptHandler()], level=0)

15. 非常方便的解析器

从生成的日志中提取特定的信息通常很有用，这就是为什么 Loguru 提供了一个 parse() 方法来帮助处理日志和正则表达式。

pattern = r"(?P<time>.*) - (?P<level>[0-9]+) - (?P<message>.*)"  # Regex with named groups  
caster_dict = dict(time=dateutil.parser.parse, level=int)        # Transform matching groups  
for groups in logger.parse("file.log", pattern, cast=caster_dict):  
    print("Parsed:", groups) 
    # {"level": 30, "message": "Log example", "time": datetime(2018, 12, 09, 11, 23, 55)}

16. 通知机制 (邮件告警)

import notifiers  
params = {  
    "username": "you@gmail.com",  
    "password": "abc123",  
    "to": "dest@gmail.com"  
}  
# Send a single notification  
notifier = notifiers.get_notifier("gmail")  
notifier.notify(message="The application is running!", **params)  
# Be alerted on each error message  
from notifiers.logging import NotificationHandler  
handler = NotificationHandler("gmail", defaults=params)  
logger.add(handler, level="ERROR")

17. Flask 框架集成

• 现在最关键的一个问题是如何兼容别的 logger，比如说 tornado 或者 django 有一些默认的 logger。

• 经过研究，最好的解决方案是参考官方文档的，完全整合 logging 的工作方式。比如下面将所有的 logging都用 loguru 的 logger 再发送一遍消息。

import logging  
import sys  
from pathlib import Path  
from flask import Flask  
from loguru import logger  
app = Flask(__name__)  
class InterceptHandler(logging.Handler):  
    def emit(self, record):  
        loggerlogger_opt = logger.opt(depth=6, exception=record.exc_info)  
        logger_opt.log(record.levelname, record.getMessage())  
def configure_logging(flask_app: Flask):  
    """配置日志"""  
    path = Path(flask_app.config['LOG_PATH'])  
    if not path.exists():  
        path.mkdir(parents=True)  
    log_name = Path(path, 'sips.log')  
    logging.basicConfig(handlers=[InterceptHandler(level='INFO')], level='INFO')  
    # 配置日志到标准输出流  
    logger.configure(handlers=[{"sink": sys.stderr, "level": 'INFO'}])  
    # 配置日志到输出到文件  
    logger.add(log_name, rotation="500 MB", encoding='utf-8', colorize=False, level='INFO')

18. 要点解析

介绍，主要函数的使用方法和细节 - add()的创建和删除

• add() 非常重要的参数 sink 参数

• 具体的实现规范可以参见官方文档

• 可以实现自定义 Handler 的配置，比如 FileHandler、StreamHandler 等等

• 可以自行定义输出实现

• 代表文件路径，会自动创建对应路径的日志文件并将日志输出进去

• 例如 sys.stderr 或者 open(‘file.log’, ‘w’) 都可以

• 可以传入一个 file 对象

• 可以直接传入一个 str 字符串或者 pathlib.Path 对象

• 可以是一个方法

• 可以是一个 logging 模块的 Handler

• 可以是一个自定义的类

def add(self, sink, *,  
    level=_defaults.LOGURU_LEVEL, format=_defaults.LOGURU_FORMAT,  
    filter=_defaults.LOGURU_FILTER, colorize=_defaults.LOGURU_COLORIZE,  
    serialize=_defaults.LOGURU_SERIALIZE, backtrace=_defaults.LOGURU_BACKTRACE,  
    diagnose=_defaults.LOGURU_DIAGNOSE, enqueue=_defaults.LOGURU_ENQUEUE,  
    catch=_defaults.LOGURU_CATCH, **kwargs  
):

另外添加 sink 之后我们也可以对其进行删除，相当于重新刷新并写入新的内容。删除的时候根据刚刚 add 方法返回的 id 进行删除即可。可以发现，在调用 remove 方法之后，确实将历史 log 删除了。但实际上这并不是删除，只不过是将 sink 对象移除之后，在这之前的内容不会再输出到日志中，这样我们就可以实现日志的刷新重新写入操作

from loguru import logger  
trace = logger.add('runtime.log')  
logger.debug('this is a debug message')  
logger.remove(trace)  
logger.debug('this is another debug message')

三、总结

我们在开发流程中, 通过日志快速定位问题, 高效率解决问题, 我认为 loguru 能帮你解决不少麻烦, 赶快试试吧~

当然, 使用各种也有不少麻烦, 例如:

1. 常见错误1:

--- Logging error in Loguru Handler #3 ---
Record was: None
Traceback (most recent call last):
  File "/usr/local/lib/python3.9/site-packages/loguru/_handler.py", line 272, in _queued_writer
    message = queue.get()
  File "/usr/local/lib/python3.9/multiprocessing/queues.py", line 366, in get
    res = self._reader.recv_bytes()
  File "/usr/local/lib/python3.9/multiprocessing/connection.py", line 221, in recv_bytes
    buf = self._recv_bytes(maxlength)
  File "/usr/local/lib/python3.9/multiprocessing/connection.py", line 419, in _recv_bytes
    buf = self._recv(4)
  File "/usr/local/lib/python3.9/multiprocessing/connection.py", line 384, in _recv
    chunk = read(handle, remaining)
OSError: [Errno 9] Bad file descriptor
--- End of logging error ---

解决办法:
尝试将logs文件夹忽略git提交, 避免和服务器文件冲突即可;
当然也不止这个原因引起这个问题, 也可能是三方库(ciscoconfparse)冲突所致.解决办法: https://github.com/Delgan/loguru/issues/534

2.常见错误2:

File "/home/ronaldinho/xxx/xxx/venv/lib/python3.9/site-packages/loguru/_logger.py", line 939, in add
    handler = Handler(
  File "/home/ronaldinho/xxx/xxx/venv/lib/python3.9/site-packages/loguru/_handler.py", line 86, in __init__
    self._queue = multiprocessing.SimpleQueue()
  File "/home/ronaldinho/.pyenv/versions/3.9.4/lib/python3.9/multiprocessing/context.py", line 113, in SimpleQueue
    return SimpleQueue(ctx=self.get_context())
  File "/home/ronaldinho/.pyenv/versions/3.9.4/lib/python3.9/multiprocessing/queues.py", line 342, in __init__
    self._rlock = ctx.Lock()
  File "/home/ronaldinho/.pyenv/versions/3.9.4/lib/python3.9/multiprocessing/context.py", line 68, in Lock
    return Lock(ctx=self.get_context())
  File "/home/ronaldinho/.pyenv/versions/3.9.4/lib/python3.9/multiprocessing/synchronize.py", line 162, in __init__
  File "/home/ronaldinho/.pyenv/versions/3.9.4/lib/python3.9/multiprocessing/synchronize.py", line 57, in __init__
OSError: [Errno 24] Too many open files

你可以 remove()添加的处理程序，它应该释放文件句柄。 

위 내용은 Python3 Loguru 출력 로그 도구를 사용하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!