@devkitio/faultlens 1.0.1 → 1.1.0

package/dist/axios/index.d.ts

@@ -0,0 +1,31 @@
+import { H as HttpErrorContext } from '../http-error-DTUBVanG.js';
+import { E as ErrorMonitor } from '../types-hWS-GSV1.js';
+
+interface AxiosLikeInterceptorManager {
+    use(onFulfilled?: (value: any) => any, onRejected?: (error: any) => any): number;
+    eject(id: number): void;
+}
+interface AxiosLikeClient {
+    interceptors: {
+        request: AxiosLikeInterceptorManager;
+        response: AxiosLikeInterceptorManager;
+    };
+}
+interface AxiosRequestConfigLike {
+    url?: string;
+    baseURL?: string;
+    method?: string;
+    headers?: unknown;
+    [key: string]: unknown;
+}
+interface AxiosHttpErrorContext extends HttpErrorContext {
+    error: unknown;
+    config?: AxiosRequestConfigLike;
+}
+interface AxiosInstrumentationOptions {
+    shouldPropagateTraceContext?: (url: URL) => boolean;
+    shouldCaptureHttpError?: (context: AxiosHttpErrorContext) => boolean;
+}
+declare function installAxiosInstrumentation(monitor: ErrorMonitor, client: AxiosLikeClient, options?: AxiosInstrumentationOptions): () => void;
+
+export { type AxiosHttpErrorContext, type AxiosInstrumentationOptions, type AxiosLikeClient, type AxiosLikeInterceptorManager, type AxiosRequestConfigLike, installAxiosInstrumentation };

package/dist/axios/index.js

@@ -0,0 +1,123 @@
+import { isHttpSuccessStatus, createHttpErrorContext, defaultShouldCaptureHttpError, captureHttpError } from '../chunk-GKS4FQKU.js';
+
+// src/axios/index.ts
+var installations = /* @__PURE__ */ new WeakMap();
+function record(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function requestUrl(config) {
+  const raw = typeof config?.url === "string" ? config.url.trim() : "";
+  if (!raw) return void 0;
+  const configuredBase = typeof config?.baseURL === "string" ? config.baseURL.trim() : "";
+  const browserBase = typeof location !== "undefined" ? location.href : "";
+  try {
+    return new URL(raw, configuredBase || browserBase || "http://faultlens.invalid");
+  } catch {
+    return void 0;
+  }
+}
+function requestMethod(config) {
+  const method = typeof config?.method === "string" ? config.method : "GET";
+  return method.trim().toUpperCase().slice(0, 32) || "GET";
+}
+function responseStatus(error) {
+  const response = record(error?.response);
+  const status = Number(response?.status ?? 0);
+  return Number.isInteger(status) && status >= 100 && status <= 599 ? status : 0;
+}
+function defaultShouldPropagate(url) {
+  return typeof location !== "undefined" && url.origin === location.origin;
+}
+function setRequestHeader(config, name, value) {
+  const headers = record(config.headers);
+  const set = headers?.set;
+  if (typeof set === "function") {
+    set.call(config.headers, name, value);
+    return;
+  }
+  if (headers) headers[name] = value;
+}
+function installAxiosInstrumentation(monitor, client, options = {}) {
+  const existing = installations.get(client);
+  if (existing) {
+    existing.references += 1;
+    return releaseInstallation(client, existing);
+  }
+  const requestStates = /* @__PURE__ */ new WeakMap();
+  const requestInterceptorId = client.interceptors.request.use((config) => {
+    const configRecord = record(config);
+    const method = requestMethod(configRecord);
+    const url = requestUrl(configRecord);
+    const span = monitor.startSpan(`HTTP ${method}`, {
+      attributes: {
+        "http.method": method,
+        ...url ? { "url.path": url.pathname.slice(0, 2048) || "/" } : {}
+      }
+    });
+    requestStates.set(config, { method, span, ...url ? { url } : {} });
+    if (url && (options.shouldPropagateTraceContext ?? defaultShouldPropagate)(url)) {
+      for (const [name, value] of Object.entries(span.toTraceHeaders())) {
+        setRequestHeader(config, name, value);
+      }
+    }
+    return config;
+  });
+  const responseInterceptorId = client.interceptors.response.use(
+    (response) => {
+      const config = record(response)?.config;
+      const configObject = typeof config === "object" && config !== null ? config : void 0;
+      const state = configObject ? requestStates.get(configObject) : void 0;
+      if (state && configObject) {
+        const status = Number(record(response)?.status ?? 0);
+        if (Number.isInteger(status) && status > 0) {
+          state.span.setAttribute("http.status_code", status);
+        }
+        state.span.end(isHttpSuccessStatus(status) ? "ok" : "error");
+        requestStates.delete(configObject);
+      }
+      return response;
+    },
+    (error) => {
+      const errorRecord = record(error);
+      const configRecord = record(errorRecord?.config);
+      const config = configRecord;
+      const status = responseStatus(errorRecord);
+      const state = config ? requestStates.get(config) : void 0;
+      if (state && config) {
+        if (status > 0) state.span.setAttribute("http.status_code", status);
+        state.span.end(isHttpSuccessStatus(status) ? "ok" : "error");
+        requestStates.delete(config);
+      }
+      const context = createHttpErrorContext(
+        status > 0 ? "response" : "network",
+        state?.method ?? requestMethod(configRecord),
+        state?.url ?? requestUrl(configRecord),
+        status
+      );
+      const shouldCapture = options.shouldCaptureHttpError ? (httpContext) => options.shouldCaptureHttpError?.({
+        ...httpContext,
+        error,
+        ...config ? { config } : {}
+      }) === true : defaultShouldCaptureHttpError;
+      captureHttpError(monitor, "http.axios", error, context, shouldCapture);
+      return Promise.reject(error);
+    }
+  );
+  const installation = { requestInterceptorId, responseInterceptorId, references: 1 };
+  installations.set(client, installation);
+  return releaseInstallation(client, installation);
+}
+function releaseInstallation(client, installation) {
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    installation.references -= 1;
+    if (installation.references > 0) return;
+    client.interceptors.request.eject(installation.requestInterceptorId);
+    client.interceptors.response.eject(installation.responseInterceptorId);
+    if (installations.get(client) === installation) installations.delete(client);
+  };
+}
+
+export { installAxiosInstrumentation };

package/dist/chunk-GKS4FQKU.js

@@ -0,0 +1,51 @@
+// src/http-error.ts
+var httpInstrumentationErrors = /* @__PURE__ */ new WeakSet();
+function isHttpSuccessStatus(status) {
+  return status >= 200 && status < 400;
+}
+function isHttpInstrumentationError(error) {
+  return typeof error === "object" && error !== null && httpInstrumentationErrors.has(error);
+}
+function defaultShouldCaptureHttpError(context) {
+  return context.kind === "network" || context.status >= 500;
+}
+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 {
+  }
+}
+
+export { captureHttpError, createHttpErrorContext, defaultShouldCaptureHttpError, isHttpInstrumentationError, isHttpSuccessStatus };

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

@@ -1,4 +1,5 @@
-import { createMonitorRuntime } from './chunk-YQKZEUXA.js';
+import { createMonitorRuntime } from './chunk-VTX5KF2X.js';
+import { isHttpSuccessStatus, captureHttpError, createHttpErrorContext } from './chunk-GKS4FQKU.js';
 
 // src/browser-queue.ts
 var DATABASE_NAME = "faultlens";
@@ -170,6 +171,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 +191,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 +220,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(isHttpSuccessStatus(response.status) ? "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 +262,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 +295,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(isHttpSuccessStatus(this.status) ? "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-VTX5KF2X.js}

@@ -1,3 +1,5 @@
+import { isHttpInstrumentationError } from './chunk-GKS4FQKU.js';
+
 // ../security/dist/redaction.js
 var REDACTED = "[\u5DF2\u8131\u654F]";
 var MAX_STRING_LENGTH = 32768;
@@ -411,7 +413,7 @@ function traceContextHeaders(context) {
 }
 
 // src/monitor.ts
-var SDK_VERSION = "1.0.1";
+var SDK_VERSION = "1.1.0";
 var PROTOCOL_VERSION = "1.0";
 var REVOKED_CREDENTIAL_CODES = /* @__PURE__ */ new Set(["invalid_dsn", "relay_key_revoked", "credential_revoked"]);
 function eventId() {
@@ -934,14 +936,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;

package/dist/cli/index.js

@@ -1,10 +1,14 @@
 #!/usr/bin/env node
 import { realpathSync } from 'fs';
-import { lstat, readdir, readFile, writeFile, unlink } from 'fs/promises';
+import { lstat, writeFile, unlink, readdir, readFile } from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { randomUUID, createHash } from 'crypto';
+import { promisify } from 'util';
+import { gzip, brotliCompress } from 'zlib';
 
+var gzipAsync = promisify(gzip);
+var brotliCompressAsync = promisify(brotliCompress);
 var DEBUG_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var SOURCE_MAP_REFERENCE_PATTERN = /(?:\/\*[#@]\s*sourceMappingURL=.*?\*\/|\/\/[#@]\s*sourceMappingURL=.*?$)/gm;
 var DEBUG_ID_COMMENT_PATTERN = /^\/\/#\s*debugId=[0-9a-f-]{36}\s*$/gim;
@@ -73,13 +77,16 @@ async function prepareOne(root, absolutePath, dryRun) {
   const preparedBundle = `${cleanedBundle}
 ${runtimeInjection(debugId)}
 `;
+  const bundleBody = Buffer.from(preparedBundle, "utf8");
   if (!dryRun) {
     await writeFile(absolutePath, body, { mode: 384 });
-    await writeFile(bundlePath, preparedBundle, { mode: 384 });
+    await writeFile(bundlePath, bundleBody, { mode: 384 });
   }
   return {
     absolutePath,
     relativePath,
+    bundleAbsolutePath: bundlePath,
+    bundleBody,
     sha256: createHash("sha256").update(body).digest("hex"),
     size: body.byteLength,
     debugId,
@@ -92,6 +99,37 @@ async function prepareSourceMapArtifacts(root, dryRun) {
   if (!rootStats.isDirectory() || rootStats.isSymbolicLink()) throw new Error("--root \u5FC5\u987B\u662F\u771F\u5B9E\u76EE\u5F55");
   return Promise.all((await sourceMapFiles(resolvedRoot)).map((file) => prepareOne(resolvedRoot, file, dryRun)));
 }
+async function compressedSiblingExists(absolutePath) {
+  try {
+    const stats = await lstat(absolutePath);
+    if (!stats.isFile() || stats.isSymbolicLink()) {
+      throw new Error(`\u538B\u7F29\u8FD0\u884C\u5236\u54C1\u5FC5\u987B\u662F\u771F\u5B9E\u6587\u4EF6\uFF1A${absolutePath}`);
+    }
+    return true;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function synchronizeCompressedBundles(artifacts, dryRun) {
+  const synchronizedBundles = /* @__PURE__ */ new Set();
+  for (const artifact of artifacts) {
+    if (synchronizedBundles.has(artifact.bundleAbsolutePath)) continue;
+    synchronizedBundles.add(artifact.bundleAbsolutePath);
+    const gzipPath = `${artifact.bundleAbsolutePath}.gz`;
+    const brotliPath = `${artifact.bundleAbsolutePath}.br`;
+    if (await compressedSiblingExists(gzipPath)) {
+      const compressed = await gzipAsync(artifact.bundleBody);
+      if (!dryRun) await writeFile(gzipPath, compressed, { mode: 384 });
+    }
+    if (await compressedSiblingExists(brotliPath)) {
+      const compressed = await brotliCompressAsync(artifact.bundleBody);
+      if (!dryRun) await writeFile(brotliPath, compressed, { mode: 384 });
+    }
+  }
+}
 async function removeUploadedSourceMaps(artifacts) {
   for (const artifact of artifacts) await unlink(artifact.absolutePath);
 }
@@ -99,7 +137,10 @@ async function removeUploadedSourceMaps(artifacts) {
 // src/cli/index.ts
 function argument(args, name) {
   const index = args.indexOf(name);
-  return index >= 0 ? args[index + 1] : void 0;
+  if (index < 0) return void 0;
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) throw new Error(`\u7F3A\u5C11 ${name} \u7684\u53C2\u6570\u503C`);
+  return value;
 }
 function required(value, label) {
   if (!value) throw new Error(`\u7F3A\u5C11 ${label}`);
@@ -171,7 +212,7 @@ async function upload(config, artifacts) {
   }
   console.info(`\u4E0A\u4F20\u5B8C\u6210\uFF1A${artifacts.length} \u4E2A Source Map \u6587\u4EF6`);
 }
-async function verify(config, artifacts) {
+async function verify(config, artifacts, deleteAfterVerify = config.deleteAfterVerify) {
   const token = required(config.token, "--token \u6216 FAULTLENS_SOURCEMAP_TOKEN");
   const response = await fetch(`${config.endpoint.replace(/\/$/, "")}/v1/admin/source-maps/verify`, {
     method: "POST",
@@ -193,7 +234,7 @@ async function verify(config, artifacts) {
     redirect: "error"
   });
   if (!response.ok) throw new Error(`\u5236\u54C1\u6E05\u5355\u6821\u9A8C\u5931\u8D25\uFF0C\u72B6\u6001\u7801 ${response.status}`);
-  if (config.deleteAfterVerify) await removeUploadedSourceMaps(artifacts);
+  if (deleteAfterVerify) await removeUploadedSourceMaps(artifacts);
   console.info("Source Map \u5236\u54C1\u6E05\u5355\u4E0E\u670D\u52A1\u7AEF\u4E00\u81F4");
 }
 async function doctor(config) {
@@ -208,13 +249,27 @@ async function runFaultLensCli(args, env = process.env) {
   const subcommand = args[1];
   const config = resolveCliOptions(args, env);
   if (command === "doctor") return doctor(config);
-  if (command !== "sourcemaps" || !["upload", "verify"].includes(subcommand ?? "")) {
-    throw new Error("\u7528\u6CD5\uFF1Afaultlens sourcemaps <upload|verify> [\u53C2\u6570]\uFF0C\u6216 faultlens doctor [\u53C2\u6570]");
+  if (command !== "sourcemaps" || !["upload", "verify", "release"].includes(subcommand ?? "")) {
+    throw new Error("\u7528\u6CD5\uFF1Afaultlens sourcemaps <upload|verify|release> [\u53C2\u6570]\uFF0C\u6216 faultlens doctor [\u53C2\u6570]");
   }
+  if (!config.dryRun) required(config.token, "--token \u6216 FAULTLENS_SOURCEMAP_TOKEN");
   const artifacts = await prepareSourceMapArtifacts(config.root, config.dryRun);
   if (subcommand === "upload") return upload(config, artifacts);
   if (config.dryRun) {
-    console.info(`\u6F14\u7EC3\u5B8C\u6210\uFF1A\u5C06\u6821\u9A8C ${artifacts.length} \u4E2A Source Map \u6587\u4EF6`);
+    if (subcommand === "release") {
+      await synchronizeCompressedBundles(artifacts, true);
+      console.info(`\u6F14\u7EC3\u5B8C\u6210\uFF1A\u5C06\u4E0A\u4F20\u3001\u6821\u9A8C\u5E76\u5220\u9664 ${artifacts.length} \u4E2A Source Map \u6587\u4EF6`);
+    } else {
+      console.info(`\u6F14\u7EC3\u5B8C\u6210\uFF1A\u5C06\u6821\u9A8C ${artifacts.length} \u4E2A Source Map \u6587\u4EF6`);
+    }
+    return;
+  }
+  if (subcommand === "release") {
+    await upload(config, artifacts);
+    await synchronizeCompressedBundles(artifacts, false);
+    await verify(config, artifacts, false);
+    await removeUploadedSourceMaps(artifacts);
+    console.info("Source Map \u53D1\u5E03\u5B8C\u6210\uFF0C\u672C\u5730\u6620\u5C04\u6587\u4EF6\u5DF2\u5220\u9664");
     return;
   }
   return verify(config, artifacts);

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,3 @@
-export { createErrorMonitor, installFetchInstrumentation, installXhrInstrumentation } from './chunk-DQD732MN.js';
-export { FetchTelemetryTransport, formatTraceParent, parseTraceParent, traceContextHeaders } from './chunk-YQKZEUXA.js';
+export { createErrorMonitor, installFetchInstrumentation, installXhrInstrumentation } from './chunk-RFH3EN3N.js';
+export { FetchTelemetryTransport, formatTraceParent, parseTraceParent, traceContextHeaders } from './chunk-VTX5KF2X.js';
+export { defaultShouldCaptureHttpError } from './chunk-GKS4FQKU.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,6 @@
-import { parseTransportResponse, parseRemoteSdkConfig, parseTelemetryTransportResponse, createMonitorRuntime } from '../chunk-YQKZEUXA.js';
+import { parseTransportResponse, parseRemoteSdkConfig, parseTelemetryTransportResponse, createMonitorRuntime } from '../chunk-VTX5KF2X.js';
+import { captureHttpError, createHttpErrorContext, isHttpSuccessStatus } from '../chunk-GKS4FQKU.js';
+export { defaultShouldCaptureHttpError } from '../chunk-GKS4FQKU.js';
 import { createSignedRelayHeaders } from '../chunk-RXQF7F2E.js';
 import { AsyncLocalStorage } from 'async_hooks';
 import { createDecipheriv, randomBytes, createCipheriv } from 'crypto';
@@ -216,6 +218,7 @@ var NodeEncryptedFileQueue = class {
     }
   }
 };
+var nodeHttpInstallations = /* @__PURE__ */ new WeakMap();
 function builtInModules() {
   const require2 = createRequire(import.meta.url);
   return [
@@ -267,6 +270,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 +302,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(isHttpSuccessStatus(status) ? "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,5 @@
-import { clientRedact, SDK_VERSION, parseErrorStack } from '../../chunk-YQKZEUXA.js';
+import { clientRedact, SDK_VERSION, parseErrorStack } from '../../chunk-VTX5KF2X.js';
+import '../../chunk-GKS4FQKU.js';
 import { createSignedRelayHeaders } from '../../chunk-RXQF7F2E.js';
 import { randomUUID } from 'crypto';
 

package/dist/nuxt/runtime/plugin.js

@@ -1,6 +1,7 @@
-import { createErrorMonitor } from '../../chunk-DQD732MN.js';
+import { createErrorMonitor } from '../../chunk-RFH3EN3N.js';
 import { installVueErrorMonitor } from '../../chunk-P6Q63P6L.js';
-import '../../chunk-YQKZEUXA.js';
+import '../../chunk-VTX5KF2X.js';
+import '../../chunk-GKS4FQKU.js';
 import { defineNuxtPlugin, useRuntimeConfig } from '#app';
 
 var plugin_default = defineNuxtPlugin({

package/dist/react/index.js

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

package/dist/testing/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devkitio/faultlens",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "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"
     },
+    "./axios": {
+      "types": "./dist/axios/index.d.ts",
+      "import": "./dist/axios/index.js"
+    },
     "./web-vitals": {
       "types": "./dist/web-vitals/index.d.ts",
       "import": "./dist/web-vitals/index.js"
@@ -59,9 +63,15 @@
     "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",
+    "axios": ">=0.21.1 <2",
     "express": ">=4.18.0 <6",
     "fastify": ">=4.0.0 <6",
     "h3": ">=1.15.0 <2",
@@ -75,6 +85,9 @@
     "@nuxt/schema": {
       "optional": true
     },
+    "axios": {
+      "optional": true
+    },
     "express": {
       "optional": true
     },
@@ -92,20 +105,18 @@
     }
   },
   "devDependencies": {
+    "@faultlens/security": "workspace:*",
     "@nuxt/kit": "4.1.0",
     "@nuxt/schema": "4.1.0",
     "@types/react": "19.1.11",
+    "axios": "1.19.0",
+    "axios-legacy": "npm:axios@0.21.4",
     "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"
   }
-}
+}