Firebase Performance — wat is het, monitoringtool en metrics

Wat is Firebase Performance Monitoring?

Firebase Performance Monitoring is een cloudservice van Google die prestatiemetrics van mobiele applicaties verzamelt en weergeeft. De service maakt deel uit van de Firebase-toolset en vereist geen aparte betaling — monitoring is beschikbaar binnen het gratis Spark-tarief (limiet van 500.000 gebeurtenissen per dag) en het betaalde Blaze-tarief. Firebase Performance genereert automatisch traces voor standaard scenario's: cold start van het scherm, warm start, achtergrond HTTP-verzoeken.

De architectuur van de service is gebaseerd op twee gegevenstypen: traces (traceringen) en metrics (meetwaarden). Een trace is een tijdsinterval met een begin en einde, waarbinnen de uitvoeringsduur wordt gemeten. Een metric is een numerieke waarde: antwoordgrootte, foutfrequentie, snelheid in bytes/sec. Elke trace kan meerdere metrics bevatten. De SDK verzamelt gegevens op het apparaat, buffert ze en verzendt ze op de achtergrond naar Firebase met een lage latentieprioriteit om de gebruikerservaring niet te beïnvloeden.

Volgens het rapport van Google I/O 2024 wordt Firebase Performance gebruikt in meer dan 2 miljoen applicaties wereldwijd. De gemiddelde tijd om een prestatieprobleem te detecteren met Firebase Performance is 15 minuten na release, als er alerts zijn geconfigureerd. Zonder monitoring wordt een vergelijkbaar probleem gemiddeld na 2-3 dagen ontdekt op basis van gebruikersklachten aan de ondersteuning.

Verschil met Firebase Crashlytics

Crashlytics volgt crashes en fatale fouten — situaties waarin de applicatie onverwacht stopt. Firebase Performance bewaakt de prestaties van de draaiende applicatie: trage schermen, lange netwerkverzoeken, UI-responsvertragingen. Crashlytics beantwoordt de vraag ”waarom is de applicatie gecrasht?“, en Performance beantwoordt de vraag ”waarom werkt de applicatie traag?“. Beide services integreren via één SDK (Firebase Core) en gegevens worden weergegeven in gerelateerde secties van de Firebase-console.

Percentielmetrics

Firebase Performance toont geen gemiddelde waarden — alleen percentielen: P50, P75, P90, P95, P99. Dit is essentieel voor prestaties: de gemiddelde tijd verbergt uitschieters. Als 99 gebruikers een scherm in 200 ms openen en één in 20 seconden, is het gemiddelde ~400 ms, wat acceptabel lijkt. P99 toont 20 seconden — het echte probleem. Firebase geeft percentielen weer op een tijdsas, waardoor regressies met een nauwkeurigheid van een uur kunnen worden gevolgd.

Hoe werkt Firebase Performance Monitoring

Firebase Performance SDK wordt in de applicatie geïntegreerd via standaardintegratie: toevoegen van een afhankelijkheid in Gradle (Android) of via CocoaPods (iOS). Na initialisatie van Firebase in de code begint de SDK automatisch met het verzamelen van metrics zonder extra configuratie. Een belangrijk werkingsprincipe is lazy collection: de SDK verzendt gegevens niet onmiddellijk, maar accumuleert ze en stuurt ze in batches wanneer de netwerkomstandigheden gunstig zijn.

Voor iOS gebruikt de SDK NSURLProtocol voor het onderscheppen van HTTP-verzoeken, voor Android — OkHttp Interceptor. Als de applicatie geen OkHttp gebruikt, wikkelt de SDK automatisch HttpURLConnection in. Onderschepte verzoeken worden verrijkt met metadata: Content-Type, antwoordstatus, grootte in bytes, duur. Alle gegevens worden via HTTPS naar de Firebase-server verzonden met TLS 1.3-codering.

Een van de belangrijkste vereisten van Firebase Performance is de laatste plugin zijn in de lijst met Gradle-plugins. Als de volgorde wordt geschonden, kan de SDK mogelijk niet alle verzoeken onderscheppen of de opstarttijd onjuist meten. Firebase adviseert de plugin aan het einde van het plugins-blok te plaatsen, na Crashlytics en andere Google Services-plugins.

// build.gradle (Module: app) — juiste volgorde van plugins
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"  // laatste!
}

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

Automatische traces: schermen, opstarten, netwerk

Firebase Performance maakt drie soorten automatische traces: screen trace (schermweergavetijd), app start trace (applicatieopstarttijd) en network request trace (HTTP-verzoeken). Screen trace voor Android meet de tijd tussen de aanroep van Activity.onCreate en het voltooien van de weergave van het eerste frame. Voor iOS wordt de tijd gemeten tussen viewDidLoad en viewDidAppear. Firebase maakt automatisch een trace voor elk scherm, met behulp van de klassenaam van Activity of ViewController.

App start trace is onderverdeeld in twee typen: cold start (applicatie start vanaf nul, proces bestond niet) en warm start (applicatie herstelt vanuit achtergrondstatus). Cold start is de meest kritische indicator omdat het de initialisatie van alle SDK's, het laden van DEX-bestanden en het maken van de eerste Activity omvat. Firebase meet cold start vanaf het moment dat het proces start tot de volledige weergave van het eerste scherm. Volgens Google-aanbevelingen mag cold start niet langer duren dan 500 ms voor P50 en 2 seconden voor P99.

Network request trace registreert automatisch elk HTTP-verzoek met metadata: URL, methode, antwoordcode, antwoordgrootte, overdrachtssnelheid. In de Firebase Performance-console kunnen verzoeken worden gefilterd op URL-patroon — bijvoorbeeld alle verzoeken naar /api/v2/orders weergeven. Voor elk patroon worden de percentielen van de responstijd en de frequentie van 4xx/5xx-fouten weergegeven. Dit maakt het mogelijk om snel degradatie van een specifieke API te detecteren zonder afzonderlijke alerts in te stellen.

Schermmetrics in detail

Voor schermen berekent Firebase Performance ook de metric ”frozen frames“ — frames die langer dan 700 ms renderen. Dergelijke UI-bevriezingen worden door de gebruiker ervaren als ”de applicatie is vastgelopen“. Als een scherm meer dan 1% frozen frames heeft, markeert Firebase de metric als problematisch. Voor Android verzamelt de SDK ook de metric slow renders — frames langer dan 16 ms (overslaan van 60 FPS). De combinatie van screen trace en frozen frames geeft een volledig beeld van zowel de laadtijd als de vloeiendheid van animaties.

Aangepaste traces voor bedrijfsscenario's

Aangepaste traces maken het mogelijk om de duur van elk gebruikersscenario te meten: bestellen, afbeelding uploaden naar de cloud, gegevens synchroniseren. De ontwikkelaar geeft expliciet het begin en einde van de trace in code aan en geeft het scenario een naam. In tegenstelling tot automatische traces bieden aangepaste traces volledige controle over wat wordt gemeten en kunnen er attributen worden toegevoegd voor filtering.

Elke aangepaste trace kan attributen bevatten — sleutel-waardeparen die als metadata worden toegevoegd. Attributen helpen bij het segmenteren van gegevens: bijvoorbeeld kan de besteltijd afzonderlijk worden gevolgd voor ”promo_user“ en ”regular_user“. Firebase Performance ondersteunt tot 5 attributen per trace en tot 100 unieke attribuutwaarden. Attributen worden geïndexeerd en zijn beschikbaar voor filtering in de Firebase-console.

Volgens het rapport van Google I/O 2024 gebruikt het Spotify-team aangepaste Firebase-traces voor het monitoren van de tijd tussen nummers. Dit maakte het mogelijk om de mediane schakeltijd te verkorten van 400 ms naar 120 ms door het identificeren van een knelpunt in de audiobuffer-cache. De belangrijkste ontdekking was filtering op attribuut ”device_model“ — het probleem deed zich alleen voor op Samsung-apparaten met Android 13.

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

        // Uitvoeren van het bestelscenario
        validateCart()
        processPayment()
        confirmOrder()

        trace.stop()
    }
}

Firebase Performance integreren in een Android-project

Integratie van Firebase Performance in Android vereist drie stappen: toevoegen van de google-services-plugin, aansluiten van Firebase BOM (Bill of Materials) en toevoegen van de firebase-perf-afhankelijkheid. Firebase Performance werkt automatisch op alle Activity's en fragmenten als ze AppCompatActivity gebruiken. Voor Compose-schermen adviseert Firebase het gebruik van aangepaste traces, omdat automatische screen trace Compose niet direct ondersteunt.

Een belangrijk detail: de Firebase Performance Gradle-plugin wijzigt de bytecode van de applicatie tijdens de compilatiefase. De plugin voegt instrumenterende code toe aan elke Activity en OkHttp-client. Dit kan de buildtijd met 5-10% en de APK-grootte met 200-400 KB verhogen. In debug-builds wordt Firebase Performance automatisch uitgeschakeld — dit beschermt tegen vervorming van metrics tijdens lokale ontwikkeling. Voor geforceerde inschakeling in debug wordt de vlag firebasePerformanceInstrumentationEnabled in het manifest gebruikt.

Firebase Performance ondersteunt ook MetricKit voor iOS en Perfetto voor Android — laag-niveau systeemtrackers. MetricKit levert gegevens over framefrequentie, CPU- en geheugengebruik op het niveau van het besturingssysteem. Firebase aggregeert deze gegevens en toont ze in dezelfde console waar HTTP-traces en screen traces worden weergegeven, waarbij systeem- en applicatietelemetrie in één interface worden gecombineerd.

HTTP-verzoeken met 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 */ }
})

Firebase Performance integreren in een iOS-project

Voor iOS vindt integratie van Firebase Performance plaats via CocoaPods of Swift Package Manager. Na installatie van de pods FirebasePerformance en FirebaseCore begint de SDK automatisch met het verzamelen van metrics. Voor het onderscheppen van HTTP-verzoeken gebruikt Firebase Performance iOS NSURLProtocol — een systeemmechanisme waarmee alle URL-ladingen in de applicatie kunnen worden onderschept. De SDK registreert zijn eigen NSURLProtocol-subklasse bij het opstarten en alle verzoeken via URLSession vallen automatisch onder monitoring.

Beperking voor iOS: Firebase Performance ondersteunt geen automatische screen trace voor SwiftUI. Voor SwiftUI-applicaties moeten handmatig aangepaste traces worden gemaakt door de body van View in een start/stop-blok te wikkelen. Firebase werkt aan native ondersteuning voor SwiftUI, maar momenteel traceert de SDK automatisch alleen UIView-controllers. Voor hybride applicaties op UIKit + SwiftUI wordt aanbevolen om schermen in UIKit te maken en SwiftUI in te bedden via UIHostingController.

Firebase Performance iOS biedt ook integratie met MetricKit — het Apple-framework dat diagnostische gegevens verzamelt op OS-niveau. MetricKit stuurt dagelijkse rapporten met CPU-, GPU-, geheugen- en framefrequentiemetrics. Firebase Performance aggregeert deze rapporten en toont ze in de console naast aangepaste traces, wat een volledig beeld geeft van prestaties zowel op applicatie- als op systeemniveau.

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