test(core): Check that the shutdown hook delivers what an app reported before exiting

The console samples' system tests ran each sample in its own JVM,
asserted that it exited with 0 within 30 seconds, and relied on the
shutdown hook to send everything, because the samples never flush or
close Sentry. The in-process end-to-end tests flush explicitly, so
neither the clean exit nor the hook's flush was tested any more.

Run a small app in a child JVM that returns from main without flushing,
and check that it exits with 0 and that its event, log and metric
arrive.

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

Author: runningcode

sentry-test-support/src/main/kotlin/io/sentry/test/ChildJvmApp.kt

@@ -11,11 +11,12 @@ import kotlin.concurrent.thread
 
 /**
  * An app running in a child JVM, for apps that must not share the test's JVM, such as one with the
- * OpenTelemetry agent attached.
+ * OpenTelemetry agent attached or one whose exit is under test.
  *
- * The app writes the port it listens on to the file named by the `PORTFILE` environment variable,
- * which Spring Boot's `WebServerPortFileWriter` reads too. The app's output goes to the test's
- * standard output as it arrives, so Gradle's test report shows it with the test that was running.
+ * A server app writes the port it listens on to the file named by the `PORTFILE` environment
+ * variable, which Spring Boot's `WebServerPortFileWriter` reads too. The app's output goes to the
+ * test's standard output as it arrives, so Gradle's test report shows it with the test that was
+ * running.
  */
 class ChildJvmApp private constructor(private val process: Process, private val workDir: File) :
   Closeable {
@@ -37,6 +38,14 @@ class ChildJvmApp private constructor(private val process: Process, private val
     }
   }
 
+  /** Waits for the app to exit on its own and returns its exit code. */
+  fun awaitExit(timeoutSeconds: Long = 30): Int {
+    check(process.waitFor(timeoutSeconds, TimeUnit.SECONDS)) {
+      "App did not exit within ${timeoutSeconds}s"
+    }
+    return process.exitValue()
+  }
+
   override fun close() {
     process.destroyForcibly().waitFor()
     workDir.deleteRecursively()

sentry/src/test/java/io/sentry/ShutdownHookEndToEndTest.kt

@@ -0,0 +1,56 @@
+package io.sentry
+
+import com.google.common.truth.Truth.assertThat
+import io.sentry.test.ChildJvmApp
+import io.sentry.test.MockSentryServer
+import io.sentry.test.event
+import io.sentry.test.hasLogWithBody
+import io.sentry.test.hasMetric
+import io.sentry.test.logs
+import io.sentry.test.metrics
+import kotlin.test.AfterTest
+import kotlin.test.Test
+
+/**
+ * Runs an app in its own JVM that returns from `main` without flushing or closing Sentry, as most
+ * apps do, so only the shutdown hook can deliver what it reported.
+ */
+class ShutdownHookEndToEndTest {
+  private val server = MockSentryServer()
+
+  @AfterTest
+  fun teardown() {
+    server.close()
+  }
+
+  @Test
+  fun `the shutdown hook delivers what an app reported before it exited`() {
+    ChildJvmApp.start(
+        mainClass = ExitWithoutFlushApp::class.java.name,
+        classpath = System.getProperty("java.class.path"),
+        args = listOf(server.dsn),
+      )
+      .use { app ->
+        // A timeout here means a thread the SDK started kept the JVM from exiting.
+        assertThat(app.awaitExit()).isEqualTo(0)
+      }
+
+    server.awaitEnvelope { it.event()?.message?.formatted == "Reported before exit" }
+    server.awaitEnvelope { it.logs()?.hasLogWithBody("Logged before exit") == true }
+    server.awaitEnvelope { it.metrics()?.hasMetric("exitMetric", "counter", 1.0) == true }
+  }
+}
+
+/** Reports an event, a log and a metric, then returns without flushing or closing Sentry. */
+object ExitWithoutFlushApp {
+  @JvmStatic
+  fun main(args: Array<String>) {
+    Sentry.init {
+      it.dsn = args[0]
+      it.logs.isEnabled = true
+    }
+    Sentry.captureMessage("Reported before exit")
+    Sentry.logger().info("Logged before exit")
+    Sentry.metrics().count("exitMetric")
+  }
+}