MetricKit Modern Swift API

 import MetricKit
−import UIKit
+import StateReporting
+import SwiftUI
 
−// Old delegate-based approach (pre-iOS 27)
+// MARK: - App-state domain for tab tracking
 
−class LegacyPerformanceMonitor: NSObject, MXMetricManagerSubscriber {
−    static let shared = LegacyPerformanceMonitor()
−    private let manager = MXMetricManager.shared
+enum ActiveTab: String, StateValue {
+    case reports
+    case spending
+}
 
−    func start() {
−        manager.add(self)
−    }
+// MARK: - MetricKit service (retain for app lifetime)
 
−    // Called at most once per day, on a background queue
−    func didReceive(_ payloads: [MXMetricPayload]) {
−        for payload in payloads {
−            if let memory = payload.memoryMetrics {
−                print("Peak memory: \(memory.peakMemoryUsage)")
+@MainActor
+final class PerformanceMonitor {
+    static let shared = PerformanceMonitor()
+    private let manager = MetricManager()
+    private let encoder: JSONEncoder = {
+        let e = JSONEncoder()
+        e.outputFormatting = .prettyPrinted
+        return e
+    }()
+
+    func start() {
+        // Stream metric reports (daily + sub-day breakdowns)
+        Task.detached(priority: .utility) { [weak self] in
+            guard let self else { return }
+            for await report in await self.manager.metricReports {
+                await self.handle(report)
             }
−            if let hangs = payload.applicationResponsivenessMetrics {
−                print("Hang rate: \(hangs.hangRate)")
+        }
+        // Stream diagnostic reports (crashes, hangs, memory exceptions)
+        Task.detached(priority: .utility) { [weak self] in
+            guard let self else { return }
+            for await report in await self.manager.diagnosticReports {
+                await self.handle(report)
             }
−            // Encode entire payload as JSON for upload
−            let json = payload.jsonRepresentation()
−            print("JSON payload: \(json)")
         }
     }
 
−    func didReceive(_ payloads: [MXDiagnosticPayload]) {
−        for payload in payloads {
−            if let crashes = payload.crashDiagnostics {
−                for crash in crashes {
−                    print("Crash signal: \(crash.signal ?? 0)")
−                    print("Backtrace: \(crash.callStackTree)")
+    private func handle(_ report: MetricReport) async {
+        // Forward the entire Codable report to your server
+        if let data = try? encoder.encode(report),
+           let json = String(data: data, encoding: .utf8) {
+            print("[MetricKit] Report received:\n\(json.prefix(400))")
+        }
+        // Drill into memory metrics per interval
+        for entry in report.intervalEntries {
+            let memoryMetrics = entry.metrics.filter { $0.group == .memory }
+            for metric in memoryMetrics {
+                switch metric {
+                case .peakMemory(let value):
+                    print("[MetricKit] Peak memory: \(value)")
+                default:
+                    break
                 }
             }
−            if let hangs = payload.hangDiagnostics {
−                for hang in hangs {
−                    print("Hang duration: \(hang.hangDuration)")
−                }
−            }
         }
     }
+
+    private func handle(_ report: DiagnosticReport) async {
+        switch report {
+        case .crash(let crash):
+            print("[Diagnostic] Crash — reason: \(crash.reason), category: \(crash.terminationCategory)")
+            print("[Diagnostic] Backtrace:\n\(crash.backtrace)")
+        case .hang(let hang):
+            print("[Diagnostic] Hang duration: \(hang.hangDuration)")
+        case .memoryException(let mem):
+            print("[Diagnostic] Memory exception: \(mem)")
+        default:
+            break
+        }
+    }
 }
 
−// Usage in AppDelegate
−class AppDelegate: UIResponder, UIApplicationDelegate {
−    func application(_ application: UIApplication,
−                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
−        LegacyPerformanceMonitor.shared.start()
−        return true
+// MARK: - Report app state transitions so MetricKit can segment metrics
+
+struct ExpenseApp: App {
+    @State private var selectedTab: ActiveTab = .reports
+    private let tabDomain = StateDomain<ActiveTab>(id: "com.example.tab")
+
+    var body: some Scene {
+        WindowGroup {
+            TabView(selection: $selectedTab) {
+                Text("Reports").tabItem { Label("Reports", systemImage: "doc") }.tag(ActiveTab.reports)
+                Text("Spending").tabItem { Label("Spending", systemImage: "chart.pie") }.tag(ActiveTab.spending)
+            }
+            .onChange(of: selectedTab) { _, newTab in
+                tabDomain.transition(to: newTab)
+            }
+            .task {
+                PerformanceMonitor.shared.start()
+                tabDomain.transition(to: selectedTab)
+            }
+        }
     }
 }