¿Cómo abordas el logging y el monitoreo en producción con Node?

Question

Accepted Answer

El **logging** registra lo que hace tu aplicación; el **monitoreo** rastrea su salud y rendimiento. Juntos te dan **observabilidad**: la capacidad de entender y depurar un sistema de producción en ejecución. `console.log` es inadecuado para esto; necesitas logs estructurados, métricas y alertas.

## Logging estructurado (no console.log)

```js
import pino from "pino";
const logger = pino();

// ✅ logs JSON estructurados — parseables por máquina, buscables, con contexto
logger.info({ userId: 123, action: "login", ip: req.ip }, "user logged in");
logger.error({ err, requestId }, "failed to process order");
```

Usa un logger estructurado (pino/winston) que produzca **JSON** con campos consistentes. Los logs JSON son buscables y filtrables en herramientas de agregación de logs, a diferencia de los strings de formato libre de `console.log`. Incluye contexto (id de usuario, id de solicitud) en cada log.

## Niveles de log y qué registrar

```text
Niveles: error > warn > info > debug (configura el umbral por entorno)
Registra: solicitudes, errores con stack traces, eventos de negocio clave, operaciones lentas
NO registres: contraseñas, tokens, PII, payloads completos con secretos (seguridad/privacidad)
```

## Los correlation IDs rastrean una solicitud entre servicios

```js
// adjunta un id único por solicitud, inclúyelo en CADA log de esa solicitud
app.use((req, res, next) => {
  req.id = crypto.randomUUID();
  res.setHeader("X-Request-Id", req.id);
  next();
});
// ahora puedes filtrar todos los logs de una solicitud — vital en microservicios
```

Un **correlation/request ID** te permite reconstruir la historia completa de una sola solicitud, incluso a través de múltiples servicios; indispensable para depurar sistemas distribuidos.

## Centraliza los logs

```text
Envía los logs a una plataforma central (ELK/Elasticsearch, Datadog, Grafana Loki, CloudWatch)
→ busca/agrega entre todas las instancias; no hagas grep de archivos en servidores individuales.
```

## Monitoreo: métricas, alertas, tracing

```text
Métricas:  tasa de solicitudes, tasa de errores, latencia (p50/p95/p99), CPU/memoria, event-loop lag
           (a menudo con Prometheus + Grafana, o un APM como Datadog/New Relic)
Salud:     endpoints /health y /ready para load balancers y orquestadores
Alertas:   notifica (PagerDuty/Slack) cuando la tasa de errores se dispara o la latencia se degrada
Tracing:   tracing distribuido (OpenTelemetry) para seguir solicitudes entre servicios
Errores:   error tracking (Sentry) para excepciones agregadas con stack traces y contexto
```

Las métricas clave a vigilar son las **"golden signals"**: latencia, tráfico, errores y saturación. Alertar sobre estas detecta problemas antes de que los usuarios los reporten.

## Por qué es importante

En producción no puedes adjuntar un depurador: **la observabilidad mediante logging y monitoreo es cómo entiendes, depuras y operas** un sistema en vivo.

Los logs JSON estructurados con correlation IDs hacen que los incidentes sean diagnosticables (especialmente entre microservicios); la agregación centralizada hace que los logs sean utilizables a escala; y el monitoreo con métricas, health checks, tracing distribuido y alertas te permite detectar y responder a los problemas de forma proactiva en lugar de después de que los usuarios se quejen.

Incorporar esto (en vez de añadirlo después de una caída) es una práctica definitoria de operar servicios Node de producción fiables.