Firebase Performance — cos'è, strumento di monitoraggio e metriche

Cos'è Firebase Performance Monitoring?

Firebase Performance Monitoring è un servizio cloud di Google che raccoglie e visualizza metriche sulle prestazioni delle applicazioni mobili. Il servizio fa parte del set di strumenti Firebase e non richiede pagamenti separati — il monitoraggio è disponibile nel livello gratuito Spark (limite di 500.000 eventi al giorno) e nel livello a pagamento Blaze. Firebase Performance genera automaticamente trace per scenari standard: avvio a freddo dello schermo, avvio a caldo, richieste HTTP in background.

L'architettura del servizio si basa su due tipi di dati: traces (trace) e metrics (metriche). Una trace è un intervallo di tempo con un inizio e una fine, all'interno del quale viene misurata la durata dell'esecuzione. Una metrica è un valore numerico: dimensione della risposta, tasso di errore, velocità in byte/sec. Ogni trace può contenere più metriche. L'SDK raccoglie i dati sul dispositivo, li bufferizza e li invia a Firebase in background con priorità a bassa latenza per non influire sull'esperienza utente.

Secondo il rapporto Google I/O 2024, Firebase Performance è utilizzato in più di 2 milioni di applicazioni in tutto il mondo. Il tempo medio per rilevare un problema di prestazioni con Firebase Performance è di 15 minuti dopo il rilascio se gli avvisi sono configurati. Senza monitoraggio, un problema simile viene tipicamente rilevato entro 2-3 giorni attraverso i reclami degli utenti all'assistenza.

Differenza rispetto a Firebase Crashlytics

Crashlytics traccia crash ed errori fatali — situazioni in cui l'applicazione termina inaspettatamente. Firebase Performance monitora le prestazioni di un'applicazione in esecuzione: schermi lenti, richieste di rete lunghe, ritardi nella risposta dell'interfaccia utente. Crashlytics risponde alla domanda "perché l'app è andata in crash?", mentre Performance risponde a "perché l'app è lenta?". Entrambi i servizi si integrano tramite un unico SDK (Firebase Core) e i dati vengono visualizzati in sezioni adiacenti della console Firebase.

Metriche dei percentili

Firebase Performance non mostra valori medi — solo percentili: P50, P75, P90, P95, P99. Questo è fondamentale per le prestazioni: il tempo medio nasconde i valori anomali. Se 99 utenti aprono uno schermo in 200 ms e uno lo apre in 20 secondi, la media sarebbe ~400 ms, che sembra accettabile. P99 mostrerà 20 secondi — il vero problema. Firebase visualizza i percentili su una linea temporale, consentendo di tracciare le regressioni con precisione oraria.

Come funziona Firebase Performance Monitoring

Firebase Performance SDK viene integrato in un'applicazione tramite integrazione standard: aggiungendo una dipendenza in Gradle (Android) o tramite CocoaPods (iOS). Dopo l'inizializzazione di Firebase nel codice, l'SDK inizia automaticamente a raccogliere metriche senza configurazione aggiuntiva. Un principio importante è la raccolta lazy: l'SDK non invia i dati immediatamente, ma li accumula e li trasmette in batch quando le condizioni di rete sono favorevoli.

Per iOS, l'SDK utilizza NSURLProtocol per intercettare le richieste HTTP; per Android — OkHttp Interceptor. Se l'applicazione non utilizza OkHttp, l'SDK avvolge automaticamente HttpURLConnection. Le richieste intercettate vengono arricchite con metadati: Content-Type, stato della risposta, dimensione in byte, durata. Tutti i dati vengono trasmessi tramite HTTPS al server Firebase con crittografia TLS 1.3.

Uno dei requisiti chiave di Firebase Performance è essere l'ultimo plugin nell'elenco dei plugin Gradle. Se l'ordine viene violato, l'SDK potrebbe non intercettare tutte le richieste o misurare in modo errato il tempo di avvio. Firebase raccomanda di posizionare il plugin alla fine del blocco dei plugin, dopo Crashlytics e gli altri plugin di Google Services.

// build.gradle (Module: app) — ordine corretto dei plugin
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"  // ultimo!
}

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

Trace automatiche: schermi, avvio, rete

Firebase Performance crea tre tipi di trace automatiche: screen trace (tempo di rendering dello schermo), app start trace (tempo di avvio dell'applicazione) e network request trace (richieste HTTP). La screen trace per Android misura il tempo tra la chiamata Activity.onCreate e il completamento del rendering del primo fotogramma. Per iOS, viene misurato il tempo tra viewDidLoad e viewDidAppear. Firebase crea automaticamente una trace per ogni schermo, utilizzando il nome della classe Activity o ViewController.

App start trace è diviso in due tipi: avvio a freddo (l'applicazione parte da zero, il processo non esisteva) e avvio a caldo (l'applicazione viene ripristinata dallo stato di background). L'avvio a freddo è la metrica più critica perché include l'inizializzazione di tutti gli SDK, il caricamento dei file DEX e la creazione della prima Activity. Firebase misura l'avvio a freddo dal momento in cui il processo inizia fino al rendering completo del primo schermo. Secondo le raccomandazioni di Google, l'avvio a freddo non deve superare 500 ms per P50 e 2 secondi per P99.

Network request trace registra automaticamente ogni richiesta HTTP con metadati: URL, metodo, codice di risposta, dimensione della risposta, velocità di trasferimento. Nella console di Firebase Performance, puoi filtrare le richieste per modello di URL — ad esempio, mostrare tutte le richieste a /api/v2/orders. Per ogni modello, vengono visualizzati i percentili del tempo di risposta e i tassi di errore 4xx/5xx. Ciò consente di rilevare rapidamente il degrado di una specifica API senza configurare avvisi individuali.

Metriche dello schermo in dettaglio

Per gli schermi, Firebase Performance calcola inoltre la metrica "frozen frames" — fotogrammi che hanno impiegato più di 700 ms per essere renderizzati. Questi blocchi dell'interfaccia utente vengono percepiti dall'utente come "l'app si è bloccata". Se uno schermo ha più dell'1% di frozen frames, Firebase contrassegna la metrica come problematica. Per Android, l'SDK raccoglie inoltre la metrica slow renders — fotogrammi più lunghi di 16 ms (perdita di 60 FPS). La combinazione di screen trace e frozen frames fornisce un quadro completo sia del tempo di caricamento che della fluidità delle animazioni.

Trace personalizzate per scenari aziendali

Trace personalizzate consentono di misurare la durata di qualsiasi scenario utente: effettuare un ordine, caricare un'immagine sul cloud, sincronizzare i dati. Lo sviluppatore specifica esplicitamente l'inizio e la fine della trace nel codice e imposta il nome dello scenario. A differenza delle trace automatiche, le trace personalizzate offrono il controllo completo su ciò che viene misurato e consentono di aggiungere attributi per il filtraggio.

Ogni trace personalizzata può contenere attributi — coppie chiave-valore aggiunte come metadati. Gli attributi aiutano a segmentare i dati: ad esempio, puoi tracciare il tempo di checkout separatamente per "promo_user" e "regular_user". Firebase Performance supporta fino a 5 attributi per trace e fino a 100 valori di attributo univoci. Gli attributi sono indicizzati e disponibili per il filtraggio nella console Firebase.

Secondo la presentazione Google I/O 2024, il team di Spotify utilizza trace personalizzate di Firebase per monitorare il tempo di cambio traccia. Ciò ha contribuito a ridurre il tempo medio di cambio da 400 ms a 120 ms identificando un collo di bottiglia nella cache del buffer audio. L'intuizione chiave è arrivata dal filtraggio per attributo "device_model" — il problema si manifestava solo sui dispositivi Samsung con 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()

        // Esecuzione dello scenario di checkout
        validateCart()
        processPayment()
        confirmOrder()

        trace.stop()
    }
}

Integrazione di Firebase Performance in un progetto Android

L'integrazione di Firebase Performance in Android richiede tre passaggi: aggiungere il plugin google-services, collegare il BOM (Bill of Materials) di Firebase e aggiungere la dipendenza firebase-perf. Firebase Performance funziona automaticamente su tutte le Activities e i frammenti se utilizzano AppCompatActivity. Per gli schermi Compose, Firebase raccomanda di utilizzare trace personalizzate poiché la screen trace automatica non supporta Compose direttamente.

Una sfumatura importante: il plugin Gradle di Firebase Performance modifica il bytecode dell'applicazione in fase di compilazione. Il plugin aggiunge codice di strumentazione a ogni Activity e client OkHttp. Ciò può aumentare il tempo di compilazione del 5-10% e la dimensione dell'APK di 200-400 KB. Nelle build di debug, Firebase Performance viene disattivato automaticamente — ciò evita la distorsione delle metriche durante lo sviluppo locale. Per l'attivazione forzata in debug, utilizzare il flag firebasePerformanceInstrumentationEnabled nel manifest.

Firebase Performance supporta anche MetricKit per iOS e Perfetto per Android — tracciatori di sistema di basso livello. MetricKit fornisce dati su frame rate, utilizzo di CPU e memoria a livello di sistema operativo. Firebase aggrega questi dati e li visualizza nella stessa console dove vengono mostrate le trace HTTP e le screen trace, combinando la telemetria di sistema e dell'applicazione in un'unica interfaccia.

Richieste HTTP con 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 */ }
})

Integrazione di Firebase Performance in un progetto iOS

Per iOS, l'integrazione di Firebase Performance viene eseguita tramite CocoaPods o Swift Package Manager. Dopo l'installazione dei pod FirebasePerformance e FirebaseCore, l'SDK inizia automaticamente a raccogliere metriche. Per intercettare le richieste HTTP, Firebase Performance iOS utilizza NSURLProtocol — un meccanismo di sistema che consente di intercettare tutti i caricamenti di URL nell'applicazione. L'SDK registra la sua sottoclasse NSURLProtocol all'avvio e tutte le richieste tramite URLSession cadono automaticamente sotto monitoraggio.

Limitazione per iOS: Firebase Performance non supporta la screen trace automatica per SwiftUI. Per le applicazioni SwiftUI, è necessario creare manualmente trace personalizzate avvolgendo il corpo della View in un blocco di inizio/fine. Firebase sta lavorando al supporto nativo di SwiftUI, ma attualmente l'SDK traccia automaticamente solo i controller UIView. Per applicazioni ibride su UIKit + SwiftUI, si consiglia di creare schermi su UIKit e incorporare SwiftUI tramite UIHostingController.

Firebase Performance iOS offre anche l'integrazione con MetricKit — un framework Apple che raccoglie dati diagnostici a livello di sistema operativo. MetricKit invia report giornalieri con metriche di CPU, GPU, memoria e frame rate. Firebase Performance aggrega questi report e li visualizza nella console insieme alle trace personalizzate, fornendo un quadro completo delle prestazioni sia a livello di applicazione che di sistema.

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