@tracelog/lib 0.0.8 → 0.2.0

package/dist/esm/constants/validation.constants.js

@@ -1,28 +0,0 @@
-import { MIN_SESSION_TIMEOUT_MS, MAX_SESSION_TIMEOUT_MS, MIN_SAMPLING_RATE, MAX_SAMPLING_RATE, } from './limits.constants';
-// 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 ${MIN_SAMPLING_RATE} and ${MAX_SAMPLING_RATE}`,
-    INVALID_ERROR_SAMPLING_RATE: 'Error sampling must be between 0 and 1',
-    // Integration validation
-    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/handlers/network.handler.d.ts

@@ -1,16 +0,0 @@
-import { EventManager } from '../managers/event.manager';
-import { StateManager } from '../managers/state.manager';
-export declare class NetworkHandler extends StateManager {
-    private readonly eventManager;
-    private readonly originalFetch;
-    private readonly originalXHROpen;
-    private readonly originalXHRSend;
-    constructor(eventManager: EventManager);
-    startTracking(): void;
-    stopTracking(): void;
-    private interceptFetch;
-    private interceptXHR;
-    private trackNetworkError;
-    private normalizeUrlForTracking;
-    private shouldSample;
-}

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

@@ -1,132 +0,0 @@
-import { StateManager } from '../managers/state.manager';
-import { ErrorType, EventType } from '../types';
-import { normalizeUrl } from '../utils';
-import { debugLog } from '../utils/logging';
-export class NetworkHandler extends StateManager {
-    constructor(eventManager) {
-        super();
-        this.eventManager = eventManager;
-        this.originalFetch = window.fetch;
-        this.originalXHROpen = XMLHttpRequest.prototype.open;
-        this.originalXHRSend = XMLHttpRequest.prototype.send;
-    }
-    startTracking() {
-        debugLog.debug('NetworkHandler', 'Starting network error tracking');
-        this.interceptFetch();
-        this.interceptXHR();
-    }
-    stopTracking() {
-        debugLog.debug('NetworkHandler', 'Stopping network error tracking');
-        window.fetch = this.originalFetch;
-        XMLHttpRequest.prototype.open = this.originalXHROpen;
-        XMLHttpRequest.prototype.send = this.originalXHRSend;
-    }
-    interceptFetch() {
-        window.fetch = async (input, init) => {
-            const startTime = Date.now();
-            const url = typeof input === 'string' ? input : input.toString();
-            const method = init?.method ?? 'GET';
-            try {
-                const response = await this.originalFetch(input, init);
-                const duration = Date.now() - startTime;
-                if (!response.ok) {
-                    debugLog.debug('NetworkHandler', 'Fetch error detected', {
-                        method,
-                        url: this.normalizeUrlForTracking(url),
-                        status: response.status,
-                        statusText: response.statusText,
-                    });
-                    this.trackNetworkError(method.toUpperCase(), this.normalizeUrlForTracking(url), response.status, response.statusText, duration);
-                }
-                return response;
-            }
-            catch (error) {
-                const duration = Date.now() - startTime;
-                const errorMessage = error instanceof Error ? error.message : 'Network Error';
-                debugLog.debug('NetworkHandler', 'Fetch exception caught', {
-                    method,
-                    url: this.normalizeUrlForTracking(url),
-                    error: errorMessage,
-                });
-                this.trackNetworkError(method.toUpperCase(), this.normalizeUrlForTracking(url), undefined, errorMessage, duration);
-                throw error;
-            }
-        };
-    }
-    interceptXHR() {
-        const trackNetworkError = this.trackNetworkError.bind(this);
-        const normalizeUrlForTracking = this.normalizeUrlForTracking.bind(this);
-        const originalXHROpen = this.originalXHROpen;
-        const originalXHRSend = this.originalXHRSend;
-        XMLHttpRequest.prototype.open = function (method, url, async, user, password) {
-            const asyncMode = async ?? true;
-            const extendedThis = this;
-            extendedThis._tracelogStartTime = Date.now();
-            extendedThis._tracelogMethod = method.toUpperCase();
-            extendedThis._tracelogUrl = url.toString();
-            return originalXHROpen.call(this, method, url, asyncMode, user, password);
-        };
-        XMLHttpRequest.prototype.send = function (body) {
-            const xhr = this;
-            const startTime = xhr._tracelogStartTime ?? Date.now();
-            const method = xhr._tracelogMethod ?? 'GET';
-            const url = xhr._tracelogUrl ?? '';
-            const originalOnReadyStateChange = xhr.onreadystatechange;
-            xhr.onreadystatechange = (ev) => {
-                if (xhr.readyState === XMLHttpRequest.DONE) {
-                    const duration = Date.now() - startTime;
-                    if (xhr.status === 0 || xhr.status >= 400) {
-                        const statusText = xhr.statusText || 'Request Failed';
-                        debugLog.debug('NetworkHandler', 'XHR error detected', {
-                            method,
-                            url: normalizeUrlForTracking(url),
-                            status: xhr.status,
-                            statusText,
-                        });
-                        trackNetworkError(method, normalizeUrlForTracking(url), xhr.status, statusText, duration);
-                    }
-                }
-                if (originalOnReadyStateChange) {
-                    return originalOnReadyStateChange.call(xhr, ev);
-                }
-            };
-            return originalXHRSend.call(this, body);
-        };
-    }
-    trackNetworkError(method, url, status, statusText, duration) {
-        const config = this.get('config');
-        if (!this.shouldSample(config?.errorSampling ?? 0.1)) {
-            debugLog.debug('NetworkHandler', `Network error not sampled, skipping (errorSampling: ${config?.errorSampling}, method: ${method}, url: ${url})`, {
-                errorSampling: config?.errorSampling,
-                method,
-                url,
-            });
-            return;
-        }
-        debugLog.warn('NetworkHandler', `Network error tracked: ${method} ${url} (status: ${status}, statusText: ${statusText}, duration: ${duration}ms)`, { method, url, status, statusText, duration });
-        this.eventManager.track({
-            type: EventType.ERROR,
-            error_data: {
-                type: ErrorType.NETWORK_ERROR,
-                message: statusText,
-                method,
-                url,
-                status,
-                statusText,
-                duration,
-            },
-        });
-    }
-    normalizeUrlForTracking(url) {
-        try {
-            const config = this.get('config');
-            return normalizeUrl(url, config?.sensitiveQueryParams);
-        }
-        catch {
-            return url;
-        }
-    }
-    shouldSample(rate) {
-        return Math.random() < rate;
-    }
-}

package/dist/esm/managers/cross-tab-session.manager.d.ts

@@ -1,170 +0,0 @@
-import { CrossTabSessionConfig, SessionEndReason } from '../types/session.types';
-import { StateManager } from './state.manager';
-import { StorageManager } from './storage.manager';
-export declare class CrossTabSessionManager extends StateManager {
-    private readonly callbacks?;
-    private readonly config;
-    private readonly storageManager;
-    private readonly broadcastChannel;
-    private readonly tabId;
-    private readonly tabInfo;
-    private readonly projectId;
-    private leaderTabId;
-    private isTabLeader;
-    private heartbeatInterval;
-    private electionTimeout;
-    private cleanupTimeout;
-    private sessionEnded;
-    private fallbackLeadershipTimeout;
-    private electionDelayTimeout;
-    private tabInfoCleanupTimeout;
-    private closingAnnouncementTimeout;
-    private leaderHealthCheckInterval;
-    private lastHeartbeatSent;
-    constructor(storageManager: StorageManager, projectId: string, config?: Partial<CrossTabSessionConfig>, callbacks?: {
-        onSessionStart?: (sessionId: string) => void;
-        onSessionEnd?: (reason: SessionEndReason) => void;
-        onTabActivity?: () => void;
-        onCrossTabConflict?: () => void;
-    } | undefined);
-    /**
-     * Initialize BroadcastChannel if supported
-     */
-    private initializeBroadcastChannel;
-    /**
-     * Initialize the cross-tab session manager
-     */
-    private initialize;
-    /**
-     * Check if this tab should be the session leader
-     */
-    private tryJoinExistingSession;
-    /**
-     * Request leadership status from other tabs
-     */
-    private requestLeadershipStatus;
-    /**
-     * Start leader election process with debouncing to prevent excessive elections
-     */
-    private startLeaderElection;
-    /**
-     * Become the session leader
-     */
-    private becomeLeader;
-    /**
-     * Announce session start to other tabs
-     */
-    private announceSessionStart;
-    /**
-     * Announce leadership to other tabs
-     */
-    private announceLeadership;
-    /**
-     * Setup fallback mechanism to ensure a leader is always elected
-     */
-    private setupLeadershipFallback;
-    /**
-     * Setup BroadcastChannel event listeners
-     */
-    private setupBroadcastListeners;
-    /**
-     * Handle cross-tab messages
-     */
-    private handleCrossTabMessage;
-    /**
-     * Handle heartbeat message from another tab
-     */
-    private handleHeartbeatMessage;
-    /**
-     * Handle session start message from another tab
-     */
-    private handleSessionStartMessage;
-    /**
-     * Handle session end message from another tab
-     */
-    private handleSessionEndMessage;
-    /**
-     * Handle tab closing message from another tab
-     */
-    private handleTabClosingMessage;
-    /**
-     * Handle election request from another tab
-     */
-    private handleElectionRequest;
-    /**
-     * Handle election response from another tab
-     */
-    private handleElectionResponse;
-    /**
-     * Start heartbeat to keep session active
-     */
-    private startHeartbeat;
-    /**
-     * Send heartbeat to other tabs with rate limiting to prevent flooding
-     */
-    private sendHeartbeat;
-    /**
-     * Update tab info with current timestamp
-     */
-    private updateTabInfo;
-    /**
-     * End session and notify other tabs
-     */
-    endSession(reason: SessionEndReason): void;
-    /**
-     * Announce tab is closing to other tabs
-     */
-    private announceTabClosing;
-    /**
-     * Announce session end to other tabs
-     */
-    private announceSessionEnd;
-    /**
-     * Get current session ID
-     */
-    getSessionId(): string;
-    /**
-     * Get current tab ID
-     */
-    getTabId(): string;
-    /**
-     * Check if this tab is the session leader
-     */
-    isLeader(): boolean;
-    /**
-     * Get current session context from storage
-     */
-    private getStoredSessionContext;
-    /**
-     * Store session context to localStorage
-     */
-    private storeSessionContext;
-    /**
-     * Clear stored session context
-     */
-    private clearStoredSessionContext;
-    /**
-     * Store tab info to localStorage
-     */
-    private storeTabInfo;
-    /**
-     * Clear tab info from localStorage
-     */
-    private clearTabInfo;
-    /**
-     * Check if BroadcastChannel is supported
-     */
-    private isBroadcastChannelSupported;
-    /**
-     * Get session timeout considering cross-tab activity
-     */
-    getEffectiveSessionTimeout(): number;
-    /**
-     * Update session activity from any tab
-     */
-    updateSessionActivity(): void;
-    /**
-     * Cleanup resources
-     */
-    destroy(): void;
-}