Create custom Android Logger API, address PR feedback

markushi · markushi · commit 0bd817c701fe · 2025-12-03T16:49:19.000+01:00
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
@@ -57,8 +57,7 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
                 scopes,
                 this.options.getSessionTrackingIntervalMillis(),
                 this.options.isEnableAutoSessionTracking(),
-                this.options.isEnableAppLifecycleBreadcrumbs(),
-                this.options.getLogs().isEnabled());
+                this.options.isEnableAppLifecycleBreadcrumbs());
 
         AppState.getInstance().addAppStateListener(watcher);
       }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/LifecycleWatcher.java b/sentry-android-core/src/main/java/io/sentry/android/core/LifecycleWatcher.java
@@ -5,7 +5,6 @@
 import io.sentry.ISentryLifecycleToken;
 import io.sentry.SentryLevel;
 import io.sentry.Session;
-import io.sentry.logger.LoggerBatchProcessor;
 import io.sentry.transport.CurrentDateProvider;
 import io.sentry.transport.ICurrentDateProvider;
 import io.sentry.util.AutoClosableReentrantLock;
@@ -30,22 +29,18 @@ final class LifecycleWatcher implements AppState.AppStateListener {
   private final boolean enableSessionTracking;
   private final boolean enableAppLifecycleBreadcrumbs;
 
-  private final boolean enableLogFlushing;
-
   private final @NotNull ICurrentDateProvider currentDateProvider;
 
   LifecycleWatcher(
       final @NotNull IScopes scopes,
       final long sessionIntervalMillis,
       final boolean enableSessionTracking,
-      final boolean enableAppLifecycleBreadcrumbs,
-      final boolean enableLogFlushing) {
+      final boolean enableAppLifecycleBreadcrumbs) {
     this(
         scopes,
         sessionIntervalMillis,
         enableSessionTracking,
         enableAppLifecycleBreadcrumbs,
-        enableLogFlushing,
         CurrentDateProvider.getInstance());
   }
 
@@ -54,12 +49,10 @@ final class LifecycleWatcher implements AppState.AppStateListener {
       final long sessionIntervalMillis,
       final boolean enableSessionTracking,
       final boolean enableAppLifecycleBreadcrumbs,
-      final boolean enableLogFlushing,
       final @NotNull ICurrentDateProvider currentDateProvider) {
     this.sessionIntervalMillis = sessionIntervalMillis;
     this.enableSessionTracking = enableSessionTracking;
     this.enableAppLifecycleBreadcrumbs = enableAppLifecycleBreadcrumbs;
-    this.enableLogFlushing = enableLogFlushing;
     this.scopes = scopes;
     this.currentDateProvider = currentDateProvider;
   }
@@ -108,29 +101,6 @@ public void onBackground() {
     scheduleEndSession();
 
     addAppBreadcrumb("background");
-
-    if (enableLogFlushing) {
-      try {
-        scopes
-            .getOptions()
-            .getExecutorService()
-            .submit(
-                new Runnable() {
-                  @Override
-                  public void run() {
-                    scopes
-                        .getGlobalScope()
-                        .getClient()
-                        .flushLogs(LoggerBatchProcessor.FLUSH_AFTER_MS);
-                  }
-                });
-      } catch (Throwable t) {
-        scopes
-            .getOptions()
-            .getLogger()
-            .log(SentryLevel.ERROR, t, "Failed to submit log flush runnable");
-      }
-    }
   }
 
   private void scheduleEndSession() {
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/AppLifecycleIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AppLifecycleIntegrationTest.kt
@@ -34,12 +34,11 @@ class AppLifecycleIntegrationTest {
   }
 
   @Test
-  fun `When SessionTracking and AppLifecycle breadcrumbs and Logs are disabled, lifecycle watcher should not be started`() {
+  fun `When SessionTracking and AppLifecycle breadcrumbs are disabled, lifecycle watcher should not be started`() {
     val sut = fixture.getSut()
     fixture.options.apply {
       isEnableAppLifecycleBreadcrumbs = false
       isEnableAutoSessionTracking = false
-      logs.isEnabled = false
     }
 
     sut.register(fixture.scopes, fixture.options)
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
@@ -44,7 +44,6 @@ class LifecycleWatcherTest {
       sessionIntervalMillis: Long = 0L,
       enableAutoSessionTracking: Boolean = true,
       enableAppLifecycleBreadcrumbs: Boolean = true,
-      enableLogFlushing: Boolean = true,
       session: Session? = null,
     ): LifecycleWatcher {
       val argumentCaptor: ArgumentCaptor<ScopeCallback> =
@@ -67,7 +66,6 @@ class LifecycleWatcherTest {
         sessionIntervalMillis,
         enableAutoSessionTracking,
         enableAppLifecycleBreadcrumbs,
-        enableLogFlushing,
         dateProvider,
       )
     }
@@ -305,27 +303,4 @@ class LifecycleWatcherTest {
     watcher.onBackground()
     verify(fixture.replayController, timeout(10000)).stop()
   }
-
-  @Test
-  fun `flush logs when going in background`() {
-    val watcher = fixture.getSUT(enableLogFlushing = true)
-
-    watcher.onForeground()
-    watcher.onBackground()
-
-    watcher.onForeground()
-    watcher.onBackground()
-
-    verify(fixture.client, times(2)).flushLogs(any())
-  }
-
-  @Test
-  fun `do not flush logs when going in background when logging is disabled`() {
-    val watcher = fixture.getSUT(enableLogFlushing = false)
-
-    watcher.onForeground()
-    watcher.onBackground()
-
-    verify(fixture.client, never()).flushLogs(any())
-  }
 }
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/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
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
`@@ -57,8 +57,7 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions`
`57`	`57`	`scopes,`
`58`	`58`	`this.options.getSessionTrackingIntervalMillis(),`
`59`	`59`	`this.options.isEnableAutoSessionTracking(),`
`60`		`- this.options.isEnableAppLifecycleBreadcrumbs(),`
`61`		`- this.options.getLogs().isEnabled());`
	`60`	`+ this.options.isEnableAppLifecycleBreadcrumbs());`
`62`	`61`
`63`	`62`	`AppState.getInstance().addAppStateListener(watcher);`
`64`	`63`	`}`
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
`@@ -34,12 +34,11 @@ class AppLifecycleIntegrationTest {`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`@Test`
`37`		- fun `When SessionTracking and AppLifecycle breadcrumbs and Logs are disabled, lifecycle watcher should not be started`() {
	`37`	+ fun `When SessionTracking and AppLifecycle breadcrumbs are disabled, lifecycle watcher should not be started`() {
`38`	`38`	`val sut = fixture.getSut()`
`39`	`39`	`fixture.options.apply {`
`40`	`40`	`isEnableAppLifecycleBreadcrumbs = false`
`41`	`41`	`isEnableAutoSessionTracking = false`
`42`		`- logs.isEnabled = false`
`43`	`42`	`}`
`44`	`43`
`45`	`44`	`sut.register(fixture.scopes, fixture.options)`