1. Set up RUM Browser Monitoring.

2. Initialize the RUM SDK. Configure the allowedTracingUrls initialization parameter with the list of internal, first-party origins called by your browser application.

   For 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,
   })
   

   For 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. (Optional) Configure the traceSampleRate initialization parameter to keep a defined percentage of the backend traces. If not set, 100% of the traces coming from browser requests are sent to Datadog. To keep 20% of backend traces, for example:

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

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

4. (Optional) If you set a traceSampleRate, to ensure backend services’ sampling decisions are still applied, configure the traceContextInjection initialization parameter to sampled (set to sampled by default).

   For example, if you set the traceSampleRate to 20% in the Browser SDK:

   • When traceContextInjection is set to all, 20% of backend traces are kept and 80% of backend traces are dropped.

   • 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 tracing library 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. Set up RUM Android Monitoring.

2. Set up Android Trace Collection.

3. Add the Gradle dependency to the dd-sdk-android-okhttp library in the module-level build.gradle file:

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

4. Configure the OkHttpClient interceptor with the list of internal, first-party origins called by your Android application.

   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. (Optional) Configure the traceSampler parameter to keep a defined percentage of the backend traces. If not set, 20% of the traces coming from application requests are sent to Datadog. To keep 100% of backend traces:

       val tracedHosts = listOf("example.com")
   
       val okHttpClient = OkHttpClient.Builder()
       .addInterceptor(
           DatadogInterceptor.Builder(tracedHosts)
               .setTraceSampler(RateBasedSampler(100f))
               .build()
       )
       .build()
   

Note:

• traceSampler does not impact RUM sessions sampling. Only backend traces are sampled out.
• If you define custom tracing header types in the Datadog configuration and are using a tracer registered with GlobalTracer, make sure the same tracing header types are set for the tracer in use.

1. Set up RUM iOS Monitoring.

2. Enable RUM with the urlSessionTracking option and firstPartyHostsTracing parameter:

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

3. Enable URLSession instrumentation for your SessionDelegate type, which conforms to URLSessionDataDelegate protocol:

   URLSessionInstrumentation.enable(
       with: .init(
           delegateClass: <YourSessionDelegate>.self
       )
   )
   

4. Initialize URLSession as stated in Setup:

   let session =  URLSession(
       configuration: ...,
       delegate: <YourSessionDelegate>(),
       delegateQueue: ...
   )
   

   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.

   Trace ID injection works when you are providing a URLRequest to the URLSession. Distributed tracing does not work when you are using a URL object.

5. (Optional) Set the sampleRate parameter to keep a defined percentage of the backend traces. If not set, 20% of the traces coming from application requests are sent to Datadog.

   To keep 100% of backend traces:

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

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

1. Set up RUM React Native Monitoring.

2. Set the firstPartyHosts initialization parameter to define the list of internal, first-party origins called by your React Native application:

   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. (Optional) Set the resourceTracingSamplingRate initialization parameter to keep a defined percentage of the backend traces. If not set, 20% of the traces coming from application requests are sent to Datadog.

   To keep 100% of backend traces:

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

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

1. Set up RUM Flutter Monitoring.

2. Follow the instructions under Automatically track resources to include the Datadog Tracking HTTP Client package and enable HTTP tracking. This includes the following changes to your initialization to add a list of internal, first-party origins called by your Flutter application:

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

1. Set up RUM Roku Monitoring.

2. Use the datadogroku_DdUrlTransfer component to perform your network requests.

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

1. Set up RUM Kotlin Multiplatform Monitoring.

2. Set up Ktor instrumentation.

3. Set the tracedHosts initialization parameter in the Datadog Ktor Plugin configuration to define the list of internal, first-party origins called by your Kotlin Multiplatform application:

   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. (Optional) Set the traceSampleRate initialization parameter to keep a defined percentage of the backend traces. If not set, 20% of the traces coming from application requests are sent to Datadog.

   To keep 100% of backend traces:

   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. Visit a page in your application.
2. In your browser’s developer tools, go to the Network tab.
3. Check the request headers for a resource request that you expect to be correlated contains the correlation headers from Datadog.

1. Run your application from Android Studio.
2. Visit a screen in your application.
3. Open Android Studio’s Network Inspector.
4. Check the request headers for a RUM resource and verify that the required headers are set by the SDK.

1. Run your application from Xcode.
2. Visit a screen in your application.
3. Open Xcode’s Network Connections and HTTP Traffic instrument.
4. Check the request headers for a RUM resource and verify that the required headers are set by the SDK.

1. Run your application from Xcode (iOS) or Android Studio (Android).
2. Visit a screen in your application.
3. Open Xcode’s Network Connections and HTTP Traffic instrument or Android Studio’s Network Inspector.
4. Check the request headers for a RUM resource and verify that the required headers are set by the SDK.

1. Run your application using your preferred IDE or flutter run.
2. Visit a screen in your application.
3. Open Flutter’s Dev Tools and navigate to Network View.
4. Check the request headers for a RUM resource and verify that the required headers are set by the SDK.

1. Run your application from Xcode (iOS) or Android Studio (Android).
2. Visit a screen in your application.
3. Open Xcode’s Network Connections and HTTP Traffic instrument or Android Studio’s Network Inspector.
4. Check the request headers for a RUM resource and verify that the required headers are set by the SDK.

Note: If you are using a backend framework such as Next.js/Vercel that uses OpenTelemetry, follow these steps.

1. Set up RUM to connect with APM as described above.

2. Modify allowedTracingUrls as follows:

   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. Set up RUM to connect with APM as described above.

2. Use .traceWithHeaders(hostsWithHeaders:sampleRate:) instead of .trace(hosts:sampleRate:) as follows:

     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. Set up RUM to connect with APM as described above.

2. Configure the OkHttpClient interceptor with the list of internal, first-party origins and the tracing header type to use as follows:

   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. Set up RUM to connect with APM.

2. Configure the RUM SDK with the list of internal, first-party origins and the tracing header type to use as follows:

   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. Set up RUM to connect with APM as described above.

2. Use firstPartyHostsWithTracingHeaders instead of firstPartyHosts as follows:

   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. Set up RUM to connect with APM.

2. Configure the RUM SDK with the list of internal, first-party origins and the tracing header type to use as follows:

   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

Generated from the Real User Monitoring SDK. Allows Datadog to link the trace with the RUM resource.

x-datadog-parent-id

Generated from the Real User Monitoring SDK. Allows Datadog to generate the first span from the trace.

x-datadog-origin: rum

To make sure the generated traces from Real User Monitoring don’t affect your APM Index Spans counts.

x-datadog-sampling-priority

Set to 1 by the Real User Monitoring SDK if the trace was sampled, or 0 if it was not.

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

version: The current specification assumes version is set to 00.

trace id: 128 bits trace ID, hexadecimal on 32 characters. The source trace ID is 64 bits to keep compatibility with APM.

parent id: 64 bits span ID, hexadecimal on 16 characters.

trace flags: Sampled (01) or not sampled (00)

Trace ID Conversion: The 128-bit W3C trace ID is created by padding the original 64-bit source trace ID with leading zeros. This ensures compatibility with APM while conforming to the W3C Trace Context specification. The original 64-bit trace ID becomes the lower 64 bits of the 128-bit W3C trace ID.

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

dd: Datadog’s vendor prefix.

sampling priority: Set to 1 if the trace was sampled, or 0 if it was not.

origin: Always set to rum to make sure the generated traces from Real User Monitoring don’t affect your APM Index Spans counts.

Examples:

Source trace ID (64-bit): 8448eb211c80319c

W3C Trace Context (128-bit): 00000000000000008448eb211c80319c

The relationship shows that the original 64-bit trace ID 8448eb211c80319c is padded with 16 leading zeros (0000000000000000) to create the 128-bit W3C trace ID.

Complete traceparent example:

traceparent: 00-00000000000000008448eb211c80319c-b7ad6b7169203331-01

tracestate: dd=s:1;o:rum

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

trace id: 64 bits trace ID, hexadecimal on 16 characters.

span id: 64 bits span ID, hexadecimal on 16 characters.

sampled: True (1) or False (0)

Example for b3 single header:

b3: 8448eb211c80319c-b7ad6b7169203331-1

Example for b3 multiple headers:

X-B3-TraceId: 8448eb211c80319c

X-B3-SpanId: b7ad6b7169203331

X-B3-Sampled: 1