Kako pridobiti nedavna sporočila beleženja Python med napakami

Optimiziranje beleženja Python za obravnavanje napak

Prijava v Python je bistvena za sledenje dogodkov in diagnosticiranje težav med izvajanjem programa. Vendar pa lahko določeni moduli proizvedejo preveč informacij o sledenju, kar lahko povzroči nered v dnevnikih. V takih primerih nastavitev ustrezne ravni beleženja, kot je npr NAPAKA, lahko pomaga filtrirati nepotrebne podrobnosti.

V scenarijih, kjer en modul ustvari preveč dnevnikov, vendar pride do napak v drugem modulu, ki ga kliče, postane ključnega pomena dostop do zadnjih sporočil dnevnika. To se pogosto zgodi pri iskanju vzroka napake. Potrebno je ravnotežje med ignoriranjem odvečnih dnevnikov in zajemanjem pomembnih.

Knjižnice kot spdlog v C++ imajo vgrajeno podporo za sledenje nazaj prek obročnega medpomnilnika, ki razvijalcem omogoča pregled nedavnih dnevnikov, ki vodijo do napake. Pythonov sečnja knjižnica pa te funkcije ne ponuja takoj, kar postavlja vprašanje, kako implementirati podoben mehanizem.

Ta članek raziskuje, kako lahko Pythonov sistem beleženja prilagodite tako, da zajame nedavna sporočila dnevnika, ko pride do napake, in tako zagotovi kritične informacije iz dama modul je na voljo za diagnozo brez preobremenitve dnevnikov s podatki sledenja.

Učinkovito zajemanje nedavnih dnevnikov ob napaki v Pythonu

Prvi predstavljeni skript uporablja upravljalnik beleženja po meri z a deque struktura iz Pythona zbirke modul. Ta deque deluje kot medpomnilnik zvonjenja, ki hrani fiksno število nedavnih dnevniških sporočil. Upravljavec preglasi oddajajo metoda, ki se pokliče vsakič, ko se ustvari dnevnik. Pri tej metodi je vsako sporočilo dnevnika oblikovano in nato dodano deque. Ker ima deque največjo dolžino, samodejno zavrže najstarejša sporočila, ko doseže zmogljivost. Ta rešitev učinkovito sledi najnovejšim dnevnikom in zagotavlja, da prekomerna sporočila o odpravljanju napak iz modula za preverjanje ne preobremenijo izpisa dnevnika, ampak so še vedno na voljo, ko pride do napake v modulu izvajalca.

Ko je v modulu runner zaznana napaka, skript pokliče metodo po meri get_logs za pridobitev sporočil dnevnika, shranjenih v deque. To vam omogoča, da pregledate sporočila dnevnika iz preverjevalnika, ki je neposredno pred napako. Ideja za tem pristopom je, da sporočila dnevnika zagotavljajo ključni kontekst za odpravljanje težav, hkrati pa ohranjajo ravnovesje med podrobnostjo dnevnika in uporabnostjo. To je preprost in učinkovit način za ustvarjanje krožnega medpomnilnika dnevnika v Pythonu, podobnega povratna sled funkcijo, ki jo najdete v knjižnici spdlog C++.

Druga rešitev uporablja vgrajeno MemoryHandler iz Pythonovega modula za beleženje. MemoryHandler deluje tako, da medpomni sporočila dnevnika v pomnilniku in jih izprazni le, ko naleti na določeno raven dnevnika, kot je NAPAKA. V tem primeru je upravljalnik konfiguriran tako, da shrani do 10 dnevniških sporočil in jih izprazni, ko pride do napake. Ta pristop je podoben tehniki medpomnilnika obroča, vendar uporablja Pythonovo obstoječo infrastrukturo za beleženje, kar poenostavi izvedbo. MemoryHandler je idealen za scenarije, v katerih želite zajeti posnetek dnevniških sporočil, ki vodijo do napake, ne da bi med običajnim delovanjem zmešali dnevnike.

Obe rešitvi sta optimizirani za zmogljivost in zasnovani tako, da omejita porabo pomnilnika. Z omejevanjem števila dnevnikov, shranjenih v pomnilniku, in izpiranjem medpomnilnika samo med kritičnimi dogodki pomagajo vzdrževati čiste dnevnike, ki jih je mogoče upravljati. To razvijalcem omogoča, da se osredotočijo na odpravljanje napak pri dejanski napaki, namesto da prebirajo ogromne količine nepotrebnih informacij. Vsak skript je mogoče enostavno integrirati v obstoječe konfiguracije beleženja Python, tako da zadevnemu zapisovalniku preprosto dodate obdelovalce po meri ali pomnilnik, oba pa sta dovolj prilagodljiva, da ju je mogoče prilagoditi različnim formatom in nivojem dnevnika.

# 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

Raziskovanje alternativnih načinov zajemanja dnevniških sporočil v Pythonu

Drug pristop za zajemanje nedavnih dnevniških sporočil v Pythonu vključuje uporabo knjižnice tretje osebe, kot je loguru. Za razliko od Pythonovega vgrajenega modula za beleženje Loguru ponuja bolj prilagodljiv in uporabniku prijazen vmesnik. Vključuje vgrajeno podporo za rotiranje dnevnikov, filtriranje ravni dnevnikov in zajemanje dnevnikov v različnih formatih. Ta knjižnica je lahko še posebej uporabna pri delu z aplikacijami, ki ustvarjajo preveč dnevnikov, saj poenostavlja upravljanje dnevnikov, hkrati pa zagotavlja, da kritična sporočila med obravnavanjem napak niso spregledana.

Loguru omogoča nastavitev ponorov dnevnikov, ki jih je mogoče prilagoditi za shranjevanje dnevnikov v pomnilnik, datoteke ali celo zunanje storitve. Ustvarite lahko začasni vmesni pomnilnik v pomnilniku z uporabo ponora po meri, ki ga je mogoče nato izprazniti, ko naletite na napako. Zaradi tega je Loguru zmogljiva alternativa za tiste, ki želijo več nadzora nad svojim sistemom beleženja brez ročne konfiguracije upravljavcev, kot je v standardni knjižnici beleženja.

Druga prednost Loguruja je, da omogoča preprosto integracijo z obstoječimi sistemi beleženja, kar pomeni, da lahko preklopite na Loguru, ne da bi prenovili celotno nastavitev beleženja. To je lahko še posebej koristno pri delu s kompleksnimi aplikacijami, kjer sta zmogljivost in upravljanje dnevnikov ključnega pomena. Medtem ko Pythonov modul za beleženje zadostuje za večino primerov uporabe, raziskovanje knjižnic, kot je Loguru, zagotavlja dodatno prilagodljivost in enostavnost uporabe za učinkovito zajemanje in upravljanje dnevniških sporočil.