Información general

Si aún no has configurado el SDK, sigue las instrucciones de configuración disponibles en la aplicación o consulta la documentación de configuración de Android RUM.

Mejorar las sesiones de usuario

Android RUM rastrea automáticamente atributos como la actividad de usuario, las pantallas, los errores y las solicitudes de red. Consulta la documentación de recopilación de datos de RUM para obtener información sobre los eventos de RUM y los atributos predeterminados. Para mejorar aún más la información de sesión de usuario y obtener un control más preciso sobre los atributos recopilados, puedes rastrear eventos personalizados.

Vistas personalizadas

Además de rastrear vistas automáticamente, también puedes rastrear vistas distintas específicas (como actividades y fragmentos) cuando se resulten visibles e interactivas en el ciclo de vida onResume(). Termina el rastreo cuando la vista deje de estar visible. La mayoría de las veces es necesario llamar este método en la Activity o el Fragment en primer plano:

    fun onResume() {
      GlobalRumMonitor.get().startView(viewKey, viewName, viewAttributes)
    }

    fun onPause() {
      GlobalRumMonitor.get().stopView(viewKey, viewAttributes)
    }

    public void onResume() {
         GlobalRumMonitor.get().startView(viewKey, viewName, viewAttributes);
    }

    public void onPause() {
         GlobalRumMonitor.get().stopView(viewKey, viewAttributes);
    }

Añadir tus propios tiempos de rendimiento

Además de los atributos predeterminados de RUM, puedes medir a qué dedica tiempo tu aplicación con la API addTiming. La medición de tiempo guarda relación con el inicio de la vista de RUM actual. Por ejemplo, puedes medir el tiempo que tarda en aparecer tu imagen principal:

   fun onHeroImageLoaded() {
         GlobalRumMonitor.get().addTiming("hero_image")
   } 

    public void onHeroImageLoaded() {
         GlobalRumMonitor.get().addTiming("hero_image");
    }

Una vez enviado el tiempo, se puede acceder al él como @view.custom_timings.<timing_name>. Por ejemplo: @view.custom_timings.hero_image. Debes crear una medición antes de representarla gráficamente en análisis de RUM o en dashboards.

Acciones personalizadas

Además de rastrear acciones automáticamente, también puedes rastrear acciones específicas del usuario (como toques, clics y desplazamientos) con RumMonitor#addAction. Para el rastreo continuo de acciones (por ejemplo, el rastreo de un usuario que se desplaza por una lista), utiliza RumMonitor#startAction y RumMonitor#stopAction.

Ten en cuenta que el tipo de acción debe ser uno de los siguientes: “personalizada”, “hacer clic”, “tocar”, “desplazarse”, “deslizar”, “atrás”.

    fun onUserInteraction() { 
         GlobalRumMonitor.get().addAction(actionType, name, actionAttributes)
    }

    public void onUserInteraction() {
         GlobalRumMonitor.get().addAction(actionType, name, actionAttributes);
    }

Mejorar recursos

A la hora de rastrear recursos automáticamente, proporciona una instancia RumResourceAttributesProviderpersonalizada para añadir atributos personalizados a cada solicitud de red rastreada. Por ejemplo, si quieres rastrear los encabezados de una solicitud de red, crea una implementación de la siguiente manera y pásala al constructor del DatadogInterceptor.

class CustomRumResourceAttributesProvider : RumResourceAttributesProvider {
    override fun onProvideAttributes(
        request: Request,
        response: Response?,
        throwable: Throwable?
    ): Map<String, Any?> {
        val headers = request.headers
        return headers.names().associate {
            "headers.${it.lowercase(Locale.US)}" to headers.values(it).first()
        }
    }
}

public class CustomRumResourceAttributesProvider implements RumResourceAttributesProvider {
    @NonNull
    @Override
    public Map<String, Object> onProvideAttributes(
            @NonNull Request request,
            @Nullable Response response,
            @Nullable Throwable throwable
    ) {
        Map<String, Object> result = new HashMap<>();
        Headers headers = request.headers();

        for (String key : headers.names()) {
            String attrName = "headers." + key.toLowerCase(Locale.US);
            result.put(attrName, headers.values(key).get(0));
        }

        return result;
    }
}

Recursos personalizados

Además de rastrear recursos automáticamente, también puedes rastrear recursos personalizados específicos (como solicitudes de red y APIs de proveedores de terceros) con métodos (como GET y POST) mientras cargas el recurso con RumMonitor#startResource. Deja de rastrear con RumMonitor#stopResource cuando esté completamente cargado, o RumMonitor#stopResourceWithError si se produce un error al cargarlo.

    fun loadResource() {
         GlobalRumMonitor.get().startResource(resourceKey, method, url, resourceAttributes)
         try {
           // carga el recurso
           GlobalRumMonitor.get().stopResource(resourceKey, resourceKind, additionalAttributes)
         } catch (e: Exception) {
           GlobalRumMonitor.get().stopResourceWithError(resourceKey, message, origin, e)
         } 
    }

    public void loadResource() {
         GlobalRumMonitor.get().startResource(resourceKey, method, url, resourceAttributes);
         try {
             // carga el recurso
             GlobalRumMonitor.get().stopResource(resourceKey, resourceKind, additionalAttributes);
         } catch (Exception e) {
             GlobalRumMonitor.get().stopResourceWithError(resourceKey, message, origin, e);
         }
    }

Errores personalizados

Para rastrear errores específicos, notifica al monitor cada vez que se produzca un error con el mensaje, el origen, la excepción y los atributos adicionales. Consulta la documentación de atributos de error.

   GlobalRumMonitor.get().addError(message, source, throwable, attributes)

Rastrear atributos globales personalizados

Además de los atributos de RUM predeterminados capturados automáticamente por el SDK de RUM Android, puedes decidir añadir información contextual adicional, como atributos personalizados, a tus eventos de RUM para mejorar tu observabilidad en Datadog. Los atributos personalizados permiten segmentar y desglosar información sobre el comportamiento de usuario observado (como el valor del carrito, el nivel de comerciante o la campaña publicitaria) con información relacionada con el código (como los servicios de backend, la escala de tiempo de la sesión, los logs de errores y el estado de la red).

Rastrear sesiones de usuario

Al añadir información de usuario a tus sesiones de RUM, simplificas lo siguiente:

• Seguir el recorrido de un usuario concreto
• Conocer qué usuarios se han visto más afectados por los errores
• Monitorizar el rendimiento de tus usuarios más importantes

Los siguientes atributos son opcionales. Debes indicar al menos uno:

Para identificar las sesiones de usuario, utiliza, por ejemplo, la API setUserInfo:

Datadog.setUserInfo('1234', 'John Doe', 'john@doe.com')

Rastrear atributos

    // Añade un atributo a todos los eventos de RUM futuros
    GlobalRumMonitor.get().addAttribute(key, value)

    // Elimina un atributo a todos los eventos de RUM futuros
    GlobalRumMonitor.get().removeAttribute(key)

Rastrear widgets

Los widgets no se rastrean automáticamente con el SDK. Para enviar interacciones de interfaz de usuario desde tus widgets manualmente, llama a la API de Datadog. Consulta el ejemplo.

Parámetros de inicialización

Puedes usar los siguientes métodos en Configuration.Builder a la hora de crear la configuración de Datadog para inicializar la biblioteca:

setFirstPartyHosts()

define hosts que tienen el rastreo habilitado y tienen recursos de RUM categorizados como first-party. Nota: Si defines tipos de encabezado de rastreo personalizados en la configuración de Datadog y estás utilizando un rastreador registrado con GlobalTracer, asegúrate de que se establecen los mismos tipos de encabezado de rastreo para el rastreador en uso.

useSite(DatadogSite)

cambia los datos de destino a los sitios EU1, US1, US3, US5, US1_FED y AP1.

Puedes utilizar los siguientes métodos en RumConfiguration.Builder al crear la configuración de RUM para activar la característica de RUM:

trackUserInteractions(Array<ViewAttributesProvider>)

permite realizar un rastreo de las interacciones del usuario (como tocar, desplazarse o deslizar). El parámetro también permite añadir atributos personalizados a los eventos de acción de RUM en función del widget con el que interactuó el usuario.

useViewTrackingStrategy(strategy)

define la estrategia utilizada para rastrear vistas. Según la arquitectura de tu aplicación, puedes elegir una de varias implementaciones de ViewTrackingStrategy o implementar la tuya propia.

trackLongTasks(durationThreshold)

activa el rastreo de tareas que tardan más de durationThreshold en el subproceso principal como tareas largas en Datadog.

setBatchSize([SMALL|MEDIUM|LARGE])

define el tamaño de lote individual para las solicitudes enviadas a Datadog.

setUploadFrequency([FREQUENT|AVERAGE|RARE])

define la frecuencia de las solicitudes realizadas a los endpoints de Datadog (si las solicitudes están disponibles).

setVitalsUpdateFrequency([FREQUENT|AVERAGE|RARE|NEVER])

establece la frecuencia preferida para recopilar indicadores vitales de móviles.

setSessionSampleRate(<sampleRate>)

establece la frecuencia de muestreo de las sesiones de RUM. (Un valor de 0 significa que no se envía ningún evento de RUM. Un valor de 100 significa que se mantienen todas las sesiones).

setXxxEventMapper()

establece las devoluciones de llamadas de limpieza de datos para vistas, acciones, recursos y errores.

Rastrear vistas automáticamente

Para rastrear tus vistas automáticamente (como actividades y fragmentos), indica una estrategia de rastreo en la inicialización. Según la arquitectura de tu aplicación, puedes elegir una de las siguientes estrategias:

ActivityViewTrackingStrategy

cada actividad de tu aplicación se considera una vista distinta.

FragmentViewTrackingStrategy

cada fragmento de tu aplicación se considera una vista distinta.

MixedViewTrackingStrategy

cada actividad o fragmento de tu aplicación se considera una vista distinta.

NavigationViewTrackingStrategy

recomendado para usuarios de la biblioteca de navegación de Android Jetpack. Cada destino de navegación se considera una vista distinta.

Por ejemplo, para configurar cada fragmento como una vista distinta, utiliza lo siguiente en tu configuración:

    val rumConfig = RumConfiguration.Builder(applicationId)
     .useViewTrackingStrategy(FragmentViewTrackingStrategy(...))
     .build()

    RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
     .useViewTrackingStrategy(new FragmentViewTrackingStrategy(...))
     .build();

Para ActivityViewTrackingStrategy, FragmentViewTrackingStrategy, o MixedViewTrackingStrategy, puedes filtrar qué Fragment o Activity se rastrea como vista de RUM proporcionando una implementaciónComponentPredicate en el constructor:

    val rumConfig = RumConfiguration.Builder(applicationId)
     .useViewTrackingStrategy(
     ActivityViewTrackingStrategy(
         trackExtras = true,
         componentPredicate = object : ComponentPredicate<Activity> {
             override fun accept(component: Activity): Boolean {
                 return true
             }

             override fun getViewName(component: Activity): String? = null
         })
     )
     .build()  

     RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
         .useViewTrackingStrategy(new ActivityViewTrackingStrategy(
             true,
             new ComponentPredicate<Activity>() {
                 @Override
                 public boolean accept(Activity component) {
                     return true;
                 }

                 @Override
                 public String getViewName(Activity component) {
                     return null;
                 }
             }
         ))
         .build();

Nota: De manera predeterminada, la biblioteca utiliza una ActivityViewTrackingStrategy. Si decides no proporcionar una estrategia de rastreo de vistas, debes enviar manualmente las vistas llamando a los métodos startView y stopView.

Rastrear solicitudes de red automáticamente

Para obtener información de tiempo en recursos (como proveedores de terceros, solicitudes de red) como el tiempo hasta el primer byte o la resolución DNS, personaliza el OkHttpClient para añadir la fábrica EventListener:

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

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

2. Añade la fábrica EventListener:

    val okHttpClient = OkHttpClient.Builder()
     .addInterceptor(DatadogInterceptor())
     .eventListenerFactory(DatadogEventListener.Factory())
     .build()

    OkHttpClient okHttpClient = new OkHttpClient.Builder()
     .addInterceptor(new DatadogInterceptor())
     .eventListenerFactory(new DatadogEventListener.Factory())
     .build();

Rastrear tareas largas automáticamente

Las operaciones de larga ejecución realizadas en el subproceso principal pueden afectar al rendimiento visual y a la capacidad de reacción de tu aplicación. Para rastrear estas operaciones, define el umbral de duración por encima del cual se considera que una tarea es demasiado larga.

    val rumConfig = RumConfiguration.Builder(applicationId)
     // ...
     .trackLongTasks(durationThreshold)
     .build()

   val rumConfig = RumConfiguration.Builder(applicationId)
     // ...
     .trackLongTasks(250L) // track tasks longer than 250ms as long tasks
     .build()

    RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
      // ...
      .trackLongTasks(durationThreshold)
      .build();

   RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
     // ...
     .trackLongTasks(250L) // track tasks longer than 250ms as long tasks
     .build();

Modificar o descartar eventos de RUM

Para modificar algunos atributos en tus eventos de RUM, o para descartar algunos de los eventos por completo antes del procesamiento por lotes, proporciona una implementación de EventMapper<T> al inicializar el SDK de RUM Android:

    val rumConfig = RumConfiguration.Builder(applicationId)
     // ...
     .setErrorEventMapper(rumErrorEventMapper)
     .setActionEventMapper(rumActionEventMapper)
     .setResourceEventMapper(rumResourceEventMapper)
     .setViewEventMapper(rumViewEventMapper)
     .setLongTaskEventMapper(rumLongTaskEventMapper)
     .build()

    RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
      // ...
      .setErrorEventMapper(rumErrorEventMapper)
      .setActionEventMapper(rumActionEventMapper)
      .setResourceEventMapper(rumResourceEventMapper)
      .setViewEventMapper(rumViewEventMapper)
      .setLongTaskEventMapper(rumLongTaskEventMapper)
      .build();

Al implementar la interfaz EventMapper<T>, solo se pueden modificar algunos atributos para cada tipo de evento:

Nota: Al devolver el parámetro null desde la implementación de EventMapper<T>, se descarta el evento.

Recuperar el ID de sesión de RUM

Recuperar el ID de sesión de RUM puede ser útil para solucionar problemas. Por ejemplo, puedes adjuntar el ID de sesión a solicitudes de soporte, correos electrónicos o informes de errores para que tu equipo de soporte pueda encontrar posteriormente la sesión de usuario en Datadog.

Puedes acceder al identificador de sesión RUM en tiempo de ejecución sin esperar al evento sessionStarted:

GlobalRumMonitor.get().getCurrentSessionId { sessionId ->
  currentSessionId = sessionId
}

Referencias adicionales

Más enlaces, artículos y documentación útiles:

Código fuente de dd-sdk-androidCÓDIGO FUENTE Explorar RUM de DatadogDOCUMENTACIÓN