As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Migrando para Java OpenTelemetry Esta seção fornece orientação sobre a migração do X-Ray SDK para o OpenTelemetry SDK for Java. **Topics** + [Solução de instrumentação automática de código zero](#xray-migration-zero-code) + [Soluções de instrumentação manual com o SDK](#xray-migration-sdk) + [Rastrear solicitações recebidas (instrumentação do Spring Framework)](#xray-migration-tracing-setup-otel) + [AWS Instrumentação do SDK v2](#xray-migration-sdkv2) + [Instrumentar chamadas HTTP de saída](#xray-migration-http) + [Suporte de instrumentação para outras bibliotecas](#xray-migration-libraries) + [Criar dados de rastreamento manualmente](#xray-migration-tracedata) + [Instrumentação do Lambda](#xray-migration-lambda) ## Solução de instrumentação automática de código zero ------ #### [ With X-Ray Java agent ] Para habilitar o agente Java do X-Ray, os argumentos JVM da sua aplicação precisavam ser modificados. ``` -javaagent:/{{path-to-disco}}/disco-java-agent.jar=pluginPath=/{{path-to-disco}}/disco-plugins ``` ------ #### [ With OpenTelemetry-based Java agent ] Para usar agentes Java OpenTelemetry baseados. + Use o agente Java AWS Distro for OpenTelemetry (ADOT) Auto-Instrumentation para instrumentação automática com o agente ADOT Java. Para obter mais informações, consulte [Auto-Instrumentation for Traces and Metrics with the Java agent](https://aws-otel.github.io/docs/getting-started/java-sdk/auto-instr). Se você quiser somente o rastreamento, desabilite a variável de ambiente `OTEL_METRICS_EXPORTER=none ` para exportar métricas do agente Java. (Opcional) Você também pode ativar o CloudWatch Application Signals ao instrumentar automaticamente seus aplicativos AWS com a instrumentação automática ADOT Java para monitorar a integridade atual do aplicativo e monitorar o desempenho de longo prazo do aplicativo. O Application Signals fornece uma visualização unificada e centrada em aplicações para aplicações, serviços e dependências, além de ajudar você a monitorar e realizar a triagem da integridade da aplicação. Para obter mais informações, consulte [Application Signals](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Application-Monitoring-Sections.html). + Use o agente OpenTelemetry Java para instrumentação automática. Para obter mais informações, consulte [Zero-code instrumentation with the Java Agent](https://opentelemetry.io/docs/zero-code/java/agent/). ------ ## Soluções de instrumentação manual com o SDK ------ #### [ Tracing setup with X-Ray SDK ] Para instrumentar seu código com o SDK do X-Ray para Java, primeiro era necessário configurar a classe `AWSXRay` com plug-ins de serviço e regras de amostragem locais. Depois, um gravador fornecido era usado. ``` static { AWS XRayRecorderBuilder builder = AWS XRayRecorderBuilder.standard().withPlugin(new EC2Plugin()).withPlugin(new ECSPlugin()); AWS XRay.setGlobalRecorder(builder.build()); } ``` ------ #### [ Tracing setup with OpenTelemetry SDK ] As dependências a seguir são obrigatórias. ``` 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 ``` Configure o OpenTelemetry SDK instanciando um objeto `TracerProvider` e registrando globalmente um objeto. `OpenTelemetrySdk` Configure estes componentes: + Um exportador OTLP Span (por exemplo, OtlpGrpcSpanExporter) - Necessário para exportar traços para o agente ou coletor CloudWatch OpenTelemetry + Um propagador de AWS raio-X — necessário para propagar o contexto de rastreamento para AWS serviços integrados ao X-Ray + Um amostrador remoto de AWS raio-X — necessário se você precisar coletar amostras de solicitações usando as regras de amostragem de raios X + Detectores de recursos (por exemplo, EcsResource ou Ec2Resource) — Detecte metadados do host que executa seu aplicativo ``` 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(); ``` ------ ## Rastrear solicitações recebidas (instrumentação do Spring Framework) ------ #### [ With X-Ray SDK ] Para obter informações sobre como usar o SDK do X-Ray com o Spring Framework para instrumentar sua aplicação, consulte [AOP com Spring e o SDK do X-Ray para Java](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-aop-spring.html). Para habilitar o AOP no Spring, conclua as etapas a seguir. 1. [Configure o Spring](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-aop-spring.html#xray-sdk-java-aop-spring-configuration) 1. [Adicione um filtro de rastreamento à sua aplicação](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-aop-spring.html#xray-sdk-java-aop-filters-spring) 1. [Anote o seu código ou implemente uma interface](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-aop-spring.html#xray-sdk-java-aop-annotate-or-implement) 1. [Ative o X-Ray em seu aplicativo](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-aop-spring.html#xray-sdk-java-aop-activate-xray) ------ #### [ With OpenTelemetry SDK ] OpenTelemetry fornece bibliotecas de instrumentação para coletar rastreamentos para solicitações recebidas de aplicativos Spring Boot. Para habilitar a instrumentação do Spring Boot com configuração mínima, inclua a dependência a seguir. ``` io.opentelemetry.instrumentation opentelemetry-spring-boot-starter ``` Para obter mais informações sobre como habilitar e configurar a instrumentação do Spring Boot para sua OpenTelemetry configuração, consulte [Getting OpenTelemetry](https://opentelemetry.io/docs/zero-code/java/spring-boot-starter/getting-started/) Started. ------ #### [ Using OpenTelemetry-based Java agents ] O método padrão recomendado para instrumentar aplicativos Spring Boot é usar o [agente OpenTelemetry Java](https://opentelemetry.io/docs/zero-code/java/agent/) com instrumentação de *bytecode*, que também fornece mais out-of-the-box instrumentações e configurações quando comparado ao uso direto do SDK. Para começar, consulte [Solução de instrumentação automática de código zero](#xray-migration-zero-code). ------ ## AWS Instrumentação do SDK v2 ------ #### [ With X-Ray SDK ] O X-Ray SDK for Java pode instrumentar automaticamente AWS todos os clientes do SDK v2 quando você adiciona `aws-xray-recorder-sdk-aws-sdk-v2-instrumentor` o submódulo à sua compilação. Para instrumentar chamadas posteriores de clientes individuais para AWS serviços com o AWS SDK for Java 2.2 e versões posteriores, `aws-xray-recorder-sdk-aws-sdk-v2-instrumentor ` o módulo da sua configuração de compilação foi excluído e `aws-xray-recorder-sdk-aws-sdk-v2` o módulo foi incluído. Clientes individuais foram instrumentados configurando-os com um `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 ] Para instrumentar automaticamente todos os clientes AWS do SDK, adicione o `opentelemetry-aws-sdk-2.2-autoconfigure` submódulo. ``` io.opentelemetry.instrumentation opentelemetry-aws-sdk-2.2-autoconfigure 2.15.0-alpha runtime ``` Para instrumentar clientes AWS SDK individuais, adicione o `opentelemetry-aws-sdk-2.2` submódulo. ``` io.opentelemetry.instrumentation opentelemetry-aws-sdk-2.2 2.15.0-alpha compile ``` Em seguida, registre um interceptor ao criar um cliente 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(); ``` ------ ## Instrumentar chamadas HTTP de saída ------ #### [ With X-Ray SDK ] Para instrumentar as solicitações HTTP de saída com o X-Ray, era necessário o X-Ray SDK para Java, versão do Apache HttpClient . ``` import com.amazonaws.xray.proxies.apache.http.HttpClientBuilder; ... public String randomName() throws IOException { CloseableHttpClient httpclient = HttpClientBuilder.create().build(); ``` ------ #### [ With OpenTelemetry SDK ] Da mesma forma que o X-Ray Java SDK, OpenTelemetry fornece uma `ApacheHttpClientTelemetry` classe que tem um método construtor que permite a criação de uma instância de um `HttpClientBuilder` para fornecer extensões OpenTelemetry baseadas e propagação de contexto para o Apache. HttpClient ``` io.opentelemetry.instrumentation opentelemetry-apache-httpclient-5.2 2.15.0-alpha compile ``` A seguir está um exemplo de código do [opentelemetry-java-instrumentation](https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/apache-httpclient/apache-httpclient-5.2/library). O cliente HTTP fornecido por newHttpClient () gerará rastreamentos para solicitações executadas. ``` 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(); } } ``` ------ ## Suporte de instrumentação para outras bibliotecas Encontre a lista completa de instrumentações de biblioteca suportadas para OpenTelemetry Java em seu respectivo GitHub repositório de instrumentação, em [Bibliotecas, estruturas, servidores](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/docs/supported-libraries.md) de aplicativos e. JVMs Como alternativa, você pode pesquisar no OpenTelemetry Registro para descobrir se OpenTelemetry suporta instrumentação. Para começar a pesquisar, consulte [Registry](https://opentelemetry.io/ecosystem/registry/). ## Criar dados de rastreamento manualmente ------ #### [ With X-Ray SDK ] Com o SDK do X-Ray, os métodos `beginSegment` e `beginSubsegment`são necessários para criar manualmente segmentos e subsegmentos do 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 ] Você pode usar extensões personalizadas para monitorar o desempenho de atividades internas que não são capturadas pelas bibliotecas de instrumentação. Somente extensões do tipo servidor são convertidas em segmentos do X-Ray. Todas as outras extensões são convertidas em subsegmentos do X-Ray. Primeiro, você precisará criar um *Rastreador* para gerar extensões, que podem ser obtidas por meio do método `openTelemetry.getTracer`. Isso fornecerá uma instância do rastreador de `TracerProvider` que foi registrada globalmente no exemplo [Soluções de instrumentação manual com o SDK](#xray-migration-sdk). Você pode criar quantas instâncias de rastreador forem necessárias, mas é comum ter um rastreador para toda a aplicação. ``` Tracer tracer = openTelemetry.getTracer("{{my-app}}"); ``` Você pode usar o rastreador para criar extensõ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(); ``` As extensões têm um tipo padrão *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(); } ``` **Adicionar anotações e metadados aos rastreamentos com o SDK OpenTelemetry ** No exemplo acima, o método `setAttribute` é usado para adicionar atributos a cada extensão. Por padrão, todos os atributos de extensão serão convertidos em metadados nos dados brutos do X-Ray. Para garantir que um atributo seja convertido em uma anotação, e não em metadados, o exemplo acima adiciona a chave desse atributo à lista do atributo `aws.xray.annotations`. Para obter mais informações, consulte [Enable The Customized X-Ray Annotations](https://aws-otel.github.io/docs/getting-started/x-ray#enable-the-customized-x-ray-annotations) e [Anotações e metadados](https://docs.aws.amazon.com/xray/latest/devguide/xray-concepts.html#xray-concepts-annotations). **Com agentes Java OpenTelemetry baseados** Se estiver usando o agente Java para instrumentar automaticamente a aplicação, você precisará realizar a instrumentação manual na aplicação. Por exemplo, para instrumentar o código dentro da aplicação para seções que não são cobertas por nenhuma biblioteca de instrumentação automática. Você precisa usar o artefato `opentelemetry-api `para realizar a instrumentação manual com o agente. A versão do artefato não pode ser mais recente que a versão do 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(); ``` ------ ## Instrumentação do Lambda ------ #### [ With X-Ray SDK ] Ao usar o SDK do X-Ray, depois que o Lambda tiver o *Rastreamento ativo* habilitado, não há necessidade de configuração adicional para usar o SDK do X-Ray. O Lambda criará um segmento representando a invocação do manipulador do Lambda, e você poderá criar subsegmentos ou bibliotecas de instrumentos usando o SDK do X-Ray sem nenhuma configuração adicional. ------ #### [ With OpenTelemetry-based solutions ] Camadas Lambda de instrumentação automática — Você pode instrumentar automaticamente seu Lambda AWS com camadas Lambda vendidas usando as seguintes soluções: + AWS Camada Lambda para OpenTelemetry (recomendada) **nota** Essa camada Lambda tem sinais de CloudWatch aplicativo ativados por padrão, o que permite o monitoramento de desempenho e integridade de seu aplicativo Lambda por meio da coleta de métricas e rastreamentos. Para usar somente o rastreamento, defina a variável de ambiente ` OTEL_AWS_APPLICATION_SIGNALS_ENABLED=false` do Lambda. + Permite o monitoramento do desempenho e da integridade da sua aplicação Lambda + Coleta métricas e rastreamentos por padrão + AWS camada Lambda gerenciada para ADOT Java. Para obter mais informações, consulte [AWS Distro for OpenTelemetry Lambda Support For Java](https://aws-otel.github.io/docs/getting-started/lambda/lambda-java). Para usar a instrumentação manual com a camada de instrumentação automática, consulte [Soluções de instrumentação manual com o SDK](#xray-migration-sdk). Para reduzir as partidas a frio, considere usar instrumentação OpenTelemetry manual para gerar OpenTelemetry traços para sua função Lambda. ------ **OpenTelemetry instrumentação manual para Lambda AWS ** Considere o seguinte código de função Lambda que faz uma chamada do Amazon ListBuckets S3. ``` 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); } } } ``` Confira as dependências. ``` 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') } ``` Para instrumentar manualmente seu manipulador do Lambda e o cliente do Amazon S3, faça o seguinte: 1. Substitua suas classes de função que implementam `RequestHandler` (ou RequestStreamHandler) por aquelas que se estendem `TracingRequestHandler` (ou TracingRequestStreamHandler). 1. TracerProvider Instancie um objeto e registre globalmente. OpenTelemetrySdk TracerProvider Recomenda-se que seja configurado com: 1. Um processador de extensões simples com um exportador de extensões do UDP do X-Ray para enviar rastreamentos ao endpoint UDP X-Ray do Lambda 1. Um amostrador ParentBased sempre ativo (padrão se não estiver configurado) 1. Um recurso com service.name definido como o nome da função do Lambda 1. Um propagador do X-Ray Lambda 1. Altere o método `handleRequest` para `doHandleRequest` e transmita o objeto `OpenTelemetrySdk` para a classe de base. 1. Instrumente o cliente Amazon S3 com a instrumentação do OpenTemetry AWS SDK registrando o interceptor ao criar o cliente. Você precisa das seguintes dependências OpenTelemetry relacionadas. ``` 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') } ``` O código a seguir demonstra a função do Lambda após as alterações necessárias. É possível criar extensões personalizadas adicionais para complementar as extensões fornecidas automaticamente. ``` 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); } } } ``` Ao invocar a função Lambda, você verá o seguinte rastreamento *em Trace* Map no CloudWatch console. ![Mapa de rastreamento no CloudWatch console.](http://docs.aws.amazon.com/pt_br/xray/latest/devguide/images/SDKDeprecation_Java.png)