Si mund ta zbuloni dhe ta rregulloni rrjedhjen e memories në Node.js?

Question

Accepted Answer

A **memory leak** (rrjedhje e memories) është memory që nuk është më e nevojshme por asnjëherë nuk lirohet, sepse diçka e ka ende referenca për të. Me kalimin e kohës, heap-u i procesit rritet derisa të ngadalësohet ose të shembet (out-of-memory). Në serverët Node që punojnë për një kohë të gjatë, rrjedhjet janë një problem serioz i prodhimit.

## Burimet e zakonshme të rrjedhjeve

```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
}
```

Fija e përbashkët: një referencë e arritshme (një Map globale, një listener aktiv, një timer në punë, një closure) pengon objektet që të mbledhën nga garbage collection edhe pse nuk janë më të dobishme.

## Zbulimi i rrjedhjeve

```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
```

Procesi i diagnostikimit: konfirmoni që heap-u rritet vazhdimisht (jo vetëm luhatje normale), pastaj merrni **heap snapshots** para/pas një ngarkese pune dhe krahasojini për të gjetur cilat lloje objektesh po grumbullohen ("retained size" në rritje).

## Rregullimi i rrjedhjeve

```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
```

Rregullimet pasqyrojnë shkaqet: cache-a të kufizuara (LRU me madhësi maksimale/TTL), gjithmonë kombinoni krijimin e listener/timer me pastrimin, dhe përdorni `WeakMap`/`WeakSet` për metapodatet me çelësin-objekt që nuk duhet të mbajnë objektet në memori.

## Përse kjo është e rëndësishme

Rrjedhjet e memories janë veçanërisht të rrezikshme në Node sepse serverët janë **afatgjatë** — një rrjedhje e ngadaltë që është e padukshme në zhvillim gradualisht degradohet dhe përfundimisht shterat një proces prodhuese (shpesh ristarton dhe humb punën në progres).

Përvoja e burimeve klasike (cache-a të pakufizuara, listeners/timers të hequra, closures të mbetur), si të zbulohen ato (monitorimi i heap-ut + krahasimi i snapshots me DevTools/clinic.js) dhe rregullimet (cache-a LRU të kufizuara, pastrimi i disiplinuar, `WeakMap`) është thelbësor për operimin e shërbimeve Node të besueshme dhe të qëndrueshme me kalimin e kohës.