API có p99 latency 3s — bạn debug và tối ưu thế nào?

Question

IT Interview Practice · Accepted Answer

p99 = **tail latency**: 1% request chậm nhất mất 3s. Việc đầu tiên là **đo và bóc tách, đừng đoán**. So p50 với p99 — nếu p50 nhanh mà p99 tận 3s thì đường đi **không chậm đều**; có thứ chỉ cắn *khi tải cao hoặc ở ca biên* (pool cạn, GC pause, N+1, cold cache, gọi ngoài không timeout).

**Mô hình dễ hình dung:** p99 là *hàng chờ dài nhất*, không phải thời gian chờ trung bình — kéo nhanh cái trung bình chẳng giúp gì cho người kẹt ở cuối hàng.

## Quy trình (từ đâu đến đâu)
1. **Đo & bóc tách** — RED metrics (Rate, Errors, Duration) + distributed tracing; đọc p50/p95/p99. *Khoảng cách* giữa chúng nói lên câu chuyện.
2. **Khoanh chặng** — instrument từng bước để biết request chậm tốn thời gian ở đâu; đừng tối ưu theo cảm tính.

```js
// Đo từng chặng để biết p99 dồn vào đâu (đừng đoán)
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'); // nghi phạm
  res.json(courses);                         mark('total');
}
```

3. **Nhận diện nghi phạm tail** — thường là *chờ*, không phải tính toán: connection pool cạn, N+1 query, gọi ngoài không timeout, GC pause, thiếu index, cold cache.

```js
// TRƯỚC: N+1 — N round-trip nối tiếp, p99 bùng khi N lớn
const courses = await db.course.findByUser(userId);
for (const c of courses) c.lessons = await db.lesson.byCourse(c.id);

// SAU: gộp còn 1 query -> tail sụp (hết N round-trip nối tiếp)
const courses = await db.course.findByUser(userId);
const lessons = await db.lesson.byCourseIds(courses.map((c) => c.id)); // 1 query IN(...)
const byCourse = Map.groupBy(lessons, (l) => l.courseId);
for (const c of courses) c.lessons = byCourse.get(c.id) ?? [];
```

Ở đây p50 (N nhỏ) trông ổn, nhưng khi tải cao N lớn + pool cạn thì **p99 phát nổ**. Với gọi ngoài, luôn đặt **timeout + circuit breaker** để một dependency chậm không kéo p99 cả endpoint.

4. **Sửa một thứ → đo lại p99 → lặp.** Mỗi lần một biến, nếu không bạn không biết cái gì thực sự có tác dụng.
5. **Chốt lại** — đặt **SLO** (vd p99 < 300ms) + alert để tránh tái phát.

## Góc nhìn phỏng vấn
Người phỏng vấn dò một *quy trình có phương pháp*, không phải đoán may: bạn có phân biệt **tail vs mean**, có đo trước khi sửa, và có nhìn **hàng đợi/lock (chờ) trước CPU** không. Câu **yếu**: "thêm cache / scale thêm server". Câu **mạnh**: đo → khoanh vùng bằng tracing → sửa đúng nguyên nhân tail → xác minh bằng con số.

## Nguyên tắc
Tối ưu **cái đuôi (p99), không phải trung bình**. Phần lớn "3s p99" đến từ *chờ* (pool/queue/lock) hơn là *tính toán* — nên nhìn hàng đợi trước khi nhìn CPU.

Quy trình (từ đâu đến đâu)

Góc nhìn phỏng vấn

Nguyên tắc

Câu hỏi liên quan