humanbehavior-js 0.0.8 → 0.0.9

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,6 +31,20 @@ export class HumanBehaviorTracker {
     private initialized: boolean = false;
     public initializationPromise: Promise<void> | null = null;
     private redactionManager: RedactionManager;
+    
+    // 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) {
@@ -89,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;
         }
     }
@@ -108,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);
             }
         });
@@ -148,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);
         }
     }
 
@@ -194,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) => {
@@ -216,6 +332,9 @@ export class HumanBehaviorTracker {
             clearInterval(this.flushInterval);
             this.flushInterval = null;
         }
+
+        // Disable console tracking
+        this.disableConsoleTracking();
     }
 
     public async addEvent(event: any) {
@@ -250,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;
         }
@@ -270,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 {
@@ -317,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;
         }
         
@@ -331,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);