RUM-15813: Skip method scan in LayoutNodeUtils reflection fallback

satween · satween · commit c63143c525be · 2026-04-20T22:21:15.000+01:00
The Compose reflection fallback previously built a LayoutNode's
method array and scanned it on every ACTION_MOVE hit-test to find
the mangled accessors (getLayoutDelegate / getOuterCoordinator /
getCoordinates). Resolve the JVM module suffix once per instance
("", "$ui_release" or "$ui") and build every subsequent method
name via direct getMethod lookup, so the hot path no longer
allocates the methods array or walks it.

Also memoize the boundsInWindow reflection Method by lazy.
diff --git a/integrations/dd-sdk-android-compose/src/main/kotlin/com/datadog/android/compose/internal/utils/LayoutNodeUtils.kt b/integrations/dd-sdk-android-compose/src/main/kotlin/com/datadog/android/compose/internal/utils/LayoutNodeUtils.kt
@@ -22,11 +22,25 @@ import com.datadog.android.api.feature.FeatureSdkCore
 import com.datadog.android.compose.DatadogSemanticsPropertyKey
 import com.datadog.android.rum.RumAttributes.ACTION_TARGET_ROLE
 import com.datadog.android.rum.RumAttributes.ACTION_TARGET_SELECTED
+import java.lang.reflect.Method
 
 internal class LayoutNodeUtils {
 
     private var reflectionFallbackModeActivated = false
 
+    // RUM-15813: circuit breaker for the reflection fallback. Flipped to true only when
+    // reflection is proven unusable on this instance (missing boundsInWindow Method or no
+    // accessor suffix resolvable). After that we stop entering the reflection branch — it
+    // would keep throwing NoSuchMethodException on every ACTION_MOVE otherwise.
+    private var reflectionFallbackDisabled = false
+
+    // RUM-15813: Kotlin internal accessors in androidx.compose.ui are JVM-mangled with
+    // a module suffix that is stable per build (plain / "$ui" / "$ui_release"). All three
+    // prefixes we look up live in the same module, so one resolved suffix is enough to
+    // build every method name and drop the per-call javaClass.methods linear scan.
+    private var internalMethodSuffix: String? = null
+    private val boundsInWindowReflectionMethod: Method? by lazy { resolveBoundsInWindowMethod() }
+
     @Suppress("NestedBlockDepth", "CyclomaticComplexMethod")
     fun resolveLayoutNode(node: LayoutNode): TargetNode? {
         return runSafe("resolveLayoutNode") {
@@ -99,10 +113,10 @@ internal class LayoutNodeUtils {
         }
     }
 
-    fun getLayoutNodeBoundsInWindow(node: LayoutNode): Rect? = if (reflectionFallbackModeActivated) {
-        getLayoutNodeBoundsInWindowReflection(node)
-    } else {
-        getLayoutNodeBoundsInWindowInternal(node) ?: getLayoutNodeBoundsInWindowReflection(node)
+    fun getLayoutNodeBoundsInWindow(node: LayoutNode): Rect? = when {
+        reflectionFallbackDisabled -> getLayoutNodeBoundsInWindowInternal(node)
+        reflectionFallbackModeActivated -> getLayoutNodeBoundsInWindowReflection(node)
+        else -> getLayoutNodeBoundsInWindowInternal(node) ?: getLayoutNodeBoundsInWindowReflection(node)
     }
 
     private fun getLayoutNodeBoundsInWindowInternal(node: LayoutNode): Rect? = runSafe(
@@ -114,19 +128,61 @@ internal class LayoutNodeUtils {
     ) {
         // TODO RUM-13454 Update compose bom and remove this method
         reflectionFallbackModeActivated = true
-        val coordinates = node.getMethod("getLayoutDelegate")
-            ?.getMethod("getOuterCoordinator")
-            ?.getMethod("getCoordinates")
+        val method = boundsInWindowReflectionMethod
+        if (method == null) {
+            reflectionFallbackDisabled = true
+            return@runSafe null
+        }
+        val coordinates = node.invokeInternalAccessor("getLayoutDelegate")
+            ?.invokeInternalAccessor("getOuterCoordinator")
+            ?.invokeInternalAccessor("getCoordinates")
+        if (coordinates == null) {
+            // Only disable when suffix resolution itself never succeeded — i.e. no accessor
+            // exists for any known mangling. A transient null mid-chain on a working build
+            // shouldn't permanently disable the branch.
+            if (internalMethodSuffix == null) {
+                reflectionFallbackDisabled = true
+            }
+            return@runSafe null
+        }
 
         @Suppress("UnsafeThirdPartyFunctionCall") // it's okay if exception will be thrown here
+        method.invoke(null, coordinates) as? Rect
+    }
+
+    private fun resolveBoundsInWindowMethod(): Method? = runSafe(
+        "resolveBoundsInWindowMethod"
+    ) {
+        @Suppress("UnsafeThirdPartyFunctionCall") // runSafe swallows any Throwable
+        val coordinatesClass = Class.forName("androidx.compose.ui.layout.LayoutCoordinates")
+        @Suppress("UnsafeThirdPartyFunctionCall") // runSafe swallows any Throwable
         Class.forName("androidx.compose.ui.layout.LayoutCoordinatesKt")
-            .getMethod("boundsInWindow", Class.forName("androidx.compose.ui.layout.LayoutCoordinates"))
-            .invoke(null, coordinates) as? Rect
+            .getMethod("boundsInWindow", coordinatesClass)
     }
 
-    private fun Any.getMethod(prefix: String): Any? {
-        return this.javaClass.methods.firstOrNull { it.name == prefix || it.name.startsWith("$prefix$") }
-            ?.invoke(this)
+    @Suppress("UnsafeThirdPartyFunctionCall") // runSafe in the caller swallows any Throwable
+    private fun Any.invokeInternalAccessor(prefix: String): Any? {
+        val klass = this.javaClass
+        val suffix = internalMethodSuffix ?: klass.resolveInternalSuffix(prefix)?.also {
+            internalMethodSuffix = it
+        } ?: return null
+        return klass.tryGetNoArgMethod("$prefix$suffix")?.invoke(this)
+    }
+
+    private fun Class<*>.resolveInternalSuffix(prefix: String): String? {
+        for (suffix in KNOWN_INTERNAL_SUFFIXES) {
+            if (tryGetNoArgMethod("$prefix$suffix") != null) return suffix
+        }
+        return null
+    }
+
+    private fun Class<*>.tryGetNoArgMethod(name: String): Method? {
+        return try {
+            @Suppress("UnsafeThirdPartyFunctionCall") // NoSuchMethodException is expected and handled
+            getMethod(name)
+        } catch (@Suppress("SwallowedException") e: NoSuchMethodException) {
+            null
+        }
     }
 
     private fun <T> runSafe(callSite: String, action: () -> T): T? {
@@ -168,5 +224,10 @@ internal class LayoutNodeUtils {
             "androidx.compose.foundation.gestures.ScrollableElement"
         private const val CLASS_NAME_SELECTABLE_ELEMENT =
             "androidx.compose.foundation.selection.SelectableElement"
+
+        // Empty suffix covers public accessors; "$ui" and "$ui_release" cover Kotlin-internal
+        // accessors in the androidx.compose.ui module (the exact suffix depends on build
+        // configuration). Ordered by likelihood — public first, release build second.
+        private val KNOWN_INTERNAL_SUFFIXES = listOf("", "\$ui_release", "\$ui")
     }
 }
diff --git a/integrations/dd-sdk-android-compose/src/test/kotlin/com/datadog/android/compose/internal/utils/LayoutNodeGetMethodTest.kt b/integrations/dd-sdk-android-compose/src/test/kotlin/com/datadog/android/compose/internal/utils/LayoutNodeGetMethodTest.kt
@@ -11,7 +11,7 @@ import org.junit.jupiter.api.Test
 import java.lang.reflect.Method
 
 /**
- * Tests for the [LayoutNodeUtils.getMethod] reflection helper that resolves
+ * Tests for the [LayoutNodeUtils.invokeInternalAccessor] reflection helper that resolves
  * Kotlin-internal method names regardless of module-suffix mangling.
  *
  * Compose internal properties are compiled to JVM methods whose names are mangled
@@ -21,50 +21,51 @@ import java.lang.reflect.Method
  */
 internal class LayoutNodeGetMethodTest {
 
-    private val testedLayoutNodeUtils = LayoutNodeUtils()
-
-    // getMethod is private fun Any.getMethod(prefix: String): Any? compiled as an
-    // instance method with signature getMethod(Object, String) in the JVM.
-    private val getMethodFn: Method = LayoutNodeUtils::class.java
-        .getDeclaredMethod("getMethod", Any::class.java, String::class.java)
+    // invokeInternalAccessor is private fun Any.invokeInternalAccessor(prefix: String): Any? compiled
+    // as an instance method with signature invokeInternalAccessor(Object, String) in the JVM.
+    private val invokeInternalAccessorFn: Method = LayoutNodeUtils::class.java
+        .getDeclaredMethod("invokeInternalAccessor", Any::class.java, String::class.java)
         .also { it.isAccessible = true }
 
     // region $ui suffix
 
     @Test
-    fun `M find method W getMethod {method has dollar ui suffix}`() {
+    fun `M find method W invokeInternalAccessor {method has dollar ui suffix}`() {
         // Given
+        val tested = LayoutNodeUtils()
         val expected = Any()
         val fakeNode = FakeLayoutNodeUi(expected)
 
         // When
-        val result = getMethodFn.invoke(testedLayoutNodeUtils, fakeNode, "getLayoutDelegate")
+        val result = invokeInternalAccessorFn.invoke(tested, fakeNode, "getLayoutDelegate")
 
         // Then
         assertThat(result).isSameAs(expected)
     }
 
     @Test
-    fun `M find method W getMethod {outer coordinator method has dollar ui suffix}`() {
+    fun `M find method W invokeInternalAccessor {outer coordinator method has dollar ui suffix}`() {
         // Given
+        val tested = LayoutNodeUtils()
         val expected = Any()
         val fakeNode = FakeLayoutNodeUi(expected)
 
         // When
-        val result = getMethodFn.invoke(testedLayoutNodeUtils, fakeNode, "getOuterCoordinator")
+        val result = invokeInternalAccessorFn.invoke(tested, fakeNode, "getOuterCoordinator")
 
         // Then
         assertThat(result).isSameAs(expected)
     }
 
     @Test
-    fun `M find method W getMethod {coordinates method has dollar ui suffix}`() {
+    fun `M find method W invokeInternalAccessor {coordinates method has dollar ui suffix}`() {
         // Given
+        val tested = LayoutNodeUtils()
         val expected = Any()
         val fakeNode = FakeLayoutNodeUi(expected)
 
         // When
-        val result = getMethodFn.invoke(testedLayoutNodeUtils, fakeNode, "getCoordinates")
+        val result = invokeInternalAccessorFn.invoke(tested, fakeNode, "getCoordinates")
 
         // Then
         assertThat(result).isSameAs(expected)
@@ -75,55 +76,86 @@ internal class LayoutNodeGetMethodTest {
     // region $ui_release suffix
 
     @Test
-    fun `M find method W getMethod {method has dollar ui_release suffix}`() {
+    fun `M find method W invokeInternalAccessor {method has dollar ui_release suffix}`() {
         // Given
+        val tested = LayoutNodeUtils()
         val expected = Any()
         val fakeNode = FakeLayoutNodeUiRelease(expected)
 
         // When
-        val result = getMethodFn.invoke(testedLayoutNodeUtils, fakeNode, "getLayoutDelegate")
+        val result = invokeInternalAccessorFn.invoke(tested, fakeNode, "getLayoutDelegate")
 
         // Then
         assertThat(result).isSameAs(expected)
     }
 
     @Test
-    fun `M find method W getMethod {outer coordinator method has dollar ui_release suffix}`() {
+    fun `M find method W invokeInternalAccessor {outer coordinator method has dollar ui_release suffix}`() {
         // Given
+        val tested = LayoutNodeUtils()
         val expected = Any()
         val fakeNode = FakeLayoutNodeUiRelease(expected)
 
         // When
-        val result = getMethodFn.invoke(testedLayoutNodeUtils, fakeNode, "getOuterCoordinator")
+        val result = invokeInternalAccessorFn.invoke(tested, fakeNode, "getOuterCoordinator")
 
         // Then
         assertThat(result).isSameAs(expected)
     }
 
     @Test
-    fun `M find method W getMethod {coordinates method has dollar ui_release suffix}`() {
+    fun `M find method W invokeInternalAccessor {coordinates method has dollar ui_release suffix}`() {
         // Given
+        val tested = LayoutNodeUtils()
         val expected = Any()
         val fakeNode = FakeLayoutNodeUiRelease(expected)
 
         // When
-        val result = getMethodFn.invoke(testedLayoutNodeUtils, fakeNode, "getCoordinates")
+        val result = invokeInternalAccessorFn.invoke(tested, fakeNode, "getCoordinates")
 
         // Then
         assertThat(result).isSameAs(expected)
     }
 
     // endregion
 
+    // region suffix reuse
+
+    @Test
+    fun `M reuse resolved suffix W invokeInternalAccessor {subsequent prefixes on same module}`() {
+        // Given — once the first lookup resolves a suffix, later prefixes must reuse it
+        // without re-probing, because all accessors in the same compose-ui module share it.
+        val tested = LayoutNodeUtils()
+        val expected = Any()
+        val fakeNode = FakeLayoutNodeUi(expected)
+        val suffixField = LayoutNodeUtils::class.java
+            .getDeclaredField("internalMethodSuffix")
+            .also { it.isAccessible = true }
+
+        // When
+        invokeInternalAccessorFn.invoke(tested, fakeNode, "getLayoutDelegate")
+        val suffixAfterFirst = suffixField.get(tested)
+        invokeInternalAccessorFn.invoke(tested, fakeNode, "getOuterCoordinator")
+        invokeInternalAccessorFn.invoke(tested, fakeNode, "getCoordinates")
+        val suffixAfterThird = suffixField.get(tested)
+
+        // Then
+        assertThat(suffixAfterFirst).isEqualTo("\$ui")
+        assertThat(suffixAfterThird).isEqualTo("\$ui")
+    }
+
+    // endregion
+
     // region no match
 
     @Test
-    fun `M return null W getMethod {no matching method}`() {
+    fun `M return null W invokeInternalAccessor {no matching method}`() {
         // Given
+        val tested = LayoutNodeUtils()
         val fakeNode = Any()
 
         // When
-        val result = getMethodFn.invoke(testedLayoutNodeUtils, fakeNode, "getLayoutDelegate")
+        val result = invokeInternalAccessorFn.invoke(tested, fakeNode, "getLayoutDelegate")
 
         // Then
         assertThat(result).isNull()
