@edraj/sauron-browser 1.0.0 → 1.4.0

package/dist/index.js

@@ -4,7 +4,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 
 // src/utils.ts
 var SDK_NAME = "sauron.javascript";
-var SDK_VERSION = "1.0.0";
+var SDK_VERSION = "1.4.0";
 function getGlobal() {
   return globalThis;
 }
@@ -87,6 +87,7 @@ function makeLogger(debug) {
 // src/identity.ts
 var DEVICE_ID_KEY = "sauron.device_id";
 var SESSION_ID_KEY = "sauron.session_id";
+var ANON_ID_KEY = "sauron.anon_id";
 function webStorage(name) {
   try {
     const s = globalThis[name];
@@ -119,6 +120,7 @@ function persistentId(cached, storage, key) {
 }
 var deviceId = null;
 var sessionId = null;
+var anonymousId = null;
 function getDeviceId() {
   deviceId = persistentId(deviceId, webStorage("localStorage"), DEVICE_ID_KEY);
   return deviceId;
@@ -127,6 +129,40 @@ function getSessionId() {
   sessionId = persistentId(sessionId, webStorage("sessionStorage"), SESSION_ID_KEY);
   return sessionId;
 }
+function getAnonymousId() {
+  if (anonymousId) return anonymousId;
+  const storage = webStorage("localStorage");
+  if (storage) {
+    try {
+      const existing = storage.getItem(ANON_ID_KEY);
+      if (existing) {
+        anonymousId = existing;
+        return anonymousId;
+      }
+    } catch {
+    }
+  }
+  const fresh = `anon_${uuidv4()}`;
+  if (storage) {
+    try {
+      storage.setItem(ANON_ID_KEY, fresh);
+    } catch {
+    }
+  }
+  anonymousId = fresh;
+  return anonymousId;
+}
+function resetAnonymousId() {
+  anonymousId = null;
+  const storage = webStorage("localStorage");
+  if (storage) {
+    try {
+      storage.removeItem(ANON_ID_KEY);
+    } catch {
+    }
+  }
+  return getAnonymousId();
+}
 
 // src/context.ts
 function getNavigator() {
@@ -624,12 +660,7 @@ function captureMessage(message, level = "info", hint) {
     type: "error",
     timestamp: nowIso(),
     level,
-    exception: {
-      type: null,
-      value: message,
-      mechanism: { type: "message", handled: true },
-      stacktrace: []
-    },
+    message,
     breadcrumbs,
     fingerprint: hint?.fingerprint ?? null,
     session_id: getSessionId(),
@@ -832,6 +863,30 @@ var Scope = class {
   }
 };
 
+// src/workflow.ts
+var WORKFLOW_NAME_MAX = 120;
+var WORKFLOW_REASON_MAX = 120;
+var current = null;
+function getWorkflow() {
+  return current;
+}
+function setWorkflowState(workflow) {
+  current = workflow;
+}
+function resetWorkflow() {
+  current = null;
+}
+function normalizeWorkflowName(name) {
+  if (typeof name !== "string") return null;
+  const trimmed = name.trim();
+  if (trimmed.length === 0 || trimmed.length > WORKFLOW_NAME_MAX) return null;
+  return trimmed;
+}
+function normalizeReason(reason) {
+  if (typeof reason !== "string" || reason.trim().length === 0) return "user";
+  return reason.trim().slice(0, WORKFLOW_REASON_MAX);
+}
+
 // src/api/product.ts
 function track(name, properties = {}, options = {}) {
   const client = getClient();
@@ -861,12 +916,12 @@ function setScreen(name) {
 function identify(id, traits = {}) {
   const client = getClient();
   if (!client) return;
-  const anonymousId = client.getAnonymousId();
+  const anonymousId2 = client.getAnonymousId();
   client.getScope().setUser({ id, traits });
   const item = {
     type: "identify",
     distinct_id: id,
-    anonymous_id: anonymousId,
+    anonymous_id: anonymousId2,
     traits: traits ?? {}
   };
   client.captureItem(item);
@@ -902,6 +957,86 @@ function trackTransaction(input) {
   const item = buildTransactionItem(input, client.getDistinctId(), getSessionId());
   client.captureItem(item);
 }
+var NOOP_LOGGER = makeLogger(false);
+function emitWorkflowClose(active, eventName, reason, logger) {
+  const properties = {
+    workflow_id: active.workflowId,
+    workflow_name: active.name,
+    duration_ms: Math.max(0, Date.now() - Date.parse(active.startedAt))
+  };
+  if (eventName === "$workflow_cancel") {
+    properties.reason = normalizeReason(reason);
+  }
+  try {
+    track(eventName, properties);
+  } catch (err) {
+    logger.warn(`${eventName}: failed to emit the lifecycle event`, err);
+  } finally {
+    resetWorkflow();
+  }
+}
+function startWorkflow(name, options) {
+  let logger = NOOP_LOGGER;
+  try {
+    const client = getClient();
+    if (!client || !client.isEnabled()) return { status: "disabled" };
+    logger = makeLogger(client.options.debug);
+    const normalized = normalizeWorkflowName(name);
+    if (!normalized) {
+      logger.warn("startWorkflow: invalid name", name);
+      return { status: "invalid_name" };
+    }
+    const active = getWorkflow();
+    if (active && !options?.force) {
+      logger.warn(
+        `startWorkflow("${normalized}"): "${active.name}" is already active; pass { force: true } to replace it`
+      );
+      return { status: "already_active" };
+    }
+    const workflow = {
+      workflowId: uuidv4(),
+      name: normalized,
+      startedAt: nowIso()
+    };
+    if (active) emitWorkflowClose(active, "$workflow_cancel", "superseded", logger);
+    setWorkflowState(workflow);
+    try {
+      track("$workflow_start", { workflow_id: workflow.workflowId, workflow_name: workflow.name });
+    } catch (err) {
+      logger.warn("startWorkflow: failed to emit $workflow_start", err);
+    }
+    return { status: "ok", workflowId: workflow.workflowId };
+  } catch (err) {
+    logger.warn("startWorkflow failed", err);
+    return { status: "disabled" };
+  }
+}
+function closeWorkflow(eventName, name, reason) {
+  let logger = NOOP_LOGGER;
+  try {
+    const client = getClient();
+    if (!client || !client.isEnabled()) return { status: "disabled" };
+    logger = makeLogger(client.options.debug);
+    const active = getWorkflow();
+    if (!active) return { status: "not_active" };
+    if (name !== void 0 && normalizeWorkflowName(name) !== active.name) {
+      logger.warn(`${eventName}: "${name}" does not match active workflow "${active.name}"`);
+      return { status: "name_mismatch" };
+    }
+    const workflowId = active.workflowId;
+    emitWorkflowClose(active, eventName, reason, logger);
+    return { status: "ok", workflowId };
+  } catch (err) {
+    logger.warn(`${eventName} failed`, err);
+    return { status: "disabled" };
+  }
+}
+function endWorkflow(name) {
+  return closeWorkflow("$workflow_end", name);
+}
+function cancelWorkflow(name, options) {
+  return closeWorkflow("$workflow_cancel", name, options?.reason);
+}
 
 // src/integrations/performance.ts
 var PERF_FETCH = "__sauron_perf_fetch__";
@@ -1291,6 +1426,21 @@ var OfflineQueue = class {
     if (entries.length) this.write([]);
     return entries;
   }
+  /**
+   * Put drained payloads BACK at the head, keeping their relative order.
+   *
+   * The counterpart to {@link drain}: a drain empties the store immediately, so
+   * whatever the caller could not deliver only exists in its local array and is
+   * lost the moment the caller returns. Re-parking at the head (rather than via
+   * {@link enqueue}) keeps the queue oldest-first, which is what the byte-cap
+   * eviction policy assumes — the oldest entry must stay the first one evicted.
+   */
+  requeueFront(payloads) {
+    if (!this.storage || payloads.length === 0) return;
+    const entries = [...payloads, ...this.read()];
+    this.evict(entries);
+    this.write(entries);
+  }
   /** Non-destructive read of the current entries, oldest first. */
   peek() {
     return this.read();
@@ -1354,6 +1504,9 @@ var Transport = class {
     __publicField(this, "pending", []);
     __publicField(this, "timer", null);
     __publicField(this, "onlineHandler", null);
+    /** Permanent auto-disable latch, flipped by this transport itself the moment
+     * it classifies a response as 401/403 — it is the source of truth for
+     * {@link isEnabled}, not merely a mirror of something the client decided. */
     __publicField(this, "disabled", false);
     this.dsn = config.dsn;
     this.makeEnvelope = config.makeEnvelope;
@@ -1401,6 +1554,10 @@ var Transport = class {
     this.pending = [];
     this.stop();
   }
+  /** Whether the transport still accepts items (false once auth-disabled by a 401/403). */
+  isEnabled() {
+    return !this.disabled;
+  }
   /** Queue an item for the next batch; flush eagerly once the batch is full. */
   send(item) {
     if (this.disabled) return;
@@ -1443,6 +1600,7 @@ var Transport = class {
         return;
       case "disable":
         this.logger.warn("server rejected credentials; disabling client");
+        this.disable();
         this.onDisable();
         return;
       case "split": {
@@ -1468,11 +1626,21 @@ var Transport = class {
       }
     }
   }
-  /** Re-attempt any envelopes that were parked while offline. */
+  /**
+   * Re-attempt any envelopes that were parked while offline.
+   *
+   * `drain()` empties `localStorage` in one shot, so from here on the ONLY copy
+   * of the backlog is the local `payloads` array. Every early return therefore
+   * has to re-park the whole untried remainder, not just the payload that
+   * failed: this used to re-park the failing one and return, which silently
+   * deleted every payload behind it — the exact reconnect-then-one-500 case the
+   * queue exists for.
+   */
   async drainOfflineQueue() {
     if (this.disabled || !this.offline.available) return;
     const payloads = this.offline.drain();
-    for (const json of payloads) {
+    for (let i = 0; i < payloads.length; i++) {
+      const json = payloads[i];
       let outcome;
       try {
         outcome = await this.post(json);
@@ -1480,12 +1648,14 @@ var Transport = class {
         outcome = { action: "retry_backoff" };
       }
       if (outcome.action === "disable") {
+        this.logger.warn("server rejected credentials while draining; disabling client");
+        this.disable();
         this.onDisable();
-        this.offline.enqueue(json);
+        this.offline.requeueFront(payloads.slice(i));
         return;
       }
       if (outcome.action === "retry_after" || outcome.action === "retry_backoff") {
-        this.offline.enqueue(json);
+        this.offline.requeueFront(payloads.slice(i));
         return;
       }
     }
@@ -1595,8 +1765,17 @@ var SauronClient = class {
     __publicField(this, "nativeFetch");
     __publicField(this, "enabled", true);
     __publicField(this, "installed", false);
-    __publicField(this, "anonymousId", null);
     __publicField(this, "beaconCleanup", null);
+    /**
+     * Whether the anonymous id has actually been USED as a `distinct_id` in this
+     * browser session.
+     *
+     * A persisted id that has never been observed anonymously must not create a
+     * permanent `identities` alias row on the server: aliasing is a durable
+     * server-side binding of this browser profile to a named user, and an
+     * identify() on a first-ever page load has no anonymous history to link.
+     */
+    __publicField(this, "anonUsed", false);
     this.options = options;
     this.dsn = parseDsn(options.dsn);
     this.logger = makeLogger(options.debug);
@@ -1645,22 +1824,43 @@ var SauronClient = class {
   getScope() {
     return this.scope;
   }
+  /**
+   * False once this client was explicitly disabled/closed, OR once the
+   * transport has auto-disabled itself on a 401/403 (revoked/invalid DSN
+   * key) — computed from the transport's own state on every call, not a
+   * separately mirrored flag, so a propagation regression there cannot leave
+   * this predicate stale. `this.transport` always exists once a client
+   * exists (it is constructed synchronously in the constructor); the
+   * "nothing installed yet" case is instead handled one layer up, by every
+   * module-level API (`startWorkflow`, `track`, ...) treating `getClient() ===
+   * null` as the no-op/disabled case before it ever reaches here.
+   */
   isEnabled() {
-    return this.enabled;
+    return this.enabled && this.transport.isEnabled();
   }
   /** The current distinct id: the user id when identified, else an anon id. */
   getDistinctId() {
     const user = this.scope.getUser();
     if (user.id) return user.id;
-    return this.ensureAnonymousId();
+    this.anonUsed = true;
+    return getAnonymousId();
   }
-  /** The anonymous id, or null if one was never needed. */
+  /** The anonymous id, or null when it was never actually used as an identity. */
   getAnonymousId() {
-    return this.anonymousId;
+    return this.anonUsed ? getAnonymousId() : null;
   }
-  ensureAnonymousId() {
-    if (!this.anonymousId) this.anonymousId = `anon_${uuidv4()}`;
-    return this.anonymousId;
+  /**
+   * Forget the current person: clear the scope user and mint a fresh anonymous
+   * id.
+   *
+   * MUST BE CALLED ON LOGOUT. Without it, the next anonymous visitor on this
+   * browser reuses the persisted anon id, and a later identify() aliases their
+   * activity to the previous account server-side, permanently.
+   */
+  reset() {
+    this.scope.setUser(null);
+    resetAnonymousId();
+    this.anonUsed = false;
   }
   /** Stamp a fresh envelope (new `sent_at`, current context) around `items`. */
   makeEnvelope(items) {
@@ -1668,7 +1868,6 @@ var SauronClient = class {
       dsn: this.dsn.raw,
       sdk: { name: SDK_NAME, version: SDK_VERSION },
       sent_at: nowIso(),
-      environment: this.options.environment,
       release: this.options.release
     };
     const context = buildContext(this.options.release, this.scope.getUser());
@@ -1714,6 +1913,39 @@ var SauronClient = class {
       item.user = this.scope.getUser();
     }
   }
+  /**
+   * Stamp the active workflow (if any) onto a signal item.
+   *
+   * Done HERE — the single choke point every capture path funnels through —
+   * rather than at each item-construction site, so a capture path added later
+   * is stamped by construction instead of by remembering to. The keys are
+   * ASSIGNED ONLY when a workflow is active: an item with no workflow keeps
+   * them absent entirely (not present-as-`undefined`), which is what makes
+   * `JSON.stringify` omit them and keeps the no-workflow wire bytes identical
+   * to pre-1.3.0.
+   *
+   * Only error/event/transaction carry `workflow_id`/`workflow_name` columns
+   * server-side — identify and breadcrumb_batch items are deliberately left
+   * alone. An item that already carries an explicit `workflow_id` is left
+   * untouched, matching how `enrichErrorItem` defers to caller-set fields.
+   */
+  stampWorkflow(item) {
+    if (item.type !== "error" && item.type !== "event" && item.type !== "transaction") return;
+    const hasId = item.workflow_id !== void 0;
+    const hasName = item.workflow_name !== void 0;
+    if (hasId || hasName) {
+      if (hasId !== hasName) {
+        this.logger.warn(
+          "item sets only one of workflow_id/workflow_name; the server treats them as a pair and will drop this attribution. Set both, or neither."
+        );
+      }
+      return;
+    }
+    const workflow = getWorkflow();
+    if (!workflow) return;
+    item.workflow_id = workflow.workflowId;
+    item.workflow_name = workflow.name;
+  }
   /**
    * Run an item through sampling (errors only) and `beforeSend`, then hand it to
    * the transport. Returns silently when dropped.
@@ -1727,6 +1959,7 @@ var SauronClient = class {
       }
       this.enrichErrorItem(item, hint);
     }
+    this.stampWorkflow(item);
     let processed = item;
     if (this.options.beforeSend) {
       try {
@@ -1763,6 +1996,7 @@ var SauronClient = class {
     }
     onNavigation(null);
     resetScreen();
+    resetWorkflow();
     unpatchAll();
     setDsnHost(null);
     this.installed = false;
@@ -1785,7 +2019,6 @@ function resolveOptions(options) {
   const t = options.transport ?? {};
   return {
     dsn: options.dsn,
-    environment: options.environment ?? "production",
     release: options.release ?? null,
     sampleRate: clamp(options.sampleRate ?? 1, 0, 1),
     maxBreadcrumbs: options.maxBreadcrumbs ?? 50,
@@ -1870,12 +2103,31 @@ function setScreen2(name) {
 function getScreen2() {
   return getScreen();
 }
+function startWorkflow2(name, options) {
+  return startWorkflow(name, options);
+}
+function endWorkflow2(name) {
+  return endWorkflow(name);
+}
+function cancelWorkflow2(name, options) {
+  return cancelWorkflow(name, options);
+}
+function getWorkflow2() {
+  return getWorkflow();
+}
 function addBreadcrumb2(breadcrumb, hint) {
   addBreadcrumb(breadcrumb, hint);
 }
 function setUser(user) {
+  if (user === null) {
+    getClient()?.reset();
+    return;
+  }
   getClient()?.getScope().setUser(user);
 }
+function reset() {
+  getClient()?.reset();
+}
 function setTag(key, value) {
   getClient()?.getScope().setTag(key, value);
 }
@@ -1905,18 +2157,23 @@ var Sauron = {
   identify: identify2,
   addBreadcrumb: addBreadcrumb2,
   setUser,
+  reset,
   setTag,
   setTags,
   setContext,
   setExtra,
   setScreen: setScreen2,
   getScreen: getScreen2,
+  startWorkflow: startWorkflow2,
+  endWorkflow: endWorkflow2,
+  cancelWorkflow: cancelWorkflow2,
+  getWorkflow: getWorkflow2,
   flush,
   close,
   getClient
 };
 var index_default = Sauron;
 
-export { DsnError, SDK_NAME, SDK_VERSION, Sauron, SauronClient, addBreadcrumb2 as addBreadcrumb, buildEnvelope, captureException2 as captureException, captureMessage2 as captureMessage, close, index_default as default, flush, getClient, getScreen2 as getScreen, identify2 as identify, init2 as init, isInAppFrame, parseDsn, parseError, parseStackString, setContext, setExtra, setScreen2 as setScreen, setTag, setTags, setUser, track2 as track, trackTransaction2 as trackTransaction };
+export { DsnError, SDK_NAME, SDK_VERSION, Sauron, SauronClient, addBreadcrumb2 as addBreadcrumb, buildEnvelope, cancelWorkflow2 as cancelWorkflow, captureException2 as captureException, captureMessage2 as captureMessage, close, index_default as default, endWorkflow2 as endWorkflow, flush, getClient, getScreen2 as getScreen, getWorkflow2 as getWorkflow, identify2 as identify, init2 as init, isInAppFrame, parseDsn, parseError, parseStackString, reset, setContext, setExtra, setScreen2 as setScreen, setTag, setTags, setUser, startWorkflow2 as startWorkflow, track2 as track, trackTransaction2 as trackTransaction };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map