15.16-dars: logging

logger.debug(f"to'lov so'rovi: {sorov}")

logger.info("...")          →  LogRecord  →  Logger darajasi va filtrlari
                                               ↓
                                           Handler lar (har biri: daraja, filtr, Formatter)
                                               ↓
                                           ota logger lar handlerlari (propagate=True bo'lsa)

logger = logging.getLogger(__name__)     # ⭐ "ilova.db.sorovlar"

logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")

logger.debug("to'lov: %s", sorov)      # ✅ DEBUG o'chiq bo'lsa — str(sorov) chaqirilmaydi
logger.debug(f"to'lov: {sorov}")       # ❌ har doim hisoblanadi
if logger.isEnabledFor(logging.DEBUG): # juda qimmat hisob uchun
    logger.debug("statistika: %s", ogir_hisob())

logging.config.dictConfig({
    "version": 1,
    "disable_existing_loggers": False,       # ⭐ doim aniq yozing
    "formatters": {"oddiy": {"format": "%(levelname)s %(name)s: %(message)s"}},
    "handlers": {"konsol": {"class": "logging.StreamHandler", "formatter": "oddiy", "stream": "ext://sys.stderr"}},
    "root": {"handlers": ["konsol"], "level": "INFO"},
})

import logging

logger = logging.getLogger(__name__)              # modulda — faqat shu

def main() -> int:
    logging.basicConfig(level=logging.INFO,
                        format="%(asctime)s %(levelname)s %(name)s: %(message)s")
    logger.info("ishga tushdi: port=%s", port)
    try:
        ...
    except Exception:
        logger.exception("buyurtma bajarilmadi: id=%s", buyurtma_id)
        return 1
    return 0

log = logging.LoggerAdapter(logger, {"sorov_id": sid})
logging.config.dictConfig({..., "disable_existing_loggers": False})

modulda: getLogger(__name__), handler yo'q
sozlash — kirish nuqtasida, bir marta
%s argumentlar, f-string emas
except ichida — logger.exception
dictConfig — disable_existing_loggers: False
handler — root da; ikki marta chiqsa, propagatsiyani tekshiring
maxfiy ma'lumot — filtr bilan yashiring

"""Sozlanmagan holat (lastResort); logger va handler darajalari; getLogger ierarxiyasi; getEffectiveLevel; ikki marta yozish va uni tuzatish; basicConfig va force."""

import contextlib
import io
import logging


def handler(nishon: str, oqim: io.StringIO, daraja: int = logging.NOTSET) -> logging.Handler:
    h = logging.StreamHandler(oqim)
    h.setLevel(daraja)
    h.setFormatter(logging.Formatter(f"{nishon} %(levelname)s %(name)s: %(message)s"))
    return h


def main() -> None:
    print("=== 1. Sozlanmagan dastur ===")
    xato = io.StringIO()
    with contextlib.redirect_stderr(xato):
        log = logging.getLogger("sozlanmagan")
        log.debug("debug"); log.info("info"); log.warning("warning"); log.error("error")
    print(f"  stderr: {xato.getvalue().splitlines()}  ← faqat WARNING+, formatsiz (lastResort)")

    print("\n=== 2. Logger va handler darajalari ===")
    oqim = io.StringIO()
    root = logging.getLogger()
    root.handlers.clear()
    root.setLevel(logging.DEBUG)
    root.addHandler(handler("[konsol]", oqim, logging.INFO))
    db = logging.getLogger("ilova.db")
    db.debug("SQL: SELECT 1")
    db.info("ulanish ochildi")
    logging.getLogger("ilova.tolov").setLevel(logging.ERROR)
    logging.getLogger("ilova.tolov.karta").warning("urinish 2/3")
    logging.getLogger("ilova.tolov.karta").error("rad etildi")
    for qator in oqim.getvalue().splitlines():
        print(f"  {qator}")
    karta = logging.getLogger("ilova.tolov.karta")
    print(f"  ilova.tolov.karta: o'z darajasi={karta.level}, samarali={logging.getLevelName(karta.getEffectiveLevel())}, ota={karta.parent.name}")

    print("\n=== 3. ⚠️ Ikki marta yozish ===")
    oqim = io.StringIO()
    root.handlers.clear()
    root.addHandler(handler("[root]", oqim))
    ilova = logging.getLogger("ilova")
    ilova.addHandler(handler("[ilova]", oqim))
    logging.getLogger("ilova.api").warning("sekin javob: 2.3 s")
    print(f"  {oqim.getvalue().splitlines()}")
    ilova.handlers.clear()
    oqim.truncate(0); oqim.seek(0)
    logging.getLogger("ilova.api").warning("sekin javob: 2.3 s")
    print(f"  handler faqat root da: {oqim.getvalue().splitlines()}")

    print("\n=== 4. ⚠️ basicConfig bir marta ===")
    root.handlers.clear()
    birinchi, ikkinchi = io.StringIO(), io.StringIO()
    logging.basicConfig(stream=birinchi, level=logging.INFO, format="1: %(message)s")
    logging.basicConfig(stream=ikkinchi, level=logging.DEBUG, format="2: %(message)s")
    logging.getLogger("x").info("salom")
    print(f"  ikkinchi basicConfig jim e'tiborsiz: birinchi={birinchi.getvalue().strip()!r}, ikkinchi={ikkinchi.getvalue()!r}")
    logging.basicConfig(stream=ikkinchi, level=logging.DEBUG, format="2: %(message)s", force=True)
    logging.getLogger("x").debug("endi ishladi")
    print(f"  force=True: ikkinchi={ikkinchi.getvalue().strip()!r}")
    root.handlers.clear()


if __name__ == "__main__":
    main()

=== 1. Sozlanmagan dastur ===
  stderr: ['warning', 'error']  ← faqat WARNING+, formatsiz (lastResort)

=== 2. Logger va handler darajalari ===
  [konsol] INFO ilova.db: ulanish ochildi
  [konsol] ERROR ilova.tolov.karta: rad etildi
  ilova.tolov.karta: o'z darajasi=0, samarali=ERROR, ota=ilova.tolov

=== 3. ⚠️ Ikki marta yozish ===
  ['[ilova] WARNING ilova.api: sekin javob: 2.3 s', '[root] WARNING ilova.api: sekin javob: 2.3 s']
  handler faqat root da: ['[root] WARNING ilova.api: sekin javob: 2.3 s']

=== 4. ⚠️ basicConfig bir marta ===
  ikkinchi basicConfig jim e'tiborsiz: birinchi='1: salom', ikkinchi=''
  force=True: ikkinchi='2: endi ishladi'

"""Dangasa %s va f-string narxi; isEnabledFor; exception va exc_info; extra va yetishmayotgan maydon xatosi; LoggerAdapter; maxfiy ma'lumotni yashiruvchi filtr."""

import contextlib
import io
import logging
import re


class Sorov:
    def __init__(self) -> None:
        self.repr_chaqiruvlari = 0

    def __repr__(self) -> str:
        self.repr_chaqiruvlari += 1               # masalan, bazaga murojaat
        return "Sorov(id=42)"


class KontekstFiltri(logging.Filter):
    def filter(self, yozuv: logging.LogRecord) -> bool:
        if not hasattr(yozuv, "sorov_id"):
            yozuv.sorov_id = "-"
        return True


class MaxfiyFiltr(logging.Filter):
    NAQSHLAR = [
        (re.compile(r"(?<![0-9])([0-9]{4})[0-9 ]{8,11}([0-9]{4})(?![0-9])"), r"\1 **** **** \2"),
        (re.compile(r"(parol|token)=\S+", re.IGNORECASE), r"\1=***"),
    ]

    def filter(self, yozuv: logging.LogRecord) -> bool:
        matn = yozuv.getMessage()
        for naqsh, almashtirma in self.NAQSHLAR:
            matn = naqsh.sub(almashtirma, matn)
        yozuv.msg, yozuv.args = matn, None
        return True


def logger_yarat(nom: str, oqim: io.StringIO, fmt: str, daraja: int = logging.DEBUG) -> logging.Logger:
    log = logging.getLogger(nom)
    log.handlers.clear()
    log.propagate = False
    log.setLevel(daraja)
    h = logging.StreamHandler(oqim)
    h.setFormatter(logging.Formatter(fmt))
    log.addHandler(h)
    return log


def main() -> None:
    print("=== 1. ⚠️ Dangasa formatlash ===")
    log = logger_yarat("tolov", io.StringIO(), "%(message)s", daraja=logging.INFO)
    sorov = Sorov()
    for _ in range(1000):
        log.debug("so'rov: %r", sorov)
    print(f"  %r argument, DEBUG o'chiq: repr chaqiruvlari = {sorov.repr_chaqiruvlari}")
    for _ in range(1000):
        log.debug(f"so'rov: {sorov!r}")
    print(f"  f-string, DEBUG o'chiq:    repr chaqiruvlari = {sorov.repr_chaqiruvlari}")
    print(f"  isEnabledFor(DEBUG): {log.isEnabledFor(logging.DEBUG)}")

    print("\n=== 2. exception ===")
    oqim = io.StringIO()
    log = logger_yarat("hisob", oqim, "%(levelname)s %(message)s")
    try:
        {"narx": 100}["chegirma"]
    except KeyError:
        log.exception("buyurtma hisoblanmadi: id=%s", 1234)
    qatorlar = oqim.getvalue().splitlines()
    print(f"  birinchi qator: {qatorlar[0]!r}")
    print(f"  traceback bor: {qatorlar[1] == 'Traceback (most recent call last):'}, oxirgi: {qatorlar[-1]!r}")

    print("\n=== 3. ⚠️ extra va yetishmayotgan maydon ===")
    oqim = io.StringIO()
    log = logger_yarat("api", oqim, "%(levelname)s [%(sorov_id)s] %(message)s")
    log.info("buyurtma yaratildi", extra={"sorov_id": "r-7f3a"})
    xato = io.StringIO()
    with contextlib.redirect_stderr(xato):
        log.info("sorov_id siz xabar")
    print(f"  jurnal: {oqim.getvalue().splitlines()}")
    print(f"  stderr: {xato.getvalue().splitlines()[0]!r} — xabar yo'qoldi")
    log.handlers[0].addFilter(KontekstFiltri())
    log.info("filtr bilan")
    print(f"  filtr sukut qo'ydi: {oqim.getvalue().splitlines()[-1]!r}")

    print("\n=== 4. LoggerAdapter ===")
    adapter = logging.LoggerAdapter(log, {"sorov_id": "r-9b21"})
    adapter.info("to'lov boshlandi")
    adapter.warning("bank javobi sekin")
    print(f"  {oqim.getvalue().splitlines()[-2:]}")

    print("\n=== 5. Maxfiy ma'lumotni yashirish ===")
    oqim = io.StringIO()
    log = logger_yarat("xavfsiz", oqim, "%(message)s")
    log.handlers[0].addFilter(MaxfiyFiltr())
    log.info("karta %s bilan to'lov", "8600 1234 5678 9012")
    log.warning("ulanish: host=db parol=Maxfiy123 token=sk_live_abc")
    for qator in oqim.getvalue().splitlines():
        print(f"  {qator}")


if __name__ == "__main__":
    main()

=== 1. ⚠️ Dangasa formatlash ===
  %r argument, DEBUG o'chiq: repr chaqiruvlari = 0
  f-string, DEBUG o'chiq:    repr chaqiruvlari = 1000
  isEnabledFor(DEBUG): False

=== 2. exception ===
  birinchi qator: 'ERROR buyurtma hisoblanmadi: id=1234'
  traceback bor: True, oxirgi: "KeyError: 'chegirma'"

=== 3. ⚠️ extra va yetishmayotgan maydon ===
  jurnal: ['INFO [r-7f3a] buyurtma yaratildi']
  stderr: '--- Logging error ---' — xabar yo'qoldi
  filtr sukut qo'ydi: 'INFO [-] filtr bilan'

=== 4. LoggerAdapter ===
  ["INFO [r-9b21] to'lov boshlandi", 'WARNING [r-9b21] bank javobi sekin']

=== 5. Maxfiy ma'lumotni yashirish ===
  karta 8600 **** **** 9012 bilan to'lov
  ulanish: host=db parol=*** token=***

"""dictConfig va disable_existing_loggers tuzog'i; getHandlerByName; RotatingFileHandler; QueueHandler va QueueListener; kutubxonada NullHandler."""

import io
import logging
import logging.config
import logging.handlers
import queue
import tempfile
import time
from pathlib import Path


def konfiguratsiya(oqim: io.StringIO, disable: bool | None) -> dict:
    sozlama = {
        "version": 1,
        "formatters": {"oddiy": {"format": "%(levelname)s %(name)s: %(message)s"}},
        "handlers": {"konsol": {"class": "logging.StreamHandler", "formatter": "oddiy", "stream": oqim}},
        "root": {"handlers": ["konsol"], "level": "INFO"},
    }
    if disable is not None:
        sozlama["disable_existing_loggers"] = disable
    return sozlama


class SekinHandler(logging.Handler):
    def __init__(self) -> None:
        super().__init__()
        self.yozilganlar: list[str] = []

    def emit(self, yozuv: logging.LogRecord) -> None:
        time.sleep(0.02)                          # tarmoqqa yuborish kabi
        self.yozilganlar.append(yozuv.getMessage())


def main() -> None:
    print("=== 1. ⚠️ dictConfig va avval yaratilgan loggerlar ===")
    for disable in (None, False):
        eski = logging.getLogger(f"eski_modul_{disable}")      # import paytida yaratilgan kabi
        oqim = io.StringIO()
        logging.config.dictConfig(konfiguratsiya(oqim, disable))
        eski.warning("muhim ogohlantirish")
        logging.getLogger("yangi").warning("yangi logger")
        nom = "sukut (True)" if disable is None else "False"
        print(f"  disable_existing_loggers={nom:12} eski.disabled={eski.disabled!s:5} jurnal={oqim.getvalue().splitlines()}")
    print(f"  getHandlerByName('konsol'): {type(logging.getHandlerByName('konsol')).__name__}")

    print("\n=== 2. RotatingFileHandler ===")
    with tempfile.TemporaryDirectory() as katalog:
        yol = Path(katalog) / "ilova.log"
        h = logging.handlers.RotatingFileHandler(yol, maxBytes=200, backupCount=2, encoding="utf-8")
        h.setFormatter(logging.Formatter("%(message)s"))
        log = logging.getLogger("aylanma")
        log.propagate = False
        log.addHandler(h)
        log.setLevel(logging.INFO)
        for i in range(20):
            log.info("buyurtma #%03d qayta ishlandi — oʻzbekcha matn", i)
        h.close()
        fayllar = sorted(p.name for p in Path(katalog).iterdir())
        print(f"  fayllar: {fayllar}")
        print(f"  har biri 200 baytdan oshmaydi: {all(p.stat().st_size <= 200 for p in Path(katalog).iterdir())}")
        print(f"  eng yangi yozuv asosiy faylda: {'#019' in yol.read_text(encoding='utf-8')}")
        print(f"  eng eski yozuvlar o'chdi (backupCount=2): {not any('#000' in p.read_text(encoding='utf-8') for p in Path(katalog).iterdir())}")

    print("\n=== 3. QueueHandler — sekin handler asosiy ipni to'xtatmasin ===")
    sekin = SekinHandler()
    to_g_ridan = logging.getLogger("togridan")
    to_g_ridan.propagate = False
    to_g_ridan.addHandler(sekin)
    boshlanish = time.perf_counter()
    for i in range(10):
        to_g_ridan.warning("xabar %d", i)
    togridan_vaqt = time.perf_counter() - boshlanish

    navbat: queue.Queue = queue.Queue()
    sekin2 = SekinHandler()
    tinglovchi = logging.handlers.QueueListener(navbat, sekin2)
    tinglovchi.start()
    navbatli = logging.getLogger("navbatli")
    navbatli.propagate = False
    navbatli.addHandler(logging.handlers.QueueHandler(navbat))
    boshlanish = time.perf_counter()
    for i in range(10):
        navbatli.warning("xabar %d", i)
    navbat_vaqt = time.perf_counter() - boshlanish
    tinglovchi.stop()
    print(f"  to'g'ridan: 10 xabar 0.15 s dan ko'p: {togridan_vaqt > 0.15}")
    print(f"  navbat orqali: 10 barobardan ko'p tez: {togridan_vaqt / navbat_vaqt > 10}")
    print(f"  hammasi yozildi va tartib saqlandi: {sekin2.yozilganlar == [f'xabar {i}' for i in range(10)]}")

    print("\n=== 4. Kutubxonada NullHandler ===")
    kutubxona = logging.getLogger("mening_kutubxonam")
    kutubxona.addHandler(logging.NullHandler())
    print(f"  kutubxona faqat NullHandler qo'shadi: {[type(h).__name__ for h in kutubxona.handlers]}")
    print("  ⭐ basicConfig, format, fayl — ilovaning ishi")


if __name__ == "__main__":
    main()

=== 1. ⚠️ dictConfig va avval yaratilgan loggerlar ===
  disable_existing_loggers=sukut (True) eski.disabled=True  jurnal=['WARNING yangi: yangi logger']
  disable_existing_loggers=False        eski.disabled=False jurnal=['WARNING eski_modul_False: muhim ogohlantirish', 'WARNING yangi: yangi logger']
  getHandlerByName('konsol'): StreamHandler

=== 2. RotatingFileHandler ===
  fayllar: ['ilova.log', 'ilova.log.1', 'ilova.log.2']
  har biri 200 baytdan oshmaydi: True
  eng yangi yozuv asosiy faylda: True
  eng eski yozuvlar o'chdi (backupCount=2): True

=== 3. QueueHandler — sekin handler asosiy ipni to'xtatmasin ===
  to'g'ridan: 10 xabar 0.15 s dan ko'p: True
  navbat orqali: 10 barobardan ko'p tez: True
  hammasi yozildi va tartib saqlandi: True

=== 4. Kutubxonada NullHandler ===
  kutubxona faqat NullHandler qo'shadi: ['NullHandler']
  ⭐ basicConfig, format, fayl — ilovaning ishi

"""JSON formatter; contextvars bilan so'rov identifikatori; asyncio vazifalarida kontekst; maxfiy maydonlar; exception maydoni; dictConfig; jurnalni tahlil qilish."""

import asyncio
import contextvars
import io
import json
import logging
import logging.config
from collections import Counter

SOROV_ID: contextvars.ContextVar[str] = contextvars.ContextVar("sorov_id", default="-")
MAXFIY = {"parol", "token", "karta"}
QATIY_VAQT = 1_789_635_600.0


class KontekstFiltri(logging.Filter):
    def filter(self, yozuv: logging.LogRecord) -> bool:
        yozuv.sorov_id = SOROV_ID.get()
        yozuv.created = QATIY_VAQT                   # faqat misol uchun — natija takrorlansin
        return True


class JsonFormatter(logging.Formatter):
    def format(self, yozuv: logging.LogRecord) -> str:
        malumot = {
            "vaqt": self.formatTime(yozuv, "%Y-%m-%dT%H:%M:%S"),
            "daraja": yozuv.levelname,
            "logger": yozuv.name,
            "xabar": yozuv.getMessage(),
            "sorov_id": getattr(yozuv, "sorov_id", "-"),
        }
        for kalit, qiymat in getattr(yozuv, "maydonlar", {}).items():
            malumot[kalit] = "***" if kalit in MAXFIY else qiymat
        if yozuv.exc_info:
            malumot["xato"] = self.formatException(yozuv.exc_info).splitlines()[-1]
        return json.dumps(malumot, ensure_ascii=False)


def sozla(oqim: io.StringIO, daraja: str) -> None:
    JsonFormatter.converter = __import__("time").gmtime
    logging.config.dictConfig({
        "version": 1,
        "disable_existing_loggers": False,
        "filters": {"kontekst": {"()": KontekstFiltri}},
        "formatters": {"json": {"()": JsonFormatter}},
        "handlers": {"stderr": {"class": "logging.StreamHandler", "stream": oqim,
                                "formatter": "json", "filters": ["kontekst"]}},
        "root": {"handlers": ["stderr"], "level": daraja},
    })


log = logging.getLogger("dokon.buyurtma")


async def buyurtma(sorov_id: str, mahsulot: str, soni: int, karta: str) -> None:
    SOROV_ID.set(sorov_id)
    log.info("buyurtma qabul qilindi", extra={"maydonlar": {"mahsulot": mahsulot, "soni": soni, "karta": karta}})
    await asyncio.sleep(0.01 * soni)
    log.debug("ombor tekshirildi")
    try:
        if soni > 5:
            raise ValueError(f"omborda {mahsulot} yetarli emas")
        log.info("buyurtma yaratildi", extra={"maydonlar": {"summa": soni * 45_000}})
    except ValueError:
        log.exception("buyurtma rad etildi")


async def xizmat() -> None:
    await asyncio.gather(
        buyurtma("r-001", "daftar", 3, "8600123456789012"),
        buyurtma("r-002", "kitob", 9, "8600987654321098"),
        buyurtma("r-003", "ruchka", 1, "9860111122223333"),
    )


def main() -> None:
    muhit = {"LOG_DARAJASI": "INFO"}
    oqim = io.StringIO()
    sozla(oqim, muhit["LOG_DARAJASI"])
    asyncio.run(xizmat())
    yozuvlar = [json.loads(q) for q in oqim.getvalue().splitlines()]

    print("=== 1. Jurnal (har qator — JSON) ===")
    for yozuv in sorted(yozuvlar, key=lambda y: (y["sorov_id"], y["xabar"])):
        print(f"  {json.dumps(yozuv, ensure_ascii=False)}")

    print("\n=== 2. Tahlil ===")
    print(f"  darajalar: {dict(Counter(y['daraja'] for y in yozuvlar))}")
    print(f"  DEBUG yozilmadi (LOG_DARAJASI=INFO): {all(y['daraja'] != 'DEBUG' for y in yozuvlar)}")
    print(f"  har so'rov o'z yozuvlariga ega: {dict(Counter(y['sorov_id'] for y in yozuvlar))}")
    xatolar = [y for y in yozuvlar if y["daraja"] == "ERROR"]
    print(f"  xatolar: {[(y['sorov_id'], y['xato']) for y in xatolar]}")
    print(f"  karta raqami hech qayerda yo'q: {not any('8600' in json.dumps(y) for y in yozuvlar)}")
    print(f"  jami summa: {sum(y.get('summa', 0) for y in yozuvlar):,} so'm".replace(",", " "))

    print("\n=== 3. Daraja muhitdan ===")
    oqim2 = io.StringIO()
    sozla(oqim2, "DEBUG")
    asyncio.run(xizmat())
    debug = [json.loads(q) for q in oqim2.getvalue().splitlines() if json.loads(q)["daraja"] == "DEBUG"]
    print(f"  LOG_DARAJASI=DEBUG: dokon.buyurtma DEBUG yozuvlari {sum(1 for y in debug if y['logger'] == 'dokon.buyurtma')} ta")
    print(f"  ⚠️ boshqa kutubxonalar ham DEBUG yozadi: {sorted({y['logger'] for y in debug} - {'dokon.buyurtma'})}")


if __name__ == "__main__":
    main()

=== 1. Jurnal (har qator — JSON) ===
  {"vaqt": "2026-09-17T09:00:00", "daraja": "INFO", "logger": "dokon.buyurtma", "xabar": "buyurtma qabul qilindi", "sorov_id": "r-001", "mahsulot": "daftar", "soni": 3, "karta": "***"}
  {"vaqt": "2026-09-17T09:00:00", "daraja": "INFO", "logger": "dokon.buyurtma", "xabar": "buyurtma yaratildi", "sorov_id": "r-001", "summa": 135000}
  {"vaqt": "2026-09-17T09:00:00", "daraja": "INFO", "logger": "dokon.buyurtma", "xabar": "buyurtma qabul qilindi", "sorov_id": "r-002", "mahsulot": "kitob", "soni": 9, "karta": "***"}
  {"vaqt": "2026-09-17T09:00:00", "daraja": "ERROR", "logger": "dokon.buyurtma", "xabar": "buyurtma rad etildi", "sorov_id": "r-002", "xato": "ValueError: omborda kitob yetarli emas"}
  {"vaqt": "2026-09-17T09:00:00", "daraja": "INFO", "logger": "dokon.buyurtma", "xabar": "buyurtma qabul qilindi", "sorov_id": "r-003", "mahsulot": "ruchka", "soni": 1, "karta": "***"}
  {"vaqt": "2026-09-17T09:00:00", "daraja": "INFO", "logger": "dokon.buyurtma", "xabar": "buyurtma yaratildi", "sorov_id": "r-003", "summa": 45000}

=== 2. Tahlil ===
  darajalar: {'INFO': 5, 'ERROR': 1}
  DEBUG yozilmadi (LOG_DARAJASI=INFO): True
  har so'rov o'z yozuvlariga ega: {'r-001': 2, 'r-002': 2, 'r-003': 2}
  xatolar: [('r-002', 'ValueError: omborda kitob yetarli emas')]
  karta raqami hech qayerda yo'q: True
  jami summa: 180 000 so'm

=== 3. Daraja muhitdan ===
  LOG_DARAJASI=DEBUG: dokon.buyurtma DEBUG yozuvlari 3 ta
  ⚠️ boshqa kutubxonalar ham DEBUG yozadi: ['asyncio']

print("xato:", e)                             # ❌ daraja, manba, vaqt yo'q
logger.exception("buyurtma bajarilmadi")      # ✅

logger.debug(f"so'rov: {sorov!r}")            # ❌
logger.debug("so'rov: %r", sorov)             # ✅

# ilova/db.py
logging.basicConfig(level=logging.DEBUG)      # ❌ import qilgan dasturni buzadi
logger = logging.getLogger(__name__)          # ✅ faqat shu

logging.getLogger("ilova").addHandler(h)
logging.basicConfig()                         # ⚠️ root da ham handler

logging.config.dictConfig({"version": 1, ...})            # ⚠️ eski loggerlar o'chadi
logging.config.dictConfig({"version": 1, "disable_existing_loggers": False, ...})   # ✅

except Exception as e:
    logger.error(f"xato: {e}")                # ❌ qayerda — noma'lum
    logger.exception("xato")                  # ✅

logger.info("login: %s parol=%s", foydalanuvchi, parol)   # ❌

logging.info("...")                           # ⚠️ manba noma'lum, root sozlamasiga bog'liq
logger = logging.getLogger(__name__); logger.info("...")  # ✅

import logging
1.  print(logging.getLevelName(logging.WARNING))
2.  print(logging.DEBUG < logging.INFO < logging.WARNING)
3.  print(logging.getLogger("a.b").parent.name)
4.  print(logging.getLogger("x") is logging.getLogger("x"))
5.  print(logging.getLogger().name)
6.  l = logging.getLogger("yangi_q"); print(l.level)
7.  print(logging.getLevelNamesMapping()["ERROR"])
8.  print(logging.getLogger("p.q").propagate)
9.  print(isinstance(logging.NullHandler(), logging.Handler))
10. l = logging.getLogger("z_q"); l.setLevel(logging.ERROR)
    print(l.isEnabledFor(logging.WARNING))
11. print(logging.getLevelName(25))
12. print(logging.LoggerAdapter(logging.getLogger("m"), {"k": 1}).extra)

1.  # kutubxona/__init__.py
    import logging
    logging.basicConfig(level=logging.DEBUG)
    logger = logging.getLogger("kutubxona")

2.  def ishla(buyurtma):
        logger.debug(f"buyurtma: {buyurtma.toliq_malumot()}")

3.  try:
        tolov()
    except Exception as e:
        logger.error("xato: " + str(e))

4.  logging.config.dictConfig({"version": 1, "root": {"level": "INFO", "handlers": ["h"]},
                               "handlers": {"h": {"class": "logging.StreamHandler"}}})

5.  logger.info("foydalanuvchi kirdi: %s, token=%s", ism, token)