humanbehavior-js 0.0.7 → 0.0.9

package/src/redact.ts

@@ -1,6 +1,8 @@
 // Redaction functionality for sensitive input fields
 // This module provides methods to redact sensitive input fields in event recordings
 
+import { logDebug, logWarn } from './utils/logger';
+
 // Check if we're in a browser environment
 const isBrowser = typeof window !== 'undefined';
 
@@ -39,18 +41,18 @@ export class RedactionManager {
         fields.forEach(field => this.userSelectedFields.add(field));
         
         if (fields.length > 0) {
-            console.log(`Redaction: Active for ${fields.length} field(s):`, fields);
+            logDebug(`Redaction: Active for ${fields.length} field(s):`, fields);
             
             // Debug: Check if elements exist
             fields.forEach(selector => {
                 const elements = document.querySelectorAll(selector);
-                console.log(`Redaction: Found ${elements.length} element(s) for selector '${selector}'`);
+                logDebug(`Redaction: Found ${elements.length} element(s) for selector '${selector}'`);
                 elements.forEach((el, index) => {
-                    console.log(`Redaction: Element ${index} for '${selector}':`, el);
+                    logDebug(`Redaction: Element ${index} for '${selector}':`, el);
                 });
             });
         } else {
-            console.log('Redaction: Disabled - no fields selected');
+            logDebug('Redaction: Disabled - no fields selected');
         }
     }
 
@@ -85,7 +87,7 @@ export class RedactionManager {
             if (processedEvent.data.source === 5) { // Input event
                 const shouldRedact = this.isFieldSelected(processedEvent.data);
                 if (shouldRedact) {
-                    console.log('Redaction: Processing input event for redaction');
+                    logDebug('Redaction: Processing input event for redaction');
                     this.redactInputEvent(processedEvent.data);
                 }
             }
@@ -114,14 +116,14 @@ export class RedactionManager {
             return;
         }
         
-        console.log('Redaction: Redacting input event with text:', inputData.text);
+        logDebug('Redaction: Redacting input event with text:', inputData.text);
         
         // Redact all text-related properties that could contain input data
         const textProperties = ['text', 'value', 'content', 'data', 'input', 'textContent'];
         textProperties.forEach(prop => {
             if (inputData[prop] !== undefined && typeof inputData[prop] === 'string') {
                 inputData[prop] = this.redactedText;
-                console.log(`Redaction: Redacted property '${prop}'`);
+                logDebug(`Redaction: Redacted property '${prop}'`);
             }
         });
         
@@ -129,7 +131,7 @@ export class RedactionManager {
         Object.keys(inputData).forEach(key => {
             if (typeof inputData[key] === 'string' && inputData[key].length > 0) {
                 inputData[key] = this.redactedText;
-                console.log(`Redaction: Redacted additional property '${key}'`);
+                logDebug(`Redaction: Redacted additional property '${key}'`);
             }
         });
 
@@ -137,11 +139,11 @@ export class RedactionManager {
         if (inputData.attributes && typeof inputData.attributes === 'object') {
             if (inputData.attributes.value && typeof inputData.attributes.value === 'string') {
                 inputData.attributes.value = this.redactedText;
-                console.log('Redaction: Redacted nested value attribute');
+                logDebug('Redaction: Redacted nested value attribute');
             }
         }
         
-        console.log('Redaction: Input event redaction complete');
+        logDebug('Redaction: Input event redaction complete');
     }
 
     /**
@@ -209,7 +211,7 @@ export class RedactionManager {
             
             return false;
         } catch (e) {
-            console.warn('Error checking if DOM change should be redacted:', e);
+            logWarn('Error checking if DOM change should be redacted:', e);
             return false;
         }
     }
@@ -373,10 +375,10 @@ export class RedactionManager {
                         if (matchingElements.length > 0) {
                             // Check if any of these elements are currently focused
                             for (const el of matchingElements) {
-                                if (el === document.activeElement) {
-                                    console.log('Redaction: Found focused element matching selector:', selector);
-                                    return true;
-                                }
+                                                            if (el === document.activeElement) {
+                                logDebug('Redaction: Found focused element matching selector:', selector);
+                                return true;
+                            }
                             }
                         }
                     }
@@ -385,7 +387,7 @@ export class RedactionManager {
                     // Look for any input element that might be the active one
                     const activeElement = document.activeElement;
                     if (activeElement && this.shouldRedactElement(activeElement as HTMLElement)) {
-                        console.log('Redaction: Active element should be redacted');
+                        logDebug('Redaction: Active element should be redacted');
                         return true;
                     }
                     
@@ -423,7 +425,7 @@ export class RedactionManager {
             
             return false;
         } catch (e) {
-            console.warn('Error checking if field should be redacted:', e);
+            logWarn('Error checking if field should be redacted:', e);
             return false;
         }
     }

package/src/tracker.ts

@@ -2,6 +2,7 @@ import * as rrweb from 'rrweb';
 import { v1 as uuidv1 } from 'uuid';
 import { HumanBehaviorAPI } from './api';
 import { RedactionManager, RedactionOptions } from './redact';
+import { logger, logError, logWarn, logInfo, logDebug } from './utils/logger';
 
 // Check if we're in a browser environment
 const isBrowser = typeof window !== 'undefined';
@@ -30,17 +31,43 @@ export class HumanBehaviorTracker {
     private initialized: boolean = false;
     public initializationPromise: Promise<void> | null = null;
     private redactionManager: RedactionManager;
-
-    constructor(apiKey: string | undefined, ingestionUrl: string | undefined) {
+    
+    // Console tracking properties
+    private originalConsole: {
+        log: typeof console.log;
+        warn: typeof console.warn;
+        error: typeof console.error;
+    } | null = null;
+    private originalLogger: {
+        error: typeof logError;
+        warn: typeof logWarn;
+        info: typeof logInfo;
+        debug: typeof logDebug;
+    } | null = null;
+    private consoleTrackingEnabled: boolean = false;
+
+    constructor(apiKey: string | undefined, ingestionUrl?: string) {
         if (!apiKey) {
             throw new Error('Human Behavior API Key is required');
         }
-        if (!ingestionUrl) {
-            throw new Error('Human Behavior Ingestion URL is required');
-        }
+        
+        // ========================================
+        // DEVELOPER: Choose your ingestion server
+        // ========================================
+        // Uncomment ONE of the following lines to select your server:
+        
+        // AWS Development Server
+        const defaultIngestionUrl = 'http://3.137.217.33:3000';
+        
+        // Vercel Production Server
+        // const defaultIngestionUrl = 'https://ingestion-server.vercel.app';
+        
+        // Local Development Server
+        // const defaultIngestionUrl = 'http://localhost:3000';
+        
         this.api = new HumanBehaviorAPI({ 
             apiKey: apiKey,
-            ingestionUrl: ingestionUrl
+            ingestionUrl: ingestionUrl || defaultIngestionUrl
         });
         this.apiKey = apiKey;
         this.redactionManager = new RedactionManager();
@@ -77,13 +104,13 @@ export class HumanBehaviorTracker {
                 this.start();
                 this.processRejectedEvents();
             } else {
-                console.warn('HumanBehaviorTracker initialized in a non-browser environment. Session tracking is disabled.');
+                logWarn('HumanBehaviorTracker initialized in a non-browser environment. Session tracking is disabled.');
             }
 
             this.initialized = true;
-            console.log('HumanBehaviorTracker initialized');
+            logInfo('HumanBehaviorTracker initialized');
         } catch (error) {
-            console.error('Failed to initialize HumanBehaviorTracker:', error);
+            logError('Failed to initialize HumanBehaviorTracker:', error);
             throw error;
         }
     }
@@ -96,25 +123,123 @@ export class HumanBehaviorTracker {
     }
 
     public static logToStorage(message: string) {
-        try {
-            const logs = JSON.parse(localStorage.getItem('human_behavior_logs') || '[]');
-            logs.push(`${new Date().toISOString()}: ${message}`);
-            localStorage.setItem('human_behavior_logs', JSON.stringify(logs));
-        } catch (e) {
-            console.error('Failed to log to storage:', e);
-        }
+        logInfo(message);
+    }
+
+    /**
+     * Configure logging behavior for the SDK
+     * @param config Logger configuration options
+     */
+    public static configureLogging(config: { level?: 'none' | 'error' | 'warn' | 'info' | 'debug', enableConsole?: boolean, enableStorage?: boolean }) {
+        const levelMap = {
+            'none': 0,
+            'error': 1,
+            'warn': 2,
+            'info': 3,
+            'debug': 4
+        };
+        
+        logger.setConfig({
+            level: levelMap[config.level || 'error'],
+            enableConsole: config.enableConsole !== false,
+            enableStorage: config.enableStorage || false
+        });
+    }
+
+    /**
+     * Enable console event tracking
+     */
+    public enableConsoleTracking(): void {
+        if (!isBrowser || this.consoleTrackingEnabled) return;
+        
+        // Store original console methods
+        this.originalConsole = {
+            log: console.log,
+            warn: console.warn,
+            error: console.error
+        };
+
+        // Store original logger methods
+        this.originalLogger = {
+            error: logError,
+            warn: logWarn,
+            info: logInfo,
+            debug: logDebug
+        };
+
+        // Override console methods to capture ALL console output (including logger output)
+        console.log = (...args) => {
+            this.trackConsoleEvent('log', args);
+            this.originalConsole!.log(...args);
+        };
+
+        console.warn = (...args) => {
+            this.trackConsoleEvent('warn', args);
+            this.originalConsole!.warn(...args);
+        };
+
+        console.error = (...args) => {
+            this.trackConsoleEvent('error', args);
+            this.originalConsole!.error(...args);
+        };
+
+        this.consoleTrackingEnabled = true;
+        this.originalLogger!.debug('Console tracking enabled');
+    }
+
+    /**
+     * Disable console event tracking
+     */
+    public disableConsoleTracking(): void {
+        if (!isBrowser || !this.consoleTrackingEnabled || !this.originalConsole) return;
+
+        // Restore original console methods
+        console.log = this.originalConsole.log;
+        console.warn = this.originalConsole.warn;
+        console.error = this.originalConsole.error;
+
+        this.consoleTrackingEnabled = false;
+        this.originalConsole = null;
+        this.originalLogger = null;
+    }
+
+    /**
+     * Track console events
+     */
+    private trackConsoleEvent(level: 'log' | 'warn' | 'error', args: any[]): void {
+        if (!this.initialized) return;
+
+        const consoleEvent = {
+            type: 5, // Custom event type
+            data: {
+                payload: {
+                    type: 'console',
+                    level: level,
+                    message: args.map(arg => 
+                        typeof arg === 'string' ? arg : 
+                        typeof arg === 'object' ? JSON.stringify(arg) : 
+                        String(arg)
+                    ).join(' '),
+                    timestamp: Date.now(),
+                    url: window.location.href
+                }
+            },
+            timestamp: Date.now()
+        };
+
+        this.addEvent(consoleEvent);
     }
 
     private setupPageUnloadHandler() {
         if (!isBrowser) return;
         
-        console.log('Setting up page unload handler');
+        logDebug('Setting up page unload handler');
         
         // Handle visibility changes for sending events
         window.addEventListener('visibilitychange', () => {
             // Only send events when page becomes hidden
             if (document.visibilityState === 'hidden') {
-                console.log('Page hidden - sending pending events');
+                logDebug('Page hidden - sending pending events');
                 this.api.sendBeaconEvents(this.eventIngestionQueue, this.sessionId);
             }
         });
@@ -136,11 +261,11 @@ export class HumanBehaviorTracker {
 
     public viewLogs() {
         try {
-            const logs = JSON.parse(localStorage.getItem('human_behavior_logs') || '[]');
+            const logs = logger.getLogs();
             console.log('HumanBehavior Logs:', logs);
-            localStorage.removeItem('human_behavior_logs'); // Clear logs after viewing
+            logger.clearLogs(); // Clear logs after viewing
         } catch (e) {
-            console.error('Failed to read logs:', e);
+            logError('Failed to read logs:', e);
         }
     }
 
@@ -182,6 +307,9 @@ export class HumanBehaviorTracker {
             this.flush();
         }, this.FLUSH_INTERVAL_MS);
 
+        // Enable console tracking
+        this.enableConsoleTracking();
+
         // Start recording with redaction enabled
         rrweb.record({
             emit: (event) => {
@@ -204,6 +332,9 @@ export class HumanBehaviorTracker {
             clearInterval(this.flushInterval);
             this.flushInterval = null;
         }
+
+        // Disable console tracking
+        this.disableConsoleTracking();
     }
 
     public async addEvent(event: any) {
@@ -238,7 +369,7 @@ export class HumanBehaviorTracker {
             this.rejectedEvents = [];
             this.sessionId = newSessionId;
         } catch (error) {
-            console.error('Failed to process rejected events:', error);
+            logError('Failed to process rejected events:', error);
         } finally {
             this.isProcessingRejectedEvents = false;
         }
@@ -258,13 +389,13 @@ export class HumanBehaviorTracker {
             this.queueSizeBytes = 0;
 
             if (eventsToProcess.length > 0) {
-                console.log('Flushing events:', eventsToProcess);
+                logDebug('Flushing events:', eventsToProcess);
                 try {
                     await this.api.sendEvents(eventsToProcess, this.sessionId, this.endUserId!);
                 } catch (error: any) {
                     // If we get a 400 error, store events for retry
                     if (error.message?.includes('ERROR: Session already completed')) {
-                        console.log('Session expired, storing events for retry');
+                        logInfo('Session expired, storing events for retry');
                         this.rejectedEvents.push(...eventsToProcess);
                         this.processRejectedEvents();
                     } else {
@@ -305,7 +436,7 @@ export class HumanBehaviorTracker {
     public async redact(options?: RedactionOptions): Promise<void> {
         await this.ensureInitialized();
         if (!isBrowser) {
-            console.warn('Redaction is only available in browser environments');
+            logWarn('Redaction is only available in browser environments');
             return;
         }
         
@@ -319,7 +450,7 @@ export class HumanBehaviorTracker {
      */
     public setRedactedFields(fields: string[]): void {
         if (!isBrowser) {
-            console.warn('Redaction is only available in browser environments');
+            logWarn('Redaction is only available in browser environments');
             return;
         }
         

package/src/utils/logger.ts

@@ -0,0 +1,144 @@
+export enum LogLevel {
+  NONE = 0,
+  ERROR = 1,
+  WARN = 2,
+  INFO = 3,
+  DEBUG = 4
+}
+
+export interface LoggerConfig {
+  level: LogLevel;
+  enableConsole: boolean;
+  enableStorage: boolean;
+}
+
+class Logger {
+  private config: LoggerConfig = {
+    level: LogLevel.ERROR, // Default to only errors in production
+    enableConsole: true,
+    enableStorage: false
+  };
+
+  private isBrowser = typeof window !== 'undefined';
+
+  constructor(config?: Partial<LoggerConfig>) {
+    if (config) {
+      this.config = { ...this.config, ...config };
+    }
+  }
+
+  setConfig(config: Partial<LoggerConfig>): void {
+    this.config = { ...this.config, ...config };
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    return level <= this.config.level;
+  }
+
+  private formatMessage(level: string, message: string, ...args: any[]): string {
+    const timestamp = new Date().toISOString();
+    return `[HumanBehavior ${level}] ${timestamp}: ${message}`;
+  }
+
+  error(message: string, ...args: any[]): void {
+    if (!this.shouldLog(LogLevel.ERROR)) return;
+    
+    const formattedMessage = this.formatMessage('ERROR', message);
+    
+    if (this.config.enableConsole) {
+      console.error(formattedMessage, ...args);
+    }
+    
+    if (this.config.enableStorage && this.isBrowser) {
+      this.logToStorage(formattedMessage, args);
+    }
+  }
+
+  warn(message: string, ...args: any[]): void {
+    if (!this.shouldLog(LogLevel.WARN)) return;
+    
+    const formattedMessage = this.formatMessage('WARN', message);
+    
+    if (this.config.enableConsole) {
+      console.warn(formattedMessage, ...args);
+    }
+    
+    if (this.config.enableStorage && this.isBrowser) {
+      this.logToStorage(formattedMessage, args);
+    }
+  }
+
+  info(message: string, ...args: any[]): void {
+    if (!this.shouldLog(LogLevel.INFO)) return;
+    
+    const formattedMessage = this.formatMessage('INFO', message);
+    
+    if (this.config.enableConsole) {
+      console.log(formattedMessage, ...args);
+    }
+    
+    if (this.config.enableStorage && this.isBrowser) {
+      this.logToStorage(formattedMessage, args);
+    }
+  }
+
+  debug(message: string, ...args: any[]): void {
+    if (!this.shouldLog(LogLevel.DEBUG)) return;
+    
+    const formattedMessage = this.formatMessage('DEBUG', message);
+    
+    if (this.config.enableConsole) {
+      console.log(formattedMessage, ...args);
+    }
+    
+    if (this.config.enableStorage && this.isBrowser) {
+      this.logToStorage(formattedMessage, args);
+    }
+  }
+
+  private logToStorage(message: string, args: any[]): void {
+    try {
+      const logs = JSON.parse(localStorage.getItem('human_behavior_logs') || '[]');
+      const logEntry = {
+        message,
+        args: args.length > 0 ? args : undefined,
+        timestamp: Date.now()
+      };
+      logs.push(logEntry);
+      
+      // Keep only last 1000 logs to prevent storage bloat
+      if (logs.length > 1000) {
+        logs.splice(0, logs.length - 1000);
+      }
+      
+      localStorage.setItem('human_behavior_logs', JSON.stringify(logs));
+    } catch (e) {
+      // Silently fail if storage is not available
+    }
+  }
+
+  getLogs(): any[] {
+    if (!this.isBrowser) return [];
+    
+    try {
+      return JSON.parse(localStorage.getItem('human_behavior_logs') || '[]');
+    } catch (e) {
+      return [];
+    }
+  }
+
+  clearLogs(): void {
+    if (this.isBrowser) {
+      localStorage.removeItem('human_behavior_logs');
+    }
+  }
+}
+
+// Create singleton instance
+export const logger = new Logger();
+
+// Export convenience methods
+export const logError = (message: string, ...args: any[]) => logger.error(message, ...args);
+export const logWarn = (message: string, ...args: any[]) => logger.warn(message, ...args);
+export const logInfo = (message: string, ...args: any[]) => logger.info(message, ...args);
+export const logDebug = (message: string, ...args: any[]) => logger.debug(message, ...args);