p99 latency e një API-je është 3s — si e bën debug dhe optimizon?

Question

IT Interview Practice · Accepted Answer

p99 = **tail latency**: 1% më i ngadaltë i kërkesave marrin 3s. Lëvizja e parë është të **matësh dhe zbërthesh, jo të hamendësosh**. Krahaso p50 me p99 — nëse p50 është i shpejtë por p99 është 3s, rruga nuk është uniformisht e ngadaltë; diçka kafshon vetëm *nën ngarkesë ose në raste kufitare* (ngopja e pool-it, pauzat e GC, N+1, cache i ftohtë, një thirrje e jashtme pa timing).

**Modeli mendor:** p99 është *radha më e gjatë e arkës*, jo pritja mesatare — përshpejtimi i mesatares nuk bën asgjë për klientin e ngecur në fund.

## Procesi (nga ku deri ku)
1. **Mat & zbërthe** — metrika RED (Rate, Errors, Duration) + distributed tracing; lexo p50/p95/p99. *Hendeku* mes tyre tregon historinë.
2. **Lokalizo fazën** — instrumento çdo hap për të parë ku e shpenzojnë kohën kërkesat e ngadalta; mos optimizo me hamendje.

```js
// Mat kohën e secilës fazë për të parë ku grumbullohet p99 (mos hamendëso)
async function handler(req, res) {
  const t0 = process.hrtime.bigint();
  const mark = (label) =>
    req.log.info({ label, ms: Number(process.hrtime.bigint() - t0) / 1e6 });
  const user = await db.user.find(req.id);   mark('db.user');
  const courses = await loadCourses(user);   mark('loadCourses'); // i dyshuar
  res.json(courses);                         mark('total');
}
```

3. **Identifiko të dyshuarin e tail-it** — zakonisht *pritje*, jo llogaritje: shterja e connection-pool, query-t N+1, thirrje të jashtme pa timing, pauzat e GC, index që mungon, cache i ftohtë.

```js
// PARA: N+1 — N round-trip sekuenciale, p99 shpërthen ndërsa N rritet
const courses = await db.course.findByUser(userId);
for (const c of courses) c.lessons = await db.lesson.byCourse(c.id);

// PAS: përmblidhe në 1 query -> tail-i bie (nuk ka më N udhëtime sekuenciale)
const courses = await db.course.findByUser(userId);
const lessons = await db.lesson.byCourseIds(courses.map((c) => c.id)); // një IN(...)
const byCourse = Map.groupBy(lessons, (l) => l.courseId);
for (const c of courses) c.lessons = byCourse.get(c.id) ?? [];
```

Këtu p50 (N i vogël) duket në rregull, por nën ngarkesë N rritet dhe pool-i ngopet, kështu që **p99 shpërthen**. Për thirrjet e jashtme, gjithmonë vendos një **timeout + circuit breaker** që një varësi e ngadaltë të mos mund të tërheqë zvarrë p99-ën e të gjithë endpoint-it.

4. **Rregullo një gjë → ri-mat p99 → përsërit.** Një variabël në një kohë, ose nuk do ta dish çfarë ndihmoi.
5. **Fiksoje** — vendos një **SLO** (p.sh. p99 < 300ms) + alert që të mos regresojë.

## Këndvështrimi i intervistës
Intervistuesi po heton një proces *metodik*, jo një hamendje me fat: a e dallon **tail-in nga mesatarja**, mat para se të ndryshosh, dhe shiko **radhët/lock-et (pritjen) para CPU-së**. Përgjigje e dobët: "shto caching / rrit serverat." Përgjigje e fortë: mat → lokalizo me tracing → rregullo shkakun specifik të tail-it → verifiko me numra.

## Parimi
Optimizo **tail-in (p99), jo mesataren**. Pjesa më e madhe e "3s p99" vjen nga *pritja* (pool/queue/lock) sesa nga *llogaritja* — ndaj shiko radhët para CPU-së.

Procesi (nga ku deri ku)

Këndvështrimi i intervistës

Parimi

Pyetje të ngjashme