How to fix Warning: Possible memory leak in promises created within setInterval in Node.js

# Run your application with memory profiling
node --inspect server.js

# Or use heap snapshot
node --expose-gc --inspect server.js

// BAD: Memory leak - promises accumulate
setInterval(() => {
  const data = fetchData(); // Large data structure
  Promise.resolve(data).then(result => {
    processResult(result); // Closure captures 'data'
  });
}, 1000); // Runs forever without cleanup

// BEFORE: No cleanup
setInterval(() => {
  fetchData().then(processResult);
}, 1000);

// AFTER: Proper cleanup
const intervalId = setInterval(() => {
  fetchData().then(processResult);
}, 1000);

// Clear when done (on shutdown, component unmount, etc.)
function cleanup() {
  clearInterval(intervalId);
}

// In Express.js shutdown
process.on('SIGTERM', () => {
  cleanup();
  server.close();
});

// In React component
useEffect(() => {
  const intervalId = setInterval(() => {
    fetchData().then(processResult);
  }, 1000);

  return () => clearInterval(intervalId); // Cleanup
}, []);

const timers = new Set();

function createTimer() {
  const id = setInterval(() => {
    // Timer logic with promises
  }, 1000);
  timers.add(id);
  return id;
}

function cleanupAllTimers() {
  timers.forEach(id => clearInterval(id));
  timers.clear();
}

// BEFORE: Recursive promises - memory leak
function recursiveLoop() {
  return Promise.resolve()
    .then(() => doWork())
    .then(() => new Promise(resolve => setTimeout(resolve, 1000)))
    .then(recursiveLoop); // Infinite chain
}

// AFTER: Async function with controlled loop
async function asyncLoop() {
  let running = true;

  while (running) {
    await doWork();
    await new Promise(resolve => setTimeout(resolve, 1000));

    // Add condition to exit loop
    if (shouldStop()) {
      running = false;
    }
  }
}

// Start with proper error handling
let loopController = asyncLoop();

// Stop the loop
function stopLoop() {
  shouldStop = () => true;
}

async function controlledLoop(signal) {
  while (!signal.aborted) {
    await doWork();
    await new Promise(resolve => setTimeout(resolve, 1000));
  }
}

const controller = new AbortController();
controlledLoop(controller.signal);

// Stop when needed
controller.abort();

// BAD: Closure captures entire 'data' array
function startPolling() {
  const data = []; // Grows indefinitely

  setInterval(() => {
    const newItem = fetchItem();
    data.push(newItem); // Array keeps growing
    Promise.resolve(data).then(processAll); // Captures entire array
  }, 1000);
}

// GOOD: Don't capture growing data structures
function startPolling() {
  const intervalId = setInterval(async () => {
    const newItem = await fetchItem(); // Only current item
    await processItem(newItem); // Process immediately
    // No accumulation - newItem gets GC'd after processing
  }, 1000);

  return () => clearInterval(intervalId);
}

// BETTER: Pass only needed data, not entire context
function startPolling(config) {
  const { url, interval } = config; // Extract only what's needed

  const intervalId = setInterval(async () => {
    const item = await fetch(url).then(r => r.json());
    await processItem(item);
  }, interval);

  return () => clearInterval(intervalId);
}

// BAD: Strong references prevent GC
const timerData = new Map();

function createTimer(resource) {
  const id = setInterval(() => {
    const data = timerData.get(id);
    // Process data
  }, 1000);

  timerData.set(id, { resource, state: {} }); // Strong reference
}

// GOOD: WeakMap allows GC when timer is cleared
const timerData = new WeakMap();

function createTimer(resource) {
  const timerObj = {}; // Use object as key
  const id = setInterval(() => {
    const data = timerData.get(timerObj);
    if (data) {
      // Process data
    }
  }, 1000);

  timerData.set(timerObj, { resource, state: {} });

  return () => {
    clearInterval(id);
    // timerObj can be GC'd after this function scope ends
  };
}

// Monitor heap usage
function logMemoryUsage() {
  const used = process.memoryUsage();
  console.log(`Heap Used: ${Math.round(used.heapUsed / 1024 / 1024)}MB`);
  console.log(`Heap Total: ${Math.round(used.heapTotal / 1024 / 1024)}MB`);
}

// Log every 30 seconds
setInterval(logMemoryUsage, 30000);

// Advanced: Trigger alerts on high memory
function checkMemoryThreshold() {
  const threshold = 500 * 1024 * 1024; // 500MB
  const used = process.memoryUsage().heapUsed;

  if (used > threshold) {
    console.error(`Memory threshold exceeded: ${used / 1024 / 1024}MB`);
    // Send alert, log to monitoring service
    sendAlert('High memory usage detected');
  }
}

setInterval(checkMemoryThreshold, 60000);

// With Prometheus client
const promClient = require('prom-client');

const memoryGauge = new promClient.Gauge({
  name: 'nodejs_memory_heap_used_bytes',
  help: 'Heap memory used in bytes'
});

setInterval(() => {
  memoryGauge.set(process.memoryUsage().heapUsed);
}, 10000);

# Generate heap snapshots
node --inspect server.js

# Use clinic.js for detailed analysis
npm install -g clinic
clinic doctor -- node server.js

# Or use heapdump
npm install heapdump

// Take heap snapshot programmatically
const heapdump = require('heapdump');

// Before starting timers
heapdump.writeSnapshot('./before.heapsnapshot');

// After running for a while
setTimeout(() => {
  heapdump.writeSnapshot('./after.heapsnapshot');
}, 60000);

# Monitor memory during load test
NODE_ENV=production node --max-old-space-size=512 server.js

# Memory should stabilize, not grow continuously