Instrumentation Jetpack Compose
Présentation
Jetpack Compose est une boîte à outils permettant de créer une interface utilisateur native sous Android. Si votre application utilise Jetpack Compose, vous pouvez l’instrumenter manuellement ou automatiquement avec le Datadog Gradle Plugin. Cela permet d’activer le Real User Monitoring (RUM), comme pour les Views Android classiques.
La version minimale de Kotlin prise en charge est 1.9.23.
Après la configuration initiale, vous pouvez choisir entre une instrumentation automatique et manuelle.
Configuration
Étape 1 – Déclarez « dd-sdk-android-compose » comme dépendance
Ajoutez dd-sdk-android-compose en tant que dépendance à chaque module que vous souhaitez instrumenter. Cela inclut le module d’application, tous les modules d’interface utilisateur Jetpack Compose ou les modules de fonctionnalités utilisant Jetpack Compose.
La version minimale de dd-sdk-android-compose pour l’instrumentation Jetpack Compose est 2.21.0.
dependencies {
implementation "com.datadoghq:dd-sdk-android-compose:x.x.x"
//(...)
}
dependencies {
implementation("com.datadoghq:dd-sdk-android-compose:x.x.x")
//(...)
}
Étape 2 – Activez l’option de suivi des actions dans RumConfiguration
Après avoir ajouté la dépendance, activez le suivi des actions Compose dans votre RumConfiguration. Cette étape est requise quel que soit le mode d’instrumentation.
val rumConfig = RumConfiguration.Builder(applicationId)
//other configurations that you have already set
.enableComposeActionTracking()
.build()
Rum.enable(rumConfig)
RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
//other configurations that you have already set
.enableComposeActionTracking()
.build();
Rum.enable(rumConfig);
Instrumentation automatique
Pour une couverture RUM complète avec une configuration minimale, vous pouvez instrumenter automatiquement votre application Jetpack Compose.
Comme décrit à l’étape 1 de la section de configuration Android, déclarez le Datadog Gradle Plugin dans votre script de build et appliquez-le à chaque module que vous souhaitez instrumenter.
Le Datadog Gradle Plugin analyse @Composable les fonctions et ajoute des tags Semantics à leurs modificateurs. Ces tags permettent à Datadog RUM de suivre les interactions des utilisateurs sur les composants Compose avec les informations de cible correctes. Le plugin détecte également NavHost l'utilisation et écoute les événements de navigation Jetpack Compose.
Étape 1 – Déclarez le Datadog Gradle Plugin dans votre script de build
La version minimale du Datadog Gradle Plugin pour l’instrumentation Jetpack Compose est 1.17.0.
buildscript {
dependencies {
classpath "com.datadoghq:dd-sdk-android-gradle-plugin:x.x.x"
}
}
plugins {
id 'com.datadoghq.dd-sdk-android-gradle-plugin'
//(...)
}
buildscript {
dependencies {
classpath("com.datadoghq:dd-sdk-android-gradle-plugin:x.x.x")
}
}
plugins {
id("com.datadoghq.dd-sdk-android-gradle-plugin")
//(...)
}
Étape 2 – Sélectionnez le mode d’instrumentation
Dans la configuration Gradle de votre module, définissez le mode d’instrumentation Compose souhaité :
datadog {
// Other configurations that you may set before.
//(...)
// Jetpack Compose instrumentation mode option.
composeInstrumentation = "AUTO"
}
datadog {
// Other configurations that you may set before.
//(...)
// Jetpack Compose instrumentation mode option.
composeInstrumentation = InstrumentationMode.AUTO
}
Modes d’instrumentation disponibles :
"AUTO" : instrumente toutes les fonctions @Composable."ANNOTATION" : instrumente uniquement les fonctions @Composable annotées avec @ComposeInstrumentation. Vous pouvez définir le périmètre de l’auto-instrumentation en utilisant cette annotation."DISABLE" : désactive complètement l’instrumentation.
InstrumentationMode.AUTO : instrumente toutes les fonctions @Composable.InstrumentationMode.ANNOTATION : instrumente uniquement les fonctions @Composable annotées avec @ComposeInstrumentation. Vous pouvez définir le périmètre de l’auto-instrumentation en utilisant cette annotation.InstrumentationMode.DISABLE : désactive complètement l’instrumentation.
Remarque : si vous ne déclarez pas composeInstrumentation dans le bloc datadog, l’auto-instrumentation est désactivée par défaut.
Comment les noms sont attribués avec l’auto-instrumentation
Lorsque l’auto-instrumentation est activée :
- La route de navigation Compose est utilisée comme nom de vue.
- Le nom de la fonction composable directe qui enveloppe un élément interactif est utilisé comme cible d’action.
@Composable
fun AppScaffold(){
NavHost(navController = rememberNavController(), startDestination = "Home Screen"){
composable("Home Screen"){
HomeScreen()
}
}
}
@Composable
fun CustomButton(onClick: () -> Unit) {
Button(onClick = onClick){
Text("Welcome Button")
}
}
Dans l’exemple ci-dessus :
- « Home Screen » est utilisé comme nom de vue lorsque
HomeScreen() est chargé. - « CustomButton » est utilisé comme cible d’action lorsque l’on clique sur le bouton.
Instrumentation manuelle
Si vous avez besoin de plus de personnalisation ou de contrôle sur le suivi des actions et des vues, vous pouvez instrumenter manuellement vos applications.
Suivi des actions
Pour suivre les interactions des utilisateurs avec des composants Jetpack Compose spécifiques, appliquez le modificateur datadog. L’argument name définit le nom de la vue affiché dans la liste des événements RUM.
@Composable
fun HomeScreen(){
Column{
Image(modifier = Modifier.datadog(name = "Welcome Image").clickable{
// Action can be tracked if this image is clickable
},
// Other arguments
)
Text(modifier = Modifier.datadog(name = "Welcome Text").clickable{
// Action can be tracked if this text is clickable
},
// Other arguments
)
}
}
Dans l’exemple ci-dessus, les noms personnalisés sont utilisés pour les éléments interactifs dans le suivi des actions RUM.
Suivi des vues
Pour activer le suivi des vues RUM basé sur la navigation Jetpack Compose, appelez l’API NavigationViewTrackingEffect et transmettez le NavHostController de votre application.
@Composable
fun AppScaffold(){
val navController = rememberNavController()
NavigationViewTrackingEffect(
navController = navController,
trackArguments = true,
destinationPredicate = AcceptAllNavDestinations()
)
NavHost(navController = navController,
// other arguments
) {
// (...)
}
}
Pour aller plus loin
Documentation, liens et articles supplémentaires utiles: