autoconfigure and smoke

Author: jaydeluca

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 {
@@ -110,6 +118,18 @@ 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"))
 
+  // Spring Boot 4
+  add("javaSpring4CompileOnly", files(sourceSets.main.get().output.classesDirs))
+  add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-starter-web:4.0.0")
+  add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-starter-data-jdbc:4.0.0")
+  add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-starter-kafka:4.0.0")
+  add("javaSpring4CompileOnly", "io.opentelemetry:opentelemetry-sdk-extension-autoconfigure")
+  add("javaSpring4CompileOnly", "jakarta.servlet:jakarta.servlet-api:6.1.0")
+  add("javaSpring4CompileOnly", project(":instrumentation:spring:spring-web:spring-web-3.1:library"))
+  add("javaSpring4CompileOnly", project(":instrumentation:spring:spring-webmvc:spring-webmvc-6.0:library"))
+  add("javaSpring4CompileOnly", project(":instrumentation:kafka:kafka-clients:kafka-clients-2.6:library"))
+  add("javaSpring4CompileOnly", project(":instrumentation:spring:spring-kafka-2.7: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
@@ -186,6 +206,20 @@ testing {
       }
     }
 
+    val testSpring4 by registering(JvmTestSuite::class) {
+      dependencies {
+        implementation(project())
+        implementation("org.springframework.boot:spring-boot-starter-web:4.0.0")
+        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:6.1.0")
+        implementation("org.springframework.boot:spring-boot-starter-test:4.0.0") {
+          exclude("org.junit.vintage", "junit-vintage-engine")
+        }
+      }
+    }
+
     val testDeclarativeConfig by registering(JvmTestSuite::class) {
       dependencies {
         implementation(project())
@@ -234,12 +268,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/kafka/KafkaInstrumentationAutoConfiguration.java

@@ -29,6 +29,8 @@
   ConcurrentKafkaListenerContainerFactory.class,
   DefaultKafkaProducerFactoryCustomizer.class
 })
+@org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass(
+    "org.springframework.boot.kafka.autoconfigure.DefaultKafkaProducerFactoryCustomizer")
 @Configuration
 public class KafkaInstrumentationAutoConfiguration {
 

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;
+
+/**
+ * Spring Boot 4+ specific Kafka instrumentation auto-configuration. 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/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

@@ -1,6 +1,7 @@
 io.opentelemetry.instrumentation.spring.autoconfigure.OpenTelemetryAutoConfiguration
 io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.annotations.InstrumentationAnnotationsAutoConfiguration
 io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.kafka.KafkaInstrumentationAutoConfiguration
+io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.kafka.KafkaInstrumentationSpringBoot4AutoConfiguration
 io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.mongo.MongoClientInstrumentationAutoConfiguration
 io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.logging.OpenTelemetryAppenderAutoConfiguration
 io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.jdbc.JdbcInstrumentationAutoConfiguration

instrumentation/spring/spring-boot-autoconfigure/src/testSpring4/java/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/webmvc/SpringWebMvcInstrumentation7AutoConfigurationTest.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.webmvc;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.api.incubator.config.internal.InstrumentationConfig;
+import io.opentelemetry.instrumentation.spring.autoconfigure.internal.properties.ConfigPropertiesBridge;
+import io.opentelemetry.sdk.autoconfigure.spi.internal.DefaultConfigProperties;
+import jakarta.servlet.Filter;
+import java.util.Collections;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.autoconfigure.AutoConfigurations;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+
+class SpringWebMvcInstrumentation7AutoConfigurationTest {
+
+  private final ApplicationContextRunner contextRunner =
+      new ApplicationContextRunner()
+          .withBean(OpenTelemetry.class, OpenTelemetry::noop)
+          .withBean(
+              InstrumentationConfig.class,
+              () ->
+                  new ConfigPropertiesBridge(
+                      DefaultConfigProperties.createFromMap(Collections.emptyMap())))
+          .withConfiguration(
+              AutoConfigurations.of(SpringWebMvc7InstrumentationAutoConfiguration.class));
+
+  @Test
+  void instrumentationEnabled() {
+    this.contextRunner
+        .withPropertyValues("otel.instrumentation.spring-webmvc.enabled=true")
+        .run(context -> assertThat(context.getBean("otelWebMvcFilter", Filter.class)).isNotNull());
+  }
+
+  @Test
+  void instrumentationDisabled() {
+    this.contextRunner
+        .withPropertyValues("otel.instrumentation.spring-webmvc.enabled=false")
+        .run(context -> assertThat(context.containsBean("otelWebMvcFilter")).isFalse());
+  }
+
+  @Test
+  void defaultConfiguration() {
+    this.contextRunner.run(
+        context -> assertThat(context.getBean("otelWebMvcFilter", Filter.class)).isNotNull());
+  }
+}

settings.gradle.kts

@@ -44,6 +44,7 @@ dependencyResolutionManagement {
     // spring boot 3.0 is not compatible with graalvm native image
     addSpringBootCatalog("springBoot31", "3.1.0", "3.+")
     addSpringBootCatalog("springBoot32", "3.2.0", "3.+")
+    addSpringBootCatalog("springBoot40", "4.0.0", "4.+")
   }
 }
 
@@ -161,6 +162,7 @@ include(":smoke-tests-otel-starter:spring-smoke-testing")
 include(":smoke-tests-otel-starter:spring-boot-2")
 include(":smoke-tests-otel-starter:spring-boot-3")
 include(":smoke-tests-otel-starter:spring-boot-3.2")
+include(":smoke-tests-otel-starter:spring-boot-4")
 include(":smoke-tests-otel-starter:spring-boot-common")
 include(":smoke-tests-otel-starter:spring-boot-reactive-2")
 include(":smoke-tests-otel-starter:spring-boot-reactive-3")

smoke-tests-otel-starter/spring-boot-4/build.gradle.kts

@@ -0,0 +1,41 @@
+plugins {
+  id("otel.java-conventions")
+  alias(springBoot40.plugins.versions)
+}
+
+description = "smoke-tests-otel-starter-spring-boot-4"
+
+otelJava {
+  minJavaVersionSupported.set(JavaVersion.VERSION_17)
+}
+
+dependencies {
+  implementation(platform(org.springframework.boot.gradle.plugin.SpringBootPlugin.BOM_COORDINATES))
+
+  implementation("org.springframework.boot:spring-boot-starter-web")
+  implementation("org.springframework.boot:spring-boot-starter-data-jdbc")
+  implementation("org.springframework.boot:spring-boot-starter-kafka")
+  runtimeOnly("com.h2database:h2")
+
+  implementation(project(":smoke-tests-otel-starter:spring-boot-common"))
+  testImplementation("org.springframework.boot:spring-boot-starter-test")
+  testImplementation("org.springframework.boot:spring-boot-resttestclient")
+  testImplementation("org.awaitility:awaitility")
+  testImplementation(project(":instrumentation:spring:starters:spring-boot-starter"))
+  testImplementation(project(":smoke-tests-otel-starter:spring-smoke-testing"))
+}
+
+springBoot {
+  mainClass = "io.opentelemetry.spring.smoketest.OtelSpringStarterSmokeTestApplication"
+}
+
+// Disable -Werror for Spring Framework 7.0 compatibility
+tasks.withType<JavaCompile>().configureEach {
+  options.compilerArgs.removeAll(listOf("-Werror"))
+}
+
+tasks {
+  test {
+    usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
+  }
+}

smoke-tests-otel-starter/spring-boot-4/src/main/java/io/opentelemetry/spring/smoketest/OtelSpringStarterSmokeTestApplication.java

@@ -0,0 +1,19 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.spring.smoketest;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class OtelSpringStarterSmokeTestApplication {
+
+  public OtelSpringStarterSmokeTestApplication() {}
+
+  public static void main(String[] args) {
+    SpringApplication.run(OtelSpringStarterSmokeTestApplication.class);
+  }
+}

smoke-tests-otel-starter/spring-boot-4/src/main/resources/application.properties

@@ -0,0 +1 @@
+spring.application.name=otel-spring-starter-smoke-test