Merge branch 'main' into rz/fix/replay-network-body-size

Author: romtsn

CHANGELOG.md

@@ -6,6 +6,7 @@
 
 - Session Replay: Fix network detail response body size being unknown for gzip-compressed responses ([#5592](https://github.com/getsentry/sentry-java/pull/5592))
 - Session Replay: Release `MediaMuxer` when a replay segment has no encodable frames to avoid a resource leak ([#5583](https://github.com/getsentry/sentry-java/pull/5583))
+- Fix crash when `getHistoricalProcessStartReasons` is called from an isolated or wrong-userId process ([#5597](https://github.com/getsentry/sentry-java/pull/5597))
 
 ## 8.44.1
 

build-logic/src/main/kotlin/io.sentry.systemtest.gradle.kts

@@ -0,0 +1,38 @@
+import io.sentry.gradle.SystemTestExtension
+import org.gradle.api.tasks.ClasspathNormalizer
+
+val systemTest = extensions.create<SystemTestExtension>("sentrySystemTest")
+
+// The sample system tests launch the packaged app (war/shadowJar/bootJar) from build/libs as a
+// separate process, so the archive is a real input even though it is not on the test classpath.
+// Agent-based samples are additionally launched with -javaagent:<otel agent>, another runtime
+// input not on the classpath. See test/system-test-runner.py.
+tasks.matching { it.name == "systemTest" }.configureEach {
+  val archiveTask =
+    listOf("war", "shadowJar", "bootJar").firstOrNull { it in tasks.names }
+      ?: throw GradleException(
+        "io.sentry.systemtest is applied to $path but none of war/shadowJar/bootJar " +
+          "exist to provide the launched app archive for the systemTest task"
+      )
+  // Declaring the archive as an input also wires the dependency on its producing task.
+  inputs
+    .files(tasks.named(archiveTask))
+    .withPropertyName("appArchive")
+    .withNormalizer(ClasspathNormalizer::class.java)
+
+  if (systemTest.usesOpenTelemetryAgent.get()) {
+    // The runner builds the agent and launches the app with -javaagent before invoking this task,
+    // so the agent jar is tracked for content only (by path, no cross-project task dependency): a
+    // change to it makes systemTest out of date even though it runs outside the test JVM.
+    val version = providers.gradleProperty("versionName").get()
+    inputs
+      .files(
+        rootProject.layout.projectDirectory.file(
+          "sentry-opentelemetry/sentry-opentelemetry-agent/build/libs/" +
+            "sentry-opentelemetry-agent-$version.jar"
+        )
+      )
+      .withPropertyName("openTelemetryAgent")
+      .withNormalizer(ClasspathNormalizer::class.java)
+  }
+}

build-logic/src/main/kotlin/io/sentry/gradle/SystemTestExtension.kt

@@ -0,0 +1,17 @@
+package io.sentry.gradle
+
+import org.gradle.api.provider.Property
+
+/** Configuration for the `io.sentry.systemtest` convention plugin. */
+abstract class SystemTestExtension {
+  /**
+   * Set to `true` for samples that the system-test runner launches with the Sentry OpenTelemetry
+   * Java agent (`-javaagent`). The agent jar is then tracked as a `systemTest` input so the task
+   * re-runs when the agent changes, even though it is started outside the test JVM.
+   */
+  abstract val usesOpenTelemetryAgent: Property<Boolean>
+
+  init {
+    usesOpenTelemetryAgent.convention(false)
+  }
+}

sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java

@@ -11,6 +11,7 @@
 import android.os.Handler;
 import android.os.Looper;
 import android.os.SystemClock;
+import android.util.Log;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
@@ -467,18 +468,28 @@ public void registerLifecycleCallbacks(final @NotNull Application application) {
       final @Nullable ActivityManager activityManager =
           (ActivityManager) application.getSystemService(Context.ACTIVITY_SERVICE);
       if (activityManager != null) {
-        final List<ApplicationStartInfo> historicalProcessStartReasons =
-            activityManager.getHistoricalProcessStartReasons(1);
-        if (!historicalProcessStartReasons.isEmpty()) {
-          final @NotNull ApplicationStartInfo info = historicalProcessStartReasons.get(0);
-          cachedStartInfo = info;
-          if (info.getStartupState() == ApplicationStartInfo.STARTUP_STATE_STARTED) {
-            if (info.getStartType() == ApplicationStartInfo.START_TYPE_COLD) {
-              appStartType = AppStartType.COLD;
-            } else {
-              appStartType = AppStartType.WARM;
+        try {
+          final List<ApplicationStartInfo> historicalProcessStartReasons =
+              activityManager.getHistoricalProcessStartReasons(1);
+          if (!historicalProcessStartReasons.isEmpty()) {
+            final @NotNull ApplicationStartInfo info = historicalProcessStartReasons.get(0);
+            cachedStartInfo = info;
+            if (info.getStartupState() == ApplicationStartInfo.STARTUP_STATE_STARTED) {
+              if (info.getStartType() == ApplicationStartInfo.START_TYPE_COLD) {
+                appStartType = AppStartType.COLD;
+              } else {
+                appStartType = AppStartType.WARM;
+              }
             }
           }
+        } catch (RuntimeException ignored) {
+          // getHistoricalProcessStartReasons may throw different kinds of exceptions, namely:
+          // - SecurityException when called from an isolated process
+          // - IllegalArgumentException when called with a wrong userId
+          // - others
+          // See impl:
+          // https://cs.android.com/android/platform/superproject/+/android-latest-release:frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java;l=10866-10893
+          Log.w("AppStartMetrics", ignored); // no logger instance here, so we just Log
         }
       }
     }

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

@@ -12,18 +12,24 @@ class SentryShadowActivityManager {
   companion object {
     private var historicalProcessStartReasons: List<ApplicationStartInfo> = emptyList()
     private var importance: Int = RunningAppProcessInfo.IMPORTANCE_FOREGROUND
+    private var historicalProcessStartReasonsException: RuntimeException? = null
 
     fun setHistoricalProcessStartReasons(startReasons: List<ApplicationStartInfo>) {
       historicalProcessStartReasons = startReasons
     }
 
+    fun setHistoricalProcessStartReasonsException(exception: RuntimeException) {
+      historicalProcessStartReasonsException = exception
+    }
+
     fun setImportance(importance: Int) {
       this.importance = importance
     }
 
     fun reset() {
       historicalProcessStartReasons = emptyList()
       importance = RunningAppProcessInfo.IMPORTANCE_FOREGROUND
+      historicalProcessStartReasonsException = null
     }
 
     @Implementation
@@ -35,6 +41,7 @@ class SentryShadowActivityManager {
 
   @Implementation
   fun getHistoricalProcessStartReasons(maxNum: Int): List<ApplicationStartInfo> {
+    historicalProcessStartReasonsException?.let { throw it }
     return historicalProcessStartReasons.take(maxNum)
   }
 }

sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt

@@ -249,6 +249,20 @@ class AppStartMetricsTestApi35 {
     assertNull(metrics.appStartReason)
   }
 
+  @Test
+  fun `does not crash when getHistoricalProcessStartReasons throws RuntimeException`() {
+    SentryShadowActivityManager.setHistoricalProcessStartReasonsException(
+      RuntimeException("isolated process")
+    )
+    val metrics = AppStartMetrics.getInstance()
+
+    val app = ApplicationProvider.getApplicationContext<Application>()
+    metrics.registerLifecycleCallbacks(app)
+
+    assertEquals(AppStartMetrics.AppStartType.UNKNOWN, metrics.appStartType)
+    assertNull(metrics.appStartReason)
+  }
+
   private fun waitForMainLooperIdle() {
     Handler(Looper.getMainLooper()).post {}
     Shadows.shadowOf(Looper.getMainLooper()).idle()

sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt

@@ -228,18 +228,24 @@ class ComposeMaskingOptionsTest {
 
     val textNodes = activity.get().collectNodesOfType<TextViewHierarchyNode>(options)
     assertEquals(4, textNodes.size) // [TextField, Text, Button, Activity Title]
-    textNodes.forEach {
-      if ((it.layout as? ComposeTextLayout)?.layout?.layoutInput?.text?.text == "Make Request") {
-        assertFalse(
-          it.shouldMask,
-          "Node with text ${(it.layout as? ComposeTextLayout)?.layout?.layoutInput?.text?.text} should not be masked",
-        )
-      } else {
-        assertTrue(
-          it.shouldMask,
-          "Node with text ${(it.layout as? ComposeTextLayout)?.layout?.layoutInput?.text?.text} should be masked",
-        )
+
+    val unmaskNode =
+      textNodes.first {
+        (it.layout as? ComposeTextLayout)?.layout?.layoutInput?.text?.text == "Make Request"
       }
+    assertTrue(unmaskNode.isVisible, "The unmasked node must be visible for the test to be valid")
+    assertFalse(unmaskNode.shouldMask, "Node with sentryReplayUnmask() should not be masked")
+
+    // Robolectric may intermittently report zero bounds for some nodes when running
+    // the full test class, making them invisible (shouldMask = isVisible && ...).
+    // Assert that all other visible nodes remain masked.
+    val otherVisibleNodes = textNodes.filter { it !== unmaskNode && it.isVisible }
+    assertTrue(otherVisibleNodes.isNotEmpty(), "Expected at least one other visible text node")
+    otherVisibleNodes.forEach {
+      assertTrue(
+        it.shouldMask,
+        "Node with text ${(it.layout as? ComposeTextLayout)?.layout?.layoutInput?.text?.text} should be masked",
+      )
     }
   }
 

sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts

@@ -6,6 +6,7 @@ plugins {
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.shadow)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.console.Main") }
@@ -71,8 +72,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test

sentry-samples/sentry-samples-console-otlp/build.gradle.kts

@@ -6,6 +6,7 @@ plugins {
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.shadow)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.console.Main") }
@@ -74,8 +75,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test

sentry-samples/sentry-samples-console/build.gradle.kts

@@ -6,6 +6,7 @@ plugins {
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.shadow)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.console.Main") }
@@ -75,8 +76,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test