Cara Mengambil Pesan Logging Python Terbaru Saat Terjadi Kesalahan

Mengoptimalkan Logging Python untuk Penanganan Kesalahan

Masuk dengan Python sangat penting untuk melacak peristiwa dan mendiagnosis masalah selama eksekusi suatu program. Namun, modul tertentu dapat menghasilkan informasi jejak yang berlebihan, sehingga dapat mengacaukan log. Dalam kasus tersebut, menetapkan tingkat logging yang sesuai, seperti KESALAHAN, dapat membantu menyaring detail yang tidak perlu.

Dalam skenario di mana satu modul menghasilkan log yang berlebihan, namun terjadi kesalahan pada modul lain yang memanggilnya, maka mengakses pesan log terbaru menjadi sangat penting. Hal ini sering terjadi ketika menelusuri akar penyebab kesalahan. Diperlukan keseimbangan antara mengabaikan log yang berlebihan dan menangkap log yang penting.

Perpustakaan seperti spdlog di C++ memiliki dukungan bawaan untuk menelusuri kembali melalui buffer cincin, memungkinkan pengembang meninjau log terbaru yang mengarah ke kesalahan. ular piton pencatatan Namun, perpustakaan tidak menawarkan fitur ini secara langsung, sehingga menimbulkan pertanyaan tentang bagaimana menerapkan mekanisme serupa.

Artikel ini mengeksplorasi bagaimana Anda dapat mengadaptasi sistem logging Python untuk menangkap pesan log terbaru ketika terjadi kesalahan, memastikan informasi penting dari pemeriksa modul tersedia untuk diagnosis tanpa membanjiri log dengan data jejak.

Secara Efisien Menangkap Log Terbaru tentang Kesalahan dengan Python

Skrip pertama yang disajikan menggunakan penangan logging khusus dengan a deque struktur dari Python koleksi modul. Deque ini bertindak sebagai ring buffer, yang menyimpan sejumlah pesan log terbaru. Penangan menimpa memancarkan metode, yang dipanggil setiap kali log dibuat. Dalam metode ini, setiap pesan log diformat dan kemudian ditambahkan ke deque. Karena deque memiliki panjang maksimum, maka secara otomatis membuang pesan terlama ketika mencapai kapasitas. Solusi ini secara efisien melacak log terbaru, memastikan bahwa pesan debug yang berlebihan dari modul pemeriksa tidak membebani keluaran log tetapi masih tersedia ketika terjadi kesalahan pada modul runner.

Ketika kesalahan terdeteksi di modul runner, skrip memanggil metode khusus dapatkan_logs untuk mengambil pesan log yang disimpan di deque. Hal ini memungkinkan Anda memeriksa pesan log dari pemeriksa yang mendahului kesalahan. Gagasan di balik pendekatan ini adalah bahwa pesan log memberikan konteks penting untuk pemecahan masalah sekaligus menjaga keseimbangan antara verbositas log dan kegunaannya. Ini adalah cara sederhana dan efektif untuk membuat buffer log melingkar dengan Python, mirip dengan menelusuri kembali fitur yang ditemukan di perpustakaan spdlog C++.

Solusi kedua menggunakan built-in Pengendali Memori dari modul logging Python. MemoryHandler bekerja dengan melakukan buffering pesan log di memori dan menghapusnya hanya ketika level log tertentu ditemukan, seperti KESALAHAN. Dalam hal ini, handler dikonfigurasi untuk melakukan buffering hingga 10 pesan log dan menghapusnya ketika terjadi kesalahan. Pendekatan ini mirip dengan teknik ring buffer tetapi menggunakan infrastruktur logging Python yang sudah ada, sehingga menyederhanakan implementasi. MemoryHandler ideal untuk skenario di mana Anda ingin mengambil cuplikan pesan log yang menyebabkan kesalahan tanpa mengacaukan log selama operasi normal.

Kedua solusi tersebut dioptimalkan untuk kinerja dan dirancang untuk membatasi konsumsi memori. Dengan membatasi jumlah log yang disimpan dalam memori dan hanya menghapus buffer selama peristiwa penting, mereka membantu menjaga log tetap bersih dan mudah dikelola. Hal ini memungkinkan pengembang untuk fokus dalam men-debug kesalahan sebenarnya daripada memilah-milah sejumlah besar informasi yang tidak perlu. Setiap skrip dapat dengan mudah diintegrasikan ke dalam konfigurasi logging Python yang ada hanya dengan menambahkan pengendali khusus atau memori ke logger yang dimaksud, dan keduanya cukup fleksibel untuk disesuaikan dengan berbagai format dan level log.

# 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

Menjelajahi Cara Alternatif untuk Menangkap Pesan Log dengan Python

Pendekatan lain untuk menangkap pesan log terbaru dengan Python melibatkan penggunaan perpustakaan pihak ketiga seperti loguru. Tidak seperti modul logging bawaan Python, Loguru menawarkan antarmuka yang lebih fleksibel dan ramah pengguna. Ini mencakup dukungan bawaan untuk memutar log, memfilter level log, dan menangkap log dalam berbagai format. Pustaka ini sangat berguna ketika bekerja dengan aplikasi yang menghasilkan log berlebihan, karena menyederhanakan pengelolaan log sekaligus memastikan bahwa pesan penting tidak terlewatkan selama penanganan kesalahan.

Loguru memungkinkan pengaturan log sink, yang dapat disesuaikan untuk menyimpan log di memori, file, atau bahkan layanan eksternal. Anda dapat membuat buffer dalam memori sementara menggunakan sink khusus, yang kemudian dapat dihapus saat mengalami kesalahan. Hal ini menjadikan Loguru alternatif yang ampuh bagi mereka yang menginginkan kontrol lebih besar atas sistem logging mereka tanpa mengonfigurasi penangan secara manual seperti di perpustakaan logging standar.

Manfaat lain dari Loguru adalah memungkinkan integrasi yang mudah dengan sistem logging yang ada, artinya Anda dapat beralih ke Loguru tanpa merombak seluruh pengaturan logging Anda. Hal ini dapat sangat membantu ketika menangani aplikasi kompleks yang mengutamakan kinerja dan manajemen log. Pada akhirnya, meskipun modul logging Python cukup untuk sebagian besar kasus penggunaan, menjelajahi perpustakaan seperti Loguru memberikan fleksibilitas tambahan dan kemudahan penggunaan untuk menangkap dan mengelola pesan log secara efektif.