Hur man hämtar senaste Python-loggningsmeddelanden under fel

Optimera Python-loggning för felhantering

Att logga in i Python är viktigt för att spåra händelser och diagnostisera problem under körningen av ett program. Vissa moduler kan dock producera överdriven spårinformation, vilket kan störa loggarna. I sådana fall ställer du in en lämplig loggningsnivå, som t.ex FEL, kan hjälpa till att filtrera bort onödiga detaljer.

I scenarier där en modul genererar för många loggar, men fel uppstår i en annan modul som anropar den, blir det avgörande att få tillgång till de senaste loggmeddelandena. Detta är ofta fallet när man spårar grundorsaken till ett fel. En balans behövs mellan att ignorera överdrivna loggar och fånga viktiga.

Bibliotek som spdlog i C++ har inbyggt stöd för backtracking via en ringbuffert, vilket gör att utvecklare kan granska senaste loggar som leder till ett fel. Pythons skogsavverkning biblioteket erbjuder dock inte denna funktion direkt, vilket väcker frågan om hur man implementerar en liknande mekanism.

Den här artikeln undersöker hur du kan anpassa Pythons loggningssystem för att fånga upp de senaste loggmeddelanden när ett fel uppstår, vilket säkerställer viktig information från pjäs modulen är tillgänglig för diagnos utan att överväldiga loggarna med spårningsdata.

Effektivt fånga de senaste loggarna på fel i Python

Det första skriptet som presenteras använder en anpassad loggningshanterare med en deque struktur från Pythons samlingar modul. Denna deque fungerar som en ringbuffert och innehåller ett fast antal senaste loggmeddelanden. Hanteraren åsidosätter avge metod, som anropas varje gång en logg genereras. I den här metoden formateras varje loggmeddelande och läggs sedan till dequen. Eftersom dequen har en maximal längd, kasserar den automatiskt de äldsta meddelandena när den når kapacitet. Den här lösningen spårar effektivt de senaste loggarna och säkerställer att alltför många felsökningsmeddelanden från kontrollmodulen inte överväldigar loggutmatningen men fortfarande är tillgängliga när ett fel uppstår i löparmodulen.

När ett fel upptäcks i löparmodulen anropar skriptet en anpassad metod get_logs för att hämta loggmeddelanden som lagrats i deque. Detta låter dig inspektera loggmeddelanden från kontrollören som omedelbart föregick felet. Tanken bakom detta tillvägagångssätt är att loggmeddelandena ger ett avgörande sammanhang för felsökning samtidigt som en balans mellan loggspråkighet och användbarhet bibehålls. Detta är ett enkelt och effektivt sätt att skapa en cirkulär loggbuffert i Python, liknande den bakåtspårning funktion som finns i C++:s spdlog-bibliotek.

Den andra lösningen använder den inbyggda MemoryHandler från Pythons loggningsmodul. MemoryHandler fungerar genom att buffra loggmeddelanden i minnet och tömma dem endast när en specifik loggnivå påträffas, t.ex. FEL. I det här fallet är hanteraren konfigurerad att buffra upp till 10 loggmeddelanden och tömma dem när ett fel uppstår. Detta tillvägagångssätt liknar ringbufferttekniken men använder Pythons befintliga loggningsinfrastruktur, vilket förenklar implementeringen. MemoryHandler är idealiskt för scenarier där du vill fånga en ögonblicksbild av loggmeddelanden som leder till ett fel utan att belamra loggarna under normal drift.

Båda lösningarna är optimerade för prestanda och designade för att begränsa minnesförbrukningen. Genom att begränsa antalet loggar som lagras i minnet och endast spola bufferten under kritiska händelser hjälper de till att upprätthålla rena, hanterbara loggar. Detta gör att utvecklare kan fokusera på att felsöka det faktiska felet snarare än att sålla igenom stora mängder onödig information. Varje skript kan enkelt integreras i befintliga Python-loggningskonfigurationer genom att helt enkelt lägga till de anpassade eller minneshanterarna till loggern i fråga, och båda är tillräckligt flexibla för att anpassas till olika loggformat och 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

Utforska alternativa sätt att fånga loggmeddelanden i Python

Ett annat tillvägagångssätt för att fånga de senaste loggmeddelanden i Python involverar att använda ett tredjepartsbibliotek som loguru. Till skillnad från Pythons inbyggda loggningsmodul erbjuder Loguru ett mer flexibelt och användarvänligt gränssnitt. Det inkluderar inbyggt stöd för att rotera loggar, filtrera loggnivåer och fånga loggar i olika format. Det här biblioteket kan vara särskilt användbart när du arbetar med applikationer som genererar alltför många loggar, eftersom det förenklar logghanteringen samtidigt som det säkerställer att viktiga meddelanden inte missas under felhantering.

Loguru gör det möjligt att ställa in loggsänkor, som kan anpassas för att lagra loggar i minnet, filer eller till och med externa tjänster. Du kan skapa en tillfällig buffert i minnet med hjälp av en anpassad diskbänk, som sedan kan tömmas vid ett fel. Detta gör Loguru till ett kraftfullt alternativ för dem som vill ha mer kontroll över sitt loggningssystem utan att manuellt konfigurera hanterare som i standardloggningsbiblioteket.

En annan fördel med Loguru är att det möjliggör enkel integrering med befintliga loggningssystem, vilket innebär att du kan byta till Loguru utan att se över hela din loggningsinställning. Detta kan vara särskilt användbart när du hanterar komplexa applikationer där prestanda och logghantering är avgörande. I slutändan, medan Pythons loggningsmodul är tillräcklig för de flesta användningsfall, ger utforskning av bibliotek som Loguru ytterligare flexibilitet och användarvänlighet för att fånga och hantera loggmeddelanden effektivt.