@tracelog/lib 0.0.8 → 0.2.0

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

@@ -1,8 +0,0 @@
-import { EventType, WebVitalsData } from '../types';
-import { StateManager } from './state.manager';
-export declare class SamplingManager extends StateManager {
-    shouldSampleEvent(type: EventType, webVitals?: WebVitalsData): boolean;
-    private isSampledIn;
-    private isWebVitalEventSampledIn;
-    private getHash;
-}

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

@@ -1,49 +0,0 @@
-import { DEFAULT_SAMPLING_RATE, WEB_VITALS_SAMPLING, WEB_VITALS_LONG_TASK_SAMPLING } from '../constants';
-import { EventType } from '../types';
-import { StateManager } from './state.manager';
-export class SamplingManager extends StateManager {
-    shouldSampleEvent(type, webVitals) {
-        const isQaMode = this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug';
-        if (isQaMode) {
-            return true;
-        }
-        if (type === EventType.WEB_VITALS) {
-            return this.isWebVitalEventSampledIn(webVitals?.type);
-        }
-        return this.isSampledIn();
-    }
-    isSampledIn() {
-        const samplingRate = this.get('config').samplingRate ?? DEFAULT_SAMPLING_RATE;
-        if (samplingRate >= 1.0) {
-            return true;
-        }
-        if (samplingRate <= 0) {
-            return false;
-        }
-        const userHash = this.getHash(this.get('userId'));
-        const userValue = (userHash % 100) / 100;
-        const isSampled = userValue < samplingRate;
-        return isSampled;
-    }
-    isWebVitalEventSampledIn(type) {
-        const isLongTask = type === 'LONG_TASK';
-        const rate = isLongTask ? WEB_VITALS_LONG_TASK_SAMPLING : WEB_VITALS_SAMPLING;
-        if (rate >= 1)
-            return true;
-        if (rate <= 0)
-            return false;
-        const seed = `${this.get('userId')}|${isLongTask ? 'long_task' : 'web_vitals'}`;
-        const hash = this.getHash(seed);
-        const value = (hash % 100) / 100;
-        return value < rate;
-    }
-    getHash(input) {
-        let hash = 0;
-        for (let i = 0; i < input.length; i++) {
-            const char = input.charCodeAt(i);
-            hash = (hash << 5) - hash + char;
-            hash |= 0;
-        }
-        return Math.abs(hash);
-    }
-}

package/dist/esm/managers/session-recovery.manager.d.ts

@@ -1,65 +0,0 @@
-import { SessionRecoveryConfig, SessionContext } from '../types/session.types';
-import { StateManager } from './state.manager';
-import { StorageManager } from './storage.manager';
-import { EventManager } from './event.manager';
-export declare class SessionRecoveryManager extends StateManager {
-    private readonly config;
-    private readonly storageManager;
-    private readonly eventManager;
-    private readonly projectId;
-    private readonly debugMode;
-    constructor(storageManager: StorageManager, projectId: string, eventManager?: EventManager, config?: Partial<SessionRecoveryConfig>);
-    /**
-     * Attempt to recover a session
-     */
-    attemptSessionRecovery(currentSessionId?: string): {
-        recovered: boolean;
-        recoveredSessionId?: string;
-        context?: SessionContext;
-    };
-    /**
-     * Calculate the recovery window with bounds checking
-     */
-    private calculateRecoveryWindow;
-    /**
-     * Check if session recovery can be attempted
-     */
-    private canAttemptRecovery;
-    /**
-     * Store session context for potential recovery
-     */
-    storeSessionContextForRecovery(sessionContext: SessionContext): void;
-    /**
-     * Get stored recovery attempts
-     */
-    private getStoredRecoveryAttempts;
-    /**
-     * Store recovery attempts
-     */
-    private storeRecoveryAttempts;
-    /**
-     * Get the last recovery attempt
-     */
-    private getLastRecoveryAttempt;
-    /**
-     * Clean up old recovery attempts
-     */
-    cleanupOldRecoveryAttempts(): void;
-    /**
-     * Check if there's a recoverable session.
-     * Returns false when no recovery attempts are stored.
-     */
-    hasRecoverableSession(): boolean;
-    /**
-     * Get recovery window in milliseconds
-     */
-    getRecoveryWindowMs(): number;
-    /**
-     * Get max recovery attempts
-     */
-    getMaxRecoveryAttempts(): number;
-    /**
-     * Clear all stored recovery data
-     */
-    clearRecoveryData(): void;
-}

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

@@ -1,233 +0,0 @@
-import { DEFAULT_SESSION_TIMEOUT_MS, SESSION_RECOVERY_WINDOW_MULTIPLIER, MAX_SESSION_RECOVERY_ATTEMPTS, MAX_SESSION_RECOVERY_WINDOW_MS, MIN_SESSION_RECOVERY_WINDOW_MS, } from '../constants';
-import { SESSION_RECOVERY_KEY } from '../constants/storage.constants';
-import { debugLog } from '../utils/logging';
-import { StateManager } from './state.manager';
-export class SessionRecoveryManager extends StateManager {
-    constructor(storageManager, projectId, eventManager, config) {
-        super();
-        this.storageManager = storageManager;
-        this.eventManager = eventManager ?? null;
-        this.projectId = projectId;
-        this.debugMode = (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') ?? false;
-        this.config = {
-            recoveryWindowMs: this.calculateRecoveryWindow(),
-            maxRecoveryAttempts: MAX_SESSION_RECOVERY_ATTEMPTS,
-            contextPreservation: true,
-            ...config,
-        };
-    }
-    /**
-     * Attempt to recover a session
-     */
-    attemptSessionRecovery(currentSessionId) {
-        if (this.debugMode) {
-            debugLog.debug('SessionRecovery', 'Attempting session recovery');
-        }
-        // Get stored recovery attempts
-        const recoveryAttempts = this.getStoredRecoveryAttempts();
-        const lastAttempt = this.getLastRecoveryAttempt();
-        // Check if we can recover
-        if (!this.canAttemptRecovery(lastAttempt)) {
-            if (this.debugMode) {
-                debugLog.debug('SessionRecovery', 'Session recovery not possible - outside recovery window or max attempts reached');
-            }
-            return {
-                recovered: false,
-            };
-        }
-        // Get the last session context
-        const lastSessionContext = lastAttempt?.context;
-        if (!lastSessionContext) {
-            if (this.debugMode) {
-                debugLog.debug('SessionRecovery', 'No session context available for recovery');
-            }
-            return {
-                recovered: false,
-            };
-        }
-        // Check if recovery is possible
-        const now = Date.now();
-        const timeSinceLastActivity = now - lastSessionContext.lastActivity;
-        if (timeSinceLastActivity > this.config.recoveryWindowMs) {
-            if (this.debugMode) {
-                debugLog.debug('SessionRecovery', 'Session recovery failed - outside recovery window');
-            }
-            return {
-                recovered: false,
-            };
-        }
-        // Perform recovery
-        const recoveredSessionId = lastSessionContext.sessionId;
-        const attemptNumber = (lastAttempt?.attempt ?? 0) + 1;
-        // Create recovery attempt record
-        const recoveryAttempt = {
-            sessionId: currentSessionId ?? recoveredSessionId,
-            timestamp: now,
-            attempt: attemptNumber,
-            context: {
-                ...lastSessionContext,
-                recoveryAttempts: attemptNumber,
-                lastActivity: now,
-            },
-        };
-        recoveryAttempts.push(recoveryAttempt);
-        this.storeRecoveryAttempts(recoveryAttempts);
-        if (this.debugMode) {
-            debugLog.debug('SessionRecovery', `Session recovery successful: recovery of session ${recoveredSessionId}`);
-        }
-        return {
-            recovered: true,
-            recoveredSessionId,
-            context: recoveryAttempt.context,
-        };
-    }
-    /**
-     * Calculate the recovery window with bounds checking
-     */
-    calculateRecoveryWindow() {
-        const sessionTimeout = this.get('config')?.sessionTimeout ?? DEFAULT_SESSION_TIMEOUT_MS;
-        const calculatedRecoveryWindow = sessionTimeout * SESSION_RECOVERY_WINDOW_MULTIPLIER;
-        const boundedRecoveryWindow = Math.max(Math.min(calculatedRecoveryWindow, MAX_SESSION_RECOVERY_WINDOW_MS), MIN_SESSION_RECOVERY_WINDOW_MS);
-        if (this.debugMode) {
-            if (calculatedRecoveryWindow > MAX_SESSION_RECOVERY_WINDOW_MS) {
-                debugLog.warn('SessionRecovery', `Recovery window capped at ${MAX_SESSION_RECOVERY_WINDOW_MS}ms (24h). Calculated: ${calculatedRecoveryWindow}ms`);
-            }
-            else if (calculatedRecoveryWindow < MIN_SESSION_RECOVERY_WINDOW_MS) {
-                debugLog.warn('SessionRecovery', `Recovery window increased to minimum ${MIN_SESSION_RECOVERY_WINDOW_MS}ms (2min). Calculated: ${calculatedRecoveryWindow}ms`);
-            }
-        }
-        return boundedRecoveryWindow;
-    }
-    /**
-     * Check if session recovery can be attempted
-     */
-    canAttemptRecovery(lastAttempt) {
-        if (!lastAttempt) {
-            return true; // First recovery attempt
-        }
-        const now = Date.now();
-        const timeSinceLastActivity = now - lastAttempt.context.lastActivity;
-        // Check if within recovery window
-        if (timeSinceLastActivity > this.config.recoveryWindowMs) {
-            return false;
-        }
-        // Check max attempts
-        if (lastAttempt.attempt >= this.config.maxRecoveryAttempts) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Store session context for potential recovery
-     */
-    storeSessionContextForRecovery(sessionContext) {
-        try {
-            const recoveryAttempts = this.getStoredRecoveryAttempts();
-            // Create a recovery attempt record
-            const recoveryAttempt = {
-                sessionId: sessionContext.sessionId,
-                timestamp: Date.now(),
-                attempt: 0,
-                context: sessionContext,
-            };
-            // Add to recovery attempts (keep only the latest few)
-            recoveryAttempts.push(recoveryAttempt);
-            const maxStoredRecoveryAttempts = 5;
-            if (recoveryAttempts.length > maxStoredRecoveryAttempts) {
-                recoveryAttempts.splice(0, recoveryAttempts.length - maxStoredRecoveryAttempts);
-            }
-            this.storeRecoveryAttempts(recoveryAttempts);
-            if (this.debugMode) {
-                debugLog.debug('SessionRecovery', `Stored session context for recovery: ${sessionContext.sessionId}`);
-            }
-        }
-        catch (error) {
-            if (this.debugMode) {
-                debugLog.warn('SessionRecovery', 'Failed to store session context for recovery', { error });
-            }
-        }
-    }
-    /**
-     * Get stored recovery attempts
-     */
-    getStoredRecoveryAttempts() {
-        try {
-            const stored = this.storageManager.getItem(SESSION_RECOVERY_KEY(this.projectId));
-            return stored ? JSON.parse(stored) : [];
-        }
-        catch (error) {
-            if (this.debugMode) {
-                const stored = this.storageManager.getItem(SESSION_RECOVERY_KEY(this.projectId));
-                debugLog.warn('SessionRecovery', `Failed to parse stored recovery attempts for projectId ${this.projectId}. Data: ${stored}`, { error });
-            }
-            return [];
-        }
-    }
-    /**
-     * Store recovery attempts
-     */
-    storeRecoveryAttempts(attempts) {
-        try {
-            this.storageManager.setItem(SESSION_RECOVERY_KEY(this.projectId), JSON.stringify(attempts));
-        }
-        catch (error) {
-            if (this.debugMode) {
-                debugLog.warn('SessionRecovery', 'Failed to store recovery attempts', { error });
-            }
-        }
-    }
-    /**
-     * Get the last recovery attempt
-     */
-    getLastRecoveryAttempt() {
-        const attempts = this.getStoredRecoveryAttempts();
-        return attempts.length > 0 ? attempts[attempts.length - 1] : null;
-    }
-    /**
-     * Clean up old recovery attempts
-     */
-    cleanupOldRecoveryAttempts() {
-        const attempts = this.getStoredRecoveryAttempts();
-        const now = Date.now();
-        // Remove attempts older than recovery window
-        const validAttempts = attempts.filter((attempt) => now - attempt.timestamp <= this.config.recoveryWindowMs);
-        if (validAttempts.length !== attempts.length) {
-            this.storeRecoveryAttempts(validAttempts);
-            if (this.debugMode) {
-                debugLog.debug('SessionRecovery', `Cleaned up ${attempts.length - validAttempts.length} old recovery attempts`);
-            }
-        }
-    }
-    /**
-     * Check if there's a recoverable session.
-     * Returns false when no recovery attempts are stored.
-     */
-    hasRecoverableSession() {
-        const lastAttempt = this.getLastRecoveryAttempt();
-        if (!lastAttempt) {
-            return false;
-        }
-        return this.canAttemptRecovery(lastAttempt);
-    }
-    /**
-     * Get recovery window in milliseconds
-     */
-    getRecoveryWindowMs() {
-        return this.config.recoveryWindowMs;
-    }
-    /**
-     * Get max recovery attempts
-     */
-    getMaxRecoveryAttempts() {
-        return this.config.maxRecoveryAttempts;
-    }
-    /**
-     * Clear all stored recovery data
-     */
-    clearRecoveryData() {
-        this.storageManager.removeItem(SESSION_RECOVERY_KEY(this.projectId));
-        if (this.debugMode) {
-            debugLog.debug('SessionRecovery', 'Cleared all recovery data');
-        }
-    }
-}

package/dist/esm/types/web-vitals.types.d.ts

@@ -1,6 +0,0 @@
-import { WebVitalType } from './event.types';
-export type NavigationId = string;
-export interface VitalSample {
-    type: WebVitalType;
-    value: number;
-}