@tracelog/lib 0.5.4 → 0.6.0

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

@@ -1,8 +1,7 @@
 import { StateManager } from '../managers/state.manager';
 import { EventType } from '../types';
-import { LONG_TASK_THROTTLE_MS, PRECISION_TWO_DECIMALS } from '../constants';
-import { WEB_VITALS_THRESHOLDS } from '../constants/performance.constants';
-import { debugLog } from '../utils/logging';
+import { LONG_TASK_THROTTLE_MS, PRECISION_TWO_DECIMALS, WEB_VITALS_THRESHOLDS } from '../constants';
+import { log } from '@/utils';
 export class PerformanceHandler extends StateManager {
     constructor(eventManager) {
         super();
@@ -22,10 +21,7 @@ export class PerformanceHandler extends StateManager {
                 obs.disconnect();
             }
             catch (error) {
-                debugLog.warn('PerformanceHandler', 'Failed to disconnect performance observer', {
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                    observerIndex: index,
-                });
+                log('warn', 'Failed to disconnect performance observer', { error, data: { observerIndex: index } });
             }
         });
         this.observers.length = 0;
@@ -98,9 +94,7 @@ export class PerformanceHandler extends StateManager {
             onINP(report('INP'));
         }
         catch (error) {
-            debugLog.warn('PerformanceHandler', 'Failed to load web-vitals library, using fallback', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
+            log('warn', 'Failed to load web-vitals library, using fallback', { error });
             this.observeWebVitalsFallback();
         }
     }
@@ -121,9 +115,7 @@ export class PerformanceHandler extends StateManager {
             }
         }
         catch (error) {
-            debugLog.warn('PerformanceHandler', 'Failed to report TTFB', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
+            log('warn', 'Failed to report TTFB', { error });
         }
     }
     observeLongTasks() {
@@ -165,7 +157,7 @@ export class PerformanceHandler extends StateManager {
     }
     trackWebVital(type, value) {
         if (!Number.isFinite(value)) {
-            debugLog.warn('PerformanceHandler', 'Invalid web vital value', { type, value });
+            log('warn', 'Invalid web vital value', { data: { type, value } });
             return;
         }
         this.eventManager.track({
@@ -188,9 +180,7 @@ export class PerformanceHandler extends StateManager {
             return `${timestamp.toFixed(2)}_${window.location.pathname}_${random}`;
         }
         catch (error) {
-            debugLog.warn('PerformanceHandler', 'Failed to get navigation ID', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
+            log('warn', 'Failed to get navigation ID', { error });
             return null;
         }
     }
@@ -210,9 +200,9 @@ export class PerformanceHandler extends StateManager {
                     cb(list, observer);
                 }
                 catch (callbackError) {
-                    debugLog.warn('PerformanceHandler', 'Observer callback failed', {
-                        type,
-                        error: callbackError instanceof Error ? callbackError.message : 'Unknown error',
+                    log('warn', 'Observer callback failed', {
+                        error: callbackError,
+                        data: { type },
                     });
                 }
                 if (once) {
@@ -231,25 +221,20 @@ export class PerformanceHandler extends StateManager {
             return true;
         }
         catch (error) {
-            debugLog.warn('PerformanceHandler', 'Failed to create performance observer', {
-                type,
-                error: error instanceof Error ? error.message : 'Unknown error',
+            log('warn', 'Failed to create performance observer', {
+                error,
+                data: { type },
             });
             return false;
         }
     }
     shouldSendVital(type, value) {
         if (typeof value !== 'number' || !Number.isFinite(value)) {
-            debugLog.warn('PerformanceHandler', 'Invalid web vital value', { type, value });
+            log('warn', 'Invalid web vital value', { data: { type, value } });
             return false;
         }
         const threshold = this.vitalThresholds[type];
         if (typeof threshold === 'number' && value <= threshold) {
-            debugLog.debug('PerformanceHandler', 'Web vital below threshold, skipping', {
-                type,
-                value,
-                threshold,
-            });
             return false;
         }
         return true;

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

@@ -1,7 +1,7 @@
 import { MAX_SCROLL_EVENTS_PER_SESSION, MIN_SCROLL_DEPTH_CHANGE, SCROLL_DEBOUNCE_TIME_MS, SCROLL_MIN_EVENT_INTERVAL_MS, SIGNIFICANT_SCROLL_DELTA, } from '../constants';
 import { EventType, ScrollDirection } from '../types';
 import { StateManager } from '../managers/state.manager';
-import { debugLog } from '../utils/logging';
+import { log } from '../utils';
 export class ScrollHandler extends StateManager {
     constructor(eventManager) {
         super();
@@ -141,8 +141,8 @@ export class ScrollHandler extends StateManager {
             return;
         }
         this.limitWarningLogged = true;
-        debugLog.warn('ScrollHandler', 'Max scroll events per session reached', {
-            limit: this.maxEventsPerSession,
+        log('warn', 'Max scroll events per session reached', {
+            data: { limit: this.maxEventsPerSession },
         });
     }
     applyConfigOverrides() {
@@ -211,9 +211,10 @@ export class ScrollHandler extends StateManager {
             return document.querySelector(selector);
         }
         catch (error) {
-            debugLog.clientWarn('ScrollHandler', 'Invalid CSS selector', {
-                selector,
-                error: error instanceof Error ? error.message : 'Unknown error',
+            log('warn', 'Invalid CSS selector', {
+                error,
+                data: { selector },
+                showToClient: true,
             });
             return null;
         }

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

@@ -1,6 +1,6 @@
 import { SessionManager } from '../managers/session.manager';
 import { StateManager } from '../managers/state.manager';
-import { debugLog } from '../utils/logging';
+import { log } from '../utils';
 export class SessionHandler extends StateManager {
     constructor(storageManager, eventManager) {
         super();
@@ -14,16 +14,19 @@ export class SessionHandler extends StateManager {
             return;
         }
         if (this.destroyed) {
-            debugLog.warn('SessionHandler', 'Cannot start tracking on destroyed handler');
+            log('warn', 'Cannot start tracking on destroyed handler');
             return;
         }
-        const projectId = this.get('config')?.id;
+        const config = this.get('config');
+        const projectId = config?.integrations?.tracelog?.projectId ?? config?.integrations?.custom?.apiUrl ?? 'default';
         if (!projectId) {
             throw new Error('Cannot start session tracking: config not available');
         }
         try {
             this.sessionManager = new SessionManager(this.storageManager, this.eventManager, projectId);
             await this.sessionManager.startTracking();
+            // Flush any events that were buffered during initialization
+            this.eventManager.flushPendingEvents();
         }
         catch (error) {
             if (this.sessionManager) {
@@ -35,9 +38,7 @@ export class SessionHandler extends StateManager {
                 }
                 this.sessionManager = null;
             }
-            debugLog.error('SessionHandler', 'Failed to start session tracking', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
+            log('error', 'Failed to start session tracking', { error });
             throw error;
         }
     }

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

@@ -1,4 +1,4 @@
-import { debugLog } from '../utils';
+import { log } from '../utils';
 import { StateManager } from '../managers/state.manager';
 export class GoogleAnalyticsIntegration extends StateManager {
     constructor() {
@@ -24,9 +24,7 @@ export class GoogleAnalyticsIntegration extends StateManager {
             this.isInitialized = true;
         }
         catch (error) {
-            debugLog.error('GoogleAnalyticsIntegration', 'Initialization failed', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
+            log('error', 'Google Analytics initialization failed', { error });
         }
     }
     trackEvent(eventName, metadata) {
@@ -38,9 +36,7 @@ export class GoogleAnalyticsIntegration extends StateManager {
             window.gtag('event', eventName, normalizedMetadata);
         }
         catch (error) {
-            debugLog.error('GoogleAnalyticsIntegration', 'Event tracking failed', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
+            log('error', 'Google Analytics event tracking failed', { error });
         }
     }
     cleanup() {

package/dist/esm/listeners/activity-listener-manager.js

@@ -1,4 +1,4 @@
-import { debugLog } from '../utils/logging';
+import { log } from '../utils';
 export class ActivityListenerManager {
     constructor(onActivity) {
         this.options = { passive: true };
@@ -11,7 +11,7 @@ export class ActivityListenerManager {
             window.addEventListener('focus', this.onActivity, this.options);
         }
         catch (error) {
-            debugLog.error('ActivityListenerManager', 'Failed to setup activity listeners', { error });
+            log('error', 'Failed to setup activity listeners', { error });
             throw error;
         }
     }
@@ -22,7 +22,7 @@ export class ActivityListenerManager {
             window.removeEventListener('focus', this.onActivity);
         }
         catch (error) {
-            debugLog.warn('ActivityListenerManager', 'Error during activity listeners cleanup', { error });
+            log('warn', 'Error during activity listeners cleanup', { error });
         }
     }
 }

package/dist/esm/listeners/input-listener-managers.js

@@ -1,4 +1,4 @@
-import { debugLog } from '../utils/logging';
+import { log } from '../utils';
 /**
  * Base class for input listener managers to reduce code duplication
  */
@@ -14,7 +14,7 @@ class BaseInputListenerManager {
             });
         }
         catch (error) {
-            debugLog.error(this.logPrefix, `Failed to setup ${this.logPrefix.toLowerCase()} listeners`, { error });
+            log('error', `Failed to setup ${this.logPrefix.toLowerCase()} listeners`, { error });
         }
     }
     cleanup() {
@@ -24,7 +24,7 @@ class BaseInputListenerManager {
             });
         }
         catch (error) {
-            debugLog.warn(this.logPrefix, `Error during ${this.logPrefix.toLowerCase()} listeners cleanup`, { error });
+            log('warn', `Error during ${this.logPrefix.toLowerCase()} listeners cleanup`, { error });
         }
     }
 }

package/dist/esm/listeners/touch-listener-manager.js

@@ -1,4 +1,4 @@
-import { debugLog } from '../utils/logging';
+import { log } from '../utils';
 export class TouchListenerManager {
     constructor(onActivity) {
         this.options = { passive: true };
@@ -12,7 +12,7 @@ export class TouchListenerManager {
             window.addEventListener('orientationchange', this.onActivity, this.options);
         }
         catch (error) {
-            debugLog.error('TouchListenerManager', 'Failed to setup touch listeners', { error });
+            log('error', 'Failed to setup touch listeners', { error });
             throw error;
         }
     }
@@ -24,7 +24,7 @@ export class TouchListenerManager {
             window.removeEventListener('orientationchange', this.onActivity);
         }
         catch (error) {
-            debugLog.warn('TouchListenerManager', 'Error during touch listeners cleanup', { error });
+            log('warn', 'Error during touch listeners cleanup', { error });
         }
     }
 }

package/dist/esm/listeners/unload-listener-manager.js

@@ -1,4 +1,4 @@
-import { debugLog } from '../utils/logging';
+import { log } from '../utils';
 export class UnloadListenerManager {
     constructor(onInactivity) {
         this.options = { passive: true };
@@ -10,7 +10,7 @@ export class UnloadListenerManager {
             window.addEventListener('pagehide', this.onInactivity, this.options);
         }
         catch (error) {
-            debugLog.error('UnloadListenerManager', 'Failed to setup unload listeners', { error });
+            log('error', 'Failed to setup unload listeners', { error });
             throw error;
         }
     }
@@ -20,7 +20,7 @@ export class UnloadListenerManager {
             window.removeEventListener('pagehide', this.onInactivity);
         }
         catch (error) {
-            debugLog.warn('UnloadListenerManager', 'Error during unload listeners cleanup', { error });
+            log('warn', 'Error during unload listeners cleanup', { error });
         }
     }
 }

package/dist/esm/listeners/visibility-listener-manager.js

@@ -1,4 +1,4 @@
-import { debugLog } from '../utils/logging';
+import { log } from '../utils';
 export class VisibilityListenerManager {
     constructor(onActivity, onVisibilityChange) {
         this.options = { passive: true };
@@ -21,7 +21,7 @@ export class VisibilityListenerManager {
             }
         }
         catch (error) {
-            debugLog.error('VisibilityListenerManager', 'Failed to setup visibility listeners', { error });
+            log('error', 'Failed to setup visibility listeners', { error });
         }
     }
     cleanup() {
@@ -37,7 +37,7 @@ export class VisibilityListenerManager {
             }
         }
         catch (error) {
-            debugLog.warn('VisibilityListenerManager', 'Error during visibility listeners cleanup', { error });
+            log('warn', 'Error during visibility listeners cleanup', { error });
         }
     }
 }

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

@@ -8,6 +8,7 @@ export declare class EventManager extends StateManager {
     private readonly dataSender;
     private readonly emitter;
     private eventsQueue;
+    private pendingEventsBuffer;
     private lastEventFingerprint;
     private lastEventTime;
     private sendIntervalId;
@@ -18,12 +19,12 @@ export declare class EventManager extends StateManager {
     flushImmediately(): Promise<boolean>;
     flushImmediatelySync(): boolean;
     getQueueLength(): number;
+    flushPendingEvents(): void;
     private clearSendInterval;
     private flushEvents;
     private sendEventsQueue;
     private buildEventsPayload;
     private buildEventPayload;
-    private isEventExcluded;
     private isDuplicateEvent;
     private createEventFingerprint;
     private createEventSignature;

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

@@ -1,12 +1,13 @@
 import { EVENT_SENT_INTERVAL_MS, MAX_EVENTS_QUEUE_LENGTH, DUPLICATE_EVENT_THRESHOLD_MS, } from '../constants/config.constants';
-import { EmitterEvent, EventType } from '../types';
-import { getUTMParameters, isUrlPathExcluded, debugLog } from '../utils';
+import { EmitterEvent, EventType, Mode } from '../types';
+import { getUTMParameters, log, generateEventId } from '../utils';
 import { SenderManager } from './sender.manager';
 import { StateManager } from './state.manager';
 export class EventManager extends StateManager {
     constructor(storeManager, googleAnalytics = null, emitter = null) {
         super();
         this.eventsQueue = [];
+        this.pendingEventsBuffer = [];
         this.lastEventFingerprint = null;
         this.lastEventTime = 0;
         this.sendIntervalId = null;
@@ -18,7 +19,7 @@ export class EventManager extends StateManager {
         await this.dataSender.recoverPersistedEvents({
             onSuccess: (_eventCount, recoveredEvents, body) => {
                 if (recoveredEvents && recoveredEvents.length > 0) {
-                    const eventIds = recoveredEvents.map((e) => e.timestamp + '_' + e.type);
+                    const eventIds = recoveredEvents.map((e) => e.id);
                     this.removeProcessedEvents(eventIds);
                     if (body) {
                         this.emitEventsQueue(body);
@@ -26,13 +27,27 @@ export class EventManager extends StateManager {
                 }
             },
             onFailure: async () => {
-                debugLog.warn('EventManager', 'Failed to recover persisted events');
+                log('warn', 'Failed to recover persisted events');
             },
         });
     }
     track({ type, page_url, from_page_url, scroll_data, click_data, custom_event, web_vitals, error_data, session_end_reason, }) {
         if (!type) {
-            debugLog.warn('EventManager', 'Event type is required');
+            log('warn', 'Event type is required');
+            return;
+        }
+        if (!this.get('sessionId')) {
+            this.pendingEventsBuffer.push({
+                type,
+                page_url,
+                from_page_url,
+                scroll_data,
+                click_data,
+                custom_event,
+                web_vitals,
+                error_data,
+                session_end_reason,
+            });
             return;
         }
         const eventType = type;
@@ -51,21 +66,18 @@ export class EventManager extends StateManager {
             error_data,
             session_end_reason,
         });
-        if (this.isEventExcluded(payload)) {
-            return;
-        }
         if (!isCriticalEvent && !this.shouldSample()) {
             return;
         }
         if (isSessionStart) {
             const currentSessionId = this.get('sessionId');
             if (!currentSessionId) {
-                debugLog.warn('EventManager', 'Session start event ignored: missing sessionId');
+                log('warn', 'Session start event ignored: missing sessionId');
                 return;
             }
             if (this.get('hasStartSession')) {
-                debugLog.warn('EventManager', 'Duplicate session_start detected', {
-                    sessionId: currentSessionId,
+                log('warn', 'Duplicate session_start detected', {
+                    data: { sessionId: currentSessionId },
                 });
                 return;
             }
@@ -74,6 +86,14 @@ export class EventManager extends StateManager {
         if (this.isDuplicateEvent(payload)) {
             return;
         }
+        if (this.get('mode') === Mode.QA && eventType === EventType.CUSTOM && custom_event) {
+            console.log('[TraceLog] Event', {
+                name: custom_event.name,
+                ...(custom_event.metadata && { metadata: custom_event.metadata }),
+            });
+            this.emitEvent(payload);
+            return;
+        }
         this.addToQueue(payload);
     }
     stop() {
@@ -82,6 +102,7 @@ export class EventManager extends StateManager {
             this.sendIntervalId = null;
         }
         this.eventsQueue = [];
+        this.pendingEventsBuffer = [];
         this.lastEventFingerprint = null;
         this.lastEventTime = 0;
         this.dataSender.stop();
@@ -95,6 +116,20 @@ export class EventManager extends StateManager {
     getQueueLength() {
         return this.eventsQueue.length;
     }
+    flushPendingEvents() {
+        if (this.pendingEventsBuffer.length === 0) {
+            return;
+        }
+        if (!this.get('sessionId')) {
+            log('warn', 'Cannot flush pending events: session not initialized');
+            return;
+        }
+        const bufferedEvents = [...this.pendingEventsBuffer];
+        this.pendingEventsBuffer = [];
+        bufferedEvents.forEach((event) => {
+            this.track(event);
+        });
+    }
     clearSendInterval() {
         if (this.sendIntervalId) {
             clearInterval(this.sendIntervalId);
@@ -107,7 +142,7 @@ export class EventManager extends StateManager {
         }
         const body = this.buildEventsPayload();
         const eventsToSend = [...this.eventsQueue];
-        const eventIds = eventsToSend.map((e) => `${e.timestamp}_${e.type}`);
+        const eventIds = eventsToSend.map((e) => e.id);
         if (isSync) {
             const success = this.dataSender.sendEventsQueueSync(body);
             if (success) {
@@ -125,8 +160,8 @@ export class EventManager extends StateManager {
                     this.emitEventsQueue(body);
                 },
                 onFailure: () => {
-                    debugLog.warn('EventManager', 'Async flush failed', {
-                        eventCount: eventsToSend.length,
+                    log('warn', 'Async flush failed', {
+                        data: { eventCount: eventsToSend.length },
                     });
                 },
             });
@@ -138,15 +173,15 @@ export class EventManager extends StateManager {
         }
         const body = this.buildEventsPayload();
         const eventsToSend = [...this.eventsQueue];
-        const eventIds = eventsToSend.map((e) => `${e.timestamp}_${e.type}`);
+        const eventIds = eventsToSend.map((e) => e.id);
         await this.dataSender.sendEventsQueue(body, {
             onSuccess: () => {
                 this.removeProcessedEvents(eventIds);
                 this.emitEventsQueue(body);
             },
             onFailure: async () => {
-                debugLog.warn('EventManager', 'Events send failed, keeping in queue', {
-                    eventCount: eventsToSend.length,
+                log('warn', 'Events send failed, keeping in queue', {
+                    data: { eventCount: eventsToSend.length },
                 });
             },
         });
@@ -177,6 +212,7 @@ export class EventManager extends StateManager {
         const isSessionStart = data.type === EventType.SESSION_START;
         const currentPageUrl = data.page_url ?? this.get('pageUrl');
         const payload = {
+            id: generateEventId(),
             type: data.type,
             page_url: currentPageUrl,
             timestamp: Date.now(),
@@ -190,23 +226,8 @@ export class EventManager extends StateManager {
             ...(data.session_end_reason && { session_end_reason: data.session_end_reason }),
             ...(isSessionStart && getUTMParameters() && { utm: getUTMParameters() }),
         };
-        const projectTags = this.get('config')?.tags;
-        if (projectTags?.length) {
-            payload.tags = projectTags;
-        }
         return payload;
     }
-    isEventExcluded(event) {
-        const config = this.get('config');
-        const isRouteExcluded = isUrlPathExcluded(event.page_url, config?.excludedUrlPaths ?? []);
-        const hasStartSession = this.get('hasStartSession');
-        const isSessionEndEvent = event.type === EventType.SESSION_END;
-        const isSessionStartEvent = event.type === EventType.SESSION_START;
-        if (isRouteExcluded && !isSessionStartEvent && !(isSessionEndEvent && hasStartSession)) {
-            return true;
-        }
-        return config?.ipExcluded === true;
-    }
     isDuplicateEvent(event) {
         const now = Date.now();
         const fingerprint = this.createEventFingerprint(event);
@@ -247,11 +268,13 @@ export class EventManager extends StateManager {
         if (this.eventsQueue.length > MAX_EVENTS_QUEUE_LENGTH) {
             const nonCriticalIndex = this.eventsQueue.findIndex((e) => e.type !== EventType.SESSION_START && e.type !== EventType.SESSION_END);
             const removedEvent = nonCriticalIndex >= 0 ? this.eventsQueue.splice(nonCriticalIndex, 1)[0] : this.eventsQueue.shift();
-            debugLog.warn('EventManager', 'Event queue overflow, oldest non-critical event removed', {
-                maxLength: MAX_EVENTS_QUEUE_LENGTH,
-                currentLength: this.eventsQueue.length,
-                removedEventType: removedEvent?.type,
-                wasCritical: removedEvent?.type === EventType.SESSION_START || removedEvent?.type === EventType.SESSION_END,
+            log('warn', 'Event queue overflow, oldest non-critical event removed', {
+                data: {
+                    maxLength: MAX_EVENTS_QUEUE_LENGTH,
+                    currentLength: this.eventsQueue.length,
+                    removedEventType: removedEvent?.type,
+                    wasCritical: removedEvent?.type === EventType.SESSION_START || removedEvent?.type === EventType.SESSION_END,
+                },
             });
         }
         if (!this.sendIntervalId) {
@@ -268,7 +291,7 @@ export class EventManager extends StateManager {
     }
     handleGoogleAnalyticsIntegration(event) {
         if (this.googleAnalytics && event.type === EventType.CUSTOM && event.custom_event) {
-            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
+            if (this.get('mode') === Mode.QA) {
                 return;
             }
             this.googleAnalytics.trackEvent(event.custom_event.name, event.custom_event.metadata ?? {});
@@ -281,8 +304,7 @@ export class EventManager extends StateManager {
     removeProcessedEvents(eventIds) {
         const eventIdSet = new Set(eventIds);
         this.eventsQueue = this.eventsQueue.filter((event) => {
-            const eventId = `${event.timestamp}_${event.type}`;
-            return !eventIdSet.has(eventId);
+            return !eventIdSet.has(event.id);
         });
     }
     emitEvent(eventData) {