@corbado/observe 1.10.1 → 1.11.0

package/dist/analysis/queue.mjs

@@ -4,13 +4,8 @@ import { AuthEventName } from "./types.mjs";
 import { CONFIG_REQUEST_HEADER, DEFAULT_RELIABILITY_CONFIG } from "./config.mjs";
 import { EventStore } from "./store/event-store.mjs";
 import { listenWindow, readDocumentHidden, readPageUrl } from "./readers/page.mjs";
-var PROBE_QUEUE_MAX_ITEMS = 500;
-var PROBE_QUEUE_MAX_BYTES = 512 * 1024;
-var PROBE_BATCH_MAX_ITEMS = 200;
-var PROBE_BATCH_MAX_BYTES = 200 * 1024;
-var PROBE_PAYLOAD_MAX_BYTES = 16 * 1024;
 var UNLOAD_BUDGET_BYTES = 6e4;
-var UNLOAD_PROBE_MAX_BYTES = 32e3;
+var UNLOAD_PROBE_BYTES = 32e3;
 function utf8Length(text) {
   let bytes = 0;
   for (let i = 0; i < text.length; i++) {
@@ -77,15 +72,10 @@ var RequestQueue = class {
    */
   telemetryQueue = [];
   /**
-   * Probe items (`tracker.probe()`): in memory only — never the durable outbox — capped by
-   * {@link PROBE_QUEUE_MAX_ITEMS} / {@link PROBE_QUEUE_MAX_BYTES}. They arm the flush timer, ride
-   * the regular batches (probe-only batches allowed), retry under `config.retry`, and are the lowest
-   * priority at unload (a separate request after the event request, within the remaining budget).
+   * Optional probe lane (`probes()` plugin, see {@link ProbeLane}); without one, probe items are dropped
+   * and the flush paths below never see any.
    */
-  probeQueue = [];
-  probeBytes = 0;
-  /** Probe items dropped on this load (caps, permanent rejection, exhausted retries, unload budget). */
-  probesDropped = 0;
+  lane;
   timer = null;
   isFlushing = false;
   flushingDone;
@@ -220,114 +210,6 @@ var RequestQueue = class {
       this.logger.error("Failed to enqueue telemetry", error);
     }
   }
-  /**
-   * Queue a probe item (in memory only). The payload is snapshotted (serialized once) so later host
-   * mutations cannot change it; items over {@link PROBE_PAYLOAD_MAX_BYTES} are dropped, and the
-   * oldest items are dropped beyond the queue caps. Arms the normal flush timer.
-   *
-   * Error situations:
-   *  - Any error while enqueueing or scheduling the flush timer: log "Failed to enqueue probe"
-   */
-  enqueueProbe(entry, capturedSessionId = this.sessionId) {
-    try {
-      if (this.destroyed) return;
-      const payloadJson = JSON.stringify(entry.payload);
-      if (typeof payloadJson !== "string" || utf8Length(payloadJson) > PROBE_PAYLOAD_MAX_BYTES) {
-        this.probesDropped++;
-        return;
-      }
-      const snapshot = { ...entry, payload: JSON.parse(payloadJson) };
-      const bytes = utf8Length(JSON.stringify(snapshot));
-      this.probeQueue.push({ sessionId: capturedSessionId, entry: snapshot, bytes, attempts: 0, flushAfter: 0 });
-      this.probeBytes += bytes;
-      while (this.probeQueue.length > PROBE_QUEUE_MAX_ITEMS || this.probeBytes > PROBE_QUEUE_MAX_BYTES && this.probeQueue.length > 1) {
-        const dropped = this.probeQueue.shift();
-        this.probeBytes -= dropped.bytes;
-        this.probesDropped++;
-      }
-      this.scheduleFlush(this.flushInterval(), "timer");
-    } catch (error) {
-      this.logger.error("Failed to enqueue probe", error);
-    }
-  }
-  /** Number of probe items dropped on this load (diagnostics / tests). */
-  droppedProbeCount() {
-    return this.probesDropped;
-  }
-  dueProbes(now) {
-    return this.probeQueue.filter((item) => item.flushAfter <= now);
-  }
-  /** Oldest-first selection for one session, within an item and byte cap (at least one item when any fits the item cap). */
-  selectProbes(candidates, sessionId, maxItems, maxBytes) {
-    const selected = [];
-    let bytes = 0;
-    for (const item of candidates) {
-      if (selected.length >= maxItems) break;
-      if (item.sessionId !== sessionId) continue;
-      if (bytes + item.bytes > maxBytes) {
-        if (selected.length === 0 && maxBytes >= PROBE_BATCH_MAX_BYTES) selected.push(item);
-        break;
-      }
-      bytes += item.bytes;
-      selected.push(item);
-    }
-    return selected;
-  }
-  removeProbes(items) {
-    if (items.length === 0) return;
-    const removed = new Set(items);
-    this.probeQueue = this.probeQueue.filter((item) => !removed.has(item));
-    for (const item of items) this.probeBytes -= item.bytes;
-  }
-  dropProbes(items) {
-    this.removeProbes(items);
-    this.probesDropped += items.length;
-  }
-  /** Same policy as events: 2xx delivered, non-retryable dropped, retryable backed off up to `config.retry.maxAttempts`. */
-  handleProbeSendResult(response, items, now) {
-    if (items.length === 0) return;
-    const status = response.statusCode;
-    if (typeof status === "number" && status >= 200 && status < 300) {
-      this.removeProbes(items);
-      return;
-    }
-    if (!this.isRetryable(status)) {
-      this.dropProbes(items);
-      return;
-    }
-    const maxAttempts = Math.max(1, this.config.retry.maxAttempts);
-    const retryAfterMs = this.parseRetryAfter(response);
-    const exhausted = [];
-    for (const item of items) {
-      item.attempts += 1;
-      if (item.attempts >= maxAttempts) exhausted.push(item);
-      else item.flushAfter = now + this.backoffForAttempt(item.attempts, retryAfterMs);
-    }
-    this.dropProbes(exhausted);
-  }
-  /**
-   * Unload / final teardown: one probe-only request for the current session within `budget` bytes,
-   * sent after the event request so the events' delivery is unaffected. Leftovers are dropped when
-   * `dropRest` (pagehide, destroy); otherwise they stay queued.
-   */
-  sendUnloadProbes(budget, reason, dropRest, useBeacon) {
-    const sessionId = this.sessionId;
-    const envelope = { sessionId, events: [], sdk: this.sdk, probes: [] };
-    this.attachBatchMeta(envelope, [], reason);
-    const overhead = utf8Length(JSON.stringify(envelope)) + 120;
-    const items = budget > overhead ? this.selectProbes(this.probeQueue, sessionId, PROBE_BATCH_MAX_ITEMS, budget - overhead) : [];
-    if (items.length > 0) {
-      envelope.probes = items.map((item) => item.entry);
-      this.attachBatchMeta(envelope, items, reason);
-      if (useBeacon && this.config.beaconKeepalive && this.transport.sendBeacon) {
-        this.transport.sendBeacon(envelope);
-      } else {
-        void Promise.resolve(this.transport.send(envelope)).catch(() => void 0);
-      }
-      this.removeProbes(items);
-    }
-    if (dropRest) this.dropProbes(this.probeQueue.slice());
-  }
   scheduleAfterEnqueue(event) {
     this.dirtySinceSyncFlush = true;
     if (event !== void 0 && this.isPriorityEvent(event)) {
@@ -389,7 +271,7 @@ var RequestQueue = class {
       if (reason === "destroy") {
         await this.flushingDone;
         try {
-          this.sendUnloadProbes(UNLOAD_PROBE_MAX_BYTES, reason, true, false);
+          this.lane?.sendUnload(UNLOAD_PROBE_BYTES, reason, true, false);
         } catch (error) {
           this.logger.error("Unexpected error in queue flush", error);
         }
@@ -407,7 +289,8 @@ var RequestQueue = class {
         const now = Date.now();
         const due = this.getDuePending(now);
         const dueLows = this.lowPending.filter((entry) => entry.flushAfter <= now);
-        const dueProbes = reason === "destroy" ? [] : this.dueProbes(now);
+        const lane = this.lane;
+        const dueProbes = reason === "destroy" || !lane ? [] : lane.items.filter((item) => item.flushAfter <= now);
         const onlyDeviceInfo = due.length === 0 && dueLows.length === 0 && this.lowsQueue.length === 0 && this.telemetryQueue.length === 0 && dueProbes.length === 0;
         if (onlyDeviceInfo && !this.hasStandaloneDeviceInfo()) {
           break;
@@ -419,7 +302,7 @@ var RequestQueue = class {
         this.prepareEvents(batchEntries, reason);
         const telemetry = sessionId === this.sessionId ? this.takeTelemetry() : [];
         const deviceInfo = sessionId === this.sessionId ? this.takeStandaloneDeviceInfo() : void 0;
-        const probeItems = this.selectProbes(dueProbes, sessionId, PROBE_BATCH_MAX_ITEMS, PROBE_BATCH_MAX_BYTES);
+        const probeItems = lane && dueProbes.length > 0 ? lane.selectBatch(dueProbes, sessionId) : [];
         const batch = {
           sessionId,
           events: batchEntries.map((entry) => entry.event),
@@ -452,13 +335,13 @@ var RequestQueue = class {
         }
         if (this.requestConfig) this.handleConfigResponse(response);
         this.handleLowSendResult(response, lowEntries, now);
-        this.handleProbeSendResult(response, probeItems, now);
+        lane?.handleResult(response, probeItems, now);
         if (!this.handleSendResult(response, batchEntries, now)) {
           break;
         }
       }
       if (reason === "destroy") {
-        this.sendUnloadProbes(UNLOAD_PROBE_MAX_BYTES, reason, true, false);
+        this.lane?.sendUnload(UNLOAD_PROBE_BYTES, reason, true, false);
       }
     } catch (error) {
       this.logger.error("Unexpected error in queue flush", error);
@@ -734,17 +617,16 @@ var RequestQueue = class {
       if (this.timer) {
         return;
       }
-      if (this.pending.length === 0 && this.lowPending.length === 0 && this.lowsQueue.length === 0 && this.probeQueue.length === 0) {
+      const probes = this.lane ? this.lane.items : [];
+      if (this.pending.length === 0 && this.lowPending.length === 0 && this.lowsQueue.length === 0 && probes.length === 0) {
         return;
       }
       const now = Date.now();
-      if (this.getDuePending(now).length > 0 || this.lowPending.some((entry) => entry.flushAfter <= now) || this.lowsQueue.length > 0 || this.probeQueue.some((item) => item.flushAfter <= now)) {
+      if (this.getDuePending(now).length > 0 || this.lowPending.some((entry) => entry.flushAfter <= now) || this.lowsQueue.length > 0 || probes.some((item) => item.flushAfter <= now)) {
         this.scheduleFlush(this.flushInterval(), "timer");
         return;
       }
-      const nextDue = Math.min(
-        ...[...this.pending, ...this.lowPending, ...this.probeQueue].map((entry) => entry.flushAfter)
-      );
+      const nextDue = Math.min(...[...this.pending, ...this.lowPending, ...probes].map((entry) => entry.flushAfter));
       this.scheduleFlush(Math.max(0, nextDue - now), "backoff");
     } catch (error) {
       this.logger.error("Failed to reschedule queue flush", error);
@@ -870,8 +752,9 @@ var RequestQueue = class {
   }
   flushSync(reason) {
     const eventBytes = this.flushSyncEvents(reason);
-    if (reason === "pagehide" && this.probeQueue.length > 0) {
-      this.sendUnloadProbes(Math.min(UNLOAD_BUDGET_BYTES - eventBytes, UNLOAD_PROBE_MAX_BYTES), reason, true, true);
+    const lane = this.lane;
+    if (reason === "pagehide" && lane && lane.items.length > 0) {
+      lane.sendUnload(Math.min(UNLOAD_BUDGET_BYTES - eventBytes, UNLOAD_PROBE_BYTES), reason, true, true);
     }
   }
   /** The event part of the unload flush; returns the serialized size of what it sent (0 = nothing). */
@@ -936,7 +819,7 @@ var RequestQueue = class {
     try {
       this.destroyed = true;
       this.clearTimer();
-      this.dropProbes(this.probeQueue.slice());
+      if (this.lane) this.lane.drop(this.lane.items.slice());
       if (typeof window !== "undefined") {
         if (this.removeVisibilityChange) {
           this.removeVisibilityChange();
@@ -951,13 +834,7 @@ var RequestQueue = class {
   }
 };
 export {
-  PROBE_BATCH_MAX_BYTES,
-  PROBE_BATCH_MAX_ITEMS,
-  PROBE_PAYLOAD_MAX_BYTES,
-  PROBE_QUEUE_MAX_BYTES,
-  PROBE_QUEUE_MAX_ITEMS,
   RequestQueue,
   UNLOAD_BUDGET_BYTES,
-  UNLOAD_PROBE_MAX_BYTES,
   utf8Length
 };

package/dist/analysis/session-keys.mjs

@@ -0,0 +1,11 @@
+// src/session-keys.ts
+var SESSION_STORAGE_KEY = "cbo_session_id";
+var SESSION_CONTINUITY_KEY = "cbo_session";
+var SEQ_STORAGE_KEY = "cbo_seq";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export {
+  SEQ_STORAGE_KEY,
+  SESSION_CONTINUITY_KEY,
+  SESSION_STORAGE_KEY,
+  UUID_RE
+};