@tracelog/lib 0.5.5 → 0.6.1

package/dist/cjs/handlers/performance.handler.js

@@ -37,15 +37,14 @@ exports.PerformanceHandler = void 0;
 const state_manager_1 = require("../managers/state.manager");
 const types_1 = require("../types");
 const constants_1 = require("../constants");
-const performance_constants_1 = require("../constants/performance.constants");
-const logging_1 = require("../utils/logging");
+const utils_1 = require("@/utils");
 class PerformanceHandler extends state_manager_1.StateManager {
     constructor(eventManager) {
         super();
         this.reportedByNav = new Map();
         this.observers = [];
         this.lastLongTaskSentAt = 0;
-        this.vitalThresholds = performance_constants_1.WEB_VITALS_THRESHOLDS;
+        this.vitalThresholds = constants_1.WEB_VITALS_THRESHOLDS;
         this.eventManager = eventManager;
     }
     async startTracking() {
@@ -58,10 +57,7 @@ class PerformanceHandler extends state_manager_1.StateManager {
                 obs.disconnect();
             }
             catch (error) {
-                logging_1.debugLog.warn('PerformanceHandler', 'Failed to disconnect performance observer', {
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                    observerIndex: index,
-                });
+                (0, utils_1.log)('warn', 'Failed to disconnect performance observer', { error, data: { observerIndex: index } });
             }
         });
         this.observers.length = 0;
@@ -134,9 +130,7 @@ class PerformanceHandler extends state_manager_1.StateManager {
             onINP(report('INP'));
         }
         catch (error) {
-            logging_1.debugLog.warn('PerformanceHandler', 'Failed to load web-vitals library, using fallback', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
+            (0, utils_1.log)('warn', 'Failed to load web-vitals library, using fallback', { error });
             this.observeWebVitalsFallback();
         }
     }
@@ -157,9 +151,7 @@ class PerformanceHandler extends state_manager_1.StateManager {
             }
         }
         catch (error) {
-            logging_1.debugLog.warn('PerformanceHandler', 'Failed to report TTFB', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
+            (0, utils_1.log)('warn', 'Failed to report TTFB', { error });
         }
     }
     observeLongTasks() {
@@ -201,7 +193,7 @@ class PerformanceHandler extends state_manager_1.StateManager {
     }
     trackWebVital(type, value) {
         if (!Number.isFinite(value)) {
-            logging_1.debugLog.warn('PerformanceHandler', 'Invalid web vital value', { type, value });
+            (0, utils_1.log)('warn', 'Invalid web vital value', { data: { type, value } });
             return;
         }
         this.eventManager.track({
@@ -224,9 +216,7 @@ class PerformanceHandler extends state_manager_1.StateManager {
             return `${timestamp.toFixed(2)}_${window.location.pathname}_${random}`;
         }
         catch (error) {
-            logging_1.debugLog.warn('PerformanceHandler', 'Failed to get navigation ID', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
+            (0, utils_1.log)('warn', 'Failed to get navigation ID', { error });
             return null;
         }
     }
@@ -246,9 +236,9 @@ class PerformanceHandler extends state_manager_1.StateManager {
                     cb(list, observer);
                 }
                 catch (callbackError) {
-                    logging_1.debugLog.warn('PerformanceHandler', 'Observer callback failed', {
-                        type,
-                        error: callbackError instanceof Error ? callbackError.message : 'Unknown error',
+                    (0, utils_1.log)('warn', 'Observer callback failed', {
+                        error: callbackError,
+                        data: { type },
                     });
                 }
                 if (once) {
@@ -267,25 +257,20 @@ class PerformanceHandler extends state_manager_1.StateManager {
             return true;
         }
         catch (error) {
-            logging_1.debugLog.warn('PerformanceHandler', 'Failed to create performance observer', {
-                type,
-                error: error instanceof Error ? error.message : 'Unknown error',
+            (0, utils_1.log)('warn', 'Failed to create performance observer', {
+                error,
+                data: { type },
             });
             return false;
         }
     }
     shouldSendVital(type, value) {
         if (typeof value !== 'number' || !Number.isFinite(value)) {
-            logging_1.debugLog.warn('PerformanceHandler', 'Invalid web vital value', { type, value });
+            (0, utils_1.log)('warn', 'Invalid web vital value', { data: { type, value } });
             return false;
         }
         const threshold = this.vitalThresholds[type];
         if (typeof threshold === 'number' && value <= threshold) {
-            logging_1.debugLog.debug('PerformanceHandler', 'Web vital below threshold, skipping', {
-                type,
-                value,
-                threshold,
-            });
             return false;
         }
         return true;

package/dist/cjs/handlers/scroll.handler.js

@@ -4,7 +4,7 @@ exports.ScrollHandler = void 0;
 const constants_1 = require("../constants");
 const types_1 = require("../types");
 const state_manager_1 = require("../managers/state.manager");
-const logging_1 = require("../utils/logging");
+const utils_1 = require("../utils");
 class ScrollHandler extends state_manager_1.StateManager {
     constructor(eventManager) {
         super();
@@ -144,8 +144,8 @@ class ScrollHandler extends state_manager_1.StateManager {
             return;
         }
         this.limitWarningLogged = true;
-        logging_1.debugLog.warn('ScrollHandler', 'Max scroll events per session reached', {
-            limit: this.maxEventsPerSession,
+        (0, utils_1.log)('warn', 'Max scroll events per session reached', {
+            data: { limit: this.maxEventsPerSession },
         });
     }
     applyConfigOverrides() {
@@ -214,9 +214,10 @@ class ScrollHandler extends state_manager_1.StateManager {
             return document.querySelector(selector);
         }
         catch (error) {
-            logging_1.debugLog.clientWarn('ScrollHandler', 'Invalid CSS selector', {
-                selector,
-                error: error instanceof Error ? error.message : 'Unknown error',
+            (0, utils_1.log)('warn', 'Invalid CSS selector', {
+                error,
+                data: { selector },
+                showToClient: true,
             });
             return null;
         }

package/dist/cjs/handlers/session.handler.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionHandler = void 0;
 const session_manager_1 = require("../managers/session.manager");
 const state_manager_1 = require("../managers/state.manager");
-const logging_1 = require("../utils/logging");
+const utils_1 = require("../utils");
 class SessionHandler extends state_manager_1.StateManager {
     constructor(storageManager, eventManager) {
         super();
@@ -17,16 +17,19 @@ class SessionHandler extends state_manager_1.StateManager {
             return;
         }
         if (this.destroyed) {
-            logging_1.debugLog.warn('SessionHandler', 'Cannot start tracking on destroyed handler');
+            (0, utils_1.log)('warn', 'Cannot start tracking on destroyed handler');
             return;
         }
-        const projectId = this.get('config')?.id;
+        const config = this.get('config');
+        const projectId = config?.integrations?.tracelog?.projectId ?? config?.integrations?.custom?.apiUrl ?? 'default';
         if (!projectId) {
             throw new Error('Cannot start session tracking: config not available');
         }
         try {
             this.sessionManager = new session_manager_1.SessionManager(this.storageManager, this.eventManager, projectId);
             await this.sessionManager.startTracking();
+            // Flush any events that were buffered during initialization
+            this.eventManager.flushPendingEvents();
         }
         catch (error) {
             if (this.sessionManager) {
@@ -38,9 +41,7 @@ class SessionHandler extends state_manager_1.StateManager {
                 }
                 this.sessionManager = null;
             }
-            logging_1.debugLog.error('SessionHandler', 'Failed to start session tracking', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
+            (0, utils_1.log)('error', 'Failed to start session tracking', { error });
             throw error;
         }
     }

package/dist/cjs/integrations/google-analytics.integration.js

@@ -27,9 +27,7 @@ class GoogleAnalyticsIntegration extends state_manager_1.StateManager {
             this.isInitialized = true;
         }
         catch (error) {
-            utils_1.debugLog.error('GoogleAnalyticsIntegration', 'Initialization failed', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
+            (0, utils_1.log)('error', 'Google Analytics initialization failed', { error });
         }
     }
     trackEvent(eventName, metadata) {
@@ -41,9 +39,7 @@ class GoogleAnalyticsIntegration extends state_manager_1.StateManager {
             window.gtag('event', eventName, normalizedMetadata);
         }
         catch (error) {
-            utils_1.debugLog.error('GoogleAnalyticsIntegration', 'Event tracking failed', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
+            (0, utils_1.log)('error', 'Google Analytics event tracking failed', { error });
         }
     }
     cleanup() {

package/dist/cjs/listeners/activity-listener-manager.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActivityListenerManager = void 0;
-const logging_1 = require("../utils/logging");
+const utils_1 = require("../utils");
 class ActivityListenerManager {
     constructor(onActivity) {
         this.options = { passive: true };
@@ -14,7 +14,7 @@ class ActivityListenerManager {
             window.addEventListener('focus', this.onActivity, this.options);
         }
         catch (error) {
-            logging_1.debugLog.error('ActivityListenerManager', 'Failed to setup activity listeners', { error });
+            (0, utils_1.log)('error', 'Failed to setup activity listeners', { error });
             throw error;
         }
     }
@@ -25,7 +25,7 @@ class ActivityListenerManager {
             window.removeEventListener('focus', this.onActivity);
         }
         catch (error) {
-            logging_1.debugLog.warn('ActivityListenerManager', 'Error during activity listeners cleanup', { error });
+            (0, utils_1.log)('warn', 'Error during activity listeners cleanup', { error });
         }
     }
 }

package/dist/cjs/listeners/input-listener-managers.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeyboardListenerManager = exports.MouseListenerManager = void 0;
-const logging_1 = require("../utils/logging");
+const utils_1 = require("../utils");
 /**
  * Base class for input listener managers to reduce code duplication
  */
@@ -17,7 +17,7 @@ class BaseInputListenerManager {
             });
         }
         catch (error) {
-            logging_1.debugLog.error(this.logPrefix, `Failed to setup ${this.logPrefix.toLowerCase()} listeners`, { error });
+            (0, utils_1.log)('error', `Failed to setup ${this.logPrefix.toLowerCase()} listeners`, { error });
         }
     }
     cleanup() {
@@ -27,7 +27,7 @@ class BaseInputListenerManager {
             });
         }
         catch (error) {
-            logging_1.debugLog.warn(this.logPrefix, `Error during ${this.logPrefix.toLowerCase()} listeners cleanup`, { error });
+            (0, utils_1.log)('warn', `Error during ${this.logPrefix.toLowerCase()} listeners cleanup`, { error });
         }
     }
 }

package/dist/cjs/listeners/touch-listener-manager.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TouchListenerManager = void 0;
-const logging_1 = require("../utils/logging");
+const utils_1 = require("../utils");
 class TouchListenerManager {
     constructor(onActivity) {
         this.options = { passive: true };
@@ -15,7 +15,7 @@ class TouchListenerManager {
             window.addEventListener('orientationchange', this.onActivity, this.options);
         }
         catch (error) {
-            logging_1.debugLog.error('TouchListenerManager', 'Failed to setup touch listeners', { error });
+            (0, utils_1.log)('error', 'Failed to setup touch listeners', { error });
             throw error;
         }
     }
@@ -27,7 +27,7 @@ class TouchListenerManager {
             window.removeEventListener('orientationchange', this.onActivity);
         }
         catch (error) {
-            logging_1.debugLog.warn('TouchListenerManager', 'Error during touch listeners cleanup', { error });
+            (0, utils_1.log)('warn', 'Error during touch listeners cleanup', { error });
         }
     }
 }

package/dist/cjs/listeners/unload-listener-manager.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnloadListenerManager = void 0;
-const logging_1 = require("../utils/logging");
+const utils_1 = require("../utils");
 class UnloadListenerManager {
     constructor(onInactivity) {
         this.options = { passive: true };
@@ -13,7 +13,7 @@ class UnloadListenerManager {
             window.addEventListener('pagehide', this.onInactivity, this.options);
         }
         catch (error) {
-            logging_1.debugLog.error('UnloadListenerManager', 'Failed to setup unload listeners', { error });
+            (0, utils_1.log)('error', 'Failed to setup unload listeners', { error });
             throw error;
         }
     }
@@ -23,7 +23,7 @@ class UnloadListenerManager {
             window.removeEventListener('pagehide', this.onInactivity);
         }
         catch (error) {
-            logging_1.debugLog.warn('UnloadListenerManager', 'Error during unload listeners cleanup', { error });
+            (0, utils_1.log)('warn', 'Error during unload listeners cleanup', { error });
         }
     }
 }

package/dist/cjs/listeners/visibility-listener-manager.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VisibilityListenerManager = void 0;
-const logging_1 = require("../utils/logging");
+const utils_1 = require("../utils");
 class VisibilityListenerManager {
     constructor(onActivity, onVisibilityChange) {
         this.options = { passive: true };
@@ -24,7 +24,7 @@ class VisibilityListenerManager {
             }
         }
         catch (error) {
-            logging_1.debugLog.error('VisibilityListenerManager', 'Failed to setup visibility listeners', { error });
+            (0, utils_1.log)('error', 'Failed to setup visibility listeners', { error });
         }
     }
     cleanup() {
@@ -40,7 +40,7 @@ class VisibilityListenerManager {
             }
         }
         catch (error) {
-            logging_1.debugLog.warn('VisibilityListenerManager', 'Error during visibility listeners cleanup', { error });
+            (0, utils_1.log)('warn', 'Error during visibility listeners cleanup', { error });
         }
     }
 }

package/dist/cjs/managers/event.manager.d.ts

@@ -8,9 +8,12 @@ export declare class EventManager extends StateManager {
     private readonly dataSender;
     private readonly emitter;
     private eventsQueue;
+    private pendingEventsBuffer;
     private lastEventFingerprint;
     private lastEventTime;
     private sendIntervalId;
+    private rateLimitCounter;
+    private rateLimitWindowStart;
     constructor(storeManager: StorageManager, googleAnalytics?: GoogleAnalyticsIntegration | null, emitter?: Emitter | null);
     recoverPersistedEvents(): Promise<void>;
     track({ type, page_url, from_page_url, scroll_data, click_data, custom_event, web_vitals, error_data, session_end_reason, }: Partial<EventData>): void;
@@ -18,12 +21,12 @@ export declare class EventManager extends StateManager {
     flushImmediately(): Promise<boolean>;
     flushImmediatelySync(): boolean;
     getQueueLength(): number;
+    flushPendingEvents(): void;
     private clearSendInterval;
     private flushEvents;
     private sendEventsQueue;
     private buildEventsPayload;
     private buildEventPayload;
-    private isEventExcluded;
     private isDuplicateEvent;
     private createEventFingerprint;
     private createEventSignature;
@@ -31,6 +34,7 @@ export declare class EventManager extends StateManager {
     private startSendInterval;
     private handleGoogleAnalyticsIntegration;
     private shouldSample;
+    private checkRateLimit;
     private removeProcessedEvents;
     private emitEvent;
     private emitEventsQueue;

package/dist/cjs/managers/event.manager.js

@@ -10,9 +10,12 @@ class EventManager extends state_manager_1.StateManager {
     constructor(storeManager, googleAnalytics = null, emitter = null) {
         super();
         this.eventsQueue = [];
+        this.pendingEventsBuffer = [];
         this.lastEventFingerprint = null;
         this.lastEventTime = 0;
         this.sendIntervalId = null;
+        this.rateLimitCounter = 0;
+        this.rateLimitWindowStart = 0;
         this.googleAnalytics = googleAnalytics;
         this.dataSender = new sender_manager_1.SenderManager(storeManager);
         this.emitter = emitter;
@@ -21,7 +24,7 @@ class EventManager extends state_manager_1.StateManager {
         await this.dataSender.recoverPersistedEvents({
             onSuccess: (_eventCount, recoveredEvents, body) => {
                 if (recoveredEvents && recoveredEvents.length > 0) {
-                    const eventIds = recoveredEvents.map((e) => e.timestamp + '_' + e.type);
+                    const eventIds = recoveredEvents.map((e) => e.id);
                     this.removeProcessedEvents(eventIds);
                     if (body) {
                         this.emitEventsQueue(body);
@@ -29,19 +32,48 @@ class EventManager extends state_manager_1.StateManager {
                 }
             },
             onFailure: async () => {
-                utils_1.debugLog.warn('EventManager', 'Failed to recover persisted events');
+                (0, utils_1.log)('warn', 'Failed to recover persisted events');
             },
         });
     }
     track({ type, page_url, from_page_url, scroll_data, click_data, custom_event, web_vitals, error_data, session_end_reason, }) {
         if (!type) {
-            utils_1.debugLog.warn('EventManager', 'Event type is required');
+            (0, utils_1.log)('error', 'Event type is required - event will be ignored');
+            return;
+        }
+        // Check session BEFORE rate limiting to avoid consuming quota for buffered events
+        if (!this.get('sessionId')) {
+            // Protect against unbounded buffer growth during initialization delays
+            if (this.pendingEventsBuffer.length >= config_constants_1.MAX_PENDING_EVENTS_BUFFER) {
+                // Drop oldest event (FIFO) to make room for new one
+                this.pendingEventsBuffer.shift();
+                (0, utils_1.log)('warn', 'Pending events buffer full - dropping oldest event', {
+                    data: { maxBufferSize: config_constants_1.MAX_PENDING_EVENTS_BUFFER },
+                });
+            }
+            this.pendingEventsBuffer.push({
+                type,
+                page_url,
+                from_page_url,
+                scroll_data,
+                click_data,
+                custom_event,
+                web_vitals,
+                error_data,
+                session_end_reason,
+            });
+            return;
+        }
+        // Rate limiting check (except for critical events)
+        // Applied AFTER session check to only rate-limit processable events
+        const isCriticalEvent = type === types_1.EventType.SESSION_START || type === types_1.EventType.SESSION_END;
+        if (!isCriticalEvent && !this.checkRateLimit()) {
+            // Rate limit exceeded - drop event silently
+            // Logging would itself cause performance issues
             return;
         }
         const eventType = type;
         const isSessionStart = eventType === types_1.EventType.SESSION_START;
-        const isSessionEnd = eventType === types_1.EventType.SESSION_END;
-        const isCriticalEvent = isSessionStart || isSessionEnd;
         const currentPageUrl = page_url || this.get('pageUrl');
         const payload = this.buildEventPayload({
             type: eventType,
@@ -54,21 +86,18 @@ class EventManager extends state_manager_1.StateManager {
             error_data,
             session_end_reason,
         });
-        if (this.isEventExcluded(payload)) {
-            return;
-        }
         if (!isCriticalEvent && !this.shouldSample()) {
             return;
         }
         if (isSessionStart) {
             const currentSessionId = this.get('sessionId');
             if (!currentSessionId) {
-                utils_1.debugLog.warn('EventManager', 'Session start event ignored: missing sessionId');
+                (0, utils_1.log)('error', 'Session start event requires sessionId - event will be ignored');
                 return;
             }
             if (this.get('hasStartSession')) {
-                utils_1.debugLog.warn('EventManager', 'Duplicate session_start detected', {
-                    sessionId: currentSessionId,
+                (0, utils_1.log)('warn', 'Duplicate session_start detected', {
+                    data: { sessionId: currentSessionId },
                 });
                 return;
             }
@@ -77,6 +106,14 @@ class EventManager extends state_manager_1.StateManager {
         if (this.isDuplicateEvent(payload)) {
             return;
         }
+        if (this.get('mode') === types_1.Mode.QA && eventType === types_1.EventType.CUSTOM && custom_event) {
+            console.log('[TraceLog] Event', {
+                name: custom_event.name,
+                ...(custom_event.metadata && { metadata: custom_event.metadata }),
+            });
+            this.emitEvent(payload);
+            return;
+        }
         this.addToQueue(payload);
     }
     stop() {
@@ -85,8 +122,11 @@ class EventManager extends state_manager_1.StateManager {
             this.sendIntervalId = null;
         }
         this.eventsQueue = [];
+        this.pendingEventsBuffer = [];
         this.lastEventFingerprint = null;
         this.lastEventTime = 0;
+        this.rateLimitCounter = 0;
+        this.rateLimitWindowStart = 0;
         this.dataSender.stop();
     }
     async flushImmediately() {
@@ -98,6 +138,27 @@ class EventManager extends state_manager_1.StateManager {
     getQueueLength() {
         return this.eventsQueue.length;
     }
+    flushPendingEvents() {
+        if (this.pendingEventsBuffer.length === 0) {
+            return;
+        }
+        const currentSessionId = this.get('sessionId');
+        if (!currentSessionId) {
+            // Keep events in buffer for future retry - do NOT discard
+            // This prevents data loss during legitimate race conditions
+            (0, utils_1.log)('warn', 'Cannot flush pending events: session not initialized - keeping in buffer', {
+                data: { bufferedEventCount: this.pendingEventsBuffer.length },
+            });
+            return;
+        }
+        // Create copy before clearing to avoid infinite recursion
+        const bufferedEvents = [...this.pendingEventsBuffer];
+        this.pendingEventsBuffer = [];
+        // Process all buffered events now that session exists
+        bufferedEvents.forEach((event) => {
+            this.track(event);
+        });
+    }
     clearSendInterval() {
         if (this.sendIntervalId) {
             clearInterval(this.sendIntervalId);
@@ -110,7 +171,7 @@ class EventManager extends state_manager_1.StateManager {
         }
         const body = this.buildEventsPayload();
         const eventsToSend = [...this.eventsQueue];
-        const eventIds = eventsToSend.map((e) => `${e.timestamp}_${e.type}`);
+        const eventIds = eventsToSend.map((e) => e.id);
         if (isSync) {
             const success = this.dataSender.sendEventsQueueSync(body);
             if (success) {
@@ -128,8 +189,8 @@ class EventManager extends state_manager_1.StateManager {
                     this.emitEventsQueue(body);
                 },
                 onFailure: () => {
-                    utils_1.debugLog.warn('EventManager', 'Async flush failed', {
-                        eventCount: eventsToSend.length,
+                    (0, utils_1.log)('warn', 'Async flush failed', {
+                        data: { eventCount: eventsToSend.length },
                     });
                 },
             });
@@ -141,15 +202,15 @@ class EventManager extends state_manager_1.StateManager {
         }
         const body = this.buildEventsPayload();
         const eventsToSend = [...this.eventsQueue];
-        const eventIds = eventsToSend.map((e) => `${e.timestamp}_${e.type}`);
+        const eventIds = eventsToSend.map((e) => e.id);
         await this.dataSender.sendEventsQueue(body, {
             onSuccess: () => {
                 this.removeProcessedEvents(eventIds);
                 this.emitEventsQueue(body);
             },
             onFailure: async () => {
-                utils_1.debugLog.warn('EventManager', 'Events send failed, keeping in queue', {
-                    eventCount: eventsToSend.length,
+                (0, utils_1.log)('warn', 'Events send failed, keeping in queue', {
+                    data: { eventCount: eventsToSend.length },
                 });
             },
         });
@@ -180,6 +241,7 @@ class EventManager extends state_manager_1.StateManager {
         const isSessionStart = data.type === types_1.EventType.SESSION_START;
         const currentPageUrl = data.page_url ?? this.get('pageUrl');
         const payload = {
+            id: (0, utils_1.generateEventId)(),
             type: data.type,
             page_url: currentPageUrl,
             timestamp: Date.now(),
@@ -193,23 +255,8 @@ class EventManager extends state_manager_1.StateManager {
             ...(data.session_end_reason && { session_end_reason: data.session_end_reason }),
             ...(isSessionStart && (0, utils_1.getUTMParameters)() && { utm: (0, utils_1.getUTMParameters)() }),
         };
-        const projectTags = this.get('config')?.tags;
-        if (projectTags?.length) {
-            payload.tags = projectTags;
-        }
         return payload;
     }
-    isEventExcluded(event) {
-        const config = this.get('config');
-        const isRouteExcluded = (0, utils_1.isUrlPathExcluded)(event.page_url, config?.excludedUrlPaths ?? []);
-        const hasStartSession = this.get('hasStartSession');
-        const isSessionEndEvent = event.type === types_1.EventType.SESSION_END;
-        const isSessionStartEvent = event.type === types_1.EventType.SESSION_START;
-        if (isRouteExcluded && !isSessionStartEvent && !(isSessionEndEvent && hasStartSession)) {
-            return true;
-        }
-        return config?.ipExcluded === true;
-    }
     isDuplicateEvent(event) {
         const now = Date.now();
         const fingerprint = this.createEventFingerprint(event);
@@ -250,11 +297,13 @@ class EventManager extends state_manager_1.StateManager {
         if (this.eventsQueue.length > config_constants_1.MAX_EVENTS_QUEUE_LENGTH) {
             const nonCriticalIndex = this.eventsQueue.findIndex((e) => e.type !== types_1.EventType.SESSION_START && e.type !== types_1.EventType.SESSION_END);
             const removedEvent = nonCriticalIndex >= 0 ? this.eventsQueue.splice(nonCriticalIndex, 1)[0] : this.eventsQueue.shift();
-            utils_1.debugLog.warn('EventManager', 'Event queue overflow, oldest non-critical event removed', {
-                maxLength: config_constants_1.MAX_EVENTS_QUEUE_LENGTH,
-                currentLength: this.eventsQueue.length,
-                removedEventType: removedEvent?.type,
-                wasCritical: removedEvent?.type === types_1.EventType.SESSION_START || removedEvent?.type === types_1.EventType.SESSION_END,
+            (0, utils_1.log)('warn', 'Event queue overflow, oldest non-critical event removed', {
+                data: {
+                    maxLength: config_constants_1.MAX_EVENTS_QUEUE_LENGTH,
+                    currentLength: this.eventsQueue.length,
+                    removedEventType: removedEvent?.type,
+                    wasCritical: removedEvent?.type === types_1.EventType.SESSION_START || removedEvent?.type === types_1.EventType.SESSION_END,
+                },
             });
         }
         if (!this.sendIntervalId) {
@@ -271,7 +320,7 @@ class EventManager extends state_manager_1.StateManager {
     }
     handleGoogleAnalyticsIntegration(event) {
         if (this.googleAnalytics && event.type === types_1.EventType.CUSTOM && event.custom_event) {
-            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
+            if (this.get('mode') === types_1.Mode.QA) {
                 return;
             }
             this.googleAnalytics.trackEvent(event.custom_event.name, event.custom_event.metadata ?? {});
@@ -281,11 +330,25 @@ class EventManager extends state_manager_1.StateManager {
         const samplingRate = this.get('config')?.samplingRate ?? 1;
         return Math.random() < samplingRate;
     }
+    checkRateLimit() {
+        const now = Date.now();
+        // Reset counter if window has expired
+        if (now - this.rateLimitWindowStart > config_constants_1.RATE_LIMIT_WINDOW_MS) {
+            this.rateLimitCounter = 0;
+            this.rateLimitWindowStart = now;
+        }
+        // Check if limit exceeded
+        if (this.rateLimitCounter >= config_constants_1.MAX_EVENTS_PER_SECOND) {
+            return false;
+        }
+        // Increment counter
+        this.rateLimitCounter++;
+        return true;
+    }
     removeProcessedEvents(eventIds) {
         const eventIdSet = new Set(eventIds);
         this.eventsQueue = this.eventsQueue.filter((event) => {
-            const eventId = `${event.timestamp}_${event.type}`;
-            return !eventIdSet.has(eventId);
+            return !eventIdSet.has(event.id);
         });
     }
     emitEvent(eventData) {