@sailfish-ai/recorder 1.0.3 → 1.0.5

package/dist/graphql.js

@@ -52,3 +52,8 @@ export function startRecordingSession(apiKey, recordingId, backendApi) {
         backendApi,
     });
 }
+export function sendDomainsToNotPropagateHeaderTo(apiKey, domains, backendApi) {
+    return sendGraphQLRequest("DomainsToNotPassHeaderTo", `mutation DomainsToNotPassHeaderTo($apiKey: String!, $domains: [String!]!) {
+      domainsToNotPassHeaderTo(apiKey: $apiKey, domains: $domains)
+    }`, { apiKey, domains, backendApi });
+}

package/dist/index.js

@@ -1,10 +1,14 @@
+import { parse as parseDomain } from "tldts"; // Importing tldts
 import { v4 as uuidv4 } from "uuid";
 import { gatherAndCacheDeviceInfo } from "./deviceInfo";
 import { sendRecordingEvents } from "./eventCache";
-import { fetchCaptureSettings, startRecordingSession } from "./graphql";
+import { fetchCaptureSettings, sendDomainsToNotPropagateHeaderTo, startRecordingSession, } from "./graphql";
 import { initializeRecording } from "./recording";
-// Default Settings
-export const DEFAULT_DOMAINS_TO_IGNORE = [];
+// Default list of domains to ignore
+const DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT = [
+    "identitytoolkit.googleapis.com",
+];
+const DOMAINS_TO_NOT_RECORD_NETWORK_REQUESTS_TO = [];
 export const DEFAULT_CAPTURE_SETTINGS = {
     recordCanvas: false,
     recordCrossOriginIframes: false,
@@ -30,8 +34,8 @@ export const DEFAULT_CONSOLE_RECORDING_SETTINGS = {
 export const DEFAULT_NETWORK_CAPTURE_SETTINGS = {
     initiatorTypes: ["fetch", "xmlhttprequest"],
     ignoreRequestFn: (request) => {
-        const domain = extractHostname(request.url);
-        return DEFAULT_DOMAINS_TO_IGNORE.includes(domain);
+        const domain = getEffectiveDomain(request.url);
+        return DOMAINS_TO_NOT_RECORD_NETWORK_REQUESTS_TO.includes(domain);
     },
     recordHeaders: true,
     ignoreHeaders: {
@@ -45,6 +49,14 @@ export const DEFAULT_NETWORK_CAPTURE_SETTINGS = {
     recordBody: true,
     recordInitialRequests: false,
 };
+// Function to strip 'www.' and get the effective domain from a URL using tldts
+function getEffectiveDomain(url) {
+    const parsed = parseDomain(url);
+    const domain = parsed.subdomain !== ""
+        ? `${parsed.subdomain}.${parsed.domain}`
+        : parsed.domain;
+    return domain.startsWith("www.") ? domain.slice(4) : domain;
+}
 // Functions
 // Function to get the current sessionId from sessionStorage
 function getOrSetSessionId(forceNew = false) {
@@ -71,27 +83,37 @@ function storeCredentialsAndConnection({ apiKey, backendApi, }) {
     sessionStorage.setItem("sailfishBackendApi", backendApi);
 }
 // Intercepting XMLHttpRequest
-(function () {
+function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo) {
     const originalOpen = XMLHttpRequest.prototype.open;
     const originalSend = XMLHttpRequest.prototype.send;
     const sessionId = getOrSetSessionId();
+    const combinedIgnoreDomains = [
+        ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
+        ...domainsToNotPropagateHeaderTo,
+    ].map((domain) => (domain.startsWith("www.") ? domain.slice(4) : domain)); // Remove 'www.' from ignore domains
     XMLHttpRequest.prototype.open = function (...args) {
         this._url = args[1]; // Store the request URL
         originalOpen.apply(this, args);
     };
     XMLHttpRequest.prototype.send = function (...args) {
-        if (sessionId) {
+        const domain = getEffectiveDomain(this._url); // Use tldts to get the domain
+        if (sessionId && !combinedIgnoreDomains.includes(domain)) {
             this.setRequestHeader("X-Sf3-Rid", sessionId);
         }
         originalSend.apply(this, args);
     };
-})();
+}
 // Intercepting fetch API
-(function () {
+function setupFetchInterceptor(domainsToNotPropagateHeaderTo) {
     const originalFetch = window.fetch;
     const sessionId = getOrSetSessionId();
+    const combinedIgnoreDomains = [
+        ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
+        ...domainsToNotPropagateHeaderTo,
+    ].map((domain) => (domain.startsWith("www.") ? domain.slice(4) : domain)); // Remove 'www.' from ignore domains
     window.fetch = async function (input, init = {}) {
-        if (sessionId) {
+        const domain = typeof input === "string" ? getEffectiveDomain(input) : "";
+        if (sessionId && !combinedIgnoreDomains.includes(domain)) {
             init.headers = {
                 ...init.headers,
                 "X-Sf3-Rid": sessionId,
@@ -99,11 +121,18 @@ function storeCredentialsAndConnection({ apiKey, backendApi, }) {
         }
         return originalFetch(input, init);
     };
-})();
+}
 // Main Recording Function
-export async function startRecording({ apiKey, backendApi, }) {
+export async function startRecording({ apiKey, backendApi, domainsToNotPropagateHeaderTo = [], }) {
     let sessionId = getOrSetSessionId();
     storeCredentialsAndConnection({ apiKey, backendApi });
+    // Non-blocking GraphQL request to send the domains if provided
+    if (domainsToNotPropagateHeaderTo.length > 0) {
+        sendDomainsToNotPropagateHeaderTo(apiKey, domainsToNotPropagateHeaderTo, backendApi).catch((error) => console.error("Failed to send domains to not propagate header to:", error));
+    }
+    // Setup interceptors with custom ignore domains
+    setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo);
+    setupFetchInterceptor(domainsToNotPropagateHeaderTo);
     gatherAndCacheDeviceInfo();
     try {
         const captureSettingsResponse = await fetchCaptureSettings(apiKey, backendApi);
@@ -111,15 +140,11 @@ export async function startRecording({ apiKey, backendApi, }) {
             DEFAULT_CAPTURE_SETTINGS;
         const sessionResponse = await startRecordingSession(apiKey, sessionId, backendApi);
         if (sessionResponse.data?.startRecordingSession) {
-            // Initialize recording
             const websocket = await initializeRecording(captureSettings, DEFAULT_CONSOLE_RECORDING_SETTINGS, DEFAULT_NETWORK_CAPTURE_SETTINGS, backendApi, apiKey, sessionId);
-            // Set up an interval to send recording events
             setInterval(() => {
                 if (websocket && websocket.readyState === WebSocket.OPEN) {
                     sendRecordingEvents(websocket);
                 }
-                else {
-                }
             }, 10000);
         }
         else {
@@ -130,12 +155,6 @@ export async function startRecording({ apiKey, backendApi, }) {
         console.error("Error starting recording:", error);
     }
 }
-function extractHostname(url) {
-    let hostname = url.indexOf("//") > -1 ? url.split("/")[2] : url.split("/")[0];
-    hostname = hostname.split(":")[0];
-    hostname = hostname.split("?")[0];
-    return hostname;
-}
 // Re-export from other modules
 export * from "./eventCache";
 export * from "./graphql";

package/dist/recording.js

@@ -3,7 +3,6 @@ import { getRecordConsolePlugin, } from "@sailfish-rrweb/rrweb-plugin-console-re
 import { cacheEvents, sendRecordingEvents } from "./eventCache";
 import { initializeWebSocket } from "./websocket";
 const MASK_CLASS = "sailfishSanitize";
-const DEFAULT_DOMAINS_TO_IGNORE = [];
 function maskInputFn(text, node) {
     // Exclude input[type=hidden] fields
     if (node.type === "hidden") {