@devkitio/faultlens 0.1.5 → 1.0.0

package/dist/node/index.js

@@ -1,11 +1,328 @@
-import { createMonitorRuntime } from '../chunk-LRHXSFK2.js';
+import { parseTransportResponse, parseRemoteSdkConfig, parseTelemetryTransportResponse, createMonitorRuntime } from '../chunk-ZUVQIOFO.js';
 import { createSignedRelayHeaders } from '../chunk-RXQF7F2E.js';
+import { AsyncLocalStorage } from 'async_hooks';
+import { createDecipheriv, randomBytes, createCipheriv } from 'crypto';
+import { unlink, mkdir, lstat, chmod, open, stat, readFile, rename } from 'fs/promises';
+import path from 'path';
+import { createRequire } from 'module';
 
-// src/node/index.ts
-function retryAfter(response) {
-  const value = response.headers.get("retry-after");
-  return value && /^\d+$/.test(value) ? Number(value) * 1e3 : void 0;
+var STATE_FILE = "events.v2.enc";
+var LOCK_FILE = "events.v2.lock";
+var AAD_PREFIX = "faultlens-node-queue:v2";
+function sleep(timeoutMs) {
+  return new Promise((resolve) => setTimeout(resolve, timeoutMs));
+}
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function isQueueItem(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const item = value;
+  return typeof item.id === "string" && typeof item.event === "object" && item.event !== null && item.event.eventId === item.id && typeof item.enqueuedAt === "number" && typeof item.bytes === "number" && typeof item.protocolVersion === "string" && typeof item.attemptCount === "number" && typeof item.nextAttemptAt === "number" && (item.lastErrorCode === void 0 || typeof item.lastErrorCode === "string");
+}
+var NodeEncryptedFileQueue = class {
+  directory;
+  keys;
+  maxItems;
+  maxBytes;
+  maxAgeMs;
+  lockTimeoutMs;
+  staleLockMs;
+  serial = Promise.resolve();
+  constructor(options) {
+    if (!path.isAbsolute(options.directory)) {
+      throw new Error("Node \u4E8B\u4EF6\u961F\u5217\u76EE\u5F55\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84");
+    }
+    if (options.encryptionKeys.length === 0) {
+      throw new Error("Node \u4E8B\u4EF6\u961F\u5217\u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u52A0\u5BC6\u5BC6\u94A5");
+    }
+    const ids = /* @__PURE__ */ new Set();
+    this.keys = options.encryptionKeys.map((current) => {
+      if (!/^[A-Za-z0-9._-]{1,64}$/.test(current.id) || ids.has(current.id)) {
+        throw new Error("Node \u4E8B\u4EF6\u961F\u5217\u5BC6\u94A5 ID \u65E0\u6548\u6216\u91CD\u590D");
+      }
+      ids.add(current.id);
+      const key = Buffer.from(current.key);
+      if (key.length !== 32) throw new Error("Node \u4E8B\u4EF6\u961F\u5217\u5BC6\u94A5\u5FC5\u987B\u4E3A 32 \u5B57\u8282");
+      return { id: current.id, key };
+    });
+    this.directory = path.resolve(options.directory);
+    this.maxItems = Math.min(1e4, Math.max(1, options.maxItems ?? 1e3));
+    this.maxBytes = Math.min(512 * 1024 * 1024, Math.max(1024, options.maxBytes ?? 50 * 1024 * 1024));
+    this.maxAgeMs = Math.min(30 * 24 * 60 * 60 * 1e3, Math.max(6e4, options.maxAgeMs ?? 24 * 60 * 60 * 1e3));
+    this.lockTimeoutMs = Math.min(3e4, Math.max(100, options.lockTimeoutMs ?? 2e3));
+    this.staleLockMs = Math.min(12e4, Math.max(1e3, options.staleLockMs ?? 3e4));
+  }
+  load(now) {
+    return this.runExclusive(
+      async () => this.withLock(async () => {
+        const items = await this.readItems();
+        const retained = items.filter((item) => now - item.enqueuedAt <= this.maxAgeMs);
+        if (retained.length !== items.length) await this.writeItems(retained);
+        return structuredClone(retained);
+      })
+    );
+  }
+  put(item) {
+    return this.runExclusive(
+      async () => this.withLock(async () => {
+        const items = (await this.readItems()).filter((current) => current.id !== item.id);
+        items.push(structuredClone(item));
+        items.sort((first, second) => first.enqueuedAt - second.enqueuedAt);
+        let bytes = items.reduce((total, current) => total + Math.max(0, current.bytes), 0);
+        while (items.length > this.maxItems || bytes > this.maxBytes) {
+          const removed = items.shift();
+          if (!removed) break;
+          bytes -= Math.max(0, removed.bytes);
+        }
+        await this.writeItems(items);
+      })
+    );
+  }
+  remove(ids) {
+    if (ids.length === 0) return Promise.resolve();
+    const removedIds = new Set(ids);
+    return this.runExclusive(
+      async () => this.withLock(async () => {
+        const items = (await this.readItems()).filter((item) => !removedIds.has(item.id));
+        await this.writeItems(items);
+      })
+    );
+  }
+  clear() {
+    return this.runExclusive(
+      async () => this.withLock(async () => {
+        await unlink(this.statePath()).catch((error) => {
+          if (errorCode(error) !== "ENOENT") throw error;
+        });
+      })
+    );
+  }
+  runExclusive(operation) {
+    const result = this.serial.then(operation, operation);
+    this.serial = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  async ensureDirectory() {
+    await mkdir(this.directory, { recursive: true, mode: 448 });
+    const metadata = await lstat(this.directory);
+    if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+      throw new Error("Node \u4E8B\u4EF6\u961F\u5217\u76EE\u5F55\u4E0D\u5B89\u5168");
+    }
+    await chmod(this.directory, 448);
+  }
+  async withLock(operation) {
+    await this.ensureDirectory();
+    const lockPath = path.join(this.directory, LOCK_FILE);
+    const startedAt = Date.now();
+    let handle;
+    while (!handle) {
+      try {
+        handle = await open(lockPath, "wx", 384);
+      } catch (error) {
+        if (errorCode(error) !== "EEXIST") throw error;
+        const lockStat = await stat(lockPath).catch(() => void 0);
+        if (lockStat && Date.now() - lockStat.mtimeMs > this.staleLockMs) {
+          await unlink(lockPath).catch(() => void 0);
+          continue;
+        }
+        if (Date.now() - startedAt >= this.lockTimeoutMs) {
+          throw new Error("Node \u4E8B\u4EF6\u961F\u5217\u9501\u7B49\u5F85\u8D85\u65F6");
+        }
+        await sleep(20);
+      }
+    }
+    try {
+      return await operation();
+    } finally {
+      await handle.close().catch(() => void 0);
+      await unlink(lockPath).catch(() => void 0);
+    }
+  }
+  statePath() {
+    return path.join(this.directory, STATE_FILE);
+  }
+  async readItems() {
+    const statePath = this.statePath();
+    const metadata = await lstat(statePath).catch((error) => {
+      if (errorCode(error) === "ENOENT") return void 0;
+      throw error;
+    });
+    if (!metadata) return [];
+    if (!metadata.isFile() || metadata.isSymbolicLink()) {
+      throw new Error("Node \u4E8B\u4EF6\u961F\u5217\u72B6\u6001\u6587\u4EF6\u4E0D\u5B89\u5168");
+    }
+    await chmod(statePath, 384);
+    const envelope = JSON.parse(await readFile(statePath, "utf8"));
+    if (envelope.formatVersion !== 2 || typeof envelope.keyId !== "string" || typeof envelope.iv !== "string" || typeof envelope.ciphertext !== "string" || typeof envelope.authTag !== "string") {
+      throw new Error("Node \u4E8B\u4EF6\u961F\u5217\u6587\u4EF6\u683C\u5F0F\u65E0\u6548");
+    }
+    const key = this.keys.find((current) => current.id === envelope.keyId);
+    if (!key) throw new Error("Node \u4E8B\u4EF6\u961F\u5217\u7F3A\u5C11\u89E3\u5BC6\u5BC6\u94A5");
+    const decipher = createDecipheriv("aes-256-gcm", key.key, Buffer.from(envelope.iv, "base64url"));
+    decipher.setAAD(Buffer.from(`${AAD_PREFIX}:${envelope.keyId}`));
+    decipher.setAuthTag(Buffer.from(envelope.authTag, "base64url"));
+    const plaintext = Buffer.concat([
+      decipher.update(Buffer.from(envelope.ciphertext, "base64url")),
+      decipher.final()
+    ]);
+    const parsed = JSON.parse(plaintext.toString("utf8"));
+    if (!Array.isArray(parsed.items) || !parsed.items.every(isQueueItem)) {
+      throw new Error("Node \u4E8B\u4EF6\u961F\u5217\u5185\u5BB9\u65E0\u6548");
+    }
+    return parsed.items.sort((first, second) => first.enqueuedAt - second.enqueuedAt);
+  }
+  async writeItems(items) {
+    const statePath = this.statePath();
+    if (items.length === 0) {
+      await unlink(statePath).catch((error) => {
+        if (errorCode(error) !== "ENOENT") throw error;
+      });
+      return;
+    }
+    const currentKey = this.keys[0];
+    const iv = randomBytes(12);
+    const cipher = createCipheriv("aes-256-gcm", currentKey.key, iv);
+    cipher.setAAD(Buffer.from(`${AAD_PREFIX}:${currentKey.id}`));
+    const ciphertext = Buffer.concat([
+      cipher.update(JSON.stringify({ items })),
+      cipher.final()
+    ]);
+    const envelope = {
+      formatVersion: 2,
+      keyId: currentKey.id,
+      iv: iv.toString("base64url"),
+      ciphertext: ciphertext.toString("base64url"),
+      authTag: cipher.getAuthTag().toString("base64url")
+    };
+    const temporaryPath = path.join(
+      this.directory,
+      `${STATE_FILE}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`
+    );
+    const handle = await open(temporaryPath, "wx", 384);
+    try {
+      await handle.writeFile(JSON.stringify(envelope), "utf8");
+      await handle.sync();
+      await handle.close();
+      await rename(temporaryPath, statePath);
+      await chmod(statePath, 384);
+    } catch (error) {
+      await handle.close().catch(() => void 0);
+      await unlink(temporaryPath).catch(() => void 0);
+      throw error;
+    }
+  }
+};
+function builtInModules() {
+  const require2 = createRequire(import.meta.url);
+  return [
+    require2("node:http"),
+    require2("node:https")
+  ];
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !(value instanceof URL);
+}
+function requestOptions(args) {
+  if (isRecord(args[0])) return args[0];
+  return isRecord(args[1]) ? args[1] : {};
 }
+function requestUrl(args, options) {
+  const first = args[0];
+  if (first instanceof URL) return first;
+  if (typeof first === "string") {
+    try {
+      return new URL(first);
+    } catch {
+      return void 0;
+    }
+  }
+  const protocol = typeof options.protocol === "string" ? options.protocol : "http:";
+  const hostname = typeof options.hostname === "string" ? options.hostname : typeof options.host === "string" ? options.host : void 0;
+  if (!hostname) return void 0;
+  const path2 = typeof options.path === "string" ? options.path : "/";
+  try {
+    return new URL(path2, `${protocol}//${hostname}`);
+  } catch {
+    return void 0;
+  }
+}
+function normalizedHeaders(value) {
+  if (value instanceof Headers) return Object.fromEntries(value.entries());
+  return isRecord(value) ? { ...value } : {};
+}
+function instrumentedArguments(args, headers) {
+  const next = [...args];
+  if (isRecord(next[0])) {
+    next[0] = { ...next[0], headers };
+    return next;
+  }
+  if (isRecord(next[1])) next[1] = { ...next[1], headers };
+  else next.splice(1, 0, { headers });
+  return next;
+}
+function installNodeHttpInstrumentation(monitor, options = {}) {
+  const restorers = [];
+  for (const module of options.modules ?? builtInModules()) {
+    for (const key of ["request", "get"]) {
+      const original = module[key];
+      if (typeof original !== "function") continue;
+      const instrumented = function instrumentedRequest(...args) {
+        const currentOptions = requestOptions(args);
+        const method = typeof currentOptions.method === "string" ? currentOptions.method.trim().toUpperCase().slice(0, 32) || "GET" : "GET";
+        const url = requestUrl(args, currentOptions);
+        if (options.shouldTrace && !options.shouldTrace(method, url)) {
+          return original.apply(module, args);
+        }
+        const span = monitor.startSpan(`HTTP ${method}`, {
+          attributes: {
+            "http.method": method,
+            ...url ? { "url.path": url.pathname.slice(0, 2048) || "/" } : {}
+          }
+        });
+        const headers = normalizedHeaders(currentOptions.headers);
+        if (options.shouldPropagateTraceContext?.(url) === true) {
+          Object.assign(headers, span.toTraceHeaders());
+        }
+        let request;
+        try {
+          request = original.apply(module, instrumentedArguments(args, headers));
+        } catch (error) {
+          span.end("error");
+          throw error;
+        }
+        let finished = false;
+        const finish = (status, response) => {
+          if (finished) return;
+          finished = true;
+          if (response?.statusCode) span.setAttribute("http.status_code", response.statusCode);
+          span.end(status);
+        };
+        request.once("response", (response) => {
+          const status = response.statusCode ?? 0;
+          response.once("end", () => finish(status >= 400 ? "error" : "ok", response));
+          response.once("aborted", () => finish("error", response));
+          response.once("error", () => finish("error", response));
+        });
+        request.once("error", () => finish("error"));
+        request.once("abort", () => finish("error"));
+        return request;
+      };
+      module[key] = instrumented;
+      restorers.push(() => {
+        if (module[key] === instrumented) module[key] = original;
+      });
+    }
+  }
+  return () => {
+    for (const restore of restorers.reverse()) restore();
+  };
+}
+
+// src/node/index.ts
 function delay(timeoutMs) {
   return new Promise((resolve) => setTimeout(resolve, timeoutMs));
 }
@@ -55,31 +372,124 @@ var NodeRelayTransport = class {
           redirect: "error",
           signal: controller.signal
         });
-        if (response.status === 202) return { kind: "accepted" };
-        if (response.status !== 429 && response.status < 500) {
-          let code = `http_${response.status}`;
-          try {
-            const value = await response.json();
-            if (typeof value.code === "string") code = value.code;
-          } catch {
-          }
-          return { kind: "permanent_error", code };
+        const outcome = await parseTransportResponse(response, envelope);
+        if (outcome.kind === "batch" || outcome.kind === "permanent_error") return outcome;
+        const waitMs = outcome.kind === "retryable" && outcome.retryAfterMs > 0 ? outcome.retryAfterMs : Math.min(3e4, this.retryBaseMs * 2 ** attempt);
+        if (attempt + 1 >= this.maxAttempts) {
+          return {
+            kind: "retryable",
+            retryAfterMs: waitMs,
+            code: outcome.code
+          };
         }
-        const waitMs = retryAfter(response) ?? Math.min(3e4, this.retryBaseMs * 2 ** attempt);
-        if (attempt + 1 >= this.maxAttempts) return { kind: "retryable", retryAfterMs: waitMs };
         await delay(waitMs);
       } catch {
-        if (attempt + 1 >= this.maxAttempts) return { kind: "network_error" };
+        if (attempt + 1 >= this.maxAttempts) {
+          return { kind: "network_error", code: "network_error" };
+        }
         await delay(Math.min(3e4, this.retryBaseMs * 2 ** attempt));
       } finally {
         clearTimeout(timer);
       }
     }
-    return { kind: "network_error" };
+    return { kind: "network_error", code: "network_error" };
+  }
+  async loadRemoteConfig() {
+    const result = await this.loadRemoteConfigResult();
+    return result.kind === "configured" ? result.config : void 0;
+  }
+  async loadRemoteConfigResult() {
+    const endpoint = new URL(this.endpoint);
+    endpoint.pathname = "/v1/relay/config";
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+    try {
+      const response = await this.fetcher(endpoint, {
+        method: "GET",
+        headers: {
+          "x-faultlens-key-id": this.ingest.keyId,
+          "x-faultlens-key-version": this.ingest.keyVersion
+        },
+        cache: "no-store",
+        redirect: "error",
+        signal: controller.signal
+      });
+      if (response.status === 404) return { kind: "unsupported", code: "config_not_found" };
+      if (response.status === 422) return { kind: "unsupported", code: "unsupported_protocol" };
+      if (!response.ok) return { kind: "retryable_error", code: `http_${response.status}` };
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        return { kind: "retryable_error", code: "invalid_remote_config" };
+      }
+      const config = parseRemoteSdkConfig(body);
+      return config ? { kind: "configured", config } : { kind: "retryable_error", code: "invalid_remote_config" };
+    } catch {
+      return { kind: "retryable_error", code: "network_error" };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+var NodeRelayTelemetryTransport = class {
+  constructor(ingest, options = {}) {
+    this.ingest = ingest;
+    const endpoint = new URL(ingest.endpoint);
+    const local = endpoint.hostname === "localhost" || endpoint.hostname === "127.0.0.1";
+    if (endpoint.protocol !== "https:" && !(endpoint.protocol === "http:" && local)) {
+      throw new Error("Node Relay Endpoint \u5FC5\u987B\u4F7F\u7528 HTTPS");
+    }
+    if (endpoint.pathname !== "/v1/relay/envelope" || endpoint.username || endpoint.password || endpoint.search || endpoint.hash) {
+      throw new Error("Node Relay Endpoint \u683C\u5F0F\u65E0\u6548");
+    }
+    if (!ingest.keyId || !ingest.keyVersion || !ingest.secret) {
+      throw new Error("Node Relay \u51ED\u636E\u4E0D\u5B8C\u6574");
+    }
+    endpoint.pathname = "/v1/relay/telemetry";
+    this.endpoint = endpoint.toString();
+    this.fetcher = options.fetcher ?? fetch;
+    this.requestTimeoutMs = Math.min(12e4, Math.max(100, options.requestTimeoutMs ?? 5e3));
+  }
+  fetcher;
+  requestTimeoutMs;
+  endpoint;
+  async send(envelope) {
+    const body = JSON.stringify(envelope);
+    const telemetryId = envelope.traces[0]?.telemetryId ?? envelope.spans[0]?.telemetryId ?? envelope.webVitals[0]?.telemetryId;
+    if (!telemetryId) return { kind: "permanent_error", code: "empty_telemetry_envelope" };
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+    try {
+      const response = await this.fetcher(this.endpoint, {
+        method: "POST",
+        headers: createSignedRelayHeaders({
+          upstream: this.endpoint,
+          relayKeyId: this.ingest.keyId,
+          relayKeyVersion: this.ingest.keyVersion,
+          relaySecret: this.ingest.secret
+        }, body, telemetryId),
+        body,
+        cache: "no-store",
+        redirect: "error",
+        signal: controller.signal
+      });
+      return await parseTelemetryTransportResponse(response, envelope);
+    } catch {
+      return { kind: "network_error", code: "network_error" };
+    } finally {
+      clearTimeout(timer);
+    }
   }
 };
 function createNodeErrorMonitor(options, overrides = {}) {
-  const { captureGlobalErrors = true, ingest, ...monitorOptions } = options;
+  const {
+    captureGlobalErrors = true,
+    ingest,
+    persistentQueue: persistentQueueOptions,
+    ...monitorOptions
+  } = options;
+  const spanStorage = new AsyncLocalStorage();
   const monitor = createMonitorRuntime(
     {
       ...monitorOptions,
@@ -87,7 +497,13 @@ function createNodeErrorMonitor(options, overrides = {}) {
     },
     {
       ...overrides,
-      transport: overrides.transport ?? new NodeRelayTransport(ingest)
+      ...overrides.persistentQueue ? { persistentQueue: overrides.persistentQueue } : persistentQueueOptions ? { persistentQueue: new NodeEncryptedFileQueue(persistentQueueOptions) } : {},
+      transport: overrides.transport ?? new NodeRelayTransport(ingest),
+      telemetryTransport: overrides.telemetryTransport ?? new NodeRelayTelemetryTransport(ingest),
+      spanContextManager: overrides.spanContextManager ?? {
+        active: () => spanStorage.getStore(),
+        run: (span, callback) => spanStorage.run(span, callback)
+      }
     }
   );
   if (!captureGlobalErrors) return monitor;
@@ -114,4 +530,4 @@ function createNodeErrorMonitor(options, overrides = {}) {
   return monitor;
 }
 
-export { NodeRelayTransport, createNodeErrorMonitor };
+export { NodeEncryptedFileQueue, NodeRelayTelemetryTransport, NodeRelayTransport, createNodeErrorMonitor, installNodeHttpInstrumentation };

package/dist/nuxt/runtime/nitro-plugin.js

@@ -1,4 +1,4 @@
-import { clientRedact, SDK_VERSION, parseErrorStack } from '../../chunk-LRHXSFK2.js';
+import { clientRedact, SDK_VERSION, parseErrorStack } from '../../chunk-ZUVQIOFO.js';
 import { createSignedRelayHeaders } from '../../chunk-RXQF7F2E.js';
 import { randomUUID } from 'crypto';
 

package/dist/nuxt/runtime/plugin.js

@@ -1,6 +1,6 @@
-import { createErrorMonitor } from '../../chunk-K63I3OJT.js';
+import { createErrorMonitor } from '../../chunk-6LF3JLVG.js';
 import { installVueErrorMonitor } from '../../chunk-P6Q63P6L.js';
-import '../../chunk-LRHXSFK2.js';
+import '../../chunk-ZUVQIOFO.js';
 import { defineNuxtPlugin, useRuntimeConfig } from '#app';
 
 var plugin_default = defineNuxtPlugin({

package/dist/react/index.d.ts

@@ -1,5 +1,5 @@
 import { Component, ReactNode, ErrorInfo } from 'react';
-import { E as ErrorMonitor, M as MonitorOptions } from '../types-DxONWOH8.js';
+import { E as ErrorMonitor, M as MonitorOptions } from '../types-hWS-GSV1.js';
 
 interface ReactMonitorOptions extends Omit<MonitorOptions, "ingest"> {
     ingest: {

package/dist/react/index.js

@@ -1,5 +1,5 @@
-import { createErrorMonitor } from '../chunk-K63I3OJT.js';
-import '../chunk-LRHXSFK2.js';
+import { createErrorMonitor } from '../chunk-6LF3JLVG.js';
+import '../chunk-ZUVQIOFO.js';
 import { Component, createElement } from 'react';
 
 function createReactErrorMonitor(options) {

package/dist/testing/index.d.ts

@@ -1,11 +1,19 @@
-import { c as EventTransport, d as EventEnvelope, T as TransportOutcome, M as MonitorOptions, E as ErrorMonitor } from '../types-DxONWOH8.js';
+import { T as TelemetryTransport, a as TelemetryEnvelope, b as TelemetryTransportOutcome, j as EventTransport, k as EventEnvelope, l as TransportOutcome, R as RemoteSdkConfig, M as MonitorOptions, E as ErrorMonitor } from '../types-hWS-GSV1.js';
 
 declare class TestTransport implements EventTransport {
+    private readonly remoteConfig?;
     readonly envelopes: EventEnvelope[];
     private readonly outcomes;
-    constructor(outcomes?: TransportOutcome[]);
+    constructor(outcomes?: TransportOutcome[], remoteConfig?: RemoteSdkConfig | undefined);
     send(envelope: EventEnvelope): Promise<TransportOutcome>;
+    loadRemoteConfig(): Promise<RemoteSdkConfig | undefined>;
 }
-declare function createTestMonitor(options: MonitorOptions, transport: EventTransport): ErrorMonitor;
+declare class TestTelemetryTransport implements TelemetryTransport {
+    readonly envelopes: TelemetryEnvelope[];
+    private readonly outcomes;
+    constructor(outcomes?: TelemetryTransportOutcome[]);
+    send(envelope: TelemetryEnvelope): Promise<TelemetryTransportOutcome>;
+}
+declare function createTestMonitor(options: MonitorOptions, transport: EventTransport, telemetryTransport?: TelemetryTransport): ErrorMonitor;
 
-export { TestTransport, createTestMonitor };
+export { TestTelemetryTransport, TestTransport, createTestMonitor };

package/dist/testing/index.js

@@ -1,24 +1,61 @@
-import { createMonitorRuntime } from '../chunk-LRHXSFK2.js';
+import { createMonitorRuntime } from '../chunk-ZUVQIOFO.js';
 
 // src/testing/index.ts
 var TestTransport = class {
+  constructor(outcomes = [], remoteConfig) {
+    this.remoteConfig = remoteConfig;
+    this.outcomes = [...outcomes];
+  }
+  envelopes = [];
+  outcomes;
+  async send(envelope) {
+    this.envelopes.push(structuredClone(envelope));
+    return this.outcomes.shift() ?? {
+      kind: "batch",
+      ingestId: `test-ingest-${this.envelopes.length}`,
+      results: envelope.events.map((event) => ({
+        eventId: event.eventId,
+        status: "accepted"
+      })),
+      retryAfterMs: 0
+    };
+  }
+  async loadRemoteConfig() {
+    return this.remoteConfig ? structuredClone(this.remoteConfig) : void 0;
+  }
+};
+var TestTelemetryTransport = class {
   envelopes = [];
   outcomes;
-  constructor(outcomes = [{ kind: "accepted" }]) {
+  constructor(outcomes = []) {
     this.outcomes = [...outcomes];
   }
   async send(envelope) {
     this.envelopes.push(structuredClone(envelope));
-    return this.outcomes.shift() ?? { kind: "accepted" };
+    return this.outcomes.shift() ?? {
+      kind: "batch",
+      ingestId: `test-telemetry-${this.envelopes.length}`,
+      results: [
+        ...envelope.traces,
+        ...envelope.spans,
+        ...envelope.webVitals
+      ].map((item) => ({ telemetryId: item.telemetryId, status: "accepted" })),
+      retryAfterMs: 0
+    };
   }
 };
-function createTestMonitor(options, transport) {
+function createTestMonitor(options, transport, telemetryTransport = new TestTelemetryTransport()) {
   let sequence = 0;
+  let traceSequence = 0;
+  let spanSequence = 0;
   return createMonitorRuntime(options, {
     transport,
+    telemetryTransport,
     random: () => 0,
-    createEventId: () => `test-event-${++sequence}`
+    createEventId: () => `test-event-${++sequence}`,
+    createTraceId: () => (++traceSequence).toString(16).padStart(32, "0"),
+    createSpanId: () => (++spanSequence).toString(16).padStart(16, "0")
   });
 }
 
-export { TestTransport, createTestMonitor };
+export { TestTelemetryTransport, TestTransport, createTestMonitor };