Fix JavaScript heap out of memory: FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed in Node.js

This error occurs when Node.js runs out of heap memory, usually due to a memory leak from growing arrays, unclosed event listeners, or large data loaded without streaming. Fix it by identifying the leak source with heap snapshots, using streams for large data, and cleaning up event listeners properly.

Reading the Stack Trace

Here's what each line means:

• FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory: V8 failed to allocate memory after retrying garbage collection, meaning the heap is completely exhausted.
• Mark-sweep 2047.2 (2049.5) -> 2046.8 (2049.5) MB, 250.1 / 0.0 ms: The garbage collector could only free 0.4 MB from a 2 GB heap, indicating most objects are still reachable and cannot be freed.
• v8::internal::Heap::FatalProcessOutOfMemory(char const*): V8 triggered a fatal OOM handler, which terminates the process immediately.

Common Causes

const cache = [];

app.get('/api/data', async (req, res) => {
  const data = await db.query('SELECT * FROM large_table');
  cache.push(...data); // Cache grows on every request
  res.json(data);
});

app.get('/api/stream', (req, res) => {
  const handler = (data) => res.write(data);
  eventEmitter.on('data', handler);
  // handler is never removed when request ends
});

const fs = require('fs');

app.get('/download', (req, res) => {
  const file = fs.readFileSync('/data/huge-export.csv');
  res.send(file);
});

The Fix

Replace the unbounded array cache with an LRU (Least Recently Used) cache that has a maximum size and TTL. This ensures memory usage stays bounded while still providing caching benefits.

const cache = [];

app.get('/api/data', async (req, res) => {
  const data = await db.query('SELECT * FROM large_table');
  cache.push(...data);
  res.json(data);
});

const LRU = require('lru-cache');

const cache = new LRU({ max: 500, ttl: 1000 * 60 * 5 });

app.get('/api/data', async (req, res) => {
  const cacheKey = 'large_table_data';
  let data = cache.get(cacheKey);

  if (!data) {
    data = await db.query('SELECT * FROM large_table');
    cache.set(cacheKey, data);
  }

  res.json(data);
});

Testing the Fix

const LRU = require('lru-cache');

describe('LRU Cache', () => {
  it('evicts old entries when max size is reached', () => {
    const cache = new LRU({ max: 2 });
    cache.set('a', 1);
    cache.set('b', 2);
    cache.set('c', 3);
    expect(cache.get('a')).toBeUndefined();
    expect(cache.get('b')).toBe(2);
    expect(cache.get('c')).toBe(3);
  });

  it('returns cached data on subsequent calls', () => {
    const cache = new LRU({ max: 100, ttl: 1000 * 60 });
    cache.set('key', [{ id: 1 }]);
    expect(cache.get('key')).toEqual([{ id: 1 }]);
  });

  it('does not exceed max size', () => {
    const cache = new LRU({ max: 5 });
    for (let i = 0; i < 100; i++) {
      cache.set(`key-${i}`, i);
    }
    expect(cache.size).toBeLessThanOrEqual(5);
  });
});

Run your tests:

npm test

Pushing Through CI/CD

git checkout -b fix/memory-leak-cache,git add src/routes/data.js package.json,git commit -m "fix: replace unbounded cache with LRU to prevent memory leaks",git push origin fix/memory-leak-cache

Your CI config should look something like this:

name: CI
on:
  pull_request:
    branches: [main]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      - run: npm ci
      - run: npm test
      - run: npm run lint

The Full Manual Process: 18 Steps

Here's every step you just went through to fix this one bug:

1. Notice the error alert or see it in your monitoring tool
2. Open the error dashboard and read the stack trace
3. Identify the file and line number from the stack trace
4. Open your IDE and navigate to the file
5. Read the surrounding code to understand context
6. Reproduce the error locally
7. Identify the root cause
8. Write the fix
9. Run the test suite locally
10. Fix any failing tests
11. Write new tests covering the edge case
12. Run the full test suite again
13. Create a new git branch
14. Commit and push your changes
15. Open a pull request
16. Wait for code review
17. Merge and deploy to production
18. Monitor production to confirm the error is resolved

Total time: 30-60 minutes. For one bug.

npm install bugstack-sdk

const { initBugStack } = require('bugstack-sdk')

initBugStack({ apiKey: process.env.BUGSTACK_API_KEY })

Deploying the Fix (Manual Path)

1. Install the lru-cache package with npm install lru-cache.
2. Run the test suite to confirm cache behavior is correct.
3. Open a pull request with the bounded cache implementation.
4. Have a teammate review the max size and TTL settings.
5. Merge to main and monitor memory usage in production dashboards.

Frequently Asked Questions