humanbehavior-js 0.0.8 → 0.1.0

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,134 +4350,21 @@ class HumanBehaviorAPI {
                 return yield response.json();
             }
             catch (error) {
-                console.error('Error authenticating user:', error);
+                logError('Error authenticating user:', error);
                 throw error;
             }
         });
     }
-    sendSessionComplete(sessionId) {
-        return __awaiter$1(this, void 0, void 0, function* () {
-            const response = yield fetch(`${this.baseUrl}/api/ingestion/sessionComplete`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.apiKey}`
-                },
-                body: JSON.stringify({ sessionId })
-            });
-            if (!response.ok) {
-                throw new Error(`Failed to send session complete: ${response.statusText}`);
-            }
-        });
-    }
-    sendCustomEvent(eventName, eventProperties, sessionId) {
-        return __awaiter$1(this, void 0, void 0, function* () {
-            const maxRetries = 3;
-            let retryCount = 0;
-            while (retryCount < maxRetries) {
-                try {
-                    const response = yield fetch(`${this.baseUrl}/api/ingestion/customEvent`, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            'Authorization': `Bearer ${this.apiKey}`
-                        },
-                        body: JSON.stringify({
-                            name: eventName,
-                            properties: eventProperties,
-                            sessionId: sessionId,
-                            timestamp: new Date().toISOString()
-                        })
-                    });
-                    if (!response.ok) {
-                        throw new Error(`Failed to send custom event: ${response.statusText}`);
-                    }
-                    return yield response.json();
-                }
-                catch (error) {
-                    retryCount++;
-                    if (retryCount === maxRetries) {
-                        console.error('Error sending custom event after max retries:', error);
-                        throw error;
-                    }
-                    // Exponential backoff
-                    yield new Promise(resolve => setTimeout(resolve, Math.pow(2, retryCount) * 1000));
-                }
-            }
-        });
-    }
-    sendCustomEvents(events, sessionId) {
-        return __awaiter$1(this, void 0, void 0, function* () {
-            const maxRetries = 3;
-            let retryCount = 0;
-            while (retryCount < maxRetries) {
-                try {
-                    const response = yield fetch(`${this.baseUrl}/api/ingestion/customEvent/batch`, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            'Authorization': `Bearer ${this.apiKey}`
-                        },
-                        body: JSON.stringify({
-                            events: events.map(event => (Object.assign(Object.assign({}, event), { sessionId: sessionId })))
-                        })
-                    });
-                    if (!response.ok) {
-                        throw new Error(`Failed to send custom events: ${response.statusText}`);
-                    }
-                    return yield response.json();
-                }
-                catch (error) {
-                    retryCount++;
-                    if (retryCount === maxRetries) {
-                        console.error('Error sending custom events after max retries:', error);
-                        throw error;
-                    }
-                    // Exponential backoff
-                    yield new Promise(resolve => setTimeout(resolve, Math.pow(2, retryCount) * 1000));
-                }
-            }
-        });
-    }
-    sendBeaconEvents(events, sessionId, isSessionComplete = false) {
+    sendBeaconEvents(events, sessionId) {
         const data = new URLSearchParams();
         data.append('events', encodeURIComponent(JSON.stringify(events)));
         data.append('sessionId', encodeURIComponent(sessionId));
         data.append('timestamp', encodeURIComponent(Date.now().toString()));
         data.append('apiKey', encodeURIComponent(this.apiKey));
-        if (isSessionComplete) {
-            console.log('Session complete beacon sending');
-            localStorage.setItem('koalaware_session_complete', Date.now().toString());
-            data.append('sessionComplete', encodeURIComponent('true'));
-        }
         navigator.sendBeacon(`${this.baseUrl}/api/ingestion/events`, data);
         // KoalawareTracker.logToStorage(`Sending events beacon: ${this.baseUrl}/api/ingestion/events`);
         // KoalawareTracker.logToStorage(`Events beacon success: ${success}`);
     }
-    sendBeaconSessionComplete(sessionId) {
-        const data = new URLSearchParams();
-        data.append('sessionId', sessionId);
-        data.append('apiKey', this.apiKey);
-        data.append('sessionComplete', 'true');
-        navigator.sendBeacon(`${this.baseUrl}/api/ingestion/sessionComplete`, data);
-        // KoalawareTracker.logToStorage(`Sending completion beacon: ${this.baseUrl}/api/ingestion/sessionComplete`);
-        // KoalawareTracker.logToStorage(`Complete beacon success: ${success}`);
-    }
-    sendBeaconCustomEvent(eventName, eventProperties, sessionId) {
-        const data = new URLSearchParams();
-        data.append('name', encodeURIComponent(eventName));
-        data.append('properties', encodeURIComponent(JSON.stringify(eventProperties)));
-        data.append('sessionId', encodeURIComponent(sessionId));
-        data.append('timestamp', encodeURIComponent(new Date().toISOString()));
-        data.append('apiKey', encodeURIComponent(this.apiKey));
-        return navigator.sendBeacon(`${this.baseUrl}/api/ingestion/customEvent`, data);
-    }
-    sendBeaconCustomEvents(events, sessionId) {
-        const data = new URLSearchParams();
-        data.append('events', encodeURIComponent(JSON.stringify(events.map(event => (Object.assign(Object.assign({}, event), { sessionId: sessionId }))))));
-        data.append('apiKey', encodeURIComponent(this.apiKey));
-        return navigator.sendBeacon(`${this.baseUrl}/api/ingestion/customEvent/batch`, data);
-    }
 }
 
 // Redaction functionality for sensitive input fields
@@ -4393,18 +4397,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 +4438,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 +4464,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 +4549,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 +4696,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 +4706,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 +4739,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;
         }
     }
@@ -4779,6 +4783,40 @@ const redactionManager = new RedactionManager();
 // Check if we're in a browser environment
 const isBrowser = typeof window !== 'undefined';
 class HumanBehaviorTracker {
+    /**
+     * Initialize the HumanBehavior tracker
+     * This is the main entry point - call this once per page
+     */
+    static init(apiKey, options) {
+        // Return existing instance if already initialized
+        if (isBrowser && window.__humanBehaviorGlobalTracker) {
+            logDebug('Tracker already initialized, returning existing instance');
+            return window.__humanBehaviorGlobalTracker;
+        }
+        // Configure logging if specified
+        if (options === null || options === void 0 ? void 0 : options.logLevel) {
+            this.configureLogging({ level: options.logLevel });
+        }
+        // Create new tracker instance
+        const tracker = new HumanBehaviorTracker(apiKey, options === null || options === void 0 ? void 0 : options.ingestionUrl);
+        // Set redacted fields if specified
+        if (options === null || options === void 0 ? void 0 : options.redactFields) {
+            tracker.setRedactedFields(options.redactFields);
+        }
+        // Test connection (non-blocking)
+        if (isBrowser) {
+            const testUrl = tracker.api['baseUrl'] + '/api/ingestion/health';
+            fetch(testUrl, { method: 'HEAD' })
+                .then(() => logDebug('Connection test successful'))
+                .catch((error) => {
+                logWarn('Connection test failed - ad blocker may be active:', error.message);
+                tracker._connectionBlocked = true;
+            });
+        }
+        // Start tracking
+        tracker.start();
+        return tracker;
+    }
     constructor(apiKey, ingestionUrl) {
         this.eventIngestionQueue = [];
         this.queueSizeBytes = 0;
@@ -4791,61 +4829,82 @@ class HumanBehaviorTracker {
         this.endUserId = null;
         this.initialized = false;
         this.initializationPromise = null;
+        // Console tracking properties
+        this.originalConsole = null;
+        this.consoleTrackingEnabled = false;
+        // Navigation tracking properties
+        this.navigationTrackingEnabled = false;
+        this.currentUrl = '';
+        this.previousUrl = '';
+        this.originalPushState = null;
+        this.originalReplaceState = null;
+        this.navigationListeners = [];
+        this._connectionBlocked = false;
         if (!apiKey) {
             throw new Error('Human Behavior API Key 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';
+        // Initialize API
+        const defaultIngestionUrl = 'http://3.137.217.33:3000'; // AWS Development Server
         this.api = new HumanBehaviorAPI({
             apiKey: apiKey,
             ingestionUrl: ingestionUrl || defaultIngestionUrl
         });
         this.apiKey = apiKey;
         this.redactionManager = new RedactionManager();
-        // Check for existing session ID and last activity time in localStorage
-        const existingSessionId = isBrowser ? localStorage.getItem('human_behavior_session_id') : null;
-        const lastActivity = isBrowser ? localStorage.getItem('human_behavior_last_activity') : null;
-        // If we have a last activity time, check if it's within 30 minutes
-        const thirtyMinutesAgo = Date.now() - (30 * 60 * 1000);
-        const shouldUseExistingSession = lastActivity && parseInt(lastActivity) > thirtyMinutesAgo;
-        this.sessionId = (existingSessionId && shouldUseExistingSession) ? existingSessionId : v1();
-        // Store the session ID if it's new
-        if ((!existingSessionId || !shouldUseExistingSession) && isBrowser) {
-            localStorage.setItem('human_behavior_session_id', this.sessionId);
+        // Handle session restoration
+        if (isBrowser) {
+            const existingSessionId = localStorage.getItem('human_behavior_session_id');
+            const lastActivity = localStorage.getItem('human_behavior_last_activity');
+            const thirtyMinutesAgo = Date.now() - (30 * 60 * 1000);
+            if (existingSessionId && lastActivity && parseInt(lastActivity) > thirtyMinutesAgo) {
+                this.sessionId = existingSessionId;
+                logDebug(`Reusing existing session: ${this.sessionId}`);
+            }
+            else {
+                this.sessionId = v1();
+                logDebug(`Creating new session: ${this.sessionId}`);
+                localStorage.setItem('human_behavior_session_id', this.sessionId);
+            }
+            this.currentUrl = window.location.href;
+            window.__humanBehaviorGlobalTracker = this;
+        }
+        else {
+            this.sessionId = v1();
         }
-        // Start initialization immediately
+        // Start initialization
         this.initializationPromise = this.init();
     }
     init() {
         return __awaiter$1(this, void 0, void 0, function* () {
             try {
                 const userId = this.getCookie(`human_behavior_end_user_id_${this.apiKey}`);
+                logDebug(`Initializing with sessionId: ${this.sessionId}, userId: ${userId}`);
                 const { sessionId, endUserId } = yield this.api.init(this.sessionId, userId);
-                this.sessionId = sessionId;
+                // Check if server returned a different session ID
+                if (sessionId !== this.sessionId) {
+                    logDebug(`Server returned different sessionId: ${sessionId} (client had: ${this.sessionId})`);
+                    this.sessionId = sessionId;
+                    // Update localStorage with server's session ID
+                    if (isBrowser) {
+                        localStorage.setItem('human_behavior_session_id', this.sessionId);
+                    }
+                }
                 this.endUserId = endUserId;
                 this.setCookie(`human_behavior_end_user_id_${this.apiKey}`, endUserId, 365);
                 // Only setup browser-specific handlers when in browser environment
                 if (isBrowser) {
                     this.setupPageUnloadHandler();
-                    this.start();
+                    this.setupNavigationTracking();
                     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 with sessionId: ${this.sessionId}, endUserId: ${endUserId}`);
             }
             catch (error) {
-                console.error('Failed to initialize HumanBehaviorTracker:', error);
+                logError('Failed to initialize HumanBehaviorTracker:', error);
                 throw error;
             }
         });
@@ -4858,48 +4917,295 @@ class HumanBehaviorTracker {
             yield this.initializationPromise;
         });
     }
+    /**
+     * Setup navigation event tracking for SPA navigation
+     */
+    setupNavigationTracking() {
+        if (!isBrowser || this.navigationTrackingEnabled)
+            return;
+        this.navigationTrackingEnabled = true;
+        logDebug('Setting up navigation tracking');
+        // Store original history methods
+        this.originalPushState = history.pushState;
+        this.originalReplaceState = history.replaceState;
+        // Override pushState to capture programmatic navigation
+        history.pushState = (...args) => {
+            this.previousUrl = this.currentUrl;
+            this.currentUrl = window.location.href;
+            // Call original method
+            this.originalPushState.apply(history, args);
+            // Track navigation event
+            this.trackNavigationEvent('pushState', this.previousUrl, this.currentUrl);
+        };
+        // Override replaceState to capture programmatic navigation
+        history.replaceState = (...args) => {
+            this.previousUrl = this.currentUrl;
+            this.currentUrl = window.location.href;
+            // Call original method
+            this.originalReplaceState.apply(history, args);
+            // Track navigation event
+            this.trackNavigationEvent('replaceState', this.previousUrl, this.currentUrl);
+        };
+        // Listen for popstate events (back/forward navigation)
+        const popstateListener = () => {
+            this.previousUrl = this.currentUrl;
+            this.currentUrl = window.location.href;
+            this.trackNavigationEvent('popstate', this.previousUrl, this.currentUrl);
+        };
+        window.addEventListener('popstate', popstateListener);
+        this.navigationListeners.push(() => {
+            window.removeEventListener('popstate', popstateListener);
+        });
+        // Listen for hashchange events
+        const hashchangeListener = () => {
+            this.previousUrl = this.currentUrl;
+            this.currentUrl = window.location.href;
+            this.trackNavigationEvent('hashchange', this.previousUrl, this.currentUrl);
+        };
+        window.addEventListener('hashchange', hashchangeListener);
+        this.navigationListeners.push(() => {
+            window.removeEventListener('hashchange', hashchangeListener);
+        });
+        // Track initial page load
+        this.trackNavigationEvent('pageLoad', '', this.currentUrl);
+    }
+    /**
+     * Track navigation events and send custom events
+     */
+    trackNavigationEvent(type, fromUrl, toUrl) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            if (!this.initialized)
+                return;
+            try {
+                const navigationData = {
+                    type: type,
+                    from: fromUrl,
+                    to: toUrl,
+                    timestamp: new Date().toISOString(),
+                    pathname: window.location.pathname,
+                    search: window.location.search,
+                    hash: window.location.hash,
+                    referrer: document.referrer
+                };
+                // Add navigation event to the main event stream
+                yield this.addEvent({
+                    type: 5, // Custom event type
+                    data: {
+                        payload: Object.assign({ eventType: 'navigation' }, navigationData)
+                    },
+                    timestamp: Date.now()
+                });
+                logDebug(`Navigation tracked: ${type} from ${fromUrl} to ${toUrl}`);
+            }
+            catch (error) {
+                logError('Failed to track navigation event:', error);
+            }
+        });
+    }
+    /**
+     * Track a page view event (PostHog-style)
+     */
+    trackPageView(url) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            if (!this.initialized)
+                return;
+            try {
+                const pageViewData = {
+                    url: url || window.location.href,
+                    pathname: window.location.pathname,
+                    search: window.location.search,
+                    hash: window.location.hash,
+                    referrer: document.referrer,
+                    timestamp: new Date().toISOString()
+                };
+                // Add pageview event to the main event stream
+                yield this.addEvent({
+                    type: 5, // Custom event type
+                    data: {
+                        payload: Object.assign({ eventType: 'pageview' }, pageViewData)
+                    },
+                    timestamp: Date.now()
+                });
+                logDebug(`Pageview tracked: ${pageViewData.url}`);
+            }
+            catch (error) {
+                logError('Failed to track pageview event:', error);
+            }
+        });
+    }
+    /**
+     * Track a custom event (PostHog-style)
+     */
+    customEvent(eventName, properties) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            if (!this.initialized)
+                return;
+            try {
+                const customEventData = {
+                    eventName: eventName,
+                    properties: properties || {},
+                    timestamp: new Date().toISOString(),
+                    url: window.location.href,
+                    pathname: window.location.pathname
+                };
+                // Add custom event to the main event stream
+                yield this.addEvent({
+                    type: 5, // Custom event type
+                    data: {
+                        payload: Object.assign({ eventType: 'custom' }, customEventData)
+                    },
+                    timestamp: Date.now()
+                });
+                logDebug(`Custom event tracked: ${eventName}`, properties);
+            }
+            catch (error) {
+                logError('Failed to track custom event:', error);
+            }
+        });
+    }
+    /**
+     * Cleanup navigation tracking
+     */
+    cleanupNavigationTracking() {
+        if (!this.navigationTrackingEnabled)
+            return;
+        // Restore original history methods
+        if (this.originalPushState) {
+            history.pushState = this.originalPushState;
+        }
+        if (this.originalReplaceState) {
+            history.replaceState = this.originalReplaceState;
+        }
+        // Remove event listeners
+        this.navigationListeners.forEach(cleanup => cleanup());
+        this.navigationListeners = [];
+        this.navigationTrackingEnabled = false;
+        logDebug('Navigation tracking cleaned up');
+    }
     static logToStorage(message) {
+        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
+        };
+        // 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;
+        logDebug('Console tracking enabled');
+    }
+    /**
+     * Disable console event tracking
+     */
+    disableConsoleTracking() {
+        if (!isBrowser || !this.consoleTrackingEnabled)
+            return;
+        // Restore original console methods
+        if (this.originalConsole) {
+            console.log = this.originalConsole.log;
+            console.warn = this.originalConsole.warn;
+            console.error = this.originalConsole.error;
+        }
+        this.consoleTrackingEnabled = false;
+        logDebug('Console tracking disabled');
+    }
+    trackConsoleEvent(level, args) {
+        if (!this.initialized)
+            return;
         try {
-            const logs = JSON.parse(localStorage.getItem('human_behavior_logs') || '[]');
-            logs.push(`${new Date().toISOString()}: ${message}`);
-            localStorage.setItem('human_behavior_logs', JSON.stringify(logs));
+            const consoleData = {
+                level: level,
+                message: args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' '),
+                timestamp: new Date().toISOString(),
+                url: window.location.href
+            };
+            // Add console event to the main event stream
+            this.addEvent({
+                type: 5, // Custom event type
+                data: {
+                    payload: Object.assign({ eventType: 'console' }, consoleData)
+                },
+                timestamp: Date.now()
+            }).catch(error => {
+                logError('Failed to track console event:', error);
+            });
         }
-        catch (e) {
-            console.error('Failed to log to storage:', e);
+        catch (error) {
+            logError('Error in trackConsoleEvent:', error);
         }
     }
     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);
             }
         });
         // Handle actual page unload/close
         window.addEventListener('beforeunload', () => {
-            // Update last activity time
-            localStorage.setItem('human_behavior_last_activity', Date.now().toString());
             // Send final events
             this.api.sendBeaconEvents(this.eventIngestionQueue, this.sessionId);
         });
-        // Update activity timestamp periodically
-        setInterval(() => {
+        // Update activity timestamp on user interaction (not on page load)
+        const updateActivity = () => {
             localStorage.setItem('human_behavior_last_activity', Date.now().toString());
-        }, 60000); // Update every minute
+        };
+        // Listen for user interactions to update activity timestamp
+        window.addEventListener('click', updateActivity);
+        window.addEventListener('keydown', updateActivity);
+        window.addEventListener('scroll', updateActivity);
+        window.addEventListener('mousemove', updateActivity);
     }
     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) {
@@ -4928,12 +5234,6 @@ class HumanBehaviorTracker {
             yield this.api.sendUserAuth(this.endUserId, this.userProperties, this.sessionId, authFields);
         });
     }
-    customEvent(eventName_1) {
-        return __awaiter$1(this, arguments, void 0, function* (eventName, eventProperties = {}) {
-            yield this.ensureInitialized();
-            this.api.sendBeaconCustomEvent(eventName, eventProperties, this.sessionId);
-        });
-    }
     start() {
         return __awaiter$1(this, void 0, void 0, function* () {
             yield this.ensureInitialized();
@@ -4943,6 +5243,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 +5268,10 @@ class HumanBehaviorTracker {
                 clearInterval(this.flushInterval);
                 this.flushInterval = null;
             }
+            // Disable console tracking
+            this.disableConsoleTracking();
+            // Cleanup navigation tracking
+            this.cleanupNavigationTracking();
         });
     }
     addEvent(event) {
@@ -4999,7 +5305,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;
@@ -5008,7 +5314,7 @@ class HumanBehaviorTracker {
     }
     flush() {
         return __awaiter$1(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b, _c, _d;
             // Prevent concurrent flushes
             if (this.isProcessing || !this.initialized) {
                 return;
@@ -5020,17 +5326,25 @@ 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();
                         }
+                        else if (((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes('ERR_BLOCKED_BY_CLIENT')) ||
+                            ((_c = error.message) === null || _c === void 0 ? void 0 : _c.includes('Failed to fetch')) ||
+                            ((_d = error.message) === null || _d === void 0 ? void 0 : _d.includes('NetworkError'))) {
+                            // Handle ad blocker or network issues gracefully
+                            logWarn('Request blocked by ad blocker or network issue, storing events for retry');
+                            this.rejectedEvents.push(...eventsToProcess);
+                            // Don't process rejected events immediately to avoid spam
+                        }
                         else {
                             throw error;
                         }
@@ -5073,7 +5387,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 +5400,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);
@@ -5103,6 +5417,61 @@ class HumanBehaviorTracker {
     getRedactedFields() {
         return this.redactionManager.getSelectedFields();
     }
+    /**
+     * Get the current session ID
+     */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /**
+     * Get the current URL being tracked
+     */
+    getCurrentUrl() {
+        return this.currentUrl;
+    }
+    /**
+     * Test if the tracker can reach the ingestion server
+     */
+    testConnection() {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            try {
+                yield this.api.init(this.sessionId, this.endUserId);
+                return { success: true };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error.message || 'Unknown error'
+                };
+            }
+        });
+    }
+    /**
+     * Get connection status and recommendations
+     */
+    getConnectionStatus() {
+        const recommendations = [];
+        let blocked = false;
+        // Check if we have rejected events (might indicate blocking)
+        if (this.rejectedEvents.length > 0) {
+            blocked = true;
+            recommendations.push('Some requests may be blocked by ad blockers');
+        }
+        // Check if connection was blocked during initialization
+        if (this._connectionBlocked) {
+            blocked = true;
+            recommendations.push('Initial connection test failed - ad blocker may be active');
+        }
+        // Check if we're in a browser environment
+        if (typeof window === 'undefined') {
+            recommendations.push('Not running in browser environment');
+        }
+        // Check if navigator.sendBeacon is available
+        if (typeof navigator.sendBeacon === 'undefined') {
+            recommendations.push('sendBeacon not available, using fetch fallback');
+        }
+        return { blocked, recommendations };
+    }
 }
 // Only expose to window object in browser environments
 if (isBrowser) {
@@ -5117,5 +5486,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