1. Configura la monitorización del Navegador RUM.

2. Inicializa el SDK RUM. Configura el parámetro de inicialización allowedTracingUrls con la lista de orígenes internos de primera parte que invoca tu aplicación de navegador.

   Para NPM install:

   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")]
   })
   

   Para 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", /https:\/\/.*\.my-api-domain\.com/, (url) => url.startsWith("https://api.example.com")]
      sessionSampleRate: 100,
      sessionReplaySampleRate: 100, // if not included, the default is 100
      trackResources: true,
      trackLongTasks: true,
      trackUserInteractions: true,
    })
   

   Para conectar RUM con trazas, es necesario especificar la aplicación del navegador en el campo service.

   allowedTracingUrls coincide con la URL completa (<scheme>://<host>[:<port>]/<path>[?<query>][#<fragment>]). Acepta los siguientes tipos:

   • string: coincide con cualquier URL que empiece por el valor, por lo que https://api.example.com coincide con https://api.example.com/v1/resource.
   • RegExp: ejecuta un test con la expresión regular y la URL proporcionadas.
   • function: evalúa con la URL como parámetro. La devolución de un boolean configurado como true indica una coincidencia.

3. (Opcional) Configura el parámetro de inicialización traceSampleRate para mantener un porcentaje definido de trazas de backend. Si no se configura, el 100% de las trazas procedentes de solicitudes del navegador se envían a Datadog. Para conservar el 20% de las trazas de backend, por ejemplo:

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

Nota: traceSampleRate no afecta al muestreo de sesiones RUM. Sólo se muestrean las trazas de backend.

4. (Opcional) Si defines un traceSampleRate, para asegurarte de que se siguen aplicando las decisiones de muestreo de servicios de backend, configura el parámetro de inicialización traceContextInjection como sampled (definido en all por defecto).

   Por ejemplo, si configuras traceSampleRate al 20% en el SDK del navegador:

   • Cuando traceContextInjection se define en all, se conserva el 20% de las trazas de backend y se elimina el 80% de las trazas de backend.

• Cuando traceContextInjection se configura como sampled, se conserva el 20% de las trazas de backend. Para el 80% restante, el SDK del navegador no inyecta una decisión de muestreo. La decisión se toma en el servidor y se basa en la configuración del muestreo de cabeceras de la biblioteca de rastreo. En el siguiente ejemplo, la tasa de muestreo del backend se define en 40%, por lo que se conserva el 32% restante de las trazas de backend.

1. Configura la monitorización Android RUM.

2. Configura la recopilación de trazas Android.

3. Añade la dependencia Gradle a la biblioteca dd-sdk-android-okhttp en el archivo build.gradle a nivel del módulo:

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

4. Configura el interceptor OkHttpClient con la lista de orígenes internos de primera instancia invocados por tu aplicación Android.

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

   De forma predeterminada, se rastrean todos los subdominios de los hosts incluidos en la lista. Por ejemplo, si añades example.com, también habilitas el rastreo para api.example.com y foo.example.com.

5. (Opcional) Configura el parámetro traceSampler para mantener un porcentaje definido de trazas de backend. Si no se configura, el 20% de las trazas procedentes de las solicitudes de la aplicación se envían a Datadog. Para mantener el 100% de las trazas de backend:

    val okHttpClient = OkHttpClient.Builder()
       .addInterceptor(DatadogInterceptor(traceSampler = RateBasedSampler(100f)))
       .build()

Nota:

• traceSampler no afecta al muestreo de sesiones RUM. Sólo se muestrean las trazas de backend.
• Si defines tipos de cabeceras de rastreo personalizados en la configuración de Datadog y estás utilizando un rastreador registrado con GlobalTracer, asegúrate de que se configuren los mismos tipos de cabeceras de rastreo para el rastreador en uso.

1. Configura la monitorización iOS RUM.

2. Habilita RUM con la opción urlSessionTracking y el parámetro firstPartyHostsTracing:

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

3. Habilita la instrumentación URLSession para tu tipo de SessionDelegate, que se ajusta al protocolo URLSessionDataDelegate:

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

4. Inicializa URLSession como se indica en Configuración:

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

   De forma predeterminada, se rastrean todos los subdominios de los hosts incluidos en la lista. Por ejemplo, si añades example.com, también habilitarás el rastreo para api.example.com y foo.example.com.

   La inyección de ID de rastreo funciona cuando se proporciona un URLRequest a URLSession. El rastreo distribuido no funciona cuando se utiliza un objeto URL.

5. (Opcional) Configura el parámetro tracingSamplingRate para mantener un porcentaje definido de trazas de backend. Si no se configura, el 20% de las trazas procedentes de solicitudes de aplicaciones se envían a Datadog.

   Para mantener el 100% de las trazas de backend::

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

Nota: sampleRate no afecta al muestreo de sesiones RUM. Sólo se muestrean las trazas de backend.

1. Configura la monitorización RUM React Native.

2. Configura el parámetro de inicialización firstPartyHosts para definir la lista de orígenes internos de primera instancia que invoca tu aplicación React Native:

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

   De forma predeterminada, se rastrean todos los subdominios de los hosts incluidos en la lista. Por ejemplo, si añades example.com, también habilitarás el rastreo para api.example.com y foo.example.com.

3. (Opcional) Configura el parámetro de inicialización resourceTracingSamplingRate para mantener un porcentaje definido de las trazas de backend. Si no se configura, el 20% de las trazas procedentes de solicitudes de aplicaciones se envían a Datadog.

   Para mantener el 100% de las trazas de backend::

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

   Nota: resourceTracingSamplingRate no afecta al muestreo de sesiones RUM. Sólo se muestrean las trazas de backend.

1. Configura la monitorización RUM Flutter.

2. Sigue las instrucciones en Seguimiento automático de recursos para incluir el paquete de cliente HTTP de seguimiento de Datadog y habilitar el seguimiento HTTP. Esto incluye los siguientes cambios en la inicialización para añadir una lista de orígenes internos de primera instancia que invoca la aplicación Flutter:

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

1. Configura la monitorización RUM Roku.

2. Utiliza el componente datadogroku_DdUrlTransfer para realizar tus solicitudes de red.

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

1. Visita una página de tu aplicación.
2. En la página de herramientas de desarrollo de tu navegador, ve a la pestaña Red.
3. Verifica que las cabeceras de solicitud de la solicitud de un recurso que esperas correlacionar contienen las cabeceras de correlación de Datadog.

1. Ejecuta tu aplicación desde Android Studio.
2. Visita una página de tu aplicación.
3. Abre el Inspector de redes de Android Studio.
4. Verifica las cabeceras de solicitud de un recurso RUM y comprueba que las cabeceras requeridas han sido definidas por el SDK.

1. Ejecuta tu aplicación desde Xcode.
2. Visita una página de tu aplicación.
3. Abre las conexiones de red y la instrumentación del tráfico HTTP.
4. Verifica las cabeceras de solicitud de un recurso RUM y comprueba que las cabeceras requeridas han sido definidas por el SDK.

1. Ejecuta tu aplicación desde Xcode (iOS) o Android Studio (Android).
2. Visita una página de tu aplicación.
3. Abre las conexiones de red y la instrumentación del tráfico HTTP de Xcode y el Inspector de redes de Android Studio.
4. Verifica las cabeceras de solicitud de un recurso RUM y comprueba que las cabeceras requeridas han sido definidas por el SDK.

1. Ejecute su aplicación utilizando tu IDE o flutter run preferido.
2. Visita una página de tu aplicación.
3. Abre Herramientas de desarrollo de Flutter y ve a Vista de red.
4. Verifica las cabeceras de solicitud de un recurso RUM y comprueba que las cabeceras requeridas han sido definidas por el SDK.

Nota: Si estás utilizando un marco de backend como Next.js/Vercel que utiliza OpenTelemetry, sigue estos pasos.

1. Configura RUM para conectarse con APM, como se ha descrito anteriormente.

2. Modifica allowedTracingUrls como se indica a continuación:

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

   match acepta los mismos tipos de parámetros (string, ``RegExpofunction`) que cuando se utiliza en su forma simple, como se ha descrito anteriormente.

   propagatorTypes acepta una lista de cadenas para los propagadores elegidos:

   • datadog: Propagador de Datadog (x-datadog-*)
   • tracecontext: Contexto de rastreo W3C (traceparent)
   • b3: Cabecera única B3 (b3)
   • b3multi: Cabeceras múltiples B3 (X-B3-*)

1. Configura RUM para conectarse con APM, como se ha descrito anteriormente.

2. Utiliza .traceWithHeaders(hostsWithHeaders:sampleRate:) en lugar de .trace(hosts:sampleRate:), como se indica a continuación:

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

   .traceWithHeaders(hostsWithHeaders:sampleRate:) toma Dictionary<String, Set<TracingHeaderType>> como parámetro, donde la clave es un host y el valor es una lista de tipos de cabeceras de rastreo compatibles.

   TracingHeaderTypeen una enumeración que representa los siguientes tipos de cabeceras de rastreo:

   • .datadog: Propagador de Datadog (x-datadog-*)
   • .tracecontext: Contexto de rastreo W3C (traceparent)
   • .b3: Cabecera única B3 (b3)
   • .b3multi: Cabeceras múltiples B3 (X-B3-*)

1. Configura RUM para conectarse con APM, como se describe arriba.

2. Configura el interceptor OkHttpClient con la lista de orígenes internos de primera instancia y el tipo de cabecera de rastreo a utilizar como se indica a continuación:

   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 es una enumeración que representa los siguientes tipos de cabeceras de rastreo:

   • .DATADOG: Propagador de Datadog (x-datadog-*)
   • .TRACECONTEXT: Contexto de rastreo W3C (traceparent)
   • .B3: Cabecera única B3 (b3)
   • .b3multi: Cabeceras múltiples B3 (X-B3-*)

1. Configura RUM para conectarse con APM.

2. Configura el SDK RUM con la lista de orígenes internos de primera instancia y el tipo de cabecera de rastreo a utilizar como se indica a continuación:

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

   PropagatorType es una enumeración que representa los siguientes tipos de cabeceras de rastreo:

   • PropagatorType.DATADOG: Propagador de Datadog (x-datadog-*)
   • PropagatorType.TRACECONTEXT: Contexto de rastreo W3C (traceparent)
   • PropagatorType.B3: Cabecera única B3 (b3)
   • PropagatorType.B3MULTI: Cabeceras múltiples B3 (X-B3-*)

1. Configura RUM para conectarse con APM, como se describe arriba.

2. Utiliza firstPartyHostsWithTracingHeaders en vez de firstPartyHosts como se indica a continuación:

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

   firstPartyHostsWithTracingHeaders toma Map<String, Set<TracingHeaderType>> como parámetro, donde la clave es un host y el valor es una lista de tipos de cabeceras de rastreo compatibles.

   TracingHeaderType es una enumeración que representa los siguientes tipos de cabeceras de rastreo:

   • TracingHeaderType.datadog: Propagador de Datadog (x-datadog-*)
   • TracingHeaderType.tracecontext: Contexto de rastreo W3C (traceparent)
   • TracingHeaderType.b3: Cabecera única B3 (b3)
   • TracingHeaderType.b3multi: Cabeceras múltiples B3 (X-B3-*)

x-datadog-trace-id

Generado a partir del SDK de Real User Monitoring. Permite a Datadog vincular la traza con el recurso RUM.

x-datadog-parent-id

Generado desde el SDK de Real User Monitoring. Permite a Datadog generar el primer tramo (span) a partir de la traza.

x-datadog-origin: rum

Para asegurarte de que las trazas generadas por Real User Monitoring no afecten a tus recuentos de tramos de índices APM.

x-datadog-sampling-priority: 1

Para asegurarte de que el Agent conserva la traza.

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

version: La especificación actual asume que la versión se configura en 00.

trace id: ID de traza de 128 bits, hexadecimal en 32 caracteres. El ID de la traza de origen es de 64 bits para mantener la compatibilidad con APM.

parent id: ID de tramo de 64 bits, hexadecimal en 16 caracteres.

trace flags: Muestreado (01) o no muestreado (00)

Ejemplo:

traceparent: 00-00000000000000008448eb211c80319c-b7ad6b7169203331s-01

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

trace id: ID de traza de 64 bits, hexadecimal en 16 caracteres.

span id: ID de tramo de 64 bits, hexadecimal en 16 caracteres.

sampled: Verdadero (1) o Falso (0)

Ejemplo de cabecera única B3

b3: 8448eb211c80319c-b7ad6b7169203331-1

Ejemplo de cabeceras múltiples B3:

X-B3-TraceId: 8448eb211c80319c

X-B3-SpanId: b7ad6b7169203331

X-B3-Sampled: 1