@tracelog/lib 0.5.4 → 0.6.0

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TouchListenerManager = void 0;
-const logging_1 = require("../utils/logging");
+const utils_1 = require("../utils");
 class TouchListenerManager {
     constructor(onActivity) {
         this.options = { passive: true };
@@ -15,7 +15,7 @@ class TouchListenerManager {
             window.addEventListener('orientationchange', this.onActivity, this.options);
         }
         catch (error) {
-            logging_1.debugLog.error('TouchListenerManager', 'Failed to setup touch listeners', { error });
+            (0, utils_1.log)('error', 'Failed to setup touch listeners', { error });
             throw error;
         }
     }
@@ -27,7 +27,7 @@ class TouchListenerManager {
             window.removeEventListener('orientationchange', this.onActivity);
         }
         catch (error) {
-            logging_1.debugLog.warn('TouchListenerManager', 'Error during touch listeners cleanup', { error });
+            (0, utils_1.log)('warn', 'Error during touch listeners cleanup', { error });
         }
     }
 }

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnloadListenerManager = void 0;
-const logging_1 = require("../utils/logging");
+const utils_1 = require("../utils");
 class UnloadListenerManager {
     constructor(onInactivity) {
         this.options = { passive: true };
@@ -13,7 +13,7 @@ class UnloadListenerManager {
             window.addEventListener('pagehide', this.onInactivity, this.options);
         }
         catch (error) {
-            logging_1.debugLog.error('UnloadListenerManager', 'Failed to setup unload listeners', { error });
+            (0, utils_1.log)('error', 'Failed to setup unload listeners', { error });
             throw error;
         }
     }
@@ -23,7 +23,7 @@ class UnloadListenerManager {
             window.removeEventListener('pagehide', this.onInactivity);
         }
         catch (error) {
-            logging_1.debugLog.warn('UnloadListenerManager', 'Error during unload listeners cleanup', { error });
+            (0, utils_1.log)('warn', 'Error during unload listeners cleanup', { error });
         }
     }
 }

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VisibilityListenerManager = void 0;
-const logging_1 = require("../utils/logging");
+const utils_1 = require("../utils");
 class VisibilityListenerManager {
     constructor(onActivity, onVisibilityChange) {
         this.options = { passive: true };
@@ -24,7 +24,7 @@ class VisibilityListenerManager {
             }
         }
         catch (error) {
-            logging_1.debugLog.error('VisibilityListenerManager', 'Failed to setup visibility listeners', { error });
+            (0, utils_1.log)('error', 'Failed to setup visibility listeners', { error });
         }
     }
     cleanup() {
@@ -40,7 +40,7 @@ class VisibilityListenerManager {
             }
         }
         catch (error) {
-            logging_1.debugLog.warn('VisibilityListenerManager', 'Error during visibility listeners cleanup', { error });
+            (0, utils_1.log)('warn', 'Error during visibility listeners cleanup', { error });
         }
     }
 }

package/dist/cjs/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/cjs/managers/event.manager.js

@@ -10,6 +10,7 @@ class EventManager extends state_manager_1.StateManager {
     constructor(storeManager, googleAnalytics = null, emitter = null) {
         super();
         this.eventsQueue = [];
+        this.pendingEventsBuffer = [];
         this.lastEventFingerprint = null;
         this.lastEventTime = 0;
         this.sendIntervalId = null;
@@ -21,7 +22,7 @@ class EventManager extends state_manager_1.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);
@@ -29,13 +30,27 @@ class EventManager extends state_manager_1.StateManager {
                 }
             },
             onFailure: async () => {
-                utils_1.debugLog.warn('EventManager', 'Failed to recover persisted events');
+                (0, utils_1.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) {
-            utils_1.debugLog.warn('EventManager', 'Event type is required');
+            (0, utils_1.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;
@@ -54,21 +69,18 @@ class EventManager extends state_manager_1.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) {
-                utils_1.debugLog.warn('EventManager', 'Session start event ignored: missing sessionId');
+                (0, utils_1.log)('warn', 'Session start event ignored: missing sessionId');
                 return;
             }
             if (this.get('hasStartSession')) {
-                utils_1.debugLog.warn('EventManager', 'Duplicate session_start detected', {
-                    sessionId: currentSessionId,
+                (0, utils_1.log)('warn', 'Duplicate session_start detected', {
+                    data: { sessionId: currentSessionId },
                 });
                 return;
             }
@@ -77,6 +89,14 @@ class EventManager extends state_manager_1.StateManager {
         if (this.isDuplicateEvent(payload)) {
             return;
         }
+        if (this.get('mode') === types_1.Mode.QA && eventType === types_1.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() {
@@ -85,6 +105,7 @@ class EventManager extends state_manager_1.StateManager {
             this.sendIntervalId = null;
         }
         this.eventsQueue = [];
+        this.pendingEventsBuffer = [];
         this.lastEventFingerprint = null;
         this.lastEventTime = 0;
         this.dataSender.stop();
@@ -98,6 +119,20 @@ class EventManager extends state_manager_1.StateManager {
     getQueueLength() {
         return this.eventsQueue.length;
     }
+    flushPendingEvents() {
+        if (this.pendingEventsBuffer.length === 0) {
+            return;
+        }
+        if (!this.get('sessionId')) {
+            (0, utils_1.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);
@@ -110,7 +145,7 @@ class EventManager extends state_manager_1.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) {
@@ -128,8 +163,8 @@ class EventManager extends state_manager_1.StateManager {
                     this.emitEventsQueue(body);
                 },
                 onFailure: () => {
-                    utils_1.debugLog.warn('EventManager', 'Async flush failed', {
-                        eventCount: eventsToSend.length,
+                    (0, utils_1.log)('warn', 'Async flush failed', {
+                        data: { eventCount: eventsToSend.length },
                     });
                 },
             });
@@ -141,15 +176,15 @@ class EventManager extends state_manager_1.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 () => {
-                utils_1.debugLog.warn('EventManager', 'Events send failed, keeping in queue', {
-                    eventCount: eventsToSend.length,
+                (0, utils_1.log)('warn', 'Events send failed, keeping in queue', {
+                    data: { eventCount: eventsToSend.length },
                 });
             },
         });
@@ -180,6 +215,7 @@ class EventManager extends state_manager_1.StateManager {
         const isSessionStart = data.type === types_1.EventType.SESSION_START;
         const currentPageUrl = data.page_url ?? this.get('pageUrl');
         const payload = {
+            id: (0, utils_1.generateEventId)(),
             type: data.type,
             page_url: currentPageUrl,
             timestamp: Date.now(),
@@ -193,23 +229,8 @@ class EventManager extends state_manager_1.StateManager {
             ...(data.session_end_reason && { session_end_reason: data.session_end_reason }),
             ...(isSessionStart && (0, utils_1.getUTMParameters)() && { utm: (0, utils_1.getUTMParameters)() }),
         };
-        const projectTags = this.get('config')?.tags;
-        if (projectTags?.length) {
-            payload.tags = projectTags;
-        }
         return payload;
     }
-    isEventExcluded(event) {
-        const config = this.get('config');
-        const isRouteExcluded = (0, utils_1.isUrlPathExcluded)(event.page_url, config?.excludedUrlPaths ?? []);
-        const hasStartSession = this.get('hasStartSession');
-        const isSessionEndEvent = event.type === types_1.EventType.SESSION_END;
-        const isSessionStartEvent = event.type === types_1.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);
@@ -250,11 +271,13 @@ class EventManager extends state_manager_1.StateManager {
         if (this.eventsQueue.length > config_constants_1.MAX_EVENTS_QUEUE_LENGTH) {
             const nonCriticalIndex = this.eventsQueue.findIndex((e) => e.type !== types_1.EventType.SESSION_START && e.type !== types_1.EventType.SESSION_END);
             const removedEvent = nonCriticalIndex >= 0 ? this.eventsQueue.splice(nonCriticalIndex, 1)[0] : this.eventsQueue.shift();
-            utils_1.debugLog.warn('EventManager', 'Event queue overflow, oldest non-critical event removed', {
-                maxLength: config_constants_1.MAX_EVENTS_QUEUE_LENGTH,
-                currentLength: this.eventsQueue.length,
-                removedEventType: removedEvent?.type,
-                wasCritical: removedEvent?.type === types_1.EventType.SESSION_START || removedEvent?.type === types_1.EventType.SESSION_END,
+            (0, utils_1.log)('warn', 'Event queue overflow, oldest non-critical event removed', {
+                data: {
+                    maxLength: config_constants_1.MAX_EVENTS_QUEUE_LENGTH,
+                    currentLength: this.eventsQueue.length,
+                    removedEventType: removedEvent?.type,
+                    wasCritical: removedEvent?.type === types_1.EventType.SESSION_START || removedEvent?.type === types_1.EventType.SESSION_END,
+                },
             });
         }
         if (!this.sendIntervalId) {
@@ -271,7 +294,7 @@ class EventManager extends state_manager_1.StateManager {
     }
     handleGoogleAnalyticsIntegration(event) {
         if (this.googleAnalytics && event.type === types_1.EventType.CUSTOM && event.custom_event) {
-            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
+            if (this.get('mode') === types_1.Mode.QA) {
                 return;
             }
             this.googleAnalytics.trackEvent(event.custom_event.name, event.custom_event.metadata ?? {});
@@ -284,8 +307,7 @@ class EventManager extends state_manager_1.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) {

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

@@ -14,9 +14,8 @@ class SenderManager extends state_manager_1.StateManager {
         this.storeManager = storeManager;
     }
     getQueueStorageKey() {
-        const projectId = this.get('config')?.id || 'default';
         const userId = this.get('userId') || 'anonymous';
-        return `${(0, constants_1.QUEUE_KEY)(projectId)}:${userId}`;
+        return (0, constants_1.QUEUE_KEY)(userId);
     }
     sendEventsQueueSync(body) {
         if (this.shouldSkipSend()) {
@@ -24,9 +23,9 @@ class SenderManager extends state_manager_1.StateManager {
             return true;
         }
         const config = this.get('config');
-        if (config?.id === types_1.SpecialProjectId.Fail) {
-            utils_1.debugLog.warn('SenderManager', 'Fail mode: simulating network failure (sync)', {
-                events: body.events.length,
+        if (config?.integrations?.custom?.apiUrl === types_1.SpecialApiUrl.Fail) {
+            (0, utils_1.log)('warn', 'Fail mode: simulating network failure (sync)', {
+                data: { events: body.events.length },
             });
             return false;
         }
@@ -37,9 +36,11 @@ class SenderManager extends state_manager_1.StateManager {
         return success;
     }
     async sendEventsQueue(body, callbacks) {
-        const persisted = this.persistEvents(body);
-        if (!persisted && !this.shouldSkipSend()) {
-            utils_1.debugLog.warn('SenderManager', 'Failed to persist events, attempting immediate send');
+        if (!this.shouldSkipSend()) {
+            const persisted = this.persistEvents(body);
+            if (!persisted) {
+                (0, utils_1.log)('warn', 'Failed to persist events, attempting immediate send');
+            }
         }
         const success = await this.send(body);
         if (success) {
@@ -73,7 +74,7 @@ class SenderManager extends state_manager_1.StateManager {
             }
         }
         catch (error) {
-            utils_1.debugLog.error('SenderManager', 'Failed to recover persisted events', { error });
+            (0, utils_1.log)('error', 'Failed to recover persisted events', { error });
             this.clearPersistedEvents();
         }
     }
@@ -92,9 +93,9 @@ class SenderManager extends state_manager_1.StateManager {
             return this.simulateSuccessfulSend();
         }
         const config = this.get('config');
-        if (config?.id === types_1.SpecialProjectId.Fail) {
-            utils_1.debugLog.warn('SenderManager', 'Fail mode: simulating network failure', {
-                events: body.events.length,
+        if (config?.integrations?.custom?.apiUrl === types_1.SpecialApiUrl.Fail) {
+            (0, utils_1.log)('warn', 'Fail mode: simulating network failure', {
+                data: { events: body.events.length },
             });
             return false;
         }
@@ -104,11 +105,12 @@ class SenderManager extends state_manager_1.StateManager {
             return response.ok;
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            utils_1.debugLog.error('SenderManager', 'Send request failed', {
-                error: errorMessage,
-                events: body.events.length,
-                url: url.replace(/\/\/[^/]+/, '//[DOMAIN]'),
+            (0, utils_1.log)('error', 'Send request failed', {
+                error,
+                data: {
+                    events: body.events.length,
+                    url: url.replace(/\/\/[^/]+/, '//[DOMAIN]'),
+                },
             });
             return false;
         }
@@ -116,18 +118,16 @@ class SenderManager extends state_manager_1.StateManager {
     async sendWithTimeout(url, payload) {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), constants_1.REQUEST_TIMEOUT_MS);
-        const config = this.get('config');
         try {
             const response = await fetch(url, {
                 method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'X-TraceLog-Project': config?.id || 'unknown',
-                },
                 body: payload,
                 keepalive: true,
                 credentials: 'include',
                 signal: controller.signal,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
             });
             if (!response.ok) {
                 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
@@ -146,10 +146,10 @@ class SenderManager extends state_manager_1.StateManager {
             if (success) {
                 return true;
             }
-            utils_1.debugLog.warn('SenderManager', 'sendBeacon failed, persisting events for recovery');
+            (0, utils_1.log)('warn', 'sendBeacon failed, persisting events for recovery');
         }
         else {
-            utils_1.debugLog.warn('SenderManager', 'sendBeacon not available, persisting events for recovery');
+            (0, utils_1.log)('warn', 'sendBeacon not available, persisting events for recovery');
         }
         this.persistEventsForRecovery(body);
         return false;
@@ -179,7 +179,7 @@ class SenderManager extends state_manager_1.StateManager {
             }
         }
         catch (error) {
-            utils_1.debugLog.warn('SenderManager', 'Failed to parse persisted data', { error });
+            (0, utils_1.log)('warn', 'Failed to parse persisted data', { error });
             this.clearPersistedEvents();
         }
         return null;
@@ -216,7 +216,7 @@ class SenderManager extends state_manager_1.StateManager {
             return !!this.storeManager.getItem(storageKey);
         }
         catch (error) {
-            utils_1.debugLog.warn('SenderManager', 'Failed to persist events', { error });
+            (0, utils_1.log)('warn', 'Failed to persist events', { error });
             return false;
         }
     }
@@ -226,7 +226,7 @@ class SenderManager extends state_manager_1.StateManager {
             this.storeManager.removeItem(key);
         }
         catch (error) {
-            utils_1.debugLog.warn('SenderManager', 'Failed to clear persisted events', { error });
+            (0, utils_1.log)('warn', 'Failed to clear persisted events', { error });
         }
     }
     resetRetryState() {
@@ -239,7 +239,7 @@ class SenderManager extends state_manager_1.StateManager {
             return;
         }
         if (this.retryCount >= constants_1.MAX_RETRIES) {
-            utils_1.debugLog.warn('SenderManager', 'Max retries reached, giving up', { retryCount: this.retryCount });
+            (0, utils_1.log)('warn', 'Max retries reached, giving up', { data: { retryCount: this.retryCount } });
             this.clearPersistedEvents();
             this.resetRetryState();
             originalCallbacks?.onFailure?.();
@@ -270,16 +270,9 @@ class SenderManager extends state_manager_1.StateManager {
                 this.isRetrying = false;
             }
         }, retryDelay);
-        utils_1.debugLog.debug('SenderManager', 'Retry scheduled', {
-            attempt: this.retryCount + 1,
-            delay: retryDelay,
-            events: body.events.length,
-        });
     }
     shouldSkipSend() {
-        const config = this.get('config');
-        const { id } = config || {};
-        return id === types_1.SpecialProjectId.Skip;
+        return !this.get('apiUrl');
     }
     async simulateSuccessfulSend() {
         const delay = Math.random() * 400 + 100;

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionManager = void 0;
 const constants_1 = require("../constants");
 const types_1 = require("../types");
-const logging_1 = require("../utils/logging");
+const utils_1 = require("../utils");
 const state_manager_1 = require("./state.manager");
 class SessionManager extends state_manager_1.StateManager {
     constructor(storageManager, eventManager, projectId) {
@@ -20,7 +20,7 @@ class SessionManager extends state_manager_1.StateManager {
     }
     initCrossTabSync() {
         if (typeof BroadcastChannel === 'undefined') {
-            logging_1.debugLog.warn('SessionManager', 'BroadcastChannel not supported');
+            (0, utils_1.log)('warn', 'BroadcastChannel not supported');
             return;
         }
         const projectId = this.getProjectId();
@@ -31,7 +31,6 @@ class SessionManager extends state_manager_1.StateManager {
                 return;
             }
             if (action === 'session_end') {
-                logging_1.debugLog.debug('SessionManager', 'Session end synced from another tab');
                 this.resetSessionState();
                 return;
             }
@@ -42,7 +41,6 @@ class SessionManager extends state_manager_1.StateManager {
                 if (this.isTracking) {
                     this.setupSessionTimeout();
                 }
-                logging_1.debugLog.debug('SessionManager', 'Session synced from another tab', { sessionId });
             }
         };
     }
@@ -85,11 +83,9 @@ class SessionManager extends state_manager_1.StateManager {
         }
         const sessionTimeout = this.get('config')?.sessionTimeout ?? constants_1.DEFAULT_SESSION_TIMEOUT;
         if (Date.now() - storedSession.lastActivity > sessionTimeout) {
-            logging_1.debugLog.debug('SessionManager', 'Stored session expired');
             this.clearStoredSession();
             return null;
         }
-        logging_1.debugLog.info('SessionManager', 'Session recovered from storage', { sessionId: storedSession.id });
         return storedSession.id;
     }
     persistSession(sessionId, lastActivity = Date.now()) {
@@ -132,7 +128,7 @@ class SessionManager extends state_manager_1.StateManager {
     }
     async startTracking() {
         if (this.isTracking) {
-            logging_1.debugLog.warn('SessionManager', 'Session tracking already active');
+            (0, utils_1.log)('warn', 'Session tracking already active');
             return;
         }
         const recoveredSessionId = this.recoverSession();
@@ -152,7 +148,6 @@ class SessionManager extends state_manager_1.StateManager {
             this.setupSessionTimeout();
             this.setupActivityListeners();
             this.setupLifecycleListeners();
-            logging_1.debugLog.info('SessionManager', 'Session tracking started', { sessionId, recovered: isRecovered });
         }
         catch (error) {
             this.isTracking = false;
@@ -235,11 +230,10 @@ class SessionManager extends state_manager_1.StateManager {
     async endSession(reason) {
         const sessionId = this.get('sessionId');
         if (!sessionId) {
-            logging_1.debugLog.warn('SessionManager', 'endSession called without active session', { reason });
+            (0, utils_1.log)('warn', 'endSession called without active session', { data: { reason } });
             this.resetSessionState(reason);
             return;
         }
-        logging_1.debugLog.info('SessionManager', 'Ending session', { sessionId, reason });
         this.eventManager.track({
             type: types_1.EventType.SESSION_END,
             session_end_reason: reason,
@@ -258,9 +252,7 @@ class SessionManager extends state_manager_1.StateManager {
             finalize();
         }
         catch (error) {
-            logging_1.debugLog.warn('SessionManager', 'Async flush failed during session end', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
+            (0, utils_1.log)('warn', 'Async flush failed during session end', { error });
             finalize();
         }
     }

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

@@ -5,7 +5,4 @@ export declare abstract class StateManager {
     protected get<T extends keyof State>(key: T): State[T];
     protected set<T extends keyof State>(key: T, value: State[T]): void;
     protected getState(): Readonly<State>;
-    private isCriticalStateKey;
-    private shouldLog;
-    private formatLogValue;
 }

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

@@ -3,8 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StateManager = void 0;
 exports.getGlobalState = getGlobalState;
 exports.resetGlobalState = resetGlobalState;
-const logging_1 = require("../utils/logging");
-const constants_1 = require("../constants");
 const globalState = {};
 function getGlobalState() {
     return globalState;
@@ -19,50 +17,10 @@ class StateManager {
         return globalState[key];
     }
     set(key, value) {
-        const oldValue = globalState[key];
-        if (key === 'config' && value) {
-            const configValue = value;
-            if (configValue) {
-                const samplingRate = configValue.samplingRate ?? constants_1.DEFAULT_SAMPLING_RATE;
-                const normalizedSamplingRate = samplingRate < 0 || samplingRate > 1 ? constants_1.DEFAULT_SAMPLING_RATE : samplingRate;
-                const hasNormalizedSampling = normalizedSamplingRate !== samplingRate;
-                if (hasNormalizedSampling) {
-                    const normalizedConfig = { ...configValue, samplingRate: normalizedSamplingRate };
-                    globalState[key] = normalizedConfig;
-                }
-                else {
-                    globalState[key] = configValue;
-                }
-            }
-            else {
-                globalState[key] = value;
-            }
-        }
-        else {
-            globalState[key] = value;
-        }
-        if (this.isCriticalStateKey(key) && this.shouldLog(oldValue, globalState[key])) {
-            logging_1.debugLog.debug('StateManager', 'State updated', {
-                key,
-                oldValue: this.formatLogValue(key, oldValue),
-                newValue: this.formatLogValue(key, globalState[key]),
-            });
-        }
+        globalState[key] = value;
     }
     getState() {
         return { ...globalState };
     }
-    isCriticalStateKey(key) {
-        return key === 'sessionId' || key === 'config' || key === 'hasStartSession';
-    }
-    shouldLog(oldValue, newValue) {
-        return oldValue !== newValue;
-    }
-    formatLogValue(key, value) {
-        if (key === 'config') {
-            return value ? '(configured)' : '(not configured)';
-        }
-        return value;
-    }
 }
 exports.StateManager = StateManager;