@sailfish-ai/recorder 1.8.2 → 1.8.8

package/dist/recording.js

@@ -85,6 +85,8 @@ export const getUrlAndStoredUuids = () => ({
     page_visit_uuid: sessionStorage.getItem("pageVisitUUID"),
     prev_page_visit_uuid: sessionStorage.getItem("prevPageVisitUUID"),
     href: location.origin + location.pathname,
+    tabVisibilityChanged: sessionStorage.getItem("tabVisibilityChanged"),
+    tabVisibilityState: sessionStorage.getItem("tabVisibilityState"),
 });
 export function initializeDomContentEvents(sessionId) {
     document.addEventListener("readystatechange", () => {

package/dist/types/errorInterceptor.d.ts

@@ -1,8 +1,3 @@
-/**
- * Resolves stack traces using source maps.
- * @param stackTrace - The minified stack trace.
- * @returns The mapped stack trace with original file/line/column.
- */
 export declare function resolveStackTrace(stackTrace?: string | string[]): Promise<string[]>;
 /**
  * Initializes the error interceptor globally.

package/dist/types/recording.d.ts

@@ -4,6 +4,8 @@ export declare const getUrlAndStoredUuids: () => {
     page_visit_uuid: string;
     prev_page_visit_uuid: string;
     href: string;
+    tabVisibilityChanged: string;
+    tabVisibilityState: string;
 };
 export declare function initializeDomContentEvents(sessionId: string): void;
 export declare function initializeConsolePlugin(consoleRecordSettings: LogRecordOptions, sessionId: string): void;

package/dist/types/websocket.d.ts

@@ -3,3 +3,26 @@ 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;
+/**
+ * Enable function span tracking for this session (e.g., when report issue recording starts)
+ * This is LOCAL tracking mode - only this session, not global
+ */
+export declare function enableFunctionSpanTracking(): void;
+/**
+ * Disable function span tracking for this session (e.g., when report issue recording stops)
+ * Only disables if we're in LOCAL tracking mode
+ */
+export declare function disableFunctionSpanTracking(): void;
+/**
+ * Check if function span tracking is currently enabled
+ */
+export declare function isFunctionSpanTrackingEnabled(): boolean;
+/**
+ * Get the current funcspan header name and value
+ * Header constants are defined here but used by HTTP interceptors in index.tsx
+ * Checks both the enabled flag AND the expiration time before returning the header
+ */
+export declare function getFuncSpanHeader(): {
+    name: string;
+    value: string;
+} | null;

package/dist/websocket.js

@@ -8,10 +8,21 @@ import version from "./version";
 const DEBUG = readDebugFlag(); // A wrapper around fetch that suppresses connection refused errors
 const MAX_MESSAGE_SIZE_MB = 50;
 const MAX_MESSAGE_SIZE_BYTES = MAX_MESSAGE_SIZE_MB * 1024 * 1024;
+// Function span tracking header constants
+const FUNCSPAN_HEADER_NAME = "X-Sf3-FunctionSpanCaptureOverride";
+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";
 let webSocket = null;
 let isDraining = false;
 let inFlightFlush = null;
 let flushIntervalId = null;
+// 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
 function isWebSocketOpen(ws) {
     return ws?.readyState === WebSocket.OPEN;
 }
@@ -49,10 +60,15 @@ export async function flushBufferedEvents() {
             for (const batch of idbBatches) {
                 if (!isWebSocketOpen(webSocket))
                     break;
-                const eventsToSend = batch.map((e) => ({
-                    ...e.data,
-                    appUrl: e.data?.appUrl ?? window?.location?.href,
-                }));
+                const eventsToSend = batch.map((e) => {
+                    const event = {
+                        ...e.data,
+                        appUrl: e.data?.appUrl ?? window?.location?.href,
+                    };
+                    // Note: We do NOT add funcspan header to websocket events
+                    // The header is only added to HTTP network requests
+                    return event;
+                });
                 const idsToDelete = batch
                     .map((e) => e.id)
                     .filter((id) => id != null);
@@ -81,6 +97,9 @@ export function sendEvent(event) {
         ...event,
         app_url: event?.app_url ?? window?.location?.href,
     };
+    // Note: We do NOT add funcspan header to websocket events
+    // The header is only added to HTTP network requests (fetch/XMLHttpRequest)
+    // This is handled in index.tsx injectHeader function
     if (isDraining || !isWebSocketOpen(webSocket)) {
         saveEventToIDB(enrichedEvent);
         return;
@@ -107,8 +126,10 @@ export function initializeWebSocket(backendApi, apiKey, sessionId) {
     };
     webSocket = new ReconnectingWebSocket(wsUrl, [], options);
     webSocket.addEventListener("open", () => {
-        if (DEBUG)
-            console.log("WebSocket opened.");
+        if (DEBUG) {
+            console.log("[Sailfish] WebSocket connection opened");
+            console.log(`[Sailfish] Function span tracking state: ${funcSpanTrackingEnabled ? 'ENABLED' : 'DISABLED'}`);
+        }
         (async () => {
             try {
                 isDraining = true; //  begin drain (blocks live sends)
@@ -128,7 +149,109 @@ export function initializeWebSocket(backendApi, apiKey, sessionId) {
         })();
     });
     webSocket.addEventListener("close", () => {
-        console.log("WebSocket closed.");
+        if (DEBUG)
+            console.log("[Sailfish] WebSocket closed");
+    });
+    webSocket.addEventListener("message", (event) => {
+        try {
+            const data = JSON.parse(event.data);
+            // Handle function span tracking control messages from backend
+            if (data.type === "funcSpanTrackingControl") {
+                if (DEBUG) {
+                    console.log(`[Sailfish] Received funcSpanTrackingControl message:`, {
+                        enabled: data.enabled,
+                        timeoutSeconds: data.timeoutSeconds,
+                        expirationTimestampMs: data.expirationTimestampMs
+                    });
+                }
+                // Clear any existing timeout
+                if (funcSpanTimeoutId !== null) {
+                    window.clearTimeout(funcSpanTimeoutId);
+                    funcSpanTimeoutId = null;
+                }
+                // This is a GLOBAL tracking control message
+                funcSpanTrackingEnabled = data.enabled;
+                isLocalTrackingMode = false; // Mark as global tracking, not local
+                if (DEBUG) {
+                    console.log(`[Sailfish] Function span tracking ${data.enabled ? 'ENABLED (GLOBAL)' : 'DISABLED (GLOBAL)'}`);
+                }
+                if (data.enabled) {
+                    // Use server-provided expiration timestamp for synchronization across all clients/pods
+                    // This ensures all clients expire at the same time, even if they receive the message at different times
+                    if (data.expirationTimestampMs) {
+                        funcSpanExpirationTime = data.expirationTimestampMs;
+                        // Calculate how many milliseconds until expiration
+                        const now = Date.now();
+                        const msUntilExpiration = funcSpanExpirationTime - now;
+                        if (DEBUG) {
+                            console.log(`[Sailfish] Server expiration timestamp: ${funcSpanExpirationTime}, ms until expiration: ${msUntilExpiration}`);
+                        }
+                        if (msUntilExpiration > 0) {
+                            funcSpanTimeoutId = window.setTimeout(() => {
+                                // Only auto-disable if still in global mode
+                                if (!isLocalTrackingMode) {
+                                    funcSpanTrackingEnabled = false;
+                                    funcSpanExpirationTime = null;
+                                    if (DEBUG) {
+                                        console.log(`[Sailfish] GLOBAL function span tracking auto-disabled at server expiration time`);
+                                    }
+                                }
+                            }, msUntilExpiration);
+                        }
+                        else {
+                            // Already expired
+                            funcSpanTrackingEnabled = false;
+                            funcSpanExpirationTime = null;
+                            if (DEBUG) {
+                                console.log(`[Sailfish] Tracking already expired, not enabling`);
+                            }
+                        }
+                    }
+                    else {
+                        // Fallback: no server timestamp provided, use local calculation (legacy behavior)
+                        const timeoutSeconds = data.timeoutSeconds || 3600; // Default 1 hour
+                        if (timeoutSeconds > 0) {
+                            funcSpanExpirationTime = Date.now() + (timeoutSeconds * 1000);
+                            funcSpanTimeoutId = window.setTimeout(() => {
+                                if (!isLocalTrackingMode) {
+                                    funcSpanTrackingEnabled = false;
+                                    funcSpanExpirationTime = null;
+                                    if (DEBUG) {
+                                        console.log(`[Sailfish] GLOBAL function span tracking auto-disabled after ${timeoutSeconds}s (legacy)`);
+                                    }
+                                }
+                            }, timeoutSeconds * 1000);
+                        }
+                    }
+                    // Immediately report this session ID back to backend (non-blocking)
+                    // This allows backend to track which sessions are active during tracking
+                    try {
+                        const sessionId = getOrSetSessionId();
+                        webSocket.send(JSON.stringify({
+                            type: "funcSpanTrackingSessionReport",
+                            sessionId: sessionId,
+                            enabled: true,
+                            configurationType: TRACKING_CONFIG_GLOBAL
+                        }));
+                        if (DEBUG) {
+                            console.log(`[Sailfish] GLOBAL tracking session report sent for session: ${sessionId}`);
+                        }
+                    }
+                    catch (e) {
+                        if (DEBUG) {
+                            console.warn(`[Sailfish] Failed to send GLOBAL tracking session report:`, e);
+                        }
+                    }
+                }
+                else {
+                    // When disabled, clear expiration time
+                    funcSpanExpirationTime = null;
+                }
+            }
+        }
+        catch (e) {
+            // Ignore parse errors for non-JSON messages
+        }
     });
     return webSocket;
 }
@@ -157,3 +280,117 @@ function getWebSocketHost(url) {
     parser.href = url;
     return `${parser.hostname}${parser.port ? `:${parser.port}` : ""}`;
 }
+/**
+ * Enable function span tracking for this session (e.g., when report issue recording starts)
+ * This is LOCAL tracking mode - only this session, not global
+ */
+export function enableFunctionSpanTracking() {
+    if (DEBUG) {
+        console.log("[Sailfish] enableFunctionSpanTracking() called - Report Issue recording started (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;
+    }
+    // Report this session to backend for tracking with per_session configuration type
+    if (isWebSocketOpen(webSocket)) {
+        try {
+            const sessionId = getOrSetSessionId();
+            const message = {
+                type: "funcSpanTrackingSessionReport",
+                sessionId: sessionId,
+                enabled: true,
+                configurationType: TRACKING_CONFIG_PER_SESSION,
+            };
+            webSocket.send(JSON.stringify(message));
+        }
+        catch (e) {
+            console.error(`[FUNCSPAN START] ✗ Failed to send tracking session report:`, e);
+        }
+    }
+    else {
+        if (DEBUG) {
+            console.warn(`[Sailfish] WebSocket not open, cannot report LOCAL tracking session`);
+        }
+    }
+}
+/**
+ * Disable function span tracking for this session (e.g., when report issue recording stops)
+ * Only disables if we're in LOCAL tracking mode
+ */
+export function disableFunctionSpanTracking() {
+    if (DEBUG) {
+        console.log("[Sailfish] disableFunctionSpanTracking() called - Report Issue recording stopped");
+    }
+    // Always send the disable message for per-session tracking
+    // This will only disable tracking for THIS specific recording session
+    // Global tracking (if active) will remain active
+    if (isWebSocketOpen(webSocket)) {
+        try {
+            const sessionId = getOrSetSessionId();
+            const message = {
+                type: "funcSpanTrackingSessionReport",
+                sessionId: sessionId,
+                enabled: false,
+                configurationType: TRACKING_CONFIG_PER_SESSION,
+            };
+            webSocket.send(JSON.stringify(message));
+        }
+        catch (e) {
+            console.error(`[FUNCSPAN STOP] ✗ Failed to send tracking stop report:`, e);
+        }
+    }
+    else {
+        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");
+        }
+    }
+    // Clear any existing timeout
+    if (funcSpanTimeoutId !== null) {
+        window.clearTimeout(funcSpanTimeoutId);
+        funcSpanTimeoutId = null;
+    }
+}
+/**
+ * Check if function span tracking is currently enabled
+ */
+export function isFunctionSpanTrackingEnabled() {
+    return funcSpanTrackingEnabled;
+}
+/**
+ * Get the current funcspan header name and value
+ * Header constants are defined here but used by HTTP interceptors in index.tsx
+ * Checks both the enabled flag AND the expiration time before returning the header
+ */
+export function getFuncSpanHeader() {
+    if (!funcSpanTrackingEnabled) {
+        return null;
+    }
+    // Check if tracking has expired (for global mode with timeout)
+    if (funcSpanExpirationTime !== null) {
+        const now = Date.now();
+        if (now >= funcSpanExpirationTime) {
+            // Tracking has expired, disable it immediately
+            funcSpanTrackingEnabled = false;
+            funcSpanExpirationTime = null;
+            if (DEBUG) {
+                console.log("[Sailfish] Function span tracking expired on header check - disabling now");
+            }
+            return null;
+        }
+    }
+    return {
+        name: FUNCSPAN_HEADER_NAME,
+        value: FUNCSPAN_HEADER_VALUE
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailfish-ai/recorder",
-  "version": "1.8.2",
+  "version": "1.8.8",
   "publishPublicly": true,
   "type": "module",
   "main": "dist/recorder.cjs",
@@ -37,6 +37,7 @@
     "dist"
   ],
   "dependencies": {
+    "@sailfish-ai/sf-map-utils": "0.4.3",
     "@sailfish-rrweb/rrweb-plugin-console-record": "0.5.2",
     "@sailfish-rrweb/rrweb-record-only": "0.5.2",
     "@sailfish-rrweb/types": "0.5.2",