28.12-dars: Xatolarni kuzatish (Sentry)

28-QISM — INFRATUZILMA · 12-dars

1. Kirish va motivatsiya

Loglar 28.11-bob hamma narsani yozadi — normal hodisalar, ogohlantirishlar, xatolar. Lekin xatolar maxsus e'tibor talab qiladi: ular buzilishni bildiradi, tez tuzatilishi kerak. Minglab log orasida xatoni topish, uni tushunish (qanday holatda yuz berdi? qaysi foydalanuvchi? stack trace?), takrorlanishini kuzatish (bir xato 1000 marta bo'ldimi yoki bir marta?) — oddiy loglar bilan qiyin. Sentry kabi xato kuzatuv vositalari aynan xatolarga ixtisoslashgan: xatoni avtomatik to'playdi (to'liq kontekst bilan), guruhlaydi (bir xil xatolarni birlashtiradi), ogohlantiradi, tahlil qiladi. Xato kuzatuvi — muammoni tez topish va tuzatish.

Xatolarni kuzatish (error tracking / error monitoring) — ishlab chiqarishdagi xatolarni avtomatik to'plash, guruhlash va tahlil qilish: xato to'plash (istisno yuz berganda avtomatik — Sentry SDK), kontekst (stack trace, foydalanuvchi, so'rov, muhit — to'liq holat), guruhlash (bir xil xatolar bir guruhda — takrorlanish soni), ogohlantirish (yangi/ko'p xato — xabar), tahlil (trend, ta'sirlangan foydalanuvchilar). Mashhur vosita: Sentry (ochiq kodli). Bu observability 28.10-bob ning xatolarga ixtisoslashgan qismi, loglar 28.11-bob, monitoring 28.10-bob ni to'ldiradi. Xato kuzatuvi — xatolarni professional boshqarish. Xato — maxsus e'tibor.

Real vaziyat. Bir tizimda xatolar loglarda "cho'kib ketardi" (minglab log orasida) — dasturchi ular haqida foydalanuvchi shikoyatidan bilardi. Sentry qo'llanildi: har istisno avtomatik Sentry'ga yuborildi (stack trace, foydalanuvchi, so'rov ma'lumoti bilan), bir xil xatolar guruhlandi (takrorlanish soni ko'rindi), yangi xato — darrov Slack xabari. Endi dasturchi xatoni foydalanuvchidan oldin ko'rdi, to'liq kontekst bilan (qanday holat) — tez tuzatdi. Sentry — xatolarni ko'rinadigan qildi.

Bu darsda xatolarni kuzatishni (Sentry) o'rganamiz.

Bu darsda:

• Nega xato kuzatuvi (loglar yetmaydi)
• Xato to'plash va kontekst
• Xatolarni guruhlash
• Ogohlantirish va ustuvorlik
• Sentry integratsiyasi
• Xato tahlili (trend, ta'sir)
• Xato kuzatuv amaliyoti
• Amaliy: xato kuzatuv modeli

ℹ Misollar sof Python bilan xato kuzatuv mantiqini modellashtiradi (deterministik).

2. Nazariya — chuqur tushuntirish

2.1. Nega xato kuzatuvi (loglar yetmaydi)

Xatolar maxsus e'tibor talab qiladi:

Loglar: hamma narsa (normal, ogohlantirish, xato) — aralash
   xato minglab log orasida "cho'kib ketadi"
   guruhlash yo'q (bir xato 1000 marta? bir marta?)

Xato kuzatuvi: faqat xatolar, guruhlangan, kontekst bilan

Nega xato kuzatuvi — loglar hamma narsani yozadi (aralash), lekin xatolar maxsus e'tibor talab qiladi: ular loglarda cho'kib ketadi (minglab yozuv orasida), guruhlanmagan (bir xato 1000 marta bo'ldimi bilib bo'lmaydi), kontekst tarqoq (stack trace, foydalanuvchi alohida). Xato kuzatuvi (Sentry) faqat xatolarga ixtisoslashgan: to'playdi (kontekst bilan), guruhlaydi (takrorlanish), ustuvorlik beradi (ta'sir). Sabab: xato — muammo signali (tez tuzatish kerak) — maxsus vosita samaraliroq (loglar umumiy). Xato kuzatuvi — xatolarga e'tibor. Xato — maxsus muomala.

2.2. Xato to'plash va kontekst

To'liq holat bilan:

# istisno yuz berganda avtomatik to'planadi
try:
    process(order)
except Exception as e:
    # Sentry avtomatik to'playdi:
    # - stack trace (qayerda xato)
    # - foydalanuvchi (kim)
    # - so'rov (qanday)
    # - muhit (prod/staging)
    # - o'zgaruvchilar (holat)
    sentry.capture_exception(e)

Xato to'plash va kontekst — istisno yuz berganda xato avtomatik to'planadi, to'liq kontekst bilan: stack trace (qayerda, qaysi funksiyalar zanjiri), foydalanuvchi (kim ta'sirlandi), so'rov (qanday so'rov — URL, parametrlar), muhit (prod/staging), o'zgaruvchilar (xato paytidagi holat), breadcrumbs (xatodan oldingi hodisalar). Sabab: xatoni tuzatish uchun kontekst kerak (nima uchun yuz berdi — qanday holatda); shunchaki "xato bo'ldi" yetmaydi. Kontekst xatoni takrorlanadigan qiladi (tushunish, tuzatish). To'liq kontekst — tuzatiladigan xato. Kontekst — xato hikoyasi.

2.3. Xatolarni guruhlash

Bir xil xatolarni birlashtirish:

1000 marta bir xil xato (bir bug):
   loglar: 1000 alohida yozuv (shovqin)
   Sentry: 1 guruh (1000 marta yuz berdi)

guruhlash: xato turi + joyi (stack trace) bo'yicha
   → takrorlanish soni, birinchi/oxirgi, trend

Xatolarni guruhlash (grouping) — bir xil xatolarni (bir bug) bir guruhga birlashtirish: bir xato 1000 marta yuz bersa — 1000 alohida yozuv emas, 1 guruh (1000 marta yuz berdi). Guruhlash fingerprint (xato turi + joyi — stack trace) bo'yicha (bir xil xato — bir guruh). Foyda: takrorlanish soni (qanchalik tez-tez), ta'sir (nechta foydalanuvchi), trend (ko'paymoqdami), birinchi/oxirgi. Sabab: guruhlanmagan xatolar — shovqin (1000 yozuv); guruhlangan — aniq (1 bug, 1000 marta). Guruhlash — shovqinni ma'noga aylantirish. Bir bug — bir guruh.

2.4. Ogohlantirish va ustuvorlik

Muhim xatolarga e'tibor:

Ogohlantirish:
   yangi xato (birinchi marta) → xabar
   xato ko'paydi (spike) → xabar
   ko'p foydalanuvchi ta'sirlandi → kritik

Ustuvorlik:
   ta'sir (nechta foydalanuvchi) + tez-tezlik
   → qaysi xatoni avval tuzatish

Ogohlantirish va ustuvorlik: Ogohlantirish — muhim xatolar haqida xabar (yangi xato — birinchi marta ko'rindi, spike — birdan ko'paydi, regressiya — tuzatilgan xato qaytdi); Ustuvorlik — qaysi xatoni avval tuzatish (ta'sir — nechta foydalanuvchi + tez-tezlik — necha marta). Sabab: barcha xato bir xil emas (bir foydalanuvchiga bir marta vs 1000 foydalanuvchiga doim) — ustuvorlik resursni to'g'ri yo'naltiradi (eng ko'p zarar avval). Yaxshi ogohlantirish — amaliy (28.10 — kam shovqin, muhim). Ustuvorlik — eng muhim xatolarga e'tibor. Ta'sir bo'yicha tartiblash.

2.5. Sentry integratsiyasi

# Sentry SDK (o'rnatish va sozlash)
import sentry_sdk
sentry_sdk.init(
    dsn="https://...@sentry.io/...",   # loyiha manzili
    environment="production",           # muhit
    traces_sample_rate=0.1,             # tracing (10%)
)
# endi barcha istisno avtomatik Sentry'ga
# qo'lda ham: sentry_sdk.capture_message("muhim hodisa")

Sentry integratsiyasi — Sentry SDK ilovaga qo'shiladi (sentry_sdk.init — DSN loyiha manzili, muhit): keyin barcha tutilmagan istisno avtomatik Sentry'ga yuboriladi (kontekst bilan). Freymvork integratsiyalari (FastAPI, Django, Flask) — avtomatik (middleware). Qo'lda ham: capture_exception(e) (tutilgan xato), capture_message (muhim hodisa), set_user/set_context (qo'shimcha kontekst). Sozlash: muhit (prod/staging ajratish), sample rate (tracing hajmi), sirlarni filtrlash (28.9 — parol yubormaslik). Integratsiya oddiy (bir necha qator). Sentry — xatolarni avtomatik to'plash. SDK — avtomatik kuzatuv.

2.6. Xato tahlili (trend, ta'sir)

Xato tahlili — xato kuzatuv ma'lumotidan xulosa: trend (xato ko'paymoqdami/kamaymoqdami — deploy'dan keyin oshdi?), ta'sirlangan foydalanuvchilar (nechta — ustuvorlik), regressiya (tuzatilgan xato qaytdi — deploy buzdi), release bo'yicha (qaysi versiyada paydo bo'ldi — 28.6 — deploy bilan bog'lash), eng ko'p xatolar (top — qaysi bug eng zararli). Sabab: xato ma'lumoti tahlil uchun (nafaqat to'plash — tushunish, ustuvorlik, tuzatish). Bu deploy (28.8 — release bilan bog'lash), monitoring (28.10 — trend) bilan bog'liq. Xato tahlili — muammolarni tushunish va ustuvorlash. Ma'lumot — qaror uchun.

2.7. Xato kuzatuv amaliyoti

Xato kuzatuv amaliyotlari: avtomatik to'plash (SDK — tutilmagan istisnolar); kontekst (foydalanuvchi, so'rov — tuzatish uchun); guruhlash (to'g'ri fingerprint — bir bug bir guruh); sirlarsiz (28.9 — parol, shaxsiy ma'lumot Sentry'ga yubormaslik — filtrlash); ustuvorlik (ta'sir bo'yicha — eng zararli avval); release bog'lash (qaysi deploy — 28.6); muhit ajratish (prod/staging alohida); hal qilingan xatolarni yopish (resolved — tozalik). Yomon: har xatoga ogohlantirish (shovqin), sirlar Sentry'da, guruhlanmagan (shovqin). Yaxshi xato kuzatuv — amaliy, kontekstli, sirlarsiz. Amaliyot — foydali xato kuzatuv. Kontekst va ustuvorlik — samarali.

2.8. Xato kuzatuvi — xatolarni ko'rinadigan qilish

Xato kuzatuvi asosiy g'oyasi — xatolarni ko'rinadigan va boshqariladigan qilish: xatolar loglarda cho'kib ketmaydi (ixtisoslashgan vosita), kontekst bilan (tuzatiladigan), guruhlangan (aniq), ustuvorlanogan (eng muhim avval). Bu observability 28.10-bob ning xatolarga fokusi, loglar 28.11-bob, monitoring 28.10-bob ni to'ldiradi (metrika — xatolik oshdi, log — tafsilot, Sentry — guruhlangan, kontekstli xato). Xato kuzatuvi "muammoni foydalanuvchidan oldin ko'rish" (28.10 monitoring bilan). Bu deploy (28.8 — release bog'lash), CI/CD bilan to'liq ishlab chiqarish nazorati. Xato kuzatuvi — xatolarni professional boshqarish (topish, tushunish, tuzatish). Ko'rinadigan xato — tuzatiladigan xato.

3. Tez ma'lumotnoma

# Sentry SDK
import sentry_sdk
sentry_sdk.init(
    dsn="https://...@sentry.io/...",
    environment="production",
    traces_sample_rate=0.1,
)

# avtomatik: barcha tutilmagan istisno → Sentry
# qo'lda:
sentry_sdk.capture_exception(e)          # xato
sentry_sdk.capture_message("hodisa")     # xabar
sentry_sdk.set_user({"id": 42})          # kontekst
sentry_sdk.set_context("order", {...})   # qo'shimcha

# TO'PLANADIGAN KONTEKST:
# stack trace, foydalanuvchi, so'rov, muhit, o'zgaruvchilar, breadcrumbs

# GURUHLASH: fingerprint (xato turi + joyi) → 1 bug 1 guruh
# USTUVORLIK: ta'sir (foydalanuvchi) + tez-tezlik
# QOIDA: sirlarni filtrlash (parol Sentry'ga EMAS)

Xato kuzatuvi xulosasi

Xato kuzatuvi — xatolarni to'plash, guruhlash, tahlil (Sentry)
To'plash: avtomatik + kontekst (stack, user, so'rov, muhit)
Guruhlash: bir bug bir guruh (takrorlanish soni, ta'sir)
Ogohlantirish (yangi, spike) · ustuvorlik (ta'sir bo'yicha)
Sirlarsiz (filtrlash) · release bog'lash (qaysi deploy)

4. Batafsil misollar

Misollar sof Python bilan xato kuzatuv mantiqini modellashtiradi.

Misol 1 — Xato to'plash (kontekst bilan)

"""Xato to'plash: istisno + to'liq kontekst (tuzatish uchun)."""
import traceback


class XatoKuzatuvchi:
    def __init__(self) -> None:
        self.xatolar: list = []

    def capture(self, xato: Exception, kontekst: dict) -> dict:
        yozuv = {
            "tur": type(xato).__name__,
            "xabar": str(xato),
            "kontekst": kontekst,
        }
        self.xatolar.append(yozuv)
        return yozuv


def process_order(order_id: int) -> None:
    if order_id < 0:
        raise ValueError(f"Noto'g'ri buyurtma id: {order_id}")


def main() -> None:
    kuzatuvchi = XatoKuzatuvchi()

    print("=== 1. Xatoni tutish va to'plash ===")
    try:
        process_order(-5)
    except ValueError as e:
        yozuv = kuzatuvchi.capture(e, {
            "user_id": 42, "order_id": -5, "environment": "production"
        })
        print(f"  tur: {yozuv['tur']}")
        print(f"  xabar: {yozuv['xabar']}")

    print("\n=== 2. Kontekst (tuzatish uchun) ===")
    print(f"  foydalanuvchi: {kuzatuvchi.xatolar[0]['kontekst']['user_id']}")
    print(f"  muhit: {kuzatuvchi.xatolar[0]['kontekst']['environment']}")

    print("\n=== 3. Nega kontekst muhim ===")
    print("  'xato bo'ldi' yetmaydi — qanday holatda?")
    print("  user, so'rov, muhit → takrorlanadigan (tuzatish)")

    print("\n=== 4. Avtomatik to'plash ===")
    print(f"  to'plangan xatolar: {len(kuzatuvchi.xatolar)}")
    print("  ⭐ Xato to'plash — to'liq kontekst bilan")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Xatoni tutish va to'plash ===
  tur: ValueError
  xabar: Noto'g'ri buyurtma id: -5

=== 2. Kontekst (tuzatish uchun) ===
  foydalanuvchi: 42
  muhit: production

=== 3. Nega kontekst muhim ===
  'xato bo'ldi' yetmaydi — qanday holatda?
  user, so'rov, muhit → takrorlanadigan (tuzatish)

=== 4. Avtomatik to'plash ===
  to'plangan xatolar: 1
  ⭐ Xato to'plash — to'liq kontekst bilan

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — Xatolarni guruhlash

"""Guruhlash: bir xil xatolar bir guruhda (takrorlanish soni)."""


class XatoGuruhlagich:
    def __init__(self) -> None:
        self.guruhlar: dict = {}   # fingerprint → guruh

    def qosh(self, xato_turi: str, joy: str) -> None:
        # fingerprint: xato turi + joyi
        fingerprint = f"{xato_turi}@{joy}"
        if fingerprint not in self.guruhlar:
            self.guruhlar[fingerprint] = {"soni": 0, "tur": xato_turi, "joy": joy}
        self.guruhlar[fingerprint]["soni"] += 1


def main() -> None:
    guruhlagich = XatoGuruhlagich()

    # bir xato (ValueError@process) 5 marta, boshqasi 2 marta
    for _ in range(5):
        guruhlagich.qosh("ValueError", "process_order")
    for _ in range(2):
        guruhlagich.qosh("KeyError", "get_user")
    guruhlagich.qosh("ValueError", "validate")

    print("=== 1. Guruhlar soni ===")
    print(f"  {len(guruhlagich.guruhlar)} guruh (8 xatodan)")

    print("\n=== 2. Har guruh (takrorlanish) ===")
    for fp, guruh in guruhlagich.guruhlar.items():
        print(f"  {guruh['tur']}@{guruh['joy']}: {guruh['soni']} marta")

    print("\n=== 3. Eng ko'p takrorlangan ===")
    eng = max(guruhlagich.guruhlar.values(), key=lambda g: g["soni"])
    print(f"  {eng['tur']}@{eng['joy']}: {eng['soni']} marta")

    print("\n=== 4. Guruhlash foydasi ===")
    print("  8 xato → 3 guruh (aniq, shovqin emas)")
    print("  1 bug = 1 guruh (takrorlanish ko'rinadi)")
    print("  ⭐ Guruhlash — bir bug bir guruh")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Guruhlar soni ===
  3 guruh (8 xatodan)

=== 2. Har guruh (takrorlanish) ===
  ValueError@process_order: 5 marta
  KeyError@get_user: 2 marta
  ValueError@validate: 1 marta

=== 3. Eng ko'p takrorlangan ===
  ValueError@process_order: 5 marta

=== 4. Guruhlash foydasi ===
  8 xato → 3 guruh (aniq, shovqin emas)
  1 bug = 1 guruh (takrorlanish ko'rinadi)
  ⭐ Guruhlash — bir bug bir guruh

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Ustuvorlik (ta'sir bo'yicha)

"""Ustuvorlik: xatolarni ta'sir (foydalanuvchi) va tez-tezlik bo'yicha tartiblash."""


def ustuvorlik_bali(xato: dict) -> int:
    # ta'sir = foydalanuvchilar soni * takrorlanish
    return xato["foydalanuvchilar"] * xato["takrorlanish"]


def main() -> None:
    xatolar = [
        {"nom": "TolovXatosi", "foydalanuvchilar": 100, "takrorlanish": 500},
        {"nom": "AvatarXatosi", "foydalanuvchilar": 2, "takrorlanish": 3},
        {"nom": "LoginXatosi", "foydalanuvchilar": 50, "takrorlanish": 200},
    ]

    print("=== 1. Xatolar (ta'sir) ===")
    for x in xatolar:
        print(f"  {x['nom']}: {x['foydalanuvchilar']} user, {x['takrorlanish']} marta")

    print("\n=== 2. Ustuvorlik bali ===")
    for x in xatolar:
        print(f"  {x['nom']}: {ustuvorlik_bali(x)} (user * takror)")

    print("\n=== 3. Ustuvorlik tartibi ===")
    tartibli = sorted(xatolar, key=ustuvorlik_bali, reverse=True)
    for i, x in enumerate(tartibli, 1):
        print(f"  {i}. {x['nom']} ({ustuvorlik_bali(x)})")

    print("\n=== 4. Qaysi avval tuzatish ===")
    print(f"  {tartibli[0]['nom']} — eng katta ta'sir (avval)")
    print(f"  {tartibli[-1]['nom']} — kichik (keyin)")
    print("  ⭐ Ustuvorlik — eng zararli avval")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Xatolar (ta'sir) ===
  TolovXatosi: 100 user, 500 marta
  AvatarXatosi: 2 user, 3 marta
  LoginXatosi: 50 user, 200 marta

=== 2. Ustuvorlik bali ===
  TolovXatosi: 50000 (user * takror)
  AvatarXatosi: 6 (user * takror)
  LoginXatosi: 10000 (user * takror)

=== 3. Ustuvorlik tartibi ===
  1. TolovXatosi (50000)
  2. LoginXatosi (10000)
  3. AvatarXatosi (6)

=== 4. Qaysi avval tuzatish ===
  TolovXatosi — eng katta ta'sir (avval)
  AvatarXatosi — kichik (keyin)
  ⭐ Ustuvorlik — eng zararli avval

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Release bo'yicha xato (regressiya)

"""Release bog'lash: xato qaysi versiyada paydo bo'ldi (deploy bilan)."""


class ReleaseKuzatuvchi:
    def __init__(self) -> None:
        self.xatolar: list = []

    def xato_qayd(self, xato: str, versiya: str) -> None:
        self.xatolar.append({"xato": xato, "versiya": versiya})

    def versiya_boyicha(self) -> dict:
        natija: dict = {}
        for x in self.xatolar:
            natija.setdefault(x["versiya"], []).append(x["xato"])
        return natija


def main() -> None:
    kuzatuvchi = ReleaseKuzatuvchi()

    # v1.0 — 1 xato, v1.1 — yangi xatolar (regressiya?)
    kuzatuvchi.xato_qayd("EskiXato", "v1.0")
    kuzatuvchi.xato_qayd("YangiXato1", "v1.1")
    kuzatuvchi.xato_qayd("YangiXato2", "v1.1")
    kuzatuvchi.xato_qayd("YangiXato1", "v1.1")

    versiyalar = kuzatuvchi.versiya_boyicha()

    print("=== 1. Versiya bo'yicha xatolar ===")
    for versiya, xatolar in sorted(versiyalar.items()):
        print(f"  {versiya}: {len(xatolar)} xato")

    print("\n=== 2. v1.1 yangi xatolari ===")
    v10_xatolar = set(versiyalar.get("v1.0", []))
    v11_xatolar = set(versiyalar.get("v1.1", []))
    yangi = v11_xatolar - v10_xatolar
    print(f"  yangi xatolar: {sorted(yangi)}")

    print("\n=== 3. Regressiya signali ===")
    print(f"  v1.1 deploy'dan keyin {len(yangi)} yangi xato turi")
    print("  → v1.1 deploy'i muammo keltirdi (rollback?)")

    print("\n=== 4. Release bog'lash foydasi ===")
    print("  xato qaysi versiyada paydo (deploy bilan)")
    print("  regressiya darrov (deploy'ni ayblash)")
    print("  ⭐ Release bog'lash — xato manbaini topish")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Versiya bo'yicha xatolar ===
  v1.0: 1 xato
  v1.1: 3 xato

=== 2. v1.1 yangi xatolari ===
  yangi xatolar: ['YangiXato1', 'YangiXato2']

=== 3. Regressiya signali ===
  v1.1 deploy'dan keyin 2 yangi xato turi
  → v1.1 deploy'i muammo keltirdi (rollback?)

=== 4. Release bog'lash foydasi ===
  xato qaysi versiyada paydo (deploy bilan)
  regressiya darrov (deploy'ni ayblash)
  ⭐ Release bog'lash — xato manbaini topish

Nima ko'rsatdi: 2.6-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. Xatolar faqat loglarda (guruhlanmagan)

logging.error(e)   # minglab log orasida           # ⚠️
sentry_sdk.capture_exception(e)   # guruhlangan     # ✅

2. Kontekstsiz xato

capture_exception(e)   # faqat xato                 # ⚠️
set_user({"id": 42}); set_context(...); capture()   # ✅

3. Sirlarni Sentry'ga yuborish

set_context("user", {"password": p})   # sir!       # ⚠️
# sirlarni filtrlash (before_send hook)              # ✅

4. Har xatoga ogohlantirish (shovqin)

# har xato → Slack (100 xabar/kun)                  # ⚠️
# muhim (yangi, spike, ko'p ta'sir)                  # ✅

5. Guruhlash noto'g'ri (fingerprint)

# har xato alohida (dinamik xabar → yangi guruh)    # ⚠️
# barqaror fingerprint (bir bug bir guruh)           # ✅

6. Release bog'lanmagan

# xato qaysi deploy'dan? noma'lum                    # ⚠️
init(release="v1.2.3")   # release bog'lash           # ✅

7. Hal qilingan xatolarni yopmaslik

# tuzatilgan xato hali "faol" (shovqin)              # ⚠️
# resolved deb belgilash (qaytsa — ogohlantirish)     # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 28.10-dars (o'tilgan): Monitoring — metrikalar
• 28.11-dars (o'tilgan): Loglar — kontekst
• 28.8-dars (o'tilgan): CD — release bog'lash
• 09-dars (o'tilgan): Xatolar — istisnolar
• 28.9-dars (o'tilgan): Sirlar — filtrlash

8. Eng yaxshi amaliyotlar

1. Avtomatik to'plash (SDK — tutilmagan istisno).

2. Kontekst (foydalanuvchi, so'rov — tuzatish).

3. Guruhlash (barqaror fingerprint).

4. Sirlarsiz (filtrlash — parol emas).

5. Ustuvorlik (ta'sir bo'yicha).

6. Release bog'lash (qaysi deploy).

7. Muhit ajratish (prod/staging).

8. Hal qilinganni yopish (resolved).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # nega xato kuzatuvi?
2.  # loglar nega yetmaydi?
3.  # xato to'plash nima?
4.  # qanday kontekst?
5.  # guruhlash nima?
6.  # fingerprint nima?
7.  # ustuvorlik nima?
8.  # ogohlantirish qachon?
9.  # Sentry nima?
10. # release bog'lash nima?
11. # sirlar Sentry'dami?
12. # xato kuzatuvi vs log?

Vazifa 2: Xatolarni tuzating

1.  logging.error(e)   # loglarda

2.  capture_exception(e)   # kontekstsiz

3.  set_context({"password": p})   # sir

4.  # har xato → Slack

5.  init()   # release yo'q

1.  sentry_sdk.capture_exception(e)

2.  set_user, set_context + capture

3.  sirlarni filtrlash (before_send)

4.  muhim (yangi, spike)

5.  init(release="v1.2.3")

Vazifa 3: To'plash

Modellang:

1. Istisno
2. Kontekst
3. To'plash
4. Foydalanuvchi

Vazifa 4: Guruhlash

Modellang:

1. Fingerprint
2. Guruhlar
3. Takrorlanish
4. Eng ko'p

Vazifa 5: Ustuvorlik

Modellang:

1. Ta'sir
2. Tez-tezlik
3. Bal
4. Tartib

Vazifa 6: Release

Modellang:

1. Versiyalar
2. Xatolar
3. Yangi
4. Regressiya

Vazifa 7: O'ylash

Xato kuzatuvi (Sentry) loglardan farqli — u xatolarga ixtisoslashgan (guruhlash, kontekst, ustuvorlik). Nima uchun "umumiy vosita" (loglar) va "ixtisoslashgan vosita" (xato kuzatuvi) ikkalasi ham kerak (biri boshqasini almashtirmaydi), va nega "xatoni guruhlash" (1000 yozuv → 1 bug) shunchalik muhim — bu inson e'tibori haqida nima aytadi?

Nimani mustahkamlaydi: 2.1, 2.3-bo'limlar.

Xulosa

Bu darsda xatolarni kuzatishni (Sentry) o'rgandik.

Eng muhim uch fikr:

1. Nega xato kuzatuvi va to'plash. Xato kuzatuvi — xatolarni maxsus boshqarish: loglar hamma narsani yozadi (aralash — xato cho'kib ketadi, guruhlanmagan, kontekst tarqoq), xato kuzatuvi (Sentry) faqat xatolarga ixtisoslashgan (to'playdi, guruhlaydi, ustuvorlik). Xato to'plash — istisno yuz berganda avtomatik, to'liq kontekst bilan: stack trace (qayerda), foydalanuvchi (kim), so'rov (qanday), muhit (prod/staging), o'zgaruvchilar, breadcrumbs; kontekst xatoni takrorlanadigan qiladi (tushunish, tuzatish — "xato bo'ldi" yetmaydi).

2. Guruhlash, ustuvorlik, integratsiya. Guruhlash — bir xil xatolarni (bir bug) bir guruhga (1000 marta → 1 guruh, 1000 marta yuz berdi); fingerprint (xato turi + joyi) bo'yicha; takrorlanish soni, ta'sir, trend. Ustuvorlik — qaysi xatoni avval (ta'sir — nechta foydalanuvchi + tez-tezlik); eng ko'p zarar avval. Ogohlantirish — muhim xatolar (yangi, spike, regressiya). Sentry integratsiyasi — SDK (sentry_sdk.init — DSN, muhit), barcha tutilmagan istisno avtomatik; qo'lda capture_exception, set_user/set_context; sirlarni filtrlash.

3. Tahlil, amaliyot, ko'rinadigan xato. Xato tahlili — trend (deploy'dan keyin oshdi?), ta'sirlangan foydalanuvchilar, regressiya, release bog'lash (qaysi versiyada paydo — 28.6 deploy bilan). Amaliyot: avtomatik to'plash, kontekst, guruhlash, sirlarsiz (28.9 — filtrlash), ustuvorlik, release bog'lash, muhit ajratish, hal qilinganni yopish. Xato kuzatuvi xatolarni ko'rinadigan va boshqariladigan qiladi (observability 28.10 ning xatolarga fokusi; loglar 28.11, monitoring 28.10 ni to'ldiradi — metrika xatolik ko'rsatadi, log tafsilot, Sentry guruhlangan kontekstli xato). "Umumiy" (loglar) va "ixtisoslashgan" (xato kuzatuvi) ikkalasi kerak (turli maqsad); guruhlash "1000 → 1" — inson e'tiboriga ma'lumotni moslash (signal vs shovqin — cheklangan idrokga hurmat).

Keyingi darsda Cloud (AWS/GCP asoslari) ni o'rganamiz: bulut hisoblash tushunchasi, asosiy xizmatlar (hisoblash, saqlash, baza, tarmoq), boshqariladigan xizmatlar va bulut nima uchun zamonaviy infratuzilmaning asosiga aylanganini.