Memory Leaks em JavaScript: Diagnóstico, Causas Reais e Correção

// Isto NÃO vaza. Ciclo é irrelevante para mark-and-sweep.
function criarCicloIsolado() {
  const pedido = { id: 1 };
  const cliente = { nome: 'Ana' };
 
  pedido.cliente = cliente;
  cliente.ultimoPedido = pedido; // referência circular
 
  return null; // ninguém mais alcança pedido nem cliente
}
 
criarCicloIsolado();
// Ambos são coletados no próximo major GC.

// medir-heap.js — rode com: node --expose-gc medir-heap.js
// --expose-gc é a única forma confiável de medir heap "limpo" sem
// confundir lixo pendente com vazamento real.
 
function heapDepoisDoGC() {
  global.gc(); // força major GC síncrono
  const { heapUsed, external, arrayBuffers } = process.memoryUsage();
  return {
    heapMB: (heapUsed / 1024 / 1024).toFixed(2),
    externalMB: (external / 1024 / 1024).toFixed(2),
    arrayBuffersMB: (arrayBuffers / 1024 / 1024).toFixed(2),
  };
}
 
setInterval(() => {
  console.log(new Date().toISOString(), heapDepoisDoGC());
}, 10_000);

// ERRADO: cada requisição adiciona um listener no processo
import http from 'node:http';
import { EventEmitter } from 'node:events';
 
const barramentoDeMetricas = new EventEmitter();
 
const servidor = http.createServer((req, res) => {
  // Esse listener nunca é removido. Ele captura `req` e `res`,
  // que por sua vez seguram o socket e os headers.
  barramentoDeMetricas.on('flush', () => {
    console.log('requisição ainda viva:', req.url);
  });
 
  res.end('ok');
});
 
servidor.listen(3000);

// CORRETO: escopo do listener casado com o escopo do request
import http from 'node:http';
import { EventEmitter } from 'node:events';
 
const barramentoDeMetricas = new EventEmitter();
 
const servidor = http.createServer((req, res) => {
  const aoDarFlush = () => {
    console.log('requisição ainda viva:', req.url);
  };
 
  barramentoDeMetricas.on('flush', aoDarFlush);
 
  // 'close' dispara mesmo quando o cliente aborta a conexão,
  // o que 'finish' não garante. Usar 'close' evita leak em aborts.
  res.on('close', () => {
    barramentoDeMetricas.off('flush', aoDarFlush);
  });
 
  res.end('ok');
});
 
servidor.listen(3000);

// hook React que remove todos os listeners com um único sinal
import { useEffect, useRef, useState } from 'react';
 
export function usePosicaoDeScroll() {
  const [posicao, setPosicao] = useState(0);
  const ticking = useRef(false);
 
  useEffect(() => {
    const controlador = new AbortController();
 
    const aoRolar = () => {
      if (ticking.current) return;
      ticking.current = true;
      requestAnimationFrame(() => {
        setPosicao(window.scrollY);
        ticking.current = false;
      });
    };
 
    // passive: true evita bloquear a thread de composição no scroll
    window.addEventListener('scroll', aoRolar, {
      passive: true,
      signal: controlador.signal,
    });
    window.addEventListener('resize', aoRolar, { signal: controlador.signal });
 
    // um abort() derruba todos os listeners registrados com esse signal
    return () => controlador.abort();
  }, []);
 
  return posicao;
}

// ERRADO: cardinalidade infinita, cache cresce até o OOM
const cacheDeUsuarios = new Map<string, Usuario>();
 
export async function buscarUsuario(id: string): Promise<Usuario> {
  const emCache = cacheDeUsuarios.get(id);
  if (emCache) return emCache;
 
  const usuario = await db.usuario.findUniqueOrThrow({ where: { id } });
  cacheDeUsuarios.set(id, usuario); // nunca sai daqui
  return usuario;
}

import { LRUCache } from 'lru-cache';
 
interface Usuario {
  id: string;
  nome: string;
  email: string;
}
 
const cacheDeUsuarios = new LRUCache<string, Usuario>({
  max: 5_000, // teto duro de entradas: previsibilidade de memória
  ttl: 1000 * 60 * 5,
  // updateAgeOnGet: false evita que uma chave quente fique viva
  // para sempre, o que reintroduz o vazamento por outro caminho.
  updateAgeOnGet: false,
});
 
export async function buscarUsuario(id: string): Promise<Usuario> {
  const emCache = cacheDeUsuarios.get(id);
  if (emCache) return emCache;
 
  const usuario = await db.usuario.findUniqueOrThrow({ where: { id } });
  cacheDeUsuarios.set(id, usuario);
  return usuario;
}

// ERRADO: o timer de vida longa segura o buffer de 50 MB
function iniciarProcessamento(caminhoDoArquivo) {
  const conteudoBruto = fs.readFileSync(caminhoDoArquivo); // 50 MB
  const totalDeLinhas = conteudoBruto.toString().split('\n').length;
 
  // Este callback só usa totalDeLinhas, mas compartilha o Context
  // com conteudoBruto, que fica retido enquanto o intervalo existir.
  setInterval(() => {
    console.log('linhas processadas:', totalDeLinhas);
  }, 30_000);
}

// CORRETO: extraia o que precisa e feche o escopo grande
function extrairTotalDeLinhas(caminhoDoArquivo) {
  const conteudoBruto = fs.readFileSync(caminhoDoArquivo);
  return conteudoBruto.toString().split('\n').length;
  // conteudoBruto sai de escopo aqui e vira coletável
}
 
function iniciarProcessamento(caminhoDoArquivo) {
  const totalDeLinhas = extrairTotalDeLinhas(caminhoDoArquivo);
 
  const intervalo = setInterval(() => {
    console.log('linhas processadas:', totalDeLinhas);
  }, 30_000);
 
  // unref permite que o processo encerre mesmo com o timer ativo,
  // e devolver o handle permite parar explicitamente.
  intervalo.unref();
  return () => clearInterval(intervalo);
}

// ERRADO em ambiente serverless ou por-tenant
export function conectarTenant(tenantId: string) {
  setInterval(() => sincronizar(tenantId), 60_000);
}
// Cada chamada empilha um timer eterno.

// CORRETO: registry com desligamento explícito
const timersPorTenant = new Map<string, NodeJS.Timeout>();
 
export function conectarTenant(tenantId: string) {
  // idempotência: reconectar não deve criar um segundo timer
  desconectarTenant(tenantId);
 
  const timer = setInterval(() => sincronizar(tenantId), 60_000);
  timersPorTenant.set(tenantId, timer);
}
 
export function desconectarTenant(tenantId: string) {
  const timer = timersPorTenant.get(tenantId);
  if (!timer) return;
  clearInterval(timer);
  timersPorTenant.delete(tenantId);
}
 
// Sem esse handler, um SIGTERM deixa timers pendurados e o processo
// demora até o kill -9 do orquestrador.
process.on('SIGTERM', () => {
  for (const tenantId of timersPorTenant.keys()) desconectarTenant(tenantId);
});

// ERRADO: guardar referência a nó que será removido
const cacheDeElementos = {};
 
function renderizarModal(dados) {
  const modal = document.createElement('div');
  modal.innerHTML = montarConteudo(dados);
  document.body.appendChild(modal);
 
  cacheDeElementos.ultimoModal = modal; // referência forte
 
  modal.querySelector('.fechar').addEventListener('click', () => {
    modal.remove(); // sai do DOM, mas segue vivo no heap
  });
}

// CORRETO: WeakRef quando você precisa mesmo guardar referência
const cacheDeElementos = {};
 
function renderizarModal(dados) {
  const modal = document.createElement('div');
  modal.innerHTML = montarConteudo(dados);
  document.body.appendChild(modal);
 
  // WeakRef não impede coleta. deref() retorna undefined
  // depois que o GC recolheu o nó.
  cacheDeElementos.ultimoModal = new WeakRef(modal);
 
  modal.querySelector('.fechar').addEventListener('click', () => {
    modal.remove();
    delete cacheDeElementos.ultimoModal;
  });
}
 
function focarUltimoModal() {
  const modal = cacheDeElementos.ultimoModal?.deref();
  if (!modal) return; // já foi coletado, comportamento esperado
  modal.focus();
}

// snapshot-endpoint.ts
import { writeHeapSnapshot } from 'node:v8';
import { randomUUID } from 'node:crypto';
import type { FastifyInstance } from 'fastify';
 
export async function registrarDiagnostico(app: FastifyInstance) {
  app.post('/_internal/heap-snapshot', async (request, reply) => {
    // Endpoint de diagnóstico precisa de guarda: escrever snapshot
    // pausa a thread principal por segundos em heaps de 1 GB+.
    if (request.headers['x-diagnostic-token'] !== process.env.DIAGNOSTIC_TOKEN) {
      return reply.code(404).send();
    }
 
    const caminho = `/tmp/heap-${Date.now()}-${randomUUID()}.heapsnapshot`;
    writeHeapSnapshot(caminho);
    return { caminho };
  });
}

// allocation-profile.ts
import { Session } from 'node:inspector/promises';
import { writeFile } from 'node:fs/promises';
 
export async function coletarPerfilDeAlocacao(duracaoMs: number) {
  const sessao = new Session();
  sessao.connect();
 
  await sessao.post('HeapProfiler.enable');
  // trackAllocations: true registra a stack de cada alocação.
  // Custa 10-30% de throughput, então rode em uma instância isolada.
  await sessao.post('HeapProfiler.startSampling', {
    samplingInterval: 32_768, // bytes entre amostras: menor = mais preciso e mais caro
  });
 
  await new Promise((resolve) => setTimeout(resolve, duracaoMs));
 
  const { profile } = await sessao.post('HeapProfiler.stopSampling');
  await writeFile(`/tmp/alloc-${Date.now()}.heapprofile`, JSON.stringify(profile));
 
  sessao.disconnect();
}

# ERRADO: adia o problema e piora o tempo de major GC
node --max-old-space-size=8192 servidor.js

// ERRADO
if (process.memoryUsage().heapUsed > LIMITE) {
  global.gc(); // pausa síncrona, mata a latência
}

// ERRADO
emitter.setMaxListeners(0); // "resolvido"

// ERRADO: delete em objeto grande degrada o hidden class do V8
delete registro.payloadGigante;
 
// CORRETO: nulificar preserva o shape do objeto
registro.payloadGigante = null;