Merge pull request #2832 from DataDog/yl/nav3/add-lifecycle

ambushwork · web-flow · commit 44d37ef58036 · 2025-08-26T16:14:02.000+02:00
RUM-11386: Make Navigation3 tracking listen to lifecycle
diff --git a/detekt_custom.yml b/detekt_custom.yml
@@ -536,7 +536,10 @@ datadog:
       - "androidx.compose.runtime.DisposableEffect(kotlin.Any?, kotlin.Any?, kotlin.Function1)"
       - "androidx.compose.runtime.DisposableEffectScope.onDispose(kotlin.Function0)"
       - "androidx.compose.runtime.LaunchedEffect(kotlin.Any?, kotlin.coroutines.SuspendFunction1)"
+      - "androidx.compose.runtime.LaunchedEffect(kotlin.Any?, kotlin.Any?, kotlin.coroutines.SuspendFunction1)"
       - "androidx.compose.runtime.LaunchedEffect(kotlin.Any?, kotlin.Any?, kotlin.Any?, kotlin.coroutines.SuspendFunction1)"
+      - "androidx.compose.runtime.produceState(kotlin.Boolean, kotlin.Any?, kotlin.coroutines.SuspendFunction1)"
+      - "androidx.compose.runtime.ProduceStateScope.awaitDispose(kotlin.Function0)"
       - "androidx.compose.runtime.remember(kotlin.Any?, kotlin.Any?, kotlin.Function0)"
       - "androidx.compose.runtime.remember(kotlin.Function0)"
       - "androidx.compose.runtime.rememberUpdatedState(com.datadog.android.rum.tracking.ComponentPredicate)"
@@ -582,6 +585,8 @@ datadog:
       - "androidx.fragment.app.FragmentManager.unregisterFragmentLifecycleCallbacks(androidx.fragment.app.FragmentManager.FragmentLifecycleCallbacks)"
       - "androidx.lifecycle.Lifecycle.addObserver(androidx.lifecycle.LifecycleObserver)"
       - "androidx.lifecycle.Lifecycle.removeObserver(androidx.lifecycle.LifecycleObserver)"
+      - "androidx.lifecycle.Lifecycle.State.isAtLeast(androidx.lifecycle.Lifecycle.State)"
+      - "androidx.lifecycle.LifecycleEventObserver(kotlin.Function2)"
       - "androidx.navigation.NavController.addOnDestinationChangedListener(androidx.navigation.NavController.OnDestinationChangedListener)"
       - "androidx.navigation.NavController.removeOnDestinationChangedListener(androidx.navigation.NavController.OnDestinationChangedListener)"
       - "androidx.recyclerview.widget.RecyclerView.findContainingViewHolder(android.view.View)"
@@ -1277,7 +1282,7 @@ datadog:
       - "kotlin.Triple.constructor(kotlin.Nothing?, kotlin.Nothing?, kotlin.Nothing?)"
       # endregion
       # region Kotlin String
-      - "kotlin.Any?.takeIf(kotlin.Function1)"
+      - "kotlin.Any?.hashCode()"
       - "kotlin.CharSequence.isNullOrEmpty()"
       - "kotlin.String.all(kotlin.Function1)"
       - "kotlin.String.codePoints()"
diff --git a/integrations/dd-sdk-android-compose/api/apiSurface b/integrations/dd-sdk-android-compose/api/apiSurface
@@ -1,13 +1,17 @@
-open class com.datadog.android.compose.AcceptAllNavKeyPredicate<T> : com.datadog.android.rum.tracking.ComponentPredicate<T>
+open class com.datadog.android.compose.AcceptAllNavKeyPredicate<T: Any> : com.datadog.android.rum.tracking.ComponentPredicate<T>
   override fun accept(T): Boolean
   override fun getViewName(T): String?
   override fun equals(Any?): Boolean
   override fun hashCode(): Int
-interface com.datadog.android.compose.AttributesResolver<T>
+interface com.datadog.android.compose.AttributesResolver<T: Any>
   fun resolveAttributes(T): Map<String, Any?>?
+interface com.datadog.android.compose.BackStackKeyResolver<T: Any>
+  fun getStableKey(T): String
 annotation com.datadog.android.compose.ComposeInstrumentation
 fun androidx.compose.ui.Modifier.datadog(String, Boolean = false): androidx.compose.ui.Modifier
 annotation com.datadog.android.compose.ExperimentalTrackingApi
+class com.datadog.android.compose.HashcodeBackStackKeyResolver<T: Any> : BackStackKeyResolver<T>
+  override fun getStableKey(T): String
 fun trackClick(String, Map<String, Any?> = remember { emptyMap() }, com.datadog.android.api.SdkCore = Datadog.getInstance(), () -> Unit): () -> Unit
 fun TrackInteractionEffect(String, androidx.compose.foundation.interaction.InteractionSource, InteractionType, Map<String, Any?> = emptyMap(), com.datadog.android.api.SdkCore = Datadog.getInstance())
 sealed class com.datadog.android.compose.InteractionType
@@ -16,5 +20,5 @@ sealed class com.datadog.android.compose.InteractionType
   class Scroll : InteractionType
     constructor(androidx.compose.foundation.gestures.ScrollableState, androidx.compose.foundation.gestures.Orientation, Boolean = false)
 fun NavigationViewTrackingEffect(androidx.navigation.NavController, Boolean = true, com.datadog.android.rum.tracking.ComponentPredicate<androidx.navigation.NavDestination> = AcceptAllNavDestinations(), com.datadog.android.api.SdkCore = Datadog.getInstance())
-fun <T> Navigation3TrackingEffect(List<T>, com.datadog.android.rum.tracking.ComponentPredicate<T> = AcceptAllNavKeyPredicate(), AttributesResolver<T>? = null, com.datadog.android.api.SdkCore = Datadog.getInstance())
+fun <T: Any> Navigation3TrackingEffect(List<T>, com.datadog.android.rum.tracking.ComponentPredicate<T> = AcceptAllNavKeyPredicate(), BackStackKeyResolver<T> = HashcodeBackStackKeyResolver(), AttributesResolver<T>? = null, com.datadog.android.api.SdkCore = Datadog.getInstance())
 fun com.datadog.android.rum.RumConfiguration.Builder.enableComposeActionTracking(): com.datadog.android.rum.RumConfiguration.Builder
diff --git a/integrations/dd-sdk-android-compose/src/main/kotlin/com/datadog/android/compose/AcceptAllNavKeyPredicate.kt b/integrations/dd-sdk-android-compose/src/main/kotlin/com/datadog/android/compose/AcceptAllNavKeyPredicate.kt
@@ -9,13 +9,13 @@ package com.datadog.android.compose
 import com.datadog.android.rum.tracking.ComponentPredicate
 
 /**
- * A [ComponentPredicate] that accepts all keys of navigation backstack.
+ * A [ComponentPredicate] that accepts all keys of navigation back stack.
  *
  * This predicate is used when you want to track all navigation keys without any filtering.
  *
  * @param T the type of the component.
  */
-open class AcceptAllNavKeyPredicate<T> : ComponentPredicate<T> {
+open class AcceptAllNavKeyPredicate<T : Any> : ComponentPredicate<T> {
     override fun accept(component: T): Boolean {
         return true
     }
diff --git a/integrations/dd-sdk-android-compose/src/main/kotlin/com/datadog/android/compose/AttributesResolver.kt b/integrations/dd-sdk-android-compose/src/main/kotlin/com/datadog/android/compose/AttributesResolver.kt
@@ -11,7 +11,7 @@ package com.datadog.android.compose
  *
  * @param T the type of the key of navigation back stack.
  */
-interface AttributesResolver<T> {
+interface AttributesResolver<T : Any> {
 
     /**
      * Resolves attributes for the given backstack key.
diff --git a/integrations/dd-sdk-android-compose/src/main/kotlin/com/datadog/android/compose/BackStackKeyResolver.kt b/integrations/dd-sdk-android-compose/src/main/kotlin/com/datadog/android/compose/BackStackKeyResolver.kt
@@ -0,0 +1,29 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.android.compose
+
+/**
+ * Resolves a stable key for an item in a back stack.
+ * A stable key means that the same item will always return the same key during its lifetime in the
+ * back stack, and that two different items should not return the same key.
+ *
+ * This is used in [com.datadog.android.rum.RumMonitor.startView] and
+ * [com.datadog.android.rum.RumMonitor.stopView] as the key to identify items in the back
+ * stack and track them as Views in RUM.
+ *
+ * @param T the type of item in the back stack.
+ */
+interface BackStackKeyResolver<T : Any> {
+
+    /**
+     * Returns a stable key for the given item.
+     *
+     * @param item the item to get the stable key for.
+     * @return a stable key for the item.
+     */
+    fun getStableKey(item: T): String
+}
diff --git a/integrations/dd-sdk-android-compose/src/main/kotlin/com/datadog/android/compose/HashcodeBackStackKeyResolver.kt b/integrations/dd-sdk-android-compose/src/main/kotlin/com/datadog/android/compose/HashcodeBackStackKeyResolver.kt
@@ -0,0 +1,21 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.android.compose
+
+/**
+ * A [BackStackKeyResolver] that uses the [Any.hashCode] of the item as its stable key.
+ *
+ * @param T the type of item in the back stack.
+ */
+class HashcodeBackStackKeyResolver<T : Any> : BackStackKeyResolver<T> {
+
+    override fun getStableKey(
+        item: T
+    ): String {
+        return item.hashCode().toString()
+    }
+}
diff --git a/integrations/dd-sdk-android-compose/src/main/kotlin/com/datadog/android/compose/Navigation3.kt b/integrations/dd-sdk-android-compose/src/main/kotlin/com/datadog/android/compose/Navigation3.kt
@@ -10,6 +10,12 @@ package com.datadog.android.compose
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.NonRestartableComposable
+import androidx.compose.runtime.State
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.produceState
+import androidx.compose.ui.platform.LocalLifecycleOwner
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
 import com.datadog.android.Datadog
 import com.datadog.android.api.InternalLogger
 import com.datadog.android.api.SdkCore
@@ -19,27 +25,29 @@ import com.datadog.android.compose.internal.SupportLibrary
 import com.datadog.android.compose.internal.sendTelemetry
 import com.datadog.android.internal.attributes.ViewScopeInstrumentationType
 import com.datadog.android.internal.attributes.enrichWithConstantAttribute
-import com.datadog.android.rum.ExperimentalRumApi
 import com.datadog.android.rum.GlobalRumMonitor
+import com.datadog.android.rum.RumMonitor
 import com.datadog.android.rum.tracking.ComponentPredicate
 
 /**
  * A side effect which should be used to track view navigation with the Navigation3
  * for Jetpack Compose setup.
  *
  * @param T the type of the key of navigation back stack.
- * @param backStack backStack of the navigation to watch.
- * @param keyPredicate to accept the backstack key that will be taken into account as
+ * @param backStack back stack of the navigation to watch.
+ * @param keyPredicate to accept the back stack key that will be taken into account as
  * valid RUM View events.
- * @param attributesResolver to resolve attributes for the current backstack key.
+ * @param backStackKeyResolver to resolve stable keys for the back stack keys.
+ * @param attributesResolver to resolve attributes for the current back stack key.
  * @param sdkCore the SDK instance to use. If not provided, default instance will be used.
  */
 @Composable
 @NonRestartableComposable
-@ExperimentalRumApi
-fun <T> Navigation3TrackingEffect(
+@ExperimentalTrackingApi
+fun <T : Any> Navigation3TrackingEffect(
     backStack: List<T>,
     keyPredicate: ComponentPredicate<T> = AcceptAllNavKeyPredicate(),
+    backStackKeyResolver: BackStackKeyResolver<T> = HashcodeBackStackKeyResolver(),
     attributesResolver: AttributesResolver<T>? = null,
     sdkCore: SdkCore = Datadog.getInstance()
 ) {
@@ -54,16 +62,18 @@ fun <T> Navigation3TrackingEffect(
     InternalNavigation3TrackingStrategy(
         backStack = backStack,
         destinationPredicate = keyPredicate,
+        backStackKeyResolver = backStackKeyResolver,
         attributesResolver = attributesResolver,
         sdkCore = sdkCore
     )
 }
 
 @Composable
 @NonRestartableComposable
-internal fun <T> InstrumentedNavigation3TrackingEffect(
+internal fun <T : Any> InstrumentedNavigation3TrackingEffect(
     backStack: List<T>,
     keyPredicate: ComponentPredicate<T> = AcceptAllNavKeyPredicate(),
+    backStackKeyResolver: BackStackKeyResolver<T> = HashcodeBackStackKeyResolver(),
     attributesResolver: AttributesResolver<T>? = null,
     sdkCore: SdkCore = Datadog.getInstance()
 ) {
@@ -79,42 +89,95 @@ internal fun <T> InstrumentedNavigation3TrackingEffect(
         backStack = backStack,
         destinationPredicate = keyPredicate,
         attributesResolver = attributesResolver,
+        backStackKeyResolver = backStackKeyResolver,
         sdkCore = sdkCore
     )
 }
 
 @Composable
 @NonRestartableComposable
-private fun <T> InternalNavigation3TrackingStrategy(
+private fun <T : Any> InternalNavigation3TrackingStrategy(
     backStack: List<T>,
     destinationPredicate: ComponentPredicate<T> = AcceptAllNavKeyPredicate(),
+    backStackKeyResolver: BackStackKeyResolver<T> = HashcodeBackStackKeyResolver(),
     attributesResolver: AttributesResolver<T>? = null,
     sdkCore: SdkCore = Datadog.getInstance()
 ) {
+    val topKey = backStack.lastOrNull() ?: return
+    val isResumed by rememberIsResumed()
     val internalLogger = (sdkCore as? FeatureSdkCore)?.internalLogger ?: InternalLogger.UNBOUND
-    val topKey = backStack.lastOrNull()
-    LaunchedEffect(topKey) {
-        topKey?.takeIf { destinationPredicate.accept(it) }?.let { current ->
-            try {
+    LaunchedEffect(isResumed, topKey) {
+        trackBackStack(
+            topKey = topKey,
+            isResumed = isResumed,
+            keyPredicate = destinationPredicate,
+            backStackKeyResolver = backStackKeyResolver,
+            attributesResolver = attributesResolver,
+            rumMonitor = GlobalRumMonitor.get(sdkCore),
+            internalLogger = internalLogger
+        )
+    }
+}
+
+internal fun <T : Any> trackBackStack(
+    topKey: T,
+    isResumed: Boolean,
+    keyPredicate: ComponentPredicate<T> = AcceptAllNavKeyPredicate(),
+    backStackKeyResolver: BackStackKeyResolver<T>,
+    attributesResolver: AttributesResolver<T>? = null,
+    rumMonitor: RumMonitor,
+    internalLogger: InternalLogger
+) {
+    val viewKey = backStackKeyResolver.getStableKey(topKey)
+    if (isResumed) {
+        try {
+            if (keyPredicate.accept(topKey)) {
                 val attributes =
-                    attributesResolver?.resolveAttributes(current)?.toMutableMap()
+                    attributesResolver?.resolveAttributes(topKey)?.toMutableMap()
                         ?.enrichWithConstantAttribute(ViewScopeInstrumentationType.COMPOSE)
                         ?: emptyMap()
 
-                GlobalRumMonitor.get(sdkCore).startView(
-                    name = destinationPredicate.getViewName(current)
-                        ?: resolveDefaultViewName(current),
-                    key = current.toString(),
+                rumMonitor.startView(
+                    name = keyPredicate.getViewName(topKey)
+                        ?: resolveDefaultViewName(topKey),
+                    key = viewKey,
                     attributes = attributes
                 )
-            } catch (@Suppress("TooGenericExceptionCaught") e: Exception) {
+            } else {
                 internalLogger.log(
-                    InternalLogger.Level.ERROR,
-                    listOf(InternalLogger.Target.MAINTAINER, InternalLogger.Target.TELEMETRY),
-                    { "Internal operation failed on ComponentPredicate" },
-                    e
+                    InternalLogger.Level.DEBUG,
+                    InternalLogger.Target.USER,
+                    { "The provided keyPredicate did not accept the back stack top key: $topKey" }
                 )
             }
+        } catch (@Suppress("TooGenericExceptionCaught") e: Exception) {
+            internalLogger.log(
+                InternalLogger.Level.ERROR,
+                listOf(InternalLogger.Target.MAINTAINER, InternalLogger.Target.TELEMETRY),
+                { "Internal operation failed on ComponentPredicate" },
+                e
+            )
+        }
+    } else {
+        rumMonitor.stopView(viewKey)
+    }
+}
+
+@Composable
+private fun rememberIsResumed(): State<Boolean> {
+    val lifecycle = LocalLifecycleOwner.current.lifecycle
+    return produceState(
+        initialValue = lifecycle.currentState.isAtLeast(Lifecycle.State.RESUMED),
+        key1 = lifecycle
+    ) {
+        val observer = LifecycleEventObserver { _, _ ->
+            value = lifecycle.currentState.isAtLeast(Lifecycle.State.RESUMED)
+        }
+        @Suppress("ThreadSafety") // TODO RUM-525 check composable threading rules
+        lifecycle.addObserver(observer)
+        awaitDispose {
+            @Suppress("ThreadSafety") // TODO RUM-525 check composable threading rules
+            lifecycle.removeObserver(observer)
         }
     }
 }
diff --git a/integrations/dd-sdk-android-compose/src/test/kotlin/com/datadog/android/compose/HashcodeBackStackKeyResolverTest.kt b/integrations/dd-sdk-android-compose/src/test/kotlin/com/datadog/android/compose/HashcodeBackStackKeyResolverTest.kt
@@ -0,0 +1,67 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.android.compose
+
+import fr.xgouchet.elmyr.annotation.IntForgery
+import fr.xgouchet.elmyr.annotation.StringForgery
+import fr.xgouchet.elmyr.junit5.ForgeExtension
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(ForgeExtension::class)
+internal class HashcodeBackStackKeyResolverTest {
+
+    private val testedResolver = HashcodeBackStackKeyResolver<Any>()
+
+    @Test
+    fun `M return item hashcode as string W getStableKey()`(
+        @StringForgery testItem: String
+    ) {
+        // Given
+        val expectedKey = testItem.hashCode().toString()
+
+        // When
+        val actualKey = testedResolver.getStableKey(testItem)
+
+        // Then
+        assertThat(actualKey).isEqualTo(expectedKey)
+    }
+
+    @Test
+    fun `M return item hashcode as string W getStableKey {data class}`(
+        @StringForgery testItemId: String,
+        @IntForgery testItemValue: Int
+    ) {
+        // Given
+        val testItem = TestDataClass(testItemId, testItemValue)
+        val identicalItem = TestDataClass(testItemId, testItemValue)
+        val expectedKey = identicalItem.hashCode().toString()
+
+        // When
+        val actualKey = testedResolver.getStableKey(testItem)
+
+        // Then
+        assertThat(actualKey).isEqualTo(expectedKey)
+    }
+
+    @Test
+    fun `M return item hashcode as string W getStableKey {integer}`(
+        @IntForgery testItem: Int
+    ) {
+        // Given
+        val expectedKey = testItem.hashCode().toString()
+
+        // When
+        val actualKey = testedResolver.getStableKey(testItem)
+
+        // Then
+        assertThat(actualKey).isEqualTo(expectedKey)
+    }
+
+    data class TestDataClass(val id: String, val value: Int)
+}
diff --git a/integrations/dd-sdk-android-compose/src/test/kotlin/com/datadog/android/compose/Navigation3Test.kt b/integrations/dd-sdk-android-compose/src/test/kotlin/com/datadog/android/compose/Navigation3Test.kt

Original file line number	Diff line number	Diff line change
`@@ -9,13 +9,13 @@ package com.datadog.android.compose`
`9`	`9`	`import com.datadog.android.rum.tracking.ComponentPredicate`
`10`	`10`
`11`	`11`	`/**`
`12`		`- * A [ComponentPredicate] that accepts all keys of navigation backstack.`
	`12`	`+ * A [ComponentPredicate] that accepts all keys of navigation back stack.`
`13`	`13`	`*`
`14`	`14`	`* This predicate is used when you want to track all navigation keys without any filtering.`
`15`	`15`	`*`
`16`	`16`	`* @param T the type of the component.`
`17`	`17`	`*/`
`18`		`-open class AcceptAllNavKeyPredicate<T> : ComponentPredicate<T> {`
	`18`	`+open class AcceptAllNavKeyPredicate<T : Any> : ComponentPredicate<T> {`
`19`	`19`	`override fun accept(component: T): Boolean {`
`20`	`20`	`return true`
`21`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ package com.datadog.android.compose`
`11`	`11`	`*`
`12`	`12`	`* @param T the type of the key of navigation back stack.`
`13`	`13`	`*/`
`14`		`-interface AttributesResolver<T> {`
	`14`	`+interface AttributesResolver<T : Any> {`
`15`	`15`
`16`	`16`	`/**`
`17`	`17`	`* Resolves attributes for the given backstack key.`