Application Real-Time Monitoring Service:Personalizar métricas con el SDK de Java de OpenTelemetry

<dependencies>
    <dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-api</artifactId>
    </dependency>
    <dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-sdk-trace</artifactId>
    </dependency>
    <dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-sdk</artifactId>
    </dependency>
</dependencies>

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>io.opentelemetry</groupId>
      <artifactId>opentelemetry-bom</artifactId>
      <version>1.23.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

Paso 1: Agregar una métrica personalizada

El siguiente código muestra un ejemplo sencillo de una aplicación de venta flash. Define dos métricas:

• product_seckill_count: El número de intentos de venta flash.

• product_current_stock: El inventario actual del producto.

Al obtener la clase de fábrica meter para definir métricas, se pasa un parámetro product_seckill. Este parámetro funciona como identificador de grupo. Todas las métricas definidas posteriormente mediante este meter pertenecen a dicho grupo, el cual se utiliza en configuraciones posteriores.

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.metrics.LongCounter;
import io.opentelemetry.api.metrics.Meter;
import io.opentelemetry.api.metrics.ObservableLongGauge;

import javax.annotation.PreDestroy;
import java.util.concurrent.atomic.AtomicInteger;

class ProductService {

    // Static inventory counter.
    public final AtomicInteger stock = new AtomicInteger(0);

    private LongCounter seckillCounter;
    private ObservableLongGauge observableLongGauge;
    private final AttributeKey<String> seckillResult = AttributeKey.stringKey("seckill_result");

    public ProductService() {
        OpenTelemetry agentOpenTelemetry = GlobalOpenTelemetry.get();

        // Define the metric factory class. The 'product_seckill' name is important.
        Meter meter = agentOpenTelemetry.getMeter("product_seckill");
        // Define a counter to record the number of flash sale attempts.
        seckillCounter = meter.counterBuilder("product_seckill_count")
                .setUnit("1")
                .setDescription("seckill product count")
                .build();

        // Define a gauge to represent the current product inventory.
        observableLongGauge = meter.gaugeBuilder("product_current_stock").ofLongs().buildWithCallback((measurement -> {
            // Record the current product quantity.
            measurement.record(stock.get());
        }));

    }
    
    @PreDestroy
    public void clear() {
        observableLongGauge.close(); 
    }
    
    public void setKillProductCount(int count) {
        stock.set(count);
    }

    public String seckillProduct() {
        int currentStock = stock.get();
        if (currentStock <= 0) {
            seckillCounter.add(1, Attributes.of(seckillResult, "failed"));
            return "Flash sale failed. The product is sold out.";
        }
        // Try to decrement the stock.
        if (stock.decrementAndGet() >= 0) {
            seckillCounter.add(1, Attributes.of(seckillResult, "success"));
            return "Flash sale successful. Remaining stock: " + stock.get();
        } else {
            stock.incrementAndGet(); // Rollback.
            seckillCounter.add(1, Attributes.of(seckillResult, "failed"));
            return "Flash sale failed. The product is sold out.";
        }
    }
}

Paso 2: Configurar la recopilación de métricas

En la consola, modifique Custom Metric Collection Configuration agregando el nombre del grupo que especificó al crear el Meter en el paso anterior.

Esta configuración surte efecto únicamente en versiones del agente 4.5.0 o posteriores y no requiere reiniciar la aplicación. Al finalizar, haga clic en Save.

Paso 3: Consultar métricas y configurar alertas

1. En la consola de ARMS, vaya a la página Managed Service for Prometheus > Instances. En la barra de menú superior, seleccione la región donde se despliega su aplicación. Busque la instancia de almacenamiento de Prometheus cuyo nombre comienza con metricstore-apm-metrics-custom y luego haga clic en Shared Edition para abrir Grafana.

2. En la página de Grafana, haga clic en Explore. En la lista desplegable de fuentes de datos, seleccione la instancia de almacenamiento de Prometheus del paso anterior.

   En la página de carpetas de Grafana, si la carpeta está vacía, verá el mensaje This folder doesn't have any dashboards yet. Haga clic en + Create Dashboard para agregar uno nuevo, o haga clic en Manage dashboards para mover un panel existente a la carpeta.

3. Utilice PromQL para consultar las métricas personalizadas definidas en su código, como se muestra en la siguiente figura. También puede crear un custom observability dashboard en Grafana.

   

ARMS reporta y almacena las métricas personalizadas definidas con el SDK de OpenTelemetry en su instancia de almacenamiento de Prometheus. Posteriormente, puede create alert rules para estas métricas.

Notas de uso

• ARMS reporta métricas en intervalos de 15 segundos.

• Para las métricas de tipo counter, ARMS reporta el valor incremental dentro de cada intervalo de reporte, no el total acumulado.