Firebase is back at Google I/O on May 10! Register now

Personnalisez vos rapports d'erreur Firebase Crashlytics

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Ce guide décrit comment personnaliser vos rapports d'incident à l'aide des API Crashlytics. Par défaut, Crashlytics collecte automatiquement les rapports d'erreur natifs de la plate-forme pour tous les utilisateurs de votre application (vous pouvez également désactiver les rapports d'erreur automatiques et activer les rapports d'activation pour vos utilisateurs à la place). Crashlytics fournit cinq mécanismes de journalisation prêts à l'emploi : clés personnalisées , journaux personnalisés , identifiants d'utilisateur , exceptions interceptées et non interceptées .

Pour les applications Flutter, les rapports fatals sont envoyés à Crashlytics en temps réel sans que l'utilisateur ait besoin de redémarrer l'application. Les rapports non fatals sont écrits sur le disque pour être envoyés avec le prochain rapport fatal ou lorsque l'application redémarre.

Signaler les exceptions non interceptées

Vous pouvez intercepter automatiquement toutes les erreurs "fatales" générées dans le framework Flutter en remplaçant FlutterError.onError par FirebaseCrashlytics.instance.recordFlutterFatalError . Alternativement, pour intercepter également les exceptions "non fatales", remplacez FlutterError.onError par FirebaseCrashlytics.instance.recordFlutterError :

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  await Firebase.initializeApp();
  bool weWantFatalErrorRecording = true;
  FlutterError.onError = (errorDetails) {
    if(weWantFatalErrorRecording){
      FirebaseCrashlytics.instance.recordFlutterFatalError(errorDetails);
    } else {
      FirebaseCrashlytics.instance.recordFlutterError(errorDetails);
    }
  };

  runApp(MyApp());
}

Erreurs asynchrones

Les erreurs asynchrones ne sont pas interceptées par le framework Flutter :

ElevatedButton(
  onPressed: () async {
    throw Error();
  }
  ...
)

Pour intercepter de telles erreurs, vous pouvez utiliser le gestionnaire PlatformDispatcher.instance.onError :

Future<void> main() async {
    WidgetsFlutterBinding.ensureInitialized();
    await Firebase.initializeApp();
    FlutterError.onError = (errorDetails) {
      FirebaseCrashlytics.instance.recordFlutterFatalError(errorDetails);
    };
    // Pass all uncaught asynchronous errors that aren't handled by the Flutter framework to Crashlytics
    PlatformDispatcher.instance.onError = (error, stack) {
      FirebaseCrashlytics.instance.recordError(error, stack, fatal: true);
      return true;
    };
    runApp(MyApp());

}

Erreurs en dehors de Flutter

Pour intercepter les erreurs qui se produisent en dehors du contexte Flutter, installez un écouteur d'erreur sur le courant Isolate :

Isolate.current.addErrorListener(RawReceivePort((pair) async {
  final List<dynamic> errorAndStacktrace = pair;
  await FirebaseCrashlytics.instance.recordError(
    errorAndStacktrace.first,
    errorAndStacktrace.last,
    fatal: true,
  );
}).sendPort);

Signaler les exceptions interceptées

En plus de signaler automatiquement les plantages de votre application, Crashlytics vous permet d'enregistrer des exceptions non fatales et de vous les envoyer la prochaine fois qu'un événement fatal est signalé ou lorsque l'application redémarre.

Utilisez la méthode recordError pour enregistrer les exceptions non fatales dans les blocs catch de votre application. Par exemple:

await FirebaseCrashlytics.instance.recordError(
  error,
  stackTrace,
  reason: 'a non-fatal error'
);

// Or you can use:
await FirebaseCrashlytics.instance.recordFlutterError(errorDetails);

Vous pouvez également souhaiter enregistrer des informations supplémentaires sur l'erreur, ce qui est possible en utilisant la propriété information :

await FirebaseCrashlytics.instance.recordError(
  error,
  stackTrace,
  reason: 'a non-fatal error',
  information: ['further diagnostic information about the error', 'version 2.0'],
);

Ces exceptions apparaissent comme des problèmes non fatals dans la console Firebase. Le résumé du problème contient toutes les informations sur l'état que vous obtenez normalement des plantages, ainsi que les pannes par version et périphérique matériel.

Crashlytics traite les exceptions sur un thread d'arrière-plan dédié pour minimiser l'impact sur les performances de votre application. Pour réduire le trafic réseau de vos utilisateurs, Crashlytics limitera le nombre de rapports envoyés depuis l'appareil, si nécessaire.

Ajouter des clés personnalisées

Les clés personnalisées vous aident à obtenir l'état spécifique de votre application menant à un plantage. Vous pouvez associer des paires clé/valeur arbitraires à vos rapports de plantage, puis utiliser les clés personnalisées pour rechercher et filtrer les rapports de plantage 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. Voici quelques exemples:

// Set a key to a string.
FirebaseCrashlytics.instance.setCustomKey('str_key', 'hello');

// Set a key to a boolean.
FirebaseCrashlytics.instance.setCustomKey("bool_key", true);

// Set a key to an int.
FirebaseCrashlytics.instance.setCustomKey("int_key", 1);

// Set a key to a long.
FirebaseCrashlytics.instance.setCustomKey("int_key", 1L);

// Set a key to a float.
FirebaseCrashlytics.instance.setCustomKey("float_key", 1.0f);

// Set a key to a double.
FirebaseCrashlytics.instance.setCustomKey("double_key", 1.0);

Ajouter des messages de journal personnalisés

Pour vous donner plus de contexte pour les événements menant à un plantage, vous pouvez ajouter des journaux Crashlytics personnalisés à votre application. Crashlytics associe les journaux à vos données de plantage et les affiche dans la console Firebase , sous l'onglet Crashlytics Logs .

Utilisez log pour aider à identifier les problèmes. Par exemple:

FirebaseCrashlytics.instance.log("Higgs-Boson detected! Bailing out");

Définir les identifiants des utilisateurs

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

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

FirebaseCrashlytics.instance.setUserIdentifier("12345");

Si vous avez besoin d'effacer un identifiant d'utilisateur après l'avoir défini, réinitialisez la valeur sur une chaîne vide. La suppression d'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 .

Activer les rapports d'activation

Par défaut, Crashlytics collecte automatiquement les rapports de plantage 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 opt-in en désactivant les rapports automatiques et en n'envoyant des données à Crashlytics que lorsque vous le souhaitez dans votre code :

  1. Désactivez la collecte automatique nativement :

    Plateformes Apple

    Ajoutez une nouvelle clé à votre fichier Info.plist :

    • Clé : FirebaseCrashlyticsCollectionEnabled
    • Valeur : false

    Android

    Dans le bloc application de votre fichier AndroidManifest.xml , ajoutez une balise 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 lors de l'exécution.

    La valeur de remplacement persiste lors des lancements de votre application afin que Crashlytics puisse automatiquement collecter des rapports. Pour désactiver le rapport d'incident automatique, transmettez false comme valeur de remplacement. Lorsqu'elle est définie sur false , la nouvelle valeur ne s'applique qu'à la prochaine exécution de l'application.

    FirebaseCrashlytics.instance.setCrashlyticsCollectionEnabled(true);

Gérer les données Crash Insights

Crash Insights vous aide à résoudre les problèmes en comparant vos traces de pile anonymisées aux traces d'autres applications Firebase et en vous indiquant si votre problème fait partie d'une tendance plus large. Pour de nombreux problèmes, Crash Insights fournit même des ressources pour vous aider à déboguer le plantage.

Crash Insights utilise des données de crash 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 Crash Insights dans le menu Crash Insights en haut de votre liste de problèmes Crashlytics dans la console Firebase .