Lección 208: Registro y monitorización de eventos en microservicios

En una arquitectura de microservicios, el registro y la monitorización son importantes para:

• Detectar errores y fallos.
• Rastrear la "vida" de un evento, desde su aparición hasta su procesamiento.
• Depurar y analizar el rendimiento.
• Entender el estado general del sistema y sus componentes.

Registro de eventos: conceptos básicos

El registro de eventos en microservicios tiene sus particularidades. La idea principal —grabar cada evento— te permite saber siempre qué pasa y en qué orden. Pero el logging no debería ser solo "escribir en un archivo". Tiene que estar lo bastante estructurado y pensado. Vamos a ver los componentes principales.

Al registrar eventos es importante capturar:

1. ID del evento: identificador único para cada evento.
2. Tipo de evento: por ejemplo, "Creación de pedido", "Pago", "Actualización del estado de envío".
3. Fuente del evento: qué producer (servicio) generó el evento.
4. Marca temporal: cuándo se creó o procesó el evento.
5. Estado del evento: si hubo un fallo en el procesamiento (por ejemplo, "ejecución exitosa" o "error").
6. ID de correlación: se usa para relacionar varios eventos que pertenecen a un mismo proceso (por ejemplo, todas las etapas de ejecución de un pedido).

Ejemplo de evento JSON, como el descrito arriba:

{
  "eventId": "12345",
  "eventType": "OrderCreated",
  "source": "OrderService",
  "timestamp": "2023-10-12T10:15:30.000Z",
  "status": "SUCCESS",
  "correlationId": "abc-123-correlation-id"
}

Herramientas para el registro

En el mundo Java, la herramienta más popular para el registro es SLF4J junto con sus implementaciones, como Logback o Log4j2. Estas librerías permiten gestionar los logs a nivel de configuración y facilitan la integración con otros servicios.

Ejemplo de configuración de Logback (logback.xml):

<configuration>
    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>logs/microservice.log</file>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="INFO">
        <appender-ref ref="FILE" />
    </root>
</configuration>

Ejemplo de uso de SLF4J en Java:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class EventLogger {
    private static final Logger logger = LoggerFactory.getLogger(EventLogger.class);

    public void logEvent(String eventId, String eventType, String status) {
        logger.info("Event logged: id={}, type={}, status={}", eventId, eventType, status);
    }
}

Monitorización de eventos: conceptos básicos

Si el registro es recordar el pasado, la monitorización es la forma de mirar el presente. La monitorización de eventos te permite ver en tiempo real qué pasa en el sistema y alertarte ante problemas.

Cuando hablamos de monitorización de eventos, la analítica es clave:

1. Número de eventos: cuántos eventos se han procesado en un periodo determinado.
2. Errores: por ejemplo, el porcentaje de eventos que terminaron en error.
3. Latencia: tiempo desde la aparición del evento hasta su procesamiento.
4. Tamaño de las colas: cuántos eventos siguen esperando procesamiento.

¿Y cómo se ve eso?

Imagínate un dashboard donde ves cuántos pedidos se crearon en la última hora, cuántos terminaron con éxito y cuántos con error. Por ejemplo:

Herramientas para la monitorización

Para monitorizar eventos y construir dashboards puedes usar:

• Prometheus para recoger métricas.
• Grafana para visualización.
• ELK-stack (Elasticsearch, Logstash, Kibana) para analizar logs.

Ejemplo de configuración para Prometheus en Spring Boot:

Añade la dependencia en pom.xml:

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

Crea una métrica personalizada para el número de eventos procesados:

import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.stereotype.Component;

@Component
public class EventMetrics {

    private final MeterRegistry meterRegistry;

    public EventMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }

    public void incrementProcessedEvents() {
        meterRegistry.counter("event.processed.count").increment();
    }
}

Después de eso, la métrica event_processed_count estará disponible para la monitorización!

Configuración de ELK para analizar logs

Si quieres analizar los logs de eventos y construir dashboards, ELK-stack es una gran opción.

1. Logstash recoge los logs de tu aplicación.
2. Elasticsearch indexa los datos de los logs.
3. Kibana visualiza los datos y te permite filtrarlos.

Ejemplo de configuración de Logstash para leer logs desde un archivo:

input {
  file {
    path => "/path/to/log/file.log"
    start_position => "beginning"
  }
}

output {
  elasticsearch {
    hosts => ["http://localhost:9200"]
    index => "microservice-logs"
  }
}

Como resultado, todos los logs de tu aplicación estarán disponibles en la interfaz de Kibana, donde podrás crear dashboards, buscar errores o analizar rendimiento.

Puntos de monitorización y su análisis

En sistemas reales es importante no solo registrar hechos, sino analizarlos. Por ejemplo, si ves un aumento en el número de eventos con error, el sistema de monitorización (por ejemplo, Prometheus + Grafana o ELK) puede enviarte una alerta.

Configuración de alertas en Prometheus:

groups:
  - name: event-monitoring
    rules:
      - alert: HighErrorRate
        expr: rate(event_errors_total[5m]) > 0.05
        for: 1m
        labels:
          severity: warning
        annotations:
          description: "High error rate detected in the last 5 minutes!"

Ahora, si el nivel permitido de errores se supera, recibirás una notificación.

¿Qué puede salir mal?

El registro y la monitorización son perfectos solo en teoría. En la práctica puedes encontrarte con:

• Demasiados logs, lo que complica su análisis. Es importante loggear solo lo que realmente hace falta.
• Cuellos de botella en la monitorización, por ejemplo, si el sistema no aguanta la carga de datos de las métricas.
• Dificultades para correlacionar datos, especialmente si usas varios brokers de mensajes o muchos microservicios.

Para evitar esto, sigue la regla "menos es más": recoge solo los datos necesarios y diseña bien la estructura de eventos y métricas.

Ahora ya sabemos cómo hacer los microservicios "transparentes" y cómo sacar el máximo de información útil de simples logs y gráficos. ¡Vamos al siguiente tema!