Merge branch 'main' into main

Author: patpatpat123

.github/workflows/overhead-benchmark-daily.yml

@@ -42,17 +42,15 @@ jobs:
       - name: Copy results back to gh-pages branch
         run: rsync -avv benchmark-overhead/results/ gh-pages/benchmark-overhead/results/ && rm -rf benchmark-overhead/results
 
+      - name: Use CLA approved bot
+        run: .github/scripts/use-cla-approved-bot.sh
+
       - name: Commit updated results
-        uses: EndBug/add-and-commit@a94899bca583c204427a224a7af87c02f9b325d5 # v9.1.4
-        with:
-          add: "benchmark-overhead/results"
-          cwd: "./gh-pages"
-          branch: "gh-pages"
-          message: "update test result data"
-          author_name: otelbot
-          author_email: [email protected]
-          committer_name: otelbot
-          committer_email: [email protected]
+        working-directory: ./gh-pages
+        run: |
+          git add benchmark-overhead/results
+          git commit -m "update test result data"
+          git push
 
   workflow-notification:
     permissions:

CONTRIBUTING.md

@@ -15,10 +15,28 @@ See [Running the tests](./docs/contributing/running-tests.md) for more details.
 
 ### Snapshot builds
 
-For developers testing code changes before a release is complete, there are
-snapshot builds of the `main` branch. They are available from
-the Sonatype snapshot repository at `https://central.sonatype.com/repository/maven-snapshots/`
-([browse](https://central.sonatype.com/service/rest/repository/browse/maven-snapshots/io/opentelemetry/)).
+For developers testing code changes before a release is complete, snapshot builds of the `main`
+branch are available from the Sonatype snapshot repository at `https://central.sonatype.com/repository/maven-snapshots/`.
+
+To find the latest snapshot, check the maven metadata (replace `{LATEST_VERSION}` with the current
+stable release):
+
+```
+https://central.sonatype.com/repository/maven-snapshots/io/opentelemetry/javaagent/opentelemetry-javaagent/{LATEST_VERSION}-SNAPSHOT/maven-metadata.xml
+```
+
+Look for the `<timestamp>` and `<buildNumber>` in the XML response, then construct the download URL:
+
+```
+https://central.sonatype.com/repository/maven-snapshots/io/opentelemetry/javaagent/opentelemetry-javaagent/{VERSION}-SNAPSHOT/opentelemetry-javaagent-{VERSION}-{TIMESTAMP}-{BUILD_NUMBER}.jar
+```
+
+For example, if the metadata shows timestamp `20250925.160708` and build number `56` for version
+`2.21.0`, the snapshot JAR URL would be:
+
+```
+https://central.sonatype.com/repository/maven-snapshots/io/opentelemetry/javaagent/opentelemetry-javaagent/2.21.0-SNAPSHOT/opentelemetry-javaagent-2.21.0-20250925.160708-56.jar
+```
 
 ### Building from source
 

docs/instrumentation-list.yaml

@@ -390,6 +390,33 @@ libraries:
       default: ''
     telemetry:
     - when: default
+      metrics:
+      - name: rpc.client.duration
+        description: The duration of an outbound RPC invocation.
+        type: HISTOGRAM
+        unit: ms
+        attributes:
+        - name: rpc.method
+          type: STRING
+        - name: rpc.service
+          type: STRING
+        - name: rpc.system
+          type: STRING
+        - name: server.address
+          type: STRING
+        - name: server.port
+          type: LONG
+      - name: rpc.server.duration
+        description: The duration of an inbound RPC invocation.
+        type: HISTOGRAM
+        unit: ms
+        attributes:
+        - name: rpc.method
+          type: STRING
+        - name: rpc.service
+          type: STRING
+        - name: rpc.system
+          type: STRING
       spans:
       - span_kind: CLIENT
         attributes:
@@ -6399,13 +6426,6 @@ libraries:
     scope:
       name: io.opentelemetry.runtime-telemetry-java8
   rxjava:
-  - name: rxjava-1.0
-    source_path: instrumentation/rxjava/rxjava-1.0
-    scope:
-      name: io.opentelemetry.rxjava-1.0
-    target_versions:
-      library:
-      - io.reactivex:rxjava:1.0.7
   - name: rxjava-2.0
     source_path: instrumentation/rxjava/rxjava-2.0
     scope:
@@ -7977,6 +7997,13 @@ internal:
   source_path: instrumentation/internal/internal-lambda
   scope:
     name: io.opentelemetry.internal-lambda
+- name: rxjava-1.0
+  source_path: instrumentation/rxjava/rxjava-1.0
+  scope:
+    name: io.opentelemetry.rxjava-1.0
+  target_versions:
+    library:
+    - io.reactivex:rxjava:1.0.7
 - name: internal-eclipse-osgi-3.6
   source_path: instrumentation/internal/internal-eclipse-osgi-3.6
   scope:

instrumentation/java-http-client/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/javahttpclient/HttpClientInstrumentation.java

@@ -156,7 +156,7 @@ public static AsyncAdviceScope start(HttpRequest request) {
       }
 
       public CompletableFuture<HttpResponse<?>> end(
-          @Nullable Throwable throwable, @Nullable CompletableFuture<HttpResponse<?>> future) {
+          @Nullable Throwable throwable, CompletableFuture<HttpResponse<?>> future) {
         if (callDepth.decrementAndGet() > 0 || scope == null) {
           // async end nested call
           return future;
@@ -167,8 +167,8 @@ public CompletableFuture<HttpResponse<?>> end(
           instrumenter().end(context, request, null, throwable);
           return future;
         }
-        future = future.whenComplete(new ResponseConsumer(instrumenter(), context, request));
-        return CompletableFutureWrapper.wrap(future, parentContext);
+        return CompletableFutureWrapper.wrap(future, parentContext)
+            .whenComplete(new ResponseConsumer(instrumenter(), context, request));
       }
     }
 
@@ -182,7 +182,7 @@ public static AsyncAdviceScope methodEnter(
     @AssignReturned.ToReturned
     @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class)
     public static CompletableFuture<HttpResponse<?>> methodExit(
-        @Advice.Return @Nullable CompletableFuture<HttpResponse<?>> future,
+        @Advice.Return CompletableFuture<HttpResponse<?>> future,
         @Advice.Thrown @Nullable Throwable throwable,
         @Advice.Enter @Nullable AsyncAdviceScope scope) {
       return scope == null ? future : scope.end(throwable, future);

instrumentation/java-http-client/library/src/main/java/io/opentelemetry/instrumentation/javahttpclient/internal/CompletableFutureWrapper.java

@@ -13,12 +13,15 @@
  * This class is internal and is hence not for public use. Its APIs are unstable and can change at
  * any time.
  */
-public final class CompletableFutureWrapper {
+public final class CompletableFutureWrapper<T> extends CompletableFuture<T> {
+  private final CompletableFuture<?> future;
 
-  private CompletableFutureWrapper() {}
+  private CompletableFutureWrapper(CompletableFuture<?> future) {
+    this.future = future;
+  }
 
   public static <T> CompletableFuture<T> wrap(CompletableFuture<T> future, Context context) {
-    CompletableFuture<T> result = new CompletableFuture<>();
+    CompletableFuture<T> result = new CompletableFutureWrapper<>(future);
     future.whenComplete(
         (T value, Throwable throwable) -> {
           try (Scope ignored = context.makeCurrent()) {
@@ -32,4 +35,16 @@ public static <T> CompletableFuture<T> wrap(CompletableFuture<T> future, Context
 
     return result;
   }
+
+  @Override
+  public <U> CompletableFuture<U> newIncompleteFuture() {
+    return new CompletableFutureWrapper<>(future);
+  }
+
+  @Override
+  public boolean cancel(boolean mayInterruptIfRunning) {
+    boolean result = super.cancel(mayInterruptIfRunning);
+    future.cancel(mayInterruptIfRunning);
+    return result;
+  }
 }

instrumentation/java-http-client/library/src/main/java/io/opentelemetry/instrumentation/javahttpclient/internal/OpenTelemetryHttpClient.java

@@ -142,8 +142,9 @@ private <T> CompletableFuture<HttpResponse<T>> traceAsync(
       instrumenter.end(context, request, null, t);
       throw t;
     }
-    future = future.whenComplete(new ResponseConsumer(instrumenter, context, request));
-    future = CompletableFutureWrapper.wrap(future, parentContext);
+    future =
+        CompletableFutureWrapper.wrap(future, parentContext)
+            .whenComplete(new ResponseConsumer(instrumenter, context, request));
     return future;
   }
 }

instrumentation/java-http-client/testing/src/main/java/io/opentelemetry/instrumentation/javahttpclient/AbstractJavaHttpClientTest.java

@@ -5,12 +5,22 @@
 
 package io.opentelemetry.instrumentation.javahttpclient;
 
+import static io.opentelemetry.api.common.AttributeKey.stringKey;
+import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
 import static io.opentelemetry.semconv.NetworkAttributes.NETWORK_PROTOCOL_VERSION;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.SpanKind;
 import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpClientTest;
 import io.opentelemetry.instrumentation.testing.junit.http.HttpClientResult;
 import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions;
+import io.opentelemetry.sdk.trace.data.StatusData;
+import io.opentelemetry.semconv.ErrorAttributes;
+import io.opentelemetry.semconv.HttpAttributes;
+import io.opentelemetry.semconv.ServerAttributes;
+import io.opentelemetry.semconv.UrlAttributes;
 import java.io.IOException;
 import java.net.URI;
 import java.net.http.HttpClient;
@@ -19,7 +29,11 @@
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
 import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 public abstract class AbstractJavaHttpClientTest extends AbstractHttpClientTest<HttpRequest> {
 
@@ -106,4 +120,76 @@ protected void configure(HttpClientTestOptions.Builder optionsBuilder) {
           return attributes;
         });
   }
+
+  @SuppressWarnings("Interruption") // test calls CompletableFuture.cancel with true
+  @Test
+  void cancelRequest() throws InterruptedException {
+    boolean isJdk11 = "11".equals(System.getProperty("java.specification.version"));
+    String method = "GET";
+    URI uri = resolveAddress("/long-request");
+
+    CompletableFuture<String> future =
+        testing.runWithSpan(
+            "parent",
+            () -> {
+              HttpRequest request =
+                  HttpRequest.newBuilder()
+                      .uri(uri)
+                      .method(method, HttpRequest.BodyPublishers.noBody())
+                      .header("delay", String.valueOf(TimeUnit.SECONDS.toMillis(5)))
+                      .build();
+              return client
+                  .sendAsync(request, HttpResponse.BodyHandlers.ofString())
+                  .thenApply(HttpResponse::body)
+                  .whenComplete(
+                      (response, throwable) ->
+                          testing.runWithSpan(
+                              "child",
+                              () -> {
+                                if (throwable != null && throwable.getCause() != null) {
+                                  Span.current()
+                                      .setAttribute(
+                                          "throwable", throwable.getCause().getClass().getName());
+                                }
+                              }))
+                  // this stage is only added to trigger the whenComplete stage when this stage gets
+                  // cancelled
+                  .exceptionally(ex -> "cancelled");
+            });
+
+    // sleep a bit to let the request start
+    Thread.sleep(1_000);
+    future.cancel(true);
+    assertThatThrownBy(future::get).isInstanceOf(CancellationException.class);
+
+    testing.waitAndAssertTraces(
+        trace ->
+            trace.hasSpansSatisfyingExactly(
+                span -> span.hasName("parent").hasNoParent(),
+                span ->
+                    span.hasName("GET")
+                        .hasKind(SpanKind.CLIENT)
+                        .hasParent(trace.getSpan(0))
+                        .hasStatus(StatusData.error())
+                        .hasAttributesSatisfyingExactly(
+                            equalTo(UrlAttributes.URL_FULL, uri.toString()),
+                            equalTo(ServerAttributes.SERVER_ADDRESS, uri.getHost()),
+                            equalTo(ServerAttributes.SERVER_PORT, uri.getPort()),
+                            equalTo(HttpAttributes.HTTP_REQUEST_METHOD, method),
+                            equalTo(
+                                ErrorAttributes.ERROR_TYPE, CancellationException.class.getName())),
+                span ->
+                    span.hasName("test-http-server")
+                        .hasKind(SpanKind.SERVER)
+                        .hasParent(trace.getSpan(1))
+                        // jdk 11 does not cancel the request on the server side so the request
+                        // succeeds
+                        .hasStatus(isJdk11 ? StatusData.unset() : StatusData.error()),
+                span ->
+                    span.hasName("child")
+                        .hasParent(trace.getSpan(0))
+                        .hasAttributesSatisfyingExactly(
+                            equalTo(
+                                stringKey("throwable"), CancellationException.class.getName()))));
+  }
 }

instrumentation/jdbc/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jdbc/ConnectionInstrumentation.java

@@ -62,6 +62,10 @@ public static class PrepareAdvice {
     @Advice.OnMethodExit(suppress = Throwable.class)
     public static void addDbInfo(
         @Advice.Argument(0) String sql, @Advice.Return PreparedStatement statement) {
+      if (JdbcSingletons.isWrapper(statement, PreparedStatement.class)) {
+        return;
+      }
+
       JdbcData.preparedStatement.set(statement, sql);
     }
   }
@@ -105,6 +109,10 @@ public void end(@Nullable Throwable throwable) {
     @Advice.OnMethodEnter(suppress = Throwable.class)
     public static AdviceScope onEnter(
         @Advice.This Connection connection, @Advice.Origin("#m") String methodName) {
+      if (JdbcSingletons.isWrapper(connection, Connection.class)) {
+        return null;
+      }
+
       return AdviceScope.start(connection, methodName);
     }
 

instrumentation/jdbc/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jdbc/JdbcSingletons.java

@@ -11,12 +11,15 @@
 import io.opentelemetry.instrumentation.api.incubator.semconv.net.PeerServiceAttributesExtractor;
 import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor;
 import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter;
+import io.opentelemetry.instrumentation.api.internal.cache.Cache;
 import io.opentelemetry.instrumentation.jdbc.internal.DbRequest;
 import io.opentelemetry.instrumentation.jdbc.internal.JdbcInstrumenterFactory;
 import io.opentelemetry.instrumentation.jdbc.internal.JdbcNetworkAttributesGetter;
 import io.opentelemetry.javaagent.bootstrap.internal.AgentCommonConfig;
 import io.opentelemetry.javaagent.bootstrap.internal.AgentInstrumentationConfig;
 import io.opentelemetry.javaagent.bootstrap.jdbc.DbInfo;
+import java.sql.SQLException;
+import java.sql.Wrapper;
 import java.util.Collections;
 import javax.sql.DataSource;
 
@@ -68,5 +71,31 @@ public static Instrumenter<DataSource, DbInfo> dataSourceInstrumenter() {
     return DATASOURCE_INSTRUMENTER;
   }
 
+  private static final Cache<Class<?>, Boolean> wrapperClassCache = Cache.weak();
+
+  /**
+   * Returns true if the given object is a wrapper and shouldn't be instrumented. We'll instrument
+   * the underlying object called by the wrapper instead.
+   */
+  public static <T extends Wrapper> boolean isWrapper(T object, Class<T> clazz) {
+    return wrapperClassCache.computeIfAbsent(
+        object.getClass(), key -> isWrapperInternal(object, clazz));
+  }
+
+  private static <T extends Wrapper> boolean isWrapperInternal(T object, Class<T> clazz) {
+    try {
+      // we are dealing with a wrapper when the object unwraps to a different instance
+      if (object.isWrapperFor(clazz)) {
+        T unwrapped = object.unwrap(clazz);
+        if (object != unwrapped) {
+          return true;
+        }
+      }
+    } catch (SQLException | AbstractMethodError e) {
+      // ignore
+    }
+    return false;
+  }
+
   private JdbcSingletons() {}
 }