@allstak/react 0.2.1 → 0.3.0

package/dist/index.mjs

@@ -143,12 +143,12 @@ function instrumentFetch(addBreadcrumb, ownBaseUrl) {
     else if (input && typeof input.url === "string") url = input.url;
     else url = String(input);
     const safePath = url.split("?")[0];
-    const isOwnIngest = !!(ownBaseUrl && url.startsWith(ownBaseUrl));
+    const isOwnIngest2 = !!(ownBaseUrl && url.startsWith(ownBaseUrl));
     const start = Date.now();
     try {
       const response = await originalFetch.call(this, input, init);
       const durationMs = Date.now() - start;
-      if (!isOwnIngest) {
+      if (!isOwnIngest2) {
         addBreadcrumb(
           "http",
           `${method} ${safePath} -> ${response.status}`,
@@ -159,7 +159,7 @@ function instrumentFetch(addBreadcrumb, ownBaseUrl) {
       return response;
     } catch (err) {
       const durationMs = Date.now() - start;
-      if (!isOwnIngest) {
+      if (!isOwnIngest2) {
         addBreadcrumb("http", `${method} ${safePath} -> failed`, "error", {
           method,
           url: safePath,
@@ -695,10 +695,534 @@ function resolveDebugId(filename) {
   return id2;
 }
 
+// src/http-requests.ts
+var INGEST_PATH = "/ingest/v1/http-requests";
+var FLUSH_INTERVAL_MS3 = 5e3;
+var BATCH_SIZE_THRESHOLD2 = 20;
+var RECENT_FAILED_BUFFER_SIZE = 10;
+function genTraceId() {
+  const hex = (n) => Math.floor(Math.random() * n).toString(16).padStart(1, "0");
+  const seg = (len) => Array.from({ length: len }, () => hex(16)).join("");
+  return `${seg(8)}-${seg(4)}-4${seg(3)}-${(8 + Math.floor(Math.random() * 4)).toString(16)}${seg(3)}-${seg(12)}`;
+}
+function splitHostPath(url) {
+  try {
+    const u = new URL(url);
+    return { host: u.host, path: u.pathname || "/" };
+  } catch {
+    return { host: "", path: url.split("?")[0] };
+  }
+}
+var HttpRequestModule = class {
+  constructor(transport) {
+    this.transport = transport;
+    this.queue = [];
+    this.recentFailed = [];
+    this.flushTimer = null;
+    this.destroyed = false;
+    this.defaults = {};
+  }
+  setDefaults(defaults) {
+    this.defaults = { ...this.defaults, ...defaults };
+  }
+  capture(ev) {
+    if (this.destroyed) return;
+    const { host, path } = splitHostPath(ev.url);
+    const item = {
+      type: "http_request",
+      traceId: ev.traceId ?? genTraceId(),
+      direction: "outbound",
+      method: (ev.method || "GET").toUpperCase(),
+      host,
+      path,
+      url: ev.url,
+      statusCode: ev.statusCode ?? 0,
+      durationMs: Math.max(0, Math.floor(ev.durationMs)),
+      requestSize: ev.requestSize,
+      responseSize: ev.responseSize,
+      requestBody: ev.requestBody,
+      responseBody: ev.responseBody,
+      requestHeaders: ev.requestHeaders,
+      responseHeaders: ev.responseHeaders,
+      error: ev.error,
+      environment: this.defaults.environment,
+      release: this.defaults.release,
+      dist: this.defaults.dist,
+      platform: this.defaults.platform,
+      "sdk.name": this.defaults.sdkName,
+      "sdk.version": this.defaults.sdkVersion,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.queue.push(item);
+    const isFailed = item.statusCode >= 400 || !!item.error;
+    if (isFailed) {
+      this.recentFailed.push(item);
+      if (this.recentFailed.length > RECENT_FAILED_BUFFER_SIZE) this.recentFailed.shift();
+    }
+    if (this.queue.length >= BATCH_SIZE_THRESHOLD2) {
+      this.flush();
+      return;
+    }
+    if (!this.flushTimer) this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS3);
+  }
+  /** Snapshot of the last failed requests for error-linking. Newest last. */
+  getRecentFailed() {
+    return this.recentFailed;
+  }
+  flush() {
+    if (this.queue.length === 0) return;
+    const batch = this.queue;
+    this.queue = [];
+    const payload = { requests: batch };
+    this.transport.send(INGEST_PATH, payload);
+  }
+  destroy() {
+    this.destroyed = true;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flush();
+    this.recentFailed = [];
+  }
+  /** @internal — for tests. */
+  getQueueSize() {
+    return this.queue.length;
+  }
+};
+
+// src/http-redact.ts
+var ALWAYS_REDACT_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-auth-token",
+  "proxy-authorization"
+]);
+var ALWAYS_REDACT_QUERY = /* @__PURE__ */ new Set([
+  "token",
+  "password",
+  "api_key",
+  "apikey",
+  "authorization",
+  "auth",
+  "secret",
+  "access_token",
+  "refresh_token",
+  "session",
+  "sessionid",
+  "jwt"
+]);
+var REDACTED = "[REDACTED]";
+function shouldCaptureUrl(url, opts) {
+  if (!url) return false;
+  const lower = url.toLowerCase();
+  if (opts.allowedUrls && opts.allowedUrls.length > 0) {
+    return opts.allowedUrls.some((p) => matches(p, url, lower));
+  }
+  if (opts.ignoredUrls && opts.ignoredUrls.length > 0) {
+    return !opts.ignoredUrls.some((p) => matches(p, url, lower));
+  }
+  return true;
+}
+function matches(pattern, url, lower) {
+  if (pattern instanceof RegExp) return pattern.test(url);
+  if (typeof pattern !== "string") return false;
+  return lower.includes(pattern.toLowerCase());
+}
+function redactUrl(url, opts) {
+  if (!url) return url;
+  const extra = (opts.redactQueryParams ?? []).map((s) => s.toLowerCase());
+  const redactSet = /* @__PURE__ */ new Set([...ALWAYS_REDACT_QUERY, ...extra]);
+  let parsed = null;
+  try {
+    parsed = new URL(url);
+  } catch {
+  }
+  if (parsed) {
+    const params = parsed.searchParams;
+    let mutated = false;
+    const keysToRedact = [];
+    params.forEach((_v, k) => {
+      if (redactSet.has(k.toLowerCase())) keysToRedact.push(k);
+    });
+    for (const k of keysToRedact) {
+      params.set(k, REDACTED);
+      mutated = true;
+    }
+    if (mutated) parsed.search = params.toString();
+    return parsed.toString();
+  }
+  const qIdx = url.indexOf("?");
+  if (qIdx < 0) return url;
+  const head = url.slice(0, qIdx);
+  const queryAndHash = url.slice(qIdx + 1);
+  const hashIdx = queryAndHash.indexOf("#");
+  const query = hashIdx < 0 ? queryAndHash : queryAndHash.slice(0, hashIdx);
+  const hash = hashIdx < 0 ? "" : queryAndHash.slice(hashIdx);
+  const parts = query.split("&").map((pair) => {
+    const eq = pair.indexOf("=");
+    if (eq < 0) return pair;
+    const key = pair.slice(0, eq);
+    return redactSet.has(key.toLowerCase()) ? `${key}=${REDACTED}` : pair;
+  });
+  return `${head}?${parts.join("&")}${hash ? "#" + hash : ""}`;
+}
+function sanitizeHeaders(headers, opts) {
+  if (!opts.captureHeaders) return void 0;
+  if (!headers) return {};
+  const extra = (opts.redactHeaders ?? []).map((s) => s.toLowerCase());
+  const redactSet = /* @__PURE__ */ new Set([...ALWAYS_REDACT_HEADERS, ...extra]);
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    if (v == null) continue;
+    const lower = k.toLowerCase();
+    out[lower] = redactSet.has(lower) ? REDACTED : Array.isArray(v) ? v.join(", ") : String(v);
+  }
+  return out;
+}
+function captureBody(body, enabled, maxBodyBytes) {
+  if (!enabled) return void 0;
+  if (body == null) return void 0;
+  let str;
+  if (typeof body === "string") str = body;
+  else if (typeof body === "number" || typeof body === "boolean") str = String(body);
+  else if (typeof body === "object") {
+    const tag = Object.prototype.toString.call(body);
+    if (tag !== "[object Object]" && tag !== "[object Array]") return "<binary>";
+    try {
+      str = JSON.stringify(body);
+    } catch {
+      return "<unserializable>";
+    }
+  } else {
+    return "<binary>";
+  }
+  if (str.length > maxBodyBytes) return str.slice(0, maxBodyBytes) + "\u2026[truncated]";
+  return str;
+}
+
+// src/http-instrumentation.ts
+var FETCH_FLAG2 = "__allstak_http_fetch_patched__";
+var XHR_FLAG = "__allstak_http_xhr_patched__";
+var AXIOS_FLAG = /* @__PURE__ */ Symbol.for("allstak.http.axios.instrumented");
+var DEFAULT_MAX_BODY = 4096;
+var _currentModule = null;
+var _currentOpts = null;
+function currentModule() {
+  return _currentModule;
+}
+function currentOpts() {
+  return _currentOpts;
+}
+function safeCapture(ev) {
+  try {
+    currentModule()?.capture(ev);
+  } catch {
+  }
+}
+function bind(opts, ownIngestHost) {
+  return {
+    captureRequestBody: opts.captureRequestBody ?? false,
+    captureResponseBody: opts.captureResponseBody ?? false,
+    captureHeaders: opts.captureHeaders ?? false,
+    redactHeaders: opts.redactHeaders ?? [],
+    redactQueryParams: opts.redactQueryParams ?? [],
+    ignoredUrls: opts.ignoredUrls ?? [],
+    allowedUrls: opts.allowedUrls ?? [],
+    maxBodyBytes: opts.maxBodyBytes ?? DEFAULT_MAX_BODY,
+    ownIngestPrefix: ownIngestHost.replace(/\/$/, "")
+  };
+}
+function isOwnIngest(url, prefix) {
+  return !!prefix && url.startsWith(prefix);
+}
+function urlString(input) {
+  if (typeof input === "string") return input;
+  if (input && typeof input.href === "string") return input.href;
+  if (input && typeof input.url === "string") return input.url;
+  return String(input);
+}
+function safeByteLength(s) {
+  if (s == null) return void 0;
+  if (typeof s === "string") {
+    let n = 0;
+    for (let i = 0; i < s.length; i++) {
+      const c = s.charCodeAt(i);
+      if (c < 128) n += 1;
+      else if (c < 2048) n += 2;
+      else if (c >= 55296 && c <= 56319) {
+        n += 4;
+        i += 1;
+      } else n += 3;
+    }
+    return n;
+  }
+  return void 0;
+}
+function headersToObject(h) {
+  if (!h) return {};
+  if (typeof h.entries === "function") {
+    const out = {};
+    for (const [k, v] of h.entries()) out[String(k).toLowerCase()] = String(v);
+    return out;
+  }
+  if (typeof h === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(h)) {
+      if (v == null) continue;
+      out[String(k).toLowerCase()] = Array.isArray(v) ? v.join(", ") : String(v);
+    }
+    return out;
+  }
+  return {};
+}
+function patchFetch() {
+  const g = globalThis;
+  if (typeof g.fetch !== "function") return;
+  if (g.fetch[FETCH_FLAG2]) return;
+  const original = g.fetch;
+  const wrapped = async function(input, init) {
+    const opts = currentOpts();
+    if (!opts || !currentModule()) {
+      return original.call(this, input, init);
+    }
+    const rawUrl = urlString(input);
+    const sanitizedUrl = redactUrl(rawUrl, opts);
+    const method = (init?.method || input && typeof input === "object" && input.method || "GET").toUpperCase();
+    if (isOwnIngest(rawUrl, opts.ownIngestPrefix) || !shouldCaptureUrl(rawUrl, opts)) {
+      return original.call(this, input, init);
+    }
+    const start = Date.now();
+    const reqHeaders = sanitizeHeaders(headersToObject(init?.headers ?? (input && input.headers)), opts);
+    const reqBody = captureBody(init?.body, opts.captureRequestBody, opts.maxBodyBytes);
+    const reqSize = safeByteLength(typeof init?.body === "string" ? init.body : void 0);
+    let response;
+    try {
+      response = await original.call(this, input, init);
+    } catch (err) {
+      safeCapture({
+        type: "http_request",
+        method,
+        url: sanitizedUrl,
+        statusCode: 0,
+        durationMs: Date.now() - start,
+        requestBody: reqBody,
+        requestHeaders: reqHeaders,
+        requestSize: reqSize,
+        error: String(err?.message ?? err)
+      });
+      throw err;
+    }
+    const durationMs = Date.now() - start;
+    let respBody;
+    let respSize;
+    let respHeaders;
+    try {
+      respHeaders = sanitizeHeaders(headersToObject(response.headers), opts);
+      const lenHeader = typeof response.headers?.get === "function" ? response.headers.get("content-length") : null;
+      if (lenHeader) respSize = parseInt(lenHeader, 10) || void 0;
+      if (opts.captureResponseBody && typeof response.clone === "function") {
+        try {
+          const cloned = response.clone();
+          const text = await cloned.text();
+          respBody = captureBody(text, true, opts.maxBodyBytes);
+          if (respSize == null) respSize = safeByteLength(text);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    safeCapture({
+      type: "http_request",
+      method,
+      url: sanitizedUrl,
+      statusCode: response.status,
+      durationMs,
+      requestBody: reqBody,
+      requestHeaders: reqHeaders,
+      requestSize: reqSize,
+      responseBody: respBody,
+      responseHeaders: respHeaders,
+      responseSize: respSize
+    });
+    return response;
+  };
+  wrapped[FETCH_FLAG2] = true;
+  g.fetch = wrapped;
+}
+function patchXhr() {
+  const g = globalThis;
+  const X = g.XMLHttpRequest;
+  if (!X || X.prototype[XHR_FLAG]) return;
+  const origOpen = X.prototype.open;
+  const origSend = X.prototype.send;
+  const origSetRequestHeader = X.prototype.setRequestHeader;
+  X.prototype.open = function(method, url, ...rest) {
+    this.__allstak_method__ = method;
+    this.__allstak_url__ = url;
+    this.__allstak_headers__ = {};
+    return origOpen.call(this, method, url, ...rest);
+  };
+  X.prototype.setRequestHeader = function(name, value) {
+    try {
+      this.__allstak_headers__[String(name).toLowerCase()] = String(value);
+    } catch {
+    }
+    return origSetRequestHeader.call(this, name, value);
+  };
+  X.prototype.send = function(body) {
+    const opts = currentOpts();
+    if (!opts || !currentModule()) return origSend.call(this, body);
+    const start = Date.now();
+    const method = String(this.__allstak_method__ || "GET").toUpperCase();
+    const rawUrl = String(this.__allstak_url__ || "");
+    const sanitizedUrl = redactUrl(rawUrl, opts);
+    if (isOwnIngest(rawUrl, opts.ownIngestPrefix) || !shouldCaptureUrl(rawUrl, opts)) {
+      return origSend.call(this, body);
+    }
+    const reqHeaders = sanitizeHeaders(this.__allstak_headers__, opts);
+    const reqBody = captureBody(body, opts.captureRequestBody, opts.maxBodyBytes);
+    const reqSize = safeByteLength(typeof body === "string" ? body : void 0);
+    const finish = (statusCode, error) => {
+      const durationMs = Date.now() - start;
+      let respHeaders;
+      let respBody;
+      let respSize;
+      try {
+        const liveOpts = currentOpts() ?? opts;
+        if (liveOpts.captureHeaders && typeof this.getAllResponseHeaders === "function") {
+          const raw = this.getAllResponseHeaders() || "";
+          const dict = {};
+          for (const line of raw.split(/\r?\n/)) {
+            const idx = line.indexOf(":");
+            if (idx > 0) dict[line.slice(0, idx).trim().toLowerCase()] = line.slice(idx + 1).trim();
+          }
+          respHeaders = sanitizeHeaders(dict, liveOpts);
+        }
+        if (liveOpts.captureResponseBody) {
+          const text = this.responseText;
+          if (typeof text === "string") {
+            respBody = captureBody(text, true, liveOpts.maxBodyBytes);
+            respSize = safeByteLength(text);
+          }
+        }
+      } catch {
+      }
+      safeCapture({
+        type: "http_request",
+        method,
+        url: sanitizedUrl,
+        statusCode,
+        durationMs,
+        requestBody: reqBody,
+        requestHeaders: reqHeaders,
+        requestSize: reqSize,
+        responseBody: respBody,
+        responseHeaders: respHeaders,
+        responseSize: respSize,
+        error
+      });
+    };
+    this.addEventListener?.("load", () => finish(this.status || 0));
+    this.addEventListener?.("error", () => finish(0, "network"));
+    this.addEventListener?.("abort", () => finish(0, "abort"));
+    this.addEventListener?.("timeout", () => finish(0, "timeout"));
+    return origSend.call(this, body);
+  };
+  X.prototype[XHR_FLAG] = true;
+}
+function instrumentAxiosInstance(axiosInstance, module, opts) {
+  if (!axiosInstance || typeof axiosInstance.interceptors !== "object") return axiosInstance;
+  if (axiosInstance[AXIOS_FLAG]) return axiosInstance;
+  axiosInstance[AXIOS_FLAG] = true;
+  const reqStarts = /* @__PURE__ */ new WeakMap();
+  axiosInstance.interceptors.request.use((config) => {
+    try {
+      const rawUrl = (config.baseURL ? config.baseURL.replace(/\/$/, "") : "") + (config.url || "");
+      reqStarts.set(config, {
+        start: Date.now(),
+        method: String(config.method || "GET").toUpperCase(),
+        rawUrl
+      });
+    } catch {
+    }
+    return config;
+  });
+  const finalize = (cfg, statusCode, response, error) => {
+    const meta = reqStarts.get(cfg);
+    if (!meta) return;
+    reqStarts.delete(cfg);
+    if (isOwnIngest(meta.rawUrl, opts.ownIngestPrefix)) return;
+    if (!shouldCaptureUrl(meta.rawUrl, opts)) return;
+    const sanitizedUrl = redactUrl(meta.rawUrl, opts);
+    const reqHeaders = sanitizeHeaders(headersToObject(cfg.headers), opts);
+    const reqBody = captureBody(cfg.data, opts.captureRequestBody, opts.maxBodyBytes);
+    const respHeaders = sanitizeHeaders(headersToObject(response?.headers), opts);
+    const respBody = captureBody(response?.data, opts.captureResponseBody, opts.maxBodyBytes);
+    try {
+      module.capture({
+        type: "http_request",
+        method: meta.method,
+        url: sanitizedUrl,
+        statusCode,
+        durationMs: Date.now() - meta.start,
+        requestBody: reqBody,
+        requestHeaders: reqHeaders,
+        responseBody: respBody,
+        responseHeaders: respHeaders,
+        error
+      });
+    } catch {
+    }
+  };
+  axiosInstance.interceptors.response.use(
+    (response) => {
+      finalize(response.config, response.status);
+      return response;
+    },
+    (err) => {
+      const cfg = err?.config;
+      const status = err?.response?.status ?? 0;
+      finalize(cfg, status, err?.response, String(err?.message ?? err));
+      throw err;
+    }
+  );
+  return axiosInstance;
+}
+function tryAutoInstrumentAxios(module, opts) {
+  try {
+    const axios = globalThis.require?.("axios") ?? null;
+    if (axios) instrumentAxiosInstance(axios.default ?? axios, module, opts);
+  } catch {
+  }
+}
+function installHttpInstrumentation(module, options, ownIngestHost) {
+  const bound = bind(options, ownIngestHost);
+  _currentModule = module;
+  _currentOpts = bound;
+  try {
+    patchFetch();
+  } catch {
+  }
+  try {
+    patchXhr();
+  } catch {
+  }
+  try {
+    tryAutoInstrumentAxios(module, bound);
+  } catch {
+  }
+  return {
+    instrumentAxios: (axios) => instrumentAxiosInstance(axios, module, bound)
+  };
+}
+
 // src/client.ts
 var INGEST_HOST = "https://api.allstak.sa";
 var SDK_NAME = "allstak-react";
-var SDK_VERSION = "0.2.1";
+var SDK_VERSION = "0.3.0";
 var ERRORS_PATH = "/ingest/v1/errors";
 var LOGS_PATH = "/ingest/v1/logs";
 var VALID_BREADCRUMB_TYPES = /* @__PURE__ */ new Set(["http", "log", "ui", "navigation", "query", "default"]);
@@ -728,6 +1252,8 @@ var AllStakClient = class {
     this.breadcrumbs = [];
     this.scopeStack = [];
     this.replay = null;
+    this.httpRequests = null;
+    this._instrumentAxios = null;
     this.onErrorHandler = null;
     this.onRejectionHandler = null;
     if (!config.apiKey) throw new Error("AllStak: config.apiKey is required");
@@ -773,6 +1299,35 @@ var AllStakClient = class {
       } catch {
       }
     }
+    if (config.enableHttpTracking) {
+      try {
+        this.httpRequests = new HttpRequestModule(this.transport);
+        this.httpRequests.setDefaults({
+          environment: this.config.environment,
+          release: this.config.release,
+          dist: this.config.dist,
+          platform: this.config.platform,
+          sdkName: this.config.sdkName,
+          sdkVersion: this.config.sdkVersion
+        });
+        const { instrumentAxios } = installHttpInstrumentation(
+          this.httpRequests,
+          config.httpTracking ?? {},
+          baseUrl
+        );
+        this._instrumentAxios = instrumentAxios;
+      } catch {
+      }
+    }
+  }
+  /** Manually instrument an axios instance. No-op when HTTP tracking is off. */
+  instrumentAxios(axios) {
+    if (!this._instrumentAxios) return axios;
+    return this._instrumentAxios(axios);
+  }
+  /** Snapshot of recent failed HTTP requests for error-linking. */
+  getRecentFailedHttp() {
+    return this.httpRequests?.getRecentFailed() ?? [];
   }
   captureException(error, context) {
     if (!this.passesSampleRate()) return;
@@ -791,6 +1346,16 @@ var AllStakClient = class {
     if (traceId) traceContext.traceId = traceId;
     const spanId = this.tracing.getCurrentSpanId();
     if (spanId) traceContext.spanId = spanId;
+    const recentFailed = this.httpRequests?.getRecentFailed() ?? [];
+    if (recentFailed.length > 0) {
+      traceContext["http.recentFailed"] = recentFailed.map((r) => ({
+        method: r.method,
+        url: r.url,
+        statusCode: r.statusCode,
+        durationMs: r.durationMs,
+        error: r.error
+      }));
+    }
     const payload = {
       exceptionClass,
       message: error.message,
@@ -947,6 +1512,11 @@ var AllStakClient = class {
       this.replay.destroy();
       this.replay = null;
     }
+    if (this.httpRequests) {
+      this.httpRequests.destroy();
+      this.httpRequests = null;
+    }
+    this._instrumentAxios = null;
     this.breadcrumbs = [];
   }
   installBrowserHandlers() {
@@ -1155,6 +1725,10 @@ var AllStak = {
   resetTrace() {
     ensureInit().resetTrace();
   },
+  /** Manually instrument an axios instance. No-op when HTTP tracking is off. */
+  instrumentAxios(axios) {
+    return ensureInit().instrumentAxios(axios);
+  },
   getSessionId() {
     return ensureInit().getSessionId();
   },
@@ -1242,6 +1816,7 @@ export {
   AllStak,
   AllStakClient,
   AllStakErrorBoundary,
+  HttpRequestModule,
   INGEST_HOST,
   ReplayRecorder,
   SDK_NAME,