Firebase Performance — ce este, instrument de monitorizare și metrici

Ce este Firebase Performance Monitoring?

Firebase Performance Monitoring este un serviciu cloud Google care colectează și afișează metrici de performanță ale aplicațiilor mobile. Serviciul face parte din setul de instrumente Firebase și nu necesită plată separată — monitorizarea este disponibilă în cadrul tarifului gratuit Spark (limită de 500.000 de evenimente pe zi) și al tarifului plătit Blaze. Firebase Performance generează automat trasări pentru scenarii standard: cold start al ecranului, warm start, cereri HTTP în fundal.

Arhitectura serviciului se bazează pe două tipuri de date: traces (trasări) și metrics (metrici). O trasare este un interval de timp cu început și sfârșit, în interiorul căruia se măsoară durata execuției. O metrică este o valoare numerică: dimensiunea răspunsului, frecvența erorilor, viteza în octeți/sec. Fiecare trasare poate conține mai multe metrici. SDK-ul colectează datele pe dispozitiv, le bufferizează și le trimite la Firebase în fundal cu prioritate de latență scăzută pentru a nu afecta experiența utilizatorului.

Conform raportului Google I/O 2024, Firebase Performance este utilizat în peste 2 milioane de aplicații în întreaga lume. Timpul mediu de detectare a unei probleme de performanță cu Firebase Performance este de 15 minute după lansare, dacă sunt configurate alerte. Fără monitorizare, o problemă similară este detectată în medie după 2-3 zile pe baza plângerilor utilizatorilor la suport.

Diferența față de Firebase Crashlytics

Crashlytics urmărește crash-urile și erorile fatale — situații în care aplicația se oprește brusc. Firebase Performance monitorizează performanța aplicației în funcționare: ecrane lente, cereri de rețea lungi, întârzieri de răspuns UI. Crashlytics răspunde la întrebarea „de ce s-a oprit aplicația?„, iar Performance la întrebarea „de ce funcționează încet aplicația?„. Ambele servicii se integrează printr-un singur SDK (Firebase Core), iar datele sunt afișate în secțiuni conexe ale consolei Firebase.

Metrici percentilice

Firebase Performance nu arată valori medii — doar percentile: P50, P75, P90, P95, P99. Acest lucru este critic pentru performanță: timpul mediu ascunde valorile aberante. Dacă 99 de utilizatori deschid ecranul în 200 ms, iar unul în 20 de secunde, media va fi de ~400 ms, ceea ce pare acceptabil. P99 va arăta 20 de secunde — problema reală. Firebase afișează percentilele pe o axă a timpului, ceea ce permite urmărirea regresiilor cu precizie de până la o oră.

Cum funcționează Firebase Performance Monitoring

Firebase Performance SDK se integrează în aplicație prin integrare standard: adăugarea dependenței în Gradle (Android) sau prin CocoaPods (iOS). După inițializarea Firebase în cod, SDK-ul începe automat colectarea metricilor fără configurare suplimentară. Un principiu important de funcționare este lazy collection: SDK-ul nu trimite datele imediat, ci le acumulează și le transmite în loturi când condițiile de rețea sunt favorabile.

Pentru iOS, SDK-ul folosește NSURLProtocol pentru interceptarea cererilor HTTP, iar pentru Android — OkHttp Interceptor. Dacă aplicația nu folosește OkHttp, SDK-ul înglobează automat HttpURLConnection. Cererile interceptate sunt îmbogățite cu metadate: Content-Type, statusul răspunsului, dimensiunea în octeți, durata. Toate datele sunt transmise prin HTTPS către serverul Firebase cu criptare TLS 1.3.

Una dintre cerințele cheie ale Firebase Performance este să fie ultimul plugin în lista pluginurilor Gradle. Dacă ordinea este încălcată, SDK-ul poate să nu intercepteze toate cererile sau să măsoare incorect timpul de pornire. Firebase recomandă plasarea pluginului la sfârșitul blocului plugins, după Crashlytics și alte pluginuri Google Services.

// build.gradle (Module: app) — ordinea corectă a pluginurilor
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"  // ultimul!
}

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

Trasări automate: ecrane, pornire, rețea

Firebase Performance creează trei tipuri de trasări automate: screen trace (timpul de randare a ecranului), app start trace (timpul de pornire a aplicației) și network request trace (cereri HTTP). Screen trace pentru Android măsoară timpul între apelul Activity.onCreate și finalizarea randării primului cadru. Pentru iOS se măsoară timpul între viewDidLoad și viewDidAppear. Firebase creează automat o trasare pentru fiecare ecran, folosind numele clasei Activity sau ViewController.

App start trace se împarte în două tipuri: cold start (aplicația pornește de la zero, procesul nu exista) și warm start (aplicația se restabilește din starea de fundal). Cold start este cel mai critic indicator, deoarece include inițializarea tuturor SDK-urilor, încărcarea fișierelor DEX și crearea primului Activity. Firebase măsoară cold start de la momentul pornirii procesului până la randarea completă a primului ecran. Conform recomandărilor Google, cold start nu ar trebui să depășească 500 ms pentru P50 și 2 secunde pentru P99.

Network request trace înregistrează automat fiecare cerere HTTP cu metadate: URL, metodă, cod de răspuns, dimensiunea răspunsului, viteza de transfer. În consola Firebase Performance se pot filtra cererile după modelul URL — de exemplu, să se afișeze toate cererile către /api/v2/orders. Pentru fiecare model se afișează percentilele timpului de răspuns și frecvența erorilor 4xx/5xx. Acest lucru permite detectarea rapidă a degradării unei API specifice fără configurarea de alertă separate.

Metrici ale ecranelor în detaliu

Pentru ecrane, Firebase Performance calculează suplimentar metrica „frozen frames„ — cadrele care s-au randat mai mult de 700 ms. Astfel de înghețuri ale UI sunt percepute de utilizator ca „aplicația s-a blocat„. Dacă pe un ecran există mai mult de 1% frozen frames, Firebase marchează metrica ca problematică. Pentru Android, SDK-ul colectează suplimentar metrica slow renders — cadre mai lungi de 16 ms (pierderea a 60 FPS). Combinarea screen trace și frozen frames oferă o imagine completă atât a timpului de încărcare, cât și a fluenței animațiilor.

Trasări personalizate pentru scenarii de afaceri

Trasările personalizate permit măsurarea duratei oricărui scenariu de utilizator: plasarea comenzii, încărcarea unei imagini în cloud, sincronizarea datelor. Dezvoltatorul indică explicit începutul și sfârșitul trasării în cod și denumește scenariul. Spre deosebire de trasările automate, trasările personalizate oferă control complet asupra a ceea ce se măsoară și permit adăugarea de atribute pentru filtrare.

Fiecare trasare personalizată poate conține atribute — perechi cheie-valoare care sunt adăugate ca metadate. Atributele ajută la segmentarea datelor: de exemplu, se poate urmări timpul de plasare a comenzii separat pentru „promo_user„ și „regular_user„. Firebase Performance suportă până la 5 atribute per trasare și până la 100 de valori unice de atribut. Atributele sunt indexate și disponibile pentru filtrare în consola Firebase.

Conform raportului Google I/O 2024, echipa Spotify folosește trasările personalizate Firebase pentru monitorizarea timpului de comutare între melodii. Acest lucru a permis reducerea timpului median de comutare de la 400 ms la 120 ms prin identificarea unui blocaj în cache-ul bufferului audio. Insight-ul cheie a fost filtrarea după atributul „device_model„ — problema apărea doar pe dispozitivele Samsung cu 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()

        // Executarea scenariului de plasare a comenzii
        validateCart()
        processPayment()
        confirmOrder()

        trace.stop()
    }
}

Integrarea Firebase Performance în proiectul Android

Integrarea Firebase Performance în Android necesită trei pași: adăugarea pluginului google-services, conectarea BOM (Bill of Materials) Firebase și adăugarea dependenței firebase-perf. Firebase Performance funcționează automat pe toate Activity și fragmentele dacă acestea folosesc AppCompatActivity. Pentru ecranele Compose, Firebase recomandă utilizarea trasărilor personalizate, deoarece screen trace automat nu suportă Compose direct.

Un aspect important: pluginul Gradle Firebase Performance modifică bytecode-ul aplicației în etapa de compilare. Pluginul adaugă cod de instrumentare în fiecare Activity și client OkHttp. Acest lucru poate crește timpul de build cu 5-10% și dimensiunea APK-ului cu 200-400 KB. În build-urile de debug, Firebase Performance este dezactivat automat — acest lucru protejează împotriva distorsionării metricilor în timpul dezvoltării locale. Pentru activarea forțată în debug se folosește flag-ul firebasePerformanceInstrumentationEnabled în manifest.

Firebase Performance suportă de asemenea MetricKit pentru iOS și Perfetto pentru Android — trasoare de sistem de nivel scăzut. MetricKit furnizează date despre frecvența cadrelor, consumul de CPU și memorie la nivelul sistemului de operare. Firebase agregă aceste date și le afișează în aceeași consolă unde sunt arătate trasările HTTP și screen traces, combinând telemetria de sistem și cea aplicativă într-o singură interfață.

Cereri HTTP cu 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 */ }
})

Integrarea Firebase Performance în proiectul iOS

Pentru iOS, integrarea Firebase Performance se realizează prin CocoaPods sau Swift Package Manager. După instalarea podurilor FirebasePerformance și FirebaseCore, SDK-ul începe automat colectarea metricilor. Pentru interceptarea cererilor HTTP, Firebase Performance iOS folosește NSURLProtocol — un mecanism de sistem care permite interceptarea tuturor încărcărilor de URL în aplicație. SDK-ul înregistrează propria sa subclasă NSURLProtocol la pornire, iar toate cererile prin URLSession intră automat sub monitorizare.

Limitare pentru iOS: Firebase Performance nu suportă screen trace automat pentru SwiftUI. Pentru aplicațiile SwiftUI este necesar să se creeze manual trasări personalizate, înglobând corpul View într-un bloc start/stop. Firebase lucrează la suportul nativ pentru SwiftUI, dar momentan SDK-ul urmărește automat doar controlerele UIView. Pentru aplicațiile hibride UIKit + SwiftUI se recomandă crearea ecranelor în UIKit și încorporarea SwiftUI prin UIHostingController.

Firebase Performance iOS oferă de asemenea integrare cu MetricKit — framework-ul Apple care colectează date de diagnostic la nivelul sistemului de operare. MetricKit trimite rapoarte zilnice cu metrici de CPU, GPU, memorie și frecvență a cadrelor. Firebase Performance agregă aceste rapoarte și le afișează în consolă lângă trasările personalizate, oferind o imagine completă a performanței atât la nivel de aplicație, cât și la nivel de sistem.

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