@sailfish-ai/recorder 1.7.8 → 1.7.11

package/dist/types/eventStore.d.ts

@@ -0,0 +1,10 @@
+export interface IndexedEvent {
+    id?: number;
+    timestamp: number;
+    data: any;
+}
+export declare function saveEventToIDB(event: any): Promise<void>;
+export declare function saveEventsToIDB(events: any[]): Promise<void>;
+export declare function getAllIndexedEvents(): Promise<IndexedEvent[]>;
+export declare function deleteEventById(id: number): Promise<void>;
+export declare function deleteEventsByIds(ids: number[]): Promise<void>;

package/dist/types/index.d.ts

@@ -19,7 +19,7 @@ export declare const initRecorder: (options: {
     serviceVersion?: string;
     serviceIdentifier?: string;
 }) => Promise<void>;
-export * from "./eventCache";
+export * from "./utils";
 export * from "./graphql";
 export * from "./recording";
 export * from "./sendSailfishMessages";

package/dist/types/notifyEventStore.d.ts

@@ -0,0 +1,7 @@
+export interface NotifyMessageRecord {
+    id?: number;
+    value: string;
+}
+export declare function saveNotifyMessageToIDB(message: string): Promise<void>;
+export declare function getAllNotifyMessages(): Promise<NotifyMessageRecord[]>;
+export declare function deleteNotifyMessageById(id: number): Promise<void>;

package/dist/types/recording.d.ts

@@ -5,7 +5,7 @@ export declare const getUrlAndStoredUuids: () => {
     prev_page_visit_uuid: string;
     href: string;
 };
-export declare function initializeDomContentEvents(): void;
-export declare function initializeConsolePlugin(consoleRecordSettings: LogRecordOptions): void;
+export declare function initializeDomContentEvents(sessionId: string): void;
+export declare function initializeConsolePlugin(consoleRecordSettings: LogRecordOptions, sessionId: string): void;
 export declare function initializeRecording(captureSettings: any, // TODO - Sibyl post-launch - replace type
 backendApi: string, apiKey: string, sessionId: string): Promise<ReconnectingWebSocket>;

package/dist/types/utils.d.ts

@@ -0,0 +1,6 @@
+export declare function buildBatches<T extends {
+    data: {
+        sessionId?: string;
+    };
+}>(queue: T[], getSize: (item: T) => number, maxBytes: number): T[][];
+export declare function eventSize(event: any): number;

package/dist/types/websocket.d.ts

@@ -1,3 +1,5 @@
 import ReconnectingWebSocket from "reconnecting-websocket";
+export declare function flushBufferedEvents(): Promise<void>;
+export declare function sendEvent(event: any): void;
 export declare function initializeWebSocket(backendApi: string, apiKey: string, sessionId: string): ReconnectingWebSocket;
 export declare function sendMessage(message: Record<string, any>): void;

package/dist/utils.js

@@ -0,0 +1,41 @@
+export function buildBatches(queue, getSize, maxBytes) {
+    const grouped = {};
+    // Step 1: group by sessionId
+    for (const item of queue) {
+        const sessionId = item.data.sessionId || "unknown";
+        if (!grouped[sessionId]) {
+            grouped[sessionId] = [];
+        }
+        grouped[sessionId].push(item);
+    }
+    // Step 2: build batches per session
+    const batches = [];
+    for (const sessionId in grouped) {
+        const sessionQueue = grouped[sessionId];
+        let batch = [];
+        let batchSize = 0;
+        for (const item of sessionQueue) {
+            const size = getSize(item);
+            if (batchSize + size > maxBytes) {
+                if (batch.length > 0) {
+                    batches.push(batch);
+                    batch = [];
+                    batchSize = 0;
+                }
+                if (size > maxBytes) {
+                    // Skip this oversized item
+                    continue;
+                }
+            }
+            batch.push(item);
+            batchSize += size;
+        }
+        if (batch.length > 0) {
+            batches.push(batch);
+        }
+    }
+    return batches;
+}
+export function eventSize(event) {
+    return new Blob([JSON.stringify(event)]).size;
+}

package/dist/websocket.js

@@ -1,18 +1,74 @@
 import ReconnectingWebSocket from "reconnecting-websocket";
 import version from "./version";
-// Internal WebSocket instance
+import { getAllNotifyMessages, deleteNotifyMessageById, saveNotifyMessageToIDB, } from "./notifyEventStore";
+import { deleteEventsByIds, getAllIndexedEvents, saveEventToIDB, } from './eventStore';
+import { buildBatches, eventSize } from "./utils";
+const MAX_MESSAGE_SIZE_MB = 50;
+const MAX_MESSAGE_SIZE_BYTES = MAX_MESSAGE_SIZE_MB * 1024 * 1024;
 let webSocket = null;
-const messageQueue = [];
-// Helper function to send queued messages
-function flushMessageQueue() {
-    if (webSocket && webSocket.readyState === WebSocket.OPEN) {
-        while (messageQueue.length > 0) {
-            const message = messageQueue.shift();
-            if (message) {
+function isWebSocketOpen(ws) {
+    return ws?.readyState === WebSocket.OPEN;
+}
+async function flushNotifyQueue() {
+    const stored = await getAllNotifyMessages();
+    if (!isWebSocketOpen(webSocket))
+        return;
+    try {
+        for (const event of stored) {
+            webSocket.send(event.value);
+            await deleteNotifyMessageById(event.id);
+        }
+    }
+    catch (e) { }
+}
+export async function flushBufferedEvents() {
+    if (!isWebSocketOpen(webSocket))
+        return;
+    const persisted = await getAllIndexedEvents();
+    const groupedBySession = {};
+    for (const event of persisted) {
+        const sessionId = event?.data?.data?.sessionId ?? 'unknown-session';
+        if (!groupedBySession[sessionId])
+            groupedBySession[sessionId] = [];
+        groupedBySession[sessionId].push(event);
+    }
+    for (const groupedEvents of Object.values(groupedBySession)) {
+        const idbBatches = buildBatches(groupedEvents, (e) => eventSize(e.data), MAX_MESSAGE_SIZE_BYTES);
+        for (const batch of idbBatches) {
+            if (!isWebSocketOpen(webSocket))
+                break;
+            const eventsToSend = batch.map(e => e.data);
+            const idsToDelete = batch.map(e => e.id).filter((id) => id != null);
+            try {
+                const message = JSON.stringify({
+                    type: 'events',
+                    events: eventsToSend,
+                    mapUuid: window.sfMapUuid,
+                });
                 webSocket.send(message);
+                await deleteEventsByIds(idsToDelete);
             }
+            catch (err) { }
+        }
+    }
+}
+export function sendEvent(event) {
+    const msg = JSON.stringify({
+        type: 'event',
+        event,
+        mapUuid: window.sfMapUuid,
+    });
+    if (isWebSocketOpen(webSocket)) {
+        try {
+            webSocket.send(msg);
+        }
+        catch (err) {
+            saveEventToIDB(event);
         }
     }
+    else {
+        saveEventToIDB(event);
+    }
 }
 export function initializeWebSocket(backendApi, apiKey, sessionId) {
     const wsHost = getWebSocketHost(backendApi);
@@ -24,7 +80,10 @@ export function initializeWebSocket(backendApi, apiKey, sessionId) {
     };
     webSocket = new ReconnectingWebSocket(wsUrl, [], options);
     webSocket.addEventListener("open", () => {
-        flushMessageQueue();
+        (async () => {
+            await flushNotifyQueue();
+            setInterval(() => flushBufferedEvents(), 10000);
+        })();
     });
     webSocket.addEventListener("close", () => {
         // Handle reconnect logic or cleanup here if needed
@@ -33,12 +92,17 @@ export function initializeWebSocket(backendApi, apiKey, sessionId) {
     return webSocket;
 }
 export function sendMessage(message) {
-    const messageString = JSON.stringify(message);
-    if (webSocket && webSocket.readyState === WebSocket.OPEN) {
-        webSocket.send(messageString);
+    const msg = JSON.stringify(message);
+    if (isWebSocketOpen(webSocket)) {
+        try {
+            webSocket.send(msg);
+        }
+        catch (err) {
+            saveNotifyMessageToIDB(msg);
+        }
     }
     else {
-        messageQueue.push(messageString);
+        saveNotifyMessageToIDB(msg);
     }
 }
 function getWebSocketHost(url) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailfish-ai/recorder",
-  "version": "1.7.8",
+  "version": "1.7.11",
   "publishPublicly": true,
   "main": "dist/sailfish-recorder.umd.js",
   "types": "dist/types/index.d.ts",
@@ -28,6 +28,7 @@
     "@sailfish-rrweb/rrweb-record-only": "https://us-npm.pkg.dev/sailfish-ai/sailfishai-npm-public/@sailfish-rrweb/rrweb-record-only/-/rrweb-record-only-0.5.2.tgz",
     "@sailfish-rrweb/types": "https://us-npm.pkg.dev/sailfish-ai/sailfishai-npm-public/@sailfish-rrweb/types/-/types-0.5.2.tgz",
     "async-mutex": "^0.5.0",
+    "idb": "^8.0.3",
     "react-zendesk": "^0.1.13",
     "reconnecting-websocket": "^4.4.0",
     "source-map-js": "^1.2.1",

package/dist/eventCache.js

@@ -1,43 +0,0 @@
-import { Mutex } from "async-mutex";
-const MAX_MESSAGE_SIZE_MB = 50;
-const MAX_MESSAGE_SIZE_BYTES = MAX_MESSAGE_SIZE_MB * 1024 * 1024;
-let eventCache = [];
-const mutex = new Mutex();
-export function cacheEvents(event) {
-    mutex.runExclusive(() => {
-        eventCache.push(event);
-    });
-}
-export function sendRecordingEvents(webSocket) {
-    mutex.runExclusive(() => {
-        if (webSocket && webSocket.readyState === WebSocket.OPEN) {
-            if (eventCache.length > 0) {
-                let batch = [];
-                let batchSize = 0;
-                const sendBatch = () => {
-                    if (batch.length > 0) {
-                        const message = JSON.stringify({ type: "events", events: batch, mapUuid: window.sfMapUuid });
-                        webSocket.send(message);
-                        batch = [];
-                        batchSize = 0;
-                    }
-                };
-                for (const event of eventCache) {
-                    const eventSize = new Blob([JSON.stringify(event)]).size;
-                    if (eventSize > MAX_MESSAGE_SIZE_BYTES) {
-                        console.error(`Event Type: ${event.type || "unknown"} exceeds ${MAX_MESSAGE_SIZE_MB}MB limit! It may be rejected by the backend.`);
-                        webSocket.send(JSON.stringify({ type: "events", events: [event] }));
-                        continue;
-                    }
-                    if (batchSize + eventSize > MAX_MESSAGE_SIZE_BYTES) {
-                        sendBatch();
-                    }
-                    batch.push(event);
-                    batchSize += eventSize;
-                }
-                sendBatch();
-                eventCache = [];
-            }
-        }
-    });
-}

package/dist/types/eventCache.d.ts

@@ -1,2 +0,0 @@
-export declare function cacheEvents(event: any): void;
-export declare function sendRecordingEvents(webSocket: any): void;