Merge branch 'main' into issue-10856

Author: laurit

instrumentation/jdbc/javaagent/build.gradle.kts

@@ -31,6 +31,7 @@ dependencies {
   testLibrary("org.apache.tomcat:tomcat-juli:7.0.19")
   testLibrary("com.zaxxer:HikariCP:2.4.0")
   testLibrary("com.mchange:c3p0:0.9.5")
+  testLibrary("com.alibaba:druid:1.2.20")
 
   // some classes in earlier versions of derby were split out into derbytools in later versions
   latestDepTestLibrary("org.apache.derby:derbytools:latest.release")

instrumentation/jdbc/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jdbc/datasource/DataSourceInstrumentation.java

@@ -13,6 +13,7 @@
 import io.opentelemetry.context.Context;
 import io.opentelemetry.context.Scope;
 import io.opentelemetry.instrumentation.jdbc.internal.JdbcUtils;
+import io.opentelemetry.javaagent.bootstrap.CallDepth;
 import io.opentelemetry.javaagent.bootstrap.Java8BytecodeBridge;
 import io.opentelemetry.javaagent.bootstrap.jdbc.DbInfo;
 import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
@@ -33,7 +34,7 @@ public ElementMatcher<TypeDescription> typeMatcher() {
   @Override
   public void transform(TypeTransformer transformer) {
     transformer.applyAdviceToMethod(
-        named("getConnection").and(returns(named("java.sql.Connection"))),
+        named("getConnection").and(returns(implementsInterface(named("java.sql.Connection")))),
         DataSourceInstrumentation.class.getName() + "$GetConnectionAdvice");
   }
 
@@ -44,7 +45,13 @@ public static class GetConnectionAdvice {
     public static void start(
         @Advice.This DataSource ds,
         @Advice.Local("otelContext") Context context,
-        @Advice.Local("otelScope") Scope scope) {
+        @Advice.Local("otelScope") Scope scope,
+        @Advice.Local("otelCallDepth") CallDepth callDepth) {
+      callDepth = CallDepth.forClass(DataSource.class);
+      if (callDepth.getAndIncrement() > 0) {
+        return;
+      }
+
       Context parentContext = Java8BytecodeBridge.currentContext();
       if (!Java8BytecodeBridge.spanFromContext(parentContext).getSpanContext().isValid()) {
         // this instrumentation is already very noisy, and calls to getConnection outside of an
@@ -64,7 +71,12 @@ public static void stopSpan(
         @Advice.Return Connection connection,
         @Advice.Thrown Throwable throwable,
         @Advice.Local("otelContext") Context context,
-        @Advice.Local("otelScope") Scope scope) {
+        @Advice.Local("otelScope") Scope scope,
+        @Advice.Local("otelCallDepth") CallDepth callDepth) {
+      if (callDepth.decrementAndGet() > 0) {
+        return;
+      }
+
       if (scope == null) {
         return;
       }

instrumentation/jdbc/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/jdbc/test/DruicDataSourceTest.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.jdbc.test;
+
+import static io.opentelemetry.api.trace.SpanKind.INTERNAL;
+import static io.opentelemetry.instrumentation.api.internal.SemconvStability.emitStableDatabaseSemconv;
+import static io.opentelemetry.instrumentation.testing.junit.db.SemconvStabilityUtil.maybeStable;
+import static io.opentelemetry.instrumentation.testing.junit.db.SemconvStabilityUtil.maybeStableDbSystemName;
+import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
+import static io.opentelemetry.semconv.incubating.CodeIncubatingAttributes.CODE_FUNCTION;
+import static io.opentelemetry.semconv.incubating.CodeIncubatingAttributes.CODE_NAMESPACE;
+import static io.opentelemetry.semconv.incubating.DbIncubatingAttributes.DB_CONNECTION_STRING;
+import static io.opentelemetry.semconv.incubating.DbIncubatingAttributes.DB_NAME;
+import static io.opentelemetry.semconv.incubating.DbIncubatingAttributes.DB_SYSTEM;
+import static io.opentelemetry.semconv.incubating.DbIncubatingAttributes.DB_USER;
+
+import com.alibaba.druid.pool.DruidDataSource;
+import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
+import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
+import java.sql.Connection;
+import java.sql.SQLException;
+import javax.sql.DataSource;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+@SuppressWarnings("deprecation") // using deprecated semconv
+class DruicDataSourceTest {
+
+  @RegisterExtension
+  static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
+
+  private DataSource dataSource;
+
+  @BeforeEach
+  void setUp() {
+    DruidDataSource druidDataSource = new DruidDataSource();
+    druidDataSource.setUrl("jdbc:h2:mem:test");
+    druidDataSource.setDriverClassName("org.h2.Driver");
+    druidDataSource.setUsername("sa");
+    druidDataSource.setPassword("");
+    druidDataSource.setMaxActive(1);
+    this.dataSource = druidDataSource;
+  }
+
+  @AfterEach
+  void tearDown() {
+    if (dataSource instanceof DruidDataSource) {
+      ((DruidDataSource) dataSource).close();
+    }
+  }
+
+  @Test
+  void testGetConnection() throws SQLException {
+    // In DruidDataSource we instrument both DruidPooledConnection getConnection() and the bridge
+    // method Connection getConnection(). Here we call Connection getConnection() that delegates
+    // to DruidPooledConnection getConnection(), and verify that only one span is created.
+    testing.runWithSpan(
+        "parent",
+        () -> {
+          try (Connection connection = dataSource.getConnection()) {
+            return null;
+          }
+        });
+
+    testing.waitAndAssertTraces(
+        trace ->
+            trace.hasSpansSatisfyingExactly(
+                span -> span.hasName("parent").hasKind(INTERNAL).hasNoParent(),
+                span ->
+                    span.hasName("DruidDataSource.getConnection")
+                        .hasKind(INTERNAL)
+                        .hasParent(trace.getSpan(0))
+                        .hasAttributesSatisfyingExactly(
+                            equalTo(CODE_NAMESPACE, "com.alibaba.druid.pool.DruidDataSource"),
+                            equalTo(CODE_FUNCTION, "getConnection"),
+                            equalTo(
+                                DB_CONNECTION_STRING,
+                                emitStableDatabaseSemconv() ? null : "h2:mem:"),
+                            equalTo(maybeStable(DB_NAME), "test"),
+                            equalTo(maybeStable(DB_SYSTEM), maybeStableDbSystemName("h2")),
+                            equalTo(DB_USER, emitStableDatabaseSemconv() ? null : "sa"))));
+  }
+}

instrumentation/jdbc/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/jdbc/test/JdbcInstrumentationTest.java

@@ -1041,7 +1041,6 @@ void testGetConnection(
       throws SQLException {
     // Tomcat's pool doesn't work because the getConnection method is
     // implemented in a parent class that doesn't implement DataSource
-    boolean recursive = datasource instanceof EmbeddedDataSource;
 
     if (init != null) {
       init.accept(datasource);
@@ -1073,14 +1072,6 @@ void testGetConnection(
                               .hasKind(SpanKind.INTERNAL)
                               .hasParent(trace.getSpan(0))
                               .hasAttributesSatisfyingExactly(attributesAssertions)));
-          if (recursive) {
-            assertions.add(
-                span ->
-                    span.hasName(datasource.getClass().getSimpleName() + ".getConnection")
-                        .hasKind(SpanKind.INTERNAL)
-                        .hasParent(trace.getSpan(1))
-                        .hasAttributesSatisfyingExactly(attributesAssertions));
-          }
           trace.hasSpansSatisfyingExactly(assertions);
         });
   }

instrumentation/jmx-metrics/library/README.md

@@ -0,0 +1,47 @@
+# Library Instrumentation for JMX Metrics
+
+Provides OpenTelemetry instrumentation for [Java Management Extensions (JMX)](https://docs.oracle.com/javase/tutorial/jmx/).
+
+This instrumentation collects JMX-based metrics and exports them as OpenTelemetry metrics.
+
+## Quickstart
+
+### Add these dependencies to your project
+
+Replace `OPENTELEMETRY_VERSION` with the [latest release](https://central.sonatype.com/artifact/io.opentelemetry.instrumentation/opentelemetry-jmx-metrics).
+
+For Maven, add to your `pom.xml` dependencies:
+
+```xml
+<dependencies>
+  <dependency>
+    <groupId>io.opentelemetry.instrumentation</groupId>
+    <artifactId>opentelemetry-jmx-metrics</artifactId>
+    <version>OPENTELEMETRY_VERSION</version>
+  </dependency>
+</dependencies>
+```
+
+For Gradle, add to your dependencies:
+
+```kotlin
+implementation("io.opentelemetry.instrumentation:opentelemetry-jmx-metrics:OPENTELEMETRY_VERSION")
+```
+
+### Usage
+
+```java
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.jmx.engine.JmxMetricInsight;
+import io.opentelemetry.instrumentation.jmx.engine.MetricConfiguration;
+
+// Get an OpenTelemetry instance
+OpenTelemetry openTelemetry = ...;
+
+JmxMetricInsight jmxMetricInsight = JmxMetricInsight.createService(openTelemetry, 5000);
+
+// Configure your JMX metrics
+MetricConfiguration config = new MetricConfiguration();
+
+jmxMetricInsight.startLocal(config);
+```

instrumentation/lettuce/lettuce-5.1/library/README.md

@@ -0,0 +1,50 @@
+# Library Instrumentation for Lettuce version 5.1 and higher
+
+Provides OpenTelemetry instrumentation for [Lettuce](https://lettuce.io/), enabling database client
+spans and metrics.
+
+## Quickstart
+
+### Add these dependencies to your project
+
+Replace `OPENTELEMETRY_VERSION` with the [latest release](https://central.sonatype.com/artifact/io.opentelemetry.instrumentation/opentelemetry-lettuce-5.1).
+
+For Maven, add to your `pom.xml` dependencies:
+
+```xml
+<dependencies>
+  <dependency>
+    <groupId>io.opentelemetry.instrumentation</groupId>
+    <artifactId>opentelemetry-lettuce-5.1</artifactId>
+    <version>OPENTELEMETRY_VERSION</version>
+  </dependency>
+</dependencies>
+```
+
+For Gradle, add to your dependencies:
+
+```kotlin
+implementation("io.opentelemetry.instrumentation:opentelemetry-lettuce-5.1:OPENTELEMETRY_VERSION")
+```
+
+### Usage
+
+```java
+import io.lettuce.core.RedisClient;
+import io.lettuce.core.api.StatefulRedisConnection;
+import io.lettuce.core.resource.ClientResources;
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.lettuce.v5_1.LettuceTelemetry;
+
+// Get an OpenTelemetry instance
+OpenTelemetry openTelemetry = ...;
+
+LettuceTelemetry lettuceTelemetry = LettuceTelemetry.create(openTelemetry);
+
+ClientResources clientResources = ClientResources.builder()
+    .tracing(lettuceTelemetry.newTracing())
+    .build();
+
+RedisClient redisClient = RedisClient.create(clientResources, "redis://localhost:6379");
+StatefulRedisConnection<String, String> connection = redisClient.connect();
+```

instrumentation/netty/netty-4.1/library/README.md

@@ -0,0 +1,105 @@
+# Library Instrumentation for Netty version 4.1 and higher
+
+Provides OpenTelemetry instrumentation for [Netty](https://netty.io/), enabling HTTP client and
+server spans and metrics.
+
+## Quickstart
+
+### Add these dependencies to your project
+
+Replace `OPENTELEMETRY_VERSION` with the [latest release](https://central.sonatype.com/artifact/io.opentelemetry.instrumentation/opentelemetry-netty-4.1).
+
+For Maven, add to your `pom.xml` dependencies:
+
+```xml
+<dependencies>
+  <dependency>
+    <groupId>io.opentelemetry.instrumentation</groupId>
+    <artifactId>opentelemetry-netty-4.1</artifactId>
+    <version>OPENTELEMETRY_VERSION</version>
+  </dependency>
+</dependencies>
+```
+
+For Gradle, add to your dependencies:
+
+```kotlin
+implementation("io.opentelemetry.instrumentation:opentelemetry-netty-4.1:OPENTELEMETRY_VERSION")
+```
+
+### Usage
+
+#### HTTP Client
+
+```java
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.handler.codec.http.HttpClientCodec;
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.instrumentation.netty.v4_1.NettyClientTelemetry;
+
+// Get an OpenTelemetry instance
+OpenTelemetry openTelemetry = ...;
+
+NettyClientTelemetry clientTelemetry = NettyClientTelemetry.create(openTelemetry);
+
+EventLoopGroup eventLoopGroup = ...; // Use appropriate EventLoopGroup for your platform
+Class<? extends Channel> channelClass = ...; // Use appropriate Channel class for your platform
+
+Bootstrap bootstrap = new Bootstrap();
+bootstrap.group(eventLoopGroup)
+    .channel(channelClass)
+    .handler(new ChannelInitializer<SocketChannel>() {
+        @Override
+        protected void initChannel(SocketChannel ch) {
+            ch.pipeline()
+                .addLast(new HttpClientCodec())
+                .addLast(clientTelemetry.createCombinedHandler())
+                .addLast(new YourClientHandler()); // Your application handler
+        }
+    });
+
+Channel channel = bootstrap.connect("localhost", 8080).sync().channel();
+NettyClientTelemetry.setChannelContext(channel, Context.current());
+```
+
+#### HTTP Server
+
+```java
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.ServerChannel;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.handler.codec.http.HttpServerCodec;
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.netty.v4_1.NettyServerTelemetry;
+
+// Get an OpenTelemetry instance
+OpenTelemetry openTelemetry = ...;
+
+NettyServerTelemetry serverTelemetry = NettyServerTelemetry.create(openTelemetry);
+
+EventLoopGroup bossGroup = ...; // Use appropriate EventLoopGroup for your platform
+EventLoopGroup workerGroup = ...; // Use appropriate EventLoopGroup for your platform
+Class<? extends ServerChannel> serverChannelClass = ...; // Use appropriate ServerChannel class for your platform
+
+ServerBootstrap bootstrap = new ServerBootstrap();
+bootstrap.group(bossGroup, workerGroup)
+    .channel(serverChannelClass)
+    .childHandler(new ChannelInitializer<SocketChannel>() {
+        @Override
+        protected void initChannel(SocketChannel ch) {
+            ch.pipeline()
+                .addLast(new HttpServerCodec())
+                .addLast(serverTelemetry.createCombinedHandler())
+                .addLast(new YourServerHandler()); // Your application handler
+        }
+    });
+
+bootstrap.bind(8080).sync();
+```