Python Logging Freymvorki: Handler Konfiguratsiyasi va Maxsus Formatlovchilar

Pythonning logging freymvorki ilova xatti-harakatlarini boshqarish va monitoring qilish uchun kuchli vositadir. Samarali log yuritish dasturiy ta'minotingizning ishlashini tuzatish, nosozliklarni bartaraf etish va tushunish uchun hal qiluvchi ahamiyatga ega. Ushbu keng qamrovli qo'llanma Python logging freymvorkining ikkita asosiy jihatini chuqur o'rganadi: Handler konfiguratsiyasi va Maxsus Formatlovchilar. Biz sizning joylashuvingizdan qat'i nazar, Python loyihalaringizda ishonchli va samarali log yuritishni amalga oshirishingizga yordam berish uchun ularning funksionalligi, eng yaxshi amaliyotlari va amaliy misollarini ko'rib chiqamiz.

Python Logging Asoslarini Tushunish

Handlerlar va formatlovchilarga sho'ng'ishdan oldin, keling, Python logging freymvorkining asosiy komponentlari haqida mustahkam tushunchaga ega bo'laylik:

• Loggerlar: Loggerlar ilovangiz uchun log xabarlarini yozishning asosiy interfeysidir. Ular ierarxik bo'lib, ya'ni loggerning quyi loggerlari bo'lishi va ota-onalaridan konfiguratsiyani meros qilib olishi mumkin. Ularni log xabarlaringizning qo'riqchilari deb o'ylang.
• Log Darajalari: Log darajalari (DEBUG, INFO, WARNING, ERROR, CRITICAL) log xabarlarining muhimlik darajasini tasniflaydi. Siz ushbu darajalardan qaysi xabarlar qayta ishlanishini filtrlash uchun foydalanasiz. Masalan, production muhitida siz faqat WARNING, ERROR va CRITICAL xabarlarini logga yozishingiz mumkin, bu esa ortiqcha ma'lumotlarni kamaytiradi.
• Handlerlar: Handlerlar log xabarlari qayerga yuborilishini aniqlaydi. Bu konsol (stdout), fayl, tarmoq soketi yoki hatto ma'lumotlar bazasi bo'lishi mumkin. Handlerlar log darajasi bo'yicha filtrlash va formatlovchilarni qo'llash uchun sozlanishi mumkin.
• Formatlovchilar: Formatlovchilar log xabarlaringizning tuzilishi va tarkibini belgilaydi. Ular qanday ma'lumotlar kiritilishini (vaqt belgisi, logger nomi, log darajasi, xabar mazmuni va h.k.) va qanday taqdim etilishini nazorat qiladi. Formatlovchilar log xabari yozilishidan oldin handler tomonidan qo'llaniladi.

Ushbu komponentlar birgalikda moslashuvchan va sozlanuvchan log yuritish tizimini ta'minlash uchun ishlaydi. Log xabari loggerda paydo bo'ladi, handler orqali o'tadi va o'z manziliga yuborilishidan oldin formatlovchi yordamida formatlanadi. Bu tuzilma loglar qanday yaratilishi, qayta ishlanishi va saqlanishi ustidan batafsil nazoratni ta'minlaydi.

Handler Konfiguratsiyasi: Loglaringizni Samarali Yo'naltirish

Handlerlar logging freymvorkining asosiy ishchi qismi bo'lib, log xabarlaringizni yakuniy manziliga yo'naltirish uchun mas'uldirlar. To'g'ri handler konfiguratsiyasi samarali log yuritish uchun juda muhimdir. Quyida asosiy e'tiborga olinadigan jihatlar keltirilgan:

Keng tarqalgan Handler Turlari:

• StreamHandler: Log xabarlarini oqimga, odatda stdout yoki stderr'ga yuboradi. Dasturlash jarayonida konsolga log yozish uchun ideal.
• FileHandler: Log xabarlarini faylga yozadi. Ilova hodisalarini doimiy ravishda logga yozish uchun, ayniqsa production muhitida muhim. Bu, ayniqsa, joylashtirilgandan keyin yuzaga keladigan muammolarni tuzatish uchun hal qiluvchi ahamiyatga ega.
• RotatingFileHandler: FileHandlerning quyi klassi bo'lib, log fayllari ma'lum bir hajmga yetganda yoki ma'lum vaqt oralig'ida avtomatik ravishda almashtiriladi. Bitta log faylining cheksiz o'sishini oldini oladi, ishlash samaradorligini va boshqaruv qulayligini oshiradi.
• TimedRotatingFileHandler: RotatingFileHandlerga o'xshaydi, lekin vaqtga (kunlik, haftalik va h.k.) qarab almashtiradi. Loglarni sana bo'yicha tartiblash uchun foydali.
• SocketHandler: Log xabarlarini tarmoq soketi orqali yuboradi. Masofadan log yuritish imkonini beradi, bu sizga bir nechta ilovalardan loglarni markazlashtirishga imkon beradi.
• SMTPHandler: Log xabarlarini elektron pochta orqali yuboradi. Muhim xatolar yoki ogohlantirishlar haqida xabar berish uchun foydali.

Python'da Handlerlarni Sozlash:

Handlerlarni sozlashning ikkita asosiy usuli mavjud:

1. Dasturiy Konfiguratsiya: Bu Python kodingizda to'g'ridan-to'g'ri handler nusxalarini yaratish va ularni loggerlarga biriktirishni o'z ichiga oladi. Ushbu yondashuv eng katta moslashuvchanlik va nazoratni ta'minlaydi, bu sizga ilova ehtiyojlariga qarab log yuritish xatti-harakatlarini dinamik ravishda sozlash imkonini beradi.
2. Konfiguratsiya Fayllari (masalan, YAML, JSON, INI): Konfiguratsiya fayllaridan foydalanish log sozlamalarini ilova kodingizdan ajratishga imkon beradi, bu esa kod o'zgarishlarisiz log sozlamalarini boshqarish va o'zgartirishni osonlashtiradi. Bu, ayniqsa, joylashtirish muhitlari uchun foydalidir.

Dasturiy Handler Misoli:

Keling, dasturiy konfiguratsiyani konsolga va faylga yozadigan oddiy misol bilan ko'rib chiqaylik. Bu misol asosiy tuzilmani ko'rsatadi. Loyihangiz uchun fayl yo'llarini va log darajalarini kerak bo'lganda sozlashni unutmang.

            import logging

# Logger yaratish
logger = logging.getLogger('my_app')
logger.setLevel(logging.DEBUG) # Asosiy logger darajasini o'rnatish

# Konsolga (stdout) chiqarish uchun handler yaratish
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO) # Ushbu handler uchun darajani o'rnatish

# Faylga yozish uchun handler yaratish
file_handler = logging.FileHandler('my_app.log')
file_handler.setLevel(logging.DEBUG) # Hamma narsani faylga yozish

# Formatlovchilar yaratish (keyinroq tushuntiriladi)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)

# Handlerlarni loggerga qo'shish
logger.addHandler(console_handler)
logger.addHandler(file_handler)

# Log xabarlari misoli
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
              
            
          

Misoldagi asosiy nuqtalar:

• Biz logging.getLogger() yordamida logger nusxasini yaratamiz. Argument odatda modul nomi yoki ilovaga xos nom bo'ladi.
• Biz ildiz logger ('my_app') uchun log darajasini o'rnatamiz. Bu logger tomonidan qayta ishlanadigan xabarlarning *minimal* muhimlik darajasini belgilaydi.
• Biz ikkita handler yaratamiz: biri konsol (StreamHandler) uchun va ikkinchisi fayl (FileHandler) uchun.
• Biz *har bir* handler uchun darajani o'rnatamiz. Bu filtrlash imkonini beradi. Masalan, konsol handleri faqat INFO va undan yuqori xabarlarni ko'rsatishi mumkin, fayl handleri esa barcha xabarlarni (DEBUG va undan yuqori) yozib oladi.
• Biz har bir handlerga formatlovchi biriktiramiz (quyida batafsil tushuntiriladi).
• Biz logger.addHandler() yordamida handlerlarni loggerga qo'shamiz.
• Biz turli darajalarda log xabarlarini yaratish uchun loggerdan foydalanamiz.

Konfiguratsiya Fayli Misoli (YAML):

Konfiguratsiya faylidan (masalan, YAML) foydalanish log sozlamalaringizni tashqi tomondan belgilashga imkon beradi, bu esa kodni o'zgartirmasdan log yuritish xatti-harakatlarini o'zgartirishni osonlashtiradi. Mana `logging.config.dictConfig()` funksiyasidan foydalangan holda misol:

            import logging
import logging.config
import yaml

# Konfiguratsiyani YAML faylidan yuklash
with open('logging_config.yaml', 'r') as f:
    config = yaml.safe_load(f)

# Loggingni sozlash
logging.config.dictConfig(config)

# Logger olish (nom konfiguratsiya faylida belgilangan nomga mos kelishi kerak)
logger = logging.getLogger('my_app')

# Log xabarlari misoli
logger.debug('This is a debug message from the config')
logger.info('This is an info message from the config')

            

              
                Copy
              
            
          

Va mana namunaviy logging_config.yaml fayli:

            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 # Agar loggerda o'rnatilmagan bo'lsa, standart sozlamalar.
            

              
                Copy
              
            
          

YAML konfiguratsiyasining tushuntirishi:

• version: 1: Konfiguratsiya fayli versiyasini belgilaydi.
• formatters: Mavjud formatlovchilarni belgilaydi.
• handlers: Handlerlarni belgilaydi. Har bir handler o'z sinfini, darajasini, formatlovchisini va manzilini (masalan, konsol, fayl) belgilaydi.
• loggers: Loggerlarni belgilaydi. Bu yerda biz 'my_app' loggerini 'console' va 'file' handlerlaridan foydalanish uchun sozlaymiz. Shuningdek, uning log darajasini o'rnatamiz.
• root: Agar loggerlarda o'rnatilmagan bo'lsa, standart konfiguratsiya.

Konfiguratsiya fayllarining asosiy afzalliklari:

• Mas'uliyatlarni ajratish: Log konfiguratsiyangizni asosiy ilova mantig'ingizdan alohida saqlaydi.
• Oson o'zgartirish: Log yuritish xatti-harakatlarini o'zgartirish (masalan, log darajalari, chiqarish manzillari) faqat konfiguratsiya faylini o'zgartirishni talab qiladi, kodingizni emas.
• Joylashtirish moslashuvchanligi: Har xil muhitlarga (dasturlash, testlash, production) log yuritishni osongina moslashtirish imkonini beradi.

Maxsus Formatlovchilar: Log Xabarlaringizni Moslashtirish

Formatlovchilar log xabarlaringizning tuzilishi va tarkibini nazorat qiladi. Ular loglaringizda ko'rsatiladigan ma'lumotlarni sozlash imkonini beradi, bu esa ilova xatti-harakatlarini tushunish va tahlil qilishni osonlashtiradi. Formatlovchilar qanday tafsilotlar kiritilishini (vaqt belgisi, logger nomi, log darajasi, xabar va h.k.) va ular qanday taqdim etilishini belgilaydi.

Formatlovchi Komponentlarini Tushunish:

Formatlovchilar log yozuvlari qanday formatlanishini belgilaydigan format satridan foydalanadi. Quyida keng tarqalgan format spetsifikatorlari keltirilgan:

• %(asctime)s: Log yozuvi yaratilgan vaqt (masalan, '2024-01-01 12:00:00,000').
• %(name)s: Logger nomi (masalan, 'my_app.module1').
• %(levelname)s: Log darajasi (masalan, 'INFO', 'WARNING', 'ERROR').
• %(message)s: Log xabari.
• %(filename)s: Log xabari paydo bo'lgan fayl nomi.
• %(lineno)d: Log xabari paydo bo'lgan qator raqami.
• %(funcName)s: Log xabari paydo bo'lgan funksiya nomi.
• %(pathname)s: Manba faylining to'liq yo'li.
• %(threadName)s: Oqim (thread) nomi.
• %(process)d: Jarayon (process) IDsi.

Maxsus Formatlovchilarni Yaratish:

Ilovangiz ehtiyojlariga moslashtirilgan maxsus ma'lumotlarni kiritish uchun siz maxsus formatlovchilarni yaratishingiz mumkin. Bunga `logging.Formatter` sinfidan voris olib va uning `format()` metodini qayta yozish orqali erishiladi. `format()` metodi ichida siz log yozuvining atributlariga kirishingiz va xabarni kerakli tarzda formatlashingiz mumkin.

            import logging

class CustomFormatter(logging.Formatter):
    def format(self, record):
        # Asl formatlangan xabarni olish
        log_fmt = super().format(record)

        # Maxsus ma'lumot qo'shish
        custom_info = f' - User: {record.user_id if hasattr(record, "user_id") else "Guest"}' # Moslashtirish misoli
        return log_fmt + custom_info

# Foydalanish misoli (Tasviriy: handler sozlash va maxsus formatlovchini biriktirishni talab qiladi)
if __name__ == '__main__':
    logger = logging.getLogger('custom_logger')
    logger.setLevel(logging.INFO)

    # Konsol handleri yaratish
    ch = logging.StreamHandler()
    ch.setLevel(logging.INFO)

    # Handlerga maxsus formatlovchini o'rnatish
    formatter = CustomFormatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    ch.setFormatter(formatter)

    # Handlerni loggerga qo'shish
    logger.addHandler(ch)

    # Maxsus atributli log yozuvini yaratish (namoyish uchun simulyatsiya qilingan)
    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
    
    #Foydalanuvchi IDsi bilan xabar misoli
    record = LogRecordWithUser('custom_logger', logging.INFO, 'example.py', 10, 'User logged in', (), None, 'main', None, user_id='12345')
    logger.handle(record)

    # Foydalanuvchi IDsisiz xabar misoli
    logger.info('Guest user accessed the page.')

            

              
                Copy
              
            
          

Maxsus formatlovchi misolining tushuntirishi:

• Biz `logging.Formatter` dan meros oluvchi `CustomFormatter` nomli klass yaratamiz.
• `format()` metodi qayta yoziladi. Maxsus formatlash mantig'i aynan shu yerda joylashgan.
• Avval super().format(record) yordamida standart formatlangan xabarni olamiz.
• Biz maxsus ma'lumot qo'shamiz. Bu misolda, agar log yozuvining atributi sifatida mavjud bo'lsa, foydalanuvchi ma'lumotlarini (foydalanuvchi IDsi) kiritamiz. Aks holda (mehmon foydalanuvchi kabi), u "Guest" deb ko'rsatadi. `hasattr()` tekshiruvi va user_id atributining shartli kiritilishi, atribut aniqlanmagan hollarda xatoliklarni oldini olishga yordam berishini e'tiborga oling.
• Misol, tizimga kirgan foydalanuvchi haqidagi ma'lumotlarni o'z ichiga olgan log xabarini qanday qayta ishlashni ko'rsatadi.

Turli Foydalanish Holatlari uchun Log Xabarlarini Formatlash:

Ehtiyojlaringizga eng mos formatlashni tanlashga yordam berish uchun turli formatlovchi uslublarining ba'zi misollari keltirilgan.

1. Asosiy Formatlash (dasturlash uchun):

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

   Bu format oddiy vaqt belgisi, log darajasi va xabarni taqdim etadi. Tez tuzatish uchun yaxshi.
2. Batafsil Formatlash (production uchun, fayl/qator raqami bilan):

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

   Bu format logger nomini, fayl nomini, qator raqamini va log xabarini o'z ichiga oladi, bu esa loglar manbasini kuzatishni osonlashtiradi.
3. JSON Formatlash (mashina tomonidan tahlil qilish uchun):

   Avtomatlashtirilgan log tahlili uchun (masalan, log agregatsiya tizimi bilan) JSON formatlash juda samarali. Bu tuzilgan ma'lumotlarni taqdim etadi, bu esa tahlil qilishni osonlashtiradi. Siz maxsus formatlovchi klassini yaratishingiz va log yozuvini JSON sifatida kodlash uchun `json.dumps()` dan foydalanishingiz kerak bo'ladi.

               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
                 
               
             

   Ushbu formatlovchi tegishli log ma'lumotlarini o'z ichiga olgan JSON tuzilmasini yaratadi. Fayl, qator raqami va funksiya nomi manba kodida osonlik bilan orqaga kuzatish imkonini beradi. Ushbu formatlangan chiqish keyin log tahlil vositalari tomonidan osongina tahlil qilinadi.

4. Maxsus Ilovalar uchun Formatlash:

   Kontekstga xos ma'lumotlarni kiritish uchun formatlovchilaringizni moslashtiring. Agar ilovangiz foydalanuvchi autentifikatsiyasini boshqarsa, foydalanuvchi IDlarini qo'shing. Agar moliyaviy tranzaktsiyalarni qayta ishlayotgan bo'lsangiz, tranzaksiya IDlarini qo'shing. Log chiqishingizni biznes kontekstingizga va duch kelishingiz mumkin bo'lgan muammolar turlariga qarab moslashtiring.

Python Logging bo'yicha Eng Yaxshi Amaliyotlar

Eng yaxshi amaliyotlarga rioya qilish log yuritishingiz samarali, qo'llab-quvvatlanadigan va qimmatli bo'lishini ta'minlaydi. Quyida ba'zi asosiy tavsiyalar keltirilgan:

• Log Darajasi Anliqligi: Tegishli log darajalaridan izchil foydalaning.
  • DEBUG: Batafsil ma'lumot, odatda tuzatish uchun.
  • INFO: Ilova ishlashi haqida umumiy ma'lumot.
  • WARNING: Potensial muammolar yoki kutilmagan hodisalar.
  • ERROR: Ba'zi funksiya yoki funksionallikning ishlashiga to'sqinlik qilayotgan xatolar.
  • CRITICAL: Ilovaning ishdan chiqishiga yoki beqaror bo'lishiga olib kelishi mumkin bo'lgan jiddiy xatolar.

  Logga yozilgan hodisaning muhimlik darajasini aniq aks ettiruvchi darajani tanlang.

• Kontekstual Ma'lumot: Log xabarlaringizga tegishli kontekstni qo'shing. Foydalanuvchi IDlari, so'rov IDlari, tranzaksiya IDlari yoki muammoni uning kelib chiqishiga qadar kuzatishga yordam beradigan boshqa har qanday ma'lumotni qo'shing.
• Xatoliklarni Qayta Ishlash: Har doim istisnolarni logger.exception() yordamida yoki istisno ma'lumotlarini log xabariga kiritish orqali logga yozing. Bu tuzatish uchun bebaho bo'lgan stek treyslarni taqdim etadi.
• Markazlashtirilgan Log Yuritish (taqsimlangan tizimlar uchun): Markazlashtirilgan log yuritish tizimidan (masalan, Elasticsearch, Fluentd, Splunk yoki ELK steki -- Elasticsearch, Logstash va Kibana) foydalanishni ko'rib chiqing. Bu sizga bir nechta ilovalar va serverlardan loglarni yig'ish imkonini beradi, bu esa tizimlaringizni qidirish, tahlil qilish va monitoring qilishni osonlashtiradi. Bulutli hisoblash dunyosida turli xil xizmatlar boshqariladigan log yuritishni taklif qiladi, masalan, AWS CloudWatch, Azure Monitor va Google Cloud Logging.
• Almashtirish va Saqlash: Log fayllarining haddan tashqari kattalashib ketishini oldini olish uchun log almashtirishni (RotatingFileHandler yoki TimedRotatingFileHandler yordamida) amalga oshiring. Ma'lum bir muddatdan keyin loglarni avtomatik ravishda o'chirish yoki arxivlash uchun saqlash siyosatini o'rnating. Bu muvofiqlik, xavfsizlik va saqlashni boshqarish uchun muhimdir.
• Maxfiy Ma'lumotlardan Saqlanish: Hech qachon parollar, API kalitlari yoki shaxsiy ma'lumotlar kabi maxfiy ma'lumotlarni logga yozmang. GDPR yoki CCPA kabi maxfiylik qoidalariga rioya qilinishini ta'minlang. Agar ilova maxfiy ma'lumotlar bilan ishlasa, ehtiyotkorlik bilan filtrlashni amalga oshiring.
• Konfiguratsiyaga Asoslangan Log Yuritish: Log sozlamalaringizni boshqarish uchun konfiguratsiya fayllaridan (YAML, JSON yoki INI) foydalaning. Bu sizning kodingizni o'zgartirmasdan log darajalari, handlerlar va formatlovchilarni o'zgartirishni osonlashtiradi, bu esa turli muhitlar uchun log yuritishni sozlash imkonini beradi.
• Ishlash Samaradorligini Hisobga Olish: Ayniqsa, kodingizning ishlash samaradorligi muhim bo'lgan qismlarida haddan tashqari log yuritishdan saqlaning. Log yuritish qo'shimcha yuk olib kelishi mumkin, shuning uchun ilova ishlashiga ta'sirini yodda tuting. Tegishli log darajalaridan foydalaning va kerak bo'lganda xabarlarni filtrlang.
• Log Yuritishni Sinovdan O'tkazish: Log konfiguratsiyangizni va log xabarlaringiz to'g'ri yaratilishini tekshirish uchun birlik testlarini yozing. To'g'ri ishlashini ta'minlash uchun turli log darajalari va stsenariylarni sinab ko'ring.
• Hujjatlashtirish: Log konfiguratsiyangizni, shu jumladan log darajalari, handlerlar va formatlovchilarni hujjatlashtiring. Bu boshqa dasturchilarga log sozlamalaringizni tushunishga yordam beradi va kodingizni qo'llab-quvvatlash va tuzatishni osonlashtiradi.
• Foydalanuvchi IDsi va So'rov IDsi Korrelyatsiyasi: Veb-ilovalar yoki bir nechta so'rovlarni qayta ishlaydigan har qanday xizmat uchun noyob so'rov IDsi yarating va uni ma'lum bir so'rovga oid har bir log xabariga qo'shing. Xuddi shunday, kerak bo'lganda foydalanuvchi IDsi qo'shing. Bu bir nechta xizmatlar bo'ylab so'rovlarni kuzatishga va ma'lum foydalanuvchilarga oid muammolarni tuzatishga yordam beradi.

Amaliy Misollar va Qo'llash Holatlari

Keling, samarali log yuritish hal qiluvchi ahamiyatga ega bo'lgan ba'zi real hayotiy stsenariylarni ko'rib chiqaylik:

1. Veb-ilovalarni Monitoring Qilish:

Veb-ilovada siz foydalanuvchi so'rovlarini kuzatish, xatolarni kuzatib borish va ishlashdagi to'siqlarni aniqlash uchun log yuritishdan foydalanishingiz mumkin.

            import logging
from flask import Flask, request

app = Flask(__name__)

# Loggingni sozlash (bu yerda config fayli yoki dasturiy misol yordamida)
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

@app.route('/')
def index():
    # So'rov IDsi yaratish (masalan)
    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:
        # Xato holatini simulyatsiya qilish
        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)  # Production muhitida debug=True dan foydalanishda juda ehtiyot bo'ling.
            

              
                Copy
              
            
          

Bu misolda biz:

• Alohida so'rovlarni kuzatish uchun so'rov IDsi yaratamiz (yoki olamiz).
• So'rovni so'rov IDsi bilan logga yozamiz.
• Har qanday xatoni, shu jumladan istisno va so'rov IDsi bilan logga yozamiz.

2. Fon Vazifalari / Rejalashtirilgan Ishlar:

Log yuritish rejalashtirilgan ishlar yoki ma'lumotlarni qayta ishlash konveyerlari kabi fon vazifalarini kuzatish uchun juda muhimdir.

            import logging
import time
from datetime import datetime

# Loggingni sozlash (yana, config faylidan foydalanish odatda yaxshiroq)
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:
        # Ba'zi ishlarni simulyatsiya qilish
        time.sleep(2)  # Ishni simulyatsiya qilish
        # Potensial xatoni simulyatsiya qilish
        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
              
            
          

Bu vazifani bajarishdan oldin, bajarish paytida va keyin log yuritishni, muvaffaqiyat va muvaffaqiyatsizlikni ko'rsatadi. Bu rejalashtirish muammolarini tashxislashni osonlashtiradi.

3. Ma'lumotlarni Qayta Ishlash Konveyeri:

Ma'lumotlarni qayta ishlash konveyerida log yuritish ma'lumotlar transformatsiyasini kuzatish, xatolarni aniqlash va umumiy konveyer sog'lig'ini monitoring qilishga yordam beradi.

            import logging
import pandas as pd

# Loggingni sozlash
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) # Fayl turiga qarab o'zgartiring
        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:
        # Ba'zi transformatsiyalarni qo'llash
        df['processed_column'] = df['some_column'] * 2  # Misol
        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)  # Boshqa chiqish formati uchun o'zgartiring
        logger.info(f'Data saved to {output_file}')
    except Exception as e:
        logger.error(f'Error saving data: {str(e)}')

# Foydalanish misoli (haqiqiy fayl yo'llari va ma'lumotlar bilan almashtiring)
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
              
            
          

Ushbu konveyer misoli ma'lumotlarni yuklash, transformatsiya qilish va saqlashni logga yozadi. Log yozuvlari jarayonni kuzatish va agar biror narsa noto'g'ri ketsa, muammolarni osonlik bilan tashxislash imkonini beradi.

Ilg'or Logging Texnikalari

Asoslardan tashqari, log yuritish imkoniyatlaringizni maksimal darajada oshirish uchun ushbu ilg'or texnikalarni ko'rib chiqing:

• Logging ContextVars: `contextvars` moduli (Python 3.7+ da mavjud) kontekstga xos ma'lumotlarni (masalan, so'rov IDlari, foydalanuvchi IDlari) saqlash va ularni avtomatik ravishda log xabarlaringizga qo'shish imkonini beradi. Bu loglaringizga kontekstual ma'lumotlarni qo'shish jarayonini soddalashtiradi, uni har bir log chaqiruviga qo'lda uzatishga hojat qolmaydi. Bu standart kodni kamaytiradi va kodni qo'llab-quvvatlashni yaxshilaydi.
• Logging Filtrlari: Handlerlar tomonidan qaysi log xabarlari qayta ishlanishini yanada aniqlashtirish uchun filtrlardan foydalaning. Filtrlar, masalan, kelib chiqish moduli yoki ma'lum bir o'zgaruvchining qiymatiga qarab log xabarlarini shartli ravishda logga yozish uchun ishlatilishi mumkin.
• Logging Kutubxonalari Integratsiyasi: Log yuritishni loyihangizda ishlatiladigan boshqa kutubxonalar va freymvorklar bilan integratsiya qiling. Masalan, agar siz Flask yoki Django kabi veb-freymvorkdan foydalanayotgan bo'lsangiz, HTTP so'rovlari va javoblari haqidagi ma'lumotlarni avtomatik ravishda logga yozish uchun log yuritishni sozlashingiz mumkin.
• Log Agregatsiyasi va Tahlili (ELK Stack va h.k.): Log agregatsiya tizimini amalga oshiring. ELK stekini (Elasticsearch, Logstash, Kibana) yoki boshqa bulutga asoslangan yechimlarni ishlatishni ko'rib chiqing. Ushbu tizimlar sizga turli manbalardan loglarni to'plash, markazlashtirish va tahlil qilish imkonini beradi, kuchli qidiruv, filtrlash va vizualizatsiya imkoniyatlarini taqdim etadi. Bu tendentsiyalarni aniqlash, anomaliyalarni topish va muammolarni bartaraf etish qobiliyatingizni oshiradi.
• Kuzatish va Taqsimlangan Kuzatuv: Mikroservislar yoki taqsimlangan ilovalar uchun so'rovlar bir nechta xizmatlar orqali o'tayotganda ularni kuzatish uchun kuzatuvni amalga oshiring. Jaeger, Zipkin va OpenTelemetry kabi kutubxonalar kuzatuvda yordam beradi. Bu sizga turli xizmatlar bo'ylab log xabarlarini korrelyatsiya qilish imkonini beradi, ilovangizning boshidan oxirigacha bo'lgan xatti-harakatlari haqida tushunchalar beradi va murakkab taqsimlangan tizimlarda ishlashdagi to'siqlarni aniqlaydi.

Xulosa: Muvaffaqiyat uchun Log Yuritish

Samarali log yuritish dasturiy ta'minotni ishlab chiqishning asosiy jihatidir. Pythonning logging freymvorki ilovalaringizda keng qamrovli log yuritishni amalga oshirish uchun kerakli vositalarni taqdim etadi. Handler konfiguratsiyasi, maxsus formatlovchilar va eng yaxshi amaliyotlarni tushunib, siz ishonchli va samarali log yuritish yechimlarini yaratishingiz mumkin, bu esa sizga quyidagilarga imkon beradi:

• Samarali tuzatish: Muammolarning asl sababini tezroq aniqlash.
• Ilova sog'lig'ini kuzatish: Potensial muammolarni proaktiv ravishda aniqlash.
• Ilova ishlashini yaxshilash: Log yuritish tushunchalariga asoslanib kodingizni optimallashtirish.
• Qimmatli tushunchalarga ega bo'lish: Ilovangiz qanday ishlatilayotganini tushunish.
• Normativ talablarga javob berish: Log yuritish va audit standartlariga rioya qilish.

Siz o'z yo'lingizni boshlayotgan yosh dasturchi bo'lasizmi yoki keng ko'lamli taqsimlangan tizimlarni yaratayotgan tajribali mutaxassis bo'lasizmi, Pythonning logging freymvorkini yaxshi tushunish bebaho. Ushbu tushunchalarni qo'llang, misollarni o'z ehtiyojlaringizga moslashtiring va global landshaft uchun yanada ishonchli va qo'llab-quvvatlanadigan dasturiy ta'minot yaratish uchun log yuritish kuchini qabul qiling. Izchil log yuritish mahsuldorligingizni oshiradi va ilovalaringiz munosib muvaffaqiyatga erishishini ta'minlash uchun zarur bo'lgan muhim tushunchalarni taqdim etadi.