Instruments and Profiling Tools in iOS Development: A Complete Beginner's Guide

import Foundation
import UIKit
import os.log

class PerformanceMonitor: ObservableObject {
    static let shared = PerformanceMonitor()
    
    // Performance metrics
    @Published var cpuUsage: Double = 0.0
    @Published var memoryUsage: Double = 0.0
    @Published var batteryLevel: Float = 1.0
    @Published var networkLatency: TimeInterval = 0.0
    
    // Monitoring configuration
    private let monitoringInterval: TimeInterval = 1.0
    private var monitoringTimer: Timer?
    private var isMonitoring = false
    
    // Performance thresholds
    private let cpuThreshold: Double = 80.0
    private let memoryThreshold: Double = 100.0 // MB
    private let latencyThreshold: TimeInterval = 2.0
    
    // Logging
    private let performanceLogger = Logger(subsystem: "com.yourapp.performance", category: "monitoring")
    
    // Performance history for trend analysis
    private var performanceHistory: [PerformanceSnapshot] = []
    private let maxHistorySize = 100
    
    struct PerformanceSnapshot {
        let timestamp: Date
        let cpuUsage: Double
        let memoryUsage: Double
        let batteryLevel: Float
        let networkLatency: TimeInterval
    }
    
    private init() {
        setupNotifications()
    }
    
    func startMonitoring() {
        guard !isMonitoring else { return }
        
        isMonitoring = true
        monitoringTimer = Timer.scheduledTimer(withTimeInterval: monitoringInterval, repeats: true) { _ in
            Task {
                await self.collectMetrics()
            }
        }
        
        performanceLogger.info("Performance monitoring started")
    }
    
    func stopMonitoring() {
        isMonitoring = false
        monitoringTimer?.invalidate()
        monitoringTimer = nil
        
        performanceLogger.info("Performance monitoring stopped")
    }
    
    @MainActor
    private func collectMetrics() async {
        // Collect CPU usage
        cpuUsage = getCurrentCPUUsage()
        
        // Collect memory usage
        memoryUsage = getCurrentMemoryUsage()
        
        // Collect battery level
        batteryLevel = UIDevice.current.batteryLevel
        
        // Measure network latency
        networkLatency = await measureNetworkLatency()
        
        // Create snapshot
        let snapshot = PerformanceSnapshot(
            timestamp: Date(),
            cpuUsage: cpuUsage,
            memoryUsage: memoryUsage,
            batteryLevel: batteryLevel,
            networkLatency: networkLatency
        )
        
        // Add to history
        performanceHistory.append(snapshot)
        if performanceHistory.count > maxHistorySize {
            performanceHistory.removeFirst()
        }
        
        // Check thresholds and alert if needed
        checkPerformanceThresholds(snapshot)
    }
    
    private func getCurrentCPUUsage() -> Double {
        var info = mach_task_basic_info()
        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size)/4
        
        let kerr: kern_return_t = withUnsafeMutablePointer(to: &info) {
            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
                task_info(mach_task_self_,
                         task_flavor_t(MACH_TASK_BASIC_INFO),
                         $0,
                         &count)
            }
        }
        
        if kerr == KERN_SUCCESS {
            return Double(info.resident_size) / 1024.0 / 1024.0
        } else {
            return 0.0
        }
    }
    
    private func getCurrentMemoryUsage() -> Double {
        let MACH_TASK_BASIC_INFO_COUNT = MemoryLayout<mach_task_basic_info_data_t>.size / MemoryLayout<natural_t>.size
        
        var info = mach_task_basic_info_data_t()
        var count = mach_msg_type_number_t(MACH_TASK_BASIC_INFO_COUNT)
        
        let kerr = withUnsafeMutablePointer(to: &info) { infoPtr in
            infoPtr.withMemoryRebound(to: integer_t.self, capacity: Int(count)) { intPtr in
                task_info(mach_task_self_, task_flavor_t(MACH_TASK_BASIC_INFO), intPtr, &count)
            }
        }
        
        if kerr == KERN_SUCCESS {
            return Double(info.resident_size) / 1024.0 / 1024.0 // Convert to MB
        } else {
            return 0.0
        }
    }
    
    private func measureNetworkLatency() async -> TimeInterval {
        guard let url = URL(string: "https://httpbin.org/delay/0") else {
            return 0.0
        }
        
        let startTime = CFAbsoluteTimeGetCurrent()
        
        do {
            let _ = try await URLSession.shared.data(from: url)
            let endTime = CFAbsoluteTimeGetCurrent()
            return endTime - startTime
        } catch {
            return 0.0
        }
    }
    
    private func checkPerformanceThresholds(_ snapshot: PerformanceSnapshot) {
        var alerts: [String] = []
        
        if snapshot.cpuUsage > cpuThreshold {
            alerts.append("High CPU usage: \(String(format: "%.1f", snapshot.cpuUsage))%")
        }
        
        if snapshot.memoryUsage > memoryThreshold {
            alerts.append("High memory usage: \(String(format: "%.1f", snapshot.memoryUsage))MB")
        }
        
        if snapshot.networkLatency > latencyThreshold {
            alerts.append("High network latency: \(String(format: "%.2f", snapshot.networkLatency))s")
        }
        
        if snapshot.batteryLevel < 0.2 && snapshot.batteryLevel > 0 {
            alerts.append("Low battery detected: \(Int(snapshot.batteryLevel * 100))%")
        }
        
        if !alerts.isEmpty {
            performanceLogger.warning("Performance alerts: \(alerts.joined(separator: ", "))")
            
            // Send to analytics or crash reporting
            sendPerformanceAlert(alerts, snapshot)
        }
    }
    
    private func sendPerformanceAlert(_ alerts: [String], _ snapshot: PerformanceSnapshot) {
        // Integration with crash reporting tools
        let alertData = [
            "alerts": alerts,
            "cpu_usage": snapshot.cpuUsage,
            "memory_usage": snapshot.memoryUsage,
            "battery_level": snapshot.batteryLevel,
            "network_latency": snapshot.networkLatency,
            "timestamp": snapshot.timestamp.timeIntervalSince1970
        ] as [String: Any]
        
        // Send to your analytics service
        AnalyticsManager.shared.track("performance_alert", properties: alertData)
    }
    
    private func setupNotifications() {
        // Monitor app lifecycle
        NotificationCenter.default.addObserver(
            forName: UIApplication.didBecomeActiveNotification,
            object: nil,
            queue: .main
        ) { _ in
            self.startMonitoring()
        }
        
        NotificationCenter.default.addObserver(
            forName: UIApplication.didEnterBackgroundNotification,
            object: nil,
            queue: .main
        ) { _ in
            self.stopMonitoring()
        }
        
        // Enable battery monitoring
        UIDevice.current.isBatteryMonitoringEnabled = true
    }
    
    // Generate performance report
    func generatePerformanceReport() -> String {
        guard !performanceHistory.isEmpty else {
            return "No performance data available"
        }
        
        let avgCPU = performanceHistory.map { $0.cpuUsage }.reduce(0, +) / Double(performanceHistory.count)
        let avgMemory = performanceHistory.map { $0.memoryUsage }.reduce(0, +) / Double(performanceHistory.count)
        let avgLatency = performanceHistory.map { $0.networkLatency }.reduce(0, +) / Double(performanceHistory.count)
        
        return """
        Performance Report:
        - Average CPU Usage: \(String(format: "%.1f", avgCPU))%
        - Average Memory Usage: \(String(format: "%.1f", avgMemory))MB
        - Average Network Latency: \(String(format: "%.2f", avgLatency))s
        - Data Points: \(performanceHistory.count)
        """
    }
}