Node.js లో మెమరీ లీక్‌లను ఎలా కనుగొని సరిచేయాలి?

Question

IT Interview Practice · Accepted Answer

**మెమరీ లీక్** అనేది ఇకపై అవసరం లేని మెమరీ కానీ ఎప్పుడూ విడుదల చేయని మెమరీ, ఎందుకంటే ఏదైనా దానిని ఇంకా రిఫర్‌ చేస్తుంది. సమయం గడిచేకొద్దీ ప్రాసెస్ యొక్క హీప్ పెరుగుతూ దానిని నెమ్మదిస్తుంది లేదా క్రాష్ చేస్తుంది (out-of-memory). దీర్ఘకాల నడుస్తున్న Node సర్వర్‌లలో, లీక్‌లు సిరియస్ ప్రోడక్షన్ సమస్య.

## సాధారణ లీక్ సోర్సులు

```js
// 1. Unbounded caches / global collections that only grow
const cache = new Map();
app.get("/:id", (req, res) => { cache.set(req.params.id, data); }); // never cleared → grows forever

// 2. Forgotten event listeners (added repeatedly, never removed)
emitter.on("data", handler); // if added per-request and never removed → accumulates

// 3. Forgotten timers
setInterval(() => {...}, 1000); // never cleared, holds references alive

// 4. Closures capturing large objects longer than needed
function outer() {
  const huge = loadBigData();
  return () => huge.length; // keeps `huge` alive as long as the closure lives
}
```

సాధారణ థ్రెడ్: రీచేబుల్ రిఫర్‌ (ఎక్కువ మ్యాప్, లైవ్ లిస్నర్‌, నడుస్తున్న టైమర్, క్లోజర్) గార్బేజ్-కలెక్ట్ చేయవటం నుండి ఆబ్జెక్టులను ఆపివేస్తుంది అయినప్పటికీ అవి ఇకపై ఉపయోగకరమైనవి కాదు.

## లీక్‌లను కనుగొనడం

```js
// 1. Watch heap growth over time — steady upward trend = likely leak
setInterval(() => {
  const { heapUsed } = process.memoryUsage();
  console.log(`heap: ${(heapUsed / 1e6).toFixed(1)} MB`);
}, 10000);
```

```bash
# 2. Heap snapshots — capture at two points, compare what grew
node --inspect app.js     # then use Chrome DevTools → Memory → heap snapshots
# or the heapdump / clinic.js tools
```

డయాగ్నోస్టిక్ ప్రక్రియ: హీప్ స్థిరంగా పెరుగుతున్నట్లు నిశ్చితం చేయండి (కేవలం సాధారణ హెచ్చుతగ్గు కాదు), తరువాత వర్కలోడ్ ముందు/తరువాత **heap snapshots** తీసుకుని ఏ ఆబ్జెక్ట్ టైపులు సేకరం అవుతున్నాయో కనుగొనడానికి సరిపోల్చండి ("retained size" పెరుగుతోంది).

## లీక్‌లను సరిచేయడం

```js
// ✅ bound caches with TTL/size limits (LRU)
import { LRUCache } from "lru-cache";
const cache = new LRUCache({ max: 1000, ttl: 1000 * 60 }); // evicts automatically

// ✅ always remove listeners and clear timers
emitter.off("data", handler);
clearInterval(timer);

// ✅ use WeakMap/WeakSet for metadata that shouldn't keep objects alive
const meta = new WeakMap(); // entries are GC'd when the key object is
```

ఫిక్సులు కారణాలను ప్రతిబింబిస్తాయి: బౌండ్ క్యాచ్‌లు (LRU max size/TTL తో), ఎల్లప్పుడు listener/timer క్రియేషన్‌ను క్లీనప్‌తో జంటగా ఉంచండి, మరియు ఆబ్జెక్ట్‌ల కోసం `WeakMap`/`WeakSet` ఉపయోగించండి-కీయడ్ మెటాడేటా ఆబ్జెక్టులను మెమరీలో పిన్ చేయకూడదు.

## ఇది ఎందుకు ముఖ్యమైనది

Node లో మెమరీ లీక్‌లు ప్రత్యేకించి ప్రమాదకరమైనవి ఎందుకంటే సర్వర్‌లు **దీర్ఘకాల నడుస్తున్నవి** — నెమ్మదిగా లీక్ కూడా అభివృద్ధిలో అదృశ్యమైనది క్రమంగా డిగ్రేడ్ చేస్తుంది మరియు చివరికి ప్రోడక్షన్ ప్రాసెస్‌ను క్రాష్ చేస్తుంది (తరచుగా రీస్టార్ట్ చేసి ఇన్-ఫ్లైట్ కార్యను잃 देય).

క్లాసిక్ సోర్సులను (అన్‌బౌండ్ క్యాచ్‌లు, తీసివేసిన listeners/timers, నిలిచిపోయిన క్లోజర్‌లు), వాటిని ఎలా కనుగొనాలో (heap monitoring + DevTools/clinic.js తో స్నాప్‌షాట్ సరిపోలన) మరియు ఫిక్సులను (బౌండ్ LRU క్యాచ్‌లు, సంయమితమైన క్లీనప్, `WeakMap`) తెలుసుకోవడం సమయం గడిచేకొద్దీ నమ్మకమైన, స్థిరమైన Node సేవలను ఆపరేట్ చేయడానికి అవసరం.

సాధారణ లీక్ సోర్సులు

లీక్‌లను కనుగొనడం

లీక్‌లను సరిచేయడం

ఇది ఎందుకు ముఖ్యమైనది

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