fix(logging): keep queued lines when the sink is reinstalled

A busy lock puts the lines back on the state install is about to
replace, and that retry then sees a different state and returns. Carry
the lines onto the new state and schedule the retry there.

Author: TheGreatAxios

src/logging/sink.test.ts

@@ -408,6 +408,33 @@ describe("installFileLogSink", () => {
     }
   });
 
+  test("a reinstall while the log lock is held keeps queued lines", async () => {
+    const { dir, file } = tempLogFile();
+    const holder = liveLockHolder();
+    try {
+      installFileLogSink(file, { maxBytes: 10_000 });
+      fs.writeFileSync(`${file}.lock`, `${holder.pid}:held`);
+      getLogger(["logging", "reinstall"]).info("keep-me");
+      installFileLogSink(file, { maxBytes: 10_000 });
+      const before = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+      const rotatedBefore = fs.existsSync(`${file}.1`)
+        ? fs.readFileSync(`${file}.1`, "utf8")
+        : "";
+      expect(`${before}${rotatedBefore}`).not.toContain("keep-me");
+      fs.rmSync(`${file}.lock`);
+      await Promise.resolve();
+      flushFileLogSinkSync();
+      const active = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+      const rotated = fs.existsSync(`${file}.1`)
+        ? fs.readFileSync(`${file}.1`, "utf8")
+        : "";
+      expect(`${active}${rotated}`).toContain("keep-me");
+    } finally {
+      holder.kill();
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   test("a failed rotation keeps already-written records in the active file", () => {
     const { dir, file } = tempLogFile();
     try {

src/logging/sink.ts

@@ -500,20 +500,30 @@ export function installFileLogSink(
   options?: FileLogSinkOptions,
 ): void {
   // A later install must not drop lines still queued for the previous path.
+  // A busy lock puts them back and queues a retry on that state; replacing
+  // state makes the retry return. Carry the lines onto the state that will
+  // own them and schedule that retry.
   flushFileLogSinkSync();
+  const carried = state === null ? [] : state.buffer;
+  if (state !== null) {
+    state.buffer = [];
+    state.drainScheduled = false;
+  }
   fs.mkdirSync(dirname(path), { recursive: true });
   const requested = options?.maxBytes;
   const initial = statActive(path);
-  state = {
+  const next: FileSinkState = {
     path,
     maxBytes:
       requested !== undefined && requested > 0 ? requested : LOG_MAX_BYTES,
-    buffer: [],
+    buffer: [...carried],
     size: initial.size,
     dev: initial.dev,
     ino: initial.ino,
     drainScheduled: false,
   };
+  state = next;
+  scheduleDrain(next);
   if (!exitHookInstalled) {
     exitHookInstalled = true;
     process.on("exit", flushFileLogSinkSync);