@tracelog/lib 0.0.8 → 0.2.0

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

@@ -1,504 +1,353 @@
-import { EVENT_SENT_INTERVAL_MS, EVENT_SENT_INTERVAL_TEST_MS, MAX_EVENTS_QUEUE_LENGTH, DUPLICATE_EVENT_THRESHOLD_MS, CIRCUIT_BREAKER_CONSTANTS, MAX_FINGERPRINTS, FINGERPRINT_CLEANUP_MULTIPLIER, CLICK_COORDINATE_PRECISION, EVENT_PERSISTENCE_MAX_AGE_MS, } from '../constants';
-import { EventType } from '../types';
-import { getUTMParameters, isUrlPathExcluded } from '../utils';
-import { debugLog } from '../utils/logging';
+import { EVENT_SENT_INTERVAL_MS, MAX_EVENTS_QUEUE_LENGTH, DUPLICATE_EVENT_THRESHOLD_MS, } from '../constants/config.constants';
+import { EmitterEvent, EventType } from '../types';
+import { getUTMParameters, isUrlPathExcluded, debugLog } from '../utils';
 import { SenderManager } from './sender.manager';
-import { SamplingManager } from './sampling.manager';
 import { StateManager } from './state.manager';
-import { TagsManager } from './tags.manager';
+/**
+ * EventManager - Core event tracking and queue management
+ *
+ * Responsibilities:
+ * - Track user events (clicks, scrolls, page views, custom events)
+ * - Queue events and batch send them to the analytics API
+ * - Handle deduplication of similar events
+ * - Manage event sending intervals and retry logic
+ * - Integrate with Google Analytics when configured
+ */
 export class EventManager extends StateManager {
-    constructor(storeManager, googleAnalytics = null) {
+    constructor(storeManager, googleAnalytics = null, emitter = null) {
         super();
         this.eventsQueue = [];
-        this.lastEvent = null;
-        this.eventsQueueIntervalId = null;
-        this.intervalActive = false;
-        // Circuit breaker properties
-        this.failureCount = 0;
-        this.MAX_FAILURES = CIRCUIT_BREAKER_CONSTANTS.MAX_FAILURES;
-        this.circuitOpen = false;
-        this.circuitOpenTime = 0;
-        this.backoffDelay = CIRCUIT_BREAKER_CONSTANTS.INITIAL_BACKOFF_DELAY_MS;
-        this.circuitResetTimeoutId = null;
-        // Event deduplication properties
-        this.eventFingerprints = new Map();
-        // Persistence storage key
-        this.PERSISTENCE_KEY = 'tl:circuit_breaker_events';
-        this.storageManager = storeManager;
+        this.lastEventFingerprint = null;
+        this.lastEventTime = 0;
+        this.sendIntervalId = null;
         this.googleAnalytics = googleAnalytics;
-        this.samplingManager = new SamplingManager();
-        this.tagsManager = new TagsManager();
         this.dataSender = new SenderManager(storeManager);
-        // Restore any persisted events on initialization
-        this.restoreEventsFromStorage();
-        debugLog.debug('EventManager', 'EventManager initialized', {
-            hasGoogleAnalytics: !!googleAnalytics,
-            restoredEventsCount: this.eventsQueue.length,
-        });
+        this.emitter = emitter;
     }
-    track({ type, page_url, from_page_url, scroll_data, click_data, custom_event, web_vitals, session_end_reason, session_start_recovered, }) {
-        debugLog.info('EventManager', `📥 Event captured: ${type}`, {
-            type,
-            page_url,
-            hasCustomEvent: !!custom_event,
-            hasClickData: !!click_data,
-            hasScrollData: !!scroll_data,
-            hasWebVitals: !!web_vitals,
+    /**
+     * Recovers persisted events from localStorage
+     * Should be called after initialization to recover any events that failed to send
+     */
+    async recoverPersistedEvents() {
+        await this.dataSender.recoverPersistedEvents({
+            onSuccess: (_eventCount, recoveredEvents) => {
+                if (recoveredEvents && recoveredEvents.length > 0) {
+                    const eventIds = recoveredEvents.map((e) => e.timestamp + '_' + e.type);
+                    this.removeProcessedEvents(eventIds);
+                }
+            },
+            onFailure: async () => {
+                debugLog.warn('EventManager', 'Failed to recover persisted events');
+            },
         });
-        if (!this.samplingManager.shouldSampleEvent(type, web_vitals)) {
-            debugLog.debug('EventManager', 'Event filtered by sampling', { type, samplingActive: true });
+    }
+    /**
+     * Track user events with automatic deduplication and queueing
+     */
+    track({ type, page_url, from_page_url, scroll_data, click_data, custom_event, web_vitals, error_data, session_end_reason, session_start_recovered, }) {
+        if (!type) {
+            debugLog.warn('EventManager', 'Event type is required');
             return;
         }
-        const isDuplicatedEvent = this.isDuplicatedEvent({
-            type,
-            page_url,
+        const eventType = type;
+        const isSessionStart = eventType === EventType.SESSION_START;
+        const isSessionEnd = eventType === EventType.SESSION_END;
+        const isCriticalEvent = isSessionStart || isSessionEnd;
+        // Build event payload
+        const currentPageUrl = page_url || this.get('pageUrl');
+        const payload = this.buildEventPayload({
+            type: eventType,
+            page_url: currentPageUrl,
+            from_page_url,
             scroll_data,
             click_data,
             custom_event,
             web_vitals,
+            error_data,
             session_end_reason,
             session_start_recovered,
         });
-        if (isDuplicatedEvent) {
-            const now = Date.now();
-            if (this.eventsQueue && this.eventsQueue.length > 0) {
-                const lastEvent = this.eventsQueue.at(-1);
-                if (lastEvent) {
-                    lastEvent.timestamp = now;
-                }
-            }
-            if (this.lastEvent) {
-                this.lastEvent.timestamp = now;
-            }
-            debugLog.debug('EventManager', 'Duplicate event detected, timestamp updated', {
-                type,
-                queueLength: this.eventsQueue.length,
-            });
+        // Check URL exclusions
+        if (this.isEventExcluded(payload)) {
             return;
         }
-        const effectivePageUrl = page_url || this.get('pageUrl');
-        const isRouteExcluded = isUrlPathExcluded(effectivePageUrl, this.get('config').excludedUrlPaths);
-        const hasStartSession = this.get('hasStartSession');
-        const isSessionEndEvent = type == EventType.SESSION_END;
-        if (isRouteExcluded && (!isSessionEndEvent || (isSessionEndEvent && !hasStartSession))) {
-            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                debugLog.debug('EventManager', `Event ${type} on excluded route: ${page_url}`);
-            }
+        // Skip sampling for critical events, apply for the rest
+        if (!isCriticalEvent && !this.shouldSample()) {
             return;
         }
-        const isSessionStartEvent = type === EventType.SESSION_START;
-        if (isSessionStartEvent) {
+        if (isSessionStart) {
+            const currentSessionId = this.get('sessionId');
+            if (!currentSessionId) {
+                debugLog.warn('EventManager', 'Session start event ignored: missing sessionId');
+                return;
+            }
+            if (this.get('hasStartSession')) {
+                debugLog.warn('EventManager', 'Duplicate session_start detected', {
+                    sessionId: currentSessionId,
+                });
+                return;
+            }
             this.set('hasStartSession', true);
         }
-        const utmParams = isSessionStartEvent ? getUTMParameters() : undefined;
-        const payload = {
-            type: type,
-            page_url: isRouteExcluded ? 'excluded' : effectivePageUrl,
-            timestamp: Date.now(),
-            ...(isSessionStartEvent && { referrer: document.referrer || 'Direct' }),
-            ...(from_page_url && !isRouteExcluded ? { from_page_url } : {}),
-            ...(scroll_data && { scroll_data }),
-            ...(click_data && { click_data }),
-            ...(custom_event && { custom_event }),
-            ...(utmParams && { utm: utmParams }),
-            ...(web_vitals && { web_vitals }),
-            ...(session_end_reason && { session_end_reason }),
-            ...(session_start_recovered && { session_start_recovered }),
-        };
-        if (this.get('config')?.tags?.length) {
-            const matchedTags = this.tagsManager.getEventTagsIds(payload, this.get('device'));
-            if (matchedTags?.length) {
-                payload.tags =
-                    this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug'
-                        ? matchedTags.map((id) => ({
-                            id,
-                            key: this.get('config')?.tags?.find((t) => t.id === id)?.key ?? '',
-                        }))
-                        : matchedTags;
-            }
+        // Check for duplicates
+        if (this.isDuplicateEvent(payload)) {
+            return;
         }
-        this.lastEvent = payload;
-        this.processAndSend(payload);
+        // Add to queue and schedule sending
+        this.addToQueue(payload);
     }
     stop() {
-        // Clear interval and reset interval state
-        if (this.eventsQueueIntervalId) {
-            clearInterval(this.eventsQueueIntervalId);
-            this.eventsQueueIntervalId = null;
-            this.intervalActive = false;
+        // Clear interval
+        if (this.sendIntervalId) {
+            clearInterval(this.sendIntervalId);
+            this.sendIntervalId = null;
         }
-        // Clean up circuit breaker timeout
-        if (this.circuitResetTimeoutId) {
-            clearTimeout(this.circuitResetTimeoutId);
-            this.circuitResetTimeoutId = null;
-        }
-        // Persist any remaining events before stopping
-        if (this.eventsQueue.length > 0) {
-            this.persistEventsToStorage();
-        }
-        // Clean up all state variables
-        this.eventFingerprints.clear();
-        this.circuitOpen = false;
-        this.circuitOpenTime = 0;
-        this.failureCount = 0;
-        this.backoffDelay = CIRCUIT_BREAKER_CONSTANTS.INITIAL_BACKOFF_DELAY_MS;
-        this.lastEvent = null;
-        // Stop the data sender to clean up retry timeouts
+        // Reset state
+        this.eventsQueue = [];
+        this.lastEventFingerprint = null;
+        this.lastEventTime = 0;
+        // Stop sender
         this.dataSender.stop();
     }
-    processAndSend(payload) {
-        debugLog.info('EventManager', `🔄 Event processed and queued: ${payload.type}`, {
-            type: payload.type,
-            timestamp: payload.timestamp,
-            page_url: payload.page_url,
-            queueLengthBefore: this.eventsQueue.length,
-        });
-        if (this.get('config').ipExcluded) {
-            debugLog.info('EventManager', `❌ Event blocked: IP excluded`);
-            return;
-        }
-        this.eventsQueue.push(payload);
-        if (this.eventsQueue.length > MAX_EVENTS_QUEUE_LENGTH) {
-            const removedEvent = this.eventsQueue.shift();
-            debugLog.warn('EventManager', 'Event queue overflow, oldest event removed', {
-                maxLength: MAX_EVENTS_QUEUE_LENGTH,
-                currentLength: this.eventsQueue.length,
-                removedEventType: removedEvent?.type,
-            });
-        }
-        if (!this.eventsQueueIntervalId) {
-            this.initEventsQueueInterval();
-            debugLog.info('EventManager', `⏰ Event sender initialized - queue will be sent periodically`, {
-                queueLength: this.eventsQueue.length,
-            });
-        }
-        if (this.googleAnalytics && payload.type === EventType.CUSTOM) {
-            const customEvent = payload.custom_event;
-            this.trackGoogleAnalyticsEvent(customEvent);
-        }
-    }
-    trackGoogleAnalyticsEvent(customEvent) {
-        if (this.get('config').mode === 'qa' || this.get('config').mode === 'debug') {
-            debugLog.debug('EventManager', `Google Analytics event: ${JSON.stringify(customEvent)}`);
-        }
-        else if (this.googleAnalytics) {
-            this.googleAnalytics.trackEvent(customEvent.name, customEvent.metadata ?? {});
-        }
-    }
-    initEventsQueueInterval() {
-        if (this.eventsQueueIntervalId || this.intervalActive) {
-            return;
-        }
-        const interval = this.get('config')?.id === 'test' ? EVENT_SENT_INTERVAL_TEST_MS : EVENT_SENT_INTERVAL_MS;
-        this.eventsQueueIntervalId = window.setInterval(() => {
-            if (this.eventsQueue.length > 0) {
-                this.sendEventsQueue();
-            }
-        }, interval);
-        this.intervalActive = true;
-    }
+    /**
+     * Flush all queued events immediately (async)
+     */
     async flushImmediately() {
-        if (this.eventsQueue.length === 0) {
-            return true;
-        }
-        const body = this.buildEventsPayload();
-        const success = await this.dataSender.sendEventsQueueAsync(body);
-        if (success) {
-            this.eventsQueue = [];
-            this.clearQueueInterval();
-        }
-        return success;
+        return this.flushEvents(false);
     }
+    /**
+     * Flush all queued events immediately (sync)
+     */
     flushImmediatelySync() {
-        if (this.eventsQueue.length === 0) {
-            return true;
-        }
-        const body = this.buildEventsPayload();
-        const success = this.dataSender.sendEventsQueueSync(body);
-        if (success) {
-            this.eventsQueue = [];
-            this.clearQueueInterval();
-        }
-        return success;
+        return this.flushEvents(true);
     }
+    /**
+     * Queue management and sending intervals
+     */
     getQueueLength() {
         return this.eventsQueue.length;
     }
-    sendEventsQueue() {
-        if (this.eventsQueue.length === 0) {
-            return;
-        }
-        debugLog.info('EventManager', `📤 Preparing to send event queue`, {
-            queueLength: this.eventsQueue.length,
-            hasSessionId: !!this.get('sessionId'),
-            circuitOpen: this.circuitOpen,
-        });
-        // Circuit breaker: check if it should be reset or continue blocking
-        if (this.circuitOpen) {
-            const timeSinceOpen = Date.now() - this.circuitOpenTime;
-            if (timeSinceOpen >= CIRCUIT_BREAKER_CONSTANTS.RECOVERY_TIME_MS) {
-                this.resetCircuitBreaker();
-                debugLog.info('EventManager', 'Circuit breaker reset after timeout', {
-                    timeSinceOpen,
-                    recoveryTime: CIRCUIT_BREAKER_CONSTANTS.RECOVERY_TIME_MS,
-                });
-            }
-            else {
-                debugLog.debug('EventManager', 'Circuit breaker is open - skipping event sending', {
-                    queueLength: this.eventsQueue.length,
-                    failureCount: this.failureCount,
-                    timeSinceOpen,
-                    recoveryTime: CIRCUIT_BREAKER_CONSTANTS.RECOVERY_TIME_MS,
-                });
-                return;
-            }
+    clearSendInterval() {
+        if (this.sendIntervalId) {
+            clearInterval(this.sendIntervalId);
+            this.sendIntervalId = null;
         }
-        if (!this.get('sessionId')) {
-            debugLog.info('EventManager', `⏳ Queue waiting: ${this.eventsQueue.length} events waiting for active session`);
-            return;
+    }
+    /**
+     * Shared flush implementation for both sync and async modes
+     */
+    flushEvents(isSync) {
+        if (this.eventsQueue.length === 0) {
+            return isSync ? true : Promise.resolve(true);
         }
         const body = this.buildEventsPayload();
-        const success = this.dataSender.sendEventsQueue(body);
-        if (success) {
-            debugLog.info('EventManager', `✅ Event queue sent successfully`, {
-                eventsCount: body.events.length,
-                sessionId: body.session_id,
-                uniqueEventsAfterDedup: body.events.length,
-            });
-            this.eventsQueue = [];
-            this.failureCount = 0;
-            this.backoffDelay = CIRCUIT_BREAKER_CONSTANTS.INITIAL_BACKOFF_DELAY_MS;
-            // Clear any persisted events on successful send
-            this.clearPersistedEvents();
+        const eventsToSend = [...this.eventsQueue];
+        const eventIds = eventsToSend.map((e) => `${e.timestamp}_${e.type}`);
+        if (isSync) {
+            const success = this.dataSender.sendEventsQueueSync(body);
+            if (success) {
+                this.removeProcessedEvents(eventIds);
+                this.clearSendInterval();
+            }
+            return success;
         }
         else {
-            debugLog.info('EventManager', `❌ Failed to send event queue`, {
-                eventsCount: body.events.length,
-                failureCount: this.failureCount + 1,
-                willOpenCircuit: this.failureCount + 1 >= this.MAX_FAILURES,
+            return this.dataSender.sendEventsQueue(body, {
+                onSuccess: () => {
+                    this.removeProcessedEvents(eventIds);
+                    this.clearSendInterval();
+                    this.emitEventsQueue(body);
+                },
+                onFailure: () => {
+                    debugLog.warn('EventManager', 'Async flush failed', {
+                        eventCount: eventsToSend.length,
+                    });
+                },
             });
-            // Persist failed events for recovery instead of restoring queue to prevent duplicates
-            this.persistEventsToStorage();
-            this.eventsQueue = [];
-            this.failureCount++;
-            if (this.failureCount >= this.MAX_FAILURES) {
-                this.openCircuitBreaker();
-            }
         }
     }
+    /**
+     * Send queued events to the API
+     */
+    async sendEventsQueue() {
+        if (!this.get('sessionId') || this.eventsQueue.length === 0) {
+            return;
+        }
+        const body = this.buildEventsPayload();
+        const eventsToSend = [...this.eventsQueue];
+        const eventIds = eventsToSend.map((e) => `${e.timestamp}_${e.type}`);
+        await this.dataSender.sendEventsQueue(body, {
+            onSuccess: () => {
+                this.removeProcessedEvents(eventIds);
+                this.emitEventsQueue(body);
+            },
+            onFailure: async () => {
+                debugLog.warn('EventManager', 'Events send failed, keeping in queue', {
+                    eventCount: eventsToSend.length,
+                });
+            },
+        });
+    }
+    /**
+     * Build the payload for sending events to the API
+     * Includes basic deduplication and sorting
+     */
     buildEventsPayload() {
-        const uniqueEvents = new Map();
+        const eventMap = new Map();
+        const order = [];
         for (const event of this.eventsQueue) {
-            let key = `${event.type}_${event.page_url}`;
-            if (event.click_data) {
-                key += `_${event.click_data.x}_${event.click_data.y}`;
-            }
-            if (event.scroll_data) {
-                key += `_${event.scroll_data.depth}_${event.scroll_data.direction}`;
-            }
-            if (event.custom_event) {
-                key += `_${event.custom_event.name}`;
-            }
-            if (event.web_vitals) {
-                key += `_${event.web_vitals.type}`;
-            }
-            if (!uniqueEvents.has(key)) {
-                uniqueEvents.set(key, event);
+            const signature = this.createEventSignature(event);
+            if (!eventMap.has(signature)) {
+                order.push(signature);
             }
+            eventMap.set(signature, event);
         }
-        const deduplicatedEvents = [...uniqueEvents.values()];
-        deduplicatedEvents.sort((a, b) => a.timestamp - b.timestamp);
+        const events = order
+            .map((signature) => eventMap.get(signature))
+            .filter((event) => Boolean(event))
+            .sort((a, b) => a.timestamp - b.timestamp);
         return {
             user_id: this.get('userId'),
             session_id: this.get('sessionId'),
             device: this.get('device'),
-            events: deduplicatedEvents,
+            events,
             ...(this.get('config')?.globalMetadata && { global_metadata: this.get('config')?.globalMetadata }),
         };
     }
-    clearQueueInterval() {
-        if (this.eventsQueueIntervalId) {
-            clearInterval(this.eventsQueueIntervalId);
-            this.eventsQueueIntervalId = null;
-            this.intervalActive = false;
+    /**
+     * Helper methods for event processing
+     */
+    buildEventPayload(data) {
+        const isSessionStart = data.type === EventType.SESSION_START;
+        const currentPageUrl = data.page_url ?? this.get('pageUrl');
+        const payload = {
+            type: data.type,
+            page_url: currentPageUrl,
+            timestamp: Date.now(),
+            ...(isSessionStart && { referrer: document.referrer || 'Direct' }),
+            ...(data.from_page_url && { from_page_url: data.from_page_url }),
+            ...(data.scroll_data && { scroll_data: data.scroll_data }),
+            ...(data.click_data && { click_data: data.click_data }),
+            ...(data.custom_event && { custom_event: data.custom_event }),
+            ...(data.web_vitals && { web_vitals: data.web_vitals }),
+            ...(data.error_data && { error_data: data.error_data }),
+            ...(data.session_end_reason && { session_end_reason: data.session_end_reason }),
+            ...(data.session_start_recovered && { session_start_recovered: data.session_start_recovered }),
+            ...(isSessionStart && getUTMParameters() && { utm: getUTMParameters() }),
+        };
+        // Add project tags
+        const projectTags = this.get('config')?.tags;
+        if (projectTags?.length) {
+            payload.tags = projectTags;
         }
+        return payload;
     }
-    getEventFingerprint(event) {
-        const key = `${event.type}_${event.page_url}`;
-        if (event.click_data) {
-            // Round coordinates to reduce false positives
-            const x = Math.round((event.click_data.x || 0) / CLICK_COORDINATE_PRECISION) * CLICK_COORDINATE_PRECISION;
-            const y = Math.round((event.click_data.y || 0) / CLICK_COORDINATE_PRECISION) * CLICK_COORDINATE_PRECISION;
-            return `${key}_${x}_${y}_${event.click_data.tag}_${event.click_data.id}`;
-        }
-        if (event.scroll_data) {
-            return `${key}_${event.scroll_data.depth}_${event.scroll_data.direction}`;
-        }
-        if (event.custom_event) {
-            return `${key}_${event.custom_event.name}`;
-        }
-        if (event.web_vitals) {
-            return `${key}_${event.web_vitals.type}`;
-        }
-        if (event.session_end_reason) {
-            return `${key}_${event.session_end_reason}`;
-        }
-        if (event.session_start_recovered !== undefined) {
-            return `${key}_${event.session_start_recovered}`;
+    isEventExcluded(event) {
+        const config = this.get('config');
+        const isRouteExcluded = isUrlPathExcluded(event.page_url, config?.excludedUrlPaths ?? []);
+        const hasStartSession = this.get('hasStartSession');
+        const isSessionEndEvent = event.type === EventType.SESSION_END;
+        const isSessionStartEvent = event.type === EventType.SESSION_START;
+        if (isRouteExcluded && !isSessionStartEvent && !(isSessionEndEvent && hasStartSession)) {
+            return true;
         }
-        return key;
+        return config?.ipExcluded === true;
     }
-    isDuplicatedEvent(event) {
-        const fingerprint = this.getEventFingerprint(event);
-        const lastTime = this.eventFingerprints.get(fingerprint) ?? 0;
+    isDuplicateEvent(event) {
         const now = Date.now();
-        if (now - lastTime < DUPLICATE_EVENT_THRESHOLD_MS) {
+        const fingerprint = this.createEventFingerprint(event);
+        // Check if this is a duplicate within the threshold
+        if (this.lastEventFingerprint === fingerprint && now - this.lastEventTime < DUPLICATE_EVENT_THRESHOLD_MS) {
             return true;
         }
-        this.eventFingerprints.set(fingerprint, now);
-        // Clean up old fingerprints to prevent memory leaks
-        this.cleanupOldFingerprints();
+        // Update tracking
+        this.lastEventFingerprint = fingerprint;
+        this.lastEventTime = now;
         return false;
     }
-    /**
-     * Cleans up old fingerprints to prevent memory leaks
-     */
-    cleanupOldFingerprints() {
-        if (this.eventFingerprints.size <= MAX_FINGERPRINTS) {
-            return;
+    createEventFingerprint(event) {
+        let fingerprint = `${event.type}_${event.page_url}`;
+        if (event.click_data) {
+            // Round coordinates to reduce false duplicates
+            const x = Math.round((event.click_data.x || 0) / 10) * 10;
+            const y = Math.round((event.click_data.y || 0) / 10) * 10;
+            fingerprint += `_click_${x}_${y}`;
         }
-        const now = Date.now();
-        const cleanupThreshold = DUPLICATE_EVENT_THRESHOLD_MS * FINGERPRINT_CLEANUP_MULTIPLIER;
-        const keysToDelete = [];
-        for (const [key, timestamp] of this.eventFingerprints) {
-            if (now - timestamp > cleanupThreshold) {
-                keysToDelete.push(key);
-            }
+        if (event.scroll_data) {
+            fingerprint += `_scroll_${event.scroll_data.depth}_${event.scroll_data.direction}`;
         }
-        // Delete old entries
-        for (const key of keysToDelete) {
-            this.eventFingerprints.delete(key);
+        if (event.custom_event) {
+            fingerprint += `_custom_${event.custom_event.name}`;
         }
-        debugLog.debug('EventManager', 'Cleaned up old event fingerprints', {
-            totalFingerprints: this.eventFingerprints.size + keysToDelete.length,
-            cleanedCount: keysToDelete.length,
-            remainingCount: this.eventFingerprints.size,
-            cleanupThreshold,
-        });
+        if (event.web_vitals) {
+            fingerprint += `_vitals_${event.web_vitals.type}`;
+        }
+        return fingerprint;
     }
-    /**
-     * Opens the circuit breaker with time-based recovery and event persistence
-     */
-    openCircuitBreaker() {
-        this.circuitOpen = true;
-        this.circuitOpenTime = Date.now();
-        // Persist events before clearing queue to prevent data loss
-        this.persistEventsToStorage();
-        const eventsCount = this.eventsQueue.length;
-        this.eventsQueue = []; // Clear memory queue
-        debugLog.warn('EventManager', 'Circuit breaker opened with time-based recovery', {
-            maxFailures: this.MAX_FAILURES,
-            persistedEvents: eventsCount,
-            failureCount: this.failureCount,
-            recoveryTime: CIRCUIT_BREAKER_CONSTANTS.RECOVERY_TIME_MS,
-            openTime: this.circuitOpenTime,
-        });
-        // Increase backoff for next failure
-        this.backoffDelay = Math.min(this.backoffDelay * CIRCUIT_BREAKER_CONSTANTS.BACKOFF_MULTIPLIER, CIRCUIT_BREAKER_CONSTANTS.MAX_BACKOFF_DELAY_MS);
+    createEventSignature(event) {
+        return this.createEventFingerprint(event);
     }
-    /**
-     * Resets the circuit breaker and attempts to restore persisted events
-     */
-    resetCircuitBreaker() {
-        this.circuitOpen = false;
-        this.circuitOpenTime = 0;
-        this.failureCount = 0;
-        this.circuitResetTimeoutId = null;
-        debugLog.info('EventManager', 'Circuit breaker reset - attempting to restore events', {
-            currentQueueLength: this.eventsQueue.length,
-        });
-        // Restore persisted events
-        this.restoreEventsFromStorage();
-        debugLog.info('EventManager', 'Circuit breaker reset completed', {
-            restoredQueueLength: this.eventsQueue.length,
-            backoffDelay: this.backoffDelay,
-        });
-    }
-    /**
-     * Persists current events queue to localStorage for recovery
-     */
-    persistEventsToStorage() {
-        try {
-            if (this.eventsQueue.length === 0) {
-                return;
-            }
-            const persistData = {
-                events: this.eventsQueue,
-                timestamp: Date.now(),
-                failureCount: this.failureCount,
-            };
-            this.storageManager.setItem(this.PERSISTENCE_KEY, JSON.stringify(persistData));
-            debugLog.debug('EventManager', 'Events persisted to storage for recovery', {
-                eventsCount: this.eventsQueue.length,
-                failureCount: this.failureCount,
+    addToQueue(event) {
+        this.eventsQueue.push(event);
+        debugLog.info('EventManager', 'Event added to queue', event);
+        this.emitEvent(event);
+        // Prevent queue overflow
+        if (this.eventsQueue.length > MAX_EVENTS_QUEUE_LENGTH) {
+            const removedEvent = this.eventsQueue.shift();
+            debugLog.warn('EventManager', 'Event queue overflow, oldest event removed', {
+                maxLength: MAX_EVENTS_QUEUE_LENGTH,
+                currentLength: this.eventsQueue.length,
+                removedEventType: removedEvent?.type,
             });
         }
-        catch (error) {
-            debugLog.warn('EventManager', 'Failed to persist events to storage', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-                eventsCount: this.eventsQueue.length,
-            });
+        if (!this.sendIntervalId) {
+            this.startSendInterval();
         }
+        // Google Analytics integration
+        this.handleGoogleAnalyticsIntegration(event);
     }
-    /**
-     * Restores events from localStorage if available and not expired
-     */
-    restoreEventsFromStorage() {
-        try {
-            const persistedData = this.storageManager.getItem(this.PERSISTENCE_KEY);
-            if (!persistedData) {
-                return;
+    startSendInterval() {
+        this.sendIntervalId = window.setInterval(() => {
+            if (this.eventsQueue.length > 0) {
+                this.sendEventsQueue();
             }
-            const parsed = JSON.parse(persistedData);
-            const now = Date.now();
-            const maxAge = EVENT_PERSISTENCE_MAX_AGE_MS;
-            // Check if persisted data is not too old
-            if (now - parsed.timestamp > maxAge) {
-                this.clearPersistedEvents();
-                debugLog.debug('EventManager', 'Cleared expired persisted events', {
-                    age: now - parsed.timestamp,
-                    maxAge,
-                });
-                return;
+        }, EVENT_SENT_INTERVAL_MS);
+    }
+    handleGoogleAnalyticsIntegration(event) {
+        if (this.googleAnalytics && event.type === EventType.CUSTOM && event.custom_event) {
+            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
+                // Skip GA tracking in QA/debug modes
             }
-            // Restore events if we don't already have events in queue
-            if (Array.isArray(parsed.events) && parsed.events.length > 0 && this.eventsQueue.length === 0) {
-                this.eventsQueue = parsed.events;
-                debugLog.info('EventManager', 'Restored events from storage', {
-                    restoredCount: parsed.events.length,
-                    originalFailureCount: parsed.failureCount ?? 0,
-                });
+            else {
+                this.googleAnalytics.trackEvent(event.custom_event.name, event.custom_event.metadata ?? {});
             }
         }
-        catch (error) {
-            debugLog.warn('EventManager', 'Failed to restore events from storage', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
-            this.clearPersistedEvents();
-        }
+    }
+    shouldSample() {
+        const samplingRate = this.get('config')?.samplingRate ?? 1;
+        return Math.random() < samplingRate;
+    }
+    removeProcessedEvents(eventIds) {
+        const eventIdSet = new Set(eventIds);
+        this.eventsQueue = this.eventsQueue.filter((event) => {
+            const eventId = `${event.timestamp}_${event.type}`;
+            return !eventIdSet.has(eventId);
+        });
     }
     /**
-     * Clears persisted events from localStorage
+     * Emit event for external listeners
      */
-    clearPersistedEvents() {
-        try {
-            this.storageManager.removeItem(this.PERSISTENCE_KEY);
-            debugLog.debug('EventManager', 'Cleared persisted events from storage');
+    emitEvent(eventData) {
+        if (this.emitter) {
+            this.emitter.emit(EmitterEvent.EVENT, eventData);
         }
-        catch (error) {
-            debugLog.warn('EventManager', 'Failed to clear persisted events', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
+    }
+    /**
+     * Emit events queue for external listeners
+     */
+    emitEventsQueue(queue) {
+        if (this.emitter) {
+            this.emitter.emit(EmitterEvent.QUEUE, queue);
         }
     }
 }