@tracelog/lib 0.5.4 → 0.6.0

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

@@ -1,6 +1,6 @@
 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 { SpecialApiUrl } from '../types';
+import { log } from '../utils';
 import { StateManager } from './state.manager';
 export class SenderManager extends StateManager {
     constructor(storeManager) {
@@ -11,9 +11,8 @@ export class SenderManager extends StateManager {
         this.storeManager = storeManager;
     }
     getQueueStorageKey() {
-        const projectId = this.get('config')?.id || 'default';
         const userId = this.get('userId') || 'anonymous';
-        return `${QUEUE_KEY(projectId)}:${userId}`;
+        return QUEUE_KEY(userId);
     }
     sendEventsQueueSync(body) {
         if (this.shouldSkipSend()) {
@@ -21,9 +20,9 @@ export class SenderManager extends StateManager {
             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,
+        if (config?.integrations?.custom?.apiUrl === SpecialApiUrl.Fail) {
+            log('warn', 'Fail mode: simulating network failure (sync)', {
+                data: { events: body.events.length },
             });
             return false;
         }
@@ -34,9 +33,11 @@ export class SenderManager extends StateManager {
         return success;
     }
     async sendEventsQueue(body, callbacks) {
-        const persisted = this.persistEvents(body);
-        if (!persisted && !this.shouldSkipSend()) {
-            debugLog.warn('SenderManager', 'Failed to persist events, attempting immediate send');
+        if (!this.shouldSkipSend()) {
+            const persisted = this.persistEvents(body);
+            if (!persisted) {
+                log('warn', 'Failed to persist events, attempting immediate send');
+            }
         }
         const success = await this.send(body);
         if (success) {
@@ -70,7 +71,7 @@ export class SenderManager extends StateManager {
             }
         }
         catch (error) {
-            debugLog.error('SenderManager', 'Failed to recover persisted events', { error });
+            log('error', 'Failed to recover persisted events', { error });
             this.clearPersistedEvents();
         }
     }
@@ -89,9 +90,9 @@ export class SenderManager extends StateManager {
             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,
+        if (config?.integrations?.custom?.apiUrl === SpecialApiUrl.Fail) {
+            log('warn', 'Fail mode: simulating network failure', {
+                data: { events: body.events.length },
             });
             return false;
         }
@@ -101,11 +102,12 @@ export class SenderManager extends StateManager {
             return response.ok;
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            debugLog.error('SenderManager', 'Send request failed', {
-                error: errorMessage,
-                events: body.events.length,
-                url: url.replace(/\/\/[^/]+/, '//[DOMAIN]'),
+            log('error', 'Send request failed', {
+                error,
+                data: {
+                    events: body.events.length,
+                    url: url.replace(/\/\/[^/]+/, '//[DOMAIN]'),
+                },
             });
             return false;
         }
@@ -113,18 +115,16 @@ 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,
                 credentials: 'include',
                 signal: controller.signal,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
             });
             if (!response.ok) {
                 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
@@ -143,10 +143,10 @@ export class SenderManager extends StateManager {
             if (success) {
                 return true;
             }
-            debugLog.warn('SenderManager', 'sendBeacon failed, persisting events for recovery');
+            log('warn', 'sendBeacon failed, persisting events for recovery');
         }
         else {
-            debugLog.warn('SenderManager', 'sendBeacon not available, persisting events for recovery');
+            log('warn', 'sendBeacon not available, persisting events for recovery');
         }
         this.persistEventsForRecovery(body);
         return false;
@@ -176,7 +176,7 @@ export class SenderManager extends StateManager {
             }
         }
         catch (error) {
-            debugLog.warn('SenderManager', 'Failed to parse persisted data', { error });
+            log('warn', 'Failed to parse persisted data', { error });
             this.clearPersistedEvents();
         }
         return null;
@@ -213,7 +213,7 @@ export class SenderManager extends StateManager {
             return !!this.storeManager.getItem(storageKey);
         }
         catch (error) {
-            debugLog.warn('SenderManager', 'Failed to persist events', { error });
+            log('warn', 'Failed to persist events', { error });
             return false;
         }
     }
@@ -223,7 +223,7 @@ export class SenderManager extends StateManager {
             this.storeManager.removeItem(key);
         }
         catch (error) {
-            debugLog.warn('SenderManager', 'Failed to clear persisted events', { error });
+            log('warn', 'Failed to clear persisted events', { error });
         }
     }
     resetRetryState() {
@@ -236,7 +236,7 @@ export class SenderManager extends StateManager {
             return;
         }
         if (this.retryCount >= MAX_RETRIES) {
-            debugLog.warn('SenderManager', 'Max retries reached, giving up', { retryCount: this.retryCount });
+            log('warn', 'Max retries reached, giving up', { data: { retryCount: this.retryCount } });
             this.clearPersistedEvents();
             this.resetRetryState();
             originalCallbacks?.onFailure?.();
@@ -267,16 +267,9 @@ export class SenderManager extends StateManager {
                 this.isRetrying = false;
             }
         }, retryDelay);
-        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 === SpecialProjectId.Skip;
+        return !this.get('apiUrl');
     }
     async simulateSuccessfulSend() {
         const delay = Math.random() * 400 + 100;

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

@@ -1,6 +1,6 @@
 import { BROADCAST_CHANNEL_NAME, DEFAULT_SESSION_TIMEOUT, SESSION_STORAGE_KEY } from '../constants';
 import { EventType } from '../types';
-import { debugLog } from '../utils/logging';
+import { log } from '../utils';
 import { StateManager } from './state.manager';
 export class SessionManager extends StateManager {
     constructor(storageManager, eventManager, projectId) {
@@ -17,7 +17,7 @@ export class SessionManager extends StateManager {
     }
     initCrossTabSync() {
         if (typeof BroadcastChannel === 'undefined') {
-            debugLog.warn('SessionManager', 'BroadcastChannel not supported');
+            log('warn', 'BroadcastChannel not supported');
             return;
         }
         const projectId = this.getProjectId();
@@ -28,7 +28,6 @@ export class SessionManager extends StateManager {
                 return;
             }
             if (action === 'session_end') {
-                debugLog.debug('SessionManager', 'Session end synced from another tab');
                 this.resetSessionState();
                 return;
             }
@@ -39,7 +38,6 @@ export class SessionManager extends StateManager {
                 if (this.isTracking) {
                     this.setupSessionTimeout();
                 }
-                debugLog.debug('SessionManager', 'Session synced from another tab', { sessionId });
             }
         };
     }
@@ -82,11 +80,9 @@ export class SessionManager extends StateManager {
         }
         const sessionTimeout = this.get('config')?.sessionTimeout ?? DEFAULT_SESSION_TIMEOUT;
         if (Date.now() - storedSession.lastActivity > sessionTimeout) {
-            debugLog.debug('SessionManager', 'Stored session expired');
             this.clearStoredSession();
             return null;
         }
-        debugLog.info('SessionManager', 'Session recovered from storage', { sessionId: storedSession.id });
         return storedSession.id;
     }
     persistSession(sessionId, lastActivity = Date.now()) {
@@ -129,7 +125,7 @@ export class SessionManager extends StateManager {
     }
     async startTracking() {
         if (this.isTracking) {
-            debugLog.warn('SessionManager', 'Session tracking already active');
+            log('warn', 'Session tracking already active');
             return;
         }
         const recoveredSessionId = this.recoverSession();
@@ -149,7 +145,6 @@ export class SessionManager extends StateManager {
             this.setupSessionTimeout();
             this.setupActivityListeners();
             this.setupLifecycleListeners();
-            debugLog.info('SessionManager', 'Session tracking started', { sessionId, recovered: isRecovered });
         }
         catch (error) {
             this.isTracking = false;
@@ -232,11 +227,10 @@ export class SessionManager extends StateManager {
     async endSession(reason) {
         const sessionId = this.get('sessionId');
         if (!sessionId) {
-            debugLog.warn('SessionManager', 'endSession called without active session', { reason });
+            log('warn', 'endSession called without active session', { data: { reason } });
             this.resetSessionState(reason);
             return;
         }
-        debugLog.info('SessionManager', 'Ending session', { sessionId, reason });
         this.eventManager.track({
             type: EventType.SESSION_END,
             session_end_reason: reason,
@@ -255,9 +249,7 @@ export class SessionManager extends StateManager {
             finalize();
         }
         catch (error) {
-            debugLog.warn('SessionManager', 'Async flush failed during session end', {
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
+            log('warn', 'Async flush failed during session end', { error });
             finalize();
         }
     }

package/dist/esm/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/esm/managers/state.manager.js

@@ -1,5 +1,3 @@
-import { debugLog } from '../utils/logging';
-import { DEFAULT_SAMPLING_RATE } from '../constants';
 const globalState = {};
 export function getGlobalState() {
     return globalState;
@@ -14,49 +12,9 @@ export 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 ?? DEFAULT_SAMPLING_RATE;
-                const normalizedSamplingRate = samplingRate < 0 || samplingRate > 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])) {
-            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;
-    }
 }

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

@@ -1,11 +1,13 @@
 /**
- * Manages localStorage with automatic fallback to in-memory storage.
+ * Manages localStorage and sessionStorage with automatic fallback to in-memory storage.
  * Provides a consistent interface for storing session data, configuration,
  * and analytics metadata across browser environments.
  */
 export declare class StorageManager {
     private readonly storage;
+    private readonly sessionStorageRef;
     private readonly fallbackStorage;
+    private readonly fallbackSessionStorage;
     private hasQuotaExceededError;
     constructor();
     /**
@@ -34,7 +36,19 @@ export declare class StorageManager {
      */
     hasQuotaError(): boolean;
     /**
-     * Initialize localStorage with feature detection
+     * Initialize storage (localStorage or sessionStorage) with feature detection
      */
     private initializeStorage;
+    /**
+     * Retrieves an item from sessionStorage
+     */
+    getSessionItem(key: string): string | null;
+    /**
+     * Stores an item in sessionStorage
+     */
+    setSessionItem(key: string, value: string): void;
+    /**
+     * Removes an item from sessionStorage
+     */
+    removeSessionItem(key: string): void;
 }

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

@@ -1,16 +1,21 @@
-import { debugLog } from '../utils/logging/debug-logger.utils';
+import { log } from '../utils';
 /**
- * Manages localStorage with automatic fallback to in-memory storage.
+ * Manages localStorage and sessionStorage with automatic fallback to in-memory storage.
  * Provides a consistent interface for storing session data, configuration,
  * and analytics metadata across browser environments.
  */
 export class StorageManager {
     constructor() {
         this.fallbackStorage = new Map();
+        this.fallbackSessionStorage = new Map();
         this.hasQuotaExceededError = false;
-        this.storage = this.initializeStorage();
+        this.storage = this.initializeStorage('localStorage');
+        this.sessionStorageRef = this.initializeStorage('sessionStorage');
         if (!this.storage) {
-            debugLog.warn('StorageManager', 'localStorage not available, using memory fallback');
+            log('warn', 'localStorage not available, using memory fallback');
+        }
+        if (!this.sessionStorageRef) {
+            log('warn', 'sessionStorage not available, using memory fallback');
         }
     }
     /**
@@ -23,8 +28,8 @@ export class StorageManager {
             }
             return this.fallbackStorage.get(key) ?? null;
         }
-        catch (error) {
-            debugLog.warn('StorageManager', 'Failed to get item, using fallback', { key, error });
+        catch {
+            // Silent fallback - user already warned in constructor
             return this.fallbackStorage.get(key) ?? null;
         }
     }
@@ -41,14 +46,12 @@ export class StorageManager {
         catch (error) {
             if (error instanceof DOMException && error.name === 'QuotaExceededError') {
                 this.hasQuotaExceededError = true;
-                debugLog.error('StorageManager', 'localStorage quota exceeded - data will not persist after reload', {
-                    key,
-                    valueSize: value.length,
+                log('error', 'localStorage quota exceeded - data will not persist after reload', {
+                    error,
+                    data: { key, valueSize: value.length },
                 });
             }
-            else {
-                debugLog.warn('StorageManager', 'Failed to set item, using fallback', { key, error });
-            }
+            // Else: Silent fallback - user already warned in constructor
         }
         // Always update fallback for consistency
         this.fallbackStorage.set(key, value);
@@ -62,8 +65,8 @@ export class StorageManager {
                 this.storage.removeItem(key);
             }
         }
-        catch (error) {
-            debugLog.warn('StorageManager', 'Failed to remove item', { key, error });
+        catch {
+            // Silent - not critical
         }
         // Always clean fallback
         this.fallbackStorage.delete(key);
@@ -86,10 +89,9 @@ export class StorageManager {
             }
             keysToRemove.forEach((key) => this.storage.removeItem(key));
             this.fallbackStorage.clear();
-            debugLog.debug('StorageManager', 'Cleared storage', { itemsRemoved: keysToRemove.length });
         }
         catch (error) {
-            debugLog.error('StorageManager', 'Failed to clear storage', { error });
+            log('error', 'Failed to clear storage', { error });
             this.fallbackStorage.clear();
         }
     }
@@ -107,14 +109,14 @@ export class StorageManager {
         return this.hasQuotaExceededError;
     }
     /**
-     * Initialize localStorage with feature detection
+     * Initialize storage (localStorage or sessionStorage) with feature detection
      */
-    initializeStorage() {
+    initializeStorage(type) {
         if (typeof window === 'undefined') {
             return null;
         }
         try {
-            const storage = window.localStorage;
+            const storage = type === 'localStorage' ? window.localStorage : window.sessionStorage;
             const testKey = '__tracelog_test__';
             storage.setItem(testKey, 'test');
             storage.removeItem(testKey);
@@ -124,4 +126,56 @@ export class StorageManager {
             return null;
         }
     }
+    /**
+     * Retrieves an item from sessionStorage
+     */
+    getSessionItem(key) {
+        try {
+            if (this.sessionStorageRef) {
+                return this.sessionStorageRef.getItem(key);
+            }
+            return this.fallbackSessionStorage.get(key) ?? null;
+        }
+        catch {
+            // Silent fallback - user already warned in constructor
+            return this.fallbackSessionStorage.get(key) ?? null;
+        }
+    }
+    /**
+     * Stores an item in sessionStorage
+     */
+    setSessionItem(key, value) {
+        try {
+            if (this.sessionStorageRef) {
+                this.sessionStorageRef.setItem(key, value);
+                return;
+            }
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === 'QuotaExceededError') {
+                log('error', 'sessionStorage quota exceeded - data will not persist', {
+                    error,
+                    data: { key, valueSize: value.length },
+                });
+            }
+            // Else: Silent fallback - user already warned in constructor
+        }
+        // Always update fallback for consistency
+        this.fallbackSessionStorage.set(key, value);
+    }
+    /**
+     * Removes an item from sessionStorage
+     */
+    removeSessionItem(key) {
+        try {
+            if (this.sessionStorageRef) {
+                this.sessionStorageRef.removeItem(key);
+            }
+        }
+        catch {
+            // Silent - not critical
+        }
+        // Always clean fallback
+        this.fallbackSessionStorage.delete(key);
+    }
 }

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

@@ -12,5 +12,5 @@ export declare class UserManager {
      * @param projectId - Project identifier for namespacing
      * @returns Persistent unique user ID
      */
-    static getId(storageManager: StorageManager, projectId?: string): string;
+    static getId(storageManager: StorageManager): string;
 }

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

@@ -13,8 +13,8 @@ export class UserManager {
      * @param projectId - Project identifier for namespacing
      * @returns Persistent unique user ID
      */
-    static getId(storageManager, projectId) {
-        const storageKey = USER_ID_KEY(projectId ?? '');
+    static getId(storageManager) {
+        const storageKey = USER_ID_KEY;
         const storedUserId = storageManager.getItem(storageKey);
         if (storedUserId) {
             return storedUserId;

package/dist/esm/public-api.d.ts

@@ -1,8 +1,8 @@
 export * from './app.constants';
-export * from './app.types';
+export * from './types';
 export declare const tracelog: {
-    init: (appConfig: import("./app.types").AppConfig) => Promise<void>;
-    event: (name: string, metadata?: Record<string, import("./app.types").MetadataType> | Record<string, import("./app.types").MetadataType>[]) => void;
+    init: (config: import("./types").Config) => Promise<void>;
+    event: (name: string, metadata?: Record<string, import("./types").MetadataType> | Record<string, import("./types").MetadataType>[]) => void;
     on: <K extends keyof import("./types").EmitterMap>(event: K, callback: import("./types").EmitterCallback<import("./types").EmitterMap[K]>) => void;
     off: <K extends keyof import("./types").EmitterMap>(event: K, callback: import("./types").EmitterCallback<import("./types").EmitterMap[K]>) => void;
     isInitialized: () => boolean;

package/dist/esm/public-api.js

@@ -2,7 +2,7 @@ import { init, event, on, off, isInitialized, destroy } from './api';
 // Constants
 export * from './app.constants';
 // Types
-export * from './app.types';
+export * from './types';
 // TraceLog namespace containing all API methods
 export const tracelog = {
     init,

package/dist/esm/test-bridge.d.ts

@@ -16,6 +16,7 @@ export declare class TestBridge extends App implements TraceLogTestBridge {
     private _isInitializing;
     private _isDestroying;
     constructor(isInitializing: boolean, isDestroying: boolean);
+    init(config: any): Promise<void>;
     isInitializing(): boolean;
     sendCustomEvent(name: string, data?: Record<string, unknown> | Record<string, unknown>[]): void;
     getSessionData(): Record<string, unknown> | null;

package/dist/esm/test-bridge.js

@@ -1,4 +1,6 @@
 import { App } from './app';
+import { __setAppInstance } from './api';
+import { STORAGE_BASE_KEY } from './constants';
 /**
  * Test bridge for E2E testing
  */
@@ -9,6 +11,34 @@ export class TestBridge extends App {
         this._isInitializing = isInitializing;
         this._isDestroying = isDestroying;
     }
+    async init(config) {
+        // Guard: TestBridge should only be used in development
+        if (process.env.NODE_ENV !== 'dev') {
+            throw new Error('[TraceLog] TestBridge is only available in development mode');
+        }
+        // First sync with window.tracelog BEFORE initializing
+        // This ensures both APIs point to the same instance from the start
+        if (!__setAppInstance) {
+            throw new Error('[TraceLog] __setAppInstance is not available (production build?)');
+        }
+        try {
+            __setAppInstance(this);
+        }
+        catch {
+            // If __setAppInstance fails (e.g., already initialized), throw clear error
+            throw new Error('[TraceLog] TestBridge cannot sync with existing tracelog instance. Call destroy() first.');
+        }
+        try {
+            await super.init(config);
+        }
+        catch (error) {
+            // If init fails, clear the sync
+            if (__setAppInstance) {
+                __setAppInstance(null);
+            }
+            throw error;
+        }
+    }
     isInitializing() {
         return this._isInitializing;
     }
@@ -43,7 +73,8 @@ export class TestBridge extends App {
         if (!storageManager) {
             throw new Error('Storage manager not available');
         }
-        const projectId = this.get('config')?.id;
+        const config = this.get('config');
+        const projectId = config?.integrations?.tracelog?.projectId ?? config?.integrations?.custom?.apiUrl ?? 'test';
         const userId = this.get('userId');
         const sessionId = this.get('sessionId');
         if (!projectId || !userId) {
@@ -58,7 +89,7 @@ export class TestBridge extends App {
             timestamp: Date.now(),
         };
         // Store in the same format as SenderManager.persistEvents()
-        const storageKey = `tl:${projectId}:queue:${userId}`;
+        const storageKey = `${STORAGE_BASE_KEY}:${projectId}:queue:${userId}`;
         storageManager.setItem(storageKey, JSON.stringify(persistedData));
     }
     get(key) {
@@ -103,6 +134,10 @@ export class TestBridge extends App {
         this._isDestroying = true;
         try {
             await super.destroy(force);
+            // Clear window.tracelog API reference (only in dev mode)
+            if (__setAppInstance) {
+                __setAppInstance(null);
+            }
         }
         finally {
             this._isDestroying = false;