@devkitio/faultlens 1.0.1 → 1.0.2

package/dist/{chunk-DQD732MN.js → chunk-ZEZNKS4A.js}

@@ -1,4 +1,4 @@
-import { createMonitorRuntime } from './chunk-YQKZEUXA.js';
+import { createMonitorRuntime, captureHttpError, createHttpErrorContext } from './chunk-ZUSG3UKB.js';
 
 // src/browser-queue.ts
 var DATABASE_NAME = "faultlens";
@@ -170,6 +170,8 @@ function installGlobalHandlers(monitor, transportPath) {
 }
 
 // src/instrumentation.ts
+var fetchInstallations = /* @__PURE__ */ new WeakMap();
+var xhrInstallations = /* @__PURE__ */ new WeakMap();
 function requestUrl(input) {
   const raw = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
   try {
@@ -188,6 +190,11 @@ function defaultShouldPropagate(url) {
 }
 function installFetchInstrumentation(monitor, options = {}) {
   const target = options.target ?? globalThis;
+  const existing = fetchInstallations.get(target);
+  if (existing) {
+    existing.references += 1;
+    return releaseFetchInstallation(target, existing);
+  }
   const originalFetch = target.fetch;
   if (typeof originalFetch !== "function") return () => void 0;
   const instrumentedFetch = async function instrumentedFetch2(input, init) {
@@ -212,16 +219,41 @@ function installFetchInstrumentation(monitor, options = {}) {
     try {
       const response = await originalFetch.call(target, input, { ...init, headers });
       span.setAttribute("http.status_code", response.status);
-      span.end(response.status >= 400 ? "error" : "ok");
+      span.end(response.status === 200 ? "ok" : "error");
+      captureHttpError(
+        monitor,
+        "http.fetch",
+        void 0,
+        createHttpErrorContext("response", method, url, response.status),
+        options.shouldCaptureHttpError
+      );
       return response;
     } catch (error) {
       span.end("error");
+      captureHttpError(
+        monitor,
+        "http.fetch",
+        error,
+        createHttpErrorContext("network", method, url, 0),
+        options.shouldCaptureHttpError
+      );
       throw error;
     }
   };
   target.fetch = instrumentedFetch;
+  const installation = { instrumentedFetch, originalFetch, references: 1 };
+  fetchInstallations.set(target, installation);
+  return releaseFetchInstallation(target, installation);
+}
+function releaseFetchInstallation(target, installation) {
+  let released = false;
   return () => {
-    if (target.fetch === instrumentedFetch) target.fetch = originalFetch;
+    if (released) return;
+    released = true;
+    installation.references -= 1;
+    if (installation.references > 0) return;
+    if (target.fetch === installation.instrumentedFetch) target.fetch = installation.originalFetch;
+    if (fetchInstallations.get(target) === installation) fetchInstallations.delete(target);
   };
 }
 function installXhrInstrumentation(monitor, options = {}) {
@@ -229,6 +261,11 @@ function installXhrInstrumentation(monitor, options = {}) {
   const target = options.target ?? (defaultTarget.XMLHttpRequest ? defaultTarget : void 0);
   if (!target?.XMLHttpRequest) return () => void 0;
   const prototype = target.XMLHttpRequest.prototype;
+  const existing = xhrInstallations.get(prototype);
+  if (existing) {
+    existing.references += 1;
+    return releaseXhrInstallation(prototype, existing);
+  }
   const originalOpen = prototype.open;
   const originalSend = prototype.send;
   const originalSetRequestHeader = prototype.setRequestHeader;
@@ -257,27 +294,53 @@ function installXhrInstrumentation(monitor, options = {}) {
       }
     }
     let finished = false;
-    const finish = () => {
+    const finish = (kind, error) => {
       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");
+      span.end(this.status === 200 ? "ok" : "error");
+      captureHttpError(
+        monitor,
+        "http.xhr",
+        error,
+        createHttpErrorContext(kind, state.method, state.url, this.status),
+        options.shouldCaptureHttpError
+      );
     };
-    this.addEventListener("loadend", finish, { once: true });
-    this.addEventListener("error", finish, { once: true });
-    this.addEventListener("abort", finish, { once: true });
+    this.addEventListener("loadend", () => finish(this.status === 0 ? "network" : "response"), { once: true });
+    this.addEventListener("error", () => finish("network"), { once: true });
+    this.addEventListener("abort", () => finish("network"), { once: true });
     try {
       return originalSend.apply(this, args);
     } catch (error) {
-      finish();
+      finish("network", error);
       throw error;
     }
   };
-  prototype.open = instrumentedOpen;
-  prototype.send = instrumentedSend;
+  const installedOpen = instrumentedOpen;
+  const installedSend = instrumentedSend;
+  prototype.open = installedOpen;
+  prototype.send = installedSend;
+  const installation = {
+    instrumentedOpen: installedOpen,
+    instrumentedSend: installedSend,
+    originalOpen,
+    originalSend,
+    references: 1
+  };
+  xhrInstallations.set(prototype, installation);
+  return releaseXhrInstallation(prototype, installation);
+}
+function releaseXhrInstallation(prototype, installation) {
+  let released = false;
   return () => {
-    if (prototype.open === instrumentedOpen) prototype.open = originalOpen;
-    if (prototype.send === instrumentedSend) prototype.send = originalSend;
+    if (released) return;
+    released = true;
+    installation.references -= 1;
+    if (installation.references > 0) return;
+    if (prototype.open === installation.instrumentedOpen) prototype.open = installation.originalOpen;
+    if (prototype.send === installation.instrumentedSend) prototype.send = installation.originalSend;
+    if (xhrInstallations.get(prototype) === installation) xhrInstallations.delete(prototype);
   };
 }
 

package/dist/{chunk-YQKZEUXA.js → chunk-ZUSG3UKB.js}

@@ -1,3 +1,50 @@
+// src/http-error.ts
+var httpInstrumentationErrors = /* @__PURE__ */ new WeakSet();
+function isHttpInstrumentationError(error) {
+  return typeof error === "object" && error !== null && httpInstrumentationErrors.has(error);
+}
+function defaultShouldCaptureHttpError(context) {
+  return context.kind === "network" || context.status !== 200;
+}
+function createHttpErrorContext(kind, method, url, status) {
+  return {
+    kind,
+    method,
+    status,
+    ...url ? { path: url.pathname.slice(0, 2048) || "/" } : {}
+  };
+}
+function captureHttpError(monitor, mechanism, error, context, shouldCapture = defaultShouldCaptureHttpError) {
+  let accepted = false;
+  try {
+    accepted = shouldCapture(context);
+  } catch {
+    return;
+  }
+  if (!accepted) return;
+  const normalizedError = error instanceof Error ? error : new Error(
+    context.kind === "response" ? `HTTP \u8BF7\u6C42\u8FD4\u56DE ${context.status}` : "HTTP \u8BF7\u6C42\u53D1\u751F\u7F51\u7EDC\u9519\u8BEF"
+  );
+  httpInstrumentationErrors.add(normalizedError);
+  try {
+    monitor.captureException(normalizedError, {
+      handled: true,
+      mechanism,
+      tags: {
+        method: context.method,
+        status: String(context.status)
+      },
+      context: {
+        request: {
+          kind: context.kind,
+          ...context.path ? { path: context.path } : {}
+        }
+      }
+    });
+  } catch {
+  }
+}
+
 // ../security/dist/redaction.js
 var REDACTED = "[\u5DF2\u8131\u654F]";
 var MAX_STRING_LENGTH = 32768;
@@ -411,7 +458,7 @@ function traceContextHeaders(context) {
 }
 
 // src/monitor.ts
-var SDK_VERSION = "1.0.1";
+var SDK_VERSION = "1.0.2";
 var PROTOCOL_VERSION = "1.0";
 var REVOKED_CREDENTIAL_CODES = /* @__PURE__ */ new Set(["invalid_dsn", "relay_key_revoked", "credential_revoked"]);
 function eventId() {
@@ -934,14 +981,16 @@ function createMonitorRuntime(options, overrides = {}) {
       }
       seenErrors.add(error);
     }
-    const fingerprint = shallowFingerprint(event);
-    const seenAt = recentFingerprints.get(fingerprint);
-    const now = dependencies.now().getTime();
-    if (seenAt !== void 0 && now - seenAt < 2e3) {
-      drop("duplicate");
-      return true;
+    if (!isHttpInstrumentationError(error)) {
+      const fingerprint = shallowFingerprint(event);
+      const seenAt = recentFingerprints.get(fingerprint);
+      const now = dependencies.now().getTime();
+      if (seenAt !== void 0 && now - seenAt < 2e3) {
+        drop("duplicate");
+        return true;
+      }
+      recentFingerprints.set(fingerprint, now);
     }
-    recentFingerprints.set(fingerprint, now);
     if (dependencies.random() >= sampleRate) {
       drop("sampled");
       return true;
@@ -1279,4 +1328,4 @@ function createMonitorRuntime(options, overrides = {}) {
   return monitor;
 }
 
-export { FetchTelemetryTransport, SDK_VERSION, clientRedact, createMonitorRuntime, formatTraceParent, parseErrorStack, parseRemoteSdkConfig, parseTelemetryTransportResponse, parseTraceParent, parseTransportResponse, traceContextHeaders };
+export { FetchTelemetryTransport, SDK_VERSION, captureHttpError, clientRedact, createHttpErrorContext, createMonitorRuntime, defaultShouldCaptureHttpError, formatTraceParent, parseErrorStack, parseRemoteSdkConfig, parseTelemetryTransportResponse, parseTraceParent, parseTransportResponse, traceContextHeaders };

package/dist/http-error-DTUBVanG.d.ts

@@ -0,0 +1,10 @@
+interface HttpErrorContext {
+    kind: "response" | "network";
+    method: string;
+    status: number;
+    path?: string;
+}
+type ShouldCaptureHttpError = (context: HttpErrorContext) => boolean;
+declare function defaultShouldCaptureHttpError(context: HttpErrorContext): boolean;
+
+export { type HttpErrorContext as H, type ShouldCaptureHttpError as S, defaultShouldCaptureHttpError as d };

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 import { T as TelemetryTransport, I as IngestConfig, a as TelemetryEnvelope, b as TelemetryTransportOutcome, E as ErrorMonitor, M as MonitorOptions } from './types-hWS-GSV1.js';
 export { B as Breadcrumb, C as CaptureOptions, c as ContextMode, d as MonitorStatus, S as Span, e as SpanOptions, f as TelemetryOptions, g as TraceContext, W as WebVitalInput, h as formatTraceParent, p as parseTraceParent, t as traceContextHeaders } from './types-hWS-GSV1.js';
+import { S as ShouldCaptureHttpError } from './http-error-DTUBVanG.js';
+export { H as HttpErrorContext, d as defaultShouldCaptureHttpError } from './http-error-DTUBVanG.js';
 
 declare class FetchTelemetryTransport implements TelemetryTransport {
     private readonly ingest;
@@ -16,6 +18,7 @@ interface FetchInstrumentationOptions {
     target?: FetchInstrumentationTarget;
     shouldTrace?: (input: RequestInfo | URL, init?: RequestInit) => boolean;
     shouldPropagateTraceContext?: (url: URL) => boolean;
+    shouldCaptureHttpError?: ShouldCaptureHttpError;
 }
 interface XhrInstrumentationTarget {
     XMLHttpRequest: typeof XMLHttpRequest;
@@ -24,10 +27,11 @@ interface XhrInstrumentationOptions {
     target?: XhrInstrumentationTarget;
     shouldTrace?: (method: string, url: URL | undefined) => boolean;
     shouldPropagateTraceContext?: (url: URL) => boolean;
+    shouldCaptureHttpError?: ShouldCaptureHttpError;
 }
 declare function installFetchInstrumentation(monitor: ErrorMonitor, options?: FetchInstrumentationOptions): () => void;
 declare function installXhrInstrumentation(monitor: ErrorMonitor, options?: XhrInstrumentationOptions): () => void;
 
 declare function createErrorMonitor(options: MonitorOptions): ErrorMonitor;
 
-export { ErrorMonitor, type FetchInstrumentationOptions, type FetchInstrumentationTarget, FetchTelemetryTransport, IngestConfig, MonitorOptions, type XhrInstrumentationOptions, type XhrInstrumentationTarget, createErrorMonitor, installFetchInstrumentation, installXhrInstrumentation };
+export { ErrorMonitor, type FetchInstrumentationOptions, type FetchInstrumentationTarget, FetchTelemetryTransport, IngestConfig, MonitorOptions, ShouldCaptureHttpError, type XhrInstrumentationOptions, type XhrInstrumentationTarget, createErrorMonitor, installFetchInstrumentation, installXhrInstrumentation };

package/dist/index.js

@@ -1,2 +1,2 @@
-export { createErrorMonitor, installFetchInstrumentation, installXhrInstrumentation } from './chunk-DQD732MN.js';
-export { FetchTelemetryTransport, formatTraceParent, parseTraceParent, traceContextHeaders } from './chunk-YQKZEUXA.js';
+export { createErrorMonitor, installFetchInstrumentation, installXhrInstrumentation } from './chunk-ZEZNKS4A.js';
+export { FetchTelemetryTransport, defaultShouldCaptureHttpError, formatTraceParent, parseTraceParent, traceContextHeaders } from './chunk-ZUSG3UKB.js';

package/dist/node/index.d.ts

@@ -1,4 +1,6 @@
 import { P as PersistentEventQueue, i as PersistedQueueItem, E as ErrorMonitor, M as MonitorOptions, T as TelemetryTransport, a as TelemetryEnvelope, b as TelemetryTransportOutcome, j as EventTransport, k as EventEnvelope, l as TransportOutcome, R as RemoteSdkConfig, m as RemoteConfigLoadResult, n as RuntimeDependencies } from '../types-hWS-GSV1.js';
+import { S as ShouldCaptureHttpError } from '../http-error-DTUBVanG.js';
+export { H as HttpErrorContext, d as defaultShouldCaptureHttpError } from '../http-error-DTUBVanG.js';
 import { ClientRequest } from 'node:http';
 
 interface NodeQueueEncryptionKey {
@@ -45,6 +47,7 @@ interface NodeHttpInstrumentationOptions {
     modules?: NodeHttpInstrumentationModule[];
     shouldTrace?: (method: string, url: URL | undefined) => boolean;
     shouldPropagateTraceContext?: (url: URL | undefined) => boolean;
+    shouldCaptureHttpError?: ShouldCaptureHttpError;
 }
 declare function installNodeHttpInstrumentation(monitor: ErrorMonitor, options?: NodeHttpInstrumentationOptions): () => void;
 
@@ -90,4 +93,4 @@ declare function createNodeErrorMonitor(options: NodeMonitorOptions, overrides?:
     transport?: EventTransport;
 } & Partial<RuntimeDependencies>): ErrorMonitor;
 
-export { NodeEncryptedFileQueue, type NodeEncryptedFileQueueOptions, type NodeHttpInstrumentationModule, type NodeHttpInstrumentationOptions, type NodeMonitorOptions, type NodeQueueEncryptionKey, type NodeRelayIngestConfig, NodeRelayTelemetryTransport, NodeRelayTransport, type NodeRelayTransportOptions, createNodeErrorMonitor, installNodeHttpInstrumentation };
+export { NodeEncryptedFileQueue, type NodeEncryptedFileQueueOptions, type NodeHttpInstrumentationModule, type NodeHttpInstrumentationOptions, type NodeMonitorOptions, type NodeQueueEncryptionKey, type NodeRelayIngestConfig, NodeRelayTelemetryTransport, NodeRelayTransport, type NodeRelayTransportOptions, ShouldCaptureHttpError, createNodeErrorMonitor, installNodeHttpInstrumentation };

package/dist/node/index.js

@@ -1,4 +1,5 @@
-import { parseTransportResponse, parseRemoteSdkConfig, parseTelemetryTransportResponse, createMonitorRuntime } from '../chunk-YQKZEUXA.js';
+import { parseTransportResponse, parseRemoteSdkConfig, parseTelemetryTransportResponse, createMonitorRuntime, captureHttpError, createHttpErrorContext } from '../chunk-ZUSG3UKB.js';
+export { defaultShouldCaptureHttpError } from '../chunk-ZUSG3UKB.js';
 import { createSignedRelayHeaders } from '../chunk-RXQF7F2E.js';
 import { AsyncLocalStorage } from 'async_hooks';
 import { createDecipheriv, randomBytes, createCipheriv } from 'crypto';
@@ -216,6 +217,7 @@ var NodeEncryptedFileQueue = class {
     }
   }
 };
+var nodeHttpInstallations = /* @__PURE__ */ new WeakMap();
 function builtInModules() {
   const require2 = createRequire(import.meta.url);
   return [
@@ -267,6 +269,13 @@ function instrumentedArguments(args, headers) {
 function installNodeHttpInstrumentation(monitor, options = {}) {
   const restorers = [];
   for (const module of options.modules ?? builtInModules()) {
+    const existing = nodeHttpInstallations.get(module);
+    if (existing) {
+      existing.references += 1;
+      restorers.push(releaseNodeHttpInstallation(module, existing));
+      continue;
+    }
+    const moduleRestorers = [];
     for (const key of ["request", "get"]) {
       const original = module[key];
       if (typeof original !== "function") continue;
@@ -292,35 +301,82 @@ function installNodeHttpInstrumentation(monitor, options = {}) {
           request = original.apply(module, instrumentedArguments(args, headers));
         } catch (error) {
           span.end("error");
+          captureHttpError(
+            monitor,
+            "http.node",
+            error,
+            createHttpErrorContext("network", method, url, 0),
+            options.shouldCaptureHttpError
+          );
           throw error;
         }
-        let finished = false;
-        const finish = (status, response) => {
-          if (finished) return;
-          finished = true;
+        let spanFinished = false;
+        const finishSpan = (status, response) => {
+          if (spanFinished) return false;
+          spanFinished = true;
           if (response?.statusCode) span.setAttribute("http.status_code", response.statusCode);
           span.end(status);
+          return true;
+        };
+        let networkCaptured = false;
+        const captureNetwork = (error, response) => {
+          if (networkCaptured) return;
+          networkCaptured = true;
+          finishSpan("error", response);
+          captureHttpError(
+            monitor,
+            "http.node",
+            error,
+            createHttpErrorContext("network", method, url, response?.statusCode ?? 0),
+            options.shouldCaptureHttpError
+          );
         };
         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));
+          finishSpan(status === 200 ? "ok" : "error", response);
+          captureHttpError(
+            monitor,
+            "http.node",
+            void 0,
+            createHttpErrorContext("response", method, url, status),
+            options.shouldCaptureHttpError
+          );
+          response.once("aborted", () => captureNetwork(void 0, response));
+          response.once("error", (error) => captureNetwork(error, response));
         });
-        request.once("error", () => finish("error"));
-        request.once("abort", () => finish("error"));
+        request.once("error", (error) => captureNetwork(error));
+        request.once("abort", () => captureNetwork());
         return request;
       };
       module[key] = instrumented;
-      restorers.push(() => {
+      moduleRestorers.push(() => {
         if (module[key] === instrumented) module[key] = original;
       });
     }
+    const installation = {
+      references: 1,
+      restore() {
+        for (const restore of moduleRestorers.reverse()) restore();
+      }
+    };
+    nodeHttpInstallations.set(module, installation);
+    restorers.push(releaseNodeHttpInstallation(module, installation));
   }
   return () => {
     for (const restore of restorers.reverse()) restore();
   };
 }
+function releaseNodeHttpInstallation(module, installation) {
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    installation.references -= 1;
+    if (installation.references > 0) return;
+    installation.restore();
+    if (nodeHttpInstallations.get(module) === installation) nodeHttpInstallations.delete(module);
+  };
+}
 
 // src/node/index.ts
 function delay(timeoutMs) {

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

@@ -1,4 +1,4 @@
-import { clientRedact, SDK_VERSION, parseErrorStack } from '../../chunk-YQKZEUXA.js';
+import { clientRedact, SDK_VERSION, parseErrorStack } from '../../chunk-ZUSG3UKB.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-DQD732MN.js';
+import { createErrorMonitor } from '../../chunk-ZEZNKS4A.js';
 import { installVueErrorMonitor } from '../../chunk-P6Q63P6L.js';
-import '../../chunk-YQKZEUXA.js';
+import '../../chunk-ZUSG3UKB.js';
 import { defineNuxtPlugin, useRuntimeConfig } from '#app';
 
 var plugin_default = defineNuxtPlugin({

package/dist/react/index.js

@@ -1,5 +1,5 @@
-import { createErrorMonitor } from '../chunk-DQD732MN.js';
-import '../chunk-YQKZEUXA.js';
+import { createErrorMonitor } from '../chunk-ZEZNKS4A.js';
+import '../chunk-ZUSG3UKB.js';
 import { Component, createElement } from 'react';
 
 function createReactErrorMonitor(options) {

package/dist/testing/index.js

@@ -1,4 +1,4 @@
-import { createMonitorRuntime } from '../chunk-YQKZEUXA.js';
+import { createMonitorRuntime } from '../chunk-ZUSG3UKB.js';
 
 // src/testing/index.ts
 var TestTransport = class {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devkitio/faultlens",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "FaultLens 的 Browser、Node、Vue、Nuxt、React 与 Web 框架错误采集 SDK",
   "license": "UNLICENSED",
   "private": false,
@@ -59,6 +59,11 @@
     "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",
@@ -92,20 +97,16 @@
     }
   },
   "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",
-    "@faultlens/security": "1.0.1"
+    "vue": "3.5.20"
   },
   "dependencies": {
     "web-vitals": "6.2.0"
-  },
-  "scripts": {
-    "build": "tsup",
-    "check": "tsc -p tsconfig.json --noEmit"
   }
-}
+}