Surveillance Android avec RUM

Surveillance Android avec RUM

Le Real User Monitoring (RUM) de Datadog vous permet de visualiser et d’analyser les performances en temps réel et les parcours des utilisateurs de votre application.

Configuration

  1. Déclarez le SDK en tant que dépendance.
  2. Ajoutez les détails de l’application dans l’interface utilisateur.
  3. Initialisez la bibliothèque avec le contexte de l’application.
  4. Initialisez le monitor RUM ainsi que l’intercepteur et commencez à envoyer des données.

Version minimale du système d’exploitation Android prise en charge : le SDK Datadog pour Android prend en charge Android v19+.

Déclarer le SDK en tant que dépendance

Déclarez dd-sdk-android et le plug-in gradle en tant que dépendance dans votre fichier build.gradle :

plugins {
    id("dd-sdk-android-gradle-plugin")
}
dependencies {
    implementation "com.datadoghq:dd-sdk-android:x.x.x" 
}
buildscript {
    dependencies {
        classpath("com.datadoghq:dd-sdk-android-gradle-plugin:x.x.x")
    }
}

Ajouter les détails de l’application dans l’interface utilisateur

  1. Sélectionnez UX Monitoring > RUM Applications > New Application.
  2. Choisissez le type d’application android dans l'interface Datadog et attribuez un nom à l’application, afin de générer un ID d’application Datadog unique ainsi qu’un token client.

image

Pour assurer la sécurité de vos données, vous devez utiliser un token client. Vous ne pouvez pas vous contenter d’utiliser des clés d’API Datadog pour configurer la bibliothèque dd-sdk-android. En effet, elles risqueraient d’être exposées côté client dans le bytecode de l’APK de l’application Android. Pour en savoir plus sur la configuration d’un token client, consultez la documentation dédiée :

Initialiser la bibliothèque avec le contexte de l’application

class SampleApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        val configuration = Configuration.Builder(
            rumEnabled = true,
            crashReportsEnabled = true
        )
                        .trackInteractions()
                        .trackLongTasks(durationThreshold)
                        .useViewTrackingStrategy(strategy)
                        .build()
          val credentials = Credentials(<TOKEN_CLIENT>, <NOM_ENVIRONNEMENT>, <NOM_VARIANTE_APPLICATION>, <ID_APPLICATION>)
          Datadog.initialize(this, credentials, configuration, trackingConsent)

       }
   }
class SampleApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        val configuration = Configuration.Builder(
            rumEnabled = true,
            crashReportsEnabled = true
        )
                        .trackInteractions()
                        .trackLongTasks(durationThreshold)
                        .useViewTrackingStrategy(strategy)
                        .useEUEndpoints()
                        .build()
        val credentials = Credentials(<TOKEN_CLIENT>, <NOM_ENVIRONNEMENT>, <NOM_VARIANTE_APPLICATION>, <ID_APPLICATION>)
        Datadog.initialize(this, credentials, configuration, trackingConsent)

    }
}

Familiarisez-vous avec le fonctionnement de l’option ViewTrackingStrategy pour activer automatiquement le suivi de toutes vos vues (activités, fragments, etc.), de l’option trackingConsent pour implémenter la conformité au RGPD pour vos utilisateurs européens, et d'autres options de configuration pour initialiser la bibliothèque.

Remarque : dans les identifiants requis pour l’initialisation, vous devez également spécifier le nom de variante de votre application. Pour ce faire, utilisez votre valeur BuildConfig.FLAVOR (ou une chaîne vide si vous n’avez pas de variante). Cette étape est essentielle, car elle permet d’importer automatiquement le bon fichier mapping.txt ProGuard au moment du build, afin d’afficher les stack traces des erreurs RUM désobfusquées. Pour en savoir plus, consultez le guide d’importation de fichiers de mapping source Android.

Initialiser le monitor RUM et l’intercepteur

Configurez et enregistrez le monitor RUM. Cette opération, qui doit être effectuée une seule fois, s’effectue généralement dans la méthode onCreate() de votre application :

    val monitor = RumMonitor.Builder()
            .build()
    GlobalRum.registerIfAbsent(monitor)

Pour effectuer le suivi de vos requêtes OkHttp en tant que ressources, ajoutez l'intercepteur fourni :

    val okHttpClient =  OkHttpClient.Builder()
        .addInterceptor(DatadogInterceptor())
        .build()

Cette approche enregistre chaque requête traitée par le client OkHttpClient en tant que ressource dans RUM. Toutes les informations pertinentes sont automatiquement renseignées (URL, méthode, code de statut, erreur). Notez que seules les requêtes réseau lancées lorsqu’une vue est active font l’objet d’un suivi. Si vous souhaitez effectuer le suivi de requêtes lorsque votre application est en arrière-plan, vous pouvez créer une vue manuellement.

Remarque : si vous utilisez plusieurs intercepteurs, DatadogInterceptor doit être appelé en premier.

Vous pouvez également ajouter un EventListener pour le client OkHttpClient afin d'effectuer automatiquement le suivi des durées de ressources (fournisseurs tiers, requêtes réseau).

Pour aller plus loin

Documentation, liens et articles supplémentaires utiles: