Kaip atkurti naujausius Python registravimo pranešimus klaidų metu

„Python“ registravimo optimizavimas, kad būtų galima valdyti klaidas

Prisijungimas prie Python yra būtinas norint sekti įvykius ir diagnozuoti problemas vykdant programą. Tačiau tam tikri moduliai gali pateikti perteklinę sekimo informaciją, kuri gali užgriozdinti žurnalus. Tokiais atvejais nustatant atitinkamą registravimo lygį, pvz KLAIDA, gali padėti išfiltruoti nereikalingas detales.

Tais atvejais, kai vienas modulis generuoja per daug žurnalų, bet kitame jį iškviečiančiame modulyje atsiranda klaidų, labai svarbu pasiekti naujausius žurnalo pranešimus. Taip dažnai būna atsekant pagrindinę klaidos priežastį. Reikia pusiausvyros tarp perteklinių rąstų ignoravimo ir svarbių fiksavimo.

Bibliotekoms patinka spdlog C++ turi integruotą palaikymą atgaliniam sekimui per skambėjimo buferį, leidžiantį kūrėjams peržiūrėti naujausius žurnalus, vedančius į klaidą. Python's medienos ruoša Tačiau biblioteka nesiūlo šios funkcijos, todėl kyla klausimas, kaip įdiegti panašų mechanizmą.

Šiame straipsnyje nagrinėjama, kaip galite pritaikyti Python registravimo sistemą, kad įvykus klaidai užfiksuotų naujausius žurnalo pranešimus, užtikrinant svarbią informaciją iš tikrintuvas modulis yra prieinamas diagnozei neperkrauti žurnalų sekimo duomenimis.

Veiksmingas naujausių žurnalų fiksavimas dėl klaidų „Python“.

Pirmajame pateiktame scenarijuje naudojama pasirinktinė registravimo tvarkyklė su a deque struktūra iš Python's kolekcijos modulis. Šis deque veikia kaip skambėjimo buferis, kuriame yra fiksuotas skaičius naujausių žurnalo pranešimų. Valdytojas nepaiso skleisti metodas, kuris iškviečiamas kiekvieną kartą, kai sugeneruojamas žurnalas. Taikant šį metodą, kiekvienas žurnalo pranešimas suformatuojamas ir pridedamas prie deque. Kadangi deque yra maksimalus ilgis, jis automatiškai atmeta seniausius pranešimus, kai pasiekia talpą. Šis sprendimas efektyviai seka naujausius žurnalus, užtikrindamas, kad per dideli derinimo pranešimai iš tikrintuvo modulio neapsunkintų žurnalo išvesties, bet vis tiek būtų pasiekiami, kai paleidimo modulyje įvyksta klaida.

Kai bėgiko modulyje aptinkama klaida, scenarijus iškviečia pasirinktinį metodą get_logs norėdami gauti deque saugomus žurnalo pranešimus. Tai leidžia peržiūrėti žurnalo pranešimus iš tikrintuvo, kuris buvo prieš pat klaidą. Šio metodo idėja yra ta, kad žurnalo pranešimai suteikia esminį kontekstą trikčių šalinimui, išlaikant pusiausvyrą tarp žurnalo žodiškumo ir naudingumo. Tai paprastas ir efektyvus būdas sukurti apskrito žurnalo buferį Python, panašų į atgalinis pėdsakas funkcija, rasta C++ spdlog bibliotekoje.

Antrasis sprendimas naudoja įmontuotą Atminties tvarkytojas iš Python registravimo modulio. MemoryHandler veikia buferizuodamas žurnalo pranešimus atmintyje ir išplaudamas juos tik tada, kai susiduriama su tam tikru žurnalo lygiu, pvz., KLAIDA. Tokiu atveju tvarkytojas sukonfigūruotas buferizuoti iki 10 žurnalo pranešimų ir išvalyti juos, kai įvyksta klaida. Šis metodas yra panašus į žiedinio buferio techniką, bet naudoja esamą Python registravimo infrastruktūrą, kuri supaprastina įgyvendinimą. „MemoryHandler“ idealiai tinka scenarijuose, kai norite užfiksuoti momentinę žurnalo pranešimų, kurie sukelia klaidą, vaizdą, nesugriozdinant žurnalų atliekant įprastas operacijas.

Abu sprendimai yra optimizuoti našumui ir skirti apriboti atminties suvartojimą. Apribodami atmintyje saugomų žurnalų skaičių ir išvalydami buferį tik kritinių įvykių metu, jie padeda išlaikyti švarius, tvarkomus žurnalus. Tai leidžia kūrėjams sutelkti dėmesį į tikrosios klaidos derinimą, o ne ieškoti daugybės nereikalingos informacijos. Kiekvienas scenarijus gali būti lengvai integruotas į esamas Python registravimo konfigūracijas, tiesiog pridedant pasirinktines arba atminties tvarkykles prie atitinkamo registratoriaus, ir abu yra pakankamai lankstūs, kad būtų pritaikyti įvairiems žurnalų formatams ir lygiams.

# 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

Alternatyvių žurnalo pranešimų fiksavimo „Python“ būdų tyrinėjimas

Kitas būdas užfiksuoti naujausius žurnalo pranešimus Python apima trečiosios šalies bibliotekos naudojimą loguru. Skirtingai nuo Python integruoto registravimo modulio, Loguru siūlo lankstesnę ir patogesnę sąsają. Jame yra integruotas žurnalų pasukimo, žurnalų lygių filtravimo ir įvairių formatų žurnalų fiksavimo palaikymas. Ši biblioteka gali būti ypač naudinga dirbant su programomis, kurios generuoja per daug žurnalų, nes supaprastina žurnalų valdymą ir užtikrina, kad apdorojant klaidas nebūtų praleisti svarbūs pranešimai.

Loguru leidžia nustatyti žurnalų kriaukles, kurios gali būti pritaikytos saugoti žurnalus atmintyje, failuose ar net išorinėse paslaugose. Galite sukurti laikiną atmintyje esantį buferį naudodami tinkintą kriauklę, kuri gali būti išvalyta įvykus klaidai. Dėl to Loguru yra galinga alternatyva tiems, kurie nori daugiau valdyti savo registravimo sistemą nekonfigūruodami tvarkyklių rankiniu būdu, kaip standartinėje registravimo bibliotekoje.

Kitas Loguru pranašumas yra tas, kad jį galima lengvai integruoti su esamomis registravimo sistemomis, o tai reiškia, kad galite pereiti prie Loguru neperžiūrėdami visos registravimo sąrankos. Tai gali būti ypač naudinga dirbant su sudėtingomis programomis, kur našumas ir žurnalų valdymas yra labai svarbūs. Galiausiai, nors Python registravimo modulio pakanka daugeliui naudojimo atvejų, bibliotekų, tokių kaip Loguru, tyrinėjimas suteikia papildomo lankstumo ir naudojimo paprastumo, kad būtų galima efektyviai užfiksuoti ir valdyti žurnalo pranešimus.