Firebase Performance — คืออะไร เครื่องมือตรวจสอบและเมตริก

Firebase Performance Monitoring คืออะไร?

Firebase Performance Monitoring คือบริการคลาวด์ของ Google ที่รวบรวมและแสดงเมตริกประสิทธิภาพของแอปพลิเคชันมือถือ บริการนี้เป็นส่วนหนึ่งของชุดเครื่องมือ Firebase และไม่ต้องชำระเงินแยกต่างหาก — การตรวจสอบพร้อมใช้งานในระดับ Spark ฟรี (จำกัด 500,000 เหตุการณ์ต่อวัน) และระดับ Blaze แบบชำระเงิน Firebase Performance สร้างการติดตามโดยอัตโนมัติสำหรับสถานการณ์มาตรฐาน: การเริ่มต้นหน้าจอแบบเย็น การเริ่มต้นแบบอุ่น คำขอ HTTP พื้นหลัง

สถาปัตยกรรมของบริการสร้างขึ้นจากข้อมูลสองประเภท: traces (การติดตาม) และ metrics (เมตริก) การติดตามคือช่วงเวลาที่มีจุดเริ่มต้นและจุดสิ้นสุด ซึ่งภายในจะวัดระยะเวลาการดำเนินการ เมตริกคือค่าตัวเลข: ขนาดการตอบสนอง อัตราข้อผิดพลาด ความเร็วเป็นไบต์/วินาที แต่ละการติดตามสามารถมีหลายเมตริก SDK จะรวบรวมข้อมูลบนอุปกรณ์ จัดเก็บในบัฟเฟอร์ และส่งไปยัง Firebase ในพื้นหลังด้วยลำดับความสำคัญความหน่วงต่ำเพื่อไม่ให้กระทบต่อประสบการณ์ผู้ใช้

ตามรายงาน Google I/O 2024 Firebase Performance ถูกใช้ในมากกว่า 2 ล้านแอปพลิเคชันทั่วโลก เวลาเฉลี่ยในการตรวจจับปัญหาประสิทธิภาพโดยใช้ Firebase Performance คือ 15 นาทีหลังจากเผยแพร่หากมีการกำหนดค่าการแจ้งเตือน หากไม่มีการตรวจสอบ ปัญหาที่คล้ายกันมักจะถูกตรวจพบภายใน 2-3 วันผ่านการร้องเรียนจากผู้ใช้ไปยังฝ่ายสนับสนุน

ความแตกต่างจาก Firebase Crashlytics

Crashlytics จะติดตามการขัดข้องและข้อผิดพลาดร้ายแรง — สถานการณ์ที่แอปพลิเคชันสิ้นสุดลงโดยไม่คาดคิด Firebase Performance จะตรวจสอบประสิทธิภาพของแอปพลิเคชันที่กำลังทำงาน: หน้าจอช้า คำขอเครือข่ายยาว การตอบสนอง UI ล่าช้า Crashlytics ตอบคำถาม "ทำไมแอปถึงขัดข้อง?" ในขณะที่ Performance ตอบคำถาม "ทำไมแอปถึงทำงานช้า?" บริการทั้งสองรวมผ่าน SDK เดียว (Firebase Core) และข้อมูลจะแสดงในส่วนที่อยู่ติดกันของคอนโซล Firebase

เมตริกเปอร์เซ็นไทล์

Firebase Performance ไม่แสดงค่าเฉลี่ย — แสดงเฉพาะ เปอร์เซ็นไทล์: P50, P75, P90, P95, P99 นี่เป็นสิ่งสำคัญสำหรับประสิทธิภาพ: เวลาเฉลี่ยซ่อนค่าผิดปกติ หากผู้ใช้ 99 คนเปิดหน้าจอใน 200 มิลลิวินาทีและอีกหนึ่งคนเปิดใน 20 วินาที ค่าเฉลี่ยจะอยู่ที่ ~400 มิลลิวินาที ซึ่งดูยอมรับได้ P99 จะแสดง 20 วินาที — ปัญหาที่แท้จริง Firebase แสดงเปอร์เซ็นไทล์บนไทม์ไลน์ ทำให้สามารถติดตามการถดถอยด้วยความแม่นยำรายชั่วโมง

Firebase Performance Monitoring ทำงานอย่างไร

Firebase Performance SDK ถูกรวมเข้าในแอปพลิเคชันผ่านการรวมมาตรฐาน: การเพิ่มการพึ่งพาใน Gradle (Android) หรือผ่าน CocoaPods (iOS) หลังจากเริ่มต้น Firebase ในโค้ด SDK จะเริ่มรวบรวมเมตริกโดยอัตโนมัติโดยไม่ต้องกำหนดค่าเพิ่มเติม หลักการสำคัญคือ การรวบรวมแบบขี้เกียจ: SDK จะไม่ส่งข้อมูลทันที แต่จะสะสมและส่งเป็นชุดเมื่อเงื่อนไขเครือข่ายเอื้ออำนวย

สำหรับ iOS SDK ใช้ NSURLProtocol เพื่อดักจับคำขอ HTTP; สำหรับ Android — OkHttp Interceptor หากแอปพลิเคชันไม่ใช้ OkHttp SDK จะครอบ HttpURLConnection โดยอัตโนมัติ คำขอที่ถูกดักจับจะถูกเพิ่มข้อมูลเมตา: Content-Type สถานะการตอบสนอง ขนาดเป็นไบต์ ระยะเวลา ข้อมูลทั้งหมดจะถูกส่งผ่าน HTTPS ไปยังเซิร์ฟเวอร์ Firebase ด้วยการเข้ารหัส TLS 1.3

ข้อกำหนดสำคัญประการหนึ่งของ Firebase Performance คือ ต้องเป็นปลั๊กอินตัวสุดท้าย ในรายการปลั๊กอิน Gradle หากลำดับถูกละเมิด SDK อาจไม่สามารถดักจับคำขอทั้งหมดหรือวัดเวลาเริ่มต้นไม่ถูกต้อง Firebase แนะนำให้วางปลั๊กอินไว้ที่ส่วนท้ายของบล็อกปลั๊กอิน หลังจาก Crashlytics และปลั๊กอิน Google Services อื่น ๆ

// build.gradle (Module: app) — ลำดับปลั๊กอินที่ถูกต้อง
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"  // สุดท้าย!
}

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

การติดตามอัตโนมัติ: หน้าจอ การเริ่มต้น เครือข่าย

Firebase Performance สร้างการติดตามอัตโนมัติสามประเภท: screen trace (เวลาเรนเดอร์หน้าจอ), app start trace (เวลาเริ่มต้นแอปพลิเคชัน) และ network request trace (คำขอ HTTP) Screen trace สำหรับ Android วัดเวลาระหว่างการเรียก Activity.onCreate และการเรนเดอร์เฟรมแรกเสร็จสมบูรณ์ สำหรับ iOS จะวัดเวลาระหว่าง viewDidLoad และ viewDidAppear Firebase จะสร้างการติดตามสำหรับแต่ละหน้าจอโดยอัตโนมัติ โดยใช้ชื่อคลาสของ Activity หรือ ViewController

App start trace แบ่งออกเป็นสองประเภท: การเริ่มต้นแบบเย็น (แอปพลิเคชันเริ่มจากศูนย์ กระบวนการไม่มีอยู่) และการเริ่มต้นแบบอุ่น (แอปพลิเคชันถูกกู้คืนจากสถานะพื้นหลัง) การเริ่มต้นแบบเย็นเป็นเมตริกที่สำคัญที่สุดเนื่องจากรวมถึงการเริ่มต้น SDK ทั้งหมด การโหลดไฟล์ DEX และการสร้าง Activity แรก Firebase วัดการเริ่มต้นแบบเย็นตั้งแต่ช่วงเวลาที่กระบวนการเริ่มต้นจนถึงการเรนเดอร์หน้าจอแรกเต็มรูปแบบ ตามคำแนะนำของ Google การเริ่มต้นแบบเย็นไม่ควรเกิน 500 มิลลิวินาทีสำหรับ P50 และ 2 วินาทีสำหรับ P99

Network request trace จะบันทึกคำขอ HTTP แต่ละรายการโดยอัตโนมัติพร้อมข้อมูลเมตา: URL เมธอด รหัสตอบสนอง ขนาดตอบสนอง ความเร็วในการส่ง ในคอนโซล Firebase Performance คุณสามารถกรองคำขอตามรูปแบบ URL — ตัวอย่างเช่น แสดงคำขอทั้งหมดไปยัง /api/v2/orders สำหรับแต่ละรูปแบบ จะแสดงเปอร์เซ็นไทล์เวลาตอบสนองและอัตราข้อผิดพลาด 4xx/5xx ซึ่งช่วยให้ตรวจจับการเสื่อมสภาพของ API เฉพาะได้อย่างรวดเร็วโดยไม่ต้องตั้งค่าการแจ้งเตือนแยกต่างหาก

เมตริกหน้าจอโดยละเอียด

สำหรับหน้าจอ Firebase Performance จะคำนวณ เมตริก "frozen frames" เพิ่มเติม — เฟรมที่ใช้เวลาเรนเดอร์นานกว่า 700 มิลลิวินาที การค้างของ UI เหล่านี้ผู้ใช้จะรับรู้ว่า "แอปค้าง" หากหน้าจอมี frozen frames มากกว่า 1% Firebase จะทำเครื่องหมายเมตริกว่ามีปัญหา สำหรับ Android SDK จะรวบรวมเมตริก slow renders เพิ่มเติม — เฟรมที่นานกว่า 16 มิลลิวินาที (พลาด 60 FPS) การรวมกันของ screen trace และ frozen frames ให้ภาพที่สมบูรณ์ทั้งเวลาโหลดและความลื่นไหลของแอนิเมชัน

การติดตามแบบกำหนดเองสำหรับสถานการณ์ทางธุรกิจ

การติดตามแบบกำหนดเอง ช่วยให้วัดระยะเวลาของสถานการณ์ผู้ใช้ใด ๆ: การสั่งซื้อ การอัปโหลดรูปภาพไปยังคลาวด์ การซิงโครไนซ์ข้อมูล นักพัฒนาจะระบุจุดเริ่มต้นและจุดสิ้นสุดของการติดตามในโค้ดอย่างชัดเจน และตั้งชื่อสถานการณ์ ต่างจากการติดตามอัตโนมัติ การติดตามแบบกำหนดเองให้การควบคุมอย่างสมบูรณ์ว่าสิ่งใดถูกวัด และอนุญาตให้เพิ่มแอตทริบิวต์สำหรับการกรอง

แต่ละการติดตามแบบกำหนดเองสามารถมี แอตทริบิวต์ — คู่คีย์-ค่าที่เพิ่มเป็นข้อมูลเมตา แอตทริบิวต์ช่วยแบ่งส่วนข้อมูล: ตัวอย่างเช่น คุณสามารถติดตามเวลาชำระเงินแยกต่างหากสำหรับ "promo_user" และ "regular_user" Firebase Performance รองรับสูงสุด 5 แอตทริบิวต์ต่อการติดตามและสูงสุด 100 ค่าแอตทริบิวต์ที่ไม่ซ้ำกัน แอตทริบิวต์ถูกจัดทำดัชนีและพร้อมสำหรับการกรองในคอนโซล Firebase

ตามการนำเสนอ Google I/O 2024 ทีม Spotify ใช้การติดตามแบบกำหนดเองของ Firebase เพื่อตรวจสอบเวลาในการเปลี่ยนแทร็ก ซึ่งช่วยลดเวลาในการเปลี่ยนเฉลี่ยจาก 400 มิลลิวินาทีเป็น 120 มิลลิวินาทีโดยการระบุคอขวดในการแคชบัฟเฟอร์เสียง ข้อมูลเชิงลึกสำคัญมาจากการกรองตามแอตทริบิวต์ "device_model" — ปัญหาเกิดขึ้นเฉพาะบนอุปกรณ์ Samsung ที่ใช้ 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()

        // กำลังดำเนินการสถานการณ์ชำระเงิน
        validateCart()
        processPayment()
        confirmOrder()

        trace.stop()
    }
}

การรวม Firebase Performance ในโปรเจกต์ Android

การรวม Firebase Performance ใน Android ต้องใช้ สามขั้นตอน: เพิ่มปลั๊กอิน google-services เชื่อมต่อ BOM (Bill of Materials) ของ Firebase และเพิ่มการพึ่งพา firebase-perf Firebase Performance ทำงานโดยอัตโนมัติบน Activity และแฟรกเมนต์ทั้งหมดหากใช้ AppCompatActivity สำหรับหน้าจอ Compose Firebase แนะนำให้ใช้การติดตามแบบกำหนดเองเนื่องจากการติดตามหน้าจออัตโนมัติไม่รองรับ Compose โดยตรง

ความแตกต่างที่สำคัญ: ปลั๊กอิน Gradle ของ Firebase Performance จะปรับเปลี่ยนไบต์โค้ดของแอปพลิเคชันในเวลาคอมไพล์ ปลั๊กอินจะเพิ่มโค้ดการวัดในทุก Activity และ OkHttp client ซึ่งอาจเพิ่มเวลาในการ build 5-10% และขนาด APK 200-400 KB ใน build แบบดีบัก Firebase Performance จะถูกปิดใช้งานโดยอัตโนมัติ — ซึ่งป้องกันการบิดเบือนเมตริกระหว่างการพัฒนาในพื้นที่ สำหรับการเปิดใช้งานแบบบังคับในดีบัก ให้ใช้แฟล็ก firebasePerformanceInstrumentationEnabled ในแมนิเฟสต์

Firebase Performance ยังรองรับ MetricKit สำหรับ iOS และ Perfetto สำหรับ Android — ตัวติดตามระบบระดับต่ำ MetricKit ให้ข้อมูลเกี่ยวกับอัตราเฟรม การใช้งาน CPU และหน่วยความจำในระดับระบบปฏิบัติการ Firebase รวบรวมข้อมูลนี้และแสดงในคอนโซลเดียวกันกับที่แสดง HTTP traces และ screen traces รวมการวัดระยะไกลของระบบและแอปพลิเคชันในอินเทอร์เฟซเดียว

คำขอ HTTP ด้วย 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 */ }
})

การรวม Firebase Performance ในโปรเจกต์ iOS

สำหรับ iOS การรวม Firebase Performance จะดำเนินการผ่าน CocoaPods หรือ Swift Package Manager หลังจากติดตั้งพอด FirebasePerformance และ FirebaseCore SDK จะเริ่มรวบรวมเมตริกโดยอัตโนมัติ สำหรับการดักจับคำขอ HTTP Firebase Performance iOS ใช้ NSURLProtocol — กลไกระบบที่ช่วยให้ดักจับการโหลด URL ทั้งหมดในแอปพลิเคชัน SDK ลงทะเบียนคลาสย่อย NSURLProtocol เมื่อเริ่มต้น และคำขอทั้งหมดผ่าน URLSession จะตกอยู่ภายใต้การตรวจสอบโดยอัตโนมัติ

ข้อจำกัดสำหรับ iOS: Firebase Performance ไม่รองรับการติดตามหน้าจออัตโนมัติสำหรับ SwiftUI สำหรับแอปพลิเคชัน SwiftUI คุณต้องสร้างการติดตามแบบกำหนดเองด้วยตนเองโดยครอบเนื้อหา View ในบล็อกเริ่ม/หยุด Firebase กำลังทำงานเพื่อรองรับ SwiftUI ดั้งเดิม แต่ในปัจจุบัน SDK จะติดตามเฉพาะตัวควบคุม UIView โดยอัตโนมัติ สำหรับแอปพลิเคชันแบบไฮบริดบน UIKit + SwiftUI แนะนำให้สร้างหน้าจอบน UIKit และฝัง SwiftUI ผ่าน UIHostingController

Firebase Performance iOS ยังให้การรวมกับ MetricKit — เฟรมเวิร์กของ Apple ที่รวบรวมข้อมูลการวินิจฉัยในระดับระบบปฏิบัติการ MetricKit ส่งรายงานประจำวันพร้อมเมตริก CPU, GPU, หน่วยความจำ และอัตราเฟรม Firebase Performance รวบรวมรายงานเหล่านี้และแสดงในคอนโซลควบคู่ไปกับการติดตามแบบกำหนดเอง ซึ่งให้ภาพที่สมบูรณ์ของประสิทธิภาพทั้งในระดับแอปพลิเคชันและระบบ

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