@dev-anywhere/relay 0.9.1 → 0.9.2

package/dist/index.js

@@ -3,15 +3,24 @@ import {
   RELAY_VERSION,
   createRelayServer,
   parseRelayChaosFromEnv
-} from "./chunk-JLLMBFAB.js";
+} from "./chunk-RGMU7VLD.js";
 
 // ../../packages/shared/dist/logger.js
-import { lstatSync, mkdirSync, readdirSync, renameSync, statSync, symlinkSync, unlinkSync } from "fs";
+import { lstatSync, linkSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "fs";
+import { randomUUID } from "crypto";
 import { homedir } from "os";
 import { basename, join } from "path";
 import pino from "pino";
 var DEFAULT_LOG_DIR = `${homedir()}/.dev-anywhere/logs`;
 var DEFAULT_LOG_RETENTION = 50;
+var DEFAULT_LOG_RETENTION_BYTES = 256 * 1024 * 1024;
+var DEFAULT_MAX_FILE_BYTES = 16 * 1024 * 1024;
+var DEFAULT_MAX_FILES_PER_RUN = 2;
+var DEFAULT_MAX_RECORD_BYTES = 256 * 1024;
+var DEFAULT_MAX_STDOUT_BUFFER_BYTES = 1024 * 1024;
+var LOG_IO_OPERATION_TIMEOUT_MS = 5e3;
+var LOG_RUN_LEASE_SUFFIX = ".active";
+var LOG_RUN_LEASE_CANDIDATE_MARKER = `${LOG_RUN_LEASE_SUFFIX}.candidate-`;
 var PROCESS_LOG_RUN_ID = sanitizeRunId(`${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${process.pid}`);
 function sanitizeRunId(runId) {
   return runId.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -40,8 +49,137 @@ function resolveRetention(retention) {
     return DEFAULT_LOG_RETENTION;
   return Number.isFinite(retention) && retention >= 0 ? Math.floor(retention) : DEFAULT_LOG_RETENTION;
 }
-function pruneOldLogs(logDir, name, currentFilePath, retention) {
+function resolvePositiveInteger(value, fallback) {
+  return value !== void 0 && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function leasePathForLog(filePath) {
+  return `${filePath}${LOG_RUN_LEASE_SUFFIX}`;
+}
+function createLogRunLease(filePath, runId) {
+  const lease = {
+    version: 1,
+    pid: process.pid,
+    runId,
+    fileName: basename(filePath)
+  };
+  const leasePath = leasePathForLog(filePath);
+  const candidatePath = `${leasePath}.candidate-${process.pid}-${randomUUID()}`;
+  let candidateCreated = false;
+  try {
+    writeFileSync(candidatePath, `${JSON.stringify(lease)}
+`, { flag: "wx" });
+    candidateCreated = true;
+    linkSync(candidatePath, leasePath);
+  } finally {
+    if (candidateCreated) {
+      try {
+        unlinkSync(candidatePath);
+      } catch {
+      }
+    }
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+function readLogRunLease(leasePath, expectedFileName) {
+  let raw;
+  try {
+    raw = readFileSync(leasePath, "utf-8");
+  } catch (error) {
+    return error.code === "ENOENT" ? { state: "missing" } : { state: "invalid" };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    const pid = parsed.pid;
+    if (parsed.version !== 1 || !Number.isSafeInteger(pid) || typeof pid !== "number" || pid <= 0 || typeof parsed.runId !== "string" || parsed.runId.length === 0 || parsed.fileName !== expectedFileName) {
+      throw new Error("Invalid log run lease");
+    }
+    return { state: "valid", lease: parsed };
+  } catch {
+    return { state: "invalid" };
+  }
+}
+function hasLiveLogRunLease(filePath) {
+  const leasePath = leasePathForLog(filePath);
+  const result = readLogRunLease(leasePath, basename(filePath));
+  if (result.state === "missing")
+    return false;
+  if (result.state === "invalid")
+    return true;
+  if (isProcessAlive(result.lease.pid))
+    return true;
+  try {
+    unlinkSync(leasePath);
+  } catch {
+  }
+  return false;
+}
+function removeOwnedLogRunLease(filePath, runId) {
+  const leasePath = leasePathForLog(filePath);
+  const result = readLogRunLease(leasePath, basename(filePath));
+  if (result.state !== "valid" || result.lease.pid !== process.pid || result.lease.runId !== runId) {
+    return;
+  }
+  try {
+    unlinkSync(leasePath);
+  } catch {
+  }
+}
+function parseLeaseEntry(entry, name) {
+  const prefix = `${name}-`;
+  if (!entry.startsWith(prefix))
+    return null;
+  if (entry.endsWith(LOG_RUN_LEASE_SUFFIX)) {
+    const fileName2 = entry.slice(0, -LOG_RUN_LEASE_SUFFIX.length);
+    return fileName2.endsWith(".log") ? { fileName: fileName2, candidate: false } : null;
+  }
+  const markerIndex = entry.lastIndexOf(LOG_RUN_LEASE_CANDIDATE_MARKER);
+  if (markerIndex < 0 || markerIndex + LOG_RUN_LEASE_CANDIDATE_MARKER.length >= entry.length) {
+    return null;
+  }
+  const fileName = entry.slice(0, markerIndex);
+  return fileName.endsWith(".log") ? { fileName, candidate: true } : null;
+}
+function pruneOrphanedLogRunLeases(logDir, name) {
+  for (const entry of readdirSync(logDir)) {
+    const parsedEntry = parseLeaseEntry(entry, name);
+    if (!parsedEntry)
+      continue;
+    const leasePath = join(logDir, entry);
+    const result = readLogRunLease(leasePath, parsedEntry.fileName);
+    if (result.state !== "valid" || isProcessAlive(result.lease.pid))
+      continue;
+    let correspondingLogExists = false;
+    try {
+      statSync(join(logDir, parsedEntry.fileName));
+      correspondingLogExists = true;
+    } catch {
+    }
+    if (!parsedEntry.candidate && correspondingLogExists)
+      continue;
+    try {
+      unlinkSync(leasePath);
+    } catch {
+    }
+  }
+}
+function removeLogAndLease(filePath) {
+  unlinkSync(filePath);
+  try {
+    unlinkSync(leasePathForLog(filePath));
+  } catch {
+  }
+}
+function pruneOldLogs(logDir, name, currentFilePath, retention, retentionBytes) {
   const keep = resolveRetention(retention);
+  const byteBudget = resolvePositiveInteger(retentionBytes, DEFAULT_LOG_RETENTION_BYTES);
+  pruneOrphanedLogRunLeases(logDir, name);
   if (keep === 0)
     return;
   const currentFileName = basename(currentFilePath);
@@ -49,39 +187,433 @@ function pruneOldLogs(logDir, name, currentFilePath, retention) {
   const candidates = readdirSync(logDir).filter((entry) => entry.startsWith(prefix) && entry.endsWith(".log") && entry !== currentFileName).map((entry) => {
     const path = join(logDir, entry);
     try {
-      return { path, mtimeMs: statSync(path).mtimeMs };
+      const stat = statSync(path);
+      return { path, mtimeMs: stat.mtimeMs, size: stat.size };
     } catch {
       return null;
     }
   }).filter((entry) => entry !== null).sort((a, b) => b.mtimeMs - a.mtimeMs);
-  for (const stale of candidates.slice(Math.max(0, keep - 1))) {
+  const retained = [];
+  let retainedBytes = 0;
+  for (const candidate of candidates) {
+    if (hasLiveLogRunLease(candidate.path)) {
+      retained.push(candidate);
+      retainedBytes += candidate.size;
+      continue;
+    }
+    const withinCount = keep === 0 || retained.length < Math.max(0, keep - 1);
+    const withinBytes = retainedBytes + candidate.size <= byteBudget;
+    if (withinCount && withinBytes) {
+      retained.push(candidate);
+      retainedBytes += candidate.size;
+      continue;
+    }
     try {
-      unlinkSync(stale.path);
+      removeLogAndLease(candidate.path);
     } catch {
     }
   }
 }
+function waitForDestinationEvent(destination, event, deadline) {
+  if (!destination.on || !destination.off)
+    return Promise.resolve(false);
+  const addListener = destination.on.bind(destination);
+  const removeListener = destination.off.bind(destination);
+  const remaining = deadline === void 0 ? void 0 : deadline - Date.now();
+  if (remaining !== void 0 && remaining <= 0)
+    return Promise.resolve(false);
+  return new Promise((resolve) => {
+    let settled = false;
+    let timer;
+    const cleanup = () => {
+      if (timer)
+        clearTimeout(timer);
+      removeListener(event, onEvent);
+      removeListener("error", onError);
+    };
+    const settle = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      resolve(result);
+    };
+    const onEvent = () => settle(true);
+    const onError = () => settle(false);
+    addListener(event, onEvent);
+    addListener("error", onError);
+    if (remaining !== void 0) {
+      timer = setTimeout(() => settle(false), remaining);
+      timer.unref?.();
+    }
+  });
+}
+var BoundedWritableDestination = class {
+  destination;
+  maxPendingBytes;
+  droppedRecords = 0;
+  saturated = false;
+  constructor(destination, maxPendingBytes) {
+    this.destination = destination;
+    this.maxPendingBytes = maxPendingBytes;
+  }
+  write(serialized) {
+    if (this.saturated)
+      return;
+    const bytes = Buffer.byteLength(serialized);
+    const pendingBytes = this.destination.writableLength;
+    if (bytes > this.maxPendingBytes || typeof pendingBytes !== "number" || !Number.isFinite(pendingBytes)) {
+      this.droppedRecords += 1;
+      return;
+    }
+    const droppedDiagnostic = this.droppedRecords > 0 ? `${JSON.stringify({
+      level: 40,
+      time: Date.now(),
+      msg: "Log records were dropped while stdout was backpressured",
+      dropped: this.droppedRecords
+    })}
+` : null;
+    const diagnosticBytes = droppedDiagnostic ? Buffer.byteLength(droppedDiagnostic) : 0;
+    if (pendingBytes + diagnosticBytes + bytes > this.maxPendingBytes) {
+      this.droppedRecords += 1;
+      return;
+    }
+    try {
+      if (droppedDiagnostic)
+        this.destination.write(droppedDiagnostic);
+      this.destination.write(serialized);
+      this.droppedRecords = 0;
+    } catch {
+      this.saturated = true;
+    }
+  }
+};
+var BoundedLogDestination = class {
+  destination;
+  filePath;
+  runId;
+  logDir;
+  name;
+  retention;
+  retentionBytes;
+  maxFileBytes;
+  maxFilesPerRun;
+  maxRecordBytes;
+  currentBytes = 0;
+  rotating = false;
+  saturated = false;
+  droppedDuringRotation = 0;
+  pendingRecord = null;
+  rotationPromise = null;
+  rotationWaiters = /* @__PURE__ */ new Set();
+  constructor(destination, filePath, runId, logDir, name, retention, retentionBytes, maxFileBytes, maxFilesPerRun, maxRecordBytes, initialBytes) {
+    this.destination = destination;
+    this.filePath = filePath;
+    this.runId = runId;
+    this.logDir = logDir;
+    this.name = name;
+    this.retention = retention;
+    this.retentionBytes = retentionBytes;
+    this.maxFileBytes = maxFileBytes;
+    this.maxFilesPerRun = maxFilesPerRun;
+    this.maxRecordBytes = maxRecordBytes;
+    this.currentBytes = initialBytes;
+    this.destination.on?.("error", () => {
+      this.rotating = false;
+      this.saturated = true;
+      if (this.destination.fd == null || this.destination.fd < 0) {
+        removeOwnedLogRunLease(this.filePath, this.runId);
+      }
+    });
+  }
+  get fd() {
+    return this.destination.fd;
+  }
+  get _writing() {
+    return this.destination._writing;
+  }
+  once(event, cb) {
+    this.destination.once?.(event, cb);
+  }
+  on(event, cb) {
+    this.destination.on?.(event, cb);
+  }
+  off(event, cb) {
+    this.destination.off?.(event, cb);
+  }
+  listenerCount(event) {
+    return this.destination.listenerCount?.(event) ?? 0;
+  }
+  write(serialized) {
+    if (this.saturated)
+      return;
+    const record = this.boundRecord(serialized);
+    if (!record)
+      return;
+    const bytes = Buffer.byteLength(record);
+    if (this.rotating) {
+      this.droppedDuringRotation += 1;
+      return;
+    }
+    if (this.currentBytes + bytes > this.maxFileBytes) {
+      this.startRotation(record);
+      return;
+    }
+    this.writeActiveRecord(record);
+  }
+  flushSync() {
+    this.destination.flushSync?.();
+  }
+  async waitForRotation(deadline) {
+    while (this.rotationPromise) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0)
+        return false;
+      const settled = await new Promise((resolve) => {
+        let finished = false;
+        const waiter = () => finish(true);
+        const timer = setTimeout(() => finish(false), remaining);
+        timer.unref?.();
+        const finish = (result) => {
+          if (finished)
+            return;
+          finished = true;
+          clearTimeout(timer);
+          this.rotationWaiters.delete(waiter);
+          resolve(result);
+        };
+        this.rotationWaiters.add(waiter);
+        if (!this.rotationPromise)
+          finish(true);
+      });
+      if (!settled)
+        return false;
+    }
+    return true;
+  }
+  boundRecord(serialized) {
+    const bytes = Buffer.byteLength(serialized);
+    if (bytes <= this.maxRecordBytes && bytes <= this.maxFileBytes)
+      return serialized;
+    return this.boundDiagnostic({
+      level: 40,
+      time: Date.now(),
+      msg: "Log entry omitted because it exceeded the configured byte limit",
+      originalBytes: bytes
+    });
+  }
+  boundDiagnostic(value) {
+    const serialized = `${JSON.stringify(value)}
+`;
+    const bytes = Buffer.byteLength(serialized);
+    return bytes <= this.maxRecordBytes && bytes <= this.maxFileBytes ? serialized : null;
+  }
+  segmentPath(index) {
+    return this.filePath.replace(/\.log$/, `.${index}.log`);
+  }
+  writeActiveRecord(record) {
+    const bytes = Buffer.byteLength(record);
+    if (!this.destination.write || this.currentBytes + bytes > this.maxFileBytes)
+      return false;
+    this.currentBytes += bytes;
+    try {
+      this.destination.write(record);
+      return !this.saturated;
+    } catch {
+      this.saturated = true;
+      return false;
+    }
+  }
+  startRotation(pendingRecord) {
+    if (this.rotating || this.saturated)
+      return;
+    this.rotating = true;
+    this.pendingRecord = pendingRecord;
+    const tracked = Promise.resolve().then(() => this.performRotation()).catch(() => {
+      this.saturated = true;
+      this.rotating = false;
+      this.pendingRecord = null;
+      this.droppedDuringRotation = 0;
+    }).finally(() => {
+      if (this.rotationPromise === tracked)
+        this.rotationPromise = null;
+      for (const waiter of this.rotationWaiters)
+        waiter();
+      this.rotationWaiters.clear();
+    });
+    this.rotationPromise = tracked;
+  }
+  async performRotation() {
+    if (!this.destination.reopen)
+      throw new Error("Log destination cannot be reopened");
+    const deadline = Date.now() + LOG_IO_OPERATION_TIMEOUT_MS;
+    if (this.destination.fd == null || this.destination.fd < 0) {
+      if (!await waitForDestinationEvent(this.destination, "ready", deadline)) {
+        throw new Error("Log destination did not become ready");
+      }
+    }
+    if (this.destination._writing) {
+      if (!await waitForDestinationEvent(this.destination, "drain", deadline)) {
+        throw new Error("Log destination did not drain");
+      }
+    }
+    this.rotateFiles();
+    this.destination.reopen(this.filePath);
+    if (!await waitForDestinationEvent(this.destination, "ready", deadline)) {
+      throw new Error("Rotated log destination did not become ready");
+    }
+    pruneOldLogs(this.logDir, this.name, this.filePath, this.retention, this.retentionBytes);
+    this.currentBytes = 0;
+    const pendingRecord = this.pendingRecord;
+    this.pendingRecord = null;
+    const dropped = this.droppedDuringRotation;
+    this.droppedDuringRotation = 0;
+    this.rotating = false;
+    if (pendingRecord && !this.writeActiveRecord(pendingRecord))
+      return;
+    if (dropped === 0 || this.saturated)
+      return;
+    const diagnostic = this.boundDiagnostic({
+      level: 40,
+      time: Date.now(),
+      msg: "Log records were dropped while rotating the active file",
+      dropped
+    });
+    if (diagnostic && this.currentBytes + Buffer.byteLength(diagnostic) <= this.maxFileBytes) {
+      this.writeActiveRecord(diagnostic);
+    }
+  }
+  rotateFiles() {
+    if (this.maxFilesPerRun > 1) {
+      try {
+        unlinkSync(this.segmentPath(this.maxFilesPerRun - 1));
+      } catch (error) {
+        if (error.code !== "ENOENT")
+          throw error;
+      }
+      for (let index = this.maxFilesPerRun - 2; index >= 1; index -= 1) {
+        try {
+          renameSync(this.segmentPath(index), this.segmentPath(index + 1));
+        } catch (error) {
+          if (error.code !== "ENOENT")
+            throw error;
+        }
+      }
+      renameSync(this.filePath, this.segmentPath(1));
+    } else {
+      unlinkSync(this.filePath);
+    }
+  }
+};
 var loggerMetaMap = /* @__PURE__ */ new WeakMap();
+async function flushDestination(destination, deadline) {
+  while (true) {
+    if (!await destination.waitForRotation(deadline))
+      return;
+    if (destination.fd == null || destination.fd < 0) {
+      if (!await waitForDestinationEvent(destination, "ready", deadline))
+        return;
+      continue;
+    }
+    if (destination._writing) {
+      if (!await waitForDestinationEvent(destination, "drain", deadline))
+        return;
+      continue;
+    }
+    try {
+      destination.flushSync();
+    } catch {
+    }
+    return;
+  }
+}
+function resolveFlushTimeout(timeoutMs) {
+  return Number.isFinite(timeoutMs) && timeoutMs >= 0 ? Math.floor(timeoutMs) : 200;
+}
+function startFlushOperation(meta, destination) {
+  const operation = {
+    promise: flushDestination(destination, Date.now() + LOG_IO_OPERATION_TIMEOUT_MS),
+    settled: false,
+    waiters: /* @__PURE__ */ new Set()
+  };
+  meta.flushOperation = operation;
+  const finish = () => {
+    if (operation.settled)
+      return;
+    operation.settled = true;
+    if (meta.flushOperation === operation)
+      meta.flushOperation = null;
+    for (const waiter of operation.waiters)
+      waiter();
+    operation.waiters.clear();
+  };
+  void operation.promise.then(finish, finish);
+  return operation;
+}
+function waitForFlushOperation(operation, timeoutMs) {
+  if (operation.settled || timeoutMs <= 0)
+    return Promise.resolve();
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      operation.waiters.delete(finish);
+      resolve();
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    operation.waiters.add(finish);
+    if (operation.settled) {
+      finish();
+      return;
+    }
+  });
+}
 function buildPinoLogger(options) {
-  const { name, level = "info", logDir = DEFAULT_LOG_DIR, retention, stdout = false, silent = false, sync = false } = options;
+  const { name, level = "info", logDir = DEFAULT_LOG_DIR, retention, retentionBytes, maxFileBytes: requestedMaxFileBytes, maxFilesPerRun: requestedMaxFilesPerRun, maxRecordBytes: requestedMaxRecordBytes, stdout = false, silent = false, sync = false } = options;
   if (silent) {
     return { logger: pino({ level: "silent" }), destination: null };
   }
   mkdirSync(logDir, { recursive: true });
-  const runId = PROCESS_LOG_RUN_ID;
+  const runId = `${PROCESS_LOG_RUN_ID}-${randomUUID()}`;
   const filePath = join(logDir, `${name}-${runId}.log`);
-  linkLatestLog(logDir, name, filePath, runId);
-  pruneOldLogs(logDir, name, filePath, retention);
-  const destination = pino.destination({ dest: filePath, sync });
-  const streams = [{ stream: destination }];
-  if (stdout) {
-    streams.unshift({ stream: process.stdout });
-  }
-  return { logger: pino({ level }, pino.multistream(streams)), destination };
+  createLogRunLease(filePath, runId);
+  try {
+    linkLatestLog(logDir, name, filePath, runId);
+    pruneOldLogs(logDir, name, filePath, retention, retentionBytes);
+    const maxFileBytes = resolvePositiveInteger(requestedMaxFileBytes, DEFAULT_MAX_FILE_BYTES);
+    const maxFilesPerRun = resolvePositiveInteger(requestedMaxFilesPerRun, DEFAULT_MAX_FILES_PER_RUN);
+    const maxRecordBytes = Math.min(maxFileBytes, resolvePositiveInteger(requestedMaxRecordBytes, DEFAULT_MAX_RECORD_BYTES));
+    const sonicDestination = pino.destination({
+      dest: filePath,
+      sync,
+      // Bound data queued while the filesystem is stalled. Dropping diagnostics is preferable to
+      // allowing a logging failure to consume the application's heap.
+      maxLength: Math.min(maxFileBytes, 1024 * 1024)
+    });
+    let initialBytes = 0;
+    try {
+      initialBytes = statSync(filePath).size;
+    } catch {
+    }
+    const destination = new BoundedLogDestination(sonicDestination, filePath, runId, logDir, name, retention, retentionBytes, maxFileBytes, maxFilesPerRun, maxRecordBytes, initialBytes);
+    const streams = [{ stream: destination }];
+    if (stdout) {
+      streams.unshift({
+        stream: new BoundedWritableDestination(process.stdout, DEFAULT_MAX_STDOUT_BUFFER_BYTES)
+      });
+    }
+    return { logger: pino({ level }, pino.multistream(streams)), destination };
+  } catch (error) {
+    removeOwnedLogRunLease(filePath, runId);
+    throw error;
+  }
 }
 function createLogger(options) {
   let real = null;
-  const meta = { materialized: false, destination: null };
+  const meta = { materialized: false, destination: null, flushOperation: null };
   const ensure = () => {
     if (!real) {
       const built = buildPinoLogger(options);
@@ -120,40 +652,8 @@ async function flushLogger(logger2, timeoutMs = 200) {
   const dest = meta.destination;
   if (!dest)
     return;
-  if (dest.fd == null || dest.fd < 0) {
-    const opened = await new Promise((resolve) => {
-      const timer = setTimeout(() => resolve(false), timeoutMs);
-      dest.once?.("ready", () => {
-        clearTimeout(timer);
-        resolve(true);
-      });
-      dest.once?.("error", () => {
-        clearTimeout(timer);
-        resolve(false);
-      });
-    });
-    if (!opened)
-      return;
-  }
-  if (dest._writing) {
-    const drained = await new Promise((resolve) => {
-      const timer = setTimeout(() => resolve(false), timeoutMs);
-      dest.once?.("drain", () => {
-        clearTimeout(timer);
-        resolve(true);
-      });
-      dest.once?.("error", () => {
-        clearTimeout(timer);
-        resolve(false);
-      });
-    });
-    if (!drained)
-      return;
-  }
-  try {
-    dest.flushSync?.();
-  } catch {
-  }
+  const operation = meta.flushOperation ?? startFlushOperation(meta, dest);
+  await waitForFlushOperation(operation, resolveFlushTimeout(timeoutMs));
 }
 
 // src/runtime-env.ts