@devkitio/faultlens 0.1.5 → 1.0.0

package/dist/chunk-6LF3JLVG.js

@@ -0,0 +1,293 @@
+import { createMonitorRuntime } from './chunk-ZUVQIOFO.js';
+
+// src/browser-queue.ts
+var DATABASE_NAME = "faultlens";
+var STORE_NAME = "events";
+var DATABASE_VERSION = 2;
+var MAX_BYTES = 5 * 1024 * 1024;
+var MAX_ITEMS = 50;
+var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+function normalizeItem(item) {
+  return {
+    ...item,
+    protocolVersion: typeof item.protocolVersion === "string" && item.protocolVersion ? item.protocolVersion : "1.0",
+    attemptCount: typeof item.attemptCount === "number" && Number.isInteger(item.attemptCount) ? Math.max(0, item.attemptCount) : 0,
+    nextAttemptAt: typeof item.nextAttemptAt === "number" && Number.isFinite(item.nextAttemptAt) ? item.nextAttemptAt : item.enqueuedAt,
+    ...typeof item.lastErrorCode === "string" ? { lastErrorCode: item.lastErrorCode } : {}
+  };
+}
+var IndexedDbEventQueue = class {
+  databasePromise;
+  static available() {
+    return typeof indexedDB !== "undefined";
+  }
+  database() {
+    this.databasePromise ??= new Promise((resolve, reject) => {
+      const request = indexedDB.open(DATABASE_NAME, DATABASE_VERSION);
+      request.onupgradeneeded = (event) => {
+        const database = request.result;
+        let store;
+        if (!database.objectStoreNames.contains(STORE_NAME)) {
+          store = database.createObjectStore(STORE_NAME, { keyPath: "id" });
+          store.createIndex("enqueuedAt", "enqueuedAt");
+        } else {
+          store = request.transaction.objectStore(STORE_NAME);
+        }
+        if (!store.indexNames.contains("nextAttemptAt")) {
+          store.createIndex("nextAttemptAt", "nextAttemptAt");
+        }
+        if (event.oldVersion < 2) {
+          const cursorRequest = store.openCursor();
+          cursorRequest.onsuccess = () => {
+            const cursor = cursorRequest.result;
+            if (!cursor) return;
+            cursor.update(normalizeItem(cursor.value));
+            cursor.continue();
+          };
+        }
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error ?? new Error("IndexedDB \u6253\u5F00\u5931\u8D25"));
+    });
+    return this.databasePromise;
+  }
+  async all() {
+    const database = await this.database();
+    return new Promise((resolve, reject) => {
+      const request = database.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME).getAll();
+      request.onsuccess = () => resolve(
+        request.result.map(normalizeItem).sort((a, b) => a.enqueuedAt - b.enqueuedAt)
+      );
+      request.onerror = () => reject(request.error ?? new Error("IndexedDB \u8BFB\u53D6\u5931\u8D25"));
+    });
+  }
+  async load(now) {
+    const items = await this.all();
+    const expired = items.filter((item) => now - item.enqueuedAt > MAX_AGE_MS).map((item) => item.id);
+    if (expired.length > 0) await this.remove(expired);
+    return items.filter((item) => now - item.enqueuedAt <= MAX_AGE_MS).slice(-MAX_ITEMS);
+  }
+  async put(item) {
+    const database = await this.database();
+    await new Promise((resolve, reject) => {
+      const request = database.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).put(item);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error ?? new Error("IndexedDB \u5199\u5165\u5931\u8D25"));
+    });
+    const items = await this.all();
+    let bytes = items.reduce((total, current) => total + current.bytes, 0);
+    const removeIds = [];
+    for (const current of items) {
+      if (items.length - removeIds.length <= MAX_ITEMS && bytes <= MAX_BYTES) break;
+      removeIds.push(current.id);
+      bytes -= current.bytes;
+    }
+    if (removeIds.length > 0) await this.remove(removeIds);
+  }
+  async remove(ids) {
+    if (ids.length === 0) return;
+    const database = await this.database();
+    await new Promise((resolve, reject) => {
+      const transaction = database.transaction(STORE_NAME, "readwrite");
+      const store = transaction.objectStore(STORE_NAME);
+      for (const id of ids) store.delete(id);
+      transaction.oncomplete = () => resolve();
+      transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB \u5220\u9664\u5931\u8D25"));
+    });
+  }
+  async clear() {
+    const database = await this.database();
+    await new Promise((resolve, reject) => {
+      const request = database.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).clear();
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error ?? new Error("IndexedDB \u6E05\u7A7A\u5931\u8D25"));
+    });
+  }
+};
+var BrowserSendLease = class {
+  owner = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+  key = "faultlens:send-lease";
+  static available() {
+    try {
+      return typeof localStorage !== "undefined";
+    } catch {
+      return false;
+    }
+  }
+  acquire(now, durationMs = 1e4) {
+    try {
+      const current = JSON.parse(localStorage.getItem(this.key) ?? "null");
+      if (current && current.owner !== this.owner && current.expiresAt > now) return false;
+      localStorage.setItem(this.key, JSON.stringify({ owner: this.owner, expiresAt: now + durationMs }));
+      const confirmed = JSON.parse(localStorage.getItem(this.key) ?? "null");
+      return confirmed?.owner === this.owner;
+    } catch {
+      return true;
+    }
+  }
+  release() {
+    try {
+      const current = JSON.parse(localStorage.getItem(this.key) ?? "null");
+      if (current?.owner === this.owner) localStorage.removeItem(this.key);
+    } catch {
+    }
+  }
+};
+
+// src/global-handlers.ts
+function installGlobalHandlers(monitor, transportPath) {
+  if (typeof window === "undefined") return () => void 0;
+  const onError = (event) => {
+    if (event.filename?.includes(transportPath)) return;
+    if (event.error) {
+      monitor.captureException(event.error, { handled: false, mechanism: "window.error" });
+      return;
+    }
+    const target = event.target;
+    if (target instanceof HTMLScriptElement || target instanceof HTMLLinkElement || target instanceof HTMLImageElement) {
+      const resource = target instanceof HTMLLinkElement ? target.href : target.src;
+      if (!resource.includes(transportPath)) {
+        monitor.captureMessage("\u524D\u7AEF\u8D44\u6E90\u52A0\u8F7D\u5931\u8D25", {
+          handled: false,
+          mechanism: "resource.error",
+          context: { tagName: target.tagName, resource }
+        });
+      }
+    }
+  };
+  const onUnhandledRejection = (event) => {
+    monitor.captureException(event.reason, {
+      handled: false,
+      mechanism: "unhandledrejection"
+    });
+  };
+  window.addEventListener("error", onError, true);
+  window.addEventListener("unhandledrejection", onUnhandledRejection);
+  return () => {
+    window.removeEventListener("error", onError, true);
+    window.removeEventListener("unhandledrejection", onUnhandledRejection);
+  };
+}
+
+// src/instrumentation.ts
+function requestUrl(input) {
+  const raw = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+  try {
+    const base = typeof location !== "undefined" ? location.href : void 0;
+    return new URL(raw, base);
+  } catch {
+    return void 0;
+  }
+}
+function requestMethod(input, init) {
+  const method = init?.method ?? (typeof Request !== "undefined" && input instanceof Request ? input.method : "GET");
+  return method.trim().toUpperCase().slice(0, 32) || "GET";
+}
+function defaultShouldPropagate(url) {
+  return typeof location !== "undefined" && url.origin === location.origin;
+}
+function installFetchInstrumentation(monitor, options = {}) {
+  const target = options.target ?? globalThis;
+  const originalFetch = target.fetch;
+  if (typeof originalFetch !== "function") return () => void 0;
+  const instrumentedFetch = async function instrumentedFetch2(input, init) {
+    if (options.shouldTrace && !options.shouldTrace(input, init)) {
+      return originalFetch.call(target, input, init);
+    }
+    const method = requestMethod(input, init);
+    const url = requestUrl(input);
+    const span = monitor.startSpan(`HTTP ${method}`, {
+      attributes: {
+        "http.method": method,
+        ...url ? { "url.path": url.pathname.slice(0, 2048) || "/" } : {}
+      }
+    });
+    const propagate = url && (options.shouldPropagateTraceContext ?? defaultShouldPropagate)(url);
+    const headers = new Headers(
+      init?.headers ?? (typeof Request !== "undefined" && input instanceof Request ? input.headers : void 0)
+    );
+    if (propagate) {
+      for (const [name, value] of Object.entries(span.toTraceHeaders())) headers.set(name, value);
+    }
+    try {
+      const response = await originalFetch.call(target, input, { ...init, headers });
+      span.setAttribute("http.status_code", response.status);
+      span.end(response.status >= 400 ? "error" : "ok");
+      return response;
+    } catch (error) {
+      span.end("error");
+      throw error;
+    }
+  };
+  target.fetch = instrumentedFetch;
+  return () => {
+    if (target.fetch === instrumentedFetch) target.fetch = originalFetch;
+  };
+}
+function installXhrInstrumentation(monitor, options = {}) {
+  const defaultTarget = globalThis;
+  const target = options.target ?? (defaultTarget.XMLHttpRequest ? defaultTarget : void 0);
+  if (!target?.XMLHttpRequest) return () => void 0;
+  const prototype = target.XMLHttpRequest.prototype;
+  const originalOpen = prototype.open;
+  const originalSend = prototype.send;
+  const originalSetRequestHeader = prototype.setRequestHeader;
+  const states = /* @__PURE__ */ new WeakMap();
+  const instrumentedOpen = function instrumentedOpen2(...args) {
+    const method = typeof args[0] === "string" ? args[0].trim().toUpperCase().slice(0, 32) || "GET" : "GET";
+    const rawUrl = typeof args[1] === "string" || args[1] instanceof URL ? args[1] : "";
+    const url = requestUrl(rawUrl);
+    states.set(this, { method, ...url ? { url } : {} });
+    return originalOpen.apply(this, args);
+  };
+  const instrumentedSend = function instrumentedSend2(...args) {
+    const state = states.get(this) ?? { method: "GET" };
+    if (options.shouldTrace && !options.shouldTrace(state.method, state.url)) {
+      return originalSend.apply(this, args);
+    }
+    const span = monitor.startSpan(`HTTP ${state.method}`, {
+      attributes: {
+        "http.method": state.method,
+        ...state.url ? { "url.path": state.url.pathname.slice(0, 2048) || "/" } : {}
+      }
+    });
+    if (state.url && (options.shouldPropagateTraceContext ?? defaultShouldPropagate)(state.url)) {
+      for (const [name, value] of Object.entries(span.toTraceHeaders())) {
+        originalSetRequestHeader.call(this, name, value);
+      }
+    }
+    let finished = false;
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      if (this.status > 0) span.setAttribute("http.status_code", this.status);
+      span.end(this.status === 0 || this.status >= 400 ? "error" : "ok");
+    };
+    this.addEventListener("loadend", finish, { once: true });
+    this.addEventListener("error", finish, { once: true });
+    this.addEventListener("abort", finish, { once: true });
+    try {
+      return originalSend.apply(this, args);
+    } catch (error) {
+      finish();
+      throw error;
+    }
+  };
+  prototype.open = instrumentedOpen;
+  prototype.send = instrumentedSend;
+  return () => {
+    if (prototype.open === instrumentedOpen) prototype.open = originalOpen;
+    if (prototype.send === instrumentedSend) prototype.send = originalSend;
+  };
+}
+
+// src/index.ts
+function createErrorMonitor(options) {
+  return createMonitorRuntime(options, {
+    ...IndexedDbEventQueue.available() ? { persistentQueue: new IndexedDbEventQueue() } : {},
+    ...BrowserSendLease.available() ? { sendLease: new BrowserSendLease() } : {},
+    installGlobalHandlers
+  });
+}
+
+export { createErrorMonitor, installFetchInstrumentation, installXhrInstrumentation };