Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Zu Java migrieren OpenTelemetry Dieser Abschnitt enthält Anleitungen zur Migration vom X-Ray SDK zum OpenTelemetry SDK for Java Java-Anwendungen. **Topics** + [Automatische Instrumentierungslösung ohne Code](#xray-migration-zero-code) + [Lösungen für die manuelle Instrumentierung mit dem SDK](#xray-migration-sdk) + [Nachverfolgung eingehender Anfragen (Spring Framework-Instrumentierung)](#xray-migration-tracing-setup-otel) + [AWS SDK v2-Instrumentierung](#xray-migration-sdkv2) + [Instrumentieren von ausgehenden HTTP-Aufrufen](#xray-migration-http) + [Instrumentierungsunterstützung für andere Bibliotheken](#xray-migration-libraries) + [Manuelles Erstellen von Trace-Daten](#xray-migration-tracedata) + [Lambda-Instrumentierung](#xray-migration-lambda) ## Automatische Instrumentierungslösung ohne Code ------ #### [ With X-Ray Java agent ] Um den X-Ray-Java-Agenten zu aktivieren, mussten die JVM-Argumente Ihrer Anwendung geändert werden. ``` -javaagent:/{{path-to-disco}}/disco-java-agent.jar=pluginPath=/{{path-to-disco}}/disco-plugins ``` ------ #### [ With OpenTelemetry-based Java agent ] Um OpenTelemetry basierte Java-Agenten zu verwenden. + Verwenden Sie den Java-Agenten AWS Distro for OpenTelemetry (ADOT) Auto-Instrumentation für die automatische Instrumentierung mit dem ADOT-Java-Agenten. Weitere Informationen finden Sie unter [Automatische Instrumentierung für Traces und Metriken](https://aws-otel.github.io/docs/getting-started/java-sdk/auto-instr) mit dem Java-Agenten. Wenn Sie nur die Ablaufverfolgung verwenden möchten, deaktivieren Sie die `OTEL_METRICS_EXPORTER=none ` Umgebungsvariable, um Metriken aus dem Java-Agenten zu exportieren. (Optional) Sie können CloudWatch Application Signals auch aktivieren, wenn Sie Ihre Anwendungen AWS mit der automatischen ADOT-Java-Instrumentierung automatisch instrumentieren, um den aktuellen Zustand der Anwendung zu überwachen und die langfristige Anwendungsleistung zu verfolgen. Application Signals bietet eine einheitliche, anwendungsorientierte Ansicht Ihrer Anwendungen, Dienste und Abhängigkeiten und hilft bei der Überwachung und Bewertung des Anwendungszustands. Weitere Informationen finden Sie unter [Application Signals](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Application-Monitoring-Sections.html). + Verwenden Sie den OpenTelemetry Java-Agenten für die automatische Instrumentierung. Weitere Informationen finden Sie unter [Zero-Code-Instrumentierung mit dem Java-Agenten](https://opentelemetry.io/docs/zero-code/java/agent/). ------ ## Lösungen für die manuelle Instrumentierung mit dem SDK ------ #### [ Tracing setup with X-Ray SDK ] Um Ihren Code mit dem X-Ray SDK for Java zu instrumentieren, musste die `AWSXRay` Klasse zunächst mit Service-Plug-ins und lokalen Sampling-Regeln konfiguriert werden. Anschließend wurde ein mitgelieferter Rekorder verwendet. ``` static { AWS XRayRecorderBuilder builder = AWS XRayRecorderBuilder.standard().withPlugin(new EC2Plugin()).withPlugin(new ECSPlugin()); AWS XRay.setGlobalRecorder(builder.build()); } ``` ------ #### [ Tracing setup with OpenTelemetry SDK ] Die folgenden Abhängigkeiten sind erforderlich. ``` 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 ``` Konfigurieren Sie das OpenTelemetry SDK, indem Sie ein Objekt instanziieren `TracerProvider` und global registrieren. `OpenTelemetrySdk` Konfigurieren Sie diese Komponenten: + Ein OTLP Span Exporter (z. B. OtlpGrpcSpanExporter) — Erforderlich für den Export von Traces an den CloudWatch Agenten oder Collector OpenTelemetry + Ein AWS X-Ray Propagator — Erforderlich für die Weitergabe des Trace-Kontextes an AWS Dienste, die in X-Ray integriert sind + Ein AWS X-Ray Remote Sampler — Erforderlich, wenn Sie Anfragen anhand von Röntgenprobenregeln abtasten müssen + Resource Detectors (zum Beispiel EcsResource oder Ec2Resource) — Erkennt Metadaten des Hosts, auf dem Ihre Anwendung ausgeführt wird ``` 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(); ``` ------ ## Nachverfolgung eingehender Anfragen (Spring Framework-Instrumentierung) ------ #### [ With X-Ray SDK ] Informationen zur Verwendung des X-Ray-SDK mit dem Spring-Framework zur Instrumentierung Ihrer Anwendung finden Sie unter [AOP mit Spring und dem X-Ray-SDK SDK for Java](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-aop-spring.html). Gehen Sie wie folgt vor, um AOP in Spring zu aktivieren. 1. [Konfigurieren von Spring](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-aop-spring.html#xray-sdk-java-aop-spring-configuration) 1. [Hinzufügen eines Ablaufverfolgungsfilters zu Ihrer Anwendung](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-aop-spring.html#xray-sdk-java-aop-filters-spring) 1. [Kommentieren Sie Ihren Code oder implementieren Sie eine Schnittstelle](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-aop-spring.html#xray-sdk-java-aop-annotate-or-implement) 1. [Aktivieren von X-Ray in Ihrer Anwendung](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-aop-spring.html#xray-sdk-java-aop-activate-xray) ------ #### [ With OpenTelemetry SDK ] OpenTelemetry bietet Instrumentierungsbibliotheken zum Sammeln von Traces für eingehende Anfragen für Spring Boot-Anwendungen. Um die Spring Boot-Instrumentierung mit minimaler Konfiguration zu aktivieren, schließen Sie die folgende Abhängigkeit ein. ``` io.opentelemetry.instrumentation opentelemetry-spring-boot-starter ``` Weitere Informationen zur Aktivierung und Konfiguration der Spring Boot-Instrumentation für Ihr OpenTelemetry Setup finden Sie unter OpenTelemetry [Erste Schritte](https://opentelemetry.io/docs/zero-code/java/spring-boot-starter/getting-started/). ------ #### [ Using OpenTelemetry-based Java agents ] Die empfohlene Standardmethode für die Instrumentierung von Spring Boot-Anwendungen ist die Verwendung des [OpenTelemetry Java-Agenten](https://opentelemetry.io/docs/zero-code/java/agent/) mit *Bytecode-Instrumentierung*, der im Vergleich zur direkten Verwendung des SDK auch mehr out-of-the-box Instrumentierungen und Konfigurationen bietet. Informationen zu den ersten Schritten finden Sie unter. [Automatische Instrumentierungslösung ohne Code](#xray-migration-zero-code) ------ ## AWS SDK v2-Instrumentierung ------ #### [ With X-Ray SDK ] Das X-Ray SDK for Java kann automatisch alle AWS SDK v2-Clients instrumentieren, wenn Sie das `aws-xray-recorder-sdk-aws-sdk-v2-instrumentor` Untermodul zu Ihrem Build hinzugefügt haben. Um die Downstream-Client-Aufrufe einzelner Clients an AWS Dienste mit AWS SDK for Java 2.2 und höher zu instrumentieren, wurde das `aws-xray-recorder-sdk-aws-sdk-v2-instrumentor ` Modul aus Ihrer Build-Konfiguration ausgeschlossen und das `aws-xray-recorder-sdk-aws-sdk-v2` Modul wurde aufgenommen. Einzelne Clients wurden instrumentiert, indem sie mit einem `TracingInterceptor` konfiguriert wurden. ``` 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 ] Um alle AWS SDK-Clients automatisch zu instrumentieren, fügen Sie das `opentelemetry-aws-sdk-2.2-autoconfigure` Untermodul hinzu. ``` io.opentelemetry.instrumentation opentelemetry-aws-sdk-2.2-autoconfigure 2.15.0-alpha runtime ``` Um einzelne AWS SDK-Clients zu instrumentieren, fügen Sie das `opentelemetry-aws-sdk-2.2` Untermodul hinzu. ``` io.opentelemetry.instrumentation opentelemetry-aws-sdk-2.2 2.15.0-alpha compile ``` Registrieren Sie dann einen Interceptor, wenn Sie einen AWS SDK-Client erstellen. ``` 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(); ``` ------ ## Instrumentieren von ausgehenden HTTP-Aufrufen ------ #### [ With X-Ray SDK ] Um ausgehende HTTP-Anfragen mit X-Ray zu instrumentieren, HttpClient war das X-Ray SDK für Javas Version des Apache erforderlich. ``` import com.amazonaws.xray.proxies.apache.http.HttpClientBuilder; ... public String randomName() throws IOException { CloseableHttpClient httpclient = HttpClientBuilder.create().build(); ``` ------ #### [ With OpenTelemetry SDK ] Ähnlich wie das X-Ray Java SDK OpenTelemetry stellt es eine `ApacheHttpClientTelemetry` Klasse bereit, die über eine Builder-Methode verfügt, die die Erstellung einer Instanz ermöglicht, `HttpClientBuilder` um OpenTelemetry basierte Spans und Kontextpropagierung für Apache HttpClient bereitzustellen. ``` io.opentelemetry.instrumentation opentelemetry-apache-httpclient-5.2 2.15.0-alpha compile ``` Im Folgenden finden Sie ein Codebeispiel aus dem [opentelemetry-java-instrumentation](https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/apache-httpclient/apache-httpclient-5.2/library). Der von newHttpClient () bereitgestellte HTTP-Client generiert Traces für ausgeführte Anfragen. ``` 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(); } } ``` ------ ## Instrumentierungsunterstützung für andere Bibliotheken Die vollständige Liste der unterstützten Bibliotheksinstrumentierungen für OpenTelemetry Java finden Sie im entsprechenden GitHub Instrumentierungs-Repository unter [Unterstützte Bibliotheken, Frameworks, Anwendungsserver und JVMs](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/docs/supported-libraries.md). Alternativ können Sie in der OpenTelemetry Registry nachsehen, ob Instrumentierung OpenTelemetry unterstützt wird. Informationen zum Starten der Suche finden Sie unter [Registrierung](https://opentelemetry.io/ecosystem/registry/). ## Manuelles Erstellen von Trace-Daten ------ #### [ With X-Ray SDK ] Mit dem X-Ray-SDK sind die `beginSubsegment` Methoden `beginSegment` und erforderlich, um X-Ray-Segmente und -Untersegmente manuell zu erstellen. ``` 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 ] Sie können benutzerdefinierte Zeitspannen verwenden, um die Leistung interner Aktivitäten zu überwachen, die nicht von Instrumentenbibliotheken erfasst werden. Beachten Sie, dass nur Span-Kind-Server in X-Ray-Segmente konvertiert werden, alle anderen Spans werden in X-Ray-Untersegmente umgewandelt. Zunächst müssen Sie einen *Tracer* erstellen, um Spans zu generieren, die Sie mit dieser Methode abrufen können. `openTelemetry.getTracer` Dadurch wird eine Tracer-Instanz aus dem bereitgestellt`TracerProvider`, der im Beispiel global registriert wurde. [Lösungen für die manuelle Instrumentierung mit dem SDK](#xray-migration-sdk) Sie können so viele Tracer-Instanzen wie nötig erstellen, aber es ist üblich, einen Tracer für eine gesamte Anwendung zu haben. ``` Tracer tracer = openTelemetry.getTracer("{{my-app}}"); ``` Sie können den Tracer verwenden, um Spans zu erstellen. ``` 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(); ``` *Spans haben den Standardtyp 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(); } ``` **Hinzufügen von Anmerkungen und Metadaten zu Traces mit dem SDK OpenTelemetry ** Im obigen Beispiel wird die `setAttribute` Methode verwendet, um jedem Bereich Attribute hinzuzufügen. Standardmäßig werden alle Span-Attribute in Metadaten in X-Rohdaten umgewandelt. Um sicherzustellen, dass ein Attribut in eine Anmerkung und nicht in Metadaten umgewandelt wird, fügt das obige Beispiel den Schlüssel dieses Attributs zur Liste des `aws.xray.annotations` Attributs hinzu. Weitere Informationen finden Sie unter [Aktivieren der benutzerdefinierten X-Ray-Anmerkungen](https://aws-otel.github.io/docs/getting-started/x-ray#enable-the-customized-x-ray-annotations) und [Anmerkungen und Metadaten](https://docs.aws.amazon.com/xray/latest/devguide/xray-concepts.html#xray-concepts-annotations). **Mit OpenTelemetry basierten Java-Agenten** Wenn Sie den Java-Agenten zur automatischen Instrumentierung Ihrer Anwendung verwenden, müssen Sie in Ihrer Anwendung eine manuelle Instrumentierung durchführen. Zum Beispiel, um Code innerhalb der Anwendung für Abschnitte zu instrumentieren, die von keiner Bibliothek für automatische Instrumentierung abgedeckt werden. Um eine manuelle Instrumentierung mit dem Agenten durchzuführen, müssen Sie das `opentelemetry-api ` Artefakt verwenden. Die Artefaktversion darf nicht neuer als die Agentenversion sein. ``` 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(); ``` ------ ## Lambda-Instrumentierung ------ #### [ With X-Ray SDK ] Wenn Sie das X-Ray-SDK verwenden, ist nach der Aktivierung von *Active Tracing* auf Ihrem Lambda keine zusätzliche Konfiguration erforderlich, um das X-Ray-SDK zu verwenden. Lambda erstellt ein Segment, das den Lambda-Handler-Aufruf darstellt, und Sie können Untersegmente oder Instrumentenbibliotheken mit dem X-Ray SDK ohne zusätzliche Konfiguration erstellen. ------ #### [ With OpenTelemetry-based solutions ] Lambda-Schichten mit automatischer Instrumentierung — Mithilfe der folgenden Lösungen können Sie Ihr Lambda automatisch mit AWS Lambda-Schichten von Drittanbietern instrumentieren: + AWS Lambda Layer für OpenTelemetry (empfohlen) **Anmerkung** Auf dieser Lambda-Schicht sind CloudWatch Application Signals standardmäßig aktiviert, wodurch die Leistungs- und Zustandsüberwachung für Ihre Lambda-Anwendung ermöglicht wird, indem sowohl Metriken als auch Traces erfasst werden. Um nur die Ablaufverfolgung zu ermöglichen, legen Sie die Umgebungsvariable Lambda fest. ` OTEL_AWS_APPLICATION_SIGNALS_ENABLED=false` + Ermöglicht die Leistungs- und Zustandsüberwachung für Ihre Lambda-Anwendung + Sammelt standardmäßig sowohl Metriken als auch Traces + AWS verwaltete Lambda-Schicht für ADOT Java. Weitere Informationen finden Sie unter [AWS Distro for OpenTelemetry Lambda Support for Java](https://aws-otel.github.io/docs/getting-started/lambda/lambda-java). Informationen zur Verwendung der manuellen Instrumentierung zusammen mit der Ebene für automatische Instrumentierung finden Sie unter[Lösungen für die manuelle Instrumentierung mit dem SDK](#xray-migration-sdk). Um weniger Kaltstarts zu erzielen, sollten Sie erwägen, OpenTelemetry manuelle Instrumente zu verwenden, um OpenTelemetry Traces für Ihre Lambda-Funktion zu generieren. ------ **OpenTelemetry manuelle Instrumentierung für AWS Lambda** Betrachten Sie den folgenden Lambda-Funktionscode, der einen Amazon S3 ListBuckets S3-Aufruf durchführt. ``` 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); } } } ``` Hier sind die Abhängigkeiten. ``` 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') } ``` Gehen Sie wie folgt vor, um Ihren Lambda-Handler und den Amazon S3 S3-Client manuell zu instrumentieren. 1. Ersetzen Sie Ihre Funktionsklassen, die `RequestHandler` (oder RequestStreamHandler) implementieren, durch solche, die `TracingRequestHandler` (oder TracingRequestStreamHandler) erweitern. 1. Instanziieren Sie ein Objekt TracerProvider und registrieren Sie es global. OpenTelemetrySdk TracerProvider Es wird empfohlen, das zu konfigurieren mit: 1. Ein einfacher Span-Prozessor mit einem X-Ray-UDP-Span-Exporter zum Senden von Traces an den UDP-X-Ray-Endpunkt von Lambda 1. Ein ParentBased Always-On-Sampler (Standard, falls nicht konfiguriert) 1. Eine Ressource, bei der service.name auf den Lambda-Funktionsnamen gesetzt ist 1. Ein Röntgen-Lambda-Propagator 1. Ändern Sie die `handleRequest` Methode in `doHandleRequest` und übergeben Sie das `OpenTelemetrySdk` Objekt an die Basisklasse. 1. Instrumentieren Sie den Amazon S3 S3-Client mit der OpenTemetry AWS SDK-Instrumentierung, indem Sie den Interceptor bei der Erstellung des Clients registrieren. Sie benötigen die folgenden zugehörigen Abhängigkeiten OpenTelemetry. ``` 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') } ``` Der folgende Code demonstriert die Lambda-Funktion nach den erforderlichen Änderungen. Sie können zusätzliche benutzerdefinierte Bereiche erstellen, um die automatisch bereitgestellten Bereiche zu ergänzen. ``` 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); } } } ``` Wenn Sie die Lambda-Funktion aufrufen, sehen Sie in der Konsole unter *Trace Map* den CloudWatch folgenden Trace. ![Trace-Map in der Konsole CloudWatch .](http://docs.aws.amazon.com/de_de/xray/latest/devguide/images/SDKDeprecation_Java.png)