@edraj/sauron-browser 1.0.0 → 1.4.0

package/dist/index.cjs

@@ -8,7 +8,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;
 }
@@ -91,6 +91,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];
@@ -123,6 +124,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;
@@ -131,6 +133,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() {
@@ -628,12 +664,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(),
@@ -836,6 +867,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();
@@ -865,12 +920,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);
@@ -906,6 +961,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__";
@@ -1295,6 +1430,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();
@@ -1358,6 +1508,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;
@@ -1405,6 +1558,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;
@@ -1447,6 +1604,7 @@ var Transport = class {
         return;
       case "disable":
         this.logger.warn("server rejected credentials; disabling client");
+        this.disable();
         this.onDisable();
         return;
       case "split": {
@@ -1472,11 +1630,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);
@@ -1484,12 +1652,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;
       }
     }
@@ -1599,8 +1769,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);
@@ -1649,22 +1828,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) {
@@ -1672,7 +1872,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());
@@ -1718,6 +1917,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.
@@ -1731,6 +1963,7 @@ var SauronClient = class {
       }
       this.enrichErrorItem(item, hint);
     }
+    this.stampWorkflow(item);
     let processed = item;
     if (this.options.beforeSend) {
       try {
@@ -1767,6 +2000,7 @@ var SauronClient = class {
     }
     onNavigation(null);
     resetScreen();
+    resetWorkflow();
     unpatchAll();
     setDsnHost(null);
     this.installed = false;
@@ -1789,7 +2023,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,
@@ -1874,12 +2107,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);
 }
@@ -1909,12 +2161,17 @@ 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
@@ -1928,25 +2185,30 @@ exports.Sauron = Sauron;
 exports.SauronClient = SauronClient;
 exports.addBreadcrumb = addBreadcrumb2;
 exports.buildEnvelope = buildEnvelope;
+exports.cancelWorkflow = cancelWorkflow2;
 exports.captureException = captureException2;
 exports.captureMessage = captureMessage2;
 exports.close = close;
 exports.default = index_default;
+exports.endWorkflow = endWorkflow2;
 exports.flush = flush;
 exports.getClient = getClient;
 exports.getScreen = getScreen2;
+exports.getWorkflow = getWorkflow2;
 exports.identify = identify2;
 exports.init = init2;
 exports.isInAppFrame = isInAppFrame;
 exports.parseDsn = parseDsn;
 exports.parseError = parseError;
 exports.parseStackString = parseStackString;
+exports.reset = reset;
 exports.setContext = setContext;
 exports.setExtra = setExtra;
 exports.setScreen = setScreen2;
 exports.setTag = setTag;
 exports.setTags = setTags;
 exports.setUser = setUser;
+exports.startWorkflow = startWorkflow2;
 exports.track = track2;
 exports.trackTransaction = trackTransaction2;
 //# sourceMappingURL=index.cjs.map