A legutóbbi Python naplózási üzenetek visszakeresése hibák során

Python naplózás optimalizálása hibakezeléshez

A Pythonba való bejelentkezés elengedhetetlen az események nyomon követéséhez és a program végrehajtása során felmerülő problémák diagnosztizálásához. Bizonyos modulok azonban túl sok nyomkövetési információt állíthatnak elő, ami összezavarhatja a naplókat. Ilyen esetekben megfelelő naplózási szint beállítása, mint pl HIBA, segíthet kiszűrni a szükségtelen részleteket.

Azokban a forgatókönyvekben, amikor az egyik modul túl sok naplót generál, de hiba lép fel egy másik modulban, amely hívja, kulcsfontosságúvá válik a legutóbbi naplóüzenetek elérése. Ez gyakran előfordul a hiba kiváltó okának felkutatása során. Egyensúlyra van szükség a túlzott naplók figyelmen kívül hagyása és a fontosak rögzítése között.

A könyvtárak, mint spdlog A C++ beépített támogatása a visszalépéshez gyűrűs pufferen keresztül, lehetővé téve a fejlesztők számára, hogy áttekintsék a hibához vezető legutóbbi naplókat. Python fakitermelés könyvtár azonban nem kínálja ezt a funkciót a dobozból, ami felveti a kérdést, hogyan lehet megvalósítani egy hasonló mechanizmust.

Ez a cikk azt mutatja be, hogyan adaptálhatja a Python naplózási rendszerét a legutóbbi naplóüzenetek rögzítésére, ha hiba történik, így biztosítva a kritikus információkat a ellenőrző A modul elérhető a diagnosztikához anélkül, hogy nyomkövetési adatokkal túlterhelné a naplókat.

Hatékonyan rögzíti a legutóbbi naplókat a Python hibáiról

Az első bemutatott szkript egyéni naplózási kezelőt használ a deque szerkezet a Pythonból gyűjtemények modul. Ez a visszahívás csengetési pufferként működik, és rögzített számú legutóbbi naplóüzenetet tárol. A kezelő felülírja a kibocsát metódus, amely minden napló generálásakor meghívásra kerül. Ennél a módszernél minden naplóüzenet formázva van, majd hozzáfűződik a deque-hez. Mivel a deque-nek van egy maximális hossza, a kapacitás elérésekor automatikusan elveti a legrégebbi üzeneteket. Ez a megoldás hatékonyan követi a legfrissebb naplókat, biztosítva, hogy az ellenőrző modulból érkező túlzott hibakeresési üzenetek ne terheljék túl a naplókimenetet, de továbbra is elérhetők legyenek, ha hiba lép fel a futómodulban.

Ha hibát észlel a futtató modulban, a szkript meghív egy egyéni metódust get_logs a deque-ben tárolt naplóüzenetek lekéréséhez. Ez lehetővé teszi, hogy megvizsgálja a hibát közvetlenül megelőző ellenőrző naplóüzeneteit. Ennek a megközelítésnek az az ötlete, hogy a naplóüzenetek kulcsfontosságú kontextust biztosítanak a hibaelhárításhoz, miközben megőrzik az egyensúlyt a naplók szóhasználata és a hasznosság között. Ez egy egyszerű és hatékony módja egy körkörös naplópuffer létrehozásának Pythonban, hasonlóan a visszanyom a C++ spdlog könyvtárában található szolgáltatás.

A második megoldás a beépítettet használja Memóriakezelő a Python naplózási moduljából. A MemoryHandler úgy működik, hogy puffereli a naplóüzeneteket a memóriában, és csak akkor üríti ki őket, ha egy adott naplózási szint találkozik, mint pl. HIBA. Ebben az esetben a kezelő úgy van beállítva, hogy legfeljebb 10 naplóüzenetet puffereljen, és hiba esetén kiürítse azokat. Ez a megközelítés hasonló a gyűrűs puffer technikához, de a Python meglévő naplózási infrastruktúráját használja, ami leegyszerűsíti a megvalósítást. A MemoryHandler ideális olyan forgatókönyvekhez, ahol pillanatfelvételt szeretne készíteni azokról a naplóüzenetekről, amelyek hibához vezetnek anélkül, hogy a naplókat rendes műveletek során összezavarná.

Mindkét megoldást a teljesítményre optimalizálták, és a memóriafogyasztás korlátozására tervezték. A memóriában tárolt naplók számának korlátozásával és a puffer kiürítésével csak kritikus események esetén segítik a tiszta, kezelhető naplók fenntartását. Ez lehetővé teszi a fejlesztők számára, hogy a tényleges hiba hibakeresésére összpontosítsanak, ahelyett, hogy hatalmas mennyiségű szükségtelen információt szitáltak volna át. Mindegyik szkript könnyen integrálható a meglévő Python naplózási konfigurációkba, egyszerűen hozzáadva az egyéni vagy memóriakezelőket a kérdéses naplózóhoz, és mindkettő kellően rugalmas ahhoz, hogy a különféle naplóformátumokhoz és szintekhez igazítható legyen.

# 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

A naplóüzenetek rögzítésének alternatív módjainak felfedezése Pythonban

A legutóbbi naplóüzenetek Pythonban történő rögzítésének másik módja egy harmadik féltől származó könyvtár használata, például loguru. A Python beépített naplózó moduljával ellentétben a Loguru rugalmasabb és felhasználóbarátabb felületet kínál. Beépített támogatást tartalmaz a naplók forgatásához, a naplószintek szűréséhez és a naplók különféle formátumú rögzítéséhez. Ez a könyvtár különösen hasznos lehet, ha túl sok naplót generáló alkalmazásokkal dolgozik, mivel leegyszerűsíti a naplókezelést, miközben biztosítja, hogy a kritikus üzenetek ne maradjanak el a hibakezelés során.

A Loguru lehetővé teszi a naplónyelők beállítását, amelyek testreszabhatók a naplók tárolására a memóriában, fájlokban vagy akár külső szolgáltatásokban. Létrehozhat egy ideiglenes memórián belüli puffert egy egyéni fogadó segítségével, amely hiba észlelésekor kiüríthető. Ez teszi a Loguru-t hatékony alternatívává azok számára, akik nagyobb irányítást szeretnének a naplózási rendszerük felett anélkül, hogy manuálisan konfigurálnák a kezelőket, mint a szabványos naplózási könyvtárban.

A Loguru másik előnye, hogy lehetővé teszi a könnyű integrációt a meglévő naplózási rendszerekkel, ami azt jelenti, hogy a teljes naplózási beállítás átalakítása nélkül válthat át Loguru-ra. Ez különösen akkor lehet hasznos, ha összetett alkalmazásokkal foglalkozik, ahol a teljesítmény és a naplókezelés kulcsfontosságú. Végső soron, míg a Python naplózási modulja a legtöbb használati esetre elegendő, az olyan könyvtárak felfedezése, mint a Loguru, további rugalmasságot és egyszerű használatot biztosít a naplóüzenetek hatékony rögzítéséhez és kezeléséhez.