Application Real-Time Monitoring Service:Pass trace context across asynchronous boundaries in Java

Quand une propagation manuelle est nécessaire

L'agent ARMS propage automatiquement le contexte de trace pour les modèles asynchrones suivants, sans modification du code :

• Pools de threads créés avec JDK, Spring ou Netty

• Programmation réactive avec Reactor ou RxJava

• Annotations Spring @Async

• Frameworks réactifs tels que Spring Webflux et Spring Gateway

Pour la liste complète des frameworks pris en charge, consultez la rubrique Composants et frameworks Java pris en charge par ARMS.

Une propagation manuelle s'impose lorsque des threads ou des processus communiquent via des intermédiaires non instrumentés par l'agent ARMS. Voici deux exemples courants :

Prérequis

Avant de commencer, assurez-vous d'avoir :

• Intégré Application Monitoring d'ARMS. Pour plus d'informations, consultez la rubrique Présentation d'Application Monitoring

• Installé l'agent ARMS version 4.x ou ultérieure. Pour vérifier ou mettre à jour votre version, consultez la rubrique Mettre à jour l'agent ARMS

Ajouter des dépendances

Ajoutez les dépendances Maven suivantes à votre projet. Pour plus d'informations, consultez la documentation officielle d'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>

Propager le contexte au-delà des limites asynchrones

Ce modèle repose sur deux étapes :

1. Capture : Côté émetteur, appelez Context.current() pour capturer le contexte de trace actif et stockez-le conjointement avec les données transmises.

2. Restauration : Côté récepteur, appelez context.makeCurrent() pour restaurer le contexte capturé avant le traitement.

import io.opentelemetry.context.Context;
import io.opentelemetry.context.Scope;
import java.util.concurrent.LinkedBlockingQueue;

// Wrap both the message and its trace context
class Event {
    private final Context context;
    private final String msg;

    public Event(Context context, String msg) {
        this.context = context;
        this.msg = msg;
    }

    public Context getContext() {
        return context;
    }

    public String getMsg() {
        return msg;
    }
}

// Shared queue between producer and consumer threads
private final LinkedBlockingQueue<Event> queue = new LinkedBlockingQueue<>();

// Producer: capture the current trace context
public void produce(String msg) {
    queue.add(new Event(Context.current(), msg));
}

// Consumer: restore the trace context before processing
public void consume() throws InterruptedException {
    Event event = queue.take();
    // makeCurrent() sets the captured context as the active context.
    // The try-with-resources block ensures the context is cleaned up after processing.
    try (Scope scope = event.getContext().makeCurrent()) {
        processEvent(event);
    }
}

public void processEvent(Event event) {
    // Any spans created here automatically become children
    // of the producer's trace.
}

Étapes suivantes

Associez les ID de trace aux journaux d'application pour simplifier l'analyse des erreurs. Consultez la rubrique Associer les ID de trace aux journaux d'une application Java.