Monitoreo de aplicaciones en producción: logs, alertas y métricas

Introducción al monitoreo en producción

En el mundo del desarrollo de software, lanzar una aplicación a producción es solo el primer paso. El monitoreo continuo nos permite detectar problemas, entender el comportamiento de los usuarios y mantener la estabilidad del sistema. En este artículo exploraremos tres pilares fundamentales: logs, alertas y métricas.

1. Gestión de logs estructurados

Los logs son nuestra primera línea de defensa. Veamos cómo implementarlos correctamente:

// Ejemplo de logger estructurado en TypeScript
import winston from 'winston';

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' }),
  ],
});

// Uso básico
logger.info('Usuario autenticado', { userId: 123, method: 'POST' });
logger.error('Error de conexión a DB', { error: err.stack });

Mejores prácticas para logs:

• Usa formato JSON para facilitar el procesamiento
• Incluye contexto relevante en cada mensaje
• Establece niveles de severidad adecuados

2. Configuración de alertas inteligentes

Las alertas nos permiten reaccionar rápidamente ante problemas. Ejemplo con Prometheus y Alertmanager:

// Ejemplo de métrica para alertas
import client from 'prom-client';

// Contador de errores HTTP
const httpErrorCounter = new client.Counter({
  name: 'http_errors_total',
  help: 'Total de errores HTTP por código',
  labelNames: ['code', 'method', 'path'],
});

// Middleware de Express para capturar errores
app.use((err, req, res, next) => {
  httpErrorCounter.inc({
    code: res.statusCode,
    method: req.method,
    path: req.path
  });
  next(err);
});

Regla de alerta para Prometheus (alert.rules.yml):

groups:
- name: example
  rules:
  - alert: HighErrorRate
    expr: rate(http_errors_total[5m]) > 10
    for: 10m
    labels:
      severity: critical
    annotations:
      summary: "Alta tasa de errores HTTP"
      description: "{{ $value }} errores por segundo detectados"

3. Métricas clave para monitoreo

Las métricas nos dan una visión cuantitativa del rendimiento. Implementación con OpenTelemetry:

// Configuración básica de métricas
import { MeterProvider, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';

const meterProvider = new MeterProvider();

const exporter = new OTLPMetricExporter({
  url: 'http://collector:4318/v1/metrics'
});

meterProvider.addMetricReader(new PeriodicExportingMetricReader({
  exporter: exporter,
  exportIntervalMillis: 60000
}));

const meter = meterProvider.getMeter('my-app-meter');

// Ejemplo de métrica de tiempo de respuesta
const responseTime = meter.createHistogram('http_response_time_ms', {
  description: 'Tiempo de respuesta de las peticiones HTTP',
  unit: 'ms',
  valueType: ValueType.DOUBLE
});

Métricas esenciales para cualquier aplicación:

• Tiempo de respuesta (p50, p90, p99)
• Tasa de errores (4xx, 5xx)
• Uso de recursos (CPU, memoria, disco)
• Throughput (peticiones/segundo)

4. Integración con herramientas cloud

Para equipos que usan AWS, aquí un ejemplo de CloudWatch:

// Envío de métricas personalizadas a AWS CloudWatch
import { CloudWatch, PutMetricDataCommand } from '@aws-sdk/client-cloudwatch';

const cloudwatch = new CloudWatch({ region: 'us-east-1' });

async function publishMetric(metricName, value, dimensions) {
  const params = {
    MetricData: [{
      MetricName: metricName,
      Dimensions: dimensions,
      Value: value,
      Unit: 'Count',
      Timestamp: new Date()
    }],
    Namespace: 'MyApp'
  };

  await cloudwatch.send(new PutMetricDataCommand(params));
}

// Uso
await publishMetric('ActiveUsers', 42, [
  { Name: 'Environment', Value: 'Production' }
]);

5. Visualización con Grafana

Crear dashboards efectivos es crucial. Ejemplo de consulta para visualizar errores:

// Consulta PromQL para Grafana
sum(rate(http_errors_total{code=~"5.."}[5m])) by (code)
/ sum(rate(http_requests_total[5m])) by (code)
* 100

Consejos para dashboards efectivos:

• Agrupa métricas relacionadas
• Usa umbrales de colores para estados críticos
• Incluye comparativas con periodos anteriores

Conclusión

Implementar un sistema de monitoreo robusto con logs estructurados, alertas proactivas y métricas relevantes es fundamental para mantener aplicaciones saludables en producción. Las herramientas mostradas (Winston, Prometheus, OpenTelemetry) forman un stack moderno accesible para equipos de cualquier tamaño.