Application Real-Time Monitoring Service:Agregar instrumentación personalizada con OpenTelemetry para Java

<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>

Conceptos clave

Esta sección describe únicamente los términos comunes. Para obtener más información sobre otros términos, consulte la especificación de OpenTelemetry.

• span: una operación específica dentro de una solicitud, como un punto de entrada de llamada remota o una llamada a método interno.

• SpanContext: el contexto de una traza, que incluye información como el ID de traza y el ID de span.

• atributo: un campo adicional en un span que registra información clave.

• Baggage: pares clave-valor que se propagan a lo largo de toda la traza.

Usar el SDK de OpenTelemetry para Java

Con el SDK de OpenTelemetry puede ejecutar las siguientes operaciones:

• Agregar instrumentación para generar spans.

• Agregar atributos a los spans.

• Propagar Baggage en el contexto de traza.

• Obtener el contexto de traza actual e imprimir información como el ID de traza y el ID de span.

A continuación se muestra un ejemplo de código que indica cómo usar el SDK de OpenTelemetry para ejecutar estas operaciones.

@RestController
@RequestMapping("/ot")
public class OpenTelemetryController {
    private Tracer tracer;
    private ScheduledExecutorService ses = Executors.newSingleThreadScheduledExecutor();
    @PostConstruct
    public void init() {
	    OpenTelemetrySdk.builder()
			.setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance()))
			.buildAndRegisterGlobal();
		tracer = GlobalOpenTelemetry.get().getTracer("manual-sdk", "1.0.0");
        ses.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                Span span = tracer.spanBuilder("schedule")
                        .setAttribute("schedule.time", System.currentTimeMillis())
                        .startSpan();
                try (Scope scope = span.makeCurrent()) {
                    System.out.println("scheduled!");
                    Thread.sleep(500L);
                    span.setAttribute("schedule.success", true);
                    System.out.println(Span.current().getSpanContext().getTraceId()); // Get the trace ID
                } catch (Throwable t) {
                    span.setStatus(StatusCode.ERROR, t.getMessage());
                } finally {
                    span.end();
                }
            }
        }, 10, 30, TimeUnit.SECONDS);
    }
    @ResponseBody
    @RequestMapping("/parent")
    public String parent() {
        Span span = tracer.spanBuilder("parent").setSpanKind(SpanKind.SERVER).startSpan();
        try (Scope scope = span.makeCurrent()) {
            // Use Baggage to propagate custom business tags.
            Baggage baggage =  Baggage.current().toBuilder()
                    .put("user.id", "1")
                    .put("user.name", "name")
                    .build();
            try (Scope baggageScope = baggage.storeInContext(Context.current()).makeCurrent()) {
                child();
            }
            span.setAttribute("http.method", "GET");
            span.setAttribute("http.uri", "/parent");
        } finally {
            span.end();
        }
        return "parent";
    }
    private void child() {
        Span span = tracer.spanBuilder("child").startSpan();
        try (Scope scope = span.makeCurrent()) {
            System.out.println("current traceId = " + Span.current().getSpanContext().getTraceId());
            System.out.println("userId in baggage = " + Baggage.current().getEntryValue("user.id"));
            Thread.sleep(1000);
        } catch (Throwable e) {
            span.setStatus(StatusCode.ERROR, e.getMessage());
        } finally {
            span.end();
        }
    }
}

Explicación del ejemplo:

1. En el método init de OpenTelemetryController, se inicia una tarea programada. Se crea un span al inicio de cada ejecución y finaliza cuando esta termina.

2. En el método parent de OpenTelemetryController, se llaman varios métodos del SDK de OpenTelemetry.

   1. Cada vez que se llama al método, se crea un span llamado parent, el cual finaliza cuando el método termina.

   2. Se usa el SDK de Baggage para agregar dos elementos de Baggage: user.id y user.name. Estos elementos se propagan a las aplicaciones descendentes.

   3. Se agregan dos atributos al span creado en el paso 2.a.

3. El método child de OpenTelemetryController ejecuta las siguientes operaciones:

   1. Cada vez que se llama al método, se crea un span llamado child, el cual finaliza cuando el método termina. Este span es hijo del creado en el paso 2.a.

   2. Se recupera el ID de traza desde el contexto de traza y se imprime.

   3. Se recupera el Baggage agregado en el paso 2.b y se imprime su valor.

Diferencias entre versiones del agente de ARMS

La compatibilidad con las operaciones del código anterior varía según la versión del agente de ARMS.

Resultados de la instrumentación