Merge branch 'main' into feat/experimental-otel-global-hub-mode

adinauer · web-flow · commit c02df17b4e6a · 2025-04-29T15:15:48.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -10,6 +10,13 @@
     - Spans created via Sentry API are preferred over those created through OpenTelemetry API or auto instrumentation
 - New option `ignoreStandaloneClientSpans` that prevents Sentry from creating transactions for OpenTelemetry spans with kind `CLIENT` ([#4349](https://github.com/getsentry/sentry-java/pull/4349))
     - Defaults to `false` meaning standalone OpenTelemetry spans with kind `CLIENT` will be turned into Sentry transactions
+- Make `RequestDetailsResolver` public ([#4326](https://github.com/getsentry/sentry-java/pull/4326))
+  - `RequestDetailsResolver` is now public and has an additional constructor, making it easier to use a custom `TransportFactory`
+
+### Fixes
+
+- Session Replay: Fix masking of non-styled `Text` Composables ([#4361](https://github.com/getsentry/sentry-java/pull/4361))
+- Session Replay: Fix masking read-only `TextField` Composables ([#4362](https://github.com/getsentry/sentry-java/pull/4362))
 
 ## 8.10.0
 
@@ -20,7 +27,7 @@
   - Set `-Dio.opentelemetry.context.contextStorageProvider=io.sentry.opentelemetry.SentryContextStorageProvider` on your `java` command
   - Sentry will then wrap the other `ContextStorageProvider` that has been configured by loading it through SPI
   - If no other `ContextStorageProvider` is available or there are problems loading it, we fall back to using `SentryOtelThreadLocalStorage`
-
+    
 ### Fixes
 
 - Update profile chunk rate limit and client report ([#4353](https://github.com/getsentry/sentry-java/pull/4353))
diff --git a/scripts/toggle-codec-logs.sh b/scripts/toggle-codec-logs.sh
@@ -45,6 +45,10 @@ case "$ACTION" in
         adb shell setprop log.tag.BufferQueueProducer D
         adb shell setprop log.tag.ReflectedParamUpdater D
         adb shell setprop log.tag.hw-BpHwBinder D
+        adb shell setprop log.tag.ACodec D
+        adb shell setprop log.tag.VideoCapabilities D
+        adb shell setprop log.tag.OMXUtils D
+        adb shell setprop log.tag.OMXClient D
         echo "✅ Logs ENABLED"
         ;;
     disable)
@@ -67,6 +71,10 @@ case "$ACTION" in
         adb shell setprop log.tag.BufferQueueProducer SILENT
         adb shell setprop log.tag.ReflectedParamUpdater SILENT
         adb shell setprop log.tag.hw-BpHwBinder SILENT
+        adb shell setprop log.tag.ACodec SILENT
+        adb shell setprop log.tag.VideoCapabilities SILENT
+        adb shell setprop log.tag.OMXUtils SILENT
+        adb shell setprop log.tag.OMXClient SILENT
         echo "🚫 Logs DISABLED"
         ;;
     *)
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
@@ -14,6 +14,7 @@ import androidx.compose.ui.semantics.SemanticsActions
 import androidx.compose.ui.semantics.SemanticsProperties
 import androidx.compose.ui.semantics.getOrNull
 import androidx.compose.ui.text.TextLayoutResult
+import androidx.compose.ui.unit.TextUnit
 import io.sentry.SentryLevel
 import io.sentry.SentryOptions
 import io.sentry.SentryReplayOptions
@@ -40,7 +41,8 @@ internal object ComposeViewHierarchyNode {
         return when {
             isImage -> SentryReplayOptions.IMAGE_VIEW_CLASS_NAME
             collapsedSemantics?.contains(SemanticsProperties.Text) == true ||
-                collapsedSemantics?.contains(SemanticsActions.SetText) == true -> SentryReplayOptions.TEXT_VIEW_CLASS_NAME
+                collapsedSemantics?.contains(SemanticsActions.SetText) == true ||
+                collapsedSemantics?.contains(SemanticsProperties.EditableText) == true -> SentryReplayOptions.TEXT_VIEW_CLASS_NAME
             else -> "android.view.View"
         }
     }
@@ -86,7 +88,8 @@ internal object ComposeViewHierarchyNode {
         val isVisible = !node.outerCoordinator.isTransparent() &&
             (semantics == null || !semantics.contains(SemanticsProperties.InvisibleToUser)) &&
             visibleRect.height() > 0 && visibleRect.width() > 0
-        val isEditable = semantics?.contains(SemanticsActions.SetText) == true
+        val isEditable = semantics?.contains(SemanticsActions.SetText) == true ||
+            semantics?.contains(SemanticsProperties.EditableText) == true
         return when {
             semantics?.contains(SemanticsProperties.Text) == true || isEditable -> {
                 val shouldMask = isVisible && node.shouldMask(isImage = false, options)
@@ -100,14 +103,19 @@ internal object ComposeViewHierarchyNode {
                     ?.invoke(textLayoutResults)
 
                 val (color, hasFillModifier) = node.findTextAttributes()
-                var textColor = textLayoutResults.firstOrNull()?.layoutInput?.style?.color
+                val textLayoutResult = textLayoutResults.firstOrNull()
+                var textColor = textLayoutResult?.layoutInput?.style?.color
                 if (textColor?.isUnspecified == true) {
                     textColor = color
                 }
-                // TODO: support multiple text layouts
+                val isLaidOut = textLayoutResult?.layoutInput?.style?.fontSize != TextUnit.Unspecified
                 // TODO: support editable text (currently there's a way to get @Composable's padding only via reflection, and we can't reliably mask input fields based on TextLayout, so we mask the whole view instead)
                 TextViewHierarchyNode(
-                    layout = if (textLayoutResults.isNotEmpty() && !isEditable) ComposeTextLayout(textLayoutResults.first(), hasFillModifier) else null,
+                    layout = if (textLayoutResult != null && !isEditable && isLaidOut) {
+                        ComposeTextLayout(textLayoutResult, hasFillModifier)
+                    } else {
+                        null
+                    },
                     dominantColor = textColor?.toArgb()?.toOpaque(),
                     x = visibleRect.left.toFloat(),
                     y = visibleRect.top.toFloat(),
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
@@ -16,10 +16,15 @@ import androidx.compose.material3.TextField
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.semantics.editableText
 import androidx.compose.ui.semantics.invisibleToUser
 import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.input.TextFieldValue
+import androidx.compose.ui.unit.TextUnit
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import coil.compose.AsyncImage
 import io.sentry.SentryOptions
@@ -41,6 +46,7 @@ import java.io.File
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertNull
 import kotlin.test.assertTrue
 
 @RunWith(AndroidJUnit4::class)
@@ -52,7 +58,9 @@ class ComposeMaskingOptionsTest {
         System.setProperty("robolectric.areWindowsMarkedVisible", "true")
         System.setProperty("robolectric.pixelCopyRenderMode", "hardware")
         ComposeMaskingOptionsActivity.textModifierApplier = null
+        ComposeMaskingOptionsActivity.textFieldModifierApplier = null
         ComposeMaskingOptionsActivity.containerModifierApplier = null
+        ComposeMaskingOptionsActivity.fontSizeApplier = null
     }
 
     @Test
@@ -67,8 +75,40 @@ class ComposeMaskingOptionsTest {
         val textNodes = activity.get().collectNodesOfType<TextViewHierarchyNode>(options)
         assertEquals(4, textNodes.size) // [TextField, Text, Button, Activity Title]
         assertTrue(textNodes.all { it.shouldMask })
-        // just a sanity check for parsing the tree
-        assertEquals("Random repo", (textNodes[1].layout as ComposeTextLayout).layout.layoutInput.text.text)
+        // no fontSize specified - we don't use the text layout
+        assertNull(textNodes.first().layout)
+    }
+
+    @Test
+    fun `when text is laid out nodes use it`() {
+        ComposeMaskingOptionsActivity.fontSizeApplier = { 20.sp }
+        val activity = buildActivity(ComposeMaskingOptionsActivity::class.java).setup()
+        shadowOf(Looper.getMainLooper()).idle()
+
+        val options = SentryOptions().apply {
+            sessionReplay.maskAllText = true
+        }
+
+        val textNodes = activity.get().collectNodesOfType<TextViewHierarchyNode>(options)
+        // the text should be laid out when fontSize is specified
+        assertEquals("Random repo", (textNodes.first().layout as? ComposeTextLayout)?.layout?.layoutInput?.text?.text)
+    }
+
+    @Test
+    fun `when text input field is readOnly still masks it`() {
+        ComposeMaskingOptionsActivity.textFieldModifierApplier = {
+            // newer versions of compose basically do this when a TextField is readOnly
+            Modifier.clearAndSetSemantics { editableText = AnnotatedString("Placeholder") }
+        }
+        val activity = buildActivity(ComposeMaskingOptionsActivity::class.java).setup()
+        shadowOf(Looper.getMainLooper()).idle()
+
+        val options = SentryOptions().apply {
+            sessionReplay.maskAllText = true
+        }
+
+        val textNodes = activity.get().collectNodesOfType<TextViewHierarchyNode>(options)
+        assertTrue(textNodes[1].shouldMask)
     }
 
     @Test
@@ -212,7 +252,9 @@ private class ComposeMaskingOptionsActivity : ComponentActivity() {
 
     companion object {
         var textModifierApplier: (() -> Modifier)? = null
+        var textFieldModifierApplier: (() -> Modifier)? = null
         var containerModifierApplier: (() -> Modifier)? = null
+        var fontSizeApplier: (() -> TextUnit)? = null
     }
 
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -232,11 +274,12 @@ private class ComposeMaskingOptionsActivity : ComponentActivity() {
                     contentDescription = null,
                     modifier = Modifier.padding(vertical = 16.dp)
                 )
+                Text("Random repo", fontSize = fontSizeApplier?.invoke() ?: TextUnit.Unspecified)
                 TextField(
+                    modifier = textFieldModifierApplier?.invoke() ?: Modifier,
                     value = TextFieldValue("Placeholder"),
                     onValueChange = { _ -> }
                 )
-                Text("Random repo")
                 Button(
                     onClick = {},
                     modifier = Modifier
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/compose/ComposeActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/compose/ComposeActivity.kt
@@ -106,7 +106,11 @@ fun Github(
     val scope = rememberCoroutineScope()
 
     LaunchedEffect(perPage) {
-        result = GithubAPI.service.listReposAsync(user.text, perPage).random().full_name
+        result = try {
+            GithubAPI.service.listReposAsync(user.text, perPage).random().full_name
+        } catch (e: Throwable) {
+            "error"
+        }
     }
 
     SentryTraced("github-$user") {
@@ -133,12 +137,15 @@ fun Github(
                     user = newText
                 }
             )
-            Text("Random repo $result")
+            Text("Random repo: $result")
             Button(
                 onClick = {
                     scope.launch {
-                        result =
+                        result = try {
                             GithubAPI.service.listReposAsync(user.text, perPage).random().full_name
+                        } catch (e: Throwable) {
+                            "error"
+                        }
                     }
                 },
                 modifier = Modifier
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
@@ -2185,6 +2185,12 @@ public final class io/sentry/RequestDetails {
 	public fun getUrl ()Ljava/net/URL;
 }
 
+public final class io/sentry/RequestDetailsResolver {
+	public fun <init> (Lio/sentry/SentryOptions;)V
+	public fun <init> (Ljava/lang/String;Ljava/lang/String;)V
+	public fun resolve ()Lio/sentry/RequestDetails;
+}
+
 public final class io/sentry/SamplingContext {
 	public fun <init> (Lio/sentry/TransactionContext;Lio/sentry/CustomSamplingContext;)V
 	public fun <init> (Lio/sentry/TransactionContext;Lio/sentry/CustomSamplingContext;Ljava/lang/Double;Ljava/util/Map;)V
diff --git a/sentry/src/main/java/io/sentry/RequestDetailsResolver.java b/sentry/src/main/java/io/sentry/RequestDetailsResolver.java
@@ -4,24 +4,39 @@
 import java.net.URI;
 import java.util.HashMap;
 import java.util.Map;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /** Resolves {@link RequestDetails}. */
-final class RequestDetailsResolver {
+@ApiStatus.Experimental
+public final class RequestDetailsResolver {
   /** HTTP Header for the user agent. */
   private static final String USER_AGENT = "User-Agent";
   /** HTTP Header for the authentication to Sentry. */
   private static final String SENTRY_AUTH = "X-Sentry-Auth";
 
-  private final @NotNull SentryOptions options;
+  private final @NotNull Dsn dsn;
+  private final @Nullable String sentryClientName;
 
+  public RequestDetailsResolver(
+      final @NotNull String dsn, final @Nullable String sentryClientName) {
+    Objects.requireNonNull(dsn, "dsn is required");
+
+    this.dsn = new Dsn(dsn);
+    this.sentryClientName = sentryClientName;
+  }
+
+  @ApiStatus.Internal
   public RequestDetailsResolver(final @NotNull SentryOptions options) {
-    this.options = Objects.requireNonNull(options, "options is required");
+    Objects.requireNonNull(options, "options is required");
+
+    this.dsn = options.retrieveParsedDsn();
+    this.sentryClientName = options.getSentryClientName();
   }
 
   @NotNull
-  RequestDetails resolve() {
-    final Dsn dsn = options.retrieveParsedDsn();
+  public RequestDetails resolve() {
     final URI sentryUri = dsn.getSentryUri();
     final String envelopeUrl = sentryUri.resolve(sentryUri.getPath() + "/envelope/").toString();
 
@@ -33,15 +48,14 @@ RequestDetails resolve() {
             + SentryClient.SENTRY_PROTOCOL_VERSION
             + ","
             + "sentry_client="
-            + options.getSentryClientName()
+            + sentryClientName
             + ","
             + "sentry_key="
             + publicKey
             + (secretKey != null && secretKey.length() > 0 ? (",sentry_secret=" + secretKey) : "");
-    final String userAgent = options.getSentryClientName();
 
     final Map<String, String> headers = new HashMap<>();
-    headers.put(USER_AGENT, userAgent);
+    headers.put(USER_AGENT, sentryClientName);
     headers.put(SENTRY_AUTH, authHeader);
 
     return new RequestDetails(envelopeUrl, headers);
