@allstak/react-native 0.4.1 → 0.5.0

package/dist/index.mjs

@@ -1783,15 +1783,325 @@ function pickScreenshotConfig(source) {
   return out;
 }
 
+// src/contexts.ts
+function tryReq(id2) {
+  try {
+    return require(id2);
+  } catch {
+    return null;
+  }
+}
+function defaultExport(mod) {
+  if (!mod) return null;
+  return mod.default ?? mod;
+}
+function strOrUndef(v) {
+  if (v == null) return void 0;
+  const s = String(v);
+  return s.length > 0 ? s : void 0;
+}
+function collectAutoContexts(opts = {}) {
+  const captureDev = opts.captureDeviceContext !== false;
+  const captureScreen = opts.captureScreenContext !== false;
+  const contexts = {};
+  const tags = {};
+  const RN = tryReq("react-native");
+  const Platform = RN?.Platform;
+  const Dimensions = RN?.Dimensions;
+  const NativeModules = RN?.NativeModules;
+  const osName = strOrUndef(Platform?.OS);
+  const osVersion = strOrUndef(Platform?.Version);
+  const osConstants = Platform?.constants ?? {};
+  if (osName) {
+    contexts.os = {
+      name: osName === "ios" ? "iOS" : osName === "android" ? "Android" : osName,
+      version: osVersion,
+      build: strOrUndef(osConstants?.osBuildId ?? osConstants?.Release)
+    };
+    tags["os.name"] = osName;
+    if (osVersion) tags["os.version"] = osVersion;
+  }
+  const g = globalThis;
+  const hermes = typeof g.HermesInternal !== "undefined";
+  const fabric = typeof g.__turboModuleProxy !== "undefined";
+  const turboModules = fabric;
+  const bridgeless = typeof g.RN$Bridgeless !== "undefined" && !!g.RN$Bridgeless;
+  const jsEngine = hermes ? "hermes" : "jsc";
+  tags["js_engine"] = jsEngine;
+  tags["fabric"] = String(fabric);
+  tags["turbo_modules"] = String(turboModules);
+  const hermesVersion = (() => {
+    try {
+      return g.HermesInternal?.getRuntimeProperties?.()?.["OSS Release Version"];
+    } catch {
+      return void 0;
+    }
+  })();
+  contexts.runtime = {
+    name: jsEngine,
+    version: strOrUndef(hermesVersion) ?? "unknown",
+    bridgeless
+  };
+  if (captureDev) {
+    const device = {};
+    if (osConstants?.Model) device.model = String(osConstants.Model);
+    if (osConstants?.Brand) device.brand = String(osConstants.Brand);
+    if (osConstants?.Manufacturer) device.manufacturer = String(osConstants.Manufacturer);
+    if (osConstants?.systemName) device.systemName = String(osConstants.systemName);
+    if (osConstants?.interfaceIdiom) device.family = String(osConstants.interfaceIdiom);
+    const isSim = Boolean(osConstants?.isTesting) || typeof osConstants?.reactNativeVersion === "object" && String(osConstants?.systemName ?? "").toLowerCase().includes("simulator");
+    if (isSim) {
+      device.simulator = true;
+      tags["simulator"] = "true";
+    }
+    const expoDevice = tryReq("expo-device");
+    if (expoDevice) {
+      const ed = defaultExport(expoDevice) ?? expoDevice;
+      if (ed.modelName) device.model = String(ed.modelName);
+      if (ed.brand) device.brand = String(ed.brand);
+      if (ed.manufacturer) device.manufacturer = String(ed.manufacturer);
+      if (ed.deviceYearClass != null) device.yearClass = ed.deviceYearClass;
+      if (ed.totalMemory != null) device.memory_size = ed.totalMemory;
+      if (typeof ed.supportedCpuArchitectures !== "undefined") {
+        const arr = ed.supportedCpuArchitectures;
+        if (Array.isArray(arr) && arr.length > 0) device.arch = String(arr[0]);
+      }
+      if (typeof ed.isDevice === "boolean" && !ed.isDevice) {
+        device.simulator = true;
+        tags["simulator"] = "true";
+      }
+    } else {
+      const dinfo = tryReq("react-native-device-info");
+      if (dinfo) {
+        const d = defaultExport(dinfo) ?? dinfo;
+        try {
+          device.model = device.model ?? d.getModel?.();
+        } catch {
+        }
+        try {
+          device.manufacturer = device.manufacturer ?? d.getManufacturerSync?.();
+        } catch {
+        }
+        try {
+          device.memory_size = device.memory_size ?? d.getTotalMemorySync?.();
+        } catch {
+        }
+        try {
+          const isEm = d.isEmulatorSync?.();
+          if (isEm) {
+            device.simulator = true;
+            tags["simulator"] = "true";
+          }
+        } catch {
+        }
+      }
+    }
+    if (captureScreen && Dimensions && typeof Dimensions.get === "function") {
+      try {
+        const screen = Dimensions.get("screen");
+        if (screen?.width && screen?.height) {
+          device.screen_width_pixels = Math.round(screen.width * (screen.scale ?? 1));
+          device.screen_height_pixels = Math.round(screen.height * (screen.scale ?? 1));
+          device.screen_density = screen.scale;
+          device.orientation = screen.width >= screen.height ? "landscape" : "portrait";
+          tags["app_orientation"] = device.orientation;
+        }
+      } catch {
+      }
+    }
+    if (opts.captureBattery) {
+      const expoBattery = tryReq("expo-battery");
+      if (expoBattery) {
+        try {
+          const eb = defaultExport(expoBattery) ?? expoBattery;
+          device.battery_available = true;
+          if (typeof eb.getBatteryLevelAsync === "function") {
+          }
+        } catch {
+        }
+      }
+    }
+    if (Object.keys(device).length > 0) {
+      contexts.device = device;
+      if (device.model) tags["device.model"] = String(device.model);
+    }
+  }
+  const app = {};
+  app.app_start_time = (/* @__PURE__ */ new Date()).toISOString();
+  const expoApp = tryReq("expo-application");
+  if (expoApp) {
+    const ea = defaultExport(expoApp) ?? expoApp;
+    if (ea.applicationName) app.app_name = String(ea.applicationName);
+    if (ea.applicationId) app.app_identifier = String(ea.applicationId);
+    if (ea.nativeBuildVersion) app.app_build = String(ea.nativeBuildVersion);
+    if (ea.nativeApplicationVersion) app.app_version = String(ea.nativeApplicationVersion);
+  } else {
+    const dinfo = tryReq("react-native-device-info");
+    if (dinfo) {
+      const d = defaultExport(dinfo) ?? dinfo;
+      try {
+        app.app_name = d.getApplicationName?.();
+      } catch {
+      }
+      try {
+        app.app_identifier = d.getBundleId?.();
+      } catch {
+      }
+      try {
+        app.app_build = d.getBuildNumber?.();
+      } catch {
+      }
+      try {
+        app.app_version = d.getVersion?.();
+      } catch {
+      }
+    }
+  }
+  if (Object.keys(app).length > 0) {
+    contexts.app = app;
+    if (app.app_version) tags["app.version"] = String(app.app_version);
+    if (app.app_build) tags["app.build"] = String(app.app_build);
+  }
+  const rn = {
+    hermes,
+    fabric,
+    turbo_modules: turboModules,
+    bridgeless,
+    js_engine: jsEngine
+  };
+  if (osConstants?.reactNativeVersion) {
+    const v = osConstants.reactNativeVersion;
+    if (typeof v === "object" && v.major != null) {
+      rn.react_native_version = `${v.major}.${v.minor ?? 0}.${v.patch ?? 0}`;
+    } else if (typeof v === "string") {
+      rn.react_native_version = v;
+    }
+  }
+  const expoConstants = tryReq("expo-constants");
+  if (expoConstants) {
+    const ec = defaultExport(expoConstants) ?? expoConstants;
+    if (ec.expoVersion) rn.expo = ec.expoVersion;
+    else if (ec.expoConfig?.sdkVersion) rn.expo = ec.expoConfig.sdkVersion;
+    if (ec.appOwnership) rn.expo_application_ownership = String(ec.appOwnership);
+    if (ec.executionEnvironment) rn.expo_execution_environment = String(ec.executionEnvironment);
+  } else {
+    rn.expo = false;
+  }
+  contexts.react_native = rn;
+  if (rn.expo && rn.expo !== false) tags["expo"] = "true";
+  if (rn.react_native_version) tags["rn.version"] = String(rn.react_native_version);
+  return { contexts, tags };
+}
+function buildUserContext(user, opts = {}) {
+  if (!user) return void 0;
+  const out = {};
+  if (user.id) out.id = user.id;
+  if (user.username) out.username = user.username;
+  if (opts.sendDefaultPii) {
+    if (user.email) out.email = user.email;
+    if (user.ip_address) out.ip_address = user.ip_address;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+
+// src/mechanism.ts
+var URL_QUERY_RE = /\?.*$/;
+function sanitizeUrl(url) {
+  if (!url) return "";
+  const s = String(url).replace(URL_QUERY_RE, "");
+  return s;
+}
+function exceptionClassName(err) {
+  if (err && typeof err === "object") {
+    const e = err;
+    const fromName = e.name && e.name !== "Error" ? e.name : void 0;
+    return fromName ?? e.constructor?.name ?? "Error";
+  }
+  return "Error";
+}
+function exceptionValue(err) {
+  if (err == null) return "";
+  if (err instanceof Error) return err.message ?? "";
+  if (typeof err === "string") return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+function buildExceptionChain(err, mechanism, handled) {
+  const values = [];
+  const seen = /* @__PURE__ */ new Set();
+  let cursor = err;
+  let depth = 0;
+  while (cursor && depth < 5 && !seen.has(cursor)) {
+    seen.add(cursor);
+    const e = cursor;
+    const frames = parseStack(e?.stack);
+    values.push({
+      type: exceptionClassName(e),
+      value: exceptionValue(e),
+      stacktrace: frames.length > 0 ? { frames } : void 0,
+      // Only the outermost exception carries the mechanism, like Sentry.
+      ...depth === 0 ? { mechanism: { type: mechanism, handled } } : {}
+    });
+    cursor = e?.cause;
+    depth += 1;
+  }
+  return values.reverse();
+}
+function extractAxiosRequest(err) {
+  if (!err || typeof err !== "object") return null;
+  const e = err;
+  if (e.isAxiosError !== true) return null;
+  const cfg = e.config ?? {};
+  const resp = e.response ?? null;
+  const method = strUpper(cfg.method);
+  const rawUrl = composeAxiosUrl(cfg);
+  const url_sanitized = sanitizeUrl(rawUrl);
+  const status_code = typeof resp?.status === "number" ? resp.status : void 0;
+  const duration_ms = typeof e.duration === "number" ? e.duration : void 0;
+  const category = classifyHttpError(e, status_code);
+  return {
+    method,
+    url_sanitized,
+    status_code,
+    duration_ms,
+    category
+  };
+}
+function composeAxiosUrl(cfg) {
+  const base = typeof cfg?.baseURL === "string" ? cfg.baseURL.replace(/\/$/, "") : "";
+  const path = typeof cfg?.url === "string" ? cfg.url : "";
+  if (!base && !path) return "";
+  if (path.startsWith("http://") || path.startsWith("https://")) return path;
+  return base + path;
+}
+function strUpper(v) {
+  if (typeof v !== "string" || v.length === 0) return void 0;
+  return v.toUpperCase();
+}
+function classifyHttpError(err, status) {
+  const code = typeof err?.code === "string" ? err.code.toUpperCase() : "";
+  if (code === "ECONNABORTED" || code === "ETIMEDOUT") return "timeout";
+  if (code === "ERR_CANCELED" || code === "CANCELED") return "cancel";
+  if (typeof status === "number" && status >= 500) return "http_server_error";
+  if (typeof status === "number" && status >= 400) return "http_client_error";
+  return "network";
+}
+function maybeExtractHttpRequest(err) {
+  return extractAxiosRequest(err);
+}
+
 // src/client.ts
 var INGEST_HOST = "https://api.allstak.sa";
 var SDK_NAME = "allstak-react-native";
-var SDK_VERSION = "0.4.1";
+var SDK_VERSION = "0.5.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"]);
 var VALID_BREADCRUMB_LEVELS = /* @__PURE__ */ new Set(["info", "warn", "error", "debug"]);
-var DEFAULT_MAX_BREADCRUMBS = 50;
+var DEFAULT_MAX_BREADCRUMBS = 100;
 function frameToString(f) {
   const fn = f.function && f.function.length > 0 ? f.function : "<anonymous>";
   const file = f.filename || f.absPath || "<anonymous>";
@@ -1820,6 +2130,12 @@ var AllStakClient = class {
     this.replay = null;
     this.httpRequests = null;
     this._instrumentAxios = null;
+    /** Auto-collected Sentry-shape contexts (device/os/app/react_native/runtime). */
+    this.autoContexts = {};
+    /** Auto-collected tags (device.model, os.name, js_engine, …). */
+    this.autoTags = {};
+    /** Current screen / transaction name — set via setCurrentScreen() or nav auto-instrument. */
+    this.currentTransaction = null;
     this.config = { ...config };
     if (!this.config.environment) this.config.environment = "production";
     if (!this.config.sdkName) this.config.sdkName = SDK_NAME;
@@ -1841,6 +2157,18 @@ var AllStakClient = class {
       } catch {
       }
     }
+    try {
+      const opts = {
+        captureDeviceContext: config.captureDeviceContext !== false,
+        captureBattery: config.captureBattery === true,
+        captureScreenContext: config.captureScreenContext !== false,
+        sendDefaultPii: config.sendDefaultPii === true
+      };
+      const { contexts, tags } = collectAutoContexts(opts);
+      this.autoContexts = contexts;
+      this.autoTags = tags;
+    } catch {
+    }
     if (config.enableHttpTracking) {
       try {
         this.httpRequests = new HttpRequestModule(this.transport);
@@ -1883,7 +2211,7 @@ var AllStakClient = class {
     return this.httpRequests?.getRecentFailed() ?? [];
   }
   // ── Public API ────────────────────────────────────────────────────
-  captureException(error, context) {
+  captureException(error, context, opts) {
     if (!this.passesSampleRate()) return;
     const frames = parseStack(error.stack).map((f) => ({
       ...f,
@@ -1965,6 +2293,35 @@ var AllStakClient = class {
       breadcrumbs: currentBreadcrumbs,
       fingerprint: eff.fingerprint
     };
+    const mechanism = opts?.mechanism ?? "captureException";
+    const handled = opts?.handled ?? (mechanism === "captureException" || mechanism === "errorboundary");
+    payload.eventId = generateEventId();
+    payload.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    payload.handled = handled;
+    payload.mechanism = mechanism;
+    if (this.currentTransaction) payload.transaction = this.currentTransaction;
+    payload.exception = { values: buildExceptionChain(error, mechanism, handled) };
+    const req = maybeExtractHttpRequest(error);
+    if (req) payload.request = req;
+    const userCtx = buildUserContext(eff.user, { sendDefaultPii: this.config.sendDefaultPii });
+    const traceCtx = {};
+    if (payload.traceId) traceCtx.trace_id = payload.traceId;
+    if (payload.spanId) traceCtx.span_id = payload.spanId;
+    if (payload.parentSpanId) traceCtx.parent_span_id = payload.parentSpanId;
+    payload.contexts = {
+      ...this.autoContexts,
+      ...eff.contexts ?? {},
+      ...userCtx ? { user: userCtx } : {},
+      ...Object.keys(traceCtx).length > 0 ? { trace: traceCtx } : {}
+    };
+    payload.tags = {
+      ...this.autoTags,
+      ...this.config.tags ?? {},
+      ...eff.tags ?? {},
+      environment: this.config.environment ?? "production",
+      ...this.config.release ? { release: this.config.release } : {},
+      ...this.config.dist ? { dist: this.config.dist } : {}
+    };
     const flatPresent = this.config.captureScreenshotOnError === true;
     const callbackPresent = Boolean(this.config.screenshot?.provider);
     warnIfBothApisPresent(callbackPresent, flatPresent);
@@ -2122,16 +2479,59 @@ var AllStakClient = class {
     }
   }
   addBreadcrumb(type, message, level, data) {
-    const crumb = {
+    let crumb = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       type: VALID_BREADCRUMB_TYPES.has(type) ? type : "default",
       message,
       level: level && VALID_BREADCRUMB_LEVELS.has(level) ? level : "info",
       ...data ? { data } : {}
     };
+    if (crumb.type === "http" && (this.config.denyUrls || this.config.allowUrls)) {
+      const url = typeof crumb.data?.url === "string" ? crumb.data.url : "";
+      if (url) {
+        if (this.config.denyUrls && this.config.denyUrls.some((p) => matchUrlPattern(url, p))) return;
+        if (this.config.allowUrls && this.config.allowUrls.length > 0 && !this.config.allowUrls.some((p) => matchUrlPattern(url, p))) return;
+      }
+    }
+    if (crumb.data && this.config.scrubKeys && this.config.scrubKeys.length > 0) {
+      crumb = { ...crumb, data: scrubObject(crumb.data, this.config.scrubKeys) };
+    }
+    if (this.config.beforeBreadcrumb) {
+      try {
+        const out = this.config.beforeBreadcrumb(crumb);
+        if (out === null) return;
+        if (out) crumb = out;
+      } catch {
+      }
+    }
     if (this.breadcrumbs.length >= this.maxBreadcrumbs) this.breadcrumbs.shift();
     this.breadcrumbs.push(crumb);
   }
+  /**
+   * Set the current screen / route name. Stamps `transaction` on every
+   * subsequent event and emits a `navigation` breadcrumb. Use this when
+   * not on `@react-navigation/native` (the nav auto-instrument calls
+   * this for you).
+   */
+  setCurrentScreen(name) {
+    if (!name) return;
+    const prev = this.currentTransaction;
+    this.currentTransaction = name;
+    if (prev !== name) {
+      this.addBreadcrumb("navigation", `${prev ?? "<start>"} -> ${name}`, "info", {
+        from: prev,
+        to: name
+      });
+    }
+  }
+  /** @internal — current transaction (or undefined). */
+  getCurrentTransaction() {
+    return this.currentTransaction ?? void 0;
+  }
+  /** @internal — set transaction without emitting a breadcrumb. */
+  __setTransactionSilent(name) {
+    this.currentTransaction = name && name.length > 0 ? name : null;
+  }
   clearBreadcrumbs() {
     this.breadcrumbs = [];
   }
@@ -2412,9 +2812,9 @@ var AllStak = {
       return instance;
     }
   },
-  captureException(error, context) {
+  captureException(error, context, opts) {
     try {
-      maybeInit()?.captureException(error, context);
+      maybeInit()?.captureException(error, context, opts);
     } catch {
     }
   },
@@ -2497,6 +2897,27 @@ var AllStak = {
     } catch {
     }
   },
+  /** Set the current screen / transaction name. Stamps event.transaction + emits nav breadcrumb. */
+  setCurrentScreen(name) {
+    try {
+      maybeInit()?.setCurrentScreen(name);
+    } catch {
+    }
+  },
+  getCurrentTransaction() {
+    try {
+      return maybeInit()?.getCurrentTransaction();
+    } catch {
+      return void 0;
+    }
+  },
+  /** @internal — set transaction without emitting a breadcrumb (nav auto-instrument uses this). */
+  __setTransactionSilent(name) {
+    try {
+      maybeInit()?.__setTransactionSilent(name);
+    } catch {
+    }
+  },
   /**
    * Run `callback` with a fresh scoped context. Any user/tag/extra/context/
    * fingerprint/level set on the passed `Scope` is visible only inside the
@@ -2586,6 +3007,29 @@ var AllStak = {
     return instance;
   }
 };
+function matchUrlPattern(url, p) {
+  if (!url || !p) return false;
+  if (typeof p === "string") return url.includes(p);
+  try {
+    return p.test(url);
+  } catch {
+    return false;
+  }
+}
+function scrubObject(obj, keys) {
+  if (!obj || keys.length === 0) return obj;
+  const out = {};
+  const lower = new Set(keys.map((k) => k.toLowerCase()));
+  for (const [k, v] of Object.entries(obj)) {
+    out[k] = lower.has(k.toLowerCase()) ? "[Filtered]" : v;
+  }
+  return out;
+}
+function generateEventId() {
+  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 byteSize(value) {
   if (!value) return 0;
   try {
@@ -2790,6 +3234,10 @@ function instrumentReactNavigation(navigationRef, options = {}) {
       );
     } catch {
     }
+    try {
+      AllStak.__setTransactionSilent?.(next);
+    } catch {
+    }
     if (forwardToReplay) {
       try {
         const replay = AllStak.getReplay?.();
@@ -3029,7 +3477,7 @@ function installReactNative(options = {}) {
           AllStak.captureException(error, {
             source: "react-native-ErrorUtils",
             fatal: String(Boolean(isFatal))
-          });
+          }, { mechanism: "onerror", handled: false });
         } catch {
         }
         try {
@@ -3043,7 +3491,11 @@ function installReactNative(options = {}) {
     const wrapTrackerReason = (rejection) => rejection instanceof Error ? rejection : new Error(`Unhandled promise rejection: ${String(rejection)}`);
     const ship = (err) => {
       try {
-        AllStak.captureException(err, { source: "unhandledRejection" });
+        AllStak.captureException(
+          err,
+          { source: "unhandledRejection" },
+          { mechanism: "onunhandledrejection", handled: false }
+        );
       } catch {
       }
     };
@@ -3107,7 +3559,7 @@ var AllStakErrorBoundary = class extends React2.Component {
       AllStak.captureException(error, {
         componentStack: info.componentStack ?? "",
         source: "AllStakProvider.ErrorBoundary"
-      });
+      }, { mechanism: "errorboundary", handled: true });
       if (this.props.debug) {
         console.log(`[AllStak] Captured render error: ${error.message}`);
       }
@@ -3225,6 +3677,10 @@ function AllStakProvider({
       };
       clientRef.current = AllStak.init(config);
       __providerOwnedInstance = clientRef.current;
+      try {
+        AllStak.addBreadcrumb("default", "app.start", "info", { source: "AllStakProvider" });
+      } catch {
+      }
       installReactNative({
         autoErrorHandler,
         autoPromiseRejections,
@@ -3318,7 +3774,7 @@ async function drainPendingNativeCrashes(release) {
           AllStak.captureException(err, {
             ...payload?.metadata || {},
             "native.crash": "true"
-          });
+          }, { mechanism: "native_crash", handled: false });
         } catch {
         }
       }
@@ -3353,23 +3809,30 @@ export {
   __resetRuntimeModeForTest,
   __setNativeModuleForTest,
   applyArchitectureTags,
+  buildExceptionChain,
+  buildUserContext,
   captureBodyResult,
   captureViaViewShot,
+  classifyHttpError,
+  collectAutoContexts,
   detectArchitecture,
   detectRuntimeMode,
   drainPendingNativeCrashes,
+  extractAxiosRequest,
   installReactNative,
   instrumentNavigationFromLinking,
   instrumentReactNavigation,
   isCapturingScreenshot,
   isViewShotAvailable,
   maybeCaptureScreenshot,
+  maybeExtractHttpRequest,
   pickScreenshotConfig,
   redactUrl,
   registerSensitiveRef,
   resolveScreenshotConfig,
   runtimeAllowsScreenshot,
   sanitizeHeaders,
+  sanitizeUrl,
   tryAutoInstrumentNavigation,
   useAllStak,
   useAllStakPrivacy