@tracelog/lib 0.1.0 → 0.2.1

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

@@ -1,353 +1,65 @@
-import { SESSION_HEARTBEAT_INTERVAL_MS, SESSION_STORAGE_KEY, DEFAULT_SESSION_TIMEOUT_MS, SESSION_SYNC_CONSTANTS, } from '../constants';
-import { EventType } from '../types';
 import { SessionManager } from '../managers/session.manager';
-import { SessionRecoveryManager } from '../managers/session-recovery.manager';
-import { CrossTabSessionManager } from '../managers/cross-tab-session.manager';
 import { StateManager } from '../managers/state.manager';
 import { debugLog } from '../utils/logging';
 export class SessionHandler extends StateManager {
-    get crossTabSessionManager() {
-        if (!this._crossTabSessionManager && !this._isInitializingCrossTab && this.shouldUseCrossTabs()) {
-            this._isInitializingCrossTab = true;
-            try {
-                const projectId = this.get('config')?.id;
-                if (projectId) {
-                    this.initializeCrossTabSessionManager(projectId);
-                }
-            }
-            catch (error) {
-                debugLog.error('SessionHandler', 'Failed to initialize cross-tab session manager', {
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                });
-            }
-            finally {
-                this._isInitializingCrossTab = false;
-            }
-        }
-        return this._crossTabSessionManager;
-    }
-    shouldUseCrossTabs() {
-        // Only initialize if BroadcastChannel is supported (indicates potential for multiple tabs)
-        // and ServiceWorker is available (better cross-tab coordination)
-        return typeof BroadcastChannel !== 'undefined' && typeof navigator !== 'undefined' && 'serviceWorker' in navigator;
-    }
     constructor(storageManager, eventManager) {
         super();
         this.sessionManager = null;
-        this.recoveryManager = null;
-        this._crossTabSessionManager = null;
-        this.heartbeatInterval = null;
-        this._isInitializingCrossTab = false;
+        this.destroyed = false;
         this.eventManager = eventManager;
         this.storageManager = storageManager;
-        this.sessionStorageKey = SESSION_STORAGE_KEY(this.get('config')?.id);
-        const projectId = this.get('config')?.id;
-        if (projectId) {
-            this.initializeSessionRecoveryManager(projectId);
-            // CrossTabSessionManager will be initialized lazily when needed via the getter
-        }
     }
-    startTracking() {
-        if (this.sessionManager) {
-            debugLog.debug('SessionHandler', 'Session tracking already active');
+    async startTracking() {
+        if (this.isActive()) {
             return;
         }
-        debugLog.debug('SessionHandler', 'Starting session tracking');
-        this.checkOrphanedSessions();
-        const onActivity = async () => {
-            if (this.crossTabSessionManager) {
-                this.crossTabSessionManager.updateSessionActivity();
-            }
-            if (this.get('sessionId')) {
-                return;
-            }
-            try {
-                const sessionResult = await this.createOrJoinSession();
-                this.set('sessionId', sessionResult.sessionId);
-                debugLog.info('SessionHandler', '🏁 Session started', {
-                    sessionId: sessionResult.sessionId,
-                    recovered: sessionResult.recovered,
-                    crossTabActive: !!this.crossTabSessionManager,
-                });
-                this.trackSession(EventType.SESSION_START, sessionResult.recovered);
-                this.persistSession(sessionResult.sessionId);
-                this.startHeartbeat();
-            }
-            catch (error) {
-                debugLog.error('SessionHandler', `Session creation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                this.forceCleanupSession();
-            }
-        };
-        const onInactivity = () => {
-            if (!this.get('sessionId')) {
-                return;
-            }
-            if (this.crossTabSessionManager && this.crossTabSessionManager.getEffectiveSessionTimeout() > 0) {
-                if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                    debugLog.debug('SessionHandler', 'Session kept alive by cross-tab activity');
-                }
-                return;
-            }
-            this.sessionManager.endSessionManaged('inactivity')
-                .then((result) => {
-                debugLog.info('SessionHandler', '🛑 Session ended by inactivity', {
-                    sessionId: this.get('sessionId'),
-                    reason: result.reason,
-                    success: result.success,
-                    eventsFlushed: result.eventsFlushed,
-                });
-                if (this.crossTabSessionManager) {
-                    this.crossTabSessionManager.endSession('inactivity');
-                }
-                this.clearPersistedSession();
-                this.stopHeartbeat();
-            })
-                .catch((error) => {
-                debugLog.error('SessionHandler', `Session end failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                this.forceCleanupSession();
-            });
-        };
-        const sessionEndConfig = {
-            enablePageUnloadHandlers: true,
-            debugMode: (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') ?? false,
-            syncTimeoutMs: SESSION_SYNC_CONSTANTS.SYNC_TIMEOUT_MS,
-            maxRetries: SESSION_SYNC_CONSTANTS.MAX_RETRY_ATTEMPTS,
-        };
-        this.sessionManager = new SessionManager(onActivity, onInactivity, this.eventManager, this.storageManager, sessionEndConfig);
-        debugLog.debug('SessionHandler', 'Session manager initialized');
-        this.startInitialSession();
-    }
-    stopTracking() {
-        debugLog.info('SessionHandler', 'Stopping session tracking');
-        if (this.sessionManager) {
-            if (this.get('sessionId')) {
+        if (this.destroyed) {
+            debugLog.warn('SessionHandler', 'Cannot start tracking on destroyed handler');
+            return;
+        }
+        try {
+            this.sessionManager = new SessionManager(this.storageManager, this.eventManager);
+            await this.sessionManager.startTracking();
+        }
+        catch (error) {
+            // Cleanup on failure
+            if (this.sessionManager) {
                 try {
-                    this.sessionManager.endSessionSafely('manual_stop', { forceSync: true });
-                    this.clearPersistedSession();
-                    this.stopHeartbeat();
+                    this.sessionManager.destroy();
                 }
-                catch (error) {
-                    debugLog.error('SessionHandler', `Manual session stop failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                    this.forceCleanupSession();
+                catch {
+                    // Ignore cleanup errors
                 }
+                this.sessionManager = null;
             }
-            this.sessionManager.destroy();
-            this.sessionManager = null;
-        }
-        if (this._crossTabSessionManager) {
-            this._crossTabSessionManager.destroy();
-            this._crossTabSessionManager = null;
-        }
-        // Reset cross-tab initialization flag
-        this._isInitializingCrossTab = false;
-        if (this.recoveryManager) {
-            this.recoveryManager.cleanupOldRecoveryAttempts();
-            this.recoveryManager = null;
+            debugLog.error('SessionHandler', 'Failed to start session tracking', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+            });
+            throw error;
         }
     }
-    initializeSessionRecoveryManager(projectId) {
-        this.recoveryManager = new SessionRecoveryManager(this.storageManager, projectId, this.eventManager);
-        debugLog.debug('SessionHandler', 'Session recovery manager initialized', { projectId });
-    }
-    initializeCrossTabSessionManager(projectId) {
-        const config = {
-            debugMode: (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') ?? false,
-        };
-        const onSessionStart = (sessionId) => {
-            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                debugLog.debug('SessionHandler', `Cross-tab session started: ${sessionId}`);
-            }
-            this.set('sessionId', sessionId);
-            this.trackSession(EventType.SESSION_START, false);
-            this.persistSession(sessionId);
-            this.startHeartbeat();
-        };
-        const onSessionEnd = (reason) => {
-            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                debugLog.debug('SessionHandler', `Cross-tab session ended: ${reason}`);
-            }
-            this.clearPersistedSession();
-            this.trackSession(EventType.SESSION_END, false, reason);
-        };
-        const onTabActivity = () => {
-            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                debugLog.debug('SessionHandler', 'Cross-tab activity detected');
-            }
-        };
-        const onCrossTabConflict = () => {
-            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                debugLog.warn('SessionHandler', 'Cross-tab conflict detected');
-            }
-            // Track cross-tab conflict in session health
-            if (this.sessionManager) {
-                this.sessionManager.trackSessionHealth('conflict');
-            }
-        };
-        const callbacks = {
-            onSessionStart,
-            onSessionEnd,
-            onTabActivity,
-            onCrossTabConflict,
-        };
-        this._crossTabSessionManager = new CrossTabSessionManager(this.storageManager, projectId, config, callbacks);
-        debugLog.debug('SessionHandler', 'Cross-tab session manager initialized', { projectId });
-    }
-    async createOrJoinSession() {
-        if (this.crossTabSessionManager) {
-            const existingSessionId = this.crossTabSessionManager.getSessionId();
-            if (existingSessionId) {
-                return { sessionId: existingSessionId, recovered: false };
-            }
-            // If cross-tab manager exists but no session, create one through regular session manager
-            // The cross-tab manager will coordinate with other tabs automatically
-            const sessionResult = this.sessionManager.startSession();
-            return { sessionId: sessionResult.sessionId, recovered: sessionResult.recovered ?? false };
-        }
-        // Fallback: create regular session when no cross-tab manager
-        const sessionResult = this.sessionManager.startSession();
-        return { sessionId: sessionResult.sessionId, recovered: sessionResult.recovered ?? false };
+    isActive() {
+        return this.sessionManager !== null && !this.destroyed;
     }
-    forceCleanupSession() {
-        // Clear session state
-        this.set('sessionId', null);
-        // Clear persisted session data
-        this.clearPersistedSession();
-        // Stop heartbeat timer
-        this.stopHeartbeat();
-        // Clean up cross-tab session if exists
-        if (this.crossTabSessionManager) {
-            try {
-                this.crossTabSessionManager.endSession('orphaned_cleanup');
-            }
-            catch (error) {
-                // Silent cleanup - we're already in error recovery
-                if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                    debugLog.warn('SessionHandler', `Cross-tab cleanup failed during force cleanup: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                }
-            }
-        }
-        // Track session end for analytics
-        try {
-            this.trackSession(EventType.SESSION_END, false, 'orphaned_cleanup');
-        }
-        catch (error) {
-            // Silent tracking failure - we're already in error recovery
-            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                debugLog.warn('SessionHandler', `Session tracking failed during force cleanup: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            }
-        }
-        if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-            debugLog.debug('SessionHandler', 'Forced session cleanup completed');
+    async cleanupSessionManager() {
+        if (this.sessionManager) {
+            await this.sessionManager.stopTracking();
+            this.sessionManager.destroy();
+            this.sessionManager = null;
         }
     }
-    trackSession(eventType, sessionStartRecovered = false, sessionEndReason) {
-        this.eventManager.track({
-            type: eventType,
-            ...(eventType === EventType.SESSION_START &&
-                sessionStartRecovered && { session_start_recovered: sessionStartRecovered }),
-            ...(eventType === EventType.SESSION_END && { session_end_reason: sessionEndReason ?? 'orphaned_cleanup' }),
-        });
+    async stopTracking() {
+        await this.cleanupSessionManager();
     }
-    startInitialSession() {
-        if (this.get('sessionId')) {
-            debugLog.debug('SessionHandler', 'Session already exists, skipping initial session creation');
+    destroy() {
+        if (this.destroyed) {
             return;
         }
-        debugLog.debug('SessionHandler', 'Starting initial session');
-        // Check if there's already a cross-tab session active
-        if (this.crossTabSessionManager) {
-            const existingSessionId = this.crossTabSessionManager.getSessionId();
-            if (existingSessionId) {
-                // Join existing cross-tab session
-                this.set('sessionId', existingSessionId);
-                this.persistSession(existingSessionId);
-                this.startHeartbeat();
-                return;
-            }
-            // No existing cross-tab session, so trigger activity to potentially create one
-            // The cross-tab session manager will handle session creation when activity occurs
-            return;
-        }
-        // Fallback: no cross-tab session manager, start regular session
-        debugLog.debug('SessionHandler', 'Starting regular session (no cross-tab)');
-        const sessionResult = this.sessionManager.startSession();
-        this.set('sessionId', sessionResult.sessionId);
-        this.trackSession(EventType.SESSION_START, sessionResult.recovered);
-        this.persistSession(sessionResult.sessionId);
-        this.startHeartbeat();
-    }
-    checkOrphanedSessions() {
-        const storedSessionData = this.storageManager.getItem(this.sessionStorageKey);
-        if (storedSessionData) {
-            try {
-                const session = JSON.parse(storedSessionData);
-                const now = Date.now();
-                const timeSinceLastHeartbeat = now - session.lastHeartbeat;
-                const sessionTimeout = this.get('config')?.sessionTimeout ?? DEFAULT_SESSION_TIMEOUT_MS;
-                if (timeSinceLastHeartbeat > sessionTimeout) {
-                    const canRecover = this.recoveryManager?.hasRecoverableSession();
-                    if (canRecover) {
-                        if (this.recoveryManager) {
-                            const sessionContext = {
-                                sessionId: session.sessionId,
-                                startTime: session.startTime,
-                                lastActivity: session.lastHeartbeat,
-                                tabCount: 1,
-                                recoveryAttempts: 0,
-                                metadata: {
-                                    userAgent: navigator.userAgent,
-                                    pageUrl: this.get('pageUrl'),
-                                },
-                            };
-                            this.recoveryManager.storeSessionContextForRecovery(sessionContext);
-                            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                                debugLog.debug('SessionHandler', `Orphaned session stored for recovery: ${session.sessionId}`);
-                            }
-                        }
-                    }
-                    this.trackSession(EventType.SESSION_END);
-                    this.clearPersistedSession();
-                    if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                        debugLog.debug('SessionHandler', `Orphaned session ended: ${session.sessionId}, recovery available: ${canRecover}`);
-                    }
-                }
-            }
-            catch {
-                this.clearPersistedSession();
-            }
-        }
-    }
-    persistSession(sessionId) {
-        const sessionData = {
-            sessionId,
-            startTime: Date.now(),
-            lastHeartbeat: Date.now(),
-        };
-        this.storageManager.setItem(this.sessionStorageKey, JSON.stringify(sessionData));
-    }
-    clearPersistedSession() {
-        this.storageManager.removeItem(this.sessionStorageKey);
-    }
-    startHeartbeat() {
-        this.stopHeartbeat();
-        this.heartbeatInterval = setInterval(() => {
-            const storedSessionData = this.storageManager.getItem(this.sessionStorageKey);
-            if (storedSessionData) {
-                try {
-                    const session = JSON.parse(storedSessionData);
-                    session.lastHeartbeat = Date.now();
-                    this.storageManager.setItem(this.sessionStorageKey, JSON.stringify(session));
-                }
-                catch {
-                    this.clearPersistedSession();
-                }
-            }
-        }, SESSION_HEARTBEAT_INTERVAL_MS);
-    }
-    stopHeartbeat() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = null;
+        if (this.sessionManager) {
+            this.sessionManager.destroy();
+            this.sessionManager = null;
         }
+        this.destroyed = true;
+        this.set('hasStartSession', false);
     }
 }

package/dist/esm/integrations/google-analytics.integration.d.ts

@@ -8,7 +8,6 @@ declare global {
 }
 export declare class GoogleAnalyticsIntegration extends StateManager {
     private isInitialized;
-    constructor();
     initialize(): Promise<void>;
     trackEvent(eventName: string, metadata: Record<string, MetadataType>): void;
     cleanup(): void;

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

@@ -1,8 +1,8 @@
-import { debugLog } from '../utils/logging';
+import { debugLog } from '../utils';
 import { StateManager } from '../managers/state.manager';
 export class GoogleAnalyticsIntegration extends StateManager {
     constructor() {
-        super();
+        super(...arguments);
         this.isInitialized = false;
     }
     async initialize() {
@@ -10,69 +10,35 @@ export class GoogleAnalyticsIntegration extends StateManager {
             return;
         }
         const measurementId = this.get('config').integrations?.googleAnalytics?.measurementId;
-        if (!measurementId?.trim()) {
-            debugLog.clientWarn('GoogleAnalytics', 'Google Analytics integration disabled - measurementId not configured', {
-                hasIntegrations: !!this.get('config').integrations,
-                hasGoogleAnalytics: !!this.get('config').integrations?.googleAnalytics,
-            });
-            return;
-        }
         const userId = this.get('userId');
-        if (!userId?.trim()) {
-            debugLog.warn('GoogleAnalytics', 'Google Analytics initialization delayed - userId not available', {
-                measurementId: measurementId.substring(0, 8) + '...',
-            });
+        if (!measurementId?.trim() || !userId?.trim()) {
             return;
         }
         try {
             if (this.isScriptAlreadyLoaded()) {
-                debugLog.info('GoogleAnalytics', 'Google Analytics script already loaded', { measurementId });
                 this.isInitialized = true;
                 return;
             }
             await this.loadScript(measurementId);
             this.configureGtag(measurementId, userId);
             this.isInitialized = true;
-            debugLog.info('GoogleAnalytics', 'Google Analytics integration initialized successfully', {
-                measurementId,
-                userId,
-            });
         }
         catch (error) {
-            debugLog.error('GoogleAnalytics', 'Google Analytics initialization failed', {
+            debugLog.error('GoogleAnalyticsIntegration', 'Initialization failed', {
                 error: error instanceof Error ? error.message : 'Unknown error',
-                measurementId,
-                userId,
             });
         }
     }
     trackEvent(eventName, metadata) {
-        if (!eventName?.trim()) {
-            debugLog.clientWarn('GoogleAnalytics', 'Event tracking skipped - invalid event name provided', {
-                eventName,
-                hasMetadata: !!metadata && Object.keys(metadata).length > 0,
-            });
-            return;
-        }
-        if (!this.isInitialized) {
-            return;
-        }
-        if (typeof window.gtag !== 'function') {
-            debugLog.warn('GoogleAnalytics', 'Event tracking failed - gtag function not available', {
-                eventName,
-                hasGtag: typeof window.gtag,
-                hasDataLayer: Array.isArray(window.dataLayer),
-            });
+        if (!eventName?.trim() || !this.isInitialized || typeof window.gtag !== 'function') {
             return;
         }
         try {
             window.gtag('event', eventName, metadata);
         }
         catch (error) {
-            debugLog.error('GoogleAnalytics', 'Event tracking failed', {
-                eventName,
+            debugLog.error('GoogleAnalyticsIntegration', 'Event tracking failed', {
                 error: error instanceof Error ? error.message : 'Unknown error',
-                metadataKeys: Object.keys(metadata || {}),
             });
         }
     }
@@ -82,74 +48,37 @@ export class GoogleAnalyticsIntegration extends StateManager {
         if (script) {
             script.remove();
         }
-        debugLog.info('GoogleAnalytics', 'Google Analytics integration cleanup completed');
     }
     isScriptAlreadyLoaded() {
-        const tracelogScript = document.getElementById('tracelog-ga-script');
-        if (tracelogScript) {
+        // Check if we already loaded the script
+        if (document.getElementById('tracelog-ga-script')) {
             return true;
         }
+        // Check if GA is already loaded by another source
         const existingGAScript = document.querySelector('script[src*="googletagmanager.com/gtag/js"]');
-        if (existingGAScript) {
-            debugLog.clientWarn('GoogleAnalytics', 'Google Analytics script already loaded from external source', {
-                scriptSrc: existingGAScript.getAttribute('src'),
-                hasGtag: typeof window.gtag === 'function',
-            });
-            return true;
-        }
-        return false;
+        return !!existingGAScript;
     }
     async loadScript(measurementId) {
         return new Promise((resolve, reject) => {
-            try {
-                const script = document.createElement('script');
-                script.id = 'tracelog-ga-script';
-                script.async = true;
-                script.src = `https://www.googletagmanager.com/gtag/js?id=${measurementId}`;
-                script.onload = () => {
-                    resolve();
-                };
-                script.onerror = () => {
-                    const error = new Error('Failed to load Google Analytics script');
-                    debugLog.error('GoogleAnalytics', 'Google Analytics script load failed', {
-                        measurementId,
-                        error: error.message,
-                        scriptSrc: script.src,
-                    });
-                    reject(error);
-                };
-                document.head.appendChild(script);
-            }
-            catch (error) {
-                const errorMsg = error instanceof Error ? error : new Error(String(error));
-                debugLog.error('GoogleAnalytics', 'Error creating Google Analytics script', {
-                    measurementId,
-                    error: errorMsg.message,
-                });
-                reject(errorMsg);
-            }
+            const script = document.createElement('script');
+            script.id = 'tracelog-ga-script';
+            script.async = true;
+            script.src = `https://www.googletagmanager.com/gtag/js?id=${measurementId}`;
+            script.onload = () => resolve();
+            script.onerror = () => reject(new Error('Failed to load Google Analytics script'));
+            document.head.appendChild(script);
         });
     }
     configureGtag(measurementId, userId) {
-        try {
-            const gaScriptConfig = document.createElement('script');
-            gaScriptConfig.innerHTML = `
-        window.dataLayer = window.dataLayer || [];
-        function gtag(){dataLayer.push(arguments);}
-        gtag('js', new Date());
-        gtag('config', '${measurementId}', {
-          'user_id': '${userId}'
-        });
-      `;
-            document.head.appendChild(gaScriptConfig);
-        }
-        catch (error) {
-            debugLog.error('GoogleAnalytics', 'Failed to configure Google Analytics', {
-                measurementId,
-                userId,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
-            throw error;
-        }
+        const gaScriptConfig = document.createElement('script');
+        gaScriptConfig.innerHTML = `
+      window.dataLayer = window.dataLayer || [];
+      function gtag(){dataLayer.push(arguments);}
+      gtag('js', new Date());
+      gtag('config', '${measurementId}', {
+        'user_id': '${userId}'
+      });
+    `;
+        document.head.appendChild(gaScriptConfig);
     }
 }

package/dist/esm/listeners/input-listener-managers.d.ts

@@ -1,15 +1,24 @@
 import { EventListenerManager } from './listeners.types';
-export declare class MouseListenerManager implements EventListenerManager {
-    private readonly onActivity;
-    private readonly options;
+/**
+ * Base class for input listener managers to reduce code duplication
+ */
+declare abstract class BaseInputListenerManager implements EventListenerManager {
+    protected readonly onActivity: () => void;
+    protected readonly options: {
+        passive: boolean;
+    };
+    protected abstract readonly events: string[];
+    protected abstract readonly logPrefix: string;
     constructor(onActivity: () => void);
     setup(): void;
     cleanup(): void;
 }
-export declare class KeyboardListenerManager implements EventListenerManager {
-    private readonly onActivity;
-    private readonly options;
-    constructor(onActivity: () => void);
-    setup(): void;
-    cleanup(): void;
+export declare class MouseListenerManager extends BaseInputListenerManager {
+    protected readonly events: string[];
+    protected readonly logPrefix = "MouseListenerManager";
+}
+export declare class KeyboardListenerManager extends BaseInputListenerManager {
+    protected readonly events: string[];
+    protected readonly logPrefix = "KeyboardListenerManager";
 }
+export {};