Slik henter du nylige Python-loggingsmeldinger under feil

Optimalisering av Python-logging for feilhåndtering

Å logge på Python er avgjørende for å spore hendelser og diagnostisere problemer under kjøringen av et program. Imidlertid kan enkelte moduler produsere overdreven sporingsinformasjon, noe som kan rote loggene. I slike tilfeller må du sette et passende loggingsnivå, som f.eks FEIL, kan bidra til å filtrere ut unødvendige detaljer.

I scenarier der en modul genererer for mange logger, men det oppstår feil i en annen modul som kaller den, blir det avgjørende å få tilgang til nylige loggmeldinger. Dette er ofte tilfellet når man skal spore årsaken til en feil. En balanse er nødvendig mellom å ignorere overdreven logger og fange viktige.

Biblioteker liker spdlog i C++ har innebygd støtte for tilbakesporing via en ringbuffer, slik at utviklere kan se gjennom nylige logger som fører til en feil. Python sin logging biblioteket tilbyr imidlertid ikke denne funksjonen ut av esken, noe som reiser spørsmålet om hvordan man implementerer en lignende mekanisme.

Denne artikkelen utforsker hvordan du kan tilpasse Pythons loggsystem til å fange opp nylige loggmeldinger når det oppstår en feil, og sikre kritisk informasjon fra brikke modulen er tilgjengelig for diagnose uten å overvelde loggene med sporingsdata.

Effektivt fange opp nylige logger på feil i Python

Det første skriptet som presenteres bruker en tilpasset loggingsbehandler med en deque struktur fra Python's samlinger modul. Denne dequen fungerer som en ringebuffer, og inneholder et fast antall nylige loggmeldinger. Behandleren overstyrer avgir metode, som kalles hver gang en logg genereres. I denne metoden blir hver loggmelding formatert og deretter lagt til deque. Fordi dequen har en maksimal lengde, forkaster den automatisk de eldste meldingene når den når kapasitet. Denne løsningen sporer effektivt de nyeste loggene, og sikrer at overdreven feilsøkingsmeldinger fra kontrollmodulen ikke overvelder loggutgangen, men fortsatt er tilgjengelig når det oppstår en feil i løpermodulen.

Når det oppdages en feil i løpermodulen, kaller skriptet en egendefinert metode få_logger for å hente loggmeldinger som er lagret i deque. Dette lar deg inspisere loggmeldingene fra kontrolløren som gikk umiddelbart før feilen. Tanken bak denne tilnærmingen er at loggmeldingene gir en avgjørende kontekst for feilsøking samtidig som de opprettholder en balanse mellom loggomtale og nytteverdi. Dette er en enkel og effektiv måte å lage en sirkulær loggbuffer i Python, som ligner på tilbakesporing funksjon funnet i C++s spdlog-bibliotek.

Den andre løsningen bruker den innebygde MemoryHandler fra Pythons loggmodul. MemoryHandler fungerer ved å bufre loggmeldinger i minnet og tømme dem bare når et spesifikt loggnivå påtreffes, for eksempel en FEIL. I dette tilfellet er behandleren konfigurert til å bufre opptil 10 loggmeldinger og tømme dem når det oppstår en feil. Denne tilnærmingen ligner på ringbufferteknikken, men bruker Pythons eksisterende loggingsinfrastruktur, noe som forenkler implementeringen. MemoryHandler er ideell for scenarier der du ønsker å ta et øyeblikksbilde av loggmeldinger som fører opp til en feil uten å rote loggene under normale operasjoner.

Begge løsningene er optimalisert for ytelse og designet for å begrense minneforbruket. Ved å begrense antallet logger som er lagret i minnet og kun tømme bufferen under kritiske hendelser, bidrar de til å opprettholde rene, håndterbare logger. Dette lar utviklere fokusere på å feilsøke selve feilen i stedet for å sile gjennom enorme mengder unødvendig informasjon. Hvert skript kan enkelt integreres i eksisterende Python-loggingskonfigurasjoner ved ganske enkelt å legge til tilpassede eller minnebehandlere til den aktuelle loggeren, og begge er fleksible nok til å tilpasses ulike loggformater og nivåer.

# 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

Utforske alternative måter å fange opp loggmeldinger i Python

En annen tilnærming for å fange opp nylige loggmeldinger i Python innebærer å bruke et tredjepartsbibliotek som loguru. I motsetning til Pythons innebygde loggmodul, tilbyr Loguru et mer fleksibelt og brukervennlig grensesnitt. Den inkluderer innebygd støtte for roterende logger, filtrering av loggnivåer og fangst av logger i ulike formater. Dette biblioteket kan være spesielt nyttig når du arbeider med applikasjoner som genererer overdreven logger, siden det forenkler loggadministrasjon samtidig som det sikrer at kritiske meldinger ikke går glipp av under feilhåndtering.

Loguru gjør det mulig å sette opp loggvasker, som kan tilpasses for å lagre logger i minnet, filer eller til og med eksterne tjenester. Du kan opprette en midlertidig buffer i minnet ved å bruke en tilpasset vask, som deretter kan tømmes når det oppstår en feil. Dette gjør Loguru til et kraftig alternativ for de som ønsker mer kontroll over loggingssystemet sitt uten å manuelt konfigurere behandlere som i standard loggbibliotek.

En annen fordel med Loguru er at det muliggjør enkel integrasjon med eksisterende loggingssystemer, noe som betyr at du kan bytte til Loguru uten å overhale hele loggoppsettet. Dette kan være spesielt nyttig når du arbeider med komplekse applikasjoner der ytelse og loggadministrasjon er avgjørende. Til syvende og sist, mens Pythons loggmodul er tilstrekkelig for de fleste brukstilfeller, gir utforskning av biblioteker som Loguru ekstra fleksibilitet og brukervennlighet for å fange og administrere loggmeldinger effektivt.