@tracelog/lib 0.5.4 → 0.6.0

package/dist/cjs/utils/validations/type-guards.utils.js

@@ -1,10 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isOnlyPrimitiveFields = void 0;
+const constants_1 = require("../../constants");
 /**
- * Checks if an object contains only primitive fields (string, number, boolean, or string arrays)
+ * Validates if an item in an array is a valid nested object
+ * @param item - The item to validate
+ * @returns True if the item is a valid nested object
+ */
+const isValidArrayItem = (item) => {
+    if (typeof item === 'string') {
+        return true;
+    }
+    // Allow objects with primitive fields only (one level deep)
+    if (typeof item === 'object' && item !== null && !Array.isArray(item)) {
+        const entries = Object.entries(item);
+        // Check key count limit
+        if (entries.length > constants_1.MAX_NESTED_OBJECT_KEYS) {
+            return false;
+        }
+        // All values must be primitives (no nested objects or arrays)
+        for (const [, value] of entries) {
+            if (value === null || value === undefined) {
+                continue;
+            }
+            const type = typeof value;
+            if (type !== 'string' && type !== 'number' && type !== 'boolean') {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+};
+/**
+ * Checks if an object contains only primitive fields, string arrays, or arrays of flat objects
  * @param object - The object to check
- * @returns True if the object contains only primitive fields
+ * @returns True if the object contains only valid fields
  */
 const isOnlyPrimitiveFields = (object) => {
     if (typeof object !== 'object' || object === null) {
@@ -19,8 +50,23 @@ const isOnlyPrimitiveFields = (object) => {
             continue;
         }
         if (Array.isArray(value)) {
-            if (!value.every((item) => typeof item === 'string')) {
-                return false;
+            if (value.length === 0) {
+                continue;
+            }
+            // Determine array type from first item
+            const firstItem = value[0];
+            const isStringArray = typeof firstItem === 'string';
+            // All items must be of the same type (all strings OR all objects)
+            if (isStringArray) {
+                if (!value.every((item) => typeof item === 'string')) {
+                    return false;
+                }
+            }
+            else {
+                // Must be all objects
+                if (!value.every((item) => isValidArrayItem(item))) {
+                    return false;
+                }
             }
             continue;
         }

package/dist/esm/api.d.ts

@@ -1,8 +1,18 @@
-import { MetadataType, AppConfig, EmitterCallback, EmitterMap } from './types';
+import { App } from './app';
+import { MetadataType, Config, EmitterCallback, EmitterMap } from './types';
 import './types/window.types';
-export declare const init: (appConfig: AppConfig) => Promise<void>;
+export declare const init: (config: Config) => Promise<void>;
 export declare const event: (name: string, metadata?: Record<string, MetadataType> | Record<string, MetadataType>[]) => void;
 export declare const on: <K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>) => void;
 export declare const off: <K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>) => void;
 export declare const isInitialized: () => boolean;
 export declare const destroy: () => Promise<void>;
+/**
+ * Internal sync function - ONLY for TestBridge in development
+ *
+ * WARNING: This function is internal and should NEVER be called directly.
+ * It's only exported for TestBridge synchronization in dev mode.
+ *
+ * @internal
+ */
+export declare const __setAppInstance: (instance: App | null) => void;

package/dist/esm/api.js

@@ -1,48 +1,50 @@
 import { App } from './app';
-import { debugLog, validateAndNormalizeConfig } from './utils';
+import { log, validateAndNormalizeConfig } from './utils';
 import { TestBridge } from './test-bridge';
 import './types/window.types';
+// Buffer for listeners registered before init()
+const pendingListeners = [];
 let app = null;
 let isInitializing = false;
 let isDestroying = false;
-export const init = async (appConfig) => {
+export const init = async (config) => {
     if (typeof window === 'undefined' || typeof document === 'undefined') {
-        throw new Error('This library can only be used in a browser environment');
+        throw new Error('[TraceLog] This library can only be used in a browser environment');
     }
     if (window.__traceLogDisabled) {
         return;
     }
     if (app) {
-        debugLog.debug('API', 'Library already initialized, skipping duplicate initialization');
         return;
     }
     if (isInitializing) {
-        debugLog.warn('API', 'Initialization already in progress');
-        throw new Error('Initialization already in progress');
+        return;
     }
     isInitializing = true;
     try {
-        debugLog.info('API', 'Initializing TraceLog', { projectId: appConfig.id });
-        const validatedConfig = validateAndNormalizeConfig(appConfig);
+        const validatedConfig = validateAndNormalizeConfig(config);
         const instance = new App();
         try {
+            // Attach buffered listeners BEFORE init() so they capture initial events
+            pendingListeners.forEach(({ event, callback }) => {
+                instance.on(event, callback);
+            });
+            pendingListeners.length = 0;
             await instance.init(validatedConfig);
             app = instance;
-            debugLog.info('API', 'TraceLog initialized successfully', { projectId: validatedConfig.id });
         }
         catch (error) {
             try {
                 await instance.destroy(true);
             }
             catch (cleanupError) {
-                debugLog.warn('API', 'Failed to cleanup partially initialized app', { cleanupError });
+                log('error', 'Failed to cleanup partially initialized app', { error: cleanupError });
             }
             throw error;
         }
     }
     catch (error) {
         app = null;
-        debugLog.error('API', 'Initialization failed', { error });
         throw error;
     }
     finally {
@@ -51,25 +53,29 @@ export const init = async (appConfig) => {
 };
 export const event = (name, metadata) => {
     if (!app) {
-        throw new Error('TraceLog not initialized. Please call init() first.');
-    }
-    try {
-        app.sendCustomEvent(name, metadata);
+        throw new Error('[TraceLog] TraceLog not initialized. Please call init() first.');
     }
-    catch (error) {
-        debugLog.error('API', 'Failed to send custom event', { eventName: name, error });
-        throw error;
+    if (isDestroying) {
+        throw new Error('[TraceLog] Cannot send events while TraceLog is being destroyed');
     }
+    app.sendCustomEvent(name, metadata);
 };
 export const on = (event, callback) => {
-    if (!app) {
-        throw new Error('TraceLog not initialized. Please call init() first.');
+    if (!app || isInitializing) {
+        // Buffer listeners registered before or during init()
+        pendingListeners.push({ event, callback });
+        return;
     }
     app.on(event, callback);
 };
 export const off = (event, callback) => {
     if (!app) {
-        throw new Error('TraceLog not initialized. Please call init() first.');
+        // Remove from pending listeners if not yet initialized
+        const index = pendingListeners.findIndex((l) => l.event === event && l.callback === callback);
+        if (index !== -1) {
+            pendingListeners.splice(index, 1);
+        }
+        return;
     }
     app.off(event, callback);
 };
@@ -78,24 +84,28 @@ export const isInitialized = () => {
 };
 export const destroy = async () => {
     if (!app) {
-        throw new Error('App not initialized');
+        throw new Error('[TraceLog] App not initialized');
     }
     if (isDestroying) {
-        throw new Error('Destroy operation already in progress');
+        throw new Error('[TraceLog] Destroy operation already in progress');
     }
     isDestroying = true;
     try {
-        debugLog.info('API', 'Destroying TraceLog instance');
         await app.destroy();
         app = null;
         isInitializing = false;
-        debugLog.info('API', 'TraceLog destroyed successfully');
+        pendingListeners.length = 0;
+        // Clear TestBridge reference in dev mode to prevent stale references
+        if (process.env.NODE_ENV === 'dev' && typeof window !== 'undefined' && window.__traceLogBridge) {
+            // Don't call destroy on bridge (would cause recursion), just clear reference
+            window.__traceLogBridge = undefined;
+        }
     }
     catch (error) {
-        // Force cleanup even if destroy fails
         app = null;
         isInitializing = false;
-        debugLog.error('API', 'Error during destroy, forced cleanup', { error });
+        pendingListeners.length = 0;
+        log('error', 'Error during destroy, forced cleanup', { error });
         throw error;
     }
     finally {
@@ -113,3 +123,28 @@ if (process.env.NODE_ENV === 'dev' && typeof window !== 'undefined') {
         injectTestingBridge();
     }
 }
+/**
+ * Internal sync function - ONLY for TestBridge in development
+ *
+ * WARNING: This function is internal and should NEVER be called directly.
+ * It's only exported for TestBridge synchronization in dev mode.
+ *
+ * @internal
+ */
+export const __setAppInstance = (instance) => {
+    if (instance !== null) {
+        const hasRequiredMethods = typeof instance === 'object' &&
+            'init' in instance &&
+            'destroy' in instance &&
+            'on' in instance &&
+            'off' in instance;
+        if (!hasRequiredMethods) {
+            throw new Error('[TraceLog] Invalid app instance type');
+        }
+    }
+    // Prevent overwriting an already initialized app (except when clearing)
+    if (app !== null && instance !== null && app !== instance) {
+        throw new Error('[TraceLog] Cannot overwrite existing app instance. Call destroy() first.');
+    }
+    app = instance;
+};

package/dist/esm/app.d.ts

@@ -4,7 +4,7 @@ import { SessionHandler } from './handlers/session.handler';
 import { PageViewHandler } from './handlers/page-view.handler';
 import { ClickHandler } from './handlers/click.handler';
 import { ScrollHandler } from './handlers/scroll.handler';
-import { AppConfig, EmitterCallback, EmitterMap } from './types';
+import { Config, EmitterCallback, EmitterMap } from './types';
 import { GoogleAnalyticsIntegration } from './integrations/google-analytics.integration';
 import { StorageManager } from './managers/storage.manager';
 import { PerformanceHandler } from './handlers/performance.handler';
@@ -29,7 +29,7 @@ export declare class App extends StateManager {
         googleAnalytics?: GoogleAnalyticsIntegration;
     };
     get initialized(): boolean;
-    init(appConfig: AppConfig): Promise<void>;
+    init(config: Config): Promise<void>;
     sendCustomEvent(name: string, metadata?: Record<string, unknown> | Record<string, unknown>[]): void;
     on<K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>): void;
     off<K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>): void;

package/dist/esm/app.js

@@ -1,5 +1,3 @@
-import { getApiUrlForProject } from './managers/api.manager';
-import { ConfigManager } from './managers/config.manager';
 import { EventManager } from './managers/event.manager';
 import { UserManager } from './managers/user.manager';
 import { StateManager } from './managers/state.manager';
@@ -7,9 +5,9 @@ import { SessionHandler } from './handlers/session.handler';
 import { PageViewHandler } from './handlers/page-view.handler';
 import { ClickHandler } from './handlers/click.handler';
 import { ScrollHandler } from './handlers/scroll.handler';
-import { EventType } from './types';
+import { EventType, Mode } from './types';
 import { GoogleAnalyticsIntegration } from './integrations/google-analytics.integration';
-import { isEventValid, getDeviceType, normalizeUrl, debugLog, Emitter } from './utils';
+import { isEventValid, getDeviceType, normalizeUrl, Emitter, getApiUrl, detectQaMode, log } from './utils';
 import { StorageManager } from './managers/storage.manager';
 import { SCROLL_DEBOUNCE_TIME_MS, SCROLL_SUPPRESS_MULTIPLIER } from './constants/config.constants';
 import { PerformanceHandler } from './handlers/performance.handler';
@@ -27,27 +25,25 @@ export class App extends StateManager {
     get initialized() {
         return this.isInitialized;
     }
-    async init(appConfig) {
+    async init(config) {
         if (this.isInitialized) {
             return;
         }
-        if (!appConfig.id?.trim()) {
-            throw new Error('Project ID is required');
-        }
         this.managers.storage = new StorageManager();
         try {
-            await this.setupState(appConfig);
+            this.setupState(config);
             await this.setupIntegrations();
             this.managers.event = new EventManager(this.managers.storage, this.integrations.googleAnalytics, this.emitter);
-            this.initializeHandlers();
-            await this.managers.event.recoverPersistedEvents().catch(() => {
-                debugLog.warn('App', 'Failed to recover persisted events');
+            await this.initializeHandlers();
+            await this.managers.event.recoverPersistedEvents().catch((error) => {
+                log('warn', 'Failed to recover persisted events', { error });
             });
             this.isInitialized = true;
         }
         catch (error) {
             await this.destroy(true);
-            throw new Error(`TraceLog initialization failed: ${error}`);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`[TraceLog] TraceLog initialization failed: ${errorMessage}`);
         }
     }
     sendCustomEvent(name, metadata) {
@@ -56,9 +52,8 @@ export class App extends StateManager {
         }
         const { valid, error, sanitizedMetadata } = isEventValid(name, metadata);
         if (!valid) {
-            const config = this.get('config');
-            if (config?.mode === 'qa' || config?.mode === 'debug') {
-                throw new Error(`Custom event "${name}" validation failed: ${error}`);
+            if (this.get('mode') === Mode.QA) {
+                throw new Error(`[TraceLog] Custom event "${name}" validation failed: ${error}`);
             }
             return;
         }
@@ -87,8 +82,8 @@ export class App extends StateManager {
             try {
                 await handler.stopTracking();
             }
-            catch {
-                debugLog.warn('App', 'Failed to stop tracking');
+            catch (error) {
+                log('warn', 'Failed to stop tracking', { error });
             }
         });
         await Promise.allSettled(handlerCleanups);
@@ -105,22 +100,25 @@ export class App extends StateManager {
         this.isInitialized = false;
         this.handlers = {};
     }
-    async setupState(appConfig) {
-        const apiUrl = getApiUrlForProject(appConfig.id, appConfig.allowHttp);
-        this.set('apiUrl', apiUrl);
-        const configManager = new ConfigManager();
-        const config = await configManager.get(apiUrl, appConfig);
+    setupState(config) {
         this.set('config', config);
-        const userId = UserManager.getId(this.managers.storage, config.id);
+        const userId = UserManager.getId(this.managers.storage);
         this.set('userId', userId);
-        this.set('device', getDeviceType());
+        const apiUrl = getApiUrl(config);
+        this.set('apiUrl', apiUrl);
+        const device = getDeviceType();
+        this.set('device', device);
         const pageUrl = normalizeUrl(window.location.href, config.sensitiveQueryParams);
         this.set('pageUrl', pageUrl);
+        const mode = detectQaMode() ? Mode.QA : undefined;
+        if (mode) {
+            this.set('mode', mode);
+        }
     }
     async setupIntegrations() {
         const config = this.get('config');
         const measurementId = config.integrations?.googleAnalytics?.measurementId;
-        if (!config.ipExcluded && measurementId?.trim()) {
+        if (measurementId?.trim()) {
             try {
                 this.integrations.googleAnalytics = new GoogleAnalyticsIntegration();
                 await this.integrations.googleAnalytics.initialize();
@@ -130,13 +128,9 @@ export class App extends StateManager {
             }
         }
     }
-    initializeHandlers() {
+    async initializeHandlers() {
         this.handlers.session = new SessionHandler(this.managers.storage, this.managers.event);
-        this.handlers.session.startTracking().catch((error) => {
-            debugLog.error('App', 'Session handler failed to start', {
-                message: error instanceof Error ? error.message : 'Unknown error',
-            });
-        });
+        await this.handlers.session.startTracking();
         const onPageView = () => {
             this.set('suppressNextScroll', true);
             if (this.suppressNextScrollTimer) {
@@ -153,8 +147,8 @@ export class App extends StateManager {
         this.handlers.scroll = new ScrollHandler(this.managers.event);
         this.handlers.scroll.startTracking();
         this.handlers.performance = new PerformanceHandler(this.managers.event);
-        this.handlers.performance.startTracking().catch(() => {
-            debugLog.warn('App', 'Failed to start performance tracking');
+        this.handlers.performance.startTracking().catch((error) => {
+            log('warn', 'Failed to start performance tracking', { error });
         });
         this.handlers.error = new ErrorHandler(this.managers.event);
         this.handlers.error.startTracking();

package/dist/esm/constants/config.constants.d.ts

@@ -29,6 +29,7 @@ export declare const MAX_CUSTOM_EVENT_NAME_LENGTH = 120;
 export declare const MAX_CUSTOM_EVENT_STRING_SIZE: number;
 export declare const MAX_CUSTOM_EVENT_KEYS = 10;
 export declare const MAX_CUSTOM_EVENT_ARRAY_SIZE = 10;
+export declare const MAX_NESTED_OBJECT_KEYS = 20;
 export declare const MAX_TEXT_LENGTH = 255;
 export declare const MAX_STRING_LENGTH = 1000;
 export declare const MAX_ARRAY_LENGTH = 100;
@@ -38,7 +39,7 @@ export declare const SYNC_XHR_TIMEOUT_MS = 2000;
 export declare const MAX_FINGERPRINTS = 1000;
 export declare const FINGERPRINT_CLEANUP_MULTIPLIER = 10;
 export declare const MAX_FINGERPRINTS_HARD_LIMIT = 2000;
-export declare const HTML_DATA_ATTR_PREFIX = "data-tl";
+export declare const HTML_DATA_ATTR_PREFIX = "data-tlog";
 export declare const INTERACTIVE_SELECTORS: readonly ["button", "a", "input[type=\"button\"]", "input[type=\"submit\"]", "input[type=\"reset\"]", "input[type=\"checkbox\"]", "input[type=\"radio\"]", "select", "textarea", "[role=\"button\"]", "[role=\"link\"]", "[role=\"tab\"]", "[role=\"menuitem\"]", "[role=\"option\"]", "[role=\"checkbox\"]", "[role=\"radio\"]", "[role=\"switch\"]", "[routerLink]", "[ng-click]", "[data-action]", "[data-click]", "[data-navigate]", "[data-toggle]", "[onclick]", ".btn", ".button", ".clickable", ".nav-link", ".menu-item", "[data-testid]", "[tabindex=\"0\"]"];
 export declare const UTM_PARAMS: string[];
 export declare const INITIALIZATION_MAX_CONCURRENT_RETRIES = 20;
@@ -60,13 +61,14 @@ export declare const RETRY_BACKOFF_INITIAL = 1000;
 export declare const RETRY_BACKOFF_MAX = 30000;
 export declare const RATE_LIMIT_INTERVAL = 1000;
 export declare const MAX_RETRY_ATTEMPTS = 10;
-export declare const ALLOWED_API_CONFIG_KEYS: Set<"mode" | "samplingRate" | "excludedUrlPaths" | keyof import("../types").ExclusiveApiConfig>;
 export declare const VALIDATION_MESSAGES: {
     readonly MISSING_PROJECT_ID: "Project ID is required";
     readonly PROJECT_ID_EMPTY_AFTER_TRIM: "Project ID is required";
     readonly INVALID_SESSION_TIMEOUT: "Session timeout must be between 30000ms (30 seconds) and 86400000ms (24 hours)";
     readonly INVALID_SAMPLING_RATE: "Sampling rate must be between 0 and 1";
     readonly INVALID_ERROR_SAMPLING_RATE: "Error sampling must be between 0 and 1";
+    readonly INVALID_TRACELOG_PROJECT_ID: "TraceLog project ID is required when integration is enabled";
+    readonly INVALID_CUSTOM_API_URL: "Custom API URL is required when integration is enabled";
     readonly INVALID_GOOGLE_ANALYTICS_ID: "Google Analytics measurement ID is required when integration is enabled";
     readonly INVALID_SCROLL_CONTAINER_SELECTORS: "Scroll container selectors must be valid CSS selectors";
     readonly INVALID_GLOBAL_METADATA: "Global metadata must be an object";

package/dist/esm/constants/config.constants.js

@@ -42,6 +42,7 @@ export const MAX_CUSTOM_EVENT_NAME_LENGTH = 120;
 export const MAX_CUSTOM_EVENT_STRING_SIZE = 8 * 1024; // 8KB
 export const MAX_CUSTOM_EVENT_KEYS = 10;
 export const MAX_CUSTOM_EVENT_ARRAY_SIZE = 10;
+export const MAX_NESTED_OBJECT_KEYS = 20; // Maximum keys in nested objects within arrays
 // Text content limits
 export const MAX_TEXT_LENGTH = 255; // For click tracking text content
 // Data sanitization limits
@@ -59,7 +60,7 @@ export const MAX_FINGERPRINTS_HARD_LIMIT = 2000; // Hard limit for aggressive cl
 // ============================================================================
 // BROWSER & HTML
 // ============================================================================
-export const HTML_DATA_ATTR_PREFIX = 'data-tl';
+export const HTML_DATA_ATTR_PREFIX = 'data-tlog';
 // Interactive element selectors for click tracking
 export const INTERACTIVE_SELECTORS = [
     'button',
@@ -133,31 +134,18 @@ export const MAX_RETRY_ATTEMPTS = 10;
 // ============================================================================
 // VALIDATION
 // ============================================================================
-// Allowed API config keys for runtime validation
-export const ALLOWED_API_CONFIG_KEYS = new Set([
-    'mode',
-    'tags',
-    'samplingRate',
-    'excludedUrlPaths',
-    'ipExcluded',
-]);
 // Validation error messages - standardized across all layers
 export const VALIDATION_MESSAGES = {
-    // Project ID validation - consistent message across all layers
     MISSING_PROJECT_ID: 'Project ID is required',
     PROJECT_ID_EMPTY_AFTER_TRIM: 'Project ID is required',
-    // Session timeout validation
     INVALID_SESSION_TIMEOUT: `Session timeout must be between ${MIN_SESSION_TIMEOUT_MS}ms (30 seconds) and ${MAX_SESSION_TIMEOUT_MS}ms (24 hours)`,
-    // Sampling rate validation
     INVALID_SAMPLING_RATE: 'Sampling rate must be between 0 and 1',
     INVALID_ERROR_SAMPLING_RATE: 'Error sampling must be between 0 and 1',
-    // Integration validation
+    INVALID_TRACELOG_PROJECT_ID: 'TraceLog project ID is required when integration is enabled',
+    INVALID_CUSTOM_API_URL: 'Custom API URL is required when integration is enabled',
     INVALID_GOOGLE_ANALYTICS_ID: 'Google Analytics measurement ID is required when integration is enabled',
-    // UI validation
     INVALID_SCROLL_CONTAINER_SELECTORS: 'Scroll container selectors must be valid CSS selectors',
-    // Global metadata validation
     INVALID_GLOBAL_METADATA: 'Global metadata must be an object',
-    // Array validation
     INVALID_SENSITIVE_QUERY_PARAMS: 'Sensitive query params must be an array of strings',
 };
 // ============================================================================

package/dist/esm/constants/index.d.ts

@@ -1,4 +1,3 @@
-export * from './api.constants';
 export * from './config.constants';
 export * from './storage.constants';
 export * from './performance.constants';

package/dist/esm/constants/index.js

@@ -1,4 +1,3 @@
-export * from './api.constants';
 export * from './config.constants';
 export * from './storage.constants';
 export * from './performance.constants';

package/dist/esm/constants/storage.constants.d.ts

@@ -1,5 +1,6 @@
-export declare const STORAGE_BASE_KEY = "tl";
-export declare const USER_ID_KEY: (id: string) => string;
+export declare const STORAGE_BASE_KEY = "tlog";
+export declare const QA_MODE_KEY = "tlog:qa_mode";
+export declare const USER_ID_KEY = "tlog:uid";
 export declare const QUEUE_KEY: (id: string) => string;
 export declare const SESSION_STORAGE_KEY: (id: string) => string;
 export declare const CROSS_TAB_SESSION_KEY: (id: string) => string;

package/dist/esm/constants/storage.constants.js

@@ -1,5 +1,6 @@
-export const STORAGE_BASE_KEY = 'tl';
-export const USER_ID_KEY = (id) => (id ? `${STORAGE_BASE_KEY}:${id}:uid` : `${STORAGE_BASE_KEY}:uid`);
+export const STORAGE_BASE_KEY = 'tlog';
+export const QA_MODE_KEY = `${STORAGE_BASE_KEY}:qa_mode`;
+export const USER_ID_KEY = `${STORAGE_BASE_KEY}:uid`;
 export const QUEUE_KEY = (id) => (id ? `${STORAGE_BASE_KEY}:${id}:queue` : `${STORAGE_BASE_KEY}:queue`);
 export const SESSION_STORAGE_KEY = (id) => id ? `${STORAGE_BASE_KEY}:${id}:session` : `${STORAGE_BASE_KEY}:session`;
 // Cross-tab session management storage keys

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

@@ -1,7 +1,7 @@
 import { HTML_DATA_ATTR_PREFIX, MAX_TEXT_LENGTH, INTERACTIVE_SELECTORS } from '../constants';
 import { EventType } from '../types';
 import { StateManager } from '../managers/state.manager';
-import { debugLog } from '../utils/logging';
+import { log } from '@/utils';
 export class ClickHandler extends StateManager {
     constructor(eventManager) {
         super();
@@ -20,7 +20,7 @@ export class ClickHandler extends StateManager {
                     ? target.parentElement
                     : null;
             if (!clickedElement) {
-                debugLog.warn('ClickHandler', 'Click target not found or not an element');
+                log('warn', 'Click target not found or not an element');
                 return;
             }
             const trackingElement = this.findTrackingElement(clickedElement);
@@ -72,10 +72,7 @@ export class ClickHandler extends StateManager {
                 }
             }
             catch (error) {
-                debugLog.warn('ClickHandler', 'Invalid selector in element search', {
-                    selector,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                });
+                log('warn', 'Invalid selector in element search', { error, data: { selector } });
                 continue;
             }
         }

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

@@ -1,7 +1,6 @@
 import { StateManager } from '../managers/state.manager';
 import { ErrorType, EventType } from '../types';
 import { PII_PATTERNS, MAX_ERROR_MESSAGE_LENGTH, ERROR_SUPPRESSION_WINDOW_MS, MAX_TRACKED_ERRORS, MAX_TRACKED_ERRORS_HARD_LIMIT, } from '../constants/error.constants';
-import { debugLog } from '../utils/logging';
 /**
  * Simplified error handler for tracking JavaScript errors and unhandled promise rejections
  * Includes PII sanitization and sampling support
@@ -18,11 +17,6 @@ export class ErrorHandler extends StateManager {
             if (this.shouldSuppressError(ErrorType.JS_ERROR, sanitizedMessage)) {
                 return;
             }
-            debugLog.warn('ErrorHandler', 'JS error captured', {
-                message: sanitizedMessage,
-                filename: event.filename,
-                line: event.lineno,
-            });
             this.eventManager.track({
                 type: EventType.ERROR,
                 error_data: {
@@ -43,7 +37,6 @@ export class ErrorHandler extends StateManager {
             if (this.shouldSuppressError(ErrorType.PROMISE_REJECTION, sanitizedMessage)) {
                 return;
             }
-            debugLog.warn('ErrorHandler', 'Promise rejection captured', { message: sanitizedMessage });
             this.eventManager.track({
                 type: EventType.ERROR,
                 error_data: {
@@ -107,10 +100,7 @@ export class ErrorHandler extends StateManager {
         }
         this.recentErrors.set(key, now);
         if (this.recentErrors.size > MAX_TRACKED_ERRORS_HARD_LIMIT) {
-            debugLog.warn('ErrorHandler', 'Hard limit exceeded, clearing all tracked errors', {
-                size: this.recentErrors.size,
-                limit: MAX_TRACKED_ERRORS_HARD_LIMIT,
-            });
+            // Hard limit exceeded, clearing all tracked errors
             this.recentErrors.clear();
             this.recentErrors.set(key, now);
             return false;

package/dist/esm/handlers/page-view.handler.js

@@ -1,7 +1,6 @@
 import { EventType } from '../types';
 import { normalizeUrl } from '../utils';
 import { StateManager } from '../managers/state.manager';
-import { debugLog } from '../utils/logging';
 export class PageViewHandler extends StateManager {
     constructor(eventManager, onTrack) {
         super();
@@ -13,7 +12,6 @@ export class PageViewHandler extends StateManager {
             }
             this.onTrack();
             const fromUrl = this.get('pageUrl');
-            debugLog.debug('PageViewHandler', 'Page navigation detected', { from: fromUrl, to: normalizedUrl });
             this.set('pageUrl', normalizedUrl);
             const pageViewData = this.extractPageViewData();
             this.eventManager.track({
@@ -27,7 +25,6 @@ export class PageViewHandler extends StateManager {
         this.onTrack = onTrack;
     }
     startTracking() {
-        debugLog.debug('PageViewHandler', 'Starting page view tracking');
         this.trackInitialPageView();
         window.addEventListener('popstate', this.trackCurrentPage, true);
         window.addEventListener('hashchange', this.trackCurrentPage, true);
@@ -35,7 +32,6 @@ export class PageViewHandler extends StateManager {
         this.patchHistory('replaceState');
     }
     stopTracking() {
-        debugLog.debug('PageViewHandler', 'Stopping page view tracking');
         window.removeEventListener('popstate', this.trackCurrentPage, true);
         window.removeEventListener('hashchange', this.trackCurrentPage, true);
         if (this.originalPushState) {