@tracelog/lib 0.4.0 → 0.5.0

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

@@ -1,4 +1,4 @@
-import { QUEUE_KEY, EVENT_EXPIRY_HOURS, SYNC_XHR_TIMEOUT_MS, MAX_RETRIES, RETRY_DELAY_MS, REQUEST_TIMEOUT_MS, } from '../constants';
+import { QUEUE_KEY, EVENT_EXPIRY_HOURS, MAX_RETRIES, RETRY_DELAY_MS, REQUEST_TIMEOUT_MS } from '../constants';
 import { SpecialProjectId } from '../types';
 import { debugLog } from '../utils';
 import { StateManager } from './state.manager';
@@ -15,40 +15,34 @@ export class SenderManager extends StateManager {
         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) {
-        // 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 === SpecialProjectId.Fail) {
+            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()) {
             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);
@@ -56,10 +50,6 @@ export class SenderManager extends 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();
@@ -72,7 +62,7 @@ export class SenderManager extends 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);
@@ -81,35 +71,30 @@ export class SenderManager extends StateManager {
         }
         catch (error) {
             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 === SpecialProjectId.Fail) {
+            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);
@@ -120,7 +105,7 @@ export class SenderManager extends StateManager {
             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;
         }
@@ -128,11 +113,13 @@ export class SenderManager extends StateManager {
     async sendWithTimeout(url, payload) {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), 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,
@@ -151,42 +138,33 @@ export class SenderManager extends 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 = SYNC_XHR_TIMEOUT_MS;
-            xhr.send(payload);
-            const success = xhr.status >= 200 && xhr.status < 300;
-            if (!success) {
-                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;
+            debugLog.warn('SenderManager', 'sendBeacon failed, persisting events for recovery');
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            debugLog.warn('SenderManager', 'Sync XHR error', {
-                error: errorMessage,
-                status: xhr.status || 'unknown',
-            });
-            return false;
+        else {
+            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() {
@@ -199,7 +177,6 @@ export class SenderManager extends StateManager {
         }
         catch (error) {
             debugLog.warn('SenderManager', 'Failed to parse persisted data', { error });
-            // Clean up corrupted data
             this.clearPersistedEvents();
         }
         return null;
@@ -242,7 +219,8 @@ export class SenderManager extends StateManager {
     }
     clearPersistedEvents() {
         try {
-            this.storeManager.removeItem(this.getQueueStorageKey());
+            const key = this.getQueueStorageKey();
+            this.storeManager.removeItem(key);
         }
         catch (error) {
             debugLog.warn('SenderManager', 'Failed to clear persisted events', { error });
@@ -265,13 +243,10 @@ export class SenderManager extends StateManager {
             return;
         }
         const retryDelay = 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) {
@@ -303,15 +278,10 @@ export class SenderManager extends StateManager {
         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
+        return true;
     }
     isSendBeaconAvailable() {
         return typeof navigator !== 'undefined' && typeof navigator.sendBeacon === 'function';

package/dist/esm/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;
 }

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

@@ -3,7 +3,7 @@ import { EventType } from '../types';
 import { debugLog } from '../utils/logging';
 import { StateManager } from './state.manager';
 export class SessionManager extends StateManager {
-    constructor(storageManager, eventManager) {
+    constructor(storageManager, eventManager, projectId) {
         super();
         this.sessionTimeoutId = null;
         this.broadcastChannel = null;
@@ -13,10 +13,8 @@ export class SessionManager extends StateManager {
         this.isTracking = false;
         this.storageManager = storageManager;
         this.eventManager = eventManager;
+        this.projectId = projectId;
     }
-    /**
-     * Initialize cross-tab synchronization
-     */
     initCrossTabSync() {
         if (typeof BroadcastChannel === 'undefined') {
             debugLog.warn('SessionManager', 'BroadcastChannel not supported');
@@ -45,41 +43,38 @@ export class SessionManager extends StateManager {
             }
         };
     }
-    /**
-     * Share session with other tabs
-     */
     shareSession(sessionId) {
-        this.broadcastChannel?.postMessage({
-            action: 'session_start',
-            projectId: this.getProjectId(),
-            sessionId,
-            timestamp: Date.now(),
-        });
+        if (this.broadcastChannel && typeof this.broadcastChannel.postMessage === 'function') {
+            this.broadcastChannel.postMessage({
+                action: 'session_start',
+                projectId: this.getProjectId(),
+                sessionId,
+                timestamp: Date.now(),
+            });
+        }
     }
     broadcastSessionEnd(sessionId, reason) {
         if (!sessionId) {
             return;
         }
-        this.broadcastChannel?.postMessage({
-            action: 'session_end',
-            projectId: this.getProjectId(),
-            sessionId,
-            reason,
-            timestamp: Date.now(),
-        });
+        if (this.broadcastChannel && typeof this.broadcastChannel.postMessage === 'function') {
+            this.broadcastChannel.postMessage({
+                action: 'session_end',
+                projectId: this.getProjectId(),
+                sessionId,
+                reason,
+                timestamp: Date.now(),
+            });
+        }
     }
-    /**
-     * Cleanup cross-tab sync
-     */
     cleanupCrossTabSync() {
         if (this.broadcastChannel) {
-            this.broadcastChannel.close();
+            if (typeof this.broadcastChannel.close === 'function') {
+                this.broadcastChannel.close();
+            }
             this.broadcastChannel = null;
         }
     }
-    /**
-     * Recover session from localStorage if it exists and hasn't expired
-     */
     recoverSession() {
         const storedSession = this.loadStoredSession();
         if (!storedSession) {
@@ -94,9 +89,6 @@ export class SessionManager extends StateManager {
         debugLog.info('SessionManager', 'Session recovered from storage', { sessionId: storedSession.id });
         return storedSession.id;
     }
-    /**
-     * Persist session data to localStorage
-     */
     persistSession(sessionId, lastActivity = Date.now()) {
         this.saveStoredSession({
             id: sessionId,
@@ -133,11 +125,8 @@ export class SessionManager extends StateManager {
         return SESSION_STORAGE_KEY(this.getProjectId());
     }
     getProjectId() {
-        return this.get('config')?.id ?? '';
+        return this.projectId;
     }
-    /**
-     * Start session tracking
-     */
     async startTracking() {
         if (this.isTracking) {
             debugLog.warn('SessionManager', 'Session tracking already active');
@@ -150,12 +139,11 @@ export class SessionManager extends StateManager {
         try {
             this.set('sessionId', sessionId);
             this.persistSession(sessionId);
-            // Track session start event
-            this.eventManager.track({
-                type: EventType.SESSION_START,
-                ...(isRecovered && { session_start_recovered: true }),
-            });
-            // Initialize components
+            if (!isRecovered) {
+                this.eventManager.track({
+                    type: EventType.SESSION_START,
+                });
+            }
             this.initCrossTabSync();
             this.shareSession(sessionId);
             this.setupSessionTimeout();
@@ -173,15 +161,9 @@ export class SessionManager extends StateManager {
             throw error;
         }
     }
-    /**
-     * Generate unique session ID
-     */
     generateSessionId() {
         return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
     }
-    /**
-     * Setup session timeout
-     */
     setupSessionTimeout() {
         this.clearSessionTimeout();
         const sessionTimeout = this.get('config')?.sessionTimeout ?? DEFAULT_SESSION_TIMEOUT;
@@ -189,9 +171,6 @@ export class SessionManager extends StateManager {
             this.endSession('inactivity');
         }, sessionTimeout);
     }
-    /**
-     * Reset session timeout and update activity
-     */
     resetSessionTimeout() {
         this.setupSessionTimeout();
         const sessionId = this.get('sessionId');
@@ -199,27 +178,18 @@ export class SessionManager extends StateManager {
             this.persistSession(sessionId);
         }
     }
-    /**
-     * Clear session timeout
-     */
     clearSessionTimeout() {
         if (this.sessionTimeoutId) {
             clearTimeout(this.sessionTimeoutId);
             this.sessionTimeoutId = null;
         }
     }
-    /**
-     * Setup activity listeners to track user engagement
-     */
     setupActivityListeners() {
         this.activityHandler = () => this.resetSessionTimeout();
         document.addEventListener('click', this.activityHandler, { passive: true });
         document.addEventListener('keydown', this.activityHandler, { passive: true });
         document.addEventListener('scroll', this.activityHandler, { passive: true });
     }
-    /**
-     * Clean up activity listeners
-     */
     cleanupActivityListeners() {
         if (this.activityHandler) {
             document.removeEventListener('click', this.activityHandler);
@@ -228,9 +198,6 @@ export class SessionManager extends StateManager {
             this.activityHandler = null;
         }
     }
-    /**
-     * Setup page lifecycle listeners (visibility and unload)
-     */
     setupLifecycleListeners() {
         if (this.visibilityChangeHandler || this.beforeUnloadHandler) {
             return;
@@ -249,9 +216,7 @@ export class SessionManager extends StateManager {
         this.beforeUnloadHandler = () => {
             this.endSession('page_unload');
         };
-        // Handle tab visibility changes
         document.addEventListener('visibilitychange', this.visibilityChangeHandler);
-        // Handle page unload
         window.addEventListener('beforeunload', this.beforeUnloadHandler);
     }
     cleanupLifecycleListeners() {
@@ -264,14 +229,11 @@ export class SessionManager extends StateManager {
             this.beforeUnloadHandler = null;
         }
     }
-    /**
-     * End current session
-     */
-    endSession(reason) {
+    async endSession(reason) {
         const sessionId = this.get('sessionId');
         if (!sessionId) {
             debugLog.warn('SessionManager', 'endSession called without active session', { reason });
-            this.resetSessionState();
+            this.resetSessionState(reason);
             return;
         }
         debugLog.info('SessionManager', 'Ending session', { sessionId, reason });
@@ -281,42 +243,39 @@ export class SessionManager extends StateManager {
         });
         const finalize = () => {
             this.broadcastSessionEnd(sessionId, reason);
-            this.resetSessionState();
+            this.resetSessionState(reason);
         };
         const flushResult = this.eventManager.flushImmediatelySync();
         if (flushResult) {
             finalize();
             return;
         }
-        this.eventManager
-            .flushImmediately()
-            .then(finalize)
-            .catch((error) => {
+        try {
+            await this.eventManager.flushImmediately();
+            finalize();
+        }
+        catch (error) {
             debugLog.warn('SessionManager', 'Async flush failed during session end', {
                 error: error instanceof Error ? error.message : 'Unknown error',
             });
             finalize();
-        });
+        }
     }
-    resetSessionState() {
+    resetSessionState(reason) {
         this.clearSessionTimeout();
         this.cleanupActivityListeners();
         this.cleanupLifecycleListeners();
         this.cleanupCrossTabSync();
-        this.clearStoredSession();
+        if (reason !== 'page_unload') {
+            this.clearStoredSession();
+        }
         this.set('sessionId', null);
         this.set('hasStartSession', false);
         this.isTracking = false;
     }
-    /**
-     * Stop session tracking
-     */
     async stopTracking() {
-        this.endSession('manual_stop');
+        await this.endSession('manual_stop');
     }
-    /**
-     * Clean up all resources
-     */
     destroy() {
         this.clearSessionTimeout();
         this.cleanupActivityListeners();

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

@@ -1,38 +1,11 @@
 import { State } from '../types';
-/**
- * Resets the global state to its initial empty state.
- * Used primarily for testing and cleanup scenarios.
- */
+export declare function getGlobalState(): Readonly<State>;
 export declare function resetGlobalState(): void;
-/**
- * Abstract base class providing state management capabilities to TraceLog components.
- *
- * All managers and handlers extend this class to access and modify the shared global state.
- * State operations are synchronous and thread-safe within the single-threaded browser environment.
- */
 export declare abstract class StateManager {
-    /**
-     * Gets a value from the global state
-     */
     protected get<T extends keyof State>(key: T): State[T];
-    /**
-     * Sets a value in the global state
-     */
     protected set<T extends keyof State>(key: T, value: State[T]): void;
-    /**
-     * Gets the entire state object (for debugging purposes)
-     */
     protected getState(): Readonly<State>;
-    /**
-     * Checks if a state key is considered critical for logging
-     */
     private isCriticalStateKey;
-    /**
-     * Determines if a state change should be logged
-     */
     private shouldLog;
-    /**
-     * Formats values for logging (avoiding large object dumps)
-     */
     private formatLogValue;
 }