La latenza p99 di un'API è 3s — come la debugghi e la ottimizzi?

Question

IT Interview Practice · Accepted Answer

p99 = **tail latency**: l'1% di richieste più lente impiega 3s. La prima mossa è **misurare e scomporre, non tirare a indovinare**. Confronta p50 e p99 — se il p50 è veloce ma il p99 è 3s, il percorso non è uniformemente lento; qualcosa morde solo *sotto carico o in casi limite* (saturazione del pool, pause GC, N+1, cache fredda, una chiamata esterna senza timeout).

**Modello mentale:** il p99 è la *fila alla cassa più lunga*, non l'attesa media — velocizzare la media non fa nulla per il cliente bloccato in fondo.

## Il processo (da dove a dove)
1. **Misura e scomponi** — metriche RED (Rate, Errors, Duration) + distributed tracing; leggi p50/p95/p99. Il *divario* tra loro racconta la storia.
2. **Localizza lo stadio** — strumenta ogni passo per vedere dove le richieste lente spendono tempo; non ottimizzare a intuito.

```js
// Cronometra ogni fase per vedere dove si accumula il p99 (non tirare a indovinare)
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'); // sospetto
  res.json(courses);                         mark('total');
}
```

3. **Individua il sospetto della coda** — di solito è *attesa*, non calcolo: esaurimento del connection-pool, query N+1, chiamate esterne senza timeout, pause GC, indice mancante, cache fredda.

```js
// PRIMA: N+1 — N round-trip sequenziali, il p99 esplode al crescere di N
const courses = await db.course.findByUser(userId);
for (const c of courses) c.lessons = await db.lesson.byCourse(c.id);

// DOPO: riduci a 1 query -> la coda cala (niente più N viaggi sequenziali)
const courses = await db.course.findByUser(userId);
const lessons = await db.lesson.byCourseIds(courses.map((c) => c.id)); // un solo IN(...)
const byCourse = Map.groupBy(lessons, (l) => l.courseId);
for (const c of courses) c.lessons = byCourse.get(c.id) ?? [];
```

Qui il p50 (N piccolo) sembra a posto, ma sotto carico N cresce e il pool si satura, quindi **il p99 esplode**. Per le chiamate esterne, imposta sempre un **timeout + circuit breaker** così una dipendenza lenta non può trascinare il p99 dell'intero endpoint.

4. **Correggi una cosa → rimisura il p99 → ripeti.** Una variabile alla volta, o non saprai cosa ha aiutato.
5. **Fissalo** — imposta uno **SLO** (es. p99 < 300ms) + alert così non regredisce.

## Ottica del colloquio
L'intervistatore verifica un processo *metodico*, non una supposizione fortunata: distingui la **coda dalla media**, misuri prima di cambiare, e guardi le **code/lock (attesa) prima della CPU**. Risposta debole: "aggiungi caching / scala i server." Risposta forte: misura → localizza col tracing → correggi la causa specifica della coda → verifica con i numeri.

## Principio
Ottimizza la **coda (p99), non la media.** La maggior parte dei "3s p99" deriva dall'*attesa* (pool/coda/lock) più che dal *calcolo* — quindi guarda le code prima della CPU.

Il processo (da dove a dove)

Ottica del colloquio

Principio

Domande correlate