28.11-dars: Markazlashgan loglar

28-QISM — INFRATUZILMA · 11-dars

1. Kirish va motivatsiya

Bir server bo'lganda loglar oddiy: fayl ochasiz, tail -f qilasiz, xatoni ko'rasiz. Lekin zamonaviy tizim — ko'p konteyner, ko'p server, ko'p xizmat (mikroservis — 27.9). Xato bo'lsa — qaysi server? Qaysi konteyner? Konteyner yiqilsa loglari ham yo'qoladi (o'tkinchi — 28.1). Bir foydalanuvchi so'rovi 10 xizmatdan o'tadi — loglari 10 joyda tarqoq. 20 serverga kirib log qidirish — koshmar. Markazlashgan loglar bu muammoni hal qiladi: barcha xizmatdan loglar bir joyga yig'iladi, u yerda qidiriladi, tahlil qilinadi. Bir qidiruv — barcha loglar. Markazlashgan log — tarqoq tizimda ko'rish.

Markazlashgan loglar — ko'p manbadan loglarni bir joyga yig'ish va tahlil qilish: log yig'ish (konteynerlar/xizmatlardan loglarni to'plash — Fluentd, Logstash), markaziy saqlash (barcha log bir joyda — Elasticsearch, Loki), qidiruv/tahlil (Kibana, Grafana — filtrlash, qidiruv), tuzilmali logging (structured logging — JSON log, mashina o'qiy oladigan). Mashhur steklar: ELK (Elasticsearch, Logstash, Kibana), Loki + Grafana. Bu observability 28.10-bob ning "loglar" ustuni. Bu monitoring (28.10 — metrikalar), tracing 27.9-bob bilan birga to'liq ko'rish. Markazlashgan log — tarqoq loglarni birlashtirish. Bir joy — barcha log.

Real vaziyat. Bir mikroservisli tizimda xato bo'lganda dasturchi 15 konteynerga birma-bir kirib log qidirardi (soatlab, ko'pincha topolmasdan). ELK steki qo'llanildi: barcha xizmat loglari Elasticsearch'ga yig'ildi, tuzilmali (JSON) formatda, trace_id bilan. Endi Kibana'da bir qidiruv (trace_id: abc123) — o'sha so'rovning barcha xizmatdagi loglari bir joyda, tartibda. Xato daqiqalarda topildi. Markazlashgan log — qidiruvni soatdan daqiqaga aylantirdi.

Bu darsda markazlashgan loglarni o'rganamiz.

Bu darsda:

• Nega markazlashgan loglar
• Tuzilmali logging (structured)
• Log darajalari (level)
• Log yig'ish va saqlash (ELK, Loki)
• Correlation ID (so'rovni kuzatish)
• Log qidiruv va tahlil
• Logging amaliyoti
• Amaliy: log modeli

ℹ Misollar sof Python (logging, JSON) bilan log mantiqini ko'rsatadi (deterministik).

2. Nazariya — chuqur tushuntirish

2.1. Nega markazlashgan loglar

Tarqoq loglarni birlashtirish:

Ko'p xizmat/server: loglar tarqoq (har joyda)
   xato → qaysi server? qaysi konteyner? (koshmar)
   konteyner yiqilsa — loglar yo'qoladi (o'tkinchi)

Markazlashgan: barcha log → bir joy → bir qidiruv

Nega markazlashgan — zamonaviy tizim ko'p xizmat/server/konteyner (mikroservis) — loglar tarqoq (har joyda): xato bo'lsa qaysi server/konteyner noma'lum, konteyner yiqilsa loglari yo'qoladi (o'tkinchi — 28.1), bir so'rov ko'p xizmatdan o'tadi (loglari tarqoq). Markazlashgan loglar barcha manbani bir joyga yig'adi — bir qidiruv barcha loglarni qamraydi. Sabab: tarqoq loglarda qidirish imkonsiz (20 serverga kirish); markaziy — tez qidiruv, tahlil, saqlash (konteyner o'chsa ham log qoladi). Markazlashgan log — tarqoq tizimda ko'rish. Bir joy — qidiriladigan log.

2.2. Tuzilmali logging (structured)

Mashina o'qiy oladigan log:

# YOMON: matn log (odam o'qiydi, mashina qiyin)
logging.info("Foydalanuvchi 42 buyurtma 100 berdi")

# YAXSHI: tuzilmali (JSON — mashina qidiradi)
logging.info("buyurtma_yaratildi", extra={
    "user_id": 42, "buyurtma_id": 100, "summa": 1000
})
# {"event": "buyurtma_yaratildi", "user_id": 42, ...}

Tuzilmali logging (structured logging) — loglarni matn emas, tuzilmali (JSON — kalit-qiymat) formatda yozish: {"event": "buyurtma_yaratildi", "user_id": 42, "summa": 1000}. Sabab: matn log odam o'qiydi (grep bilan), lekin mashina qiyin qidiradi (matnni tahlil qilish); JSON log — mashina maydonlar bo'yicha qidiradi/filtrlaydi (user_id: 42), tahlil qiladi (agregatsiya). Markazlashgan tizimda (Elasticsearch) tuzilmali log qidiruvni kuchli qiladi (maydon bo'yicha filtr, statistika). Tuzilmali log — mashina uchun (qidiruv, tahlil). JSON — qidiriladigan log.

2.3. Log darajalari (level)

Muhimlik darajasi:

logging.debug("tafsilot")      # rivojlanish (batafsil)
logging.info("normal hodisa")   # odatiy oqim
logging.warning("ehtiyot")      # e'tibor, lekin xato emas
logging.error("xato")           # xato (davom etadi)
logging.critical("halokat")     # jiddiy (tizim xavfda)
# prodda odatda INFO va yuqori (DEBUG ko'p — shovqin)

Log darajalari (levels) — logning muhimlik darajasi: DEBUG (batafsil — rivojlanish, muammo tahlili), INFO (odatiy hodisalar — normal oqim), WARNING (ehtiyot — g'ayrioddiy, lekin xato emas), ERROR (xato — biror amal muvaffaqiyatsiz, lekin tizim davom etadi), CRITICAL (halokat — tizim xavfda). Sabab: har log bir xil emas (tafsilot vs xato) — daraja filtrlash imkonini beradi (prodda INFO va yuqori — DEBUG ko'p, shovqin; muammoda DEBUG yoqiladi). Daraja log hajmini va muhimlilikni boshqaradi. To'g'ri daraja — foydali log. Daraja — muhimlik signali.

2.4. Log yig'ish va saqlash (ELK, Loki)

Log yig'ish va saqlash: yig'uvchi (agent — konteynerlardan/fayllardan loglarni to'playdi: Fluentd, Fluent Bit, Logstash), saqlash (markaziy — barcha log: Elasticsearch (qidiruv indeksi), Loki (yengil, Grafana bilan)), ko'rish (Kibana (Elasticsearch), Grafana (Loki) — qidiruv, filtr, panellar). Mashhur steklar: ELK (Elasticsearch + Logstash + Kibana — kuchli, og'ir), Loki + Grafana (yengil, metrikalar bilan birga). Oqim: xizmat log yozadi → agent yig'adi → markaziy saqlash → ko'rish/qidiruv. Bulut: CloudWatch, Datadog Logs. Stack — loglarni yig'ish, saqlash, ko'rish. Yig'ish → saqlash → qidiruv.

2.5. Correlation ID (so'rovni kuzatish)

Bir so'rovni xizmatlar bo'ylab:

# har so'rovga noyob ID (trace_id / correlation_id)
trace_id = "abc123"
# barcha xizmat shu ID bilan log yozadi
logging.info("so'rov qabul", extra={"trace_id": trace_id})
# → boshqa xizmatga ID uzatiladi (header)
# qidiruv: trace_id=abc123 → butun so'rov yo'li

Correlation ID (bog'lash identifikatori / trace_id) — har so'rovga noyob ID beriladi, u so'rov o'tgan barcha xizmat loglariga qo'shiladi: bir so'rov 10 xizmatdan o'tsa ham, trace_id=abc123 bo'yicha qidiruv butun so'rov yo'lini ko'rsatadi (barcha xizmatdagi loglar, tartibda). Sabab: mikroservisda bir so'rov tarqoq (ko'p xizmat) — correlation ID ularni bog'laydi (qaysi loglar bir so'rovga tegishli). ID so'rov kirganda yaratiladi, xizmatlararo (HTTP header) uzatiladi. Bu tracing 27.9-bob bilan bog'liq. Correlation ID — tarqoq loglarni bir so'rovga bog'lash. Bir ID — butun yo'l.

2.6. Log qidiruv va tahlil

Log qidiruv va tahlil — markazlashgan loglarning asosiy foydasi: qidiruv (maydon bo'yicha — user_id: 42, level: error, trace_id: abc; vaqt oralig'i), filtrlash (faqat xatolar, faqat bir xizmat), agregatsiya (statistika — "soatda nechta xato", "qaysi xizmat ko'p xato"), vizualizatsiya (grafik — xato trendi), ogohlantirish (log asosida — "ERROR ko'paydi"). Tuzilmali log (JSON) buni kuchli qiladi (maydon bo'yicha). Sabab: log — ma'lumot manbai (nima bo'ldi — tahlil, muammo topish); qidiruv/tahlil uni foydali qiladi. Log qidiruv — muammoni topish, tahlil qilish. Qidiruv — loglardan ma'no.

2.7. Logging amaliyoti

Logging amaliyotlari: tuzilmali (JSON — mashina qidiradi); to'g'ri daraja (INFO odatiy, ERROR xato — shovqin emas); kontekst (user_id, trace_id — qidiriladigan); correlation ID (so'rovni kuzatish); sirlarsiz (parol, shaxsiy ma'lumot logga emas — 28.9 xavfsizlik, GDPR); markazlashgan (bir joy — tarqoq emas); saqlash muddati (retention — eski loglar o'chiriladi, joy/xarajat); mazmunli xabar (nima bo'ldi, nima uchun — foydali). Yomon: ko'p shovqin (har narsa DEBUG), sirlar (parol), matn (qidiruv qiyin). Yaxshi log — tuzilmali, kontekstli, sirlarsiz. Amaliyot — foydali log. Kontekstli, tuzilmali — yaxshi log.

2.8. Loglar — observability ning hikoyasi

Loglar observability 28.10-bob ning hikoya ustuni: metrikalar nima (raqamlar — 100 xato), loglar nima bo'ldi (har xatoning tafsiloti — nima, qachon, nima uchun, qanday kontekst), tracing qayerda (qaysi xizmat). Metrika muammoni ko'rsatadi (xatolik oshdi), log uni tushuntiradi (nega — qaysi xato, qaysi foydalanuvchi). Markazlashgan loglar tarqoq tizimda (mikroservis — 27.9) bu hikoyani bir joyga yig'adi. Bu monitoring 28.10-bob, tracing, xato kuzatuvi 28.12-bob bilan to'liq ko'rish. "Log — o'tmishning qora quti yozuvchisi" (nima bo'lganini tiklaydi). Loglar — hodisalar tarixi (tushuntirish). Log — tizim hikoyasi.

3. Tez ma'lumotnoma

import logging, json

# TUZILMALI LOGGING (JSON)
logger = logging.getLogger("app")
logger.info("buyurtma_yaratildi", extra={
    "user_id": 42, "buyurtma_id": 100, "trace_id": "abc123"
})

# DARAJALAR (past → yuqori)
logger.debug(...)     # tafsilot (rivojlanish)
logger.info(...)      # odatiy hodisa
logger.warning(...)   # ehtiyot
logger.error(...)     # xato (davom etadi)
logger.critical(...)  # halokat

# CORRELATION ID: har so'rovga trace_id (xizmatlar bo'ylab)

# STACK:
# yig'ish: Fluentd/Fluent Bit/Logstash
# saqlash: Elasticsearch / Loki
# ko'rish: Kibana / Grafana
# ELK = Elasticsearch + Logstash + Kibana

# QIDIRUV: maydon bo'yicha (user_id:42, level:error, trace_id:abc)
# QOIDA: sirlarsiz (parol, shaxsiy ma'lumot logga EMAS)

Markazlashgan loglar xulosasi

Markazlashgan log — barcha manbadan bir joyga (tarqoq emas)
Tuzilmali (JSON — mashina qidiradi) · darajalar (DEBUG→CRITICAL)
Yig'ish (Fluentd) → saqlash (Elasticsearch/Loki) → ko'rish (Kibana)
Correlation ID (trace_id) — so'rovni xizmatlar bo'ylab kuzatish
Loglar — observability hikoyasi (nima bo'ldi, nima uchun)

4. Batafsil misollar

Misollar sof Python (logging, JSON) bilan log mantiqini ko'rsatadi.

Misol 1 — Tuzilmali log (JSON)

"""Tuzilmali logging: JSON format (mashina maydon bo'yicha qidiradi)."""
import json


class TuzilmaliLogger:
    def __init__(self) -> None:
        self.loglar: list = []

    def log(self, daraja: str, event: str, **kontekst) -> str:
        yozuv = {"level": daraja, "event": event, **kontekst}
        satr = json.dumps(yozuv, ensure_ascii=False, sort_keys=True)
        self.loglar.append(yozuv)
        return satr


def main() -> None:
    logger = TuzilmaliLogger()

    print("=== 1. Tuzilmali log yozish ===")
    satr = logger.log("info", "buyurtma_yaratildi", user_id=42, summa=1000)
    print(f"  {satr}")

    print("\n=== 2. Boshqa hodisalar ===")
    print(f"  {logger.log('error', 'tolov_xatosi', user_id=42, sabab='kam mablag')}")
    print(f"  {logger.log('info', 'login', user_id=99)}")

    print("\n=== 3. Maydon bo'yicha qidiruv (user_id=42) ===")
    topilgan = [l for l in logger.loglar if l.get("user_id") == 42]
    print(f"  user 42 loglari: {len(topilgan)}")

    print("\n=== 4. Level bo'yicha filtr (error) ===")
    xatolar = [l for l in logger.loglar if l["level"] == "error"]
    print(f"  xatolar: {len(xatolar)}")
    print("  matn emas, maydon bo'yicha qidiruv (kuchli)")
    print("  ⭐ Tuzilmali log — mashina qidiradi (JSON)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Tuzilmali log yozish ===
  {"event": "buyurtma_yaratildi", "level": "info", "summa": 1000, "user_id": 42}

=== 2. Boshqa hodisalar ===
  {"event": "tolov_xatosi", "level": "error", "sabab": "kam mablag", "user_id": 42}
  {"event": "login", "level": "info", "user_id": 99}

=== 3. Maydon bo'yicha qidiruv (user_id=42) ===
  user 42 loglari: 2

=== 4. Level bo'yicha filtr (error) ===
  xatolar: 1
  matn emas, maydon bo'yicha qidiruv (kuchli)
  ⭐ Tuzilmali log — mashina qidiradi (JSON)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — Log darajalari (filtrlash)

"""Log darajalari: muhimlikka qarab filtrlash (prodda INFO va yuqori)."""


DARAJALAR = {"debug": 10, "info": 20, "warning": 30, "error": 40, "critical": 50}


class Logger:
    def __init__(self, min_daraja: str = "info") -> None:
        self.min = DARAJALAR[min_daraja]
        self.chiqarilgan: list = []

    def log(self, daraja: str, xabar: str) -> bool:
        # faqat min darajadan yuqori loglar chiqadi
        if DARAJALAR[daraja] >= self.min:
            self.chiqarilgan.append((daraja, xabar))
            return True
        return False   # filtrlanadi (chiqmaydi)


def main() -> None:
    print("=== 1. Prod logger (min: info) ===")
    prod = Logger(min_daraja="info")
    for daraja in ["debug", "info", "warning", "error"]:
        chiqdi = prod.log(daraja, f"{daraja} xabari")
        holat = "chiqdi" if chiqdi else "filtrlandi"
        print(f"  {daraja}: {holat}")

    print("\n=== 2. Chiqarilgan loglar ===")
    print(f"  {len(prod.chiqarilgan)} log (debug filtrlandi)")

    print("\n=== 3. Debug logger (min: debug) ===")
    debug = Logger(min_daraja="debug")
    debug.log("debug", "tafsilot")
    debug.log("info", "hodisa")
    print(f"  chiqarilgan: {len(debug.chiqarilgan)} (debug ham)")

    print("\n=== 4. Nega darajalar ===")
    print("  prodda INFO+ (debug — shovqin)")
    print("  muammoda debug yoqiladi (batafsil)")
    print("  ⭐ Darajalar — muhimlikka qarab filtr")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Prod logger (min: info) ===
  debug: filtrlandi
  info: chiqdi
  warning: chiqdi
  error: chiqdi

=== 2. Chiqarilgan loglar ===
  3 log (debug filtrlandi)

=== 3. Debug logger (min: debug) ===
  chiqarilgan: 2 (debug ham)

=== 4. Nega darajalar ===
  prodda INFO+ (debug — shovqin)
  muammoda debug yoqiladi (batafsil)
  ⭐ Darajalar — muhimlikka qarab filtr

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Correlation ID (so'rovni kuzatish)

"""Correlation ID: bir so'rov trace_id bilan barcha xizmatda kuzatiladi."""


class MarkaziyLog:
    def __init__(self) -> None:
        self.loglar: list = []

    def yoz(self, xizmat: str, trace_id: str, xabar: str) -> None:
        self.loglar.append({"xizmat": xizmat, "trace_id": trace_id, "xabar": xabar})

    def sorov_izi(self, trace_id: str) -> list:
        # bir so'rovning barcha xizmatdagi loglari
        return [l for l in self.loglar if l["trace_id"] == trace_id]


def main() -> None:
    log = MarkaziyLog()

    # so'rov abc123 — bir necha xizmatdan o'tadi
    log.yoz("gateway", "abc123", "so'rov qabul qilindi")
    log.yoz("buyurtma", "abc123", "buyurtma yaratildi")
    log.yoz("tolov", "abc123", "to'lov qayta ishlandi")
    # boshqa so'rov (xyz789)
    log.yoz("gateway", "xyz789", "boshqa so'rov")

    print("=== 1. Barcha loglar (tarqoq) ===")
    print(f"  jami: {len(log.loglar)} log (turli xizmat)")

    print("\n=== 2. Bir so'rov izi (trace_id=abc123) ===")
    iz = log.sorov_izi("abc123")
    for l in iz:
        print(f"  [{l['xizmat']}] {l['xabar']}")

    print("\n=== 3. So'rov yo'li ===")
    yol = " → ".join(l["xizmat"] for l in iz)
    print(f"  {yol}")

    print("\n=== 4. Foyda ===")
    print("  bir qidiruv (trace_id) → butun so'rov yo'li")
    print("  tarqoq loglar bog'landi (bir so'rov)")
    print("  ⭐ Correlation ID — so'rovni kuzatish")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Barcha loglar (tarqoq) ===
  jami: 4 log (turli xizmat)

=== 2. Bir so'rov izi (trace_id=abc123) ===
  [gateway] so'rov qabul qilindi
  [buyurtma] buyurtma yaratildi
  [tolov] to'lov qayta ishlandi

=== 3. So'rov yo'li ===
  gateway → buyurtma → tolov

=== 4. Foyda ===
  bir qidiruv (trace_id) → butun so'rov yo'li
  tarqoq loglar bog'landi (bir so'rov)
  ⭐ Correlation ID — so'rovni kuzatish

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — Log tahlili (agregatsiya)

"""Log tahlili: markaziy loglardan statistika (agregatsiya, muammo topish)."""


def loglarni_tahlil(loglar: list) -> dict:
    natija = {"jami": len(loglar), "darajalar": {}, "xizmatlar": {}}
    for log in loglar:
        daraja = log["level"]
        xizmat = log["xizmat"]
        natija["darajalar"][daraja] = natija["darajalar"].get(daraja, 0) + 1
        natija["xizmatlar"][xizmat] = natija["xizmatlar"].get(xizmat, 0) + 1
    return natija


def main() -> None:
    loglar = [
        {"level": "info", "xizmat": "buyurtma"},
        {"level": "error", "xizmat": "tolov"},
        {"level": "info", "xizmat": "buyurtma"},
        {"level": "error", "xizmat": "tolov"},
        {"level": "error", "xizmat": "tolov"},
        {"level": "warning", "xizmat": "gateway"},
    ]

    tahlil = loglarni_tahlil(loglar)

    print("=== 1. Jami loglar ===")
    print(f"  {tahlil['jami']}")

    print("\n=== 2. Daraja bo'yicha ===")
    for daraja, soni in sorted(tahlil["darajalar"].items()):
        print(f"  {daraja}: {soni}")

    print("\n=== 3. Xizmat bo'yicha ===")
    for xizmat, soni in sorted(tahlil["xizmatlar"].items()):
        print(f"  {xizmat}: {soni}")

    print("\n=== 4. Muammo topish ===")
    eng_kop_xato = max(tahlil["xizmatlar"], key=lambda x: sum(
        1 for l in loglar if l["xizmat"] == x and l["level"] == "error"))
    print(f"  eng ko'p xato: {eng_kop_xato} xizmati")
    print("  markaziy log → statistika → muammo manbai")
    print("  ⭐ Log tahlili — muammoni topish (agregatsiya)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Jami loglar ===
  6

=== 2. Daraja bo'yicha ===
  error: 3
  info: 2
  warning: 1

=== 3. Xizmat bo'yicha ===
  buyurtma: 2
  gateway: 1
  tolov: 3

=== 4. Muammo topish ===
  eng ko'p xato: tolov xizmati
  markaziy log → statistika → muammo manbai
  ⭐ Log tahlili — muammoni topish (agregatsiya)

Nima ko'rsatdi: 2.6-bo'lim.

5. To'g'ri va noto'g'ri tushunishlar

6. Keng tarqalgan xatolar va yechimlari

1. Matn log (qidiruv qiyin)

logging.info(f"User {id} did {action}")   # matn      # ⚠️
logging.info("action", extra={"user": id})   # JSON     # ✅

2. Sirlarni logga yozish

logging.info(f"login: {parol}")   # sir logda!         # ⚠️
logging.info("login", extra={"user_id": id})            # ✅

3. Har narsa bir darajada

logging.info(...)   # xato ham info                     # ⚠️
logging.error(...)   # to'g'ri daraja                    # ✅

4. Correlation ID yo'q

# so'rovni xizmatlar bo'ylab kuzatib bo'lmaydi          # ⚠️
# trace_id (har so'rovga, uzatiladi)                     # ✅

5. Faqat konteyner logi (markazsiz)

# konteyner yiqilsa log yo'qoladi                       # ⚠️
# markaziy yig'ish (Fluentd → Elasticsearch)             # ✅

6. Ko'p shovqin (foydasiz DEBUG)

logging.debug("har o'zgaruvchi")   # shovqin (prodda)   # ⚠️
# INFO+ prodda, DEBUG faqat kerakda                       # ✅

7. Saqlash muddatisiz (cheksiz log)

# loglar abadiy saqlanadi (joy/xarajat)                  # ⚠️
# retention (masalan 30 kun), keyin o'chirish             # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 28.10-dars (o'tilgan): Monitoring — observability
• 28.12-dars: Xatolarni kuzatish (Sentry)
• 27.9-dars (o'tilgan): Mikroservis — tarqoq loglar
• 26-qism (o'tilgan): Logging asoslari
• 28.9-dars (o'tilgan): Sirlar — logga yozmaslik

8. Eng yaxshi amaliyotlar

1. Tuzilmali (JSON — mashina qidiradi).

2. To'g'ri daraja (INFO odatiy, ERROR xato).

3. Kontekst (user_id, trace_id).

4. Correlation ID (so'rovni kuzatish).

5. Sirlarsiz (parol, shaxsiy — logga emas).

6. Markazlashgan (bir joy — Fluentd → ELK).

7. Saqlash muddati (retention).

8. Mazmunli xabar (nima, nima uchun).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # nega markazlashgan loglar?
2.  # tarqoq log muammosi?
3.  # tuzilmali logging nima?
4.  # JSON log nega yaxshi?
5.  # log darajalari qaysi?
6.  # prodda qaysi daraja?
7.  # ELK nima?
8.  # correlation ID nima?
9.  # trace_id nega?
10. # log qidiruv nima?
11. # sirlar logdami?
12. # log vs metrika?

Vazifa 2: Xatolarni tuzating

1.  logging.info(f"User {id}")   # matn

2.  logging.info(f"login: {parol}")   # sir

3.  logging.info(...)   # xato ham info

4.  # correlation ID yo'q

5.  logging.debug(...)   # prodda shovqin

1.  logging.info("event", extra={"user": id})

2.  logging.info("login", extra={"user_id": id})

3.  logging.error(...) (to'g'ri daraja)

4.  trace_id (har request)

5.  INFO+ prodda (DEBUG kerakda)

Vazifa 3: Tuzilmali log

Modellang:

1. JSON
2. Maydonlar
3. Qidiruv
4. Filtr

Vazifa 4: Darajalar

Modellang:

1. Darajalar
2. Min daraja
3. Filtr
4. Prod

Vazifa 5: Correlation ID

Modellang:

1. trace_id
2. Xizmatlar
3. Iz
4. Yo'l

Vazifa 6: Tahlil

Modellang:

1. Loglar
2. Daraja
3. Xizmat
4. Muammo

Vazifa 7: O'ylash

Observability'da metrikalar "nima" (100 xato), loglar "nima bo'ldi" (har xatoning tafsiloti) ni ko'rsatadi. Nima uchun metrikalar va loglar bir-birini to'ldiradi (biri yetmaydi), va nega "correlation ID" (bir so'rovni tarqoq loglar bo'ylab bog'lash) mikroservisda shunchalik muhim — tarqoq tizimda "nima bo'ldi?" savoliga javob berish nega qiyin?

Nimani mustahkamlaydi: 2.5, 2.8-bo'limlar.

Xulosa

Bu darsda markazlashgan loglarni o'rgandik.

Eng muhim uch fikr:

1. Markazlashgan loglar va tuzilmali logging. Markazlashgan loglar — ko'p manbadan loglarni bir joyga yig'ish: zamonaviy tizim ko'p xizmat/server/konteyner (mikroservis) — loglar tarqoq (xato qayerda noma'lum, konteyner yiqilsa log yo'qoladi, so'rov ko'p xizmatdan o'tadi); markazlashgan — bir qidiruv barcha loglar. Tuzilmali logging — loglarni matn emas, tuzilmali (JSON — kalit-qiymat: {"event": "...", "user_id": 42}); mashina maydon bo'yicha qidiradi/filtrlaydi (matn — grep, JSON — kuchli qidiruv, tahlil).

2. Darajalar, stack, correlation ID. Log darajalari — muhimlik: DEBUG (tafsilot), INFO (odatiy), WARNING (ehtiyot), ERROR (xato — davom etadi), CRITICAL (halokat); prodda INFO va yuqori (DEBUG shovqin), daraja filtrlash imkonini beradi. Stack: yig'uvchi (Fluentd, Logstash) → saqlash (Elasticsearch, Loki) → ko'rish (Kibana, Grafana); ELK (Elasticsearch + Logstash + Kibana). Correlation ID (trace_id) — har so'rovga noyob ID, barcha xizmat loglariga qo'shiladi; trace_id bo'yicha qidiruv butun so'rov yo'lini ko'rsatadi (tarqoq loglarni bir so'rovga bog'laydi).

3. Qidiruv, amaliyot, hikoya. Log qidiruv va tahlil — maydon bo'yicha qidiruv (user_id:42, level:error), filtrlash, agregatsiya (statistika — "qaysi xizmat ko'p xato"), muammo topish. Amaliyot: tuzilmali, to'g'ri daraja, kontekst (user_id, trace_id), correlation ID, sirlarsiz (parol/shaxsiy ma'lumot logga emas — 28.9, GDPR), markazlashgan, saqlash muddati. Loglar observability 28.10-bob ning hikoya ustuni: metrikalar nima (raqamlar), loglar nima bo'ldi (tafsilot, sabab), tracing qayerda — metrika ko'rsatadi, log tushuntiradi (bir-birini to'ldiradi, biri yetmaydi). Correlation ID mikroservisda zarur (bir so'rov ko'p xizmatdan — bo'lingan hikoyani butun qiladi). Monitoring 28.10-bob, Sentry 28.12-bob bilan to'liq ko'rish.

Keyingi darsda xatolarni kuzatishni (Sentry) o'rganamiz: ishlab chiqarishdagi xatolarni avtomatik to'plash, guruhlash, ogohlantirish va tahlil qilish — xato monitoringi maxsus vositalar (Sentry) bilan.