Merge 0bd817c into ee35ac3

markushi · web-flow · commit 294dba246660 · 2025-12-03T15:49:38.000Z
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -49,6 +49,7 @@ SentryAndroid.init(
 ```
 
 </details>
+- Android: Flush logs when app enters background ([#4873](https://github.com/getsentry/sentry-java/pull/4873))
 
 
 ### Improvements
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidLoggerApi.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidLoggerApi.java
@@ -0,0 +1,49 @@
+package io.sentry.android.core;
+
+import io.sentry.Scopes;
+import io.sentry.SentryLevel;
+import io.sentry.logger.LoggerApi;
+import io.sentry.logger.LoggerBatchProcessor;
+import java.io.Closeable;
+import java.io.IOException;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+@ApiStatus.Internal
+public class AndroidLoggerApi extends LoggerApi implements Closeable, AppState.AppStateListener {
+
+  public AndroidLoggerApi(final @NotNull Scopes scopes) {
+    super(scopes);
+    AppState.getInstance().addAppStateListener(this);
+  }
+
+  @Override
+  @ApiStatus.Internal
+  public void close() throws IOException {
+    AppState.getInstance().removeAppStateListener(this);
+  }
+
+  @Override
+  public void onForeground() {}
+
+  @Override
+  public void onBackground() {
+    try {
+      scopes
+          .getOptions()
+          .getExecutorService()
+          .submit(
+              new Runnable() {
+                @Override
+                public void run() {
+                  scopes.getClient().flushLogs(LoggerBatchProcessor.FLUSH_AFTER_MS);
+                }
+              });
+    } catch (Throwable t) {
+      scopes
+          .getOptions()
+          .getLogger()
+          .log(SentryLevel.ERROR, t, "Failed to submit log flush runnable");
+    }
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidLoggerApiFactory.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidLoggerApiFactory.java
@@ -0,0 +1,17 @@
+package io.sentry.android.core;
+
+import io.sentry.Scopes;
+import io.sentry.logger.ILoggerApiFactory;
+import io.sentry.logger.LoggerApi;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+@ApiStatus.Internal
+public final class AndroidLoggerApiFactory implements ILoggerApiFactory {
+
+  @Override
+  @NotNull
+  public LoggerApi create(@NotNull Scopes scopes) {
+    return new AndroidLoggerApi(scopes);
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
@@ -139,6 +139,8 @@ static void loadDefaultAndMetadataOptions(
 
     readDefaultOptionValues(options, finalContext, buildInfoProvider);
     AppState.getInstance().registerLifecycleObserver(options);
+
+    options.setLoggerApiFactory(new AndroidLoggerApiFactory());
   }
 
   @TestOnly
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AppLifecycleIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/AppLifecycleIntegration.java
@@ -45,7 +45,8 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
             this.options.isEnableAppLifecycleBreadcrumbs());
 
     if (this.options.isEnableAutoSessionTracking()
-        || this.options.isEnableAppLifecycleBreadcrumbs()) {
+        || this.options.isEnableAppLifecycleBreadcrumbs()
+        || this.options.getLogs().isEnabled()) {
       try (final ISentryLifecycleToken ignored = lock.acquire()) {
         if (watcher != null) {
           return;
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidLoggerApiFactoryTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidLoggerApiFactoryTest.kt
@@ -0,0 +1,19 @@
+package io.sentry.android.core
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.sentry.Scopes
+import kotlin.test.assertIs
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.mock
+
+@RunWith(AndroidJUnit4::class)
+class AndroidLoggerApiFactoryTest {
+
+  @Test
+  fun `factory creates AndroidLogger`() {
+    val factory = AndroidLoggerApiFactory()
+    val logger = factory.create(mock<Scopes>())
+    assertIs<AndroidLoggerApi>(logger)
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidLoggerApiTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidLoggerApiTest.kt
@@ -0,0 +1,51 @@
+package io.sentry.android.core
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.sentry.Scopes
+import io.sentry.SentryClient
+import io.sentry.SentryOptions
+import io.sentry.test.ImmediateExecutorService
+import kotlin.test.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+@RunWith(AndroidJUnit4::class)
+class AndroidLoggerApiTest {
+
+  @Before
+  fun setup() {
+    AppState.getInstance().resetInstance()
+  }
+
+  @Test
+  fun `AndroidLogger registers and unregisters app state listener`() {
+    val scopes = mock<Scopes>()
+    val logger = AndroidLoggerApi(scopes)
+    assertTrue(AppState.getInstance().lifecycleObserver.listeners.isNotEmpty())
+
+    logger.close()
+    assertTrue(AppState.getInstance().lifecycleObserver.listeners.isEmpty())
+  }
+
+  @Test
+  fun `AndroidLogger triggers flushing if app goes in background`() {
+    val scopes = mock<Scopes>()
+
+    val client = mock<SentryClient>()
+    whenever(scopes.client).thenReturn(client)
+
+    val options = SentryOptions()
+    options.executorService = ImmediateExecutorService()
+    whenever(scopes.options).thenReturn(options)
+
+    val logger = AndroidLoggerApi(scopes)
+    logger.onBackground()
+
+    verify(client).flushLogs(any())
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt
@@ -926,4 +926,10 @@ class AndroidOptionsInitializerTest {
     fixture.initSut()
     assertIs<AndroidRuntimeManager>(fixture.sentryOptions.runtimeManager)
   }
+
+  @Test
+  fun `AndroidLoggerApiFactory is set in the options`() {
+    fixture.initSut()
+    assertIs<AndroidLoggerApiFactory>(fixture.sentryOptions.loggerApiFactory)
+  }
 }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/LifecycleWatcherTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/LifecycleWatcherTest.kt
@@ -5,12 +5,14 @@ import io.sentry.DateUtils
 import io.sentry.IContinuousProfiler
 import io.sentry.IScope
 import io.sentry.IScopes
+import io.sentry.ISentryClient
 import io.sentry.ReplayController
 import io.sentry.ScopeCallback
 import io.sentry.SentryLevel
 import io.sentry.SentryOptions
 import io.sentry.Session
 import io.sentry.Session.State
+import io.sentry.test.ImmediateExecutorService
 import io.sentry.transport.ICurrentDateProvider
 import kotlin.test.BeforeTest
 import kotlin.test.Test
@@ -36,6 +38,8 @@ class LifecycleWatcherTest {
     val replayController = mock<ReplayController>()
     val continuousProfiler = mock<IContinuousProfiler>()
 
+    val client = mock<ISentryClient>()
+
     fun getSUT(
       sessionIntervalMillis: Long = 0L,
       enableAutoSessionTracking: Boolean = true,
@@ -49,9 +53,13 @@ class LifecycleWatcherTest {
       whenever(scopes.configureScope(argumentCaptor.capture())).thenAnswer {
         argumentCaptor.value.run(scope)
       }
+      whenever(scope.client).thenReturn(client)
+
       options.setReplayController(replayController)
       options.setContinuousProfiler(continuousProfiler)
+      options.executorService = ImmediateExecutorService()
       whenever(scopes.options).thenReturn(options)
+      whenever(scopes.globalScope).thenReturn(scope)
 
       return LifecycleWatcher(
         scopes,
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SessionTrackingIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SessionTrackingIntegrationTest.kt
@@ -142,6 +142,10 @@ class SessionTrackingIntegrationTest {
       TODO("Not yet implemented")
     }
 
+    override fun flushLogs(timeoutMillis: Long) {
+      TODO("Not yet implemented")
+    }
+
     override fun captureFeedback(feedback: Feedback, hint: Hint?, scope: IScope): SentryId {
       TODO("Not yet implemented")
     }
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
@@ -1053,6 +1053,7 @@ public abstract interface class io/sentry/ISentryClient {
 	public abstract fun close ()V
 	public abstract fun close (Z)V
 	public abstract fun flush (J)V
+	public abstract fun flushLogs (J)V
 	public abstract fun getRateLimiter ()Lio/sentry/transport/RateLimiter;
 	public abstract fun isEnabled ()Z
 	public fun isHealthy ()Z
@@ -2856,6 +2857,7 @@ public final class io/sentry/SentryClient : io/sentry/ISentryClient {
 	public fun close ()V
 	public fun close (Z)V
 	public fun flush (J)V
+	public fun flushLogs (J)V
 	public fun getRateLimiter ()Lio/sentry/transport/RateLimiter;
 	public fun isEnabled ()Z
 	public fun isHealthy ()Z
diff --git a/sentry/src/main/java/io/sentry/ISentryClient.java b/sentry/src/main/java/io/sentry/ISentryClient.java
@@ -47,6 +47,8 @@ public interface ISentryClient {
    */
   void flush(long timeoutMillis);
 
+  void flushLogs(long timeoutMillis);
+
   /**
    * Captures the event.
    *
diff --git a/sentry/src/main/java/io/sentry/NoOpSentryClient.java b/sentry/src/main/java/io/sentry/NoOpSentryClient.java
@@ -38,6 +38,9 @@ public void close() {}
   @Override
   public void flush(long timeoutMillis) {}
 
+  @Override
+  public void flushLogs(long timeoutMillis) {}
+
   @Override
   public @NotNull SentryId captureFeedback(
       @NotNull Feedback feedback, @Nullable Hint hint, @NotNull IScope scope) {
diff --git a/sentry/src/main/java/io/sentry/Scopes.java b/sentry/src/main/java/io/sentry/Scopes.java
@@ -4,7 +4,6 @@
 import io.sentry.hints.SessionEndHint;
 import io.sentry.hints.SessionStartHint;
 import io.sentry.logger.ILoggerApi;
-import io.sentry.logger.LoggerApi;
 import io.sentry.protocol.*;
 import io.sentry.transport.RateLimiter;
 import io.sentry.util.HintUtils;
@@ -56,7 +55,7 @@ private Scopes(
     final @NotNull SentryOptions options = getOptions();
     validateOptions(options);
     this.compositePerformanceCollector = options.getCompositePerformanceCollector();
-    this.logger = new LoggerApi(this);
+    this.logger = options.getLoggerApiFactory().create(this);
   }
 
   public @NotNull String getCreator() {
@@ -463,6 +462,10 @@ public void close(final boolean isRestarting) {
           executorService.close(getOptions().getShutdownTimeoutMillis());
         }
 
+        if (logger instanceof Closeable) {
+          ((Closeable) logger).close();
+        }
+
         // TODO: should we end session before closing client?
         configureScope(ScopeType.CURRENT, scope -> scope.getClient().close(isRestarting));
         configureScope(ScopeType.ISOLATION, scope -> scope.getClient().close(isRestarting));
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -1563,10 +1563,15 @@ public void close(final boolean isRestarting) {
 
   @Override
   public void flush(final long timeoutMillis) {
-    loggerBatchProcessor.flush(timeoutMillis);
+    flushLogs(timeoutMillis);
     transport.flush(timeoutMillis);
   }
 
+  @Override
+  public void flushLogs(final long timeoutMillis) {
+    loggerBatchProcessor.flush(timeoutMillis);
+  }
+
   @Override
   public @Nullable RateLimiter getRateLimiter() {
     return transport.getRateLimiter();
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -15,6 +15,8 @@
 import io.sentry.internal.modules.IModulesLoader;
 import io.sentry.internal.modules.NoOpModulesLoader;
 import io.sentry.internal.viewhierarchy.ViewHierarchyExporter;
+import io.sentry.logger.DefaultLoggerApiFactory;
+import io.sentry.logger.ILoggerApiFactory;
 import io.sentry.protocol.SdkVersion;
 import io.sentry.protocol.SentryTransaction;
 import io.sentry.transport.ITransport;
@@ -626,6 +628,15 @@ public class SentryOptions {
 
   private @Nullable String profilingTracesDirPath;
 
+  private final @NotNull LazyEvaluator<ILoggerApiFactory> loggerApiFactory =
+      new LazyEvaluator<>(
+          new LazyEvaluator.Evaluator<ILoggerApiFactory>() {
+            @Override
+            public @NotNull ILoggerApiFactory evaluate() {
+              return new DefaultLoggerApiFactory();
+            }
+          });
+
   public @NotNull IProfileConverter getProfilerConverter() {
     return profilerConverter;
   }
@@ -3532,6 +3543,16 @@ public void setLogs(@NotNull SentryOptions.Logs logs) {
     this.logs = logs;
   }
 
+  @ApiStatus.Internal
+  public @NotNull ILoggerApiFactory getLoggerApiFactory() {
+    return loggerApiFactory.getValue();
+  }
+
+  @ApiStatus.Internal
+  public void setLoggerApiFactory(final @NotNull ILoggerApiFactory loggerApiFactory) {
+    this.loggerApiFactory.setValue(loggerApiFactory);
+  }
+
   public static final class Proxy {
     private @Nullable String host;
     private @Nullable String port;
diff --git a/sentry/src/main/java/io/sentry/logger/DefaultLoggerApiFactory.java b/sentry/src/main/java/io/sentry/logger/DefaultLoggerApiFactory.java
@@ -0,0 +1,15 @@
+package io.sentry.logger;
+
+import io.sentry.Scopes;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+@ApiStatus.Internal
+public final class DefaultLoggerApiFactory implements ILoggerApiFactory {
+
+  @Override
+  @NotNull
+  public LoggerApi create(@NotNull final Scopes scopes) {
+    return new LoggerApi(scopes);
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/logger/ILoggerApiFactory.java b/sentry/src/main/java/io/sentry/logger/ILoggerApiFactory.java
@@ -0,0 +1,11 @@
+package io.sentry.logger;
+
+import io.sentry.Scopes;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+@ApiStatus.Internal
+public interface ILoggerApiFactory {
+  @NotNull
+  LoggerApi create(@NotNull Scopes scopes);
+}
diff --git a/sentry/src/main/java/io/sentry/logger/LoggerApi.java b/sentry/src/main/java/io/sentry/logger/LoggerApi.java
diff --git a/sentry/src/test/java/io/sentry/ScopesTest.kt b/sentry/src/test/java/io/sentry/ScopesTest.kt

Original file line number	Diff line number	Diff line change
`@@ -139,6 +139,8 @@ static void loadDefaultAndMetadataOptions(`
`139`	`139`
`140`	`140`	`readDefaultOptionValues(options, finalContext, buildInfoProvider);`
`141`	`141`	`AppState.getInstance().registerLifecycleObserver(options);`
	`142`	`+`
	`143`	`+ options.setLoggerApiFactory(new AndroidLoggerApiFactory());`
`142`	`144`	`}`
`143`	`145`
`144`	`146`	`@TestOnly`
Original file line number	Diff line number	Diff line change
`@@ -926,4 +926,10 @@ class AndroidOptionsInitializerTest {`
`926`	`926`	`fixture.initSut()`
`927`	`927`	`assertIs<AndroidRuntimeManager>(fixture.sentryOptions.runtimeManager)`
`928`	`928`	`}`
	`929`	`+`
	`930`	`+ @Test`
	`931`	+ fun `AndroidLoggerApiFactory is set in the options`() {
	`932`	`+ fixture.initSut()`
	`933`	`+ assertIs<AndroidLoggerApiFactory>(fixture.sentryOptions.loggerApiFactory)`
	`934`	`+ }`
`929`	`935`	`}`
Original file line number	Diff line number	Diff line change
`@@ -142,6 +142,10 @@ class SessionTrackingIntegrationTest {`
`142`	`142`	`TODO("Not yet implemented")`
`143`	`143`	`}`
`144`	`144`
	`145`	`+ override fun flushLogs(timeoutMillis: Long) {`
	`146`	`+ TODO("Not yet implemented")`
	`147`	`+ }`
	`148`	`+`
`145`	`149`	`override fun captureFeedback(feedback: Feedback, hint: Hint?, scope: IScope): SentryId {`
`146`	`150`	`TODO("Not yet implemented")`
`147`	`151`	`}`