Firebase Performance — mi ez, monitorozó eszköz és metrikák

Mi az a Firebase Performance Monitoring?

Firebase Performance Monitoring egy Google-felhőszolgáltatás, amely a mobilalkalmazások teljesítménymetrikáit gyűjti és jeleníti meg. A szolgáltatás a Firebase eszközkészlet része, és nem igényel külön fizetést — a monitorozás az ingyenes Spark tarifa (napi 500 000 esemény korlát) és a fizetős Blaze tarifa keretében érhető el. A Firebase Performance automatikusan nyomvonalakat generál a standard forgatókönyvekhez: képernyő cold start, warm start, háttérbeli HTTP-kérések.

A szolgáltatás architektúrája két adattípusra épül: traces (nyomvonalak) és metrics (metrikák). A nyomvonal egy időintervallum kezdettel és véggel, amelyen belül a végrehajtás időtartamát mérik. A metrika egy numerikus érték: válaszméret, hibagyakoriság, sebesség bájt/másodpercben. Minden nyomvonal több metrikát is tartalmazhat. Az SDK az eszközön gyűjti az adatokat, puffereli őket, és alacsony késleltetési prioritással a háttérben küldi el a Firebase-nek, hogy ne befolyásolja a felhasználói élményt.

A Google I/O 2024 jelentése szerint a Firebase Performance-t világszerte több mint 2 millió alkalmazás használja. A Firebase Performance segítségével történő teljesítményprobléma-észlelés átlagos ideje 15 perc a kiadás után, ha a riasztások be vannak állítva. Monitorozás nélkül egy hasonló problémát átlagosan 2-3 nap után észlelnek a felhasználók támogatáshoz benyújtott panaszai alapján.

Különbség a Firebase Crashlytics-től

Crashlytics az összeomlásokat és végzetes hibákat követi nyomon — azokat a helyzeteket, amikor az alkalmazás váratlanul leáll. A Firebase Performance a futó alkalmazás teljesítményét monitorozza: lassú képernyők, hosszú hálózati kérések, UI-válasz késések. A Crashlytics arra a kérdésre válaszol, hogy „miért omlott össze az alkalmazás?„, a Performance pedig arra, hogy „miért működik lassan az alkalmazás?„. Mindkét szolgáltatás egyetlen SDK-n (Firebase Core) keresztül integrálódik, és az adatok a Firebase konzol kapcsolódó szekcióiban jelennek meg.

Percentilis metrikák

A Firebase Performance nem átlagértékeket mutat — csak percentiliseket: P50, P75, P90, P95, P99. Ez kritikus a teljesítmény szempontjából: az átlagos idő elrejti a kiugró értékeket. Ha 99 felhasználó 200 ms alatt nyitja meg a képernyőt, egy pedig 20 másodperc alatt, az átlag ~400 ms lesz, ami elfogadhatónak tűnik. A P99 20 másodpercet fog mutatni — a valódi problémát. A Firebase a percentiliseket időskálán jeleníti meg, lehetővé téve a regressziók akár egyórás pontosságú nyomon követését.

Hogyan működik a Firebase Performance Monitoring

Firebase Performance SDK szabványos integrációval kerül az alkalmazásba: függőség hozzáadása a Gradle-ben (Android) vagy CocoaPods-on keresztül (iOS). A Firebase kódban történő inicializálása után az SDK automatikusan megkezdi a metrikák gyűjtését további konfiguráció nélkül. Fontos működési elv a lazy collection: az SDK nem küldi el azonnal az adatokat, hanem felhalmozza őket, és kedvező hálózati körülmények között kötegenként továbbítja.

iOS esetén az SDK a HTTP-kérések elfogásához NSURLProtocol-t használ, Android esetén OkHttp Interceptor-t. Ha az alkalmazás nem használ OkHttp-t, az SDK automatikusan becsomagolja a HttpURLConnection-t. Az elfogott kérések metaadatokkal gyarapodnak: Content-Type, válasz állapota, méret bájtokban, időtartam. Minden adat HTTPS-en keresztül, TLS 1.3 titkosítással kerül a Firebase szerverre.

A Firebase Performance egyik kulcsfontosságú követelménye, hogy az utolsó plugin legyen a Gradle-pluginek listájában. Ha a sorrend megsérül, az SDK előfordulhat, hogy nem fog el minden kérést, vagy helytelenül méri az indítási időt. A Firebase azt javasolja, hogy a plugin a plugins blokk végére kerüljön, a Crashlytics és más Google Services pluginok után.

// build.gradle (Module: app) — a pluginok helyes sorrendje
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"  // utolsóként!
}

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

Automatikus nyomvonalak: képernyők, indítás, hálózat

Firebase Performance három típusú automatikus nyomvonalat hoz létre: screen trace (képernyő-megjelenítési idő), app start trace (alkalmazás indítási ideje) és network request trace (HTTP-kérések). A screen trace Android esetén az Activity.onCreate meghívása és az első képkocka megjelenítésének befejezése közötti időt méri. iOS esetén a viewDidLoad és viewDidAppear közötti időt méri. A Firebase automatikusan nyomvonalat hoz létre minden képernyőhöz, az Activity vagy ViewController osztálynevét használva.

App start trace két típusra oszlik: cold start (az alkalmazás a semmiből indul, a folyamat nem létezett) és warm start (az alkalmazás háttérállapotból áll helyre). A cold start a legkritikusabb mutató, mivel magában foglalja az összes SDK inicializálását, a DEX-fájlok betöltését és az első Activity létrehozását. A Firebase a cold start-ot a folyamat indításától az első képernyő teljes megjelenítéséig méri. A Google ajánlásai szerint a cold start nem haladhatja meg az 500 ms-ot P50 esetén és a 2 másodpercet P99 esetén.

Network request trace automatikusan rögzíti minden HTTP-kérést metaadatokkal: URL, metódus, válaszkód, válaszméret, átviteli sebesség. A Firebase Performance konzolban a kérések URL-minta szerint szűrhetők — például az összes /api/v2/orders címre irányuló kérés megjeleníthető. Minden mintához megjelennek a válaszidő percentilisei és a 4xx/5xx hibák gyakorisága. Ez lehetővé teszi egy adott API degradációjának gyors észlelését külön riasztások beállítása nélkül.

Képernyő metrikák részletesen

A képernyők esetében a Firebase Performance emellett kiszámítja a „frozen frames” metrikát — azokat a képkockákat, amelyek 700 ms-nál tovább renderelődtek. Az ilyen UI-befagyásokat a felhasználó úgy érzékeli, hogy „az alkalmazás lefagyott„. Ha egy képernyőn több mint 1% frozen frames van, a Firebase problémásnak jelöli a metrikát. Android esetén az SDK emellett gyűjti a slow renders metrikát — a 16 ms-nál hosszabb képkockákat (60 FPS kihagyása). A screen trace és a frozen frames kombinációja teljes képet ad mind a betöltési időről, mind az animációk simaságáról.

Egyedi nyomvonalak üzleti forgatókönyvekhez

Egyedi nyomvonalak lehetővé teszik bármely felhasználói forgatókönyv időtartamának mérését: rendelés leadása, kép feltöltése a felhőbe, adatok szinkronizálása. A fejlesztő explicit módon jelöli meg a nyomvonal kezdetét és végét a kódban, és elnevezi a forgatókönyvet. Az automatikus nyomvonalakkal ellentétben az egyedi nyomvonalak teljes ellenőrzést biztosítanak a mérendő dolgok felett, és lehetővé teszik attribútumok hozzáadását a szűréshez.

Minden egyedi nyomvonal tartalmazhat attribútumokat — kulcs-érték párokat, amelyek metaadatként kerülnek hozzáadásra. Az attribútumok segítenek az adatok szegmentálásában: például a rendelési idő külön követhető a “promo_user” és a “regular_user” számára. A Firebase Performance nyomvonalanként legfeljebb 5 attribútumot és attribútumonként legfeljebb 100 egyedi értéket támogat. Az attribútumok indexeltek és szűrésre elérhetők a Firebase konzolban.

A Google I/O 2024 jelentése szerint a Spotify csapat a Firebase egyedi nyomvonalait használja a számok közötti váltási idő monitorozására. Ez lehetővé tette a medián kapcsolási idő 400 ms-ról 120 ms-ra csökkentését az audiobuffer-gyorsítótár szűk keresztmetszetének azonosításával. A kulcsfontosságú felismerés a “device_model” attribútum szerinti szűrés volt — a probléma csak Android 13-mal rendelkező Samsung eszközökön jelentkezett.

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

        // Rendelési forgatókönyv végrehajtása
        validateCart()
        processPayment()
        confirmOrder()

        trace.stop()
    }
}

Firebase Performance integrálása Android-projektbe

A Firebase Performance Androidba történő integrálása három lépést igényel: a google-services plugin hozzáadása, a Firebase BOM (Bill of Materials) csatlakoztatása és a firebase-perf függőség hozzáadása. A Firebase Performance automatikusan működik minden Activity-n és fragmenten, ha azok AppCompatActivity-t használnak. A Compose-képernyők esetében a Firebase az egyedi nyomvonalak használatát javasolja, mivel az automatikus screen trace nem támogatja közvetlenül a Compose-t.

Fontos részlet: a Firebase Performance Gradle-plugin módosítja az alkalmazás bytecode-ját a fordítási szakaszban. A plugin instrumentáló kódot ad minden Activity-hez és OkHttp-klienshez. Ez a build-időt 5-10%-kal, az APK méretét pedig 200-400 KB-tal növelheti. Debug-build-ekben a Firebase Performance automatikusan kikapcsol — ez véd a metrikák torzulása ellen a helyi fejlesztés során. A debug-beli kényszerített bekapcsoláshoz a firebasePerformanceInstrumentationEnabled flag használható a manifestben.

A Firebase Performance emellett támogatja a MetricKit-et iOS-hez és a Perfetto-t Android-hoz — alacsony szintű rendszerkövetőket. A MetricKit adatokat szolgáltat a képkocka-sebességről, CPU- és memóriafogyasztásról az operációs rendszer szintjén. A Firebase összesíti ezeket az adatokat, és ugyanabban a konzolban jeleníti meg, ahol a HTTP-nyomvonalak és screen trace-ek láthatók, egyetlen felületen egyesítve a rendszer- és alkalmazás-telemetriát.

HTTP-kérések OkHttp-val

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 integrálása iOS-projektbe

iOS esetén a Firebase Performance integrálása CocoaPods vagy Swift Package Manager segítségével történik. A FirebasePerformance és FirebaseCore podok telepítése után az SDK automatikusan megkezdi a metrikák gyűjtését. A HTTP-kérések elfogásához a Firebase Performance iOS a NSURLProtocol-t használja — egy rendszermechanizmust, amely lehetővé teszi az összes URL-betöltés elfogását az alkalmazásban. Az SDK regisztrálja saját NSURLProtocol alosztályát induláskor, és az URLSession-en keresztül érkező összes kérés automatikusan monitorozás alá kerül.

Korlátozás iOS esetén: A Firebase Performance nem támogatja az automatikus screen trace-t SwiftUI-hoz. SwiftUI-alkalmazások esetén manuálisan kell egyedi nyomvonalakat létrehozni a View törzsének start/stop blokkba csomagolásával. A Firebase dolgozik a SwiftUI natív támogatásán, de jelenleg az SDK automatikusan csak UIView-vezérlőket követ nyomon. Hibrid UIKit + SwiftUI alkalmazások esetén ajánlott a képernyőket UIKit-ben létrehozni, és a SwiftUI-t UIHostingController-en keresztül beágyazni.

A Firebase Performance iOS emellett integrációt biztosít a MetricKit-kel — az Apple keretrendszerével, amely diagnosztikai adatokat gyűjt az operációs rendszer szintjén. A MetricKit napi jelentéseket küld CPU, GPU, memória és képkocka-sebesség metrikákkal. A Firebase Performance összesíti ezeket a jelentéseket, és a konzolban az egyedi nyomvonalak mellett jeleníti meg, teljes képet adva a teljesítményről mind az alkalmazás, mind a rendszer szintjén.

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