humanbehavior-js 0.2.5 → 0.2.7

package/dist/types/index.d.ts

@@ -109,6 +109,9 @@ declare class HumanBehaviorTracker {
     private originalReplaceState;
     private navigationListeners;
     private _connectionBlocked;
+    private recordInstance;
+    private frequencyUpdateInterval;
+    private sessionStartTime;
     /**
      * Initialize the HumanBehavior tracker
      * This is the main entry point - call this once per page
@@ -240,6 +243,15 @@ declare class HumanBehaviorTracker {
      * Get the current URL being tracked
      */
     getCurrentUrl(): string;
+    /**
+     * Get current snapshot frequency info
+     */
+    getSnapshotFrequencyInfo(): {
+        sessionDuration: number;
+        currentInterval: number;
+        currentThreshold: number;
+        phase: string;
+    };
     /**
      * Test if the tracker can reach the ingestion server
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "humanbehavior-js",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "SDK for HumanBehavior session and event recording",
   "type": "module",
   "main": "./dist/cjs/index.js",

package/src/tracker.ts

@@ -47,6 +47,9 @@ export class HumanBehaviorTracker {
     private originalReplaceState: typeof history.replaceState | null = null;
     private navigationListeners: Array<() => void> = [];
     private _connectionBlocked: boolean = false;
+    private recordInstance: any = null;
+    private frequencyUpdateInterval: any = null;
+    private sessionStartTime: number = Date.now();
 
     /**
      * Initialize the HumanBehavior tracker
@@ -759,19 +762,70 @@ export class HumanBehaviorTracker {
         // Enable console tracking
         this.enableConsoleTracking();
 
-        // Start recording with redaction enabled
-        rrweb.record({
-            emit: (event) => {
-                this.addEvent(event);
-            },
-            inlineStylesheet: true,
-            recordCanvas: true,
-            collectFonts: true,
-            inlineImages: true,
-            blockClass: 'rr-block',
-            ignoreClass: 'rr-ignore',
-            maskTextClass: 'rr-ignore'
-        });
+            // Adaptive snapshot configuration based on session duration
+    const sessionStartTime = Date.now();
+    let snapshotInterval = 5000; // Start with 5 seconds
+    let eventThreshold = 100; // Start with 100 events
+    
+    // Function to update snapshot frequency based on session duration
+    const updateSnapshotFrequency = () => {
+        const sessionDuration = Date.now() - sessionStartTime;
+        const thirtyMinutes = 30 * 60 * 1000;
+        const twoHours = 2 * 60 * 60 * 1000;
+        const fourHours = 4 * 60 * 60 * 1000;
+        
+        if (sessionDuration > twoHours) {
+            // After 2 hours, very infrequent snapshots
+            snapshotInterval = 30000; // 30 seconds
+            eventThreshold = 500; // 500 events
+            logDebug('Reduced snapshot frequency: 30s/500 events (2+ hours)');
+        } else if (sessionDuration > thirtyMinutes) {
+            // After 30 minutes, moderate frequency
+            snapshotInterval = 15000; // 15 seconds
+            eventThreshold = 300; // 300 events
+            logDebug('Reduced snapshot frequency: 15s/300 events (30+ minutes)');
+        }
+        // First 30 minutes: 5s/100 events (default)
+    };
+    
+    // Update frequency every 5 minutes
+    const frequencyUpdateInterval = setInterval(updateSnapshotFrequency, 5 * 60 * 1000);
+    
+    // Start recording with adaptive redaction enabled
+    const recordInstance = rrweb.record({
+        emit: (event) => {
+            // Add additional validation for FullSnapshot events
+            if (event.type === 2) { // FullSnapshot event
+                if (!event.data || !event.data.node) {
+                    logWarn('rrweb generated malformed FullSnapshot event:', {
+                        hasData: !!event.data,
+                        hasNode: !!(event.data && event.data.node),
+                        dataType: typeof event.data,
+                        eventType: event.type,
+                        timestamp: event.timestamp
+                    });
+                    // Don't skip - let the addEvent method handle it
+                } else {
+                    logDebug('Valid FullSnapshot event received from rrweb');
+                }
+            }
+            this.addEvent(event);
+        },
+        inlineStylesheet: true,
+        recordCanvas: true,
+        collectFonts: true,
+        inlineImages: true,
+        blockClass: 'rr-block',
+        ignoreClass: 'rr-ignore',
+        maskTextClass: 'rr-ignore',
+        // Adaptive configuration
+        checkoutEveryNms: snapshotInterval,
+        checkoutEveryNth: eventThreshold
+    });
+    
+    // Store the record instance and interval for cleanup
+    this.recordInstance = recordInstance;
+    this.frequencyUpdateInterval = frequencyUpdateInterval;
     }
 
     public async stop() {
@@ -783,6 +837,18 @@ export class HumanBehaviorTracker {
             this.flushInterval = null;
         }
 
+        // Cleanup adaptive snapshot intervals
+        if (this.frequencyUpdateInterval) {
+            clearInterval(this.frequencyUpdateInterval);
+            this.frequencyUpdateInterval = null;
+        }
+
+        // Stop rrweb recording
+        if (this.recordInstance) {
+            this.recordInstance();
+            this.recordInstance = null;
+        }
+
         // Disable console tracking
         this.disableConsoleTracking();
 
@@ -793,6 +859,19 @@ export class HumanBehaviorTracker {
     public async addEvent(event: any) {
         await this.ensureInitialized();
         
+        // Validate FullSnapshot events before processing
+        if (event.type === 2) { // FullSnapshot event
+            if (!event.data || !event.data.node) {
+                logWarn('Malformed FullSnapshot event detected, skipping:', {
+                    hasData: !!event.data,
+                    hasNode: !!(event.data && event.data.node),
+                    dataType: typeof event.data,
+                    eventType: event.type
+                });
+                return; // Skip malformed FullSnapshot events
+            }
+        }
+        
         // Process event through redaction manager if active
         const processedEvent = this.redactionManager.processEvent(event);
         
@@ -1010,6 +1089,41 @@ export class HumanBehaviorTracker {
         return this.currentUrl;
     }
 
+    /**
+     * Get current snapshot frequency info
+     */
+    public getSnapshotFrequencyInfo(): {
+        sessionDuration: number;
+        currentInterval: number;
+        currentThreshold: number;
+        phase: string;
+    } {
+        const sessionDuration = Date.now() - this.sessionStartTime;
+        const thirtyMinutes = 30 * 60 * 1000;
+        const twoHours = 2 * 60 * 60 * 1000;
+        
+        let phase = 'initial';
+        let interval = 5000;
+        let threshold = 100;
+        
+        if (sessionDuration > twoHours) {
+            phase = 'extended';
+            interval = 30000;
+            threshold = 500;
+        } else if (sessionDuration > thirtyMinutes) {
+            phase = 'moderate';
+            interval = 15000;
+            threshold = 300;
+        }
+        
+        return {
+            sessionDuration,
+            currentInterval: interval,
+            currentThreshold: threshold,
+            phase
+        };
+    }
+
     /**
      * Test if the tracker can reach the ingestion server
      */