humanbehavior-js 0.2.6 → 0.2.8

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
@@ -210,8 +213,9 @@ declare class HumanBehaviorTracker {
      */
     private deleteCookie;
     /**
-     * Log out the current user by clearing all user-related data
-     * This will delete the user ID cookie, clear localStorage, and reset user properties
+     * Clear user data and reset session when user signs out of the site
+     * This should be called when a user logs out of your application to prevent
+     * data contamination between different users
      */
     logout(): void;
     /**
@@ -240,6 +244,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
      */
@@ -297,6 +310,25 @@ declare class HumanBehaviorAPI {
     }>): Promise<any>;
 }
 
+/**
+ * Server-side utilities for HumanBehavior SDK
+ */
+interface ServerSideUserData {
+    email: string;
+    name?: string;
+    image?: string;
+    provider?: string;
+    [key: string]: any;
+}
+/**
+ * Identify user from server-side (NextAuth, Firebase, etc.)
+ * Use this in your auth events to track users immediately on sign-in
+ */
+declare function identifyUser(userData: ServerSideUserData, apiKey: string): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+
 declare enum LogLevel {
     NONE = 0,
     ERROR = 1,
@@ -330,5 +362,5 @@ declare const logWarn: (message: string, ...args: any[]) => void;
 declare const logInfo: (message: string, ...args: any[]) => void;
 declare const logDebug: (message: string, ...args: any[]) => void;
 
-export { HumanBehaviorAPI, HumanBehaviorTracker, LogLevel, MAX_CHUNK_SIZE_BYTES, RedactionManager, HumanBehaviorTracker as default, isChunkSizeExceeded, logDebug, logError, logInfo, logWarn, logger, redactionManager, splitLargeEvent, validateSingleEventSize };
-export type { LoggerConfig, RedactionOptions };
+export { HumanBehaviorAPI, HumanBehaviorTracker, LogLevel, MAX_CHUNK_SIZE_BYTES, RedactionManager, HumanBehaviorTracker as default, identifyUser, isChunkSizeExceeded, logDebug, logError, logInfo, logWarn, logger, redactionManager, splitLargeEvent, validateSingleEventSize };
+export type { LoggerConfig, RedactionOptions, ServerSideUserData };

package/package.json

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

package/src/index.ts

@@ -13,6 +13,9 @@ export * from './api';
 // Export redaction functionality
 export * from './redact';
 
+// Export server-side utilities
+export * from './server';
+
 // Export logger functionality
 export * from './utils/logger';
 

package/src/react/index.tsx

@@ -11,6 +11,7 @@ interface HumanBehaviorInterface {
   addUserInfo: ({ userId, userProperties }: { userId?: string, userProperties: Record<string, any> }) => Promise<string>;
   start: () => void;
   stop: () => void;
+  logout: () => void;
   viewLogs: () => void;
 }
 
@@ -173,6 +174,7 @@ const defaultImplementation: HumanBehaviorInterface = {
   },
   start: () => {},
   stop: () => {},
+  logout: () => {},
   viewLogs: () => {},
 };
 
@@ -195,6 +197,9 @@ const createQueuingImplementation = (queueEvent: (event: any) => void): HumanBeh
   stop: () => {
     // Stop is a no-op when not initialized
   },
+  logout: () => {
+    // Logout is a no-op when not initialized
+  },
   viewLogs: () => {
     logWarn('Logs are not available until HumanBehaviorTracker is initialized');
   }

package/src/server.ts

@@ -0,0 +1,51 @@
+/**
+ * Server-side utilities for HumanBehavior SDK
+ */
+
+export interface ServerSideUserData {
+  email: string;
+  name?: string;
+  image?: string;
+  provider?: string;
+  [key: string]: any; // Allow additional properties
+}
+
+/**
+ * Identify user from server-side (NextAuth, Firebase, etc.)
+ * Use this in your auth events to track users immediately on sign-in
+ */
+export async function identifyUser(
+  userData: ServerSideUserData,
+  apiKey: string
+): Promise<{ success: boolean; error?: string }> {
+  try {
+    const response = await fetch('https://ingest.humanbehavior.co/api/ingestion/user', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        userId: userData.email,
+        userAttributes: userData,
+        sessionId: null, // Will be set by client-side session recording
+        posthogName: userData.email || userData.name || null // Update posthogName with email
+      })
+    });
+    
+    if (!response.ok) {
+      const errorText = await response.text();
+      return { 
+        success: false, 
+        error: `Failed to identify user: ${response.status} ${response.statusText} - ${errorText}` 
+      };
+    }
+    
+    return { success: true };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : 'Unknown error' 
+    };
+  }
+} 

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,37 +762,70 @@ export class HumanBehaviorTracker {
         // Enable console tracking
         this.enableConsoleTracking();
 
-        // Start recording with redaction enabled
-        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');
-                    }
+            // 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',
-            // Add more robust configuration
-            checkoutEveryNms: 5000, // Take full snapshot every 5 seconds
-            checkoutEveryNth: 100 // Take full snapshot every 100 events
-        });
+            }
+            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() {
@@ -801,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();
 
@@ -960,8 +1008,9 @@ export class HumanBehaviorTracker {
     }
 
     /**
-     * Log out the current user by clearing all user-related data
-     * This will delete the user ID cookie, clear localStorage, and reset user properties
+     * Clear user data and reset session when user signs out of the site
+     * This should be called when a user logs out of your application to prevent
+     * data contamination between different users
      */
     public logout(): void {
         if (!isBrowser) return;
@@ -979,7 +1028,14 @@ export class HumanBehaviorTracker {
             this.endUserId = null;
             this.userProperties = {};
             
-            logInfo('User logged out - cleared all user data and cookies');
+            // Generate a new session ID for the next user
+            this.sessionId = uuidv1();
+            if (isBrowser) {
+                localStorage.setItem('human_behavior_session_id', this.sessionId);
+                localStorage.setItem('human_behavior_last_activity', Date.now().toString());
+            }
+            
+            logInfo('User logged out - cleared all user data and started fresh session');
         } catch (error) {
             logError('Error during logout:', error);
         }
@@ -1041,6 +1097,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
      */