p99 latency sebuah API ialah 3s — bagaimana anda debug dan optimumkannya?

Question

IT Interview Practice · Accepted Answer

p99 = **tail latency**: 1% request paling perlahan mengambil masa 3s. Langkah pertama ialah **ukur dan pecahkan, jangan teka**. Bandingkan p50 vs p99 — jika p50 pantas tetapi p99 ialah 3s, laluan itu tidak perlahan secara seragam; sesuatu menggigit hanya *di bawah beban atau dalam kes tepi* (pool saturation, GC pauses, N+1, cold cache, satu panggilan luaran yang tidak di-time).

**Model mental:** p99 ialah *barisan checkout terpanjang*, bukan purata masa menunggu — mempercepatkan purata tidak membantu langsung pelanggan yang tersangkut di belakang.

## Prosesnya (dari mana ke mana)
1. **Ukur & pecahkan** — RED metrics (Rate, Errors, Duration) + distributed tracing; baca p50/p95/p99. *Jurang* antara mereka menceritakan kisahnya.
2. **Lokalkan peringkat** — instrumen setiap langkah untuk melihat di mana request perlahan menghabiskan masa; jangan optimum atas telahan.

```js
// Time setiap peringkat untuk melihat di mana p99 menimbun (jangan teka)
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'); // disyaki
  res.json(courses);                         mark('total');
}
```

3. **Kenal pasti suspek tail** — biasanya *menunggu*, bukan mengira: connection-pool exhaustion, N+1 queries, panggilan luaran tak di-time, GC pauses, index hilang, cold cache.

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

// SELEPAS: runtuhkan kepada 1 query -> tail menurun (tiada lagi N perjalanan berjujukan)
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) nampak elok, tetapi di bawah beban N membesar dan pool tepu, jadi **p99 meletup**. Untuk panggilan luaran, sentiasa tetapkan **timeout + circuit breaker** supaya satu dependency perlahan tidak boleh menyeret p99 keseluruhan endpoint.

4. **Baiki satu perkara → ukur semula p99 → ulang.** Satu pemboleh ubah pada satu masa, atau anda tidak akan tahu apa yang membantu.
5. **Kunci ia** — tetapkan satu **SLO** (cth. p99 < 300ms) + alert supaya ia tidak regresi.

## Sudut pandang temu duga
Penemu duga sedang menguji proses yang *bermetodologi*, bukan telahan bertuah: adakah anda membezakan **tail daripada mean**, mengukur sebelum menukar, dan melihat **queue/lock (menunggu) sebelum CPU**. Jawapan lemah: "tambah caching / scale up pelayan." Jawapan kuat: ukur → lokalkan dengan tracing → baiki punca tail spesifik → sahkan dengan nombor.

## Prinsip
Optimumkan **tail (p99), bukan purata**. Kebanyakan "3s p99" datang daripada *menunggu* (pool/queue/lock) dan bukan *mengira* — jadi lihat queue sebelum CPU.

Prosesnya (dari mana ke mana)

Sudut pandang temu duga

Prinsip

Soalan berkaitan