RadrootsAppleLoggerTelemetry.swift (5986B)
1 import Foundation 2 import OSLog 3 4 public struct RadrootsAppleTelemetryLogRecord: Sendable, Equatable { 5 public let subsystem: String 6 public let category: String 7 public let level: RadrootsTelemetryLevel 8 public let renderedMessage: String 9 10 public init( 11 subsystem: String, 12 category: String, 13 level: RadrootsTelemetryLevel, 14 renderedMessage: String 15 ) { 16 self.subsystem = subsystem 17 self.category = category 18 self.level = level 19 self.renderedMessage = renderedMessage 20 } 21 } 22 23 public struct RadrootsAppleLoggerTelemetryAdapters: Sendable { 24 public let emit: @Sendable (RadrootsAppleTelemetryLogRecord) -> Void 25 26 public init(emit: @escaping @Sendable (RadrootsAppleTelemetryLogRecord) -> Void) { 27 self.emit = emit 28 } 29 30 public static let live = Self { record in 31 let logger = Logger(subsystem: record.subsystem, category: record.category) 32 logger.log(level: record.osLogType, "\(record.renderedMessage, privacy: .public)") 33 } 34 } 35 36 public final class RadrootsAppleLoggerTelemetry: RadrootsTelemetry, Sendable { 37 private let subsystem: String 38 private let adapters: RadrootsAppleLoggerTelemetryAdapters 39 private let redactionPolicy: RadrootsTelemetryRedactionPolicy 40 private let maximumRenderedMessageLength: Int 41 42 public init( 43 subsystem: String, 44 adapters: RadrootsAppleLoggerTelemetryAdapters = .live, 45 redactionPolicy: RadrootsTelemetryRedactionPolicy = .default, 46 maximumRenderedMessageLength: Int = 1000 47 ) { 48 self.subsystem = Self.normalizedSubsystem(subsystem) 49 self.adapters = adapters 50 self.redactionPolicy = redactionPolicy 51 self.maximumRenderedMessageLength = max(160, maximumRenderedMessageLength) 52 } 53 54 public func record(_ event: RadrootsTelemetryEvent) async { 55 let redactedEvent = redactionPolicy.redacted(event) 56 let renderedMessage = Self.renderedMessage( 57 for: redactedEvent, 58 maximumLength: maximumRenderedMessageLength 59 ) 60 adapters.emit( 61 RadrootsAppleTelemetryLogRecord( 62 subsystem: subsystem, 63 category: Self.normalizedCategory(redactedEvent.category), 64 level: redactedEvent.level, 65 renderedMessage: renderedMessage 66 ) 67 ) 68 } 69 70 public static func normalizedSubsystem(_ value: String) -> String { 71 normalizedLogIdentifier( 72 value, 73 fallback: "org.radroots.apple_kit", 74 maximumLength: 120 75 ) 76 } 77 78 public static func normalizedCategory(_ value: String) -> String { 79 normalizedLogIdentifier( 80 value, 81 fallback: "app", 82 maximumLength: 80 83 ) 84 } 85 86 public static func renderedMessage( 87 for event: RadrootsTelemetryEvent, 88 maximumLength: Int = 1000 89 ) -> String { 90 guard let milliseconds = RadrootsAppleTimeConversion.unixMilliseconds(event.occurredAt) 91 else { 92 return "{\"event\":\"\(event.name)\",\"level\":\"\(event.level.rawValue)\"}" 93 } 94 let payload = RadrootsAppleTelemetryPayload( 95 category: event.category, 96 event: event.name, 97 fields: Dictionary( 98 uniqueKeysWithValues: event.fields.map { field in 99 (field.key, field.value.renderedValue) 100 }), 101 level: event.level.rawValue, 102 message: event.message, 103 occurredAtUnixMilliseconds: milliseconds 104 ) 105 let rendered: String 106 do { 107 let encoder = JSONEncoder() 108 encoder.outputFormatting = [.sortedKeys] 109 let data = try encoder.encode(payload) 110 rendered = String(decoding: data, as: UTF8.self) 111 } catch { 112 rendered = "{\"event\":\"\(event.name)\",\"level\":\"\(event.level.rawValue)\"}" 113 } 114 let boundedLength = max(160, maximumLength) 115 guard rendered.count > boundedLength else { 116 return rendered 117 } 118 return String(rendered.prefix(boundedLength)) 119 } 120 121 private static func normalizedLogIdentifier( 122 _ value: String, 123 fallback: String, 124 maximumLength: Int 125 ) -> String { 126 let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines) 127 guard !trimmed.isEmpty else { 128 return fallback 129 } 130 var normalized = "" 131 for scalar in trimmed.unicodeScalars { 132 if CharacterSet.alphanumerics.contains(scalar) || scalar == "." || scalar == "_" 133 || scalar == "-" 134 { 135 normalized.append(String(scalar)) 136 } else { 137 normalized.append("_") 138 } 139 } 140 let collapsed = normalized.replacingOccurrences( 141 of: "_+", 142 with: "_", 143 options: .regularExpression 144 ) 145 let trimmedSeparators = collapsed.trimmingCharacters(in: CharacterSet(charactersIn: "._-")) 146 guard !trimmedSeparators.isEmpty else { 147 return fallback 148 } 149 return String(trimmedSeparators.prefix(maximumLength)) 150 } 151 } 152 153 private struct RadrootsAppleTelemetryPayload: Encodable { 154 let category: String 155 let event: String 156 let fields: [String: String] 157 let level: String 158 let message: String? 159 let occurredAtUnixMilliseconds: Int64 160 161 enum CodingKeys: String, CodingKey { 162 case category 163 case event 164 case fields 165 case level 166 case message 167 case occurredAtUnixMilliseconds = "occurred_at_unix_ms" 168 } 169 } 170 171 extension RadrootsAppleTelemetryLogRecord { 172 var osLogType: OSLogType { 173 switch level { 174 case .trace, .debug: 175 .debug 176 case .info: 177 .info 178 case .notice, .warning: 179 .default 180 case .error: 181 .error 182 case .critical: 183 .fault 184 } 185 } 186 }