பிழைகளின் போது சமீபத்திய பைதான் பதிவு செய்திகளை எவ்வாறு மீட்டெடுப்பது

பிழை கையாளுதலுக்காக பைதான் லாக்கிங்கை மேம்படுத்துகிறது

பைத்தானில் உள்நுழைவது நிகழ்வுகளைக் கண்காணிப்பதற்கும் ஒரு நிரலை செயல்படுத்தும் போது சிக்கல்களைக் கண்டறிவதற்கும் அவசியம். இருப்பினும், சில தொகுதிகள் அதிகப்படியான சுவடு தகவலை உருவாக்கலாம், இது பதிவுகளை ஒழுங்கீனம் செய்யக்கூடும். இது போன்ற சந்தர்ப்பங்களில், பொருத்தமான பதிவு நிலை அமைப்பது பிழை, தேவையற்ற விவரங்களை வடிகட்ட உதவும்.

ஒரு தொகுதி அதிகப்படியான பதிவுகளை உருவாக்கும் சூழ்நிலைகளில், ஆனால் அதை அழைக்கும் மற்றொரு தொகுதியில் பிழைகள் ஏற்பட்டால், சமீபத்திய பதிவு செய்திகளை அணுகுவது முக்கியமானது. பிழையின் மூல காரணத்தைக் கண்டறியும் போது இது பெரும்பாலும் நிகழ்கிறது. அதிகப்படியான பதிவுகளைப் புறக்கணிப்பதற்கும் முக்கியமானவற்றைப் பிடிப்பதற்கும் இடையில் சமநிலை தேவை.

நூலகங்கள் போன்றவை spdlog C++ இல் ரிங் பஃபர் மூலம் பின்னடைவுக்கான உள்ளமைக்கப்பட்ட ஆதரவைக் கொண்டுள்ளது, இது பிழைக்கு வழிவகுக்கும் சமீபத்திய பதிவுகளை மதிப்பாய்வு செய்ய டெவலப்பர்களை அனுமதிக்கிறது. பைத்தானின் மரம் வெட்டுதல் இருப்பினும், நூலகம் இந்த அம்சத்தை பெட்டிக்கு வெளியே வழங்கவில்லை, இதேபோன்ற பொறிமுறையை எவ்வாறு செயல்படுத்துவது என்ற கேள்வியை எழுப்புகிறது.

பிழை ஏற்படும் போது சமீபத்திய பதிவு செய்திகளைப் பிடிக்க பைத்தானின் லாக்கிங் அமைப்பை எவ்வாறு மாற்றியமைக்கலாம் என்பதை இந்தக் கட்டுரை ஆராய்கிறது. சரிபார்ப்பவர் ட்ரேஸ் டேட்டாவுடன் பதிவுகளை அதிகப்படுத்தாமல் நோயறிதலுக்கு தொகுதி கிடைக்கிறது.

பைத்தானில் பிழையின் சமீபத்திய பதிவுகளை திறம்படப் பிடிக்கிறது

வழங்கப்பட்ட முதல் ஸ்கிரிப்ட் ஒரு தனிப்பயன் லாக்கிங் ஹேண்ட்லரைப் பயன்படுத்துகிறது deque பைத்தானின் அமைப்பு சேகரிப்புகள் தொகுதி. இந்த deque ஆனது ஒரு குறிப்பிட்ட எண்ணிக்கையிலான சமீபத்திய பதிவு செய்திகளை வைத்திருக்கும் ஒரு வளைய இடையகமாக செயல்படுகிறது. கையாளுபவர் மேலெழுதுகிறார் உமிழ்கின்றன முறை, ஒவ்வொரு முறையும் பதிவு உருவாக்கப்படும் போது அழைக்கப்படுகிறது. இந்த முறையில், ஒவ்வொரு பதிவு செய்தியும் வடிவமைக்கப்பட்டு பின்னர் deque உடன் இணைக்கப்படும். டீக்கின் அதிகபட்ச நீளம் இருப்பதால், அது திறனை அடையும் போது தானாகவே பழைய செய்திகளை நிராகரிக்கும். இந்தத் தீர்வு, மிகச் சமீபத்திய பதிவுகளைத் திறம்படக் கண்காணிக்கிறது, செக்கர் தொகுதியிலிருந்து வரும் அதிகப்படியான பிழைத்திருத்தச் செய்திகள் பதிவு வெளியீட்டை அதிகப்படுத்தாது, ஆனால் ரன்னர் தொகுதியில் பிழை ஏற்பட்டால் அவை கிடைக்கின்றன.

ரன்னர் தொகுதியில் பிழை கண்டறியப்பட்டால், ஸ்கிரிப்ட் தனிப்பயன் முறையை அழைக்கிறது பெற_பதிவுகள் deque இல் சேமிக்கப்பட்ட பதிவு செய்திகளை மீட்டெடுக்க. இது பிழைக்கு முந்தைய சரிபார்ப்பாளரிடமிருந்து பதிவு செய்திகளை உடனடியாக ஆய்வு செய்ய உங்களை அனுமதிக்கிறது. இந்த அணுகுமுறையின் பின்னணியில் உள்ள யோசனை என்னவென்றால், பதிவுச் செய்திகள் பிழையறிந்து திருத்துவதற்கான முக்கியமான சூழலை வழங்குகின்றன, அதே நேரத்தில் பதிவு verbosity மற்றும் பயன்பாட்டிற்கு இடையில் சமநிலையை பராமரிக்கின்றன. பைத்தானில் ஒரு வட்ட பதிவு இடையகத்தை உருவாக்க இது ஒரு எளிய மற்றும் பயனுள்ள வழியாகும் பின்னோக்கி அம்சம் C++ இன் spdlog நூலகத்தில் உள்ளது.

இரண்டாவது தீர்வு உள்ளமைக்கப்பட்டதைப் பயன்படுத்துகிறது நினைவகம் கையாளுபவர் பைத்தானின் பதிவு தொகுதியிலிருந்து. MemoryHandler நினைவகத்தில் பதிவு செய்திகளை இடையகப்படுத்தி, ஒரு குறிப்பிட்ட பதிவு நிலை ஏற்படும் போது மட்டுமே அவற்றை சுத்தப்படுத்துகிறது. பிழை. இந்த வழக்கில், ஹேண்ட்லர் 10 பதிவு செய்திகளை இடையகப்படுத்தவும், பிழை ஏற்படும் போது அவற்றை பறிக்கவும் கட்டமைக்கப்பட்டுள்ளது. இந்த அணுகுமுறை ரிங் பஃபர் நுட்பத்தைப் போன்றது ஆனால் பைத்தானின் ஏற்கனவே உள்ள பதிவு உள்கட்டமைப்பைப் பயன்படுத்துகிறது, இது செயல்படுத்தலை எளிதாக்குகிறது. சாதாரண செயல்பாடுகளின் போது பதிவுகளை ஒழுங்கீனம் செய்யாமல் பிழைக்கு வழிவகுக்கும் பதிவு செய்திகளின் ஸ்னாப்ஷாட்டை நீங்கள் எடுக்க விரும்பும் காட்சிகளுக்கு MemoryHandler சிறந்தது.

இரண்டு தீர்வுகளும் செயல்திறனுக்காக உகந்தவை மற்றும் நினைவக நுகர்வு குறைக்க வடிவமைக்கப்பட்டுள்ளன. நினைவகத்தில் சேமிக்கப்பட்ட பதிவுகளின் எண்ணிக்கையைக் கட்டுப்படுத்துவதன் மூலமும், முக்கியமான நிகழ்வுகளின் போது இடையகத்தை மட்டும் சுத்தப்படுத்துவதன் மூலமும், அவை சுத்தமான, நிர்வகிக்கக்கூடிய பதிவுகளை பராமரிக்க உதவுகின்றன. இது டெவலப்பர்கள் அதிக அளவு தேவையற்ற தகவல்களைப் பிரிப்பதை விட உண்மையான பிழையை பிழைத்திருத்துவதில் கவனம் செலுத்த அனுமதிக்கிறது. ஒவ்வொரு ஸ்கிரிப்டையும் தனிப்பயன் அல்லது நினைவக ஹேண்ட்லர்களைச் சேர்ப்பதன் மூலம் ஏற்கனவே உள்ள பைதான் லாக்கிங் உள்ளமைவுகளுடன் எளிதாக ஒருங்கிணைக்க முடியும், மேலும் இரண்டும் பல்வேறு பதிவு வடிவங்கள் மற்றும் நிலைகளுக்கு ஏற்றவாறு நெகிழ்வாக இருக்கும்.

# 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

பைத்தானில் பதிவு செய்திகளைப் பிடிக்க மாற்று வழிகளை ஆராய்தல்

பைத்தானில் சமீபத்திய பதிவு செய்திகளைப் படம்பிடிப்பதற்கான மற்றொரு அணுகுமுறை மூன்றாம் தரப்பு நூலகத்தைப் பயன்படுத்துவதை உள்ளடக்கியது. லோகுரு. பைத்தானின் உள்ளமைக்கப்பட்ட பதிவு தொகுதி போலல்லாமல், Loguru மிகவும் நெகிழ்வான மற்றும் பயனர் நட்பு இடைமுகத்தை வழங்குகிறது. பதிவுகளை சுழற்றுவதற்கும், பதிவு நிலைகளை வடிகட்டுவதற்கும், பல்வேறு வடிவங்களில் பதிவுகளை கைப்பற்றுவதற்கும் உள்ளமைக்கப்பட்ட ஆதரவு இதில் அடங்கும். அதிகப்படியான பதிவுகளை உருவாக்கும் பயன்பாடுகளுடன் பணிபுரியும் போது இந்த நூலகம் மிகவும் பயனுள்ளதாக இருக்கும், ஏனெனில் இது பதிவு நிர்வாகத்தை எளிதாக்குகிறது, அதே நேரத்தில் பிழை கையாளும் போது முக்கியமான செய்திகள் தவறவிடப்படாமல் இருப்பதை உறுதி செய்கிறது.

நினைவகம், கோப்புகள் அல்லது வெளிப்புற சேவைகளில் பதிவுகளை சேமிக்க தனிப்பயனாக்கக்கூடிய பதிவு மூழ்கிகளை அமைக்க Loguru அனுமதிக்கிறது. தனிப்பயன் மடுவைப் பயன்படுத்தி தற்காலிக நினைவகத்தில் இடையகத்தை உருவாக்கலாம், பிழை ஏற்பட்டால் அதைச் சுத்தப்படுத்தலாம். நிலையான பதிவு நூலகத்தில் உள்ளதைப் போல கைமுறையாக ஹேண்ட்லர்களை உள்ளமைக்காமல், தங்கள் பதிவு முறையின் மீது அதிகக் கட்டுப்பாட்டை விரும்புவோருக்கு இது லோகுருவை ஒரு சக்திவாய்ந்த மாற்றாக ஆக்குகிறது.

Loguru இன் மற்றொரு நன்மை என்னவென்றால், இது ஏற்கனவே உள்ள பதிவு அமைப்புகளுடன் எளிதாக ஒருங்கிணைக்க அனுமதிக்கிறது, அதாவது உங்கள் முழு பதிவு அமைப்பையும் மாற்றியமைக்காமல் Loguru க்கு மாறலாம். செயல்திறன் மற்றும் பதிவு மேலாண்மை முக்கியமாக இருக்கும் சிக்கலான பயன்பாடுகளைக் கையாளும் போது இது குறிப்பாக உதவியாக இருக்கும். இறுதியில், பைத்தானின் பதிவுத் தொகுதி பெரும்பாலான பயன்பாட்டு நிகழ்வுகளுக்குப் போதுமானதாக இருக்கும் போது, ​​Loguru போன்ற நூலகங்களை ஆராய்வது, பதிவு செய்திகளை திறம்பட கைப்பற்றுவதற்கும் நிர்வகிப்பதற்கும் கூடுதல் நெகிழ்வுத்தன்மையையும் பயன்பாட்டின் எளிமையையும் வழங்குகிறது.