Firebase Crashlytics für Capacitor Apps

Firebase Crashlytics hilft dir, App-Crashes in Echtzeit zu tracken und liefert detaillierte Reports, um Fehler schnell zu beheben. Es lässt sich nahtlos integrieren mit Capacitor für iOS- und Android-Apps. Hier ist das Wichtigste im Überblick:

Warum Crashlytics nutzen?
- Jetzt Echtzeit-Crash-Alerts.
- Analysiere detaillierte Crash-Reports mit automatischer Fehlergruppierung.
- Überwache kritische Fehler für maximale App-Stabilität.
Voraussetzungen:
- Installieren Node.js (v16+), Capacitor (v4+), sowie Tools wie Xcode 14+ und Android Studio Electric Eel.
- Download Firebase Konfigurationsdateien (GoogleService-Info.plist für iOS, google-services.json für Android).
- Plattformspezifische Dateien aktualisieren wie Podfile (iOS) und build.gradle (Android).

Wichtige Schritte:

Crashlytics installieren:

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

Crashlytics in deiner App initialisieren:

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

Setup testen:
- Einen Test-Crash auslösen:
```
await FirebaseCrashlytics.crash();
```
Bonus-Tipp: Kombiniere Crashlytics mit Capgo für sofortige Live Updates ohne App Store Verzögerungen.

Dieser Guide stellt sicher, dass deine App crashfrei und benutzerfreundlich bleibt. Richte Firebase Crashlytics noch heute ein!

2021 Android-Guide: Firebase Crashlytics - benutzerdefinierte Crashes …

Firebase Crashlytics

Voraussetzungen

Bevor du startest, stelle sicher, dass du folgende Schritte abgeschlossen hast:

Benötigte Software und Accounts

Du musst Folgendes installieren:

Node.js (v16 oder höher) und Capacitor (v4 oder höher)
Ein Firebase-Account mit einem aktiven Projekt
Xcode 14+ für die iOS-Entwicklung
Android Studio Electric Eel oder eine neuere Version für Android
Die aktuellste Version von CocoaPods (erforderlich für iOS)

Plattform-Konfigurationsdateien

Für iOS:

Download the GoogleService-Info.plist Datei aus der Firebase Console herunter.
Aktualisiere deine Podfile um die Crashlytics-Abhängigkeiten einzubinden.
Füge die erforderlichen Privacy-Keys zu deiner Info.plist Datei.

Für Android:

Lade die google-services.json Datei aus der Firebase Console herunter.
Nimm Änderungen sowohl auf Projekt- als auch auf App-Ebene in den build.gradle Dateien vor.
Aktualisiere die AndroidManifest.xml um die benötigten Berechtigungen hinzuzufügen.

Firebase Console-Einrichtung

Firebase Platform Dashboard

Richte Firebase und Crashlytics mit diesen Schritten ein:

Erstelle ein Firebase-Projekt und aktiviere Crashlytics.
Registriere deine Apps in der Firebase Console:
- Nutze den Bundle ID für iOS und den Package Name für Android.
- Lade die Konfigurationsdateien herunter: GoogleService-Info.plist (iOS) und google-services.json (Android).

Firebase SDKs integrieren indem du diese Abhängigkeiten hinzufügst:

Für Android (App-Ebene) 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'
}

Für iOS (Podfile):

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

Sobald diese Schritte abgeschlossen sind, können Sie mit dem Abschnitt zur Plugin-Installation fortfahren.

Installationsschritte

Plugin-Installation

Synchronisiere dann das Plugin mit deinen nativen Plattformen und schau auf der @capgo/capacitor-firebase-crashlytics Plugin-Seite für die vollständige API Referenz:

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

Initialisiere anschließend Crashlytics in deiner App. Füge den folgenden code hinzu: app.component.ts oder main.ts:

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

Plattform-Konfiguration

Richte die erforderlichen Konfigurationen für Android und iOS ein.

Android-Setup

Füge das Crashlytics Gradle-Plugin auf App-Ebene hinzu build.gradle Datei ein:

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

Crash-Erfassung aktivieren in AndroidManifest.xml:

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

iOS-Setup

Firebase konfigurieren in AppDelegate.swift:
```
import Firebase
FirebaseApp.configure()
```

Dein Setup testen

Bestätige, dass Crashlytics funktioniert, indem du einen Test-Crash auslöst und die Firebase Console prüfst:

Löse einen Test-Crash mit einem Custom Key aus:

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

Optional kannst du einen User identifizieren:

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

Custom Events loggen:

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

Berichte inklusive Stack Traces, Gerätedetails und Custom Keys sollten innerhalb von ca. 5 Minuten in der Firebase Console erscheinen.

Wichtig: Entferne die Crash-Aufrufe vor dem Release deiner App. Um die Crash-Erfassung während der Entwicklung zu deaktivieren, nutze:

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

Monitoring-Guide

Sobald du dein Setup mit einem Test-Crash bestätigt hast, kannst du die Firebase Console nutzen, um echte Crashes und Fehler in deiner Live-App zu tracken.

Crash-Reports lesen

Crash-Reports findest du in der Firebase Console im Bereich Crashlytics. Folgendes siehst du dort:

Crash-freie User: Der Prozentsatz der User, die keine Crashes hatten.
Stabilität der Issues: Wie häufig Abstürze auftreten.
Impact-Analyse: Die Anzahl der betroffenen Nutzer.

Klicke auf ein Issue, um Details wie Stack Traces, Geräteinfos (z. B. OS-Version, RAM), Custom Keys, Logs und den User Journey vor dem Crash zu analysieren.

Pro-Tipp: Aktiviere „Velocity Alerts“, um bei plötzlichen Anstiegen der Crash-Rate benachrichtigt zu werden. So kannst du Probleme lösen, bevor zu viele Nutzer betroffen sind.

Tipps zum Error Management

Priorisierung nach Impact: Konzentriere dich auf Crashes, die die meisten Nutzer betreffen oder in kritischen App-Bereichen auftreten. Trends zu verfolgen hilft, dringende Issues zu erkennen.

Custom Keys nutzen: Füge deinen Crash-Reports mit Custom Keys mehr Kontext hinzu. Zum Beispiel:

await FirebaseCrashlytics.setCustomKey({
  key: 'current_view',
  value: 'payment_processing'
});

Ähnliche Issues gruppieren: Nutze die automatische Gruppierung von Firebase. Du kannst zudem verwandte Crashes mit konsistenten Custom Keys taggen und aussagekräftige Titel verwenden, um die Nachverfolgung zu erleichtern.

Datenschutz der Nutzer schützen

Um Compliance zu gewährleisten und Nutzerdaten zu schützen, beachte diese Richtlinien:

Berechtigungen:
- Erwähne das Crash-Reporting in deiner Datenschutzerklärung.
- Hol dir die Einwilligung der Nutzer zur Datenerhebung in Regionen mit DSGVO-Vorgaben.
- Biete Nutzern die Option, das Crash-Reporting zu deaktivieren.

Kontrolle der Datenerhebung:

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

Datenaufbewahrung:
- Richte eine automatische Datenlöschung nach 90 Tagen ein.
- Entferne sensible Informationen aus deinen Reports.
- Nutze nicht identifizierbare Custom Keys, um die Privatsphäre der Nutzer beim Debugging zu wahren.

Capgo Integration

Capgo Live Update Dashboard-Interface

Optimiere den Prozess von der Crash-Erkennung bis zum Fix, indem du das live update System von Capgo mit Crashlytics kombinierst.

Über Capgo

Capgo ist ein live update Tool, das speziell entwickelt wurde für Capacitor Apps. Mit über 1.900 Apps in Produktion und einer Update-Rate von 95 % innerhalb von 24 Stunden ermöglicht es schnelle Fixes ohne Verzögerungen durch App Store Approvals. [1].

Hauptfunktionen sind:

Ende-zu-Ende-Verschlüsselung für sichere Updates
Ein-Klick-Rollback auf vorherige Versionen
Channel-basierte Distribution für gezielte Releases
Nahtlose CI/CD-Integration
Ein 100 % Open-Source-Plattform

Crashlytics und Capgo kombiniert

Die Nutzung von Crashlytics mit Capgo ermöglicht einen effizienten Workflow, um Fehler schnell zu identifizieren und zu beheben.

So funktioniert es:

Crash-Erkennung und Reaktion
Crashlytics erkennt einen Crash, und Capgo erlaubt es dir, Fixes sofort zu deployen, ohne auf die App Store-Freigabe zu warten.
Gezielte Updates
- Beta-Testing: Teste Fixes mit einer spezifischen Gruppe, um deren Wirksamkeit sicherzustellen.
- Stufenweises Rollout: Rolle Updates schrittweise aus, um Risiken zu minimieren.
- Notfall-Fix: Pushe kritische Patches schnell, um dringende Probleme zu lösen.
Monitoring und Verifizierung
Nach dem Deployment von Updates mit Capgo nutzt du Crashlytics, um Crash-Raten zu tracken und die Fehlerbehebung zu bestätigen.

Sicherheit und App Store Regeln

Capgo hält die Richtlinien von Apple und Google ein und bietet gleichzeitig starke Sicherheitsfeatures:

82 % globale Erfolgsrate bei der Auslieferung von Updates [1]
Automatische Versionskontrolle für bessere Organisation
Einhaltung der live update App Store Guidelines

Für eine sichere Crashlytics-Integration:

Aktivieren Sie das Error Tracking in beiden Systemen.
Nutzen Sie die Monitoring-Tools von Capgo zusätzlich zu Crashlytics-Reports.
Behalten Sie die Versionskontrolle für alle Updates bei.
Führen Sie detaillierte Logs aller Updates für Audits.

Gehen Sie zum Abschnitt Plugin Options, um weitere live update Tools zu entdecken.

Plugin-Optionen

Die Wahl des richtigen Crash-Reporting-Plugins beeinflusst maßgeblich, wie Sie Fehler in Ihrer App identifizieren und beheben.

Hier ist ein kurzer Vergleich von Crashlytics mit anderen gängigen Error-Reporting-Tools für Capacitor:

Sentry: Bietet einen kostenlosen Plan sowie kostenpflichtige Optionen ab 26 $/Monat. Unterstützt über 30 Plattformen und bietet Echtzeit-Error-Monitoring mit detailliertem Kontext.
Bugsnag: Ab 47 $/Monat. Deckt sowohl Mobile als auch Web ab, inklusive automatischem Error-Grouping und Release-Tracking.
RollbarAb 31 $/Monat. Funktioniert plattformübergreifend mit Features wie Deployment-Tracking und Person-Tracking.

Crashlytics ist besonders attraktiv für Teams, die bereits Firebase nutzen, dank der nahtlosen Integration und des kostenlosen Plans.

Zusammenfassung

Hier ist eine kurze Übersicht über deine Fortschritte und die nächsten Schritte:

Zusammenfassung der Setup-Schritte

Du hast drei wichtige Schritte abgeschlossen, um loszulegen:

Ein Firebase-Projekt erstellt und deine iOS/Android-Apps registriert.
Das Crashlytics-Plugin installiert und konfiguriert.
Notwendige iOS- und Android-Plattformdateien aktualisiert.

Warum diese Tools kombinieren?

Die Kombination von Firebase Crashlytics mit Capgo bietet ein leistungsstarkes System für das Error Tracking und Update-Management. Das bietet diese Kombi:

Schnelle Fixes: Pushe sofortige Updates und rolle Änderungen mit nur einem Klick zurück.
Zuverlässige Rollouts: Stelle sicher, dass Updates weit verbreitet und reibungslos an die User ausgeliefert werden.

Wie geht es weiter?

Aktiviere detaillierte Crash-Analytics in der Firebase Console.
Füge Capgo deiner CI/CD-Pipeline hinzu, um Updates zu optimieren.
Nutze Capgo Channels um Fixes Schritt für Schritt zu testen und zu releasen.

Mit Crashlytics und Capgo im Einsatz ist alles bereit, damit deine App reibungslos läuft und sich stetig verbessert.

Weiterlesen: Firebase Crashlytics für Capacitor Apps

Wenn Sie ... verwenden Firebase Crashlytics für Capacitor Apps um die Arbeit an Native Plugins zu planen, verbinde es mit Capgo Plugin-Verzeichnis für den Produkt-Workflow im Capgo Plugin-Verzeichnis, Capacitor Plugins von Capgo für die Implementierungsdetails in Capacitor Plugins von Capgo, Plugins hinzufügen oder aktualisieren für die Implementierungsdetails in Adding or Updating Plugins, Ionic Enterprise Plugin-Alternativen für den Produkt-Workflow in Ionic Enterprise Plugin Alternatives und Capgo Native Builds für den Produkt-Workflow in Capgo Native Builds.