@sailfish-ai/recorder 1.7.46 → 1.7.49

package/dist/session.js

@@ -0,0 +1,12 @@
+import { v4 as uuidv4 } from "uuid";
+import { HAS_WINDOW } from "./runtimeEnv";
+// Storing the sailfishSessionId in window.name, as window.name retains its value after a page refresh
+// but resets when a new tab (including a duplicated tab) is opened.
+export function getOrSetSessionId() {
+    if (!HAS_WINDOW)
+        return uuidv4();
+    if (!window.name) {
+        window.name = uuidv4();
+    }
+    return window.name;
+}

package/dist/types/inAppReportIssueModal.d.ts

@@ -25,12 +25,14 @@ export declare const ReportIssueContext: {
     apiKey: string | null;
     backendApi: string | null;
     triageBaseUrl: string;
+    deactivateIsolation: () => void;
 };
 export declare function setupIssueReporting(options: {
     apiKey: string;
     backendApi: string;
     getSessionId: () => string;
     shortcuts?: Partial<ShortcutsConfig>;
+    customBaseUrl?: string;
 }): void;
-export declare function openReportIssueModal(customBaseUrl?: string): void;
+export declare function openReportIssueModal(): void;
 export {};

package/dist/types/index.d.ts

@@ -2,17 +2,6 @@ import { LogRecordOptions } from "@sailfish-rrweb/rrweb-plugin-console-record";
 import { ShortcutsConfig } from "./inAppReportIssueModal";
 import { CaptureSettings } from "./types";
 export declare const STORAGE_VERSION = 1;
-export declare const DYNAMIC_PASSED_HOSTS_KEY = "dynamicPassedHosts";
-export declare const DYNAMIC_EXCLUDED_HOSTS_KEY = "dynamicExcludedHosts";
-export declare const dynamicExcludedHosts: Set<string>;
-export declare const dynamicPassedHosts: Set<string>;
-/**
- * Given a set of excluded hostPaths (like "foo.com/bar", "foo.com/baz", etc.),
- * find any path prefixes under each host that appear ≥ threshold times,
- * and replace their individual entries with a single wildcard pattern
- * (e.g. "foo.com/bar*").
- */
-export declare function consolidateDynamicExclusions(hostPathSet: Set<string>, threshold?: number): Set<string>;
 export declare const DEFAULT_CAPTURE_SETTINGS: CaptureSettings;
 export declare const DEFAULT_CONSOLE_RECORDING_SETTINGS: LogRecordOptions;
 export declare function matchUrlWithWildcard(input: unknown, patterns: string[]): boolean;
@@ -36,6 +25,7 @@ export declare const initRecorder: (options: {
     serviceIdentifier?: string;
     gitSha?: string;
     serviceAdditionalMetadata?: Record<string, any>;
+    customBaseUrl?: string;
 }) => Promise<void>;
 export * from "./graphql";
 export { openReportIssueModal } from "./inAppReportIssueModal";

package/dist/types/runtimeEnv.d.ts

@@ -0,0 +1,4 @@
+export declare const HAS_WINDOW: boolean;
+export declare const HAS_DOCUMENT: boolean;
+export declare const HAS_LOCAL_STORAGE: boolean;
+export declare const HAS_SESSION_STORAGE: boolean;

package/dist/types/session.d.ts

@@ -0,0 +1 @@
+export declare function getOrSetSessionId(): string;

package/dist/websocket.js

@@ -1,12 +1,16 @@
 import ReconnectingWebSocket from "reconnecting-websocket";
 import { deleteEventsByIds, getAllIndexedEvents, saveEventToIDB, } from "./eventStore";
 import { deleteNotifyMessageById, getAllNotifyMessages, saveNotifyMessageToIDB, } from "./notifyEventStore";
+import { getOrSetSessionId } from "./session";
 import { buildBatches, eventSize } from "./utils";
 import version from "./version";
 const MAX_MESSAGE_SIZE_MB = 50;
 const MAX_MESSAGE_SIZE_BYTES = MAX_MESSAGE_SIZE_MB * 1024 * 1024;
 const DEBUG = import.meta.env.VITE_DEBUG ? import.meta.env.VITE_DEBUG : false;
 let webSocket = null;
+let isDraining = false;
+let inFlightFlush = null;
+let flushIntervalId = null;
 function isWebSocketOpen(ws) {
     return ws?.readyState === WebSocket.OPEN;
 }
@@ -25,51 +29,64 @@ async function flushNotifyQueue() {
 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);
+    // ensure only one flush at a time
+    if (inFlightFlush) {
+        await inFlightFlush;
+        return;
     }
-    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);
+    inFlightFlush = (async () => {
+        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) { }
             }
-            catch (err) { }
         }
+    })();
+    try {
+        await inFlightFlush;
+    }
+    finally {
+        inFlightFlush = null;
     }
 }
 export function sendEvent(event) {
+    // while draining, never send live—persist so flush preserves order
+    if (isDraining || !isWebSocketOpen(webSocket)) {
+        saveEventToIDB(event);
+        return;
+    }
     const msg = JSON.stringify({
         type: "event",
         event,
         mapUuid: window.sfMapUuid,
     });
-    if (isWebSocketOpen(webSocket)) {
-        try {
-            webSocket.send(msg);
-        }
-        catch (err) {
-            saveEventToIDB(event);
-        }
+    try {
+        webSocket.send(msg);
     }
-    else {
+    catch (err) {
         saveEventToIDB(event);
     }
 }
@@ -86,8 +103,21 @@ export function initializeWebSocket(backendApi, apiKey, sessionId) {
         if (DEBUG)
             console.log("WebSocket opened.");
         (async () => {
-            await flushNotifyQueue();
-            setInterval(() => flushBufferedEvents(), 10000);
+            try {
+                isDraining = true; //  begin drain (blocks live sends)
+                await flushNotifyQueue(); // notify messages can go first
+                await flushBufferedEvents(); //  ordered drain of IDB events
+            }
+            finally {
+                isDraining = false; //  resume live sends
+            }
+            // start periodic top-up flush after initial drain
+            if (flushIntervalId != null)
+                clearInterval(flushIntervalId);
+            flushIntervalId = window.setInterval(() => {
+                // fire-and-forget; single-flight guard prevents overlaps
+                void flushBufferedEvents();
+            }, 2000);
         })();
     });
     webSocket.addEventListener("close", () => {
@@ -96,6 +126,9 @@ export function initializeWebSocket(backendApi, apiKey, sessionId) {
     return webSocket;
 }
 export function sendMessage(message) {
+    if (!("sessionId" in message)) {
+        message.sessionId = getOrSetSessionId();
+    }
     const msg = JSON.stringify(message);
     if (isWebSocketOpen(webSocket)) {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailfish-ai/recorder",
-  "version": "1.7.46",
+  "version": "1.7.49",
   "publishPublicly": true,
   "main": "dist/sailfish-recorder.umd.js",
   "types": "dist/types/index.d.ts",