@tracelog/lib 0.0.8 → 0.2.0

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

@@ -1,46 +1,64 @@
 import { BaseEventsQueueDto } from '../types';
 import { StorageManager } from './storage.manager';
 import { StateManager } from './state.manager';
+interface SendCallbacks {
+    onSuccess?: (eventCount?: number, events?: any[]) => void;
+    onFailure?: () => void;
+}
 export declare class SenderManager extends StateManager {
     private readonly storeManager;
-    private readonly queueStorageKey;
-    private retryDelay;
     private retryTimeoutId;
-    private lastAsyncSend;
-    private lastSyncSend;
+    private retryCount;
+    private isRetrying;
     constructor(storeManager: StorageManager);
-    sendEventsQueueAsync(body: BaseEventsQueueDto): Promise<boolean>;
+    private getQueueStorageKey;
+    /**
+     * Send events synchronously using sendBeacon or XHR fallback
+     * Used primarily for page unload scenarios
+     */
     sendEventsQueueSync(body: BaseEventsQueueDto): boolean;
-    sendEventsQueue(body: BaseEventsQueueDto): boolean;
-    recoverPersistedEvents(): void;
-    stop(): void;
     /**
-     * Sends recovered events without re-deduplication since they were already processed
+     * 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
      */
-    private sendRecoveredEvents;
+    recoverPersistedEvents(callbacks?: SendCallbacks): Promise<void>;
     /**
-     * Schedules retry for recovered events using the specific recovery method
+     * Persist events for recovery in case of failure
      */
-    private scheduleRetryForRecoveredEvents;
-    private canSendAsync;
-    private canSendSync;
-    private sendQueueAsync;
-    private sendQueueSync;
-    private sendQueue;
+    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;
     private createRecoveryBody;
-    private logQueue;
-    private handleSendFailure;
-    private persistFailedEvents;
+    private persistEvents;
     private clearPersistedEvents;
     private resetRetryState;
     private scheduleRetry;
-    private executeSend;
-    private executeSendSync;
     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;
 }
+export {};

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

@@ -1,111 +1,154 @@
-import { QUEUE_KEY, RETRY_BACKOFF_INITIAL, RETRY_BACKOFF_MAX, RATE_LIMIT_INTERVAL, EVENT_EXPIRY_HOURS, SYNC_XHR_TIMEOUT_MS, } from '../constants';
-import { SpecialProjectId, Mode } from '../types';
-import { debugLog } from '../utils/logging';
+import { QUEUE_KEY, EVENT_EXPIRY_HOURS, SYNC_XHR_TIMEOUT_MS, MAX_RETRIES, RETRY_DELAY_MS, REQUEST_TIMEOUT_MS, } from '../constants';
+import { SpecialProjectId } from '../types';
+import { debugLog } from '../utils';
 import { StateManager } from './state.manager';
 export class SenderManager extends StateManager {
     constructor(storeManager) {
         super();
-        this.retryDelay = RETRY_BACKOFF_INITIAL;
         this.retryTimeoutId = null;
-        this.lastAsyncSend = 0;
-        this.lastSyncSend = 0;
+        this.retryCount = 0;
+        this.isRetrying = false;
         this.storeManager = storeManager;
-        this.queueStorageKey = `${QUEUE_KEY(this.get('config')?.id)}:${this.get('userId')}`;
-        this.recoverPersistedEvents();
     }
-    async sendEventsQueueAsync(body) {
-        return this.executeSend(body, () => this.sendQueueAsync(body));
+    getQueueStorageKey() {
+        const projectId = this.get('config')?.id || 'default';
+        const userId = this.get('userId') || 'anonymous';
+        return `${QUEUE_KEY(projectId)}:${userId}`;
     }
+    /**
+     * Send events synchronously using sendBeacon or XHR fallback
+     * Used primarily for page unload scenarios
+     */
     sendEventsQueueSync(body) {
-        return this.executeSendSync(body, () => this.sendQueueSync(body));
+        // For skip mode, simulate success immediately (sync version)
+        if (this.shouldSkipSend()) {
+            this.clearPersistedEvents();
+            this.resetRetryState();
+            return true;
+        }
+        const success = this.sendQueueSyncInternal(body);
+        if (success) {
+            this.clearPersistedEvents();
+            this.resetRetryState();
+        }
+        return success;
     }
-    sendEventsQueue(body) {
-        return this.executeSendSync(body, () => this.sendQueue(body));
+    /**
+     * 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()) {
+            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);
+        }
+        else {
+            this.scheduleRetry(body, callbacks);
+            callbacks?.onFailure?.();
+        }
+        return success;
     }
-    recoverPersistedEvents() {
+    /**
+     * Recover and send previously persisted events
+     * Called during initialization to handle events from previous session
+     */
+    async recoverPersistedEvents(callbacks) {
         try {
             const persistedData = this.getPersistedData();
             if (!persistedData || !this.isDataRecent(persistedData) || persistedData.events.length === 0) {
                 this.clearPersistedEvents();
                 return;
             }
-            const recoveryBody = this.createRecoveryBody(persistedData);
-            const success = this.sendRecoveredEvents(recoveryBody);
+            const body = this.createRecoveryBody(persistedData);
+            const success = await this.send(body);
             if (success) {
-                debugLog.info('SenderManager', 'Persisted events recovered successfully', {
-                    eventsCount: persistedData.events.length,
-                    sessionId: persistedData.sessionId,
-                });
                 this.clearPersistedEvents();
+                this.resetRetryState();
+                callbacks?.onSuccess?.(persistedData.events.length);
             }
             else {
-                debugLog.warn('SenderManager', 'Failed to recover persisted events, scheduling retry', {
-                    eventsCount: persistedData.events.length,
-                });
-                this.scheduleRetryForRecoveredEvents(recoveryBody);
+                this.scheduleRetry(body, callbacks);
+                callbacks?.onFailure?.();
             }
         }
         catch (error) {
             debugLog.error('SenderManager', 'Failed to recover persisted events', { error });
+            this.clearPersistedEvents(); // Clean up corrupted data
         }
     }
-    stop() {
-        this.clearRetryTimeout();
-        this.resetRetryState();
-    }
     /**
-     * Sends recovered events without re-deduplication since they were already processed
+     * Persist events for recovery in case of failure
      */
-    sendRecoveredEvents(body) {
-        return this.executeSendSync(body, () => this.sendQueue(body));
+    persistEventsForRecovery(body) {
+        return this.persistEvents(body);
     }
     /**
-     * Schedules retry for recovered events using the specific recovery method
+     * Legacy method for backward compatibility
+     * @deprecated Use sendEventsQueue instead
      */
-    scheduleRetryForRecoveredEvents(body) {
-        if (this.retryTimeoutId !== null) {
-            return;
-        }
-        this.retryTimeoutId = window.setTimeout(() => {
-            this.retryTimeoutId = null;
-            this.sendRecoveredEvents(body);
-        }, this.retryDelay);
-        this.retryDelay = Math.min(this.retryDelay * 2, RETRY_BACKOFF_MAX);
-    }
-    canSendAsync() {
-        return Date.now() - this.lastAsyncSend >= RATE_LIMIT_INTERVAL;
+    async sendEventsQueueAsync(body) {
+        return this.sendEventsQueue(body);
     }
-    canSendSync() {
-        return Date.now() - this.lastSyncSend >= RATE_LIMIT_INTERVAL;
+    /**
+     * 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 sendQueueAsync(body) {
+    async send(body) {
+        if (this.shouldSkipSend()) {
+            return this.simulateSuccessfulSend();
+        }
         const { url, payload } = this.prepareRequest(body);
         try {
-            const response = await fetch(url, {
-                method: 'POST',
-                mode: 'cors',
-                credentials: 'include',
-                body: payload,
-                headers: {
-                    'Content-Type': 'application/json',
-                    Origin: window.location.origin,
-                    Referer: window.location.href,
-                },
-            });
+            const response = await this.sendWithTimeout(url, payload);
             return response.ok;
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            const isCorsError = errorMessage.includes('CORS') || errorMessage.includes('NotSameOrigin') || errorMessage.includes('blocked');
-            debugLog.error('SenderManager', 'Failed to send events async', {
+            debugLog.error('SenderManager', 'Send request failed', {
                 error: errorMessage,
-                isCorsError,
-                url: url.replace(/\/\/[^/]+/, '//[DOMAIN]'),
+                events: body.events.length,
+                url: url.replace(/\/\/[^/]+/, '//[DOMAIN]'), // Hide domain for privacy
             });
             return false;
         }
     }
-    sendQueueSync(body) {
+    async sendWithTimeout(url, payload) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: payload,
+                keepalive: true,
+                credentials: 'include',
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            return response;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    sendQueueSyncInternal(body) {
         const { url, payload } = this.prepareRequest(body);
         const blob = new Blob([payload], { type: 'application/json' });
         if (this.isSendBeaconAvailable() && navigator.sendBeacon(url, blob)) {
@@ -113,54 +156,61 @@ export class SenderManager extends StateManager {
         }
         return this.sendSyncXHR(url, payload);
     }
-    sendQueue(body) {
-        if (!this.isSendBeaconAvailable()) {
-            return false;
-        }
-        const { url, payload } = this.prepareRequest(body);
-        const blob = new Blob([payload], { type: 'application/json' });
-        return navigator.sendBeacon(url, blob);
-    }
     sendSyncXHR(url, payload) {
         const xhr = new XMLHttpRequest();
         try {
             xhr.open('POST', url, false);
             xhr.setRequestHeader('Content-Type', 'application/json');
-            xhr.setRequestHeader('Origin', window.location.origin);
-            xhr.setRequestHeader('Referer', window.location.href);
             xhr.withCredentials = true;
             xhr.timeout = SYNC_XHR_TIMEOUT_MS;
             xhr.send(payload);
-            return xhr.status >= 200 && xhr.status < 300;
+            const success = xhr.status >= 200 && xhr.status < 300;
+            if (!success) {
+                debugLog.warn('SenderManager', 'Sync XHR failed', {
+                    status: xhr.status,
+                    statusText: xhr.statusText || 'Unknown error',
+                });
+            }
+            return success;
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            const isCorsError = errorMessage.includes('CORS') || errorMessage.includes('NotSameOrigin') || errorMessage.includes('blocked');
-            debugLog.error('SenderManager', 'Sync XHR failed', {
+            debugLog.warn('SenderManager', 'Sync XHR error', {
                 error: errorMessage,
-                isCorsError,
-                status: xhr.status ?? 'unknown',
-                url: url.replace(/\/\/[^/]+/, '//[DOMAIN]'),
+                status: xhr.status || 'unknown',
             });
             return false;
         }
     }
     prepareRequest(body) {
-        const useLocalServer = this.get('config').id === SpecialProjectId.HttpLocal;
-        const baseUrl = useLocalServer ? window.location.origin : this.get('apiUrl');
-        const url = `${baseUrl}/collect`;
+        const url = `${this.get('apiUrl')}/collect`;
         return {
             url,
             payload: JSON.stringify(body),
         };
     }
     getPersistedData() {
-        const persistedDataString = this.storeManager.getItem(this.queueStorageKey);
-        return persistedDataString ? JSON.parse(persistedDataString) : null;
+        try {
+            const storageKey = this.getQueueStorageKey();
+            const persistedDataString = this.storeManager.getItem(storageKey);
+            if (persistedDataString) {
+                return JSON.parse(persistedDataString);
+            }
+        }
+        catch (error) {
+            debugLog.warn('SenderManager', 'Failed to parse persisted data', { error });
+            // Clean up corrupted data
+            this.clearPersistedEvents();
+        }
+        return null;
     }
     isDataRecent(data) {
+        if (!data.timestamp || typeof data.timestamp !== 'number') {
+            return false;
+        }
         const ageInHours = (Date.now() - data.timestamp) / (1000 * 60 * 60);
-        return ageInHours < EVENT_EXPIRY_HOURS;
+        const isRecent = ageInHours < EVENT_EXPIRY_HOURS;
+        return isRecent;
     }
     createRecoveryBody(data) {
         return {
@@ -171,14 +221,7 @@ export class SenderManager extends StateManager {
             ...(data.global_metadata && { global_metadata: data.global_metadata }),
         };
     }
-    logQueue(queue) {
-        debugLog.info('SenderManager', ` ⏩ Queue snapshot`, queue);
-    }
-    handleSendFailure(body) {
-        this.persistFailedEvents(body);
-        this.scheduleRetry(body);
-    }
-    persistFailedEvents(body) {
+    persistEvents(body) {
         try {
             const persistedData = {
                 userId: body.user_id,
@@ -188,131 +231,90 @@ export class SenderManager extends StateManager {
                 timestamp: Date.now(),
                 ...(body.global_metadata && { global_metadata: body.global_metadata }),
             };
-            this.storeManager.setItem(this.queueStorageKey, JSON.stringify(persistedData));
+            const storageKey = this.getQueueStorageKey();
+            this.storeManager.setItem(storageKey, JSON.stringify(persistedData));
+            return !!this.storeManager.getItem(storageKey);
         }
         catch (error) {
-            debugLog.error('SenderManager', 'Failed to persist events', { error });
+            debugLog.warn('SenderManager', 'Failed to persist events', { error });
+            return false;
         }
     }
     clearPersistedEvents() {
-        this.storeManager.removeItem(this.queueStorageKey);
+        try {
+            this.storeManager.removeItem(this.getQueueStorageKey());
+        }
+        catch (error) {
+            debugLog.warn('SenderManager', 'Failed to clear persisted events', { error });
+        }
     }
     resetRetryState() {
-        this.retryDelay = RETRY_BACKOFF_INITIAL;
+        this.retryCount = 0;
+        this.isRetrying = false;
         this.clearRetryTimeout();
     }
-    scheduleRetry(body) {
-        if (this.retryTimeoutId !== null) {
+    scheduleRetry(body, originalCallbacks) {
+        if (this.retryTimeoutId !== null || this.isRetrying) {
             return;
         }
-        this.retryTimeoutId = window.setTimeout(() => {
-            this.retryTimeoutId = null;
-            this.sendEventsQueue(body);
-        }, this.retryDelay);
-        this.retryDelay = Math.min(this.retryDelay * 2, RETRY_BACKOFF_MAX);
-    }
-    async executeSend(body, sendFn) {
-        if (this.shouldSkipSend()) {
-            this.logQueue(body);
-            return true;
-        }
-        if (!this.canSendAsync()) {
-            debugLog.info('SenderManager', `⏱️ Rate limited - skipping async send`, {
-                eventsCount: body.events.length,
-                timeSinceLastSend: Date.now() - this.lastAsyncSend,
-            });
-            return false;
+        if (this.retryCount >= MAX_RETRIES) {
+            debugLog.warn('SenderManager', 'Max retries reached, giving up', { retryCount: this.retryCount });
+            this.clearPersistedEvents();
+            this.resetRetryState();
+            originalCallbacks?.onFailure?.();
+            return;
         }
-        debugLog.info('SenderManager', `🌐 Sending events to server (async)`, {
-            eventsCount: body.events.length,
-            sessionId: body.session_id,
-            userId: body.user_id,
-        });
-        this.lastAsyncSend = Date.now();
-        try {
-            const success = await sendFn();
-            if (success) {
-                debugLog.info('SenderManager', `✅ Successfully sent events to server`, {
-                    eventsCount: body.events.length,
-                    method: 'async',
-                });
-                this.resetRetryState();
-                this.clearPersistedEvents();
-            }
-            else {
-                debugLog.warn('SenderManager', 'Failed to send events', {
-                    eventsCount: body.events.length,
-                    method: 'async',
-                });
-                this.handleSendFailure(body);
+        const retryDelay = RETRY_DELAY_MS * Math.pow(2, this.retryCount); // Exponential backoff
+        this.retryTimeoutId = window.setTimeout(async () => {
+            this.retryTimeoutId = null;
+            if (this.isRetrying) {
+                return;
             }
-            return success;
-        }
-        catch {
-            this.handleSendFailure(body);
-            return false;
-        }
-    }
-    executeSendSync(body, sendFn) {
-        if (this.shouldSkipSend()) {
-            this.logQueue(body);
-            return true;
-        }
-        if (!this.canSendSync()) {
-            debugLog.info('SenderManager', `⏱️ Rate limited - skipping sync send`, {
-                eventsCount: body.events.length,
-                timeSinceLastSend: Date.now() - this.lastSyncSend,
-            });
-            return false;
-        }
-        debugLog.info('SenderManager', `🌐 Sending events to server (sync)`, {
-            eventsCount: body.events.length,
-            sessionId: body.session_id,
-            userId: body.user_id,
-            method: 'sendBeacon/XHR',
-        });
-        this.lastSyncSend = Date.now();
-        try {
-            const success = sendFn();
-            if (success) {
-                debugLog.info('SenderManager', `✅ Successfully sent events to server`, {
-                    eventsCount: body.events.length,
-                    method: 'sync',
-                });
-                this.resetRetryState();
-                this.clearPersistedEvents();
+            this.retryCount++;
+            this.isRetrying = true;
+            try {
+                const success = await this.send(body);
+                if (success) {
+                    this.clearPersistedEvents();
+                    this.resetRetryState();
+                    originalCallbacks?.onSuccess?.(body.events.length);
+                }
+                else if (this.retryCount >= MAX_RETRIES) {
+                    this.clearPersistedEvents();
+                    this.resetRetryState();
+                    originalCallbacks?.onFailure?.();
+                }
+                else {
+                    this.scheduleRetry(body, originalCallbacks);
+                }
             }
-            else {
-                debugLog.warn('SenderManager', 'Failed to send events', {
-                    eventsCount: body.events.length,
-                    method: 'sync',
-                });
-                this.handleSendFailure(body);
+            finally {
+                this.isRetrying = false;
             }
-            return success;
-        }
-        catch {
-            debugLog.info('SenderManager', `💥 Exception during event sending`, {
-                eventsCount: body.events.length,
-                method: 'sync',
-            });
-            this.handleSendFailure(body);
-            return false;
-        }
+        }, retryDelay);
+        debugLog.debug('SenderManager', 'Retry scheduled', {
+            attempt: this.retryCount + 1,
+            delay: retryDelay,
+            events: body.events.length,
+        });
     }
     shouldSkipSend() {
-        const { id, mode } = this.get('config');
-        const specialModes = [Mode.QA, Mode.DEBUG];
-        if (id === SpecialProjectId.HttpSkip) {
-            return true;
-        }
-        return !!mode && specialModes.includes(mode) && id !== SpecialProjectId.HttpLocal;
+        const config = this.get('config');
+        const { id } = config || {};
+        return id === 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
     }
     isSendBeaconAvailable() {
-        if (typeof navigator.sendBeacon !== 'function') {
-            return false;
-        }
-        return true;
+        return typeof navigator !== 'undefined' && typeof navigator.sendBeacon === 'function';
     }
     clearRetryTimeout() {
         if (this.retryTimeoutId !== null) {