Latența p99 a unui API este de 3s — cum o depanezi și optimizezi?

Question

IT Interview Practice · Accepted Answer

p99 = **tail latency**: cele mai lente 1% dintre cereri durează 3s. Prima mișcare este să **măsori și să descompui, nu să ghicești**. Compară p50 vs p99 — dacă p50 este rapid, dar p99 este 3s, calea nu este uniform lentă; ceva mușcă doar *sub sarcină sau în cazuri limită* (saturarea pool-ului, pauze GC, N+1, cache rece, un apel extern necronometrat).

**Model mental:** p99 este *cea mai lungă coadă la casă*, nu așteptarea medie — accelerarea mediei nu face nimic pentru clientul blocat la coadă.

## Procesul (de unde până unde)
1. **Măsoară și descompune** — metrici RED (Rate, Errors, Duration) + distributed tracing; citește p50/p95/p99. *Diferența* dintre ele spune povestea.
2. **Localizează etapa** — instrumentează fiecare pas pentru a vedea unde își petrec timpul cererile lente; nu optimiza din intuiție.

```js
// Cronometrează fiecare etapă pentru a vedea unde se acumulează p99 (nu ghici)
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'); // suspect
  res.json(courses);                         mark('total');
}
```

3. **Identifică suspectul din tail** — de obicei *așteptare*, nu calcul: epuizarea connection pool-ului, interogări N+1, apeluri externe necronometrate, pauze GC, index lipsă, cache rece.

```js
// ÎNAINTE: N+1 — N round-trip-uri secvențiale, p99 explodează pe măsură ce N crește
const courses = await db.course.findByUser(userId);
for (const c of courses) c.lessons = await db.lesson.byCourse(c.id);

// DUPĂ: comprimă la 1 interogare -> tail-ul scade (fără N drumuri secvențiale)
const courses = await db.course.findByUser(userId);
const lessons = await db.lesson.byCourseIds(courses.map((c) => c.id)); // un IN(...)
const byCourse = Map.groupBy(lessons, (l) => l.courseId);
for (const c of courses) c.lessons = byCourse.get(c.id) ?? [];
```

Aici p50 (N mic) pare în regulă, dar sub sarcină N crește și pool-ul se saturează, așa că **p99 explodează**. Pentru apeluri externe, setează întotdeauna un **timeout + circuit breaker** ca o dependență lentă să nu poată trage în jos p99-ul întregului endpoint.

4. **Repară un lucru → re-măsoară p99 → repetă.** O variabilă pe rând, altfel nu vei ști ce a ajutat.
5. **Fixează-l** — setează un **SLO** (ex. p99 < 300ms) + alertă ca să nu regreseze.

## Perspectiva de interviu
Intervievatorul verifică un proces *metodic*, nu o ghicire norocoasă: distingi **tail de medie**, măsori înainte de a schimba și te uiți la **cozi/lock-uri (așteptare) înainte de CPU**. Răspuns slab: „adaugă caching / scalează serverele.” Răspuns puternic: măsoară → localizează cu tracing → repară cauza specifică din tail → verifică cu cifre.

## Principiu
Optimizează **tail-ul (p99), nu media**. Cel mai adesea „p99 de 3s” vine din *așteptare* (pool/coadă/lock) mai degrabă decât din *calcul* — deci uită-te la cozi înainte de CPU.

Procesul (de unde până unde)

Perspectiva de interviu

Principiu

Întrebări conexe