Firebase Performance — apa itu, alat pemantauan dan metrik

Apa itu Firebase Performance Monitoring?

Firebase Performance Monitoring adalah layanan cloud Google yang mengumpulkan dan menampilkan metrik kinerja aplikasi mobile. Layanan ini termasuk dalam rangkaian alat Firebase dan tidak memerlukan pembayaran terpisah — pemantauan tersedia dalam tarif gratis Spark (batas 500.000 peristiwa per hari) dan tarif berbayar Blaze. Firebase Performance secara otomatis menghasilkan trace untuk skenario standar: cold start layar, warm start, permintaan HTTP latar belakang.

Arsitektur layanan dibangun di atas dua jenis data: traces (jejak) dan metrics (metrik). Trace adalah interval waktu dengan awal dan akhir, di mana durasi eksekusi diukur. Metrik adalah nilai numerik: ukuran respons, frekuensi kesalahan, kecepatan dalam byte/detik. Setiap trace dapat berisi beberapa metrik. SDK mengumpulkan data di perangkat, mem-buffer-nya, dan mengirimkannya ke Firebase di latar belakang dengan prioritas latensi rendah agar tidak memengaruhi pengalaman pengguna.

Menurut laporan Google I/O 2024, Firebase Performance digunakan di lebih dari 2 juta aplikasi di seluruh dunia. Waktu rata-rata untuk mendeteksi masalah kinerja dengan Firebase Performance adalah 15 menit setelah rilis, jika peringatan dikonfigurasi. Tanpa pemantauan, masalah serupa terdeteksi rata-rata setelah 2-3 hari berdasarkan keluhan pengguna ke dukungan.

Perbedaan dari Firebase Crashlytics

Crashlytics melacak crash dan kesalahan fatal — situasi di mana aplikasi berhenti secara tidak terduga. Firebase Performance memantau kinerja aplikasi yang sedang berjalan: layar lambat, permintaan jaringan panjang, keterlambatan respons UI. Crashlytics menjawab pertanyaan “ mengapa aplikasi crash?”, sedangkan Performance menjawab pertanyaan “ mengapa aplikasi berjalan lambat?”. Kedua layanan terintegrasi melalui satu SDK (Firebase Core) dan data ditampilkan di bagian terkait konsol Firebase.

Metrik persentil

Firebase Performance tidak menampilkan nilai rata-rata — hanya persentil: P50, P75, P90, P95, P99. Ini sangat penting untuk kinerja: waktu rata-rata menyembunyikan pencilan. Jika 99 pengguna membuka layar dalam 200 ms, dan satu dalam 20 detik, rata-rata akan menjadi ~400 ms, yang terlihat dapat diterima. P99 akan menunjukkan 20 detik — masalah sebenarnya. Firebase menampilkan persentil pada skala waktu, memungkinkan pelacakan regresi dengan akurasi hingga satu jam.

Bagaimana Firebase Performance Monitoring bekerja

Firebase Performance SDK diintegrasikan ke dalam aplikasi melalui integrasi standar: menambahkan dependensi di Gradle (Android) atau melalui CocoaPods (iOS). Setelah inisialisasi Firebase dalam kode, SDK secara otomatis mulai mengumpulkan metrik tanpa konfigurasi tambahan. Prinsip kerja yang penting adalah lazy collection: SDK tidak mengirim data segera, tetapi mengakumulasikannya dan mengirimkannya dalam batch ketika kondisi jaringan mendukung.

Untuk iOS, SDK menggunakan NSURLProtocol untuk mencegat permintaan HTTP, untuk Android — OkHttp Interceptor. Jika aplikasi tidak menggunakan OkHttp, SDK secara otomatis membungkus HttpURLConnection. Permintaan yang dicegat diperkaya dengan metadata: Content-Type, status respons, ukuran dalam byte, durasi. Semua data dikirim melalui HTTPS ke server Firebase dengan enkripsi TLS 1.3.

Salah satu persyaratan utama Firebase Performance adalah menjadi plugin terakhir dalam daftar plugin Gradle. Jika urutannya dilanggar, SDK mungkin tidak mencegat semua permintaan atau mengukur waktu startup secara tidak benar. Firebase merekomendasikan menempatkan plugin di akhir blok plugins, setelah Crashlytics dan plugin Google Services lainnya.

// build.gradle (Module: app) — urutan plugin yang benar
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"  // terakhir!
}

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

Trace otomatis: layar, startup, jaringan

Firebase Performance membuat tiga jenis trace otomatis: screen trace (waktu rendering layar), app start trace (waktu startup aplikasi), dan network request trace (permintaan HTTP). Screen trace untuk Android mengukur waktu antara pemanggilan Activity.onCreate dan selesainya rendering frame pertama. Untuk iOS, waktu diukur antara viewDidLoad dan viewDidAppear. Firebase secara otomatis membuat trace untuk setiap layar menggunakan nama kelas Activity atau ViewController.

App start trace dibagi menjadi dua jenis: cold start (aplikasi dimulai dari awal, proses belum ada) dan warm start (aplikasi dipulihkan dari status latar belakang). Cold start adalah indikator paling kritis karena mencakup inisialisasi semua SDK, memuat file DEX, dan membuat Activity pertama. Firebase mengukur cold start dari saat proses dimulai hingga rendering penuh layar pertama. Menurut rekomendasi Google, cold start tidak boleh melebihi 500 md untuk P50 dan 2 detik untuk P99.

Network request trace secara otomatis mencatat setiap permintaan HTTP dengan metadata: URL, metode, kode respons, ukuran respons, kecepatan transfer. Di konsol Firebase Performance, permintaan dapat difilter berdasarkan pola URL — misalnya, menampilkan semua permintaan ke /api/v2/orders. Untuk setiap pola, persentil waktu respons dan frekuensi kesalahan 4xx/5xx ditampilkan. Ini memungkinkan deteksi cepat degradasi API tertentu tanpa mengonfigurasi peringatan terpisah.

Metrik layar secara detail

Untuk layar, Firebase Performance juga menghitung metrik “frozen frames” — frame yang dirender lebih dari 700 md. Pembekuan UI semacam itu dirasakan oleh pengguna sebagai “aplikasi macet”. Jika di layar terdapat lebih dari 1% frozen frames, Firebase menandai metrik sebagai bermasalah. Untuk Android, SDK juga mengumpulkan metrik slow renders — frame lebih dari 16 md (kehilangan 60 FPS). Kombinasi screen trace dan frozen frames memberikan gambaran lengkap tentang waktu muat dan kehalusan animasi.

Trace kustom untuk skenario bisnis

Trace kustom memungkinkan mengukur durasi skenario pengguna apa pun: pemesanan, mengunggah gambar ke cloud, sinkronisasi data. Pengembang secara eksplisit menentukan awal dan akhir trace dalam kode dan memberi nama skenario. Berbeda dengan trace otomatis, trace kustom memberikan kontrol penuh atas apa yang diukur dan memungkinkan penambahan atribut untuk pemfilteran.

Setiap trace kustom dapat berisi atribut — pasangan kunci-nilai yang ditambahkan sebagai metadata. Atribut membantu segmentasi data: misalnya, waktu pemesanan dapat dilacak secara terpisah untuk “promo_user” dan “regular_user”. Firebase Performance mendukung hingga 5 atribut per trace dan hingga 100 nilai atribut unik. Atribut diindeks dan tersedia untuk pemfilteran di konsol Firebase.

Menurut laporan Google I/O 2024, tim Spotify menggunakan trace kustom Firebase untuk memantau waktu perpindahan antar lagu. Ini memungkinkan pengurangan waktu perpindahan median dari 400 md menjadi 120 md dengan mengidentifikasi hambatan dalam cache buffer audio. Wawasan kuncinya adalah pemfilteran berdasarkan atribut “device_model” — masalah hanya muncul pada perangkat Samsung dengan 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()

        // Eksekusi skenario pemesanan
        validateCart()
        processPayment()
        confirmOrder()

        trace.stop()
    }
}

Integrasi Firebase Performance ke proyek Android

Integrasi Firebase Performance di Android memerlukan tiga langkah: menambahkan plugin google-services, menghubungkan BOM (Bill of Materials) Firebase, dan menambahkan dependensi firebase-perf. Firebase Performance secara otomatis berfungsi di semua Activity dan fragmen jika menggunakan AppCompatActivity. Untuk layar Compose, Firebase merekomendasikan penggunaan trace kustom karena screen trace otomatis tidak mendukung Compose secara langsung.

Nuansa penting: plugin Gradle Firebase Performance memodifikasi bytecode aplikasi pada tahap kompilasi. Plugin menambahkan kode instrumentasi ke setiap Activity dan klien OkHttp. Ini dapat meningkatkan waktu build sebesar 5-10% dan ukuran APK sebesar 200-400 KB. Dalam build debug, Firebase Performance dinonaktifkan secara otomatis — ini melindungi dari distorsi metrik selama pengembangan lokal. Untuk aktivasi paksa di debug, gunakan flag firebasePerformanceInstrumentationEnabled di manifes.

Firebase Performance juga mendukung MetricKit untuk iOS dan Perfetto untuk Android — pelacak sistem tingkat rendah. MetricKit menyediakan data tentang frekuensi frame, konsumsi CPU dan memori di tingkat sistem operasi. Firebase mengagregasi data ini dan menampilkannya di konsol yang sama dengan trace HTTP dan screen traces, menggabungkan telemetri sistem dan aplikasi dalam satu antarmuka.

Permintaan HTTP dengan 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 */ }
})

Integrasi Firebase Performance ke proyek iOS

Untuk iOS, integrasi Firebase Performance dilakukan melalui CocoaPods atau Swift Package Manager. Setelah menginstal pod FirebasePerformance dan FirebaseCore, SDK secara otomatis mulai mengumpulkan metrik. Untuk mencegat permintaan HTTP, Firebase Performance iOS menggunakan NSURLProtocol — mekanisme sistem yang memungkinkan mencegat semua pemuatan URL di aplikasi. SDK mendaftarkan subkelas NSURLProtocol-nya sendiri saat startup, dan semua permintaan melalui URLSession secara otomatis masuk ke dalam pemantauan.

Keterbatasan untuk iOS: Firebase Performance tidak mendukung screen trace otomatis untuk SwiftUI. Untuk aplikasi SwiftUI, perlu membuat trace kustom secara manual dengan membungkus body View dalam blok start/stop. Firebase sedang mengerjakan dukungan native untuk SwiftUI, tetapi saat ini SDK hanya melacak pengontrol UIView secara otomatis. Untuk aplikasi hybrid UIKit + SwiftUI, disarankan untuk membuat layar di UIKit dan menyematkan SwiftUI melalui UIHostingController.

Firebase Performance iOS juga menyediakan integrasi dengan MetricKit — framework Apple yang mengumpulkan data diagnostik di tingkat OS. MetricKit mengirimkan laporan harian dengan metrik CPU, GPU, memori, dan frekuensi frame. Firebase Performance mengagregasi laporan ini dan menampilkannya di konsol di samping trace kustom, memberikan gambaran lengkap tentang kinerja baik di tingkat aplikasi maupun 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()
    }
}