Add Spring Boot 3.3 smoke tests

Author: smola

dd-smoke-tests/spring-boot-3.3-webmvc/application/.gitignore

@@ -0,0 +1,6 @@
+# Ignore all project specific gradle directories/files
+.gradle
+gradle
+build
+gradlew
+gradlew.bat

dd-smoke-tests/spring-boot-3.3-webmvc/application/build.gradle

@@ -0,0 +1,33 @@
+plugins {
+  id 'java'
+  id 'org.springframework.boot' version '3.3.5'
+  id 'io.spring.dependency-management' version '1.0.14.RELEASE'
+  id "com.diffplug.spotless" version "6.13.0"
+}
+
+def sharedRootDir = "$rootDir/../../../"
+def sharedConfigDirectory = "$sharedRootDir/gradle"
+rootProject.ext.sharedConfigDirectory = sharedConfigDirectory
+
+apply from: "$sharedConfigDirectory/repositories.gradle"
+apply from: "$sharedConfigDirectory/spotless.gradle"
+
+if (hasProperty('appBuildDir')) {
+  buildDir = property('appBuildDir')
+}
+
+version = ""
+
+dependencies {
+  implementation 'org.springframework.boot:spring-boot-starter-web'
+  implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+  implementation group: 'com.h2database', name: 'h2', version: '2.1.214'
+  compileOnly group:"com.google.code.findbugs", name:"jsr305", version:"3.0.2"
+
+
+  if (hasProperty('apiJar')) {
+    implementation files(property('apiJar'))
+  } else {
+    implementation "com.datadoghq:dd-trace-api:1.2.0"
+  }
+}

dd-smoke-tests/spring-boot-3.3-webmvc/application/settings.gradle

@@ -0,0 +1,22 @@
+pluginManagement {
+  repositories {
+    mavenLocal()
+    mavenCentral()
+    gradlePluginPortal()
+  }
+}
+
+def isCI = System.getenv("CI") != null
+
+// Don't pollute the dependency cache with the build cache
+if (isCI) {
+  def sharedRootDir = "$rootDir/../../../"
+  buildCache {
+    local {
+      // This needs to line up with the code in the outer project settings.gradle
+      directory = "$sharedRootDir/workspace/build-cache"
+    }
+  }
+}
+
+rootProject.name='webmvc-3.3-smoketest'

dd-smoke-tests/spring-boot-3.3-webmvc/application/src/main/java/datadog/smoketest/springboot/AppInitializer.java

@@ -0,0 +1,22 @@
+package datadog.smoketest.springboot;
+
+import datadog.smoketest.springboot.model.Fruit;
+import datadog.smoketest.springboot.repository.FruitRepository;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AppInitializer implements InitializingBean {
+  private final FruitRepository fruitRepository;
+
+  public AppInitializer(FruitRepository fruitRepository) {
+    this.fruitRepository = fruitRepository;
+  }
+
+  @Override
+  public void afterPropertiesSet() throws Exception {
+    fruitRepository.save(new Fruit("apple"));
+    fruitRepository.save(new Fruit("banana"));
+    fruitRepository.save(new Fruit("orange"));
+  }
+}

dd-smoke-tests/spring-boot-3.3-webmvc/application/src/main/java/datadog/smoketest/springboot/SpringbootApplication.java

@@ -0,0 +1,14 @@
+package datadog.smoketest.springboot;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+
+@SpringBootApplication
+@EnableJpaRepositories
+public class SpringbootApplication {
+
+  public static void main(final String[] args) {
+    SpringApplication.run(SpringbootApplication.class, args);
+  }
+}

dd-smoke-tests/spring-boot-3.3-webmvc/application/src/main/java/datadog/smoketest/springboot/controller/FruitController.java

@@ -0,0 +1,33 @@
+package datadog.smoketest.springboot.controller;
+
+import datadog.smoketest.springboot.model.Fruit;
+import datadog.smoketest.springboot.repository.FruitRepository;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/fruits")
+public class FruitController {
+
+  private final FruitRepository fruitRepository;
+
+  public FruitController(FruitRepository fruitRepository) {
+    this.fruitRepository = fruitRepository;
+  }
+
+  @GetMapping
+  public Iterable<Fruit> listFruits() {
+    return fruitRepository.findAll();
+  }
+
+  @GetMapping("/{name}")
+  public ResponseEntity<Fruit> findOneFruit(@PathVariable("name") final String name) {
+    return fruitRepository
+        .findByName(name)
+        .map(ResponseEntity::ok)
+        .orElseGet(() -> ResponseEntity.notFound().build());
+  }
+}

dd-smoke-tests/spring-boot-3.3-webmvc/application/src/main/java/datadog/smoketest/springboot/model/Fruit.java

@@ -0,0 +1,58 @@
+package datadog.smoketest.springboot.model;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import java.util.Objects;
+import javax.annotation.Nonnull;
+
+@Entity
+@Table
+public class Fruit {
+
+  public Fruit() {}
+
+  public Fruit(@Nonnull String name) {
+    this.name = name;
+  }
+
+  @Id @GeneratedValue private Long id;
+
+  @Column(nullable = false)
+  private String name;
+
+  public Long getId() {
+    return id;
+  }
+
+  public void setId(Long id) {
+    this.id = id;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    Fruit fruit = (Fruit) o;
+    return Objects.equals(id, fruit.id);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(id);
+  }
+}

dd-smoke-tests/spring-boot-3.3-webmvc/application/src/main/java/datadog/smoketest/springboot/repository/FruitRepository.java

@@ -0,0 +1,12 @@
+package datadog.smoketest.springboot.repository;
+
+import datadog.smoketest.springboot.model.Fruit;
+import java.util.Optional;
+import javax.annotation.Nonnull;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface FruitRepository extends CrudRepository<Fruit, Long> {
+  Optional<Fruit> findByName(@Nonnull final String name);
+}

dd-smoke-tests/spring-boot-3.3-webmvc/application/src/main/resources/application.properties

@@ -0,0 +1,7 @@
+logging.level.root=INFO
+spring.datasource.url=jdbc:h2:mem:fruitdb
+spring.datasource.driverClassName=org.h2.Driver
+spring.datasource.username=sa
+spring.datasource.password=password
+spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
+spring.jpa.generate-ddl=true

dd-smoke-tests/spring-boot-3.3-webmvc/build.gradle

@@ -0,0 +1,61 @@
+ext {
+  minJavaVersionForTests = JavaVersion.VERSION_17
+}
+
+apply from: "$rootDir/gradle/java.gradle"
+
+description = 'Spring Boot 3.3 WebMvc Smoke Tests.'
+
+dependencies {
+  testImplementation project(':dd-smoke-tests')
+}
+
+def appDir = "$projectDir/application"
+def appBuildDir = "$buildDir/application"
+def isWindows = System.getProperty("os.name").toLowerCase().contains("win")
+def gradlewCommand = isWindows ? 'gradlew.bat' : 'gradlew'
+
+// define the task that builds the project
+tasks.register('webmvcBuild3', Exec) {
+  workingDir "$appDir"
+  def toolchain17 = getJavaLauncherFor(17).get()
+  environment += ["GRADLE_OPTS": "-Dorg.gradle.jvmargs='-Xmx512M'", "JAVA_HOME": "$toolchain17.metadata.installationPath"]
+  commandLine "$rootDir/${gradlewCommand}", "bootJar", "--no-daemon", "--max-workers=4", "-PappBuildDir=$appBuildDir", "-PapiJar=${project(':dd-trace-api').tasks.jar.archiveFile.get()}"
+
+  outputs.cacheIf { true }
+
+  outputs.dir(appBuildDir)
+    .withPropertyName("applicationJar")
+
+  inputs.files(fileTree(appDir) {
+    include '**/*'
+    exclude '.gradle/**'
+  })
+  .withPropertyName("application")
+  .withPathSensitivity(PathSensitivity.RELATIVE)
+}
+
+compileTestGroovy {
+  dependsOn project(':dd-trace-api').tasks.named("jar")
+}
+
+tasks.named("compileTestGroovy").configure {
+  dependsOn 'webmvcBuild3'
+  outputs.upToDateWhen {
+    !webmvcBuild3.didWork
+  }
+}
+
+tasks.withType(Test).configureEach {
+  jvmArgs "-Ddatadog.smoketest.springboot.uberJar.path=$appBuildDir/libs/webmvc-3.3-smoketest.jar"
+}
+
+spotless {
+  java {
+    target "**/*.java"
+  }
+
+  groovyGradle {
+    target '*.gradle', "**/*.gradle"
+  }
+}

dd-smoke-tests/spring-boot-3.3-webmvc/src/test/groovy/SpringBootWebmvcIntegrationTest.groovy

@@ -0,0 +1,82 @@
+import datadog.smoketest.AbstractServerSmokeTest
+import okhttp3.Request
+
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.regex.Pattern
+
+class SpringBootWebmvcIntegrationTest extends AbstractServerSmokeTest {
+
+  @Override
+  ProcessBuilder createProcessBuilder() {
+    String springBootShadowJar = System.getProperty("datadog.smoketest.springboot.uberJar.path")
+
+    List<String> command = new ArrayList<>()
+    command.add(javaPath())
+    command.addAll(defaultJavaProperties)
+    command.addAll((String[]) [
+      "-Ddd.writer.type=MultiWriter:TraceStructureWriter:${output.getAbsolutePath()}:includeResource,DDAgentWriter",
+      "-jar",
+      springBootShadowJar,
+      "--server.port=${httpPort}"
+    ])
+    ProcessBuilder processBuilder = new ProcessBuilder(command)
+    processBuilder.directory(new File(buildDirectory))
+  }
+
+  @Override
+  File createTemporaryFile() {
+    return File.createTempFile("trace-structure-docs", "out")
+  }
+
+  @Override
+  protected Set<String> expectedTraces() {
+    return [
+      "\\[servlet\\.request:GET /fruits\\[spring\\.handler:FruitController\\.listFruits\\[repository\\.operation:FruitRepository\\.findAll\\[h2\\.query:.*",
+      "\\[servlet\\.request:GET /fruits/\\{name}\\[spring\\.handler:FruitController\\.findOneFruit\\[repository\\.operation:FruitRepository\\.findByName\\[h2\\.query:.*"
+    ]
+  }
+
+  @Override
+  protected Set<String> assertTraceCounts(Set<String> expected, Map<String, AtomicInteger> traceCounts) {
+    List<Pattern> remaining = expected.collect { Pattern.compile(it) }.toList()
+    for (def i = remaining.size() - 1; i >= 0; i--) {
+      for (Map.Entry<String, AtomicInteger> entry : traceCounts.entrySet()) {
+        if (entry.getValue() > 0 && remaining.get(i).matcher(entry.getKey()).matches()) {
+          remaining.remove(i)
+          break
+        }
+      }
+    }
+    return remaining.collect { it.pattern() }.toSet()
+  }
+
+  def "find all fruits"() {
+    setup:
+    String url = "http://localhost:${httpPort}/fruits"
+
+    when:
+    def response = client.newCall(new Request.Builder().url(url).get().build()).execute()
+
+    then:
+    def responseBodyStr = response.body().string()
+    responseBodyStr != null
+    ["banana", "apple", "orange"].each { responseBodyStr.contains(it) }
+    waitForTraceCount(1)
+  }
+
+  def "find a banana"() {
+    setup:
+    String url = "http://localhost:${httpPort}/fruits/banana"
+
+    when:
+    def response = client.newCall(new Request.Builder().url(url).get().build()).execute()
+
+    then:
+    def responseBodyStr = response.body().string()
+    responseBodyStr != null
+    ["apple", "orange"].each { !responseBodyStr.contains(it) }
+    responseBodyStr.contains("banana")
+    waitForTraceCount(1)
+  }
+
+}

settings.gradle

@@ -134,6 +134,7 @@ include ':dd-smoke-tests:spring-boot-3.0-webflux'
 include ':dd-smoke-tests:spring-boot-2.3-webmvc-jetty'
 include ':dd-smoke-tests:spring-boot-2.6-webmvc'
 include ':dd-smoke-tests:spring-boot-3.0-webmvc'
+include ':dd-smoke-tests:spring-boot-3.3-webmvc'
 include ':dd-smoke-tests:spring-boot-rabbit'
 include ':dd-smoke-tests:spring-security'
 include ':dd-smoke-tests:springboot'