test(spring-boot): Move the Boot 4 Kafka test into the module (#6298)

Ports the Boot 4 sample's KafkaQueueSystemTest to the integrationTest
suite with @embeddedkafka, as for Boot 3. Spring Boot 4 needs its Kafka
starter for the auto-configuration, and spring-kafka-test comes from the
Boot BOM like spring-kafka.

The Boot 4 sample has no system tests left, so it comes off the
system-test runner, the backend workflow and the Spring Boot 4 matrix.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: runningcode

.github/workflows/spring-boot-4-matrix.yml

@@ -71,8 +71,6 @@ jobs:
       - name: Build sample artifacts
         run: |
           ./gradlew \
-            :sentry-samples:sentry-samples-spring-boot-4:bootJar \
-            :sentry-samples:sentry-samples-spring-boot-4:testClasses \
             :sentry-samples:sentry-samples-spring-boot-4-webflux:bootJar \
             :sentry-samples:sentry-samples-spring-boot-4-webflux:testClasses \
             :sentry-samples:sentry-samples-spring-boot-4-opentelemetry:bootJar \
@@ -86,13 +84,6 @@ jobs:
       - name: Test sentry-spring-boot-4 integration suite
         run: ./gradlew :sentry-spring-boot-4:integrationTest
 
-      - name: Run sentry-samples-spring-boot-4
-        run: |
-          python3 test/system-test-runner.py test \
-            --module "sentry-samples-spring-boot-4" \
-            --agent false \
-            --auto-init "true"
-
       - name: Run sentry-samples-spring-boot-4-webflux
         run: |
           python3 test/system-test-runner.py test \

.github/workflows/system-tests-backend.yml

@@ -67,9 +67,6 @@ jobs:
           - sample: "sentry-samples-jul"
             agent: "false"
             agent-auto-init: "true"
-          - sample: "sentry-samples-spring-boot-4"
-            agent: "false"
-            agent-auto-init: "true"
           - sample: "sentry-samples-spring-boot-4-log4j2"
             agent: "false"
             agent-auto-init: "true"

gradle/libs.versions.toml

@@ -223,6 +223,7 @@ spring-kafka2 = { module = "org.springframework.kafka:spring-kafka", version = "
 spring-kafka3 = { module = "org.springframework.kafka:spring-kafka", version.ref = "springKafka3" }
 spring-kafka3-test = { module = "org.springframework.kafka:spring-kafka-test", version.ref = "springKafka3" }
 spring-kafka4 = { module = "org.springframework.kafka:spring-kafka" }
+spring-kafka4-test = { module = "org.springframework.kafka:spring-kafka-test" }
 kafka-clients = { module = "org.apache.kafka:kafka-clients", version = "3.8.1" }
 springboot4-otel = { module = "io.opentelemetry.instrumentation:opentelemetry-spring-boot-starter", version.ref = "otelInstrumentation" }
 springboot4-resttestclient = { module = "org.springframework.boot:spring-boot-resttestclient", version.ref = "springboot4" }

sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts

@@ -6,7 +6,6 @@ plugins {
   alias(libs.plugins.spring.dependency.management)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
-  id("io.sentry.systemtest")
 }
 
 group = "io.sentry.sample.spring-boot-4"
@@ -61,35 +60,4 @@ dependencies {
   // database query tracing
   implementation(projects.sentryJdbc)
   runtimeOnly(libs.hsqldb)
-
-  testImplementation(kotlin(Config.kotlinStdLib))
-  testImplementation(projects.sentry)
-  testImplementation(projects.sentrySystemTestSupport)
-  testImplementation(libs.apollo3.kotlin)
-  testImplementation(libs.kotlin.test.junit)
-  testImplementation(libs.slf4j2.api)
-  testImplementation(libs.springboot4.starter.test) {
-    exclude(group = "org.junit.vintage", module = "junit-vintage-engine")
-  }
-  testImplementation("ch.qos.logback:logback-classic:1.5.16")
-  testImplementation("ch.qos.logback:logback-core:1.5.16")
-}
-
-tasks.register<Test>("systemTest").configure {
-  group = "verification"
-  description = "Runs the System tests"
-
-  val test = project.extensions.getByType<SourceSetContainer>()["test"]
-  testClassesDirs = test.output.classesDirs
-  classpath = test.runtimeClasspath
-
-  maxParallelForks = 1
-
-  filter { includeTestsMatching("io.sentry.systemtest*") }
-}
-
-tasks.named("test").configure {
-  require(this is Test)
-
-  filter { excludeTestsMatching("io.sentry.systemtest.*") }
 }

sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/DummyTest.kt

@@ -169,6 +169,7 @@ testing {
         implementation(projects.sentryAsyncProfiler)
         implementation(projects.sentryGraphql22)
         implementation(projects.sentryJdbc)
+        implementation(projects.sentryKafka)
         implementation(projects.sentryLogback)
         implementation(projects.sentryOkhttp)
         implementation(projects.sentryTestSupport)
@@ -184,11 +185,13 @@ testing {
         implementation(libs.springboot4.starter.cache)
         implementation(libs.springboot4.starter.graphql)
         implementation(libs.springboot4.starter.jdbc)
+        implementation(libs.springboot4.starter.kafka)
         implementation(libs.springboot4.starter.restclient)
         implementation(libs.springboot4.starter.test)
         implementation(libs.springboot4.starter.web)
         implementation(libs.springboot4.starter.webclient)
         implementation(libs.springboot4.starter.webflux)
+        implementation(libs.spring.kafka4.test)
         runtimeOnly(libs.hsqldb)
       }
     }

sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/KafkaQueueSystemTest.kt

@@ -7,18 +7,22 @@ import org.springframework.boot.restclient.RestTemplateBuilder
 import org.springframework.boot.resttestclient.TestRestTemplate
 import org.springframework.boot.test.context.SpringBootTest
 import org.springframework.boot.test.web.server.LocalServerPort
+import org.springframework.kafka.test.context.EmbeddedKafka
 import org.springframework.test.context.DynamicPropertyRegistry
 import org.springframework.test.context.DynamicPropertySource
 import org.springframework.test.context.junit4.SpringRunner
 
 /**
  * Drives [IntegrationTestApplication] over HTTP and asserts what reaches [server].
  *
- * Subclasses share one application context and one server, so the app starts once per suite.
- * Envelopes that arrive late can outlive [server]'s reset, so tests match on values only they
- * produce.
+ * Subclasses share one application context, one server and one Kafka broker, so each starts once
+ * per suite. Envelopes that arrive late can outlive [server]'s reset, so tests match on values only
+ * they produce.
  */
 @RunWith(SpringRunner::class)
+// An in-JVM KRaft broker, so no Docker is needed. As part of the context, it starts before the
+// app's Kafka listener connects and stops after it.
+@EmbeddedKafka(topics = [KAFKA_TOPIC], bootstrapServersProperty = "spring.kafka.bootstrap-servers")
 @SpringBootTest(
   classes = [IntegrationTestApplication::class],
   webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
@@ -27,12 +31,14 @@ import org.springframework.test.context.junit4.SpringRunner
       "sentry.traces-sample-rate=1.0",
       "sentry.clients.ok-http-enabled=true",
       "sentry.enable-cache-tracing=true",
+      "sentry.enable-queue-tracing=true",
       "sentry.logs.enabled=true",
       "sentry.profile-session-sample-rate=1.0",
       "sentry.profile-lifecycle=TRACE",
       "sentry.profiling-traces-dir-path=\${java.io.tmpdir}/sentry-integration-test/profiling-traces",
       "spring.datasource.url=jdbc:p6spy:hsqldb:mem:testdb",
       "spring.datasource.driver-class-name=com.p6spy.engine.spy.P6SpyDriver",
+      "spring.kafka.consumer.auto-offset-reset=earliest",
     ],
 )
 abstract class IntegrationTest {

sentry-samples/sentry-samples-spring-boot-4/src/test/resources/logback.xml

@@ -0,0 +1,28 @@
+package io.sentry.spring.boot4.integrationtest
+
+import org.springframework.kafka.annotation.KafkaListener
+import org.springframework.kafka.core.KafkaTemplate
+import org.springframework.stereotype.Component
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RequestParam
+import org.springframework.web.bind.annotation.RestController
+
+const val KAFKA_TOPIC = "sentry-topic"
+
+@RestController
+@RequestMapping("/kafka")
+class KafkaController(private val kafkaTemplate: KafkaTemplate<String, String>) {
+  @GetMapping("/produce")
+  fun produce(@RequestParam message: String): String {
+    kafkaTemplate.send(KAFKA_TOPIC, message)
+    return "Message sent: $message"
+  }
+}
+
+@Component
+class KafkaConsumer {
+  /** Does nothing with the message; Sentry traces the listener invocation. */
+  @KafkaListener(topics = [KAFKA_TOPIC], groupId = "sentry-integration-test")
+  fun listen(message: String) {}
+}