logging: test that log lines accumulate instead of overwriting

148cdf7 replaced seekToEndOfFile() + write(data) with a POSIX append and
dropped the seek. FileHandle(forWritingTo:) opens at offset zero and write(2)
writes at the current offset, so every line overwrote from the start and the
file was left holding only the most recent one. 0b09c54 fixed it with an
lseek to SEEK_END under the append lock.

Nothing would have caught that. It compiles cleanly, and the round-trip check
used to justify the original change opened one descriptor, wrote once and read
back -- on an empty file offset zero already is the end, so a single write
passes with or without the seek. The bug only appears across repeated
open/write/close cycles, which is the actual usage pattern.

So test that pattern: write five lines through the logger and assert all five
survive. Verified it fails on the regression -- removing the lseek turns it from
passing in 0.022s into failing after the full poll deadline.

Testing it needs a writable directory, so the log location becomes an init
parameter with a convenience init() preserving FilePath.logsDirectory for
production. Applied to both platforms to keep the two files in step, though only
macOS has a test target to run it.

Verified locally on both: make macos-unit-tests reports TEST SUCCEEDED, and make
ios-compile-check builds Runner.app.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: Adam Fisk

ios/Shared/Logger.swift

@@ -37,9 +37,17 @@ class LanternLogger {
   /// Bytes appended since the last size check, so we don't stat on every line.
   private var sinceCheck = 0
 
-  init() {
+  convenience init() {
+    self.init(logsDirectory: FilePath.logsDirectory)
+  }
+
+  /// Designated initializer. The directory is a parameter so tests can drive
+  /// the real write path against a temporary location -- appends only reveal
+  /// themselves across repeated open/write/close cycles, which is exactly what
+  /// a unit test can reproduce and a compile check cannot.
+  init(logsDirectory: URL) {
     // Ensure Logs directory exists
-    let logsDir = FilePath.logsDirectory
+    let logsDir = logsDirectory
     if !FileManager.default.fileExists(atPath: logsDir.path) {
       try? FileManager.default.createDirectory(at: logsDir, withIntermediateDirectories: true)
     }

macos/RunnerTests/RunnerTests.swift

@@ -7,6 +7,48 @@ import XCTest
 
 final class RunnerTests: XCTestCase {
 
+  /// Every log line must survive. FileHandle(forWritingTo:) opens at offset 0,
+  /// so a write that does not seek to the end first overwrites from the start
+  /// and the file ends up holding only the most recent line. That regression
+  /// shipped briefly and compiled cleanly -- it is invisible to a build and to
+  /// any test that writes exactly once, because on an empty file offset 0 is
+  /// already the end. It only shows up across repeated open/write/close cycles,
+  /// which is the real usage pattern, so drive several writes and assert that
+  /// all of them are still there.
+  func testLogLinesAccumulateAcrossWrites() throws {
+    let directory = URL(fileURLWithPath: NSTemporaryDirectory())
+      .appendingPathComponent("lantern-logger-\(UUID().uuidString)")
+    try FileManager.default.createDirectory(
+      at: directory, withIntermediateDirectories: true)
+    defer { try? FileManager.default.removeItem(at: directory) }
+
+    let logger = LanternLogger(logsDirectory: directory)
+    let lines = (1...5).map { "accumulate-marker-\($0)" }
+    for line in lines {
+      logger.log(line)
+    }
+
+    // Writes are dispatched asynchronously onto the logger's serial queue, so
+    // poll rather than assuming they have landed.
+    let logFile = directory.appendingPathComponent("lantern_macos.log")
+    let deadline = Date().addingTimeInterval(10)
+    var contents = ""
+    while Date() < deadline {
+      contents = (try? String(contentsOf: logFile, encoding: .utf8)) ?? ""
+      if lines.allSatisfy({ contents.contains($0) }) {
+        break
+      }
+      usleep(20_000)
+    }
+
+    for line in lines {
+      XCTAssertTrue(
+        contents.contains(line),
+        "\(line) is missing, so appends are overwriting instead of appending. "
+          + "File held: \(contents.debugDescription)")
+    }
+  }
+
   private func assertVPNManagerError(
     _ expected: VPNManagerError,
     _ operation: () throws -> Void

macos/Shared/Logger.swift

@@ -41,8 +41,16 @@ class LanternLogger {
   /// Bytes appended since the last size check, so we don't stat on every line.
   private var sinceCheck = 0
 
-  init() {
-    let logsDir = FilePath.logsDirectory
+  convenience init() {
+    self.init(logsDirectory: FilePath.logsDirectory)
+  }
+
+  /// Designated initializer. The directory is a parameter so tests can drive
+  /// the real write path against a temporary location -- appends only reveal
+  /// themselves across repeated open/write/close cycles, which is exactly what
+  /// a unit test can reproduce and a compile check cannot.
+  init(logsDirectory: URL) {
+    let logsDir = logsDirectory
     if !FileManager.default.fileExists(atPath: logsDir.path) {
       try? FileManager.default.createDirectory(at: logsDir, withIntermediateDirectories: true)
     }