28.10-dars: Monitoring va metrikalar

28-QISM — INFRATUZILMA · 10-dars

1. Kirish va motivatsiya

Ilova prodda ishlayapti — lekin qanday ishlayapti? Tez javob berayaptimi yoki sekinlashganmi? Xatolar bormi? Yuk qancha? Server resurslari yetarlimi? Bularni bilmasdan — siz ko'r uchuvchisiz (samolyot uchmoqda, lekin asboblar yo'q). Muammo foydalanuvchi shikoyat qilgandan keyin ("sayt ishlamayapti!") ma'lum bo'ladi — kech. Monitoring tizimni doimiy kuzatadi: metrikalar yig'adi (so'rovlar soni, javob vaqti, xatolik foizi), ko'rsatadi (grafiklar), ogohlantiradi (muammo bo'lsa xabar). Monitoring — muammoni foydalanuvchidan oldin, hatto oldindan ko'rish. Ko'rinmas tizim — boshqarib bo'lmaydi; monitoring uni ko'rinadigan qiladi.

Monitoring va metrikalar — ishlab chiqarishdagi tizimni kuzatish: metrikalar (o'lchanadigan qiymatlar — so'rovlar soni, javob vaqti, xatolik, CPU/xotira), turlari (counter — o'suvchi hisoblagich; gauge — joriy qiymat; histogram — taqsimot), yig'ish (Prometheus — metrikalarni to'playdi), vizualizatsiya (Grafana — grafiklar, panellar), ogohlantirish (alerting — chegaradan oshsa xabar). Kengroq tushuncha: observability (kuzatiluvchanlik — tizim ichida nima bo'layotganini tushunish: metrikalar, loglar, tracing). Bu CD (28.8 — deploy kuzatuvi), chidamlilik 27.12-bob bilan bog'liq. Monitoring — tizimni ko'rinadigan qilish. Metrika — tizim salomatligi.

Real vaziyat. Bir tizim ba'zan sekinlashardi, lekin sabab noma'lum edi (qachon, nega?). Monitoring qo'llanildi: Prometheus metrikalarni yig'di (javob vaqti, so'rovlar, xatolik), Grafana grafiklarni ko'rsatdi, ogohlantirish sozlandi (javob vaqti 1s dan oshsa — xabar). Ma'lum bo'ldi: har kuni soat 18:00da yuk oshib, baza sekinlashardi. Sabab ko'rindi (grafikda), tuzatildi (baza optimizatsiyasi). Endi muammo darrov (ogohlantirish), foydalanuvchidan oldin. Monitoring — ko'rinmasni ko'rinadigan qildi.

Bu darsda monitoring va metrikalarni o'rganamiz.

Bu darsda:

• Nega monitoring
• Metrika turlari (counter, gauge, histogram)
• Asosiy metrikalar (RED, USE)
• Yig'ish va vizualizatsiya (Prometheus, Grafana)
• Ogohlantirish (alerting)
• Observability (kuzatiluvchanlik)
• Monitoring amaliyoti
• Amaliy: metrikalar modeli

ℹ Misollar sof Python bilan metrika mantiqini modellashtiradi (deterministik).

2. Nazariya — chuqur tushuntirish

2.1. Nega monitoring

Ko'rinmasni ko'rinadigan qilish:

Monitoringsiz: tizim "qora quti" (ichida nima?)
   muammo foydalanuvchi shikoyatidan ma'lum (kech)

Monitoring bilan: metrikalar, grafiklar, ogohlantirish
   muammo darrov (hatto oldindan) ko'rinadi

Nega monitoring — ishlab chiqarishdagi tizim ko'rinmas (ichida nima bo'layotgani noma'lum) — monitoring uni ko'rinadigan qiladi: metrikalar yig'adi (so'rov, vaqt, xato), ko'rsatadi (grafik), ogohlantiradi (muammo). Sabab: monitoringsiz muammo foydalanuvchi shikoyatidan bilinadi (kech, zarar yetgan); monitoring bilan — muammo darrov (ogohlantirish), hatto oldindan (trend — "xotira to'lmoqda" — yiqilishdan oldin). "O'lchamasang — boshqarolmaysan" — monitoring boshqaruv asosi. Monitoring — tizim salomatligini kuzatish. Ko'rinadigan tizim — boshqariladigan tizim.

2.2. Metrika turlari (counter, gauge, histogram)

Uch asosiy tur:

# COUNTER — faqat o'suvchi (jami so'rovlar, xatolar)
sorovlar_soni += 1        # kamaymaydi

# GAUGE — joriy qiymat (o'sadi/kamayadi)
faol_ulanishlar = 42      # hozirgi holat

# HISTOGRAM — taqsimot (javob vaqti bo'yicha)
# [0-100ms: 500, 100-500ms: 200, 500ms+: 10]

Metrika turlari: Counter (hisoblagich) — faqat o'suvchi qiymat (jami so'rovlar, jami xatolar — kamaymaydi, faqat oshadi; tezlik — hosila hisoblanadi); Gauge (o'lchagich) — joriy qiymat (o'sadi va kamayadi — faol ulanishlar, xotira, navbat uzunligi — hozirgi holat); Histogram (gistogramma) — qiymatlar taqsimoti (javob vaqti "bucket"lari — 0-100ms nechta, 100-500ms nechta; foizli — p50, p95, p99). Har tur bir jihatni o'lchaydi: counter (jami hodisa), gauge (joriy holat), histogram (taqsimot). To'g'ri tur — to'g'ri o'lchov. Metrika turlari — o'lchash usullari. Har biri bir savol.

2.3. Asosiy metrikalar (RED, USE)

Nima o'lchash kerak:

RED (xizmat uchun):
   Rate — so'rovlar tezligi (soniyada nechta)
   Errors — xatolik foizi
   Duration — javob vaqti (latency)

USE (resurs uchun):
   Utilization — foydalanish (CPU %, xotira %)
   Saturation — to'yinganlik (navbat, kutish)
   Errors — apparat/tizim xatolari

Asosiy metrikalar — nima o'lchash kerakligini tizimlashtirish: RED (xizmat — so'rovga javob beruvchi uchun): Rate (so'rovlar tezligi — yuk), Errors (xatolik foizi — sifat), Duration (javob vaqti — tezlik); USE (resurs — CPU, disk uchun): Utilization (foydalanish %), Saturation (to'yinganlik — navbat, ortiqcha yuk), Errors (xatolar). Sabab: hamma narsani o'lchash — shovqin (foydasiz); RED/USE — muhim metrikalarni ajratadi (nima haqiqatan tizim salomatligini ko'rsatadi). RED — foydalanuvchi tajribasi (tez, xatosiz), USE — resurs holati. Asosiy metrikalar — muhimni o'lchash. Nima muhim — RED/USE.

2.4. Yig'ish va vizualizatsiya (Prometheus, Grafana)

Yig'ish va vizualizatsiya: Prometheus — metrikalarni yig'ish tizimi (ilovalardan metrikalarni "tortadi" — pull, saqlaydi — vaqt qatorlari time-series, so'rov tili — PromQL); ilova metrikalarni ochib qo'yadi (/metrics endpoint — prometheus_client kutubxonasi). Grafana — metrikalarni ko'rsatish (grafiklar, panellar, dashboard — javob vaqti grafigi, xatolik grafigi; real vaqtda). Oqim: ilova metrikalarni ochadi → Prometheus yig'adi → Grafana ko'rsatadi. Boshqalar: Datadog, New Relic (bulut, birlashtirilgan). Bu monitoring stacki (yig'ish + saqlash + ko'rsatish). Prometheus/Grafana — mashhur, ochiq kodli. Yig'ish + ko'rsatish — monitoring tizimi.

2.5. Ogohlantirish (alerting)

Muammo bo'lsa xabar:

# ogohlantirish qoidasi
if xatolik_foizi > 5:              # chegara
    ogohlantir("Xatolik yuqori!")   # email, Slack, PagerDuty

# yaxshi ogohlantirish:
# - amaliy (harakat talab qiladi)
# - kam yolg'on signal (shovqin emas)
# - muhimlilik darajasi (kritik vs ogohlantirish)

Ogohlantirish (alerting) — metrika chegaradan oshsa avtomatik xabar (email, Slack, PagerDuty — navbatchi dasturchiga): xatolik 5% dan oshdi, javob vaqti 1s dan oshdi, disk 90% to'ldi. Sabab: hech kim grafiklarga doim qaramaydi — ogohlantirish muammoni itaradi (dasturchiga xabar, ayniqsa kechasi). Yaxshi ogohlantirish: amaliy (harakat talab qiladi — "disk to'lyapti, tozala"; foydasiz — "CPU 60%"), kam yolg'on signal (shovqin — e'tibor yo'qoladi, "bo'ri!" sindromi), darajali (kritik — darrov; ogohlantirish — keyin). Yomon ogohlantirish (ko'p, foydasiz) — e'tiborsiz qolinadi. Ogohlantirish — muammoni yetkazish (amaliy, kam shovqin). Xabar — harakat uchun.

2.6. Observability (kuzatiluvchanlik)

Uch ustun:

Observability (kuzatiluvchanlik) — 3 ustun:
   Metrikalar — nima (raqamlar: so'rov, vaqt, xato)
   Loglar — nima bo'ldi (hodisalar, tafsilot)
   Tracing — qayerda (so'rov qaysi xizmatdan o'tdi)
   birga: "nima, nima uchun, qayerda" — to'liq ko'rish

Observability (kuzatiluvchanlik) — tizim ichida nima bo'layotganini tushunish qobiliyati, uch ustun: Metrikalar (raqamlar — nima: so'rov soni, vaqt, xatolik — umumiy holat); Loglar (hodisalar — nima bo'ldi: xato tafsiloti, hodisalar — 26-qism); Tracing (izlash — qayerda: so'rov qaysi xizmatlardan o'tdi, qaysi sekin — 27.9 taqsimlangan). Farqi monitoring'dan: monitoring — ma'lum muammolarni kuzatish (chegaralar), observability — noma'lum muammolarni tushunish (nega sekin? — chuqur tahlil). Uch ustun birga — to'liq ko'rish (nima, nima uchun, qayerda). Observability — tizimni chuqur tushunish. Uch ustun — to'liq ko'rinish.

2.7. Monitoring amaliyoti

Monitoring amaliyotlari: RED/USE o'lcha (muhim metrikalar — hamma narsa emas); amaliy ogohlantirish (harakat talab, kam shovqin); dashboard (asosiy metrikalar bir joyda — tez ko'rish); SLO/SLI (Service Level Objective — maqsad: "99.9% so'rov 200ms dan tez"; o'lchanadigan); deploy kuzatuvi (28.8 — chiqarishdan keyin metrikalar); trend (o'sish — "xotira asta to'lmoqda" — yiqilishdan oldin); foydalanuvchi nuqtai nazari (RED — foydalanuvchi tajribasi, nafaqat server). Yaxshi monitoring — muhim, amaliy, oldindan ogohlantiruvchi. Amaliyot — foydali kuzatuv (shovqin emas). Muhim va amaliy — yaxshi monitoring.

2.8. Monitoring — o'lchash va boshqarish

Monitoring asosiy g'oyasi — "o'lchamasang — boshqarolmaysan": tizimni o'lchash (metrikalar) uni ko'rinadigan (grafiklar), boshqariladigan (ogohlantirish, qaror) qiladi. Bu ilovaning ishlab chiqarishdagi hayotini kuzatadi (kod yozildi — 27-qism, deploy qilindi — 28.6-8, endi kuzatiladi). Monitoring CD (28.8 — avtomatik rollback metrikaga asoslanadi), chidamlilik (27.12 — muammoni ko'rish), miqyoslash (29-qism — yukni o'lchash) uchun asos. "Kechqurun uxlash uchun monitoring" (muammo bo'lsa xabar, doim qarab turish shart emas). Observability — zamonaviy, murakkab tizimlar uchun zarur (mikroservis — ko'p qism). Monitoring — tizimni ko'rish va boshqarish. O'lchash — boshqaruvning asosi.

3. Tez ma'lumotnoma

# METRIKA TURLARI
sorovlar = Counter()      # o'suvchi (jami so'rov, xato)
ulanishlar = Gauge()      # joriy (o'sadi/kamayadi)
vaqt = Histogram()        # taqsimot (p50, p95, p99)

# RED (xizmat): Rate, Errors, Duration
# USE (resurs): Utilization, Saturation, Errors

# prometheus_client (Python):
from prometheus_client import Counter, Histogram
SOROV = Counter("sorovlar_jami", "Jami so'rovlar")
VAQT = Histogram("javob_vaqti", "Javob vaqti")
SOROV.inc()               # counter oshirish
VAQT.observe(0.25)        # histogramga qiymat

# OGOHLANTIRISH: chegara → xabar (amaliy, kam shovqin)
# OBSERVABILITY: metrikalar + loglar + tracing

# STACK: Prometheus (yig'ish) + Grafana (ko'rsatish)
# SLO: "99.9% so'rov 200ms dan tez"

Monitoring xulosasi

Monitoring — tizimni kuzatish (ko'rinmasni ko'rinadigan)
Metrika: counter (o'suvchi), gauge (joriy), histogram (taqsimot)
RED (rate, errors, duration) · USE (utilization, saturation)
Prometheus (yig'ish) + Grafana (ko'rsatish) · alerting (xabar)
Observability: metrikalar + loglar + tracing (to'liq ko'rish)

4. Batafsil misollar

Misollar sof Python bilan metrika mantiqini modellashtiradi.

Misol 1 — Metrika turlari (counter, gauge, histogram)

"""Metrika turlari: counter (o'suvchi), gauge (joriy), histogram (taqsimot)."""


class Metrikalar:
    def __init__(self) -> None:
        self.sorovlar = 0            # counter
        self.faol_ulanishlar = 0     # gauge
        self.vaqt_bucketlari = {"0-100ms": 0, "100-500ms": 0, "500ms+": 0}  # histogram

    def sorov_qayd(self, javob_vaqti_ms: float) -> None:
        self.sorovlar += 1           # counter oshadi
        # histogramga joylash
        if javob_vaqti_ms < 100:
            self.vaqt_bucketlari["0-100ms"] += 1
        elif javob_vaqti_ms < 500:
            self.vaqt_bucketlari["100-500ms"] += 1
        else:
            self.vaqt_bucketlari["500ms+"] += 1

    def ulanish(self, ochildi: bool) -> None:
        self.faol_ulanishlar += 1 if ochildi else -1   # gauge


def main() -> None:
    m = Metrikalar()

    # so'rovlarni qayd qilamiz
    for vaqt in [50, 80, 150, 300, 600, 90, 200]:
        m.sorov_qayd(vaqt)

    print("=== 1. Counter (jami so'rovlar) ===")
    print(f"  sorovlar: {m.sorovlar} (faqat o'sadi)")

    print("\n=== 2. Gauge (faol ulanishlar) ===")
    m.ulanish(True)
    m.ulanish(True)
    m.ulanish(False)
    print(f"  faol ulanishlar: {m.faol_ulanishlar} (o'sadi/kamayadi)")

    print("\n=== 3. Histogram (javob vaqti taqsimoti) ===")
    for bucket, soni in m.vaqt_bucketlari.items():
        print(f"  {bucket}: {soni}")

    print("\n=== 4. Har tur — o'z savoli ===")
    print("  counter: jami nechta? gauge: hozir nechta?")
    print("  histogram: qanday taqsimlangan?")
    print("  ⭐ Metrika turlari — turli o'lchovlar")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Counter (jami so'rovlar) ===
  sorovlar: 7 (faqat o'sadi)

=== 2. Gauge (faol ulanishlar) ===
  faol ulanishlar: 1 (o'sadi/kamayadi)

=== 3. Histogram (javob vaqti taqsimoti) ===
  0-100ms: 3
  100-500ms: 3
  500ms+: 1

=== 4. Har tur — o'z savoli ===
  counter: jami nechta? gauge: hozir nechta?
  histogram: qanday taqsimlangan?
  ⭐ Metrika turlari — turli o'lchovlar

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — RED metrikalari (rate, errors, duration)

"""RED: xizmat salomatligi — so'rov tezligi, xatolik, javob vaqti."""


class REDMetrikalar:
    def __init__(self) -> None:
        self.jami_sorov = 0
        self.xatolar = 0
        self.vaqtlar: list = []

    def qayd(self, muvaffaqiyat: bool, vaqt_ms: float) -> None:
        self.jami_sorov += 1
        if not muvaffaqiyat:
            self.xatolar += 1
        self.vaqtlar.append(vaqt_ms)

    def hisobot(self) -> dict:
        return {
            "rate": self.jami_sorov,
            "errors_foiz": round(self.xatolar / self.jami_sorov * 100, 1) if self.jami_sorov else 0,
            "avg_duration": round(sum(self.vaqtlar) / len(self.vaqtlar), 1) if self.vaqtlar else 0,
            "max_duration": max(self.vaqtlar) if self.vaqtlar else 0,
        }


def main() -> None:
    red = REDMetrikalar()

    # so'rovlar (muvaffaqiyat, vaqt)
    sorovlar = [(True, 50), (True, 80), (False, 200), (True, 120),
                (True, 90), (False, 500), (True, 70)]
    for muvaffaqiyat, vaqt in sorovlar:
        red.qayd(muvaffaqiyat, vaqt)

    hisobot = red.hisobot()

    print("=== 1. Rate (so'rovlar) ===")
    print(f"  jami so'rov: {hisobot['rate']}")

    print("\n=== 2. Errors (xatolik foizi) ===")
    print(f"  xatolik: {hisobot['errors_foiz']}%")

    print("\n=== 3. Duration (javob vaqti) ===")
    print(f"  o'rtacha: {hisobot['avg_duration']}ms")
    print(f"  eng katta: {hisobot['max_duration']}ms")

    print("\n=== 4. RED — foydalanuvchi tajribasi ===")
    print("  rate (yuk), errors (sifat), duration (tezlik)")
    print("  tizim foydalanuvchi uchun qanday ishlayapti")
    print("  ⭐ RED — xizmat salomatligi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Rate (so'rovlar) ===
  jami so'rov: 7

=== 2. Errors (xatolik foizi) ===
  xatolik: 28.6%

=== 3. Duration (javob vaqti) ===
  o'rtacha: 158.6ms
  eng katta: 500ms

=== 4. RED — foydalanuvchi tajribasi ===
  rate (yuk), errors (sifat), duration (tezlik)
  tizim foydalanuvchi uchun qanday ishlayapti
  ⭐ RED — xizmat salomatligi

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Persentil (p50, p95, p99)

"""Persentil: javob vaqti taqsimoti — o'rtacha yashiradi, persentil ochadi."""


def persentil(vaqtlar: list, p: int) -> float:
    tartibli = sorted(vaqtlar)
    indeks = min(int(len(tartibli) * p / 100), len(tartibli) - 1)
    return tartibli[indeks]


def main() -> None:
    # ko'p tez, bir necha sekin (real vaziyat)
    vaqtlar = [50, 55, 60, 52, 58, 51, 54, 900, 53, 950]

    print("=== 1. Javob vaqtlari ===")
    print(f"  {vaqtlar}")

    print("\n=== 2. O'rtacha (yashiradi) ===")
    ortacha = sum(vaqtlar) / len(vaqtlar)
    print(f"  o'rtacha: {ortacha:.0f}ms")
    print("  o'rtacha 'yaxshi' ko'rinadi (sekin so'rovlarni yashiradi)")

    print("\n=== 3. Persentillar (ochadi) ===")
    print(f"  p50 (median): {persentil(vaqtlar, 50):.0f}ms (ko'pchilik tez)")
    print(f"  p95: {persentil(vaqtlar, 95):.0f}ms (95% shu vaqtda)")
    print(f"  p99: {persentil(vaqtlar, 99):.0f}ms (eng sekin 1%)")

    print("\n=== 4. Nega persentil muhim ===")
    print("  p50 tez, lekin p99 sekin (ba'zi foydalanuvchi azob chekadi)")
    print("  o'rtacha yashiradi, persentil haqiqatni ko'rsatadi")
    print("  ⭐ Persentil — taqsimotni ochadi (o'rtacha emas)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Javob vaqtlari ===
  [50, 55, 60, 52, 58, 51, 54, 900, 53, 950]

=== 2. O'rtacha (yashiradi) ===
  o'rtacha: 228ms
  o'rtacha 'yaxshi' ko'rinadi (sekin so'rovlarni yashiradi)

=== 3. Persentillar (ochadi) ===
  p50 (median): 55ms (ko'pchilik tez)
  p95: 950ms (95% shu vaqtda)
  p99: 950ms (eng sekin 1%)

=== 4. Nega persentil muhim ===
  p50 tez, lekin p99 sekin (ba'zi foydalanuvchi azob chekadi)
  o'rtacha yashiradi, persentil haqiqatni ko'rsatadi
  ⭐ Persentil — taqsimotni ochadi (o'rtacha emas)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 4 — Ogohlantirish (chegara)

"""Ogohlantirish: metrika chegaradan oshsa xabar (amaliy, darajali)."""


OGOHLANTIRISH_QOIDALARI = [
    {"metrika": "xatolik_foizi", "chegara": 5.0, "daraja": "kritik"},
    {"metrika": "javob_vaqti_ms", "chegara": 1000.0, "daraja": "ogohlantirish"},
    {"metrika": "disk_foizi", "chegara": 90.0, "daraja": "kritik"},
]


def ogohlantirishlarni_tekshir(metrikalar: dict) -> list:
    ogohlantirishlar = []
    for qoida in OGOHLANTIRISH_QOIDALARI:
        qiymat = metrikalar.get(qoida["metrika"])
        if qiymat is not None and qiymat > qoida["chegara"]:
            ogohlantirishlar.append({
                "metrika": qoida["metrika"],
                "qiymat": qiymat,
                "chegara": qoida["chegara"],
                "daraja": qoida["daraja"],
            })
    return ogohlantirishlar


def main() -> None:
    print("=== 1. Sog'lom tizim (ogohlantirish yo'q) ===")
    yaxshi = {"xatolik_foizi": 1.0, "javob_vaqti_ms": 200, "disk_foizi": 60}
    ogoh = ogohlantirishlarni_tekshir(yaxshi)
    print(f"  ogohlantirishlar: {len(ogoh)}")

    print("\n=== 2. Muammoli tizim ===")
    yomon = {"xatolik_foizi": 8.0, "javob_vaqti_ms": 1500, "disk_foizi": 60}
    ogoh = ogohlantirishlarni_tekshir(yomon)
    for o in ogoh:
        print(f"  [{o['daraja']}] {o['metrika']}: {o['qiymat']} > {o['chegara']}")

    print("\n=== 3. Kritik vs ogohlantirish ===")
    kritik = [o for o in ogoh if o["daraja"] == "kritik"]
    print(f"  kritik: {len(kritik)} (darrov harakat)")

    print("\n=== 4. Amaliy ogohlantirish ===")
    print("  chegaradan oshsa → xabar (Slack, PagerDuty)")
    print("  darajali (kritik darrov, ogohlantirish keyin)")
    print("  ⭐ Ogohlantirish — muammoni yetkazish")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Sog'lom tizim (ogohlantirish yo'q) ===
  ogohlantirishlar: 0

=== 2. Muammoli tizim ===
  [kritik] xatolik_foizi: 8.0 > 5.0
  [ogohlantirish] javob_vaqti_ms: 1500 > 1000.0

=== 3. Kritik vs ogohlantirish ===
  kritik: 1 (darrov harakat)

=== 4. Amaliy ogohlantirish ===
  chegaradan oshsa → xabar (Slack, PagerDuty)
  darajali (kritik darrov, ogohlantirish keyin)
  ⭐ Ogohlantirish — muammoni yetkazish

Nima ko'rsatdi: 2.5-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. Monitoringsiz prod

# tizim ishlaydi, lekin ko'rinmas                 # ⚠️
# metrikalar, dashboard, ogohlantirish            # ✅

2. Faqat o'rtacha (persentilsiz)

avg = sum(vaqtlar) / len(vaqtlar)   # yashiradi   # ⚠️
p95 = persentil(vaqtlar, 95)   # haqiqat           # ✅

3. Ko'p, foydasiz ogohlantirish

if cpu > 50: ogohlantir()   # shovqin             # ⚠️
if cpu > 90 and davomiy: ogohlantir()   # amaliy   # ✅

4. Sekin so'rovni counter bilan o'lchash

sekin_sorovlar += 1   # taqsimot yo'q             # ⚠️
histogram.observe(vaqt)   # taqsimot               # ✅

5. Server metrikasi, foydalanuvchi emas

# faqat CPU, xotira (USE)                          # ⚠️
# RED ham (foydalanuvchi tajribasi)                 # ✅

6. Trend'ni e'tiborsiz qoldirish

# faqat joriy qiymat (xotira 70%)                  # ⚠️
# trend (xotira asta to'lmoqda → oldindan)          # ✅

7. Sirlarni metrikaga qo'shish

metrika(user_email=email)   # maxfiy               # ⚠️
metrika(user_id=hash)   # anonimlashtirilgan        # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 28.8-dars (o'tilgan): CD — deploy kuzatuvi, avtomatik rollback
• 28.11-dars: Loglar — observability
• 28.12-dars: Xatolarni kuzatish (Sentry)
• 27.12-dars (o'tilgan): Chidamlilik — muammoni ko'rish
• 29-qism: Miqyoslash — yukni o'lchash

8. Eng yaxshi amaliyotlar

1. RED/USE o'lcha (muhim metrikalar).

2. Persentil (p95, p99 — o'rtacha emas).

3. Amaliy ogohlantirish (kam shovqin).

4. Dashboard (asosiy metrikalar bir joyda).

5. SLO/SLI (o'lchanadigan maqsad).

6. Deploy kuzatuvi (chiqarishdan keyin).

7. Trend (oldindan ogohlantirish).

8. Observability (metrika + log + tracing).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # nega monitoring?
2.  # counter nima?
3.  # gauge nima?
4.  # histogram nima?
5.  # counter vs gauge?
6.  # RED nima?
7.  # USE nima?
8.  # Prometheus nima?
9.  # Grafana nima?
10. # ogohlantirish nima?
11. # observability nima?
12. # nega persentil?

Vazifa 2: Xatolarni tuzating

1.  # monitoringsiz prod

2.  avg = sum/len   # yashiradi

3.  if cpu > 50: ogohlantir   # shovqin

4.  sekin_sorovlar += 1   # taqsimot yo'q

5.  metrika(user_email)   # maxfiy

1.  metrikalar, dashboard, ogohlantirish

2.  p95 = persentil(vaqtlar, 95)

3.  if cpu > 90 and davomiy: ogohlantir

4.  histogram.observe(vaqt)

5.  metrika(user_id=hash) (anonim)

Vazifa 3: Metrika turlari

Modellang:

1. Counter
2. Gauge
3. Histogram
4. Savol

Vazifa 4: RED

Modellang:

1. Rate
2. Errors
3. Duration
4. Hisobot

Vazifa 5: Persentil

Modellang:

1. Vaqtlar
2. O'rtacha
3. p95, p99
4. Farq

Vazifa 6: Ogohlantirish

Modellang:

1. Qoidalar
2. Chegara
3. Daraja
4. Tekshirish

Vazifa 7: O'ylash

Monitoring'da "o'rtacha yashiradi, persentil ochadi" — muhim tushuncha (o'rtacha javob vaqti 100ms, lekin p99 900ms bo'lishi mumkin). Nima uchun "o'rtacha" ko'pincha aldamchi (nafaqat monitoring'da — statistikada umuman), va nega "eng yomon holat" (p99, tail latency) ko'pincha "o'rtacha holat"dan muhimroq — bu foydalanuvchi tajribasi haqida nima aytadi?

Nimani mustahkamlaydi: 2.2, 2.3-bo'limlar.

Xulosa

Bu darsda monitoring va metrikalarni o'rgandik.

Eng muhim uch fikr:

1. Monitoring va metrika turlari. Monitoring — ishlab chiqarishdagi tizimni kuzatish (ko'rinmasni ko'rinadigan qilish): metrikalar yig'adi, ko'rsatadi, ogohlantiradi; muammo darrov (hatto oldindan), foydalanuvchidan oldin ("o'lchamasang — boshqarolmaysan"). Metrika turlari: Counter (faqat o'suvchi — jami so'rov, xato), Gauge (joriy qiymat — o'sadi/kamayadi, faol ulanishlar, xotira), Histogram (qiymatlar taqsimoti — javob vaqti bucketlari, persentil p50/p95/p99). Har tur bir savolga javob (jami, joriy, taqsimot).

2. Asosiy metrikalar va stack. RED (xizmat): Rate (so'rov tezligi — yuk), Errors (xatolik foizi — sifat), Duration (javob vaqti — tezlik); USE (resurs): Utilization (foydalanish %), Saturation (to'yinganlik), Errors — muhim metrikalarni ajratadi (hamma narsa emas). Yig'ish va vizualizatsiya: Prometheus (metrikalarni yig'adi — pull, time-series, PromQL), Grafana (grafiklar, dashboard). Ogohlantirish — metrika chegaradan oshsa xabar (amaliy — harakat talab, kam yolg'on signal, darajali — kritik/ogohlantirish).

3. Observability va o'lchash. Observability (kuzatiluvchanlik) — tizim ichida nima bo'layotganini tushunish, uch ustun: metrikalar (nima — raqamlar), loglar (nima bo'ldi — hodisalar, 28.11), tracing (qayerda — so'rov qaysi xizmatdan o'tdi); monitoring ma'lum muammolarni, observability noma'lum muammolarni. "O'rtacha yashiradi, persentil ochadi" — o'rtacha taqsimotni bir songa siqadi (aldamchi), persentil (p95, p99) haqiqiy taqsimotni ochadi; foydalanuvchi eng yomon holatda (tail latency) his qiladi (SLO persentil bilan — o'rtacha emas). Monitoring "o'lchash → ko'rish → boshqarish" (CD 28.8 avtomatik rollback, chidamlilik 27.12, miqyoslash 29-qism uchun asos); observability zamonaviy murakkab tizimlar (mikroservis) uchun zarur.

Keyingi darsda markazlashgan loglarni o'rganamiz: ko'p xizmatdan loglarni bir joyga yig'ish, tuzilmali logging (structured logging), qidiruv va tahlil — observability ning "loglar" ustuni.