La latencia p99 de una API es de 3s — ¿cómo la depuras y optimizas?

Question

IT Interview Practice · Accepted Answer

p99 = **tail latency**: el 1% más lento de las peticiones tarda 3s. El primer paso es **medir y desglosar, no adivinar**. Compara p50 vs p99 — si p50 es rápido pero p99 es 3s, la ruta no es uniformemente lenta; algo muerde solo *bajo carga o en casos límite* (saturación del pool, pausas de GC, N+1, cache fría, una llamada externa sin timing).

**Modelo mental:** p99 es la *fila de caja más larga*, no la espera media — acelerar la media no hace nada por el cliente atascado al final.

## El proceso (de dónde a dónde)
1. **Mide y desglosa** — métricas RED (Rate, Errors, Duration) + distributed tracing; lee p50/p95/p99. El *gap* entre ellos cuenta la historia.
2. **Localiza la etapa** — instrumenta cada paso para ver dónde pasan el tiempo las peticiones lentas; no optimices por corazonada.

```js
// Cronometra cada etapa para ver dónde se acumula el p99 (no adivines)
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'); // sospechoso
  res.json(courses);                         mark('total');
}
```

3. **Identifica al sospechoso de la cola** — normalmente *esperar*, no computar: agotamiento del connection pool, N+1 queries, llamadas externas sin timing, pausas de GC, índice faltante, cache fría.

```js
// ANTES: N+1 — N round-trips secuenciales, el p99 explota a medida que N crece
const courses = await db.course.findByUser(userId);
for (const c of courses) c.lessons = await db.lesson.byCourse(c.id);

// DESPUÉS: colapsa a 1 query -> la cola cae (no más N viajes secuenciales)
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) ?? [];
```

Aquí p50 (N pequeño) se ve bien, pero bajo carga N crece y el pool se satura, así que **el p99 detona**. Para las llamadas externas, pon siempre un **timeout + circuit breaker** para que una dependencia lenta no pueda arrastrar el p99 de todo el endpoint.

4. **Arregla una cosa → vuelve a medir p99 → repite.** Una variable a la vez, o no sabrás qué ayudó.
5. **Consolídalo** — define un **SLO** (p. ej. p99 < 300ms) + alerta para que no regrese.

## Enfoque de entrevista
El entrevistador está sondeando un proceso *metódico*, no una suposición afortunada: ¿distingues la **cola de la media**, mides antes de cambiar, y miras las **colas/locks (esperar) antes que la CPU**? Respuesta débil: "añade caching / escala los servidores". Respuesta fuerte: medir → localizar con tracing → arreglar la causa concreta de la cola → verificar con números.

## Principio
Optimiza la **cola (p99), no la media**. La mayoría de los "p99 de 3s" vienen de *esperar* (pool/cola/lock) más que de *computar* — así que mira las colas antes que la CPU.

El proceso (de dónde a dónde)

Enfoque de entrevista

Principio

Preguntas relacionadas