From fb6e20ddf6b376ccd3e1a17aae1715ae1804619d Mon Sep 17 00:00:00 2001 From: David-DAM <82216301+David-DAM@users.noreply.github.com> Date: Sun, 9 Aug 2026 17:58:34 +0200 Subject: [PATCH 1/5] Add OpenTelemetry-based tracing module (powertools-tracing-opentelemetry) --- pom.xml | 2 + powertools-tracing-opentelemetry/pom.xml | 138 ++++++++++++++ .../opentelemetry/TracingOpenTelemetry.java | 110 +++++++++++ .../opentelemetry/internal/SpanOperation.java | 46 +++++ .../opentelemetry/internal/SpanScope.java | 67 +++++++ .../TracingOpenTelemetryTest.java | 173 ++++++++++++++++++ 6 files changed, 536 insertions(+) create mode 100644 powertools-tracing-opentelemetry/pom.xml create mode 100644 powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java create mode 100644 powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanOperation.java create mode 100644 powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanScope.java create mode 100644 powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetryTest.java diff --git a/pom.xml b/pom.xml index 8e847983a..227fdc8d6 100644 --- a/pom.xml +++ b/pom.xml @@ -77,6 +77,7 @@ powertools-parameters/powertools-parameters-appconfig powertools-parameters/powertools-parameters-tests examples + powertools-tracing-opentelemetry @@ -119,6 +120,7 @@ 2.3.0 1.5.0 0.11.5 + 1.65.0 diff --git a/powertools-tracing-opentelemetry/pom.xml b/powertools-tracing-opentelemetry/pom.xml new file mode 100644 index 000000000..9062184d7 --- /dev/null +++ b/powertools-tracing-opentelemetry/pom.xml @@ -0,0 +1,138 @@ + + + + 4.0.0 + + powertools-tracing-opentelemetry + jar + + + software.amazon.lambda + powertools-parent + 2.10.0 + + + Powertools for AWS Lambda (Java) - Tracing OpenTelemetry + + A suite of utilities for AWS Lambda Functions that makes tracing with OpenTelemetry, structured logging and creating custom metrics asynchronously easier. + + + + + io.opentelemetry + opentelemetry-api + ${opentelemetry-api.version} + + + org.aspectj + aspectjrt + provided + + + software.amazon.lambda + powertools-common + + + software.amazon.awssdk + aws-core + + + software.amazon.awssdk + sdk-core + + + com.amazonaws + aws-lambda-java-core + + + + + io.opentelemetry + opentelemetry-sdk + ${opentelemetry-api.version} + test + + + io.opentelemetry + opentelemetry-sdk-testing + ${opentelemetry-api.version} + test + + + org.mockito + mockito-core + test + + + org.junit.jupiter + junit-jupiter-api + test + + + org.junit.jupiter + junit-jupiter-engine + test + + + software.amazon.lambda + powertools-common + ${project.version} + test-jar + test + + + org.slf4j + slf4j-simple + test + + + org.junit-pioneer + junit-pioneer + test + + + org.apache.commons + commons-lang3 + test + + + org.aspectj + aspectjweaver + test + + + org.assertj + assertj-core + test + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + + + on-demand + + + + + + + \ No newline at end of file diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java new file mode 100644 index 000000000..4fd01b3b8 --- /dev/null +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java @@ -0,0 +1,110 @@ +/* + * Copyright 2023 Amazon.com, Inc. or its affiliates. + * Licensed under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package software.amazon.lambda.powertools.tracing.opentelemetry; + +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.Tracer; +import java.util.Objects; +import software.amazon.lambda.powertools.tracing.opentelemetry.internal.SpanOperation; +import software.amazon.lambda.powertools.tracing.opentelemetry.internal.SpanScope; + +/** + * A wrapper for OpenTelemetry's Tracer that simplifies the creation and management of spans. + * This class provides utility functions for starting and controlling spans and their contexts + * in the current execution thread. + *

+ * This is a final class and cannot be extended. + */ +public final class TracingOpenTelemetry { + + private final Tracer tracer; + + private TracingOpenTelemetry(Builder builder) { + this.tracer = builder.tracer; + } + + /** + * Creates a new span with the specified name and makes it the current span in the thread context. + * The span must be manually closed to properly end it and revert the thread context. + * + * @param name the name of the span to be created + * @return an instance of {@link SpanScope}, which represents the created span and its associated context + */ + public SpanScope addSpan(String name) { + return new SpanScope(tracer.spanBuilder(name).startSpan()); + } + + /** + * Retrieves the current active span in the execution context. + * + * @return the current {@link Span} if one is active, or a default no-op {@link Span} if none is active + */ + public Span currentSpan() { + return Span.current(); + } + + /** + * Executes the specified operation within the context of a new span. + * The span is automatically managed and closed when the operation completes + * or an exception is thrown. + * + * @param name the name of the span to be created + * @param operation the operation to be executed within the span's context + * @throws Exception if the provided operation throws an exception during execution + */ + public void withSpan(String name, SpanOperation operation) throws Exception { + try (SpanScope scope = addSpan(name)) { + try { + operation.execute(scope.span()); + } catch (Exception e) { + scope.recordException(e); + throw e; + } + } + } + + /** + * Creates and returns a new instance of the {@code Builder} class for constructing + * instances of {@code TracingOpenTelemetry}. + * + * @return a new {@code Builder} instance for configuring and building a {@code TracingOpenTelemetry} object + */ + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + + private Tracer tracer; + + public Builder tracer(Tracer tracer) { + this.tracer = tracer; + return this; + } + + /** + * Builds and returns a {@code TracingOpenTelemetry} instance configured with the specified {@code Tracer}. + * The returned instance provides utilities for creating and managing spans. + * + * @return a fully constructed {@code TracingOpenTelemetry} object based on the builder's configuration + * @throws NullPointerException if the {@code tracer} has not been set + */ + public TracingOpenTelemetry build() { + Objects.requireNonNull(tracer, "tracer must not be null"); + return new TracingOpenTelemetry(this); + } + } + +} \ No newline at end of file diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanOperation.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanOperation.java new file mode 100644 index 000000000..e93d080e0 --- /dev/null +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanOperation.java @@ -0,0 +1,46 @@ +/* + * Copyright 2023 Amazon.com, Inc. or its affiliates. + * Licensed under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package software.amazon.lambda.powertools.tracing.opentelemetry.internal; + +import io.opentelemetry.api.trace.Span; + +/** + * Represents a functional interface that encapsulates an operation to be performed + * within the context of an OpenTelemetry {@link Span}. + *

+ * This interface provides a contract for defining custom operations that take a + * {@link Span} as input and execute within its context. It is used in conjunction + * with utilities that manage OpenTelemetry spans, such as the {@code withSpan} method + * in the {@code TracingOpenTelemetry} class. + *

+ * Implementations of this interface enable the customization of behavior for spans, + * including adding events, setting attributes, or modifying the span's status. + *

+ * The operation defined by the {@code execute} method can throw an exception, which + * allows for handling of error scenarios and proper recording of exceptions in the span. + */ +@FunctionalInterface +public interface SpanOperation { + + /** + * Executes a custom operation within the context of the provided {@link Span}. + * This method allows for interaction with the span, such as adding events, + * setting attributes, or manipulating its status during the operation. + * + * @param span the {@link Span} within whose context the operation will be executed + * @throws Exception if an error occurs during the execution of the operation + */ + void execute(Span span) throws Exception; +} diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanScope.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanScope.java new file mode 100644 index 000000000..2326fbbca --- /dev/null +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanScope.java @@ -0,0 +1,67 @@ +/* + * Copyright 2023 Amazon.com, Inc. or its affiliates. + * Licensed under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package software.amazon.lambda.powertools.tracing.opentelemetry.internal; + +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.StatusCode; +import io.opentelemetry.context.Scope; + +/** + * A utility class that manages the lifecycle of a span and its associated context + * within a thread. It ensures that the span is properly closed and the thread context + * is restored when the scope is closed. + *

+ * This class is primarily used to work with OpenTelemetry spans, making them current + * in the thread context and managing their lifecycle, including recording exceptions + * and handling automatic cleanup of associated resources. + *

+ * It implements {@link AutoCloseable}, allowing it to be used in try-with-resources blocks + * to ensure proper cleanup of the span and scope. + */ +public final class SpanScope implements AutoCloseable { + + private final Span span; + private final Scope scope; + + public SpanScope(Span span) { + this.span = span; + this.scope = span.makeCurrent(); + } + + /** + * Retrieves the {@link Span} associated with this {@link SpanScope}. + * + * @return the {@link Span} managed by this {@link SpanScope} + */ + public Span span() { + return span; + } + + /** + * Records an exception in the span and sets its status to {@code StatusCode.ERROR}. + * + * @param throwable the {@link Throwable} instance to be recorded as an event in the span. + */ + public void recordException(Throwable throwable) { + span.recordException(throwable); + span.setStatus(StatusCode.ERROR); + } + + @Override + public void close() { + scope.close(); + span.end(); + } +} diff --git a/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetryTest.java b/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetryTest.java new file mode 100644 index 000000000..b6d37206c --- /dev/null +++ b/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetryTest.java @@ -0,0 +1,173 @@ +/* + * Copyright 2023 Amazon.com, Inc. or its affiliates. + * Licensed under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package software.amazon.lambda.powertools.tracing.opentelemetry; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.Tracer; +import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter; +import io.opentelemetry.sdk.trace.SdkTracerProvider; +import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor; +import org.junit.jupiter.api.Test; +import software.amazon.lambda.powertools.tracing.opentelemetry.internal.SpanScope; + +class TracingOpenTelemetryTest { + + @Test + void shouldCreateAndMakeSpanCurrent() { + SdkTracerProvider tracerProvider = SdkTracerProvider.builder().build(); + + Tracer tracer = tracerProvider.get("test-tracer"); + + TracingOpenTelemetry tracing = TracingOpenTelemetry.builder() + .tracer(tracer) + .build(); + + try (SpanScope scope = tracing.addSpan("payment")) { + assertThat(scope.span().getSpanContext().isValid()) + .isTrue(); + + assertThat(Span.current()) + .isEqualTo(scope.span()); + } + } + + @Test + void shouldEndSpanWhenScopeIsClosed() { + InMemorySpanExporter exporter = InMemorySpanExporter.create(); + + SdkTracerProvider tracerProvider = SdkTracerProvider.builder() + .addSpanProcessor(SimpleSpanProcessor.create(exporter)) + .build(); + + Tracer tracer = tracerProvider.get("test-tracer"); + + TracingOpenTelemetry tracing = TracingOpenTelemetry.builder() + .tracer(tracer) + .build(); + + try (SpanScope scope = tracing.addSpan("payment")) { + assertThat(exporter.getFinishedSpanItems()) + .isEmpty(); + } + + assertThat(exporter.getFinishedSpanItems()) + .hasSize(1); + + assertThat(exporter.getFinishedSpanItems().get(0).getName()) + .isEqualTo("payment"); + + tracerProvider.close(); + } + + @Test + void shouldRestorePreviousSpanWhenScopeIsClosed() { + + SdkTracerProvider tracerProvider = SdkTracerProvider.builder().build(); + + Tracer tracer = tracerProvider.get("test-tracer"); + + TracingOpenTelemetry tracing = TracingOpenTelemetry.builder() + .tracer(tracer) + .build(); + + try (SpanScope outer = tracing.addSpan("outer")) { + + assertThat(Span.current()).isEqualTo(outer.span()); + + try (SpanScope inner = tracing.addSpan("inner")) { + assertThat(Span.current()).isEqualTo(inner.span()); + } + + assertThat(Span.current()).isEqualTo(outer.span()); + } + } + + @Test + void shouldRecordException() { + InMemorySpanExporter exporter = InMemorySpanExporter.create(); + + SdkTracerProvider tracerProvider = SdkTracerProvider.builder() + .addSpanProcessor(SimpleSpanProcessor.create(exporter)) + .build(); + + Tracer tracer = tracerProvider.get("test-tracer"); + + TracingOpenTelemetry tracing = TracingOpenTelemetry.builder() + .tracer(tracer) + .build(); + + RuntimeException exception = new RuntimeException("boom"); + + try (SpanScope scope = tracing.addSpan("payment")) { + scope.recordException(exception); + } + + assertThat(exporter.getFinishedSpanItems()) + .hasSize(1); + + assertThat(exporter.getFinishedSpanItems().get(0).getEvents()) + .hasSize(1); + + assertThat(exporter.getFinishedSpanItems().get(0).getEvents().get(0).getName()) + .isEqualTo("exception"); + + assertThat(exporter.getFinishedSpanItems().get(0).getStatus().getStatusCode()) + .isEqualTo(io.opentelemetry.api.trace.StatusCode.ERROR); + + tracerProvider.close(); + } + + @Test + void shouldRecordExceptionWhenUsingWithSpan() throws Exception { + InMemorySpanExporter exporter = InMemorySpanExporter.create(); + + SdkTracerProvider tracerProvider = SdkTracerProvider.builder() + .addSpanProcessor(SimpleSpanProcessor.create(exporter)) + .build(); + + Tracer tracer = tracerProvider.get("test-tracer"); + + TracingOpenTelemetry tracing = TracingOpenTelemetry.builder() + .tracer(tracer) + .build(); + + RuntimeException exception = new RuntimeException("boom"); + + assertThatThrownBy(() -> + tracing.withSpan("payment", span -> { + throw exception; + }) + ).isSameAs(exception); + + assertThat(exporter.getFinishedSpanItems()) + .hasSize(1); + + assertThat(exporter.getFinishedSpanItems().get(0).getEvents()) + .hasSize(1); + + assertThat(exporter.getFinishedSpanItems().get(0).getEvents().get(0).getName()) + .isEqualTo("exception"); + + assertThat(exporter.getFinishedSpanItems().get(0).getStatus().getStatusCode()) + .isEqualTo(io.opentelemetry.api.trace.StatusCode.ERROR); + + tracerProvider.close(); + } + + +} \ No newline at end of file From 4aa52290a7c773123f77702a3c520006e8698805 Mon Sep 17 00:00:00 2001 From: David-DAM <82216301+David-DAM@users.noreply.github.com> Date: Sat, 15 Aug 2026 12:03:21 +0200 Subject: [PATCH 2/5] Introduce TracingOpenTelemetryAspect for annotation-based span creation --- .../common/internal/SystemWrapper.java | 4 + powertools-tracing-opentelemetry/pom.xml | 4 + .../tracing/opentelemetry/CaptureMode.java | 32 +++++ .../opentelemetry/TracingOpenTelemetry.java | 69 +++++----- .../tracing/opentelemetry/TracingOtel.java | 36 +++++ .../opentelemetry/internal/SpanOperation.java | 27 ++-- .../internal/TracingOpenTelemetryAspect.java | 123 ++++++++++++++++++ .../TracingOpenTelemetryTest.java | 24 +--- .../opentelemetry/internal/SpanScopeTest.java | 51 ++++++++ .../TracingOpenTelemetryAspectTest.java | 114 ++++++++++++++++ 10 files changed, 420 insertions(+), 64 deletions(-) create mode 100644 powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/CaptureMode.java create mode 100644 powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOtel.java create mode 100644 powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspect.java create mode 100644 powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanScopeTest.java create mode 100644 powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspectTest.java diff --git a/powertools-common/src/main/java/software/amazon/lambda/powertools/common/internal/SystemWrapper.java b/powertools-common/src/main/java/software/amazon/lambda/powertools/common/internal/SystemWrapper.java index 6dc4e9d9f..cc8ea39e9 100644 --- a/powertools-common/src/main/java/software/amazon/lambda/powertools/common/internal/SystemWrapper.java +++ b/powertools-common/src/main/java/software/amazon/lambda/powertools/common/internal/SystemWrapper.java @@ -22,6 +22,10 @@ public static String getenv(String name) { return System.getenv(name); } + public static boolean containsKey(String key) { + return System.getenv().containsKey(key); + } + public static String getProperty(String name) { return System.getProperty(name); } diff --git a/powertools-tracing-opentelemetry/pom.xml b/powertools-tracing-opentelemetry/pom.xml index 9062184d7..7533345e1 100644 --- a/powertools-tracing-opentelemetry/pom.xml +++ b/powertools-tracing-opentelemetry/pom.xml @@ -58,6 +58,10 @@ com.amazonaws aws-lambda-java-core + + com.fasterxml.jackson.core + jackson-databind + diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/CaptureMode.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/CaptureMode.java new file mode 100644 index 000000000..d62c3b1ff --- /dev/null +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/CaptureMode.java @@ -0,0 +1,32 @@ +package software.amazon.lambda.powertools.tracing.opentelemetry; + +/** + * Defines how method responses and errors are captured by tracing. + */ +public enum CaptureMode { + + /** + * Capture response and errors according to environment variables. + */ + ENVIRONMENT_VAR, + + /** + * Capture the method response. + */ + RESPONSE, + + /** + * Capture errors thrown by the method. + */ + ERROR, + + /** + * Capture both the method response and errors. + */ + RESPONSE_AND_ERROR, + + /** + * Disable response and error capture. + */ + DISABLED +} \ No newline at end of file diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java index 4fd01b3b8..b3ab1cdd8 100644 --- a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java @@ -14,6 +14,7 @@ package software.amazon.lambda.powertools.tracing.opentelemetry; +import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.api.trace.Span; import io.opentelemetry.api.trace.Tracer; import java.util.Objects; @@ -29,10 +30,31 @@ */ public final class TracingOpenTelemetry { + private static final String INSTRUMENTATION_NAME = + "aws-lambda-powertools"; + private final Tracer tracer; - private TracingOpenTelemetry(Builder builder) { - this.tracer = builder.tracer; + /** + * Creates a tracing instance using the provided tracer. + * + *

This constructor is primarily useful for testing. + * + * @param tracer the OpenTelemetry tracer + */ + TracingOpenTelemetry(Tracer tracer) { + this.tracer = Objects.requireNonNull(tracer, "tracer must not be null"); + } + + /** + * Initializes a new instance of the {@code TracingOpenTelemetry} class, using + * the global OpenTelemetry tracer identified by the instrumentation name. + *

+ * This constructor simplifies the setup process for applications by + * automatically leveraging the globally configured instrumentation tracer. + */ + public TracingOpenTelemetry() { + this(GlobalOpenTelemetry.getTracer(INSTRUMENTATION_NAME)); } /** @@ -43,7 +65,11 @@ private TracingOpenTelemetry(Builder builder) { * @return an instance of {@link SpanScope}, which represents the created span and its associated context */ public SpanScope addSpan(String name) { - return new SpanScope(tracer.spanBuilder(name).startSpan()); + Span span = tracer + .spanBuilder(name) + .startSpan(); + + return new SpanScope(span); } /** @@ -60,14 +86,14 @@ public Span currentSpan() { * The span is automatically managed and closed when the operation completes * or an exception is thrown. * - * @param name the name of the span to be created + * @param name the name of the span to be created * @param operation the operation to be executed within the span's context * @throws Exception if the provided operation throws an exception during execution */ - public void withSpan(String name, SpanOperation operation) throws Exception { + public T withSpan(String name, SpanOperation operation) throws Exception { try (SpanScope scope = addSpan(name)) { try { - operation.execute(scope.span()); + return operation.execute(scope.span()); } catch (Exception e) { scope.recordException(e); throw e; @@ -76,35 +102,12 @@ public void withSpan(String name, SpanOperation operation) throws Exception { } /** - * Creates and returns a new instance of the {@code Builder} class for constructing - * instances of {@code TracingOpenTelemetry}. + * Creates a new tracing instance using the global OpenTelemetry tracer. * - * @return a new {@code Builder} instance for configuring and building a {@code TracingOpenTelemetry} object + * @return a new tracing instance */ - public static Builder builder() { - return new Builder(); - } - - public static final class Builder { - - private Tracer tracer; - - public Builder tracer(Tracer tracer) { - this.tracer = tracer; - return this; - } - - /** - * Builds and returns a {@code TracingOpenTelemetry} instance configured with the specified {@code Tracer}. - * The returned instance provides utilities for creating and managing spans. - * - * @return a fully constructed {@code TracingOpenTelemetry} object based on the builder's configuration - * @throws NullPointerException if the {@code tracer} has not been set - */ - public TracingOpenTelemetry build() { - Objects.requireNonNull(tracer, "tracer must not be null"); - return new TracingOpenTelemetry(this); - } + public static TracingOpenTelemetry create() { + return new TracingOpenTelemetry(); } } \ No newline at end of file diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOtel.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOtel.java new file mode 100644 index 000000000..1112b53aa --- /dev/null +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOtel.java @@ -0,0 +1,36 @@ +package software.amazon.lambda.powertools.tracing.opentelemetry; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.METHOD) +public @interface TracingOtel { + /** + * The namespace associated with the span. + * + *

If empty, the default Powertools service name is used. + * + * @return the namespace + */ + String namespace() default ""; + + /** + * The name of the span. + * + *

If empty, the annotated method name is used. + * + * @return the span name + */ + String spanName() default ""; + + /** + * Controls whether the method response and/or errors are captured + * as span data. + * + * @return the capture mode + */ + CaptureMode captureMode() default CaptureMode.ENVIRONMENT_VAR; +} diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanOperation.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanOperation.java index e93d080e0..a0d589db5 100644 --- a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanOperation.java +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanOperation.java @@ -17,22 +17,21 @@ import io.opentelemetry.api.trace.Span; /** - * Represents a functional interface that encapsulates an operation to be performed - * within the context of an OpenTelemetry {@link Span}. - *

- * This interface provides a contract for defining custom operations that take a - * {@link Span} as input and execute within its context. It is used in conjunction - * with utilities that manage OpenTelemetry spans, such as the {@code withSpan} method - * in the {@code TracingOpenTelemetry} class. - *

- * Implementations of this interface enable the customization of behavior for spans, - * including adding events, setting attributes, or modifying the span's status. + * Represents a functional interface used to execute a custom operation within + * the context of a given {@link Span}. This interface requires implementing a + * single method that performs an operation with the span and optionally + * returns a result. + * *

- * The operation defined by the {@code execute} method can throw an exception, which - * allows for handling of error scenarios and proper recording of exceptions in the span. + * The {@code SpanOperation} interface enables tracing and manipulation of + * a span during its lifecycle, such as setting attributes, adding events, + * or updating status codes. It can be used alongside frameworks that support + * OpenTelemetry for distributed tracing. + * + * @param the type of result returned by the custom span operation */ @FunctionalInterface -public interface SpanOperation { +public interface SpanOperation { /** * Executes a custom operation within the context of the provided {@link Span}. @@ -42,5 +41,5 @@ public interface SpanOperation { * @param span the {@link Span} within whose context the operation will be executed * @throws Exception if an error occurs during the execution of the operation */ - void execute(Span span) throws Exception; + T execute(Span span) throws Exception; } diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspect.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspect.java new file mode 100644 index 000000000..fee0d1bfd --- /dev/null +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspect.java @@ -0,0 +1,123 @@ +package software.amazon.lambda.powertools.tracing.opentelemetry.internal; + +import static software.amazon.lambda.powertools.common.internal.LambdaHandlerProcessor.coldStartDone; +import static software.amazon.lambda.powertools.common.internal.LambdaHandlerProcessor.isColdStart; +import static software.amazon.lambda.powertools.common.internal.LambdaHandlerProcessor.isHandlerMethod; +import static software.amazon.lambda.powertools.common.internal.LambdaHandlerProcessor.serviceName; + +import com.fasterxml.jackson.databind.ObjectMapper; +import io.opentelemetry.api.trace.Span; +import org.aspectj.lang.ProceedingJoinPoint; +import org.aspectj.lang.annotation.Around; +import org.aspectj.lang.annotation.Aspect; +import org.aspectj.lang.annotation.Pointcut; +import software.amazon.lambda.powertools.common.internal.SystemWrapper; +import software.amazon.lambda.powertools.tracing.opentelemetry.TracingOpenTelemetry; +import software.amazon.lambda.powertools.tracing.opentelemetry.TracingOtel; + +@Aspect +public final class TracingOpenTelemetryAspect { + //tracing cannot be final for testing purposes + private static TracingOpenTelemetry tracing = + TracingOpenTelemetry.create(); + + private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper(); + private static final String COLD_START_ATTRIBUTE = + "aws.lambda.powertools.cold_start"; + + private static final String SERVICE_ATTRIBUTE = + "aws.lambda.powertools.service"; + + private static final String RESPONSE_ATTRIBUTE = + "aws.lambda.powertools.response"; + + @SuppressWarnings({"EmptyMethod"}) + @Pointcut("@annotation(tracingOtel)") + public void callAt(TracingOtel tracingOtel) { + } + + @Around( + value = "callAt(tracingOtel) && execution(@TracingOtel * *.*(..))", + argNames = "pjp,tracingOtel" + ) + public Object around(ProceedingJoinPoint pjp, TracingOtel tracingOtel) throws Throwable { + + String spanName = tracingOtel.spanName().isEmpty() + ? pjp.getSignature().getName() + : tracingOtel.spanName(); + + String namespace = tracingOtel.namespace().isEmpty() + ? serviceName() + : tracingOtel.namespace(); + + try (SpanScope scope = tracing.addSpan(spanName)) { + + Span span = scope.span(); + + if (isHandlerMethod(pjp)) { + span.setAttribute(COLD_START_ATTRIBUTE, isColdStart()); + span.setAttribute(SERVICE_ATTRIBUTE, namespace); + } + + try { + + Object result = pjp.proceed(pjp.getArgs()); + + if (captureResponse(tracingOtel)) { + span.setAttribute(RESPONSE_ATTRIBUTE, OBJECT_MAPPER.writeValueAsString(result)); + } + + if (isHandlerMethod(pjp)) { + coldStartDone(); + } + + return result; + } catch (Throwable throwable) { + + if (captureError(tracingOtel)) { + scope.recordException(throwable); + } + throw throwable; + } + } + } + + private boolean captureResponse(TracingOtel tracing) { + switch (tracing.captureMode()) { + case ENVIRONMENT_VAR: + return isEnvironmentVariableSet("POWERTOOLS_TRACER_CAPTURE_RESPONSE") + && environmentVariable("POWERTOOLS_TRACER_CAPTURE_RESPONSE"); + case RESPONSE: + case RESPONSE_AND_ERROR: + return true; + case DISABLED: + case ERROR: + default: + return false; + } + } + + private boolean captureError(TracingOtel tracing) { + switch (tracing.captureMode()) { + case ENVIRONMENT_VAR: + return isEnvironmentVariableSet("POWERTOOLS_TRACER_CAPTURE_ERROR") + && environmentVariable("POWERTOOLS_TRACER_CAPTURE_ERROR"); + case ERROR: + case RESPONSE_AND_ERROR: + return true; + case DISABLED: + case RESPONSE: + default: + return false; + } + } + + private boolean environmentVariable(String key) { + return Boolean.parseBoolean(SystemWrapper.getenv(key)); + } + + private boolean isEnvironmentVariableSet(String key) { + return SystemWrapper.containsKey(key); + } + +} diff --git a/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetryTest.java b/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetryTest.java index b6d37206c..cb64c11f3 100644 --- a/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetryTest.java +++ b/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetryTest.java @@ -33,9 +33,7 @@ void shouldCreateAndMakeSpanCurrent() { Tracer tracer = tracerProvider.get("test-tracer"); - TracingOpenTelemetry tracing = TracingOpenTelemetry.builder() - .tracer(tracer) - .build(); + TracingOpenTelemetry tracing = new TracingOpenTelemetry(tracer); try (SpanScope scope = tracing.addSpan("payment")) { assertThat(scope.span().getSpanContext().isValid()) @@ -56,11 +54,9 @@ void shouldEndSpanWhenScopeIsClosed() { Tracer tracer = tracerProvider.get("test-tracer"); - TracingOpenTelemetry tracing = TracingOpenTelemetry.builder() - .tracer(tracer) - .build(); + TracingOpenTelemetry tracing = new TracingOpenTelemetry(tracer); - try (SpanScope scope = tracing.addSpan("payment")) { + try (SpanScope ignored = tracing.addSpan("payment")) { assertThat(exporter.getFinishedSpanItems()) .isEmpty(); } @@ -81,9 +77,7 @@ void shouldRestorePreviousSpanWhenScopeIsClosed() { Tracer tracer = tracerProvider.get("test-tracer"); - TracingOpenTelemetry tracing = TracingOpenTelemetry.builder() - .tracer(tracer) - .build(); + TracingOpenTelemetry tracing = new TracingOpenTelemetry(tracer); try (SpanScope outer = tracing.addSpan("outer")) { @@ -107,9 +101,7 @@ void shouldRecordException() { Tracer tracer = tracerProvider.get("test-tracer"); - TracingOpenTelemetry tracing = TracingOpenTelemetry.builder() - .tracer(tracer) - .build(); + TracingOpenTelemetry tracing = new TracingOpenTelemetry(tracer); RuntimeException exception = new RuntimeException("boom"); @@ -133,7 +125,7 @@ void shouldRecordException() { } @Test - void shouldRecordExceptionWhenUsingWithSpan() throws Exception { + void shouldRecordExceptionWhenUsingWithSpan() { InMemorySpanExporter exporter = InMemorySpanExporter.create(); SdkTracerProvider tracerProvider = SdkTracerProvider.builder() @@ -142,9 +134,7 @@ void shouldRecordExceptionWhenUsingWithSpan() throws Exception { Tracer tracer = tracerProvider.get("test-tracer"); - TracingOpenTelemetry tracing = TracingOpenTelemetry.builder() - .tracer(tracer) - .build(); + TracingOpenTelemetry tracing = new TracingOpenTelemetry(tracer); RuntimeException exception = new RuntimeException("boom"); diff --git a/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanScopeTest.java b/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanScopeTest.java new file mode 100644 index 000000000..e0710f765 --- /dev/null +++ b/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanScopeTest.java @@ -0,0 +1,51 @@ +package software.amazon.lambda.powertools.tracing.opentelemetry.internal; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.context.Scope; +import org.junit.jupiter.api.Test; + +class SpanScopeTest { + + @Test + void span_returnsCurrentSpan() { + + Span mockSpan = mock(Span.class); + SpanScope spanScope = new SpanScope(mockSpan); + + Span result = spanScope.span(); + + assertEquals(mockSpan, result, "The span method should return the same Span instance."); + } + + @Test + void recordException_recordsThrowableAndSetsErrorStatus() { + Span mockSpan = mock(Span.class); + SpanScope spanScope = new SpanScope(mockSpan); + Throwable exception = new RuntimeException("Test exception"); + + spanScope.recordException(exception); + + verify(mockSpan).recordException(exception); + verify(mockSpan).setStatus(io.opentelemetry.api.trace.StatusCode.ERROR); + } + + @Test + void close_closesScopeAndEndsSpan() { + + Span mockSpan = mock(Span.class); + Scope mockScope = mock(Scope.class); + when(mockSpan.makeCurrent()).thenReturn(mockScope); + + SpanScope spanScope = new SpanScope(mockSpan); + + spanScope.close(); + + verify(mockScope).close(); + verify(mockSpan).end(); + } +} \ No newline at end of file diff --git a/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspectTest.java b/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspectTest.java new file mode 100644 index 000000000..fc1da7408 --- /dev/null +++ b/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspectTest.java @@ -0,0 +1,114 @@ +package software.amazon.lambda.powertools.tracing.opentelemetry.internal; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.anyString; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.amazonaws.services.lambda.runtime.RequestHandler; +import org.apache.commons.lang3.reflect.FieldUtils; +import org.aspectj.lang.ProceedingJoinPoint; +import org.aspectj.lang.Signature; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import software.amazon.lambda.powertools.tracing.opentelemetry.CaptureMode; +import software.amazon.lambda.powertools.tracing.opentelemetry.TracingOpenTelemetry; +import software.amazon.lambda.powertools.tracing.opentelemetry.TracingOtel; + +class TracingOpenTelemetryAspectTest { + + private ProceedingJoinPoint pjp; + private TracingOtel tracingOtel; + private TracingOpenTelemetry tracingOpenTelemetry; + private SpanScope spanScope; + private Signature signature; + private TracingOpenTelemetry originalTracing; + + @BeforeEach + void setUp() throws IllegalAccessException { + pjp = mock(ProceedingJoinPoint.class); + tracingOtel = mock(TracingOtel.class); + tracingOpenTelemetry = mock(TracingOpenTelemetry.class); + spanScope = mock(SpanScope.class); + signature = mock(Signature.class); + + originalTracing = (TracingOpenTelemetry) FieldUtils + .readStaticField(TracingOpenTelemetryAspect.class, "tracing", true); + + FieldUtils.writeStaticField(TracingOpenTelemetryAspect.class, "tracing", tracingOpenTelemetry, true); + } + + @AfterEach + void tearDown() throws IllegalAccessException { + FieldUtils.writeStaticField(TracingOpenTelemetryAspect.class, "tracing", originalTracing, true); + } + + @Test + void testAroundMethodSuccessfulExecution() throws Throwable { + + when(tracingOpenTelemetry.addSpan(anyString())).thenReturn(spanScope); + when(pjp.getSignature()).thenReturn(signature); + when(signature.getName()).thenReturn("testMethod"); + when(signature.getDeclaringType()).thenReturn(RequestHandler.class); + Object[] args = new Object[0]; + when(pjp.getArgs()).thenReturn(args); + when(tracingOtel.spanName()).thenReturn("testMethod"); + when(tracingOtel.namespace()).thenReturn("test"); + when(tracingOtel.captureMode()).thenReturn(CaptureMode.ENVIRONMENT_VAR); + when(pjp.proceed(any(Object[].class))).thenReturn("Success"); + + TracingOpenTelemetryAspect aspect = new TracingOpenTelemetryAspect(); + Object result = aspect.around(pjp, tracingOtel); + + verify(tracingOpenTelemetry).addSpan("testMethod"); + verify(pjp).proceed(any(Object[].class)); + assertEquals("Success", result); + } + + @Test + void testAroundMethodExceptionFlow() throws Throwable { + + + when(tracingOpenTelemetry.addSpan(anyString())).thenReturn(spanScope); + when(pjp.getSignature()).thenReturn(signature); + when(signature.getName()).thenReturn("testMethod"); + when(signature.getDeclaringType()).thenReturn(RequestHandler.class); + when(pjp.getArgs()).thenReturn(new Object[0]); + Throwable mockThrowable = new RuntimeException("Test Exception"); + when(tracingOtel.spanName()).thenReturn("testMethod"); + when(tracingOtel.namespace()).thenReturn("test"); + when(tracingOtel.captureMode()).thenReturn(CaptureMode.ERROR); + when(pjp.proceed(pjp.getArgs())).thenThrow(mockThrowable); + + TracingOpenTelemetryAspect aspect = new TracingOpenTelemetryAspect(); + RuntimeException exception = assertThrows(RuntimeException.class, () -> aspect.around(pjp, tracingOtel)); + + verify(tracingOpenTelemetry).addSpan("testMethod"); + verify(spanScope).recordException(mockThrowable); + assertEquals("Test Exception", exception.getMessage()); + } + + @Test + void testAddSpanIsCalledWithCorrectSignature() throws Throwable { + + when(tracingOpenTelemetry.addSpan(anyString())).thenReturn(spanScope); + when(pjp.getSignature()).thenReturn(signature); + Object[] args = new Object[0]; + when(pjp.getArgs()).thenReturn(args); + when(signature.getDeclaringType()).thenReturn(RequestHandler.class); + when(signature.getName()).thenReturn("correctMethodSignature"); + when(tracingOtel.spanName()).thenReturn("correctMethodSignature"); + when(tracingOtel.captureMode()).thenReturn(CaptureMode.ENVIRONMENT_VAR); + when(tracingOtel.namespace()).thenReturn("test"); + when(pjp.proceed()).thenReturn("Success"); + + TracingOpenTelemetryAspect aspect = new TracingOpenTelemetryAspect(); + aspect.around(pjp, tracingOtel); + + verify(tracingOpenTelemetry).addSpan("correctMethodSignature"); + } +} \ No newline at end of file From e01f87d503c8772792cc47aff6d9858048b7fdba Mon Sep 17 00:00:00 2001 From: David-DAM <82216301+David-DAM@users.noreply.github.com> Date: Sat, 15 Aug 2026 12:05:55 +0200 Subject: [PATCH 3/5] Add JavaDoc to TracingOtel annotation for OpenTelemetry tracing configuration --- .../powertools/tracing/opentelemetry/TracingOtel.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOtel.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOtel.java index 1112b53aa..33dc7ee2c 100644 --- a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOtel.java +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOtel.java @@ -5,6 +5,13 @@ import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; +/** + * Annotation to enable OpenTelemetry tracing for the annotated method. + * Automatically creates and manages an OpenTelemetry span for the method invocation. + *

+ * This annotation allows configuration of the namespace, span name, and capture mode + * for tracing purposes. If no explicit configuration is provided, default values are used. + */ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface TracingOtel { From bac5e69c9c3b02cc5ff53d65843eba71dc838136 Mon Sep 17 00:00:00 2001 From: David-DAM <82216301+David-DAM@users.noreply.github.com> Date: Sun, 16 Aug 2026 11:51:38 +0200 Subject: [PATCH 4/5] Refactor TracingOpenTelemetry for handler-specific attributes, response/error capture, and contextual propagation --- powertools-tracing-opentelemetry/pom.xml | 19 +- .../{TracingOtel.java => Tracing.java} | 2 +- .../opentelemetry/TracingOpenTelemetry.java | 268 ++++++++++++++---- .../internal/AttributesConstants.java | 42 +++ .../internal/LambdaResource.java | 115 ++++++++ .../internal/OpenTelemetryProvider.java | 79 ++++++ .../opentelemetry/internal/SpanScope.java | 42 ++- .../internal/TracingOpenTelemetryAspect.java | 199 +++++++++---- .../TracingOpenTelemetryTest.java | 163 +++++++++++ .../TracingOpenTelemetryAspectTest.java | 30 +- 10 files changed, 800 insertions(+), 159 deletions(-) rename powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/{TracingOtel.java => Tracing.java} (97%) create mode 100644 powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/AttributesConstants.java create mode 100644 powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/LambdaResource.java create mode 100644 powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/OpenTelemetryProvider.java diff --git a/powertools-tracing-opentelemetry/pom.xml b/powertools-tracing-opentelemetry/pom.xml index 7533345e1..304ee0d42 100644 --- a/powertools-tracing-opentelemetry/pom.xml +++ b/powertools-tracing-opentelemetry/pom.xml @@ -28,7 +28,8 @@ Powertools for AWS Lambda (Java) - Tracing OpenTelemetry - A suite of utilities for AWS Lambda Functions that makes tracing with OpenTelemetry, structured logging and creating custom metrics asynchronously easier. + A suite of utilities for AWS Lambda Functions that makes tracing with OpenTelemetry, structured logging and + creating custom metrics asynchronously easier. @@ -37,6 +38,16 @@ opentelemetry-api ${opentelemetry-api.version} + + io.opentelemetry + opentelemetry-sdk + ${opentelemetry-api.version} + + + io.opentelemetry + opentelemetry-exporter-otlp + ${opentelemetry-api.version} + org.aspectj aspectjrt @@ -64,12 +75,6 @@ - - io.opentelemetry - opentelemetry-sdk - ${opentelemetry-api.version} - test - io.opentelemetry opentelemetry-sdk-testing diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOtel.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/Tracing.java similarity index 97% rename from powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOtel.java rename to powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/Tracing.java index 33dc7ee2c..2d4d68608 100644 --- a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOtel.java +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/Tracing.java @@ -14,7 +14,7 @@ */ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) -public @interface TracingOtel { +public @interface Tracing { /** * The namespace associated with the span. * diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java index b3ab1cdd8..e96c525a5 100644 --- a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java @@ -2,8 +2,10 @@ * Copyright 2023 Amazon.com, Inc. or its affiliates. * Licensed under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at + * with the License. You may obtain a copy of the License at + * * http://www.apache.org/licenses/LICENSE-2.0 + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @@ -14,100 +16,240 @@ package software.amazon.lambda.powertools.tracing.opentelemetry; -import io.opentelemetry.api.GlobalOpenTelemetry; +import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.SpanKind; import io.opentelemetry.api.trace.Tracer; +import io.opentelemetry.context.Context; +import io.opentelemetry.context.propagation.TextMapGetter; +import io.opentelemetry.context.propagation.TextMapPropagator; +import io.opentelemetry.context.propagation.TextMapSetter; import java.util.Objects; +import software.amazon.lambda.powertools.common.internal.LambdaHandlerProcessor; +import software.amazon.lambda.powertools.tracing.opentelemetry.internal.OpenTelemetryProvider; import software.amazon.lambda.powertools.tracing.opentelemetry.internal.SpanOperation; import software.amazon.lambda.powertools.tracing.opentelemetry.internal.SpanScope; -/** - * A wrapper for OpenTelemetry's Tracer that simplifies the creation and management of spans. - * This class provides utility functions for starting and controlling spans and their contexts - * in the current execution thread. - *

- * This is a final class and cannot be extended. - */ -public final class TracingOpenTelemetry { - private static final String INSTRUMENTATION_NAME = - "aws-lambda-powertools"; +public final class TracingOpenTelemetry { private final Tracer tracer; + private final TextMapPropagator propagator; + + private TracingOpenTelemetry(Builder builder) { + this.tracer = Objects.requireNonNull( + builder.tracer, + "tracer must not be null" + ); + this.propagator = Objects.requireNonNull( + builder.propagator, + "propagator must not be null" + ); + } - /** - * Creates a tracing instance using the provided tracer. - * - *

This constructor is primarily useful for testing. - * - * @param tracer the OpenTelemetry tracer - */ - TracingOpenTelemetry(Tracer tracer) { - this.tracer = Objects.requireNonNull(tracer, "tracer must not be null"); - } - - /** - * Initializes a new instance of the {@code TracingOpenTelemetry} class, using - * the global OpenTelemetry tracer identified by the instrumentation name. - *

- * This constructor simplifies the setup process for applications by - * automatically leveraging the globally configured instrumentation tracer. - */ public TracingOpenTelemetry() { - this(GlobalOpenTelemetry.getTracer(INSTRUMENTATION_NAME)); + this(OpenTelemetryProvider.tracer()); + } + + + public TracingOpenTelemetry(Tracer tracer) { + this(tracer, createDefaultPropagator()); } - /** - * Creates a new span with the specified name and makes it the current span in the thread context. - * The span must be manually closed to properly end it and revert the thread context. - * - * @param name the name of the span to be created - * @return an instance of {@link SpanScope}, which represents the created span and its associated context - */ + + public TracingOpenTelemetry( + Tracer tracer, + TextMapPropagator propagator) { + + this.tracer = Objects.requireNonNull( + tracer, + "tracer must not be null" + ); + this.propagator = Objects.requireNonNull( + propagator, + "propagator must not be null" + ); + } + + public SpanScope addSpan(String name) { - Span span = tracer - .spanBuilder(name) + return addSpan(name, SpanKind.INTERNAL); + } + + + public SpanScope addSpan( + String name, + SpanKind kind) { + + return addSpan(name, kind, Attributes.empty()); + } + + + public SpanScope addSpan( + String name, + SpanKind kind, + Attributes attributes) { + + Objects.requireNonNull(name, "name must not be null"); + Objects.requireNonNull(kind, "kind must not be null"); + Objects.requireNonNull(attributes, "attributes must not be null"); + + Span span = tracer.spanBuilder(name) + .setSpanKind(kind) + .setAllAttributes(attributes) .startSpan(); return new SpanScope(span); } - /** - * Retrieves the current active span in the execution context. - * - * @return the current {@link Span} if one is active, or a default no-op {@link Span} if none is active - */ + public SpanScope addSpan( + String name, + SpanKind kind, + Attributes attributes, + Context parentContext) { + + Objects.requireNonNull(parentContext, "parentContext must not be null"); + + Span span = tracer.spanBuilder(name) + .setParent(parentContext) + .setSpanKind(kind) + .setAllAttributes(attributes) + .startSpan(); + + return new SpanScope(span); + } + + public Span currentSpan() { return Span.current(); } - /** - * Executes the specified operation within the context of a new span. - * The span is automatically managed and closed when the operation completes - * or an exception is thrown. - * - * @param name the name of the span to be created - * @param operation the operation to be executed within the span's context - * @throws Exception if the provided operation throws an exception during execution - */ - public T withSpan(String name, SpanOperation operation) throws Exception { + + public T withSpan( + String name, + SpanOperation operation) throws Exception { + + Objects.requireNonNull(operation, "operation must not be null"); + try (SpanScope scope = addSpan(name)) { try { return operation.execute(scope.span()); - } catch (Exception e) { - scope.recordException(e); - throw e; + } catch (Exception exception) { + scope.recordException(exception); + throw exception; } } } - /** - * Creates a new tracing instance using the global OpenTelemetry tracer. - * - * @return a new tracing instance - */ + public T captureLambdaHandler( + String name, + com.amazonaws.services.lambda.runtime.Context lambdaContext, + io.opentelemetry.context.Context parentContext, + SpanOperation operation) throws Exception { + + Objects.requireNonNull(name, "name must not be null"); + Objects.requireNonNull(parentContext, "parentContext must not be null"); + Objects.requireNonNull(operation, "operation must not be null"); + + Span span = tracer.spanBuilder(name) + .setParent(parentContext) + .setSpanKind(SpanKind.SERVER) + .setAttribute("faas.coldstart", LambdaHandlerProcessor.isColdStart()) + .setAttribute("faas.invocation_id", lambdaContext.getAwsRequestId()) + .startSpan(); + + try (SpanScope scope = new SpanScope(span)) { + try { + T result = operation.execute(span); + + LambdaHandlerProcessor.coldStartDone(); + + return result; + } catch (Exception exception) { + scope.recordException(exception); + throw exception; + } + } + } + + public Context extractContext( + T carrier, + TextMapGetter getter) { + + return extractContext(Context.current(), carrier, getter); + } + + + public Context extractContext( + Context context, + T carrier, + TextMapGetter getter) { + + Objects.requireNonNull(context, "context must not be null"); + Objects.requireNonNull(getter, "getter must not be null"); + + return propagator.extract( + context, + carrier, + getter + ); + } + + + public void injectContext( + T carrier, + TextMapSetter setter) { + + injectContext(Context.current(), carrier, setter); + } + + + public void injectContext( + Context context, + T carrier, + TextMapSetter setter) { + + Objects.requireNonNull(context, "context must not be null"); + Objects.requireNonNull(setter, "setter must not be null"); + + propagator.inject( + context, + carrier, + setter + ); + } + + private static TextMapPropagator createDefaultPropagator() { + return OpenTelemetryProvider.propagator(); + } + + public static TracingOpenTelemetry create() { return new TracingOpenTelemetry(); } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + + private Tracer tracer; + private TextMapPropagator propagator = createDefaultPropagator(); + + public Builder tracer(Tracer tracer) { + this.tracer = tracer; + return this; + } + + public Builder propagator(TextMapPropagator propagator) { + this.propagator = propagator; + return this; + } + + public TracingOpenTelemetry build() { + return new TracingOpenTelemetry(this); + } + } } \ No newline at end of file diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/AttributesConstants.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/AttributesConstants.java new file mode 100644 index 000000000..a9e980e1d --- /dev/null +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/AttributesConstants.java @@ -0,0 +1,42 @@ +package software.amazon.lambda.powertools.tracing.opentelemetry.internal; + +public final class AttributesConstants { + + private AttributesConstants() { + // Constant holder class + } + + public static final String AWS_LAMBDA_FUNCTION_NAME = + "AWS_LAMBDA_FUNCTION_NAME"; + + public static final String AWS_LAMBDA_FUNCTION_VERSION = + "AWS_LAMBDA_FUNCTION_VERSION"; + + public static final String AWS_LAMBDA_FUNCTION_MEMORY_SIZE = + "AWS_LAMBDA_FUNCTION_MEMORY_SIZE"; + + public static final String AWS_LAMBDA_LOG_STREAM_NAME = + "AWS_LAMBDA_LOG_STREAM_NAME"; + + public static final String AWS_REGION = + "AWS_REGION"; + + public static final String AWS_LAMBDA_FUNCTION_ARN = + "AWS_LAMBDA_FUNCTION_ARN"; + + public static final String TELEMETRY_DISTRO_NAME = + "powertools-for-aws-lambda"; + + public static final String FAAS_COLDSTART = "faas.coldstart"; + + public static final String FAAS_INVOCATION_ID = "faas.invocation_id"; + + public static final String RESPONSE_ATTRIBUTE = + "aws.lambda.powertools.response"; + + public static final String CAPTURE_RESPONSE_ENV = + "POWERTOOLS_TRACER_CAPTURE_RESPONSE"; + + public static final String CAPTURE_ERROR_ENV = + "POWERTOOLS_TRACER_CAPTURE_ERROR"; +} diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/LambdaResource.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/LambdaResource.java new file mode 100644 index 000000000..1186c85f4 --- /dev/null +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/LambdaResource.java @@ -0,0 +1,115 @@ +package software.amazon.lambda.powertools.tracing.opentelemetry.internal; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.common.AttributesBuilder; +import io.opentelemetry.sdk.resources.Resource; +import software.amazon.lambda.powertools.common.internal.SystemWrapper; + +public final class LambdaResource { + + private LambdaResource() { + } + + public static Resource create() { + AttributesBuilder attributes = Attributes.builder(); + + putIfPresent( + attributes, + "cloud.provider", + "aws" + ); + + putIfPresent( + attributes, + "cloud.region", + SystemWrapper.getenv(AttributesConstants.AWS_REGION) + ); + + putIfPresent( + attributes, + "service.name", + SystemWrapper.getenv(AttributesConstants.AWS_LAMBDA_FUNCTION_NAME) + ); + + putIfPresent( + attributes, + "service.version", + SystemWrapper.getenv(AttributesConstants.AWS_LAMBDA_FUNCTION_VERSION) + ); + + putIfPresent( + attributes, + "faas.name", + SystemWrapper.getenv(AttributesConstants.AWS_LAMBDA_FUNCTION_NAME) + ); + + putIfPresent( + attributes, + "faas.version", + SystemWrapper.getenv(AttributesConstants.AWS_LAMBDA_FUNCTION_VERSION) + ); + + putIfPresent( + attributes, + "faas.instance", + SystemWrapper.getenv(AttributesConstants.AWS_LAMBDA_LOG_STREAM_NAME) + ); + + String memory = SystemWrapper.getenv(AttributesConstants.AWS_LAMBDA_FUNCTION_MEMORY_SIZE); + + if (memory != null) { + attributes.put( + "faas.max_memory", + Long.parseLong(memory) + ); + } + + String functionArn = SystemWrapper.getenv(AttributesConstants.AWS_LAMBDA_FUNCTION_ARN); + + if (functionArn != null) { + String accountId = extractAccountId(functionArn); + + if (accountId != null) { + attributes.put( + "cloud.account.id", + accountId + ); + } + } + + attributes.put( + "telemetry.sdk.name", + "opentelemetry" + ); + + attributes.put( + "telemetry.distro.name", + AttributesConstants.TELEMETRY_DISTRO_NAME + ); + + attributes.put( + "telemetry.sdk.language", + "java" + ); + + return Resource.create(attributes.build()); + } + + private static void putIfPresent( + AttributesBuilder attributes, + String key, + String value) { + + if (value != null && !value.isBlank()) { + attributes.put(key, value); + } + } + + private static String extractAccountId(String arn) { + String[] parts = arn.split(":"); + + return parts.length > 4 + ? parts[4] + : null; + } +} \ No newline at end of file diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/OpenTelemetryProvider.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/OpenTelemetryProvider.java new file mode 100644 index 000000000..41674821a --- /dev/null +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/OpenTelemetryProvider.java @@ -0,0 +1,79 @@ +/* + * Copyright 2023 Amazon.com, Inc. or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + */ + +package software.amazon.lambda.powertools.tracing.opentelemetry.internal; + +import io.opentelemetry.api.trace.Tracer; +import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator; +import io.opentelemetry.context.propagation.TextMapPropagator; +import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter; +import io.opentelemetry.sdk.trace.SdkTracerProvider; +import io.opentelemetry.sdk.trace.export.BatchSpanProcessor; +import java.util.concurrent.TimeUnit; + +public final class OpenTelemetryProvider { + + private static final String INSTRUMENTATION_NAME = + "aws-lambda-powertools"; + + private static final int MAX_EXPORT_BATCH_SIZE = 10; + private static final int MAX_QUEUE_SIZE = 100; + private static final long SCHEDULE_DELAY_MILLIS = 1_000; + private static final long EXPORT_TIMEOUT_MILLIS = 3_000; + + private static final SdkTracerProvider TRACER_PROVIDER = + createTracerProvider(); + + private OpenTelemetryProvider() { + } + + public static Tracer tracer() { + return TRACER_PROVIDER.get(INSTRUMENTATION_NAME); + } + + public static SdkTracerProvider tracerProvider() { + return TRACER_PROVIDER; + } + + public static TextMapPropagator propagator() { + return createPropagator(); + } + + private static SdkTracerProvider createTracerProvider() { + + OtlpGrpcSpanExporter exporter = + OtlpGrpcSpanExporter.builder() + .setTimeout( + EXPORT_TIMEOUT_MILLIS, + TimeUnit.MILLISECONDS + ) + .build(); + + BatchSpanProcessor processor = + BatchSpanProcessor.builder(exporter) + .setMaxExportBatchSize(MAX_EXPORT_BATCH_SIZE) + .setMaxQueueSize(MAX_QUEUE_SIZE) + .setScheduleDelay( + SCHEDULE_DELAY_MILLIS, + TimeUnit.MILLISECONDS + ) + .setExporterTimeout( + EXPORT_TIMEOUT_MILLIS, + TimeUnit.MILLISECONDS + ) + .build(); + + return SdkTracerProvider.builder() + .setResource(LambdaResource.create()) + .addSpanProcessor(processor) + .build(); + } + + //TODO Pending adding AWS X-RAY propagation, the library opentelemetry-aws-xray-propagator is still in alpha + private static TextMapPropagator createPropagator() { + return W3CTraceContextPropagator.getInstance(); + } +} \ No newline at end of file diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanScope.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanScope.java index 2326fbbca..fe757d840 100644 --- a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanScope.java +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/SpanScope.java @@ -1,19 +1,6 @@ -/* - * Copyright 2023 Amazon.com, Inc. or its affiliates. - * Licensed under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * http://www.apache.org/licenses/LICENSE-2.0 - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - package software.amazon.lambda.powertools.tracing.opentelemetry.internal; +import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.trace.Span; import io.opentelemetry.api.trace.StatusCode; import io.opentelemetry.context.Scope; @@ -40,20 +27,25 @@ public SpanScope(Span span) { this.scope = span.makeCurrent(); } - /** - * Retrieves the {@link Span} associated with this {@link SpanScope}. - * - * @return the {@link Span} managed by this {@link SpanScope} - */ public Span span() { return span; } - /** - * Records an exception in the span and sets its status to {@code StatusCode.ERROR}. - * - * @param throwable the {@link Throwable} instance to be recorded as an event in the span. - */ + public SpanScope setStatus(StatusCode status) { + span.setStatus(status); + return this; + } + + public SpanScope addEvent(String name) { + span.addEvent(name); + return this; + } + + public SpanScope addEvent(String name, Attributes attributes) { + span.addEvent(name, attributes); + return this; + } + public void recordException(Throwable throwable) { span.recordException(throwable); span.setStatus(StatusCode.ERROR); @@ -64,4 +56,4 @@ public void close() { scope.close(); span.end(); } -} +} \ No newline at end of file diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspect.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspect.java index fee0d1bfd..dcd410dee 100644 --- a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspect.java +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspect.java @@ -1,95 +1,193 @@ +/* + * Copyright 2023 Amazon.com, Inc. or its affiliates. + * Licensed under the Apache License, Version 2.0 + */ + package software.amazon.lambda.powertools.tracing.opentelemetry.internal; import static software.amazon.lambda.powertools.common.internal.LambdaHandlerProcessor.coldStartDone; import static software.amazon.lambda.powertools.common.internal.LambdaHandlerProcessor.isColdStart; import static software.amazon.lambda.powertools.common.internal.LambdaHandlerProcessor.isHandlerMethod; -import static software.amazon.lambda.powertools.common.internal.LambdaHandlerProcessor.serviceName; import com.fasterxml.jackson.databind.ObjectMapper; +import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.SpanKind; +import io.opentelemetry.context.Context; +import java.util.Optional; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Pointcut; +import software.amazon.lambda.powertools.common.internal.LambdaHandlerProcessor; import software.amazon.lambda.powertools.common.internal.SystemWrapper; +import software.amazon.lambda.powertools.tracing.opentelemetry.Tracing; import software.amazon.lambda.powertools.tracing.opentelemetry.TracingOpenTelemetry; -import software.amazon.lambda.powertools.tracing.opentelemetry.TracingOtel; @Aspect public final class TracingOpenTelemetryAspect { - //tracing cannot be final for testing purposes - private static TracingOpenTelemetry tracing = - TracingOpenTelemetry.create(); - - private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper(); - private static final String COLD_START_ATTRIBUTE = - "aws.lambda.powertools.cold_start"; - private static final String SERVICE_ATTRIBUTE = - "aws.lambda.powertools.service"; + // Cannot be final for testing purposes + private static TracingOpenTelemetry tracingOtel = TracingOpenTelemetry.create(); - private static final String RESPONSE_ATTRIBUTE = - "aws.lambda.powertools.response"; + private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper(); - @SuppressWarnings({"EmptyMethod"}) - @Pointcut("@annotation(tracingOtel)") - public void callAt(TracingOtel tracingOtel) { + @SuppressWarnings("EmptyMethod") + @Pointcut("@annotation(tracing)") + public void callAt(Tracing tracing) { } @Around( - value = "callAt(tracingOtel) && execution(@TracingOtel * *.*(..))", - argNames = "pjp,tracingOtel" + value = "callAt(tracing) && execution(@Tracing * *.*(..))", + argNames = "pjp,tracing" ) - public Object around(ProceedingJoinPoint pjp, TracingOtel tracingOtel) throws Throwable { + public Object around( + ProceedingJoinPoint pjp, + Tracing tracing) throws Throwable { - String spanName = tracingOtel.spanName().isEmpty() + String spanName = tracing.spanName().isEmpty() ? pjp.getSignature().getName() - : tracingOtel.spanName(); + : tracing.spanName(); + + if (isHandlerMethod(pjp)) { + return traceHandler(pjp, tracing, spanName); + } - String namespace = tracingOtel.namespace().isEmpty() - ? serviceName() - : tracingOtel.namespace(); + return traceMethod(pjp, tracing, spanName); + } + + private Object traceHandler( + ProceedingJoinPoint pjp, + Tracing tracing, + String spanName) throws Throwable { + + Context parentContext = Context.current(); - try (SpanScope scope = tracing.addSpan(spanName)) { + try (SpanScope scope = tracingOtel.addSpan( + spanName, + SpanKind.SERVER, + handlerAttributes(), + parentContext)) { Span span = scope.span(); - if (isHandlerMethod(pjp)) { - span.setAttribute(COLD_START_ATTRIBUTE, isColdStart()); - span.setAttribute(SERVICE_ATTRIBUTE, namespace); - } + addLambdaInvocationAttributes(pjp, span); try { - Object result = pjp.proceed(pjp.getArgs()); - if (captureResponse(tracingOtel)) { - span.setAttribute(RESPONSE_ATTRIBUTE, OBJECT_MAPPER.writeValueAsString(result)); - } + captureResponse( + span, + tracing, + result + ); + + coldStartDone(); + + return result; + + } catch (Throwable throwable) { + + captureError( + scope, + tracing, + throwable + ); + + throw throwable; + } + } + } + + private Object traceMethod( + ProceedingJoinPoint pjp, + Tracing tracing, + String spanName) throws Throwable { + + try (SpanScope scope = tracingOtel.addSpan( + spanName, + SpanKind.INTERNAL, + Attributes.empty(), + Context.current())) { - if (isHandlerMethod(pjp)) { - coldStartDone(); - } + Span span = scope.span(); + + try { + Object result = pjp.proceed(pjp.getArgs()); + + captureResponse( + span, + tracing, + result + ); return result; } catch (Throwable throwable) { + captureError( + scope, + tracing, + throwable + ); - if (captureError(tracingOtel)) { - scope.recordException(throwable); - } throw throwable; } } } - private boolean captureResponse(TracingOtel tracing) { + private Attributes handlerAttributes() { + return Attributes.builder() + .put(AttributesConstants.FAAS_COLDSTART, isColdStart()) + .build(); + } + + private void addLambdaInvocationAttributes(ProceedingJoinPoint pjp, Span span) { + + Optional.ofNullable(LambdaHandlerProcessor.extractContext(pjp)) + .ifPresent(context -> + span.setAttribute( + AttributesConstants.FAAS_INVOCATION_ID, + context.getAwsRequestId() + ) + ); + } + + private void captureResponse( + Span span, + Tracing tracing, + Object response) throws Exception { + + if (!captureResponse(tracing)) { + return; + } + + span.setAttribute( + AttributesConstants.RESPONSE_ATTRIBUTE, + OBJECT_MAPPER.writeValueAsString(response) + ); + } + + private void captureError( + SpanScope scope, + Tracing tracing, + Throwable throwable) { + + if (captureError(tracing)) { + scope.recordException(throwable); + } + } + + private boolean captureResponse(Tracing tracing) { switch (tracing.captureMode()) { case ENVIRONMENT_VAR: - return isEnvironmentVariableSet("POWERTOOLS_TRACER_CAPTURE_RESPONSE") - && environmentVariable("POWERTOOLS_TRACER_CAPTURE_RESPONSE"); + return isEnvironmentVariableSet( + AttributesConstants.CAPTURE_RESPONSE_ENV) + && environmentVariable( + AttributesConstants.CAPTURE_RESPONSE_ENV); + case RESPONSE: case RESPONSE_AND_ERROR: return true; + case DISABLED: case ERROR: default: @@ -97,14 +195,18 @@ private boolean captureResponse(TracingOtel tracing) { } } - private boolean captureError(TracingOtel tracing) { + private boolean captureError(Tracing tracing) { switch (tracing.captureMode()) { case ENVIRONMENT_VAR: - return isEnvironmentVariableSet("POWERTOOLS_TRACER_CAPTURE_ERROR") - && environmentVariable("POWERTOOLS_TRACER_CAPTURE_ERROR"); + return isEnvironmentVariableSet( + AttributesConstants.CAPTURE_ERROR_ENV) + && environmentVariable( + AttributesConstants.CAPTURE_ERROR_ENV); + case ERROR: case RESPONSE_AND_ERROR: return true; + case DISABLED: case RESPONSE: default: @@ -113,11 +215,12 @@ private boolean captureError(TracingOtel tracing) { } private boolean environmentVariable(String key) { - return Boolean.parseBoolean(SystemWrapper.getenv(key)); + return Boolean.parseBoolean( + SystemWrapper.getenv(key) + ); } private boolean isEnvironmentVariableSet(String key) { return SystemWrapper.containsKey(key); } - -} +} \ No newline at end of file diff --git a/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetryTest.java b/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetryTest.java index cb64c11f3..8ca67d47a 100644 --- a/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetryTest.java +++ b/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetryTest.java @@ -18,15 +18,39 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.SpanKind; import io.opentelemetry.api.trace.Tracer; +import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator; +import io.opentelemetry.context.Context; +import io.opentelemetry.context.propagation.TextMapGetter; +import io.opentelemetry.context.propagation.TextMapPropagator; import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter; import io.opentelemetry.sdk.trace.SdkTracerProvider; +import io.opentelemetry.sdk.trace.data.SpanData; import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor; +import java.util.HashMap; +import java.util.List; +import java.util.Map; import org.junit.jupiter.api.Test; import software.amazon.lambda.powertools.tracing.opentelemetry.internal.SpanScope; class TracingOpenTelemetryTest { + public static final TextMapGetter> MAP_GETTER = new TextMapGetter<>() { + @Override + public Iterable keys(Map carrier) { + return carrier.keySet(); + } + + @Override + public String get( + Map carrier, + String key) { + return carrier.get(key); + } + }; + @Test void shouldCreateAndMakeSpanCurrent() { SdkTracerProvider tracerProvider = SdkTracerProvider.builder().build(); @@ -159,5 +183,144 @@ void shouldRecordExceptionWhenUsingWithSpan() { tracerProvider.close(); } + @Test + void shouldExtractContext() { + TextMapPropagator propagator = + W3CTraceContextPropagator.getInstance(); + + SdkTracerProvider tracerProvider = SdkTracerProvider.builder().build(); + + Tracer tracer = tracerProvider.get("test-tracer"); + + TracingOpenTelemetry tracing = + TracingOpenTelemetry.builder() + .tracer(tracer) + .propagator(propagator) + .build(); + + Map headers = new HashMap<>(); + headers.put( + "traceparent", + "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01" + ); + + Context context = tracing.extractContext( + headers, + MAP_GETTER + ); + + SpanContext spanContext = Span.fromContext(context).getSpanContext(); + + assertThat(spanContext.isValid()).isTrue(); + assertThat(spanContext.isRemote()).isTrue(); + + assertThat(spanContext.getTraceId()) + .isEqualTo("4bf92f3577b34da6a3ce929d0e0e4736"); + + assertThat(spanContext.getSpanId()) + .isEqualTo("00f067aa0ba902b7"); + + assertThat(spanContext.getTraceFlags().isSampled()) + .isTrue(); + } + + @Test + void shouldReturnInvalidContextWhenTraceparentIsMissing() { + TextMapPropagator propagator = + W3CTraceContextPropagator.getInstance(); + + SdkTracerProvider tracerProvider = + SdkTracerProvider.builder().build(); + + TracingOpenTelemetry tracing = + TracingOpenTelemetry.builder() + .tracer(tracerProvider.get("test-tracer")) + .propagator(propagator) + .build(); + + Map headers = new HashMap<>(); + + Context context = tracing.extractContext( + headers, + MAP_GETTER + ); + + assertThat(Span.fromContext(context).getSpanContext().isValid()) + .isFalse(); + } + + @Test + void shouldCreateServerSpanWithParentContext() throws Exception { + + String traceId = "4bf92f3577b34da6a3ce929d0e0e4736"; + String parentSpanId = "00f067aa0ba902b7"; + + Map headers = new HashMap<>(); + headers.put( + "traceparent", + "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01" + ); + + TextMapPropagator propagator = + W3CTraceContextPropagator.getInstance(); + + InMemorySpanExporter exporter = + InMemorySpanExporter.create(); + + SdkTracerProvider tracerProvider = + SdkTracerProvider.builder() + .addSpanProcessor( + SimpleSpanProcessor.create(exporter) + ) + .build(); + + Tracer tracer = tracerProvider.get("test-tracer"); + + TracingOpenTelemetry tracing = + TracingOpenTelemetry.builder() + .tracer(tracer) + .propagator(propagator) + .build(); + + Context parentContext = tracing.extractContext( + headers, + MAP_GETTER + ); + + + tracing.captureLambdaHandler( + "lambda-handler", + null, + parentContext, + span -> "result" + ); + + + List spans = exporter.getFinishedSpanItems(); + + assertThat(spans) + .hasSize(1); + + SpanData span = spans.get(0); + + assertThat(span.getName()) + .isEqualTo("lambda-handler"); + + assertThat(span.getKind()) + .isEqualTo(SpanKind.SERVER); + + assertThat(span.getSpanContext().isValid()) + .isTrue(); + + assertThat(span.getSpanContext().getTraceId()) + .isEqualTo(traceId); + + assertThat(span.getParentSpanId()) + .isEqualTo(parentSpanId); + + assertThat(span.getSpanId()) + .isNotEqualTo(parentSpanId); + } + } \ No newline at end of file diff --git a/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspectTest.java b/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspectTest.java index fc1da7408..5c149b631 100644 --- a/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspectTest.java +++ b/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspectTest.java @@ -16,13 +16,13 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import software.amazon.lambda.powertools.tracing.opentelemetry.CaptureMode; +import software.amazon.lambda.powertools.tracing.opentelemetry.Tracing; import software.amazon.lambda.powertools.tracing.opentelemetry.TracingOpenTelemetry; -import software.amazon.lambda.powertools.tracing.opentelemetry.TracingOtel; class TracingOpenTelemetryAspectTest { private ProceedingJoinPoint pjp; - private TracingOtel tracingOtel; + private Tracing tracing; private TracingOpenTelemetry tracingOpenTelemetry; private SpanScope spanScope; private Signature signature; @@ -31,7 +31,7 @@ class TracingOpenTelemetryAspectTest { @BeforeEach void setUp() throws IllegalAccessException { pjp = mock(ProceedingJoinPoint.class); - tracingOtel = mock(TracingOtel.class); + tracing = mock(Tracing.class); tracingOpenTelemetry = mock(TracingOpenTelemetry.class); spanScope = mock(SpanScope.class); signature = mock(Signature.class); @@ -56,13 +56,13 @@ void testAroundMethodSuccessfulExecution() throws Throwable { when(signature.getDeclaringType()).thenReturn(RequestHandler.class); Object[] args = new Object[0]; when(pjp.getArgs()).thenReturn(args); - when(tracingOtel.spanName()).thenReturn("testMethod"); - when(tracingOtel.namespace()).thenReturn("test"); - when(tracingOtel.captureMode()).thenReturn(CaptureMode.ENVIRONMENT_VAR); + when(tracing.spanName()).thenReturn("testMethod"); + when(tracing.namespace()).thenReturn("test"); + when(tracing.captureMode()).thenReturn(CaptureMode.ENVIRONMENT_VAR); when(pjp.proceed(any(Object[].class))).thenReturn("Success"); TracingOpenTelemetryAspect aspect = new TracingOpenTelemetryAspect(); - Object result = aspect.around(pjp, tracingOtel); + Object result = aspect.around(pjp, tracing); verify(tracingOpenTelemetry).addSpan("testMethod"); verify(pjp).proceed(any(Object[].class)); @@ -79,13 +79,13 @@ void testAroundMethodExceptionFlow() throws Throwable { when(signature.getDeclaringType()).thenReturn(RequestHandler.class); when(pjp.getArgs()).thenReturn(new Object[0]); Throwable mockThrowable = new RuntimeException("Test Exception"); - when(tracingOtel.spanName()).thenReturn("testMethod"); - when(tracingOtel.namespace()).thenReturn("test"); - when(tracingOtel.captureMode()).thenReturn(CaptureMode.ERROR); + when(tracing.spanName()).thenReturn("testMethod"); + when(tracing.namespace()).thenReturn("test"); + when(tracing.captureMode()).thenReturn(CaptureMode.ERROR); when(pjp.proceed(pjp.getArgs())).thenThrow(mockThrowable); TracingOpenTelemetryAspect aspect = new TracingOpenTelemetryAspect(); - RuntimeException exception = assertThrows(RuntimeException.class, () -> aspect.around(pjp, tracingOtel)); + RuntimeException exception = assertThrows(RuntimeException.class, () -> aspect.around(pjp, tracing)); verify(tracingOpenTelemetry).addSpan("testMethod"); verify(spanScope).recordException(mockThrowable); @@ -101,13 +101,13 @@ void testAddSpanIsCalledWithCorrectSignature() throws Throwable { when(pjp.getArgs()).thenReturn(args); when(signature.getDeclaringType()).thenReturn(RequestHandler.class); when(signature.getName()).thenReturn("correctMethodSignature"); - when(tracingOtel.spanName()).thenReturn("correctMethodSignature"); - when(tracingOtel.captureMode()).thenReturn(CaptureMode.ENVIRONMENT_VAR); - when(tracingOtel.namespace()).thenReturn("test"); + when(tracing.spanName()).thenReturn("correctMethodSignature"); + when(tracing.captureMode()).thenReturn(CaptureMode.ENVIRONMENT_VAR); + when(tracing.namespace()).thenReturn("test"); when(pjp.proceed()).thenReturn("Success"); TracingOpenTelemetryAspect aspect = new TracingOpenTelemetryAspect(); - aspect.around(pjp, tracingOtel); + aspect.around(pjp, tracing); verify(tracingOpenTelemetry).addSpan("correctMethodSignature"); } From c4241154e3e13e1413c0f8408b779f8d2667325a Mon Sep 17 00:00:00 2001 From: David-DAM <82216301+David-DAM@users.noreply.github.com> Date: Sun, 16 Aug 2026 17:53:09 +0200 Subject: [PATCH 5/5] Introduce Lambda event context extraction and enrichment for OpenTelemetry tracing --- powertools-tracing-opentelemetry/pom.xml | 4 + .../opentelemetry/TracingOpenTelemetry.java | 51 ++++++-- .../ApiGatewayTraceContextExtractor.java | 119 ++++++++++++++++++ .../context/LambdaEventContextExtractor.java | 14 +++ .../LambdaEventContextExtractorResolver.java | 44 +++++++ .../internal/TracingOpenTelemetryAspect.java | 29 +++-- .../OpenTelemetryProvider.java | 3 +- .../ApiGatewayTraceContextExtractorTest.java | 47 +++++++ 8 files changed, 288 insertions(+), 23 deletions(-) create mode 100644 powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/ApiGatewayTraceContextExtractor.java create mode 100644 powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/LambdaEventContextExtractor.java create mode 100644 powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/LambdaEventContextExtractorResolver.java rename powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/{internal => provider}/OpenTelemetryProvider.java (96%) create mode 100644 powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/ApiGatewayTraceContextExtractorTest.java diff --git a/powertools-tracing-opentelemetry/pom.xml b/powertools-tracing-opentelemetry/pom.xml index 304ee0d42..6fe91dbcc 100644 --- a/powertools-tracing-opentelemetry/pom.xml +++ b/powertools-tracing-opentelemetry/pom.xml @@ -69,6 +69,10 @@ com.amazonaws aws-lambda-java-core + + com.amazonaws + aws-lambda-java-events + com.fasterxml.jackson.core jackson-databind diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java index e96c525a5..2e41050c8 100644 --- a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/TracingOpenTelemetry.java @@ -26,15 +26,18 @@ import io.opentelemetry.context.propagation.TextMapSetter; import java.util.Objects; import software.amazon.lambda.powertools.common.internal.LambdaHandlerProcessor; -import software.amazon.lambda.powertools.tracing.opentelemetry.internal.OpenTelemetryProvider; +import software.amazon.lambda.powertools.tracing.opentelemetry.context.LambdaEventContextExtractorResolver; +import software.amazon.lambda.powertools.tracing.opentelemetry.internal.AttributesConstants; import software.amazon.lambda.powertools.tracing.opentelemetry.internal.SpanOperation; import software.amazon.lambda.powertools.tracing.opentelemetry.internal.SpanScope; +import software.amazon.lambda.powertools.tracing.opentelemetry.provider.OpenTelemetryProvider; public final class TracingOpenTelemetry { private final Tracer tracer; private final TextMapPropagator propagator; + private final LambdaEventContextExtractorResolver eventContextExtractorResolver; private TracingOpenTelemetry(Builder builder) { this.tracer = Objects.requireNonNull( @@ -45,6 +48,10 @@ private TracingOpenTelemetry(Builder builder) { builder.propagator, "propagator must not be null" ); + this.eventContextExtractorResolver = Objects.requireNonNull( + builder.eventContextExtractorResolver, + "eventContextExtractorResolver must not be null" + ); } public TracingOpenTelemetry() { @@ -53,13 +60,14 @@ public TracingOpenTelemetry() { public TracingOpenTelemetry(Tracer tracer) { - this(tracer, createDefaultPropagator()); + this(tracer, createDefaultPropagator(), createDefaultEventContextExtractorResolver()); } public TracingOpenTelemetry( Tracer tracer, - TextMapPropagator propagator) { + TextMapPropagator propagator, + LambdaEventContextExtractorResolver eventContextExtractorResolver) { this.tracer = Objects.requireNonNull( tracer, @@ -69,6 +77,22 @@ public TracingOpenTelemetry( propagator, "propagator must not be null" ); + this.eventContextExtractorResolver = Objects.requireNonNull( + eventContextExtractorResolver, + "eventContextExtractorResolver must not be null" + ); + } + + public TextMapPropagator propagator() { + return propagator; + } + + public LambdaEventContextExtractorResolver eventContextExtractorResolver() { + return eventContextExtractorResolver; + } + + public Span currentSpan() { + return Span.current(); } @@ -120,11 +144,6 @@ public SpanScope addSpan( } - public Span currentSpan() { - return Span.current(); - } - - public T withSpan( String name, SpanOperation operation) throws Exception { @@ -154,8 +173,8 @@ public T captureLambdaHandler( Span span = tracer.spanBuilder(name) .setParent(parentContext) .setSpanKind(SpanKind.SERVER) - .setAttribute("faas.coldstart", LambdaHandlerProcessor.isColdStart()) - .setAttribute("faas.invocation_id", lambdaContext.getAwsRequestId()) + .setAttribute(AttributesConstants.AWS_LAMBDA_FUNCTION_ARN, LambdaHandlerProcessor.isColdStart()) + .setAttribute(AttributesConstants.FAAS_INVOCATION_ID, lambdaContext.getAwsRequestId()) .startSpan(); try (SpanScope scope = new SpanScope(span)) { @@ -223,6 +242,10 @@ private static TextMapPropagator createDefaultPropagator() { return OpenTelemetryProvider.propagator(); } + private static LambdaEventContextExtractorResolver createDefaultEventContextExtractorResolver() { + return LambdaEventContextExtractorResolver.create(); + } + public static TracingOpenTelemetry create() { return new TracingOpenTelemetry(); @@ -237,6 +260,8 @@ public static final class Builder { private Tracer tracer; private TextMapPropagator propagator = createDefaultPropagator(); + private LambdaEventContextExtractorResolver eventContextExtractorResolver = + createDefaultEventContextExtractorResolver(); public Builder tracer(Tracer tracer) { this.tracer = tracer; @@ -248,6 +273,12 @@ public Builder propagator(TextMapPropagator propagator) { return this; } + public Builder eventContextExtractorResolver( + LambdaEventContextExtractorResolver eventContextExtractorResolver) { + this.eventContextExtractorResolver = eventContextExtractorResolver; + return this; + } + public TracingOpenTelemetry build() { return new TracingOpenTelemetry(this); } diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/ApiGatewayTraceContextExtractor.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/ApiGatewayTraceContextExtractor.java new file mode 100644 index 000000000..5a2381cf1 --- /dev/null +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/ApiGatewayTraceContextExtractor.java @@ -0,0 +1,119 @@ +package software.amazon.lambda.powertools.tracing.opentelemetry.context; + +import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent; +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.context.Context; +import io.opentelemetry.context.propagation.TextMapGetter; +import io.opentelemetry.context.propagation.TextMapPropagator; +import java.util.Collections; +import java.util.Map; +import java.util.stream.Collectors; + +public final class ApiGatewayTraceContextExtractor implements LambdaEventContextExtractor { + private static final TextMapGetter> HEADER_GETTER = + new TextMapGetter<>() { + + @Override + public Iterable keys(Map carrier) { + + return carrier != null + ? carrier.keySet() + : Collections.emptyList(); + } + + @Override + public String get(Map carrier, String key) { + + if (carrier == null) { + return null; + } + + return carrier.get(key); + } + }; + + + @Override + public boolean supports(Object event) { + return event instanceof APIGatewayProxyRequestEvent; + } + + @Override + public Context extract(Object event, Context parentContext, TextMapPropagator propagator) { + + APIGatewayProxyRequestEvent apiGatewayEvent = (APIGatewayProxyRequestEvent) event; + + Map headers = apiGatewayEvent.getHeaders(); + + if (headers == null || headers.isEmpty()) { + return parentContext; + } + + return propagator.extract( + parentContext, + headers, + HEADER_GETTER + ); + } + + @Override + public void enrichSpan(Object event, Span span) { + + APIGatewayProxyRequestEvent apiGatewayEvent = (APIGatewayProxyRequestEvent) event; + + if (apiGatewayEvent.getHttpMethod() != null) { + span.setAttribute("http.request.method", apiGatewayEvent.getHttpMethod()); + } + + if (apiGatewayEvent.getPath() != null) { + span.setAttribute("url.path", apiGatewayEvent.getPath()); + } + + if (apiGatewayEvent.getQueryStringParameters() != null) { + + String queryString = apiGatewayEvent.getQueryStringParameters() + .entrySet() + .stream() + .map(entry -> entry.getKey() + "=" + entry.getValue()) + .collect(Collectors.joining("&")); + + span.setAttribute("url.query", queryString); + } + + if (apiGatewayEvent.getHeaders() != null) { + + apiGatewayEvent.getHeaders() + .entrySet() + .stream() + .filter(entry -> "user-agent".equalsIgnoreCase(entry.getKey())) + .map(Map.Entry::getValue) + .findFirst() + .ifPresent(userAgent -> span.setAttribute("user_agent.original", userAgent)); + } + + if (apiGatewayEvent.getRequestContext() != null) { + + APIGatewayProxyRequestEvent.ProxyRequestContext requestContext = + apiGatewayEvent.getRequestContext(); + + if (requestContext.getRequestId() != null) { + span.setAttribute("aws.request_id", requestContext.getRequestId()); + } + + if (requestContext.getStage() != null) { + span.setAttribute("aws.apigateway.stage", requestContext.getStage()); + } + + if (requestContext.getResourceId() != null) { + span.setAttribute("aws.apigateway.resource_id", requestContext.getResourceId()); + } + + if (requestContext.getResourcePath() != null) { + span.setAttribute("aws.apigateway.resource_path", requestContext.getResourcePath()); + } + } + + } + + +} \ No newline at end of file diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/LambdaEventContextExtractor.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/LambdaEventContextExtractor.java new file mode 100644 index 000000000..90eae00ae --- /dev/null +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/LambdaEventContextExtractor.java @@ -0,0 +1,14 @@ +package software.amazon.lambda.powertools.tracing.opentelemetry.context; + +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.context.Context; +import io.opentelemetry.context.propagation.TextMapPropagator; + +public interface LambdaEventContextExtractor { + + boolean supports(Object event); + + Context extract(Object event, Context parentContext, TextMapPropagator propagator); + + void enrichSpan(Object event, Span span); +} \ No newline at end of file diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/LambdaEventContextExtractorResolver.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/LambdaEventContextExtractorResolver.java new file mode 100644 index 000000000..ac528a3a7 --- /dev/null +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/LambdaEventContextExtractorResolver.java @@ -0,0 +1,44 @@ +package software.amazon.lambda.powertools.tracing.opentelemetry.context; + +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.context.Context; +import io.opentelemetry.context.propagation.TextMapPropagator; +import java.util.List; + +public final class LambdaEventContextExtractorResolver { + + private final List extractors; + + public LambdaEventContextExtractorResolver(List extractors) { + + this.extractors = List.copyOf(extractors); + } + + public static LambdaEventContextExtractorResolver create() { + return new LambdaEventContextExtractorResolver( + List.of( + new ApiGatewayTraceContextExtractor() + ) + ); + } + + public Context extract(Object event, Context parentContext, TextMapPropagator propagator) { + + return extractors.stream() + .filter(extractor -> extractor.supports(event)) + .findFirst() + .map(extractor -> + extractor.extract( + event, + parentContext, + propagator)) + .orElse(parentContext); + } + + public void enrichSpan(Object event, Span span) { + extractors.stream() + .filter(extractor -> extractor.supports(event)) + .findFirst() + .ifPresent(extractor -> extractor.enrichSpan(event, span)); + } +} diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspect.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspect.java index dcd410dee..3d7e5d460 100644 --- a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspect.java +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/TracingOpenTelemetryAspect.java @@ -41,9 +41,7 @@ public void callAt(Tracing tracing) { value = "callAt(tracing) && execution(@Tracing * *.*(..))", argNames = "pjp,tracing" ) - public Object around( - ProceedingJoinPoint pjp, - Tracing tracing) throws Throwable { + public Object around(ProceedingJoinPoint pjp, Tracing tracing) throws Throwable { String spanName = tracing.spanName().isEmpty() ? pjp.getSignature().getName() @@ -56,12 +54,9 @@ public Object around( return traceMethod(pjp, tracing, spanName); } - private Object traceHandler( - ProceedingJoinPoint pjp, - Tracing tracing, - String spanName) throws Throwable { + private Object traceHandler(ProceedingJoinPoint pjp, Tracing tracing, String spanName) throws Throwable { - Context parentContext = Context.current(); + Context parentContext = extractParentContext(pjp); try (SpanScope scope = tracingOtel.addSpan( spanName, @@ -71,6 +66,10 @@ private Object traceHandler( Span span = scope.span(); + Object event = pjp.getArgs()[0]; + + tracingOtel.eventContextExtractorResolver().enrichSpan(event, span); + addLambdaInvocationAttributes(pjp, span); try { @@ -99,10 +98,7 @@ private Object traceHandler( } } - private Object traceMethod( - ProceedingJoinPoint pjp, - Tracing tracing, - String spanName) throws Throwable { + private Object traceMethod(ProceedingJoinPoint pjp, Tracing tracing, String spanName) throws Throwable { try (SpanScope scope = tracingOtel.addSpan( spanName, @@ -134,6 +130,15 @@ private Object traceMethod( } } + private Context extractParentContext(ProceedingJoinPoint pjp) { + + return tracingOtel.eventContextExtractorResolver().extract( + pjp.getArgs()[0], + Context.current(), + tracingOtel.propagator() + ); + } + private Attributes handlerAttributes() { return Attributes.builder() .put(AttributesConstants.FAAS_COLDSTART, isColdStart()) diff --git a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/OpenTelemetryProvider.java b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/provider/OpenTelemetryProvider.java similarity index 96% rename from powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/OpenTelemetryProvider.java rename to powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/provider/OpenTelemetryProvider.java index 41674821a..d2f54394a 100644 --- a/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/internal/OpenTelemetryProvider.java +++ b/powertools-tracing-opentelemetry/src/main/java/software/amazon/lambda/powertools/tracing/opentelemetry/provider/OpenTelemetryProvider.java @@ -4,7 +4,7 @@ * you may not use this file except in compliance with the License. */ -package software.amazon.lambda.powertools.tracing.opentelemetry.internal; +package software.amazon.lambda.powertools.tracing.opentelemetry.provider; import io.opentelemetry.api.trace.Tracer; import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator; @@ -13,6 +13,7 @@ import io.opentelemetry.sdk.trace.SdkTracerProvider; import io.opentelemetry.sdk.trace.export.BatchSpanProcessor; import java.util.concurrent.TimeUnit; +import software.amazon.lambda.powertools.tracing.opentelemetry.internal.LambdaResource; public final class OpenTelemetryProvider { diff --git a/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/ApiGatewayTraceContextExtractorTest.java b/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/ApiGatewayTraceContextExtractorTest.java new file mode 100644 index 000000000..695a7ef05 --- /dev/null +++ b/powertools-tracing-opentelemetry/src/test/java/software/amazon/lambda/powertools/tracing/opentelemetry/context/ApiGatewayTraceContextExtractorTest.java @@ -0,0 +1,47 @@ +package software.amazon.lambda.powertools.tracing.opentelemetry.context; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; + +import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent; +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator; +import io.opentelemetry.context.Context; +import java.util.Map; +import org.junit.jupiter.api.Test; + +class ApiGatewayTraceContextExtractorTest { + + @Test + void shouldExtractTraceContextFromApiGatewayEvent() { + + String traceId = "4bf92f3577b34da6a3ce929d0e0e4736"; + + String spanId = "00f067aa0ba902b7"; + + APIGatewayProxyRequestEvent event = new APIGatewayProxyRequestEvent() + .withHeaders(Map.of( + "traceparent", + "00-" + traceId + "-" + spanId + "-01" + )); + + ApiGatewayTraceContextExtractor apiGatewayTraceContextExtractor = new ApiGatewayTraceContextExtractor(); + + Context parentContext = apiGatewayTraceContextExtractor.extract( + event, + Context.current(), + W3CTraceContextPropagator.getInstance() + ); + + SpanContext spanContext = Span.fromContext(parentContext).getSpanContext(); + + assertThat(spanContext.isValid()).isTrue(); + assertThat(spanContext.isRemote()).isTrue(); + + assertThat(spanContext.getTraceId()).isEqualTo(traceId); + + assertThat(spanContext.getSpanId()).isEqualTo(spanId); + } + + +} \ No newline at end of file