1. Configurez la surveillance RUM du navigateur.

2. Initialisez le SDK RUM. Configurez le paramètre d’initialisation allowedTracingUrls avec la liste des origines internes et de première partie appelées par votre application navigateur.

   Pour npm install :

   import { datadogRum } from '@datadog/browser-rum'
   
   datadogRum.init({
     clientToken: '<CLIENT_TOKEN>',
     applicationId: '<APPLICATION_ID>',
     site: 'datadoghq.com',
     //  service: 'my-web-application',
     //  env: 'production',
     //  version: '1.0.0',
     allowedTracingUrls: [
       "https://api.example.com",
       // Matches any subdomain of my-api-domain.com, such as https://foo.my-api-domain.com
       /^https:\/\/[^\/]+\.my-api-domain\.com/,
       // You can also use a function for advanced matching:
       (url) => url.startsWith("https://api.example.com")
     ],
     sessionSampleRate: 100,
     sessionReplaySampleRate: 100, // if not specified, defaults to 100
     trackResources: true,
     trackLongTasks: true,
     trackUserInteractions: true,
   })
   

   Pour CDN install :

   window.DD_RUM.init({
      clientToken: '<CLIENT_TOKEN>',
      applicationId: '<APPLICATION_ID>',
      site: 'datadoghq.com',
      //  service: 'my-web-application',
      //  env: 'production',
      //  version: '1.0.0',
      allowedTracingUrls: [
        "https://api.example.com",
        // Matches any subdomain of my-api-domain.com, such as https://foo.my-api-domain.com
        /^https:\/\/[^\/]+\.my-api-domain\.com/,
        // You can also use a function for advanced matching:
        (url) => url.startsWith("https://api.example.com")
      ],
      sessionSampleRate: 100,
      sessionReplaySampleRate: 100, // if not included, the default is 100
      trackResources: true,
      trackLongTasks: true,
      trackUserInteractions: true,
    })
   

   To connect RUM to Traces, you need to specify your browser application in the service field.

   allowedTracingUrls matches the full URL (<scheme>://<host>[:<port>]/<path>[?<query>][#<fragment>]). It accepts the following types:

   • string: matches any URL that starts with the value, so https://api.example.com matches https://api.example.com/v1/resource.
   • RegExp: matches if any substring of the URL matches the provided RegExp. For example, /^https:\/\/[^\/]+\.my-api-domain\.com/ matches URLs like https://foo.my-api-domain.com/path, but not https://notintended.com/?from=guess.my-api-domain.com. Note: The RegExp is not anchored to the start of the URL unless you use ^. Be careful, as overly broad patterns can unintentionally match unwanted URLs and cause CORS errors.
   • function: evaluates with the URL as parameter. Returning a boolean set to true indicates a match.

3. (Optionnel) Configurez le paramètre d’initialisation traceSampleRate pour conserver un pourcentage défini des traces backend. S’il n’est pas défini, 100 % des traces provenant des requêtes du navigateur sont envoyées à Datadog. Pour conserver 20 % des traces backend, par exemple :

   import { datadogRum } from '@datadog/browser-rum'
   
   datadogRum.init({
       ...otherConfig,
       traceSampleRate: 20
   })
   

Remarque : traceSampleRate n’a pas d’impact sur l’échantillonnage des sessions RUM. Seules les traces backend sont échantillonnées.

4. (Optionnel) Si vous définissez un traceSampleRate, pour garantir que les décisions d’échantillonnage des services backend sont toujours appliquées, configurez le paramètre d’initialisation traceContextInjection à sampled (défini à sampled par défaut).

   Par exemple, si vous définissez le traceSampleRate à 20 % dans le Browser SDK :

   • Lorsque traceContextInjection est défini sur all, 20 % des traces backend sont conservées et 80 % des traces backend sont supprimées.

   • When traceContextInjection is set to sampled, 20% of backend traces are kept. For the remaining 80%, the browser SDK does not inject a sampling decision. The decision is made on the server side and is based on the SDK head-based sampling configuration. In the example below, the backend sample rate is set to 40%, and therefore 32% of the remaining backend traces are kept.

1. Configurez la surveillance RUM Android.

2. Configurez Android Trace Collection.

3. Ajoutez la dépendance Gradle à la bibliothèque dd-sdk-android-okhttp dans le fichier build.gradle au niveau du module :

   dependencies {
       implementation "com.datadoghq:dd-sdk-android-okhttp:x.x.x"
   }
   

4. Configurez l’intercepteur OkHttpClient avec la liste des origines internes et de première partie appelées par votre application Android.

   val tracedHosts = listOf("example.com", "example.eu")
   
   val okHttpClient = OkHttpClient.Builder()
       .addInterceptor(DatadogInterceptor.Builder(tracedHosts).build())
       .addNetworkInterceptor(TracingInterceptor.Builder(tracedHosts).build())
       .eventListenerFactory(DatadogEventListener.Factory())
       .build()
   

   By default, all subdomains of listed hosts are traced. For instance, if you add example.com, you also enable the tracing for api.example.com and foo.example.com.

5. (Optionnel) Configurez le paramètre traceSampleRate pour conserver un pourcentage défini des traces backend. S’il n’est pas défini, 100 % des traces provenant des requêtes d’application sont envoyées à Datadog. Pour conserver 20 % des traces backend :

   val tracedHosts = listOf("example.com")
   
   val okHttpClient = OkHttpClient.Builder()
       .addInterceptor(
         DatadogInterceptor.Builder(tracedHosts)
             .setTraceSampleRate(20f)
             .build()
       )
       .build()
   

Remarque :

• traceSampleRate n’impacte pas l’échantillonnage des sessions RUM. Seules les traces backend sont échantillonnées.
• Si vous définissez des types d’en-têtes de traçage personnalisés dans la configuration de Datadog et que vous utilisez un traceur enregistré avec GlobalTracer, assurez-vous que les mêmes types d’en-têtes de traçage sont définis pour le SDK utilisé.

1. Configurez la surveillance RUM iOS.

2. Activez RUM et l’instrumentation URLSession avec la configuration urlSessionTracking et le paramètre firstPartyHostsTracing :

   RUM.enable(
       with: RUM.Configuration(
           applicationID: "<rum application id>",
           urlSessionTracking: .init(
               firstPartyHostsTracing: .trace(
                   hosts: [
                       "example.com",
                       "api.yourdomain.com"
                   ]
               )
           )
       )
   )
   

   Par défaut, tous les sous-domaines des hôtes listés sont tracés. Par exemple, si vous ajoutez example.com, vous activez également le traçage pour api.example.com et foo.example.com.

   L’injection de l’ID de trace fonctionne lorsque vous fournissez un URLRequest au URLSession. Le traçage distribué ne fonctionne pas lorsque vous utilisez un objet URL.

3. (Optionnel) Pour une répartition détaillée des temps (résolution DNS, poignée de main SSL, temps jusqu’au premier octet, temps de connexion et durée de téléchargement), activez URLSessionInstrumentation pour votre type SessionDelegate :

   URLSessionInstrumentation.enableDurationBreakdown(
       with: .init(
           delegateClass: <YourSessionDelegate>.self
       )
   )
   
   let session = URLSession(
       configuration: ...,
       delegate: <YourSessionDelegate>(),
       delegateQueue: ...
   )
   

   Remarque : Le traçage distribué fonctionne automatiquement, mais les temps de trace sont plus précis après avoir activé URLSessionInstrumentation.

4. (Optionnel) Définissez le paramètre sampleRate pour conserver un pourcentage défini des traces backend. S’il n’est pas défini, 100 % des traces provenant des requêtes d’application sont envoyées à Datadog.

   Pour conserver 20 % des traces backend :

   RUM.enable(
       with: RUM.Configuration(
           applicationID: "<rum application id>",
           urlSessionTracking: .init(
               firstPartyHostsTracing: .trace(
                   hosts: [
                       "example.com",
                       "api.yourdomain.com"
                   ],
                   sampleRate: 20
               )
           )
       )
   )
   

Remarque : sampleRate n’impacte pas l’échantillonnage des sessions RUM. Seules les traces backend sont échantillonnées.

1. Configurez la surveillance RUM React Native.

2. Définissez le paramètre d’initialisation firstPartyHosts pour définir la liste des origines internes et de première partie appelées par votre application React Native :

   const config = new DatadogProviderConfiguration(
       // ...
   );
   config.firstPartyHosts = ["example.com", "api.yourdomain.com"];
   

   By default, all subdomains of listed hosts are traced. For instance, if you add example.com, you also enable tracing for api.example.com and foo.example.com.

3. (Optionnel) Définissez le paramètre d’initialisation resourceTracingSamplingRate pour conserver un pourcentage défini des traces backend. S’il n’est pas défini, 100 % des traces provenant des requêtes d’application sont envoyées à Datadog.

   Pour conserver 20 % des traces backend :

   const config = new DatadogProviderConfiguration(
       // ...
   );
   config.resourceTracingSamplingRate = 20;
   

   Note: resourceTracingSamplingRate does not impact RUM sessions sampling. Only backend traces are sampled out.

1. Configurez RUM Flutter Monitoring.

2. Suivez les instructions sous Suivi automatique des ressources pour inclure le package HTTP Client de Datadog et activer le suivi HTTP. Cela inclut les modifications suivantes à votre initialisation pour ajouter une liste d’origines internes de première partie appelées par votre application Flutter :

   final configuration = DatadogConfiguration(
     // ...
     // added configuration
     firstPartyHosts: ['example.com', 'api.yourdomain.com'],
   )..enableHttpTracking()
   

1. Configurez RUM Roku Monitoring.

2. Utilisez le composant datadogroku_DdUrlTransfer pour effectuer vos requêtes réseau.

       ddUrlTransfer = datadogroku_DdUrlTransfer(m.global.datadogRumAgent)
       ddUrlTransfer.SetUrl(url)
       ddUrlTransfer.EnablePeerVerification(false)
       ddUrlTransfer.EnableHostVerification(false)
       result = ddUrlTransfer.GetToString()
   

1. Configurez RUM Kotlin Multiplatform Monitoring.

2. Configurez l’instrumentation Ktor.

3. Définissez le paramètre d’initialisation tracedHosts dans la configuration du plugin Ktor de Datadog pour définir la liste des origines internes de première partie appelées par votre application Kotlin Multiplatform :

   val ktorClient = HttpClient {
       install(
           datadogKtorPlugin(
               tracedHosts = mapOf(
                   "example.com" to setOf(TracingHeaderType.DATADOG),
                   "example.eu" to setOf(TracingHeaderType.DATADOG)
               ),
               traceSampleRate = 100f
           )
       )
   }
   

   By default, all subdomains of listed hosts are traced. For instance, if you add example.com, you also enable tracing for api.example.com and foo.example.com.

4. (Optionnel) Définissez le paramètre d’initialisation traceSampleRate pour conserver un pourcentage défini des traces backend. S’il n’est pas défini, 20 % des traces provenant des requêtes de l’application sont envoyées à Datadog.

   Pour conserver 100 % des traces backend :

   val ktorClient = HttpClient {
       install(
           datadogKtorPlugin(
               tracedHosts = mapOf(
                   "example.com" to setOf(TracingHeaderType.DATADOG),
                   "example.eu" to setOf(TracingHeaderType.DATADOG)
               ),
               traceSampleRate = 100f
           )
       )
   }
   

   Note: traceSampleRate does not impact RUM sessions sampling. Only backend traces are sampled out.

1. Visitez une page de votre application.
2. Dans les outils de développement de votre navigateur, allez à l’onglet Réseau.
3. Vérifiez les en-têtes de la requête d’une ressource que vous attendez corrélée et assurez-vous qu’ils contiennent les en-têtes de corrélation de Datadog.

1. Exécutez votre application depuis Android Studio.
2. Visitez un écran de votre application.
3. Ouvrez l’inspecteur de réseau d’Android Studio.
4. Vérifiez les en-têtes de requête pour une ressource RUM et vérifiez que les en-têtes requis sont définis par le SDK.

1. Exécutez votre application depuis Xcode.
2. Visitez un écran de votre application.
3. Ouvrez l’instrument Réseaux et Trafic HTTP d’Xcode.
4. Vérifiez les en-têtes de requête pour une ressource RUM et vérifiez que les en-têtes requis sont définis par le SDK.

1. Exécutez votre application depuis Xcode (iOS) ou Android Studio (Android).
2. Visitez un écran de votre application.
3. Ouvrez l’instrument Réseaux et Trafic HTTP d’Xcode ou l’Inspecteur de Réseau d’Android Studio.
4. Vérifiez les en-têtes de requête pour une ressource RUM et vérifiez que les en-têtes requis sont définis par le SDK.

1. Exécutez votre application en utilisant votre IDE préféré ou flutter run.
2. Visitez un écran de votre application.
3. Ouvrez les Outils de Développement de Flutter et naviguez vers Vue Réseau.
4. Vérifiez les en-têtes de requête pour une ressource RUM et vérifiez que les en-têtes requis sont définis par le SDK.

1. Exécutez votre application depuis Xcode (iOS) ou Android Studio (Android).
2. Visitez un écran de votre application.
3. Ouvrez l’instrument Réseaux et Trafic HTTP d’Xcode ou l’Inspecteur de Réseau d’Android Studio.
4. Vérifiez les en-têtes de requête pour une ressource RUM et vérifiez que les en-têtes requis sont définis par le SDK.

Remarque : Si vous utilisez un framework backend tel que Next.js/Vercel qui utilise OpenTelemetry, suivez ces étapes.

1. Configurez RUM pour se connecter à APM comme décrit ci-dessus.

2. Modifiez allowedTracingUrls comme suit :

   import { datadogRum } from '@datadog/browser-rum'
   
   datadogRum.init({
       ...otherConfig,
       allowedTracingUrls: [
         { match: "https://api.example.com", propagatorTypes: ["tracecontext"]}
       ]
   })
   

   match accepts the same parameter types (string, RegExp or function) as when used in its simple form, described above.

   propagatorTypes accepts a list of strings for desired propagators:

   • datadog: Datadog’s propagator (x-datadog-*)
   • tracecontext: W3C Trace Context (traceparent, tracestate)
   • b3: B3 single header (b3)
   • b3multi: B3 multiple headers (X-B3-*)

1. Configurez RUM pour se connecter à APM comme décrit ci-dessus.

2. Utilisez .traceWithHeaders(hostsWithHeaders:sampleRate:) au lieu de .trace(hosts:sampleRate:) comme suit :

     RUM.enable(
         with: RUM.Configuration(
             applicationID: "<rum application id>",
             urlSessionTracking: .init(
                 firstPartyHostsTracing: .traceWithHeaders(
                     hostsWithHeaders: [
                         "api.example.com": [.tracecontext]
                     ],
                     sampleRate: 100
                 )
             )
         )
     )
   

   .traceWithHeaders(hostsWithHeaders:sampleRate:) takes Dictionary<String, Set<TracingHeaderType>> as a parameter, where the key is a host and the value is a list of supported tracing header types.

   TracingHeaderType in an enum representing the following tracing header types:

   • .datadog: Datadog’s propagator (x-datadog-*)
   • .tracecontext: W3C Trace Context (traceparent)
   • .b3: B3 single header (b3)
   • .b3multi: B3 multiple headers (X-B3-*)

1. Configurez RUM pour se connecter à APM comme décrit ci-dessus.

2. Configurez l’intercepteur OkHttpClient avec la liste des origines internes et de première partie ainsi que le type d’en-tête de traçage à utiliser comme suit:

   val tracedHosts = mapOf("example.com" to setOf(TracingHeaderType.TRACECONTEXT),
                         "example.eu" to setOf(TracingHeaderType.DATADOG))
   
   val okHttpClient = OkHttpClient.Builder()
       .addInterceptor(DatadogInterceptor.Builder(tracedHosts).build())
       .addNetworkInterceptor(TracingInterceptor.Builder(tracedHosts).build())
       .eventListenerFactory(DatadogEventListener.Factory())
       .build()
   

   TracingHeaderType is an enum representing the following tracing header types:

   • .DATADOG: Datadog’s propagator (x-datadog-*)
   • .TRACECONTEXT: W3C Trace Context (traceparent)
   • .B3: B3 single header (b3)
   • .B3MULTI: B3 multiple headers (X-B3-*)

1. Configurez RUM pour se connecter à APM.

2. Configurez le SDK RUM avec la liste des origines internes et de première partie ainsi que le type d’en-tête de traçage à utiliser comme suit:

   const config = new DatadogProviderConfiguration(
       // ...
   );
   config.firstPartyHosts = [{
       match: "example.com",
       propagatorTypes: [
           PropagatorType.TRACECONTEXT,
           PropagatorType.DATADOG
       ]
   }];
   

   PropagatorType is an enum representing the following tracing header types:

   • PropagatorType.DATADOG: Datadog’s propagator (x-datadog-*)
   • PropagatorType.TRACECONTEXT: W3C Trace Context (traceparent)
   • PropagatorType.B3: B3 single header (b3)
   • PropagatorType.B3MULTI: B3 multiple headers (X-B3-*)

1. Configurez RUM pour se connecter à APM comme décrit ci-dessus.

2. Utilisez firstPartyHostsWithTracingHeaders au lieu de firstPartyHosts comme suit :

   final configuration = DatadogConfiguration(
     // ...
     // added configuration
     firstPartyHostsWithTracingHeaders: {
       'example.com': { TracingHeaderType.tracecontext },
     },
   )..enableHttpTracking()
   

   firstPartyHostsWithTracingHeaders takes Map<String, Set<TracingHeaderType>> as a parameter, where the key is a host and the value is a list of supported tracing header types.

   TracingHeaderType in an enum representing the following tracing header types:

   • TracingHeaderType.datadog: Datadog’s propagator (x-datadog-*)
   • TracingHeaderType.tracecontext: W3C Trace Context (traceparent)
   • TracingHeaderType.b3: B3 single header (b3)
   • TracingHeaderType.b3multi: B3 multiple headers (X-B3-*)

1. Configurez RUM pour se connecter à APM.

2. Configurez le SDK RUM avec la liste des origines internes et de première partie ainsi que le type d’en-tête de traçage à utiliser comme suit:

   val ktorClient = HttpClient {
       install(
           datadogKtorPlugin(
               tracedHosts = mapOf(
                   "example.com" to setOf(TracingHeaderType.DATADOG),
                   "example.eu" to setOf(TracingHeaderType.DATADOG)
               ),
               traceSampleRate = 100f
           )
       )
   }
   

   TracingHeaderType is an enum representing the following tracing header types:

   • TracingHeaderType.DATADOG: Datadog’s propagator (x-datadog-*)
   • TracingHeaderType.TRACECONTEXT: W3C Trace Context (traceparent)
   • TracingHeaderType.B3: B3 single header (b3)
   • TracingHeaderType.B3MULTI: B3 multiple headers (X-B3-*)

x-datadog-trace-id

Généré à partir du SDK de Real User Monitoring. Permet à Datadog de lier la trace à la ressource RUM.

x-datadog-parent-id

Généré à partir du SDK de Real User Monitoring. Permet à Datadog de générer le premier span à partir de la trace.

x-datadog-origin: rum

Généré à partir du SDK de Real User Monitoring. Permet à Datadog de détecter la source de la trace.

x-datadog-sampling-priority

Défini à 1 par le SDK de Real User Monitoring si la trace a été échantillonnée, ou 0 si ce n’est pas le cas.

traceparent: [version]-[trace id]-[parent id]-[trace flags]

version: La spécification actuelle suppose que la version est définie sur 00.

trace id: ID de trace de 128 bits, hexadécimal sur 32 caractères. L’ID de trace source est de 64 bits pour maintenir la compatibilité avec APM.

parent id: ID de span de 64 bits, hexadécimal sur 16 caractères.

trace flags: Échantillonné (01) ou non échantillonné (00)

Conversion de l’ID de trace : L’ID de trace W3C de 128 bits est créé en complétant l’ID de trace source de 64 bits avec des zéros en tête. Cela garantit la compatibilité avec APM tout en respectant la spécification du contexte de traçage W3C. L’ID de trace d’origine de 64 bits devient les 64 bits inférieurs de l’ID de trace W3C de 128 bits.

tracestate: dd=s:[sampling priority];o:[origin]

dd: Le préfixe de fournisseur de Datadog.

sampling priority: Défini sur 1 si la trace a été échantillonnée, ou 0 si ce n’est pas le cas.

origin: Toujours défini sur rum pour s’assurer que les traces générées par la surveillance des utilisateurs réels n’affectent pas vos comptes d’index de spans APM.

Exemples :

ID de trace source (64 bits) : 8448eb211c80319c

Contexte de trace W3C (128 bits) : 00000000000000008448eb211c80319c

La relation montre que l’ID de trace d’origine de 64 bits 8448eb211c80319c est complété par 16 zéros en tête (0000000000000000) pour créer l’ID de trace W3C de 128 bits.

Exemple complet de traceparent :

traceparent: 00-00000000000000008448eb211c80319c-b7ad6b7169203331-01

tracestate: dd=s:1;o:rum

b3: [ID de trace]-[ID de span]-[échantillonné]

trace id: ID de trace de 64 bits, hexadécimal sur 16 caractères.

span id: ID de span de 64 bits, hexadécimal sur 16 caractères.

sampled: Vrai (1) ou Faux (0)

Exemple pour un en-tête b3 unique :

b3: 8448eb211c80319c-b7ad6b7169203331-1

Exemple pour des en-têtes b3 multiples :

X-B3-TraceId: 8448eb211c80319c

X-B3-SpanId: b7ad6b7169203331

X-B3-Sampled: 1