[Spring Starter] Spring boot 4 support

.github/workflows/codeql.yml

@@ -80,6 +80,7 @@ jobs:
           ./gradlew assemble -x javadoc
           -x :smoke-tests-otel-starter:spring-boot-3:collectReachabilityMetadata
           -x :smoke-tests-otel-starter:spring-boot-3.2:collectReachabilityMetadata
+          -x :smoke-tests-otel-starter:spring-boot-4:collectReachabilityMetadata
           -x :smoke-tests-otel-starter:spring-boot-reactive-3:collectReachabilityMetadata
           --no-build-cache --no-daemon
 

instrumentation/spring/spring-boot-autoconfigure/build.gradle.kts

@@ -23,12 +23,20 @@ sourceSets {
       setSrcDirs(listOf("src/main/javaSpring3"))
     }
   }
+  create("javaSpring4") {
+    java {
+      setSrcDirs(listOf("src/main/javaSpring4"))
+    }
+  }
 }
 
 configurations {
   named("javaSpring3CompileOnly") {
     extendsFrom(configurations["compileOnly"])
   }
+  named("javaSpring4CompileOnly") {
+    extendsFrom(configurations["compileOnly"])
+  }
 }
 
 dependencies {
@@ -100,6 +108,8 @@ dependencies {
   testImplementation("io.opentelemetry:opentelemetry-exporter-zipkin")
   testImplementation(project(":instrumentation-annotations"))
 
+  latestDepTestLibrary("org.springframework.boot:spring-boot-starter-micrometer-metrics:latest.release")
+
   // needed for the Spring Boot 3 support
   implementation(project(":instrumentation:spring:spring-webmvc:spring-webmvc-6.0:library"))
 
@@ -110,15 +120,19 @@ dependencies {
   add("javaSpring3CompileOnly", project(":instrumentation:spring:spring-web:spring-web-3.1:library"))
   add("javaSpring3CompileOnly", project(":instrumentation:spring:spring-webmvc:spring-webmvc-6.0:library"))
 
-  // tests don't work with spring boot 4 yet
-  latestDepTestLibrary("org.springframework.boot:spring-boot-starter-test:3.+") // documented limitation
-  latestDepTestLibrary("org.springframework.boot:spring-boot-starter-actuator:3.+") // documented limitation
-  latestDepTestLibrary("org.springframework.boot:spring-boot-starter-aop:3.+") // documented limitation
-  latestDepTestLibrary("org.springframework.boot:spring-boot-starter-web:3.+") // documented limitation
-  latestDepTestLibrary("org.springframework.boot:spring-boot-starter-webflux:3.+") // documented limitation
-  latestDepTestLibrary("org.springframework.boot:spring-boot-starter-data-mongodb:3.+") // documented limitation
-  latestDepTestLibrary("org.springframework.boot:spring-boot-starter-data-r2dbc:3.+") // documented limitation
-  latestDepTestLibrary("org.springframework.boot:spring-boot-starter-data-jdbc:3.+") // documented limitation
+  // Spring Boot 4
+  add("javaSpring4CompileOnly", files(sourceSets.main.get().output.classesDirs))
+  add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-starter-kafka:4.0.0")
+  add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-autoconfigure:4.0.0")
+  add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-jdbc:4.0.0")
+  add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-starter-jdbc:4.0.0")
+  add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-restclient:4.0.0")
+  add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-starter-data-mongodb:4.0.0")
+  add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-starter-micrometer-metrics:4.0.0")
+  add("javaSpring4CompileOnly", project(":instrumentation:kafka:kafka-clients:kafka-clients-2.6:library"))
+  add("javaSpring4CompileOnly", project(":instrumentation:spring:spring-kafka-2.7:library"))
+  add("javaSpring4CompileOnly", project(":instrumentation:mongo:mongo-3.1:library"))
+  add("javaSpring4CompileOnly", project(":instrumentation:micrometer:micrometer-1.5:library"))
 }
 
 val latestDepTest = findProperty("testLatestDeps") as Boolean
@@ -186,6 +200,28 @@ testing {
       }
     }
 
+    val testSpring4 by registering(JvmTestSuite::class) {
+      dependencies {
+        implementation(project())
+        implementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure")
+        implementation("org.springframework.boot:spring-boot-starter-jdbc:4.0.0")
+        implementation("org.springframework.boot:spring-boot-restclient:4.0.0")
+        implementation("org.springframework.boot:spring-boot-starter-kafka:4.0.0")
+        implementation("org.springframework.boot:spring-boot-starter-actuator:4.0.0")
+        implementation("org.springframework.boot:spring-boot-starter-data-r2dbc:4.0.0")
+        implementation("org.springframework.boot:spring-boot-starter-micrometer-metrics:4.0.0")
+        implementation("io.opentelemetry:opentelemetry-sdk")
+        implementation("io.opentelemetry:opentelemetry-sdk-testing")
+        implementation(project(":instrumentation-api"))
+        implementation(project(":instrumentation:micrometer:micrometer-1.5:library"))
+        implementation("org.springframework.boot:spring-boot-starter-test:4.0.0") {
+          exclude("org.junit.vintage", "junit-vintage-engine")
+        }
+        runtimeOnly("com.h2database:h2:1.4.197")
+        runtimeOnly("io.r2dbc:r2dbc-h2:1.0.0.RELEASE")
+      }
+    }
+
     val testDeclarativeConfig by registering(JvmTestSuite::class) {
       dependencies {
         implementation(project())
@@ -208,6 +244,15 @@ configurations.configureEach {
 tasks {
   compileTestJava {
     options.compilerArgs.add("-parameters")
+
+    // Exclude Spring Boot specific tests from compilation when testLatestDeps is true
+    // These tests are covered by testSpring4 suite
+    if (latestDepTest) {
+      exclude("**/micrometer/MicrometerBridgeAutoConfigurationTest.java")
+      exclude("**/r2dbc/R2DbcInstrumentationAutoConfigurationTest.java")
+      exclude("**/jdbc/JdbcInstrumentationAutoConfigurationTest.java")
+      exclude("**/web/SpringWebInstrumentationAutoConfigurationTest.java")
+    }
   }
 
   withType<Test>().configureEach {
@@ -218,6 +263,17 @@ tasks {
     jvmArgs("-XX:+IgnoreUnrecognizedVMOptions")
   }
 
+  test {
+    // Exclude Spring Boot specific tests when testLatestDeps is true
+    // These tests are covered by testSpring4 suite
+    if (latestDepTest) {
+      exclude("**/micrometer/MicrometerBridgeAutoConfigurationTest.class")
+      exclude("**/r2dbc/R2DbcInstrumentationAutoConfigurationTest.class")
+      exclude("**/jdbc/JdbcInstrumentationAutoConfigurationTest.class")
+      exclude("**/web/SpringWebInstrumentationAutoConfigurationTest.class")
+    }
+  }
+
   named<JavaCompile>("compileJavaSpring3Java") {
     sourceCompatibility = "17"
     targetCompatibility = "17"
@@ -234,12 +290,30 @@ tasks {
     isEnabled = testSpring3
   }
 
+  named<JavaCompile>("compileJavaSpring4Java") {
+    sourceCompatibility = "17"
+    targetCompatibility = "17"
+    options.release.set(17)
+  }
+
+  named<JavaCompile>("compileTestSpring4Java") {
+    sourceCompatibility = "17"
+    targetCompatibility = "17"
+    options.release.set(17)
+  }
+
+  named<Test>("testSpring4") {
+    isEnabled = testSpring3 // same condition as Spring 3 (requires Java 17+)
+  }
+
   named<Jar>("jar") {
     from(sourceSets["javaSpring3"].output)
+    from(sourceSets["javaSpring4"].output)
   }
 
   named<Jar>("sourcesJar") {
     from(sourceSets["javaSpring3"].java)
+    from(sourceSets["javaSpring4"].java)
   }
 
   val testStableSemconv by registering(Test::class) {

instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/jdbc/JdbcInstrumentationAutoConfiguration.java

@@ -12,6 +12,7 @@
 import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.boot.autoconfigure.AutoConfiguration;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -23,6 +24,7 @@
 @ConditionalOnEnabledInstrumentation(module = "jdbc")
 @AutoConfiguration(after = DataSourceAutoConfiguration.class)
 @ConditionalOnBean({DataSource.class})
+@ConditionalOnClass(DataSourceAutoConfiguration.class)
 @Configuration(proxyBeanMethods = false)
 public class JdbcInstrumentationAutoConfiguration {
 

instrumentation/spring/spring-boot-autoconfigure/src/main/javaSpring4/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/jdbc/JdbcInstrumentationSpringBoot4AutoConfiguration.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.jdbc;
+
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.api.incubator.config.internal.InstrumentationConfig;
+import io.opentelemetry.instrumentation.spring.autoconfigure.internal.ConditionalOnEnabledInstrumentation;
+import javax.sql.DataSource;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.boot.autoconfigure.AutoConfiguration;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.jdbc.autoconfigure.DataSourceAutoConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * This class is internal and is hence not for public use. Its APIs are unstable and can change at
+ * any time.
+ */
+@ConditionalOnEnabledInstrumentation(module = "jdbc")
+@AutoConfiguration(after = DataSourceAutoConfiguration.class)
+@ConditionalOnBean({DataSource.class})
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnClass(DataSourceAutoConfiguration.class)
+public class JdbcInstrumentationSpringBoot4AutoConfiguration {
+
+  // For error prone
+  public JdbcInstrumentationSpringBoot4AutoConfiguration() {}
+
+  @Bean
+  // static to avoid "is not eligible for getting processed by all BeanPostProcessors" warning
+  static DataSourcePostProcessor dataSourcePostProcessor(
+      ObjectProvider<OpenTelemetry> openTelemetryProvider,
+      ObjectProvider<InstrumentationConfig> configProvider) {
+    return new DataSourcePostProcessor(openTelemetryProvider, configProvider);
+  }
+}

instrumentation/spring/spring-boot-autoconfigure/src/main/javaSpring4/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/kafka/KafkaInstrumentationSpringBoot4AutoConfiguration.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.kafka;
+
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.api.incubator.config.internal.InstrumentationConfig;
+import io.opentelemetry.instrumentation.kafkaclients.v2_6.KafkaTelemetry;
+import io.opentelemetry.instrumentation.spring.autoconfigure.internal.ConditionalOnEnabledInstrumentation;
+import io.opentelemetry.instrumentation.spring.kafka.v2_7.SpringKafkaTelemetry;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.kafka.autoconfigure.DefaultKafkaProducerFactoryCustomizer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
+import org.springframework.kafka.core.KafkaTemplate;
+
+/**
+ * This class is internal and is hence not for public use. Its APIs are unstable and can change at
+ * any time.
+ */
+@ConditionalOnEnabledInstrumentation(module = "kafka")
+@ConditionalOnClass({
+  KafkaTemplate.class,
+  ConcurrentKafkaListenerContainerFactory.class,
+  DefaultKafkaProducerFactoryCustomizer.class
+})
+@ConditionalOnMissingBean(name = "otelKafkaProducerFactoryCustomizer")
+@Configuration
+public class KafkaInstrumentationSpringBoot4AutoConfiguration {
+
+  @Bean
+  DefaultKafkaProducerFactoryCustomizer otelKafkaProducerFactoryCustomizer(
+      OpenTelemetry openTelemetry) {
+    KafkaTelemetry kafkaTelemetry = KafkaTelemetry.create(openTelemetry);
+    return producerFactory -> producerFactory.addPostProcessor(kafkaTelemetry::wrap);
+  }
+
+  @Bean
+  static SpringKafkaTelemetry getTelemetry(
+      ObjectProvider<OpenTelemetry> openTelemetryProvider,
+      ObjectProvider<InstrumentationConfig> configProvider) {
+    return SpringKafkaTelemetry.builder(openTelemetryProvider.getObject())
+        .setCaptureExperimentalSpanAttributes(
+            configProvider
+                .getObject()
+                .getBoolean("otel.instrumentation.kafka.experimental-span-attributes", false))
+        .build();
+  }
+
+  // static to avoid "is not eligible for getting processed by all BeanPostProcessors" warning
+  @Bean
+  @ConditionalOnProperty(
+      name = "otel.instrumentation.kafka.autoconfigure-interceptor",
+      havingValue = "true",
+      matchIfMissing = true)
+  @ConditionalOnMissingBean
+  static ConcurrentKafkaListenerContainerFactoryPostProcessor
+      otelKafkaListenerContainerFactoryBeanPostProcessor(
+          ObjectProvider<OpenTelemetry> openTelemetryProvider,
+          ObjectProvider<InstrumentationConfig> configProvider) {
+    return new ConcurrentKafkaListenerContainerFactoryPostProcessor(
+        () -> getTelemetry(openTelemetryProvider, configProvider));
+  }
+}

instrumentation/spring/spring-boot-autoconfigure/src/main/javaSpring4/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/micrometer/MicrometerBridgeSpringBoot4AutoConfiguration.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.micrometer;
+
+import io.micrometer.core.instrument.Clock;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.micrometer.v1_5.OpenTelemetryMeterRegistry;
+import io.opentelemetry.instrumentation.spring.autoconfigure.OpenTelemetryAutoConfiguration;
+import io.opentelemetry.instrumentation.spring.autoconfigure.internal.ConditionalOnEnabledInstrumentation;
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
+import org.springframework.boot.autoconfigure.AutoConfigureBefore;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.micrometer.metrics.autoconfigure.CompositeMeterRegistryAutoConfiguration;
+import org.springframework.boot.micrometer.metrics.autoconfigure.MetricsAutoConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * This class is internal and is hence not for public use. Its APIs are unstable and can change at
+ * any time.
+ */
+@ConditionalOnEnabledInstrumentation(module = "micrometer", enabledByDefault = false)
+@AutoConfigureAfter({MetricsAutoConfiguration.class, OpenTelemetryAutoConfiguration.class})
+@AutoConfigureBefore(CompositeMeterRegistryAutoConfiguration.class)
+@ConditionalOnBean(Clock.class)
+@ConditionalOnClass({MeterRegistry.class, MetricsAutoConfiguration.class})
+@Configuration
+public class MicrometerBridgeSpringBoot4AutoConfiguration {
+
+  @Bean
+  MeterRegistry otelMeterRegistry(OpenTelemetry openTelemetry, Clock micrometerClock) {
+    return OpenTelemetryMeterRegistry.builder(openTelemetry).setClock(micrometerClock).build();
+  }
+}

instrumentation/spring/spring-boot-autoconfigure/src/main/javaSpring4/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/mongo/MongoClientInstrumentationSpringBoot4AutoConfiguration.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.mongo;
+
+import com.mongodb.MongoClientSettings;
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.api.incubator.config.internal.InstrumentationConfig;
+import io.opentelemetry.instrumentation.mongo.v3_1.MongoTelemetry;
+import io.opentelemetry.instrumentation.spring.autoconfigure.internal.ConditionalOnEnabledInstrumentation;
+import io.opentelemetry.instrumentation.spring.autoconfigure.internal.properties.InstrumentationConfigUtil;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.mongodb.autoconfigure.MongoClientSettingsBuilderCustomizer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * This class is internal and is hence not for public use. Its APIs are unstable and can change at
+ * any time.
+ */
+@ConditionalOnClass({MongoClientSettings.class, MongoClientSettingsBuilderCustomizer.class})
+@ConditionalOnEnabledInstrumentation(module = "mongo")
+@Configuration
+public class MongoClientInstrumentationSpringBoot4AutoConfiguration {
+
+  @Bean
+  MongoClientSettingsBuilderCustomizer customizer(
+      OpenTelemetry openTelemetry, InstrumentationConfig config) {
+    return builder ->
+        builder.addCommandListener(
+            MongoTelemetry.builder(openTelemetry)
+                .setStatementSanitizationEnabled(
+                    InstrumentationConfigUtil.isStatementSanitizationEnabled(
+                        config, "otel.instrumentation.mongo.statement-sanitizer.enabled"))
+                .build()
+                .newCommandListener());
+  }
+}