چارچوب لاگینگ پایتون: پیکربندی Handler در مقابل Formatter های سفارشی

چارچوب لاگینگ پایتون ابزاری قدرتمند برای مدیریت و نظارت بر رفتار برنامه است. لاگینگ مؤثر برای دیباگ کردن، عیب‌یابی و به دست آوردن بینش در مورد عملکرد نرم‌افزار شما بسیار حیاتی است. این راهنمای جامع به دو جنبه کلیدی چارچوب لاگینگ پایتون می‌پردازد: پیکربندی Handler و Formatter های سفارشی. ما عملکردها، بهترین شیوه‌ها و مثال‌های عملی آن‌ها را بررسی خواهیم کرد تا به شما کمک کنیم لاگینگ قوی و کارآمد را در پروژه‌های پایتون خود پیاده‌سازی کنید، صرف نظر از موقعیت مکانی شما در سراسر جهان.

درک اصول بنیادی لاگینگ پایتون

قبل از پرداختن به هندلرها و فرمترها، بیایید درک کاملی از اجزای اصلی چارچوب لاگینگ پایتون به دست آوریم:

• Loggers: لاگرها رابط اصلی برنامه شما برای نوشتن پیام‌های لاگ هستند. آن‌ها سلسله‌مراتبی هستند، به این معنی که یک لاگر می‌تواند لاگرهای فرزند داشته باشد و پیکربندی را از والدین خود به ارث ببرد. آن‌ها را به عنوان دروازه‌بان‌های پیام‌های لاگ خود در نظر بگیرید.
• Log Levels: سطوح لاگ (DEBUG, INFO, WARNING, ERROR, CRITICAL) شدت پیام‌های لاگ را دسته‌بندی می‌کنند. شما از این سطوح برای فیلتر کردن اینکه کدام پیام‌ها پردازش شوند استفاده می‌کنید. به عنوان مثال، در یک محیط پروداکشن، ممکن است فقط پیام‌های WARNING، ERROR و CRITICAL را برای کاهش پرحرفی لاگ کنید.
• Handlers: هندلرها تعیین می‌کنند که پیام‌های لاگ به کجا ارسال شوند. این مکان می‌تواند کنسول (stdout)، یک فایل، یک سوکت شبکه یا حتی یک پایگاه داده باشد. هندلرها قابل پیکربندی برای فیلتر کردن بر اساس سطح لاگ و اعمال فرمترها هستند.
• Formatters: فرمترها ساختار و محتوای پیام‌های لاگ شما را تعریف می‌کنند. آن‌ها کنترل می‌کنند که چه اطلاعاتی (مهر زمانی، نام لاگر، سطح لاگ، محتوای پیام و غیره) شامل شود و چگونه ارائه شود. فرمترها توسط هندلر قبل از نوشته شدن پیام لاگ اعمال می‌شوند.

این اجزا با هم کار می‌کنند تا یک سیستم لاگینگ انعطاف‌پذیر و قابل پیکربندی را فراهم کنند. یک پیام لاگ از لاگر سرچشمه می‌گیرد، از طریق یک هندلر عبور می‌کند و با استفاده از یک فرمتر قالب‌بندی می‌شود قبل از اینکه به مقصد خود ارسال شود. این ساختار امکان کنترل دقیق بر نحوه تولید، پردازش و ذخیره لاگ‌ها را فراهم می‌کند.

پیکربندی Handler: مسیریابی مؤثر لاگ‌های شما

هندلرها اسب‌های کاری چارچوب لاگینگ هستند و مسئول هدایت پیام‌های لاگ شما به مقصد نهایی‌شان می‌باشند. پیکربندی صحیح هندلر برای لاگینگ مؤثر حیاتی است. در اینجا به بررسی ملاحظات کلیدی می‌پردازیم:

انواع رایج Handler:

• StreamHandler: پیام‌های لاگ را به یک استریم، معمولاً stdout یا stderr، ارسال می‌کند. برای لاگینگ کنسول در حین توسعه ایده‌آل است.
• FileHandler: پیام‌های لاگ را در یک فایل می‌نویسد. برای لاگینگ پایدار رویدادهای برنامه، به ویژه در پروداکشن، ضروری است. این امر برای دیباگ کردن مشکلاتی که پس از استقرار به وجود می‌آیند، حیاتی است.
• RotatingFileHandler: زیرکلاسی از FileHandler است که به طور خودکار فایل‌های لاگ را هنگامی که به اندازه معینی می‌رسند یا در فواصل زمانی مشخص، می‌چرخاند. از رشد بی‌نهایت فایل‌های لاگ جلوگیری کرده و عملکرد و قابلیت مدیریت را بهبود می‌بخشد.
• TimedRotatingFileHandler: شبیه به RotatingFileHandler است اما بر اساس زمان (روزانه، هفتگی و غیره) می‌چرخاند. برای سازماندهی لاگ‌ها بر اساس تاریخ مفید است.
• SocketHandler: پیام‌های لاگ را از طریق یک سوکت شبکه ارسال می‌کند. لاگینگ از راه دور را فعال می‌کند و به شما امکان می‌دهد لاگ‌ها را از چندین برنامه متمرکز کنید.
• SMTPHandler: پیام‌های لاگ را از طریق ایمیل ارسال می‌کند. برای هشدار در مورد خطاهای حیاتی یا هشدارها مفید است.

پیکربندی هندلرها در پایتون:

دو روش اصلی برای پیکربندی هندلرها وجود دارد:

1. پیکربندی برنامه‌نویسی شده (Programmatic): این شامل ایجاد نمونه‌های هندلر به طور مستقیم در کد پایتون شما و پیوست کردن آن‌ها به لاگرها است. این رویکرد بیشترین انعطاف‌پذیری و کنترل را فراهم می‌کند و به شما امکان می‌دهد رفتار لاگینگ را به صورت پویا بر اساس نیازهای برنامه تنظیم کنید.
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): پیکربندی لاگینگ شما را از منطق اصلی برنامه جدا نگه می‌دارد.
• تغییر آسان: تغییر رفتار لاگینگ (مانند سطوح لاگ، مقاصد خروجی) فقط نیاز به تغییر فایل پیکربندی دارد، نه کد شما.
• انعطاف‌پذیری در استقرار: به شما امکان می‌دهد لاگینگ را به راحتی برای محیط‌های مختلف (توسعه، تست، پروداکشن) سفارشی کنید.

Formatter های سفارشی: سفارشی‌سازی پیام‌های لاگ شما

فرمترها ساختار و محتوای پیام‌های لاگ شما را کنترل می‌کنند. آن‌ها به شما امکان می‌دهند اطلاعات نمایش داده شده در لاگ‌های خود را سفارشی کنید، که درک و تحلیل رفتار برنامه را آسان‌تر می‌کند. فرمترها تعیین می‌کنند که چه جزئیاتی (مهر زمانی، نام لاگر، سطح لاگ، پیام و غیره) شامل شود و چگونه ارائه شوند.

درک اجزای Formatter:

فرمترها از یک رشته قالب استفاده می‌کنند که نحوه قالب‌بندی رکوردهای لاگ را تعریف می‌کند. در اینجا برخی از مشخص‌کننده‌های قالب رایج آورده شده است:

• %(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: نام ترد (thread).
• %(process)d: شناسه فرآیند (process ID).

ایجاد Formatter های سفارشی:

شما می‌توانید فرمترهای سفارشی ایجاد کنید تا اطلاعات خاصی را که متناسب با نیازهای برنامه شماست، شامل شود. این کار با زیرکلاس‌بندی از کلاس 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
              
            
          

توضیح مثال فرمتر سفارشی:

• ما کلاسی به نام `CustomFormatter` ایجاد می‌کنیم که از `logging.Formatter` ارث می‌برد.
• متد `format()` بازنویسی می‌شود. اینجاست که منطق قالب‌بندی سفارشی قرار دارد.
• ابتدا پیام قالب‌بندی شده استاندارد را با استفاده از super().format(record) دریافت می‌کنیم.
• ما اطلاعات سفارشی اضافه می‌کنیم. در این مثال، ما اطلاعات کاربر (شناسه کاربر) را در صورتی که به عنوان یک ویژگی از رکورد لاگ وجود داشته باشد، شامل می‌کنیم. در غیر این صورت (مانند یک کاربر مهمان)، "Guest" را نشان می‌دهد. توجه کنید که چگونه بررسی `hasattr()` و گنجاندن شرطی ویژگی user_id به شما کمک می‌کند تا از خطا در مواردی که ویژگی تعریف نشده است، جلوگیری کنید.
• این مثال نشان می‌دهد که چگونه یک پیام لاگ را برای گنجاندن اطلاعات در مورد کاربر وارد شده فعلی، مدیریت کنیم.

قالب‌بندی پیام‌های لاگ برای موارد استفاده مختلف:

در اینجا چند نمونه از سبک‌های مختلف فرمتر برای کمک به شما در انتخاب مناسب‌ترین قالب‌بندی برای نیازهایتان آورده شده است.

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.dumps()` برای کدگذاری رکورد لاگ به صورت JSON استفاده کنید.

               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: خطاهای شدید که ممکن است باعث از کار افتادن یا ناپایدار شدن برنامه شوند.

  سطحی را انتخاب کنید که به درستی شدت رویداد لاگ شده را منعکس کند.

• اطلاعات زمینه‌ای: زمینه مربوطه را در پیام‌های لاگ خود بگنجانید. شناسه‌های کاربری، شناسه‌های درخواست، شناسه‌های تراکنش یا هر اطلاعات دیگری که می‌تواند به شما در ردیابی یک مشکل به منشأ آن کمک کند را شامل کنید.
• مدیریت خطا: همیشه استثناها را با استفاده از logger.exception() یا با گنجاندن اطلاعات استثنا در پیام لاگ، لاگ کنید. این کار ردپای پشته (stack trace) را فراهم می‌کند که برای دیباگ کردن بسیار ارزشمند است.
• لاگینگ متمرکز (برای سیستم‌های توزیع‌شده): استفاده از یک سیستم لاگینگ متمرکز (مانند Elasticsearch, Fluentd, Splunk, یا پشته ELK -- Elasticsearch, Logstash, and Kibana) را در نظر بگیرید. این به شما امکان می‌دهد لاگ‌ها را از چندین برنامه و سرور جمع‌آوری کنید و جستجو، تحلیل و نظارت بر سیستم‌های خود را آسان‌تر می‌کند. در دنیای رایانش ابری، خدمات متنوعی لاگینگ مدیریت‌شده را ارائه می‌دهند، مانند AWS CloudWatch, Azure Monitor, و Google Cloud Logging.
• چرخش و نگهداری: چرخش لاگ را (با استفاده از `RotatingFileHandler` یا `TimedRotatingFileHandler`) برای جلوگیری از بزرگ شدن بیش از حد فایل‌های لاگ پیاده‌سازی کنید. یک سیاست نگهداری برای حذف یا بایگانی خودکار لاگ‌ها پس از یک دوره مشخص ایجاد کنید. این برای انطباق با مقررات، امنیت و مدیریت ذخیره‌سازی مهم است.
• اجتناب از اطلاعات حساس: هرگز اطلاعات حساس مانند رمزهای عبور، کلیدهای API یا داده‌های شخصی را لاگ نکنید. از انطباق با مقررات حریم خصوصی مانند GDPR یا CCPA اطمینان حاصل کنید. در صورتی که برنامه با داده‌های حساس کار می‌کند، فیلترینگ دقیقی را پیاده‌سازی کنید.
• لاگینگ مبتنی بر پیکربندی: از فایل‌های پیکربندی (YAML, JSON, or INI) برای مدیریت تنظیمات لاگینگ خود استفاده کنید. این کار تغییر سطوح لاگ، هندلرها و فرمترها را بدون تغییر کد شما آسان‌تر می‌کند و به شما امکان می‌دهد لاگینگ را برای محیط‌های مختلف سفارشی کنید.
• ملاحظات عملکرد: از لاگینگ بیش از حد، به ویژه در بخش‌های حساس به عملکرد کد خود، خودداری کنید. لاگینگ می‌تواند سربار ایجاد کند، بنابراین مراقب تأثیر آن بر عملکرد برنامه باشید. از سطوح لاگ مناسب استفاده کنید و در صورت لزوم پیام‌ها را فیلتر کنید.
• تست لاگینگ: تست‌های واحد بنویسید تا پیکربندی لاگینگ خود را تأیید کنید و مطمئن شوید که پیام‌های لاگ شما به درستی تولید می‌شوند. تست سطوح مختلف لاگ و سناریوها را برای اطمینان از عملکرد صحیح در نظر بگیرید.
• مستندسازی: پیکربندی لاگینگ خود، از جمله سطوح لاگ، هندلرها و فرمترها را مستند کنید. این به سایر توسعه‌دهندگان کمک می‌کند تا تنظیمات لاگینگ شما را درک کنند و نگهداری و عیب‌یابی کد شما را آسان‌تر می‌کند.
• ارتباط شناسه کاربر و شناسه درخواست: برای برنامه‌های وب یا هر سرویسی که چندین درخواست را مدیریت می‌کند، یک شناسه درخواست منحصر به فرد ایجاد کنید و آن را در هر پیام لاگ مربوط به یک درخواست خاص بگنجانید. به طور مشابه، در صورت لزوم شناسه کاربر را نیز شامل کنید. این به ردیابی درخواست‌ها در چندین سرویس و دیباگ کردن مشکلات مربوط به کاربران خاص کمک می‌کند.

مثال‌های عملی و موارد استفاده

بیایید برخی از سناریوهای دنیای واقعی را که در آن‌ها لاگینگ مؤثر حیاتی است، بررسی کنیم:

۱. نظارت بر برنامه وب:

در یک برنامه وب، می‌توانید از لاگینگ برای نظارت بر درخواست‌های کاربر، ردیابی خطاها و شناسایی گلوگاه‌های عملکردی استفاده کنید.

            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
              
            
          

در این مثال، ما:

• یک شناسه درخواست برای ردیابی درخواست‌های فردی تولید (یا دریافت) می‌کنیم.
• درخواست را با شناسه درخواست لاگ می‌کنیم.
• هرگونه خطا، از جمله استثنا و شناسه درخواست را لاگ می‌کنیم.

۲. وظایف پس‌زمینه / کارهای زمان‌بندی شده:

لاگینگ برای نظارت بر وظایف پس‌زمینه، مانند کارهای زمان‌بندی شده یا خطوط لوله پردازش داده، حیاتی است.

            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
              
            
          

این کد لاگینگ قبل، حین و بعد از اجرای یک وظیفه را نشان می‌دهد و موفقیت و شکست را نمایش می‌دهد. این کار تشخیص مشکلات زمان‌بندی را آسان می‌کند.

۳. خط لوله پردازش داده:

در یک خط لوله پردازش داده، لاگینگ به شما کمک می‌کند تا تبدیلات داده را ردیابی کنید، خطاها را شناسایی کنید و سلامت کلی خط لوله را نظارت کنید.

            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
              
            
          

این مثال خط لوله، بارگذاری، تبدیل و ذخیره داده‌ها را لاگ می‌کند. دستورات لاگینگ به شما امکان می‌دهد فرآیند را نظارت کرده و در صورت بروز مشکل، به راحتی آن را تشخیص دهید.

تکنیک‌های پیشرفته لاگینگ

فراتر از اصول اولیه، این تکنیک‌های پیشرفته را برای به حداکثر رساندن قابلیت‌های لاگینگ خود در نظر بگیرید:

• Logging ContextVars: ماژول `contextvars` (موجود در پایتون 3.7+) به شما امکان می‌دهد داده‌های وابسته به زمینه (مانند شناسه‌های درخواست، شناسه‌های کاربر) را ذخیره کرده و به طور خودکار آن را در پیام‌های لاگ خود بگنجانید. این کار فرآیند افزودن اطلاعات زمینه‌ای به لاگ‌های شما را بدون نیاز به ارسال دستی آن به هر فراخوانی لاگینگ، ساده می‌کند. این امر کدهای تکراری را کاهش داده و قابلیت نگهداری کد را بهبود می‌بخشد.
• فیلترهای لاگینگ: از فیلترها برای پالایش بیشتر اینکه کدام پیام‌های لاگ توسط هندلرها پردازش شوند، استفاده کنید. فیلترها می‌توانند، به عنوان مثال، برای لاگ کردن شرطی پیام‌ها بر اساس معیارهای سفارشی، مانند ماژول منشأ یا مقدار یک متغیر خاص، استفاده شوند.
• ادغام کتابخانه‌های لاگینگ: لاگینگ خود را با سایر کتابخانه‌ها و چارچوب‌های مورد استفاده در پروژه خود ادغام کنید. به عنوان مثال، اگر از یک چارچوب وب مانند Flask یا Django استفاده می‌کنید، می‌توانید لاگینگ را برای ثبت خودکار اطلاعات در مورد درخواست‌ها و پاسخ‌های HTTP پیکربندی کنید.
• تجمیع و تحلیل لاگ (پشته ELK و غیره): یک سیستم تجمیع لاگ را پیاده‌سازی کنید. استفاده از پشته ELK (Elasticsearch, Logstash, Kibana) یا سایر راه‌حل‌های مبتنی بر ابر را در نظر بگیرید. این سیستم‌ها به شما امکان می‌دهند لاگ‌ها را از منابع مختلف جمع‌آوری، متمرکز و تحلیل کنید و قابلیت‌های جستجو، فیلتر و تجسم قدرتمندی را فراهم می‌کنند. این توانایی شما را در شناسایی روندها، تشخیص ناهنجاری‌ها و عیب‌یابی مشکلات افزایش می‌دهد.
• ردیابی و ردیابی توزیع‌شده (Tracing): برای میکروسرویس‌ها یا برنامه‌های توزیع‌شده، ردیابی را برای دنبال کردن درخواست‌ها در حین عبور از چندین سرویس پیاده‌سازی کنید. کتابخانه‌هایی مانند Jaeger, Zipkin, و OpenTelemetry به ردیابی کمک می‌کنند. این به شما امکان می‌دهد پیام‌های لاگ را در سرویس‌های مختلف مرتبط کنید و بینش‌هایی در مورد رفتار سرتاسری برنامه خود و شناسایی گلوگاه‌های عملکردی در سیستم‌های توزیع‌شده پیچیده فراهم می‌کند.

نتیجه‌گیری: لاگینگ برای موفقیت

لاگینگ مؤثر یک جنبه اساسی از توسعه نرم‌افزار است. چارچوب لاگینگ پایتون ابزارهایی را که برای پیاده‌سازی لاگینگ جامع در برنامه‌های خود نیاز دارید، فراهم می‌کند. با درک پیکربندی هندلر، فرمترهای سفارشی و بهترین شیوه‌ها، می‌توانید راه‌حل‌های لاگینگ قوی و کارآمدی ایجاد کنید که به شما امکان می‌دهد:

• دیباگ مؤثر: علت اصلی مشکلات را سریع‌تر مشخص کنید.
• نظارت بر سلامت برنامه: مشکلات بالقوه را به صورت پیشگیرانه شناسایی کنید.
• بهبود عملکرد برنامه: کد خود را بر اساس بینش‌های لاگینگ بهینه کنید.
• به دست آوردن بینش‌های ارزشمند: درک کنید که برنامه شما چگونه استفاده می‌شود.
• برآورده کردن الزامات قانونی: با استانداردهای لاگینگ و حسابرسی مطابقت داشته باشید.

چه شما یک توسعه‌دهنده تازه‌کار باشید که سفر خود را آغاز کرده‌اید یا یک حرفه‌ای با تجربه که سیستم‌های توزیع‌شده در مقیاس بزرگ می‌سازد، درک قوی از چارچوب لاگینگ پایتون بسیار ارزشمند است. این مفاهیم را به کار بگیرید، مثال‌ها را با نیازهای خاص خود تطبیق دهید و از قدرت لاگینگ برای ایجاد نرم‌افزاری قابل اعتمادتر و قابل نگهداری‌تر برای چشم‌انداز جهانی استقبال کنید. لاگینگ مداوم بهره‌وری شما را افزایش می‌دهد و بینش‌های حیاتی مورد نیاز برای اطمینان از دستیابی برنامه‌های شما به موفقیتی که شایسته آن هستند را فراهم می‌کند.