Resumen

Android Error Tracking te brinda una visibilidad completa sobre la salud de tu aplicación móvil al capturar automáticamente fallos, excepciones y errores. Con esta función, puedes:

• Monitorear la estabilidad de la aplicación en tiempo real con alertas instantáneas de fallos y seguimiento de la tasa de errores a través de versiones, dispositivos y segmentos de usuarios.
• Depura problemas más rápido con trazas de pila desofuscadas y cargas automáticas de archivos de mapeo de ProGuard para una identificación más fácil de problemas.
• Mejora la calidad de la aplicación al identificar características propensas a fallos, rastrear tendencias de errores y priorizar correcciones para una mejor satisfacción del usuario.
• Accede a tableros de fallos en Android agregados y atributos.
• Visualiza informes de fallos en Android desofuscados con análisis de tendencias.

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

Tus informes de fallos aparecen en Seguimiento de Errores.

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 - Declara el SDK de Android como una dependencia

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

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 - Especifica los detalles de la aplicación en la UI

1. Navega a Errors > Settings > Browser and Mobile > + New Application.
2. Selecciona android como el tipo de aplicación e ingresa un nombre de aplicación para generar un ID de aplicación único de Datadog y un token de cliente.
3. Haz clic en Create Application.

Paso 3 - Inicializa el SDK de Datadog con el contexto de la aplicación

Actualiza el fragmento de inicialización

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

Durante la inicialización, también puedes establecer la tasa de muestreo (sesiones RUM) y establecer el consentimiento de seguimiento para el cumplimiento del GDPR, 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 asociar los errores reportados de tu aplicación con los archivos de mapeo subidos por el complemento de Gradle. Si no tienes variantes, las credenciales utilizan una cadena vacía.

El complemento de Gradle sube automáticamente el archivo ProGuard mapping.txt apropiado en el momento de la construcción para que puedas ver las trazas de pila desofuscadas. Para más información, consulta la sección Upload your mapping file.

Habilita la función para comenzar a enviar datos

Para habilitar el SDK de Android para comenzar a enviar datos:

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

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

Consulta ViewTrackingStrategy para habilitar el seguimiento automático de todas tus vistas (actividades, fragmentos y más).

Instrumenta tus webviews (opcional)

Si tu aplicación de Android utiliza WebViews para mostrar contenido web, puedes instrumentarlas para rastrear errores de JavaScript y bloqueos que ocurren dentro del contenido web.

Para instrumentar tus webviews:

1. Agrega la dependencia de 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 webview para una instancia de WebView proporcionando una lista de hosts a rastrear:

   WebViewTracking.enable(webView, hosts)
   

Para más información, consulta Web View Tracking.

Paso 4 - Agrega informes de fallos NDK

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

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

Para habilitar el reporte de fallos de NDK, usa el complemento Datadog NDK:

1. Agrega 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 de NDK después de inicializar el SDK:

   NdkCrashReports.enable()
   

Paso 5 - Agrega el reporte de ANR

Un “Application Not Responding” (ANR) es un error específico de Android que se produce cuando la aplicación no responde durante demasiado tiempo. Puedes agregar el reporte de ANR a tu configuración de RUM para monitorear estos problemas de respuesta de la aplicación.

Para habilitar el reporte de ANR, agrega lo siguiente a tu configuración de RUM:

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

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

Los ANRs solo se reportan a través del SDK (no a través de los Logs).

Informando ANRs fatales

Los ANRs fatales resultan en fallos. La aplicación los reporta cuando no responde, lo que hace que el sistema operativo Android muestre un cuadro de diálogo emergente al usuario, quien elige forzar el cierre de la aplicación.

• En la página Error Tracking, los ANRs fatales se agrupan según su similitud, lo que puede resultar en la creación de varios problemas individuales.
• Por defecto, Datadog captura ANRs fatales a través de la API ApplicationExitInfo (disponible desde Android 30+), que se puede leer en el próximo lanzamiento de la aplicación.
• En Android 29 y versiones anteriores, no es posible reportar ANRs fatales.

Reporte de ANRs no fatales

Los ANRs no fatales pueden o no haber llevado a la terminación de la aplicación (fallo).

• En la página Error Tracking, los ANRs no fatales se agrupan bajo un único problema debido a su nivel de ruido.
• Por defecto, el informe de ANRs no fatales en Android 30+ está deshabilitado porque generaría demasiado ruido sobre los ANRs fatales. En Android 29 y versiones anteriores, sin embargo, el informe de ANRs no fatales está habilitado por defecto, ya que los ANRs fatales no pueden ser reportados en esas versiones.

Para cualquier versión de Android, puedes anular la configuración predeterminada para informar ANRs no fatales configurando trackNonFatalAnrs a true o false al inicializar el SDK.

Paso 6 - Obtener trazas de pila desofuscadas

Cuando tu aplicación de Android se construye para producción, el código se ofusca típicamente usando 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 pila en los informes de accidentes sean ilegibles, mostrando nombres de clases y métodos sin sentido como a.b.c() en lugar de com.example.MyClass.myMethod().

Para hacer que estas trazas de pila sean legibles para la depuración, necesitas subir tus archivos de mapeo a Datadog. Estos archivos contienen el mapeo entre el código ofuscado y el original, permitiendo que Datadog desofusque automáticamente las trazas de pila en tus informes de errores.

Cómo funciona

Datadog utiliza un ID de construcción único generado para cada construcción para emparejar automáticamente las trazas de pila con los archivos de mapeo correctos. Esto asegura que:

• Las trazas de pila siempre se desofusquen con el archivo de mapeo correcto, independientemente de cuándo se haya subido.
• Puedes cargar archivos de mapeo durante compilaciones de pre-producción o producción.
• El proceso funciona sin problemas a través de diferentes variantes de compilación y entornos.

El proceso de coincidencia depende de tu versión del plugin de Gradle para Android:

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

Sube tu archivo de mapeo

El plugin de Gradle para Android automatiza el proceso de carga del archivo de mapeo. Después de la configuración, sube automáticamente el archivo de mapeo ProGuard/R8 apropiado para cada variante de compilación cuando construyes tu aplicación.

Nota: Volver a subir un archivo de mapeo no reemplaza el existente si la versión no ha cambiado. Para información sobre limitaciones de tamaño de archivo y otras restricciones, consulta la sección Limitaciones.

Ejecuta las tareas de carga

Después de configurar el plugin, ejecuta las tareas de Gradle para subir tu archivo de mapeo Proguard/R8 y los archivos de símbolos NDK a Datadog:

./gradlew uploadMappingRelease
./gradlew uploadNdkSymbolFilesRelease

Para cualquier error dado, puedes acceder a la ruta del archivo, número de línea y un fragmento de código para cada marco de la traza de pila relacionada.

Listar archivos de mapeo subidos

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

Características 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 archivo

Los archivos de mapeo están limitados en tamaño a 500 MB cada uno. Si tu proyecto tiene un archivo de mapeo más grande que esto, utiliza una de las siguientes opciones para reducir el tamaño del archivo:

• Establece la opción mappingFileTrimIndents a true. Esto reduce el tamaño de tu archivo en un 5%, en promedio.
• Establece un mapa de mappingFilePackagesAliases: Esto reemplaza los nombres de los paquetes con alias más cortos. Nota: El stacktrace de Datadog utiliza el mismo alias en lugar del nombre de paquete original, por lo que es mejor usar esta opción para las 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"
    )
}

Colección

Al observar los comportamientos de informes de fallos de RUM para Android, considera lo siguiente:

• El fallo solo puede ser detectado después de que el SDK esté inicializado. Dado esto, la recomendación es inicializar el SDK lo antes posible en el método onCreate de tu aplicación.
• Los fallos de RUM deben estar asociados a una vista de RUM. Si ocurre un fallo antes de que una vista sea visible (típicamente una Actividad o Fragmento en un estado onResume), o después de que el usuario envíe la aplicación a segundo plano al navegar fuera de ella, el fallo se silencia y no se reporta para su recopilación. Para mitigar esto, utiliza el método trackBackgroundEvents() método en tu constructor RumConfiguration.
• Solo se conservan los fallos que ocurren en sesiones muestreadas. Si una tasa de muestreo de sesiones no es del 100%, algunos fallos no son reportados.

Prueba tu implementación

Para verificar tu configuración de informes de fallos y seguimiento de errores en Android, necesitas provocar un fallo en tu aplicación y confirmar que el error aparece en Datadog.

Para probar tu implementación:

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

2. Ejecuta algún código que contenga un error o fallo. Por ejemplo:

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

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

Extensiones de Kotlin

Closeable extensión

Puedes realizar el seguimiento del uso de la instancia Closeable con el método useMonitored, que reporta errores a Datadog y cierra el recurso después:

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

Realizar el seguimiento de activos locales como recursos

Puedes realizar el seguimiento del acceso a los activos utilizando el método de extensión getAssetAsRumResource:

val inputStream = context.getAssetAsRumResource(fileName)

Puedes realizar el seguimiento del uso de los recursos locales utilizando el método de extensión getRawResAsRumResource:

val inputStream = context.getRawResAsRumResource(id)

Lectura adicional

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

Frontend Error TrackingDOCUMENTATION Código fuente para dd-sdk-androidSOURCE CODE Comienza con Error TrackingDOCUMENTATION Visualiza los datos de Error Tracking en el Explorer.DOCUMENTATION