Conceptos Básicos de Rendimiento

8 ejemplos para empezar con el Rendimiento para backends de Node.js - 6 básicos y 2 intermedios.

Prerrequisitos

• Node.js 24.18.0 instalado.
• Un servicio HTTP en ejecución (Express 5 o Fastify 5) para comparar.
• Opcional: npm install -g clinic para perfilar (ver Suite clinic.js).

Ejemplos Básicos

1. Medir la Duración de la Solicitud con hrtime

Los temporizadores de alta resolución superan a Date.now() para la medición de latencia.

import { createServer } from "node:http";
 
const server = createServer((req, res) => {
  const start = process.hrtime.bigint();
  res.end("ok");
  const elapsedMs = Number(process.hrtime.bigint() - start) / 1_000_000;
  console.log(JSON.stringify({ path: req.url, durationMs: elapsedMs }));
});
server.listen(3000);

• process.hrtime.bigint() es monotónico, no afectado por la deriva del reloj.
• Registra JSON estructurado para que los agregadores puedan calcular p50/p95/p99.
• La temporización del manejador excluye el RTT de la red; combínalo con pruebas de carga para SLOs de extremo a extremo.

Relacionado: Pruebas de Carga - saturación y p95 bajo concurrencia

2. Rastrear la Latencia p95 en el Código de la Aplicación

Los percentiles importan más que los promedios para los SLO de API.

const durations: number[] = [];
 
function recordDuration(ms: number): void {
  durations.push(ms);
  if (durations.length > 10_000) durations.shift();
}
 
function p95(): number {
  const sorted = [...durations].sort((a, b) => a - b);
  const idx = Math.ceil(sorted.length * 0.95) - 1;
  return sorted[idx] ?? 0;
}
 
// Exponer a través de /metrics o registrar cada N solicitudes

• La latencia promedio oculta las solicitudes de cola lenta que los usuarios perciben.
• p95 es un objetivo SLO común para APIs internas (p99 para APIs orientadas al cliente).
• En producción, exporta histogramas a través de OpenTelemetry o Prometheus; no mantengas arrays en memoria a largo plazo.

Relacionado: Métricas Importantes - RPS, p95, tasa de errores

3. Monitorear el Retraso del Bucle de Eventos

El retraso del bucle afecta a cada cliente concurrente, no solo a una ruta lenta.

import { monitorEventLoopDelay } from "node:perf_hooks";
 
const histogram = monitorEventLoopDelay({ resolution: 20 });
histogram.enable();
 
setInterval(() => {
  console.log(JSON.stringify({
    event: "loop_delay",
    p99Ms: histogram.percentile(99) / 1e6,
    maxMs: histogram.max / 1e6,
  }));
  histogram.reset();
}, 10_000);

• monitorEventLoopDelay mide cuánto se retrasa el bucle al ejecutar el trabajo programado.
• Un aumento en el retraso del bucle p99 con una CPU moderada indica un bloqueo síncrono en el hilo principal.
• Alerta antes de que el p95 orientado al usuario se duplique; el retraso del bucle es una advertencia temprana.

Relacionado: Detección de Bloqueo del Bucle de Eventos - herramientas de atribución

4. Usar performance.mark para Rutas Críticas

Las marcas integradas se integran con Chrome DevTools y clinic.js.

import { performance } from "node:perf_hooks";
 
async function fetchUser(id: string) {
  performance.mark("fetchUser:start");
  const user = await db.query("SELECT * FROM users WHERE id = $1", [id]);
  performance.mark("fetchUser:end");
  performance.measure("fetchUser", "fetchUser:start", "fetchUser:end");
  return user;
}

• Las marcas son baratas cuando se usan en rutas de código acotadas, no en cada línea.
• performance.getEntriesByName("fetchUser") devuelve arrays de duración para el análisis.
• Borra las marcas periódicamente en procesos de larga duración para evitar el crecimiento de la memoria.

Relacionado: Suite clinic.js - gráficos de llama para rutas críticas

5. Rendimiento Base Antes de la Optimización

Conoce las solicitudes por segundo en la concurrencia objetivo antes de cambiar el código.

# Prueba rápida (no una prueba de carga completa)
npx autocannon -c 50 -d 10 http://localhost:3000/health

• -c 50 simula 50 conexiones concurrentes, más cerca de la producción que un solo curl.
• Registra RPS, latencia p99 y tasa de errores como tu instantánea de referencia.
• Vuelve a ejecutar después de cada afirmación de optimización: los números superan la intuición.

Relacionado: Pruebas de Carga - escenarios de k6 y puntos de saturación

6. Limitar el Tamaño de la Carga Útil en el Borde

Los cuerpos JSON grandes bloquean el análisis de forma síncrona en el hilo principal.

import express from "express";
 
const app = express();
app.use(express.json({ limit: "1mb" }));
 
app.post("/events", (req, res) => {
  // el cuerpo ya está limitado - rechaza los de tamaño excesivo en el analizador
  res.status(201).json({ ok: true });
});

• limit devuelve 413 antes de que se ejecute tu manejador, lo que ahorra CPU en caso de abuso.
• Combínalo con una dieta de la forma de la respuesta: devuelve solo los campos que los clientes necesitan.
• Los puntos finales de streaming necesitan límites diferentes a las APIs CRUD de JSON.

Relacionado: Costo de Serialización JSON - dieta de la forma de la respuesta

Ejemplos Intermedios

7. Script de Prueba de Carga Similar a Producción

La concurrencia sostenida revela bloqueos que las solicitudes individuales ocultan.

// script k6 - guardar como load-test.js
import http from "k6/http";
import { check, sleep } from "k6";
 
export const options = {
  stages: [
    { duration: "1m", target: 50 },
    { duration: "3m", target: 50 },
    { duration: "1m", target: 0 },
  ],
  thresholds: { http_req_duration: ["p(95)<200"] },
};
 
export default function () {
  const res = http.get("http://localhost:3000/users");
  check(res, { "status is 200": (r) => r.status === 200 });
  sleep(0.1);
}

• Aumenta gradualmente: el tráfico instantáneo de picos prueba el generador de carga, no tu aplicación de manera justa.
• thresholds falla la ejecución cuando p95 excede los 200ms, lo que impide las fusiones en caso de regresión.
• Ejecuta contra el entorno de staging con un volumen de datos y tamaños de pool de conexiones similares a los de producción.

Relacionado: Rendimiento en Express - ajuste de Express bajo carga

8. Instantánea del Heap Cuando la Memoria Crece

Las fugas sospechosas necesitan evidencia antes de ajustar --max-old-space-size.

import { writeHeapSnapshot } from "node:v8";
import { writeFileSync } from "node:fs";
 
function captureHeap(label: string): void {
  const path = writeHeapSnapshot();
  writeFileSync(`/tmp/heap-${label}.json`, ""); // archivo marcador
  console.log(JSON.stringify({ event: "heap_snapshot", label, path }));
}
 
// Llamar en SIGUSR2 o después de N solicitudes en staging
process.on("SIGUSR2", () => captureHeap("manual"));

• Compara dos instantáneas en Chrome DevTools para encontrar objetos retenidos.
• No tomes instantáneas de producción bajo tráfico: pausa el proceso.
• Corrige las fugas antes de aumentar los límites del heap: los heaps más grandes retrasan el dolor del GC, no la causa raíz.

Relacionado: Ajuste de Memoria y GC - --max-old-space-size y banderas de GC

Versiones de la pila: Esta página fue escrita para Node.js 24.18.0 (LTS Activo), npm 10+, TypeScript 5.6+, Express 5, Fastify 5 y NestJS 11.