Spring boot 2 smoke test using inheritance (#11278)

settings.gradle.kts

@@ -139,8 +139,12 @@ include(":smoke-tests:images:servlet:servlet-5.0")
 include(":smoke-tests:images:spring-boot")
 
 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-reactive")
+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")
+include(":smoke-tests-otel-starter:spring-boot-reactive-common")
 
 include(":instrumentation:akka:akka-actor-2.3:javaagent")
 include(":instrumentation:akka:akka-actor-fork-join-2.5:javaagent")

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

@@ -0,0 +1,30 @@
+plugins {
+  id("otel.java-conventions")
+  id("org.springframework.boot") version "2.7.18"
+}
+
+description = "smoke-tests-otel-starter-spring-boot-2"
+
+dependencies {
+  implementation("org.springframework.boot:spring-boot-starter-web")
+  implementation("org.springframework.boot:spring-boot-starter-data-jdbc")
+  runtimeOnly("com.h2database:h2")
+  implementation("org.apache.commons:commons-dbcp2")
+  implementation("org.springframework.kafka:spring-kafka") // not tested here, just make sure there are no warnings when it's included
+  implementation(platform(org.springframework.boot.gradle.plugin.SpringBootPlugin.BOM_COORDINATES))
+
+  implementation(project(":smoke-tests-otel-starter:spring-boot-common"))
+  testImplementation("org.springframework.boot:spring-boot-starter-test")
+}
+
+springBoot {
+  mainClass = "io.opentelemetry.spring.smoketest.OtelSpringStarterSmokeTestApplication"
+}
+
+configurations.configureEach {
+  resolutionStrategy {
+    // our dependency management pins to a version that is not compatible with spring boot 2.7
+    force("ch.qos.logback:logback-classic:1.2.13")
+    force("org.slf4j:slf4j-api:1.7.36")
+  }
+}

smoke-tests-otel-starter/spring-boot-2/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-2/src/test/java/io/opentelemetry/spring/smoketest/OtelSpringStarterSmokeTest.java

@@ -0,0 +1,21 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.spring.smoketest;
+
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest(
+    classes = {
+      OtelSpringStarterSmokeTestApplication.class,
+      AbstractOtelSpringStarterSmokeTest.TestConfiguration.class,
+      SpringSmokeOtelConfiguration.class
+    },
+    webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
+    properties = {
+      // The headers are simply set here to make sure that headers can be parsed
+      "otel.exporter.otlp.headers.c=3"
+    })
+class OtelSpringStarterSmokeTest extends AbstractOtelSpringStarterSmokeTest {}

smoke-tests-otel-starter/spring-boot-3/build.gradle.kts → smoke-tests-otel-starter/spring-boot-3/spring-boot-non-reactive-3/build.gradle.kts

@@ -16,19 +16,17 @@ dependencies {
   runtimeOnly("com.h2database:h2")
   implementation("org.apache.commons:commons-dbcp2")
   implementation("org.springframework.kafka:spring-kafka") // not tested here, just make sure there are no warnings when it's included
-  implementation("io.opentelemetry:opentelemetry-extension-trace-propagators")
-  implementation(project(":instrumentation:spring:starters:spring-boot-starter"))
   implementation(platform(org.springframework.boot.gradle.plugin.SpringBootPlugin.BOM_COORDINATES))
 
+  implementation(project(":smoke-tests-otel-starter:spring-boot-common"))
   testImplementation("org.springframework.boot:spring-boot-starter-test")
-  testImplementation(project(":smoke-tests-otel-starter:spring-smoke-testing"))
+}
+
+springBoot {
+  mainClass = "io.opentelemetry.spring.smoketest.OtelSpringStarterSmokeTestApplication"
 }
 
 tasks {
-  test {
-    // suppress warning about byte-buddy-agent being loaded dynamically
-    jvmArgs("-XX:+EnableDynamicAgentLoading")
-  }
   compileAotJava {
     with(options) {
       compilerArgs.add("-Xlint:-deprecation,-unchecked,none")

smoke-tests-otel-starter/spring-boot-3/spring-boot-non-reactive-3/src/main/java/io/opentelemetry/spring/smoketest/RestClientSmokeTestController.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.spring.smoketest;
+
+import java.util.Optional;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.client.RestClient;
+
+@RestController
+public class RestClientSmokeTestController {
+
+  public static final String REST_CLIENT = "/rest-client";
+  private final Optional<RestClient> restClient;
+
+  public RestClientSmokeTestController(
+      RestClient.Builder restClientBuilder, OtelSpringStarterSmokeTestController controller) {
+    restClient = controller.getRootUri().map(uri -> restClientBuilder.baseUrl(uri).build());
+  }
+
+  @GetMapping(REST_CLIENT)
+  public String restClient() {
+    return restClient
+        .map(
+            c ->
+                c.get()
+                    .uri(OtelSpringStarterSmokeTestController.PING)
+                    .retrieve()
+                    .body(String.class))
+        .orElseThrow(() -> new IllegalStateException("RestClient not available"));
+  }
+}

smoke-tests-otel-starter/spring-boot-3/src/test/java/io/opentelemetry/smoketest/OtelSpringStarterDisabledSmokeTest.java → smoke-tests-otel-starter/spring-boot-3/spring-boot-non-reactive-3/src/test/java/io/opentelemetry/spring/smoketest/OtelSpringStarterDisabledSmokeTest.java

@@ -3,9 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-package io.opentelemetry.smoketest;
+package io.opentelemetry.spring.smoketest;
 
-import io.opentelemetry.spring.smoketest.OtelSpringStarterSmokeTestApplication;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.condition.DisabledInNativeImage;
 import org.springframework.boot.test.context.SpringBootTest;
@@ -13,7 +12,7 @@ import org.springframework.boot.test.context.SpringBootTest;
 @SpringBootTest(
     classes = {
       OtelSpringStarterSmokeTestApplication.class,
-      OtelSpringStarterSmokeTest.TestConfiguration.class
+      AbstractOtelSpringStarterSmokeTest.TestConfiguration.class
     },
     properties = {"otel.sdk.disabled=true"})
 @DisabledInNativeImage // Without this the native tests in the OtelSpringStarterSmokeTest class will

smoke-tests-otel-starter/spring-boot-3/spring-boot-non-reactive-3/src/test/java/io/opentelemetry/spring/smoketest/OtelSpringStarterSmokeTest.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.spring.smoketest;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest(
+    classes = {
+      OtelSpringStarterSmokeTestApplication.class,
+      AbstractOtelSpringStarterSmokeTest.TestConfiguration.class,
+      SpringSmokeOtelConfiguration.class
+    },
+    webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
+    properties = {
+      // The headers are simply set here to make sure that headers can be parsed
+      "otel.exporter.otlp.headers.c=3"
+    })
+class OtelSpringStarterSmokeTest extends AbstractOtelSpringStarterSmokeTest {
+
+  @Test
+  void restClient() {
+    assertClient(OtelSpringStarterSmokeTestController.REST_CLIENT);
+  }
+}

smoke-tests-otel-starter/spring-boot-3/src/test/java/io/opentelemetry/smoketest/OtelSpringStarterUserDataSourceBeanTest.java → smoke-tests-otel-starter/spring-boot-3/spring-boot-non-reactive-3/src/test/java/io/opentelemetry/spring/smoketest/OtelSpringStarterUserDataSourceBeanTest.java

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-package io.opentelemetry.smoketest;
+package io.opentelemetry.spring.smoketest;
 
 import org.junit.jupiter.api.condition.DisabledInNativeImage;
 import org.springframework.test.context.ActiveProfiles;

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

@@ -0,0 +1,20 @@
+plugins {
+  id("otel.java-conventions")
+  id("org.springframework.boot") version "2.7.18"
+}
+
+description = "smoke-tests-otel-starter-spring-boot-common"
+
+dependencies {
+  // spring dependencies are compile only to enable testing against different versions of spring
+  compileOnly(platform(org.springframework.boot.gradle.plugin.SpringBootPlugin.BOM_COORDINATES))
+  compileOnly("org.springframework.boot:spring-boot-starter-web")
+  compileOnly("org.springframework.boot:spring-boot-starter-test")
+  compileOnly("org.springframework.boot:spring-boot-starter-data-jdbc")
+  compileOnly("org.apache.commons:commons-dbcp2")
+
+  api(project(":smoke-tests-otel-starter:spring-smoke-testing"))
+
+  implementation("io.opentelemetry:opentelemetry-extension-trace-propagators")
+  implementation(project(":instrumentation:spring:starters:spring-boot-starter"))
+}

smoke-tests-otel-starter/spring-boot-3/src/test/java/io/opentelemetry/smoketest/OtelSpringStarterSmokeTest.java → smoke-tests-otel-starter/spring-boot-common/src/main/java/io/opentelemetry/spring/smoketest/AbstractOtelSpringStarterSmokeTest.java

@@ -3,11 +3,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-package io.opentelemetry.smoketest;
+package io.opentelemetry.spring.smoketest;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-import io.opentelemetry.api.OpenTelemetry;
 import io.opentelemetry.api.common.AttributeKey;
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.SpanKind;
@@ -26,20 +25,13 @@ import io.opentelemetry.semconv.UrlAttributes;
 import io.opentelemetry.semconv.incubating.CodeIncubatingAttributes;
 import io.opentelemetry.semconv.incubating.DbIncubatingAttributes;
 import io.opentelemetry.semconv.incubating.ServiceIncubatingAttributes;
-import io.opentelemetry.spring.smoketest.AbstractSpringStarterSmokeTest;
-import io.opentelemetry.spring.smoketest.OtelSpringStarterSmokeTestApplication;
-import io.opentelemetry.spring.smoketest.OtelSpringStarterSmokeTestController;
-import io.opentelemetry.spring.smoketest.SpringSmokeOtelConfiguration;
-import io.opentelemetry.spring.smoketest.SpringSmokeTestRunner;
 import java.util.Collections;
 import org.assertj.core.api.AbstractCharSequenceAssert;
 import org.assertj.core.api.AbstractIterableAssert;
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.MethodOrderer;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestMethodOrder;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.boot.test.web.client.TestRestTemplate;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -49,23 +41,9 @@ import org.springframework.core.env.Environment;
 /**
  * This test class enforces the order of the tests to make sure that {@link #shouldSendTelemetry()},
  * which asserts the telemetry data from the application startup, is executed first.
- *
- * <p>The exporters are not reset using {@link org.junit.jupiter.api.BeforeEach}, because it would
- * prevent the telemetry data from the application startup to be asserted.
  */
-@SpringBootTest(
-    classes = {
-      OtelSpringStarterSmokeTestApplication.class,
-      OtelSpringStarterSmokeTest.TestConfiguration.class,
-      SpringSmokeOtelConfiguration.class
-    },
-    webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
-    properties = {
-      // The headers are simply set here to make sure that headers can be parsed
-      "otel.exporter.otlp.headers.c=3"
-    })
 @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
-class OtelSpringStarterSmokeTest extends AbstractSpringStarterSmokeTest {
+class AbstractOtelSpringStarterSmokeTest extends AbstractSpringStarterSmokeTest {
 
   @Autowired private TestRestTemplate testRestTemplate;
 
@@ -74,13 +52,6 @@ class OtelSpringStarterSmokeTest extends AbstractSpringStarterSmokeTest {
   @Autowired private OtelResourceProperties otelResourceProperties;
   @Autowired private OtlpExporterProperties otlpExporterProperties;
 
-  @Autowired OpenTelemetry openTelemetry;
-
-  @BeforeEach
-  void initOpenTelemetry() {
-    testing = new SpringSmokeTestRunner(openTelemetry);
-  }
-
   @Configuration(proxyBeanMethods = false)
   static class TestConfiguration {
 
@@ -188,12 +159,7 @@ class OtelSpringStarterSmokeTest extends AbstractSpringStarterSmokeTest {
     assertClient(OtelSpringStarterSmokeTestController.REST_TEMPLATE);
   }
 
-  @Test
-  void restClient() {
-    assertClient(OtelSpringStarterSmokeTestController.REST_CLIENT);
-  }
-
-  private void assertClient(String url) {
+  protected void assertClient(String url) {
     testing.clearAllExportedData();
 
     testRestTemplate.getForObject(url, String.class);

smoke-tests-otel-starter/spring-boot-3/src/main/java/io/opentelemetry/spring/smoketest/OtelSpringStarterSmokeTestController.java → smoke-tests-otel-starter/spring-boot-common/src/main/java/io/opentelemetry/spring/smoketest/OtelSpringStarterSmokeTestController.java

@@ -13,7 +13,6 @@ import org.springframework.boot.web.client.RestTemplateBuilder;
 import org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RestController;
-import org.springframework.web.client.RestClient;
 import org.springframework.web.client.RestTemplate;
 
 @RestController
@@ -23,22 +22,23 @@ public class OtelSpringStarterSmokeTestController {
   public static final String REST_CLIENT = "/rest-client";
   public static final String REST_TEMPLATE = "/rest-template";
   public static final String TEST_HISTOGRAM = "histogram-test-otel-spring-starter";
-  public static final String METER_SCOPE_NAME =
-      OtelSpringStarterSmokeTestApplication.class.getName();
+  public static final String METER_SCOPE_NAME = "scope";
   private final LongHistogram histogram;
   private final Optional<RestTemplate> restTemplate;
-  private final Optional<RestClient> restClient;
+  private final Optional<ServletWebServerApplicationContext> server;
 
   public OtelSpringStarterSmokeTestController(
       OpenTelemetry openTelemetry,
-      RestClient.Builder restClientBuilder,
       RestTemplateBuilder restTemplateBuilder,
       Optional<ServletWebServerApplicationContext> server) {
+    this.server = server;
     Meter meter = openTelemetry.getMeter(METER_SCOPE_NAME);
     histogram = meter.histogramBuilder(TEST_HISTOGRAM).ofLongs().build();
-    Optional<String> rootUri = server.map(s -> "http://localhost:" + s.getWebServer().getPort());
-    restClient = rootUri.map(uri -> restClientBuilder.baseUrl(uri).build());
-    restTemplate = rootUri.map(uri -> restTemplateBuilder.rootUri(uri).build());
+    restTemplate = getRootUri().map(uri -> restTemplateBuilder.rootUri(uri).build());
+  }
+
+  public Optional<String> getRootUri() {
+    return server.map(s -> "http://localhost:" + s.getWebServer().getPort());
   }
 
   @GetMapping(PING)
@@ -47,13 +47,6 @@ public class OtelSpringStarterSmokeTestController {
     return "pong";
   }
 
-  @GetMapping(REST_CLIENT)
-  public String restClient() {
-    return restClient
-        .map(c -> c.get().uri(PING).retrieve().body(String.class))
-        .orElseThrow(() -> new IllegalStateException("RestClient not available"));
-  }
-
   @GetMapping(REST_TEMPLATE)
   public String restTemplate() {
     return restTemplate

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

@@ -0,0 +1,29 @@
+plugins {
+  id("otel.java-conventions")
+  id("org.springframework.boot") version "2.7.18"
+}
+
+description = "smoke-tests-otel-starter-spring-boot-reactive-2"
+
+dependencies {
+  implementation(project(":instrumentation:spring:starters:spring-boot-starter"))
+  implementation(platform(org.springframework.boot.gradle.plugin.SpringBootPlugin.BOM_COORDINATES))
+
+  implementation(project(":smoke-tests-otel-starter:spring-boot-reactive-common"))
+  implementation("org.springframework.boot:spring-boot-starter-webflux")
+
+  testImplementation("org.springframework.boot:spring-boot-starter-test")
+  testImplementation("io.projectreactor:reactor-test")
+}
+
+springBoot {
+  mainClass = "io.opentelemetry.spring.smoketest.OtelReactiveSpringStarterSmokeTestApplication"
+}
+
+configurations.configureEach {
+  resolutionStrategy {
+    // our dependency management pins to a version that is not compatible with spring boot 2.7
+    force("ch.qos.logback:logback-classic:1.2.13")
+    force("org.slf4j:slf4j-api:1.7.36")
+  }
+}

smoke-tests-otel-starter/spring-boot-reactive-2/src/test/java/io/opentelemetry/spring/smoketest/OtelReactiveSpringStarterSmokeTest.java

@@ -0,0 +1,8 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.spring.smoketest;
+
+class OtelReactiveSpringStarterSmokeTest extends AbstractOtelReactiveSpringStarterSmokeTest {}

smoke-tests-otel-starter/spring-boot-3-reactive/build.gradle.kts → smoke-tests-otel-starter/spring-boot-reactive-3/build.gradle.kts

@@ -4,7 +4,7 @@ plugins {
   id("org.graalvm.buildtools.native")
 }
 
-description = "smoke-tests-otel-starter-spring-boot-3-reactive"
+description = "smoke-tests-otel-starter-spring-boot-reactive-3"
 
 otelJava {
   minJavaVersionSupported.set(JavaVersion.VERSION_17)
@@ -14,18 +14,18 @@ dependencies {
   implementation(project(":instrumentation:spring:starters:spring-boot-starter"))
   implementation(platform(org.springframework.boot.gradle.plugin.SpringBootPlugin.BOM_COORDINATES))
 
+  implementation(project(":smoke-tests-otel-starter:spring-boot-reactive-common"))
   implementation("org.springframework.boot:spring-boot-starter-webflux")
 
   testImplementation("org.springframework.boot:spring-boot-starter-test")
   testImplementation("io.projectreactor:reactor-test")
-  testImplementation(project(":smoke-tests-otel-starter:spring-smoke-testing"))
+}
+
+springBoot {
+  mainClass = "io.opentelemetry.spring.smoketest.OtelReactiveSpringStarterSmokeTestApplication"
 }
 
 tasks {
-  test {
-    // suppress warning about byte-buddy-agent being loaded dynamically
-    jvmArgs("-XX:+EnableDynamicAgentLoading")
-  }
   compileAotJava {
     with(options) {
       compilerArgs.add("-Xlint:-deprecation,-unchecked,none")

smoke-tests-otel-starter/spring-boot-reactive-3/src/test/java/io/opentelemetry/spring/smoketest/OtelReactiveSpringStarterSmokeTest.java

@@ -0,0 +1,8 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.spring.smoketest;
+
+class OtelReactiveSpringStarterSmokeTest extends AbstractOtelReactiveSpringStarterSmokeTest {}

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

@@ -0,0 +1,15 @@
+plugins {
+  id("otel.java-conventions")
+  id("org.springframework.boot") version "2.7.18"
+}
+
+description = "smoke-tests-otel-starter-spring-boot-reactive-common"
+
+dependencies {
+  // spring dependencies are compile only to enable testing against different versions of spring
+  compileOnly(platform(org.springframework.boot.gradle.plugin.SpringBootPlugin.BOM_COORDINATES))
+  compileOnly("org.springframework.boot:spring-boot-starter-web")
+  compileOnly("org.springframework.boot:spring-boot-starter-webflux")
+  compileOnly("org.springframework.boot:spring-boot-starter-test")
+  api(project(":smoke-tests-otel-starter:spring-smoke-testing"))
+}

smoke-tests-otel-starter/spring-boot-3-reactive/src/test/java/io/opentelemetry/smoketest/OtelReactiveSpringStarterSmokeTest.java → smoke-tests-otel-starter/spring-boot-reactive-common/src/main/java/io/opentelemetry/spring/smoketest/AbstractOtelReactiveSpringStarterSmokeTest.java

@@ -3,17 +3,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-package io.opentelemetry.smoketest;
+package io.opentelemetry.spring.smoketest;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 import io.opentelemetry.api.trace.SpanKind;
 import io.opentelemetry.semconv.HttpAttributes;
 import io.opentelemetry.semconv.UrlAttributes;
-import io.opentelemetry.spring.smoketest.AbstractSpringStarterSmokeTest;
-import io.opentelemetry.spring.smoketest.OtelReactiveSpringStarterSmokeTestApplication;
-import io.opentelemetry.spring.smoketest.OtelReactiveSpringStarterSmokeTestController;
-import io.opentelemetry.spring.smoketest.SpringSmokeOtelConfiguration;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -27,7 +23,7 @@ import org.springframework.web.reactive.function.client.WebClient;
       SpringSmokeOtelConfiguration.class
     },
     webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
-class OtelReactiveSpringStarterSmokeTest extends AbstractSpringStarterSmokeTest {
+public class AbstractOtelReactiveSpringStarterSmokeTest extends AbstractSpringStarterSmokeTest {
 
   @LocalServerPort int serverPort;
 

smoke-tests-otel-starter/spring-smoke-testing/build.gradle.kts

@@ -1,18 +1,15 @@
 plugins {
   id("otel.java-conventions")
+  id("org.springframework.boot") version "2.7.18"
 }
 
-otelJava {
-  minJavaVersionSupported.set(JavaVersion.VERSION_17)
-}
-
-val versions: Map<String, String> by project
-val springBootVersion = versions["org.springframework.boot"]
+description = "smoke-tests-otel-starter-spring-smoke-testing"
 
 dependencies {
-  // spring depdenencies are compile only to enable testing against different versions of spring
-  compileOnly("org.springframework.boot:spring-boot-starter:$springBootVersion")
-  compileOnly("org.springframework.boot:spring-boot-starter-test:$springBootVersion")
+  // spring dependencies are compile only to enable testing against different versions of spring
+  compileOnly(platform(org.springframework.boot.gradle.plugin.SpringBootPlugin.BOM_COORDINATES))
+  compileOnly("org.springframework.boot:spring-boot-starter")
+  compileOnly("org.springframework.boot:spring-boot-starter-test")
   api(project(":testing-common"))
   api(project(":instrumentation:spring:spring-boot-autoconfigure"))
   api("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure-spi")

smoke-tests-otel-starter/spring-smoke-testing/src/main/java/io/opentelemetry/spring/smoketest/AbstractSpringStarterSmokeTest.java

@@ -18,18 +18,23 @@ import org.springframework.boot.test.system.OutputCaptureExtension;
 @ExtendWith(OutputCaptureExtension.class)
 public abstract class AbstractSpringStarterSmokeTest {
 
-  @Autowired OpenTelemetry openTelemetry;
+  @Autowired protected OpenTelemetry openTelemetry;
 
   protected SpringSmokeTestRunner testing;
 
   @BeforeEach
-  void initOpenTelemetry() {
+  void setUpTesting() {
     testing = new SpringSmokeTestRunner(openTelemetry);
   }
 
   @AfterEach
   void checkSpringLogs(CapturedOutput output) {
     // warnings are emitted if the auto-configuration have non-fatal problems
-    assertThat(output).doesNotContain("WARN").doesNotContain("ERROR");
+    assertThat(output)
+        // only look for WARN and ERROR log level, e.g. [Test worker] WARN
+        .doesNotContain("] WARN")
+        .doesNotContain("] ERROR")
+        // not a warning in Spring Boot 2
+        .doesNotContain("is not eligible for getting processed by all BeanPostProcessors");
   }
 }

smoke-tests-otel-starter/spring-smoke-testing/src/main/java/io/opentelemetry/spring/smoketest/SpringSmokeOtelConfiguration.java

@@ -5,6 +5,7 @@
 
 package io.opentelemetry.spring.smoketest;
 
+import com.google.common.collect.ImmutableMap;
 import io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizerProvider;
 import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
 import io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogRecordExporterProvider;
@@ -28,7 +29,7 @@ public class SpringSmokeOtelConfiguration {
   }
 
   private static Map<String, String> getProperties() {
-    return Map.of(
+    return ImmutableMap.of(
         // We set the export interval of the metrics to 100 ms. The default value is 1 minute.
         "otel.metric.export.interval",
         "100",