Correlation ID: X-Request-Id, AsyncLocalStorage va so'rov kuzatuvi

const YAROQLI = /^[\w.-]{8,128}$/;

export function sorovId(yangiId: () => string = randomUUID) {
  return (req, res, next) => {
    const kelgan = req.get("x-request-id");
    req.sorovId =
      kelgan !== undefined && YAROQLI.test(kelgan)
        ? kelgan
        : yangiId();
    res.set("X-Request-Id", req.sorovId);
    next();
  };
}

import { createServer } from "node:http";
import { AsyncLocalStorage } from "node:async_hooks";
import { setTimeout as kut } from "node:timers/promises";

const kontekst = new AsyncLocalStorage();

function log(xabar, maydonlar = {}) {
  const sorovId = kontekst.getStore() ?? "-";
  const qator = { sorovId, ...maydonlar, msg: xabar };
  console.log(JSON.stringify(qator));
}

// xizmat qatlami: req'ni ham, ID'ni ham bilmaydi
async function vazifaYarat(matn) {
  await kut(matn.length * 10); // baza o'rnida
  log("vazifa yaratildi", { matn });
}

const server = createServer((req, res) => {
  const id = req.headers["x-request-id"] ?? "yangi-id";
  res.setHeader("X-Request-Id", id);
  kontekst.run(id, async () => {
    const matn = decodeURIComponent(req.url.slice(1));
    await vazifaYarat(matn);
    res.end("ok");
    log("javob ketdi");
  });
});

server.listen(0, "127.0.0.1");
await new Promise((ok) => server.once("listening", ok));
const asos = `http://127.0.0.1:${server.address().port}`;
const sora = (id, matn) =>
  fetch(`${asos}/${encodeURIComponent(matn)}`, {
    headers: { "X-Request-Id": id },
  });

await Promise.all([
  sora("aaa-0001", "Hisobot yozish"),
  sora("bbb-0002", "Non"),
]);
log("hammasi tugadi");
server.closeAllConnections();
server.close();

{"sorovId":"bbb-0002","matn":"Non","msg":"vazifa yaratildi"}
{"sorovId":"bbb-0002","msg":"javob ketdi"}
{"sorovId":"aaa-0001","matn":"Hisobot yozish","msg":"vazifa yaratildi"}
{"sorovId":"aaa-0001","msg":"javob ketdi"}
{"sorovId":"-","msg":"hammasi tugadi"}

const kontekst = new AsyncLocalStorage<Log>();

/** Joriy so'rovning logger'i; so'rovdan tashqarida — asosiy */
export function joriyLog(asosiy: Log): Log {
  return kontekst.getStore() ?? asosiy;
}

export function sorovLogi(log: Log): RequestHandler[] {
  const http = pinoHttp({ /* … Pino chuqur darsida */ });
  return [
    http,
    (req, _res, next) => {
      kontekst.run(req.log, next);
    },
  ];
}

const xizmat = vazifaXizmati(ombor, () => joriyLog(log));

const v = await ombor.yarat(yangi);
log().info({ vazifaId: v.id }, "vazifa yaratildi");

// eksport.ts (holat 44): logger javobdan OLDIN olinadi
const l = log();
bajar(ish).then(
  () => {
    l.info({ eksportId: ish.id, soni: ish.tayyor }, "eksport tayyor");
  },
  (x: unknown) => {
    ish.holat = "xato";
    ish.xato = "Eksport bajarilmadi";
    l.error({ err: x, eksportId: ish.id }, "eksport bajarilmadi");
  },
);

{"daraja":"info","time":"2026-10-24T06:04:49.109Z","ilova":"vazifalar-api","sorovId":"kanon-44-0003","req":{"method":"POST","url":"/v1/eksportlar","ip":"127.0.0.1","userAgent":"curl/8.19.0"},"res":{"status":202},"ms":1,"msg":"POST /v1/eksportlar 202"}
{"daraja":"info","time":"2026-10-24T06:04:49.110Z","ilova":"vazifalar-api","sorovId":"kanon-44-0003","eksportId":"deb4d671-f6e4-484d-87d4-a8cfa1d92697","soni":1,"msg":"eksport tayyor"}

import { createServer } from "node:http";
import { once } from "node:events";
import { AsyncLocalStorage } from "node:async_hooks";

const kontekst = new AsyncLocalStorage();
const log = (servis, xabar) => {
  const id = kontekst.getStore()?.id ?? "-";
  console.log(`[${servis}] [${id}] ${xabar}`);
};

// Ichki so'rov: joriy so'rov ID'sini sarlavhaga qo'shadi
function ichkiFetch(url) {
  const id = kontekst.getStore()?.id;
  const headers = id ? { "X-Request-Id": id } : {};
  return fetch(url, { headers });
}

function servis(nom, ishlov) {
  return createServer((req, res) => {
    const id = req.headers["x-request-id"] ?? `${nom}-yangi`;
    kontekst.run({ id }, () => ishlov(req, res));
  }).listen(0, "127.0.0.1");
}
const manzil = (s) => `http://127.0.0.1:${s.address().port}`;

const xabar = servis("xabar", (req, res) => {
  log("xabar", "bildirishnoma yuborildi");
  res.end();
});
const api = servis("api", async (req, res) => {
  log("api", "vazifa bajarildi");
  await ichkiFetch(manzil(xabar));
  log("api", "javob ketdi");
  res.end();
});
await Promise.all([once(api, "listening"), once(xabar, "listening")]);

const sarlavha = { "X-Request-Id": "mijoz-0007" };
await fetch(manzil(api), { headers: sarlavha });
for (const s of [api, xabar]) {
  s.closeAllConnections();
  s.close();
}

[api] [mijoz-0007] vazifa bajarildi
[xabar] [mijoz-0007] bildirishnoma yuborildi
[api] [mijoz-0007] javob ketdi

traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01

const NAQSH = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/;

function traceparentOch(qiymat) {
  const m = NAQSH.exec(qiymat);
  if (!m || /^0+$/.test(m[1]) || /^0+$/.test(m[2])) return null;
  const namuna = (parseInt(m[3], 16) & 1) === 1;
  return { traceId: m[1], spanId: m[2], namuna };
}

function keyingiTraceparent(ota, yangiSpanId) {
  const bayroq = ota.namuna ? "01" : "00";
  return `00-${ota.traceId}-${yangiSpanId}-${bayroq}`;
}

const kelgan =
  "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01";
const ota = traceparentOch(kelgan);
console.log(ota.traceId);
console.log(ota.spanId, ota.namuna);
console.log(keyingiTraceparent(ota, "b7ad6b7169203331"));
console.log(traceparentOch("salom"));
const nollar = "00-" + "0".repeat(32) + "-00f067aa0ba902b7-01";
console.log(traceparentOch(nollar));

4bf92f3577b34da6a3ce929d0e0e4736
00f067aa0ba902b7 true
00-4bf92f3577b34da6a3ce929d0e0e4736-b7ad6b7169203331-01
null
null

// log.ts — strukturali (JSON) log: Pino. stdout'ga yoziladi
// (12-factor) — faylga yozish, rotatsiya, yig'ish — muhitning
// ishi (Docker, Loki — 34-qism).
// Correlation ID: har so'rov AsyncLocalStorage ichida — xizmat
// va fon ishlari ham joriy so'rov logger'ini oladi
// (req'ni uzatmasdan)
import { AsyncLocalStorage } from "node:async_hooks";
import { pino } from "pino";
import type { DestinationStream, Logger, LoggerOptions } from "pino";
import { pinoHttp } from "pino-http";
import type { RequestHandler } from "express";

export type Log = Logger;

/** Hech qachon logga tushmasligi kerak bo'lgan joylar —
 * qiymat "[yashirildi]" ga almashadi */
export const YASHIRIN = [
  "req.headers.authorization",
  "req.headers.cookie",
  'req.headers["x-api-key"]',
  "res.headers['set-cookie']",
  "*.parol",
  "*.token",
];

export function logYarat(
  daraja: string,
  manzil?: DestinationStream,
): Log {
  const sozlama: LoggerOptions = {
    level: daraja,
    // vaqt ISO ko'rinishda (epoch ms emas) — odam ham o'qisin;
    // Toshkentga aylantirish — ko'rsatuvchi vositada
    timestamp: pino.stdTimeFunctions.isoTime,
    redact: { paths: YASHIRIN, censor: "[yashirildi]" },
    base: { ilova: "vazifalar-api" },
    formatters: { level: (label) => ({ daraja: label }) },
  };
  return manzil === undefined ? pino(sozlama) : pino(sozlama, manzil);
}

const kontekst = new AsyncLocalStorage<Log>();

/** Joriy so'rovning logger'i (sorovId bilan);
 * so'rovdan tashqarida — asosiy logger */
export function joriyLog(asosiy: Log): Log {
  return kontekst.getStore() ?? asosiy;
}

/**
 * pino-http: har so'rov oxirida bitta qator
 * (metod, yo'l, status, vaqt),
 * sorovId — bizning X-Request-Id; keyin qolgan zanjir
 * AsyncLocalStorage
 * ichida ishlaydi. sorovId() middleware'idan KEYIN qo'yiladi
 */
function asliYol(req: { url?: string | undefined }): string {
  const r = req as { originalUrl?: string; url?: string };
  return (r.originalUrl ?? r.url ?? "").split("?")[0] ?? "";
}

export function sorovLogi(log: Log): RequestHandler[] {
  const http = pinoHttp({
    logger: log,
    genReqId: (req) =>
      (req as unknown as { sorovId: string }).sorovId,
    customAttributeKeys: { reqId: "sorovId", responseTime: "ms" },
    // req.log (va AsyncLocalStorage'dagi) child logger'ga
    // faqat sorovId
    // bog'lanadi — har qatorga butun req yozilmasin
    quietReqLogger: true,
    // 4xx — warn, 5xx — error (xato ishlovchi o'zi ham yozadi),
    // qolgani info
    customLogLevel: (_req, res, xato) =>
      xato !== undefined || res.statusCode >= 500
        ? "error"
        : res.statusCode >= 400
          ? "warn"
          : "info",
    // req.url — router ichida qisqaradi ("/"),
    // originalUrl — to'liq yo'l
    customSuccessMessage: (req, res) =>
      `${String(req.method)} ${asliYol(req)} ` +
      String(res.statusCode),
    customErrorMessage: (req, res) =>
      `${String(req.method)} ${asliYol(req)} ` +
      String(res.statusCode),
    serializers: {
      // to'liq sarlavhalar o'rniga keraklilari (hajm va maxfiylik)
      req: (req: {
        method: string;
        url: string;
        raw?: { originalUrl?: string };
        headers: Record<string, string | undefined>;
        remoteAddress?: string;
      }) => ({
        method: req.method,
        url: req.raw?.originalUrl ?? req.url,
        ip: req.remoteAddress,
        userAgent: req.headers["user-agent"],
      }),
      res: (res: { statusCode: number }) => ({
        status: res.statusCode,
      }),
    },
  });
  return [
    http,
    (req, _res, next) => {
      kontekst.run(req.log, next);
    },
  ];
}

--- a/ilova.ts
+++ b/ilova.ts
-import type { XatoLogi } from "./umumiy/xato-ishlovchi.ts";
-import { logYarat, sorovLogi } from "./umumiy/log.ts";
+import { joriyLog, logYarat, sorovLogi } from "./umumiy/log.ts";
@@ Bogliqliklar @@
-  /** kutilmagan xatolarni yozish (sukut — console.error) */
-  xatoLogi?: XatoLogi;
@@ ilovaYarat parametrlari @@
-  xatoLogi,
   log = logYarat("silent"),
@@ middleware tartibi @@
   app.use(sorovId());
+  // so'rov logi + AsyncLocalStorage konteksti (sorovId) —
+  // qolgan hamma middleware va handler shu kontekst ichida
   app.use(sorovLogi(log));
@@ routerlar @@
-  const xizmat = vazifaXizmati(ombor);
+  const xizmat = vazifaXizmati(ombor, () => joriyLog(log));
-  v1.use("/eksportlar", eksportRouteri(ombor));
+  v1.use(
+    "/eksportlar",
+    eksportRouteri(ombor, { log: () => joriyLog(log) }),
+  );
@@ oxiri @@
-  app.use(xatoIshlovchi(xatoLogi));
+  app.use(
+    xatoIshlovchi((_id, xato) => {
+      joriyLog(log).error({ err: xato }, "kutilmagan xato");
+    }),
+  );

--- a/xizmat.ts
+++ b/xizmat.ts
+import type { Log } from "../umumiy/log.ts";
@@ vazifaXizmati @@
-export function vazifaXizmati(ombor: VazifaOmbori) {
+// log — funksiya: har chaqiruvda JORIY so'rov logger'i
+// (AsyncLocalStorage) — sorovId avtomatik qo'shiladi
+export function vazifaXizmati(
+  ombor: VazifaOmbori,
+  log: () => Pick<Log, "info"> = () => ({ info: () => undefined }),
+) {
@@ yarat @@
-      return ombor.yarat(yangi);
+      const v = await ombor.yarat(yangi);
+      log().info({ vazifaId: v.id }, "vazifa yaratildi");
+      return v;
@@ ochir @@
       natija(id, await ombor.ochir(id, shart));
+      log().info({ vazifaId: id }, "vazifa o'chirildi");

--- a/eksport.ts
+++ b/eksport.ts
+import type { Log } from "../umumiy/log.ts";
@@ BOLAK dan keyin @@
+type EksportLogi = Pick<Log, "info" | "error">;
+const jimLog: EksportLogi = {
+  info: () => undefined,
+  error: () => undefined,
+};
@@ eksportRouteri parametrlari @@
   bolakdanKeyin = (): Promise<void> => navbat(),
+  log = (): EksportLogi => jimLog,
@@ POST / @@
-    bajar(ish).catch((x: unknown) => {
-      ish.holat = "xato";
-      ish.xato = "Eksport bajarilmadi";
-      console.error(`[eksport ${ish.id}]`, x);
-    });
+    const l = log();
+    bajar(ish).then( /* «Javobdan keyin: fon ishi» */ );

       saqla.catch((x: unknown) => {
-        console.error(
-          `[${req.sorovId}] idempotentlik omboriga yozilmadi`, x);
+        req.log.error(
+          { err: x }, "idempotentlik omboriga yozilmadi");
       });

-import { jsonYubor } from "./yordamchi.ts";
+import { jsonYubor, xotiraLogi } from "./yordamchi.ts";
@@ before/after @@
-const loglar: unknown[][] = [];
-const aslError = console.error;
+const { log, qatorlar } = xotiraLogi();
 before(async () => {
-  console.error = (...x: unknown[]) => loglar.push(x);
-  const { server, manzil } = await ishga({ port: 0,
-    bogliqliklar: { ombor: new BuzuqOmbor() } });
+  const { server, manzil } = await ishga({ port: 0,
+    bogliqliklar: { ombor: new BuzuqOmbor(), log } });
   asos = manzil;
   toxta = () => yop(server, 1000);
 });
-after(async () => {
-  console.error = aslError;
-  await toxta();
-});
+after(() => toxta());
@@ 500 testining oxiri @@
-  assert.ok(loglar.some((q) => q[0] === "[test-500-abcdef]"
-    && q[1] instanceof Error));
+  // logda — to'liq xato (stack bilan) va o'sha sorovId
+  const q = qatorlar.find((x) => x.msg === "kutilmagan xato");
+  assert.ok(q);
+  assert.equal(q.sorovId, "test-500-abcdef");
+  assert.equal(q.daraja, "error");
+  assert.match(String((q.err as { stack?: string } | undefined)
+    ?.stack), /ulanish uzildi/);

import { after, before, test } from "node:test";
import assert from "node:assert/strict";
import { ishgaTushir as ishga } from "../src/ishga-tushir.ts";
import { yop } from "../src/yopish.ts";
import { XotiraOmbori } from "../src/vazifalar/xotira-ombor.ts";
import { xotiraLogi } from "./yordamchi.ts";

const { log, qatorlar } = xotiraLogi();
let asos = "";
let toxta: () => Promise<boolean>;
before(async () => {
  const { server, manzil } = await ishga({
    port: 0,
    bogliqliklar: { ombor: new XotiraOmbori(), log },
  });
  asos = manzil;
  toxta = () => yop(server, 1000);
});
after(() => toxta());

test("correlation ID: xizmat ichidagi log (req'siz) " +
  "so'rov sorovId'sini oladi — POST tanasi bilan ham " +
  "(AsyncLocalStorage)", async () => {
  await fetch(`${asos}/v1/vazifalar`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Request-Id": "kor-0001-abc",
    },
    body: '{"matn":"Non"}',
  });
  const xizmat = qatorlar.find((q) => q.msg === "vazifa yaratildi");
  assert.ok(xizmat);
  assert.equal(xizmat.sorovId, "kor-0001-abc");
  assert.equal(xizmat.vazifaId, 1);
  const sorov = qatorlar.find(
    (q) => q.msg === "POST /v1/vazifalar 201",
  );
  assert.ok(sorov);
  assert.equal(sorov.sorovId, "kor-0001-abc");
  assert.equal(sorov.daraja, "info");
  assert.equal(typeof sorov.ms, "number");
  assert.match(String(sorov.time), /^\d{4}-\d{2}-\d{2}T.*Z$/);
});

test("parallel so'rovlar loglari aralashmaydi", async () => {
  await Promise.all(
    ["par-aaaa-1", "par-bbbb-2", "par-cccc-3"].map((id, i) =>
      fetch(`${asos}/v1/vazifalar`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "X-Request-Id": id,
        },
        body: JSON.stringify({ matn: `p${String(i)}` }),
      })),
  );
  const yaratilgan = qatorlar.filter(
    (q) => q.msg === "vazifa yaratildi" &&
      String(q.sorovId).startsWith("par-"),
  );
  assert.equal(yaratilgan.length, 3);
  assert.equal(new Set(yaratilgan.map((q) => q.sorovId)).size, 3);
});

test("4xx — warn; Authorization va cookie logga tushmaydi (redact)",
  async () => {
    await fetch(`${asos}/v1/vazifalar/999`, {
      headers: {
        Authorization: "Bearer SOXTA-TOKEN",
        "X-Request-Id": "red-0001-abc",
      },
    });
    const q = qatorlar.find(
      (x) => x.sorovId === "red-0001-abc" &&
        x.msg === "GET /v1/vazifalar/999 404",
    );
    assert.ok(q);
    assert.equal(q.daraja, "warn");
    assert.doesNotMatch(JSON.stringify(qatorlar), /SOXTA-TOKEN/);
  });

test("fon ishi (eksport) logi ham boshlagan so'rov sorovId'si bilan",
  async () => {
    const r = await fetch(`${asos}/v1/eksportlar`, {
      method: "POST",
      headers: { "X-Request-Id": "eks-0001-abc" },
    });
    const joy = String(r.headers.get("location"));
    for (let i = 0; i < 50 &&
      !qatorlar.some((q) => q.msg === "eksport tayyor"); i++) {
      await new Promise((ok) => setTimeout(ok, 10));
    }
    const q = qatorlar.find((x) => x.msg === "eksport tayyor");
    assert.ok(q);
    assert.equal(q.sorovId, "eks-0001-abc");
    assert.equal(q.eksportId, joy.split("/").at(-1));
  });

git add -A
git commit -m "Log: Pino JSON (stdout), pino-http, redact, X-Request-Id → AsyncLocalStorage orqali hamma qatorlarda; pino-pretty faqat dev"