Firebase Crashlytics pour les apps Capacitor

Firebase Crashlytics vous aide à suivre les crashs de votre application en temps réel et fournit des rapports détaillés pour corriger les problèmes rapidement. Il s’intègre parfaitement avec Capacitor pour les applications iOS et Android. Voici ce qu’il faut savoir :

Pourquoi utiliser Crashlytics ?
- Obtenez alertes de crash en temps réel.
- Analyser les rapports de crash détaillés avec regroupement automatique des problèmes.
- Monitor critical errors to keep apps stable.
Configuration requise :
- Installer Node.js (v16+), Capacitor (v4+), et des outils comme Xcode 14+ et Android Studio Anguille électrique.
- Télécharger Firebase fichiers de configuration (GoogleService-Info.plist pour iOS, google-services.json pour Android).
- Update platform-specific files like Podfile (iOS) et build.gradle (Android).

Étapes clés :

Installez Crashlytics :

npm install @capgo/capacitor-firebase-crashlytics && npx cap sync

Initialisez Crashlytics dans votre application :

import { FirebaseCrashlytics } from '@capgo/capacitor-firebase-crashlytics';
await FirebaseCrashlytics.initialize();

Testez votre configuration :
- Déclenchez un crash de test :
```
await FirebaseCrashlytics.crash();
```
Astuce bonus : Associez Crashlytics à Capgo pour des live updates instantanées, sans attendre les stores.

Ce guide vous aide à garder une app sans crash et agréable à utiliser. Configurez Firebase Crashlytics dès aujourd'hui !

Guide Android 2021 : Firebase Crashlytics - crash personnalisé …

Firebase Crashlytics

Prérequis de configuration

Avant de commencer, assurez-vous d’avoir effectué les étapes suivantes :

Logiciels et comptes requis

Vous devrez installer les éléments suivants :

Node.js (v16 ou supérieure) et Capacitor (v4 ou supérieure)
Un Compte Firebase avec un projet actif
Xcode 14+ pour le développement iOS
Android Studio Electric Eel ou une version plus récente pour le développement Android
La dernière version de CocoaPods (requis pour iOS)

Fichiers de configuration de la plateforme

Pour iOS :

Téléchargez le GoogleService-Info.plist fichier depuis la console Firebase.
Mettez à jour votre Podfile pour inclure les dépendances Crashlytics.
Ajoutez les clés de confidentialité nécessaires à votre Info.plist fichier.

Pour Android :

Récupérez le google-services.json fichier depuis la console Firebase.
Modifiez les fichiers au niveau du projet et de l'application build.gradle fichiers.
Mettez à jour le AndroidManifest.xml pour inclure les permissions requises.

Firebase Configuration de la console

Dashboard de la plateforme Firebase

Pour configurer Firebase et activer Crashlytics, suivez ces étapes :

Créez un projet Firebase et activez Crashlytics.
Enregistrez vos apps dans la console Firebase :
- Utilisez le ID du bundle pour iOS et le nom du package pour Android.
- Téléchargez les fichiers de configuration : GoogleService-Info.plist (iOS) et google-services.json (Android).

Intégrer les SDK Firebase dans votre application en ajoutant ces dépendances :

Pour Android (au niveau de l'app build.gradle):

dependencies {
    implementation platform('com.google.firebase:firebase-bom:32.0.0')
    implementation 'com.google.firebase:firebase-crashlytics'
    implementation 'com.google.firebase:firebase-analytics'
}

Pour iOS (Podfile):

pod 'Firebase/Crashlytics'
pod 'Firebase/Analytics'

Une fois ces étapes terminées, vous pouvez passer à la section Installation du plugin.

Étapes d'installation

Installation du plugin

Ensuite, synchronisez le plugin avec vos plateformes natives et consultez la @capgo/capacitor-firebase-crashlytics page du plugin pour la référence complète de API :

npm install @capgo/capacitor-firebase-crashlytics && npx cap sync

Ensuite, initialisez Crashlytics dans votre application. Ajoutez le code suivant à app.component.ts ou main.ts:

import { FirebaseCrashlytics } from '@capgo/capacitor-firebase-crashlytics';
await FirebaseCrashlytics.initialize();

Configuration des plateformes

Configurez les paramètres requis pour les plateformes Android et iOS.

Configuration Android

Ajoutez le plugin Gradle Crashlytics à votre niveau d'application build.gradle fichier :

buildscript { 
    dependencies { 
        classpath 'com.google.firebase:firebase-crashlytics-gradle:2.9.5' 
    } 
}
apply plugin: 'com.google.firebase.crashlytics'

Activez la collecte des crashs dans AndroidManifest.xml:

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

Configuration iOS

Configurer Firebase dans AppDelegate.swift:
```
import Firebase
FirebaseApp.configure()
```

Tester votre configuration

Vérifiez que Crashlytics fonctionne en déclenchant un crash de test et en consultant la console Firebase :

Déclenchez un crash de test avec une clé personnalisée :

await FirebaseCrashlytics.setCustomKey({key: 'test_scenario', value: 'manual_crash'});
await FirebaseCrashlytics.crash();

En option, identifiez un utilisateur :

await FirebaseCrashlytics.setUserId({userId: 'user123'});

Enregistrez des événements personnalisés :

await FirebaseCrashlytics.log({message: 'Test crash triggered'});

Les rapports, incluant les stack traces, les détails de l'appareil et les clés personnalisées, doivent apparaître dans la console Firebase sous environ 5 minutes.

Important : Supprimez les appels de crash avant de publier votre app. Pour désactiver la collecte de crashs pendant le développement, utilisez :

await FirebaseCrashlytics.setCrashlyticsCollectionEnabled({enabled: false});

Guide de monitoring

Une fois votre configuration confirmée par un crash de test, utilisez la console Firebase pour suivre les crashs et erreurs réels de votre app en production.

Lire les rapports de crash

Vous trouverez les rapports de crash dans la console Firebase, dans la section Crashlytics. Voici ce que vous verrez :

Utilisateurs sans crash: Le pourcentage d'utilisateurs n'ayant pas subi de crash.
Stabilité des incidents: La fréquence des crashs.
Analyse d'impact: Le nombre d'utilisateurs affectés.

Cliquez sur n'importe quel incident pour approfondir les détails comme les stack traces, les infos de l'appareil (par ex. : version de l'OS, mémoire), les clés personnalisées, les logs et le parcours de l'utilisateur avant le crash.

Conseil de pro: Activez la fonctionnalité « velocity alerts » pour être notifié quand le taux de crash augmente soudainement. Cela peut vous aider à résoudre les problèmes avant qu'ils ne touchent trop d'utilisateurs.

Conseils de gestion des erreurs

Prioriser par impact: Concentrez-vous sur les crashs qui affectent le plus d'utilisateurs ou qui surviennent dans des parties critiques de votre app. Suivre les tendances peut vous aider à identifier les problèmes urgents.
Utiliser des clés personnalisées: Ajoutez du contexte à vos rapports de crash avec des clés personnalisées. Par exemple :
```
await FirebaseCrashlytics.setCustomKey({
  key: 'current_view',
  value: 'payment_processing'
});
```
Grouper les problèmes similaires: Profitez du regroupement automatique des problèmes par Firebase. Vous pouvez également étiqueter les crashs liés avec des clés personnalisées cohérentes et utiliser des titres clairs et descriptifs pour un suivi plus facile.

Protéger la confidentialité des utilisateurs

Pour garantir la conformité et protéger les données des utilisateurs, suivez ces recommandations :

Autorisations:
- Mention crash reporting in your privacy policy.
- Obtenez le consentement des utilisateurs pour la collecte de données dans les régions soumises au RGPD.
- Offrez aux utilisateurs la possibilité de refuser la collecte des rapports de crash.

Contrôles de la collecte de données:

await FirebaseCrashlytics.setCrashlyticsCollectionEnabled({enabled: false});
await FirebaseCrashlytics.setCrashlyticsCollectionEnabled({enabled: true});

Rétention des données:
- Configurez la purge automatique des données après 90 jours.
- Supprimez les informations sensibles de vos rapports.
- Use non-identifiable custom keys to maintain user privacy while debugging.

Capgo Intégration

Interface du dashboard Capgo Live Update

Optimisez le processus, de la détection du crash au déploiement du correctif, en couplant le système live update de Capgo avec Crashlytics.

À propos de Capgo

Capgo est un outil live update conçu spécialement pour apps Capacitor. Avec plus de 1 900 apps en production et un taux de mise à jour de 95 % en 24 heures, il garantit des correctifs rapides sans les délais de validation des stores [1].

Les fonctionnalités clés incluent :

Chiffrement de bout en bout pour des mises à jour sécurisées
Rollback en un clic aux versions précédentes
Distribution par canal pour des releases ciblées
Intégration CI/CD transparente
Un Plateforme 100 % open source

Crashlytics et Capgo ensemble

L’utilisation de Crashlytics avec Capgo crée un workflow efficace pour identifier et résoudre rapidement les problèmes.

Voici comment ça marche :

Détection et réponse aux crashs
Crashlytics identifie un crash et Capgo vous permet de déployer des correctifs instantanément, sans attendre la validation des stores.
Mises à jour ciblées
- Tests bêta: Testez les correctifs avec un groupe spécifique pour vérifier leur efficacité.
- Déploiement progressif: Gradually deploy updates to reduce risks.
- Correctif d'urgence: Déployez rapidement des patchs critiques pour résoudre les problèmes urgents.
Suivi et vérification
Après avoir déployé des mises à jour avec Capgo, utilisez Crashlytics pour suivre le taux de crash et confirmer que le problème est résolu.

Sécurité et règles des stores

Capgo respecte les politiques d'Apple et de Google tout en offrant des fonctionnalités de sécurité robustes :

Taux de réussite global de 82 % pour la livraison des mises à jour [1]
Contrôle de version automatique pour une meilleure organisation
Conformité aux directives live update des stores

Pour une intégration sécurisée avec Crashlytics :

Activez le suivi des erreurs dans les deux systèmes.
Utilisez les outils de monitoring de Capgo en complément des rapports Crashlytics.
Gérez le contrôle de version de toutes les mises à jour.
Conservez des logs détaillés des mises à jour pour l'audit.

Passez à la section Options du plugin pour explorer d'autres outils live update.

Options du plugin

Choisir le bon plugin de rapport de crash peut grandement influencer votre capacité à identifier et corriger les erreurs de votre app.

Voici une comparaison rapide de Crashlytics avec d'autres outils populaires de reporting d'erreurs pour Capacitor :

Sentry: Propose un forfait gratuit et des plans payants à partir de 26 $/mois. Prend en charge plus de 30 plateformes et offre une surveillance des erreurs en temps réel avec un contexte détaillé.
Bugsnag: À partir de 47 $/mois. Couvre les plateformes mobile et web, avec regroupement automatique des erreurs et suivi des releases.
Rollbar: À partir de 31 $/mois. Fonctionne sur plusieurs plateformes, avec des fonctionnalités comme le suivi des déploiements et le suivi des utilisateurs.

Crashlytics est particulièrement attractif pour les équipes qui utilisent déjà Firebase, grâce à son intégration fluide et son offre gratuite.

Résumé

Voici un aperçu rapide de ce que vous avez accompli et de la suite :

Récapitulatif des étapes de configuration

Vous avez effectué trois étapes clés pour démarrer :

Création d’un projet Firebase et enregistrement de vos applications iOS/Android.
Installation et configuration du plugin Crashlytics.
Mise à jour des fichiers de plateforme iOS et Android nécessaires.

Pourquoi intégrer ces outils ?

Associer Firebase Crashlytics à Capgo vous offre un système puissant pour le suivi des erreurs et gestion des mises à jour. Voici ce que cette combinaison vous apporte :

Corrections rapides: Publiez des mises à jour instantanées et effectuez un rollback en un seul clic.
Déploiements fiables: Assurez-vous que les mises à jour sont largement adoptées et livrées en douceur aux utilisateurs.

Et après ?

Activez l’analyse détaillée des crashs dans la Firebase Console.
Ajoutez Capgo à votre pipeline CI/CD pour des mises à jour simplifiées.
Utiliser canaux Capgo pour tester et déployer des correctifs étape par étape.

Avec Crashlytics et Capgo, vous êtes prêt à assurer la stabilité de votre application et à l'améliorer au fil du temps.

Poursuivre avec Firebase Crashlytics pour les apps Capacitor

Si vous utilisez Firebase Crashlytics pour les apps Capacitor pour planifier le travail sur les plugins natifs, connectez-l’à Capgo Répertoire des plugins pour le workflow produit dans Capgo Plugin Directory, Plugins Capacitor par Capgo pour les détails d'implémentation dans Plugins Capacitor par Capgo, Ajouter ou mettre à jour des plugins pour les détails d'implémentation dans Adding or Updating Plugins, Alternatives aux plugins Ionic Enterprise pour le workflow produit dans les alternatives aux plugins Ionic Enterprise, et Capgo Native Build pour le workflow produit dans Capgo Native Builds.