OpenTelemetry Migrazione a Java

Per abilitare l'agente X-Ray Java, era necessario modificare gli argomenti JVM dell'applicazione.

-javaagent:/path-to-disco/disco-java-agent.jar=pluginPath=/path-to-disco/disco-plugins

Per utilizzare agenti Java OpenTelemetry basati.

Per strumentare il codice con X-Ray SDK for Java, prima era necessario configurare la AWSXRay classe con plug-in di servizio e regole di campionamento locali, quindi è stato utilizzato un registratore fornito.

static { AWS XRayRecorderBuilder builder = AWS XRayRecorderBuilder.standard().withPlugin(new EC2Plugin()).withPlugin(new ECSPlugin()); AWS XRay.setGlobalRecorder(builder.build());
}

Sono richieste le seguenti dipendenze.

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>io.opentelemetry</groupId>
                <artifactId>opentelemetry-bom</artifactId>
                <version>1.49.0</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>io.opentelemetry.instrumentation</groupId>
                <artifactId>opentelemetry-instrumentation-bom</artifactId>
                <version>2.15.0</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>io.opentelemetry</groupId>
            <artifactId>opentelemetry-sdk</artifactId>
        </dependency>
        <dependency>
            <groupId>io.opentelemetry</groupId>
            <artifactId>opentelemetry-api</artifactId>
        </dependency>
        <dependency>
            <groupId>io.opentelemetry.semconv</groupId>
            <artifactId>opentelemetry-semconv</artifactId>
        </dependency>
        <dependency>
            <groupId>io.opentelemetry</groupId>
            <artifactId>opentelemetry-exporter-otlp</artifactId>
        </dependency>
        <dependency>
            <groupId>io.opentelemetry.contrib</groupId>
            <artifactId>opentelemetry-aws-xray</artifactId>
            <version>1.46.0</version>
        </dependency>
        <dependency>
            <groupId>io.opentelemetry.contrib</groupId>
            <artifactId>opentelemetry-aws-xray-propagator</artifactId>
            <version>1.46.0-alpha</version>
        </dependency>
        <dependency>
            <groupId>io.opentelemetry.contrib</groupId>
            <artifactId>opentelemetry-aws-resources</artifactId>
            <version>1.46.0-alpha</version>
        </dependency>
    </dependencies>

Configura l' OpenTelemetry SDK creando un'istanza TracerProvider e registrando globalmente un oggetto. OpenTelemetrySdk Configura questi componenti:

Per informazioni su come utilizzare X-Ray SDK con il framework Spring per strumentare l'applicazione, consulta AOP with Spring e X-Ray SDK for Java. Per abilitare AOP in Spring, completa questi passaggi.

OpenTelemetry fornisce librerie di strumentazione per raccogliere tracce per le richieste in arrivo per le applicazioni Spring Boot. Per abilitare la strumentazione Spring Boot con una configurazione minima, includi la seguente dipendenza.

<dependency>
           <groupId>io.opentelemetry.instrumentation</groupId>
            <artifactId>opentelemetry-spring-boot-starter</artifactId>
        </dependency>

Per ulteriori informazioni su come abilitare e configurare la strumentazione Spring Boot per la OpenTelemetry configurazione, vedere Guida introduttiva. OpenTelemetry

Il metodo predefinito consigliato per strumentare le applicazioni Spring Boot consiste nell'utilizzare l'agente OpenTelemetry Java con strumentazione bytecode, che fornisce anche più out-of-the-box strumentazioni e configurazioni rispetto all'utilizzo diretto dell'SDK. Soluzione di strumentazione automatica a codice zeroPer iniziare, consulta.

L'X-Ray SDK for Java è in grado di strumentare automaticamente tutti i client AWS SDK v2 quando aggiungi il sottomodulo nella build. aws-xray-recorder-sdk-aws-sdk-v2-instrumentor

Per strumentare le chiamate dei client a valle dei singoli client ai AWS servizi con AWS SDK for Java 2.2 e versioni successive, aws-xray-recorder-sdk-aws-sdk-v2-instrumentor il modulo dalla configurazione di build è stato escluso e aws-xray-recorder-sdk-aws-sdk-v2 il modulo è stato incluso. I singoli client sono stati strumentati configurandoli con un. TracingInterceptor

import com.amazonaws.xray.interceptors.TracingInterceptor;
import software.amazon.awssdk.core.client.config.ClientOverrideConfiguration
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
//...

public class MyModel {
  private DynamoDbClient client = DynamoDbClient.builder()
    .region(Region.US_WEST_2)
    .overrideConfiguration(
      ClientOverrideConfiguration.builder()
        .addExecutionInterceptor(new TracingInterceptor())
        .build()
      )
    .build();
//...

Per strumentare automaticamente tutti i client AWS SDK, aggiungi il sottomodulo. opentelemetry-aws-sdk-2.2-autoconfigure

<dependency>
            <groupId>io.opentelemetry.instrumentation</groupId>
            <artifactId>opentelemetry-aws-sdk-2.2-autoconfigure</artifactId>
            <version>2.15.0-alpha</version>
            <scope>runtime</scope>
        </dependency>

Per strumentare i singoli client AWS SDK, aggiungi il sottomodulo. opentelemetry-aws-sdk-2.2

<dependency>
            <groupId>io.opentelemetry.instrumentation</groupId>
            <artifactId>opentelemetry-aws-sdk-2.2</artifactId>
            <version>2.15.0-alpha</version>
            <scope>compile</scope>
        </dependency>

Quindi, registra un interceptor durante la creazione di un client SDK. AWS

import io.opentelemetry.instrumentation.awssdk.v2_2.AwsSdkTelemetry;

// ...

    AwsSdkTelemetry telemetry = AwsSdkTelemetry.create(openTelemetry);
    private final S3Client S3_CLIENT = S3Client.builder()
      .overrideConfiguration(ClientOverrideConfiguration.builder()
        .addExecutionInterceptor(telemetry.newExecutionInterceptor())
        .build())
      .build();

Per strumentare le richieste HTTP in uscita con X-Ray, era necessario l'X-Ray SDK per la versione di Apache di Java. HttpClient

import com.amazonaws.xray.proxies.apache.http.HttpClientBuilder;
...
  public String randomName() throws IOException {
    CloseableHttpClient httpclient = HttpClientBuilder.create().build();

Analogamente a X-Ray Java SDK, OpenTelemetry fornisce una ApacheHttpClientTelemetry classe con un metodo builder che consente la creazione di un'istanza di un set HttpClientBuilder per fornire intervalli OpenTelemetry basati e propagazione del contesto per Apache. HttpClient

<dependency>
            <groupId>io.opentelemetry.instrumentation</groupId>
            <artifactId>opentelemetry-apache-httpclient-5.2</artifactId>
            <version>2.15.0-alpha</version>
            <scope>compile</scope>
        </dependency>

Di seguito è riportato un esempio di codice tratto da. opentelemetry-java-instrumentation Il client HTTP fornito da newHttpClient () genererà tracce per le richieste eseguite.

import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.instrumentation.apachehttpclient.v5_2.ApacheHttpClientTelemetry;
import org.apache.hc.client5.http.classic.HttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClientBuilder;

public class ApacheHttpClientConfiguration {

  private OpenTelemetry openTelemetry;

  public ApacheHttpClientConfiguration(OpenTelemetry openTelemetry) {
    this.openTelemetry = openTelemetry;
  }

  // creates a new http client builder for constructing http clients with open telemetry instrumentation
  public HttpClientBuilder createBuilder() {
    return ApacheHttpClientTelemetry.builder(openTelemetry).build().newHttpClientBuilder();
  }

  // creates a new http client with open telemetry instrumentation
  public HttpClient newHttpClient() {
    return ApacheHttpClientTelemetry.builder(openTelemetry).build().newHttpClient();
  }
}

Con X-Ray SDK, sono necessari i beginSubsegment metodi beginSegment and per creare manualmente segmenti e sottosegmenti X-Ray.

  Segment segment = xrayRecorder.beginSegment("ManualSegment");
        segment.putAnnotation("annotationKey", "annotationValue");
        segment.putMetadata("metadataKey", "metadataValue");

        try {
            Subsegment subsegment = xrayRecorder.beginSubsegment("ManualSubsegment");
            subsegment.putAnnotation("key", "value");

            // Do something here

        } catch (Exception e) {
            subsegment.addException(e);
        } finally {
            xrayRecorder.endSegment();
        }

È possibile utilizzare intervalli personalizzati per monitorare le prestazioni delle attività interne che non vengono acquisite dalle librerie di strumentazione. Nota che solo i server di tipo span vengono convertiti in segmenti X-Ray, tutti gli altri span vengono convertiti in sottosegmenti X-Ray.

Innanzitutto, è necessario creare un Tracer per generare intervalli, che è possibile ottenere tramite il metodo. openTelemetry.getTracer Ciò fornirà un'istanza Tracer tra quelle registrate globalmente nell'esempio. TracerProvider Soluzioni di strumentazione manuale con SDK È possibile creare tutte le istanze Tracer necessarie, ma è comune avere una sola istanza Tracer per un'intera applicazione.

Tracer tracer = openTelemetry.getTracer("my-app");

È possibile utilizzare Tracer per creare intervalli.

import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.SpanKind;
import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.context.Scope;

...

// SERVER span will become an X-Ray segment
Span span = tracer.spanBuilder("get-token")
  .setKind(SpanKind.SERVER)
  .setAttribute("key", "value")
  .startSpan();
try (Scope ignored = span.makeCurrent()) {

  span.setAttribute("metadataKey", "metadataValue");
  span.setAttribute("annotationKey", "annotationValue");
  
  // The following ensures that "annotationKey: annotationValue" is an annotation in X-Ray raw data.
  span.setAttribute(AttributeKey.stringArrayKey("aws.xray.annotations"), List.of("annotationKey"));

  // Do something here
}

span.end();

Gli intervalli hanno un tipo predefinito di INTERNAL.

// Default span of type INTERNAL will become an X-Ray subsegment
Span span = tracer.spanBuilder("process-header")
  .startSpan();
try (Scope ignored = span.makeCurrent()) {
  doProcessHeader();
}

Aggiungere annotazioni e metadati alle tracce con SDK OpenTelemetry

Nell'esempio precedente, il setAttribute metodo viene utilizzato per aggiungere attributi a ogni intervallo. Per impostazione predefinita, tutti gli attributi span verranno convertiti in metadati nei dati grezzi X-Ray. Per garantire che un attributo venga convertito in un'annotazione e non in metadati, l'esempio precedente aggiunge la chiave di quell'attributo all'elenco dell'attributo. aws.xray.annotations Per ulteriori informazioni, consulta Abilitare le annotazioni e le annotazioni a raggi X personalizzate e i metadati.

Con agenti Java basati OpenTelemetry

Se si utilizza l'agente Java per strumentare automaticamente l'applicazione, è necessario eseguire la strumentazione manuale nell'applicazione. Ad esempio, al codice dello strumento all'interno dell'applicazione per sezioni che non sono coperte da alcuna libreria di strumentazione automatica.

Per eseguire la strumentazione manuale con l'agente, è necessario utilizzare l'artefatto. opentelemetry-api La versione dell'artefatto non può essere più recente della versione dell'agente.

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.trace.Span;

// ...
  
        Span parentSpan = Span.current();
        Tracer tracer = GlobalOpenTelemetry.getTracer("my-app");
        Span span = tracer.spanBuilder("my-span-name")
            .setParent(io.opentelemetry.context.Context.current().with(parentSpan))
            .startSpan();
        span.end();

Utilizzando l'SDK X-Ray, dopo che Lambda ha abilitato l'Active Tracing, non è richiesta alcuna configurazione aggiuntiva per utilizzare l'SDK X-Ray. Lambda creerà un segmento che rappresenta l'invocazione del gestore Lambda e potrai creare sottosegmenti o librerie di strumenti utilizzando l'SDK X-Ray senza alcuna configurazione aggiuntiva.

Strumentazione automatica Lambda: puoi strumentare automaticamente la tua Lambda AWS con strati Lambda venduti utilizzando le seguenti soluzioni:

Per utilizzare la strumentazione manuale insieme al livello di strumentazione automatica, vedere. Soluzioni di strumentazione manuale con SDK Per ridurre gli avviamenti a freddo, prendi in considerazione OpenTelemetry l'utilizzo di strumentazione manuale per generare OpenTelemetry tracce per la tua funzione Lambda.