Как получить последние сообщения журнала Python во время ошибок

Оптимизация ведения журнала Python для обработки ошибок

Вход в Python необходим для отслеживания событий и диагностики проблем во время выполнения программы. Однако некоторые модули могут выдавать избыточную информацию трассировки, которая может засорять журналы. В таких случаях установка соответствующего уровня ведения журнала, например ОШИБКА, может помочь отфильтровать ненужные детали.

В сценариях, когда один модуль генерирует слишком много журналов, но в другом модуле, вызывающем его, возникают ошибки, становится критически важным получить доступ к последним сообщениям журнала. Это часто бывает при отслеживании основной причины ошибки. Необходим баланс между игнорированием чрезмерных журналов и записью важных.

Библиотеки, такие как Спдлог в C++ есть встроенная поддержка обратного отслеживания через кольцевой буфер, что позволяет разработчикам просматривать последние журналы, которые привели к ошибке. Python регистрация библиотека, однако, не предлагает эту функцию «из коробки», что поднимает вопрос о том, как реализовать аналогичный механизм.

В этой статье рассматривается, как можно адаптировать систему журналирования Python для сбора последних сообщений журнала при возникновении ошибки, обеспечивая получение важной информации из системы. шашка Модуль доступен для диагностики, не перегружая журналы данными трассировки.

Эффективный сбор последних журналов ошибок в Python

Первый представленный скрипт использует собственный обработчик журналирования с дек структура из Python коллекции модуль. Эта дека действует как кольцевой буфер, хранящий фиксированное количество последних сообщений журнала. Обработчик переопределяет излучать метод, который вызывается каждый раз при создании журнала. В этом методе каждое сообщение журнала форматируется, а затем добавляется в двухстороннюю очередь. Поскольку дек имеет максимальную длину, он автоматически отбрасывает самые старые сообщения, когда достигает своей емкости. Это решение эффективно отслеживает самые последние журналы, гарантируя, что чрезмерные отладочные сообщения из модуля проверки не перегружают выходные данные журнала, но по-прежнему доступны в случае возникновения ошибки в модуле запуска.

При обнаружении ошибки в модуле бегуна скрипт вызывает собственный метод. get_logs для получения сообщений журнала, хранящихся в очереди. Это позволяет вам проверять сообщения журнала проверки, которые непосредственно предшествовали ошибке. Идея этого подхода заключается в том, что сообщения журнала предоставляют важный контекст для устранения неполадок, сохраняя при этом баланс между подробностью журнала и полезностью. Это простой и эффективный способ создать циклический буфер журнала в Python, аналогичный обратная трассировка функция, найденная в библиотеке spdlog C++.

Второе решение использует встроенный Обработчик памяти из модуля журналирования Python. MemoryHandler работает путем буферизации сообщений журнала в памяти и их очистки только при обнаружении определенного уровня журнала, например ОШИБКА. В этом случае обработчик настроен на буферизацию до 10 сообщений журнала и их очистку при возникновении ошибки. Этот подход аналогичен методу кольцевого буфера, но использует существующую инфраструктуру журналирования Python, что упрощает реализацию. MemoryHandler идеально подходит для сценариев, в которых вы хотите сделать снимок сообщений журнала, которые приводят к ошибке, не загромождая журналы во время обычных операций.

Оба решения оптимизированы по производительности и предназначены для ограничения потребления памяти. Ограничивая количество журналов, хранящихся в памяти, и очищая буфер только во время критических событий, они помогают поддерживать чистые и управляемые журналы. Это позволяет разработчикам сосредоточиться на устранении фактической ошибки, а не на анализе огромных объемов ненужной информации. Каждый скрипт можно легко интегрировать в существующие конфигурации ведения журналов Python, просто добавив к соответствующему регистратору собственные обработчики или обработчики памяти, и оба они достаточно гибки, чтобы их можно было адаптировать к различным форматам и уровням журналов.

# Approach 1: Using a custom handler with a deque (ring buffer) to store recent logs
import logging
from collections import deque
# Custom log handler to store recent log messages
class BufferingHandler(logging.Handler):
    def __init__(self, capacity):
        super().__init__()
        self.log_buffer = deque(maxlen=capacity)  # Circular buffer
    def emit(self, record):
        self.log_buffer.append(self.format(record))  # Store formatted log messages
    def get_logs(self):
        return list(self.log_buffer)  # Retrieve recent log messages
# Configure logging with custom handler
logger = logging.getLogger('checker')
buffer_handler = BufferingHandler(capacity=10)
logger.addHandler(buffer_handler)
logger.setLevel(logging.DEBUG)
# Example log generation
for i in range(20):
    logger.debug(f"Debug message {i}")
# Simulate an error in runner and print the last few log messages
try:
    1 / 0  # Simulate error
except ZeroDivisionError:
    print("Error occurred, recent log messages:")
    for log in buffer_handler.get_logs():
        print(log)

# Approach 2: Using MemoryHandler to buffer log messages
import logging
# MemoryHandler buffers log records in memory and flushes them when conditions are met
memory_handler = logging.handlers.MemoryHandler(capacity=10, flushLevel=logging.ERROR)
# Configuring logging with a stream handler for output
stream_handler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
stream_handler.setFormatter(formatter)
# Attach the memory handler and stream handler to logger
logger = logging.getLogger('checker')
logger.setLevel(logging.DEBUG)
memory_handler.setTarget(stream_handler)
logger.addHandler(memory_handler)
# Generating some debug messages
for i in range(15):
    logger.debug(f"Debug message {i}")
# Simulate an error that will trigger the buffer to flush
logger.error("An error occurred in runner")
# The memory handler will now flush its buffer and show the last 10 messages

Изучение альтернативных способов захвата сообщений журнала в Python

Другой подход к сбору последних сообщений журнала в Python предполагает использование сторонней библиотеки, например логуру. В отличие от встроенного модуля журналирования Python, Loguru предлагает более гибкий и удобный интерфейс. Он включает встроенную поддержку ротации журналов, фильтрации уровней журналов и записи журналов в различных форматах. Эта библиотека может быть особенно полезна при работе с приложениями, генерирующими слишком много журналов, поскольку она упрощает управление журналами и гарантирует, что критические сообщения не будут пропущены во время обработки ошибок.

Loguru позволяет настраивать приемники журналов, которые можно настроить для хранения журналов в памяти, файлах или даже во внешних службах. Вы можете создать временный буфер в памяти, используя собственный приемник, который затем можно будет сбросить при возникновении ошибки. Это делает Loguru мощной альтернативой для тех, кто хочет получить больше контроля над своей системой журналирования без ручной настройки обработчиков, как в стандартной библиотеке журналирования.

Еще одним преимуществом Loguru является то, что он позволяет легко интегрироваться с существующими системами ведения журналов, а это означает, что вы можете перейти на Loguru, не пересматривая всю настройку ведения журналов. Это может быть особенно полезно при работе со сложными приложениями, где производительность и управление журналами имеют решающее значение. В конечном счете, хотя модуля ведения журнала Python достаточно для большинства случаев использования, изучение таких библиотек, как Loguru, обеспечивает дополнительную гибкость и простоту использования для эффективного сбора и управления сообщениями журнала.