@devkitio/faultlens 0.1.5 → 1.0.1

package/dist/types-hWS-GSV1.d.ts

@@ -0,0 +1,302 @@
+interface StackFrame {
+    filename: string;
+    function?: string;
+    line?: number;
+    column?: number;
+    inApp: boolean;
+    debugId?: string;
+}
+interface ErrorEvent {
+    eventId: string;
+    occurredAt: string;
+    type: string;
+    message: string;
+    handled: boolean;
+    mechanism: string;
+    level: "debug" | "info" | "warning" | "error" | "fatal";
+    stack: StackFrame[];
+    tags: Record<string, string>;
+    context?: unknown;
+    fingerprint?: string[];
+    traceId?: string;
+    spanId?: string;
+}
+type TelemetryAttributeValue = string | number | boolean;
+type TelemetryAttributes = Record<string, TelemetryAttributeValue>;
+type TelemetryStatus = "unset" | "ok" | "error";
+interface TelemetryTrace {
+    telemetryId: string;
+    occurredAt: string;
+    traceId: string;
+    name: string;
+    startedAt: string;
+    endedAt: string;
+    status: TelemetryStatus;
+    attributes: TelemetryAttributes;
+}
+interface TelemetrySpan {
+    telemetryId: string;
+    occurredAt: string;
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    startedAt: string;
+    endedAt: string;
+    status: TelemetryStatus;
+    attributes: TelemetryAttributes;
+}
+interface WebVital {
+    telemetryId: string;
+    occurredAt: string;
+    name: "CLS" | "FCP" | "FID" | "INP" | "LCP" | "TTFB";
+    value: number;
+    rating: "good" | "needs-improvement" | "poor";
+    pageUrl: string;
+    navigationType?: string;
+    attributes?: TelemetryAttributes;
+}
+interface TelemetryEnvelope {
+    protocolVersion: string;
+    sdkName: string;
+    sdkVersion: string;
+    clientType: "browser" | "relay" | "nitro" | "testing";
+    expectedEnvironment?: string;
+    release: string;
+    dist?: string;
+    buildId: string;
+    clientBatchId: string;
+    traces: TelemetryTrace[];
+    spans: TelemetrySpan[];
+    webVitals: WebVital[];
+}
+interface EventEnvelope {
+    protocolVersion: string;
+    sdkName: string;
+    sdkVersion: string;
+    clientType: "browser" | "relay" | "nitro" | "testing";
+    expectedEnvironment?: string;
+    release: string;
+    dist?: string;
+    buildId: string;
+    clientBatchId: string;
+    events: ErrorEvent[];
+}
+
+interface TraceContext {
+    traceId: string;
+    spanId: string;
+    traceFlags: string;
+    traceState?: string;
+    traceVersion?: string;
+}
+declare function parseTraceParent(traceParent: string | null | undefined, traceState?: string | null): TraceContext | undefined;
+declare function formatTraceParent(context: TraceContext): string;
+declare function traceContextHeaders(context: TraceContext): Record<string, string>;
+
+type ContextMode = "minimal" | "full";
+type IngestConfig = {
+    mode: "direct";
+    dsn: string;
+} | {
+    mode: "relay";
+    endpoint: string;
+};
+interface CaptureOptions {
+    handled?: boolean;
+    mechanism?: string;
+    context?: unknown;
+    level?: ErrorEvent["level"];
+    tags?: Record<string, string>;
+    traceId?: string;
+    spanId?: string;
+}
+interface TelemetryOptions {
+    enabled?: boolean;
+    sampleRate?: number;
+}
+interface SpanOptions {
+    parent?: TraceContext;
+    attributes?: Record<string, string | number | boolean>;
+    startTime?: Date;
+}
+interface Span {
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly parentSpanId?: string;
+    readonly name: string;
+    setAttribute(name: string, value: string | number | boolean): void;
+    setStatus(status: "unset" | "ok" | "error"): void;
+    getTraceContext(): TraceContext;
+    toTraceHeaders(): Record<string, string>;
+    end(status?: "unset" | "ok" | "error"): void;
+}
+interface SpanContextManager {
+    active(): Span | undefined;
+    run<T>(span: Span, callback: () => T): T;
+}
+interface Breadcrumb {
+    category: string;
+    message: string;
+    level?: "debug" | "info" | "warning" | "error";
+    timestamp?: string;
+    data?: unknown;
+}
+interface MonitorOptions {
+    ingest: IngestConfig;
+    expectedEnvironment: string;
+    release: string;
+    dist?: string;
+    buildId?: string;
+    contextMode?: ContextMode;
+    ignoreError?: (error: unknown) => boolean;
+    beforeSend?: (event: ErrorEvent) => ErrorEvent | null | Promise<ErrorEvent | null>;
+    sampleRate?: number;
+    queueLimit?: number;
+    telemetry?: TelemetryOptions;
+    remoteConfigRefreshIntervalMs?: number;
+}
+interface MonitorStatus {
+    queueLength: number;
+    recentSendStatus: "idle" | "sending" | "accepted" | "retryable" | "permanent_error";
+    droppedReasons: Readonly<Record<string, number>>;
+    protocolVersion: string;
+    sdkVersion: string;
+    lastRateLimitedAt: string | null;
+    remotelyDisabled: boolean;
+    telemetryEnabled: boolean;
+    telemetryQueueLength: number;
+    remoteConfigLastRefreshAt: string | null;
+    remoteConfigLastSuccessAt: string | null;
+    remoteConfigFailureCode: string | null;
+    remoteConfigRefreshFailures: number;
+}
+interface ErrorMonitor {
+    captureException(error: unknown, options?: CaptureOptions): string;
+    captureMessage(message: string, options?: CaptureOptions): string;
+    addBreadcrumb(breadcrumb: Breadcrumb): void;
+    setUser(user: Record<string, unknown> | null): void;
+    setContext(name: string, value: unknown): void;
+    startSpan(name: string, options?: SpanOptions): Span;
+    withSpan<T>(name: string, callback: (span: Span) => T, options?: SpanOptions): T;
+    captureWebVital(vital: WebVitalInput): string;
+    getStatus(): MonitorStatus;
+    flush(timeout: number): Promise<boolean>;
+    close(): Promise<boolean>;
+}
+type WebVitalInput = Omit<WebVital, "telemetryId" | "occurredAt"> & {
+    occurredAt?: Date | string;
+};
+type BatchEventStatus = "accepted" | "duplicate" | "rejected" | "retryable";
+interface BatchEventOutcome {
+    eventId: string;
+    status: BatchEventStatus;
+    errorCode?: string;
+}
+type BatchTransportOutcome = {
+    kind: "batch";
+    ingestId: string;
+    results: BatchEventOutcome[];
+    retryAfterMs: number;
+} | {
+    kind: "retryable";
+    retryAfterMs: number;
+    code: string;
+} | {
+    kind: "permanent_error";
+    code: string;
+} | {
+    kind: "network_error";
+    code: "network_error";
+};
+type TransportOutcome = BatchTransportOutcome;
+type RemoteConfigLoadResult = {
+    kind: "configured";
+    config: RemoteSdkConfig;
+} | {
+    kind: "unsupported";
+    code: "config_not_found" | "unsupported_protocol";
+} | {
+    kind: "retryable_error";
+    code: string;
+};
+interface EventTransport {
+    send(envelope: EventEnvelope): Promise<TransportOutcome>;
+    loadRemoteConfig?(): Promise<RemoteSdkConfig | undefined>;
+    loadRemoteConfigResult?(): Promise<RemoteConfigLoadResult>;
+}
+interface RemoteSdkConfig {
+    enabled?: boolean;
+    sampleRate?: number;
+    errorTypeAllowlist?: string[];
+    queueLimit?: number;
+    retryBaseMs?: number;
+    telemetry?: {
+        enabled?: boolean;
+        sampleRate?: number;
+        dailyQuota?: number;
+        retentionDays?: number;
+    };
+}
+interface TelemetryBatchItemOutcome {
+    telemetryId: string;
+    status: BatchEventStatus;
+    errorCode?: string;
+}
+type TelemetryTransportOutcome = {
+    kind: "batch";
+    ingestId: string;
+    results: TelemetryBatchItemOutcome[];
+    retryAfterMs: number;
+} | {
+    kind: "unsupported";
+    code: string;
+} | {
+    kind: "retryable";
+    retryAfterMs: number;
+    code: string;
+} | {
+    kind: "permanent_error";
+    code: string;
+} | {
+    kind: "network_error";
+    code: "network_error";
+};
+interface TelemetryTransport {
+    send(envelope: TelemetryEnvelope): Promise<TelemetryTransportOutcome>;
+}
+interface RuntimeDependencies {
+    transport: EventTransport;
+    telemetryTransport: TelemetryTransport;
+    now: () => Date;
+    random: () => number;
+    createEventId: () => string;
+    createTraceId: () => string;
+    createSpanId: () => string;
+    spanContextManager: SpanContextManager;
+    persistentQueue: PersistentEventQueue;
+    sendLease: SendLease;
+    installGlobalHandlers: (monitor: ErrorMonitor, transportPath: string) => () => void;
+}
+interface PersistentEventQueue {
+    load(now: number): Promise<PersistedQueueItem[]>;
+    put(item: PersistedQueueItem): Promise<void>;
+    remove(ids: string[]): Promise<void>;
+    clear(): Promise<void>;
+}
+interface PersistedQueueItem {
+    id: string;
+    event: ErrorEvent;
+    enqueuedAt: number;
+    bytes: number;
+    protocolVersion: string;
+    attemptCount: number;
+    nextAttemptAt: number;
+    lastErrorCode?: string;
+}
+interface SendLease {
+    acquire(now: number): boolean;
+    release(): void;
+}
+
+export { type Breadcrumb as B, type CaptureOptions as C, type ErrorMonitor as E, type IngestConfig as I, type MonitorOptions as M, type PersistentEventQueue as P, type RemoteSdkConfig as R, type Span as S, type TelemetryTransport as T, type WebVitalInput as W, type TelemetryEnvelope as a, type TelemetryTransportOutcome as b, type ContextMode as c, type MonitorStatus as d, type SpanOptions as e, type TelemetryOptions as f, type TraceContext as g, formatTraceParent as h, type PersistedQueueItem as i, type EventTransport as j, type EventEnvelope as k, type TransportOutcome as l, type RemoteConfigLoadResult as m, type RuntimeDependencies as n, parseTraceParent as p, traceContextHeaders as t };

package/dist/vue/index.d.ts

@@ -1,4 +1,4 @@
-import { E as ErrorMonitor } from '../types-DxONWOH8.js';
+import { E as ErrorMonitor } from '../types-hWS-GSV1.js';
 
 interface VueLikeApp {
     config: {

package/dist/web-vitals/index.d.ts

@@ -0,0 +1,28 @@
+import { E as ErrorMonitor } from '../types-hWS-GSV1.js';
+
+interface WebVitalsMetric {
+    name: "CLS" | "FCP" | "FID" | "INP" | "LCP" | "TTFB";
+    value: number;
+    rating: "good" | "needs-improvement" | "poor";
+    navigationType?: string;
+}
+type WebVitalsRegistrar = (handler: (metric: WebVitalsMetric) => void, options?: {
+    reportAllChanges?: boolean;
+}) => void | (() => void);
+interface WebVitalsSource {
+    onCLS: WebVitalsRegistrar;
+    onFCP: WebVitalsRegistrar;
+    onFID?: WebVitalsRegistrar;
+    onINP: WebVitalsRegistrar;
+    onLCP: WebVitalsRegistrar;
+    onTTFB: WebVitalsRegistrar;
+}
+interface WebVitalsInstrumentationOptions {
+    source?: WebVitalsSource;
+    reportAllChanges?: boolean;
+    pageUrl?: () => string;
+    attributes?: (metric: WebVitalsMetric) => Record<string, string | number | boolean>;
+}
+declare function installWebVitalsInstrumentation(monitor: ErrorMonitor, options?: WebVitalsInstrumentationOptions): () => void;
+
+export { type WebVitalsInstrumentationOptions, type WebVitalsMetric, type WebVitalsRegistrar, type WebVitalsSource, installWebVitalsInstrumentation };

package/dist/web-vitals/index.js

@@ -0,0 +1,58 @@
+import { onTTFB, onLCP, onINP, onFCP, onCLS } from 'web-vitals';
+
+// src/web-vitals/index.ts
+function metricAdapter(handler) {
+  return (metric) => handler({
+    name: metric.name,
+    value: metric.value,
+    rating: metric.rating,
+    ...metric.navigationType ? { navigationType: metric.navigationType } : {}
+  });
+}
+var defaultSource = {
+  onCLS: (handler, options) => onCLS(metricAdapter(handler), options),
+  onFCP: (handler, options) => onFCP(metricAdapter(handler), options),
+  onINP: (handler, options) => onINP(metricAdapter(handler), options),
+  onLCP: (handler, options) => onLCP(metricAdapter(handler), options),
+  onTTFB: (handler, options) => onTTFB(metricAdapter(handler), options)
+};
+function installWebVitalsInstrumentation(monitor, options = {}) {
+  const source = options.source ?? defaultSource;
+  const cleanup = [];
+  let active = true;
+  const handler = (metric) => {
+    if (!active) return;
+    const pageUrl = options.pageUrl?.() ?? (typeof location !== "undefined" ? location.href : "");
+    monitor.captureWebVital({
+      name: metric.name,
+      value: metric.value,
+      rating: metric.rating,
+      pageUrl,
+      ...metric.navigationType ? { navigationType: metric.navigationType } : {},
+      ...options.attributes ? { attributes: options.attributes(metric) } : {}
+    });
+  };
+  const registrars = [
+    source.onCLS,
+    source.onFCP,
+    source.onFID,
+    source.onINP,
+    source.onLCP,
+    source.onTTFB
+  ].filter((registrar) => typeof registrar === "function");
+  for (const registrar of registrars) {
+    try {
+      const remove = registrar(handler, { reportAllChanges: options.reportAllChanges ?? false });
+      if (remove) cleanup.push(remove);
+    } catch {
+      continue;
+    }
+  }
+  return () => {
+    if (!active) return;
+    active = false;
+    for (const remove of cleanup.splice(0)) remove();
+  };
+}
+
+export { installWebVitalsInstrumentation };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devkitio/faultlens",
-  "version": "0.1.5",
+  "version": "1.0.1",
   "description": "FaultLens 的 Browser、Node、Vue、Nuxt、React 与 Web 框架错误采集 SDK",
   "license": "UNLICENSED",
   "private": false,
@@ -28,6 +28,10 @@
       "types": "./dist/node/index.d.ts",
       "import": "./dist/node/index.js"
     },
+    "./web-vitals": {
+      "types": "./dist/web-vitals/index.d.ts",
+      "import": "./dist/web-vitals/index.js"
+    },
     "./express": {
       "types": "./dist/express/index.d.ts",
       "import": "./dist/express/index.js"
@@ -48,16 +52,13 @@
   "bin": {
     "faultlens": "dist/cli/index.js"
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "scripts": {
-    "build": "tsup",
-    "check": "tsc -p tsconfig.json --noEmit",
-    "prepack": "pnpm build"
-  },
   "peerDependencies": {
     "@nuxt/kit": ">=4.1.0 <5",
     "@nuxt/schema": ">=4.1.0 <5",
@@ -91,13 +92,20 @@
     }
   },
   "devDependencies": {
-    "@faultlens/security": "workspace:*",
     "@nuxt/kit": "4.1.0",
     "@nuxt/schema": "4.1.0",
     "@types/react": "19.1.11",
     "h3": "1.15.9",
     "react": "19.1.1",
     "tsup": "8.5.0",
-    "vue": "3.5.20"
+    "vue": "3.5.20",
+    "@faultlens/security": "1.0.1"
+  },
+  "dependencies": {
+    "web-vitals": "6.2.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "check": "tsc -p tsconfig.json --noEmit"
   }
-}
+}

package/dist/chunk-K63I3OJT.js

@@ -1,154 +0,0 @@
-import { createMonitorRuntime } from './chunk-LRHXSFK2.js';
-
-// src/browser-queue.ts
-var DATABASE_NAME = "faultlens";
-var STORE_NAME = "events";
-var MAX_BYTES = 5 * 1024 * 1024;
-var MAX_ITEMS = 50;
-var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
-var IndexedDbEventQueue = class {
-  databasePromise;
-  static available() {
-    return typeof indexedDB !== "undefined";
-  }
-  database() {
-    this.databasePromise ??= new Promise((resolve, reject) => {
-      const request = indexedDB.open(DATABASE_NAME, 1);
-      request.onupgradeneeded = () => {
-        const database = request.result;
-        if (!database.objectStoreNames.contains(STORE_NAME)) {
-          const store = database.createObjectStore(STORE_NAME, { keyPath: "id" });
-          store.createIndex("enqueuedAt", "enqueuedAt");
-        }
-      };
-      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.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/index.ts
-function createErrorMonitor(options) {
-  return createMonitorRuntime(options, {
-    ...IndexedDbEventQueue.available() ? { persistentQueue: new IndexedDbEventQueue() } : {},
-    ...BrowserSendLease.available() ? { sendLease: new BrowserSendLease() } : {},
-    installGlobalHandlers
-  });
-}
-
-export { createErrorMonitor };