Gestión del rendimiento de las aplicaciones con InspectIT

Hoy vamos a ver una herramienta open source para realizar diferentes tipos de tareas, desde tracing, monitorización o instrumentación: inspectIT. Esta herramienta es un Java Agent, los cuales ya conocemos algo mejor por el último post que hicimos, y que puedes ver aquí. 

Este software intenta minimizar dos cosas. Por un lado, el tiempo de configuración necesario para utilizar otras herramientas de Application Performance Management, APM. Tal y como pueden ser Jaeger, Prometheus, Zipkin o Micrometer. Y por otro reducir las modificaciones a realizar en nuestras aplicaciones si queremos realizar tareas de instrumentación. 

InspectIT esta basado en OpenCensus, que es un conjunto de librerías open software realizada en distintos lenguajes que permiten obtener métricas y trazas distribuidas. Dicho software tiene ya una amplia gama de exporters que permiten enviar la información a otras herramientas de monitorización. Y inspectIT soporta la mayoría de estos exporters. 

Por todo ello, inspectIT es una herramienta genial. Al ser un Java Agent no necesitaremos modificar nuestras aplicaciones para obtener información de su rendimiento. Y además permite obtener métricas y trazas de forma automática y enviarlas a distintos destinos. 

A través de los ejemplos, podremos ver como obtener las trazas y métricas de nuestra aplicación. El funcionamiento será similar en los distintos ejemplos. Para poder hacerlo funcionar deberemos seguir los dos siguientes pasos:

• Asociar el java agent almacenado en la librería a través del argumento de la JVM '-javaagent:/full/path/to/library'.
• Asociar a través de un argumento de la JVM la propiedad del exporter a utilizar. 

Para el primer ejemplo, usaremos un exporter de Jaeger, con el cual podremos obtener las trazas de la aplicación. La base del mismo será uno de nuestros ejemplos que hemos hecho en post anteriores, basados en Apache Camel, y que puedes ver aquí. Cabe recordar que Jaeger es una herramienta o Tracer que nos permitirá recolectar la información de las trazas de nuestra aplicación y visualizarlas en un interfaz gráfica propia 

Los pasos son los siguientes: 

• Por un lado, tenemos que hacer es descargarnos la librería que contiene el java agent, lo podemos hacer desde aquí. Y la ubicamos en una ruta que indicaremos más adelante al arrancar la aplicación. 
• Arrancar Jaeger, por ejemplo con un docker-compose como el siguiente.

version: '2.4'
networks:
  sandbox-apache-net:
    ipam:
      driver: default
      config:
        - subnet: 172.24.0.0/16

services:
  mysql:
    image: mysql:5.7.26
    mem_limit: 2G
    container_name: sandbox-apache-mysql
    hostname: sandbox-apache-mysql
    networks:
      sandbox-apache-net:
        ipv4_address: 172.24.1.1
    environment:
      MYSQL_HOST: sandbox-apache-mysql
      MYSQL_ROOT_PASSWORD: root
    ports:
      - 3306:3306
    volumes:
      - ./configs/mysql/conf.d/custom.cnf:/etc/mysql/conf.d/custom.cnf
      - ./configs/mysql/scripts:/docker-entrypoint-initdb.d

  jaeger:
    image: jaegertracing/all-in-one:latest
    ports:
      - 16686:16686
      - 14268:14268

• Por último arrancar la JVM pasandole los argumentos que nos permitan configurar el exporter deseado. Para el caso de Jaeger usaremos los siguientes:

-javaagent:/home/deesebc/Downloads/inspectit-ocelot-agent-1.8.1.jar \

-Dinspectit.exporters.tracing.jaeger.url=http://127.0.0.1:14268/api/traces \

-Dinspectit.exporters.tracing.jaeger.service-name=inspectitJaegerExample

En la propiedad URL indicamos la dirección donde esta ubicado Jaeger, y con service-name podemos indicar el nombre con el cual registraremos las trazas de Jaeger. 

Como paso previo a ver el funcionamiento en Jaeger, vamos ha hacer varias consultas a nuestra aplicación. Para que así puedan ser registradas por inspectIT. Si usas el código de mi aplicación, será una invocación similar a esta: http://localhost:9090/book/1.

Si accedemos a la URL http://localhost:16686/search podremos acceder al buscador de trazas y buscar por las de nuestra aplicación.

La siguiente parte del ejemplo, para ver más del potencial de inspectIT y ver su funcionamiento para obtener métricas haremos uso de los exporters para Prometheus. El ejemplo en el que nos basaremos, será este. 

Empezamos de nuevo preparando un docker-compose que nos permita desplegar Prometheus. Podemos basarnos en el del ejemplo anterior y sería algo similar a esto:

version: '2.4'
networks:
  sandbox-apache-net:
    ipam:
      driver: default
      config:
        - subnet: 172.24.0.0/16

services:
  mysql:
    image: mysql:5.7.26
    mem_limit: 2G
    container_name: sandbox-apache-mysql
    hostname: sandbox-apache-mysql
    networks:
      sandbox-apache-net:
        ipv4_address: 172.24.1.1
    environment:
      MYSQL_HOST: sandbox-apache-mysql
      MYSQL_ROOT_PASSWORD: root
    ports:
      - 3306:3306
    volumes:
      - ./configs/mysql/conf.d/custom.cnf:/etc/mysql/conf.d/custom.cnf
      - ./configs/mysql/scripts:/docker-entrypoint-initdb.d
      
  prometheus:
    image: prom/prometheus:v2.6.1
    ports:
      - 9091:9090
    volumes:
      - ./configs/prometheus.yml:/etc/prometheus/prometheus.yml
    networks:
      sandbox-apache-net:
        ipv4_address: 172.24.1.2
    extra_hosts:
      docker.host: 172.28.0.1

172.28.0.1 es la IP de la interfaz bridge de docker. 

El siguiente punto será arrancar nuestra aplicación con los argumentos que nos permitan exportar la información a Prometheus. 

-javaagent:/home/deesebc/Downloads/inspectit-ocelot-agent-1.8.1.jar \

-Dinspectit.exporters.metrics.prometheus.host=172.28.0.1 \

-Dinspectit.exporters.metrics.prometheus.port=8888

Recordemos que para que Prometheus funcione, tiene que leer de una URL información sobre la aplicación. Por lo que por un lado debemos configurar, que Prometheus lea de un punto específico. Y esto lo haremos a través del fichero de configuración de Prometheus (parte del docker-compose):

scrape_configs:
  - job_name: 'prometheus'
    scrape_interval: 1m
    static_configs:
      - targets: ['localhost:9090']
  - job_name: 'apache_example'
    scrape_interval: 1m
    metrics_path: '/metrics'
    static_configs:
      - targets: ['172.28.0.1:8888']

Y a través de los argumentos JVM, indicaremos a inspectIT que queremos exponer la información de nuestra aplicación en la IP y puerto indicados. Algo que en el ejemplo en el cual nos basamos era realizado por Spring Actuator.  

Una vez con todo arrancado, realizaremos un par de invocaciones como las comentadas anteriormente. Y ya podremos acceder a Prometheus y ver la monitorización que se ha realizado del mismo. 

Si accedemos a la ruta http://localhost:8888/metrics podremos ver las distintas métricas que estamos generando desde la aplicación. Y si accedemos a la URL de Prometheus http://localhost:9091/targets podremos observar si nuestro endpoint esta siendo leído correctamente por Prometheus.

El siguiente paso será acceder a http://localhost:9091/graph y realizar algún gráfico en función de las métricas obtenidas. Por ejemplo uno que cuente las invocaciones que realizamos a endpoints de nuestra aplicación, a través del parámetro http_in_count.

Como veis, realmente facil. Ya no hay excusas para realizar tareas de gestión del rendimiento de las aplicaciones con InspectIT. Y esto han sido un par de ejemplos, pero podréis hacer más cosas a través de los distintos exporters.