Call Sentry#close on JVM shutdown.

sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java

@@ -9,6 +9,7 @@
 import io.sentry.core.ILogger;
 import io.sentry.core.SendCachedEventFireAndForgetIntegration;
 import io.sentry.core.SendFireAndForgetEnvelopeSender;
+import io.sentry.core.SendFireAndForgetEventSender;
 import io.sentry.core.SentryLevel;
 import io.sentry.core.SentryOptions;
 import io.sentry.core.util.Objects;
@@ -115,6 +116,14 @@ private static void installDefaultIntegrations(
       final @NotNull IBuildInfoProvider buildInfoProvider,
       final @NotNull ILoadClass loadClass) {
 
+    options.addIntegration(
+        new SendCachedEventFireAndForgetIntegration(
+            new SendFireAndForgetEventSender(() -> options.getCacheDirPath())));
+
+    options.addIntegration(
+        new SendCachedEventFireAndForgetIntegration(
+            new SendFireAndForgetEnvelopeSender(() -> options.getSessionsPath())));
+
     // Integrations are registered in the same order. NDK before adding Watch outbox,
     // because sentry-native move files around and we don't want to watch that.
     final Class<?> sentryNdkClass = loadNdkIfAvailable(options, buildInfoProvider, loadClass);

sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt

@@ -13,6 +13,7 @@ import com.nhaarman.mockitokotlin2.verify
 import com.nhaarman.mockitokotlin2.whenever
 import io.sentry.core.ILogger
 import io.sentry.core.MainEventProcessor
+import io.sentry.core.SendCachedEventFireAndForgetIntegration
 import io.sentry.core.SentryLevel
 import io.sentry.core.SentryOptions
 import java.io.File
@@ -269,6 +270,16 @@ class AndroidOptionsInitializerTest {
         assertNotNull(actual)
     }
 
+    @Test
+    fun `SendCachedEventFireAndForgetIntegration added to integration list`() {
+        val sentryOptions = SentryAndroidOptions()
+        val mockContext = createMockContext()
+
+        AndroidOptionsInitializer.init(sentryOptions, mockContext)
+        val actual = sentryOptions.integrations.firstOrNull { it is SendCachedEventFireAndForgetIntegration }
+        assertNotNull(actual)
+    }
+
     @Test
     fun `When given Context returns a non null ApplicationContext, uses it`() {
         val sentryOptions = SentryAndroidOptions()

sentry-core/src/main/java/io/sentry/core/SendFireAndForgetEventSender.java

@@ -1,14 +1,16 @@
 package io.sentry.core;
 
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
-final class SendFireAndForgetEventSender
+@ApiStatus.Internal
+public final class SendFireAndForgetEventSender
     implements SendCachedEventFireAndForgetIntegration.SendFireAndForgetFactory {
 
   private final @NotNull SendCachedEventFireAndForgetIntegration.SendFireAndForgetDirPath
       sendFireAndForgetDirPath;
 
-  SendFireAndForgetEventSender(
+  public SendFireAndForgetEventSender(
       final @NotNull SendCachedEventFireAndForgetIntegration.SendFireAndForgetDirPath
               sendFireAndForgetDirPath) {
     this.sendFireAndForgetDirPath = sendFireAndForgetDirPath;

sentry-core/src/main/java/io/sentry/core/SentryOptions.java

@@ -1033,14 +1033,8 @@ public SentryOptions() {
     // if there's an error on the setup, we are able to capture it
     integrations.add(new UncaughtExceptionHandlerIntegration());
 
-    eventProcessors.add(new MainEventProcessor(this));
-
-    integrations.add(
-        new SendCachedEventFireAndForgetIntegration(
-            new SendFireAndForgetEventSender(() -> getCacheDirPath())));
+    integrations.add(new ShutdownHookIntegration(Runtime.getRuntime()));
 
-    integrations.add(
-        new SendCachedEventFireAndForgetIntegration(
-            new SendFireAndForgetEnvelopeSender(() -> getSessionsPath())));
+    eventProcessors.add(new MainEventProcessor(this));
   }
 }

sentry-core/src/main/java/io/sentry/core/ShutdownHookIntegration.java

@@ -0,0 +1,21 @@
+package io.sentry.core;
+
+import io.sentry.core.util.Objects;
+import org.jetbrains.annotations.NotNull;
+
+/** Registers hook that closes {@link Hub} when main thread shuts down. */
+public final class ShutdownHookIntegration implements Integration {
+
+  private final @NotNull Runtime runtime;
+
+  public ShutdownHookIntegration(final @NotNull Runtime runtime) {
+    this.runtime = Objects.requireNonNull(runtime, "Runtime is required");
+  }
+
+  @Override
+  public void register(@NotNull IHub hub, @NotNull SentryOptions options) {
+    Objects.requireNonNull(hub, "Hub is required");
+
+    runtime.addShutdownHook(new Thread(() -> hub.close()));
+  }
+}

sentry-core/src/test/java/io/sentry/core/SentryOptionsTest.kt

@@ -44,6 +44,11 @@ class SentryOptionsTest {
         assertTrue(SentryOptions().integrations.any { it is UncaughtExceptionHandlerIntegration })
     }
 
+    @Test
+    fun `when options is initialized, integrations contain ShutdownHookIntegration`() {
+        assertTrue(SentryOptions().integrations.any { it is ShutdownHookIntegration })
+    }
+
     @Test
     fun `when options is initialized, default maxBreadcrumb is 100`() =
         assertEquals(100, SentryOptions().maxBreadcrumbs)

sentry-core/src/test/java/io/sentry/core/ShutdownHookIntegrationTest.kt

@@ -0,0 +1,19 @@
+package io.sentry.core
+
+import com.nhaarman.mockitokotlin2.any
+import com.nhaarman.mockitokotlin2.mock
+import com.nhaarman.mockitokotlin2.verify
+import kotlin.test.Test
+
+class ShutdownHookIntegrationTest {
+
+    @Test
+    fun `registration attaches shutdown hook to runtime`() {
+        val runtime = mock<Runtime>()
+        val integration = ShutdownHookIntegration(runtime)
+
+        integration.register(NoOpHub.getInstance(), SentryOptions())
+
+        verify(runtime).addShutdownHook(any())
+    }
+}