Cách truy xuất các thông báo ghi nhật ký Python gần đây khi xảy ra lỗi

Tối ưu hóa ghi nhật ký Python để xử lý lỗi

Đăng nhập Python là điều cần thiết để theo dõi các sự kiện và chẩn đoán sự cố trong quá trình thực thi chương trình. Tuy nhiên, một số mô-đun nhất định có thể tạo ra quá nhiều thông tin theo dõi, điều này có thể làm lộn xộn nhật ký. Trong những trường hợp như vậy, việc đặt mức ghi nhật ký thích hợp, chẳng hạn như LỖI, có thể giúp lọc ra những chi tiết không cần thiết.

Trong trường hợp một mô-đun tạo ra quá nhiều nhật ký nhưng xảy ra lỗi trong một mô-đun khác đang gọi nó, việc truy cập các thông báo nhật ký gần đây trở nên quan trọng. Điều này thường xảy ra khi truy tìm nguyên nhân gốc rễ của lỗi. Cần có sự cân bằng giữa việc bỏ qua các nhật ký quá mức và ghi lại những nhật ký quan trọng.

Thư viện như spdlog trong C++ có hỗ trợ tích hợp cho việc quay lui thông qua bộ đệm vòng, cho phép các nhà phát triển xem lại các nhật ký gần đây dẫn đến lỗi. của Python khai thác gỗ tuy nhiên, thư viện không cung cấp tính năng này ngay lập tức, đặt ra câu hỏi về cách triển khai một cơ chế tương tự.

Bài viết này khám phá cách bạn có thể điều chỉnh hệ thống ghi nhật ký của Python để ghi lại các thông báo nhật ký gần đây khi xảy ra lỗi, đảm bảo thông tin quan trọng từ người kiểm tra mô-đun có sẵn để chẩn đoán mà không làm tràn ngập nhật ký với dữ liệu theo dõi.

Ghi lại các nhật ký lỗi gần đây một cách hiệu quả trong Python

Tập lệnh đầu tiên được trình bày sử dụng trình xử lý ghi nhật ký tùy chỉnh với deque cấu trúc từ Python bộ sưu tập mô-đun. Deque này hoạt động như một bộ đệm vòng, chứa một số lượng thông điệp tường trình gần đây cố định. Trình xử lý sẽ ghi đè phát ra phương thức này được gọi mỗi khi nhật ký được tạo. Trong phương pháp này, mỗi thông điệp tường trình được định dạng và sau đó được thêm vào deque. Vì deque có độ dài tối đa nên nó sẽ tự động loại bỏ các tin nhắn cũ nhất khi đạt đến dung lượng. Giải pháp này theo dõi các nhật ký gần đây nhất một cách hiệu quả, đảm bảo rằng các thông báo gỡ lỗi quá mức từ mô-đun kiểm tra không lấn át đầu ra nhật ký nhưng vẫn sẵn có khi xảy ra lỗi trong mô-đun Á hậu.

Khi phát hiện lỗi trong mô-đun Á hậu, tập lệnh sẽ gọi một phương thức tùy chỉnh get_logs để truy xuất các thông điệp tường trình được lưu trữ trong deque. Điều này cho phép bạn kiểm tra thông điệp tường trình từ trình kiểm tra ngay trước lỗi. Ý tưởng đằng sau phương pháp này là các thông điệp tường trình cung cấp ngữ cảnh quan trọng cho việc khắc phục sự cố trong khi vẫn duy trì sự cân bằng giữa mức độ chi tiết và tiện ích của nhật ký. Đây là một cách đơn giản và hiệu quả để tạo bộ đệm nhật ký tròn trong Python, tương tự như cách dấu vết quay lại tính năng được tìm thấy trong thư viện spdlog của C++.

Giải pháp thứ hai sử dụng tính năng tích hợp sẵn Trình xử lý bộ nhớ từ mô-đun ghi nhật ký của Python. MemoryHandler hoạt động bằng cách đệm các thông điệp tường trình vào bộ nhớ và chỉ xóa chúng khi gặp phải một mức nhật ký cụ thể, chẳng hạn như một LỖI. Trong trường hợp này, trình xử lý được cấu hình để đệm tối đa 10 thông điệp tường trình và xóa chúng khi xảy ra lỗi. Cách tiếp cận này tương tự như kỹ thuật đệm vòng nhưng sử dụng cơ sở hạ tầng ghi nhật ký hiện có của Python, giúp đơn giản hóa việc triển khai. MemoryHandler lý tưởng cho các tình huống mà bạn muốn chụp ảnh nhanh các thông báo nhật ký dẫn đến lỗi mà không làm lộn xộn nhật ký trong các hoạt động thông thường.

Cả hai giải pháp đều được tối ưu hóa về hiệu suất và được thiết kế để hạn chế mức tiêu thụ bộ nhớ. Bằng cách hạn chế số lượng nhật ký được lưu trữ trong bộ nhớ và chỉ xóa bộ đệm trong các sự kiện quan trọng, chúng giúp duy trì nhật ký sạch sẽ, dễ quản lý. Điều này cho phép các nhà phát triển tập trung vào việc sửa lỗi thực tế thay vì sàng lọc lượng lớn thông tin không cần thiết. Mỗi tập lệnh có thể được tích hợp dễ dàng vào các cấu hình ghi nhật ký Python hiện có bằng cách chỉ cần thêm trình xử lý tùy chỉnh hoặc bộ nhớ vào trình ghi nhật ký được đề cập và cả hai đều đủ linh hoạt để thích ứng với các định dạng và cấp độ nhật ký khác nhau.

# 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

Khám phá các cách thay thế để ghi lại thông điệp tường trình bằng Python

Một cách tiếp cận khác để ghi lại các thông điệp tường trình gần đây bằng Python liên quan đến việc sử dụng thư viện của bên thứ ba như loguru. Không giống như mô-đun ghi nhật ký tích hợp của Python, Loguru cung cấp giao diện linh hoạt và thân thiện hơn với người dùng. Nó bao gồm hỗ trợ tích hợp để xoay nhật ký, lọc cấp độ nhật ký và ghi nhật ký ở nhiều định dạng khác nhau. Thư viện này có thể đặc biệt hữu ích khi làm việc với các ứng dụng tạo ra quá nhiều nhật ký vì nó đơn giản hóa việc quản lý nhật ký đồng thời đảm bảo rằng các thông báo quan trọng không bị bỏ sót trong quá trình xử lý lỗi.

Loguru cho phép thiết lập các vùng chứa nhật ký, có thể được tùy chỉnh để lưu trữ nhật ký trong bộ nhớ, tệp hoặc thậm chí các dịch vụ bên ngoài. Bạn có thể tạo bộ đệm trong bộ nhớ tạm thời bằng cách sử dụng bộ đệm tùy chỉnh, bộ đệm này sau đó có thể bị xóa khi gặp lỗi. Điều này làm cho Loguru trở thành một giải pháp thay thế mạnh mẽ cho những ai muốn kiểm soát nhiều hơn hệ thống ghi nhật ký của mình mà không cần cấu hình trình xử lý theo cách thủ công như trong thư viện ghi nhật ký tiêu chuẩn.

Một lợi ích khác của Loguru là nó cho phép tích hợp dễ dàng với các hệ thống ghi nhật ký hiện có, nghĩa là bạn có thể chuyển sang Loguru mà không cần sửa lại toàn bộ thiết lập ghi nhật ký của mình. Điều này có thể đặc biệt hữu ích khi xử lý các ứng dụng phức tạp trong đó hiệu suất và quản lý nhật ký là rất quan trọng. Cuối cùng, mặc dù mô-đun ghi nhật ký của Python đủ cho hầu hết các trường hợp sử dụng, nhưng việc khám phá các thư viện như Loguru mang lại sự linh hoạt và dễ sử dụng hơn để thu thập và quản lý thông điệp tường trình một cách hiệu quả.