[Spring Starter] Spring boot 4 support (#15459)

Co-authored-by: Lauri Tulmin <[email protected]>

Author: jaydeluca

.github/graal-native-docker-compose.yaml

@@ -5,15 +5,15 @@ services:
       - "27017:27017"
 
   zookeeper:
-    image: confluentinc/cp-zookeeper:6.2.10
+    image: confluentinc/cp-zookeeper:7.7.7
     environment:
       ZOOKEEPER_CLIENT_PORT: 2181
       ZOOKEEPER_TICK_TIME: 2000
     ports:
       - "22181:2181"
 
   kafka:
-    image: confluentinc/cp-kafka:6.2.10
+    image: confluentinc/cp-kafka:7.7.7
     ports:
       - 9094:9094
     depends_on:

.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 {
@@ -99,6 +107,9 @@ dependencies {
   testImplementation("io.opentelemetry:opentelemetry-exporter-otlp")
   testImplementation("io.opentelemetry:opentelemetry-exporter-zipkin")
   testImplementation(project(":instrumentation-annotations"))
+  testImplementation(project(":instrumentation:spring:spring-boot-autoconfigure:testing"))
+
+  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 +121,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
@@ -172,17 +187,62 @@ testing {
       }
     }
 
+    val testSpring2 by registering(JvmTestSuite::class) {
+      dependencies {
+        implementation(project())
+        implementation("io.opentelemetry:opentelemetry-sdk")
+        implementation("io.opentelemetry:opentelemetry-sdk-testing")
+        implementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure")
+        implementation(project(":instrumentation-api"))
+        implementation(project(":instrumentation:micrometer:micrometer-1.5:library"))
+        implementation(project(":instrumentation:spring:spring-boot-autoconfigure:testing"))
+        // configure Spring Boot 3.x dependencies for latest dep testing
+        val version = if (latestDepTest) "3.+" else springBootVersion
+        implementation("org.springframework.boot:spring-boot-starter-test:$version")
+        implementation("org.springframework.boot:spring-boot-starter-actuator:$version")
+        implementation("org.springframework.boot:spring-boot-starter-web:$version")
+        implementation("org.springframework.boot:spring-boot-starter-jdbc:$version")
+        implementation("org.springframework.boot:spring-boot-starter-data-r2dbc:$version")
+        val springKafkaVersion = if (latestDepTest) "3.+" else "2.9.0"
+        implementation("org.springframework.kafka:spring-kafka:$springKafkaVersion")
+        implementation("javax.servlet:javax.servlet-api:3.1.0")
+        runtimeOnly("com.h2database:h2:1.4.197")
+        runtimeOnly("io.r2dbc:r2dbc-h2:1.0.0.RELEASE")
+      }
+    }
+
     val testSpring3 by registering(JvmTestSuite::class) {
       dependencies {
         implementation(project())
-        implementation("org.springframework.boot:spring-boot-starter-web:3.2.4")
+        val version = if (latestDepTest) "3.+" else "3.2.4"
+        implementation("org.springframework.boot:spring-boot-starter-web:$version")
         implementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure")
         implementation(project(":instrumentation:spring:spring-web:spring-web-3.1:library"))
         implementation(project(":instrumentation:spring:spring-webmvc:spring-webmvc-6.0:library"))
         implementation("jakarta.servlet:jakarta.servlet-api:5.0.0")
-        implementation("org.springframework.boot:spring-boot-starter-test:3.2.4") {
-          exclude("org.junit.vintage", "junit-vintage-engine")
-        }
+        implementation("org.springframework.boot:spring-boot-starter-test:$version")
+      }
+    }
+
+    val testSpring4 by registering(JvmTestSuite::class) {
+      dependencies {
+        implementation(project())
+        implementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure")
+        val version = if (latestDepTest) "latest.release" else "4.0.0"
+        implementation("org.springframework.boot:spring-boot-starter-jdbc:$version")
+        implementation("org.springframework.boot:spring-boot-restclient:$version")
+        implementation("org.springframework.boot:spring-boot-starter-kafka:$version")
+        implementation("org.springframework.boot:spring-boot-starter-actuator:$version")
+        implementation("org.springframework.boot:spring-boot-starter-data-r2dbc:$version")
+        implementation("org.springframework.boot:spring-boot-starter-micrometer-metrics:$version")
+        implementation("io.opentelemetry:opentelemetry-sdk")
+        implementation("io.opentelemetry:opentelemetry-sdk-testing")
+        implementation(project(":instrumentation-api"))
+        implementation(project(":instrumentation:micrometer:micrometer-1.5:library"))
+        implementation(project(":instrumentation:spring:spring-boot-autoconfigure:testing"))
+        implementation("org.springframework.boot:spring-boot-starter-test:$version")
+        runtimeOnly("com.h2database:h2:1.4.197")
+        runtimeOnly("io.r2dbc:r2dbc-h2:1.0.0.RELEASE")
       }
     }
 
@@ -225,22 +285,50 @@ tasks {
     options.release.set(17)
   }
 
+  named<JavaCompile>("compileTestSpring2Java") {
+    sourceCompatibility = "17"
+    targetCompatibility = "17"
+    options.release.set(17)
+  }
+
   named<JavaCompile>("compileTestSpring3Java") {
     sourceCompatibility = "17"
     targetCompatibility = "17"
     options.release.set(17)
   }
 
+  named<Test>("testSpring2") {
+    isEnabled = testSpring3
+  }
+
   named<Test>("testSpring3") {
     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) // module changed in Spring Boot 4
 @Configuration(proxyBeanMethods = false)
 public class JdbcInstrumentationAutoConfiguration {
 

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

@@ -7,13 +7,11 @@
 
 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.ConditionalOnProperty;
-import org.springframework.boot.autoconfigure.kafka.DefaultKafkaProducerFactoryCustomizer;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
@@ -27,17 +25,11 @@
 @ConditionalOnClass({
   KafkaTemplate.class,
   ConcurrentKafkaListenerContainerFactory.class,
-  DefaultKafkaProducerFactoryCustomizer.class
 })
 @Configuration
 public class KafkaInstrumentationAutoConfiguration {
 
-  @Bean
-  DefaultKafkaProducerFactoryCustomizer otelKafkaProducerFactoryCustomizer(
-      OpenTelemetry openTelemetry) {
-    KafkaTelemetry kafkaTelemetry = KafkaTelemetry.create(openTelemetry);
-    return producerFactory -> producerFactory.addPostProcessor(kafkaTelemetry::wrap);
-  }
+  public KafkaInstrumentationAutoConfiguration() {}
 
   @Bean
   static SpringKafkaTelemetry getTelemetry(

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

@@ -0,0 +1,38 @@
+/*
+ * 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.kafkaclients.v2_6.KafkaTelemetry;
+import io.opentelemetry.instrumentation.spring.autoconfigure.internal.ConditionalOnEnabledInstrumentation;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.kafka.DefaultKafkaProducerFactoryCustomizer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.kafka.core.DefaultKafkaProducerFactory;
+
+/**
+ * This class is internal and is hence not for public use. Its APIs are unstable and can change at
+ * any time.
+ */
+@ConditionalOnEnabledInstrumentation(module = "kafka")
+// package changed in Spring Boot 4
+@ConditionalOnClass({
+  DefaultKafkaProducerFactoryCustomizer.class,
+  DefaultKafkaProducerFactory.class
+})
+@Configuration
+public class ProducerFactoryCustomizerConfiguration {
+
+  public ProducerFactoryCustomizerConfiguration() {}
+
+  @Bean
+  static DefaultKafkaProducerFactoryCustomizer otelKafkaProducerFactoryCustomizer(
+      OpenTelemetry openTelemetry) {
+    KafkaTelemetry kafkaTelemetry = KafkaTelemetry.create(openTelemetry);
+    return producerFactory -> producerFactory.addPostProcessor(kafkaTelemetry::wrap);
+  }
+}

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

@@ -28,7 +28,7 @@
 @AutoConfigureAfter({MetricsAutoConfiguration.class, OpenTelemetryAutoConfiguration.class})
 @AutoConfigureBefore(CompositeMeterRegistryAutoConfiguration.class)
 @ConditionalOnBean(Clock.class)
-@ConditionalOnClass(MeterRegistry.class)
+@ConditionalOnClass(MeterRegistry.class) // module changed in Spring Boot 4
 @Configuration
 public class MicrometerBridgeAutoConfiguration {
 

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

@@ -20,7 +20,10 @@
  * 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})
+@ConditionalOnClass({
+  MongoClientSettings.class,
+  MongoClientSettingsBuilderCustomizer.class
+}) // module changed in Spring Boot 4
 @ConditionalOnEnabledInstrumentation(module = "mongo")
 @Configuration
 public class MongoClientInstrumentationAutoConfiguration {

instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/web/RestTemplateBeanPostProcessor.java

@@ -11,7 +11,11 @@
 import org.springframework.beans.factory.config.BeanPostProcessor;
 import org.springframework.web.client.RestTemplate;
 
-final class RestTemplateBeanPostProcessor implements BeanPostProcessor {
+/**
+ * This class is internal and is hence not for public use. Its APIs are unstable and can change at
+ * any time.
+ */
+public final class RestTemplateBeanPostProcessor implements BeanPostProcessor {
 
   private final ObjectProvider<OpenTelemetry> openTelemetryProvider;
 

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);
+  }
+}