apitally 0.25.8 → 1.0.0-beta.1

package/dist/spool.cjs

@@ -0,0 +1,314 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var spool_exports = {};
+__export(spool_exports, {
+  Spool: () => Spool,
+  SpoolFile: () => SpoolFile
+});
+module.exports = __toCommonJS(spool_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var import_node_zlib = require("node:zlib");
+var import_logger = require('./logger.cjs');
+const WRITE_FAILURE_WARNING = "Error writing to disk, dropping buffered telemetry";
+const SIGNALS = ["traces", "logs", "metrics"];
+const MAX_UNCOMPRESSED_FILE_SIZE = 4e6;
+const MAX_RETRY_TIME_AFTER_FIRST_ATTEMPT_MILLIS = 59 * 60 * 1e3;
+const MAX_SPOOL_SIZE_DISK = 5e7;
+const MAX_SPOOL_SIZE_MEMORY = 1e7;
+const MAX_UNTOUCHED_FILE_AGE_MILLIS = 2 * 60 * 60 * 1e3;
+const SPOOL_FILE_NAME_PATTERN = /^apitally-.*\.gz$/;
+class Spool {
+  inMemory;
+  maxSize;
+  current = /* @__PURE__ */ new Map();
+  closed = [];
+  tempDir;
+  queues = {
+    traces: Promise.resolve(),
+    logs: Promise.resolve(),
+    metrics: Promise.resolve()
+  };
+  constructor(tempDir = (0, import_node_os.tmpdir)()) {
+    this.tempDir = tempDir;
+    this.inMemory = !isTempDirWritable(tempDir);
+    if (this.inMemory) {
+      (0, import_logger.logWarning)(
+        `Unable to create temporary files, buffering telemetry in memory (max ${MAX_SPOOL_SIZE_MEMORY / 1e6} MB)`
+      );
+    } else {
+      cleanupOrphanedFiles(tempDir);
+    }
+    this.maxSize = this.inMemory ? MAX_SPOOL_SIZE_MEMORY : MAX_SPOOL_SIZE_DISK;
+  }
+  append(signal, payload) {
+    return this.enqueue(signal, async () => {
+      let file = this.current.get(signal);
+      if (file && file.uncompressedSize + payload.length > MAX_UNCOMPRESSED_FILE_SIZE) {
+        await this.closeCurrentFile(signal);
+        file = void 0;
+      }
+      try {
+        if (!file) {
+          file = new SpoolFile(signal, this.inMemory ? void 0 : this.tempDir);
+          this.current.set(signal, file);
+        }
+        await file.write(payload);
+        (0, import_logger.resetWarning)(WRITE_FAILURE_WARNING);
+      } catch {
+        (0, import_logger.logWarning)(WRITE_FAILURE_WARNING);
+        await this.discardCurrentFile(signal);
+      }
+      await this.evict();
+    });
+  }
+  // Current files close only when no backlog exists, avoiding one file per cycle.
+  // Sequential rotation preserves send order.
+  async rotateForExport() {
+    for (const signal of SIGNALS) {
+      await this.enqueue(signal, async () => {
+        if (this.current.has(signal) && !this.closed.some((file) => file.signal === signal)) {
+          await this.closeCurrentFile(signal);
+        }
+      });
+    }
+    await this.evict();
+  }
+  async closeCurrentFiles() {
+    for (const signal of SIGNALS) {
+      await this.enqueue(signal, () => this.closeCurrentFile(signal));
+    }
+  }
+  pendingFiles() {
+    return [...this.closed];
+  }
+  async deleteFile(file) {
+    const index = this.closed.indexOf(file);
+    if (index >= 0) {
+      this.closed.splice(index, 1);
+    }
+    await file.delete();
+  }
+  // Apitally ingest deduplicates for one hour; a later retry could ingest the file twice.
+  deleteIfExpired(file) {
+    if (!file.isExpired()) {
+      return void 0;
+    }
+    (0, import_logger.logWarning)(`Buffered ${file.signal} could not be delivered within an hour and were dropped`);
+    return this.deleteFile(file);
+  }
+  // Refresh mtimes so orphan cleanup in another process preserves live files.
+  touchFiles() {
+    for (const file of [...this.current.values(), ...this.closed]) {
+      file.touch();
+    }
+  }
+  async clear() {
+    await Promise.all(
+      SIGNALS.map((signal) => this.enqueue(signal, () => this.discardCurrentFile(signal)))
+    );
+    const files = this.closed.splice(0);
+    await Promise.all(files.map((file) => file.delete()));
+  }
+  enqueue(signal, operation) {
+    const result = this.queues[signal].then(operation);
+    this.queues[signal] = result.catch(() => void 0);
+    return result;
+  }
+  async closeCurrentFile(signal) {
+    const file = this.current.get(signal);
+    if (!file) {
+      return;
+    }
+    this.current.delete(signal);
+    try {
+      await file.close();
+      this.closed.push(file);
+    } catch {
+      (0, import_logger.logWarning)(WRITE_FAILURE_WARNING);
+      await file.delete();
+    }
+  }
+  async discardCurrentFile(signal) {
+    const file = this.current.get(signal);
+    if (file) {
+      this.current.delete(signal);
+      await file.delete();
+    }
+  }
+  async evict() {
+    const deletions = [...this.closed].map((file) => this.deleteIfExpired(file));
+    while (this.totalSize() > this.maxSize) {
+      const oldest = this.closed.find((file) => file.signal !== "metrics") ?? this.closed[0];
+      if (!oldest) {
+        break;
+      }
+      (0, import_logger.logWarning)(`Buffer size limit reached, dropping oldest buffered ${oldest.signal}`);
+      deletions.push(this.deleteFile(oldest));
+    }
+    await Promise.all(deletions);
+  }
+  totalSize() {
+    let total = 0;
+    for (const file of [...this.closed, ...this.current.values()]) {
+      total += file.storedSize;
+    }
+    return total;
+  }
+}
+class SpoolFile {
+  signal;
+  path;
+  firstAttemptAtMillis;
+  uncompressedSize = 0;
+  gzip;
+  fileStream;
+  memoryChunks;
+  memorySize = 0;
+  streamError;
+  closedPromise;
+  constructor(signal, tempDir) {
+    this.signal = signal;
+    this.gzip = (0, import_node_zlib.createGzip)();
+    let closeTarget;
+    let closeEvent;
+    if (tempDir === void 0) {
+      const chunks = [];
+      this.memoryChunks = chunks;
+      this.gzip.on("data", (chunk) => {
+        chunks.push(chunk);
+        this.memorySize += chunk.length;
+      });
+      closeTarget = this.gzip;
+      closeEvent = "end";
+    } else {
+      this.path = (0, import_node_path.join)(tempDir, `apitally-${(0, import_node_crypto.randomUUID)()}.gz`);
+      const fd = (0, import_node_fs.openSync)(this.path, "wx", 384);
+      this.fileStream = (0, import_node_fs.createWriteStream)(this.path, { fd });
+      this.gzip.pipe(this.fileStream);
+      closeTarget = this.fileStream;
+      closeEvent = "close";
+    }
+    const streams = this.fileStream ? [this.gzip, this.fileStream] : [this.gzip];
+    this.closedPromise = new Promise((resolve, reject) => {
+      closeTarget.once(closeEvent, resolve);
+      for (const stream of streams) {
+        stream.once("error", reject);
+      }
+    });
+    this.closedPromise.catch(() => void 0);
+    for (const stream of streams) {
+      stream.on("error", (error) => {
+        this.streamError ??= error;
+      });
+    }
+  }
+  write(payload) {
+    return new Promise((resolve, reject) => {
+      if (this.streamError) {
+        reject(this.streamError);
+        return;
+      }
+      this.gzip.write(payload, (error) => {
+        const failure = error ?? this.streamError;
+        if (failure) {
+          reject(failure);
+        } else {
+          this.uncompressedSize += payload.length;
+          resolve();
+        }
+      });
+    });
+  }
+  async close() {
+    if (this.streamError) {
+      throw this.streamError;
+    }
+    this.gzip.end();
+    await this.closedPromise;
+  }
+  get storedSize() {
+    return this.fileStream ? this.fileStream.bytesWritten : this.memorySize;
+  }
+  markAttempt() {
+    this.firstAttemptAtMillis ??= performance.now();
+  }
+  isExpired() {
+    return this.firstAttemptAtMillis !== void 0 && performance.now() - this.firstAttemptAtMillis > MAX_RETRY_TIME_AFTER_FIRST_ATTEMPT_MILLIS;
+  }
+  touch() {
+    if (this.path) {
+      try {
+        const now = /* @__PURE__ */ new Date();
+        (0, import_node_fs.utimesSync)(this.path, now, now);
+      } catch {
+      }
+    }
+  }
+  readStoredBytes() {
+    if (this.path) {
+      return (0, import_promises.readFile)(this.path);
+    }
+    return Promise.resolve(Buffer.concat(this.memoryChunks ?? []));
+  }
+  async delete() {
+    this.gzip.destroy();
+    this.fileStream?.destroy();
+    if (this.path) {
+      await (0, import_promises.unlink)(this.path).catch(() => void 0);
+    }
+  }
+}
+function isTempDirWritable(tempDir) {
+  const probePath = (0, import_node_path.join)(tempDir, `apitally-${(0, import_node_crypto.randomUUID)()}.gz`);
+  try {
+    (0, import_node_fs.writeFileSync)(probePath, "", { flag: "wx", mode: 384 });
+    (0, import_node_fs.unlinkSync)(probePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cleanupOrphanedFiles(tempDir) {
+  const cutoff = Date.now() - MAX_UNTOUCHED_FILE_AGE_MILLIS;
+  try {
+    for (const name of (0, import_node_fs.readdirSync)(tempDir)) {
+      if (!SPOOL_FILE_NAME_PATTERN.test(name)) {
+        continue;
+      }
+      try {
+        const filePath = (0, import_node_path.join)(tempDir, name);
+        if ((0, import_node_fs.statSync)(filePath).mtimeMs < cutoff) {
+          (0, import_node_fs.unlinkSync)(filePath);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Spool,
+  SpoolFile
+});
+//# sourceMappingURL=spool.cjs.map

package/dist/spool.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/spool.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport {\n  createWriteStream,\n  openSync,\n  readdirSync,\n  statSync,\n  unlinkSync,\n  utimesSync,\n  type WriteStream,\n  writeFileSync,\n} from \"node:fs\";\nimport { readFile, unlink } from \"node:fs/promises\";\nimport { tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport { createGzip, type Gzip } from \"node:zlib\";\nimport { logWarning, resetWarning } from \"./logger.js\";\n\nconst WRITE_FAILURE_WARNING = \"Error writing to disk, dropping buffered telemetry\";\n\nconst SIGNALS = [\"traces\", \"logs\", \"metrics\"] as const;\nexport type Signal = (typeof SIGNALS)[number];\n\nconst MAX_UNCOMPRESSED_FILE_SIZE = 4_000_000;\nconst MAX_RETRY_TIME_AFTER_FIRST_ATTEMPT_MILLIS = 59 * 60 * 1000;\nconst MAX_SPOOL_SIZE_DISK = 50_000_000;\nconst MAX_SPOOL_SIZE_MEMORY = 10_000_000;\nconst MAX_UNTOUCHED_FILE_AGE_MILLIS = 2 * 60 * 60 * 1000;\nconst SPOOL_FILE_NAME_PATTERN = /^apitally-.*\\.gz$/;\n\n// Operations for each signal are serialized because gzip and file streams\n// complete asynchronously.\nexport class Spool {\n  readonly inMemory: boolean;\n  maxSize: number;\n  readonly current = new Map<Signal, SpoolFile>();\n  private readonly closed: SpoolFile[] = [];\n  private readonly tempDir: string;\n  private readonly queues: Record<Signal, Promise<void>> = {\n    traces: Promise.resolve(),\n    logs: Promise.resolve(),\n    metrics: Promise.resolve(),\n  };\n\n  constructor(tempDir: string = tmpdir()) {\n    this.tempDir = tempDir;\n    this.inMemory = !isTempDirWritable(tempDir);\n    if (this.inMemory) {\n      logWarning(\n        `Unable to create temporary files, buffering telemetry in memory (max ${MAX_SPOOL_SIZE_MEMORY / 1_000_000} MB)`,\n      );\n    } else {\n      cleanupOrphanedFiles(tempDir);\n    }\n    this.maxSize = this.inMemory ? MAX_SPOOL_SIZE_MEMORY : MAX_SPOOL_SIZE_DISK;\n  }\n\n  append(signal: Signal, payload: Uint8Array): Promise<void> {\n    return this.enqueue(signal, async () => {\n      let file = this.current.get(signal);\n      if (file && file.uncompressedSize + payload.length > MAX_UNCOMPRESSED_FILE_SIZE) {\n        await this.closeCurrentFile(signal);\n        file = undefined;\n      }\n      try {\n        if (!file) {\n          file = new SpoolFile(signal, this.inMemory ? undefined : this.tempDir);\n          this.current.set(signal, file);\n        }\n        await file.write(payload);\n        // Writes recovered; the write-failure warning may fire again later.\n        resetWarning(WRITE_FAILURE_WARNING);\n      } catch {\n        logWarning(WRITE_FAILURE_WARNING);\n        await this.discardCurrentFile(signal);\n      }\n      await this.evict();\n    });\n  }\n\n  // Current files close only when no backlog exists, avoiding one file per cycle.\n  // Sequential rotation preserves send order.\n  async rotateForExport(): Promise<void> {\n    for (const signal of SIGNALS) {\n      await this.enqueue(signal, async () => {\n        if (this.current.has(signal) && !this.closed.some((file) => file.signal === signal)) {\n          await this.closeCurrentFile(signal);\n        }\n      });\n    }\n    await this.evict();\n  }\n\n  async closeCurrentFiles(): Promise<void> {\n    for (const signal of SIGNALS) {\n      await this.enqueue(signal, () => this.closeCurrentFile(signal));\n    }\n  }\n\n  pendingFiles(): SpoolFile[] {\n    return [...this.closed];\n  }\n\n  async deleteFile(file: SpoolFile): Promise<void> {\n    const index = this.closed.indexOf(file);\n    if (index >= 0) {\n      this.closed.splice(index, 1);\n    }\n    await file.delete();\n  }\n\n  // Apitally ingest deduplicates for one hour; a later retry could ingest the file twice.\n  deleteIfExpired(file: SpoolFile): Promise<void> | undefined {\n    if (!file.isExpired()) {\n      return undefined;\n    }\n    logWarning(`Buffered ${file.signal} could not be delivered within an hour and were dropped`);\n    return this.deleteFile(file);\n  }\n\n  // Refresh mtimes so orphan cleanup in another process preserves live files.\n  touchFiles(): void {\n    for (const file of [...this.current.values(), ...this.closed]) {\n      file.touch();\n    }\n  }\n\n  async clear(): Promise<void> {\n    await Promise.all(\n      SIGNALS.map((signal) => this.enqueue(signal, () => this.discardCurrentFile(signal))),\n    );\n    const files = this.closed.splice(0);\n    await Promise.all(files.map((file) => file.delete()));\n  }\n\n  private enqueue(signal: Signal, operation: () => Promise<void>): Promise<void> {\n    const result = this.queues[signal].then(operation);\n    this.queues[signal] = result.catch(() => undefined);\n    return result;\n  }\n\n  private async closeCurrentFile(signal: Signal): Promise<void> {\n    const file = this.current.get(signal);\n    if (!file) {\n      return;\n    }\n    this.current.delete(signal);\n    try {\n      await file.close();\n      this.closed.push(file);\n    } catch {\n      logWarning(WRITE_FAILURE_WARNING);\n      await file.delete();\n    }\n  }\n\n  private async discardCurrentFile(signal: Signal): Promise<void> {\n    const file = this.current.get(signal);\n    if (file) {\n      this.current.delete(signal);\n      await file.delete();\n    }\n  }\n\n  private async evict(): Promise<void> {\n    const deletions = [...this.closed].map((file) => this.deleteIfExpired(file));\n    while (this.totalSize() > this.maxSize) {\n      // Prefer retaining metrics, but enforce the size limit when only metrics remain.\n      const oldest = this.closed.find((file) => file.signal !== \"metrics\") ?? this.closed[0];\n      if (!oldest) {\n        break;\n      }\n      logWarning(`Buffer size limit reached, dropping oldest buffered ${oldest.signal}`);\n      deletions.push(this.deleteFile(oldest));\n    }\n    await Promise.all(deletions);\n  }\n\n  private totalSize(): number {\n    let total = 0;\n    for (const file of [...this.closed, ...this.current.values()]) {\n      total += file.storedSize;\n    }\n    return total;\n  }\n}\n\n// One gzip stream of concatenated OTLP request payloads for a single signal,\n// written through to a temp file or, as fallback, an in-memory buffer.\nexport class SpoolFile {\n  readonly signal: Signal;\n  readonly path?: string;\n  firstAttemptAtMillis?: number;\n  uncompressedSize = 0;\n  readonly gzip: Gzip;\n  private readonly fileStream?: WriteStream;\n  private readonly memoryChunks?: Buffer[];\n  private memorySize = 0;\n  private streamError?: Error;\n  private readonly closedPromise: Promise<void>;\n\n  constructor(signal: Signal, tempDir?: string) {\n    this.signal = signal;\n    this.gzip = createGzip();\n    let closeTarget: Gzip | WriteStream;\n    let closeEvent: string;\n    if (tempDir === undefined) {\n      const chunks: Buffer[] = [];\n      this.memoryChunks = chunks;\n      this.gzip.on(\"data\", (chunk: Buffer) => {\n        chunks.push(chunk);\n        this.memorySize += chunk.length;\n      });\n      closeTarget = this.gzip;\n      closeEvent = \"end\";\n    } else {\n      this.path = join(tempDir, `apitally-${randomUUID()}.gz`);\n      // A synchronous exclusive open reports creation errors to the triggering append.\n      const fd = openSync(this.path, \"wx\", 0o600);\n      this.fileStream = createWriteStream(this.path, { fd });\n      this.gzip.pipe(this.fileStream);\n      closeTarget = this.fileStream;\n      closeEvent = \"close\";\n    }\n    const streams: (Gzip | WriteStream)[] = this.fileStream\n      ? [this.gzip, this.fileStream]\n      : [this.gzip];\n    this.closedPromise = new Promise((resolve, reject) => {\n      closeTarget.once(closeEvent, resolve);\n      for (const stream of streams) {\n        stream.once(\"error\", reject);\n      }\n    });\n    // Stream errors can occur outside an awaited operation; rejection handling\n    // prevents an unhandled rejection.\n    this.closedPromise.catch(() => undefined);\n    for (const stream of streams) {\n      stream.on(\"error\", (error: Error) => {\n        this.streamError ??= error;\n      });\n    }\n  }\n\n  write(payload: Uint8Array): Promise<void> {\n    return new Promise((resolve, reject) => {\n      if (this.streamError) {\n        reject(this.streamError);\n        return;\n      }\n      this.gzip.write(payload, (error) => {\n        const failure = error ?? this.streamError;\n        if (failure) {\n          reject(failure);\n        } else {\n          this.uncompressedSize += payload.length;\n          resolve();\n        }\n      });\n    });\n  }\n\n  async close(): Promise<void> {\n    if (this.streamError) {\n      throw this.streamError;\n    }\n    this.gzip.end();\n    await this.closedPromise;\n  }\n\n  get storedSize(): number {\n    return this.fileStream ? this.fileStream.bytesWritten : this.memorySize;\n  }\n\n  markAttempt(): void {\n    this.firstAttemptAtMillis ??= performance.now();\n  }\n\n  isExpired(): boolean {\n    return (\n      this.firstAttemptAtMillis !== undefined &&\n      performance.now() - this.firstAttemptAtMillis > MAX_RETRY_TIME_AFTER_FIRST_ATTEMPT_MILLIS\n    );\n  }\n\n  touch(): void {\n    if (this.path) {\n      try {\n        const now = new Date();\n        utimesSync(this.path, now, now);\n      } catch {\n        // The file may already be gone; orphan cleanup only targets stale files.\n      }\n    }\n  }\n\n  readStoredBytes(): Promise<Buffer> {\n    if (this.path) {\n      return readFile(this.path);\n    }\n    return Promise.resolve(Buffer.concat(this.memoryChunks ?? []));\n  }\n\n  async delete(): Promise<void> {\n    this.gzip.destroy();\n    this.fileStream?.destroy();\n    if (this.path) {\n      await unlink(this.path).catch(() => undefined);\n    }\n  }\n}\n\nfunction isTempDirWritable(tempDir: string): boolean {\n  const probePath = join(tempDir, `apitally-${randomUUID()}.gz`);\n  try {\n    writeFileSync(probePath, \"\", { flag: \"wx\", mode: 0o600 });\n    unlinkSync(probePath);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n// Live processes refresh mtimes each cycle, so only stale spool files from dead\n// processes are removed.\nfunction cleanupOrphanedFiles(tempDir: string): void {\n  const cutoff = Date.now() - MAX_UNTOUCHED_FILE_AGE_MILLIS;\n  try {\n    for (const name of readdirSync(tempDir)) {\n      if (!SPOOL_FILE_NAME_PATTERN.test(name)) {\n        continue;\n      }\n      try {\n        const filePath = join(tempDir, name);\n        if (statSync(filePath).mtimeMs < cutoff) {\n          unlinkSync(filePath);\n        }\n      } catch {\n        // Another process may have removed the file first.\n      }\n    }\n  } catch {\n    // Reading the temporary directory is best-effort.\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/spool.d.cts

@@ -0,0 +1,49 @@
+import { Gzip } from 'node:zlib';
+
+declare const SIGNALS: readonly ["traces", "logs", "metrics"];
+type Signal = (typeof SIGNALS)[number];
+declare class Spool {
+    readonly inMemory: boolean;
+    maxSize: number;
+    readonly current: Map<"traces" | "logs" | "metrics", SpoolFile>;
+    private readonly closed;
+    private readonly tempDir;
+    private readonly queues;
+    constructor(tempDir?: string);
+    append(signal: Signal, payload: Uint8Array): Promise<void>;
+    rotateForExport(): Promise<void>;
+    closeCurrentFiles(): Promise<void>;
+    pendingFiles(): SpoolFile[];
+    deleteFile(file: SpoolFile): Promise<void>;
+    deleteIfExpired(file: SpoolFile): Promise<void> | undefined;
+    touchFiles(): void;
+    clear(): Promise<void>;
+    private enqueue;
+    private closeCurrentFile;
+    private discardCurrentFile;
+    private evict;
+    private totalSize;
+}
+declare class SpoolFile {
+    readonly signal: Signal;
+    readonly path?: string;
+    firstAttemptAtMillis?: number;
+    uncompressedSize: number;
+    readonly gzip: Gzip;
+    private readonly fileStream?;
+    private readonly memoryChunks?;
+    private memorySize;
+    private streamError?;
+    private readonly closedPromise;
+    constructor(signal: Signal, tempDir?: string);
+    write(payload: Uint8Array): Promise<void>;
+    close(): Promise<void>;
+    get storedSize(): number;
+    markAttempt(): void;
+    isExpired(): boolean;
+    touch(): void;
+    readStoredBytes(): Promise<Buffer>;
+    delete(): Promise<void>;
+}
+
+export { type Signal, Spool, SpoolFile };

package/dist/spool.d.ts

@@ -0,0 +1,49 @@
+import { Gzip } from 'node:zlib';
+
+declare const SIGNALS: readonly ["traces", "logs", "metrics"];
+type Signal = (typeof SIGNALS)[number];
+declare class Spool {
+    readonly inMemory: boolean;
+    maxSize: number;
+    readonly current: Map<"traces" | "logs" | "metrics", SpoolFile>;
+    private readonly closed;
+    private readonly tempDir;
+    private readonly queues;
+    constructor(tempDir?: string);
+    append(signal: Signal, payload: Uint8Array): Promise<void>;
+    rotateForExport(): Promise<void>;
+    closeCurrentFiles(): Promise<void>;
+    pendingFiles(): SpoolFile[];
+    deleteFile(file: SpoolFile): Promise<void>;
+    deleteIfExpired(file: SpoolFile): Promise<void> | undefined;
+    touchFiles(): void;
+    clear(): Promise<void>;
+    private enqueue;
+    private closeCurrentFile;
+    private discardCurrentFile;
+    private evict;
+    private totalSize;
+}
+declare class SpoolFile {
+    readonly signal: Signal;
+    readonly path?: string;
+    firstAttemptAtMillis?: number;
+    uncompressedSize: number;
+    readonly gzip: Gzip;
+    private readonly fileStream?;
+    private readonly memoryChunks?;
+    private memorySize;
+    private streamError?;
+    private readonly closedPromise;
+    constructor(signal: Signal, tempDir?: string);
+    write(payload: Uint8Array): Promise<void>;
+    close(): Promise<void>;
+    get storedSize(): number;
+    markAttempt(): void;
+    isExpired(): boolean;
+    touch(): void;
+    readStoredBytes(): Promise<Buffer>;
+    delete(): Promise<void>;
+}
+
+export { type Signal, Spool, SpoolFile };