Personaliza los informes de fallas de Firebase Crashlytics

iOS+ Android Flutter Unity

En el panel de Crashlytics, puedes hacer clic en un problema para obtener un informe detallado del evento. Puedes personalizar esos informes para comprender mejor lo que sucede en tu app y las circunstancias de los eventos informados a Crashlytics.

• Instrumenta tu app para registrar claves personalizadas, mensajes de registro personalizados y, además, identificadores de usuario.

• Informa excepciones a Crashlytics.

• Obtén automáticamente registros de rutas de navegación si tu app usa el SDK de Firebase para Google Analytics. Estos registros te brindan visibilidad sobre las acciones del usuario que conducen a un evento recopilado por Crashlytics en tu app.

• Desactiva los informes de fallas automáticos y habilita los informes de aceptación para tus usuarios. Ten en cuenta que, de forma predeterminada, Crashlytics recopila informes de fallas de todos los usuarios de tu app automáticamente.

Agrega claves personalizadas

Las claves personalizadas te ayudan a obtener el estado específico de la app hasta el momento de la falla. Puedes asociar pares clave-valor arbitrarios con tus informes de fallas y, luego, usar las claves personalizadas para buscar y filtrar informes de fallas en Firebase console.

• En el panel de Crashlytics, puedes buscar problemas que coincidan con una clave personalizada.

• Cuando revises un problema específico en la consola, podrás ver las claves personalizadas asociadas a cada evento (pestaña secundaria Claves) y filtrar los eventos por claves personalizadas (menú Filtrar en la parte superior de la página).

Nota: Crashlytics admite un máximo de 64 pares clave-valor. Cuando alcances este límite, no se guardarán los valores adicionales. Cada par clave-valor puede tener un tamaño máximo de 1 KB.

Usa el método de instancia setCustomKey para establecer pares clave-valor. Ten en cuenta que setCustomKey se sobrecarga para que el parámetro value acepte cualquier argumento básico o String. Estos son algunos ejemplos:

Kotlin

val crashlytics = Firebase.crashlytics
crashlytics.setCustomKeys {
    key("my_string_key", "foo") // String value
    key("my_bool_key", true) // boolean value
    key("my_double_key", 1.0) // double value
    key("my_float_key", 1.0f) // float value
    key("my_int_key", 1) // int value
}

Java

FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

crashlytics.setCustomKey("my_string_key", "foo" /* string value */);

crashlytics.setCustomKey("my_bool_key", true /* boolean value */);

crashlytics.setCustomKey("my_double_key", 1.0 /* double value */);

crashlytics.setCustomKey("my_float_key", 1.0f /* float value */);

crashlytics.setCustomKey("my_int_key", 1 /* int value */);

También puedes modificar el valor de una clave existente llamando a la clave y configurándola con un valor diferente. Por ejemplo:

Kotlin

val crashlytics = Firebase.crashlytics
crashlytics.setCustomKeys {
    key("current_level", 3)
    key("last_UI_action", "logged_in")
}

Java

FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

crashlytics.setCustomKey("current_level", 3);
crashlytics.setCustomKey("last_UI_action", "logged_in");

Para agregar pares clave-valor de forma masiva, pasa una instancia de CustomKeysAndValues al método de instancia setCustomKeys:

Kotlin

Para Kotlin, la funcionalidad existente es más simple que usar el compilador CustomKeysAndValues:

crashlytics.setCustomKeys {
  key("str_key", "hello")
  key("bool_key", true)
  key("int_key", 1)
  key("long_key", 1L)
  key("float_key", 1.0f)
  key("double_key", 1.0)
}

Java

CustomKeysAndValues keysAndValues = new CustomKeysAndValues.Builder()
.putString("string key", "string value")
.putString("string key 2", "string  value 2")
.putBoolean("boolean key", True)
.putBoolean("boolean key 2", False)
.putFloat("float key", 1.01)
.putFloat("float key 2", 2.02)
.build();

FirebaseCrashlytics.getInstance().setCustomKeys(keysAndValues);

Agrega mensajes de registro personalizados

Para darte más contexto sobre los eventos que se produjeron antes de una falla, puedes agregar registros personalizados de Crashlytics a la app. Crashlytics asocia los registros con los datos de fallas y los hace visibles en la página de Crashlytics de Firebase console, en la pestaña Registros.

Nota: Para evitar que la app se ralentice, Crashlytics limita los registros a 64 kB y borra las entradas de registro anteriores cuando los registros de una sesión superan ese límite.

Usa log para identificar problemas. Por ejemplo:

Kotlin

Firebase.crashlytics.log("message")

Java

FirebaseCrashlytics.getInstance().log("message");

Configura identificadores de usuarios

Para diagnosticar un problema, resulta útil saber cuáles de tus usuarios sufrieron una falla. Crashlytics incluye una manera de identificar usuarios de forma anónima en los informes de fallas.

Para agregar los ID de usuario a tus informes, asigna a cada usuario un identificador único con el formato de un número de ID, un token o un valor de hash:

Kotlin

Firebase.crashlytics.setUserId("user123456789")

Java

FirebaseCrashlytics.getInstance().setUserId("user123456789");

Si en algún momento necesitas borrar un identificador de usuario después de configurarlo, restablece el valor a una string en blanco. Borrar un identificador de usuario no quita los registros de Crashlytics existentes. Si necesitas borrar los registros asociados con un ID de usuario, comunícate con el equipo de asistencia de Firebase.

(Solo para el NDK de Android) Agrega metadatos a los informes de fallas del NDK

De manera opcional, puedes incluir el encabezado crashlytics.h en tu código de C++ para agregar metadatos a los informes de fallas del NDK, como claves personalizadas, registros personalizados e identificadores de usuario. Todas estas opciones se describieron más arriba en esta página.

crashlytics.h está disponible como una biblioteca C++ de solo encabezado en el repositorio de GitHub del SDK de Firebase Android.

Lee los comentarios del archivo de encabezado para obtener instrucciones sobre el uso de las APIs de C++ del NDK.

Incluye informes de GWP-ASan para depurar problemas de corrupción de memoria

Crashlytics puede ayudarte a depurar fallas causadas por errores de la memoria nativa; para ello, recopila los informes de GWP-ASan. Estos errores relacionados con la memoria se pueden asociar con la corrupción de la memoria dentro de tu app, lo que es la causa principal de las vulnerabilidades de seguridad de las apps.

• Puedes ver estos datos en la nueva pestaña "Seguimientos de pila de memoria" cuando haces clic en los detalles de un problema en el panel de Crashlytics.

• También puedes usar el nuevo indicador “Informe de GWP-ASan” y filtrar el contenido para ver rápidamente todos los problemas relacionados con estos datos.

Puedes obtener informes de memoria de GWP-ASan si habilitas GWP-ASan explícitamente en tu app y usas el SDK de Crashlytics para el NDK v18.3.6 y versiones posteriores (Firebase BoM v31.3.0 y versiones posteriores). Puedes probar tu configuración de GWP-ASan con el código nativo de ejemplo en la documentación de Android.

Informa excepciones recuperables

Además de informar las fallas de la app automáticamente, Crashlytics te permite registrar excepciones recuperables y te las envía la próxima vez que se inicie la app.

Nota: Crashlytics solo almacena las ocho excepciones registradas más recientes. Si la app genera más de ocho excepciones, se perderán las excepciones anteriores.

Usa el método recordException para registrar excepciones recuperables en los bloques catch de tu app. Por ejemplo:

Kotlin

try {
    methodThatThrows()
} catch (e: Exception) {
    Firebase.crashlytics.recordException(e)
    // handle your exception here
}

Java

try {
    methodThatThrows();
} catch (Exception e) {
    FirebaseCrashlytics.getInstance().recordException(e);
    // handle your exception here
}

Además, también puedes adjuntar claves personalizadas a la excepción específica no fatal. Por ejemplo:

Kotlin

try {
    methodThatThrows()
} catch (e: Exception) {
    Firebase.crashlytics.recordException(e) {
        key("string key", "string value")
        key("boolean key", true)
        key("float key", Float.MAX_VALUE)
    }
    // handle your exception here
}

Java

try {
    methodThatThrows();
} catch (Exception e) {
    CustomKeysAndValues keysAndValues = new CustomKeysAndValues.Builder()
            .putString("string key", "string value")
            .putBoolean("boolean key", true)
            .putFloat("float key", Float.MAX_VALUE)
            .build();
    FirebaseCrashlytics.getInstance().recordException(e, keysAndValues);
    // handle your exception here
}

Advertencia: Evita incluir un valor único (por ejemplo, un ID de usuario o una marca de tiempo) en tu mensaje de excepción. En su lugar, usa una clave personalizada. Agregar valores directamente puede provocar varios problemas y hacer que Crashlytics limite los informes de errores en tu app.

Todas las excepciones registradas aparecen como problemas recuperables en Firebase console. Este resumen de problemas contiene toda la información de estado que se obtiene normalmente a partir de las fallas, junto con desgloses por versión de Android y dispositivo de hardware.

Crashlytics procesa las excepciones en un subproceso dedicado en segundo plano para minimizar el impacto en el rendimiento de tu app. Para reducir el tráfico de red de tus usuarios, Crashlytics agrupa las excepciones registradas y las envía la próxima vez que se inicie la app.

Obtén registros de rutas de navegación

Los registros de rutas de navegación te permiten comprender mejor las interacciones que un usuario tuvo con tu app que desencadenaron el evento de falla, recuperable o de ANR. Estos registros pueden ser útiles cuando se intenta reproducir y depurar un problema.

Los registros de rutas de navegación se basan en Google Analytics, por lo que, para obtenerlos, debes habilitar Google Analytics para tu proyecto de Firebase y agregar el SDK de Firebase para Google Analytics a tu app. Una vez que se cumplan estos requisitos, los registros de rutas de navegación se incluyen automáticamente con los datos de un evento en la pestaña Registros cuando ves los detalles de un problema.

El SDK de Analytics registra automáticamente el evento screen_view, lo que permite que los registros de rutas de navegación muestren una lista de pantallas vistas antes del evento de falla, recuperable o de ANR. Un registro de rutas de navegación screen_view contiene un parámetro firebase_screen_class.

Los registros de rutas de navegación también se completan con cualquier evento personalizado que registres de forma manual en la sesión del usuario, incluidos los datos de los parámetros del evento. Estos datos pueden ayudar a mostrar una serie de acciones del usuario que desencadenaron un evento de falla, recuperable o de ANR.

Ten en cuenta que puedes controlar la recopilación y el uso de los datos de Google Analytics, que incluyen los datos que propagan los registros de rutas de navegación.

Habilita los informes de aceptación

Si habilitas los informes de aceptación inhabilitando los informes automáticos, reducirás la exactitud del recuento de eventos y las métricas sin fallas de tu app, lo que hará que reflejen en menor medida la estabilidad general de tu app. Obtén más información.

Según la configuración predeterminada, Crashlytics recopila informes de fallas de todos los usuarios de la app automáticamente. Para permitir que los usuarios tengan más control sobre los datos que envían, puedes habilitar los informes de aceptación si inhabilitas los informes automáticos y solo envías datos a Crashlytics cuando lo decidas en tu código.

1. En el bloque application del archivo AndroidManifest.xml, agrega una etiqueta meta-data para desactivar la recopilación automática:

   <meta-data
       android:name="firebase_crashlytics_collection_enabled"
       android:value="false" />
   

2. Habilita la recopilación para usuarios específicos; para ello, llama la anulación de recopilación de datos de Crashlytics durante el tiempo de ejecución. El valor de anulación persiste en todos los lanzamientos posteriores de tu app para que Crashlytics pueda recopilar informes automáticamente para ese usuario.

   Kotlin

   Firebase.crashlytics.setCrashlyticsCollectionEnabled(true)

   Java

   FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(true);

   Si el usuario inhabilita la recopilación de datos más adelante, puedes pasar false como el valor de anulación, que se aplicará la próxima vez que el usuario inicie la app y persistirá en todos los inicios posteriores de ese usuario.

Nota: Cuando se inhabilita la recopilación de datos para un usuario, Crashlytics almacenará la información de fallas de forma local en el dispositivo. Si después se habilita la recopilación de datos, toda la información de fallas almacenada en el dispositivo se enviará a Crashlytics para procesarla.

Administra los datos de Crash Insights

Crash Insights te ayuda a resolver problemas a través de la comparación de tus seguimientos de pila anonimizados con seguimientos de otras apps de Firebase y te permite saber si tu problema es parte de una tendencia mayor. En muchos casos, Crash Insights incluso proporciona recursos para ayudarte a depurar la falla.

Crash Insights usa datos de fallas globales para identificar las tendencias de estabilidad comunes. Si prefieres no compartir los datos de la app, puedes inhabilitar esta función en el menú Crash Insights ubicado en la parte superior de la lista de problemas de Crashlytics de Firebase console.

Nota: Si inhabilitas el uso compartido de los datos, también se quitarán las estadísticas de tus problemas. Los cambios pueden tardar hasta 24 horas en aplicarse.