Add Timber and Fragment integrations if they are present on the classpath

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+* Feat: Automatically enable `Timber` and `Fragment` integrations if they are present on the classpath (#1936)
+
+Behaviour change:
+[Performance tracking](https://docs.sentry.io/platforms/android/configuration/integrations/fragment/#configure) for fragment's lifecycle is enabled by default now.
+
 ## 5.6.2
 
 ### Various fixes & improvements

sentry-android-core/build.gradle.kts

@@ -49,6 +49,7 @@ android {
 
         // We run a full lint analysis as build part in CI, so skip vital checks for assemble tasks.
         checkReleaseBuilds = false
+        disable += "LogNotTimber"
     }
 
     // needed because of Kotlin 1.4.x
@@ -78,6 +79,8 @@ tasks.withType<JavaCompile>().configureEach {
 
 dependencies {
     api(projects.sentry)
+    compileOnly(projects.sentryAndroidFragment)
+    compileOnly(projects.sentryAndroidTimber)
 
     // lifecycle processor, session tracking
     implementation(Config.Libs.lifecycleProcess)
@@ -102,4 +105,6 @@ dependencies {
     testImplementation(Config.TestLibs.mockitoInline)
     testImplementation(Config.TestLibs.awaitility)
     testImplementation(projects.sentryTestSupport)
+    testImplementation(projects.sentryAndroidFragment)
+    testImplementation(projects.sentryAndroidTimber)
 }

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

@@ -13,6 +13,8 @@
 import io.sentry.SendFireAndForgetOutboxSender;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
+import io.sentry.android.fragment.FragmentLifecycleIntegration;
+import io.sentry.android.timber.SentryTimberIntegration;
 import io.sentry.util.Objects;
 import java.io.BufferedInputStream;
 import java.io.File;
@@ -30,6 +32,12 @@
 @SuppressWarnings("Convert2MethodRef") // older AGP versions do not support method references
 final class AndroidOptionsInitializer {
 
+  static final String SENTRY_FRAGMENT_INTEGRATION_CLASS_NAME =
+      "io.sentry.android.fragment.FragmentLifecycleIntegration";
+
+  static final String SENTRY_TIMBER_INTEGRATION_CLASS_NAME =
+      "io.sentry.android.timber.SentryTimberIntegration";
+
   /** private ctor */
   private AndroidOptionsInitializer() {}
 
@@ -155,12 +163,18 @@ private static void installDefaultIntegrations(
           new ActivityLifecycleIntegration(
               (Application) context, buildInfoProvider, activityFramesTracker));
       options.addIntegration(new UserInteractionIntegration((Application) context, loadClass));
+      if (isIntegrationAvailable(SENTRY_FRAGMENT_INTEGRATION_CLASS_NAME, options, loadClass)) {
+        options.addIntegration(new FragmentLifecycleIntegration((Application) context));
+      }
     } else {
       options
           .getLogger()
           .log(
               SentryLevel.WARNING,
-              "ActivityLifecycle and UserInteraction Integrations need an Application class to be installed.");
+              "ActivityLifecycle, FragmentLifecycle and UserInteraction Integrations need an Application class to be installed.");
+    }
+    if (isIntegrationAvailable(SENTRY_TIMBER_INTEGRATION_CLASS_NAME, options, loadClass)) {
+      options.addIntegration(new SentryTimberIntegration());
     }
     options.addIntegration(new AppComponentsBreadcrumbsIntegration(context));
     options.addIntegration(new SystemEventsBreadcrumbsIntegration(context));
@@ -277,4 +291,23 @@ private static boolean isNdkAvailable(final @NotNull IBuildInfoProvider buildInf
     }
     return null;
   }
+
+  private static boolean isIntegrationAvailable(
+      final @NotNull String integrationClassName,
+      final @NotNull SentryOptions options,
+      final @NotNull LoadClass loadClass) {
+    boolean isAvailable;
+    try {
+      loadClass.loadClass(integrationClassName);
+      isAvailable = true;
+    } catch (ClassNotFoundException ignored) {
+      isAvailable = false;
+      options
+          .getLogger()
+          .log(
+              SentryLevel.WARNING,
+              integrationClassName + " won't be installed as it's not available on the classpath");
+    }
+    return isAvailable;
+  }
 }

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

@@ -17,9 +17,10 @@ import io.sentry.SendCachedEnvelopeFireAndForgetIntegration
 import io.sentry.SentryLevel
 import io.sentry.SentryOptions
 import io.sentry.android.core.NdkIntegration.SENTRY_NDK_CLASS_NAME
+import io.sentry.android.fragment.FragmentLifecycleIntegration
+import io.sentry.android.timber.SentryTimberIntegration
 import org.junit.runner.RunWith
 import java.io.File
-import java.lang.RuntimeException
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -336,6 +337,106 @@ class AndroidOptionsInitializerTest {
         assertNull(actual)
     }
 
+    @Test
+    fun `FragmentLifecycleIntegration added to the integration list if available on classpath`() {
+        val mockContext = ContextUtilsTest.mockMetaData(metaData = createBundleWithDsn())
+        val logger = mock<ILogger>()
+        val sentryOptions = SentryAndroidOptions().apply {
+            setDebug(true)
+        }
+
+        AndroidOptionsInitializer.init(
+            sentryOptions,
+            mockContext,
+            logger,
+            createBuildInfo(),
+            createClassMock(FragmentLifecycleIntegration::class.java)
+        )
+
+        val actual = sentryOptions.integrations.firstOrNull { it is FragmentLifecycleIntegration }
+        assertNotNull(actual)
+
+        verify(logger, never()).log(eq(SentryLevel.WARNING), any<String>(), any())
+    }
+
+    @Test
+    fun `FragmentLifecycleIntegration won't be enabled, it throws class not found`() {
+        val mockContext = ContextUtilsTest.mockMetaData(metaData = createBundleWithDsn())
+        val logger = mock<ILogger>()
+        val sentryOptions = SentryAndroidOptions().apply {
+            setDebug(true)
+        }
+
+        AndroidOptionsInitializer.init(
+            sentryOptions,
+            mockContext,
+            logger,
+            createBuildInfo(),
+            createClassMockThrows(
+                ClassNotFoundException(),
+                AndroidOptionsInitializer.SENTRY_FRAGMENT_INTEGRATION_CLASS_NAME
+            )
+        )
+
+        val actual = sentryOptions.integrations.firstOrNull { it is FragmentLifecycleIntegration }
+        assertNull(actual)
+
+        verify(logger).log(
+            eq(SentryLevel.WARNING),
+            eq("${AndroidOptionsInitializer.SENTRY_FRAGMENT_INTEGRATION_CLASS_NAME} won't be installed as it's not available on the classpath")
+        )
+    }
+
+    @Test
+    fun `SentryTimberIntegration added to the integration list if available on classpath`() {
+        val mockContext = ContextUtilsTest.mockMetaData(metaData = createBundleWithDsn())
+        val logger = mock<ILogger>()
+        val sentryOptions = SentryAndroidOptions().apply {
+            setDebug(true)
+        }
+
+        AndroidOptionsInitializer.init(
+            sentryOptions,
+            mockContext,
+            logger,
+            createBuildInfo(),
+            createClassMock(SentryTimberIntegration::class.java)
+        )
+
+        val actual = sentryOptions.integrations.firstOrNull { it is SentryTimberIntegration }
+        assertNotNull(actual)
+
+        verify(logger, never()).log(eq(SentryLevel.WARNING), any<String>(), any())
+    }
+
+    @Test
+    fun `SentryTimberIntegration won't be enabled, it throws class not found`() {
+        val mockContext = ContextUtilsTest.mockMetaData(metaData = createBundleWithDsn())
+        val logger = mock<ILogger>()
+        val sentryOptions = SentryAndroidOptions().apply {
+            setDebug(true)
+        }
+
+        AndroidOptionsInitializer.init(
+            sentryOptions,
+            mockContext,
+            logger,
+            createBuildInfo(),
+            createClassMockThrows(
+                ClassNotFoundException(),
+                AndroidOptionsInitializer.SENTRY_TIMBER_INTEGRATION_CLASS_NAME
+            )
+        )
+
+        val actual = sentryOptions.integrations.firstOrNull { it is SentryTimberIntegration }
+        assertNull(actual)
+
+        verify(logger).log(
+            eq(SentryLevel.WARNING),
+            eq("${AndroidOptionsInitializer.SENTRY_TIMBER_INTEGRATION_CLASS_NAME} won't be installed as it's not available on the classpath")
+        )
+    }
+
     private fun createMockContext(): Context {
         val mockContext = ContextUtilsTest.createMockContext()
         whenever(mockContext.cacheDir).thenReturn(file)
@@ -366,9 +467,12 @@ class AndroidOptionsInitializerTest {
         return loadClassMock
     }
 
-    private fun createClassMockThrows(ex: Throwable): LoadClass {
+    private fun createClassMockThrows(
+        ex: Throwable,
+        className: String = SENTRY_NDK_CLASS_NAME
+    ): LoadClass {
         val loadClassMock = mock<LoadClass>()
-        whenever(loadClassMock.loadClass(eq(SENTRY_NDK_CLASS_NAME))).thenThrow(ex)
+        whenever(loadClassMock.loadClass(eq(className))).thenThrow(ex)
         return loadClassMock
     }
 }

sentry-android-fragment/src/main/java/io/sentry/android/fragment/FragmentLifecycleIntegration.kt

@@ -20,7 +20,7 @@ class FragmentLifecycleIntegration(
     Integration,
     Closeable {
 
-    constructor(application: Application) : this(application, true, false)
+    constructor(application: Application) : this(application, true, true)
 
     private lateinit var hub: IHub
     private lateinit var options: SentryOptions

sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MyApplication.java

@@ -3,8 +3,6 @@
 import android.app.Application;
 import android.os.StrictMode;
 import io.sentry.android.core.SentryAndroid;
-import io.sentry.android.fragment.FragmentLifecycleIntegration;
-import io.sentry.android.timber.SentryTimberIntegration;
 
 /** Apps. main Application. */
 public class MyApplication extends Application {
@@ -19,8 +17,13 @@ public void onCreate() {
     SentryAndroid.init(
         this,
         options -> {
-          options.addIntegration(new FragmentLifecycleIntegration(MyApplication.this, true, true));
-          options.addIntegration(new SentryTimberIntegration());
+          /*
+          use options, for example, to add a beforeSend callback:
+
+          options.setBeforeSend((event, hint) -> {
+            process event
+          });
+           */
         });
   }