feat(logging): rotate diagnostic logs by size and time

MenuBarItemService/Listener.swift

@@ -39,8 +39,13 @@ final class Listener: @unchecked Sendable {
                 diagLog.debug("Listener received start request")
                 return .start
             case let .configureLogging(filePath):
-                DiagnosticLogger.shared.attachToFile(at: URL(fileURLWithPath: filePath))
-                diagLog.debug("Listener attached diagnostic logging to \(filePath)")
+                if let filePath {
+                    DiagnosticLogger.shared.attachToFile(at: URL(fileURLWithPath: filePath))
+                    diagLog.debug("Listener attached diagnostic logging to \(filePath)")
+                } else {
+                    DiagnosticLogger.shared.isEnabled = false
+                    diagLog.debug("Listener disabled diagnostic logging")
+                }
                 return .configureLogging
             case let .sourcePID(window):
                 diagLog.debug("Listener: sourcePID request for windowID=\(window.windowID) title=\(window.title ?? "nil")")

Shared/Services/MenuBarItemService.swift

@@ -15,7 +15,10 @@ enum MenuBarItemService {
 extension MenuBarItemService {
     enum Request: Codable {
         case start
-        case configureLogging(filePath: String)
+        /// Points the service's diagnostic logger at `filePath`, or disables it
+        /// when `nil`. Sent at startup, on each rotation, and when the user
+        /// toggles diagnostic logging.
+        case configureLogging(filePath: String?)
         case sourcePID(WindowInfo)
         case sourcePIDs([WindowInfo])
     }

Thaw/Main/AppState.swift

@@ -82,6 +82,13 @@ final class AppState: ObservableObject {
     let diagLog = DiagLog(category: "AppState")
 
     private lazy var setupTask = Task { @MainActor in
+        // When the main app rotates to a new log file, hand its path to the XPC
+        // service so both processes keep appending to the same segment. Set
+        // before logging is enabled so the first rotation is handled.
+        DiagnosticLogger.shared.onRotate = { url in
+            Task { await MenuBarItemService.Connection.shared.configureLogging(to: url.path) }
+        }
+
         #if DEBUG
             // Debug builds always have diagnostic logging on so logs are
             // captured during development without depending on the toggle.

Thaw/MenuBar/MenuBarItems/MenuBarItemServiceConnection.swift

@@ -27,6 +27,19 @@ extension MenuBarItemService {
         /// The connection's diagnostic logger.
         private let diagLog: DiagLog
 
+        /// Tracks the diagnostic log path last pushed to the service so a
+        /// failed push can be retried on the next request.
+        private struct LoggingState {
+            var hasDesired = false
+            var desiredPath: String?
+            var dirty = false
+            /// Bumped on every new desired state so a stale, out-of-order
+            /// response cannot clear a newer pending retry.
+            var generation = 0
+        }
+
+        private let loggingState = OSAllocatedUnfairLock(initialState: LoggingState())
+
         /// Creates a new connection.
         private init() {
             let queue = DispatchQueue.targetingGlobal(
@@ -44,22 +57,16 @@ extension MenuBarItemService {
         func start() async {
             diagLog.debug("Starting MenuBarItemService connection")
 
-            // If the main app already has a diagnostic log file open,
-            // hand its path to the XPC service so both processes append
-            // to the same file. Sent before the start request so the
-            // XPC service is logging to disk by the time it handles any
-            // subsequent traffic. When file logging is off in the main
-            // app currentLogFile is nil and the XPC service simply logs
-            // to OSLog only, matching the prior release-build behaviour.
-            if let logFile = DiagnosticLogger.shared.currentLogFile {
-                let response = await session.sendAsync(request: .configureLogging(filePath: logFile.path))
-                if response == nil {
-                    diagLog.error("configureLogging request returned nil")
-                } else if case .configureLogging = response {
-                    // success
-                } else {
-                    diagLog.error("configureLogging request returned invalid response \(String(describing: response))")
-                }
+            // Hand the service the diagnostic log path so both processes append
+            // to the same file. Sent before the start request so the XPC service
+            // is logging to disk by the time it handles any subsequent traffic.
+            // After the first push, `loggingState` holds the desired state
+            // (path, or nil to disable) and is replayed on reconnect.
+            let pending = loggingState.withLock { ($0.hasDesired, $0.desiredPath, $0.generation) }
+            if pending.0 {
+                await sendConfigureLogging(pending.1, generation: pending.2)
+            } else if let logFile = DiagnosticLogger.shared.currentLogFile {
+                await configureLogging(to: logFile.path)
             }
 
             let response = await session.sendAsync(request: .start)
@@ -74,6 +81,50 @@ extension MenuBarItemService {
             }
         }
 
+        /// Points the service's diagnostic logger at `filePath`, or disables it
+        /// when `nil`. Called at startup, on each log rotation, and when the
+        /// user toggles diagnostic logging.
+        func configureLogging(to filePath: String?) async {
+            let generation = loggingState.withLock { state -> Int in
+                state.hasDesired = true
+                state.desiredPath = filePath
+                state.generation += 1
+                return state.generation
+            }
+            await sendConfigureLogging(filePath, generation: generation)
+        }
+
+        /// Sends a single configureLogging request and records whether it needs
+        /// to be retried. Only the latest send (matching `generation`) may
+        /// update the dirty flag, so a stale response cannot clear a newer retry.
+        private func sendConfigureLogging(_ filePath: String?, generation: Int) async {
+            let response = await session.sendAsync(request: .configureLogging(filePath: filePath))
+            loggingState.withLock { state in
+                guard state.generation == generation else { return }
+                if case .configureLogging = response {
+                    state.dirty = false
+                } else {
+                    state.dirty = true
+                }
+            }
+            if response == nil {
+                diagLog.error("configureLogging request returned nil")
+            } else if case .configureLogging = response {
+                // success
+            } else {
+                diagLog.error("configureLogging request returned invalid response \(String(describing: response))")
+            }
+        }
+
+        /// Resends the desired logging configuration if a previous push failed.
+        private func resendLoggingIfDirty() async {
+            let pending = loggingState.withLock { state -> (Bool, String?, Int) in
+                (state.dirty, state.desiredPath, state.generation)
+            }
+            guard pending.0 else { return }
+            await sendConfigureLogging(pending.1, generation: pending.2)
+        }
+
         /// Returns the source process identifier for the given window.
         func sourcePID(for window: WindowInfo) async -> pid_t? {
             let response = await session.sendAsync(request: .sourcePID(window))
@@ -93,6 +144,8 @@ extension MenuBarItemService {
         /// single batch XPC request, avoiding concurrent thread explosion
         /// in the XPC service.
         func sourcePIDs(for windows: [WindowInfo]) async -> [pid_t?] {
+            // Opportunistically retry a failed logging push on this frequent path.
+            await resendLoggingIfDirty()
             let response = await session.sendAsync(request: .sourcePIDs(windows))
             guard let response else {
                 diagLog.error("Source PIDs batch request returned nil")

Thaw/Settings/Models/AdvancedSettings.swift

@@ -9,6 +9,38 @@
 import Combine
 import SwiftUI
 
+// MARK: - LogRotationInterval
+
+/// How often diagnostic logs are rotated on a time basis, in addition to the
+/// size limit.
+enum LogRotationInterval: String, CaseIterable, Identifiable {
+    case off
+    case hourly
+    case daily
+
+    var id: String {
+        rawValue
+    }
+
+    /// The interval in seconds, or `0` when time-based rotation is off.
+    var seconds: TimeInterval {
+        switch self {
+        case .off: 0
+        case .hourly: 3600
+        case .daily: 86400
+        }
+    }
+
+    /// A human-readable title for the picker.
+    var title: String {
+        switch self {
+        case .off: String(localized: "Off")
+        case .hourly: String(localized: "Hourly")
+        case .daily: String(localized: "Daily")
+        }
+    }
+}
+
 // MARK: - AdvancedSettings
 
 /// Model for the app's Advanced settings.
@@ -55,6 +87,16 @@ final class AdvancedSettings: ObservableObject {
     /// A Boolean value that indicates whether diagnostic logging to file is enabled.
     @Published var enableDiagnosticLogging = Defaults.DefaultValue.enableDiagnosticLogging
 
+    /// The maximum size, in megabytes, a diagnostic log file may reach before
+    /// it is rotated.
+    @Published var diagnosticLogMaxSizeMB = Defaults.DefaultValue.diagnosticLogMaxSizeMB
+
+    /// The number of days to keep diagnostic log files before deleting them.
+    @Published var diagnosticLogRetentionDays = Defaults.DefaultValue.diagnosticLogRetentionDays
+
+    /// How often diagnostic logs are rotated on a time basis.
+    @Published var diagnosticLogRotationInterval = Defaults.DefaultValue.diagnosticLogRotationInterval
+
     /// A Boolean value that indicates whether to use LCS sorting instead of
     /// full sorting on notched displays.
     @Published var useLCSSortingOnNotchedDisplays = Defaults.DefaultValue.useLCSSortingOnNotchedDisplays
@@ -107,6 +149,13 @@ final class AdvancedSettings: ObservableObject {
         Defaults.ifPresent(key: .showMenuBarTooltips, assign: &showMenuBarTooltips)
         Defaults.ifPresent(key: .iconRefreshInterval, assign: &iconRefreshInterval)
         Defaults.ifPresent(key: .enableDiagnosticLogging, assign: &enableDiagnosticLogging)
+        Defaults.ifPresent(key: .diagnosticLogMaxSizeMB, assign: &diagnosticLogMaxSizeMB)
+        Defaults.ifPresent(key: .diagnosticLogRetentionDays, assign: &diagnosticLogRetentionDays)
+        Defaults.ifPresent(key: .diagnosticLogRotationInterval) { (rawValue: String) in
+            if let interval = LogRotationInterval(rawValue: rawValue) {
+                diagnosticLogRotationInterval = interval
+            }
+        }
         Defaults.ifPresent(key: .useLCSSortingOnNotchedDisplays, assign: &useLCSSortingOnNotchedDisplays)
         Defaults.ifPresent(key: .enableMenuBarItemOverflow, assign: &enableMenuBarItemOverflow)
         Defaults.ifPresent(key: .searchIncludeVisible, assign: &searchIncludeVisible)
@@ -170,9 +219,37 @@ final class AdvancedSettings: ObservableObject {
                 #else
                     DiagnosticLogger.shared.isEnabled = enabled
                 #endif
+                // Push the new state to the XPC service so toggling after launch
+                // takes effect there too (nil disables its file logging).
+                let path = DiagnosticLogger.shared.currentLogFile?.path
+                Task { await MenuBarItemService.Connection.shared.configureLogging(to: path) }
             },
             in: &c
         )
+        $diagnosticLogMaxSizeMB.persistToDefaults(key: .diagnosticLogMaxSizeMB, in: &c)
+        $diagnosticLogRetentionDays.persistToDefaults(key: .diagnosticLogRetentionDays, in: &c)
+        $diagnosticLogRotationInterval.persistToDefaults(
+            key: .diagnosticLogRotationInterval,
+            transform: \.rawValue,
+            in: &c
+        )
+        // Apply the rotation policy to the logger whenever any of its inputs
+        // change. CombineLatest3 also emits once on subscription, seeding the
+        // initial policy.
+        Publishers.CombineLatest3(
+            $diagnosticLogMaxSizeMB,
+            $diagnosticLogRetentionDays,
+            $diagnosticLogRotationInterval
+        )
+        .receive(on: DispatchQueue.main)
+        .sink { maxSizeMB, retentionDays, interval in
+            var policy = DiagnosticLogger.RotationPolicy()
+            policy.maxFileSizeBytes = UInt64(max(0, maxSizeMB)) * 1024 * 1024
+            policy.retentionDays = max(1, retentionDays)
+            policy.rotationInterval = interval.seconds
+            DiagnosticLogger.shared.setRotationPolicy(policy)
+        }
+        .store(in: &c)
         $useLCSSortingOnNotchedDisplays.persistToDefaults(key: .useLCSSortingOnNotchedDisplays, in: &c)
         $enableMenuBarItemOverflow.persistToDefaults(key: .enableMenuBarItemOverflow, in: &c)
         $searchSectionOrder.persistToDefaults(

Thaw/Settings/Models/Profile.swift

@@ -100,6 +100,9 @@ struct AdvancedSettingsSnapshot: Codable {
     var showMenuBarTooltips: Bool
     var iconRefreshInterval: TimeInterval
     var enableDiagnosticLogging: Bool
+    var diagnosticLogMaxSizeMB: Int
+    var diagnosticLogRetentionDays: Int
+    var diagnosticLogRotationInterval: String
     var useDoubleClickToShowAlwaysHiddenSection: Bool
     var useOptionClickToShowAlwaysHiddenSection: Bool
     var useLCSSortingOnNotchedDisplays: Bool
@@ -123,6 +126,9 @@ struct AdvancedSettingsSnapshot: Codable {
             showMenuBarTooltips: settings.showMenuBarTooltips,
             iconRefreshInterval: settings.iconRefreshInterval,
             enableDiagnosticLogging: settings.enableDiagnosticLogging,
+            diagnosticLogMaxSizeMB: settings.diagnosticLogMaxSizeMB,
+            diagnosticLogRetentionDays: settings.diagnosticLogRetentionDays,
+            diagnosticLogRotationInterval: settings.diagnosticLogRotationInterval.rawValue,
             useDoubleClickToShowAlwaysHiddenSection: settings.useDoubleClickToShowAlwaysHiddenSection,
             useOptionClickToShowAlwaysHiddenSection: settings.useOptionClickToShowAlwaysHiddenSection,
             useLCSSortingOnNotchedDisplays: settings.useLCSSortingOnNotchedDisplays,
@@ -149,6 +155,11 @@ struct AdvancedSettingsSnapshot: Codable {
         settings.showMenuBarTooltips = showMenuBarTooltips
         settings.iconRefreshInterval = iconRefreshInterval
         settings.enableDiagnosticLogging = enableDiagnosticLogging
+        settings.diagnosticLogMaxSizeMB = diagnosticLogMaxSizeMB
+        settings.diagnosticLogRetentionDays = diagnosticLogRetentionDays
+        if let interval = LogRotationInterval(rawValue: diagnosticLogRotationInterval) {
+            settings.diagnosticLogRotationInterval = interval
+        }
         settings.useDoubleClickToShowAlwaysHiddenSection = useDoubleClickToShowAlwaysHiddenSection
         settings.useOptionClickToShowAlwaysHiddenSection = useOptionClickToShowAlwaysHiddenSection
         settings.useLCSSortingOnNotchedDisplays = useLCSSortingOnNotchedDisplays
@@ -171,6 +182,9 @@ struct AdvancedSettingsSnapshot: Codable {
         case showMenuBarTooltips
         case iconRefreshInterval
         case enableDiagnosticLogging
+        case diagnosticLogMaxSizeMB
+        case diagnosticLogRetentionDays
+        case diagnosticLogRotationInterval
         case useDoubleClickToShowAlwaysHiddenSection
         case useOptionClickToShowAlwaysHiddenSection
         case useLCSSortingOnNotchedDisplays
@@ -193,6 +207,9 @@ struct AdvancedSettingsSnapshot: Codable {
         showMenuBarTooltips: Bool,
         iconRefreshInterval: TimeInterval,
         enableDiagnosticLogging: Bool,
+        diagnosticLogMaxSizeMB: Int = Defaults.DefaultValue.diagnosticLogMaxSizeMB,
+        diagnosticLogRetentionDays: Int = Defaults.DefaultValue.diagnosticLogRetentionDays,
+        diagnosticLogRotationInterval: String = Defaults.DefaultValue.diagnosticLogRotationInterval.rawValue,
         useDoubleClickToShowAlwaysHiddenSection: Bool,
         useOptionClickToShowAlwaysHiddenSection: Bool,
         useLCSSortingOnNotchedDisplays: Bool,
@@ -213,6 +230,9 @@ struct AdvancedSettingsSnapshot: Codable {
         self.showMenuBarTooltips = showMenuBarTooltips
         self.iconRefreshInterval = iconRefreshInterval
         self.enableDiagnosticLogging = enableDiagnosticLogging
+        self.diagnosticLogMaxSizeMB = diagnosticLogMaxSizeMB
+        self.diagnosticLogRetentionDays = diagnosticLogRetentionDays
+        self.diagnosticLogRotationInterval = diagnosticLogRotationInterval
         self.useDoubleClickToShowAlwaysHiddenSection = useDoubleClickToShowAlwaysHiddenSection
         self.useOptionClickToShowAlwaysHiddenSection = useOptionClickToShowAlwaysHiddenSection
         self.useLCSSortingOnNotchedDisplays = useLCSSortingOnNotchedDisplays
@@ -258,6 +278,15 @@ struct AdvancedSettingsSnapshot: Codable {
         enableDiagnosticLogging = try container.decodeIfPresent(
             Bool.self, forKey: .enableDiagnosticLogging
         ) ?? Defaults.DefaultValue.enableDiagnosticLogging
+        diagnosticLogMaxSizeMB = try container.decodeIfPresent(
+            Int.self, forKey: .diagnosticLogMaxSizeMB
+        ) ?? Defaults.DefaultValue.diagnosticLogMaxSizeMB
+        diagnosticLogRetentionDays = try container.decodeIfPresent(
+            Int.self, forKey: .diagnosticLogRetentionDays
+        ) ?? Defaults.DefaultValue.diagnosticLogRetentionDays
+        diagnosticLogRotationInterval = try container.decodeIfPresent(
+            String.self, forKey: .diagnosticLogRotationInterval
+        ) ?? Defaults.DefaultValue.diagnosticLogRotationInterval.rawValue
         useDoubleClickToShowAlwaysHiddenSection = try container.decodeIfPresent(
             Bool.self, forKey: .useDoubleClickToShowAlwaysHiddenSection
         ) ?? Defaults.DefaultValue.useDoubleClickToShowAlwaysHiddenSection
@@ -486,6 +515,9 @@ struct Profile: Codable, Identifiable {
             showMenuBarTooltips: Defaults.DefaultValue.showMenuBarTooltips,
             iconRefreshInterval: Defaults.DefaultValue.iconRefreshInterval,
             enableDiagnosticLogging: Defaults.DefaultValue.enableDiagnosticLogging,
+            diagnosticLogMaxSizeMB: Defaults.DefaultValue.diagnosticLogMaxSizeMB,
+            diagnosticLogRetentionDays: Defaults.DefaultValue.diagnosticLogRetentionDays,
+            diagnosticLogRotationInterval: Defaults.DefaultValue.diagnosticLogRotationInterval.rawValue,
             useDoubleClickToShowAlwaysHiddenSection: Defaults.DefaultValue.useDoubleClickToShowAlwaysHiddenSection,
             useOptionClickToShowAlwaysHiddenSection: Defaults.DefaultValue.useOptionClickToShowAlwaysHiddenSection,
             useLCSSortingOnNotchedDisplays: Defaults.DefaultValue.useLCSSortingOnNotchedDisplays,

Thaw/Settings/Models/SettingsResetter.swift

@@ -58,6 +58,9 @@ extension AppSettings {
         advanced.showMenuBarTooltips = Defaults.DefaultValue.showMenuBarTooltips
         advanced.iconRefreshInterval = Defaults.DefaultValue.iconRefreshInterval
         advanced.enableDiagnosticLogging = Defaults.DefaultValue.enableDiagnosticLogging
+        advanced.diagnosticLogMaxSizeMB = Defaults.DefaultValue.diagnosticLogMaxSizeMB
+        advanced.diagnosticLogRetentionDays = Defaults.DefaultValue.diagnosticLogRetentionDays
+        advanced.diagnosticLogRotationInterval = Defaults.DefaultValue.diagnosticLogRotationInterval
         advanced.searchSectionOrder = AdvancedSettings.sanitizedSearchSectionOrder(
             from: Defaults.DefaultValue.searchSectionOrder
         )