Découvrez le nouveau MetricKit

4:59 - Receive metrics from MetricKit

// Receive metrics from MetricKit

import MetricKit

let manager = MetricManager()

for await report in manager.metricReports {
    processReport(report)
}

5:25 - Send your metrics to the server

// Send your metrics to the server

import MetricKit

for await report in manager.metricReports {
    let jsonData = try JSONEncoder().encode(report)
    sendToServer(jsonData)
}

5:44 - Access your performance metrics

// Access your performance metrics

import MetricKit

for await report in manager.metricReports {
    let intervalEntries = report.intervalEntries
    let fullDayEntry = intervalEntries.fullDayEntry
    
    for entry in intervalEntries {
        let memoryMetrics = entry.values.filter { $0.metricGroup == .memory }
        
        for metric in memoryMetrics {
            switch metric {
            case .peakMemory(let peak):
                processPeakMemory(peak)
            default: break
            }
        }
    }
}

8:59 - Receive diagnostics

// Receive diagnostics

import MetricKit

let manager = MetricManager()

for await report in manager.diagnosticReports {
    processReport(report)
}

9:14 - Send your diagnostic data to the server

// Send your diagnostic data to the server

import MetricKit

for await report in manager.diagnosticReports {
    let jsonData = try JSONEncoder().encode(report)
    sendToServer(jsonData)
}

9:39 - Access your diagnostic data

// Access your diagnostic data

import MetricKit

for await report in manager.diagnosticReports {
    switch report.result {
    case .crash(let crash):
        let backtrace = crash.callStackTree
        let reason = crash.terminationReason
        let category = crash.terminationCategory
        processCrash(backtrace: backtrace, reason: reason, category: category)
    case .hang(let hang):
        processHangDiagnostic(hang)
    default: break
    }
}

13:57 - Receive MetricKit data with states

// Receive MetricKit data with states

import MetricKit
import StateReporting

let domain = StateReportingDomain("com.metrickitsample.tabs")
let manager = MetricManager(enabledStateReportingDomains: [domain])


// Report transitions throughout the app

let reporter = StateReporter.reporter(for: domain.rawValue)
reporter.reportTransition(to: "Reports")

14:21 - Define custom structured types

// Define custom structured types

import StateReporting

@ReportableMetadata
struct ViewConfiguration {
    let listSize: String
    let isSorted: Bool
}

let reporter = StateReporter.reporter(
    for: domain.rawValue,
    stableMetadata: ViewConfiguration.self
)

reporter.reportTransition(
    to: "Reports",
    stableMetadata: ViewConfiguration(listSize: "large", isSorted: false)
)

15:29 - Send encoded metric reports to the server

// Send encoded metric reports to the server

import MetricKit

for await report in manager.metricReports {
    let encoder = JSONEncoder()
    
    let formatKey = MetricReport.encodingFormatKey
    encoder.userInfo[formatKey] = MetricReport.EncodingFormat.byStateReportingDomain
    
    let jsonData = try encoder.encode(report)
    sendToServer(jsonData)
}