humanbehavior-js 0.0.8 → 0.0.9

package/dist/esm/index.js

@@ -4049,6 +4049,123 @@ function v1Bytes(rnds, msecs, nsecs, clockseq, node, buf, offset = 0) {
     return buf;
 }
 
+var LogLevel;
+(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";
+})(LogLevel || (LogLevel = {}));
+class Logger {
+    constructor(config) {
+        this.config = {
+            level: 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(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(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(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(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({
@@ -4180,7 +4297,7 @@ class HumanBehaviorAPI {
                 return results.flat();
             }
             catch (error) {
-                console.error('Error sending events:', error);
+                logError('Error sending events:', error);
                 throw error;
             }
         });
@@ -4206,7 +4323,7 @@ class HumanBehaviorAPI {
                 return yield response.json();
             }
             catch (error) {
-                console.error('Error sending user data:', error);
+                logError('Error sending user data:', error);
                 throw error;
             }
         });
@@ -4233,7 +4350,7 @@ class HumanBehaviorAPI {
                 return yield response.json();
             }
             catch (error) {
-                console.error('Error authenticating user:', error);
+                logError('Error authenticating user:', error);
                 throw error;
             }
         });
@@ -4280,7 +4397,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
@@ -4313,7 +4430,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
@@ -4329,7 +4446,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'));
         }
@@ -4393,18 +4510,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');
         }
     }
     /**
@@ -4434,7 +4551,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);
                 }
             }
@@ -4460,30 +4577,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
@@ -4545,7 +4662,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;
         }
     }
@@ -4692,7 +4809,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;
                                 }
                             }
@@ -4702,7 +4819,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;
@@ -4735,7 +4852,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;
         }
     }
@@ -4791,6 +4908,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');
         }
@@ -4839,13 +4960,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;
             }
         });
@@ -4859,24 +4980,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);
             }
         });
@@ -4894,12 +5098,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) {
@@ -4943,6 +5147,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) => {
@@ -4966,6 +5172,8 @@ class HumanBehaviorTracker {
                 clearInterval(this.flushInterval);
                 this.flushInterval = null;
             }
+            // Disable console tracking
+            this.disableConsoleTracking();
         });
     }
     addEvent(event) {
@@ -4999,7 +5207,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;
@@ -5020,14 +5228,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();
                         }
@@ -5073,7 +5281,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
@@ -5086,7 +5294,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);
@@ -5117,5 +5325,5 @@ if (typeof window !== 'undefined') {
     window.HumanBehaviorTracker = HumanBehaviorTracker;
 }
 
-export { HumanBehaviorAPI, HumanBehaviorTracker, MAX_CHUNK_SIZE_BYTES, RedactionManager, HumanBehaviorTracker as default, isChunkSizeExceeded, redactionManager, validateSingleEventSize };
+export { HumanBehaviorAPI, HumanBehaviorTracker, LogLevel, MAX_CHUNK_SIZE_BYTES, RedactionManager, HumanBehaviorTracker as default, isChunkSizeExceeded, logDebug, logError, logInfo, logWarn, logger, redactionManager, validateSingleEventSize };
 //# sourceMappingURL=index.js.map