apple_kit

Apple-native services for Radroots iOS and macOS apps
git clone https://radroots.dev/git/apple_kit.git
Log | Files | Refs | README | LICENSE

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 }