പിശകുകളുടെ സമയത്ത്

Mia Chevalier

2024, നവംബർ 1, വെള്ളിയാഴ്‌ച 10:31:00 PM

പിശക് കൈകാര്യം ചെയ്യുന്നതിനായി പൈത്തൺ ലോഗിംഗ് ഒപ്റ്റിമൈസ് ചെയ്യുന്നു
ഒരു പ്രോഗ്രാമിൻ്റെ നിർവ്വഹണ വേളയിൽ ഇവൻ്റുകൾ ട്രാക്കുചെയ്യുന്നതിനും പ്രശ്നങ്ങൾ കണ്ടെത്തുന്നതിനും പൈത്തണിൽ ലോഗിൻ ചെയ്യുന്നത് അത്യന്താപേക്ഷിതമാണ്. എന്നിരുന്നാലും, ചില മൊഡ്യൂളുകൾക്ക് അമിതമായ ട്രെയ്സ് വിവരങ്ങൾ സൃഷ്ടിക്കാൻ കഴിയും, ഇത് ലോഗുകൾ അലങ്കോലപ്പെടുത്തിയേക്കാം. അത്തരം സന്ദർഭങ്ങളിൽ, ഉചിതമായ ഒരു ലോഗിംഗ് ലെവൽ സജ്ജീകരിക്കുക , അനാവശ്യ വിശദാംശങ്ങൾ ഫിൽട്ടർ ചെയ്യാൻ സഹായിക്കും.
ഒരു മൊഡ്യൂൾ അമിതമായ ലോഗുകൾ സൃഷ്ടിക്കുന്ന സാഹചര്യത്തിൽ, മറ്റൊരു മൊഡ്യൂളിനെ വിളിക്കുന്നതിൽ പിശകുകൾ സംഭവിക്കുമ്പോൾ, സമീപകാല ലോഗ് സന്ദേശങ്ങൾ ആക്സസ് ചെയ്യുന്നത് നിർണായകമാണ്. ഒരു പിശകിൻ്റെ മൂലകാരണം കണ്ടെത്തുമ്പോൾ ഇത് പലപ്പോഴും സംഭവിക്കാറുണ്ട്. അമിതമായ ലോഗുകൾ അവഗണിക്കുന്നതിനും പ്രധാനപ്പെട്ടവ പിടിച്ചെടുക്കുന്നതിനും ഇടയിൽ ഒരു ബാലൻസ് ആവശ്യമാണ്.
ലൈബ്രറികൾ ഇഷ്ടപ്പെടുന്നു C++-ൽ ഒരു റിംഗ് ബഫർ വഴി ബാക്ക്‌ട്രാക്ക് ചെയ്യുന്നതിനുള്ള ബിൽറ്റ്-ഇൻ പിന്തുണയുണ്ട്, ഇത് ഒരു പിശകിലേക്ക് നയിക്കുന്ന സമീപകാല ലോഗുകൾ അവലോകനം ചെയ്യാൻ ഡവലപ്പർമാരെ അനുവദിക്കുന്നു. പൈത്തണിൻ്റെ എന്നിരുന്നാലും, ലൈബ്രറി ഈ സവിശേഷത ബോക്‌സിന് പുറത്ത് വാഗ്ദാനം ചെയ്യുന്നില്ല, സമാനമായ ഒരു സംവിധാനം എങ്ങനെ നടപ്പിലാക്കാം എന്ന ചോദ്യം ഉയർത്തുന്നു.
ഒരു പിശക് സംഭവിക്കുമ്പോൾ സമീപകാല ലോഗ് സന്ദേശങ്ങൾ ക്യാപ്‌ചർ ചെയ്യുന്നതിന് പൈത്തണിൻ്റെ ലോഗിംഗ് സിസ്റ്റം എങ്ങനെ പൊരുത്തപ്പെടുത്താമെന്ന് ഈ ലേഖനം പര്യവേക്ഷണം ചെയ്യുന്നു, അതിൽ നിന്നുള്ള നിർണായക വിവരങ്ങൾ ഉറപ്പാക്കുന്നു. ട്രെയ്സ് ഡാറ്റ ഉപയോഗിച്ച് ലോഗുകൾ അധികമാക്കാതെ രോഗനിർണയത്തിനായി മൊഡ്യൂൾ ലഭ്യമാണ്.

കമാൻഡ് ഉപയോഗത്തിൻ്റെ ഉദാഹരണം

deque(maxlen=capacity) എന്നതിൽ നിന്ന് ഒരു ഇരട്ട ക്യൂ മൊഡ്യൂൾ, ഒരു നിശ്ചിത എണ്ണം ലോഗ് സന്ദേശങ്ങൾ ഉൾക്കൊള്ളുന്ന ഒരു റിംഗ് ബഫർ സൃഷ്ടിക്കാൻ ഇവിടെ ഉപയോഗിക്കുന്നു, പുതിയ സന്ദേശങ്ങൾ വരുമ്പോൾ ഏറ്റവും പഴയവ നിരസിക്കുന്നു. സമീപകാല സന്ദേശങ്ങളുടെ ഒരു ലോഗ് കാര്യക്ഷമമായി പരിപാലിക്കുന്നതിനുള്ള ഒരു നിർണായക ഘടനയാണിത്.

emit(self, record) ഓരോ ലോഗ് സന്ദേശവും ജനറേറ്റ് ചെയ്യുമ്പോൾ അത് പ്രോസസ്സ് ചെയ്യുന്നതിനായി ഇഷ്‌ടാനുസൃത ലോഗിംഗ് ഹാൻഡ്‌ലറുകളിൽ ഒരു രീതി അസാധുവാക്കിയിരിക്കുന്നു. എന്നതിലേക്ക് ലോഗ് സന്ദേശം ചേർക്കുന്നതിന് ഇത് ഉത്തരവാദിയാണ് ഞങ്ങളുടെ ഇഷ്‌ടാനുസൃത റിംഗ് ബഫർ പരിഹാരത്തിൽ.

logging.handlers.MemoryHandler മെമ്മറിയിൽ ലോഗ് സന്ദേശങ്ങൾ ബഫർ ചെയ്യുന്ന ഒരു ലോഗിംഗ് ഹാൻഡ്‌ലറാണിത്. ഒരു നിശ്ചിത ലോഗ് ലെവലിൽ എത്തുമ്പോൾ അത് അവരെ ഫ്ലഷ് ചെയ്യുന്നു (ഈ സാഹചര്യത്തിൽ, ). കൂടുതൽ ഗുരുതരമായ ഇവൻ്റ് സംഭവിക്കുന്നത് വരെ ലോഗ് സന്ദേശങ്ങളുടെ ഔട്ട്പുട്ട് മാറ്റിവയ്ക്കുന്നതിന് ഇത് ഉപയോഗപ്രദമാണ്.

flushLevel=logging.ERROR ഒരു വാദം കൈമാറി അവസാന ലക്ഷ്യസ്ഥാനത്തേക്ക് (കൺസോൾ അല്ലെങ്കിൽ ഒരു ഫയൽ പോലെ) ബഫർ ചെയ്ത സന്ദേശങ്ങളുടെ ഫ്ലഷിംഗ് ട്രിഗർ ചെയ്യുന്ന ലോഗ് ലെവൽ വ്യക്തമാക്കുന്നതിന്. ഒരു പിശക് സംഭവിച്ചാൽ മാത്രമേ ഞങ്ങൾ ഡീബഗ് ലോഗുകൾ കാണൂ എന്ന് ഇത് ഉറപ്പാക്കുന്നു.

setTarget(stream_handler) ൽ സമീപനം, ഈ രീതി ബഫർ ചെയ്ത ലോഗുകൾ ഫ്ലഷ് ചെയ്യുന്ന ടാർഗെറ്റ് ഹാൻഡ്‌ലറിനെ സജ്ജമാക്കുന്നു. ഈ സാഹചര്യത്തിൽ, ലക്ഷ്യം എ , ഇത് കൺസോളിലേക്ക് ലോഗുകൾ ഔട്ട്പുട്ട് ചെയ്യുന്നു.

format(record) ലോഗിംഗ് മൊഡ്യൂളിൻ്റെ ഫോർമാറ്റിംഗ് സിസ്റ്റത്തിൻ്റെ ഭാഗം. ഇഷ്‌ടാനുസൃത ഹാൻഡ്‌ലറിൽ, ഈ രീതി റിംഗ് ബഫറിലേക്ക് ചേർക്കുന്നതിന് മുമ്പ് ലോഗ് റെക്കോർഡ് ഫോർമാറ്റ് ചെയ്യുന്നു, ഇത് സ്ഥിരതയുള്ളതും വായിക്കാനാകുന്നതുമായ ഔട്ട്‌പുട്ട് അനുവദിക്കുന്നു.

logger.addHandler(buffer_handler) ലോഗറിലേക്ക് ഇഷ്‌ടാനുസൃത അല്ലെങ്കിൽ മെമ്മറി ഹാൻഡ്‌ലർ അറ്റാച്ചുചെയ്യുന്നു, അങ്ങനെ അത് ഹാൻഡ്‌ലറിൻ്റെ കോൺഫിഗറേഷൻ അനുസരിച്ച് ലോഗ് സന്ദേശങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നു (ഉദാ. ബഫറിംഗ്, സർക്കുലർ സ്റ്റോറേജ് മുതലായവ). ഈ കമാൻഡ് ഞങ്ങളുടെ ബഫർ ലോഗിംഗിനായി ഉപയോഗിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുന്നു.

logger.setLevel(logging.DEBUG) സന്ദേശങ്ങൾ ലോഗിൻ ചെയ്യുന്നതിനുള്ള ഏറ്റവും കുറഞ്ഞ തീവ്രത നിർവ്വചിക്കുന്നു. ഉദാഹരണങ്ങളിൽ, ഇത് സജ്ജീകരിച്ചിരിക്കുന്നു , തീവ്രത കുറഞ്ഞവ ഉൾപ്പെടെ എല്ലാ സന്ദേശങ്ങളും ക്യാപ്‌ചർ ചെയ്‌ത് പിന്നീടുള്ള പരിശോധനയ്‌ക്കായി ബഫർ ചെയ്‌തിരിക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.

കമാൻഡ്	ഉപയോഗത്തിൻ്റെ ഉദാഹരണം
deque(maxlen=capacity)	എന്നതിൽ നിന്ന് ഒരു ഇരട്ട ക്യൂ മൊഡ്യൂൾ, ഒരു നിശ്ചിത എണ്ണം ലോഗ് സന്ദേശങ്ങൾ ഉൾക്കൊള്ളുന്ന ഒരു റിംഗ് ബഫർ സൃഷ്ടിക്കാൻ ഇവിടെ ഉപയോഗിക്കുന്നു, പുതിയ സന്ദേശങ്ങൾ വരുമ്പോൾ ഏറ്റവും പഴയവ നിരസിക്കുന്നു. സമീപകാല സന്ദേശങ്ങളുടെ ഒരു ലോഗ് കാര്യക്ഷമമായി പരിപാലിക്കുന്നതിനുള്ള ഒരു നിർണായക ഘടനയാണിത്.
emit(self, record)	ഓരോ ലോഗ് സന്ദേശവും ജനറേറ്റ് ചെയ്യുമ്പോൾ അത് പ്രോസസ്സ് ചെയ്യുന്നതിനായി ഇഷ്‌ടാനുസൃത ലോഗിംഗ് ഹാൻഡ്‌ലറുകളിൽ ഒരു രീതി അസാധുവാക്കിയിരിക്കുന്നു. എന്നതിലേക്ക് ലോഗ് സന്ദേശം ചേർക്കുന്നതിന് ഇത് ഉത്തരവാദിയാണ് ഞങ്ങളുടെ ഇഷ്‌ടാനുസൃത റിംഗ് ബഫർ പരിഹാരത്തിൽ.
logging.handlers.MemoryHandler	മെമ്മറിയിൽ ലോഗ് സന്ദേശങ്ങൾ ബഫർ ചെയ്യുന്ന ഒരു ലോഗിംഗ് ഹാൻഡ്‌ലറാണിത്. ഒരു നിശ്ചിത ലോഗ് ലെവലിൽ എത്തുമ്പോൾ അത് അവരെ ഫ്ലഷ് ചെയ്യുന്നു (ഈ സാഹചര്യത്തിൽ, ). കൂടുതൽ ഗുരുതരമായ ഇവൻ്റ് സംഭവിക്കുന്നത് വരെ ലോഗ് സന്ദേശങ്ങളുടെ ഔട്ട്പുട്ട് മാറ്റിവയ്ക്കുന്നതിന് ഇത് ഉപയോഗപ്രദമാണ്.
flushLevel=logging.ERROR	ഒരു വാദം കൈമാറി അവസാന ലക്ഷ്യസ്ഥാനത്തേക്ക് (കൺസോൾ അല്ലെങ്കിൽ ഒരു ഫയൽ പോലെ) ബഫർ ചെയ്ത സന്ദേശങ്ങളുടെ ഫ്ലഷിംഗ് ട്രിഗർ ചെയ്യുന്ന ലോഗ് ലെവൽ വ്യക്തമാക്കുന്നതിന്. ഒരു പിശക് സംഭവിച്ചാൽ മാത്രമേ ഞങ്ങൾ ഡീബഗ് ലോഗുകൾ കാണൂ എന്ന് ഇത് ഉറപ്പാക്കുന്നു.
setTarget(stream_handler)	ൽ സമീപനം, ഈ രീതി ബഫർ ചെയ്ത ലോഗുകൾ ഫ്ലഷ് ചെയ്യുന്ന ടാർഗെറ്റ് ഹാൻഡ്‌ലറിനെ സജ്ജമാക്കുന്നു. ഈ സാഹചര്യത്തിൽ, ലക്ഷ്യം എ , ഇത് കൺസോളിലേക്ക് ലോഗുകൾ ഔട്ട്പുട്ട് ചെയ്യുന്നു.
format(record)	ലോഗിംഗ് മൊഡ്യൂളിൻ്റെ ഫോർമാറ്റിംഗ് സിസ്റ്റത്തിൻ്റെ ഭാഗം. ഇഷ്‌ടാനുസൃത ഹാൻഡ്‌ലറിൽ, ഈ രീതി റിംഗ് ബഫറിലേക്ക് ചേർക്കുന്നതിന് മുമ്പ് ലോഗ് റെക്കോർഡ് ഫോർമാറ്റ് ചെയ്യുന്നു, ഇത് സ്ഥിരതയുള്ളതും വായിക്കാനാകുന്നതുമായ ഔട്ട്‌പുട്ട് അനുവദിക്കുന്നു.
logger.addHandler(buffer_handler)	ലോഗറിലേക്ക് ഇഷ്‌ടാനുസൃത അല്ലെങ്കിൽ മെമ്മറി ഹാൻഡ്‌ലർ അറ്റാച്ചുചെയ്യുന്നു, അങ്ങനെ അത് ഹാൻഡ്‌ലറിൻ്റെ കോൺഫിഗറേഷൻ അനുസരിച്ച് ലോഗ് സന്ദേശങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നു (ഉദാ. ബഫറിംഗ്, സർക്കുലർ സ്റ്റോറേജ് മുതലായവ). ഈ കമാൻഡ് ഞങ്ങളുടെ ബഫർ ലോഗിംഗിനായി ഉപയോഗിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുന്നു.
logger.setLevel(logging.DEBUG)	സന്ദേശങ്ങൾ ലോഗിൻ ചെയ്യുന്നതിനുള്ള ഏറ്റവും കുറഞ്ഞ തീവ്രത നിർവ്വചിക്കുന്നു. ഉദാഹരണങ്ങളിൽ, ഇത് സജ്ജീകരിച്ചിരിക്കുന്നു , തീവ്രത കുറഞ്ഞവ ഉൾപ്പെടെ എല്ലാ സന്ദേശങ്ങളും ക്യാപ്‌ചർ ചെയ്‌ത് പിന്നീടുള്ള പരിശോധനയ്‌ക്കായി ബഫർ ചെയ്‌തിരിക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.

പൈത്തണിലെ പിശകിലെ സമീപകാല ലോഗുകൾ കാര്യക്ഷമമായി ക്യാപ്‌ചർ ചെയ്യുന്നു

അവതരിപ്പിച്ച ആദ്യ സ്ക്രിപ്റ്റ് ഒരു ഇഷ്‌ടാനുസൃത ലോഗിംഗ് ഹാൻഡ്‌ലർ ഉപയോഗിക്കുന്നു പൈത്തണിൽ നിന്നുള്ള ഘടന മൊഡ്യൂൾ. ഈ ഡിക്യൂ ഒരു റിംഗ് ബഫറായി പ്രവർത്തിക്കുന്നു, ഒരു നിശ്ചിത എണ്ണം സമീപകാല ലോഗ് സന്ദേശങ്ങൾ സൂക്ഷിക്കുന്നു. കൈകാര്യം ചെയ്യുന്നയാൾ അസാധുവാക്കുന്നു ഒരു ലോഗ് ജനറേറ്റുചെയ്യുമ്പോഴെല്ലാം വിളിക്കപ്പെടുന്ന രീതി. ഈ രീതിയിൽ, ഓരോ ലോഗ് സന്ദേശവും ഫോർമാറ്റ് ചെയ്യുകയും തുടർന്ന് ഡിക്യൂവിൽ കൂട്ടിച്ചേർക്കുകയും ചെയ്യുന്നു. ഡീക്യൂവിന് പരമാവധി ദൈർഘ്യമുള്ളതിനാൽ, ശേഷിയിലെത്തുമ്പോൾ അത് പഴയ സന്ദേശങ്ങൾ സ്വയമേവ നിരസിക്കുന്നു. ഈ സൊല്യൂഷൻ ഏറ്റവും പുതിയ ലോഗുകൾ കാര്യക്ഷമമായി ട്രാക്ക് ചെയ്യുന്നു, ചെക്കർ മൊഡ്യൂളിൽ നിന്നുള്ള അമിതമായ ഡീബഗ് സന്ദേശങ്ങൾ ലോഗ് ഔട്ട്‌പുട്ടിനെ മറികടക്കുന്നില്ലെന്നും എന്നാൽ റണ്ണർ മൊഡ്യൂളിൽ ഒരു പിശക് സംഭവിക്കുമ്പോൾ അവ ലഭ്യമാകുമെന്നും ഉറപ്പാക്കുന്നു.

റണ്ണർ മൊഡ്യൂളിൽ ഒരു പിശക് കണ്ടെത്തുമ്പോൾ, സ്ക്രിപ്റ്റ് ഒരു ഇഷ്‌ടാനുസൃത രീതിയെ വിളിക്കുന്നു deque-ൽ സംഭരിച്ചിരിക്കുന്ന ലോഗ് സന്ദേശങ്ങൾ വീണ്ടെടുക്കാൻ. പിശകിന് മുമ്പുള്ള ചെക്കറിൽ നിന്നുള്ള ലോഗ് സന്ദേശങ്ങൾ പരിശോധിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. ലോഗ് വെർബോസിറ്റിയും യൂട്ടിലിറ്റിയും തമ്മിലുള്ള സന്തുലിതാവസ്ഥ നിലനിർത്തിക്കൊണ്ട് ലോഗ് സന്ദേശങ്ങൾ ട്രബിൾഷൂട്ടിംഗിന് നിർണായക സന്ദർഭം നൽകുന്നു എന്നതാണ് ഈ സമീപനത്തിന് പിന്നിലെ ആശയം. പൈത്തണിൽ ഒരു വൃത്താകൃതിയിലുള്ള ലോഗ് ബഫർ സൃഷ്ടിക്കുന്നതിനുള്ള ലളിതവും ഫലപ്രദവുമായ മാർഗ്ഗമാണിത് 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

പൈത്തണിൽ ലോഗ് സന്ദേശങ്ങൾ ക്യാപ്ചർ ചെയ്യുന്നതിനുള്ള ഇതര മാർഗങ്ങൾ പര്യവേക്ഷണം ചെയ്യുന്നു

പൈത്തണിൽ സമീപകാല ലോഗ് സന്ദേശങ്ങൾ ക്യാപ്‌ചർ ചെയ്യുന്നതിനുള്ള മറ്റൊരു സമീപനം ഒരു മൂന്നാം കക്ഷി ലൈബ്രറി ഉപയോഗിക്കുന്നത് ഉൾപ്പെടുന്നു. . പൈത്തണിൻ്റെ ബിൽറ്റ്-ഇൻ ലോഗിംഗ് മൊഡ്യൂളിൽ നിന്ന് വ്യത്യസ്തമായി, ലോഗുരു കൂടുതൽ വഴക്കമുള്ളതും ഉപയോക്തൃ-സൗഹൃദവുമായ ഇൻ്റർഫേസ് വാഗ്ദാനം ചെയ്യുന്നു. ലോഗുകൾ തിരിക്കുന്നതിനും ലോഗ് ലെവലുകൾ ഫിൽട്ടർ ചെയ്യുന്നതിനും വിവിധ ഫോർമാറ്റുകളിൽ ലോഗുകൾ ക്യാപ്‌ചർ ചെയ്യുന്നതിനുമുള്ള ബിൽറ്റ്-ഇൻ പിന്തുണ ഇതിൽ ഉൾപ്പെടുന്നു. അമിതമായ ലോഗുകൾ സൃഷ്ടിക്കുന്ന ആപ്ലിക്കേഷനുകൾക്കൊപ്പം പ്രവർത്തിക്കുമ്പോൾ ഈ ലൈബ്രറി പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാകും, കാരണം ഇത് ലോഗ് മാനേജ്മെൻ്റ് ലളിതമാക്കുകയും പിശക് കൈകാര്യം ചെയ്യുന്നതിനിടയിൽ നിർണായക സന്ദേശങ്ങൾ നഷ്‌ടപ്പെടുന്നില്ലെന്ന് ഉറപ്പാക്കുകയും ചെയ്യുന്നു.

ലോഗ് സിങ്കുകൾ സജ്ജീകരിക്കാൻ ലോഗുരു അനുവദിക്കുന്നു, ഇത് മെമ്മറിയിലോ ഫയലുകളിലോ ബാഹ്യ സേവനങ്ങളിലോ ലോഗുകൾ സംഭരിക്കുന്നതിന് ഇഷ്ടാനുസൃതമാക്കാവുന്നതാണ്. ഒരു ഇഷ്‌ടാനുസൃത സിങ്ക് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു താൽക്കാലിക ഇൻ-മെമ്മറി ബഫർ സൃഷ്‌ടിക്കാനാകും, ഒരു പിശക് നേരിടുമ്പോൾ അത് ഫ്ലഷ് ചെയ്യാവുന്നതാണ്. സ്റ്റാൻഡേർഡ് ലോഗിംഗ് ലൈബ്രറിയിലേതുപോലെ ഹാൻഡ്‌ലറുകൾ സ്വമേധയാ കോൺഫിഗർ ചെയ്യാതെ തന്നെ ലോഗിംഗ് സിസ്റ്റത്തിൽ കൂടുതൽ നിയന്ത്രണം ആഗ്രഹിക്കുന്നവർക്ക് ഇത് ലോഗുരുവിനെ ഒരു ശക്തമായ ബദലാക്കുന്നു.

ലോഗുരുവിൻ്റെ മറ്റൊരു നേട്ടം, നിലവിലുള്ള ലോഗിംഗ് സിസ്റ്റങ്ങളുമായി എളുപ്പത്തിൽ സംയോജിപ്പിക്കാൻ ഇത് അനുവദിക്കുന്നു, അതായത് നിങ്ങളുടെ മുഴുവൻ ലോഗിംഗ് സജ്ജീകരണവും ഓവർഹോൾ ചെയ്യാതെ തന്നെ നിങ്ങൾക്ക് ലോഗുരുവിലേക്ക് മാറാം. പ്രകടനവും ലോഗ് മാനേജ്മെൻ്റും നിർണായകമായ സങ്കീർണ്ണമായ ആപ്ലിക്കേഷനുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ ഇത് പ്രത്യേകിച്ചും സഹായകമാകും. ആത്യന്തികമായി, മിക്ക ഉപയോഗ കേസുകൾക്കും പൈത്തണിൻ്റെ ലോഗിംഗ് മൊഡ്യൂൾ മതിയാകുമ്പോൾ, ലോഗുരു പോലുള്ള ലൈബ്രറികൾ പര്യവേക്ഷണം ചെയ്യുന്നത് ലോഗ് സന്ദേശങ്ങൾ ഫലപ്രദമായി ക്യാപ്‌ചർ ചെയ്യുന്നതിനും കൈകാര്യം ചെയ്യുന്നതിനും അധിക വഴക്കവും ഉപയോഗവും നൽകുന്നു.

ലോഗ് മെസേജ് വെർബോസിറ്റി എനിക്ക് എങ്ങനെ പരിമിതപ്പെടുത്താനാകും?
ഉപയോഗിക്കുക ഡീബഗ്, ഇൻഫോ പോലുള്ള കുറഞ്ഞ തീവ്രതയുള്ള സന്ദേശങ്ങൾ അടിച്ചമർത്താൻ, പിശകുകൾ മാത്രം കാണിക്കുന്നു.
സമീപകാല ലോഗുകൾ മെമ്മറിയിൽ സൂക്ഷിക്കുന്നതിനുള്ള ഏറ്റവും നല്ല മാർഗം ഏതാണ്?
എ ഏറ്റവും പഴയ എൻട്രികൾ സ്വയമേവ നിരസിച്ചുകൊണ്ട് സമീപകാല ലോഗ് സന്ദേശങ്ങൾ സംഭരിക്കുന്നതിന് ഉപയോഗിക്കാം.
ഒരു പിശക് സംഭവിക്കുമ്പോൾ ബഫർ ചെയ്ത ലോഗുകൾ എങ്ങനെ ഫ്ലഷ് ചെയ്യാം?
കൂടെ , ലോഗുകൾ മെമ്മറിയിൽ സംഭരിക്കുകയും ഒരു നിശ്ചിത ലോഗ് ലെവൽ ട്രിഗർ ചെയ്യുമ്പോൾ ഫ്ലഷ് ചെയ്യുകയും ചെയ്യുന്നു .
പൈത്തണിൻ്റെ ലോഗിംഗിൽ ലോഗുരു ഉപയോഗിക്കുന്നതിൻ്റെ പ്രയോജനം എന്താണ്?
കുറഞ്ഞ ബോയിലർ പ്ലേറ്റ് കോഡ് ഉപയോഗിച്ച് ലോഗ് സജ്ജീകരണം ലളിതമാക്കുകയും ലോഗുകൾ എളുപ്പത്തിൽ ഫിൽട്ടറിംഗ് ചെയ്യാനും തിരിക്കാനും പോലുള്ള കൂടുതൽ അവബോധജന്യമായ സവിശേഷതകൾ നൽകുന്നു.
നിലവിലുള്ള ലോഗിംഗ് കോൺഫിഗറേഷനുകളുമായി എനിക്ക് ലോഗുരു സംയോജിപ്പിക്കാനാകുമോ?
അതെ, ഡിഫോൾട്ട് ലോഗിംഗ് ഹാൻഡ്‌ലർ മാറ്റി പകരം പൈത്തണിൻ്റെ ബിൽറ്റ്-ഇൻ ലോഗിംഗ് സിസ്റ്റവുമായി ലോഗുരുവിന് സുഗമമായി സംയോജിപ്പിക്കാൻ കഴിയും.

പിശക് സാധ്യതയുള്ള സാഹചര്യങ്ങളിൽ, പൈത്തണിൻ്റെ ലോഗിംഗ് മൊഡ്യൂൾ കാര്യക്ഷമമായി ഉപയോഗിക്കുന്നത് ഔട്ട്‌പുട്ട് അലങ്കോലപ്പെടുത്താതെ സമീപകാല ലോഗ് സന്ദേശങ്ങൾ ക്യാപ്‌ചർ ചെയ്യാൻ സഹായിക്കുന്നു. പോലുള്ള കസ്റ്റം ഹാൻഡ്‌ലർമാർ ഒപ്പം ഒരു പിശക് സംഭവിക്കുമ്പോൾ നിർണായക സന്ദേശങ്ങൾ സംഭരിക്കുന്നതിനുള്ള ബഹുമുഖ മാർഗങ്ങൾ നൽകുക.

ഡെവലപ്പർമാർക്ക് ആവശ്യമായ ലോഗ് ഡാറ്റ ലഭ്യമാണെന്ന് ഉറപ്പാക്കിക്കൊണ്ട്, ഉയർന്ന വാചികതയുള്ള മൊഡ്യൂളുകളിലെ പിശകുകൾ ഡീബഗ്ഗിംഗ് ചെയ്യുന്നതിന് ഈ പരിഹാരങ്ങൾ പ്രായോഗികമാണ്. പോലുള്ള മൂന്നാം കക്ഷി ടൂളുകൾ സമന്വയിപ്പിക്കുന്നതിലൂടെ , കുറഞ്ഞ കോൺഫിഗറേഷനോടുകൂടിയ വിപുലമായ ലോഗ് മാനേജ്മെൻ്റ് വാഗ്ദാനം ചെയ്യുന്ന, കൂടുതൽ വഴക്കം ലഭ്യമാണ്.

പൈത്തണിൻ്റെ വിശദീകരണം നടപ്പിലാക്കലും ലോഗിംഗിൽ അതിൻ്റെ ഉപയോഗവും: പൈത്തൺ ഡോക്യുമെൻ്റേഷൻ - ശേഖരങ്ങൾ
പൈത്തണിൻ്റെ വിശദാംശങ്ങൾ ലൈബ്രറിയും മെമ്മറി ഹാൻഡ്‌ലറും: പൈത്തൺ ഡോക്യുമെൻ്റേഷൻ - ലോഗിംഗ്
യുടെ അവലോകനം ഒരു നൂതന പൈത്തൺ ലോഗിംഗ് ബദലായി: ലോഗുരു ഡോക്യുമെൻ്റേഷൻ
താരതമ്യവും ഉപയോഗവും ബാക്ക്ട്രെയിസ് പിന്തുണയ്‌ക്കായി C++ ൽ: spdlog GitHub റിപ്പോസിറ്ററി

പിശകുകളുടെ സമയത്ത് സമീപകാല പൈത്തൺ ലോഗിംഗ് സന്ദേശങ്ങൾ എങ്ങനെ വീണ്ടെടുക്കാം

പൈത്തണിലെ പിശകിലെ സമീപകാല ലോഗുകൾ കാര്യക്ഷമമായി ക്യാപ്‌ചർ ചെയ്യുന്നു

ഒരു ഇഷ്‌ടാനുസൃത റിംഗ് ബഫർ ഉപയോഗിച്ച് പിശകിൽ സമീപകാല പൈത്തൺ ലോഗിംഗ് സന്ദേശങ്ങൾ ക്യാപ്‌ചർ ചെയ്യുന്നു

പൈത്തണിലെ ബഫർഡ് ലോഗിംഗിനായി മെമ്മറി ഹാൻഡ്‌ലർ ഉപയോഗിക്കുന്നു

പൈത്തണിൽ ലോഗ് സന്ദേശങ്ങൾ ക്യാപ്ചർ ചെയ്യുന്നതിനുള്ള ഇതര മാർഗങ്ങൾ പര്യവേക്ഷണം ചെയ്യുന്നു