@sessionsight/insights 1.0.0

package/src/worker.ts

@@ -0,0 +1,302 @@
+/**
+ * SessionSight Insights Web Worker
+ *
+ * Owns the event buffer, flush lifecycle, and WebSocket/HTTP transport.
+ * Receives pre-masked events from the main thread via postMessage.
+ * This file is bundled into a string and inlined as a blob URL at build time.
+ */
+
+// ── Types (inlined to avoid cross-bundle imports) ────────────────
+
+interface IngestPayload {
+  sessionId: string;
+  propertyId: string;
+  visitorId: string;
+  events: any[];
+  metadata?: SessionMetadata;
+  userId?: string | null;
+  userProperties?: Record<string, string | number | boolean>;
+  seqStart?: number;
+  seqEnd?: number;
+  final?: boolean;
+}
+
+interface SessionMetadata {
+  url: string;
+  referrer: string;
+  userAgent: string;
+  screenWidth: number;
+  screenHeight: number;
+  language: string;
+}
+
+interface PrivacyConfig {
+  privacyMode: 'default' | 'relaxed';
+  excludePages: string[];
+}
+
+// ── Configuration ────────────────────────────────────────────────
+
+const FLUSH_INTERVAL_MS = 6_000;
+const FLUSH_EVENT_THRESHOLD = 50;
+const MAX_KEEPALIVE_BYTES = 60_000;
+
+// ── Worker state ─────────────────────────────────────────────────
+
+let apiUrl = '';
+let publicApiKey = '';
+let propertyId = '';
+let sessionId = '';
+let visitorId = '';
+let userId: string | null = null;
+let userProperties: Record<string, string | number | boolean> | null = null;
+let userPropertiesDirty = false;
+let metadata: SessionMetadata | null = null;
+let metadataSent = false;
+let killed = false;
+
+// Buffer of { event, seq } entries
+const buffer: Array<{ event: any; seq: number }> = [];
+let flushTimer: ReturnType<typeof setInterval> | null = null;
+
+// ── WebSocket transport ──────────────────────────────────────────
+
+let ws: WebSocket | null = null;
+let wsReady = false;
+let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+let reconnectDelay = 1_000;
+const MAX_RECONNECT_DELAY = 30_000;
+let closed = false;
+
+function connectWs(): void {
+  if (killed || closed) return;
+
+  try {
+    const wsUrl = apiUrl.replace(/^http/, 'ws').replace(/\/$/, '');
+    ws = new WebSocket(`${wsUrl}/ws/ingest?key=${encodeURIComponent(publicApiKey)}&propertyId=${encodeURIComponent(propertyId)}`);
+
+    ws.onmessage = (event) => {
+      try {
+        const msg = JSON.parse(typeof event.data === 'string' ? event.data : '');
+        if (msg.type === 'ready') {
+          wsReady = true;
+          reconnectDelay = 1_000;
+          self.postMessage({ type: 'ready' });
+          if (msg.privacy) {
+            self.postMessage({ type: 'privacy', config: msg.privacy });
+          }
+        }
+      } catch {
+        // ignore non-JSON messages
+      }
+    };
+
+    ws.onclose = (event) => {
+      wsReady = false;
+      ws = null;
+
+      if (event.code === 4001) {
+        killed = true;
+        self.postMessage({ type: 'killed', reason: 'invalid_api_key' });
+        return;
+      }
+      if (event.code === 4002) {
+        killed = true;
+        self.postMessage({ type: 'killed', reason: 'subscription_required' });
+        return;
+      }
+
+      scheduleReconnect();
+    };
+
+    ws.onerror = () => {
+      // onclose fires after onerror, reconnect handled there
+    };
+  } catch {
+    scheduleReconnect();
+  }
+}
+
+function scheduleReconnect(): void {
+  if (killed || closed || reconnectTimer) return;
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    connectWs();
+  }, reconnectDelay);
+  reconnectDelay = Math.min(reconnectDelay * 2 + Math.random() * 500, MAX_RECONNECT_DELAY);
+}
+
+// ── Flush logic ──────────────────────────────────────────────────
+
+function flush(isFinal: boolean = false): void {
+  if (killed || buffer.length === 0) return;
+
+  const entries = buffer.splice(0);
+  const events = entries.map(e => e.event);
+  const seqStart = entries[0]!.seq;
+  const seqEnd = entries[entries.length - 1]!.seq;
+
+  const payload: IngestPayload = {
+    sessionId,
+    propertyId,
+    visitorId,
+    events,
+    seqStart,
+    seqEnd,
+  };
+
+  if (userId) payload.userId = userId;
+
+  if (userPropertiesDirty && userProperties) {
+    payload.userProperties = { ...userProperties };
+    userPropertiesDirty = false;
+  }
+
+  if (!metadataSent && metadata) {
+    payload.metadata = metadata;
+    metadataSent = true;
+  }
+
+  if (isFinal) {
+    payload.final = true;
+  }
+
+  sendPayload(payload, seqEnd);
+}
+
+function sendPayload(payload: IngestPayload, seqEnd: number): void {
+  // Try WebSocket first
+  if (wsReady && ws?.readyState === WebSocket.OPEN) {
+    try {
+      ws.send(JSON.stringify(payload));
+      self.postMessage({ type: 'ack', seq: seqEnd });
+      return;
+    } catch {
+      // WS send failed, fall through to HTTP
+    }
+  }
+
+  // HTTP fallback: ack only after successful send
+  sendHttpAsync(payload, seqEnd);
+}
+
+async function sendHttpAsync(payload: IngestPayload, seqEnd: number): Promise<void> {
+  const chunks = chunkEvents(payload);
+  let anyFailed = false;
+  for (const chunk of chunks) {
+    try {
+      const body = JSON.stringify(chunk);
+      const res = await fetch(`${apiUrl}/v1/ingest`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': publicApiKey,
+        },
+        body,
+        keepalive: body.length < MAX_KEEPALIVE_BYTES,
+      });
+      if (res.status === 401 || res.status === 403) {
+        killed = true;
+        self.postMessage({ type: 'killed', reason: 'invalid_api_key' });
+        return;
+      }
+    } catch {
+      anyFailed = true;
+    }
+  }
+  // Only ack if all chunks sent successfully, so the mirror buffer retains
+  // unacked events for the sendBeacon fallback on page unload.
+  if (!anyFailed) {
+    self.postMessage({ type: 'ack', seq: seqEnd });
+  }
+}
+
+function chunkEvents(payload: IngestPayload): IngestPayload[] {
+  const { events, ...rest } = payload;
+  if (events.length === 0) return [payload];
+
+  const envelopeSize = JSON.stringify({ ...rest, events: [] }).length;
+  const chunks: IngestPayload[] = [];
+  let currentEvents: any[] = [];
+  let currentSize = envelopeSize;
+
+  for (const event of events) {
+    const eventSize = JSON.stringify(event).length + 1;
+    if (currentEvents.length > 0 && currentSize + eventSize > MAX_KEEPALIVE_BYTES) {
+      chunks.push({ ...rest, events: currentEvents });
+      currentEvents = [];
+      currentSize = envelopeSize;
+    }
+    currentEvents.push(event);
+    currentSize += eventSize;
+  }
+
+  if (currentEvents.length > 0) {
+    chunks.push({ ...rest, events: currentEvents });
+  }
+
+  return chunks;
+}
+
+// ── Message handler ──────────────────────────────────────────────
+
+self.onmessage = (e: MessageEvent) => {
+  try {
+    const msg = e.data;
+    switch (msg.type) {
+      case 'init':
+        apiUrl = msg.apiUrl;
+        publicApiKey = msg.publicApiKey;
+        propertyId = msg.propertyId;
+        sessionId = msg.sessionId;
+        visitorId = msg.visitorId;
+        connectWs();
+        flushTimer = setInterval(() => flush(), FLUSH_INTERVAL_MS);
+        break;
+
+      case 'event':
+        if (killed) break;
+        buffer.push({ event: msg.event, seq: msg.seq });
+        if (buffer.length >= FLUSH_EVENT_THRESHOLD) {
+          flush();
+        }
+        break;
+
+      case 'metadata':
+        metadata = msg.metadata;
+        break;
+
+      case 'identify':
+        userId = msg.userId;
+        if (msg.userProperties) {
+          userProperties = { ...(userProperties || {}), ...msg.userProperties };
+          userPropertiesDirty = true;
+        }
+        break;
+
+      case 'flush':
+        flush();
+        break;
+
+      case 'flush-final':
+        if (flushTimer) {
+          clearInterval(flushTimer);
+          flushTimer = null;
+        }
+        flush(true);
+        closed = true;
+        if (ws) {
+          try { ws.close(1000); } catch {}
+          ws = null;
+        }
+        wsReady = false;
+        if (reconnectTimer) {
+          clearTimeout(reconnectTimer);
+          reconnectTimer = null;
+        }
+        break;
+    }
+  } catch (err) {
+    console.warn('SessionSight worker: error handling message', err);
+  }
+};

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "declaration": true,
+    "noEmit": false,
+    "rootDir": "./src",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler"
+  },
+  "include": ["src/**/*.ts"]
+}