humanbehavior-js 0.1.8 → 0.2.0

package/dist/types/index.d.ts

@@ -89,8 +89,6 @@ declare global {
 declare class HumanBehaviorTracker {
     private eventIngestionQueue;
     private queueSizeBytes;
-    private rejectedEvents;
-    private isProcessingRejectedEvents;
     private sessionId;
     private userProperties;
     private isProcessing;
@@ -188,19 +186,31 @@ declare class HumanBehaviorTracker {
     private trackConsoleEvent;
     private setupPageUnloadHandler;
     viewLogs(): void;
-    addUserInfo(userProperties: Record<string, any>): Promise<void>;
+    addUserInfo({ userId, userProperties }: {
+        userId: string;
+        userProperties: Record<string, any>;
+    }): Promise<void>;
     /**
-     * Authenticate user using existing userInfo data
+     * Add user identification information to the tracker
      * @param authFields Array of field names to check for existing users (e.g., ['email', 'phoneNumber'])
      */
-    auth(authFields: string[]): Promise<void>;
+    private auth;
     start(): Promise<void>;
     stop(): Promise<void>;
     addEvent(event: any): Promise<void>;
-    private processRejectedEvents;
     private flush;
     private setCookie;
     getCookie(name: string): string | null;
+    /**
+     * Delete a cookie by setting its expiration date to the past
+     * @param name The name of the cookie to delete
+     */
+    private deleteCookie;
+    /**
+     * Log out the current user by clearing all user-related data
+     * This will delete the user ID cookie, clear localStorage, and reset user properties
+     */
+    logout(): void;
     /**
      * Start redaction functionality for sensitive input fields
      * @param options Optional configuration for redaction behavior
@@ -260,6 +270,7 @@ declare class HumanBehaviorTracker {
 declare const MAX_CHUNK_SIZE_BYTES: number;
 declare function isChunkSizeExceeded(currentChunk: any[], newEvent: any, sessionId: string): boolean;
 declare function validateSingleEventSize(event: any, sessionId: string): void;
+declare function splitLargeEvent(event: any, sessionId: string): any[];
 declare class HumanBehaviorAPI {
     private apiKey;
     private baseUrl;
@@ -272,7 +283,7 @@ declare class HumanBehaviorAPI {
         endUserId: any;
     }>;
     sendEvents(events: any[], sessionId: string, userId: string): Promise<void>;
-    sendEventsChunked(events: any[], sessionId: string): Promise<any[]>;
+    sendEventsChunked(events: any[], sessionId: string, userId?: string): Promise<any[]>;
     sendUserData(userId: string, userData: Record<string, any>, sessionId: string): Promise<any>;
     sendUserAuth(userId: string, userData: Record<string, any>, sessionId: string, authFields: string[]): Promise<any>;
     sendBeaconEvents(events: any[], sessionId: string): boolean;
@@ -316,5 +327,9 @@ declare const logWarn: (message: string, ...args: any[]) => void;
 declare const logInfo: (message: string, ...args: any[]) => void;
 declare const logDebug: (message: string, ...args: any[]) => void;
 
-export { HumanBehaviorAPI, HumanBehaviorTracker, LogLevel, MAX_CHUNK_SIZE_BYTES, RedactionManager, HumanBehaviorTracker as default, isChunkSizeExceeded, logDebug, logError, logInfo, logWarn, logger, redactionManager, validateSingleEventSize };
+/**
+ * Main entry point for the HumanBehavior SDK
+ */
+
+export { HumanBehaviorAPI, HumanBehaviorTracker, LogLevel, MAX_CHUNK_SIZE_BYTES, RedactionManager, HumanBehaviorTracker as default, isChunkSizeExceeded, logDebug, logError, logInfo, logWarn, logger, redactionManager, splitLargeEvent, validateSingleEventSize };
 export type { LoggerConfig, RedactionOptions };

package/dist/types/react/index.d.ts

@@ -1,4 +1,5 @@
-import React, { ReactNode } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
 import { HumanBehaviorTracker } from '..';
 export { HumanBehaviorTracker } from '..';
 
@@ -12,7 +13,21 @@ interface HumanBehaviorProviderProps {
         redactFields?: string[];
     };
 }
-declare const HumanBehaviorProvider: ({ apiKey, client, children, options }: HumanBehaviorProviderProps) => React.JSX.Element;
+declare const HumanBehaviorProvider: ({ apiKey, client, children, options }: HumanBehaviorProviderProps) => react_jsx_runtime.JSX.Element;
 declare const useHumanBehavior: () => HumanBehaviorTracker;
+declare const useRedaction: () => {
+    setRedactedFields: (fields: string[]) => void;
+    isRedactionActive: () => boolean;
+    getRedactedFields: () => string[];
+};
+declare const useUserTracking: () => {
+    addUserInfo: (userId: string, userProperties: Record<string, any>) => Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: unknown;
+    }>;
+};
 
-export { HumanBehaviorProvider, useHumanBehavior };
+export { HumanBehaviorProvider, useHumanBehavior, useRedaction, useUserTracking };

package/package.json

@@ -1,36 +1,50 @@
 {
   "name": "humanbehavior-js",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "SDK for HumanBehavior session and event recording",
   "type": "module",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
   "types": "./dist/types/index.d.ts",
   "unpkg": "dist/index.min.js",
+  "jsdelivr": "dist/index.min.js",
+  "homepage": "https://documentation.humanbehavior.co",
   "exports": {
     ".": {
       "import": "./dist/esm/index.js",
       "require": "./dist/cjs/index.js",
-      "types": "./dist/types/index.d.ts"
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/esm/index.js"
     },
     "./react": {
       "import": "./dist/esm/react/index.js",
       "require": "./dist/cjs/react/index.js",
-      "types": "./dist/types/react/index.d.ts"
-    }
+      "types": "./dist/types/react/index.d.ts",
+      "default": "./dist/esm/react/index.js"
+    },
+    "./package.json": "./package.json"
   },
+  "files": [
+    "dist/**/*",
+    "src/**/*",
+    "*.d.ts"
+  ],
   "scripts": {
     "build": "rollup -c",
     "build:dev": "rollup -c --environment NODE_ENV:development",
     "prepare": "npm run build",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node scripts/test-bundlers.js",
+    "test:bundlers": "node scripts/test-bundlers.js",
+    "test:framework": "node scripts/test-framework-compatibility.js",
+    "test:all": "npm run test:bundlers && npm run test:framework"
   },
   "author": "Chirag Kawediya, Skyler Ji, Amogh Chaturvedi",
   "license": "ISC",
+  "peerDependencies": {
+    "react": ">=16.8.0",
+    "react-dom": ">=16.8.0"
+  },
   "dependencies": {
-    "@types/react": "^19.0.12",
-    "humanbehavior-js": "^0.0.9",
-    "react": "^19.0.0",
     "rrweb": "^2.0.0-alpha.4",
     "uuid": "^11.1.0"
   },
@@ -40,6 +54,8 @@
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.1.2",
     "@types/node": "^24.0.3",
+    "@types/react": "^19.0.12",
+    "@types/react-dom": "^19.0.0",
     "rollup": "^4.36.0",
     "rollup-plugin-dts": "^6.2.1",
     "tslib": "^2.8.1",
@@ -56,6 +72,13 @@
     "session-recording",
     "analytics",
     "rrweb",
-    "koalaware"
-  ]
+    "koalaware",
+    "webpack",
+    "esbuild",
+    "vite",
+    "rollup"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  }
 }

package/readme.md

@@ -2,6 +2,8 @@
 
 A simplified session recording and analytics SDK that maintains session continuity across page navigations.
 
+📖 **[Full Documentation](https://documentation.humanbehavior.co)** - Complete API reference, examples, and integration guides
+
 ## Quick Start
 
 ### Single Page Application (Recommended)

package/src/api.ts

@@ -1,6 +1,6 @@
-import { logError, logInfo } from './utils/logger';
+import { logError, logInfo, logDebug } from './utils/logger';
 
-export const MAX_CHUNK_SIZE_BYTES = 1024 * 1024 * 10; // 10MB chunk size
+export const MAX_CHUNK_SIZE_BYTES = 1024 * 1024; // 1MB chunk size - more conservative
 
 export function isChunkSizeExceeded(currentChunk: any[], newEvent: any, sessionId: string): boolean {
     const nextChunkSize = new TextEncoder().encode(JSON.stringify({
@@ -18,10 +18,62 @@ export function validateSingleEventSize(event: any, sessionId: string): void {
     })).length;
 
     if (singleEventSize > MAX_CHUNK_SIZE_BYTES) {
-        throw new Error(`Single event size (${singleEventSize} bytes) exceeds maximum chunk size (${MAX_CHUNK_SIZE_BYTES} bytes)`);
+        // Instead of throwing, log a warning and suggest reducing event size
+        console.warn(`Single event size (${singleEventSize} bytes) exceeds maximum chunk size (${MAX_CHUNK_SIZE_BYTES} bytes). Consider reducing event data size.`);
     }
 }
 
+export function splitLargeEvent(event: any, sessionId: string): any[] {
+    const eventSize = new TextEncoder().encode(JSON.stringify({
+        sessionId,
+        events: [event]
+    })).length;
+
+    if (eventSize <= MAX_CHUNK_SIZE_BYTES) {
+        return [event];
+    }
+
+    // If event is too large, try to split it by removing large properties
+    const simplifiedEvent = { ...event };
+    
+    // Remove potentially large properties
+    const largeProperties = ['screenshot', 'html', 'dom', 'fullText', 'innerHTML', 'outerHTML'];
+    largeProperties.forEach(prop => {
+        if (simplifiedEvent[prop]) {
+            delete simplifiedEvent[prop];
+        }
+    });
+
+    // Check if simplified event is now small enough
+    const simplifiedSize = new TextEncoder().encode(JSON.stringify({
+        sessionId,
+        events: [simplifiedEvent]
+    })).length;
+
+    if (simplifiedSize <= MAX_CHUNK_SIZE_BYTES) {
+        return [simplifiedEvent];
+    }
+
+    // If still too large, create a minimal event
+    const minimalEvent = {
+        type: event.type,
+        timestamp: event.timestamp,
+        url: event.url,
+        pathname: event.pathname,
+        // Keep only essential properties
+        ...Object.fromEntries(
+            Object.entries(event).filter(([key, value]) => 
+                !largeProperties.includes(key) && 
+                typeof value !== 'object' && 
+                typeof value !== 'string' || 
+                (typeof value === 'string' && value.length < 1000)
+            )
+        )
+    };
+
+    return [minimalEvent];
+}
+
 export class HumanBehaviorAPI {
     private apiKey: string;
     private baseUrl: string;
@@ -98,7 +150,7 @@ export class HumanBehaviorAPI {
         }
     }
     
-    async sendEventsChunked(events: any[], sessionId: string) {
+    async sendEventsChunked(events: any[], sessionId: string, userId?: string) {
         try {
             const results = [];
             let currentChunk: any[] = [];
@@ -115,7 +167,8 @@ export class HumanBehaviorAPI {
                             },
                             body: JSON.stringify({
                                 sessionId,
-                                events: currentChunk
+                                events: currentChunk,
+                                endUserId: userId
                             })
                         });
                         
@@ -127,11 +180,11 @@ export class HumanBehaviorAPI {
                         currentChunk = [];
                     }
 
-                    // Validate single event size
-                    validateSingleEventSize(event, sessionId);
+                    // Handle large events by splitting them
+                    const splitEvents = splitLargeEvent(event, sessionId);
                     
-                    // Start new chunk with this event
-                    currentChunk = [event];
+                    // Start new chunk with the split events
+                    currentChunk = splitEvents;
                 } else {
                     // Add event to current chunk
                     currentChunk.push(event);
@@ -148,7 +201,8 @@ export class HumanBehaviorAPI {
                     },
                     body: JSON.stringify({
                         sessionId,
-                        events: currentChunk
+                        events: currentChunk,
+                        endUserId: userId
                     })
                 });
                 
@@ -224,7 +278,8 @@ export class HumanBehaviorAPI {
         const payload = {
             sessionId: sessionId,
             events: events,
-            endUserId: null // Beacon doesn't have user context
+            endUserId: null, // Beacon doesn't have user context
+            apiKey: this.apiKey // Include API key in body since beacon can't use headers
         };
 
         // Convert to Blob for sendBeacon
@@ -241,6 +296,7 @@ export class HumanBehaviorAPI {
     }
 
     async sendCustomEvent(sessionId: string, eventName: string, eventProperties?: Record<string, any>) {
+        logInfo('[SDK] Sending custom event', { sessionId, eventName, eventProperties });
         try {
             const response = await fetch(`${this.baseUrl}/api/ingestion/customEvent`, {
                 method: 'POST',
@@ -254,14 +310,17 @@ export class HumanBehaviorAPI {
                     eventProperties: eventProperties || {}
                 })
             });
-            
+            logInfo('[SDK] Custom event response', { status: response.status, statusText: response.statusText });
             if (!response.ok) {
-                throw new Error(`Failed to send custom event: ${response.statusText}`);
+                const errorText = await response.text();
+                logError('[SDK] Failed to send custom event', { status: response.status, statusText: response.statusText, errorText });
+                throw new Error(`Failed to send custom event: ${response.status} ${response.statusText} - ${errorText}`);
             }
-            
-            return await response.json();
+            const json = await response.json();
+            logDebug('[SDK] Custom event success', json);
+            return json;
         } catch (error) {
-            logError('Error sending custom event:', error);
+            logError('[SDK] Error sending custom event', error, { sessionId, eventName, eventProperties });
             throw error;
         }
     }

package/src/index.ts

@@ -16,8 +16,8 @@ export * from './redact';
 // Export logger functionality
 export * from './utils/logger';
 
-// Also export the tracker as the default export
-export { HumanBehaviorTracker as default } from './tracker';
+// Export the tracker as the default export
+export default HumanBehaviorTracker;
 
 // For UMD builds, expose the main class globally
 if (typeof window !== 'undefined') {

package/src/react/index.tsx

@@ -114,21 +114,24 @@ export const HumanBehaviorProvider = ({ apiKey, client, children, options }: Hum
 
     // Wait for initialization to complete
     tracker.initializationPromise?.then(async () => {
-        // Start the tracker to enable event flushing and recording
         await tracker.start();
         setIsInitialized(true);
         
       // Process any queued events
       const currentQueue = eventQueueRef.current;
       if (currentQueue.length > 0) {
-        currentQueue.forEach(event => {
+        for (const event of currentQueue) {
           if (event.type === 'identify') {
             logDebug('Processing queued identify event', event.userProperties);
-            tracker.addUserInfo(event.userProperties);
+            try {
+              await tracker.addUserInfo(event.userProperties);
+            } catch (error) {
+              logError('Failed to process queued user info:', error);
+            }
           } else {
             tracker.addEvent(event);
           }
-        });
+        }
         setEventQueue([]); // Clear the queue
       }
     }).catch(error => {
@@ -201,6 +204,48 @@ export const useHumanBehavior = () => {
   return tracker;
 };
 
+// Custom hook for managing redaction fields dynamically
+export const useRedaction = () => {
+  const tracker = useHumanBehavior();
+  
+  const setRedactedFields = useCallback((fields: string[]) => {
+    tracker.setRedactedFields(fields);
+  }, [tracker]);
+  
+  const isRedactionActive = useCallback(() => {
+    return tracker.isRedactionActive();
+  }, [tracker]);
+  
+  const getRedactedFields = useCallback(() => {
+    return tracker.getRedactedFields();
+  }, [tracker]);
+  
+  return {
+    setRedactedFields,
+    isRedactionActive,
+    getRedactedFields
+  };
+};
+
+// Custom hook for managing user info
+export const useUserTracking = () => {
+  const tracker = useHumanBehavior();
+  
+  const addUserInfo = useCallback(async (userId: string, userProperties: Record<string, any>) => {
+    try {
+      await tracker.addUserInfo({ userId, userProperties });
+      return { success: true };
+    } catch (error) {
+      logError('Failed to add user info:', error);
+      return { success: false, error };
+    }
+  }, [tracker]);
+  
+  return {
+    addUserInfo
+  };
+};
+
 // Automatic page tracking component (similar to PostHog's PostHogPageView)
 function HumanBehaviorPageView() {
   const tracker = useContext(HumanBehaviorContext);

package/src/tracker.ts

@@ -18,8 +18,6 @@ declare global {
 export class HumanBehaviorTracker {
     private eventIngestionQueue: any[] = [];
     private queueSizeBytes: number = 0;
-    private rejectedEvents: any[] = [];
-    private isProcessingRejectedEvents: boolean = false;
 
     private sessionId!: string;
     private userProperties: Record<string, any> = {};
@@ -183,7 +181,6 @@ export class HumanBehaviorTracker {
             if (isBrowser) {
                 this.setupPageUnloadHandler();
                 this.setupNavigationTracking();
-                this.processRejectedEvents();
             } else {
                 logWarn('HumanBehaviorTracker initialized in a non-browser environment. Session tracking is disabled.');
             }
@@ -349,10 +346,21 @@ export class HumanBehaviorTracker {
             await this.api.sendCustomEvent(this.sessionId, eventName, properties);
             
             logDebug(`Custom event tracked: ${eventName}`, properties);
-        } catch (error) {
+        } catch (error: any) {
             logError('Failed to track custom event:', error);
             
-            // Fallback: add to event stream if direct API call fails
+            // Handle specific error types - check for any custom event failure
+            if (error.message?.includes('500') || 
+                error.message?.includes('Internal Server Error') ||
+                error.message?.includes('Failed to send custom event')) {
+                logWarn('Custom event endpoint failed, using fallback');
+            } else if (error.message?.includes('ERR_BLOCKED_BY_CLIENT')) {
+                logWarn('Custom event request blocked by ad blocker, using fallback');
+            } else if (error.message?.includes('Failed to fetch')) {
+                logWarn('Custom event network error, using fallback');
+            }
+            
+            // Always try fallback for any custom event error
             try {
                 const customEventData = {
                     eventName: eventName,
@@ -709,30 +717,31 @@ export class HumanBehaviorTracker {
         }
     }
 
-    public async addUserInfo(userProperties: Record<string, any>) {
+    public async addUserInfo(
+        { userId, userProperties }: { userId: string, userProperties: Record<string, any> }
+    ) {
         await this.ensureInitialized();
         if (!this.endUserId) {
             throw new Error('Cannot add user info before tracker initialization');
         }
         this.userProperties = userProperties;
         await this.api.sendUserData(this.endUserId, userProperties, this.sessionId);
+        if (userId) {
+            this.endUserId = userId;
+        }
     }
 
     /**
-     * Authenticate user using existing userInfo data
+     * Add user identification information to the tracker
      * @param authFields Array of field names to check for existing users (e.g., ['email', 'phoneNumber'])
      */
-    public async auth(authFields: string[]) {
+    private async auth(id: string) {
         await this.ensureInitialized();
         if (!this.endUserId) {
             throw new Error('Cannot authenticate before tracker initialization');
         }
-        if (!this.userProperties || Object.keys(this.userProperties).length === 0) {
-            throw new Error('No user info available. Call addUserInfo() first.');
-        }
-        const response = await this.api.sendUserAuth(this.endUserId, this.userProperties, this.sessionId, authFields);
+        const response = await this.api.sendUserAuth(this.endUserId, { id }, this.sessionId, ["id"]);
         if (response && response.userId && response.userId !== this.endUserId) {
-            // Update endUserId and cookie if backend returns a new userId
             this.endUserId = response.userId;
             this.setCookie(`human_behavior_end_user_id_${this.apiKey}`, response.userId, 365);
         }
@@ -792,33 +801,6 @@ export class HumanBehaviorTracker {
         this.queueSizeBytes += eventSize;
     }
 
-    private async processRejectedEvents() {
-        if (this.isProcessingRejectedEvents || this.rejectedEvents.length === 0) return;
-        
-        this.isProcessingRejectedEvents = true;
-        try {
-            // Create a new session ID for rejected events
-            const newSessionId = uuidv1();
-            if (isBrowser) {
-                localStorage.setItem('human_behavior_session_id', newSessionId);
-            }
-            
-            // Try to send rejected events with new session ID using beacon
-            // sendBeacon returns true if the request was queued successfully
-            this.api.sendBeaconEvents(this.rejectedEvents, newSessionId);
-            
-            // Clear rejected events and update session ID
-            // Note: We can't verify if the beacon data was actually sent,
-            // but we clear the events to prevent duplicate sending attempts
-            this.rejectedEvents = [];
-            this.sessionId = newSessionId;
-        } catch (error) {
-            logError('Failed to process rejected events:', error);
-        } finally {
-            this.isProcessingRejectedEvents = false;
-        }
-    }
-
     private async flush() {
         // Prevent concurrent flushes
         if (this.isProcessing || !this.initialized) {
@@ -835,20 +817,18 @@ export class HumanBehaviorTracker {
             if (eventsToProcess.length > 0) {
                 logDebug('Flushing events:', eventsToProcess);
                 try {
-                    await this.api.sendEvents(eventsToProcess, this.sessionId, this.endUserId!);
+                    // Use chunked sending to handle large payloads
+                    await this.api.sendEventsChunked(eventsToProcess, this.sessionId, this.endUserId!);
                 } catch (error: any) {
-                    // If we get a 400 error, store events for retry
+                    // Handle specific error types with graceful degradation
                     if (error.message?.includes('ERROR: Session already completed')) {
-                        logInfo('Session expired, storing events for retry');
-                        this.rejectedEvents.push(...eventsToProcess);
-                        this.processRejectedEvents();
+                        logWarn('Session expired, events will be lost');
+                    } else if (error.message?.includes('413') || error.message?.includes('Content Too Large')) {
+                        logWarn('Payload too large, events will be lost');
                     } else if (error.message?.includes('ERR_BLOCKED_BY_CLIENT') || 
                                error.message?.includes('Failed to fetch') ||
                                error.message?.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
+                        logWarn('Request blocked by ad blocker or network issue, events will be lost');
                     } else {
                         throw error;
                     }
@@ -924,6 +904,56 @@ export class HumanBehaviorTracker {
         }
     }
 
+    /**
+     * Delete a cookie by setting its expiration date to the past
+     * @param name The name of the cookie to delete
+     */
+    private deleteCookie(name: string) {
+        if (!isBrowser) return;
+        
+        try {
+            // Delete cookie by setting expiration to past
+            document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/; SameSite=Lax`;
+            logDebug(`Deleted cookie: ${name}`);
+        } catch (error) {
+            logError(`Failed to delete cookie: ${name}`, error);
+        }
+        
+        // Also remove from localStorage
+        try {
+            localStorage.removeItem(name);
+            logDebug(`Removed from localStorage: ${name}`);
+        } catch (error) {
+            logError(`Failed to remove from localStorage: ${name}`, error);
+        }
+    }
+
+    /**
+     * Log out the current user by clearing all user-related data
+     * This will delete the user ID cookie, clear localStorage, and reset user properties
+     */
+    public logout(): void {
+        if (!isBrowser) return;
+        
+        try {      
+            // Clear user ID cookie and localStorage
+            const userIdCookieName = `human_behavior_end_user_id_${this.apiKey}`;
+            this.deleteCookie(userIdCookieName);
+            
+            // Clear session data from localStorage
+            localStorage.removeItem('human_behavior_session_id');
+            localStorage.removeItem('human_behavior_last_activity');
+            
+            // Reset user-related properties
+            this.endUserId = null;
+            this.userProperties = {};
+            
+            logInfo('User logged out - cleared all user data and cookies');
+        } catch (error) {
+            logError('Error during logout:', error);
+        }
+    }
+
     /**
      * Start redaction functionality for sensitive input fields
      * @param options Optional configuration for redaction behavior
@@ -1005,8 +1035,8 @@ export class HumanBehaviorTracker {
         const recommendations: string[] = [];
         let blocked = false;
 
-        // Check if we have rejected events (might indicate blocking)
-        if (this.rejectedEvents.length > 0) {
+        // Check if we have queued events (might indicate blocking)
+        if (this.eventIngestionQueue.length > 0) {
             blocked = true;
             recommendations.push('Some requests may be blocked by ad blockers');
         }