Lección 115: Práctica: configuración y visualización de métricas de la aplicación

1. Integración de Actuator en el proyecto de práctica

Para empezar necesitamos conectar Spring Boot Actuator a nuestro proyecto existente (o uno nuevo). Conectar Actuator es, básicamente, añadir una dependencia.

Si usas Maven, añade la siguiente dependencia en pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Si trabajas con Gradle, añade esta línea en tu build.gradle:

implementation 'org.springframework.boot:spring-boot-starter-actuator'

Después actualiza las dependencias de tu proyecto. ¡Actuator activado! Fácil, ¿no? Esto es la magia de Spring.

2. Comprobación de disponibilidad de los endpoints

Después de añadir la dependencia de Actuator, arranca tu aplicación. Por defecto Actuator proporciona varios endpoints estándar para monitorizar.

Por ejemplo:

• /actuator/health — estado de la aplicación.
• /actuator/info — información sobre la aplicación.
• /actuator/metrics — distintas métricas de rendimiento.

Prueba a abrir /actuator/health desde el navegador o Postman. Si ves algo como {"status":"UP"}, entonces Actuator se integró correctamente en el proyecto.

El camino secreto hacia la felicidad: configurar la ruta base de los endpoints

Si te preguntas — "¿Se puede hacer la ruta de estos endpoints más cómoda o, por el contrario, protegerla de ojos demasiado curiosos?" — sí, se puede. En el archivo application.properties puedes cambiar la ruta base:

management.endpoints.web.base-path=/my-actuator

Ahora todos tus endpoints estarán disponibles, por ejemplo, en /my-actuator/health.

3. Visualización de métricas

Trabajando con /metrics

El endpoint /actuator/metrics es una verdadera mina. Aquí encontrarás métricas sobre el número de hilos activos, uso de memoria, carga de CPU y mucho más. Escribe en el navegador o Postman:

http://localhost:8080/actuator/metrics

La lista de métricas puede ser extensa. Aquí tienes un ejemplo de lo que podrías ver:

{
  "names": [
    "jvm.memory.used",
    "jvm.memory.max",
    "process.cpu.usage",
    "system.cpu.usage",
    "http.server.requests",
    ...
  ]
}

Puedes solicitar información detallada de una métrica concreta. Por ejemplo, para ver cuánta memoria usa la JVM, solicita:

http://localhost:8080/actuator/metrics/jvm.memory.used

Y obtendrás algo así:

{
  "name": "jvm.memory.used",
  "measurements": [
    {
      "statistic": "VALUE",
      "value": 12345678
    }
  ],
  "availableTags": [
    {
      "tag": "area",
      "values": ["heap", "nonheap"]
    }
  ]
}

"Vale, ahora sé cuánta memoria se está consumiendo" — dirás. Y tendrás razón.

Ejercicio práctico: habilitar endpoints

No todos los endpoints de Actuator están habilitados por defecto. Vamos a activar métricas adicionales. En application.properties añade la siguiente configuración:

management.endpoints.web.exposure.include=*

Ahora están disponibles todos los endpoints de Actuator. Actualiza la lista de métricas disponibles solicitando /actuator.

4. Análisis de métricas en tiempo real

Imagínate que eres el administrador (o el "Señor de las métricas"), y tu aplicación de repente empieza a ir lenta. Puedes revisar /metrics y ver si hay una carga elevada. Por ejemplo, la métrica http.server.requests te mostrará qué requests están generando la carga.

Esto podría verse así:

{
  "name": "http.server.requests",
  "measurements": [
    {
      "statistic": "COUNT",
      "value": 120
    },
    {
      "statistic": "MAX",
      "value": 150.5
    }
  ],
  "availableTags": [
    {
      "tag": "method",
      "values": ["GET", "POST"]
    },
    {
      "tag": "uri",
      "values": ["/api/users", "/api/orders"]
    }
  ]
}

Puedes saber cuántas peticiones se están procesando, por ejemplo, en /api/users. ¿Útil? Seguro que sí.

5. Ejercicio práctico: configurar una métrica personalizada

Bueno, es momento de improvisar un poco y añadir tu propia métrica. Imagina que quieres monitorizar la cantidad de productos en el carrito de los usuarios.

Añade el siguiente código en uno de tus components:

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

@Component
public class CartMetrics {

    private final MeterRegistry meterRegistry;

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

    public void incrementCartItems(int items) {
        meterRegistry.counter("cart.items.added").increment(items);
    }
}

Ahora llama al método incrementCartItems() cuando añadas productos al carrito. La métrica cart.items.added empezará a monitorear el total de productos añadidos. Puedes comprobarla en:

http://localhost:8080/actuator/metrics/cart.items.added

6. Mejora mediante observabilidad

Con los datos en tiempo real puedes tomar decisiones. Por ejemplo, si ves que la métrica jvm.memory.used está constantemente cerca del máximo, quizá debas revisar la lógica que maneja objetos grandes o aumentar el heap de la JVM.

Si la métrica http.server.requests muestra tiempos de respuesta anormalmente bajos — es una buena señal de que tu aplicación aguanta la carga. Pero si al contrario los tiempos suben, quizá sea hora de pensar en cachear o en escalar.

Ejercicio para hacer por tu cuenta

Ahora que eres todo un experto en configurar y usar métricas, intenta lo siguiente:

1. Configura Actuator en tu proyecto de práctica.
2. Activa todos los endpoints.
3. Encuentra y analiza tres métricas clave de la aplicación (por ejemplo, rendimiento de las peticiones, uso de memoria y carga de CPU).
4. Configura una métrica personalizada para monitorizar algún aspecto importante de tu app (por ejemplo, el número de operaciones de usuario realizadas por día).
5. Intenta encontrar problemas en tu aplicación usando las métricas.

Y no olvides sentirte como un verdadero superhéroe de la monitorización!