Firebase Performance — ce que c'est, outil de surveillance et métriques

Qu'est-ce que Firebase Performance Monitoring ?

Firebase Performance Monitoring est un service cloud de Google qui collecte et affiche les métriques de performances des applications mobiles. Le service fait partie de l'ensemble d'outils Firebase et ne nécessite pas de paiement séparé — la surveillance est disponible dans le niveau gratuit Spark (limite de 500 000 événements par jour) et le niveau payant Blaze. Firebase Performance génère automatiquement des traces pour les scénarios standard : démarrage à froid de l'écran, démarrage à chaud, requêtes HTTP en arrière-plan.

L'architecture du service repose sur deux types de données : les traces et les métriques. Une trace est un intervalle de temps avec un début et une fin, à l'intérieur duquel la durée d'exécution est mesurée. Une métrique est une valeur numérique : taille de la réponse, taux d'erreur, vitesse en octets/s. Chaque trace peut contenir plusieurs métriques. Le SDK collecte les données sur l'appareil, les met en mémoire tampon et les envoie à Firebase en arrière-plan avec une priorité de faible latence pour ne pas affecter l'expérience utilisateur.

Selon le rapport Google I/O 2024, Firebase Performance est utilisé dans plus de 2 millions d'applications dans le monde. Le temps moyen de détection d'un problème de performance avec Firebase Performance est de 15 minutes après la publication si les alertes sont configurées. Sans surveillance, un problème similaire est généralement détecté en 2 à 3 jours via les réclamations des utilisateurs au support.

Différence avec Firebase Crashlytics

Crashlytics suit les plantages et les erreurs fatales — les situations où l'application se termine de manière inattendue. Firebase Performance surveille les performances d'une application en cours d'exécution : écrans lents, requêtes réseau longues, retards de réponse de l'interface utilisateur. Crashlytics répond à la question « pourquoi l'application a-t-elle planté ? », tandis que Performance répond à « pourquoi l'application est-elle lente ? ». Les deux services s'intègrent via un seul SDK (Firebase Core) et les données sont affichées dans des sections adjacentes de la console Firebase.

Métriques de centiles

Firebase Performance n'affiche pas les valeurs moyennes — seulement les centiles : P50, P75, P90, P95, P99. C'est crucial pour les performances : le temps moyen cache les valeurs aberrantes. Si 99 utilisateurs ouvrent un écran en 200 ms et un en 20 secondes, la moyenne serait d'environ 400 ms, ce qui semble acceptable. P99 affichera 20 secondes — le vrai problème. Firebase affiche les centiles sur une chronologie, permettant de suivre les régressions avec une précision à l'heure près.

Comment fonctionne Firebase Performance Monitoring

Firebase Performance SDK est intégré dans une application via une intégration standard : ajout d'une dépendance dans Gradle (Android) ou via CocoaPods (iOS). Après l'initialisation de Firebase dans le code, le SDK commence automatiquement à collecter des métriques sans configuration supplémentaire. Un principe important est la collecte paresseuse : le SDK n'envoie pas les données immédiatement, mais les accumule et les transmet par lots lorsque les conditions réseau sont favorables.

Pour iOS, le SDK utilise NSURLProtocol pour intercepter les requêtes HTTP ; pour Android — OkHttp Interceptor. Si l'application n'utilise pas OkHttp, le SDK encapsule automatiquement HttpURLConnection. Les requêtes interceptées sont enrichies de métadonnées : Content-Type, statut de la réponse, taille en octets, durée. Toutes les données sont transmises via HTTPS au serveur Firebase avec chiffrement TLS 1.3.

L'une des exigences clés de Firebase Performance est d'être le dernier plugin dans la liste des plugins Gradle. Si l'ordre est violé, le SDK peut ne pas intercepter toutes les requêtes ou mesurer incorrectement le temps de démarrage. Firebase recommande de placer le plugin à la fin du bloc de plugins, après Crashlytics et les autres plugins Google Services.

// build.gradle (Module: app) — ordre correct des 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"  // dernier !
}

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

Traces automatiques : écrans, démarrage, réseau

Firebase Performance crée trois types de traces automatiques : screen trace (temps de rendu de l'écran), app start trace (temps de démarrage de l'application) et network request trace (requêtes HTTP). La screen trace pour Android mesure le temps entre l'appel Activity.onCreate et la fin du rendu de la première image. Pour iOS, le temps entre viewDidLoad et viewDidAppear est mesuré. Firebase crée automatiquement une trace pour chaque écran, en utilisant le nom de la classe Activity ou ViewController.

App start trace est divisé en deux types : démarrage à froid (l'application démarre de zéro, le processus n'existait pas) et démarrage à chaud (l'application est restaurée depuis l'état d'arrière-plan). Le démarrage à froid est la métrique la plus critique car elle inclut l'initialisation de tous les SDK, le chargement des fichiers DEX et la création de la première Activity. Firebase mesure le démarrage à froid depuis le moment où le processus commence jusqu'au rendu complet du premier écran. Selon les recommandations de Google, le démarrage à froid ne doit pas dépasser 500 ms pour P50 et 2 secondes pour P99.

Network request trace enregistre automatiquement chaque requête HTTP avec des métadonnées : URL, méthode, code de réponse, taille de la réponse, vitesse de transfert. Dans la console Firebase Performance, vous pouvez filtrer les requêtes par modèle d'URL — par exemple, afficher toutes les requêtes vers /api/v2/orders. Pour chaque modèle, les centiles de temps de réponse et les taux d'erreur 4xx/5xx sont affichés. Cela permet de détecter rapidement la dégradation d'une API spécifique sans configurer d'alertes individuelles.

Métriques d'écran en détail

Pour les écrans, Firebase Performance calcule en plus la métrique « frozen frames » — les images qui ont pris plus de 700 ms à rendre. Ces gelées de l'interface utilisateur sont perçues par l'utilisateur comme « l'application a gelé ». Si un écran a plus de 1 % de frozen frames, Firebase marque la métrique comme problématique. Pour Android, le SDK collecte en plus la métrique slow renders — les images de plus de 16 ms (perte de 60 FPS). La combinaison de screen trace et de frozen frames donne une image complète à la fois du temps de chargement et de la fluidité des animations.

Traces personnalisées pour scénarios métier

Les traces personnalisées permettent de mesurer la durée de tout scénario utilisateur : passer une commande, télécharger une image dans le cloud, synchroniser des données. Le développeur spécifie explicitement le début et la fin de la trace dans le code et définit le nom du scénario. Contrairement aux traces automatiques, les traces personnalisées offrent un contrôle total sur ce qui est mesuré et permettent d'ajouter des attributs pour le filtrage.

Chaque trace personnalisée peut contenir des attributs — des paires clé-valeur ajoutées comme métadonnées. Les attributs aident à segmenter les données : par exemple, vous pouvez suivre le temps de finalisation de la commande séparément pour « promo_user » et « regular_user ». Firebase Performance prend en charge jusqu'à 5 attributs par trace et jusqu'à 100 valeurs d'attribut uniques. Les attributs sont indexés et disponibles pour le filtrage dans la console Firebase.

Selon la présentation Google I/O 2024, l'équipe Spotify utilise des traces personnalisées Firebase pour surveiller le temps de changement de pistes. Cela a permis de réduire le temps médian de changement de 400 ms à 120 ms en identifiant un goulot d'étranglement dans la mise en cache du tampon audio. L'information clé est venue du filtrage par l'attribut « device_model » — le problème ne se manifestait que sur les appareils Samsung avec 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()

        // Exécution du scénario de finalisation de commande
        validateCart()
        processPayment()
        confirmOrder()

        trace.stop()
    }
}

Intégration de Firebase Performance dans un projet Android

L'intégration de Firebase Performance dans Android nécessite trois étapes : ajouter le plugin google-services, connecter le BOM (Bill of Materials) Firebase et ajouter la dépendance firebase-perf. Firebase Performance fonctionne automatiquement sur toutes les Activities et fragments s'ils utilisent AppCompatActivity. Pour les écrans Compose, Firebase recommande d'utiliser des traces personnalisées car la screen trace automatique ne prend pas en charge Compose directement.

Une nuance importante : le plugin Gradle Firebase Performance modifie le bytecode de l'application au moment de la compilation. Le plugin ajoute du code d'instrumentation à chaque Activity et client OkHttp. Cela peut augmenter le temps de compilation de 5 à 10 % et la taille de l'APK de 200 à 400 Ko. Dans les builds de débogage, Firebase Performance est automatiquement désactivé — cela évite la distorsion des métriques pendant le développement local. Pour l'activation forcée en débogage, utilisez le flag firebasePerformanceInstrumentationEnabled dans le manifeste.

Firebase Performance prend également en charge MetricKit pour iOS et Perfetto pour Android — des traceurs système de bas niveau. MetricKit fournit des données sur la fréquence d'images, l'utilisation du CPU et de la mémoire au niveau du système d'exploitation. Firebase agrège ces données et les affiche dans la même console où les traces HTTP et les screen traces sont montrées, combinant la télémétrie système et applicative dans une seule interface.

Requêtes HTTP avec 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 */ }
})

Intégration de Firebase Performance dans un projet iOS

Pour iOS, l'intégration de Firebase Performance se fait via CocoaPods ou Swift Package Manager. Après l'installation des pods FirebasePerformance et FirebaseCore, le SDK commence automatiquement à collecter des métriques. Pour intercepter les requêtes HTTP, Firebase Performance iOS utilise NSURLProtocol — un mécanisme système qui permet d'intercepter tous les chargements d'URL dans l'application. Le SDK enregistre sa sous-classe NSURLProtocol au démarrage, et toutes les requêtes via URLSession tombent automatiquement sous surveillance.

Limitation pour iOS : Firebase Performance ne prend pas en charge la screen trace automatique pour SwiftUI. Pour les applications SwiftUI, vous devez créer manuellement des traces personnalisées en encapsulant le corps de la View dans un bloc début/fin. Firebase travaille sur la prise en charge native de SwiftUI, mais actuellement le SDK trace automatiquement uniquement les contrôleurs UIView. Pour les applications hybrides sur UIKit + SwiftUI, il est recommandé de créer des écrans sur UIKit et d'intégrer SwiftUI via UIHostingController.

Firebase Performance iOS offre également une intégration avec MetricKit — un framework Apple qui collecte des données de diagnostic au niveau du système d'exploitation. MetricKit envoie des rapports quotidiens avec des métriques de CPU, GPU, mémoire et fréquence d'images. Firebase Performance agrège ces rapports et les affiche dans la console aux côtés des traces personnalisées, fournissant une image complète des performances tant au niveau de l'application que du système.

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