use a log file for daemon

Author: ethanndickson

Coder-Desktop/Coder-Desktop/Preview Content/PreviewFileSync.swift

@@ -2,12 +2,12 @@ import VPNLib
 
 @MainActor
 final class PreviewFileSync: FileSyncDaemon {
+    var logFile: URL = .init(filePath: "~/log.txt")!
+
     var sessionState: [VPNLib.FileSyncSession] = []
 
     var state: DaemonState = .running
 
-    var recentLogs: [String] = []
-
     init() {}
 
     func refreshSessions() async {}

Coder-Desktop/Coder-Desktop/Views/FileSync/FileSyncConfig.swift

@@ -86,10 +86,12 @@ struct FileSyncConfig<VPN: VPNService, FS: FileSyncDaemon>: View {
                     dontRetry = true
                 }
             } message: {
-                // You can't have styled text in alert messages
                 Text("""
-                File sync daemon failed: \(fileSync.state.description)\n\n\(fileSync.recentLogs.joined(separator: "\n"))
-                """)
+                File sync daemon failed. The daemon log file at\n\(fileSync.logFile.path)\nhas been opened.
+                """).onAppear {
+                    // Open the log file in the default editor
+                    NSWorkspace.shared.open(fileSync.logFile)
+                }
             }.task {
                 // When the Window is visible, poll for session updates every
                 // two seconds.

Coder-Desktop/Coder-DesktopTests/Util.swift

@@ -29,12 +29,12 @@ class MockVPNService: VPNService, ObservableObject {
 
 @MainActor
 class MockFileSyncDaemon: FileSyncDaemon {
+    var logFile: URL = .init(filePath: "~/log.txt")
+
     var sessionState: [VPNLib.FileSyncSession] = []
 
     func refreshSessions() async {}
 
-    var recentLogs: [String] = []
-
     func deleteSessions(ids _: [String]) async throws(VPNLib.DaemonError) {}
 
     var state: VPNLib.DaemonState = .running

Coder-Desktop/VPNLib/FileSync/FileSyncDaemon.swift

@@ -10,7 +10,7 @@ import SwiftUI
 public protocol FileSyncDaemon: ObservableObject {
     var state: DaemonState { get }
     var sessionState: [FileSyncSession] { get }
-    var recentLogs: [String] { get }
+    var logFile: URL { get }
     func tryStart() async
     func stop() async
     func refreshSessions() async
@@ -39,15 +39,13 @@ public class MutagenDaemon: FileSyncDaemon {
 
     @Published public var sessionState: [FileSyncSession] = []
 
-    // We store the last N log lines to show in the UI if the daemon crashes
-    private var logBuffer: RingBuffer<String>
-    public var recentLogs: [String] { logBuffer.elements }
-
     private var mutagenProcess: Subprocess?
     private let mutagenPath: URL!
     private let mutagenDataDirectory: URL
     private let mutagenDaemonSocket: URL
 
+    public let logFile: URL
+
     // Managing sync sessions could take a while, especially with prompting
     let sessionMgmtReqTimeout: TimeAmount = .seconds(15)
 
@@ -64,13 +62,12 @@ public class MutagenDaemon: FileSyncDaemon {
                 mutagenDataDirectory: URL = FileManager.default.urls(
                     for: .applicationSupportDirectory,
                     in: .userDomainMask
-                ).first!.appending(path: "Coder Desktop").appending(path: "Mutagen"),
-                logBufferCapacity: Int = 10)
+                ).first!.appending(path: "Coder Desktop").appending(path: "Mutagen"))
     {
-        logBuffer = .init(capacity: logBufferCapacity)
         self.mutagenPath = mutagenPath
         self.mutagenDataDirectory = mutagenDataDirectory
         mutagenDaemonSocket = mutagenDataDirectory.appending(path: "daemon").appending(path: "daemon.sock")
+        logFile = mutagenDataDirectory.appending(path: "daemon.log")
         // It shouldn't be fatal if the app was built without Mutagen embedded,
         // but file sync will be unavailable.
         if mutagenPath == nil {
@@ -113,34 +110,23 @@ public class MutagenDaemon: FileSyncDaemon {
 
         // Creating the same process twice from Swift will crash the MainActor,
         // so we need to wait for an earlier process to die
-        if let waitForExit {
-            await waitForExit()
-            // We *need* to be sure the process is dead or the app ends up in an
-            // unrecoverable state
-            try? await Task.sleep(for: .seconds(1))
-        }
+        await waitForExit?()
 
         await transition.wait()
         defer { transition.signal() }
         logger.info("starting mutagen daemon")
 
         mutagenProcess = createMutagenProcess()
-        // swiftlint:disable:next large_tuple
-        let (standardOutput, standardError, waitForExit): (Pipe.AsyncBytes, Pipe.AsyncBytes, @Sendable () async -> Void)
+        let (standardError, waitForExit): (Pipe.AsyncBytes, @Sendable () async -> Void)
         do {
-            (standardOutput, standardError, waitForExit) = try mutagenProcess!.run()
+            (_, standardError, waitForExit) = try mutagenProcess!.run()
         } catch {
             throw .daemonStartFailure(error)
         }
         self.waitForExit = waitForExit
 
         Task {
-            await streamHandler(io: standardOutput)
-            logger.info("standard output stream closed")
-        }
-
-        Task {
-            await streamHandler(io: standardError)
+            await handleDaemonLogs(io: standardError)
             logger.info("standard error stream closed")
         }
 
@@ -283,11 +269,30 @@ public class MutagenDaemon: FileSyncDaemon {
         }
     }
 
-    private func streamHandler(io: Pipe.AsyncBytes) async {
+    private func handleDaemonLogs(io: Pipe.AsyncBytes) async {
+        if !FileManager.default.fileExists(atPath: logFile.path) {
+            guard FileManager.default.createFile(atPath: logFile.path, contents: nil) else {
+                logger.error("Failed to create log file")
+                return
+            }
+        }
+
+        guard let fileHandle = try? FileHandle(forWritingTo: logFile) else {
+            logger.error("Failed to open log file for writing")
+            return
+        }
+
         for await line in io.lines {
             logger.info("\(line, privacy: .public)")
-            logBuffer.append(line)
+
+            do {
+                try fileHandle.write(contentsOf: Data("\(line)\n".utf8))
+            } catch {
+                logger.error("Failed to write to daemon log file: \(error)")
+            }
         }
+
+        try? fileHandle.close()
     }
 }
 

Coder-Desktop/VPNLib/Util.swift

@@ -29,39 +29,3 @@ public func makeNSError(suffix: String, code: Int = -1, desc: String) -> NSError
         userInfo: [NSLocalizedDescriptionKey: desc]
     )
 }
-
-// Insertion-only RingBuffer for buffering the last `capacity` elements,
-// and retrieving them in insertion order.
-public struct RingBuffer<T> {
-    private var buffer: [T?]
-    private var start = 0
-    private var size = 0
-
-    public init(capacity: Int) {
-        buffer = Array(repeating: nil, count: capacity)
-    }
-
-    public mutating func append(_ element: T) {
-        let writeIndex = (start + size) % buffer.count
-        buffer[writeIndex] = element
-
-        if size < buffer.count {
-            size += 1
-        } else {
-            start = (start + 1) % buffer.count
-        }
-    }
-
-    public var elements: [T] {
-        var result = [T]()
-        result.reserveCapacity(size)
-        for i in 0 ..< size {
-            let index = (start + i) % buffer.count
-            if let element = buffer[index] {
-                result.append(element)
-            }
-        }
-
-        return result
-    }
-}