Rebuilt MetricKit with Swift-First API

import MetricKit
import SwiftUI

// MARK: - Performance Monitor (start at app launch, keep alive)

actor PerformanceMonitor {
    static let shared = PerformanceMonitor()
    private let manager = MetricManager()

    func startMonitoring() {
        // Stream daily metric reports
        Task.detached(priority: .utility) {
            for await report in await self.manager.metricReports {
                await self.handleMetricReport(report)
            }
        }

        // Stream diagnostic reports (delivered immediately after events)
        Task.detached(priority: .utility) {
            for await report in await self.manager.diagnosticReports {
                await self.handleDiagnosticReport(report)
            }
        }
    }

    private func handleMetricReport(_ report: MetricReport) {
        // Encode and ship to analytics server
        let encoder = JSONEncoder()
        encoder.dateEncodingStrategy = .iso8601
        if let data = try? encoder.encode(report),
           let json = String(data: data, encoding: .utf8) {
            print("[MetricKit] Sending metric report (\(json.count) bytes) to server")
        }

        // Inspect memory metrics across all interval entries
        for entry in report.intervalEntries {
            let memoryMetrics = entry.metrics.filter { $0.group == .memory }
            for metric in memoryMetrics {
                switch metric {
                case .peakMemory(let measurement):
                    print("[MetricKit] Peak memory: \(measurement)")
                default:
                    break
                }
            }
        }
    }

    private func handleDiagnosticReport(_ report: DiagnosticReport) {
        let encoder = JSONEncoder()
        if let data = try? encoder.encode(report) {
            print("[MetricKit] Diagnostic report: \(data.count) bytes")
        }

        switch report {
        case .crash(let crash):
            let frames = crash.backtrace.frames
                .map { $0.description }
                .joined(separator: "\n  ")
            print("""
            [MetricKit] Crash detected
              Reason: \(crash.terminationReason)
              Category: \(crash.terminationCategory)
              Backtrace:\n  \(frames)
            """)

        case .hang(let hang):
            let frames = hang.backtrace.frames
                .map { $0.description }
                .joined(separator: "\n  ")
            print("""
            [MetricKit] Hang detected (\(hang.duration))
              Backtrace:\n  \(frames)
            """)

        case .memoryException(let mem):
            print("[MetricKit] Memory exception — limit: \(mem.memoryLimit), usage at termination: \(mem.memoryUsage)")

        default:
            print("[MetricKit] Other diagnostic received")
        }
    }
}

// MARK: - App Entry Point

@main
struct MetricKitDemoApp: App {
    init() {
        Task { await PerformanceMonitor.shared.startMonitoring() }
    }

    var body: some Scene {
        WindowGroup { ContentView() }
    }
}

struct ContentView: View {
    var body: some View {
        Text("MetricKit monitoring active")
            .padding()
    }
}