Associer RUM à vos traces

1. Configurez la surveillance Browser RUM.

2. Initialisez le SDK RUM. Configurez le paramètre d’initialisation allowedTracingUrls avec la liste des origines internes first party appelées par votre application Browser.

   import { datadogRum } from '@datadog/browser-rum'
   
   datadogRum.init({
       applicationId: '<DATADOG_APPLICATION_ID>',
       clientToken: '<DATADOG_CLIENT_TOKEN>',
       ...otherConfig,
       service: "my-web-application",
       allowedTracingUrls: ["https://api.example.com", /https:\/\/.*\.my-api-domain\.com/, (url) => url.startsWith("https://api.example.com")]
   })
   

   Pour associer RUM à vos traces, vous devez indiquer votre application Browser dans le champ service.

   allowedTracingUrls prend l’URL complète (<schéma>://<host>[:<port>]/<chemin>[?<requête>][#<fragment>]). Ce paramètre accepte les types suivants :

   • string : toutes les URL qui commencent par la valeur définie sont incluses. Par exemple, https://api.example.com inclut https://api.example.com/v1/resource.
   • RegExp : exécute un test avec le RegExp et l’URL fournis.
   • function : l’URL est utilisée en tant que paramètre pour l’évaluation. Lorsqu’un boolean défini sur true est renvoyé, cela indique une correspondance.

3. (Facultatif) Configurez le paramètre d’initialisation traceSampleRate pour conserver un certain pourcentage des traces backend. Si ce paramètre n’est pas défini, 100 % des traces issues des requêtes Browser sont envoyées à Datadog. Par exemple, pour ne conserver que 20 % des traces backend :

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

Remarque : le paramètre traceSampleRate n’affecte pas l’échantillonnage des sessions RUM. Seules les traces backend sont filtrées.

1. Configurez la surveillance Android RUM.

2. Configurez l’intercepteur OkHttpClient avec la liste des origines internes first party appelées par votre application Android.

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

   Par défaut, tous les sous-domaines des hosts répertoriés sont tracés. Par exemple, si vous ajoutez example.com, vous activez également le tracing de api.example.com et foo.example.com.

3. (Facultatif) Configurez le paramètre traceSamplingRate pour conserver un certain pourcentage des traces backend. Si ce paramètre n’est pas défini, 20 % des traces issues des requêtes d’application sont envoyées à Datadog. Pour conserver 100 % des traces backend :

    val okHttpClient = OkHttpClient.Builder()
        .addInterceptor(RumInterceptor(traceSamplingRate = 100f))
       .build()

Remarque : le paramètre traceSamplingRate n’affecte pas l’échantillonnage des sessions RUM. Seules les traces backend sont filtrées.

1. Configurez la surveillance iOS RUM.

2. Appelez la fonction builder trackURLSession(firstPartyHosts:) avec la liste des origines internes first party appelées par votre application iOS.

   Datadog.initialize(
       appContext: .init(),
       configuration: Datadog.Configuration
           .builderUsing(
               rumApplicationID: "<rum_app_id>", 
               clientToken: "<client_token>", 
               environment: "<env_name>"
           )
           .trackURLSession(firstPartyHosts: ["example.com", "api.yourdomain.com"])
           .build()
   )
   

3. Initialisez le Tracer global :

   Global.sharedTracer = Tracer.initialize(
       configuration: Tracer.Configuration(...)
   )
   

4. Initialisez URLSession tel qu’indiqué à la rubrique Configuration :

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

   Par défaut, tous les sous-domaines des hosts répertoriés sont tracés. Par exemple, si vous ajoutez example.com, vous activez également le tracing de api.example.com et foo.example.com.

   Pour que l’injection des ID de trace fonctionne, vous devez spécifier une URLRequest pour la URLSession. Le tracing distribué ne fonctionne pas lorsque vous utilisez un objet URL.

5. (Facultatif) Configurez le paramètre tracingSamplingRate pour conserver un certain pourcentage des traces backend. Si ce paramètre n’est pas défini, 20 % des traces issues des requêtes d’application sont envoyées à Datadog.

   Pour conserver 100 % des traces backend :

   Datadog.initialize(
       appContext: .init(),
       configuration: Datadog.Configuration
           .builderUsing(rumApplicationID: "<rum_app_id>", clientToken: "<client_token>", environment: "<env_name>")
           .set(tracingSamplingRate: 100)
           .build()
   )
   

Remarque : le paramètre tracingSamplingRate n’affecte pas l’échantillonnage des sessions RUM. Seules les traces backend sont filtrées.

1. Configurez la surveillance React Native RUM.

2. Configurez le paramètre d’initialisation firstPartyHosts pour définir la liste des origines internes first party appelées par votre application React Native.

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

   Par défaut, tous les sous-domaines des hosts répertoriés sont tracés. Par exemple, si vous ajoutez example.com, vous activez également le tracing de api.example.com et foo.example.com.

3. (Facultatif) Configurez le paramètre resourceTracingSamplingRate pour conserver un certain pourcentage des traces backend. Si ce paramètre n’est pas défini, 20 % des traces issues des requêtes d’application sont envoyées à Datadog.

   Pour conserver 100 % des traces backend :

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

   Remarque : le paramètre resourceTracingSamplingRate n’affecte pas l’échantillonnage des sessions RUM. Seules les traces backend sont filtrées.

1. Configurez la surveillance Flutter RUM.

2. Suivez les instructions de la section Suivi automatique de ressources pour inclure le package Datadog Tracking HTTP Client et activer le suivi HTTP. Vous devrez notamment apporter les modifications suivantes à vos paramètres d’initialisation pour ajouter la liste des origines internes first party appelées par votre application Flutter :

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

1. Configurez RUM pour qu’il se connecte avec APM en suivant les instructions ci-dessus.

2. Modifiez le paramètre allowedTracingUrls comme suit :

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

   match accepte les mêmes types de paramètres (string, RegExp ou function) que lorsqu’il est utilisé dans sa forme simple, comme décrit ci-dessus.

   propagatorTypes accepte une liste de chaînes avec les propagateurs souhaités :

   • datadog : propagateur de Datadog (x-datadog-*)
   • tracecontext : W3C Trace Context (traceparent)
   • b3 : B3 single header (b3)
   • b3multi : B3 multiple headers (X-B3-*)

1. Configurez RUM pour qu’il se connecte avec APM en suivant les instructions ci-dessus.

2. Utilisez trackURLSession(firstPartyHostsWithHeaderTypes:) au lieu de trackURLSession(firstPartyHosts:) comme suit :

   Datadog.initialize(
       appContext: .init(),
       configuration: Datadog.Configuration
           .builderUsing(
               rumApplicationID: "<rum_app_id>", 
               clientToken: "<client_token>", 
               environment: "<env_name>"
           )
           .trackURLSession(
               firstPartyHostsWithHeaderTypes: [
                   "api.example.com": [.tracecontext]
               ]
           )
           .build()
       )
   

   trackURLSession(firstPartyHostsWithHeaderTypes:) accepte Dictionary<Chaîne, Set<TypeEn-têteTracing>> en tant que paramètre, la clé étant un host et la valeur étant une liste de types d’en-têtes de tracing pris en charge.

   TracingHeaderType est un enum représentant les types d’en-têtes de tracing suivants :

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

1. Configurez RUM pour qu’il se connecte avec APM en suivant les instructions ci-dessus.

2. Configurez l’intercepteur OkHttpClient avec la liste des origines internes first party et le type d’en-tête de tracing à utiliser, comme suit :

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

   TracingHeaderType est un enum représentant les types d’en-têtes de tracing suivants :

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

1. Configurez RUM pour qu’il se connecte avec APM.

2. Configurez le SDK RUM avec la liste des origines internes first party et le type d’en-tête de tracing à utiliser, comme suit :

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

   PropagatorType est un enum représentant les types d’en-têtes de tracing suivants :

   • PropagatorType.DATADOG : propagateur de Datadog (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 qu’il se connecte avec APM en suivant les instructions ci-dessus.

2. Utilisez firstPartyHostsWithTracingHeaders au lieu de firstPartyHosts, comme suit :

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

   firstPartyHostsWithTracingHeaders accepte Map<Châine, Set<TypeEn-têteTracing>> en tant que paramètre, la clé étant un host et la valeur étant une liste de types d’en-têtes de tracing pris en charge.

   TracingHeaderType est un enum représentant les types d’en-têtes de tracing suivants :

   • TracingHeaderType.datadog : propagateur de Datadog (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 RUM. Permet à Datadog de lier la trace à la ressource RUM.

x-datadog-parent-id

Généré à partir du SDK RUM. Permet à Datadog de générer la première span depuis la trace.

x-datadog-origin: rum

Permet de s’assurer que les traces générées à partir de la fonctionnalité RUM ne rentrent pas en compte dans le calcul de vos spans indexées APM.

x-datadog-sampling-priority: 1

Permet de s’assurer que l’Agent conserve la trace.

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

version : la spécification actuelle part du principe que la version est définie sur 00.

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

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

trace flags : avec échantillonnage (01) ou sans échantillonnage (00)

Exemple :

traceparent: 00-00000000000000008448eb211c80319c-b7ad6b7169203331s-01

b3: [trace id]-[span id]-[sampled]

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

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

sampled : True (1) ou False (0)

Exemple pour le propagateur b3 single header :

b3: 8448eb211c80319c-b7ad6b7169203331-1

Exemple pour le propagateur b3 multiple headers :

X-B3-TraceId: 8448eb211c80319c

X-B3-SpanId: b7ad6b7169203331

X-B3-Sampled: 1