Performance em APIs Node.js: Profiling e Otimização

npm install -g clinic

# Detecta automaticamente o tipo de problema
clinic doctor -- node server.js

# Análise detalhada de CPU
clinic flame -- node server.js

# Perfil de I/O e delays de event loop
clinic bubbleprof -- node server.js

// Sem dependências externas
const v8Profiler = require('v8-profiler-next');
const fs = require('fs');

// Inicia o profiling
v8Profiler.startProfiling('API Profile', true);

// Após a janela que você quer analisar:
setTimeout(() => {
  const profile = v8Profiler.stopProfiling('API Profile');
  profile.export((error, result) => {
    fs.writeFileSync('profile.cpuprofile', result);
    profile.delete();
    // Abra no Chrome DevTools > Performance > Load Profile
  });
}, 30000);

// Lento para payloads > 100KB
app.post('/import', express.json({ limit: '10mb' }), (req, res) => {
  const data = req.body; // JSON.parse já aconteceu aqui
  processData(data);
});

// Melhor: streaming parser
import { createStream } from 'JSONStream';
import { pipeline } from 'stream/promises';

app.post('/import', async (req, res) => {
  const records = [];
  const jsonStream = createStream('records.*');
  
  jsonStream.on('data', (record) => records.push(record));
  
  await pipeline(req, jsonStream);
  processData(records);
  res.json({ imported: records.length });
});

// Causa 101 queries para 100 posts
const posts = await Post.findAll();
const result = await Promise.all(
  posts.map(async (post) => ({
    ...post.toJSON(),
    author: await User.findByPk(post.authorId), // N queries!
  }))
);

// Correto: eager loading
const posts = await Post.findAll({
  include: [{ model: User, as: 'author' }],
});
// 1 query com JOIN

// Bloqueia o event loop inteiro enquanto computa
app.get('/report', (req, res) => {
  const result = heavyComputation(largeDataset); // BLOQUEANTE
  res.json(result);
});

// Melhor: worker threads para CPU-bound
import { Worker, isMainThread, parentPort } from 'worker_threads';

if (isMainThread) {
  app.get('/report', (req, res) => {
    const worker = new Worker(__filename, {
      workerData: { dataset: req.query.id }
    });
    worker.once('message', (result) => res.json(result));
  });
} else {
  const result = heavyComputation(workerData.dataset);
  parentPort.postMessage(result);
}

// Leak clássico: listeners nunca removidos
class DataProcessor extends EventEmitter {
  constructor() {
    super();
    // Toda instância adiciona um listener no processo
    process.on('SIGTERM', () => this.cleanup()); // LEAK!
  }
}

// Correto: guardar referência e remover
class DataProcessor extends EventEmitter {
  constructor() {
    super();
    this._cleanup = () => this.cleanup();
    process.on('SIGTERM', this._cleanup);
  }

  destroy() {
    process.off('SIGTERM', this._cleanup);
    this.removeAllListeners();
  }
}

// .env ou configuração de deploy

// Aumenta o heap disponível (padrão ~1.5GB no Node 20)
NODE_OPTIONS=--max-old-space-size=4096

// Ativa a compilação antecipada (melhora cold start em Lambda)
NODE_OPTIONS=--enable-source-maps

// Cluster: usa todos os cores
import cluster from 'cluster';
import os from 'os';

if (cluster.isPrimary) {
  const numCPUs = os.cpus().length;
  for (let i = 0; i < numCPUs; i++) cluster.fork();
  cluster.on('exit', (worker) => cluster.fork()); // auto-restart
} else {
  startServer();
}

import { Histogram, Counter } from 'prom-client';

const httpDuration = new Histogram({
  name: 'http_request_duration_ms',
  help: 'Duração das requisições HTTP',
  labelNames: ['method', 'route', 'status'],
  buckets: [5, 10, 25, 50, 100, 250, 500, 1000],
});

app.use((req, res, next) => {
  const end = httpDuration.startTimer();
  res.on('finish', () => {
    end({
      method: req.method,
      route: req.route?.path ?? 'unknown',
      status: res.statusCode,
    });
  });
  next();
});

// Expor para Prometheus/Grafana
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', register.contentType);
  res.end(await register.metrics());
});