Información general

Android Error Tracking te ofrece una visibilidad completa del estado de tu aplicación móvil mediante la captura automática de fallos, excepciones y errores. Con esta función, puedes:

• Monitorizar la estabilidad de la aplicación en tiempo real con alertas instantáneas de fallos y un seguimiento de la tasa de errores en cualquier versión, dispositivo y segmento de usuarios.
• Depurar los problemas con mayor rapidez gracias a las trazas de stack tecnológico desofuscadas y a las cargas automáticas de archivos de asignación de ProGuard para facilitar la identificación de los problemas.
• Mejorar la calidad de la aplicación detectando las funciones propensas a fallos, realizando un seguimiento de las tendencias de errores y priorizando las correcciones con el fin de mejorar la satisfacción del usuario.
• Acceder a dashboards y atributos agregados de fallos de Android.
• Visualizar informes de fallos de Android desofuscados junto a un análisis de las tendencias.

El SDK de Datadog Android es compatible con Android 5.0+ (nivel de la API 21) y Android TV.

Tus informes de fallos aparecen en Error Tracking.

Configuración

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

Paso 1: Declarar el SDK de Android como dependencia

Declara dd-sdk-android-rum y el complemento Gradle como dependencias en el archivo build.gradle de tu módulo de aplicación:

buildscript {
    dependencies {
        classpath("com.datadoghq:dd-sdk-android-gradle-plugin:x.x.x")
    }
}
plugins {
    id("com.datadoghq.dd-sdk-android-gradle-plugin")
    //(...)
}
android {
    //(...)
}
dependencies {
    implementation "com.datadoghq:dd-sdk-android-rum:x.x.x" 
    //(...)
}

Paso 2: Especificar la información de la aplicación en la interfaz de usuario

1. Ve a Errors > Settings > Browser and Mobile > + New Application (Errores > Configuración > Navegador y móvil > + Nueva aplicación).
2. Selecciona android como tipo de aplicación e introduce un nombre de la aplicación para generar un ID de la aplicación de Datadog y un token de cliente únicos.
3. Haz clic en Create Application (Crear aplicación).

Paso 3: Inicializar el SDK de Datadog con el contexto de la aplicación

Actualizar el fragmento de inicialización

En el fragmento de inicialización, define un nombre de entorno, un nombre de servicio y un número de versión. En los ejemplos siguientes, APP_VARIANT_NAME especifica la variante de la aplicación que genera datos. Para obtener más información, consulta Uso de etiquetas.

Durante la inicialización, también puedes definir la frecuencia de muestreo (sesiones RUM) y el consentimiento de seguimiento para el cumplimiento del RGPD, como se describe a continuación. Consulta otras opciones de configuración para inicializar la biblioteca.

class SampleApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        val configuration = Configuration.Builder(
            clientToken = <CLIENT_TOKEN>,
            env = <ENV_NAME>,
            variant = <APP_VARIANT_NAME>
        ).build()
        Datadog.initialize(this, configuration, trackingConsent)
    }
}

public class SampleApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Configuration configuration =
                new Configuration.Builder(<CLIENT_TOKEN>, <ENV_NAME>, <APP_VARIANT_NAME>)
                        .build();
        Datadog.initialize(this, configuration, trackingConsent);
    }
}

class SampleApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        val configuration = Configuration.Builder(
                clientToken = <CLIENT_TOKEN>,
                env = <ENV_NAME>,
                variant = <APP_VARIANT_NAME>
            )
            .useSite(DatadogSite.EU1)
            .build()
        Datadog.initialize(this, configuration, trackingConsent)
    }
}

public class SampleApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Configuration configuration =
                new Configuration.Builder(<CLIENT_TOKEN>, <ENV_NAME>, <APP_VARIANT_NAME>)
                        .useSite(DatadogSite.EU1)
                        .build();
        Datadog.initialize(this, configuration, trackingConsent);
    }
}

class SampleApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        val configuration = Configuration.Builder(
                clientToken = <CLIENT_TOKEN>,
                env = <ENV_NAME>,
                variant = <APP_VARIANT_NAME>
            )
            .useSite(DatadogSite.US3)
            .build()
        Datadog.initialize(this, configuration, trackingConsent)
    }
}

public class SampleApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Configuration configuration =
                new Configuration.Builder(<CLIENT_TOKEN>, <ENV_NAME>, <APP_VARIANT_NAME>)
                        .useSite(DatadogSite.US3)
                        .build();
        Datadog.initialize(this, configuration, trackingConsent);
    }
}

class SampleApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        val configuration = Configuration.Builder(
                clientToken = <CLIENT_TOKEN>,
                env = <ENV_NAME>,
                variant = <APP_VARIANT_NAME>
            )
            .useSite(DatadogSite.US5)
            .build()
        Datadog.initialize(this, configuration, trackingConsent)
    }
}

public class SampleApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Configuration configuration =
                new Configuration.Builder(<CLIENT_TOKEN>, <ENV_NAME>, <APP_VARIANT_NAME>)
                        .useSite(DatadogSite.US5)
                        .build();
        Datadog.initialize(this, configuration, trackingConsent);
    }
}

class SampleApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        val configuration = Configuration.Builder(
                clientToken = <CLIENT_TOKEN>,
                env = <ENV_NAME>,
                variant = <APP_VARIANT_NAME>
            )
            .useSite(DatadogSite.US1_FED)
            .build()
        Datadog.initialize(this, configuration, trackingConsent)
    }
}

public class SampleApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Configuration configuration =
                new Configuration.Builder(<CLIENT_TOKEN>, <ENV_NAME>, <APP_VARIANT_NAME>)
                        .useSite(DatadogSite.US1_FED)
                        .build();
        Datadog.initialize(this, configuration, trackingConsent);
    }
}

class SampleApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        val configuration = Configuration.Builder(
                clientToken = <CLIENT_TOKEN>,
                env = <ENV_NAME>,
                variant = <APP_VARIANT_NAME>
            )
            .useSite(DatadogSite.AP1)
            .build()
        Datadog.initialize(this, configuration, trackingConsent)
    }
}

public class SampleApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Configuration configuration =
                new Configuration.Builder(<CLIENT_TOKEN>, <ENV_NAME>, <APP_VARIANT_NAME>)
                        .useSite(DatadogSite.AP1)
                        .build();
        Datadog.initialize(this, configuration, trackingConsent);
    }
}

class SampleApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        val configuration = Configuration.Builder(
                clientToken = <CLIENT_TOKEN>,
                env = <ENV_NAME>,
                variant = <APP_VARIANT_NAME>
            )
            .useSite(DatadogSite.AP2)
            .build()
        Datadog.initialize(this, configuration, trackingConsent)
    }
}

public class SampleApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Configuration configuration =
                new Configuration.Builder(<CLIENT_TOKEN>, <ENV_NAME>, <APP_VARIANT_NAME>)
                        .useSite(DatadogSite.AP2)
                        .build();
        Datadog.initialize(this, configuration, trackingConsent);
    }
}

Las credenciales de inicialización requieren el nombre de variante de tu aplicación y utilizan el valor de BuildConfig.FLAVOR. Con la variante, el SDK puede hacer coincidir los errores informados desde tu aplicación con los archivos de asignación cargados por el complemento Gradle. Si no tienes variantes, las credenciales utilizan una cadena vacía.

El complemento Gradle carga automáticamente el archivo mapping.txt ProGuard adecuado en el momento de la compilación para que puedas ver las trazas (traces) de error de stack tecnológico desofuscadas. Para obtener más información, consulta la sección Cargar el archivo de asignación.

Activar la función para iniciar el envío de datos

Para permitir que el SDK Android comience a enviar datos:

    val rumConfig = RumConfiguration.Builder(applicationId)
      .trackInteractions()
      .trackLongTasks(durationThreshold) // Not applicable to Error Tracking
      .useViewTrackingStrategy(strategy)
      .build()
    Rum.enable(rumConfig)

    RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
      .trackInteractions()
      .trackLongTasks(durationThreshold) // Not applicable to Error Tracking
      .useViewTrackingStrategy(strategy)
      .build();
    Rum.enable(rumConfig);

Consulta ViewTrackingStrategy para activar el seguimiento automático de todas tus vistas (actividades, fragmentos, etc.).

Instrumentar tus WebViews (opcional)

Si tu aplicación Android utiliza WebViews para mostrar contenido web, puedes instrumentarlos para rastrear errores y fallos de JavaScript que ocurran dentro del contenido web.

Para instrumentar tus WebViews:

1. Añade la dependencia Gradle declarando dd-sdk-android-webview como dependencia en tu archivo build.gradle:

   dependencies {
    implementation "com.datadoghq:dd-sdk-android-webview:<latest_version>"
   }
   

2. Habilita el seguimiento de WebViews de una instancia WebView dada proporcionando una lista de hosts para realizar un seguimiento:

   WebViewTracking.enable(webView, hosts)
   

Para obtener más información, consulta Seguimiento de WebViews.

Paso 4: Añadir informes de fallos del NDK

Si tu aplicación Android utiliza código nativo (C/C++) a través del Android NDK (Native Development Kit), puedes realizar un seguimiento de los fallos que se producen en este código nativo. El código nativo se utiliza a menudo para operaciones críticas para el rendimiento, el procesamiento de imágenes o cuando se reutilizan bibliotecas C/C++ existentes.

Sin los informes de fallos del NDK, los fallos de tu código nativo no aparecen en Error Tracking, lo que dificulta la depuración de problemas en esta parte de tu aplicación.

Para activar el informe de fallos del NDK, utiliza el complemento Datadog NDK:

1. Añade la dependencia de Gradle declarando la biblioteca como dependencia en tu archivo build.gradle:

    dependencies {
        implementation("com.datadoghq:dd-sdk-android-ndk:x.x.x")
        //(...)
    }
   

2. Habilita la recopilación de fallos del NDK luego de inicializar el SDK:

   NdkCrashReports.enable()
   

Paso 5: Añadir informes de una ANR

Una “Aplicación que no responde” (ANR) es un tipo de error específico de Android que se activa cuando la aplicación no responde durante demasiado tiempo. Puedes añadir informes de ANR a tu configuración de RUM para monitorizar estos problemas con las respuestas de las aplicaciones.

Para habilitar los informes de ANR, añade lo siguiente a tu configuración de RUM:

val rumConfig = RumConfiguration.Builder(applicationId)
    .trackInteractions()
    .trackLongTasks(durationThreshold)
    .trackNonFatalAnrs(true) // Enable non-fatal ANR reporting
    .useViewTrackingStrategy(strategy)
    .build()
Rum.enable(rumConfig)

RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
    .trackInteractions()
    .trackLongTasks(durationThreshold)
    .trackNonFatalAnrs(true) // Enable non-fatal ANR reporting
    .useViewTrackingStrategy(strategy)
    .build();
Rum.enable(rumConfig);

Los casos de ANR sólo se notifican a través del SDK (no a través de los logs).

Notificación de ANR fatales

Los casos de ANR fatales provocan fallos. La aplicación informa de ellos cuando no responde, lo que lleva a que el sistema operativo Android muestre un cuadro de diálogo emergente al usuario, que decide forzar el cierre de la aplicación a través de la ventana emergente.

• En la página de Error Tracking, las ANR fatales se agrupan en función de su similitud, lo que puede dar lugar a la creación de varios problemas individuales.
• Por defecto, Datadog captura las ANR fatales a través de la API ApplicationExitInfo (disponible a partir de Android v30 o posteriores), que pueden ser leídas en el siguiente lanzamiento de la aplicación.
• En Android v29 y anteriores, no es posible informar de ANR fatales.

Notificación de ANR no fatales

Los casos de ANR no fatales pueden o no haber provocado el cierre de la aplicación (fallo).

• En la página de Error Tracking, las ANR no fatales se agrupan en un problema único debido a su nivel de ruido
• Por defecto, la notificación de casos de ANR no fatales en Android v30 o posteriores está deshabilitada, ya que crearía demasiado ruido sobre los casos de ANR fatales. Sin embargo, en Android v29 y anteriores, la notificación de casos de ANR no fatales está habilitada por defecto, ya que en esas versiones no se pueden notificar casos de ANR fatales.

Para cualquier versión de Android, puedes anular la configuración predeterminada para la notificación de casos de ANR no fatales definiendo trackNonFatalAnrs como true o false al inicializar el SDK.

Paso 6: Obtener trazas de stack tecnológico desofuscadas

Cuando se crea una aplicación Android para producción, el código suele ofuscarse con ProGuard o R8 para reducir el tamaño de la aplicación y proteger la propiedad intelectual. Esta ofuscación hace que las trazas de stack tecnológico de los informes de fallos sean ilegibles, mostrando nombres de clases y métodos sin sentido como a.b.c() en lugar de com.example.MyClass.myMethod().

Para que estas trazas de stack tecnológico sean legibles para la depuración, debes cargar tus archivos de asignación en Datadog. Estos archivos contienen la asignación entre el código ofuscado y el original, lo que permite a Datadog desofuscar automáticamente las trazas de stack tecnológico en tus informes de error.

Cómo funciona

Datadog utiliza un ID de compilación único generado para cada compilación con el fin de hacer coincidir automáticamente las trazas de stack tecnológico con los archivos de asignación correctos. Esto garantiza que:

• Las trazas de stack tecnológico siempre se desofuscan con el archivo de asignación correcto, independientemente de cuándo se haya cargado.
• Puedes cargar archivos de asignación durante las compilaciones de preproducción o producción.
• El proceso funciona a la perfección en diferentes variantes y entornos de compilación.

El proceso de emparejamiento depende de la versión de tu complemento Gradle para Android:

• Versiones 1.13.0 y superiores: Utiliza el campo build_id (requiere el SDK Android para Datadog v2.8.0 o posteriores).
• Versiones anteriores: Utiliza una combinación de los campos service, version y variant

Carga de tu archivo de asignación

El complemento Gradle para Android automatiza el proceso de carga de archivos de asignación. Una vez configurado, carga automáticamente el archivo de asignación ProGuard/R8 adecuado para cada variante de compilación al compilar la aplicación.

Nota: Al volver a cargar un archivo de asignación no se anula el existente, si la versión no ha cambiado. Para obtener información sobre las limitaciones de tamaño de los archivos y otras restricciones, consulta la sección Limitaciones.

Ejecutar las tareas de carga

Después de configurar el complemento, ejecuta las tareas de Gradle para cargar tu archivo de asignación Proguard/R8 y los archivos de símbolos NDK a Datadog:

./gradlew uploadMappingRelease
./gradlew uploadNdkSymbolFilesRelease

Para cualquier error, puedes acceder a la ruta del archivo, al número de línea y a un fragmento de código para cada marco de la trace (traza) de stack tecnológico.

Lista de archivos de asignación cargados

Consulta la página Símbolos de depuración RUM para ver todos los símbolos cargados.

Funciones avanzadas de Error Tracking

val rumConfig = RumConfiguration.Builder(applicationId)
        // Here 75% of the RUM sessions are sent to Datadog
        .setSessionSampleRate(75.0f)
        .build()
Rum.enable(rumConfig)

val tracedHostsWithHeaderType = mapOf(
    "example.com" to setOf(
        TracingHeaderType.DATADOG,
        TracingHeaderType.TRACECONTEXT),
    "example.eu" to setOf(
        TracingHeaderType.DATADOG,
        TracingHeaderType.TRACECONTEXT))
val okHttpClient = OkHttpClient.Builder()
    .addInterceptor(DatadogInterceptor.Builder(tracedHostsWithHeaderType).build())
    .build()

Map<String, Set<TracingHeaderType>> tracedHostsWithHeaderType = new HashMap<>();
Set<TracingHeaderType> datadogAndW3HeadersTypes = new HashSet<>(Arrays.asList(TracingHeaderType.DATADOG, TracingHeaderType.TRACECONTEXT));
tracedHostsWithHeaderType.put("example.com", datadogAndW3HeadersTypes);
tracedHostsWithHeaderType.put("example.eu", datadogAndW3HeadersTypes);
OkHttpClient okHttpClient = new OkHttpClient.Builder()
    .addInterceptor(new DatadogInterceptor.Builder(tracedHostsWithHeaderType).build())
    .build();

val okHttpClient = OkHttpClient.Builder()
    .addNetworkInterceptor(DatadogInterceptor.Builder(tracedHostsWithHeaderType).build())
    .build()

OkHttpClient okHttpClient = new OkHttpClient.Builder()
    .addNetworkInterceptor(new DatadogInterceptor.Builder(tracedHostsWithHeaderType).build())
    .build();

.trackBackgroundEvents(true)

.trackBackgroundEvents(true)

datadog {
    foo {
        versionName = "foo"
    }
    bar {
        versionName = "bar"
    }
    fooBar {
        versionName = "fooBar"
    }
}

tasks["minify${variant}WithR8"].finalizedBy { tasks["uploadMapping${variant}"] }

Limitaciones

Tamaño de los archivos

El tamaño de los archivos de asignación está limitado a 500 MB cada uno. Si tu proyecto tiene un archivo de asignación de mayor tamaño, utiliza una de las siguientes opciones para reducir el tamaño del archivo:

• Define la opción mappingFileTrimIndents como true. En promedio, esto reduce el tamaño del archivo en un 5%.
• Configura un mapa de mappingFilePackagesAliases: Esto sustituye los nombres de paquetes por alias más cortos. Nota: Las trazas de stack tecnológico de Datadog utilizan el mismo alias, en lugar del nombre original del paquete, por lo que es mejor utilizar esta opción para dependencias de terceros.

datadog {
    mappingFileTrimIndents = true
    mappingFilePackageAliases = mapOf(
        "kotlinx.coroutines" to "kx.cor",
        "com.google.android.material" to "material",
        "com.google.gson" to "gson",
        "com.squareup.picasso" to "picasso"
    )
}

Recopilación

Al examinar los comportamientos de los informes de fallos RUM para Android, ten en cuenta lo siguiente:

• El fallo sólo puede detectarse una vez inicializado el SDK. Teniendo esto en cuenta, la recomendación es inicializar el SDK lo antes posible en el método onCreate de tu aplicación.
• Los fallos RUM deben estar asociados a una vista RUM. Si un fallo se produce antes de que una vista sea visible (normalmente una actividad o fragmento en un estado onResume) o después de que la aplicación sea enviada a un segundo plano por el usuario final que deja de utilizarla, el fallo se silencia y no se informa para su recopilación. Para mitigar esta situación, utiliza el método trackBackgroundEvents()en tu compilador RumConfiguration.
• Solo se conservan los fallos que se producen en las sesiones muestreadas. Si una frecuencia de muestreo de sesión no es del 100%, algunos fallos no se notifican.

Para test tu implementación

Para verificar la configuración de Crash Reporting y Error Tracking Android, necesitas generar un error en tu aplicación y confirmar que el error aparece en Datadog.

Para test tu implementación

1. Ejecuta tu aplicación en un emulador de Android o en un dispositivo real.

2. Ejecuta un código que contenga un error o bloqueo. Por ejemplo:

   fun onEvent() {
       throw RuntimeException("Crash the app")
   }
   

3. Después de que se produzca el fallo, reinicia tu aplicación y espera a que el SDK Android cargue el informe de fallo en Error Tracking.

Extensiones Kotlin

extensión Closeable

Puedes monitorizar el uso de instancias Closeable con el método useMonitored, que informa de los errores a Datadog y luego cierra el recurso:

val closeable: Closeable = ...
closeable.useMonitored {
    // Your code here
}

Seguimiento de recursos locales

Puedes rastrear el acceso a los activos mediante la utilización del método de extensión getAssetAsRumResource:

val inputStream = context.getAssetAsRumResource(fileName)

El uso de los recursos locales puede rastrearse utilizando el método de extensión getRawResAsRumResource:

val inputStream = context.getRawResAsRumResource(id)

Referencias adicionales

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

Error Tracking en el frontendDOCUMENTACIÓN Código fuente de dd-sdk-androidCÓDIGO FUENTE Para empezar con Error TrackingDOCUMENTACIÓN Visualizar los datos de Error Tracking en el ExplorerDOCUMENTACIÓN