p99 latency sebuah API adalah 3s — bagaimana Anda men-debug dan mengoptimalkannya?

Question

IT Interview Practice · Accepted Answer

p99 = **tail latency**: 1% request paling lambat memakan 3s. Langkah pertama adalah **mengukur dan memecahnya, bukan menebak**. Bandingkan p50 vs p99 — jika p50 cepat tapi p99 3s, jalurnya tidak lambat merata; ada yang menggigit hanya *saat beban atau di edge case* (saturasi pool, jeda GC, N+1, cold cache, panggilan eksternal tanpa timeout).

**Model mental:** p99 adalah *antrean kasir terpanjang*, bukan rata-rata tunggu — mempercepat rata-rata tak berbuat apa pun bagi pelanggan yang tersangkut di belakang.

## Prosesnya (dari mana ke mana)
1. **Ukur & pecah** — metrik RED (Rate, Errors, Duration) + distributed tracing; baca p50/p95/p99. *Jarak* di antaranya menceritakan kisahnya.
2. **Lokalisasi tahapnya** — instrumentasikan tiap langkah untuk melihat di mana request lambat menghabiskan waktu; jangan optimasi berdasar firasat.

```js
// Ukur tiap tahap untuk melihat di mana p99 menumpuk (jangan menebak)
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'); // dicurigai
  res.json(courses);                         mark('total');
}
```

3. **Identifikasi tersangka tail** — biasanya *menunggu*, bukan menghitung: kehabisan connection-pool, query N+1, panggilan eksternal tanpa timeout, jeda GC, index hilang, cold cache.

```js
// SEBELUM: N+1 — N round-trip berurutan, p99 meledak saat N membesar
const courses = await db.course.findByUser(userId);
for (const c of courses) c.lessons = await db.lesson.byCourse(c.id);

// SESUDAH: ringkas jadi 1 query -> tail turun (tak ada lagi N round-trip berurutan)
const courses = await db.course.findByUser(userId);
const lessons = await db.lesson.byCourseIds(courses.map((c) => c.id)); // satu IN(...)
const byCourse = Map.groupBy(lessons, (l) => l.courseId);
for (const c of courses) c.lessons = byCourse.get(c.id) ?? [];
```

Di sini p50 (N kecil) tampak baik, tapi di bawah beban N membesar dan pool jenuh, sehingga **p99 meledak**. Untuk panggilan eksternal, selalu pasang **timeout + circuit breaker** agar satu dependency lambat tak bisa menyeret p99 seluruh endpoint.

4. **Perbaiki satu hal → ukur ulang p99 → ulangi.** Satu variabel per kali, atau Anda takkan tahu mana yang membantu.
5. **Kunci** — tetapkan **SLO** (mis. p99 < 300ms) + alert agar tak regresi.

## Sudut pandang wawancara
Pewawancara menyelidiki proses yang *metodis*, bukan tebakan beruntung: apakah Anda membedakan **tail dari mean**, mengukur sebelum mengubah, dan melihat **queue/lock (menunggu) sebelum CPU**. Jawaban lemah: "tambah caching / scale up server." Jawaban kuat: ukur → lokalisasi dengan tracing → perbaiki penyebab tail spesifik → verifikasi dengan angka.

## Prinsip
Optimalkan **tail (p99), bukan rata-rata.** Sebagian besar "3s p99" berasal dari *menunggu* (pool/queue/lock) alih-alih *menghitung* — jadi lihat queue sebelum CPU.

Prosesnya (dari mana ke mana)

Sudut pandang wawancara

Prinsip

Pertanyaan terkait