Merge branch 'main' into rz/fix/system-events-receiver-faster

Author: romtsn

CHANGELOG.md

@@ -2,14 +2,23 @@
 
 ## Unreleased
 
-### Improvements
+### Features
 
-- Make `SystemEventsBreadcrumbsIntegration` faster ([#4330](https://github.com/getsentry/sentry-java/pull/4330))
+- Add `CoroutineExceptionHandler` for reporting uncaught exceptions in coroutines to Sentry ([#4259](https://github.com/getsentry/sentry-java/pull/4259))
+  - This is now part of `sentry-kotlin-extensions` and can be used together with `SentryContext` when launching a coroutine
+  - Any exceptions thrown in a coroutine when using the handler will be captured (not rethrown!) and reported to Sentry
+  - It's also possible to extend `CoroutineExceptionHandler` to implement custom behavior in addition to the one we provide by default
 
 ### Fixes
 
 - Use thread context classloader when available ([#4320](https://github.com/getsentry/sentry-java/pull/4320))
   - This ensures correct resource loading in environments like Spring Boot where the thread context classloader is used for resource loading.
+- Improve low memory breadcrumb capturing ([#4325](https://github.com/getsentry/sentry-java/pull/4325))
+- Fix do not initialize SDK for Jetpack Compose Preview builds ([#4324](https://github.com/getsentry/sentry-java/pull/4324))
+
+### Improvements
+
+- Make `SystemEventsBreadcrumbsIntegration` faster ([#4330](https://github.com/getsentry/sentry-java/pull/4330))
 
 ## 8.7.0
 

buildSrc/src/main/java/Config.kt

@@ -121,6 +121,8 @@ object Config {
 
         val coroutinesCore = "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.1"
 
+        val coroutinesAndroid = "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.1"
+
         val fragment = "androidx.fragment:fragment-ktx:1.3.5"
 
         val reactorCore = "io.projectreactor:reactor-core:3.5.3"
@@ -214,6 +216,7 @@ object Config {
         val leakCanaryInstrumentation = "com.squareup.leakcanary:leakcanary-android-instrumentation:2.14"
         val composeUiTestJunit4 = "androidx.compose.ui:ui-test-junit4:1.6.8"
         val okio = "com.squareup.okio:okio:1.13.0"
+        val coroutinesTest = "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.1"
     }
 
     object QualityPlugins {

sentry-android-core/api/sentry-android-core.api

@@ -185,6 +185,7 @@ public final class io/sentry/android/core/BuildInfoProvider {
 }
 
 public final class io/sentry/android/core/ContextUtils {
+	public static fun appIsLibraryForComposePreview (Landroid/content/Context;)Z
 	public static fun getApplicationContext (Landroid/content/Context;)Landroid/content/Context;
 	public static fun isForegroundImportance ()Z
 }

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

@@ -12,6 +12,8 @@
 import io.sentry.Integration;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
+import io.sentry.android.core.internal.util.AndroidCurrentDateProvider;
+import io.sentry.android.core.internal.util.Debouncer;
 import io.sentry.android.core.internal.util.DeviceOrientations;
 import io.sentry.protocol.Device;
 import io.sentry.util.Objects;
@@ -24,10 +26,17 @@
 public final class AppComponentsBreadcrumbsIntegration
     implements Integration, Closeable, ComponentCallbacks2 {
 
+  private static final long DEBOUNCE_WAIT_TIME_MS = 60 * 1000;
+  // pre-allocate hint to avoid creating it every time for the low memory case
+  private static final @NotNull Hint EMPTY_HINT = new Hint();
+
   private final @NotNull Context context;
   private @Nullable IScopes scopes;
   private @Nullable SentryAndroidOptions options;
 
+  private final @NotNull Debouncer trimMemoryDebouncer =
+      new Debouncer(AndroidCurrentDateProvider.getInstance(), DEBOUNCE_WAIT_TIME_MS, 0);
+
   public AppComponentsBreadcrumbsIntegration(final @NotNull Context context) {
     this.context =
         Objects.requireNonNull(ContextUtils.getApplicationContext(context), "Context is required");
@@ -91,42 +100,43 @@ public void onConfigurationChanged(@NotNull Configuration newConfig) {
 
   @Override
   public void onLowMemory() {
-    final long now = System.currentTimeMillis();
-    executeInBackground(() -> captureLowMemoryBreadcrumb(now, null));
+    // we do this in onTrimMemory below already, this is legacy API (14 or below)
   }
 
   @Override
   public void onTrimMemory(final int level) {
+    if (level < TRIM_MEMORY_BACKGROUND) {
+      // only add breadcrumb if TRIM_MEMORY_BACKGROUND, TRIM_MEMORY_MODERATE or
+      // TRIM_MEMORY_COMPLETE.
+      // Release as much memory as the process can.
+
+      // TRIM_MEMORY_UI_HIDDEN, TRIM_MEMORY_RUNNING_MODERATE, TRIM_MEMORY_RUNNING_LOW and
+      // TRIM_MEMORY_RUNNING_CRITICAL.
+      // Release any memory that your app doesn't need to run.
+      // So they are still not so critical at the point of killing the process.
+      // https://developer.android.com/topic/performance/memory
+      return;
+    }
+
+    if (trimMemoryDebouncer.checkForDebounce()) {
+      // if we received trim_memory within 1 minute time, ignore this call
+      return;
+    }
+
     final long now = System.currentTimeMillis();
     executeInBackground(() -> captureLowMemoryBreadcrumb(now, level));
   }
 
-  private void captureLowMemoryBreadcrumb(final long timeMs, final @Nullable Integer level) {
+  private void captureLowMemoryBreadcrumb(final long timeMs, final int level) {
     if (scopes != null) {
       final Breadcrumb breadcrumb = new Breadcrumb(timeMs);
-      if (level != null) {
-        // only add breadcrumb if TRIM_MEMORY_BACKGROUND, TRIM_MEMORY_MODERATE or
-        // TRIM_MEMORY_COMPLETE.
-        // Release as much memory as the process can.
-
-        // TRIM_MEMORY_UI_HIDDEN, TRIM_MEMORY_RUNNING_MODERATE, TRIM_MEMORY_RUNNING_LOW and
-        // TRIM_MEMORY_RUNNING_CRITICAL.
-        // Release any memory that your app doesn't need to run.
-        // So they are still not so critical at the point of killing the process.
-        // https://developer.android.com/topic/performance/memory
-
-        if (level < TRIM_MEMORY_BACKGROUND) {
-          return;
-        }
-        breadcrumb.setData("level", level);
-      }
-
       breadcrumb.setType("system");
       breadcrumb.setCategory("device.event");
       breadcrumb.setMessage("Low memory");
       breadcrumb.setData("action", "LOW_MEMORY");
+      breadcrumb.setData("level", level);
       breadcrumb.setLevel(SentryLevel.WARNING);
-      scopes.addBreadcrumb(breadcrumb);
+      scopes.addBreadcrumb(breadcrumb, EMPTY_HINT);
     }
   }
 

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

@@ -7,6 +7,7 @@
 import android.annotation.SuppressLint;
 import android.app.ActivityManager;
 import android.content.BroadcastReceiver;
+import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
@@ -27,6 +28,7 @@
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
@@ -285,6 +287,36 @@ public static boolean isForegroundImportance() {
     return isForegroundImportance.getValue();
   }
 
+  /**
+   * Determines if the app is a packaged android library for running Compose Preview Mode
+   *
+   * @param context the context
+   * @return true, if the app is actually a library running as an app for Compose Preview Mode
+   */
+  @ApiStatus.Internal
+  public static boolean appIsLibraryForComposePreview(final @NotNull Context context) {
+    // Jetpack Compose Preview (aka "Run Preview on Device")
+    // uses the androidTest flavor for android library modules,
+    // so let's fail-fast by checking this first
+    if (context.getPackageName().endsWith(".test")) {
+      try {
+        final @NotNull ActivityManager activityManager =
+            (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
+        final @NotNull List<ActivityManager.AppTask> appTasks = activityManager.getAppTasks();
+        for (final ActivityManager.AppTask task : appTasks) {
+          final @Nullable ComponentName component = task.getTaskInfo().baseIntent.getComponent();
+          if (component != null
+              && component.getClassName().equals("androidx.compose.ui.tooling.PreviewActivity")) {
+            return true;
+          }
+        }
+      } catch (Throwable t) {
+        // ignored
+      }
+    }
+    return false;
+  }
+
   /**
    * Get the device's current kernel version, as a string. Attempts to read /proc/version, and falls
    * back to the 'os.version' System Property.

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

@@ -21,7 +21,9 @@ public boolean onCreate() {
       logger.log(SentryLevel.FATAL, "App. Context from ContentProvider is null");
       return false;
     }
-    if (ManifestMetadataReader.isAutoInit(context, logger)) {
+
+    if (ManifestMetadataReader.isAutoInit(context, logger)
+        && !ContextUtils.appIsLibraryForComposePreview(context)) {
       SentryAndroid.init(context, logger);
       SentryIntegrationPackageStorage.getInstance().addIntegration("AutoInit");
     }

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

@@ -15,6 +15,7 @@ import org.mockito.kotlin.check
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.never
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoMoreInteractions
 import org.mockito.kotlin.whenever
 import java.lang.NullPointerException
 import kotlin.test.Test
@@ -95,24 +96,6 @@ class AppComponentsBreadcrumbsIntegrationTest {
         sut.close()
     }
 
-    @Test
-    fun `When low memory event, a breadcrumb with type, category and level should be set`() {
-        val sut = fixture.getSut()
-        val options = SentryAndroidOptions().apply {
-            executorService = ImmediateExecutorService()
-        }
-        val scopes = mock<IScopes>()
-        sut.register(scopes, options)
-        sut.onLowMemory()
-        verify(scopes).addBreadcrumb(
-            check<Breadcrumb> {
-                assertEquals("device.event", it.category)
-                assertEquals("system", it.type)
-                assertEquals(SentryLevel.WARNING, it.level)
-            }
-        )
-    }
-
     @Test
     fun `When trim memory event with level, a breadcrumb with type, category and level should be set`() {
         val sut = fixture.getSut()
@@ -127,7 +110,8 @@ class AppComponentsBreadcrumbsIntegrationTest {
                 assertEquals("device.event", it.category)
                 assertEquals("system", it.type)
                 assertEquals(SentryLevel.WARNING, it.level)
-            }
+            },
+            anyOrNull()
         )
     }
 
@@ -162,4 +146,26 @@ class AppComponentsBreadcrumbsIntegrationTest {
             anyOrNull()
         )
     }
+
+    @Test
+    fun `low memory changes are debounced`() {
+        val sut = fixture.getSut()
+
+        val scopes = mock<IScopes>()
+        val options = SentryAndroidOptions().apply {
+            executorService = ImmediateExecutorService()
+        }
+        sut.register(scopes, options)
+        sut.onTrimMemory(ComponentCallbacks2.TRIM_MEMORY_BACKGROUND)
+        sut.onTrimMemory(ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL)
+
+        // should only add the first crumb
+        verify(scopes).addBreadcrumb(
+            check<Breadcrumb> {
+                assertEquals(it.data["level"], 40)
+            },
+            anyOrNull()
+        )
+        verifyNoMoreInteractions(scopes)
+    }
 }

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

@@ -5,7 +5,9 @@ import android.app.ActivityManager
 import android.app.ActivityManager.MemoryInfo
 import android.app.ActivityManager.RunningAppProcessInfo
 import android.content.BroadcastReceiver
+import android.content.ComponentName
 import android.content.Context
+import android.content.Intent
 import android.content.IntentFilter
 import android.content.pm.ApplicationInfo
 import android.content.pm.PackageInfo
@@ -270,4 +272,35 @@ class ContextUtilsTest {
         val appContext = ContextUtils.getApplicationContext(contextMock)
         assertSame(appContextMock, appContext)
     }
+
+    @Test
+    fun `appIsLibraryForComposePreview is correctly determined`() {
+        fun getMockContext(
+            packageName: String,
+            activityClassName: String
+        ): Context {
+            val context = mock<Context>()
+            val activityManager = mock<ActivityManager>()
+            whenever(context.packageName).thenReturn(packageName)
+            whenever(context.getSystemService(eq(Context.ACTIVITY_SERVICE))).thenReturn(
+                activityManager
+            )
+            val taskInfo = ActivityManager.RecentTaskInfo()
+            taskInfo.baseIntent = Intent().setComponent(
+                ComponentName(
+                    "com.example.library",
+                    activityClassName
+                )
+            )
+            val appTask = mock<ActivityManager.AppTask>()
+            whenever(appTask.taskInfo).thenReturn(taskInfo)
+            whenever(activityManager.appTasks).thenReturn(listOf(appTask))
+
+            return context
+        }
+
+        assertTrue(ContextUtils.appIsLibraryForComposePreview(getMockContext("com.example.library.test", "androidx.compose.ui.tooling.PreviewActivity")))
+        assertFalse(ContextUtils.appIsLibraryForComposePreview(getMockContext("com.example.library.test", "com.example.HomeActivity")))
+        assertFalse(ContextUtils.appIsLibraryForComposePreview(getMockContext("com.example.library", "androidx.compose.ui.tooling.PreviewActivity")))
+    }
 }

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

@@ -7,11 +7,14 @@ import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.Sentry
 import io.sentry.test.callMethod
 import org.junit.runner.RunWith
+import org.mockito.Mockito
+import org.mockito.kotlin.any
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertFailsWith
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
+import kotlin.use
 
 @RunWith(AndroidJUnit4::class)
 class SentryInitProviderTest {
@@ -153,6 +156,24 @@ class SentryInitProviderTest {
         assertFalse(sentryOptions.isEnableNdk)
     }
 
+    @Test
+    fun `skips init in compose preview mode`() {
+        val providerInfo = ProviderInfo()
+
+        assertFalse(Sentry.isEnabled())
+        providerInfo.authority = AUTHORITY
+
+        val metaData = Bundle()
+        metaData.putString(ManifestMetadataReader.DSN, "https://key@sentry.io/123")
+        val mockContext = ContextUtilsTestHelper.mockMetaData(metaData = metaData)
+
+        Mockito.mockStatic(ContextUtils::class.java).use { contextUtils ->
+            contextUtils.`when`<Boolean> { ContextUtils.appIsLibraryForComposePreview(any()) }.thenReturn(true)
+            sentryInitProvider.attachInfo(mockContext, providerInfo)
+        }
+        assertFalse(Sentry.isEnabled())
+    }
+
     companion object {
         private const val AUTHORITY = "io.sentry.sample.SentryInitProvider"
     }

sentry-apollo-4/build.gradle.kts

@@ -41,7 +41,7 @@ dependencies {
     testImplementation(Config.TestLibs.mockitoInline)
     testImplementation(Config.TestLibs.mockWebserver)
     testImplementation(Config.Libs.apolloKotlin4)
-    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3")
+    testImplementation(Config.TestLibs.coroutinesTest)
     testImplementation("org.jetbrains.kotlin:kotlin-reflect:2.0.0")
 }