Personnaliser vos rapports d'erreur Firebase Crashlytics

Dans le tableau de bord Crashlytics, vous pouvez cliquer sur un problème pour obtenir un rapport d'événement détaillé. Vous pouvez personnaliser ces rapports pour mieux comprendre ce qui se passe dans votre application et les circonstances des événements signalés à Crashlytics.

• Instrumentez votre application pour enregistrer des clés personnalisées, des messages de journal personnalisés et des identifiants utilisateur.

• Signalez les exceptions à Crashlytics.

• Obtenez automatiquement des journaux de fil d'Ariane si votre application utilise le SDK Firebase pour Google Analytics. Ces journaux vous permettent de voir les actions des utilisateurs qui ont déclenché un événement collecté par Crashlytics dans votre application.

• Désactivez les rapports d'erreur automatiques et activez les rapports avec option d'activation pour vos utilisateurs. Notez que, par défaut, Crashlytics collecte automatiquement les rapports d'erreur pour tous les utilisateurs de votre application.

Ajouter des clés personnalisées

Les clés personnalisées vous permettent de connaître l'état spécifique de votre application pouvant entraîner un plantage. Vous pouvez associer des paires clé/valeur arbitraires à vos rapports d'erreur, puis utiliser les clés personnalisées pour rechercher et filtrer les rapports d'erreur dans la console Firebase.

• Dans le tableau de bord Crashlytics, vous pouvez rechercher les problèmes qui correspondent à une clé personnalisée.

• Lorsque vous examinez un problème spécifique dans la console, vous pouvez afficher les clés personnalisées associées à chaque événement (sous-onglet Clés) et même filtrer les événements par clés personnalisées (menu Filtrer en haut de la page).

Utilisez la méthode d'instance setCustomKey pour définir des paires clé/valeur. Notez que setCustomKey est surchargé pour le paramètre value afin d'accepter tout argument primitif ou String. Voici quelques exemples :

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
}

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 */);

Vous pouvez également modifier la valeur d'une clé existante en appelant la clé et en définissant une autre valeur. Exemple :

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

FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

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

Ajoutez des paires clé/valeur de manière groupée en transmettant une instance de CustomKeysAndValues à la méthode d'instance setCustomKeys :

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

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);

Ajouter des messages de journaux personnalisés

Pour obtenir plus de contexte sur les événements ayant précédé un plantage, vous pouvez ajouter des journaux Crashlytics personnalisés à votre application. Crashlytics associe les journaux à vos données de plantage et les affiche sur la page Crashlytics de la console Firebase, sous l'onglet Journaux.

Utilisez log pour identifier les problèmes. Exemple :

Firebase.crashlytics.log("message")

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

Définir des identifiants utilisateur

Pour diagnostiquer un problème, il est souvent utile de savoir quels utilisateurs ont rencontré un plantage donné. Crashlytics inclut un moyen d'identifier anonymement les utilisateurs dans vos rapports d'erreur.

Pour ajouter des User-ID à vos rapports, attribuez à chaque utilisateur un identifiant unique sous la forme d'un numéro d'ID, d'un jeton ou d'une valeur hachée :

Firebase.crashlytics.setUserId("user123456789")

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

Si vous devez effacer un identifiant utilisateur après l'avoir défini, réinitialisez la valeur sur une chaîne vide. Effacer un identifiant utilisateur ne supprime pas les enregistrements Crashlytics existants. Si vous devez supprimer des enregistrements associés à un ID utilisateur, contactez l'assistance Firebase.

(NDK Android uniquement) Ajouter des métadonnées aux rapports d'erreur NDK

Vous pouvez éventuellement inclure l'en-tête crashlytics.h dans votre code C++ pour ajouter des métadonnées aux rapports d'erreur NDK, telles que des clés personnalisées, des journaux personnalisés et des identifiants utilisateur. Toutes ces options sont décrites sur cette page.

crashlytics.h est disponible en tant que bibliothèque C++ d'en-tête uniquement dans le dépôt GitHub du SDK Firebase Android.

Lisez les commentaires dans le fichier d'en-tête pour obtenir des instructions sur l'utilisation des API C++ du NDK.

Inclure les rapports GWP-ASan pour déboguer les problèmes de mémoire corrompue

Crashlytics peut vous aider à déboguer les plantages causés par des erreurs de mémoire native en collectant des rapports GWP-ASan. Ces erreurs liées à la mémoire peuvent être associées à une corruption de la mémoire dans votre application, qui est la principale cause des failles de sécurité des applications.

• Vous pouvez afficher ces données dans un nouvel onglet "Traces de pile de mémoire" lorsque vous cliquez sur les détails d'un problème dans le tableau de bord Crashlytics.

• Vous pouvez également utiliser le nouveau signal et filtre "Rapport GWP-ASan" pour afficher rapidement tous les problèmes liés à ces données.

Vous pouvez obtenir des rapports de mémoire GWP-ASan si vous activez explicitement GWP-ASan dans votre application et utilisez le SDK Crashlytics pour NDK 18.3.6 ou version ultérieure (Firebase BoM 31.3.0 ou version ultérieure). Vous pouvez tester votre configuration GWP-ASan à l'aide de l'exemple de code natif dans la documentation Android.

Signaler les exceptions non fatales

En plus de signaler automatiquement les plantages de votre application, Crashlytics vous permet d'enregistrer les exceptions non fatales et de vous les envoyer au prochain lancement de votre application.

Utilisez la méthode recordException pour enregistrer les exceptions non fatales dans les blocs catch de votre application. Exemple :

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

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

Vous pouvez également associer des clés personnalisées à l'exception non fatale spécifique. Exemple :

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
}

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
}

Toutes les exceptions enregistrées s'affichent comme des problèmes non fatals dans la console Firebase. Le récapitulatif des problèmes contient toutes les informations sur l'état que vous obtenez normalement à partir des plantages, ainsi que des détails par version d'Android et par appareil.

Crashlytics traite les exceptions sur un thread d'arrière-plan dédié afin de minimiser l'impact sur les performances de votre application. Pour réduire le trafic réseau de vos utilisateurs, Crashlytics regroupe les exceptions enregistrées et les envoie au prochain lancement de l'application.

Obtenir les journaux du fil d'Ariane

Les journaux de fil d'Ariane vous permettent de mieux comprendre les interactions d'un utilisateur avec votre application avant un plantage, une erreur non fatale ou un événement ANR. Ces journaux peuvent être utiles pour reproduire et déboguer un problème.

Les journaux de fil d'Ariane sont fournis par Google Analytics. Pour les obtenir, vous devez activer Google Analytics pour votre projet Firebase et ajouter le SDK Firebase pour Google Analytics à votre application. Une fois ces conditions remplies, les journaux de fil d'Ariane sont automatiquement inclus dans les données d'un événement dans l'onglet Journaux lorsque vous affichez les détails d'un problème.

Le SDK Analytics enregistre automatiquement l'événement screen_view, ce qui permet aux journaux de fil d'Ariane d'afficher la liste des écrans consultés avant le plantage, l'erreur non fatale ou l'événement ANR. Un journal de breadcrumbs screen_view contient un paramètre firebase_screen_class.

Les journaux de fil d'Ariane sont également renseignés avec tous les événements personnalisés que vous enregistrez manuellement dans la session de l'utilisateur, y compris les données des paramètres de l'événement. Ces données peuvent aider à afficher une série d'actions utilisateur ayant conduit à un plantage, une erreur non fatale ou un événement ANR.

Notez que vous pouvez contrôler la collecte et l'utilisation des données Google Analytics, y compris celles qui alimentent les journaux de fil d'Ariane.

Activer les rapports d'activation

Par défaut, Crashlytics collecte automatiquement les rapports d'erreur pour tous les utilisateurs de votre application. Pour donner aux utilisateurs plus de contrôle sur les données qu'ils envoient, vous pouvez activer les rapports avec option d'activation en désactivant les rapports automatiques et en n'envoyant des données à Crashlytics que lorsque vous le choisissez dans votre code.

1. Dans le bloc application de votre fichier AndroidManifest.xml, ajoutez un tag meta-data pour désactiver la collecte automatique :

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

2. Activez la collecte pour certains utilisateurs en appelant le remplacement de la collecte de données Crashlytics au moment de l'exécution. La valeur de remplacement persiste lors de tous les lancements ultérieurs de votre application. Crashlytics peut ainsi collecter automatiquement des rapports pour cet utilisateur.

   Kotlin

   Firebase.crashlytics.setCrashlyticsCollectionEnabled(true)

   Java

   FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(true);

   Si l'utilisateur désactive ultérieurement la collecte de données, vous pouvez transmettre false comme valeur de remplacement. Cette valeur s'appliquera la prochaine fois que l'utilisateur lancera l'application et persistera lors de tous les lancements ultérieurs pour cet utilisateur.

Gérer les données des insights sur les plantages

Les insights sur les plantages vous aident à résoudre les problèmes en comparant vos traces de pile anonymisées à celles d'autres applications Firebase. Ils vous indiquent si votre problème fait partie d'une tendance plus large. Pour de nombreux problèmes, les insights sur les plantages fournissent même des ressources pour vous aider à déboguer le plantage.

Crash Insights utilise des données de plantage agrégées pour identifier les tendances de stabilité courantes. Si vous préférez ne pas partager les données de votre application, vous pouvez désactiver les insights sur les plantages dans le menu Insights sur les plantages en haut de la liste des problèmes Crashlytics de la Firebase Console.