Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Migration vers Java OpenTelemetry Cette section fournit des conseils sur la migration du SDK X-Ray vers le SDK pour les OpenTelemetry applications Java. **Topics** + [Solution d'instrumentation automatique à code zéro](#xray-migration-zero-code) + [Solutions d'instrumentation manuelle avec le SDK](#xray-migration-sdk) + [Suivi des demandes entrantes (instrumentation Spring Framework)](#xray-migration-tracing-setup-otel) + [AWS Instrumentation du SDK v2](#xray-migration-sdkv2) + [Instrumentation des appels HTTP sortants](#xray-migration-http) + [Support d'instrumentation pour d'autres bibliothèques](#xray-migration-libraries) + [Création manuelle de données de trace](#xray-migration-tracedata) + [Instrumentation Lambda](#xray-migration-lambda) ## Solution d'instrumentation automatique à code zéro ------ #### [ With X-Ray Java agent ] Pour activer l'agent Java X-Ray, les arguments JVM de votre application devaient être modifiés. ``` -javaagent:/{{path-to-disco}}/disco-java-agent.jar=pluginPath=/{{path-to-disco}}/disco-plugins ``` ------ #### [ With OpenTelemetry-based Java agent ] Pour utiliser des agents Java OpenTelemetry basés sur Java. + Utilisez l'agent Java AWS Distro for OpenTelemetry (ADOT) Auto-Instrumentation pour l'instrumentation automatique avec l'agent ADOT Java. Pour plus d'informations, voir [Instrumentation automatique pour les traces et les métriques avec l'agent Java](https://aws-otel.github.io/docs/getting-started/java-sdk/auto-instr). Si vous souhaitez uniquement le suivi, désactivez la variable d'`OTEL_METRICS_EXPORTER=none `environnement pour exporter les métriques depuis l'agent Java. (Facultatif) Vous pouvez également activer les signaux CloudWatch d'application lorsque vous instrumentez automatiquement vos applications à l' AWS aide de l'instrumentation automatique ADOT Java pour surveiller l'état actuel des applications et suivre les performances des applications à long terme. Application Signals fournit une vue unifiée et centrée sur les applications de vos applications, services et dépendances, et permet de surveiller et de trier l'état de santé des applications. Pour plus d’informations, veuillez consulter la rubrique [Applications Signals](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Application-Monitoring-Sections.html). + Utilisez l'agent OpenTelemetry Java pour l'instrumentation automatique. Pour plus d'informations, consultez la section [Instrumentation à code zéro avec l'agent Java](https://opentelemetry.io/docs/zero-code/java/agent/). ------ ## Solutions d'instrumentation manuelle avec le SDK ------ #### [ Tracing setup with X-Ray SDK ] Pour instrumenter votre code avec le SDK X-Ray pour Java, il fallait d'abord configurer `AWSXRay` la classe avec des plug-ins de service et des règles d'échantillonnage locales, puis utiliser un enregistreur fourni. ``` static { AWS XRayRecorderBuilder builder = AWS XRayRecorderBuilder.standard().withPlugin(new EC2Plugin()).withPlugin(new ECSPlugin()); AWS XRay.setGlobalRecorder(builder.build()); } ``` ------ #### [ Tracing setup with OpenTelemetry SDK ] Les dépendances suivantes sont requises. ``` io.opentelemetry opentelemetry-bom 1.49.0 pom import io.opentelemetry.instrumentation opentelemetry-instrumentation-bom 2.15.0 pom import io.opentelemetry opentelemetry-sdk io.opentelemetry opentelemetry-api io.opentelemetry.semconv opentelemetry-semconv io.opentelemetry opentelemetry-exporter-otlp io.opentelemetry.contrib opentelemetry-aws-xray 1.46.0 io.opentelemetry.contrib opentelemetry-aws-xray-propagator 1.46.0-alpha io.opentelemetry.contrib opentelemetry-aws-resources 1.46.0-alpha ``` Configurez le OpenTelemetry SDK en instanciant un objet `TracerProvider` et enregistrez globalement un objet. `OpenTelemetrySdk` Configurez les composants suivants : + Un exportateur OTLP Span (par exemple, OtlpGrpcSpanExporter) - Nécessaire pour exporter des traces vers l' CloudWatch agent ou OpenTelemetry le collecteur + Un propagateur de AWS rayons X : nécessaire pour propager le contexte de trace aux AWS services intégrés à X-Ray + Un échantillonneur à distance à AWS rayons X : obligatoire si vous devez effectuer des demandes d'échantillonnage à l'aide des règles d'échantillonnage par rayons X + Détecteurs de ressources (par exemple, EcsResource ou Ec2Resource) : détectent les métadonnées de l'hôte exécutant votre application ``` import io.opentelemetry.api.common.Attributes; import io.opentelemetry.context.propagation.ContextPropagators; import io.opentelemetry.contrib.aws.resource.Ec2Resource; import io.opentelemetry.contrib.aws.resource.EcsResource; import io.opentelemetry.contrib.awsxray.AwsXrayRemoteSampler; import io.opentelemetry.contrib.awsxray.propagator.AwsXrayPropagator; import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter; import io.opentelemetry.sdk.OpenTelemetrySdk; import io.opentelemetry.sdk.resources.Resource; import io.opentelemetry.sdk.trace.SdkTracerProvider; import io.opentelemetry.sdk.trace.export.BatchSpanProcessor; import io.opentelemetry.sdk.trace.samplers.Sampler; import static io.opentelemetry.semconv.ServiceAttributes.SERVICE_NAME; // ... private static final Resource otelResource = Resource.create(Attributes.of(SERVICE_NAME, "{{YOUR_SERVICE_NAME}}")) .merge(EcsResource.get()) .merge(Ec2Resource.get()); private static final SdkTracerProvider sdkTracerProvider = SdkTracerProvider.builder() .addSpanProcessor(BatchSpanProcessor.create( OtlpGrpcSpanExporter.getDefault() )) .addResource(otelResource) .setSampler(Sampler.parentBased( AwsXrayRemoteSampler.newBuilder(otelResource).build() )) .build(); // Globally registering a TracerProvider makes it available throughout the application to create as many Tracers as needed. private static final OpenTelemetrySdk openTelemetry = OpenTelemetrySdk.builder() .setTracerProvider(sdkTracerProvider) .setPropagators(ContextPropagators.create(AwsXrayPropagator.getInstance())) .buildAndRegisterGlobal(); ``` ------ ## Suivi des demandes entrantes (instrumentation Spring Framework) ------ #### [ With X-Ray SDK ] Pour plus d'informations sur l'utilisation du SDK X-Ray avec le framework Spring pour instrumenter votre application, consultez [AOP with Spring et le SDK X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-aop-spring.html) pour Java. Pour activer l'AOP au printemps, procédez comme suit. 1. [Configurez Spring](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-aop-spring.html#xray-sdk-java-aop-spring-configuration) 1. [Ajouter un filtre de suivi à votre application](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-aop-spring.html#xray-sdk-java-aop-filters-spring) 1. [Annotez votre code ou implémentez une interface](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-aop-spring.html#xray-sdk-java-aop-annotate-or-implement) 1. [Activez X-Ray dans votre application](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-aop-spring.html#xray-sdk-java-aop-activate-xray) ------ #### [ With OpenTelemetry SDK ] OpenTelemetry fournit des bibliothèques d'instrumentation pour collecter des traces pour les demandes entrantes pour les applications Spring Boot. Pour activer l'instrumentation Spring Boot avec une configuration minimale, incluez la dépendance suivante. ``` io.opentelemetry.instrumentation opentelemetry-spring-boot-starter ``` Pour plus d'informations sur la façon d'activer et de configurer l'instrumentation Spring Boot pour votre OpenTelemetry installation, consultez OpenTelemetry [Getting started](https://opentelemetry.io/docs/zero-code/java/spring-boot-starter/getting-started/). ------ #### [ Using OpenTelemetry-based Java agents ] La méthode recommandée par défaut pour instrumenter les applications Spring Boot consiste à utiliser l'[agent OpenTelemetry Java](https://opentelemetry.io/docs/zero-code/java/agent/) avec une instrumentation en *bytecode*, qui fournit également davantage d' out-of-the-boxinstrumentations et de configurations par rapport à l'utilisation directe du SDK. Pour commencer, voir[Solution d'instrumentation automatique à code zéro](#xray-migration-zero-code). ------ ## AWS Instrumentation du SDK v2 ------ #### [ With X-Ray SDK ] Le SDK X-Ray pour Java peut automatiquement instrumenter AWS tous les clients du SDK v2 lorsque vous avez ajouté `aws-xray-recorder-sdk-aws-sdk-v2-instrumentor` le sous-module dans votre build. Pour instrumenter les appels clients individuels aux AWS services en aval avec AWS SDK for Java 2.2 et versions ultérieures, `aws-xray-recorder-sdk-aws-sdk-v2-instrumentor ` le module de votre configuration de compilation a été exclu et `aws-xray-recorder-sdk-aws-sdk-v2` le module a été inclus. Les clients individuels ont été instrumentés en les configurant avec 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(); //... ``` ------ #### [ With OpenTelemetry SDK ] Pour instrumenter automatiquement tous les clients du AWS SDK, ajoutez le `opentelemetry-aws-sdk-2.2-autoconfigure` sous-module. ``` io.opentelemetry.instrumentation opentelemetry-aws-sdk-2.2-autoconfigure 2.15.0-alpha runtime ``` Pour instrumenter des clients AWS SDK individuels, ajoutez le `opentelemetry-aws-sdk-2.2` sous-module. ``` io.opentelemetry.instrumentation opentelemetry-aws-sdk-2.2 2.15.0-alpha compile ``` Enregistrez ensuite un intercepteur lors de la création d'un client AWS SDK. ``` 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(); ``` ------ ## Instrumentation des appels HTTP sortants ------ #### [ With X-Ray SDK ] Pour instrumenter les requêtes HTTP sortantes avec X-Ray, le SDK X-Ray pour Java HttpClient était requis. ``` import com.amazonaws.xray.proxies.apache.http.HttpClientBuilder; ... public String randomName() throws IOException { CloseableHttpClient httpclient = HttpClientBuilder.create().build(); ``` ------ #### [ With OpenTelemetry SDK ] Comme le SDK Java X-Ray, il OpenTelemetry fournit une `ApacheHttpClientTelemetry` classe dotée d'une méthode de création qui permet de créer une instance d'un `HttpClientBuilder` pour fournir des étendues OpenTelemetry basées et une propagation du contexte pour Apache. HttpClient ``` io.opentelemetry.instrumentation opentelemetry-apache-httpclient-5.2 2.15.0-alpha compile ``` Voici un exemple de code tiré du [opentelemetry-java-instrumentation](https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/apache-httpclient/apache-httpclient-5.2/library). Le client HTTP fourni par newHttpClient () générera des traces pour les requêtes exécutées. ``` 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(); } } ``` ------ ## Support d'instrumentation pour d'autres bibliothèques Retrouvez la liste complète des instrumentations de bibliothèque prises en charge pour OpenTelemetry Java dans son GitHub référentiel d'instrumentation respectif, sous [Bibliothèques, frameworks, serveurs d'applications et JVMs](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/docs/supported-libraries.md). Vous pouvez également effectuer une recherche OpenTelemetry dans le registre pour savoir si l'instrumentation est OpenTelemetry compatible. Pour commencer la recherche, consultez la section [Registre](https://opentelemetry.io/ecosystem/registry/). ## Création manuelle de données de trace ------ #### [ With X-Ray SDK ] Avec le SDK X-Ray, les `beginSubsegment` méthodes `beginSegment` et sont nécessaires pour créer manuellement des segments et des sous-segments 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(); } ``` ------ #### [ With OpenTelemetry SDK ] Vous pouvez utiliser des intervalles personnalisés pour surveiller les performances des activités internes qui ne sont pas capturées par les bibliothèques d'instrumentation. Notez que seuls les serveurs de type span sont convertis en segments X-Ray, tous les autres serveurs sont convertis en sous-segments X-Ray. Tout d'abord, vous devez créer un *traceur* afin de générer des spans, que vous pouvez obtenir grâce à la `openTelemetry.getTracer` méthode. Cela fournira une instance Tracer à partir de `TracerProvider` celle qui a été enregistrée globalement dans l'[Solutions d'instrumentation manuelle avec le SDK](#xray-migration-sdk)exemple. Vous pouvez créer autant d'instances de Tracer que nécessaire, mais il est courant d'avoir un seul Tracer pour l'ensemble d'une application. ``` Tracer tracer = openTelemetry.getTracer("{{my-app}}"); ``` Vous pouvez utiliser le Tracer pour créer des travées. ``` 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(); ``` Le type par défaut des travées est *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(); } ``` **Ajouter des annotations et des métadonnées aux traces avec OpenTelemetry le SDK** Dans l'exemple ci-dessus, la `setAttribute` méthode est utilisée pour ajouter des attributs à chaque intervalle. Par défaut, tous les attributs de span seront convertis en métadonnées dans les données brutes de X-Ray. Pour garantir qu'un attribut est converti en annotation et non en métadonnées, l'exemple ci-dessus ajoute la clé de cet attribut à la liste de l'`aws.xray.annotations`attribut. [Pour plus d'informations, voir [Activer les annotations et les métadonnées X-Ray personnalisées](https://aws-otel.github.io/docs/getting-started/x-ray#enable-the-customized-x-ray-annotations).](https://docs.aws.amazon.com/xray/latest/devguide/xray-concepts.html#xray-concepts-annotations) **Avec des agents Java OpenTelemetry basés** Si vous utilisez l'agent Java pour instrumenter automatiquement votre application, vous devez effectuer une instrumentation manuelle dans votre application. Par exemple, pour coder les instruments dans l'application pour les sections qui ne sont couvertes par aucune bibliothèque d'auto-instrumentation. Pour effectuer une instrumentation manuelle avec l'agent, vous devez utiliser l'`opentelemetry-api `artefact. La version de l'artefact ne peut pas être plus récente que la version de l'agent. ``` 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(); ``` ------ ## Instrumentation Lambda ------ #### [ With X-Ray SDK ] À l'aide du SDK X-Ray, une fois qu'*Active Tracing est* activé sur votre Lambda, aucune configuration supplémentaire n'est requise pour utiliser le SDK X-Ray. Lambda créera un segment représentant l'invocation du gestionnaire Lambda, et vous pouvez créer des sous-segments ou des bibliothèques d'instruments à l'aide du SDK X-Ray sans aucune configuration supplémentaire. ------ #### [ With OpenTelemetry-based solutions ] Couches Lambda à instrumentation automatique — Vous pouvez instrumenter automatiquement votre Lambda AWS avec des couches Lambda vendues à l'aide des solutions suivantes : + AWS Lambda Lambda pour OpenTelemetry (recommandé) **Note** Les signaux d' CloudWatch application sont activés par défaut sur cette couche Lambda, ce qui permet de surveiller les performances et l'état de santé de votre application Lambda en collectant à la fois des métriques et des traces. Pour le suivi uniquement, définissez la variable d'environnement Lambda. ` OTEL_AWS_APPLICATION_SIGNALS_ENABLED=false` + Permet de surveiller les performances et l'état de santé de votre application Lambda + Collecte à la fois les métriques et les traces par défaut + AWS couche Lambda gérée pour ADOT Java. Pour plus d'informations, consultez [AWS Distro for OpenTelemetry Lambda Support](https://aws-otel.github.io/docs/getting-started/lambda/lambda-java) for Java. Pour utiliser l'instrumentation manuelle avec la couche d'instrumentation automatique, voir[Solutions d'instrumentation manuelle avec le SDK](#xray-migration-sdk). Pour réduire les démarrages à froid, pensez à utiliser une instrumentation OpenTelemetry manuelle pour générer des OpenTelemetry traces pour votre fonction Lambda. ------ **OpenTelemetry instrumentation manuelle pour AWS Lambda** Prenez en compte le code de fonction Lambda suivant qui effectue un appel Amazon S3 ListBuckets . ``` package example; import com.amazonaws.services.lambda.runtime.Context; import com.amazonaws.services.lambda.runtime.RequestHandler; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.ListBucketsRequest; import software.amazon.awssdk.services.s3.model.ListBucketsResponse; import software.amazon.awssdk.services.s3.model.S3Exception; public class ListBucketsLambda implements RequestHandler { private final S3Client S3_CLIENT = S3Client.builder() .build(); @Override public String handleRequest(String input, Context context) { try { ListBucketsResponse response = makeListBucketsCall(); context.getLogger().log("response: " + response.toString()); return "Success"; } catch (Exception e) { throw new RuntimeException(e); } } private ListBucketsResponse makeListBucketsCall() { try { ListBucketsRequest listBucketsRequest = ListBucketsRequest.builder() .build(); ListBucketsResponse response = S3_CLIENT.listBuckets(listBucketsRequest); return response; } catch (S3Exception e) { throw new RuntimeException("Failed to call S3 listBuckets" + e.awsErrorDetails().errorMessage(), e); } } } ``` Voici les dépendances. ``` dependencies { implementation('com.amazonaws:aws-lambda-java-core:1.2.3') implementation('software.amazon.awssdk:s3:2.28.29') implementation('org.slf4j:slf4j-nop:2.0.16') } ``` Pour instrumenter manuellement votre gestionnaire Lambda et le client Amazon S3, procédez comme suit. 1. Remplacez les classes de fonctions qui implémentent `RequestHandler` (ou RequestStreamHandler) par celles qui étendent `TracingRequestHandler` (ou TracingRequestStreamHandler). 1. Instanciez un objet TracerProvider et enregistrez globalement un OpenTelemetrySdk objet. TracerProvider Il est recommandé de le configurer avec : 1. Un processeur Span simple avec un exportateur de span UDP X-Ray pour envoyer des traces au point de terminaison UDP X-Ray de Lambda 1. Un échantillonneur ParentBased toujours actif (par défaut s'il n'est pas configuré) 1. Une ressource dont service.name est défini sur le nom de la fonction Lambda 1. Un propagateur X-Ray Lambda 1. Changez la `handleRequest` méthode `doHandleRequest` et transmettez l'`OpenTelemetrySdk`objet à la classe de base. 1. Instrumentez le client Amazon S3 avec l'instrumentation du OpenTemetry AWS SDK en enregistrant l'intercepteur lors de la création du client. Vous avez besoin des dépendances OpenTelemetry connexes suivantes. ``` dependencies { ... implementation("software.amazon.distro.opentelemetry:aws-distro-opentelemetry-xray-udp-span-exporter:0.1.0") implementation(platform('io.opentelemetry.instrumentation:opentelemetry-instrumentation-bom:2.14.0')) implementation(platform('io.opentelemetry:opentelemetry-bom:1.48.0')) implementation('io.opentelemetry:opentelemetry-sdk') implementation('io.opentelemetry:opentelemetry-api') implementation('io.opentelemetry.contrib:opentelemetry-aws-xray-propagator:1.45.0-alpha') implementation('io.opentelemetry.contrib:opentelemetry-aws-resources:1.45.0-alpha') implementation('io.opentelemetry.instrumentation:opentelemetry-aws-lambda-core-1.0:2.14.0-alpha') implementation('io.opentelemetry.instrumentation:opentelemetry-aws-sdk-2.2:2.14.0-alpha') } ``` Le code suivant illustre la fonction Lambda après les modifications requises. Vous pouvez créer des travées personnalisées supplémentaires pour compléter les travées fournies automatiquement. ``` package example; import java.time.Duration; import com.amazonaws.services.lambda.runtime.Context; import io.opentelemetry.api.common.Attributes; import io.opentelemetry.context.propagation.ContextPropagators; import io.opentelemetry.contrib.aws.resource.LambdaResource; import io.opentelemetry.contrib.awsxray.propagator.AwsXrayLambdaPropagator; import io.opentelemetry.instrumentation.awslambdacore.v1_0.TracingRequestHandler; import io.opentelemetry.instrumentation.awssdk.v2_2.AwsSdkTelemetry; import io.opentelemetry.sdk.OpenTelemetrySdk; import io.opentelemetry.sdk.resources.Resource; import io.opentelemetry.sdk.trace.SdkTracerProvider; import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor; import io.opentelemetry.sdk.trace.samplers.Sampler; import static io.opentelemetry.semconv.ServiceAttributes.SERVICE_NAME; import software.amazon.awssdk.core.client.config.ClientOverrideConfiguration; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.ListBucketsRequest; import software.amazon.awssdk.services.s3.model.ListBucketsResponse; import software.amazon.awssdk.services.s3.model.S3Exception; import software.amazon.distro.opentelemetry.exporter.xray.udp.trace.AwsXrayUdpSpanExporterBuilder; public class ListBucketsLambda extends TracingRequestHandler { private static final Resource lambdaResource = LambdaResource.get(); private static final SdkTracerProvider sdkTracerProvider = SdkTracerProvider.builder() .addSpanProcessor(SimpleSpanProcessor.create( new AwsXrayUdpSpanExporterBuilder().build() )) .addResource( lambdaResource .merge(Resource.create(Attributes.of(SERVICE_NAME, System.getenv("AWS_LAMBDA_FUNCTION_NAME")))) ) .setSampler(Sampler.parentBased(Sampler.alwaysOn())) .build(); private static final OpenTelemetrySdk openTelemetry = OpenTelemetrySdk.builder() .setTracerProvider(sdkTracerProvider) .setPropagators(ContextPropagators.create(AwsXrayLambdaPropagator.getInstance())) .buildAndRegisterGlobal(); private static final AwsSdkTelemetry telemetry = AwsSdkTelemetry.create(openTelemetry); private final S3Client S3_CLIENT = S3Client.builder() .overrideConfiguration(ClientOverrideConfiguration.builder() .addExecutionInterceptor(telemetry.newExecutionInterceptor()) .build()) .build(); public ListBucketsLambda() { super(openTelemetry, Duration.ofMillis(0)); } @Override public String doHandleRequest(String input, Context context) { try { ListBucketsResponse response = makeListBucketsCall(); context.getLogger().log("response: " + response.toString()); return "Success"; } catch (Exception e) { throw new RuntimeException(e); } } private ListBucketsResponse makeListBucketsCall() { try { ListBucketsRequest listBucketsRequest = ListBucketsRequest.builder() .build(); ListBucketsResponse response = S3_CLIENT.listBuckets(listBucketsRequest); return response; } catch (S3Exception e) { throw new RuntimeException("Failed to call S3 listBuckets" + e.awsErrorDetails().errorMessage(), e); } } } ``` Lorsque vous appelez la fonction Lambda, vous verrez la trace suivante *sous* Trace Map dans CloudWatch la console. ![Tracez la carte dans CloudWatch la console.](http://docs.aws.amazon.com/fr_fr/xray/latest/devguide/images/SDKDeprecation_Java.png)