apitally 0.25.7 → 1.0.0-alpha.1

package/dist/spool.js

@@ -0,0 +1,297 @@
+import { randomUUID } from "node:crypto";
+import {
+  createWriteStream,
+  openSync,
+  readdirSync,
+  statSync,
+  unlinkSync,
+  utimesSync,
+  writeFileSync
+} from "node:fs";
+import { readFile, unlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createGzip } from "node:zlib";
+import { logWarning, resetWarning } from "./logger.js";
+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 = tmpdir()) {
+    this.tempDir = tempDir;
+    this.inMemory = !isTempDirWritable(tempDir);
+    if (this.inMemory) {
+      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);
+        resetWarning(WRITE_FAILURE_WARNING);
+      } catch {
+        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;
+    }
+    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 {
+      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;
+      }
+      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 = 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 = join(tempDir, `apitally-${randomUUID()}.gz`);
+      const fd = openSync(this.path, "wx", 384);
+      this.fileStream = 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();
+        utimesSync(this.path, now, now);
+      } catch {
+      }
+    }
+  }
+  readStoredBytes() {
+    if (this.path) {
+      return readFile(this.path);
+    }
+    return Promise.resolve(Buffer.concat(this.memoryChunks ?? []));
+  }
+  async delete() {
+    this.gzip.destroy();
+    this.fileStream?.destroy();
+    if (this.path) {
+      await unlink(this.path).catch(() => void 0);
+    }
+  }
+}
+function isTempDirWritable(tempDir) {
+  const probePath = join(tempDir, `apitally-${randomUUID()}.gz`);
+  try {
+    writeFileSync(probePath, "", { flag: "wx", mode: 384 });
+    unlinkSync(probePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cleanupOrphanedFiles(tempDir) {
+  const cutoff = Date.now() - MAX_UNTOUCHED_FILE_AGE_MILLIS;
+  try {
+    for (const name of readdirSync(tempDir)) {
+      if (!SPOOL_FILE_NAME_PATTERN.test(name)) {
+        continue;
+      }
+      try {
+        const filePath = join(tempDir, name);
+        if (statSync(filePath).mtimeMs < cutoff) {
+          unlinkSync(filePath);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+export {
+  Spool,
+  SpoolFile
+};
+//# sourceMappingURL=spool.js.map

package/dist/spool.js.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/startup.cjs

@@ -0,0 +1,93 @@
+"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 startup_exports = {};
+__export(startup_exports, {
+  emitStartupEvent: () => emitStartupEvent,
+  resetStartupEventEmitted: () => resetStartupEventEmitted
+});
+module.exports = __toCommonJS(startup_exports);
+var import_api = require("@opentelemetry/api");
+var import_config = require('./config.cjs');
+var import_logger = require('./logger.cjs');
+let startupEventEmitted = false;
+function emitStartupEvent(loggerProvider, info) {
+  if (startupEventEmitted) {
+    return;
+  }
+  startupEventEmitted = true;
+  const versions = { node: process.versions.node };
+  if (info.frameworkVersion) {
+    versions[info.framework] = info.frameworkVersion;
+  }
+  const appVersion = (0, import_config.getConfig)().appVersion;
+  if (appVersion) {
+    versions.app = appVersion;
+  }
+  let paths;
+  try {
+    paths = normalizeStartupPaths(info.resolvePaths());
+  } catch (error) {
+    (0, import_logger.logDebug)(`Error resolving the app's routes for the startup event: ${String(error)}`);
+  }
+  const body = serializePayload({ framework: info.framework, versions, paths }) ?? (paths !== void 0 ? serializePayload({ framework: info.framework, versions }) : void 0);
+  if (body === void 0) {
+    return;
+  }
+  loggerProvider.getLogger("apitally").emit({
+    timestamp: Date.now(),
+    // The explicit root context keeps the record separate from the request
+    // whose handling triggered the emit.
+    context: import_api.ROOT_CONTEXT,
+    eventName: "apitally.app.startup",
+    body
+  });
+}
+function resetStartupEventEmitted() {
+  startupEventEmitted = false;
+}
+function normalizeStartupPaths(candidates) {
+  const paths = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const method = candidate.method.toUpperCase();
+    if (method === "ALL" || method === "HEAD" || method === "OPTIONS") {
+      continue;
+    }
+    const key = `${method}\0${candidate.path}`;
+    if (!seenPaths.has(key)) {
+      seenPaths.add(key);
+      paths.push({ ...candidate, method });
+    }
+  }
+  return paths;
+}
+function serializePayload(payload) {
+  try {
+    return JSON.stringify(payload);
+  } catch (error) {
+    (0, import_logger.logDebug)(`Error serializing the startup event payload: ${String(error)}`);
+    return void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  emitStartupEvent,
+  resetStartupEventEmitted
+});
+//# sourceMappingURL=startup.cjs.map

package/dist/startup.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startup.ts"],"sourcesContent":["import { ROOT_CONTEXT } from \"@opentelemetry/api\";\nimport type { LoggerProvider } from \"@opentelemetry/api-logs\";\nimport { getConfig } from \"./config.js\";\nimport { logDebug } from \"./logger.js\";\n\nexport interface RoutePath {\n  method: string;\n  path: string;\n}\n\nexport interface StartupEventInfo {\n  framework: string;\n  frameworkVersion?: string;\n  // Resolved at emission because routes often finalize after setup.\n  resolvePaths: () => RoutePath[];\n}\n\nlet startupEventEmitted = false;\n\n// The startup event emits at most once. Route resolution or serialization\n// failures emit the remaining valid data and never reach the application.\nexport function emitStartupEvent(loggerProvider: LoggerProvider, info: StartupEventInfo): void {\n  if (startupEventEmitted) {\n    return;\n  }\n  startupEventEmitted = true;\n  const versions: Record<string, string> = { node: process.versions.node };\n  if (info.frameworkVersion) {\n    versions[info.framework] = info.frameworkVersion;\n  }\n  const appVersion = getConfig().appVersion;\n  if (appVersion) {\n    versions.app = appVersion;\n  }\n  let paths: RoutePath[] | undefined;\n  try {\n    paths = normalizeStartupPaths(info.resolvePaths());\n  } catch (error) {\n    logDebug(`Error resolving the app's routes for the startup event: ${String(error)}`);\n  }\n  const body =\n    serializePayload({ framework: info.framework, versions, paths }) ??\n    (paths !== undefined ? serializePayload({ framework: info.framework, versions }) : undefined);\n  if (body === undefined) {\n    return;\n  }\n  loggerProvider.getLogger(\"apitally\").emit({\n    timestamp: Date.now(),\n    // The explicit root context keeps the record separate from the request\n    // whose handling triggered the emit.\n    context: ROOT_CONTEXT,\n    eventName: \"apitally.app.startup\",\n    body,\n  });\n}\n\nexport function resetStartupEventEmitted(): void {\n  startupEventEmitted = false;\n}\n\nfunction normalizeStartupPaths(candidates: RoutePath[]): RoutePath[] {\n  const paths: RoutePath[] = [];\n  const seenPaths = new Set<string>();\n  for (const candidate of candidates) {\n    const method = candidate.method.toUpperCase();\n    if (method === \"ALL\" || method === \"HEAD\" || method === \"OPTIONS\") {\n      continue;\n    }\n    const key = `${method}\\0${candidate.path}`;\n    if (!seenPaths.has(key)) {\n      seenPaths.add(key);\n      paths.push({ ...candidate, method });\n    }\n  }\n  return paths;\n}\n\nfunction serializePayload(payload: {\n  framework: string;\n  versions: Record<string, string>;\n  paths?: RoutePath[];\n}): string | undefined {\n  try {\n    return JSON.stringify(payload);\n  } catch (error) {\n    logDebug(`Error serializing the startup event payload: ${String(error)}`);\n    return undefined;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAA6B;AAE7B,oBAA0B;AAC1B,oBAAyB;AAczB,IAAI,sBAAsB;AAInB,SAAS,iBAAiB,gBAAgC,MAA8B;AAC7F,MAAI,qBAAqB;AACvB;AAAA,EACF;AACA,wBAAsB;AACtB,QAAM,WAAmC,EAAE,MAAM,QAAQ,SAAS,KAAK;AACvE,MAAI,KAAK,kBAAkB;AACzB,aAAS,KAAK,SAAS,IAAI,KAAK;AAAA,EAClC;AACA,QAAM,iBAAa,yBAAU,EAAE;AAC/B,MAAI,YAAY;AACd,aAAS,MAAM;AAAA,EACjB;AACA,MAAI;AACJ,MAAI;AACF,YAAQ,sBAAsB,KAAK,aAAa,CAAC;AAAA,EACnD,SAAS,OAAO;AACd,gCAAS,2DAA2D,OAAO,KAAK,CAAC,EAAE;AAAA,EACrF;AACA,QAAM,OACJ,iBAAiB,EAAE,WAAW,KAAK,WAAW,UAAU,MAAM,CAAC,MAC9D,UAAU,SAAY,iBAAiB,EAAE,WAAW,KAAK,WAAW,SAAS,CAAC,IAAI;AACrF,MAAI,SAAS,QAAW;AACtB;AAAA,EACF;AACA,iBAAe,UAAU,UAAU,EAAE,KAAK;AAAA,IACxC,WAAW,KAAK,IAAI;AAAA;AAAA;AAAA,IAGpB,SAAS;AAAA,IACT,WAAW;AAAA,IACX;AAAA,EACF,CAAC;AACH;AAEO,SAAS,2BAAiC;AAC/C,wBAAsB;AACxB;AAEA,SAAS,sBAAsB,YAAsC;AACnE,QAAM,QAAqB,CAAC;AAC5B,QAAM,YAAY,oBAAI,IAAY;AAClC,aAAW,aAAa,YAAY;AAClC,UAAM,SAAS,UAAU,OAAO,YAAY;AAC5C,QAAI,WAAW,SAAS,WAAW,UAAU,WAAW,WAAW;AACjE;AAAA,IACF;AACA,UAAM,MAAM,GAAG,MAAM,KAAK,UAAU,IAAI;AACxC,QAAI,CAAC,UAAU,IAAI,GAAG,GAAG;AACvB,gBAAU,IAAI,GAAG;AACjB,YAAM,KAAK,EAAE,GAAG,WAAW,OAAO,CAAC;AAAA,IACrC;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,iBAAiB,SAIH;AACrB,MAAI;AACF,WAAO,KAAK,UAAU,OAAO;AAAA,EAC/B,SAAS,OAAO;AACd,gCAAS,gDAAgD,OAAO,KAAK,CAAC,EAAE;AACxE,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/startup.d.cts

@@ -0,0 +1,15 @@
+import { LoggerProvider } from '@opentelemetry/api-logs';
+
+interface RoutePath {
+    method: string;
+    path: string;
+}
+interface StartupEventInfo {
+    framework: string;
+    frameworkVersion?: string;
+    resolvePaths: () => RoutePath[];
+}
+declare function emitStartupEvent(loggerProvider: LoggerProvider, info: StartupEventInfo): void;
+declare function resetStartupEventEmitted(): void;
+
+export { type RoutePath, type StartupEventInfo, emitStartupEvent, resetStartupEventEmitted };

package/dist/startup.d.ts

@@ -0,0 +1,15 @@
+import { LoggerProvider } from '@opentelemetry/api-logs';
+
+interface RoutePath {
+    method: string;
+    path: string;
+}
+interface StartupEventInfo {
+    framework: string;
+    frameworkVersion?: string;
+    resolvePaths: () => RoutePath[];
+}
+declare function emitStartupEvent(loggerProvider: LoggerProvider, info: StartupEventInfo): void;
+declare function resetStartupEventEmitted(): void;
+
+export { type RoutePath, type StartupEventInfo, emitStartupEvent, resetStartupEventEmitted };

package/dist/startup.js

@@ -0,0 +1,68 @@
+import { ROOT_CONTEXT } from "@opentelemetry/api";
+import { getConfig } from "./config.js";
+import { logDebug } from "./logger.js";
+let startupEventEmitted = false;
+function emitStartupEvent(loggerProvider, info) {
+  if (startupEventEmitted) {
+    return;
+  }
+  startupEventEmitted = true;
+  const versions = { node: process.versions.node };
+  if (info.frameworkVersion) {
+    versions[info.framework] = info.frameworkVersion;
+  }
+  const appVersion = getConfig().appVersion;
+  if (appVersion) {
+    versions.app = appVersion;
+  }
+  let paths;
+  try {
+    paths = normalizeStartupPaths(info.resolvePaths());
+  } catch (error) {
+    logDebug(`Error resolving the app's routes for the startup event: ${String(error)}`);
+  }
+  const body = serializePayload({ framework: info.framework, versions, paths }) ?? (paths !== void 0 ? serializePayload({ framework: info.framework, versions }) : void 0);
+  if (body === void 0) {
+    return;
+  }
+  loggerProvider.getLogger("apitally").emit({
+    timestamp: Date.now(),
+    // The explicit root context keeps the record separate from the request
+    // whose handling triggered the emit.
+    context: ROOT_CONTEXT,
+    eventName: "apitally.app.startup",
+    body
+  });
+}
+function resetStartupEventEmitted() {
+  startupEventEmitted = false;
+}
+function normalizeStartupPaths(candidates) {
+  const paths = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const method = candidate.method.toUpperCase();
+    if (method === "ALL" || method === "HEAD" || method === "OPTIONS") {
+      continue;
+    }
+    const key = `${method}\0${candidate.path}`;
+    if (!seenPaths.has(key)) {
+      seenPaths.add(key);
+      paths.push({ ...candidate, method });
+    }
+  }
+  return paths;
+}
+function serializePayload(payload) {
+  try {
+    return JSON.stringify(payload);
+  } catch (error) {
+    logDebug(`Error serializing the startup event payload: ${String(error)}`);
+    return void 0;
+  }
+}
+export {
+  emitStartupEvent,
+  resetStartupEventEmitted
+};
+//# sourceMappingURL=startup.js.map

package/dist/startup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startup.ts"],"sourcesContent":["import { ROOT_CONTEXT } from \"@opentelemetry/api\";\nimport type { LoggerProvider } from \"@opentelemetry/api-logs\";\nimport { getConfig } from \"./config.js\";\nimport { logDebug } from \"./logger.js\";\n\nexport interface RoutePath {\n  method: string;\n  path: string;\n}\n\nexport interface StartupEventInfo {\n  framework: string;\n  frameworkVersion?: string;\n  // Resolved at emission because routes often finalize after setup.\n  resolvePaths: () => RoutePath[];\n}\n\nlet startupEventEmitted = false;\n\n// The startup event emits at most once. Route resolution or serialization\n// failures emit the remaining valid data and never reach the application.\nexport function emitStartupEvent(loggerProvider: LoggerProvider, info: StartupEventInfo): void {\n  if (startupEventEmitted) {\n    return;\n  }\n  startupEventEmitted = true;\n  const versions: Record<string, string> = { node: process.versions.node };\n  if (info.frameworkVersion) {\n    versions[info.framework] = info.frameworkVersion;\n  }\n  const appVersion = getConfig().appVersion;\n  if (appVersion) {\n    versions.app = appVersion;\n  }\n  let paths: RoutePath[] | undefined;\n  try {\n    paths = normalizeStartupPaths(info.resolvePaths());\n  } catch (error) {\n    logDebug(`Error resolving the app's routes for the startup event: ${String(error)}`);\n  }\n  const body =\n    serializePayload({ framework: info.framework, versions, paths }) ??\n    (paths !== undefined ? serializePayload({ framework: info.framework, versions }) : undefined);\n  if (body === undefined) {\n    return;\n  }\n  loggerProvider.getLogger(\"apitally\").emit({\n    timestamp: Date.now(),\n    // The explicit root context keeps the record separate from the request\n    // whose handling triggered the emit.\n    context: ROOT_CONTEXT,\n    eventName: \"apitally.app.startup\",\n    body,\n  });\n}\n\nexport function resetStartupEventEmitted(): void {\n  startupEventEmitted = false;\n}\n\nfunction normalizeStartupPaths(candidates: RoutePath[]): RoutePath[] {\n  const paths: RoutePath[] = [];\n  const seenPaths = new Set<string>();\n  for (const candidate of candidates) {\n    const method = candidate.method.toUpperCase();\n    if (method === \"ALL\" || method === \"HEAD\" || method === \"OPTIONS\") {\n      continue;\n    }\n    const key = `${method}\\0${candidate.path}`;\n    if (!seenPaths.has(key)) {\n      seenPaths.add(key);\n      paths.push({ ...candidate, method });\n    }\n  }\n  return paths;\n}\n\nfunction serializePayload(payload: {\n  framework: string;\n  versions: Record<string, string>;\n  paths?: RoutePath[];\n}): string | undefined {\n  try {\n    return JSON.stringify(payload);\n  } catch (error) {\n    logDebug(`Error serializing the startup event payload: ${String(error)}`);\n    return undefined;\n  }\n}\n"],"mappings":"AAAA,SAAS,oBAAoB;AAE7B,SAAS,iBAAiB;AAC1B,SAAS,gBAAgB;AAczB,IAAI,sBAAsB;AAInB,SAAS,iBAAiB,gBAAgC,MAA8B;AAC7F,MAAI,qBAAqB;AACvB;AAAA,EACF;AACA,wBAAsB;AACtB,QAAM,WAAmC,EAAE,MAAM,QAAQ,SAAS,KAAK;AACvE,MAAI,KAAK,kBAAkB;AACzB,aAAS,KAAK,SAAS,IAAI,KAAK;AAAA,EAClC;AACA,QAAM,aAAa,UAAU,EAAE;AAC/B,MAAI,YAAY;AACd,aAAS,MAAM;AAAA,EACjB;AACA,MAAI;AACJ,MAAI;AACF,YAAQ,sBAAsB,KAAK,aAAa,CAAC;AAAA,EACnD,SAAS,OAAO;AACd,aAAS,2DAA2D,OAAO,KAAK,CAAC,EAAE;AAAA,EACrF;AACA,QAAM,OACJ,iBAAiB,EAAE,WAAW,KAAK,WAAW,UAAU,MAAM,CAAC,MAC9D,UAAU,SAAY,iBAAiB,EAAE,WAAW,KAAK,WAAW,SAAS,CAAC,IAAI;AACrF,MAAI,SAAS,QAAW;AACtB;AAAA,EACF;AACA,iBAAe,UAAU,UAAU,EAAE,KAAK;AAAA,IACxC,WAAW,KAAK,IAAI;AAAA;AAAA;AAAA,IAGpB,SAAS;AAAA,IACT,WAAW;AAAA,IACX;AAAA,EACF,CAAC;AACH;AAEO,SAAS,2BAAiC;AAC/C,wBAAsB;AACxB;AAEA,SAAS,sBAAsB,YAAsC;AACnE,QAAM,QAAqB,CAAC;AAC5B,QAAM,YAAY,oBAAI,IAAY;AAClC,aAAW,aAAa,YAAY;AAClC,UAAM,SAAS,UAAU,OAAO,YAAY;AAC5C,QAAI,WAAW,SAAS,WAAW,UAAU,WAAW,WAAW;AACjE;AAAA,IACF;AACA,UAAM,MAAM,GAAG,MAAM,KAAK,UAAU,IAAI;AACxC,QAAI,CAAC,UAAU,IAAI,GAAG,GAAG;AACvB,gBAAU,IAAI,GAAG;AACjB,YAAM,KAAK,EAAE,GAAG,WAAW,OAAO,CAAC;AAAA,IACrC;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,iBAAiB,SAIH;AACrB,MAAI;AACF,WAAO,KAAK,UAAU,OAAO;AAAA,EAC/B,SAAS,OAAO;AACd,aAAS,gDAAgD,OAAO,KAAK,CAAC,EAAE;AACxE,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/tracing.cjs

@@ -0,0 +1,116 @@
+"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 tracing_exports = {};
+__export(tracing_exports, {
+  instrument: () => instrument,
+  span: () => span
+});
+module.exports = __toCommonJS(tracing_exports);
+var import_node_url = require("node:url");
+var import_api = require("@opentelemetry/api");
+var import_exceptions = require('./exceptions.cjs');
+var import_logger = require('./logger.cjs');
+const STACK_FRAME_PATTERN = /at (?:.*\()?(.*?):(\d+):\d+\)?$/;
+function instrument(nameOrFn, fnWhenNamed) {
+  const fn = typeof nameOrFn === "function" ? nameOrFn : fnWhenNamed;
+  const spanName = typeof nameOrFn === "string" ? nameOrFn : fn.name || "anonymous";
+  const attributes = {};
+  if (fn.name) {
+    attributes["code.function.name"] = fn.name;
+  }
+  const wrapSite = resolveWrapSite();
+  if (wrapSite) {
+    attributes["code.file.path"] = wrapSite.filePath;
+    attributes["code.line.number"] = wrapSite.lineNumber;
+  }
+  return function(...args) {
+    return runInsideSpan(spanName, attributes, () => fn.apply(this, args));
+  };
+}
+function span(name, fn) {
+  return runInsideSpan(name, void 0, fn);
+}
+function runInsideSpan(name, attributes, fn) {
+  let internalSpan;
+  try {
+    internalSpan = import_api.trace.getTracer("apitally.otel").startSpan(name, { kind: import_api.SpanKind.INTERNAL, attributes });
+  } catch (error) {
+    (0, import_logger.logDebug)(`Error starting a manual span: ${String(error)}`);
+    return fn();
+  }
+  let result;
+  try {
+    result = import_api.context.with(import_api.trace.setSpan(import_api.context.active(), internalSpan), fn);
+  } catch (error) {
+    endSpanWithError(internalSpan, error);
+    throw error;
+  }
+  if (isPromiseLike(result)) {
+    result.then(
+      () => endSpan(internalSpan),
+      (error) => endSpanWithError(internalSpan, error)
+    );
+    return result;
+  }
+  endSpan(internalSpan);
+  return result;
+}
+function resolveWrapSite() {
+  const holder = {};
+  Error.captureStackTrace(holder, instrument);
+  for (const frame of (holder.stack ?? "").split("\n")) {
+    const match = STACK_FRAME_PATTERN.exec(frame);
+    if (match) {
+      return {
+        filePath: match[1].startsWith("file://") ? (0, import_node_url.fileURLToPath)(match[1]) : match[1],
+        lineNumber: Number(match[2])
+      };
+    }
+  }
+  return void 0;
+}
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+function endSpan(internalSpan) {
+  try {
+    internalSpan.end();
+  } catch (error) {
+    (0, import_logger.logDebug)(`Error ending a manual span: ${String(error)}`);
+  }
+}
+function endSpanWithError(internalSpan, error) {
+  try {
+    const exception = (0, import_exceptions.coerceToException)(error);
+    internalSpan.recordException(exception);
+    internalSpan.setStatus({
+      code: import_api.SpanStatusCode.ERROR,
+      message: typeof exception === "string" ? exception : exception.message
+    });
+    internalSpan.end();
+  } catch (endError) {
+    (0, import_logger.logDebug)(`Error ending a manual span: ${String(endError)}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  instrument,
+  span
+});
+//# sourceMappingURL=tracing.cjs.map