Firebase Performance — was es ist, Überwachungstool und Metriken

Was ist Firebase Performance Monitoring?

Firebase Performance Monitoring ist ein Cloud-Dienst von Google, der Leistungsmetriken mobiler Anwendungen sammelt und anzeigt. Der Dienst ist Teil des Firebase-Toolsets und erfordert keine separate Zahlung — die Überwachung ist im kostenlosen Spark-Tarif (Limit von 500.000 Ereignissen pro Tag) und im kostenpflichtigen Blaze-Tarif verfügbar. Firebase Performance generiert automatisch Traces für Standardszenarien: Kaltstart des Bildschirms, Warmstart, Hintergrund-HTTP-Anfragen.

Die Architektur des Dienstes basiert auf zwei Datentypen: Traces und Metriken. Ein Trace ist ein Zeitintervall mit Anfang und Ende, innerhalb dessen die Ausführungsdauer gemessen wird. Eine Metrik ist ein numerischer Wert: Antwortgröße, Fehlerrate, Geschwindigkeit in Bytes/Sek. Jeder Trace kann mehrere Metriken enthalten. Das SDK sammelt Daten auf dem Gerät, puffert sie und sendet sie im Hintergrund mit niedriger Latenzpriorität an Firebase, um die Benutzererfahrung nicht zu beeinträchtigen.

Laut dem Bericht Google I/O 2024 wird Firebase Performance in mehr als 2 Millionen Anwendungen weltweit verwendet. Die durchschnittliche Zeit zur Erkennung eines Leistungsproblems mit Firebase Performance beträgt 15 Minuten nach der Veröffentlichung, wenn Warnungen konfiguriert sind. Ohne Überwachung wird ein ähnliches Problem typischerweise innerhalb von 2-3 Tagen durch Benutzerbeschwerden an den Support entdeckt.

Unterschied zu Firebase Crashlytics

Crashlytics verfolgt Abstürze und fatale Fehler — Situationen, in denen die Anwendung unerwartet beendet wird. Firebase Performance überwacht die Leistung einer laufenden Anwendung: langsame Bildschirme, lange Netzwerkanfragen, UI-Antwortverzögerungen. Crashlytics beantwortet die Frage „Warum ist die App abgestürzt?“, während Performance die Frage „Warum läuft die App langsam?“ beantwortet. Beide Dienste integrieren sich über ein SDK (Firebase Core) und die Daten werden in benachbarten Abschnitten der Firebase-Konsole angezeigt.

Perzentil-Metriken

Firebase Performance zeigt keine Durchschnittswerte — nur Perzentile: P50, P75, P90, P95, P99. Dies ist entscheidend für die Leistung: Die Durchschnittszeit verbirgt Ausreißer. Wenn 99 Benutzer einen Bildschirm in 200 ms öffnen und einer in 20 Sekunden, beträgt der Durchschnitt ~400 ms, was akzeptabel erscheint. P99 zeigt 20 Sekunden — das eigentliche Problem. Firebase zeigt Perzentile auf einer Zeitachse an, was die Verfolgung von Regressionen mit stündlicher Genauigkeit ermöglicht.

Wie Firebase Performance Monitoring funktioniert

Firebase Performance SDK wird durch Standardintegration in eine Anwendung eingebunden: Hinzufügen einer Abhängigkeit in Gradle (Android) oder über CocoaPods (iOS). Nach der Firebase-Initialisierung im Code beginnt das SDK automatisch mit der Sammlung von Metriken ohne zusätzliche Konfiguration. Ein wichtiges Prinzip ist die lazy collection: Das SDK sendet Daten nicht sofort, sondern sammelt sie und überträgt sie in Batches unter günstigen Netzwerkbedingungen.

Für iOS verwendet das SDK NSURLProtocol zum Abfangen von HTTP-Anfragen; für Android — OkHttp Interceptor. Wenn die Anwendung OkHttp nicht verwendet, umschließt das SDK automatisch HttpURLConnection. Abgefangene Anfragen werden mit Metadaten angereichert: Content-Type, Antwortstatus, Größe in Bytes, Dauer. Alle Daten werden per HTTPS mit TLS 1.3-Verschlüsselung an den Firebase-Server übertragen.

Eine der Hauptanforderungen von Firebase Performance ist, das letzte Plugin in der Gradle-Plugin-Liste zu sein. Bei Verletzung der Reihenfolge kann das SDK möglicherweise nicht alle Anfragen abfangen oder die Startzeit falsch messen. Firebase empfiehlt, das Plugin am Ende des Plugin-Blocks nach Crashlytics und anderen Google Services-Plugins zu platzieren.

// build.gradle (Module: app) — korrekte Plugin-Reihenfolge
plugins {
    id "com.android.application"
    id "org.jetbrains.kotlin.android"
    id "com.google.gms.google-services"
    id "com.google.firebase.crashlytics"
    id "com.google.firebase.firebase-perf"  // zuletzt!
}

dependencies {
    implementation platform("com.google.firebase:firebase-bom:33.0.0")
    implementation "com.google.firebase:firebase-perf"
}

Automatische Traces: Bildschirme, Start, Netzwerk

Firebase Performance erstellt drei Arten von automatischen Traces: screen trace (Bildschirm-Rendering-Zeit), app start trace (Anwendungsstartzeit) und network request trace (HTTP-Anfragen). Screen trace für Android misst die Zeit zwischen dem Activity.onCreate-Aufruf und dem Abschluss des ersten Frame-Renderings. Für iOS wird die Zeit zwischen viewDidLoad und viewDidAppear gemessen. Firebase erstellt automatisch einen Trace für jeden Bildschirm, wobei der Klassenname der Activity oder des ViewController verwendet wird.

App start trace wird in zwei Typen unterteilt: Kaltstart (die Anwendung startet von Grund auf, der Prozess existierte nicht) und Warmstart (die Anwendung wird aus dem Hintergrundzustand wiederhergestellt). Der Kaltstart ist die kritischste Metrik, da er die Initialisierung aller SDKs, das Laden von DEX-Dateien und die Erstellung der ersten Activity umfasst. Firebase misst den Kaltstart vom Moment des Prozessstarts bis zur vollständigen Darstellung des ersten Bildschirms. Nach Google-Empfehlungen sollte der Kaltstart P50 500 ms und P99 2 Sekunden nicht überschreiten.

Network request trace zeichnet automatisch jede HTTP-Anfrage mit Metadaten auf: URL, Methode, Antwortcode, Antwortgröße, Übertragungsgeschwindigkeit. In der Firebase Performance-Konsole können Sie Anfragen nach URL-Muster filtern — zum Beispiel alle Anfragen an /api/v2/orders anzeigen. Für jedes Muster werden Antwortzeit-Perzentile und 4xx/5xx-Fehlerraten angezeigt. Dies ermöglicht die schnelle Erkennung der Verschlechterung einer bestimmten API ohne Einrichtung einzelner Warnungen.

Bildschirmmetriken im Detail

Für Bildschirme berechnet Firebase Performance zusätzlich die Metrik „frozen frames" — Frames, deren Rendering länger als 700 ms dauerte. Solche UI-Einfrierungen werden vom Benutzer als „Die App hängt" wahrgenommen. Wenn ein Bildschirm mehr als 1% frozen frames aufweist, markiert Firebase die Metrik als problematisch. Für Android sammelt das SDK zusätzlich die Metrik slow renders — Frames länger als 16 ms (Verpassen von 60 FPS). Die Kombination von screen trace und frozen frames ergibt ein vollständiges Bild sowohl der Ladezeit als auch der Animationsglätte.

Benutzerdefinierte Traces für Geschäftsszenarien

Benutzerdefinierte Traces ermöglichen die Messung der Dauer jedes Benutzerszenarios: Bestellung aufgeben, Bild in die Cloud hochladen, Daten synchronisieren. Der Entwickler gibt explizit Anfang und Ende des Traces im Code an und legt den Szenarionamen fest. Im Gegensatz zu automatischen Traces bieten benutzerdefinierte Traces die vollständige Kontrolle darüber, was gemessen wird, und ermöglichen das Hinzufügen von Attributen zur Filterung.

Jeder benutzerdefinierte Trace kann Attribute enthalten — Schlüssel-Wert-Paare, die als Metadaten hinzugefügt werden. Attribute helfen bei der Segmentierung von Daten: Sie können beispielsweise die Checkout-Zeit getrennt für „promo_user" und „regular_user" verfolgen. Firebase Performance unterstützt bis zu 5 Attribute pro Trace und bis zu 100 eindeutige Attributwerte. Attribute werden indiziert und sind in der Firebase-Konsole zur Filterung verfügbar.

Laut der Google I/O 2024-Präsentation verwendet das Spotify-Team benutzerdefinierte Firebase-Traces zur Überwachung der Titelwechselzeit. Dies half, die mediane Wechselzeit von 400 ms auf 120 ms zu reduzieren, indem ein Engpass im Audiopuffer-Caching identifiziert wurde. Die wichtigste Erkenntnis kam durch Filterung nach dem Attribut „device_model" — das Problem trat nur auf Samsung-Geräten mit Android 13 auf.

import com.google.firebase.perf.FirebasePerformance
import com.google.firebase.perf.metrics.Trace

class CheckoutTracker {

    private val firebasePerf = FirebasePerformance.getInstance()

    fun trackCheckoutFlow(userId: String, promoApplied: Boolean) {
        val trace: Trace = firebasePerf.newTrace("checkout_flow")
        trace.putAttribute("promo_user", promoApplied.toString())
        trace.putAttribute("user_tier", "premium")
        trace.start()

        // Checkout-Szenario wird ausgeführt
        validateCart()
        processPayment()
        confirmOrder()

        trace.stop()
    }
}

Integration von Firebase Performance in ein Android-Projekt

Die Integration von Firebase Performance in Android erfordert drei Schritte: Hinzufügen des google-services-Plugins, Anschließen der Firebase BOM (Bill of Materials) und Hinzufügen der firebase-perf-Abhängigkeit. Firebase Performance funktioniert automatisch auf allen Activities und Fragmenten, wenn sie AppCompatActivity verwenden. Für Compose-Bildschirme empfiehlt Firebase die Verwendung benutzerdefinierter Traces, da der automatische screen trace Compose nicht direkt unterstützt.

Eine wichtige Nuance: Das Firebase Performance Gradle-Plugin modifiziert den Bytecode der Anwendung zur Kompilierzeit. Das Plugin fügt Instrumentierungscode zu jeder Activity und jedem OkHttp-Client hinzu. Dies kann die Build-Zeit um 5-10% und die APK-Größe um 200-400 KB erhöhen. In Debug-Builds wird Firebase Performance automatisch deaktiviert — dies verhindert die Verzerrung von Metriken während der lokalen Entwicklung. Zur erzwungenen Aktivierung im Debug-Modus verwenden Sie das Flag firebasePerformanceInstrumentationEnabled im Manifest.

Firebase Performance unterstützt auch MetricKit für iOS und Perfetto für Android — Low-Level-System-Tracer. MetricKit liefert Daten zur Bildrate, CPU- und Speichernutzung auf Betriebssystemebene. Firebase aggregiert diese Daten und zeigt sie in derselben Konsole an, in der HTTP-Traces und screen traces angezeigt werden, und kombiniert System- und Anwendungstelemetrie in einer Oberfläche.

HTTP-Anfragen mit OkHttp

import okhttp3.OkHttpClient
import com.google.firebase.perf.network.FirebasePerfOkHttpClient

val client = OkHttpClient.Builder()
    .addInterceptor FirebasePerfOkHttpClient
    .build()

val request = Request.Builder()
    .url("https://api.example.com/orders")
    .build()

client.newCall(request).enqueue(object : Callback {
    override fun onFailure(call: Call, e: IOException) { /* handle */ }
    override fun onResponse(call: Call, response: Response) { /* handle */ }
})

Integration von Firebase Performance in ein iOS-Projekt

Für iOS erfolgt die Integration von Firebase Performance über CocoaPods oder Swift Package Manager. Nach der Installation der FirebasePerformance- und FirebaseCore-Pods beginnt das SDK automatisch mit der Sammlung von Metriken. Zum Abfangen von HTTP-Anfragen verwendet Firebase Performance iOS NSURLProtocol — einen Systemmechanismus, der das Abfangen aller URL-Ladungen in der Anwendung ermöglicht. Das SDK registriert seine NSURLProtocol-Unterklasse beim Start, und alle Anfragen über URLSession fallen automatisch unter Überwachung.

Einschränkung für iOS: Firebase Performance unterstützt keinen automatischen screen trace für SwiftUI. Für SwiftUI-Anwendungen müssen Sie manuell benutzerdefinierte Traces erstellen, indem Sie den View-Körper in einen Start/Stopp-Block einschließen. Firebase arbeitet an nativer SwiftUI-Unterstützung, aber derzeit verfolgt das SDK automatisch nur UIView-Controller. Für hybride Anwendungen auf UIKit + SwiftUI wird empfohlen, Bildschirme auf UIKit zu erstellen und SwiftUI über UIHostingController einzubetten.

Firebase Performance iOS bietet auch Integration mit MetricKit — einem Apple-Framework, das Diagnosedaten auf Betriebssystemebene sammelt. MetricKit sendet tägliche Berichte mit CPU-, GPU-, Speicher- und Bildratenmetriken. Firebase Performance aggregiert diese Berichte und zeigt sie in der Konsole zusammen mit benutzerdefinierten Traces an, was ein vollständiges Bild der Leistung sowohl auf Anwendungs- als auch auf Systemebene liefert.

import FirebasePerformance

final class ImageUploadService {

    func uploadImage(_ data: Data, to url: URL) async throws {
        guard let trace = Performance.startTrace(name: "image_upload") else { return }
        trace?.setValue("image/jpeg", forAttribute: "content_type")
        trace?.setValue("\(data.count)", forAttribute: "file_size")

        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.httpBody = data

        let (_, response) = try await URLSession.shared.data(for: request)
        guard let httpResponse = response as? HTTPURLResponse else { return }
        trace?.setValue("\(httpResponse.statusCode)",
                        forAttribute: "status_code")
        trace?.stop()
    }
}