Cara menggunakan alat log keluaran Python3 Loguru

1. Prakata

Modul pengelogan Python mentakrifkan fungsi dan kelas yang melaksanakan pengelogan peristiwa fleksibel untuk aplikasi dan perpustakaan.

Semasa proses pembangunan program, banyak program perlu merekodkan log, dan maklumat yang terkandung dalam log termasuk log akses program biasa dan mungkin juga termasuk ralat, amaran dan output maklumat lain yang disediakan oleh modul pengelogan Python log Antara muka di mana log dalam pelbagai format boleh disimpan Pembalakan menyediakan satu set fungsi kemudahan untuk penggunaan pembalakan yang mudah.

Faedah utama menggunakan modul Python Logging ialah semua modul Python boleh mengambil bahagian dalam pengelogan Modul Logging menyediakan banyak fleksibiliti.

Mengapa menggunakan loguru?

Mudah dan mudah untuk membantu kami mengeluarkan maklumat log yang diperlukan:

Apabila menggunakan Python untuk menulis atur cara atau skrip, masalah biasa ialah: Log perlu dipadamkan. Di satu pihak, ia boleh membantu kami menyelesaikan masalah apabila terdapat masalah dengan program, dan sebaliknya, ia boleh membantu kami merekodkan maklumat yang memerlukan perhatian.
Walau bagaimanapun, jika anda menggunakan modul pengelogan terbina dalam, kami perlu melakukan pemulaan yang berbeza dan kerja lain yang berkaitan. Bagi pelajar yang tidak biasa dengan modul ini, ia masih agak sukar, seperti keperluan untuk mengkonfigurasi Handler/Formatter, dll. Apabila kerumitan perniagaan meningkat, terdapat keperluan yang lebih tinggi untuk pengumpulan log, seperti: klasifikasi log, storan fail, penulisan tak segerak, jenis tersuai, dsb.

loguru ialah pihak ketiga yang mudah dan berkuasa dalam perpustakaan Pengelogan Python yang bertujuan untuk menjadikan pembalakan Python kurang menyakitkan dengan menambahkan satu set ciri berguna yang menangani kaveat pembalak standard.

2. Gunakan loguru dengan elegan

1. Pasang loguru

pip install loguru

2. disenaraikan di bawah Beberapa perkara:

Sedia untuk digunakan di luar kotak, tiada penyediaan diperlukan
Tiada permulaan diperlukan, fungsi yang diimport boleh digunakan
Kaedah pembalakan dan lambakan/pemeliharaan/pemampatan fail yang lebih mudah
Output berformat rentetan yang lebih elegan
Pengecualian boleh ditangkap dalam benang atau benang utama
Tahap gaya pembalakan yang berbeza boleh ditetapkan
Menyokong asynchronous, threading dan berbilang proses Selamat
Menyokong penilaian malas
Berfungsi dengan skrip dan perpustakaan
Serasi sepenuhnya dengan pengelogan standard
Pengendalian tarikh dan masa yang lebih baik
3. Tidak perlu Selepas memulakan dan mengimport fungsi, anda mesti bertanya, bagaimana untuk menyelesaikan masalah?

Bagaimana untuk menetapkan pemformatan log?

Bagaimana untuk menapis mesej?
Bagaimana untuk menetapkan tahap log?

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

Bukankah sangat mudah~

• 4. Kaedah pengelogan dan pemindahan/pengekalan/mampatan yang lebih mudah

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

5 output berformat

• # 日志文件记录  
  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")

  6. Tangkap pengecualian dalam sub-benang atau utas utama

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

7 Tahap gaya pengelogan yang berbeza boleh ditetapkan

Loguru akan menambah warna yang berbeza secara automatik. membezakan tahap log yang berbeza, dan juga menyokong warna tersuai~

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

8 Sokong keselamatan tak segerak dan benang dan berbilang proses

Secara lalai, maklumat log ditambahkan pada logger adalah selamat untuk benang. Tetapi ini tidak selamat berbilang proses, kami boleh memastikan integriti log dengan menambah parameter enqueue.

Jika kami ingin menggunakan log masuk tugas tak segerak, kami juga boleh menggunakan parameter yang sama untuk memastikan ini. Dan tunggu untuk pelaksanaan selesai melalui complete().

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

Anda membacanya dengan betul, cuma
• boleh dilaksanakan secara tak segerak
  9 Perihalan lengkap pengecualian
• digunakan untuk merekodkan kod Untuk penjejakan pepijat bagi pengecualian yang berlaku dalam Loguru, Loguru membantu anda mengenal pasti masalah dengan membenarkan keseluruhan surih tindanan dipaparkan (termasuk nilai pembolehubah)

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

  10. Pengelogan berstruktur

enqueue=True Untuk mensiri log untuk memudahkan menghuraikan atau menghantar struktur data, gunakan parameter penyirian untuk menukar setiap mesej log kepada rentetan JSON sebelum menghantarnya kepada penerima yang dikonfigurasikan.

Selain itu, menggunakan kaedah bind(), mesej logger boleh dikontekstualisasikan dengan mengubah suai sifat rekod tambahan. Anda juga boleh mempunyai kawalan yang lebih terperinci ke atas pembalakan dengan menggabungkan bind() dan penapis.

Akhir sekali kaedah patch() membenarkan menambahkan nilai dinamik pada dict rekod untuk setiap mesej baharu.

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

11. Pengiraan malas

• Kadangkala anda ingin log butiran dalam persekitaran pengeluaran tanpa menjejaskan prestasi Anda boleh menggunakan kaedah opt() untuk mencapai ini.

  # 序列化为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()))

12. Tahap boleh disesuaikan

• 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")

  13 Sesuai untuk skrip dan perpustakaan

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

14. Serasi sepenuhnya dengan pengelogan standard

>Mahu menggunakan Loguru sebagai pengendali log terbina dalam?

Perlu log mesej Loguru ke log standard?

Ingin memintas mesej log standard dan meringkaskannya dalam 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()添加的处理程序，它应该释放文件句柄。 

Atas ialah kandungan terperinci Cara menggunakan alat log keluaran Python3 Loguru. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!