Dasturlash kitobi/5-QISM — Nodejs16 daqiqa

5.12-bob: Logger — Winston / Pino (chuqur)

5-QISM — Node.js Backend · 12-mavzu

1. Kirish va motivatsiya

Error handling 5.10-bob da xatolarni log qilishni tilga oldik; fayl yuklashda 5.11-bob ham. Endi professional loggingni — production'da nima bo'layotganini ko'rishning yagona yo'lini — chuqur o'rganamiz.

Tasavvur qil: ilovang production'da (10) ishlamoqda. To'satdan foydalanuvchi "to'lov o'tmadi" deb shikoyat qildi. Siz serverni ko'rmaysiz — u uzoq mashinada. Nima bo'lganini qanday bilasiz? Log orqali. Agar yaxshi log yozgan bo'lsangiz — qaysi foydalanuvchi, qaysi vaqtda, qaysi so'rov, qaysi xato — hammasi yozilgan, muammoni topasiz. Agar console.log bilan cheklansangiz — production'da ular yo'qoladi (yoki tartibsiz), va siz ko'rsiz.

console.log (2.1-JS) — dev uchun yaxshi, lekin production uchun yetarli emas: darajalar yo'q (info/error farqi), struktura yo'q (qidirib bo'lmaydi), timestamp yo'q, faylga yozmaydi, sekin. Professional ilova logger kutubxonasi ishlatadi: Winston (moslashuvchan, keng) yoki Pino (juda tez, JSON).

O'xshatish: log — samolyotning qora qutisi (black box). Hamma narsani yozib boradi: balandlik, tezlik, dvigatel holati, xatolar. Hodisa (crash) bo'lganda, qora quti nima bo'lganini aniq aytadi. Logsiz ilova — qora qutisiz samolyot: halokat bo'ldi, lekin nega — hech kim bilmaydi. console.log — qog'ozga qalam bilan yozish; logger — professional qora quti (struktura, vaqt, daraja).

Nega muhim?

Production ko'zi (10) — serverni ko'rmaysiz; log — yagona oyna.
Debug/diagnostika — xato qachon, kimda, qanday sodir bo'lgan.
Monitoring/ogohlantirish (10.9) — log Sentry/Datadog muammo signali.
Audit/xavfsizlik (14) — kim nima qildi (login, o'zgartirish).

2. Nazariya — chuqur tushuntirish

2.1. Nega console.log yetarli emas

console.log (2.1-JS) — oddiy, lekin production'da kamchiliklari:

text

   Daraja yo'q       — info, warning, error farqlanmaydi
   Struktura yo'q    — oddiy matn; qidirib/filtrlab bo'lmaydi (grep qiyin)
   Timestamp yo'q    — qachon sodir bo'lgani noma'lum
   Manzil yo'q       — faqat konsol; faylga/cloud'ga yozmaydi
   Sekin (sync)      — katta yukda ilovani sekinlashtiradi (5.1: event loop)
   Kontekst yo'q     — qaysi so'rov/foydalanuvchi bilan bog'liq emas

Logger bularning hammasini hal qiladi: darajalar, JSON struktura, timestamp, ko'p manzil (transport), tezlik (async), kontekst (child logger).

2.2. Log darajalari (levels)

Log darajalari — xabarning muhimligini bildiradi (signoz, pino docs). Standart darajalar (past yuqori muhimlik):

text

  trace  — eng mayda tafsilot (kamdan-kam)
  debug  — dev diagnostika ("bu yerga yetdi", o'zgaruvchi qiymati)
  info   — normal hodisa ("server ishga tushdi", "foydalanuvchi kirdi")
  warn   — ogohlantirish (xato emas, lekin e'tibor: "disk 80%")
  error  — xato (so'rov bajarilmadi, lekin ilova ishlaydi)
  fatal  — halokatli (ilova davom etolmaydi — 5.10: uncaughtException)

Daraja filtri: logger'ga "minimal daraja" beriladi (masalan info). Undan pastlari (debug, trace) yozilmaydi. Dev'da debug, production'da info yoki warn (5.8: NODE_ENV) — production'da kam, muhim log.

2.3. Strukturali (JSON) logging

Eng muhim production amaliyoti: JSON formatda log (signoz, best practices). Oddiy matn o'rniga — strukturali obyekt:

text

   Matn:  "2026-06-21 Foydalanuvchi 42 kirdi IP 1.2.3.4"
           (qidirish qiyin: "barcha 42-foydalanuvchi xatolari"?)

   JSON:  {"level":"info","time":"...","msg":"Login","userId":42,"ip":"1.2.3.4"}
           (qidirish oson: userId=42 bo'yicha filtr; mashina o'qiydi)

Nega JSON: production log'lari log aggregatorga (Datadog, ELK, Loki — 10.9) yuboriladi; ular JSON'ni parse qiladi, indekslaydi, qidiriladi (userId=42 AND level=error). Matn log — mashina uchun qiyin. Dev'da esa odam o'qishi uchun "pretty" (rangli) format 2.8-bob.

2.4. Winston — moslashuvchan, klassik

Winston — eng mashhur, moslashuvchan logger (keng plugin ekotizimi):

bash

npm install winston         # (5.2)

import winston from "winston";

const logger = winston.createLogger({
  level: "info",                          // minimal daraja (2.2)
  format: winston.format.json(),          // JSON (2.3)
  transports: [                           // qayerga yozish (2.6)
    new winston.transports.Console(),     // konsol
    new winston.transports.File({ filename: "logs/error.log", level: "error" }),
    new winston.transports.File({ filename: "logs/combined.log" }),
  ],
});

logger.info("Server ishga tushdi", { port: 3000 });   // (2.2)
logger.error("DB ulanmadi", { error: err.message });

Winston — moslashuvchan format/transport, ko'p integratsiya (DB, cloud); API tanish. Murakkab formatlash kerak bo'lganda yaxshi.

2.5. Pino — juda tez, JSON-first

Pino — juda tez (Winston'dan 5-8 baravar tez), JSON-first logger (signoz, betterstack). Fastify'ning default'i:

bash

npm install pino            # (5.2)

import pino from "pino";

const logger = pino({ level: "info" });   // JSON, async (tez — 2.7)

logger.info({ port: 3000 }, "Server ishga tushdi");   // (obyekt, xabar)
logger.error({ err }, "DB ulanmadi");

Pino vs Winston: Pino — tezlik kerak bo'lganda (yuqori trafik — performance — 2.7); JSON-first, sodda, async. Winston — moslashuvchanlik/ko'p transport kerak bo'lganda. Ikkalasi ham a'lo; yangi yuqori-yukli loyihada ko'pincha Pino tanlanadi. (Manba: 2026 taqqoslashlar.)

2.6. Transport — log qayerga boradi

Transport — log yoziladigan manzil (winston/pino):

text

  Console   — terminal (dev — 2.8)
  File      — fayl (logs/app.log) — rotatsiya bilan 2.9-bob
  HTTP/cloud — Datadog, Logtail, Elasticsearch 10.9-bob
  Database  — (kamdan-kam; audit uchun)

Bitta logger bir nechta transportga bir vaqtda yozishi mumkin (konsol + fayl + cloud).

2.7. Async/performance (nega muhim)

Logging — har so'rovda sodir bo'ladi; sekin logger ilovani sekinlashtiradi (5.1: event loop bloklanishi). Pino async, minimal overhead bilan ishlaydi (stdout'ga yozadi, og'ir ish boshqa joyda — 2.5).

Production maslahat: og'ir formatlash/yozishni asosiy thread'dan tashqarida qiling (Pino transport, yoki stdout tashqi yig'uvchi). Sinxron, og'ir log (Winston'da noto'g'ri sozlansa) — yuqori yukda muammo 2.1-bob.

2.8. Dev vs Production format (5.8)

text

  Development:  pretty (rangli, o'qish oson) — pino-pretty / winston colorize
  Production:   JSON (mashina o'qiydi, aggregator — 2.3, 10.9)

// Pino: dev'da pretty (5.8: NODE_ENV)
const logger = pino(
  process.env.NODE_ENV === "production"
    ? { level: "info" }                                    // JSON
    : { level: "debug", transport: { target: "pino-pretty" } }  // rangli
);

2.9. Log rotatsiyasi (fayl o'sib ketmasligi)

Faylga yozsangiz, u cheksiz o'sadi (diskni to'ldiradi — 0.2). Rotatsiya — faylni vaqt/hajm bo'yicha bo'lish (har kun yangi fayl, eskisini siqish/o'chirish):

text

  app-2026-06-20.log  (kecha)
  app-2026-06-21.log  (bugun)   faqat shu yozilmoqda
  eski (>14 kun)       o'chiriladi

Winston: winston-daily-rotate-file. Pino: pino-roll yoki tashqi vosita (logrotate). Production'da (10) ko'pincha log stdout'ga yoziladi, platforma/Docker 10.3-bob uni yig'adi.

2.10. HTTP so'rovlarni log qilish (morgan / pino-http)

Har HTTP so'rovni 5.6-bob log qilish — qaysi endpoint, status, davomiylik. Buning uchun maxsus middleware:

text

  morgan      — Express HTTP logger (oddiy, mashhur — 5.6'da ko'rdik)
  pino-http   — Pino bilan strukturali HTTP log (production)

Ajratish: morgan/pino-http — HTTP so'rov loglari (kirish/chiqish). Winston/Pino — ilova va xato loglari (biznes hodisalar). Ikkalasi birga (best practices).

2.11. Correlation ID (so'rovni kuzatish)

Bir so'rov ko'p funksiya/servisdan o'tadi. Correlation ID (request ID) — har so'rovga noyob ID berib, shu so'rovga oid barcha loglarni bog'lash (dev.to/axiom, best practices):

text

  So'rov keldi  reqId: "abc-123" yaratiladi
  Barcha log shu so'rov uchun: { reqId: "abc-123", ... }
   keyin "abc-123" bo'yicha filtrlab, butun so'rov yo'lini ko'rasiz

Mikroservislarda 9.9-bob bu juda muhim: so'rov bir necha servisdan o'tadi; correlation ID hammasini bog'laydi. child logger 2.12-bob bilan amalga oshiriladi.

2.12. Child logger (kontekst qo'shish)

Child logger — asosiy logger'dan "nasl", har doim qo'shimcha kontekst (masalan reqId, userId) bilan (pino docs):

const reqLogger = logger.child({ reqId: "abc-123", userId: 42 });
reqLogger.info("Mahsulot qo'shildi");
//  { reqId: "abc-123", userId: 42, msg: "Mahsulot qo'shildi" }
// Har log avtomatik reqId/userId bilan (qo'lda qo'shmaysiz — 2.11)

2.13. Maxfiy ma'lumotni log qilmang (xavfsizlik — 14)

Hech qachon log qilmang (best practices, 14):

text

   Parol, token (JWT — 5.15), API kalit (5.18)
   Kredit karta, shaxsiy ma'lumot (PII — GDPR)
   To'liq so'rov body (parol bo'lishi mumkin)

Logger'da redaction (yashirin) sozlanadi: Pino redact: ["password", "*.token"] — bu maydonlarni avtomatik [Redacted] qiladi. Log fayllar ham xavfsiz saqlanishi kerak (14).

2.14. Markazlashtirilgan logger moduli (5.8, 5.10 bilan)

Logger'ni bir marta sozlab, butun ilovada import qilish (5.8: config kabi):

// utils/logger.js — bir marta sozlang
import pino from "pino";
import { config } from "../config/index.js";   // (5.8)
export const logger = pino({ level: config.isProd ? "info" : "debug", ... });

// Boshqa fayllarda
import { logger } from "../utils/logger.js";
logger.info("...");

Bu — error handler 5.10-bob, middleware 5.6-bob, service'larda bir xil logger (izchil).

2.15. Log aggregatsiya va monitoring (10.9 ga ko'prik)

Production'da loglar markaziy joyga yig'iladi va kuzatiladi 10.9-bob:

text

  Ilova  stdout (JSON)  yig'uvchi (Fluentd/Vector)
         saqlash/qidiruv (Elasticsearch/Loki/Datadog)
         dashboard + ogohlantirish (error ko'paydi  Slack/email signal)
  Xato kuzatuvi: Sentry (stack, kontekst — 10.9)

Bu — DevOps (10) mavzusi; bu yerda logger to'g'ri JSON chiqarsa, keyin har qanday tizimga ulanadi. Asos — strukturali log 2.3-bob.

3. Sintaksis — tez ma'lumotnoma

// Pino (tez — 2.5)
import pino from "pino";
const logger = pino({ level: "info" });
logger.info({ userId: 42 }, "Login");      // (obyekt, xabar)
logger.error({ err }, "Xato");
const child = logger.child({ reqId });      // kontekst (2.12)

// Winston (moslashuvchan — 2.4)
import winston from "winston";
const logger = winston.createLogger({ level, format: winston.format.json(), transports: [...] });
logger.info("xabar", { meta });

// Darajalar 2.2-bob: trace < debug < info < warn < error < fatal
// HTTP: pino-http / morgan (2.10)
// Maxfiy: redact 2.13-bob — parol/token YOZMANG

4. Batafsil kod namunalari

Misol 1 — Pino markazlashtirilgan logger (2.14, 2.8)

// utils/logger.js
import pino from "pino";
import { config } from "../config/index.js";    // (5.8)

export const logger = pino({
  level: config.isProd ? "info" : "debug",        // prod: info, dev: debug (2.2, 2.8)
  // Dev'da pretty, prod'da JSON (2.8)
  ...(config.isProd
    ? {}
    : { transport: { target: "pino-pretty", options: { colorize: true } } }),
  // Maxfiy maydonlarni yashir (2.13, 14)
  redact: ["req.headers.authorization", "password", "*.token", "*.password"],
});

// Ishlatish
logger.info({ port: 3000 }, "Server ishga tushdi");
logger.warn({ disk: "85%" }, "Disk to'lmoqda");
logger.error({ err: new Error("boom") }, "Xato yuz berdi");

Misol 2 — Winston markazlashtirilgan logger (2.4, 2.6)

// utils/logger.js (Winston varianti)
import winston from "winston";
import { config } from "../config/index.js";

const { combine, timestamp, json, colorize, printf } = winston.format;

export const logger = winston.createLogger({
  level: config.isProd ? "info" : "debug",         // (2.2)
  format: combine(timestamp(), json()),             // JSON + vaqt (2.3)
  defaultMeta: { service: "mana-api" },             // har log'ga (2.12)
  transports: [
    new winston.transports.Console({                // konsol (2.6)
      format: config.isProd
        ? combine(timestamp(), json())
        : combine(colorize(), printf((i) => `${i.level}: ${i.message}`)),  // dev rangli (2.8)
    }),
    new winston.transports.File({ filename: "logs/error.log", level: "error" }),  // (2.6)
    new winston.transports.File({ filename: "logs/combined.log" }),
  ],
});

Misol 3 — HTTP so'rov log (pino-http — 2.10)

import express from "express";
import pinoHttp from "pino-http";              // npm install pino-http
import { logger } from "./utils/logger.js";

const app = express();

// Har HTTP so'rovni avtomatik log 2.10-bob + correlation ID (2.11)
app.use(pinoHttp({
  logger,
  genReqId: (req) => req.headers["x-request-id"] || crypto.randomUUID(),  // reqId (5.3, 2.11)
}));

app.get("/users", (req, res) => {
  req.log.info("Foydalanuvchilar so'raldi");    // so'rov logger'i (reqId bilan — 2.12)
  res.json([]);
});
// Har so'rov: { reqId, method, url, statusCode, responseTime } avtomatik

Misol 4 — Correlation ID + child logger (2.11, 2.12)

import crypto from "node:crypto";
import { logger } from "./utils/logger.js";

// Middleware: har so'rovga reqId va child logger (5.6, 2.12)
app.use((req, res, next) => {
  req.id = crypto.randomUUID();                 // (5.3)
  req.logger = logger.child({ reqId: req.id, ip: req.ip });   // kontekst (2.12)
  next();
});

app.post("/orders", (req, res) => {
  req.logger.info({ userId: req.user?.id }, "Buyurtma boshlandi");
  // ... bir necha qadam, har biri req.logger bilan ...
  req.logger.info("Buyurtma yaratildi");
  // Barcha log shu reqId bilan — keyin filtrlab, butun yo'lni ko'rasiz (2.11)
  res.status(201).json({ ok: true });
});

Misol 5 — Darajalardan to'g'ri foydalanish (2.2)

import { logger } from "./utils/logger.js";

logger.debug({ query }, "DB so'rovi bajarilmoqda");        // dev diagnostika (2.2)
logger.info({ userId: 42 }, "Foydalanuvchi kirdi");        // normal hodisa
logger.warn({ urinish: 5 }, "Ko'p login urinishi");        // ogohlantirish (xato emas)
logger.error({ err, orderId: 7 }, "To'lov amalga oshmadi"); // xato (ilova ishlaydi)
logger.fatal({ err }, "DB butunlay yo'q — to'xtaymiz");    // halokatli (5.10)

//  Hammasi info bo'lsa — filtrlab bo'lmaydi; to'g'ri daraja muhim (2.2)

Misol 6 — Error handler bilan integratsiya (5.10, 2.14)

// middleware/errorHandler.js 5.10-bob + logger
import { logger } from "../utils/logger.js";

export const errorHandler = (err, req, res, next) => {
  const statusCode = err.statusCode || 500;

  // 5xx — to'liq log (stack, kontekst); 4xx — qisqa (5.10)
  if (statusCode >= 500) {
    (req.logger || logger).error({       // child logger (reqId — 2.12)
      err: { message: err.message, stack: err.stack },
      url: req.originalUrl,
      method: req.method,
      userId: req.user?.id,
    }, "Server xatosi");
  } else {
    (req.logger || logger).warn({ msg: err.message, url: req.originalUrl }, "Mijoz xatosi");
  }

  res.status(statusCode).json({ success: false, error: { message: err.message } });
};

Misol 7 — Maxfiy ma'lumotni yashirish (redact — 2.13, 14)

import pino from "pino";

const logger = pino({
  redact: {
    paths: ["password", "*.password", "req.headers.authorization", "card.number"],   // (2.13)
    censor: "[YASHIRIN]",
  },
});

logger.info({ user: { email: "a@b.uz", password: "maxfiy123" } }, "Login");
//  { user: { email: "a@b.uz", password: "[YASHIRIN]" } }  — parol yashirin! (14)

Misol 8 — To'liq: server + log + graceful (5.10, 2.7)

// server.js
import app from "./app.js";
import { logger } from "./utils/logger.js";

const server = app.listen(3000, () => {
  logger.info({ port: 3000, env: process.env.NODE_ENV }, "Server ishga tushdi");
});

// Process xatolari 5.10-bob — fatal daraja (2.2)
process.on("uncaughtException", (err) => {
  logger.fatal({ err }, "Uncaught exception");
  process.exit(1);                            // (5.10)
});
process.on("unhandledRejection", (reason) => {
  logger.error({ reason }, "Unhandled rejection");   // (5.10)
});
process.on("SIGTERM", () => {
  logger.info("SIGTERM — yopilmoqda");
  server.close(() => { logger.info("Yopildi"); process.exit(0); });   // (5.10)
});

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

1) Production'da console.log

//  struktura/daraja/manzil yo'q (2.1)
console.log("Foydalanuvchi kirdi", user);

//  strukturali logger
logger.info({ userId: user.id }, "Foydalanuvchi kirdi");

2) Hamma narsa bir darajada

//  hammasi info — filtrlab bo'lmaydi (2.2)
logger.info("xato!");  logger.info("normal");

//  to'g'ri daraja
logger.error("xato!");  logger.info("normal");

3) Maxfiy ma'lumotni log qilish

//  parol/token log'da (14, 2.13)
logger.info({ password: req.body.password }, "Login");

//  redact yoki umuman yozmaslik
logger.info({ email: req.body.email }, "Login");

4) Matn (strukturasiz) log production'da

//  qidirib bo'lmaydi (2.3)
logger.info(`User ${id} did ${action} at ${time}`);

//  JSON (maydonlar)
logger.info({ userId: id, action }, "Foydalanuvchi harakati");

5) Har faylda alohida logger sozlash

text

 har joyda createLogger (turlicha, takror — 2.14)
 bitta utils/logger.js, hamma import qiladi

6. Keng tarqalgan xatolar va yechimlari

Xato 1 — Production'da loglar yo'qoladi

Sababi: console.log (faqat konsol, deploy'da ko'rinmaydi) yoki transport yo'q 2.6-bob. Yechimi: logger + fayl/stdout transport; platforma yig'adi (10).

Xato 2 — Log fayli diskni to'ldirdi

Sababi: rotatsiya yo'q 2.9-bob. Yechimi: daily-rotate yoki stdout + tashqi yig'uvchi (2.9, 10).

Xato 3 — Log juda ko'p (shovqin)

Sababi: hamma narsa info/debug production'da 2.2-bob. Yechimi: production'da level: "info" yoki warn; debug'ni dev'da 2.8-bob.

Xato 4 — Xatoni log qilganda stack yo'q

logger.error("Xato: " + err.message);   // stack yo'qoldi!

Sababi: error obyektini string qildi. Yechimi: logger.error({ err }, "...") — logger stack'ni oladi (serializer).

Xato 5 — pino-pretty production'da

Sababi: pretty — sekin, JSON emas 2.8-bob. Yechimi: faqat dev'da pretty; prod'da xom JSON 5.8-bob.

Xato 6 — Maxfiy ma'lumot log'ga tushdi

Sababi: to'liq body/headers log qilindi 2.13-bob. Yechimi: redact; tanlab log qilish (14).

7. Integratsiya — bu mavzu stack'ning qayerida uchraydi

console (2.1-JS): logger uni almashtiradi.
Express 5.6-bob: pino-http/morgan — HTTP log; req.log.
Error handling 5.10-bob: xatolarni log (5xx to'liq).
Config/env 5.8-bob: NODE_ENV bo'yicha daraja/format.
File upload 5.11-bob: xato/hodisa log.
Auth 5.15-bob: login/audit log (maxfiyni yashir — 14).
DevOps 10.9-bob: log aggregatsiya, Sentry monitoring.
Mikroservis 9.9-bob: correlation ID — so'rovni kuzatish.
NestJS (8): built-in Logger + Pino integratsiya.

8. Eng yaxshi amaliyotlar (best practices)

console.log o'rniga logger (production — 2.1).
Strukturali JSON log (production — qidiriladigan — 2.3); dev'da pretty 2.8-bob.
To'g'ri darajalar (debug/info/warn/error/fatal — 2.2); production'da info/warn.
Markazlashtirilgan logger moduli (bir marta sozlang — 2.14).
HTTP log (pino-http/morgan) — ilova log'idan alohida 2.10-bob.
Correlation ID + child logger — so'rovni kuzatish (2.11, 2.12).
Maxfiy ma'lumotni log qilmang (redact — parol/token/PII — 14, 2.13).
Error obyektini { err } sifatida log (stack saqlanadi).
Log rotatsiyasi yoki stdout tashqi yig'uvchi (2.9, 10).
Pino — tezlik (yuqori yuk); Winston — moslashuvchanlik 2.5-bob.

9. Amaliy loyiha: "Production-darajali Logging Tizimi"

Professional logging'ni mustahkamlash.

Maqsad

Pino (yoki Winston) bilan strukturali log, darajalar, HTTP log, correlation ID, redaction va error handler integratsiyasini birlashtirib, production-tayyor logging tizimini qurish.

Talablar (requirements)

Markazlashtirilgan logger: utils/logger.js — Pino/Winston; dev'da pretty, prod'da JSON; NODE_ENV bo'yicha daraja (Misol 1/2, 2.8, 2.14).
Darajalar: debug/info/warn/error/fatal — har birini to'g'ri o'rinda ishlating (Misol 5, 2.2).
HTTP log: pino-http (yoki morgan) — har so'rov (method, url, status, vaqt — Misol 3, 2.10).
Correlation ID: har so'rovga reqId + child logger; barcha log shu reqId bilan (Misol 4, 2.11, 2.12).
Redaction: parol/token/authorization yashir (Misol 7, 2.13, 14).
Error handler integratsiya: 5xx to'liq (stack+kontekst), 4xx qisqa; child logger bilan (Misol 6, 5.10).
Process log: uncaughtException (fatal), SIGTERM (Misol 8, 5.10).
Fayl/rotatsiya (bonus): error.log + combined.log yoki daily-rotate (2.6, 2.9).
Butun ilova bitta logger'ni import qilsin (izchil — 2.14).

Maslahatlar (hint)

Dev pretty: transport: { target: "pino-pretty" } (faqat dev — 2.8, 5-xato).
reqId: crypto.randomUUID() + logger.child({ reqId }) (5.3, 2.12).
Error: logger.error({ err }, "...") — stack uchun (4-xato).
Redact: redact: ["password", "*.token", "req.headers.authorization"] 2.13-bob.
Daraja: prod info, dev debug (config.isProd — 5.8).

"Tayyor" mezonlari (acceptance criteria)

Markazlashtirilgan logger (dev pretty / prod JSON).
Darajalar to'g'ri ishlatilgan.
Har HTTP so'rov log qilinadi.
Correlation ID barcha so'rov loglarini bog'laydi.
Maxfiy ma'lumot redact qilinadi.
Error handler logger bilan (5xx to'liq).
Process xatolari (fatal) log qilinadi.
Butun ilova bitta logger ishlatadi.

Yechim kodi ataylab berilmagan — bu loyihani o'zingiz yozib ko'ring.

10. Xulosa va keyingi bobga ko'prik

Bu bobda production'ning "ko'zi"ni — loggingni — chuqur o'rgandik:

console.log yetarli emas (production) — logger: daraja, struktura, timestamp, transport, tezlik 2.1-bob.
Darajalar (debugfatal — 2.2); strukturali JSON (qidiriladigan — 2.3); dev pretty / prod JSON 2.8-bob.
Winston (moslashuvchan) vs Pino (tez — 2.4, 2.5); transport (manzil — 2.6).
HTTP log (pino-http/morgan — 2.10); correlation ID + child logger (so'rovni kuzatish — 2.11, 2.12).
Maxfiy ma'lumotni log qilmang (redact — 14, 2.13); markazlashtirilgan logger 2.14-bob; aggregatsiya/monitoring 10.9-bob.

Keyingi bob — 5.13-bob: Real-time — WebSocket va Socket.io. Hozirgacha so'rov-javob (request-response — 5.6) modelini ko'rdik: client so'raydi, server javob beradi. Endi real-time aloqani — server o'zi clientga xabar yuborishini (chat, bildirishnoma, jonli yangilanish) — WebSocket va Socket.io bilan o'rganamiz. Bu — zamonaviy interaktiv ilovalarning asosi.

Foydalanilgan rasmiy/ishonchli manbalar

getpino.io — Pino (darajalar, child logger, transport, redact); SigNoz — Pino guide
github.com/winstonjs/winston — Winston (format, transport); Better Stack — Pino guide
expressjs.com — morgan; pino-http (HTTP log, correlation ID)

Izohlar (0)

Izoh yozish uchun kiring.

Hozircha izoh yo'q. Birinchi bo'ling!