@tracelog/lib 0.0.8 → 0.2.0

package/dist/cjs/utils/index.d.ts

@@ -4,3 +4,4 @@ export * from './logging';
 export * from './network';
 export * from './security';
 export * from './validations';
+export * from './emitter.utils';

package/dist/cjs/utils/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./logging"), exports);
 __exportStar(require("./network"), exports);
 __exportStar(require("./security"), exports);
 __exportStar(require("./validations"), exports);
+__exportStar(require("./emitter.utils"), exports);

package/dist/cjs/utils/logging/debug-logger.utils.d.ts

@@ -1,56 +1,15 @@
 import { StateManager } from '../../managers/state.manager';
-/**
- * Debug logger class that extends StateManager for clean access to global state
- */
 declare class DebugLogger extends StateManager {
-    /**
-     * Client-facing error - Configuration/usage errors by the client
-     * Console: qa and debug modes | Events: NODE_ENV=dev
-     */
-    clientError(namespace: string, message: string, data?: unknown): void;
-    /**
-     * Client-facing warning - Configuration/usage warnings by the client
-     * Console: qa and debug modes | Events: NODE_ENV=dev
-     */
-    clientWarn(namespace: string, message: string, data?: unknown): void;
-    /**
-     * General operational information
-     * Console: qa and debug modes | Events: NODE_ENV=dev
-     */
-    info(namespace: string, message: string, data?: unknown): void;
-    /**
-     * Internal library errors
-     * Console: debug mode only | Events: NODE_ENV=dev
-     */
-    error(namespace: string, message: string, data?: unknown): void;
-    /**
-     * Internal library warnings
-     * Console: debug mode only | Events: NODE_ENV=dev
-     */
-    warn(namespace: string, message: string, data?: unknown): void;
-    /**
-     * Strategic debug information
-     * Console: debug mode only | Events: NODE_ENV=dev
-     */
-    debug(namespace: string, message: string, data?: unknown): void;
-    /**
-     * Detailed trace information
-     * Console: debug mode only | Events: NODE_ENV=dev
-     */
-    verbose(namespace: string, message: string, data?: unknown): void;
-    private getCurrentMode;
-    private shouldShowLog;
-    private formatMessage;
-    private getConsoleMethod;
-    private logMessage;
-    /**
-     * Dispatches tracelog:log events for E2E testing and development debugging
-     */
-    private dispatchEvent;
+    clientError: (ns: string, msg: string, data?: unknown) => void;
+    clientWarn: (ns: string, msg: string, data?: unknown) => void;
+    info: (ns: string, msg: string, data?: unknown) => void;
+    error: (ns: string, msg: string, data?: unknown) => void;
+    warn: (ns: string, msg: string, data?: unknown) => void;
+    debug: (ns: string, msg: string, data?: unknown) => void;
+    verbose: (ns: string, msg: string, data?: unknown) => void;
+    private log;
+    private shouldShow;
+    private getMethod;
 }
-/**
- * Singleton debug logger instance
- * Provides the same API as before: debugLog.clientError(), debugLog.info(), etc.
- */
 export declare const debugLog: DebugLogger;
 export {};

package/dist/cjs/utils/logging/debug-logger.utils.js

@@ -2,138 +2,47 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.debugLog = void 0;
 const state_manager_1 = require("../../managers/state.manager");
-/**
- * Debug logger class that extends StateManager for clean access to global state
- */
 class DebugLogger extends state_manager_1.StateManager {
-    /**
-     * Client-facing error - Configuration/usage errors by the client
-     * Console: qa and debug modes | Events: NODE_ENV=dev
-     */
-    clientError(namespace, message, data) {
-        this.logMessage('CLIENT_ERROR', namespace, message, data);
-    }
-    /**
-     * Client-facing warning - Configuration/usage warnings by the client
-     * Console: qa and debug modes | Events: NODE_ENV=dev
-     */
-    clientWarn(namespace, message, data) {
-        this.logMessage('CLIENT_WARN', namespace, message, data);
-    }
-    /**
-     * General operational information
-     * Console: qa and debug modes | Events: NODE_ENV=dev
-     */
-    info(namespace, message, data) {
-        this.logMessage('INFO', namespace, message, data);
-    }
-    /**
-     * Internal library errors
-     * Console: debug mode only | Events: NODE_ENV=dev
-     */
-    error(namespace, message, data) {
-        this.logMessage('ERROR', namespace, message, data);
-    }
-    /**
-     * Internal library warnings
-     * Console: debug mode only | Events: NODE_ENV=dev
-     */
-    warn(namespace, message, data) {
-        this.logMessage('WARN', namespace, message, data);
-    }
-    /**
-     * Strategic debug information
-     * Console: debug mode only | Events: NODE_ENV=dev
-     */
-    debug(namespace, message, data) {
-        this.logMessage('DEBUG', namespace, message, data);
-    }
-    /**
-     * Detailed trace information
-     * Console: debug mode only | Events: NODE_ENV=dev
-     */
-    verbose(namespace, message, data) {
-        this.logMessage('VERBOSE', namespace, message, data);
-    }
-    getCurrentMode() {
-        try {
-            return this.get('config')?.mode;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    shouldShowLog(level) {
-        const mode = this.getCurrentMode();
-        switch (mode) {
-            case 'qa':
-                return ['INFO', 'CLIENT_ERROR', 'CLIENT_WARN'].includes(level);
-            case 'debug':
-                return true;
-            default:
-                return false;
-        }
-    }
-    formatMessage(namespace, message) {
-        return `[TraceLog:${namespace}] ${message}`;
-    }
-    getConsoleMethod(level) {
-        switch (level) {
-            case 'CLIENT_ERROR':
-            case 'ERROR':
-                return 'error';
-            case 'CLIENT_WARN':
-            case 'WARN':
-                return 'warn';
-            case 'INFO':
-            case 'DEBUG':
-            case 'VERBOSE':
-            default:
-                return 'log';
-        }
-    }
-    logMessage(level, namespace, message, data) {
-        if (!this.shouldShowLog(level)) {
+    constructor() {
+        super(...arguments);
+        this.clientError = (ns, msg, data) => this.log('CLIENT_ERROR', ns, msg, data);
+        this.clientWarn = (ns, msg, data) => this.log('CLIENT_WARN', ns, msg, data);
+        this.info = (ns, msg, data) => this.log('INFO', ns, msg, data);
+        this.error = (ns, msg, data) => this.log('ERROR', ns, msg, data);
+        this.warn = (ns, msg, data) => this.log('WARN', ns, msg, data);
+        this.debug = (ns, msg, data) => this.log('DEBUG', ns, msg, data);
+        this.verbose = (ns, msg, data) => this.log('VERBOSE', ns, msg, data);
+    }
+    log(level, ns, msg, data) {
+        const mode = this.get('config')?.mode;
+        if (!this.shouldShow(level, mode))
             return;
-        }
-        const formattedMessage = this.formatMessage(namespace, message);
-        const consoleMethod = this.getConsoleMethod(level);
+        const formattedMsg = `[TraceLog:${ns}] ${msg}`;
+        const method = this.getMethod(level);
         if (data !== undefined) {
-            console[consoleMethod](formattedMessage, data);
+            console[method](formattedMsg, data);
         }
         else {
-            console[consoleMethod](formattedMessage);
-        }
-        if (process.env.NODE_ENV === 'dev') {
-            this.dispatchEvent(level, namespace, message, data);
-        }
-    }
-    /**
-     * Dispatches tracelog:log events for E2E testing and development debugging
-     */
-    dispatchEvent(level, namespace, message, data) {
-        if (typeof window === 'undefined' || typeof CustomEvent === 'undefined') {
-            return;
-        }
-        try {
-            const event = new CustomEvent('tracelog:log', {
-                detail: {
-                    timestamp: new Date().toISOString(),
-                    level,
-                    namespace,
-                    message,
-                    data,
-                },
-            });
-            window.dispatchEvent(event);
-        }
-        catch {
-            console.log(`[TraceLog:${namespace}] ${message}`, data);
-        }
+            console[method](formattedMsg);
+        }
+    }
+    shouldShow(level, mode) {
+        if (['CLIENT_ERROR', 'ERROR'].includes(level))
+            return true;
+        if (!mode)
+            return level === 'CLIENT_WARN';
+        if (mode === 'qa')
+            return ['INFO', 'CLIENT_ERROR', 'CLIENT_WARN'].includes(level);
+        if (mode === 'debug')
+            return true; // Debug mode shows all logs
+        return false;
+    }
+    getMethod(level) {
+        if (['CLIENT_ERROR', 'ERROR'].includes(level))
+            return 'error';
+        if (['CLIENT_WARN', 'WARN'].includes(level))
+            return 'warn';
+        return 'log';
     }
 }
-/**
- * Singleton debug logger instance
- * Provides the same API as before: debugLog.clientError(), debugLog.info(), etc.
- */
 exports.debugLog = new DebugLogger();

package/dist/cjs/utils/network/fetch-with-timeout.utils.d.ts

@@ -0,0 +1,4 @@
+export interface FetchWithTimeoutOptions extends RequestInit {
+    timeout?: number;
+}
+export declare function fetchWithTimeout(url: string, options?: FetchWithTimeoutOptions): Promise<Response>;

package/dist/cjs/utils/network/fetch-with-timeout.utils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchWithTimeout = fetchWithTimeout;
+async function fetchWithTimeout(url, options = {}) {
+    const { timeout = 10000, ...fetchOptions } = options;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+        controller.abort();
+    }, timeout);
+    try {
+        const response = await fetch(url, {
+            ...fetchOptions,
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        return response;
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error(`Request timeout after ${timeout}ms`);
+        }
+        throw error;
+    }
+}

package/dist/cjs/utils/network/index.d.ts

@@ -1 +1,2 @@
 export * from './url.utils';
+export * from './fetch-with-timeout.utils';

package/dist/cjs/utils/network/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./url.utils"), exports);
+__exportStar(require("./fetch-with-timeout.utils"), exports);

package/dist/cjs/utils/network/url.utils.js

@@ -9,7 +9,6 @@ const logging_1 = require("../logging");
  * @returns The generated API URL
  */
 const getApiUrl = (id, allowHttp = false) => {
-    logging_1.debugLog.debug('URLUtils', 'Generating API URL', { projectId: id, allowHttp });
     const url = new URL(window.location.href);
     const host = url.hostname;
     const parts = host.split('.');
@@ -20,14 +19,6 @@ const getApiUrl = (id, allowHttp = false) => {
     const cleanDomain = parts.slice(-2).join('.');
     const protocol = allowHttp && url.protocol === 'http:' ? 'http' : 'https';
     const apiUrl = `${protocol}://${id}.${cleanDomain}`;
-    logging_1.debugLog.debug('URLUtils', 'Generated API URL', {
-        originalUrl: window.location.href,
-        hostname: host,
-        domainParts: parts.length,
-        cleanDomain,
-        protocol,
-        generatedUrl: apiUrl,
-    });
     const isValid = (0, validations_1.isValidUrl)(apiUrl, allowHttp);
     if (!isValid) {
         logging_1.debugLog.clientError('URLUtils', 'Generated API URL failed validation', {
@@ -36,7 +27,6 @@ const getApiUrl = (id, allowHttp = false) => {
         });
         throw new Error('Invalid URL');
     }
-    logging_1.debugLog.debug('URLUtils', 'API URL generation completed successfully', { apiUrl });
     return apiUrl;
 };
 exports.getApiUrl = getApiUrl;
@@ -47,10 +37,6 @@ exports.getApiUrl = getApiUrl;
  * @returns The normalized URL
  */
 const normalizeUrl = (url, sensitiveQueryParams = []) => {
-    logging_1.debugLog.debug('URLUtils', 'Normalizing URL', {
-        urlLength: url.length,
-        sensitiveParamsCount: sensitiveQueryParams.length,
-    });
     try {
         const urlObject = new URL(url);
         const searchParams = urlObject.searchParams;
@@ -72,16 +58,10 @@ const normalizeUrl = (url, sensitiveQueryParams = []) => {
             });
         }
         if (!hasChanged && url.includes('?')) {
-            logging_1.debugLog.debug('URLUtils', 'URL normalization - no changes needed');
             return url;
         }
         urlObject.search = searchParams.toString();
         const result = urlObject.toString();
-        logging_1.debugLog.debug('URLUtils', 'URL normalization completed', {
-            hasChanged,
-            originalLength: url.length,
-            normalizedLength: result.length,
-        });
         return result;
     }
     catch (error) {
@@ -100,18 +80,13 @@ exports.normalizeUrl = normalizeUrl;
  * @returns True if the URL should be excluded
  */
 const isUrlPathExcluded = (url, excludedPaths = []) => {
-    logging_1.debugLog.debug('URLUtils', 'Checking if URL path is excluded', {
-        urlLength: url.length,
-        excludedPathsCount: excludedPaths.length,
-    });
     if (excludedPaths.length === 0) {
-        logging_1.debugLog.debug('URLUtils', 'No excluded paths configured');
         return false;
     }
     let path;
     try {
-        path = new URL(url, window.location.origin).pathname;
-        logging_1.debugLog.debug('URLUtils', 'Extracted path from URL', { path });
+        const parsedUrl = new URL(url, window.location.origin);
+        path = parsedUrl.pathname + (parsedUrl.hash ?? '');
     }
     catch (error) {
         logging_1.debugLog.warn('URLUtils', 'Failed to parse URL for path exclusion check', {
@@ -132,23 +107,14 @@ const isUrlPathExcluded = (url, excludedPaths = []) => {
         try {
             if (isRegularExpression(pattern)) {
                 const matches = pattern.test(path);
-                if (matches) {
-                    logging_1.debugLog.debug('URLUtils', 'Path matched regex pattern', { path, pattern: pattern.toString() });
-                }
                 return matches;
             }
             if (pattern.includes('*')) {
                 const regex = wildcardToRegex(pattern);
                 const matches = regex.test(path);
-                if (matches) {
-                    logging_1.debugLog.debug('URLUtils', 'Path matched wildcard pattern', { path, pattern, regex: regex.toString() });
-                }
                 return matches;
             }
             const matches = pattern === path;
-            if (matches) {
-                logging_1.debugLog.debug('URLUtils', 'Path matched exact pattern', { path, pattern });
-            }
             return matches;
         }
         catch (error) {
@@ -161,12 +127,6 @@ const isUrlPathExcluded = (url, excludedPaths = []) => {
         }
     });
     const isExcluded = !!matchedPattern;
-    logging_1.debugLog.debug('URLUtils', 'URL path exclusion check completed', {
-        path,
-        isExcluded,
-        matchedPattern: matchedPattern ?? null,
-        totalPatternsChecked: excludedPaths.length,
-    });
     return isExcluded;
 };
 exports.isUrlPathExcluded = isUrlPathExcluded;

package/dist/cjs/utils/security/sanitize.utils.d.ts

@@ -1,5 +1,4 @@
-import { MetadataType } from '../../types/common.types';
-import { ApiConfig } from '../../types/config.types';
+import { MetadataType, ApiConfig } from '../../types';
 /**
  * Sanitizes a string value to prevent XSS attacks
  * @param value - The string to sanitize
@@ -24,9 +23,3 @@ export declare const sanitizeApiConfig: (data: unknown) => ApiConfig;
  * @returns The sanitized metadata
  */
 export declare const sanitizeMetadata: (metadata: unknown) => Record<string, MetadataType>;
-/**
- * Sanitizes URL strings for tracking
- * @param url - The URL to sanitize
- * @returns The sanitized URL
- */
-export declare const sanitizeUrl: (url: string) => string;

package/dist/cjs/utils/security/sanitize.utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitizeUrl = exports.sanitizeMetadata = exports.sanitizeApiConfig = exports.sanitizePathString = exports.sanitizeString = void 0;
+exports.sanitizeMetadata = exports.sanitizeApiConfig = exports.sanitizePathString = exports.sanitizeString = void 0;
 const constants_1 = require("../../constants");
 const logging_1 = require("../logging");
 /**
@@ -211,6 +211,12 @@ const sanitizeApiConfig = (data) => {
                         logging_1.debugLog.warn('Sanitize', 'Tags value is not an array', { value, type: typeof value });
                     }
                 }
+                else if (key === 'samplingRate') {
+                    const sanitizedValue = sanitizeValue(value);
+                    if (typeof sanitizedValue === 'number') {
+                        safeData.samplingRate = sanitizedValue;
+                    }
+                }
                 else {
                     const sanitizedValue = sanitizeValue(value);
                     if (sanitizedValue !== null) {
@@ -277,43 +283,3 @@ const sanitizeMetadata = (metadata) => {
     }
 };
 exports.sanitizeMetadata = sanitizeMetadata;
-/**
- * Sanitizes URL strings for tracking
- * @param url - The URL to sanitize
- * @returns The sanitized URL
- */
-const sanitizeUrl = (url) => {
-    logging_1.debugLog.debug('Sanitize', 'Starting URL sanitization', { urlLength: typeof url === 'string' ? url.length : 0 });
-    if (typeof url !== 'string') {
-        logging_1.debugLog.warn('Sanitize', 'URL is not a string', { url, type: typeof url });
-        return '';
-    }
-    try {
-        // Basic URL validation
-        const urlObject = new URL(url);
-        // Only allow http/https protocols
-        if (!['http:', 'https:'].includes(urlObject.protocol)) {
-            logging_1.debugLog.warn('Sanitize', 'URL protocol not allowed', {
-                protocol: urlObject.protocol,
-                allowedProtocols: ['http:', 'https:'],
-            });
-            return '';
-        }
-        // Sanitize the URL string
-        const result = (0, exports.sanitizeString)(urlObject.href);
-        logging_1.debugLog.debug('Sanitize', 'URL sanitization completed via URL object', {
-            originalLength: url.length,
-            sanitizedLength: result.length,
-            protocol: urlObject.protocol,
-        });
-        return result;
-    }
-    catch {
-        // If URL parsing fails, sanitize as string
-        logging_1.debugLog.warn('Sanitize', 'URL parsing failed, falling back to string sanitization', {
-            urlPreview: url.slice(0, 100),
-        });
-        return (0, exports.sanitizeString)(url);
-    }
-};
-exports.sanitizeUrl = sanitizeUrl;

package/dist/cjs/utils/validations/config-validations.utils.d.ts

@@ -24,6 +24,12 @@ export declare const validateAndNormalizeConfig: (config: AppConfig) => AppConfi
 export declare const validateConfig: (config: Config) => {
     errors: string[];
     warnings: string[];
+    samplingRate: number;
+};
+export declare const normalizeConfig: (config: Config) => {
+    config: Config;
+    errors: string[];
+    warnings: string[];
 };
 /**
  * Validates the final configuration
@@ -33,6 +39,7 @@ export declare const validateConfig: (config: Config) => {
 export declare const validateFinalConfig: (config: Config) => {
     errors: string[];
     warnings: string[];
+    samplingRate: number;
 };
 /**
  * Type guard to check if a JSON response is a valid API config

package/dist/cjs/utils/validations/config-validations.utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidConfigApiResponse = exports.validateFinalConfig = exports.validateConfig = exports.validateAndNormalizeConfig = exports.validateAppConfig = void 0;
+exports.isValidConfigApiResponse = exports.validateFinalConfig = exports.normalizeConfig = exports.validateConfig = exports.validateAndNormalizeConfig = exports.validateAppConfig = void 0;
 const constants_1 = require("../../constants");
 const types_1 = require("../../types");
 const validation_error_types_1 = require("../../types/validation-error.types");
@@ -87,6 +87,47 @@ const validateAppConfig = (config) => {
     }
 };
 exports.validateAppConfig = validateAppConfig;
+/**
+ * Validates CSS selector syntax without executing querySelector (XSS prevention)
+ * @param selector - CSS selector to validate
+ * @returns True if the selector syntax is valid
+ */
+const isValidCssSelectorSyntax = (selector) => {
+    // Prevent dangerous characters that could indicate XSS attempts
+    if (selector.includes('<') || selector.includes('>') || /on\w+\s*=/i.test(selector)) {
+        return false;
+    }
+    // Safe CSS selector pattern - allows common selector syntax
+    const safePattern = /^[a-zA-Z0-9\-_#.[\]="':, >+~*()]+$/;
+    if (!safePattern.test(selector)) {
+        return false;
+    }
+    // Check for balanced parentheses
+    let parenthesesCount = 0;
+    for (const char of selector) {
+        if (char === '(')
+            parenthesesCount++;
+        if (char === ')')
+            parenthesesCount--;
+        if (parenthesesCount < 0)
+            return false;
+    }
+    if (parenthesesCount !== 0)
+        return false;
+    // Check for balanced square brackets
+    let bracketsCount = 0;
+    for (const char of selector) {
+        if (char === '[')
+            bracketsCount++;
+        if (char === ']')
+            bracketsCount--;
+        if (bracketsCount < 0)
+            return false;
+    }
+    if (bracketsCount !== 0)
+        return false;
+    return true;
+};
 /**
  * Validates scroll container selectors
  * @param selectors - CSS selectors to validate
@@ -102,16 +143,14 @@ const validateScrollContainerSelectors = (selectors) => {
             });
             throw new validation_error_types_1.AppConfigValidationError(constants_1.VALIDATION_MESSAGES.INVALID_SCROLL_CONTAINER_SELECTORS, 'config');
         }
-        // Validate CSS selector syntax but handle invalid selectors gracefully
-        if (typeof document !== 'undefined') {
-            try {
-                document.querySelector(selector);
-            }
-            catch {
-                // Invalid CSS selectors are handled gracefully
-                // they will be ignored by the ScrollHandler and it will fall back to window scrolling
-                logging_1.debugLog.clientWarn('ConfigValidation', `Invalid CSS selector will be ignored: "${selector}"`);
-            }
+        // Validate CSS selector syntax using regex-based validation (XSS prevention)
+        // This validates syntax WITHOUT executing document.querySelector()
+        if (!isValidCssSelectorSyntax(selector)) {
+            logging_1.debugLog.clientError('ConfigValidation', 'Invalid or potentially unsafe CSS selector', {
+                selector,
+                reason: 'Failed security validation',
+            });
+            throw new validation_error_types_1.AppConfigValidationError('Invalid or potentially unsafe CSS selector', 'config');
         }
     }
 };
@@ -176,14 +215,18 @@ exports.validateAndNormalizeConfig = validateAndNormalizeConfig;
  * @param errors - Array to push errors to
  */
 const validateSamplingRate = (samplingRate, errors) => {
-    if (samplingRate !== undefined) {
-        if (typeof samplingRate !== 'number') {
-            errors.push('samplingRate must be a number');
-        }
-        else if (samplingRate < 0 || samplingRate > 1) {
-            errors.push('samplingRate must be between 0 and 1');
-        }
+    if (samplingRate === undefined) {
+        return undefined;
+    }
+    if (typeof samplingRate !== 'number') {
+        errors.push('samplingRate must be a number');
+        return constants_1.DEFAULT_SAMPLING_RATE;
+    }
+    if (Number.isNaN(samplingRate) || samplingRate <= 0 || samplingRate > 1) {
+        errors.push(constants_1.VALIDATION_MESSAGES.INVALID_SAMPLING_RATE);
+        return constants_1.DEFAULT_SAMPLING_RATE;
     }
+    return samplingRate;
 };
 /**
  * Validates excluded URL paths
@@ -247,14 +290,26 @@ const validateConfig = (config) => {
         }
     }
     // No custom API endpoints supported
-    validateSamplingRate(config.samplingRate, errors);
+    const validatedSamplingRate = validateSamplingRate(config.samplingRate, errors) ?? constants_1.DEFAULT_SAMPLING_RATE;
     if (config.tags !== undefined && !Array.isArray(config.tags)) {
         errors.push('tags must be an array');
     }
     validateExcludedUrlPaths(config.excludedUrlPaths, errors);
-    return { errors, warnings };
+    return { errors, warnings, samplingRate: validatedSamplingRate };
 };
 exports.validateConfig = validateConfig;
+const normalizeConfig = (config) => {
+    const { errors, warnings, samplingRate } = (0, exports.validateConfig)(config);
+    return {
+        config: {
+            ...config,
+            samplingRate,
+        },
+        errors,
+        warnings,
+    };
+};
+exports.normalizeConfig = normalizeConfig;
 /**
  * Validates the final configuration
  * @param config - The configuration to validate
@@ -263,10 +318,10 @@ exports.validateConfig = validateConfig;
 const validateFinalConfig = (config) => {
     const errors = [];
     const warnings = [];
-    validateSamplingRate(config.samplingRate, errors);
+    const validatedSamplingRate = validateSamplingRate(config.samplingRate, errors) ?? constants_1.DEFAULT_SAMPLING_RATE;
     validateExcludedUrlPaths(config.excludedUrlPaths, errors);
     // No custom API endpoints supported
-    return { errors, warnings };
+    return { errors, warnings, samplingRate: validatedSamplingRate };
 };
 exports.validateFinalConfig = validateFinalConfig;
 /**