പൈത്തൺ ലോഗിംഗ് ഫ്രെയിംവർക്ക്: ഹാൻഡ്‌ലർ കോൺഫിഗറേഷനും കസ്റ്റം ഫോർമാറ്ററുകളും

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

പൈത്തൺ ലോഗിംഗിന്റെ അടിസ്ഥാനകാര്യങ്ങൾ മനസ്സിലാക്കാം

ഹാൻഡ്‌ലറുകളെയും ഫോർമാറ്ററുകളെയും കുറിച്ച് പഠിക്കുന്നതിന് മുമ്പ്, പൈത്തൺ ലോഗിംഗ് ഫ്രെയിംവർക്കിന്റെ പ്രധാന ഘടകങ്ങളെക്കുറിച്ച് വ്യക്തമായ ധാരണയുണ്ടാക്കാം:

• ലോഗറുകൾ (Loggers): ലോഗറുകളാണ് നിങ്ങളുടെ ആപ്ലിക്കേഷനിൽ നിന്ന് ലോഗ് സന്ദേശങ്ങൾ രേഖപ്പെടുത്താനുള്ള പ്രധാന ഇന്റർഫേസ്. അവ ശ്രേണിയിലുള്ളവയാണ്, അതായത് ഒരു ലോഗറിന് ചൈൽഡ് ലോഗറുകൾ ഉണ്ടാകാം, അത് മാതാപിതാക്കളിൽ നിന്ന് കോൺഫിഗറേഷൻ പാരമ്പര്യമായി സ്വീകരിക്കുന്നു. അവയെ നിങ്ങളുടെ ലോഗ് സന്ദേശങ്ങളുടെ കാവൽക്കാരായി കരുതുക.
• ലോഗ് ലെവലുകൾ (Log Levels): ലോഗ് ലെവലുകൾ (DEBUG, INFO, WARNING, ERROR, CRITICAL) ലോഗ് സന്ദേശങ്ങളുടെ ഗൗരവം തരംതിരിക്കുന്നു. ഏതൊക്കെ സന്ദേശങ്ങൾ പ്രോസസ്സ് ചെയ്യണമെന്ന് ഫിൽട്ടർ ചെയ്യാൻ നിങ്ങൾ ഈ ലെവലുകൾ ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു പ്രൊഡക്ഷൻ എൻവയോൺമെന്റിൽ, അനാവശ്യ സന്ദേശങ്ങൾ കുറയ്ക്കുന്നതിന് നിങ്ങൾ WARNING, ERROR, CRITICAL സന്ദേശങ്ങൾ മാത്രം ലോഗ് ചെയ്യാം.
• ഹാൻഡ്‌ലറുകൾ (Handlers): ഹാൻഡ്‌ലറുകളാണ് ലോഗ് സന്ദേശങ്ങൾ എവിടേക്ക് അയയ്ക്കണമെന്ന് തീരുമാനിക്കുന്നത്. ഇത് കൺസോൾ (stdout), ഒരു ഫയൽ, ഒരു നെറ്റ്‌വർക്ക് സോക്കറ്റ്, അല്ലെങ്കിൽ ഒരു ഡാറ്റാബേസ് ആകാം. ലോഗ് ലെവൽ അനുസരിച്ച് ഫിൽട്ടർ ചെയ്യാനും ഫോർമാറ്ററുകൾ പ്രയോഗിക്കാനും ഹാൻഡ്‌ലറുകളെ കോൺഫിഗർ ചെയ്യാൻ കഴിയും.
• ഫോർമാറ്ററുകൾ (Formatters): ഫോർമാറ്ററുകൾ നിങ്ങളുടെ ലോഗ് സന്ദേശങ്ങളുടെ ഘടനയും ഉള്ളടക്കവും നിർവചിക്കുന്നു. അവ ഏതൊക്കെ വിവരങ്ങൾ ഉൾപ്പെടുത്തണം (ടൈംസ്റ്റാമ്പ്, ലോഗർ നെയിം, ലോഗ് ലെവൽ, സന്ദേശത്തിന്റെ ഉള്ളടക്കം മുതലായവ) എന്നും അത് എങ്ങനെ അവതരിപ്പിക്കണമെന്നും നിയന്ത്രിക്കുന്നു. ലോഗ് സന്ദേശം എഴുതുന്നതിനു മുമ്പ് ഹാൻഡ്‌ലറാണ് ഫോർമാറ്ററുകൾ പ്രയോഗിക്കുന്നത്.

ഈ ഘടകങ്ങൾ ഒരുമിച്ച് പ്രവർത്തിച്ച് വഴക്കമുള്ളതും കോൺഫിഗർ ചെയ്യാവുന്നതുമായ ഒരു ലോഗിംഗ് സിസ്റ്റം നൽകുന്നു. ഒരു ലോഗ് സന്ദേശം ലോഗറിൽ നിന്ന് ഉത്ഭവിച്ച്, ഒരു ഹാൻഡ്‌ലറിലൂടെ കടന്നുപോയി, അതിന്റെ ലക്ഷ്യസ്ഥാനത്തേക്ക് അയയ്ക്കുന്നതിന് മുമ്പ് ഒരു ഫോർമാറ്റർ ഉപയോഗിച്ച് ഫോർമാറ്റ് ചെയ്യപ്പെടുന്നു. ഈ ഘടന ലോഗുകൾ എങ്ങനെ സൃഷ്ടിക്കപ്പെടുന്നു, പ്രോസസ്സ് ചെയ്യപ്പെടുന്നു, സംഭരിക്കപ്പെടുന്നു എന്നതിനെക്കുറിച്ച് സൂക്ഷ്മമായ നിയന്ത്രണം നൽകുന്നു.

ഹാൻഡ്‌ലർ കോൺഫിഗറേഷൻ: നിങ്ങളുടെ ലോഗുകൾ ഫലപ്രദമായി റൂട്ട് ചെയ്യുക

ലോഗിംഗ് ഫ്രെയിംവർക്കിലെ പ്രധാന ജോലിക്കാർ ഹാൻഡ്‌ലറുകളാണ്, നിങ്ങളുടെ ലോഗ് സന്ദേശങ്ങളെ അവയുടെ അവസാന ലക്ഷ്യസ്ഥാനത്തേക്ക് നയിക്കുന്നത് അവരാണ്. ഫലപ്രദമായ ലോഗിംഗിന് ശരിയായ ഹാൻഡ്‌ലർ കോൺഫിഗറേഷൻ അത്യാവശ്യമാണ്. പ്രധാന പരിഗണനകളുടെ ഒരു വിവരണം താഴെ നൽകുന്നു:

സാധാരണ ഹാൻഡ്‌ലർ തരങ്ങൾ:

• StreamHandler: ലോഗ് സന്ദേശങ്ങളെ ഒരു സ്ട്രീമിലേക്ക് അയയ്ക്കുന്നു, സാധാരണയായി stdout അല്ലെങ്കിൽ stderr-ലേക്ക്. ഡെവലപ്‌മെന്റ് സമയത്ത് കൺസോൾ ലോഗിംഗിന് അനുയോജ്യമാണിത്.
• FileHandler: ലോഗ് സന്ദേശങ്ങളെ ഒരു ഫയലിലേക്ക് എഴുതുന്നു. ആപ്ലിക്കേഷൻ ഇവന്റുകളുടെ സ്ഥിരമായ ലോഗിംഗിന് അത്യാവശ്യമാണ്, പ്രത്യേകിച്ച് പ്രൊഡക്ഷനിൽ. വിന്യാസത്തിന് ശേഷം ഉണ്ടാകുന്ന പ്രശ്നങ്ങൾ ഡീബഗ്ഗ് ചെയ്യുന്നതിന് ഇത് നിർണ്ണായകമാണ്.
• RotatingFileHandler: FileHandler-ന്റെ ഒരു സബ് ക്ലാസ്സാണിത്. ലോഗ് ഫയലുകൾ ഒരു നിശ്ചിത വലുപ്പത്തിൽ എത്തുമ്പോഴോ അല്ലെങ്കിൽ നിർദ്ദിഷ്ട സമയ ഇടവേളകളിലോ സ്വയമേവ റൊട്ടേറ്റ് ചെയ്യുന്നു. ഒരൊറ്റ ലോഗ് ഫയൽ അനന്തമായി വളരുന്നത് തടയുകയും പ്രകടനവും കൈകാര്യം ചെയ്യാനുള്ള എളുപ്പവും മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു.
• TimedRotatingFileHandler: RotatingFileHandler-ന് സമാനമാണ്, പക്ഷേ സമയത്തെ അടിസ്ഥാനമാക്കി (ദിവസേന, ആഴ്ചതോറും, മുതലായവ) റൊട്ടേറ്റ് ചെയ്യുന്നു. തീയതി അനുസരിച്ച് ലോഗുകൾ ഓർഗനൈസ് ചെയ്യാൻ ഇത് ഉപയോഗപ്രദമാണ്.
• SocketHandler: ഒരു നെറ്റ്‌വർക്ക് സോക്കറ്റിലൂടെ ലോഗ് സന്ദേശങ്ങൾ അയയ്ക്കുന്നു. റിമോട്ട് ലോഗിംഗ് സാധ്യമാക്കുന്നു, ഒന്നിലധികം ആപ്ലിക്കേഷനുകളിൽ നിന്നുള്ള ലോഗുകൾ കേന്ദ്രീകരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.
• SMTPHandler: ഇമെയിൽ വഴി ലോഗ് സന്ദേശങ്ങൾ അയയ്ക്കുന്നു. ഗുരുതരമായ പിഴവുകളെക്കുറിച്ചോ മുന്നറിയിപ്പുകളെക്കുറിച്ചോ അലേർട്ട് ചെയ്യാൻ ഇത് ഉപയോഗപ്രദമാണ്.

പൈത്തണിൽ ഹാൻഡ്‌ലറുകൾ കോൺഫിഗർ ചെയ്യൽ:

ഹാൻഡ്‌ലറുകൾ കോൺഫിഗർ ചെയ്യാൻ പ്രധാനമായും രണ്ട് വഴികളുണ്ട്:

1. പ്രോഗ്രാമാറ്റിക് കോൺഫിഗറേഷൻ: ഇത് നിങ്ങളുടെ പൈത്തൺ കോഡിൽ നേരിട്ട് ഹാൻഡ്‌ലർ ഇൻസ്റ്റൻസുകൾ സൃഷ്ടിക്കുകയും അവയെ ലോഗറുകളുമായി ബന്ധിപ്പിക്കുകയും ചെയ്യുന്നു. ഈ സമീപനം ഏറ്റവും കൂടുതൽ വഴക്കവും നിയന്ത്രണവും നൽകുന്നു, ആപ്ലിക്കേഷൻ ആവശ്യങ്ങൾക്കനുസരിച്ച് ലോഗിംഗ് രീതികൾ ചലനാത്മകമായി ക്രമീകരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.
2. കോൺഫിഗറേഷൻ ഫയലുകൾ (ഉദാഹരണത്തിന്, YAML, JSON, INI): കോൺഫിഗറേഷൻ ഫയലുകൾ ഉപയോഗിക്കുന്നത് നിങ്ങളുടെ ആപ്ലിക്കേഷൻ കോഡിൽ നിന്ന് ലോഗിംഗ് കോൺഫിഗറേഷൻ വേർതിരിക്കാൻ അനുവദിക്കുന്നു. ഇത് കോഡ് മാറ്റങ്ങൾ വരുത്താതെ ലോഗിംഗ് ക്രമീകരണങ്ങൾ കൈകാര്യം ചെയ്യാനും പരിഷ്കരിക്കാനും എളുപ്പമാക്കുന്നു. വിന്യാസ പരിതസ്ഥിതികൾക്ക് ഇത് പ്രത്യേകിച്ചും സഹായകമാണ്.

പ്രോഗ്രാമാറ്റിക് ഹാൻഡ്‌ലർ ഉദാഹരണം:

കൺസോളിലേക്കും ഒരു ഫയലിലേക്കും ലോഗ് ചെയ്യുന്ന ഒരു ലളിതമായ ഉദാഹരണത്തിലൂടെ പ്രോഗ്രാമാറ്റിക് കോൺഫിഗറേഷൻ എങ്ങനെയെന്ന് നോക്കാം. ഈ ഉദാഹരണം അടിസ്ഥാന ഘടന കാണിക്കുന്നു. നിങ്ങളുടെ പ്രോജക്റ്റിന് ആവശ്യമായ ഫയൽ പാതകളും ലോഗ് ലെവലുകളും ക്രമീകരിക്കാൻ ഓർക്കുക.

            import logging

# Create a logger
logger = logging.getLogger('my_app')
logger.setLevel(logging.DEBUG) # Set the root logger level

# Create a handler to print to the console (stdout)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO) # Set level for this handler

# Create a handler to write to a file
file_handler = logging.FileHandler('my_app.log')
file_handler.setLevel(logging.DEBUG) # Log everything to the file

# Create formatters (explained later)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)

# Add the handlers to the logger
logger.addHandler(console_handler)
logger.addHandler(file_handler)

# Example log messages
logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')

            

              
                Copy
              
            
          

ഉദാഹരണത്തിലെ പ്രധാന പോയിന്റുകൾ:

• നമ്മൾ logging.getLogger() ഉപയോഗിച്ച് ഒരു ലോഗർ ഇൻസ്റ്റൻസ് ഉണ്ടാക്കുന്നു. ആർഗ്യുമെന്റ് സാധാരണയായി മൊഡ്യൂളിന്റെ പേരോ അല്ലെങ്കിൽ ആപ്ലിക്കേഷന്റെ പ്രത്യേക പേരോ ആയിരിക്കും.
• നമ്മൾ റൂട്ട് ലോഗറിന് (ഇവിടെ 'my_app') ലോഗ് ലെവൽ സെറ്റ് ചെയ്യുന്നു. ഇത് ലോഗർ പ്രോസസ്സ് ചെയ്യുന്ന സന്ദേശങ്ങളുടെ ഏറ്റവും കുറഞ്ഞ ഗൗരവം നിർണ്ണയിക്കുന്നു.
• നമ്മൾ രണ്ട് ഹാൻഡ്‌ലറുകൾ ഉണ്ടാക്കുന്നു: ഒന്ന് കൺസോളിനും (StreamHandler), മറ്റൊന്ന് ഫയലിനും (FileHandler).
• നമ്മൾ ഓരോ ഹാൻഡ്‌ലറിനും ലെവൽ സെറ്റ് ചെയ്യുന്നു. ഇത് ഫിൽട്ടർ ചെയ്യാൻ സഹായിക്കുന്നു. ഉദാഹരണത്തിന്, കൺസോൾ ഹാൻഡ്‌ലർ INFO-ഉം അതിനു മുകളിലുള്ള സന്ദേശങ്ങളും മാത്രം കാണിക്കുമ്പോൾ, ഫയൽ ഹാൻഡ്‌ലർ എല്ലാ സന്ദേശങ്ങളും (DEBUG-ഉം അതിനു മുകളിലുള്ളവയും) രേഖപ്പെടുത്തുന്നു.
• നമ്മൾ ഓരോ ഹാൻഡ്‌ലറിലും ഒരു ഫോർമാറ്റർ ചേർക്കുന്നു (ഇതിനെക്കുറിച്ച് താഴെ വിശദീകരിക്കുന്നു).
• നമ്മൾ logger.addHandler() ഉപയോഗിച്ച് ഹാൻഡ്‌ലറുകളെ ലോഗറിലേക്ക് ചേർക്കുന്നു.
• വിവിധ ലെവലുകളിൽ ലോഗ് സന്ദേശങ്ങൾ ഉണ്ടാക്കാൻ നമ്മൾ ലോഗർ ഉപയോഗിക്കുന്നു.

കോൺഫിഗറേഷൻ ഫയൽ ഉദാഹരണം (YAML):

ഒരു കോൺഫിഗറേഷൻ ഫയൽ (ഉദാഹരണത്തിന്, YAML) ഉപയോഗിക്കുന്നത് നിങ്ങളുടെ ലോഗിംഗ് സജ്ജീകരണം ബാഹ്യമായി നിർവചിക്കാൻ അനുവദിക്കുന്നു, ഇത് കോഡ് മാറ്റാതെ തന്നെ ലോഗിംഗ് സ്വഭാവം പരിഷ്കരിക്കുന്നത് എളുപ്പമാക്കുന്നു. logging.config.dictConfig() ഫംഗ്ഷൻ ഉപയോഗിച്ചുള്ള ഒരു ഉദാഹരണം ഇതാ:

            import logging
import logging.config
import yaml

# Load the configuration from a YAML file
with open('logging_config.yaml', 'r') as f:
    config = yaml.safe_load(f)

# Configure logging
logging.config.dictConfig(config)

# Get a logger (the name should match the one defined in the config file)
logger = logging.getLogger('my_app')

# Example log messages
logger.debug('This is a debug message from the config')
logger.info('This is an info message from the config')

            

              
                Copy
              
            
          

ഇവിടെ ഒരു സാമ്പിൾ logging_config.yaml ഫയൽ നൽകുന്നു:

            version: 1
formatters:
  simple:
    format: '%(levelname)s - %(message)s'
  detailed:
    format: '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
handlers:
  console:
    class: logging.StreamHandler
    level: INFO
    formatter: simple
    stream: ext://sys.stdout
  file:
    class: logging.FileHandler
    level: DEBUG
    formatter: detailed
    filename: my_app_config.log
loggers:
  my_app:
    level: DEBUG
    handlers: [console, file]
    propagate: no
root:
  level: WARNING # Defaults, if not set in logger.
            

              
                Copy
              
            
          

YAML കോൺഫിഗറേഷന്റെ വിശദീകരണം:

• version: 1: കോൺഫിഗറേഷൻ ഫയലിന്റെ പതിപ്പ് വ്യക്തമാക്കുന്നു.
• formatters: ലഭ്യമായ ഫോർമാറ്ററുകളെ നിർവചിക്കുന്നു.
• handlers: ഹാൻഡ്‌ലറുകളെ നിർവചിക്കുന്നു. ഓരോ ഹാൻഡ്‌ലറും അതിന്റെ ക്ലാസ്, ലെവൽ, ഫോർമാറ്റർ, ലക്ഷ്യസ്ഥാനം (ഉദാഹരണത്തിന്, കൺസോൾ, ഫയൽ) എന്നിവ വ്യക്തമാക്കുന്നു.
• loggers: ലോഗറുകളെ നിർവചിക്കുന്നു. ഇവിടെ, 'my_app' ലോഗറിനെ 'console', 'file' എന്നീ രണ്ട് ഹാൻഡ്‌ലറുകളും ഉപയോഗിക്കാൻ നമ്മൾ കോൺഫിഗർ ചെയ്യുന്നു. അതിന്റെ ലോഗ് ലെവലും നമ്മൾ സെറ്റ് ചെയ്യുന്നു.
• root: ലോഗറുകളിൽ സെറ്റ് ചെയ്തിട്ടില്ലെങ്കിൽ, ഒരു ഡിഫോൾട്ട് കോൺഫിഗറേഷൻ.

കോൺഫിഗറേഷൻ ഫയലുകളുടെ പ്രധാന ഗുണങ്ങൾ:

• വേർതിരിക്കൽ (Separation of Concerns): നിങ്ങളുടെ പ്രധാന ആപ്ലിക്കേഷൻ ലോജിക്കിൽ നിന്ന് ലോഗിംഗ് കോൺഫിഗറേഷൻ വേറിട്ട് നിർത്തുന്നു.
• എളുപ്പത്തിൽ പരിഷ്കരിക്കാം: ലോഗിംഗ് സ്വഭാവം മാറ്റുന്നതിന് (ഉദാഹരണത്തിന്, ലോഗ് ലെവലുകൾ, ഔട്ട്പുട്ട് ലക്ഷ്യസ്ഥാനങ്ങൾ) കോൺഫിഗറേഷൻ ഫയലിൽ മാത്രം മാറ്റം വരുത്തിയാൽ മതി, കോഡിൽ മാറ്റം വരുത്തേണ്ടതില്ല.
• വിന്യാസത്തിലെ വഴക്കം (Deployment Flexibility): വിവിധ എൻവയോൺമെന്റുകൾക്ക് (ഡെവലപ്‌മെന്റ്, ടെസ്റ്റിംഗ്, പ്രൊഡക്ഷൻ) അനുസരിച്ച് ലോഗിംഗ് എളുപ്പത്തിൽ ക്രമീകരിക്കാൻ അനുവദിക്കുന്നു.

കസ്റ്റം ഫോർമാറ്ററുകൾ: നിങ്ങളുടെ ലോഗ് സന്ദേശങ്ങൾ ഇഷ്ടാനുസൃതമാക്കാം

ഫോർമാറ്ററുകൾ നിങ്ങളുടെ ലോഗ് സന്ദേശങ്ങളുടെ ഘടനയും ഉള്ളടക്കവും നിയന്ത്രിക്കുന്നു. നിങ്ങളുടെ ലോഗുകളിൽ പ്രദർശിപ്പിക്കുന്ന വിവരങ്ങൾ ഇഷ്ടാനുസൃതമാക്കാൻ അവ നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് ആപ്ലിക്കേഷന്റെ പ്രവർത്തനം മനസ്സിലാക്കാനും വിശകലനം ചെയ്യാനും എളുപ്പമാക്കുന്നു. ടൈംസ്റ്റാമ്പ്, ലോഗർ നെയിം, ലോഗ് ലെവൽ, സന്ദേശം തുടങ്ങിയ വിശദാംശങ്ങൾ എങ്ങനെ ഉൾപ്പെടുത്തണം, എങ്ങനെ അവതരിപ്പിക്കണം എന്ന് ഫോർമാറ്ററുകൾ തീരുമാനിക്കുന്നു.

ഫോർമാറ്റർ ഘടകങ്ങൾ മനസ്സിലാക്കൽ:

ലോഗ് റെക്കോർഡുകൾ എങ്ങനെ ഫോർമാറ്റ് ചെയ്യണമെന്ന് നിർവചിക്കുന്ന ഒരു ഫോർമാറ്റ് സ്ട്രിംഗ് ഫോർമാറ്ററുകൾ ഉപയോഗിക്കുന്നു. സാധാരണയായി ഉപയോഗിക്കുന്ന ചില ഫോർമാറ്റ് സ്പെസിഫയറുകൾ താഴെ നൽകുന്നു:

• %(asctime)s: ലോഗ് റെക്കോർഡ് ഉണ്ടാക്കിയ സമയം (ഉദാഹരണം, '2024-01-01 12:00:00,000').
• %(name)s: ലോഗറിന്റെ പേര് (ഉദാഹരണം, 'my_app.module1').
• %(levelname)s: ലോഗ് ലെവൽ (ഉദാഹരണം, 'INFO', 'WARNING', 'ERROR').
• %(message)s: ലോഗ് സന്ദേശം.
• %(filename)s: ലോഗ് സന്ദേശം ഉത്ഭവിച്ച ഫയലിന്റെ പേര്.
• %(lineno)d: ലോഗ് സന്ദേശം ഉത്ഭവിച്ച ലൈൻ നമ്പർ.
• %(funcName)s: ലോഗ് സന്ദേശം ഉത്ഭവിച്ച ഫംഗ്ഷന്റെ പേര്.
• %(pathname)s: സോഴ്സ് ഫയലിന്റെ പൂർണ്ണ പാത്ത്.
• %(threadName)s: ത്രെഡിന്റെ പേര്.
• %(process)d: പ്രോസസ്സ് ഐഡി.

കസ്റ്റം ഫോർമാറ്ററുകൾ ഉണ്ടാക്കൽ:

നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ ആവശ്യങ്ങൾക്ക് അനുസരിച്ചുള്ള പ്രത്യേക വിവരങ്ങൾ ഉൾപ്പെടുത്താൻ നിങ്ങൾക്ക് കസ്റ്റം ഫോർമാറ്ററുകൾ ഉണ്ടാക്കാം. ഇത് `logging.Formatter` ക്ലാസ്സിനെ സബ്ക്ലാസ്സ് ചെയ്തും അതിന്റെ `format()` മെത്തേഡിനെ ഓവർറൈഡ് ചെയ്തും സാധ്യമാക്കാം. `format()` മെത്തേഡിനുള്ളിൽ, നിങ്ങൾക്ക് ലോഗ് റെക്കോർഡിന്റെ ആട്രിബ്യൂട്ടുകൾ ആക്സസ് ചെയ്യാനും ആവശ്യാനുസരണം സന്ദേശം ഫോർമാറ്റ് ചെയ്യാനും കഴിയും.

            import logging

class CustomFormatter(logging.Formatter):
    def format(self, record):
        # Get the original formatted message
        log_fmt = super().format(record)

        # Add custom information
        custom_info = f' - User: {record.user_id if hasattr(record, "user_id") else "Guest"}' # Example customization
        return log_fmt + custom_info

# Example Usage (Illustrative:  Requires setting up a handler and attaching the custom formatter)
if __name__ == '__main__':
    logger = logging.getLogger('custom_logger')
    logger.setLevel(logging.INFO)

    # Create a console handler
    ch = logging.StreamHandler()
    ch.setLevel(logging.INFO)

    # Set the custom formatter on the handler
    formatter = CustomFormatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    ch.setFormatter(formatter)

    # Add the handler to the logger
    logger.addHandler(ch)

    # Create a log record with custom attribute (simulated for demonstration)
    class LogRecordWithUser(logging.LogRecord):
        def __init__(self, name, level, pathname, lineno, msg, args, exc_info, func, sinfo, user_id=None):
            super().__init__(name, level, pathname, lineno, msg, args, exc_info, func, sinfo)
            self.user_id = user_id
    
    #Example message with a user id
    record = LogRecordWithUser('custom_logger', logging.INFO, 'example.py', 10, 'User logged in', (), None, 'main', None, user_id='12345')
    logger.handle(record)

    # Example message without a user id
    logger.info('Guest user accessed the page.')

            

              
                Copy
              
            
          

കസ്റ്റം ഫോർമാറ്റർ ഉദാഹരണത്തിന്റെ വിശദീകരണം:

• നമ്മൾ `logging.Formatter` ൽ നിന്ന് പാരമ്പര്യമായി `CustomFormatter` എന്ന ഒരു ക്ലാസ്സ് ഉണ്ടാക്കുന്നു.
• `format()` മെത്തേഡ് ഓവർറൈഡ് ചെയ്യുന്നു. ഇവിടെയാണ് കസ്റ്റം ഫോർമാറ്റിംഗ് ലോജിക് ഉള്ളത്.
• നമ്മൾ ആദ്യം super().format(record) ഉപയോഗിച്ച് സാധാരണ ഫോർമാറ്റ് ചെയ്ത സന്ദേശം എടുക്കുന്നു.
• നമ്മൾ കസ്റ്റം വിവരങ്ങൾ ചേർക്കുന്നു. ഈ ഉദാഹരണത്തിൽ, ലോഗ് റെക്കോർഡിന്റെ ഒരു ആട്രിബ്യൂട്ടായി ഉപയോക്തൃ വിവരങ്ങൾ (യൂസർ ഐഡി) ഉണ്ടെങ്കിൽ അത് ഉൾപ്പെടുത്തുന്നു. ഇല്ലെങ്കിൽ (ഒരു ഗസ്റ്റ് യൂസറെ പോലെ), അത് "Guest" എന്ന് കാണിക്കുന്നു. `hasattr()` ചെക്കും യൂസർ ഐഡി ആട്രിബ്യൂട്ട് ഉൾപ്പെടുത്തുന്ന രീതിയും, ആട്രിബ്യൂട്ട് നിർവചിക്കാത്ത സാഹചര്യങ്ങളിൽ പിഴവുകൾ ഒഴിവാക്കാൻ എങ്ങനെ സഹായിക്കുന്നു എന്ന് ശ്രദ്ധിക്കുക.
• നിലവിൽ ലോഗിൻ ചെയ്തിരിക്കുന്ന ഉപയോക്താവിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ ഉൾപ്പെടുത്താൻ ഒരു ലോഗ് സന്ദേശം എങ്ങനെ കൈകാര്യം ചെയ്യാമെന്ന് ഈ ഉദാഹരണം കാണിക്കുന്നു.

വിവിധ ഉപയോഗങ്ങൾക്കുള്ള ലോഗ് സന്ദേശങ്ങൾ ഫോർമാറ്റ് ചെയ്യൽ:

നിങ്ങളുടെ ആവശ്യങ്ങൾക്ക് ഏറ്റവും അനുയോജ്യമായ ഫോർമാറ്റിംഗ് തിരഞ്ഞെടുക്കാൻ സഹായിക്കുന്ന വിവിധ ഫോർമാറ്റർ ശൈലികളുടെ ചില ഉദാഹരണങ്ങൾ ഇതാ.

1. അടിസ്ഥാന ഫോർമാറ്റിംഗ് (ഡെവലപ്‌മെന്റിനായി):

               '%(asctime)s - %(levelname)s - %(message)s'
               
   
                 
                   Copy
                 
               
             

   ഈ ഫോർമാറ്റ് ലളിതമായ ഒരു ടൈംസ്റ്റാമ്പ്, ലോഗ് ലെവൽ, സന്ദേശം എന്നിവ നൽകുന്നു. വേഗത്തിലുള്ള ഡീബഗ്ഗിംഗിന് ഇത് നല്ലതാണ്.
2. വിശദമായ ഫോർമാറ്റിംഗ് (പ്രൊഡക്ഷനായി, ഫയൽ/ലൈൻ നമ്പറോടുകൂടി):

               '%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s'
               
   
                 
                   Copy
                 
               
             

   ഈ ഫോർമാറ്റിൽ ലോഗറിന്റെ പേര്, ഫയൽ നെയിം, ലൈൻ നമ്പർ, ലോഗ് സന്ദേശം എന്നിവ ഉൾപ്പെടുന്നു, ഇത് ലോഗുകളുടെ ഉറവിടം കണ്ടെത്തുന്നത് എളുപ്പമാക്കുന്നു.
3. JSON ഫോർമാറ്റിംഗ് (മെഷീൻ പാഴ്സിംഗിനായി):

   ഓട്ടോമേറ്റഡ് ലോഗ് വിശകലനത്തിനായി (ഉദാഹരണത്തിന്, ഒരു ലോഗ് അഗ്രഗേഷൻ സിസ്റ്റം ഉപയോഗിച്ച്), JSON ഫോർമാറ്റിംഗ് വളരെ ഫലപ്രദമാണ്. ഇത് ഘടനാപരമായ ഡാറ്റ നൽകുന്നു, ഇത് പാഴ്സിംഗും വിശകലനവും എളുപ്പമാക്കുന്നു. നിങ്ങൾ ഒരു കസ്റ്റം ഫോർമാറ്റർ ക്ലാസ്സ് ഉണ്ടാക്കുകയും ലോഗ് റെക്കോർഡ് JSON ആയി എൻകോഡ് ചെയ്യാൻ `json.dumps()` ഉപയോഗിക്കുകയും വേണം.

               import json
   import logging
   
   class JsonFormatter(logging.Formatter):
       def format(self, record):
           log_record = {
               'timestamp': self.formatTime(record, self.datefmt),
               'name': record.name,
               'levelname': record.levelname,
               'message': record.getMessage(),
               'filename': record.filename,
               'lineno': record.lineno,
               'funcName': record.funcName
           }
           return json.dumps(log_record)
   
               
   
                 
                   Copy
                 
               
             

   ഈ ഫോർമാറ്റർ പ്രസക്തമായ ലോഗ് ഡാറ്റ അടങ്ങുന്ന ഒരു JSON ഘടന ഉണ്ടാക്കുന്നു. ഫയൽ, ലൈൻ നമ്പർ, ഫംഗ്ഷൻ നെയിം എന്നിവ സോഴ്സ് കോഡിൽ എളുപ്പത്തിൽ പിന്നോട്ട് കണ്ടെത്താൻ അനുവദിക്കുന്നു. ഈ ഫോർമാറ്റ് ചെയ്ത ഔട്ട്പുട്ട് പിന്നീട് ലോഗ് വിശകലന ഉപകരണങ്ങൾ എളുപ്പത്തിൽ പാഴ്സ് ചെയ്യുന്നു.

4. പ്രത്യേക ആപ്ലിക്കേഷനുകൾക്കുള്ള ഫോർമാറ്റിംഗ്:

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

പൈത്തൺ ലോഗിംഗിനുള്ള മികച്ച രീതികൾ

മികച്ച രീതികൾ പിന്തുടരുന്നത് നിങ്ങളുടെ ലോഗിംഗ് ഫലപ്രദവും, പരിപാലിക്കാൻ കഴിയുന്നതും, വിലപ്പെട്ടതുമാണെന്ന് ഉറപ്പാക്കുന്നു. ചില പ്രധാന ശുപാർശകൾ ഇതാ:

• ലോഗ് ലെവൽ സൂക്ഷ്മത: ഉചിതമായ ലോഗ് ലെവലുകൾ സ്ഥിരമായി ഉപയോഗിക്കുക.
  • DEBUG: വിശദമായ വിവരങ്ങൾ, സാധാരണയായി ഡീബഗ്ഗിംഗിനായി.
  • INFO: ആപ്ലിക്കേഷൻ പ്രവർത്തനത്തെക്കുറിച്ചുള്ള പൊതുവായ വിവരങ്ങൾ.
  • WARNING: സാധ്യതയുള്ള പ്രശ്നങ്ങൾ അല്ലെങ്കിൽ അപ്രതീക്ഷിത സംഭവങ്ങൾ.
  • ERROR: ഏതെങ്കിലും ഫംഗ്ഷനോ പ്രവർത്തനത്തിനോ തടസ്സമാകുന്ന പിഴവുകൾ.
  • CRITICAL: ആപ്ലിക്കേഷൻ ക്രാഷാകാനോ അസ്ഥിരമാകാനോ കാരണമായേക്കാവുന്ന ഗുരുതരമായ പിഴവുകൾ.

  ലോഗ് ചെയ്ത സംഭവത്തിന്റെ ഗൗരവം കൃത്യമായി പ്രതിഫലിപ്പിക്കുന്ന ലെവൽ തിരഞ്ഞെടുക്കുക.

• സന്ദർഭോചിതമായ വിവരങ്ങൾ: നിങ്ങളുടെ ലോഗ് സന്ദേശങ്ങളിൽ പ്രസക്തമായ സന്ദർഭം ഉൾപ്പെടുത്തുക. യൂസർ ഐഡികൾ, അഭ്യർത്ഥന ഐഡികൾ, ഇടപാട് ഐഡികൾ അല്ലെങ്കിൽ ഒരു പ്രശ്നം അതിന്റെ ഉറവിടത്തിലേക്ക് കണ്ടെത്താൻ സഹായിക്കുന്ന മറ്റേതെങ്കിലും വിവരങ്ങൾ ഉൾപ്പെടുത്തുക.
• പിഴവ് കൈകാര്യം ചെയ്യൽ (Error Handling): എപ്പോഴും logger.exception() ഉപയോഗിച്ചോ അല്ലെങ്കിൽ ലോഗ് സന്ദേശത്തിൽ ഒഴിവാക്കൽ വിവരങ്ങൾ ഉൾപ്പെടുത്തിയോ എക്സെപ്ഷനുകൾ ലോഗ് ചെയ്യുക. ഇത് സ്റ്റാക്ക് ട്രെയ്സുകൾ നൽകുന്നു, ഇത് ഡീബഗ്ഗിംഗിന് അമൂല്യമാണ്.
• കേന്ദ്രീകൃത ലോഗിംഗ് (വിതരണം ചെയ്ത സിസ്റ്റങ്ങൾക്കായി): ഒരു കേന്ദ്രീകൃത ലോഗിംഗ് സിസ്റ്റം (ഉദാഹരണത്തിന്, Elasticsearch, Fluentd, Splunk, അല്ലെങ്കിൽ ELK സ്റ്റാക്ക് -- Elasticsearch, Logstash, and Kibana) ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക. ഇത് ഒന്നിലധികം ആപ്ലിക്കേഷനുകളിൽ നിന്നും സെർവറുകളിൽ നിന്നും ലോഗുകൾ ശേഖരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് നിങ്ങളുടെ സിസ്റ്റങ്ങൾ തിരയാനും, വിശകലനം ചെയ്യാനും, നിരീക്ഷിക്കാനും എളുപ്പമാക്കുന്നു. ക്ലൗഡ് കമ്പ്യൂട്ടിംഗിന്റെ ലോകത്ത്, AWS CloudWatch, Azure Monitor, Google Cloud Logging പോലുള്ള വിവിധ സേവനങ്ങൾ നിയന്ത്രിത ലോഗിംഗ് വാഗ്ദാനം ചെയ്യുന്നു.
• റൊട്ടേഷനും നിലനിർത്തലും (Rotation and Retention): ലോഗ് ഫയലുകൾ വളരെ വലുതാകുന്നത് തടയാൻ ലോഗ് റൊട്ടേഷൻ (`RotatingFileHandler` അല്ലെങ്കിൽ `TimedRotatingFileHandler` ഉപയോഗിച്ച്) നടപ്പിലാക്കുക. ഒരു നിശ്ചിത കാലയളവിനുശേഷം ലോഗുകൾ സ്വയമേവ ഇല്ലാതാക്കാനോ ആർക്കൈവ് ചെയ്യാനോ ഒരു നിലനിർത്തൽ നയം സ്ഥാപിക്കുക. ഇത് നിയമങ്ങൾ പാലിക്കുന്നതിനും, സുരക്ഷയ്ക്കും, സ്റ്റോറേജ് മാനേജ്‌മെന്റിനും പ്രധാനമാണ്.
• സെൻസിറ്റീവ് വിവരങ്ങൾ ഒഴിവാക്കുക: പാസ്‌വേഡുകൾ, API കീകൾ, അല്ലെങ്കിൽ വ്യക്തിഗത ഡാറ്റ പോലുള്ള സെൻസിറ്റീവ് വിവരങ്ങൾ ഒരിക്കലും ലോഗ് ചെയ്യരുത്. GDPR അല്ലെങ്കിൽ CCPA പോലുള്ള സ്വകാര്യതാ നിയമങ്ങൾ പാലിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക. ആപ്ലിക്കേഷൻ സെൻസിറ്റീവ് ഡാറ്റ കൈകാര്യം ചെയ്യുന്നുണ്ടെങ്കിൽ ശ്രദ്ധാപൂർവ്വം ഫിൽട്ടറിംഗ് നടപ്പിലാക്കുക.
• കോൺഫിഗറേഷൻ-ഡ്രിവൻ ലോഗിംഗ്: നിങ്ങളുടെ ലോഗിംഗ് ക്രമീകരണങ്ങൾ നിയന്ത്രിക്കാൻ കോൺഫിഗറേഷൻ ഫയലുകൾ (YAML, JSON, അല്ലെങ്കിൽ INI) ഉപയോഗിക്കുക. ഇത് നിങ്ങളുടെ കോഡ് പരിഷ്കരിക്കാതെ തന്നെ ലോഗ് ലെവലുകൾ, ഹാൻഡ്‌ലറുകൾ, ഫോർമാറ്ററുകൾ എന്നിവ മാറ്റുന്നത് എളുപ്പമാക്കുന്നു, ഇത് വിവിധ എൻവയോൺമെന്റുകൾക്കായി ലോഗിംഗ് ഇഷ്ടാനുസൃതമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.
• പ്രകടന പരിഗണനകൾ: അമിതമായ ലോഗിംഗ് ഒഴിവാക്കുക, പ്രത്യേകിച്ച് നിങ്ങളുടെ കോഡിന്റെ പ്രകടനത്തിന് നിർണ്ണായകമായ ഭാഗങ്ങളിൽ. ലോഗിംഗ് ഓവർഹെഡ് ഉണ്ടാക്കാം, അതിനാൽ ആപ്ലിക്കേഷൻ പ്രകടനത്തിലുള്ള അതിന്റെ സ്വാധീനത്തെക്കുറിച്ച് ശ്രദ്ധാലുവായിരിക്കുക. ഉചിതമായ ലോഗ് ലെവലുകൾ ഉപയോഗിക്കുകയും ആവശ്യമുള്ളപ്പോൾ സന്ദേശങ്ങൾ ഫിൽട്ടർ ചെയ്യുകയും ചെയ്യുക.
• ലോഗിംഗ് ടെസ്റ്റിംഗ്: നിങ്ങളുടെ ലോഗിംഗ് കോൺഫിഗറേഷനും ലോഗ് സന്ദേശങ്ങളും ശരിയായി ജനറേറ്റ് ചെയ്യുന്നുണ്ടോയെന്ന് പരിശോധിക്കാൻ യൂണിറ്റ് ടെസ്റ്റുകൾ എഴുതുക. ശരിയായ പ്രവർത്തനം ഉറപ്പാക്കാൻ വിവിധ ലോഗ് ലെവലുകളും സാഹചര്യങ്ങളും പരീക്ഷിക്കുന്നത് പരിഗണിക്കുക.
• ഡോക്യുമെന്റേഷൻ: ലോഗ് ലെവലുകൾ, ഹാൻഡ്‌ലറുകൾ, ഫോർമാറ്ററുകൾ എന്നിവയുൾപ്പെടെ നിങ്ങളുടെ ലോഗിംഗ് കോൺഫിഗറേഷൻ ഡോക്യുമെന്റ് ചെയ്യുക. ഇത് മറ്റ് ഡെവലപ്പർമാർക്ക് നിങ്ങളുടെ ലോഗിംഗ് സജ്ജീകരണം മനസ്സിലാക്കാൻ സഹായിക്കുകയും നിങ്ങളുടെ കോഡ് പരിപാലിക്കാനും ട്രബിൾഷൂട്ട് ചെയ്യാനും എളുപ്പമാക്കുകയും ചെയ്യുന്നു.
• യൂസർ ഐഡിയും അഭ്യർത്ഥന ഐഡിയും തമ്മിലുള്ള ബന്ധം: വെബ് ആപ്ലിക്കേഷനുകൾക്കോ അല്ലെങ്കിൽ ഒന്നിലധികം അഭ്യർത്ഥനകൾ കൈകാര്യം ചെയ്യുന്ന ഏതൊരു സേവനത്തിനോ, ഒരു തനതായ അഭ്യർത്ഥന ഐഡി ഉണ്ടാക്കുകയും ഒരു പ്രത്യേക അഭ്യർത്ഥനയുമായി ബന്ധപ്പെട്ട എല്ലാ ലോഗ് സന്ദേശങ്ങളിലും അത് ഉൾപ്പെടുത്തുകയും ചെയ്യുക. അതുപോലെ, ഉചിതമായ സമയത്ത് ഒരു യൂസർ ഐഡിയും ഉൾപ്പെടുത്തുക. ഇത് ഒന്നിലധികം സേവനങ്ങളിലുടനീളം അഭ്യർത്ഥനകൾ കണ്ടെത്താനും നിർദ്ദിഷ്ട ഉപയോക്താക്കളുമായി ബന്ധപ്പെട്ട പ്രശ്നങ്ങൾ ഡീബഗ്ഗ് ചെയ്യാനും സഹായിക്കുന്നു.

പ്രായോഗിക ഉദാഹരണങ്ങളും ഉപയോഗ സാഹചര്യങ്ങളും

ഫലപ്രദമായ ലോഗിംഗ് നിർണ്ണായകമായ ചില യഥാർത്ഥ സാഹചര്യങ്ങൾ നമുക്ക് നോക്കാം:

1. വെബ് ആപ്ലിക്കേഷൻ നിരീക്ഷണം:

ഒരു വെബ് ആപ്ലിക്കേഷനിൽ, ഉപയോക്തൃ അഭ്യർത്ഥനകൾ നിരീക്ഷിക്കാനും, പിഴവുകൾ കണ്ടെത്താനും, പ്രകടനത്തിലെ തടസ്സങ്ങൾ തിരിച്ചറിയാനും നിങ്ങൾക്ക് ലോഗിംഗ് ഉപയോഗിക്കാം.

            import logging
from flask import Flask, request

app = Flask(__name__)

# Configure logging (using a config file, or a programmatic example here)
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

@app.route('/')
def index():
    # Generate a request ID (for example)
    request_id = request.headers.get('X-Request-Id')
    if not request_id:
        request_id = 'unknown'
    
    logger.info(f'Request received, Request ID: {request_id}')
    try:
        # Simulate an error condition
        if request.args.get('error'):
            raise ValueError('Simulated error')
        return 'Hello, World!'
    except Exception as e:
        logger.error(f'Error processing request {request_id}: {str(e)}')
        return 'Internal Server Error', 500

if __name__ == '__main__':
    app.run(debug=True)  # Be very careful using debug=True in production.
            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, നമ്മൾ:

• ഓരോ അഭ്യർത്ഥനയും കണ്ടെത്താൻ ഒരു അഭ്യർത്ഥന ഐഡി ഉണ്ടാക്കുന്നു (അല്ലെങ്കിൽ സ്വീകരിക്കുന്നു).
• അഭ്യർത്ഥന ഐഡിയോടുകൂടി അഭ്യർത്ഥന ലോഗ് ചെയ്യുന്നു.
• എക്സെപ്ഷനും അഭ്യർത്ഥന ഐഡിയും ഉൾപ്പെടെ ഏതെങ്കിലും പിഴവുകൾ ലോഗ് ചെയ്യുന്നു.

2. പശ്ചാത്തല ജോലികൾ / ഷെഡ്യൂൾഡ് ജോലികൾ:

ഷെഡ്യൂൾഡ് ജോലികൾ അല്ലെങ്കിൽ ഡാറ്റ പ്രോസസ്സിംഗ് പൈപ്പ്ലൈനുകൾ പോലുള്ള പശ്ചാത്തല ജോലികൾ നിരീക്ഷിക്കുന്നതിന് ലോഗിംഗ് നിർണ്ണായകമാണ്.

            import logging
import time
from datetime import datetime

# Configure logging (again, using config file is generally better)
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def my_scheduled_task():
    start_time = datetime.now()
    logger.info(f'Starting scheduled task at {start_time}')
    try:
        # Simulate some work
        time.sleep(2)  # Simulate work
        # Simulate a potential error
        if datetime.now().minute % 5 == 0:
            raise ValueError('Simulated error in task')
        logger.info('Task completed successfully')
    except Exception as e:
        logger.error(f'Task failed: {str(e)}')
    finally:
      end_time = datetime.now()
      logger.info(f'Task finished at {end_time}.  Duration: {end_time - start_time}')

if __name__ == '__main__':
    my_scheduled_task()
            

              
                Copy
              
            
          

ഒരു ടാസ്ക് എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് മുമ്പും, സമയത്തും, ശേഷവും ലോഗിംഗ് ചെയ്യുന്നത് ഇത് കാണിക്കുന്നു, വിജയവും പരാജയവും കാണിക്കുന്നു. ഇത് ഷെഡ്യൂളിംഗ് പ്രശ്നങ്ങൾ എളുപ്പത്തിൽ കണ്ടെത്താൻ സഹായിക്കും.

3. ഡാറ്റ പ്രോസസ്സിംഗ് പൈപ്പ്ലൈൻ:

ഒരു ഡാറ്റ പ്രോസസ്സിംഗ് പൈപ്പ്ലൈനിൽ, ഡാറ്റാ പരിവർത്തനങ്ങൾ ട്രാക്ക് ചെയ്യാനും, പിഴവുകൾ കണ്ടെത്താനും, പൈപ്പ്ലൈനിന്റെ മൊത്തത്തിലുള്ള ആരോഗ്യം നിരീക്ഷിക്കാനും ലോഗിംഗ് നിങ്ങളെ സഹായിക്കുന്നു.

            import logging
import pandas as pd

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def load_data(file_path):
    try:
        df = pd.read_csv(file_path) # Replace with your file type
        logger.info(f'Data loaded from {file_path}, shape: {df.shape}')
        return df
    except FileNotFoundError:
        logger.error(f'File not found: {file_path}')
        return None
    except Exception as e:
        logger.error(f'Error loading data: {str(e)}')
        return None

def transform_data(df):
    if df is None:
        return None
    try:
        # Apply some transformation
        df['processed_column'] = df['some_column'] * 2  # Example
        logger.info('Data transformation completed.')
        return df
    except Exception as e:
        logger.error(f'Error transforming data: {str(e)}')
        return None

def save_data(df, output_file):
    if df is None:
        return
    try:
        df.to_csv(output_file, index=False)  # Modify for different output format
        logger.info(f'Data saved to {output_file}')
    except Exception as e:
        logger.error(f'Error saving data: {str(e)}')

# Example Usage (replace with your actual file paths and data)
if __name__ == '__main__':
    input_file = 'input.csv'
    output_file = 'output.csv'

    data = load_data(input_file)
    transformed_data = transform_data(data)
    save_data(transformed_data, output_file)
            

              
                Copy
              
            
          

ഈ പൈപ്പ്ലൈൻ ഉദാഹരണം ഡാറ്റ ലോഡിംഗ്, ട്രാൻസ്ഫോർമേഷൻ, സേവിംഗ് എന്നിവ ലോഗ് ചെയ്യുന്നു. ലോഗിംഗ് സ്റ്റേറ്റ്മെന്റുകൾ പ്രോസസ്സ് നിരീക്ഷിക്കാനും എന്തെങ്കിലും തെറ്റ് സംഭവിച്ചാൽ പ്രശ്നങ്ങൾ എളുപ്പത്തിൽ കണ്ടെത്താനും നിങ്ങളെ അനുവദിക്കുന്നു.

അഡ്വാൻസ്ഡ് ലോഗിംഗ് ടെക്നിക്കുകൾ

അടിസ്ഥാന കാര്യങ്ങൾക്കപ്പുറം, നിങ്ങളുടെ ലോഗിംഗ് കഴിവുകൾ വർദ്ധിപ്പിക്കുന്നതിന് ഈ അഡ്വാൻസ്ഡ് ടെക്നിക്കുകൾ പരിഗണിക്കുക:

• ലോഗിംഗ് ContextVars: `contextvars` മൊഡ്യൂൾ (പൈത്തൺ 3.7+ ൽ ലഭ്യമാണ്) സന്ദർഭത്തിനനുസരിച്ചുള്ള ഡാറ്റ (ഉദാഹരണത്തിന്, അഭ്യർത്ഥന ഐഡികൾ, യൂസർ ഐഡികൾ) സംഭരിക്കാനും നിങ്ങളുടെ ലോഗ് സന്ദേശങ്ങളിൽ അത് സ്വയമേവ ഉൾപ്പെടുത്താനും നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് എല്ലാ ലോഗിംഗ് കോളിലേക്കും സന്ദർഭോചിതമായ വിവരങ്ങൾ നേരിട്ട് പാസ് ചെയ്യാതെ തന്നെ ലോഗുകളിൽ ചേർക്കുന്നത് ലളിതമാക്കുന്നു. ഇത് ബോയിലർപ്ലേറ്റ് കുറയ്ക്കുകയും കോഡിന്റെ പരിപാലനം എളുപ്പമാക്കുകയും ചെയ്യുന്നു.
• ലോഗിംഗ് ഫിൽട്ടറുകൾ: ഏതൊക്കെ ലോഗ് സന്ദേശങ്ങളാണ് ഹാൻഡ്‌ലറുകൾ പ്രോസസ്സ് ചെയ്യേണ്ടതെന്ന് കൂടുതൽ കൃത്യമായി നിർവചിക്കാൻ ഫിൽട്ടറുകൾ ഉപയോഗിക്കുക. ഉദാഹരണത്തിന്, ഉത്ഭവിക്കുന്ന മൊഡ്യൂളിനെയോ അല്ലെങ്കിൽ ഒരു പ്രത്യേക വേരിയബിളിന്റെ മൂല്യത്തെയോ അടിസ്ഥാനമാക്കി ലോഗ് സന്ദേശങ്ങൾ ഉപാധികളോടെ ലോഗ് ചെയ്യാൻ ഫിൽട്ടറുകൾ ഉപയോഗിക്കാം.
• ലോഗിംഗ് ലൈബ്രറികളുടെ സംയോജനം: നിങ്ങളുടെ പ്രോജക്റ്റിൽ ഉപയോഗിക്കുന്ന മറ്റ് ലൈബ്രറികളുമായും ഫ്രെയിംവർക്കുകളുമായും നിങ്ങളുടെ ലോഗിംഗ് സംയോജിപ്പിക്കുക. ഉദാഹരണത്തിന്, നിങ്ങൾ ഫ്ലാസ്ക് അല്ലെങ്കിൽ ജാംഗോ പോലുള്ള ഒരു വെബ് ഫ്രെയിംവർക്ക് ഉപയോഗിക്കുകയാണെങ്കിൽ, HTTP അഭ്യർത്ഥനകളെയും പ്രതികരണങ്ങളെയും കുറിച്ചുള്ള വിവരങ്ങൾ സ്വയമേവ ലോഗ് ചെയ്യാൻ നിങ്ങൾക്ക് ലോഗിംഗ് കോൺഫിഗർ ചെയ്യാം.
• ലോഗ് അഗ്രഗേഷനും വിശകലനവും (ELK സ്റ്റാക്ക്, മുതലായവ): ഒരു ലോഗ് അഗ്രഗേഷൻ സിസ്റ്റം നടപ്പിലാക്കുക. ELK സ്റ്റാക്ക് (Elasticsearch, Logstash, Kibana) അല്ലെങ്കിൽ മറ്റ് ക്ലൗഡ് അധിഷ്ഠിത പരിഹാരങ്ങൾ ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക. ഈ സിസ്റ്റങ്ങൾ വിവിധ ഉറവിടങ്ങളിൽ നിന്നുള്ള ലോഗുകൾ ശേഖരിക്കാനും, കേന്ദ്രീകരിക്കാനും, വിശകലനം ചെയ്യാനും നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് ശക്തമായ തിരയൽ, ഫിൽട്ടറിംഗ്, ദൃശ്യവൽക്കരണ കഴിവുകൾ നൽകുന്നു. ഇത് ട്രെൻഡുകൾ തിരിച്ചറിയാനും, അപാകതകൾ കണ്ടെത്താനും, പ്രശ്നങ്ങൾ പരിഹരിക്കാനുമുള്ള നിങ്ങളുടെ കഴിവ് വർദ്ധിപ്പിക്കുന്നു.
• ട്രെയ്‌സിംഗും ഡിസ്ട്രിബ്യൂട്ടഡ് ട്രെയ്‌സിംഗും: മൈക്രോസർവീസുകൾക്കോ വിതരണം ചെയ്ത ആപ്ലിക്കേഷനുകൾക്കോ, ഒന്നിലധികം സേവനങ്ങളിലൂടെ കടന്നുപോകുമ്പോൾ അഭ്യർത്ഥനകൾ ട്രാക്ക് ചെയ്യാൻ ട്രെയ്‌സിംഗ് നടപ്പിലാക്കുക. Jaeger, Zipkin, OpenTelemetry പോലുള്ള ലൈബ്രറികൾ ട്രെയ്‌സിംഗിൽ സഹായിക്കുന്നു. ഇത് വിവിധ സേവനങ്ങളിലുടനീളം ലോഗ് സന്ദേശങ്ങൾ ബന്ധിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ എൻഡ്-ടു-എൻഡ് സ്വഭാവത്തെക്കുറിച്ചുള്ള ഉൾക്കാഴ്ചകൾ നൽകുകയും സങ്കീർണ്ണമായ വിതരണം ചെയ്ത സിസ്റ്റങ്ങളിലെ പ്രകടന തടസ്സങ്ങൾ തിരിച്ചറിയുകയും ചെയ്യുന്നു.

ഉപസംഹാരം: വിജയത്തിനായുള്ള ലോഗിംഗ്

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

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

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