Configuration avancée du RUM sur iOS

Si vous n’avez pas encore configuré le SDK iOS RUM, consultez les instructions de configuration intégrées à l’application ou reportez-vous à la documentation sur la configuration du RUM sur iOS.

Enrichissement des sessions utilisateur

Le service RUM pour iOS effectue automatiquement le suivi d’attributs relatifs à l’activité utilisateur, aux écrans, aux erreurs et aux requêtes réseau. Consultez la documentation sur la collecte de données RUM pour en savoir plus sur les événements RUM et les attributs par défaut. Vous pouvez enrichir les informations sur les sessions utilisateur et bénéficier d’un meilleur contrôle sur les attributs recueillis en effectuant le suivi des événements personnalisés.

Vues personnalisées

En plus du suivi automatique des vues, vous pouvez effectuer le suivi de vues distinctes spécifiques comme viewControllers lorsqu’elles deviennent visibles et interactives. Arrêtez le suivi lorsque la vue n’est plus visible à l’aide des méthodes suivantes dans RUMMonitor.shared() :

• .startView(viewController:)
• .stopView(viewController:)

Par exemple :

import DatadogRUM

// dans votre `UIViewController` :
let rum = RUMMonitor.shared()

override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)
    rum.startView(viewController: self)
}

override func viewDidDisappear(_ animated: Bool) {
  super.viewDidDisappear(animated)
  rum.stopView(viewController: self)
}

@import DatadogObjc;
// dans votre `UIViewController` :

DDRUMMonitor *rum = [DDRUMMonitor shared];

- (void)viewDidAppear:(BOOL)animated {
    [super viewDidAppear:animated];

    [rum startViewWithViewController:self name:nil attributes:nil];
}

- (void)viewDidDisappear:(BOOL)animated {
    [super viewDidDisappear:animated];

    [rum stopViewWithViewController:self attributes:nil];
}

Pour découvrir les options disponibles et obtenir plus de détails, consultez la classe DDRUMMonitor.

Ajouter vos propres durées de performance

En plus des attributs RUM par défaut, vous pouvez tirer profit de l’API addTiming(name:) pour découvrir combien de temps votre application consacre à chaque tâche. Les mesures de temps sont exprimées en fonction du début de la vue RUM actuelle.

Par exemple, vous pouvez mesurer le temps nécessaire pour afficher votre bannière :

func onHeroImageLoaded() {
    let rum = RUMMonitor.shared()
    rum.addTiming(name: "hero_image")
} 

- (void)onHeroImageLoad {
    [[DDRUMMonitor shared] addTimingWithName:@"hero_image"];
}

Une fois la durée définie, elle est représentée par @view.custom_timings.<nom_durée>. Exemple : @view.custom_timings.hero_image.

Pour créer des visualisations dans vos dashboards, commencez par créer une mesure.

Actions personnalisées

En plus du suivi automatique des actions, vous pouvez effectuer le suivi d’actions utilisateur personnalisées, comme des touchers, des clics et des défilements, via l’API addAction(type:name:).

Pour enregistrer manuellement des actions RUM instantanées, comme .tap sur RUMMonitor.shared(), utilisez .addAction(type:name:). Pour enregistrer des actions RUM continues, comme .scroll, utilisez .startAction(type:name:) ou .stopAction(type:).

Par exemple :

import DatadogRUM

// dans votre `UIViewController` :

let rum = RUMMonitor.shared()

@IBAction func didTapDownloadResourceButton(_ sender: UIButton) {
    rum.addAction(
        type: .tap,
        name: sender.currentTitle ?? "",
    )
}

- (IBAction)didTapDownloadResourceButton:(UIButton *)sender {
    NSString *name = sender.currentTitle ? sender.currentTitle : @"";
    [[DDRUMMonitor shared] addActionWithType:DDRUMActionTypeTap name:name attributes:@{}];
}

Remarque : lorsque vous utilisez .startUserAction(type:name:) et .stopUserAction(type:), l’action type doit être identique pour que le SDK iOS RUM puisse faire correspondre le début d’une action à sa fin.

Pour découvrir les options disponibles et obtenir plus de détails, consultez la classe DDRUMMonitor.

Ressources personnalisées

En plus du suivi automatique des ressources, vous pouvez effectuer le suivi de ressources personnalisées spécifiques, comme des requêtes réseau ou des API de fournisseurs tiers. Utilisez les méthodes suivantes sur RUMMonitor.shared() pour recueillir manuellement des ressources RUM :

• .startResource(resourceKey:request:)
• .stopResource(resourceKey:response:)
• .stopResourceWithError(resourceKey:error:)
• .stopResourceWithError(resourceKey:message:)

Par exemple :

import DatadogRUM

// dans votre client réseau :

let rum = RUMMonitor.shared()

rum.startResource(
    resourceKey: "resource-key", 
    request: request
)

rum.stopResource(
    resourceKey: "resource-key",
    response: response
)

// dans votre client réseau :

[[DDRUMMonitor shared] startResourceWithResourceKey:@"resource-key"
                                            request:request
                                         attributes:@{}];

[[DDRUMMonitor shared] stopResourceWithResourceKey:@"resource-key"
                                          response:response
                                        attributes:@{}];

Remarque : la chaîne utilisée pour resourceKey dans les deux appels doit être unique à la ressource que vous appelez. Dans le cas contraire, le SDK iOS RUM ne pourra pas faire correspondre le début d’une ressource à sa fin.

Pour découvrir les options disponibles et obtenir plus de détails, consultez la classe DDRUMMonitor.

Erreurs personnalisées

Pour effectuer le suivi d’erreurs spécifiques, informez Global.rum lorsqu’une erreur survient et transmettez le message, la source, l’exception et les attributs supplémentaires. Consultez la rubrique Attributs d’erreur pour en savoir plus.

let rum = RUMMonitor.shared()
rum.addError(message: "error message.")

[[DDRUMMonitor shared] addErrorWithMessage:@"error message." stack:nil source:DDRUMErrorSourceCustom attributes:@{}];

Pour en savoir plus et découvrir toutes les options disponibles, référez-vous aux commentaires de la documentation relative au code dans la classe DDRUMMonitor.

Suivi d’attributs globaux personnalisés

En plus des attributs RUM par défaut enregistrés automatiquement par le SDK iOS RUM, vous pouvez choisir d’ajouter à vos événements RUM des informations de contexte supplémentaires, comme des attributs personnalisés, afin d’améliorer votre observabilité dans Datadog.

Les attributs personnalisés vous permettent de filtrer et de regrouper des informations à propos du comportement de l’utilisateur observé (comme la valeur de son panier, le niveau du commerçant ou la campagne publicitaire) avec des informations au niveau du code (notamment les services backend, la chronologie de la session, les logs d’erreur et la santé du réseau).

Définir un attribut global personnalisé

Pour définir un attribut global personnalisé, utilisez RUMMonitor.shared().addAttribute(forKey:value:).

• Pour ajouter un attribut, utilisez RUMMonitor.shared().addAttribute(forKey: "une clé", value: "une valeur").
• Pour mettre à jour la valeur, utilisez RUMMonitor.shared().addAttribute(forKey: "une clé", value: "une autre valeur").
• Pour supprimer une clé, utilisez RUMMonitor.shared().removeAttribute(forKey: "une clé").

Suivi des sessions utilisateur

L’ajout des informations utilisateur à vos sessions RUM facilite :

• le suivi du parcours d’un utilisateur donné ;
• l’identification des utilisateurs les plus touchés par les erreurs ;
• la surveillance des performances de vos utilisateurs les plus importants.

Les attributs suivants sont facultatifs, mais nous vous conseillons d’en spécifier au moins un :

Pour identifier des sessions utilisateur, utilisez l’API setUserInfo(id:name:email:).

Par exemple :

Datadog.setUserInfo(id: "1234", name: "John Doe", email: "john@doe.com")

[DDDatadog setUserInfoWithId:@"1234" name:@"John Doe" email:@"john@doe.com" extraInfo:@{}];

Paramètres d’initialisation

Les propriétés suivantes peuvent être utilisées dans Datadog.Configuration lors de la création de la configuration Datadog pour initialiser la bibliothèque :

site

Définit l’endpoint du serveur Datadog vers lequel ces données sont envoyées.

batchSize

Définit la taille souhaitée pour les groupes de données importés dans Datadog. Cette valeur modifie la taille et le nombre des requêtes transmises par le SDK iOS RUM. De petits groupes impliquent l’envoi d’un plus grand nombre de requêtes de petite taille. Valeurs disponibles : .small, .medium et .large.

uploadFrequency

Définit la fréquence souhaitée pour l’importation des données dans Datadog. Valeurs disponibles : .frequent, .average et .rare.

Configuration RUM

Vous pouvez utiliser les propriétés suivantes dans RUM.Configuration lors de l’activation de RUM :

sessionSampleRate

Définit le taux d’échantillonnage des sessions RUM. La valeur sessionSampleRate doit être comprise entre 0.0 et 100.0. La valeur 0.0 signifie qu’aucune session n’est envoyée, tandis que la valeur 100.0 entraîne l’envoi de toutes les sessions à Datadog. Si vous ne configurez pas ce paramètre, la valeur par défaut 100.0 est utilisée.

uiKitViewsPredicate

Active le suivi des UIViewControllers en tant que vues RUM. Vous pouvez utiliser l’implémentation par défaut de predicate en définissant le paramètre DefaultUIKitRUMViewsPredicate ou implémenter votre propre UIKitRUMViewsPredicate personnalisé pour votre application.

uiKitActionsPredicate

Active le suivi des interactions utilisateur (touchers) en tant qu’actions RUM. Vous pouvez utiliser l’implémentation par défaut de predicate en définissant le paramètre DefaultUIKitRUMActionsPredicate ou implémenter votre propre UIKitRUMActionsPredicate personnalisé pour votre application.

urlSessionTracking

Active le suivi des tâches URLSession (requêtes réseau) en tant que ressources RUM. Le paramètre firstPartyHostsTracing définit les hosts qui sont considérés comme des ressources first-party (si la fonctionnalité RUM est activée) et qui reçoivent des informations de tracing (si la fonctionnalité de tracing est activée). Le paramètre resourceAttributesProvider définit une fermeture pour appliquer des attributs personnalisés aux ressources interceptées, et celle-ci est appelée pour chaque ressource recueillie par le SDK RUM pour iOS. Cette fermeture est appelée avec des informations de tâche et peut renvoyer des attributs de ressource personnalisés, ou la valeur nil si aucun attribut ne doit être ajouté.

viewEventMapper

Définit le rappel de nettoyage de données pour les vues. Cela vous permet de modifier des événements de vue avant leur envoi à Datadog. Consultez la rubrique Modifier ou ignorer des événements RUM pour en savoir plus.

resourceEventMapper

Définit le rappel de nettoyage de données pour les ressources. Cela vous permet de modifier ou d’ignorer des événements de ressource avant leur envoi à Datadog. Consultez la rubrique Modifier ou ignorer des événements RUM pour en savoir plus.

actionEventMapper

Définit le rappel de nettoyage de données pour les actions. Cela vous permet de modifier ou d’ignorer des événements d’action avant leur envoi à Datadog. Consultez la rubrique Modifier ou ignorer des événements RUM pour en savoir plus.

errorEventMapper

Définit le rappel de nettoyage de données pour les erreurs. Cela vous permet de modifier ou d’ignorer des événements d’erreur avant leur envoi à Datadog. Consultez la rubrique Modifier ou ignorer des événements RUM pour en savoir plus.

longTaskEventMapper

Définit le rappel de nettoyage de données pour les tâches longues. Cela vous permet de modifier ou d’ignorer des événements de tâche longue avant leur envoi à Datadog. Consultez la rubrique Modifier ou ignorer des événements RUM pour en savoir plus.

vitalsUpdateFrequency

Définit la fréquence souhaitée pour la collecte des signaux mobiles essentiels. Valeurs disponibles : .frequent (toutes les 100 ms), .average (toutes les 500 ms), .rare (toutes les 1 s) et .never (désactive le suivi des signaux).

Suivi automatique des vues

Pour effectuer le suivi automatique des vues (UIViewControllers), utilisez l’option uiKitViewsPredicate lors de l’activation de RUM. Par défaut, le nom des vues est basé sur le nom de la classe du contrôleur des vues. Pour le personnaliser, fournissez votre propre implémentation du predicate en prenant soin de respecter le protocole UIKitRUMViewsPredicate :

public protocol UIKitRUMViewsPredicate {
    func rumView(for viewController: UIViewController) -> RUMView?
}

@objc
public protocol DDUIKitRUMViewsPredicate: AnyObject {
    func rumView(for viewController: UIViewController) -> DDRUMView?
}

Au sein de l’implémentation rumView(for:), votre application doit décider si une instance donnée de UIViewController doit démarrer la vue RUM (ce qui entraîne l’envoi de sa valeur) ou non (ce qui l’entraîne l’envoi de la valeur nil). La valeur de RUMView renvoyée doit spécifier le name et peut fournir des attributes supplémentaires pour la vue RUM créée.

Par exemple, vous pouvez configurer le predicate de façon à utiliser un check explicite pour chaque contrôleur de vue de votre application :

class YourCustomPredicate: UIKitRUMViewsPredicate {

    func rumView(for viewController: UIViewController) -> RUMView? {
        switch viewController {
        case is HomeViewController:     return .init(name: "Accueil")
        case is DetailsViewController:  return .init(name: "Détails")
        default:                        return nil
        }
    }
}

@interface YourCustomPredicate : NSObject<DDUIKitRUMViewsPredicate>

@end

@implementation YourCustomPredicate

- (DDRUMView * _Nullable)rumViewFor:(UIViewController * _Nonnull)viewController {
    if ([viewController isKindOfClass:[HomeViewController class]]) {
        return [[DDRUMView alloc] initWithName:@"Home" attributes:@{}];
    }

    if ([viewController isKindOfClass:[DetailsViewController class]]) {
        return [[DDRUMView alloc] initWithName:@"Details" attributes:@{}];
    }

    return nil;
}

@end

Il est même possible de mettre en place une solution plus dynamique selon l’architecture de votre application.

Par exemple, si vos contrôleurs de vue utilisent systématiquement accessibilityLabel, vous pouvez nommer les vues en tenant compte de la valeur de l’étiquette d’accessibilité :

class YourCustomPredicate: UIKitRUMViewsPredicate {

    func rumView(for viewController: UIViewController) -> RUMView? {
        guard let accessibilityLabel = viewController.accessibilityLabel else {
            return nil
        }

        return RUMView(name: accessibilityLabel)
    }
}

@interface YourCustomPredicate : NSObject<DDUIKitRUMViewsPredicate>

@end

@implementation YourCustomPredicate

- (DDRUMView * _Nullable)rumViewFor:(UIViewController * _Nonnull)viewController {
    if (viewController.accessibilityLabel) {
        return [[DDRUMView alloc] initWithName:viewController.accessibilityLabel attributes:@{}];
    }

    return nil;
}

@end

Remarque : le SDK RUM pour iOS appelle de nombreuses fois rumView(for:) pendant l’exécution de votre application. Veillez donc à ce que cette implémentation demeure rapide, avec un seul thread.

Suivi automatique des actions utilisateur

Pour effectuer le suivi automatique des actions de toucher, définissez l’option uiKitActionsPredicate lors de l’activation de RUM.

Suivi automatique des requêtes réseau

Pour effectuer automatiquement le suivi des ressources (requêtes réseau) et obtenir leurs informations de durée, comme le temps de latence du premier octet ou la résolution DNS, utilisez l’option urlSessionTracking lors de l’activation de RUM et définissez DatadogURLSessionDelegate pour la URLSession que vous souhaitez surveiller :

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

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

Vous pouvez également configurer des hosts first party à l’aide de urlSessionTracking. Ainsi, les ressources correspondant au domaine fourni sont considérées comme des « first party » dans RUM, et les informations de tracing sont transmises à votre backend (si la fonctionnalité de tracing est activée). Les traces réseau sont échantillonnées selon un taux paramétrable. Un taux d’échantillonnage de 20 % est appliqué par défaut.

Par exemple, vous pouvez configurer example.com en tant que host first party et activer les fonctionnalités RUM et de tracing :

import DatadogRUM

RUM.enable(
  with: RUM.Configuration(
    applicationID: "<ID de l'application RUM>",
    uiKitViewsPredicate: DefaultUIKitRUMViewsPredicate(),
    uiKitActionsPredicate: DefaultUIKitRUMActionsPredicate(),
    urlSessionTracking: RUM.Configuration.URLSessionTracking(
        firstPartyHostsTracing: .trace(hosts: ["example.com"], sampleRate: 20)
    )
  )
)

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

@import DatadogObjc;

DDRUMConfiguration *configuration = [[DDRUMConfiguration alloc] initWithApplicationID:@"<ID de l'application RUM>"];
DDRUMURLSessionTracking *urlSessionTracking = [DDRUMURLSessionTracking new];
[urlSessionTracking setFirstPartyHostsTracing:[DDRUMFirstPartyHostsTracing alloc] initWithHosts:@[@"example.com"] sampleRate:20];
[configuration setURLSessionTracking:urlSessionTracking];

[DDRUM enableWith:configuration];

Pour ajouter des attributs personnalisés aux ressources, utilisez l’option URLSessionTracking.resourceAttributesProvider lors de l’activation de RUM. En définissant la fermeture du fournisseur d’attributs, vous pouvez renvoyer des attributs supplémentaires afin de les joindre à la ressource suivie.

Par exemple, si vous souhaitez ajouter une requête HTTP et des en-têtes de réponse à la ressource RUM :

RUM.enable(
  with: RUM.Configuration(
    ...
    urlSessionTracking: RUM.Configuration.URLSessionTracking(
        resourceAttributesProvider: { request, response, data, error in
            return [
                "request.headers" : redactedHeaders(from: request),
                "response.headers" : redactedHeaders(from: response)
            ]
        } 
    )
  )
)

Suivi automatique des erreurs

Tous les logs de type « error » et « critical » envoyés avec Logger sont automatiquement transmis en tant qu’erreurs RUM et associés à la vue RUM actuelle :

import DatadogLogs

let logger = Logger.create()

logger.error("message")
logger.critical("message")

@import DatadogObjc;

DDLogger *logger = [DDLogger create];
[logger error:@"message"];
[logger critical:@"message"];

De la même manière, toutes les spans finalisées et considérées comme des erreurs sont transmises en tant qu’erreurs RUM :

import DatadogTrace

let span = Tracer.shared().startSpan(operationName: "operation")
// ... capturer l'`error`
span.setError(error)
span.finish()

// ... capturer l'`error`
id<OTSpan> span = [[DDTracer shared] startSpan:@"operation"];
[span setError:error];
[span finish];

Modifier ou ignorer des événements RUM

Pour modifier les attributs d’un événement RUM avant de l’envoyer à Datadog, ou pour ignorer complètement un événement, utilisez l’API Event Mappers lors de la configuration du SDK RUM pour iOS :

let configuration = RUM.Configuration(
    applicationID: "<ID de l'application RUM>",
    viewEventMapper: { viewEvent in 
        return viewEvent
    }
    resourceEventMapper: { resourceEvent in
        return resourceEvent
    }
    actionEventMapper: { actionEvent in
        return actionEvent
    }
    errorEventMapper: { errorEvent in
        return errorEvent
    }
    longTaskEventMapper: { longTaskEvent in
        return longTaskEvent
    }
)

DDRUMConfiguration *configuration = [[DDRUMConfiguration alloc] initWithApplicationID:@"<rum application id>"];

[configuration setViewEventMapper:^DDRUMViewEvent * _Nonnull(DDRUMViewEvent * _Nonnull viewEvent) {
    return viewEvent;
}];

[configuration setErrorEventMapper:^DDRUMErrorEvent * _Nullable(DDRUMErrorEvent * _Nonnull errorEvent) {
    return errorEvent;
}];

[configuration setResourceEventMapper:^DDRUMResourceEvent * _Nullable(DDRUMResourceEvent * _Nonnull resourceEvent) {
    return resourceEvent;
}];

[configuration setActionEventMapper:^DDRUMActionEvent * _Nullable(DDRUMActionEvent * _Nonnull actionEvent) {
    return actionEvent;
}];

[configuration setLongTaskEventMapper:^DDRUMLongTaskEvent * _Nullable(DDRUMLongTaskEvent * _Nonnull longTaskEvent) {
    return longTaskEvent;
}];

Chaque mapper est une fermeture Swift avec une signature (T) -> T?, où T est un type d’événement RUM concret. Cela permet de modifier des parties de l’événement avant son envoi.

Par exemple, pour effacer des informations sensibles de l’url d’une ressource RUM, implémentez une fonction redacted(_:) -> String personnalisée et utilisez-la dans resourceEventMapper :

let configuration = RUM.Configuration(
    applicationID: "<ID de l'application RUM>",
    resourceEventMapper: { resourceEvent in
        var resourceEvent = resourceEvent
        resourceEvent.resource.url = redacted(resourceEvent.resource.url)
        return resourceEvent
    }
)

DDRUMConfiguration *configuration = [[DDRUMConfiguration alloc] initWithApplicationID:@"<ID de l'application RUM>"];

[configuration setResourceEventMapper:^DDRUMResourceEvent * _Nullable(DDRUMResourceEvent * _Nonnull resourceEvent) {
    return resourceEvent;
}];

Si le mapper d’erreurs, de ressources ou d’actions renvoie la valeur nil, l’événement est entièrement ignoré, et il n’est pas envoyé à Datadog. Le mapper d’événements de vue ne doit pas renvoyer la valeur nil. Pour ignorer des vues, personnalisez votre implémentation de UIKitRUMViewsPredicate. Pour en savoir plus, consultez la rubrique Suivi automatique des vues.

Selon le type de l’événement, seules certaines propriétés peuvent être modifiées :

Activer le consentement au suivi (conformité au RGPD)

Pour répondre aux exigences du RGPD, le SDK RUM pour iOS nécessite la valeur de consentement au suivi à son initialisation.

Le paramètre trackingConsent peut prendre l’une des valeurs suivantes :

1. .pending : le SDK RUM pour iOS commence à recueillir les données et à les regrouper par lots, mais ne les envoie pas à Datadog. Il attend d’obtenir la nouvelle valeur de consentement au suivi pour déterminer ce qu’il doit faire de ces lots de données.
2. .granted : le SDK RUM pour iOS commence à recueillir les données et les envoie à Datadog.
3. .notGranted : le SDK RUM pour iOS ne recueille aucune donnée. Aucun log, aucun événement, ni aucune trace n’est envoyé à Datadog.

Pour modifier la valeur de consentement au suivi après l’initialisation du SDK RUM pour iOS, utilisez l’appel d’API Datadog.set(trackingConsent:). Le SDK modifie son comportement en tenant compte de la nouvelle valeur.

Par exemple, en cas de modification de la valeur de consentement .pending :

• Si la nouvelle valeur est .granted, le SDK RUM pour iOS envoie toutes les données actuelles et futures à Datadog.
• Si la nouvelle valeur est .notGranted, le SDK RUM pour iOS efface toutes les données actuelles et ne recueille pas les futures données.

Échantillonner des sessions RUM

Pour contrôler les données que votre application envoie au service RUM de Datadog, vous pouvez spécifier un taux d’échantillonnage pour les sessions RUM lors de l’initialisation du SDK RUM pour iOS. Ce taux est défini sous forme de pourcentage entre 0 et 100.

Par exemple, pour ne conserver que 50 % des sessions, utilisez la configuration suivante :

let configuration = RUM.Configuration(
    applicationID: "<ID de l'application RUM>",
    sessionSampleRate: 50
)

DDRUMConfiguration *configuration = [[DDRUMConfiguration alloc] initWithApplicationID:@"<ID de l'application RUM>"];
configuration.sessionSampleRate = 50;

Envoi de données lorsque l’appareil est hors ligne

La fonction RUM s’assure que les données restent disponibles, même lorsque l’appareil de l’utilisateur est hors ligne. Lorsque la connexion réseau est mauvaise ou que la batterie de l’appareil est trop faible, tous les événements RUM sont d’abord stockés en local sur l’appareil sous forme groupée. Ils sont envoyés dès que le réseau est disponible, et dès que la batterie est suffisamment élevée pour que le SDK RUM pour iOS n’affecte pas l’expérience de l’utilisateur final. Si le réseau n’est pas disponible alors que votre application s’exécute au premier plan, ou si l’envoi des données échoue, le groupe de logs est conservé jusqu’à ce qu’il puisse être envoyé.

Cela signifie que même si les utilisateurs ouvrent votre application en étant hors ligne, aucune donnée ne sera perdue.

Remarque : les données stockées sont automatiquement supprimées si elles sont trop anciennes pour limiter l’espace utilisé par le SDK RUM pour iOS.

Configuration d’un proxy personnalisé pour l’importation de données dans Datadog

Si votre application s’exécute sur des appareils qui se trouvent derrière un proxy personnalisé, vous pouvez l’indiquer à l’outil d’importation de données du SDK RUM pour iOS afin de veiller à ce que les données de suivi soient importées avec la bonne configuration.

Lors de l’initialisation du SDK iOS, spécifiez ce qui suit dans la configuration de votre proxy.

import DatadogCore

Datadog.initialize(
  with: Datadog.Configuration(
    clientToken: "<token client>",
    env: "<environnement>",
    proxyConfiguration: [
        kCFNetworkProxiesHTTPEnable: true, 
        kCFNetworkProxiesHTTPPort: 123, 
        kCFNetworkProxiesHTTPProxy: "www.example.com", 
        kCFProxyUsernameKey: "proxyuser", 
        kCFProxyPasswordKey: "proxypass" 
    ]
  ), 
  trackingConsent: trackingConsent
)

@import DatadogObjc;

DDConfiguration *configuration = [[DDConfiguration alloc] initWithClientToken:@"<token client>" env:@"<environnement>"];
configuration.proxyConfiguration = @{
    (NSString *)kCFNetworkProxiesHTTPEnable: @YES,
    (NSString *)kCFNetworkProxiesHTTPPort: @123,
    (NSString *)kCFNetworkProxiesHTTPProxy: @"www.example.com",
    (NSString *)kCFProxyUsernameKey: @"proxyuser",
    (NSString *)kCFProxyPasswordKey: @"proxypass"
}];

[DDDatadog initializeWithConfiguration:configuration
                       trackingConsent:trackingConsent];

Pour en savoir plus, consultez la documentation relative à URLSessionConfiguration.connectionProxyDictionary (en anglais).

Pour aller plus loin

Documentation, liens et articles supplémentaires utiles:

Code source de dd-sdk-iosGITHUB RUM et Session ReplayDOCUMENTATION