Surveillance iOS et tvOS avec RUM

Docs > RUM et Session Replay > Surveillance iOS et tvOS avec RUM

Présentation

La solution 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

Déclarez le SDK en tant que dépendance.
Ajoutez les détails de l’application dans l’interface utilisateur.
Initialisez la bibliothèque.
Initialisez le monitor RUM et DDURLSessionDelegate pour commencer à envoyer des données.

Remarque : la version 11 et les versions ultérieures du SDK iOS Datadog sont prises en charge. Le SDK iOS Datadog prend également en charge tvOS.

Déclarer le SDK en tant que dépendance

Déclarez dd-sdk-ios en tant que dépendance, en fonction de votre gestionnaire de packages.

Gestionnaire de packages	Méthode d’installation
CocoaPods	`pod 'DatadogSDK'`
Swift Package Manager	`.package(url: "https://github.com/DataDog/dd-sdk-ios.git", .upToNextMajor(from: "1.0.0"))`
Carthage	`github "DataDog/dd-sdk-ios"`

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

Accédez à UX Monitoring > RUM Applications > New Application.
Sélectionnez le type d’application iOS et attribuez un nom à l’application, afin de générer un ID d’application Datadog unique ainsi qu’un token client.
Pour instrumenter vos vues Web, cliquez sur le bouton Instrument your webviews. Pour en savoir plus, consultez la section Suivi des vues Web iOS.

Pour assurer la sécurité de vos données, vous devez utiliser un token client. Si vous vous contentez d’utiliser des clés d’API Datadog pour configurer la bibliothèque dd-sdk-ios, ces clés seront exposées côté client dans le bytecode de l’application iOS.

Pour en savoir plus sur la configuration d’un token client, consultez la documentation à ce sujet.

Initialiser la bibliothèque

Dans l’extrait d’initialisation, définissez un nom d’environnement, un nom de service et un numéro de version. Dans les exemples ci-dessous, app-name spécifie la variante de l’application qui génère des données.

Pour en savoir plus, consultez la section Utiliser les tags.

Datadog.initialize(
    appContext: .init(),
    trackingConsent: trackingConsent,
    configuration: Datadog.Configuration
        .builderUsing(
            rumApplicationID: "<ID_APPLICATION_RUM>",
            clientToken: "<TOKEN_CLIENT>",
            environment: "<NOM_ENVIRONNEMENT>"
        )
        .set(serviceName: "app-name")
        .set(endpoint: .us1)
        .trackUIKitRUMViews()
        .trackUIKitRUMActions()
        .trackURLSession()
        .build()
)

DDConfigurationBuilder *builder = [DDConfiguration builderWithRumApplicationID:@"<id_application_rum>"
                                                                   clientToken:@"<token_client>"
                                                                   environment:@"<nom_environnement>"];
[builder setWithServiceName:@"app-name"];
[builder setWithEndpoint:[DDEndpoint us1]];
[builder trackUIKitRUMViews];
[builder trackUIKitRUMActions];
[builder trackURLSessionWithFirstPartyHosts:[NSSet new]];

[DDDatadog initializeWithAppContext:[DDAppContext new]
                    trackingConsent:trackingConsent
                      configuration:[builder build]];

Datadog.initialize(
    appContext: .init(),
    trackingConsent: trackingConsent,
    configuration: Datadog.Configuration
        .builderUsing(
            rumApplicationID: "<ID_APPLICATION_RUM>",
            clientToken: "<TOKEN_CLIENT>",
            environment: "<NOM_ENVIRONNEMENT>"
        )
        .set(serviceName: "app-name")
        .set(endpoint: .eu1)
        .trackUIKitRUMViews()
        .trackUIKitRUMActions()
        .trackURLSession()
        .build()
)

DDConfigurationBuilder *builder = [DDConfiguration builderWithRumApplicationID:@"<id_application_rum>"
                                                                   clientToken:@"<token_client>"
                                                                   environment:@"<nom_environnement>"];
[builder setWithServiceName:@"app-name"];
[builder setWithEndpoint:[DDEndpoint eu1]];
[builder trackUIKitRUMViews];
[builder trackUIKitRUMActions];
[builder trackURLSessionWithFirstPartyHosts:[NSSet new]];

[DDDatadog initializeWithAppContext:[DDAppContext new]
                    trackingConsent:trackingConsent
                      configuration:[builder build]];

Datadog.initialize(
    appContext: .init(),
    trackingConsent: trackingConsent,
    configuration: Datadog.Configuration
        .builderUsing(
            rumApplicationID: "<ID_APPLICATION_RUM>",
            clientToken: "<TOKEN_CLIENT>",
            environment: "<NOM_ENVIRONNEMENT>"
        )
        .set(serviceName: "app-name")
        .set(endpoint: .us3)
        .trackUIKitRUMViews()
        .trackUIKitRUMActions()
        .trackURLSession()
        .build()
)

DDConfigurationBuilder *builder = [DDConfiguration builderWithRumApplicationID:@"<id_application_rum>"
                                                                   clientToken:@"<token_client>"
                                                                   environment:@"<nom_environnement>"];
[builder setWithServiceName:@"app-name"];
[builder setWithEndpoint:[DDEndpoint us3]];
[builder trackUIKitRUMViews];
[builder trackUIKitRUMActions];
[builder trackURLSessionWithFirstPartyHosts:[NSSet new]];

[DDDatadog initializeWithAppContext:[DDAppContext new]
                    trackingConsent:trackingConsent
                      configuration:[builder build]];

Datadog.initialize(
    appContext: .init(),
    trackingConsent: trackingConsent,
    configuration: Datadog.Configuration
        .builderUsing(
            rumApplicationID: "<ID_APPLICATION_RUM>",
            clientToken: "<TOKEN_CLIENT>",
            environment: "<NOM_ENVIRONNEMENT>"
        )
        .set(serviceName: "app-name")
        .set(endpoint: .us5)
        .trackUIKitRUMViews()
        .trackUIKitRUMActions()
        .trackURLSession()
        .build()
)

DDConfigurationBuilder *builder = [DDConfiguration builderWithRumApplicationID:@"<id_application_rum>"
                                                                   clientToken:@"<token_client>"
                                                                   environment:@"<nom_environnement>"];
[builder setWithServiceName:@"app-name"];
[builder setWithEndpoint:[DDEndpoint us5]];
[builder trackUIKitRUMViews];
[builder trackUIKitRUMActions];
[builder trackURLSessionWithFirstPartyHosts:[NSSet new]];

[DDDatadog initializeWithAppContext:[DDAppContext new]
                    trackingConsent:trackingConsent
                      configuration:[builder build]];

Datadog.initialize(
    appContext: .init(),
    trackingConsent: trackingConsent,
    configuration: Datadog.Configuration
        .builderUsing(
            rumApplicationID: "<ID_APPLICATION_RUM>",
            clientToken: "<TOKEN_CLIENT>",
            environment: "<NOM_ENVIRONNEMENT>"
        )
        .set(serviceName: "app-name")
        .set(endpoint: .us1_fed)
        .trackUIKitRUMViews()
        .trackUIKitRUMActions()
        .trackURLSession()
        .build()
)

DDConfigurationBuilder *builder = [DDConfiguration builderWithRumApplicationID:@"<id_application_rum>"
                                                                   clientToken:@"<token_client>"
                                                                   environment:@"<nom_environnement>"];
[builder setWithServiceName:@"app-name"];
[builder setWithEndpoint:[DDEndpoint us1_fed]];
[builder trackUIKitRUMViews];
[builder trackUIKitRUMActions];
[builder trackURLSessionWithFirstPartyHosts:[NSSet new]];

[DDDatadog initializeWithAppContext:[DDAppContext new]
                    trackingConsent:trackingConsent
                      configuration:[builder build]];

Le SDK iOS RUM effectue automatiquement le suivi des sessions utilisateur, en fonction des options fournies lors de son initialisation. Pour implémenter la conformité au RGPD pour vos utilisateurs européens et appliquer d’autres paramètres d’initialisation dans la configuration du SDK, consultez la rubrique Activer le consentement au suivi.

Initialiser le monitor RUM et `DDURLSessionDelegate`

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

import Datadog

Global.rum = RUMMonitor.initialize()

@import DatadogObjc;

DDGlobal.rum = [[DDRUMMonitor alloc] init];

Pour surveiller les requêtes envoyées par l’instance URLSession en tant que ressources, assignez DDURLSessionDelegate() en tant que delegate de la URLSession en question :

let session = URLSession(
    configuration: .default,
    delegate: DDURLSessionDelegate(),
    delegateQueue: nil
)

NSURLSession *session = [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration]
                                                      delegate:[[DDNSURLSessionDelegate alloc] init]
                                                 delegateQueue:nil];

Effectuer le suivi d’événements en arrière-plan

Vous pouvez effectuer le suivi d’événements, tels que des crashs et des requêtes réseau, pendant que votre application s’exécute en arrière-plan (par exemple, lorsqu’aucune vue active n’est disponible).

Ajoutez l’extrait suivant lors de l’initialisation dans votre configuration Datadog :

.trackBackgroundEvents()

Le suivi d'événements en arrière-plan peut générer des sessions supplémentaires et augmenter vos coûts. Si vous avez la moindre question, contactez l'assistance Datadog.

Consulter les erreurs non résolues

Les rapports de crash et le suivi des erreurs pour iOS mettent en évidence les problèmes et les dernières erreurs disponibles. Vous pouvez visualiser les détails des erreurs ainsi que les attributs, y compris le JSON, dans le RUM Explorer.