@tracelog/lib 0.4.0 → 0.5.0

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

@@ -6,16 +6,6 @@ const types_1 = require("../types");
 const utils_1 = require("../utils");
 const sender_manager_1 = require("./sender.manager");
 const state_manager_1 = require("./state.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
- */
 class EventManager extends state_manager_1.StateManager {
     constructor(storeManager, googleAnalytics = null, emitter = null) {
         super();
@@ -27,16 +17,15 @@ class EventManager extends state_manager_1.StateManager {
         this.dataSender = new sender_manager_1.SenderManager(storeManager);
         this.emitter = emitter;
     }
-    /**
-     * 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) => {
+            onSuccess: (_eventCount, recoveredEvents, body) => {
                 if (recoveredEvents && recoveredEvents.length > 0) {
                     const eventIds = recoveredEvents.map((e) => e.timestamp + '_' + e.type);
                     this.removeProcessedEvents(eventIds);
+                    if (body) {
+                        this.emitEventsQueue(body);
+                    }
                 }
             },
             onFailure: async () => {
@@ -44,10 +33,7 @@ class EventManager extends state_manager_1.StateManager {
             },
         });
     }
-    /**
-     * 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, }) {
+    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');
             return;
@@ -56,7 +42,6 @@ class EventManager extends state_manager_1.StateManager {
         const isSessionStart = eventType === types_1.EventType.SESSION_START;
         const isSessionEnd = eventType === types_1.EventType.SESSION_END;
         const isCriticalEvent = isSessionStart || isSessionEnd;
-        // Build event payload
         const currentPageUrl = page_url || this.get('pageUrl');
         const payload = this.buildEventPayload({
             type: eventType,
@@ -68,13 +53,10 @@ class EventManager extends state_manager_1.StateManager {
             web_vitals,
             error_data,
             session_end_reason,
-            session_start_recovered,
         });
-        // Check URL exclusions
         if (this.isEventExcluded(payload)) {
             return;
         }
-        // Skip sampling for critical events, apply for the rest
         if (!isCriticalEvent && !this.shouldSample()) {
             return;
         }
@@ -92,41 +74,27 @@ class EventManager extends state_manager_1.StateManager {
             }
             this.set('hasStartSession', true);
         }
-        // Check for duplicates
         if (this.isDuplicateEvent(payload)) {
             return;
         }
-        // Add to queue and schedule sending
         this.addToQueue(payload);
     }
     stop() {
-        // Clear interval
         if (this.sendIntervalId) {
             clearInterval(this.sendIntervalId);
             this.sendIntervalId = null;
         }
-        // Reset state
         this.eventsQueue = [];
         this.lastEventFingerprint = null;
         this.lastEventTime = 0;
-        // Stop sender
         this.dataSender.stop();
     }
-    /**
-     * Flush all queued events immediately (async)
-     */
     async flushImmediately() {
         return this.flushEvents(false);
     }
-    /**
-     * Flush all queued events immediately (sync)
-     */
     flushImmediatelySync() {
         return this.flushEvents(true);
     }
-    /**
-     * Queue management and sending intervals
-     */
     getQueueLength() {
         return this.eventsQueue.length;
     }
@@ -136,9 +104,6 @@ class EventManager extends state_manager_1.StateManager {
             this.sendIntervalId = null;
         }
     }
-    /**
-     * Shared flush implementation for both sync and async modes
-     */
     flushEvents(isSync) {
         if (this.eventsQueue.length === 0) {
             return isSync ? true : Promise.resolve(true);
@@ -151,6 +116,7 @@ class EventManager extends state_manager_1.StateManager {
             if (success) {
                 this.removeProcessedEvents(eventIds);
                 this.clearSendInterval();
+                this.emitEventsQueue(body);
             }
             return success;
         }
@@ -169,9 +135,6 @@ class EventManager extends state_manager_1.StateManager {
             });
         }
     }
-    /**
-     * Send queued events to the API
-     */
     async sendEventsQueue() {
         if (!this.get('sessionId') || this.eventsQueue.length === 0) {
             return;
@@ -191,10 +154,6 @@ class EventManager extends state_manager_1.StateManager {
             },
         });
     }
-    /**
-     * Build the payload for sending events to the API
-     * Includes basic deduplication and sorting
-     */
     buildEventsPayload() {
         const eventMap = new Map();
         const order = [];
@@ -217,9 +176,6 @@ class EventManager extends state_manager_1.StateManager {
             ...(this.get('config')?.globalMetadata && { global_metadata: this.get('config')?.globalMetadata }),
         };
     }
-    /**
-     * Helper methods for event processing
-     */
     buildEventPayload(data) {
         const isSessionStart = data.type === types_1.EventType.SESSION_START;
         const currentPageUrl = data.page_url ?? this.get('pageUrl');
@@ -235,10 +191,8 @@ class EventManager extends state_manager_1.StateManager {
             ...(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 && (0, utils_1.getUTMParameters)() && { utm: (0, utils_1.getUTMParameters)() }),
         };
-        // Add project tags
         const projectTags = this.get('config')?.tags;
         if (projectTags?.length) {
             payload.tags = projectTags;
@@ -259,11 +213,9 @@ class EventManager extends state_manager_1.StateManager {
     isDuplicateEvent(event) {
         const now = Date.now();
         const fingerprint = this.createEventFingerprint(event);
-        // Check if this is a duplicate within the threshold
         if (this.lastEventFingerprint === fingerprint && now - this.lastEventTime < config_constants_1.DUPLICATE_EVENT_THRESHOLD_MS) {
             return true;
         }
-        // Update tracking
         this.lastEventFingerprint = fingerprint;
         this.lastEventTime = now;
         return false;
@@ -271,7 +223,6 @@ class EventManager extends state_manager_1.StateManager {
     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}`;
@@ -285,6 +236,9 @@ class EventManager extends state_manager_1.StateManager {
         if (event.web_vitals) {
             fingerprint += `_vitals_${event.web_vitals.type}`;
         }
+        if (event.error_data) {
+            fingerprint += `_error_${event.error_data.type}_${event.error_data.message}`;
+        }
         return fingerprint;
     }
     createEventSignature(event) {
@@ -292,21 +246,20 @@ class EventManager extends state_manager_1.StateManager {
     }
     addToQueue(event) {
         this.eventsQueue.push(event);
-        utils_1.debugLog.info('EventManager', 'Event added to queue', event);
         this.emitEvent(event);
-        // Prevent queue overflow
         if (this.eventsQueue.length > config_constants_1.MAX_EVENTS_QUEUE_LENGTH) {
-            const removedEvent = this.eventsQueue.shift();
-            utils_1.debugLog.warn('EventManager', 'Event queue overflow, oldest event removed', {
+            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,
             });
         }
         if (!this.sendIntervalId) {
             this.startSendInterval();
         }
-        // Google Analytics integration
         this.handleGoogleAnalyticsIntegration(event);
     }
     startSendInterval() {
@@ -319,11 +272,9 @@ 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') {
-                // Skip GA tracking in QA/debug modes
-            }
-            else {
-                this.googleAnalytics.trackEvent(event.custom_event.name, event.custom_event.metadata ?? {});
+                return;
             }
+            this.googleAnalytics.trackEvent(event.custom_event.name, event.custom_event.metadata ?? {});
         }
     }
     shouldSample() {
@@ -337,17 +288,11 @@ class EventManager extends state_manager_1.StateManager {
             return !eventIdSet.has(eventId);
         });
     }
-    /**
-     * Emit event for external listeners
-     */
     emitEvent(eventData) {
         if (this.emitter) {
             this.emitter.emit(types_1.EmitterEvent.EVENT, eventData);
         }
     }
-    /**
-     * Emit events queue for external listeners
-     */
     emitEventsQueue(queue) {
         if (this.emitter) {
             this.emitter.emit(types_1.EmitterEvent.QUEUE, queue);

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

@@ -2,7 +2,7 @@ import { BaseEventsQueueDto } from '../types';
 import { StorageManager } from './storage.manager';
 import { StateManager } from './state.manager';
 interface SendCallbacks {
-    onSuccess?: (eventCount?: number, events?: any[]) => void;
+    onSuccess?: (eventCount?: number, events?: any[], body?: BaseEventsQueueDto) => void;
     onFailure?: () => void;
 }
 export declare class SenderManager extends StateManager {
@@ -12,38 +12,15 @@ export declare class SenderManager extends StateManager {
     private isRetrying;
     constructor(storeManager: StorageManager);
     private getQueueStorageKey;
-    /**
-     * Send events synchronously using sendBeacon or XHR fallback
-     * Used primarily for page unload scenarios
-     */
     sendEventsQueueSync(body: BaseEventsQueueDto): boolean;
-    /**
-     * Send events asynchronously with persistence and retry logic
-     * Main method for sending events during normal operation
-     */
     sendEventsQueue(body: BaseEventsQueueDto, callbacks?: SendCallbacks): Promise<boolean>;
-    /**
-     * Recover and send previously persisted events
-     * Called during initialization to handle events from previous session
-     */
     recoverPersistedEvents(callbacks?: SendCallbacks): Promise<void>;
-    /**
-     * Persist events for recovery in case of failure
-     */
     persistEventsForRecovery(body: BaseEventsQueueDto): boolean;
-    /**
-     * Legacy method for backward compatibility
-     * @deprecated Use sendEventsQueue instead
-     */
     sendEventsQueueAsync(body: BaseEventsQueueDto): Promise<boolean>;
-    /**
-     * Stop the sender manager and clean up resources
-     */
     stop(): void;
     private send;
     private sendWithTimeout;
     private sendQueueSyncInternal;
-    private sendSyncXHR;
     private prepareRequest;
     private getPersistedData;
     private isDataRecent;
@@ -53,10 +30,6 @@ export declare class SenderManager extends StateManager {
     private resetRetryState;
     private scheduleRetry;
     private shouldSkipSend;
-    /**
-     * Simulate a successful send operation for skip mode
-     * Provides realistic timing and behavior without making HTTP requests
-     */
     private simulateSuccessfulSend;
     private isSendBeaconAvailable;
     private clearRetryTimeout;

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

@@ -18,40 +18,34 @@ class SenderManager extends state_manager_1.StateManager {
         const userId = this.get('userId') || 'anonymous';
         return `${(0, constants_1.QUEUE_KEY)(projectId)}:${userId}`;
     }
-    /**
-     * Send events synchronously using sendBeacon or XHR fallback
-     * Used primarily for page unload scenarios
-     */
     sendEventsQueueSync(body) {
-        // For skip mode, simulate success immediately (sync version)
         if (this.shouldSkipSend()) {
-            this.clearPersistedEvents();
             this.resetRetryState();
             return true;
         }
+        const config = this.get('config');
+        if (config?.id === types_1.SpecialProjectId.Fail) {
+            utils_1.debugLog.warn('SenderManager', 'Fail mode: simulating network failure (sync)', {
+                events: body.events.length,
+            });
+            return false;
+        }
         const success = this.sendQueueSyncInternal(body);
         if (success) {
-            this.clearPersistedEvents();
             this.resetRetryState();
         }
         return success;
     }
-    /**
-     * Send events asynchronously with persistence and retry logic
-     * Main method for sending events during normal operation
-     */
     async sendEventsQueue(body, callbacks) {
-        // First, try to persist events for recovery (even in skip mode for consistency)
         const persisted = this.persistEvents(body);
         if (!persisted && !this.shouldSkipSend()) {
             utils_1.debugLog.warn('SenderManager', 'Failed to persist events, attempting immediate send');
         }
-        // Attempt to send events (or simulate in skip mode)
         const success = await this.send(body);
         if (success) {
             this.clearPersistedEvents();
             this.resetRetryState();
-            callbacks?.onSuccess?.(body.events.length);
+            callbacks?.onSuccess?.(body.events.length, body.events, body);
         }
         else {
             this.scheduleRetry(body, callbacks);
@@ -59,10 +53,6 @@ class SenderManager extends state_manager_1.StateManager {
         }
         return success;
     }
-    /**
-     * Recover and send previously persisted events
-     * Called during initialization to handle events from previous session
-     */
     async recoverPersistedEvents(callbacks) {
         try {
             const persistedData = this.getPersistedData();
@@ -75,7 +65,7 @@ class SenderManager extends state_manager_1.StateManager {
             if (success) {
                 this.clearPersistedEvents();
                 this.resetRetryState();
-                callbacks?.onSuccess?.(persistedData.events.length);
+                callbacks?.onSuccess?.(persistedData.events.length, persistedData.events, body);
             }
             else {
                 this.scheduleRetry(body, callbacks);
@@ -84,35 +74,30 @@ class SenderManager extends state_manager_1.StateManager {
         }
         catch (error) {
             utils_1.debugLog.error('SenderManager', 'Failed to recover persisted events', { error });
-            this.clearPersistedEvents(); // Clean up corrupted data
+            this.clearPersistedEvents();
         }
     }
-    /**
-     * Persist events for recovery in case of failure
-     */
     persistEventsForRecovery(body) {
         return this.persistEvents(body);
     }
-    /**
-     * Legacy method for backward compatibility
-     * @deprecated Use sendEventsQueue instead
-     */
     async sendEventsQueueAsync(body) {
         return this.sendEventsQueue(body);
     }
-    /**
-     * Stop the sender manager and clean up resources
-     */
     stop() {
         this.clearRetryTimeout();
         this.resetRetryState();
-        // Clear any persisted events on shutdown to prevent stale data
-        this.clearPersistedEvents();
     }
     async send(body) {
         if (this.shouldSkipSend()) {
             return this.simulateSuccessfulSend();
         }
+        const config = this.get('config');
+        if (config?.id === types_1.SpecialProjectId.Fail) {
+            utils_1.debugLog.warn('SenderManager', 'Fail mode: simulating network failure', {
+                events: body.events.length,
+            });
+            return false;
+        }
         const { url, payload } = this.prepareRequest(body);
         try {
             const response = await this.sendWithTimeout(url, payload);
@@ -123,7 +108,7 @@ class SenderManager extends state_manager_1.StateManager {
             utils_1.debugLog.error('SenderManager', 'Send request failed', {
                 error: errorMessage,
                 events: body.events.length,
-                url: url.replace(/\/\/[^/]+/, '//[DOMAIN]'), // Hide domain for privacy
+                url: url.replace(/\/\/[^/]+/, '//[DOMAIN]'),
             });
             return false;
         }
@@ -131,11 +116,13 @@ class SenderManager extends state_manager_1.StateManager {
     async sendWithTimeout(url, payload) {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), constants_1.REQUEST_TIMEOUT_MS);
+        const config = this.get('config');
         try {
             const response = await fetch(url, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
+                    'X-TraceLog-Project': config?.id || 'unknown',
                 },
                 body: payload,
                 keepalive: true,
@@ -154,42 +141,33 @@ class SenderManager extends state_manager_1.StateManager {
     sendQueueSyncInternal(body) {
         const { url, payload } = this.prepareRequest(body);
         const blob = new Blob([payload], { type: 'application/json' });
-        if (this.isSendBeaconAvailable() && navigator.sendBeacon(url, blob)) {
-            return true;
-        }
-        return this.sendSyncXHR(url, payload);
-    }
-    sendSyncXHR(url, payload) {
-        const xhr = new XMLHttpRequest();
-        try {
-            xhr.open('POST', url, false);
-            xhr.setRequestHeader('Content-Type', 'application/json');
-            xhr.withCredentials = true;
-            xhr.timeout = constants_1.SYNC_XHR_TIMEOUT_MS;
-            xhr.send(payload);
-            const success = xhr.status >= 200 && xhr.status < 300;
-            if (!success) {
-                utils_1.debugLog.warn('SenderManager', 'Sync XHR failed', {
-                    status: xhr.status,
-                    statusText: xhr.statusText || 'Unknown error',
-                });
+        if (this.isSendBeaconAvailable()) {
+            const success = navigator.sendBeacon(url, blob);
+            if (success) {
+                return true;
             }
-            return success;
+            utils_1.debugLog.warn('SenderManager', 'sendBeacon failed, persisting events for recovery');
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            utils_1.debugLog.warn('SenderManager', 'Sync XHR error', {
-                error: errorMessage,
-                status: xhr.status || 'unknown',
-            });
-            return false;
+        else {
+            utils_1.debugLog.warn('SenderManager', 'sendBeacon not available, persisting events for recovery');
         }
+        this.persistEventsForRecovery(body);
+        return false;
     }
     prepareRequest(body) {
         const url = `${this.get('apiUrl')}/collect`;
+        // Enrich payload with metadata for sendBeacon() fallback
+        // sendBeacon() doesn't send custom headers, so we include referer in payload
+        const enrichedBody = {
+            ...body,
+            _metadata: {
+                referer: typeof window !== 'undefined' ? window.location.href : undefined,
+                timestamp: Date.now(),
+            },
+        };
         return {
             url,
-            payload: JSON.stringify(body),
+            payload: JSON.stringify(enrichedBody),
         };
     }
     getPersistedData() {
@@ -202,7 +180,6 @@ class SenderManager extends state_manager_1.StateManager {
         }
         catch (error) {
             utils_1.debugLog.warn('SenderManager', 'Failed to parse persisted data', { error });
-            // Clean up corrupted data
             this.clearPersistedEvents();
         }
         return null;
@@ -245,7 +222,8 @@ class SenderManager extends state_manager_1.StateManager {
     }
     clearPersistedEvents() {
         try {
-            this.storeManager.removeItem(this.getQueueStorageKey());
+            const key = this.getQueueStorageKey();
+            this.storeManager.removeItem(key);
         }
         catch (error) {
             utils_1.debugLog.warn('SenderManager', 'Failed to clear persisted events', { error });
@@ -268,13 +246,10 @@ class SenderManager extends state_manager_1.StateManager {
             return;
         }
         const retryDelay = constants_1.RETRY_DELAY_MS * Math.pow(2, this.retryCount); // Exponential backoff
+        this.isRetrying = true;
         this.retryTimeoutId = window.setTimeout(async () => {
             this.retryTimeoutId = null;
-            if (this.isRetrying) {
-                return;
-            }
             this.retryCount++;
-            this.isRetrying = true;
             try {
                 const success = await this.send(body);
                 if (success) {
@@ -306,15 +281,10 @@ class SenderManager extends state_manager_1.StateManager {
         const { id } = config || {};
         return id === types_1.SpecialProjectId.Skip;
     }
-    /**
-     * Simulate a successful send operation for skip mode
-     * Provides realistic timing and behavior without making HTTP requests
-     */
     async simulateSuccessfulSend() {
-        // Simulate realistic network delay (100-500ms)
         const delay = Math.random() * 400 + 100;
         await new Promise((resolve) => setTimeout(resolve, delay));
-        return true; // Always successful in skip mode
+        return true;
     }
     isSendBeaconAvailable() {
         return typeof navigator !== 'undefined' && typeof navigator.sendBeacon === 'function';

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

@@ -4,83 +4,36 @@ import { EventManager } from './event.manager';
 export declare class SessionManager extends StateManager {
     private readonly storageManager;
     private readonly eventManager;
+    private readonly projectId;
     private sessionTimeoutId;
     private broadcastChannel;
     private activityHandler;
     private visibilityChangeHandler;
     private beforeUnloadHandler;
     private isTracking;
-    constructor(storageManager: StorageManager, eventManager: EventManager);
-    /**
-     * Initialize cross-tab synchronization
-     */
+    constructor(storageManager: StorageManager, eventManager: EventManager, projectId: string);
     private initCrossTabSync;
-    /**
-     * Share session with other tabs
-     */
     private shareSession;
     private broadcastSessionEnd;
-    /**
-     * Cleanup cross-tab sync
-     */
     private cleanupCrossTabSync;
-    /**
-     * Recover session from localStorage if it exists and hasn't expired
-     */
     private recoverSession;
-    /**
-     * Persist session data to localStorage
-     */
     private persistSession;
     private clearStoredSession;
     private loadStoredSession;
     private saveStoredSession;
     private getSessionStorageKey;
     private getProjectId;
-    /**
-     * Start session tracking
-     */
     startTracking(): Promise<void>;
-    /**
-     * Generate unique session ID
-     */
     private generateSessionId;
-    /**
-     * Setup session timeout
-     */
     private setupSessionTimeout;
-    /**
-     * Reset session timeout and update activity
-     */
     private resetSessionTimeout;
-    /**
-     * Clear session timeout
-     */
     private clearSessionTimeout;
-    /**
-     * Setup activity listeners to track user engagement
-     */
     private setupActivityListeners;
-    /**
-     * Clean up activity listeners
-     */
     private cleanupActivityListeners;
-    /**
-     * Setup page lifecycle listeners (visibility and unload)
-     */
     private setupLifecycleListeners;
     private cleanupLifecycleListeners;
-    /**
-     * End current session
-     */
     private endSession;
     private resetSessionState;
-    /**
-     * Stop session tracking
-     */
     stopTracking(): Promise<void>;
-    /**
-     * Clean up all resources
-     */
     destroy(): void;
 }