@allstak/react-native 0.3.1 → 0.3.2

package/dist/index.mjs

@@ -3,28 +3,57 @@ import {
 } from "./chunk-BJTO5JO5.mjs";
 
 // src/transport.ts
-var REQUEST_TIMEOUT = 3e3;
+var REQUEST_TIMEOUT = 2e3;
 var MAX_BUFFER = 100;
+var FAILURE_THRESHOLD = 3;
+var BACKOFF_BASE_MS = 500;
+var BACKOFF_MAX_MS = 3e4;
 var HttpTransport = class {
-  constructor(baseUrl, apiKey) {
+  constructor(baseUrl, apiKey, enabled = true) {
     this.baseUrl = baseUrl;
     this.apiKey = apiKey;
+    this.enabled = enabled;
     this.buffer = [];
     this.flushing = false;
+    this.consecutiveFailures = 0;
+    this.circuitOpenUntil = 0;
+    this.sent = 0;
+    this.failed = 0;
+    this.dropped = 0;
+  }
+  send(path, payload) {
+    if (!this.enabled) {
+      this.noteDropped();
+      return Promise.resolve();
+    }
+    this.enqueueOrDispatch({ path, payload });
+    return Promise.resolve();
+  }
+  enqueueOrDispatch(item) {
+    if (Date.now() < this.circuitOpenUntil) {
+      this.push(item);
+      return;
+    }
+    void this.dispatch(item).catch(() => void 0);
   }
-  async send(path, payload) {
+  async dispatch(item) {
     try {
-      await this.doFetch(path, payload);
-      await this.flushBuffer();
-    } catch {
-      if (this.buffer.length >= MAX_BUFFER) this.buffer.shift();
-      this.buffer.push({ path, payload });
+      await this.doFetch(item.path, item.payload);
+      this.sent++;
+      this.consecutiveFailures = 0;
+      this.circuitOpenUntil = 0;
+      this.scheduleFlush();
+    } catch (err) {
+      this.failed++;
+      this.recordFailure(err);
+      this.push(item);
     }
   }
   async doFetch(path, payload) {
     const url = `${this.baseUrl}${path}`;
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
+    const started = Date.now();
     try {
       const res = await fetch(url, {
         method: "POST",
@@ -38,26 +67,77 @@ var HttpTransport = class {
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
     } finally {
       clearTimeout(timeoutId);
+      this.lastTransportLatencyMs = Date.now() - started;
+    }
+  }
+  push(item) {
+    if (this.buffer.length >= MAX_BUFFER) {
+      this.buffer.shift();
+      this.dropped++;
     }
+    this.buffer.push(item);
+  }
+  scheduleFlush() {
+    if (this.flushing || this.buffer.length === 0) return;
+    const delay = Math.max(0, this.circuitOpenUntil - Date.now());
+    const timer = setTimeout(() => {
+      void this.flushBuffer().catch(() => void 0);
+    }, delay);
+    if (typeof timer === "object" && typeof timer.unref === "function") timer.unref();
   }
   async flushBuffer() {
     if (this.flushing || this.buffer.length === 0) return;
     this.flushing = true;
+    const started = Date.now();
     try {
       const items = this.buffer.splice(0, this.buffer.length);
       for (const item of items) {
+        if (Date.now() < this.circuitOpenUntil) {
+          this.push(item);
+          continue;
+        }
         try {
           await this.doFetch(item.path, item.payload);
-        } catch {
+          this.sent++;
+          this.consecutiveFailures = 0;
+          this.circuitOpenUntil = 0;
+        } catch (err) {
+          this.failed++;
+          this.recordFailure(err);
+          this.push(item);
         }
       }
     } finally {
+      this.lastFlushDurationMs = Date.now() - started;
       this.flushing = false;
+      if (this.buffer.length > 0) this.scheduleFlush();
     }
   }
+  recordFailure(error) {
+    this.consecutiveFailures++;
+    if (this.consecutiveFailures < FAILURE_THRESHOLD) return;
+    const retryAfterMs = retryAfterFromError(error);
+    const backoff = retryAfterMs ?? jitteredBackoff(this.consecutiveFailures);
+    this.circuitOpenUntil = Date.now() + backoff;
+  }
   getBufferSize() {
     return this.buffer.length;
   }
+  noteDropped(count = 1) {
+    this.dropped += Math.max(0, count);
+  }
+  getStats() {
+    return {
+      queued: this.buffer.length,
+      sent: this.sent,
+      failed: this.failed,
+      dropped: this.dropped,
+      consecutiveFailures: this.consecutiveFailures,
+      circuitOpenUntil: this.circuitOpenUntil,
+      lastTransportLatencyMs: this.lastTransportLatencyMs,
+      lastFlushDurationMs: this.lastFlushDurationMs
+    };
+  }
   /**
    * Wait for the in-flight retry-buffer to drain. Resolves `true` if the
    * buffer empties within `timeoutMs` (default 2000ms), `false` otherwise.
@@ -74,6 +154,14 @@ var HttpTransport = class {
     return true;
   }
 };
+function jitteredBackoff(failures) {
+  const exp = Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * 2 ** Math.min(8, failures - FAILURE_THRESHOLD));
+  return Math.floor(exp / 2 + Math.random() * (exp / 2));
+}
+function retryAfterFromError(error) {
+  const message = error instanceof Error ? error.message : "";
+  return /HTTP\s+(429|503)/.test(message) ? BACKOFF_MAX_MS : null;
+}
 
 // src/stack.ts
 var V8_FRAME_RE = /^\s*at\s+(?:(.+?)\s+\()?((?:.+?):(\d+):(\d+))\)?\s*$/;
@@ -128,6 +216,24 @@ function isInApp(filename) {
   return true;
 }
 
+// src/utils/debug-id.ts
+var REGISTRY_KEY = "_allstakDebugIds";
+var cache = /* @__PURE__ */ new Map();
+function resolveDebugId(filename) {
+  if (!filename) return void 0;
+  if (cache.has(filename)) return cache.get(filename) ?? void 0;
+  const registry = globalThis[REGISTRY_KEY];
+  if (registry && typeof registry === "object") {
+    const hit = registry[filename];
+    if (typeof hit === "string" && hit.length > 0) {
+      cache.set(filename, hit);
+      return hit;
+    }
+  }
+  cache.set(filename, null);
+  return void 0;
+}
+
 // src/scope.ts
 var Scope = class {
   constructor() {
@@ -339,6 +445,7 @@ var TracingModule = class {
     }
     if (!this.flushTimer) {
       this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS);
+      this.flushTimer?.unref?.();
     }
   }
   flush() {
@@ -384,10 +491,11 @@ var ReplaySurrogate = class {
     if (Math.random() >= this.opts.sampleRate) return false;
     this.active = true;
     this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS2);
+    this.flushTimer?.unref?.();
     return true;
   }
   /** Record a screen view. Filters params through the safeParams allow-list. */
-  recordScreenView(routeName, params) {
+  recordScreenView(routeName, params, context) {
     if (!this.active) return;
     const safe = {};
     if (params && this.opts.safeParams.length > 0) {
@@ -395,17 +503,22 @@ var ReplaySurrogate = class {
         if (key in params) safe[key] = params[key];
       }
     }
-    this.push({ ts: Date.now(), k: "screen", data: { route: routeName, params: safe } });
+    this.push({ ts: Date.now(), k: "screen", data: { route: routeName, params: safe, ...compact(context) } });
   }
   /** Record an AppState transition (foreground/background/inactive). */
-  recordAppState(next) {
+  recordAppState(next, context) {
     if (!this.active) return;
-    this.push({ ts: Date.now(), k: "appstate", data: { state: next } });
+    this.push({ ts: Date.now(), k: "appstate", data: { state: next, ...compact(context) } });
   }
   /** Record a free-form, customer-validated checkpoint. */
-  recordManual(label, data) {
+  recordManual(label, data, context) {
+    if (!this.active) return;
+    this.push({ ts: Date.now(), k: "manual", data: { label, ...data ?? {}, ...compact(context) } });
+  }
+  /** Record a forensic mobile session timeline marker. This is not replay. */
+  recordTimelineMarker(kind, label, data, context) {
     if (!this.active) return;
-    this.push({ ts: Date.now(), k: "manual", data: { label, ...data ?? {} } });
+    this.push({ ts: Date.now(), k: kind, data: { label, ...data ?? {}, ...compact(context) } });
   }
   destroy() {
     this.destroyed = true;
@@ -439,6 +552,14 @@ var ReplaySurrogate = class {
     });
   }
 };
+function compact(context) {
+  if (!context) return {};
+  const out = {};
+  for (const [key, value] of Object.entries(context)) {
+    if (value !== void 0 && value !== null && value !== "") out[key] = value;
+  }
+  return out;
+}
 
 // src/http-requests.ts
 var INGEST_PATH = "/ingest/v1/http-requests";
@@ -450,6 +571,12 @@ function genTraceId() {
   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 genRequestId() {
+  return genTraceId();
+}
+function generateHttpId() {
+  return genTraceId();
+}
 function splitHostPath(url) {
   try {
     const u = new URL(url);
@@ -476,6 +603,7 @@ var HttpRequestModule = class {
     const item = {
       type: "http_request",
       traceId: ev.traceId ?? genTraceId(),
+      requestId: ev.requestId ?? genRequestId(),
       direction: "outbound",
       method: (ev.method || "GET").toUpperCase(),
       host,
@@ -490,6 +618,16 @@ var HttpRequestModule = class {
       requestHeaders: ev.requestHeaders,
       responseHeaders: ev.responseHeaders,
       error: ev.error,
+      spanId: ev.spanId,
+      parentSpanId: ev.parentSpanId,
+      requestBodyStatus: ev.requestBodyStatus,
+      responseBodyStatus: ev.responseBodyStatus,
+      requestBodyRedactedFields: ev.requestBodyRedactedFields,
+      responseBodyRedactedFields: ev.responseBodyRedactedFields,
+      requestBodyTruncated: ev.requestBodyTruncated,
+      responseBodyTruncated: ev.responseBodyTruncated,
+      capturePolicy: ev.capturePolicy,
+      linkConfidence: ev.linkConfidence ?? "exact",
       environment: this.defaults.environment,
       release: this.defaults.release,
       dist: this.defaults.dist,
@@ -508,7 +646,10 @@ var HttpRequestModule = class {
       this.flush();
       return;
     }
-    if (!this.flushTimer) this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS3);
+    if (!this.flushTimer) {
+      this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS3);
+      this.flushTimer?.unref?.();
+    }
   }
   /** Snapshot of the last failed requests for error-linking. Newest last. */
   getRecentFailed() {
@@ -560,6 +701,24 @@ var ALWAYS_REDACT_QUERY = /* @__PURE__ */ new Set([
   "jwt"
 ]);
 var REDACTED = "[REDACTED]";
+var DEFAULT_REDACT_BODY_FIELDS = [
+  "password",
+  "passcode",
+  "otp",
+  "token",
+  "authorization",
+  "cookie",
+  "session",
+  "refresh_token",
+  "access_token",
+  "jwt",
+  "card",
+  "credit_card",
+  "iban",
+  "national_id",
+  "secret",
+  "api_key"
+];
 function shouldCaptureUrl(url, opts) {
   if (!url) return false;
   const lower = url.toLowerCase();
@@ -627,25 +786,125 @@ function sanitizeHeaders(headers, opts) {
   }
   return out;
 }
-function captureBody(body, enabled, maxBodyBytes) {
-  if (!enabled) return void 0;
-  if (body == null) return void 0;
+function captureBodyResult(body, enabled, maxBodyBytes, opts = {}, contentType) {
+  if (!enabled) {
+    return {
+      status: "disabled",
+      redactedFields: [],
+      truncated: false,
+      capturePolicy: "body_capture_disabled"
+    };
+  }
+  if (body == null) {
+    return {
+      status: "empty",
+      redactedFields: [],
+      truncated: false,
+      capturePolicy: "empty_body"
+    };
+  }
+  const allowed = opts.allowedContentTypes ?? ["application/json", "text/", "application/problem+json"];
+  if (contentType && !allowed.some((needle) => contentType.toLowerCase().includes(needle.toLowerCase()))) {
+    return {
+      status: "unsupported",
+      redactedFields: [],
+      truncated: false,
+      capturePolicy: `unsupported_content_type:${contentType}`
+    };
+  }
   let str;
+  let redactedFields = [];
   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>";
+    if (tag !== "[object Object]" && tag !== "[object Array]") {
+      return {
+        body: "<binary>",
+        status: "unsupported",
+        redactedFields: [],
+        truncated: false,
+        capturePolicy: "unsupported_binary_body"
+      };
+    }
+    const redacted = redactJsonValue(body, opts);
+    redactedFields = redacted.redactedFields;
     try {
-      str = JSON.stringify(body);
+      str = JSON.stringify(redacted.value);
     } catch {
-      return "<unserializable>";
+      return {
+        body: "<unserializable>",
+        status: "unsupported",
+        redactedFields,
+        truncated: false,
+        capturePolicy: "unserializable_body"
+      };
     }
   } else {
-    return "<binary>";
+    return {
+      body: "<binary>",
+      status: "unsupported",
+      redactedFields: [],
+      truncated: false,
+      capturePolicy: "unsupported_body_type"
+    };
   }
-  if (str.length > maxBodyBytes) return str.slice(0, maxBodyBytes) + "\u2026[truncated]";
-  return str;
+  if (typeof body === "string" && looksJson(contentType, str)) {
+    try {
+      const redacted = redactJsonValue(JSON.parse(str), opts);
+      redactedFields = redacted.redactedFields;
+      str = JSON.stringify(redacted.value);
+    } catch {
+      str = redactSensitiveText(str, opts);
+    }
+  }
+  let truncated = false;
+  if (str.length > maxBodyBytes) {
+    str = str.slice(0, maxBodyBytes) + "\u2026[truncated]";
+    truncated = true;
+  }
+  return {
+    body: str,
+    status: truncated ? "truncated" : redactedFields.length > 0 ? "redacted" : "captured",
+    redactedFields: Array.from(new Set(redactedFields)).sort(),
+    truncated,
+    capturePolicy: "opt_in_body_capture"
+  };
+}
+function looksJson(contentType, body) {
+  if (contentType && contentType.toLowerCase().includes("json")) return true;
+  const trimmed = body.trim();
+  return trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]");
+}
+function redactJsonValue(value, opts, path = "") {
+  const fieldSet = new Set([...DEFAULT_REDACT_BODY_FIELDS, ...opts.redactBodyFields ?? []].map((v) => v.toLowerCase()));
+  const redactedFields = [];
+  const walk = (input, currentPath) => {
+    if (Array.isArray(input)) return input.map((item, index) => walk(item, `${currentPath}[${index}]`));
+    if (!input || typeof input !== "object") return input;
+    const out = {};
+    for (const [key, raw] of Object.entries(input)) {
+      const keyLower = key.toLowerCase();
+      const nextPath = currentPath ? `${currentPath}.${key}` : key;
+      if (fieldSet.has(keyLower) || keyLower.includes("token") || keyLower.includes("password")) {
+        out[key] = REDACTED;
+        redactedFields.push(nextPath);
+      } else {
+        out[key] = walk(raw, nextPath);
+      }
+    }
+    return out;
+  };
+  return { value: walk(value, path), redactedFields };
+}
+function redactSensitiveText(input, opts) {
+  const fields = [...DEFAULT_REDACT_BODY_FIELDS, ...opts.redactBodyFields ?? []];
+  let out = input;
+  for (const key of fields) {
+    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    out = out.replace(new RegExp(`("${escaped}"\\s*:\\s*)"[^"]*"`, "gi"), `$1"${REDACTED}"`);
+  }
+  return out;
 }
 
 // src/http-instrumentation.ts
@@ -655,12 +914,16 @@ var AXIOS_FLAG = /* @__PURE__ */ Symbol.for("allstak.http.axios.instrumented");
 var DEFAULT_MAX_BODY = 4096;
 var _currentModule = null;
 var _currentOpts = null;
+var _currentRuntime = null;
 function currentModule() {
   return _currentModule;
 }
 function currentOpts() {
   return _currentOpts;
 }
+function currentRuntime() {
+  return _currentRuntime;
+}
 function safeCapture(ev) {
   try {
     currentModule()?.capture(ev);
@@ -677,6 +940,8 @@ function bind(opts, ownIngestHost) {
     ignoredUrls: opts.ignoredUrls ?? [],
     allowedUrls: opts.allowedUrls ?? [],
     maxBodyBytes: opts.maxBodyBytes ?? DEFAULT_MAX_BODY,
+    allowedContentTypes: opts.allowedContentTypes ?? ["application/json", "text/", "application/problem+json"],
+    redactBodyFields: opts.redactBodyFields ?? [],
     ownIngestPrefix: ownIngestHost.replace(/\/$/, "")
   };
 }
@@ -723,6 +988,77 @@ function headersToObject(h) {
   }
   return {};
 }
+function normalizeTraceId(traceId) {
+  const hex = traceId.replace(/[^a-fA-F0-9]/g, "").toLowerCase();
+  return (hex + "00000000000000000000000000000000").slice(0, 32);
+}
+function normalizeSpanId(spanId) {
+  const hex = spanId.replace(/[^a-fA-F0-9]/g, "").toLowerCase();
+  return (hex + "0000000000000000").slice(0, 16);
+}
+function createRequestContext(method, url) {
+  const runtime = currentRuntime();
+  if (!runtime) return null;
+  const requestId = generateHttpId();
+  const parentSpanId = runtime.tracing.getCurrentSpanId() ?? "";
+  const span = runtime.tracing.startSpan("mobile.http", {
+    description: `${method.toUpperCase()} ${url}`,
+    tags: { requestId, method: method.toUpperCase(), platform: runtime.platform ?? "react-native" }
+  });
+  const traceId = runtime.tracing.getTraceId();
+  const spanId = span.spanId;
+  return {
+    traceId,
+    requestId,
+    spanId,
+    parentSpanId,
+    traceparent: `00-${normalizeTraceId(traceId)}-${normalizeSpanId(spanId)}-01`,
+    span
+  };
+}
+function propagationHeaders(ctx) {
+  const headers = {
+    traceparent: ctx.traceparent,
+    "x-allstak-trace-id": ctx.traceId,
+    "x-allstak-request-id": ctx.requestId
+  };
+  if (ctx.parentSpanId) headers["x-allstak-parent-span-id"] = ctx.parentSpanId;
+  return headers;
+}
+function mergeHeaders(headers, propagation) {
+  const entries = Object.entries(propagation);
+  if (typeof Headers !== "undefined" && headers instanceof Headers) {
+    const next2 = new Headers(headers);
+    for (const [k, v] of entries) if (!next2.has(k)) next2.set(k, v);
+    return next2;
+  }
+  if (Array.isArray(headers)) {
+    const existing = new Set(headers.map(([k]) => String(k).toLowerCase()));
+    const next2 = [...headers];
+    for (const [k, v] of entries) if (!existing.has(k.toLowerCase())) next2.push([k, v]);
+    return next2;
+  }
+  const next = { ...headers ?? {} };
+  const lower = new Set(Object.keys(next).map((k) => k.toLowerCase()));
+  for (const [k, v] of entries) if (!lower.has(k.toLowerCase())) next[k] = v;
+  return next;
+}
+function injectFetchHeaders(input, init, ctx) {
+  const headers = mergeHeaders(init?.headers ?? (input && typeof input === "object" ? input.headers : void 0), propagationHeaders(ctx));
+  return { input, init: { ...init ?? {}, headers } };
+}
+function recordTimeline(kind, label, ctx, data) {
+  try {
+    currentRuntime()?.replay?.recordTimelineMarker?.(kind, label, data, {
+      traceId: ctx.traceId,
+      requestId: ctx.requestId,
+      spanId: ctx.spanId,
+      release: currentRuntime()?.release,
+      dist: currentRuntime()?.dist
+    });
+  } catch {
+  }
+}
 function patchFetch() {
   const g = globalThis;
   if (typeof g.fetch !== "function") return;
@@ -740,23 +1076,37 @@ function patchFetch() {
       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 ctx = createRequestContext(method, sanitizedUrl);
+    const requestInit = ctx ? injectFetchHeaders(input, init, ctx).init : init;
+    if (ctx) recordTimeline("request", "request_started", ctx, { method, url: sanitizedUrl });
+    const reqHeaders = sanitizeHeaders(headersToObject(requestInit?.headers ?? (input && input.headers)), opts);
+    const reqBody = captureBodyResult(requestInit?.body, opts.captureRequestBody, opts.maxBodyBytes, opts, reqHeaders?.["content-type"]);
     const reqSize = safeByteLength(typeof init?.body === "string" ? init.body : void 0);
     let response;
     try {
-      response = await original.call(this, input, init);
+      response = await original.call(this, input, requestInit);
     } catch (err) {
+      ctx?.span.finish("error");
+      if (ctx) recordTimeline("exception", "request_failed", ctx, { method, url: sanitizedUrl, error: String(err?.message ?? err) });
       safeCapture({
         type: "http_request",
+        traceId: ctx?.traceId ?? generateHttpId(),
+        requestId: ctx?.requestId ?? generateHttpId(),
+        spanId: ctx?.spanId,
+        parentSpanId: ctx?.parentSpanId,
         method,
         url: sanitizedUrl,
         statusCode: 0,
         durationMs: Date.now() - start,
-        requestBody: reqBody,
+        requestBody: reqBody.body,
         requestHeaders: reqHeaders,
         requestSize: reqSize,
-        error: String(err?.message ?? err)
+        requestBodyStatus: reqBody.status,
+        requestBodyRedactedFields: reqBody.redactedFields,
+        requestBodyTruncated: reqBody.truncated,
+        capturePolicy: reqBody.capturePolicy,
+        error: String(err?.message ?? err),
+        linkConfidence: "exact"
       });
       throw err;
     }
@@ -772,25 +1122,41 @@ function patchFetch() {
         try {
           const cloned = response.clone();
           const text = await cloned.text();
-          respBody = captureBody(text, true, opts.maxBodyBytes);
+          respBody = captureBodyResult(text, true, opts.maxBodyBytes, opts, respHeaders?.["content-type"]).body;
           if (respSize == null) respSize = safeByteLength(text);
         } catch {
         }
       }
     } catch {
     }
+    const respBodyResult = captureBodyResult(respBody, opts.captureResponseBody && respBody !== void 0, opts.maxBodyBytes, opts, respHeaders?.["content-type"]);
+    const isError = response.status >= 400;
+    ctx?.span.setTag("requestId", ctx.requestId).setTag("http.status_code", String(response.status)).finish(isError ? "error" : "ok");
+    if (ctx) recordTimeline(isError ? "exception" : "response", isError ? "request_failed" : "response_received", ctx, { statusCode: response.status, durationMs });
     safeCapture({
       type: "http_request",
+      traceId: ctx?.traceId ?? generateHttpId(),
+      requestId: ctx?.requestId ?? generateHttpId(),
+      spanId: ctx?.spanId,
+      parentSpanId: ctx?.parentSpanId,
       method,
       url: sanitizedUrl,
       statusCode: response.status,
       durationMs,
-      requestBody: reqBody,
+      requestBody: reqBody.body,
       requestHeaders: reqHeaders,
       requestSize: reqSize,
-      responseBody: respBody,
+      responseBody: respBodyResult.body,
       responseHeaders: respHeaders,
-      responseSize: respSize
+      responseSize: respSize,
+      requestBodyStatus: reqBody.status,
+      responseBodyStatus: respBodyResult.status,
+      requestBodyRedactedFields: reqBody.redactedFields,
+      responseBodyRedactedFields: respBodyResult.redactedFields,
+      requestBodyTruncated: reqBody.truncated,
+      responseBodyTruncated: respBodyResult.truncated,
+      capturePolicy: `${reqBody.capturePolicy};${respBodyResult.capturePolicy}`,
+      linkConfidence: "exact"
     });
     return response;
   };
@@ -828,7 +1194,17 @@ function patchXhr() {
       return origSend.call(this, body);
     }
     const reqHeaders = sanitizeHeaders(this.__allstak_headers__, opts);
-    const reqBody = captureBody(body, opts.captureRequestBody, opts.maxBodyBytes);
+    const ctx = createRequestContext(method, sanitizedUrl);
+    if (ctx) {
+      for (const [k, v] of Object.entries(propagationHeaders(ctx))) {
+        try {
+          origSetRequestHeader.call(this, k, v);
+        } catch {
+        }
+      }
+      recordTimeline("request", "request_started", ctx, { method, url: sanitizedUrl });
+    }
+    const reqBody = captureBodyResult(body, opts.captureRequestBody, opts.maxBodyBytes, opts, reqHeaders?.["content-type"]);
     const reqSize = safeByteLength(typeof body === "string" ? body : void 0);
     const finish = (statusCode, error) => {
       const durationMs = Date.now() - start;
@@ -846,28 +1222,43 @@ function patchXhr() {
           }
           respHeaders = sanitizeHeaders(dict, liveOpts);
         }
+        let respBodyResult = captureBodyResult(void 0, false, liveOpts.maxBodyBytes, liveOpts);
         if (liveOpts.captureResponseBody) {
           const text = this.responseText;
           if (typeof text === "string") {
-            respBody = captureBody(text, true, liveOpts.maxBodyBytes);
+            respBodyResult = captureBodyResult(text, true, liveOpts.maxBodyBytes, liveOpts, respHeaders?.["content-type"]);
+            respBody = respBodyResult.body;
             respSize = safeByteLength(text);
           }
         }
       } catch {
       }
+      const failed = !!error || statusCode >= 400;
+      ctx?.span.setTag("requestId", ctx.requestId).setTag("http.status_code", String(statusCode)).finish(failed ? "error" : "ok");
+      if (ctx) recordTimeline(failed ? "exception" : "response", failed ? "request_failed" : "response_received", ctx, { statusCode, durationMs, error });
       safeCapture({
         type: "http_request",
+        traceId: ctx?.traceId ?? generateHttpId(),
+        requestId: ctx?.requestId ?? generateHttpId(),
+        spanId: ctx?.spanId,
+        parentSpanId: ctx?.parentSpanId,
         method,
         url: sanitizedUrl,
         statusCode,
         durationMs,
-        requestBody: reqBody,
+        requestBody: reqBody.body,
         requestHeaders: reqHeaders,
         requestSize: reqSize,
         responseBody: respBody,
         responseHeaders: respHeaders,
         responseSize: respSize,
-        error
+        requestBodyStatus: reqBody.status,
+        responseBodyStatus: respBody ? "captured" : opts.captureResponseBody ? "empty" : "disabled",
+        requestBodyRedactedFields: reqBody.redactedFields,
+        requestBodyTruncated: reqBody.truncated,
+        capturePolicy: reqBody.capturePolicy,
+        error,
+        linkConfidence: "exact"
       });
     };
     this.addEventListener?.("load", () => finish(this.status || 0));
@@ -886,10 +1277,17 @@ function instrumentAxiosInstance(axiosInstance, module, opts) {
   axiosInstance.interceptors.request.use((config) => {
     try {
       const rawUrl = (config.baseURL ? config.baseURL.replace(/\/$/, "") : "") + (config.url || "");
+      const method = String(config.method || "GET").toUpperCase();
+      const ctx = createRequestContext(method, rawUrl);
+      if (ctx) {
+        config.headers = mergeHeaders(config.headers, propagationHeaders(ctx));
+        recordTimeline("request", "request_started", ctx, { method, url: rawUrl });
+      }
       reqStarts.set(config, {
         start: Date.now(),
-        method: String(config.method || "GET").toUpperCase(),
-        rawUrl
+        method,
+        rawUrl,
+        ctx
       });
     } catch {
     }
@@ -903,21 +1301,36 @@ function instrumentAxiosInstance(axiosInstance, module, opts) {
     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 reqBody = captureBodyResult(cfg.data, opts.captureRequestBody, opts.maxBodyBytes, opts, reqHeaders?.["content-type"]);
     const respHeaders = sanitizeHeaders(headersToObject(response?.headers), opts);
-    const respBody = captureBody(response?.data, opts.captureResponseBody, opts.maxBodyBytes);
+    const respBody = captureBodyResult(response?.data, opts.captureResponseBody, opts.maxBodyBytes, opts, respHeaders?.["content-type"]);
+    const failed = !!error || statusCode >= 400;
+    meta.ctx?.span.setTag("requestId", meta.ctx.requestId).setTag("http.status_code", String(statusCode)).finish(failed ? "error" : "ok");
+    if (meta.ctx) recordTimeline(failed ? "exception" : "response", failed ? "request_failed" : "response_received", meta.ctx, { statusCode, error });
     try {
       module.capture({
         type: "http_request",
+        traceId: meta.ctx?.traceId ?? generateHttpId(),
+        requestId: meta.ctx?.requestId ?? generateHttpId(),
+        spanId: meta.ctx?.spanId,
+        parentSpanId: meta.ctx?.parentSpanId,
         method: meta.method,
         url: sanitizedUrl,
         statusCode,
         durationMs: Date.now() - meta.start,
-        requestBody: reqBody,
+        requestBody: reqBody.body,
         requestHeaders: reqHeaders,
-        responseBody: respBody,
+        responseBody: respBody.body,
         responseHeaders: respHeaders,
-        error
+        requestBodyStatus: reqBody.status,
+        responseBodyStatus: respBody.status,
+        requestBodyRedactedFields: reqBody.redactedFields,
+        responseBodyRedactedFields: respBody.redactedFields,
+        requestBodyTruncated: reqBody.truncated,
+        responseBodyTruncated: respBody.truncated,
+        capturePolicy: `${reqBody.capturePolicy};${respBody.capturePolicy}`,
+        error,
+        linkConfidence: "exact"
       });
     } catch {
     }
@@ -943,10 +1356,11 @@ function tryAutoInstrumentAxios(module, opts) {
   } catch {
   }
 }
-function installHttpInstrumentation(module, options, ownIngestHost) {
+function installHttpInstrumentation(module, options, ownIngestHost, runtime) {
   const bound = bind(options, ownIngestHost);
   _currentModule = module;
   _currentOpts = bound;
+  _currentRuntime = runtime;
   try {
     patchFetch();
   } catch {
@@ -963,6 +1377,11 @@ function installHttpInstrumentation(module, options, ownIngestHost) {
     instrumentAxios: (axios) => instrumentAxiosInstance(axios, module, bound)
   };
 }
+function unbindHttpInstrumentation() {
+  _currentModule = null;
+  _currentOpts = null;
+  _currentRuntime = null;
+}
 
 // src/client.ts
 var INGEST_HOST = "https://api.allstak.sa";
@@ -983,6 +1402,17 @@ function generateId() {
   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 stringContextValue(context, key) {
+  const value = context[key];
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function firstRecentRequestId(recentFailed) {
+  for (let i = recentFailed.length - 1; i >= 0; i--) {
+    const requestId = recentFailed[i]?.requestId;
+    if (requestId && requestId.trim().length > 0) return requestId;
+  }
+  return void 0;
+}
 var AllStakClient = class {
   constructor(config) {
     this.breadcrumbs = [];
@@ -990,9 +1420,6 @@ var AllStakClient = class {
     this.replay = null;
     this.httpRequests = null;
     this._instrumentAxios = null;
-    if (!config.apiKey) {
-      throw new Error("AllStak: config.apiKey is required");
-    }
     this.config = { ...config };
     if (!this.config.environment) this.config.environment = "production";
     if (!this.config.sdkName) this.config.sdkName = SDK_NAME;
@@ -1001,7 +1428,7 @@ var AllStakClient = class {
     this.sessionId = generateId();
     this.maxBreadcrumbs = config.maxBreadcrumbs ?? DEFAULT_MAX_BREADCRUMBS;
     const baseUrl = (config.host ?? INGEST_HOST).replace(/\/$/, "");
-    this.transport = new HttpTransport(baseUrl, config.apiKey);
+    this.transport = new HttpTransport(baseUrl, config.apiKey ?? "", Boolean(config.apiKey));
     this.tracing = new TracingModule(this.transport, {
       service: config.service ?? config.release ?? "",
       environment: this.config.environment ?? "production",
@@ -1028,7 +1455,15 @@ var AllStakClient = class {
         const { instrumentAxios } = installHttpInstrumentation(
           this.httpRequests,
           config.httpTracking ?? {},
-          baseUrl
+          baseUrl,
+          {
+            tracing: this.tracing,
+            replay: this.replay,
+            release: this.config.release,
+            dist: this.config.dist,
+            platform: this.config.platform,
+            environment: this.config.environment
+          }
         );
         this._instrumentAxios = instrumentAxios;
       } catch {
@@ -1052,33 +1487,67 @@ var AllStakClient = class {
     if (!this.passesSampleRate()) return;
     const frames = parseStack(error.stack).map((f) => ({
       ...f,
-      platform: this.config.platform
+      platform: this.config.platform,
+      debugId: resolveDebugId(f.filename)
     }));
+    const debugIdSet = /* @__PURE__ */ new Set();
+    for (const f of frames) if (f.debugId) debugIdSet.add(f.debugId);
+    const debugMeta = debugIdSet.size > 0 ? { images: Array.from(debugIdSet).map((id2) => ({ type: "sourcemap", debugId: id2 })) } : void 0;
     const stackTrace = frames.length > 0 ? frames.map(frameToString) : void 0;
     const currentBreadcrumbs = this.breadcrumbs.length > 0 ? [...this.breadcrumbs] : void 0;
     this.breadcrumbs = [];
     const exceptionClass = (error.name && error.name !== "Error" ? error.name : void 0) || error.constructor?.name || "Error";
     const eff = this.effective();
     const traceContext = {};
-    const traceId = this.tracing.getTraceId();
+    const recentFailed = this.httpRequests?.getRecentFailed() ?? [];
+    const linkedRequest = recentFailed.length > 0 ? recentFailed[recentFailed.length - 1] : void 0;
+    if (linkedRequest?.traceId) this.tracing.setTraceId(linkedRequest.traceId);
+    const exceptionSpan = linkedRequest ? this.tracing.startSpan("mobile.exception", {
+      description: error.message,
+      tags: {
+        requestId: linkedRequest.requestId,
+        exceptionClass
+      }
+    }) : null;
+    exceptionSpan?.finish("error");
+    const traceId = linkedRequest?.traceId ?? this.tracing.getTraceId();
     if (traceId) traceContext.traceId = traceId;
-    const spanId = this.tracing.getCurrentSpanId();
+    const spanId = exceptionSpan?.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
+        error: r.error,
+        requestId: r.requestId,
+        traceId: r.traceId,
+        confidence: r.requestId === linkedRequest?.requestId ? "inferred" : "weak"
       }));
+      traceContext["http.linkConfidence"] = "inferred";
+    }
+    try {
+      if (!linkedRequest) throw new Error("no linked request");
+      this.replay?.recordTimelineMarker?.("exception", "exception_captured", {
+        exceptionClass,
+        message: error.message,
+        requestLinkConfidence: linkedRequest ? "inferred" : "none"
+      }, {
+        traceId,
+        requestId: linkedRequest?.requestId,
+        spanId: spanId ?? void 0,
+        release: this.config.release,
+        dist: this.config.dist
+      });
+    } catch {
     }
     const payload = {
       exceptionClass,
       message: error.message,
       stackTrace,
       frames: frames.length > 0 ? frames : void 0,
+      debugMeta,
       platform: this.config.platform,
       sdkName: this.config.sdkName,
       sdkVersion: this.config.sdkVersion,
@@ -1087,12 +1556,29 @@ var AllStakClient = class {
       environment: this.config.environment,
       release: this.config.release,
       sessionId: this.sessionId,
+      traceId: stringContextValue(traceContext, "traceId"),
+      spanId: stringContextValue(traceContext, "spanId"),
+      requestId: linkedRequest?.requestId ?? firstRecentRequestId(recentFailed),
+      service: this.config.service,
       user: eff.user,
       metadata: { ...this.buildMetadata(context), ...traceContext },
       breadcrumbs: currentBreadcrumbs,
       fingerprint: eff.fingerprint
     };
-    this.sendThroughBeforeSend(payload);
+    if (this.shouldCaptureScreenshot()) {
+      void this.withScreenshotMetadata(error, payload).then((enriched) => this.sendThroughBeforeSend(enriched)).catch(() => this.sendThroughBeforeSend({
+        ...payload,
+        metadata: { ...payload.metadata ?? {}, "screenshot.status": "failed" }
+      }));
+      return;
+    }
+    this.sendThroughBeforeSend({
+      ...payload,
+      metadata: {
+        ...payload.metadata ?? {},
+        "screenshot.status": this.config.screenshot?.enabled ? "unsupported" : "disabled"
+      }
+    });
   }
   /** Start a new span. Auto-parented to any currently-active span. */
   startSpan(operation, options) {
@@ -1133,6 +1619,9 @@ var AllStakClient = class {
         environment: this.config.environment,
         release: this.config.release,
         sessionId: this.sessionId,
+        traceId: this.tracing.getTraceId(),
+        spanId: this.tracing.getCurrentSpanId() ?? void 0,
+        service: this.config.service,
         user: eff.user,
         metadata: this.buildMetadata(),
         fingerprint: eff.fingerprint
@@ -1216,6 +1705,9 @@ var AllStakClient = class {
   getConfig() {
     return this.config;
   }
+  getTransportStats() {
+    return this.transport.getStats();
+  }
   destroy() {
     this.tracing.destroy();
     if (this.replay) {
@@ -1226,6 +1718,7 @@ var AllStakClient = class {
       this.httpRequests.destroy();
       this.httpRequests = null;
     }
+    unbindHttpInstrumentation();
     this._instrumentAxios = null;
     this.breadcrumbs = [];
   }
@@ -1244,6 +1737,58 @@ var AllStakClient = class {
       metadata: this.buildMetadata()
     });
   }
+  shouldCaptureScreenshot() {
+    const screenshot = this.config.screenshot;
+    if (!screenshot?.enabled || screenshot.captureOnError === false || !screenshot.provider) return false;
+    const sampleRate = screenshot.sampleRate ?? 1;
+    return !(sampleRate <= 0 || sampleRate < 1 && Math.random() >= sampleRate);
+  }
+  async withScreenshotMetadata(error, payload) {
+    const screenshot = this.config.screenshot;
+    if (!screenshot?.provider) {
+      return { ...payload, metadata: { ...payload.metadata ?? {}, "screenshot.status": "unsupported" } };
+    }
+    const timeoutMs = Math.max(100, Math.min(screenshot.timeoutMs ?? 1500, 5e3));
+    const maxBytes = Math.max(1024, screenshot.maxBytes ?? 2e5);
+    try {
+      const artifact = await Promise.race([
+        Promise.resolve(screenshot.provider({
+          type: "error",
+          error,
+          traceId: payload.traceId,
+          requestId: payload.requestId
+        })),
+        new Promise((resolve) => setTimeout(() => resolve(null), timeoutMs))
+      ]);
+      if (!artifact) {
+        return { ...payload, metadata: { ...payload.metadata ?? {}, "screenshot.status": "timeout_or_empty" } };
+      }
+      const size = artifact.sizeBytes ?? byteSize(artifact.data);
+      if (size > maxBytes) {
+        this.transport.noteDropped();
+        return {
+          ...payload,
+          metadata: { ...payload.metadata ?? {}, "screenshot.status": "dropped_too_large", "screenshot.sizeBytes": size }
+        };
+      }
+      return {
+        ...payload,
+        metadata: {
+          ...payload.metadata ?? {},
+          "screenshot.status": "captured",
+          "screenshot.contentType": artifact.contentType,
+          "screenshot.width": artifact.width,
+          "screenshot.height": artifact.height,
+          "screenshot.sizeBytes": size,
+          "screenshot.redacted": artifact.redacted ?? false,
+          "screenshot.redactionStrategy": artifact.redactionStrategy,
+          ...artifact.data ? { "screenshot.data": artifact.data } : {}
+        }
+      };
+    } catch {
+      return { ...payload, metadata: { ...payload.metadata ?? {}, "screenshot.status": "failed" } };
+    }
+  }
   passesSampleRate() {
     const r = this.config.sampleRate;
     if (typeof r !== "number" || r >= 1) return true;
@@ -1342,10 +1887,22 @@ var AllStakClient = class {
   }
 };
 var instance = null;
-function ensureInit() {
-  if (!instance) throw new Error("AllStak.init() must be called before using the SDK");
+function maybeInit() {
   return instance;
 }
+function noopSpan(operation = "") {
+  return new Span("", "", "", operation, "", "", "", {}, () => void 0);
+}
+function emptyStats() {
+  return {
+    queued: 0,
+    sent: 0,
+    failed: 0,
+    dropped: 0,
+    consecutiveFailures: 0,
+    circuitOpenUntil: 0
+  };
+}
 function __safeAddBreadcrumbForInstrumentation(type, message, level, data) {
   try {
     instance?.addBreadcrumb(type, message, level, data);
@@ -1354,51 +1911,99 @@ function __safeAddBreadcrumbForInstrumentation(type, message, level, data) {
 }
 var AllStak = {
   init(config) {
-    if (instance) instance.destroy();
-    instance = new AllStakClient(config);
-    return instance;
+    try {
+      if (instance) instance.destroy();
+      instance = new AllStakClient(config);
+      return instance;
+    } catch {
+      instance = new AllStakClient({ ...config, apiKey: "" });
+      return instance;
+    }
   },
   captureException(error, context) {
-    ensureInit().captureException(error, context);
+    try {
+      maybeInit()?.captureException(error, context);
+    } catch {
+    }
   },
   captureMessage(message, level = "info", options) {
-    ensureInit().captureMessage(message, level, options);
+    try {
+      maybeInit()?.captureMessage(message, level, options);
+    } catch {
+    }
   },
   addBreadcrumb(type, message, level, data) {
-    ensureInit().addBreadcrumb(type, message, level, data);
+    try {
+      maybeInit()?.addBreadcrumb(type, message, level, data);
+    } catch {
+    }
   },
   clearBreadcrumbs() {
-    ensureInit().clearBreadcrumbs();
+    try {
+      maybeInit()?.clearBreadcrumbs();
+    } catch {
+    }
   },
   setUser(user) {
-    ensureInit().setUser(user);
+    try {
+      maybeInit()?.setUser(user);
+    } catch {
+    }
   },
   setTag(key, value) {
-    ensureInit().setTag(key, value);
+    try {
+      maybeInit()?.setTag(key, value);
+    } catch {
+    }
   },
   setTags(tags) {
-    ensureInit().setTags(tags);
+    try {
+      maybeInit()?.setTags(tags);
+    } catch {
+    }
   },
   setExtra(key, value) {
-    ensureInit().setExtra(key, value);
+    try {
+      maybeInit()?.setExtra(key, value);
+    } catch {
+    }
   },
   setExtras(extras) {
-    ensureInit().setExtras(extras);
+    try {
+      maybeInit()?.setExtras(extras);
+    } catch {
+    }
   },
   setContext(name, ctx) {
-    ensureInit().setContext(name, ctx);
+    try {
+      maybeInit()?.setContext(name, ctx);
+    } catch {
+    }
   },
   setLevel(level) {
-    ensureInit().setLevel(level);
+    try {
+      maybeInit()?.setLevel(level);
+    } catch {
+    }
   },
   setFingerprint(fingerprint) {
-    ensureInit().setFingerprint(fingerprint);
+    try {
+      maybeInit()?.setFingerprint(fingerprint);
+    } catch {
+    }
   },
   flush(timeoutMs) {
-    return ensureInit().flush(timeoutMs);
+    try {
+      return maybeInit()?.flush(timeoutMs) ?? Promise.resolve(true);
+    } catch {
+      return Promise.resolve(false);
+    }
   },
   setIdentity(identity) {
-    ensureInit().setIdentity(identity);
+    try {
+      maybeInit()?.setIdentity(identity);
+    } catch {
+    }
   },
   /**
    * Run `callback` with a fresh scoped context. Any user/tag/extra/context/
@@ -1407,37 +2012,79 @@ var AllStak = {
    * for async callbacks and thrown errors.
    */
   withScope(callback) {
-    return ensureInit().withScope(callback);
+    try {
+      const client = maybeInit();
+      return client ? client.withScope(callback) : callback(new Scope());
+    } catch {
+      return callback(new Scope());
+    }
   },
   startSpan(operation, options) {
-    return ensureInit().startSpan(operation, options);
+    try {
+      return maybeInit()?.startSpan(operation, options) ?? noopSpan(operation);
+    } catch {
+      return noopSpan(operation);
+    }
   },
   getTraceId() {
-    return ensureInit().getTraceId();
+    try {
+      return maybeInit()?.getTraceId() ?? "";
+    } catch {
+      return "";
+    }
   },
   setTraceId(traceId) {
-    ensureInit().setTraceId(traceId);
+    try {
+      maybeInit()?.setTraceId(traceId);
+    } catch {
+    }
   },
   getCurrentSpanId() {
-    return ensureInit().getCurrentSpanId();
+    try {
+      return maybeInit()?.getCurrentSpanId() ?? null;
+    } catch {
+      return null;
+    }
   },
   resetTrace() {
-    ensureInit().resetTrace();
+    try {
+      maybeInit()?.resetTrace();
+    } catch {
+    }
   },
   /** Access the privacy-first replay surrogate (or null if disabled / sampled out). */
   getReplay() {
-    return ensureInit().getReplay();
+    try {
+      return maybeInit()?.getReplay() ?? null;
+    } catch {
+      return null;
+    }
   },
   /** Manually instrument an axios instance. No-op when HTTP tracking is off. */
   instrumentAxios(axios) {
-    return ensureInit().instrumentAxios(axios);
+    try {
+      return maybeInit()?.instrumentAxios(axios) ?? axios;
+    } catch {
+      return axios;
+    }
   },
   getSessionId() {
-    return ensureInit().getSessionId();
+    try {
+      return maybeInit()?.getSessionId() ?? "";
+    } catch {
+      return "";
+    }
   },
   getConfig() {
     return instance?.getConfig() ?? null;
   },
+  getTransportStats() {
+    try {
+      return maybeInit()?.getTransportStats() ?? emptyStats();
+    } catch {
+      return emptyStats();
+    }
+  },
   destroy() {
     instance?.destroy();
     instance = null;
@@ -1447,6 +2094,14 @@ var AllStak = {
     return instance;
   }
 };
+function byteSize(value) {
+  if (!value) return 0;
+  try {
+    if (typeof TextEncoder !== "undefined") return new TextEncoder().encode(value).length;
+  } catch {
+  }
+  return value.length;
+}
 
 // src/provider.tsx
 import * as React from "react";
@@ -1806,7 +2461,7 @@ function installReactNative(options = {}) {
     }
     AllStak.setIdentity({
       sdkName: "allstak-react-native",
-      sdkVersion: "0.3.0",
+      sdkVersion: SDK_VERSION,
       platform: "react-native",
       dist
     });
@@ -2129,11 +2784,15 @@ async function drainPendingNativeCrashes(release) {
   }
 }
 export {
+  ALWAYS_REDACT_HEADERS,
+  ALWAYS_REDACT_QUERY,
   AllStak,
   AllStakClient,
   AllStakProvider,
+  DEFAULT_REDACT_BODY_FIELDS,
   HttpRequestModule,
   INGEST_HOST,
+  REDACTED,
   ReplaySurrogate,
   SDK_NAME,
   SDK_VERSION,
@@ -2144,11 +2803,14 @@ export {
   __resetProviderInstanceForTest,
   __setNativeModuleForTest,
   applyArchitectureTags,
+  captureBodyResult,
   detectArchitecture,
   drainPendingNativeCrashes,
   installReactNative,
   instrumentNavigationFromLinking,
   instrumentReactNavigation,
+  redactUrl,
+  sanitizeHeaders,
   tryAutoInstrumentNavigation,
   useAllStak
 };