@sailfish-ai/recorder 1.8.7 → 1.8.9

package/dist/websocket.js

@@ -14,15 +14,102 @@ const FUNCSPAN_HEADER_VALUE = "1-0-5-5-0-1.0";
 // Tracking configuration type constants (must match backend TrackingConfigurationType enum)
 const TRACKING_CONFIG_GLOBAL = "global";
 const TRACKING_CONFIG_PER_SESSION = "per_session";
+// localStorage key for persisting global function span tracking state
+const FUNCSPAN_GLOBAL_STATE_KEY = "sailfish_funcspan_global_state";
 let webSocket = null;
 let isDraining = false;
 let inFlightFlush = null;
 let flushIntervalId = null;
+function saveGlobalFuncSpanState(enabled, expirationTimestampMs) {
+    try {
+        if (typeof localStorage === "undefined")
+            return;
+        const state = {
+            enabled,
+            expirationTimestampMs,
+        };
+        localStorage.setItem(FUNCSPAN_GLOBAL_STATE_KEY, JSON.stringify(state));
+        if (DEBUG) {
+            console.log(`[Sailfish] Saved global function span state to localStorage:`, state);
+        }
+    }
+    catch (e) {
+        if (DEBUG) {
+            console.warn(`[Sailfish] Failed to save global function span state to localStorage:`, e);
+        }
+    }
+}
+function loadGlobalFuncSpanState() {
+    try {
+        if (typeof localStorage === "undefined")
+            return null;
+        const stored = localStorage.getItem(FUNCSPAN_GLOBAL_STATE_KEY);
+        if (!stored)
+            return null;
+        const state = JSON.parse(stored);
+        // Check if the stored state has expired
+        if (state.enabled && state.expirationTimestampMs) {
+            const now = Date.now();
+            if (now >= state.expirationTimestampMs) {
+                // Expired - clear localStorage and return null
+                if (DEBUG) {
+                    console.log(`[Sailfish] Stored global function span state has expired, clearing`);
+                }
+                localStorage.removeItem(FUNCSPAN_GLOBAL_STATE_KEY);
+                return null;
+            }
+        }
+        if (DEBUG) {
+            console.log(`[Sailfish] Loaded global function span state from localStorage:`, state);
+        }
+        return state;
+    }
+    catch (e) {
+        if (DEBUG) {
+            console.warn(`[Sailfish] Failed to load global function span state from localStorage:`, e);
+        }
+        return null;
+    }
+}
+function clearGlobalFuncSpanState() {
+    try {
+        if (typeof localStorage === "undefined")
+            return;
+        localStorage.removeItem(FUNCSPAN_GLOBAL_STATE_KEY);
+        if (DEBUG) {
+            console.log(`[Sailfish] Cleared global function span state from localStorage`);
+        }
+    }
+    catch (e) {
+        if (DEBUG) {
+            console.warn(`[Sailfish] Failed to clear global function span state from localStorage:`, e);
+        }
+    }
+}
 // Function span tracking state (only manages enabled/disabled)
 let funcSpanTrackingEnabled = false;
 let funcSpanTimeoutId = null;
 let funcSpanExpirationTime = null; // Timestamp when tracking should expire (milliseconds)
 let isLocalTrackingMode = false; // True when tracking is enabled locally (Report Issue), not globally
+// Saved global state when switching to local mode
+let savedGlobalTimeoutId = null;
+let savedGlobalExpirationTime = null;
+// Load persisted global state immediately on module initialization
+// This ensures headers are added from the very first HTTP request, even before WebSocket connects
+(() => {
+    const persistedState = loadGlobalFuncSpanState();
+    if (persistedState && persistedState.enabled) {
+        funcSpanTrackingEnabled = true;
+        funcSpanExpirationTime = persistedState.expirationTimestampMs;
+        isLocalTrackingMode = false;
+        if (DEBUG) {
+            console.log(`[Sailfish] Module init: Restored global function span tracking from localStorage:`, {
+                enabled: true,
+                expirationTimestampMs: funcSpanExpirationTime,
+            });
+        }
+    }
+})();
 function isWebSocketOpen(ws) {
     return ws?.readyState === WebSocket.OPEN;
 }
@@ -117,6 +204,9 @@ export function sendEvent(event) {
     }
 }
 export function initializeWebSocket(backendApi, apiKey, sessionId) {
+    // Note: Global function span tracking state is now loaded at module initialization time
+    // (see IIFE above) so headers work immediately, even before WebSocket connects.
+    // The WebSocket "funcSpanTrackingControl" message will update the state if needed.
     const wsHost = getWebSocketHost(backendApi);
     const apiProtocol = new URL(backendApi).protocol;
     const wsScheme = apiProtocol === "https:" ? "wss" : "ws";
@@ -187,11 +277,15 @@ export function initializeWebSocket(backendApi, apiKey, sessionId) {
                             console.log(`[Sailfish] Server expiration timestamp: ${funcSpanExpirationTime}, ms until expiration: ${msUntilExpiration}`);
                         }
                         if (msUntilExpiration > 0) {
+                            // Save to localStorage for persistence across page refreshes
+                            saveGlobalFuncSpanState(true, funcSpanExpirationTime);
                             funcSpanTimeoutId = window.setTimeout(() => {
                                 // Only auto-disable if still in global mode
                                 if (!isLocalTrackingMode) {
                                     funcSpanTrackingEnabled = false;
                                     funcSpanExpirationTime = null;
+                                    // Clear localStorage when tracking expires
+                                    clearGlobalFuncSpanState();
                                     if (DEBUG) {
                                         console.log(`[Sailfish] GLOBAL function span tracking auto-disabled at server expiration time`);
                                     }
@@ -202,6 +296,8 @@ export function initializeWebSocket(backendApi, apiKey, sessionId) {
                             // Already expired
                             funcSpanTrackingEnabled = false;
                             funcSpanExpirationTime = null;
+                            // Clear localStorage if tracking already expired
+                            clearGlobalFuncSpanState();
                             if (DEBUG) {
                                 console.log(`[Sailfish] Tracking already expired, not enabling`);
                             }
@@ -212,10 +308,14 @@ export function initializeWebSocket(backendApi, apiKey, sessionId) {
                         const timeoutSeconds = data.timeoutSeconds || 3600; // Default 1 hour
                         if (timeoutSeconds > 0) {
                             funcSpanExpirationTime = Date.now() + (timeoutSeconds * 1000);
+                            // Save to localStorage for persistence across page refreshes
+                            saveGlobalFuncSpanState(true, funcSpanExpirationTime);
                             funcSpanTimeoutId = window.setTimeout(() => {
                                 if (!isLocalTrackingMode) {
                                     funcSpanTrackingEnabled = false;
                                     funcSpanExpirationTime = null;
+                                    // Clear localStorage when tracking expires
+                                    clearGlobalFuncSpanState();
                                     if (DEBUG) {
                                         console.log(`[Sailfish] GLOBAL function span tracking auto-disabled after ${timeoutSeconds}s (legacy)`);
                                     }
@@ -244,8 +344,9 @@ export function initializeWebSocket(backendApi, apiKey, sessionId) {
                     }
                 }
                 else {
-                    // When disabled, clear expiration time
+                    // When disabled, clear expiration time and localStorage
                     funcSpanExpirationTime = null;
+                    clearGlobalFuncSpanState();
                 }
             }
         }
@@ -288,14 +389,18 @@ export function enableFunctionSpanTracking() {
     if (DEBUG) {
         console.log("[Sailfish] enableFunctionSpanTracking() called - Report Issue recording started (LOCAL MODE)");
     }
+    // If global tracking was already active, save its state so we can restore it later
+    if (funcSpanTrackingEnabled && !isLocalTrackingMode) {
+        savedGlobalTimeoutId = funcSpanTimeoutId;
+        savedGlobalExpirationTime = funcSpanExpirationTime;
+        if (DEBUG) {
+            console.log("[Sailfish] Saved global tracking state while switching to local mode");
+        }
+    }
     funcSpanTrackingEnabled = true;
     isLocalTrackingMode = true; // Mark as local tracking
     funcSpanExpirationTime = null; // Local mode has no expiration
-    // Clear any existing timeout
-    if (funcSpanTimeoutId !== null) {
-        window.clearTimeout(funcSpanTimeoutId);
-        funcSpanTimeoutId = null;
-    }
+    funcSpanTimeoutId = null; // Clear timeout (saved above if it was global)
     // Report this session to backend for tracking with per_session configuration type
     if (isWebSocketOpen(webSocket)) {
         try {
@@ -348,17 +453,28 @@ export function disableFunctionSpanTracking() {
         console.warn(`[FUNCSPAN STOP] ✗ WebSocket not open, cannot notify tracking end`);
     }
     if (isLocalTrackingMode) {
-        funcSpanTrackingEnabled = false;
         isLocalTrackingMode = false;
-        funcSpanExpirationTime = null;
-        if (DEBUG) {
-            console.log("[Sailfish] LOCAL tracking mode disabled");
+        // Restore global tracking state if it was active before local mode
+        if (savedGlobalTimeoutId !== null || savedGlobalExpirationTime !== null) {
+            funcSpanTrackingEnabled = true; // Keep tracking enabled (global was active)
+            funcSpanExpirationTime = savedGlobalExpirationTime;
+            funcSpanTimeoutId = savedGlobalTimeoutId;
+            if (DEBUG) {
+                console.log("[Sailfish] LOCAL tracking mode disabled, restored GLOBAL tracking state");
+            }
+            // Clear saved state
+            savedGlobalTimeoutId = null;
+            savedGlobalExpirationTime = null;
+        }
+        else {
+            // No global tracking was active, fully disable
+            funcSpanTrackingEnabled = false;
+            funcSpanExpirationTime = null;
+            funcSpanTimeoutId = null;
+            if (DEBUG) {
+                console.log("[Sailfish] LOCAL tracking mode disabled, no global tracking to restore");
+            }
         }
-    }
-    // Clear any existing timeout
-    if (funcSpanTimeoutId !== null) {
-        window.clearTimeout(funcSpanTimeoutId);
-        funcSpanTimeoutId = null;
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailfish-ai/recorder",
-  "version": "1.8.7",
+  "version": "1.8.9",
   "publishPublicly": true,
   "type": "module",
   "main": "dist/recorder.cjs",