@tracelog/lib 0.0.8 → 0.2.0

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

@@ -1,93 +1,133 @@
 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, } 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
+ */
 export class ErrorHandler extends StateManager {
     constructor(eventManager) {
         super();
-        this.piiPatterns = [
-            /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g,
-            /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g,
-            /\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/g,
-            /\b[A-Z]{2}\d{2}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/g,
-        ];
+        this.recentErrors = new Map();
         this.handleError = (event) => {
-            const config = this.get('config');
-            if (!this.shouldSample(config?.errorSampling ?? 0.1)) {
-                debugLog.debug('ErrorHandler', `Error not sampled, skipping (errorSampling: ${config?.errorSampling})`, {
-                    errorSampling: config?.errorSampling,
-                });
+            if (!this.shouldSample()) {
                 return;
             }
-            debugLog.warn('ErrorHandler', `JavaScript error captured: ${event.message} (filename: ${event.filename}, lineno: ${event.lineno})`, {
-                message: event.message,
+            const sanitizedMessage = this.sanitize(event.message || 'Unknown error');
+            if (this.shouldSuppressError(ErrorType.JS_ERROR, sanitizedMessage)) {
+                return;
+            }
+            debugLog.warn('ErrorHandler', 'JS error captured', {
+                message: sanitizedMessage,
                 filename: event.filename,
-                lineno: event.lineno,
+                line: event.lineno,
             });
             this.eventManager.track({
                 type: EventType.ERROR,
                 error_data: {
                     type: ErrorType.JS_ERROR,
-                    message: this.sanitizeText(event.message || 'Unknown error'),
+                    message: sanitizedMessage,
+                    ...(event.filename && { filename: event.filename }),
+                    ...(event.lineno && { line: event.lineno }),
+                    ...(event.colno && { column: event.colno }),
                 },
             });
         };
-        this.handleUnhandledRejection = (event) => {
-            const config = this.get('config');
-            if (!this.shouldSample(config?.errorSampling ?? 0.1)) {
-                debugLog.debug('ErrorHandler', 'Promise rejection not sampled, skipping', {
-                    errorSampling: config?.errorSampling,
-                });
+        this.handleRejection = (event) => {
+            if (!this.shouldSample()) {
                 return;
             }
-            debugLog.warn('ErrorHandler', `Unhandled promise rejection captured (reason: ${typeof event.reason})`, {
-                reason: typeof event.reason,
-            });
-            let reason = 'Unknown rejection';
-            if (event.reason) {
-                if (typeof event.reason === 'string') {
-                    reason = event.reason;
-                }
-                else if (event.reason instanceof Error) {
-                    reason = event.reason.message || event.reason.toString();
-                }
-                else {
-                    reason = String(event.reason);
-                }
+            const message = this.extractRejectionMessage(event.reason);
+            const sanitizedMessage = this.sanitize(message);
+            if (this.shouldSuppressError(ErrorType.PROMISE_REJECTION, sanitizedMessage)) {
+                return;
             }
+            debugLog.warn('ErrorHandler', 'Promise rejection captured', { message: sanitizedMessage });
             this.eventManager.track({
                 type: EventType.ERROR,
                 error_data: {
                     type: ErrorType.PROMISE_REJECTION,
-                    message: this.sanitizeText(reason),
+                    message: sanitizedMessage,
                 },
             });
         };
         this.eventManager = eventManager;
     }
     startTracking() {
-        debugLog.debug('ErrorHandler', 'Starting error tracking');
-        this.setupErrorListener();
-        this.setupUnhandledRejectionListener();
+        window.addEventListener('error', this.handleError);
+        window.addEventListener('unhandledrejection', this.handleRejection);
     }
     stopTracking() {
-        debugLog.debug('ErrorHandler', 'Stopping error tracking');
         window.removeEventListener('error', this.handleError);
-        window.removeEventListener('unhandledrejection', this.handleUnhandledRejection);
+        window.removeEventListener('unhandledrejection', this.handleRejection);
+        this.recentErrors.clear();
     }
-    setupErrorListener() {
-        window.addEventListener('error', this.handleError);
+    shouldSample() {
+        const config = this.get('config');
+        const samplingRate = config?.errorSampling ?? 0.1;
+        return Math.random() < samplingRate;
     }
-    setupUnhandledRejectionListener() {
-        window.addEventListener('unhandledrejection', this.handleUnhandledRejection);
+    extractRejectionMessage(reason) {
+        if (!reason)
+            return 'Unknown rejection';
+        if (typeof reason === 'string')
+            return reason;
+        if (reason instanceof Error) {
+            return reason.stack ?? reason.message ?? reason.toString();
+        }
+        // Handle objects with message property
+        if (typeof reason === 'object' && 'message' in reason) {
+            return String(reason.message);
+        }
+        // Try to stringify objects
+        try {
+            return JSON.stringify(reason);
+        }
+        catch {
+            return String(reason);
+        }
     }
-    sanitizeText(text) {
-        let sanitized = text;
-        for (const pattern of this.piiPatterns) {
-            sanitized = sanitized.replace(pattern, '[REDACTED]');
+    sanitize(text) {
+        let sanitized = text.length > MAX_ERROR_MESSAGE_LENGTH ? text.slice(0, MAX_ERROR_MESSAGE_LENGTH) + '...' : text;
+        for (const pattern of PII_PATTERNS) {
+            // Create new regex instance to avoid global flag state issues
+            const regex = new RegExp(pattern.source, pattern.flags);
+            sanitized = sanitized.replace(regex, '[REDACTED]');
         }
         return sanitized;
     }
-    shouldSample(rate) {
-        return Math.random() < rate;
+    shouldSuppressError(type, message) {
+        const now = Date.now();
+        const key = `${type}:${message}`;
+        const lastSeenAt = this.recentErrors.get(key);
+        if (lastSeenAt && now - lastSeenAt < ERROR_SUPPRESSION_WINDOW_MS) {
+            this.recentErrors.set(key, now);
+            return true;
+        }
+        this.recentErrors.set(key, now);
+        if (this.recentErrors.size > MAX_TRACKED_ERRORS) {
+            this.pruneOldErrors();
+        }
+        return false;
+    }
+    pruneOldErrors() {
+        const now = Date.now();
+        for (const [key, timestamp] of this.recentErrors.entries()) {
+            if (now - timestamp > ERROR_SUPPRESSION_WINDOW_MS) {
+                this.recentErrors.delete(key);
+            }
+        }
+        if (this.recentErrors.size <= MAX_TRACKED_ERRORS) {
+            return;
+        }
+        const entries = Array.from(this.recentErrors.entries()).sort((a, b) => a[1] - b[1]);
+        const excess = this.recentErrors.size - MAX_TRACKED_ERRORS;
+        for (let index = 0; index < excess; index += 1) {
+            const entry = entries[index];
+            if (entry) {
+                this.recentErrors.delete(entry[0]);
+            }
+        }
     }
 }

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

@@ -5,21 +5,23 @@ import { debugLog } from '../utils/logging';
 export class PageViewHandler extends StateManager {
     constructor(eventManager, onTrack) {
         super();
-        this.trackCurrentPage = () => {
+        this.trackCurrentPage = async () => {
             const rawUrl = window.location.href;
             const normalizedUrl = normalizeUrl(rawUrl, this.get('config').sensitiveQueryParams);
-            if (this.get('pageUrl') !== normalizedUrl) {
-                const fromUrl = this.get('pageUrl');
-                debugLog.debug('PageViewHandler', 'Page navigation detected', { from: fromUrl, to: normalizedUrl });
-                this.set('pageUrl', normalizedUrl);
-                this.eventManager.track({
-                    type: EventType.PAGE_VIEW,
-                    page_url: this.get('pageUrl'),
-                    from_page_url: fromUrl,
-                    ...(this.extractPageViewData() && { page_view: this.extractPageViewData() }),
-                });
-                this.onTrack();
+            if (this.get('pageUrl') === normalizedUrl) {
+                return;
             }
+            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({
+                type: EventType.PAGE_VIEW,
+                page_url: this.get('pageUrl'),
+                from_page_url: fromUrl,
+                ...(pageViewData && { page_view: pageViewData }),
+            });
         };
         this.eventManager = eventManager;
         this.onTrack = onTrack;
@@ -27,16 +29,15 @@ export class PageViewHandler extends StateManager {
     startTracking() {
         debugLog.debug('PageViewHandler', 'Starting page view tracking');
         this.trackInitialPageView();
-        this.trackCurrentPage();
-        window.addEventListener('popstate', this.trackCurrentPage);
-        window.addEventListener('hashchange', this.trackCurrentPage);
+        window.addEventListener('popstate', this.trackCurrentPage, true);
+        window.addEventListener('hashchange', this.trackCurrentPage, true);
         this.patchHistory('pushState');
         this.patchHistory('replaceState');
     }
     stopTracking() {
         debugLog.debug('PageViewHandler', 'Stopping page view tracking');
-        window.removeEventListener('popstate', this.trackCurrentPage);
-        window.removeEventListener('hashchange', this.trackCurrentPage);
+        window.removeEventListener('popstate', this.trackCurrentPage, true);
+        window.removeEventListener('hashchange', this.trackCurrentPage, true);
         if (this.originalPushState) {
             window.history.pushState = this.originalPushState;
         }
@@ -45,35 +46,43 @@ export class PageViewHandler extends StateManager {
         }
     }
     patchHistory(method) {
+        const original = window.history[method];
         if (method === 'pushState' && !this.originalPushState) {
-            this.originalPushState = window.history.pushState;
+            this.originalPushState = original;
         }
         else if (method === 'replaceState' && !this.originalReplaceState) {
-            this.originalReplaceState = window.history.replaceState;
+            this.originalReplaceState = original;
         }
-        const original = window.history[method];
         window.history[method] = (...args) => {
             original.apply(window.history, args);
             this.trackCurrentPage();
         };
     }
     trackInitialPageView() {
+        const normalizedUrl = normalizeUrl(window.location.href, this.get('config').sensitiveQueryParams);
+        const pageViewData = this.extractPageViewData();
         this.eventManager.track({
             type: EventType.PAGE_VIEW,
-            page_url: this.get('pageUrl'),
-            ...(this.extractPageViewData() && { page_view: this.extractPageViewData() }),
+            page_url: normalizedUrl,
+            ...(pageViewData && { page_view: pageViewData }),
         });
         this.onTrack();
     }
     extractPageViewData() {
-        const location = window.location;
+        const { pathname, search, hash } = window.location;
+        const { referrer } = document;
+        const { title } = document;
+        // Early return if no meaningful data
+        if (!referrer && !title && !pathname && !search && !hash) {
+            return undefined;
+        }
         const data = {
-            ...(document.referrer && { referrer: document.referrer }),
-            ...(document.title && { title: document.title }),
-            ...(location.pathname && { pathname: location.pathname }),
-            ...(location.search && { search: location.search }),
-            ...(location.hash && { hash: location.hash }),
+            ...(referrer && { referrer }),
+            ...(title && { title }),
+            ...(pathname && { pathname }),
+            ...(search && { search }),
+            ...(hash && { hash }),
         };
-        return Object.values(data).some((value) => !!value) ? data : undefined;
+        return data;
     }
 }

package/dist/esm/handlers/performance.handler.d.ts

@@ -5,6 +5,7 @@ export declare class PerformanceHandler extends StateManager {
     private readonly reportedByNav;
     private readonly observers;
     private lastLongTaskSentAt;
+    private readonly vitalThresholds;
     constructor(eventManager: EventManager);
     startTracking(): Promise<void>;
     stopTracking(): void;
@@ -15,5 +16,7 @@ export declare class PerformanceHandler extends StateManager {
     private sendVital;
     private trackWebVital;
     private getNavigationId;
+    private isObserverSupported;
     private safeObserve;
+    private shouldSendVital;
 }

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

@@ -1,7 +1,7 @@
 import { StateManager } from '../managers/state.manager';
 import { EventType } from '../types';
-import { LONG_TASK_THROTTLE_MS } from '../constants';
-import { PRECISION_FOUR_DECIMALS, PRECISION_TWO_DECIMALS } from '../constants';
+import { LONG_TASK_THROTTLE_MS, PRECISION_TWO_DECIMALS } from '../constants';
+import { WEB_VITALS_THRESHOLDS } from '../constants/performance.constants';
 import { debugLog } from '../utils/logging';
 export class PerformanceHandler extends StateManager {
     constructor(eventManager) {
@@ -9,16 +9,14 @@ export class PerformanceHandler extends StateManager {
         this.reportedByNav = new Map();
         this.observers = [];
         this.lastLongTaskSentAt = 0;
+        this.vitalThresholds = WEB_VITALS_THRESHOLDS;
         this.eventManager = eventManager;
     }
     async startTracking() {
-        debugLog.debug('PerformanceHandler', 'Starting performance tracking');
         await this.initWebVitals();
         this.observeLongTasks();
-        this.reportTTFB();
     }
     stopTracking() {
-        debugLog.debug('PerformanceHandler', 'Stopping performance tracking', { observersCount: this.observers.length });
         this.observers.forEach((obs, index) => {
             try {
                 obs.disconnect();
@@ -32,10 +30,6 @@ export class PerformanceHandler extends StateManager {
         });
         this.observers.length = 0;
         this.reportedByNav.clear();
-        debugLog.debug('PerformanceHandler', 'Performance tracking cleanup completed', {
-            remainingObservers: this.observers.length,
-            clearedNavReports: true,
-        });
     }
     observeWebVitalsFallback() {
         // TTFB - should be captured immediately as it's available from navigation timing
@@ -51,7 +45,14 @@ export class PerformanceHandler extends StateManager {
         }, { type: 'largest-contentful-paint', buffered: true }, true);
         // CLS (layout-shift)
         let clsValue = 0;
+        let currentNavId = this.getNavigationId();
         this.safeObserve('layout-shift', (list) => {
+            const navId = this.getNavigationId();
+            // Reset CLS on navigation change
+            if (navId !== currentNavId) {
+                clsValue = 0;
+                currentNavId = navId;
+            }
             const entries = list.getEntries();
             for (const entry of entries) {
                 if (entry.hadRecentInput === true) {
@@ -60,7 +61,7 @@ export class PerformanceHandler extends StateManager {
                 const value = typeof entry.value === 'number' ? entry.value : 0;
                 clsValue += value;
             }
-            this.sendVital({ type: 'CLS', value: Number(clsValue.toFixed(PRECISION_FOUR_DECIMALS)) });
+            this.sendVital({ type: 'CLS', value: Number(clsValue.toFixed(PRECISION_TWO_DECIMALS)) });
         }, { type: 'layout-shift', buffered: true });
         // FCP
         this.safeObserve('paint', (list) => {
@@ -107,7 +108,6 @@ export class PerformanceHandler extends StateManager {
         try {
             const nav = performance.getEntriesByType('navigation')[0];
             if (!nav) {
-                debugLog.debug('PerformanceHandler', 'Navigation timing not available for TTFB');
                 return;
             }
             const ttfb = nav.responseStart;
@@ -119,9 +119,6 @@ export class PerformanceHandler extends StateManager {
             if (typeof ttfb === 'number' && Number.isFinite(ttfb)) {
                 this.sendVital({ type: 'TTFB', value: Number(ttfb.toFixed(PRECISION_TWO_DECIMALS)) });
             }
-            else {
-                debugLog.debug('PerformanceHandler', 'TTFB value is not a valid number', { ttfb });
-            }
         }
         catch (error) {
             debugLog.warn('PerformanceHandler', 'Failed to report TTFB', {
@@ -136,29 +133,38 @@ export class PerformanceHandler extends StateManager {
                 const duration = Number(entry.duration.toFixed(PRECISION_TWO_DECIMALS));
                 const now = Date.now();
                 if (now - this.lastLongTaskSentAt >= LONG_TASK_THROTTLE_MS) {
-                    this.trackWebVital('LONG_TASK', duration);
+                    if (this.shouldSendVital('LONG_TASK', duration)) {
+                        this.trackWebVital('LONG_TASK', duration);
+                    }
                     this.lastLongTaskSentAt = now;
                 }
             }
         }, { type: 'longtask', buffered: true });
     }
     sendVital(sample) {
+        if (!this.shouldSendVital(sample.type, sample.value)) {
+            return;
+        }
         const navId = this.getNavigationId();
-        const key = `${sample.type}`;
+        // Check for duplicates if we have a navigation ID
         if (navId) {
-            if (!this.reportedByNav.has(navId)) {
-                this.reportedByNav.set(navId, new Set());
-            }
-            const sent = this.reportedByNav.get(navId);
-            if (sent.has(key)) {
+            const reportedForNav = this.reportedByNav.get(navId);
+            const isDuplicate = reportedForNav?.has(sample.type);
+            if (isDuplicate) {
                 return;
             }
-            sent.add(key);
+            // Initialize or update reported vitals for this navigation
+            if (!reportedForNav) {
+                this.reportedByNav.set(navId, new Set([sample.type]));
+            }
+            else {
+                reportedForNav.add(sample.type);
+            }
         }
         this.trackWebVital(sample.type, sample.value);
     }
     trackWebVital(type, value) {
-        if (typeof value !== 'number' || !Number.isFinite(value)) {
+        if (!Number.isFinite(value)) {
             debugLog.warn('PerformanceHandler', 'Invalid web vital value', { type, value });
             return;
         }
@@ -176,7 +182,10 @@ export class PerformanceHandler extends StateManager {
             if (!nav) {
                 return null;
             }
-            return `${Math.round(nav.startTime)}_${window.location.pathname}`;
+            // Use more precise timestamp and add random component to prevent collisions
+            const timestamp = nav.startTime || performance.now();
+            const random = Math.random().toString(36).substr(2, 5);
+            return `${timestamp.toFixed(2)}_${window.location.pathname}_${random}`;
         }
         catch (error) {
             debugLog.warn('PerformanceHandler', 'Failed to get navigation ID', {
@@ -185,34 +194,64 @@ export class PerformanceHandler extends StateManager {
             return null;
         }
     }
+    isObserverSupported(type) {
+        if (typeof PerformanceObserver === 'undefined')
+            return false;
+        const supported = PerformanceObserver.supportedEntryTypes;
+        return !supported || supported.includes(type);
+    }
     safeObserve(type, cb, options, once = false) {
         try {
-            if (typeof PerformanceObserver === 'undefined')
-                return;
-            const supported = PerformanceObserver.supportedEntryTypes;
-            if (supported && !supported.includes(type))
-                return;
+            if (!this.isObserverSupported(type)) {
+                return false;
+            }
             const obs = new PerformanceObserver((list, observer) => {
-                cb(list, observer);
+                try {
+                    cb(list, observer);
+                }
+                catch (callbackError) {
+                    debugLog.warn('PerformanceHandler', 'Observer callback failed', {
+                        type,
+                        error: callbackError instanceof Error ? callbackError.message : 'Unknown error',
+                    });
+                }
                 if (once) {
                     try {
                         observer.disconnect();
                     }
                     catch {
-                        // Intentionally ignored
+                        // Disconnect errors are safe to ignore
                     }
                 }
             });
-            obs.observe((options ?? { type, buffered: true }));
+            obs.observe(options ?? { type, buffered: true });
             if (!once) {
                 this.observers.push(obs);
             }
+            return true;
         }
         catch (error) {
             debugLog.warn('PerformanceHandler', 'Failed to create performance observer', {
                 type,
                 error: error instanceof Error ? error.message : 'Unknown error',
             });
+            return false;
+        }
+    }
+    shouldSendVital(type, value) {
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            debugLog.warn('PerformanceHandler', 'Invalid web vital value', { 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.d.ts

@@ -3,10 +3,25 @@ import { StateManager } from '../managers/state.manager';
 export declare class ScrollHandler extends StateManager {
     private readonly eventManager;
     private readonly containers;
+    private limitWarningLogged;
+    private minDepthChange;
+    private minIntervalMs;
+    private maxEventsPerSession;
     constructor(eventManager: EventManager);
     startTracking(): void;
     stopTracking(): void;
     private setupScrollContainer;
+    private processScrollEvent;
+    private shouldEmitScrollEvent;
+    private hasReachedSessionLimit;
+    private hasElapsedMinimumInterval;
+    private hasSignificantDepthChange;
+    private logLimitOnce;
+    private applyConfigOverrides;
+    private isWindowScrollable;
+    private clearContainerTimer;
+    private getScrollDirection;
+    private calculateScrollDepth;
     private calculateScrollData;
     private getScrollTop;
     private getViewportHeight;