La latence p99 d'une API est de 3 s — comment la déboguez-vous et l'optimisez-vous ?

Question

IT Interview Practice · Accepted Answer

p99 = **tail latency** : le 1 % de requêtes les plus lentes prennent 3 s. Le premier réflexe est de **mesurer et décomposer, pas de deviner**. Comparez p50 et p99 — si p50 est rapide mais p99 est à 3 s, le chemin n'est pas uniformément lent ; quelque chose ne mord que *sous charge ou dans des cas limites* (saturation du pool, pauses GC, N+1, cache froid, un appel externe sans timeout).

**Modèle mental :** le p99 est la *file d'attente la plus longue en caisse*, pas l'attente moyenne — accélérer la moyenne ne fait rien pour le client coincé au fond.

## Le processus (d'où à où)
1. **Mesurer & décomposer** — métriques RED (Rate, Errors, Duration) + distributed tracing ; lire p50/p95/p99. L'*écart* entre elles raconte l'histoire.
2. **Localiser l'étape** — instrumentez chaque étape pour voir où les requêtes lentes passent leur temps ; n'optimisez pas au feeling.

```js
// Chronométrer chaque étape pour voir où le p99 s'accumule (ne pas deviner)
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. **Identifier le suspect de la queue** — généralement de l'*attente*, pas du calcul : épuisement du connection pool, requêtes N+1, appels externes sans timeout, pauses GC, index manquant, cache froid.

```js
// AVANT : N+1 — N allers-retours séquentiels, le p99 explose quand N grandit
const courses = await db.course.findByUser(userId);
for (const c of courses) c.lessons = await db.lesson.byCourse(c.id);

// APRÈS : réduire à 1 requête -> la queue chute (plus de N allers séquentiels)
const courses = await db.course.findByUser(userId);
const lessons = await db.lesson.byCourseIds(courses.map((c) => c.id)); // un seul IN(...)
const byCourse = Map.groupBy(lessons, (l) => l.courseId);
for (const c of courses) c.lessons = byCourse.get(c.id) ?? [];
```

Ici, p50 (petit N) semble bon, mais sous charge N grandit et le pool sature, donc **le p99 détonne**. Pour les appels externes, mettez toujours un **timeout + circuit breaker** pour qu'une dépendance lente ne puisse pas plomber le p99 de tout l'endpoint.

4. **Corriger une chose → re-mesurer le p99 → recommencer.** Une variable à la fois, sinon vous ne saurez pas ce qui a aidé.
5. **Verrouiller le gain** — définir un **SLO** (par ex. p99 < 300ms) + une alerte pour éviter la régression.

## L'angle de l'entretien
L'examinateur sonde un processus *méthodique*, pas un coup de chance : distinguez-vous la **queue de la moyenne**, mesurez-vous avant de changer, et regardez-vous les **files/verrous (l'attente) avant le CPU**. Mauvaise réponse : « ajouter du caching / scaler les serveurs ». Bonne réponse : mesurer → localiser avec le tracing → corriger la cause précise de la queue → vérifier avec des chiffres.

## Principe
Optimisez la **queue (p99), pas la moyenne**. La plupart des « p99 à 3 s » viennent de l'*attente* (pool/file/verrou) plutôt que du *calcul* — donc regardez les files avant le CPU.

Le processus (d'où à où)

L'angle de l'entretien

Principe

Questions connexes