@affogatosoftware/recorder 1.2.0 → 1.4.0

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { Recorder, type RecorderSettings } from './recorder/recorder';
+export { Recorder, type RecorderSettings, type CapturedUserIdentity } from './recorder/recorder';
 export { NetworkRecorder, type NetworkRequest } from './recorder/networkRecorder';

package/dist/recorder/networkRecorder.d.ts

@@ -22,6 +22,7 @@ interface NetworkRecorderSettings {
     captureResponseBodies: boolean;
     excludeHeaders: string[];
     requestBodyMaskingFunction?: (body: string) => string;
+    responseBodyMaskingFunction?: (body: string) => string;
 }
 export declare class NetworkRecorder {
     private window;
@@ -47,7 +48,8 @@ export declare class NetworkRecorder {
     private shouldCaptureRequest;
     private sanitizeUrl;
     private filterHeaders;
-    private truncateContent;
+    private truncateRequestContent;
+    private truncateResponseContent;
     private generateRequestId;
     private addCompletedRequest;
     private isErrorRequest;

package/dist/recorder/networkRecorder.js

@@ -152,7 +152,7 @@ export class NetworkRecorder {
             }
             const sanitizedUrl = self.sanitizeUrl(url);
             const filteredHeaders = self.filterHeaders(requestHeaders);
-            const truncatedBody = self.truncateContent(requestBody, self.networkSettings.maxRequestBodySize);
+            const truncatedBody = self.truncateRequestContent(requestBody, self.networkSettings.maxRequestBodySize);
             // Create initial request record
             const networkRequest = {
                 requestId,
@@ -178,7 +178,7 @@ export class NetworkRecorder {
                     try {
                         const clonedResponse = response.clone();
                         const text = await clonedResponse.text();
-                        responseBody = self.truncateContent(text, self.networkSettings.maxResponseBodySize);
+                        responseBody = self.truncateResponseContent(text, self.networkSettings.maxResponseBodySize);
                     }
                     catch (e) {
                         responseBody = "[Unable to read response body]";
@@ -249,7 +249,7 @@ export class NetworkRecorder {
                     method,
                     url,
                     requestHeaders: Object.keys(requestHeaders).length > 0 ? self.filterHeaders(requestHeaders) : undefined,
-                    requestBody: self.truncateContent(requestBody, self.networkSettings.maxRequestBodySize),
+                    requestBody: self.truncateRequestContent(requestBody, self.networkSettings.maxRequestBodySize),
                     timestamp
                 };
                 self.pendingRequests.set(requestId, networkRequest);
@@ -273,7 +273,7 @@ export class NetworkRecorder {
                         }
                         if (self.networkSettings.captureResponseBodies) {
                             try {
-                                responseBody = self.truncateContent(xhr.responseText, self.networkSettings.maxResponseBodySize);
+                                responseBody = self.truncateResponseContent(xhr.responseText, self.networkSettings.maxResponseBodySize);
                             }
                             catch (e) {
                                 responseBody = "[Unable to read response]";
@@ -353,13 +353,36 @@ export class NetworkRecorder {
         }
         return filtered;
     }
-    truncateContent(content, maxSize) {
+    truncateRequestContent(content, maxSize) {
         if (!content)
             return content;
-        // Apply masking function if provided
+        // Apply request masking function if provided
         let processedContent = content;
         if (this.networkSettings.requestBodyMaskingFunction) {
-            processedContent = this.networkSettings.requestBodyMaskingFunction(content);
+            try {
+                processedContent = this.networkSettings.requestBodyMaskingFunction(content);
+            }
+            catch (error) {
+                logger.error("Failed to apply request masking function");
+            }
+        }
+        if (processedContent.length > maxSize) {
+            return processedContent.substring(0, maxSize) + `... [truncated from ${processedContent.length} chars]`;
+        }
+        return processedContent;
+    }
+    truncateResponseContent(content, maxSize) {
+        if (!content)
+            return content;
+        // Apply response masking function if provided
+        let processedContent = content;
+        if (this.networkSettings.responseBodyMaskingFunction) {
+            try {
+                processedContent = this.networkSettings.responseBodyMaskingFunction(content);
+            }
+            catch (error) {
+                logger.error("Failed to apply response masking function");
+            }
         }
         if (processedContent.length > maxSize) {
             return processedContent.substring(0, maxSize) + `... [truncated from ${processedContent.length} chars]`;

package/dist/recorder/recorder.d.ts

@@ -9,6 +9,7 @@ export declare class Recorder {
     private capturedSessionId;
     private pingIntervalMs;
     private pingTimeout;
+    private userIdentity;
     constructor(window: Window, publicToken: string, userSettings?: Partial<RecorderSettings>);
     private schedulePing;
     private ping;
@@ -20,6 +21,15 @@ export declare class Recorder {
      * Stop all recorders
      */
     stop(): void;
+    /**
+     * Identify the current user with a unique ID
+     * @param userId - Unique identifier for the user (e.g., database ID, email)
+     * @example
+     * recorder.identify('user_123');
+     */
+    identify(userId: string): void;
+    clearUserIdentity(): void;
+    private sendUserIdentification;
     private collectCapturedUserMetadata;
 }
 export interface RecorderSettings {
@@ -37,6 +47,7 @@ export interface RecorderSettings {
         captureResponseBodies: boolean;
         excludeHeaders: string[];
         requestBodyMaskingFunction?: (body: string) => string;
+        responseBodyMaskingFunction?: (body: string) => string;
     };
 }
 export interface CapturedUserMetadata {
@@ -58,3 +69,6 @@ export interface CapturedUserMetadata {
     utmContent?: string;
     utmTerm?: string;
 }
+export interface CapturedUserIdentity {
+    userId: string;
+}

package/dist/recorder/recorder.js

@@ -2,7 +2,7 @@ import { SessionRecorder } from "./sessionRecorder";
 import { EventRecorder } from "./eventRecorder";
 import { ErrorRecorder } from "./errorRecorder";
 import { NetworkRecorder } from "./networkRecorder";
-import { post, put } from "../requests";
+import { post, put, patch } from "../requests";
 import { UAParser } from "ua-parser-js";
 export class Recorder {
     window;
@@ -15,6 +15,7 @@ export class Recorder {
     capturedSessionId = null;
     pingIntervalMs = 20000;
     pingTimeout = null;
+    userIdentity = null;
     constructor(window, publicToken, userSettings = {}) {
         this.window = window;
         this.publicToken = publicToken;
@@ -61,6 +62,8 @@ export class Recorder {
             this.schedulePing();
             const capturedUserMetadata = this.collectCapturedUserMetadata();
             post(`public/captured-sessions/${this.capturedSessionId}/captured-session/metadata`, capturedUserMetadata, { withCredentials: false });
+            // Send user identification if it was set before session creation
+            this.sendUserIdentification(this.capturedSessionId, this.userIdentity);
         })
             .catch(error => {
             console.error(error);
@@ -98,6 +101,42 @@ export class Recorder {
         this.errorRecorder.stop();
         this.networkRecorder.stop();
     }
+    /**
+     * Identify the current user with a unique ID
+     * @param userId - Unique identifier for the user (e.g., database ID, email)
+     * @example
+     * recorder.identify('user_123');
+     */
+    identify(userId) {
+        if (!userId || userId.trim() === '') {
+            console.error('Recorder.identify: userId must be a non-empty string');
+            return;
+        }
+        this.userIdentity = {
+            userId: userId.trim()
+        };
+        // If session is already created, send identification immediately
+        this.sendUserIdentification(this.capturedSessionId, this.userIdentity);
+        // If not, identification will be sent when session is created
+    }
+    clearUserIdentity() {
+        this.userIdentity = null;
+    }
+    async sendUserIdentification(capturedSessionId, userIdentity) {
+        if (!capturedSessionId || !userIdentity) {
+            return;
+        }
+        try {
+            const response = await patch(`public/captured-sessions/${capturedSessionId}/identify`, userIdentity.userId, { withCredentials: false });
+            if (response.status >= 400) {
+                console.error(`Failed to identify user: HTTP ${response.status}`, response.data);
+            }
+        }
+        catch (error) {
+            console.error("Error sending user identification:", error);
+            // Identification failure is non-critical - recording should continue
+        }
+    }
     collectCapturedUserMetadata = () => {
         const ua = new UAParser();
         const browserName = ua.getBrowser().name;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@affogatosoftware/recorder",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "license": "MIT",
   "author": "Chris Ryan",
   "main": "./dist/index.js",