ఒక API యొక్క p99 latency 3s — దాన్ని ఎలా debug చేసి optimize చేస్తారు?

Question

IT Interview Practice · Accepted Answer

p99 = **tail latency**: అత్యంత నెమ్మదైన 1% requests 3s తీసుకుంటాయి. మొదటి move ఏమిటంటే **measure చేసి break down చేయడం, guess చేయకపోవడం**. p50 vs p99 ను compare చేయండి — p50 fast కానీ p99 3s అయితే, path అంతటా uniformly slow కాదు; ఏదో కేవలం *load కింద లేదా edge cases లో* మాత్రమే కరుస్తుంది (pool saturation, GC pauses, N+1, cold cache, un-timed external call).

**Mental model:** p99 అనేది *అత్యంత పొడవైన checkout line*, average wait కాదు — average ను వేగవంతం చేయడం వెనుక చిక్కుకున్న customer కి ఏమీ చేయదు.

## The process (ఎక్కడి నుండి ఎక్కడికి)
1. **Measure & break down** — RED metrics (Rate, Errors, Duration) + distributed tracing; p50/p95/p99 ను read చేయండి. వాటి మధ్య *gap* కథను చెబుతుంది.
2. **Stage ను localize చేయండి** — slow requests ఎక్కడ time గడుపుతాయో చూడటానికి ప్రతి step ను instrument చేయండి; hunch పై optimize చేయకండి.

```js
// p99 ఎక్కడ pile up అవుతుందో చూడటానికి ప్రతి stage ను time చేయండి (guess చేయకండి)
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. **Tail suspect ను identify చేయండి** — సాధారణంగా computing కాదు, *waiting*: connection-pool exhaustion, N+1 queries, un-timed external calls, GC pauses, missing index, cold cache.

```js
// BEFORE: N+1 — N sequential round-trips, N పెరిగే కొద్దీ p99 పేలిపోతుంది
const courses = await db.course.findByUser(userId);
for (const c of courses) c.lessons = await db.lesson.byCourse(c.id);

// AFTER: 1 query కి collapse చేయండి -> tail తగ్గుతుంది (ఇక N sequential trips లేవు)
const courses = await db.course.findByUser(userId);
const lessons = await db.lesson.byCourseIds(courses.map((c) => c.id)); // one IN(...)
const byCourse = Map.groupBy(lessons, (l) => l.courseId);
for (const c of courses) c.lessons = byCourse.get(c.id) ?? [];
```

ఇక్కడ p50 (small N) fine గా కనిపిస్తుంది, కానీ load కింద N పెరుగుతుంది మరియు pool saturate అవుతుంది, కాబట్టి **p99 పేలిపోతుంది**. External calls కోసం, ఎల్లప్పుడూ ఒక **timeout + circuit breaker** ను set చేయండి, తద్వారా ఒక slow dependency మొత్తం endpoint యొక్క p99 ను లాగలేదు.

4. **ఒకదాన్ని fix చేయండి → p99 ను తిరిగి measure చేయండి → పునరావృతం చేయండి.** ఒకసారి ఒక variable, లేకపోతే ఏది సహాయపడిందో మీకు తెలియదు.
5. **దాన్ని lock చేయండి** — ఒక **SLO** ను set చేయండి (ఉదా. p99 < 300ms) + alert తద్వారా అది regress కాదు.

## Interview lens
Interviewer ఒక *methodical* process ను probe చేస్తున్నారు, lucky guess ను కాదు: మీరు **mean నుండి tail ను** వేరు చేస్తారా, మార్చడానికి ముందు measure చేస్తారా, మరియు **CPU కంటే ముందు queues/locks (waiting) ను** చూస్తారా. Weak answer: "caching add చేయండి / servers ను scale up చేయండి." Strong answer: measure → tracing తో localize → specific tail cause ను fix → numbers తో verify.

## Principle
**Average ను కాదు, tail (p99) ను** optimize చేయండి. చాలా "3s p99" *computing* కంటే *waiting* (pool/queue/lock) నుండి వస్తుంది — కాబట్టి CPU కంటే ముందు queues ను చూడండి.

The process (ఎక్కడి నుండి ఎక్కడికి)

Interview lens

Principle

సంబంధిత ప్రశ్నలు