humanbehavior-js 0.0.8 → 0.0.9

package/dist/cjs/index.js

@@ -4053,6 +4053,123 @@ function v1Bytes(rnds, msecs, nsecs, clockseq, node, buf, offset = 0) {
     return buf;
 }
 
+exports.LogLevel = void 0;
+(function (LogLevel) {
+    LogLevel[LogLevel["NONE"] = 0] = "NONE";
+    LogLevel[LogLevel["ERROR"] = 1] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["INFO"] = 3] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 4] = "DEBUG";
+})(exports.LogLevel || (exports.LogLevel = {}));
+class Logger {
+    constructor(config) {
+        this.config = {
+            level: exports.LogLevel.ERROR, // Default to only errors in production
+            enableConsole: true,
+            enableStorage: false
+        };
+        this.isBrowser = typeof window !== 'undefined';
+        if (config) {
+            this.config = Object.assign(Object.assign({}, this.config), config);
+        }
+    }
+    setConfig(config) {
+        this.config = Object.assign(Object.assign({}, this.config), config);
+    }
+    shouldLog(level) {
+        return level <= this.config.level;
+    }
+    formatMessage(level, message, ...args) {
+        const timestamp = new Date().toISOString();
+        return `[HumanBehavior ${level}] ${timestamp}: ${message}`;
+    }
+    error(message, ...args) {
+        if (!this.shouldLog(exports.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, ...args) {
+        if (!this.shouldLog(exports.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, ...args) {
+        if (!this.shouldLog(exports.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, ...args) {
+        if (!this.shouldLog(exports.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);
+        }
+    }
+    logToStorage(message, args) {
+        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() {
+        if (!this.isBrowser)
+            return [];
+        try {
+            return JSON.parse(localStorage.getItem('human_behavior_logs') || '[]');
+        }
+        catch (e) {
+            return [];
+        }
+    }
+    clearLogs() {
+        if (this.isBrowser) {
+            localStorage.removeItem('human_behavior_logs');
+        }
+    }
+}
+// Create singleton instance
+const logger = new Logger();
+// Export convenience methods
+const logError = (message, ...args) => logger.error(message, ...args);
+const logWarn = (message, ...args) => logger.warn(message, ...args);
+const logInfo = (message, ...args) => logger.info(message, ...args);
+const logDebug = (message, ...args) => logger.debug(message, ...args);
+
 const MAX_CHUNK_SIZE_BYTES = 1024 * 1024 * 10; // 10MB chunk size
 function isChunkSizeExceeded(currentChunk, newEvent, sessionId) {
     const nextChunkSize = new TextEncoder().encode(JSON.stringify({
@@ -4184,7 +4301,7 @@ class HumanBehaviorAPI {
                 return results.flat();
             }
             catch (error) {
-                console.error('Error sending events:', error);
+                logError('Error sending events:', error);
                 throw error;
             }
         });
@@ -4210,7 +4327,7 @@ class HumanBehaviorAPI {
                 return yield response.json();
             }
             catch (error) {
-                console.error('Error sending user data:', error);
+                logError('Error sending user data:', error);
                 throw error;
             }
         });
@@ -4237,7 +4354,7 @@ class HumanBehaviorAPI {
                 return yield response.json();
             }
             catch (error) {
-                console.error('Error authenticating user:', error);
+                logError('Error authenticating user:', error);
                 throw error;
             }
         });
@@ -4284,7 +4401,7 @@ class HumanBehaviorAPI {
                 catch (error) {
                     retryCount++;
                     if (retryCount === maxRetries) {
-                        console.error('Error sending custom event after max retries:', error);
+                        logError('Error sending custom event after max retries:', error);
                         throw error;
                     }
                     // Exponential backoff
@@ -4317,7 +4434,7 @@ class HumanBehaviorAPI {
                 catch (error) {
                     retryCount++;
                     if (retryCount === maxRetries) {
-                        console.error('Error sending custom events after max retries:', error);
+                        logError('Error sending custom events after max retries:', error);
                         throw error;
                     }
                     // Exponential backoff
@@ -4333,7 +4450,7 @@ class HumanBehaviorAPI {
         data.append('timestamp', encodeURIComponent(Date.now().toString()));
         data.append('apiKey', encodeURIComponent(this.apiKey));
         if (isSessionComplete) {
-            console.log('Session complete beacon sending');
+            logInfo('Session complete beacon sending');
             localStorage.setItem('koalaware_session_complete', Date.now().toString());
             data.append('sessionComplete', encodeURIComponent('true'));
         }
@@ -4397,18 +4514,18 @@ class RedactionManager {
         this.userSelectedFields.clear();
         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');
         }
     }
     /**
@@ -4438,7 +4555,7 @@ 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);
                 }
             }
@@ -4464,30 +4581,30 @@ class RedactionManager {
         if (!this.isFieldSelected(inputData)) {
             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}'`);
             }
         });
         // Also check for any other string properties that might contain input data
         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}'`);
             }
         });
         // Handle nested objects that might contain text data
         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');
     }
     /**
      * Redact sensitive data in DOM mutation events
@@ -4549,7 +4666,7 @@ 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;
         }
     }
@@ -4696,7 +4813,7 @@ class RedactionManager {
                             // 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);
+                                    logDebug('Redaction: Found focused element matching selector:', selector);
                                     return true;
                                 }
                             }
@@ -4706,7 +4823,7 @@ class RedactionManager {
                     // Look for any input element that might be the active one
                     const activeElement = document.activeElement;
                     if (activeElement && this.shouldRedactElement(activeElement)) {
-                        console.log('Redaction: Active element should be redacted');
+                        logDebug('Redaction: Active element should be redacted');
                         return true;
                     }
                     return false;
@@ -4739,7 +4856,7 @@ 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;
         }
     }
@@ -4795,6 +4912,10 @@ class HumanBehaviorTracker {
         this.endUserId = null;
         this.initialized = false;
         this.initializationPromise = null;
+        // Console tracking properties
+        this.originalConsole = null;
+        this.originalLogger = null;
+        this.consoleTrackingEnabled = false;
         if (!apiKey) {
             throw new Error('Human Behavior API Key is required');
         }
@@ -4843,13 +4964,13 @@ class HumanBehaviorTracker {
                     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;
             }
         });
@@ -4863,24 +4984,107 @@ class HumanBehaviorTracker {
         });
     }
     static logToStorage(message) {
-        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
+     */
+    static configureLogging(config) {
+        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
+     */
+    enableConsoleTracking() {
+        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
+     */
+    disableConsoleTracking() {
+        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
+     */
+    trackConsoleEvent(level, args) {
+        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);
     }
     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);
             }
         });
@@ -4898,12 +5102,12 @@ class HumanBehaviorTracker {
     }
     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);
         }
     }
     addUserInfo(userProperties) {
@@ -4947,6 +5151,8 @@ class HumanBehaviorTracker {
             this.flushInterval = window.setInterval(() => {
                 this.flush();
             }, this.FLUSH_INTERVAL_MS);
+            // Enable console tracking
+            this.enableConsoleTracking();
             // Start recording with redaction enabled
             record({
                 emit: (event) => {
@@ -4970,6 +5176,8 @@ class HumanBehaviorTracker {
                 clearInterval(this.flushInterval);
                 this.flushInterval = null;
             }
+            // Disable console tracking
+            this.disableConsoleTracking();
         });
     }
     addEvent(event) {
@@ -5003,7 +5211,7 @@ class HumanBehaviorTracker {
                 this.sessionId = newSessionId;
             }
             catch (error) {
-                console.error('Failed to process rejected events:', error);
+                logError('Failed to process rejected events:', error);
             }
             finally {
                 this.isProcessingRejectedEvents = false;
@@ -5024,14 +5232,14 @@ class HumanBehaviorTracker {
                 this.eventIngestionQueue = [];
                 this.queueSizeBytes = 0;
                 if (eventsToProcess.length > 0) {
-                    console.log('Flushing events:', eventsToProcess);
+                    logDebug('Flushing events:', eventsToProcess);
                     try {
                         yield this.api.sendEvents(eventsToProcess, this.sessionId, this.endUserId);
                     }
                     catch (error) {
                         // If we get a 400 error, store events for retry
                         if ((_a = error.message) === null || _a === void 0 ? void 0 : _a.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();
                         }
@@ -5077,7 +5285,7 @@ class HumanBehaviorTracker {
         return __awaiter$1(this, void 0, void 0, function* () {
             yield this.ensureInitialized();
             if (!isBrowser) {
-                console.warn('Redaction is only available in browser environments');
+                logWarn('Redaction is only available in browser environments');
                 return;
             }
             // Create a new redaction manager with the provided options
@@ -5090,7 +5298,7 @@ class HumanBehaviorTracker {
      */
     setRedactedFields(fields) {
         if (!isBrowser) {
-            console.warn('Redaction is only available in browser environments');
+            logWarn('Redaction is only available in browser environments');
             return;
         }
         this.redactionManager.setFieldsToRedact(fields);
@@ -5127,6 +5335,11 @@ exports.MAX_CHUNK_SIZE_BYTES = MAX_CHUNK_SIZE_BYTES;
 exports.RedactionManager = RedactionManager;
 exports.default = HumanBehaviorTracker;
 exports.isChunkSizeExceeded = isChunkSizeExceeded;
+exports.logDebug = logDebug;
+exports.logError = logError;
+exports.logInfo = logInfo;
+exports.logWarn = logWarn;
+exports.logger = logger;
 exports.redactionManager = redactionManager;
 exports.validateSingleEventSize = validateSingleEventSize;
 //# sourceMappingURL=index.js.map