@glideidentity/web-client-sdk 4.4.8-beta.1

package/dist/esm/core/logger.js

@@ -0,0 +1,359 @@
+/**
+ * Industry-grade logging for Glide Web SDK
+ * Following best practices from Stripe, Auth0, Twilio, and AWS Amplify
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["SILENT"] = 0] = "SILENT";
+    LogLevel[LogLevel["ERROR"] = 1] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["INFO"] = 3] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 4] = "DEBUG";
+})(LogLevel || (LogLevel = {}));
+/**
+ * Default browser console logger with automatic data sanitization
+ */
+export class ConsoleLogger {
+    constructor(level = LogLevel.SILENT, prefix = '[Glide]', enableGrouping = false) {
+        this.level = level;
+        this.prefix = prefix;
+        this.enableGrouping = enableGrouping;
+    }
+    debug(message, fields) {
+        if (this.level >= LogLevel.DEBUG) {
+            this.log('debug', message, fields);
+        }
+    }
+    info(message, fields) {
+        if (this.level >= LogLevel.INFO) {
+            this.log('info', message, fields);
+        }
+    }
+    warn(message, fields) {
+        if (this.level >= LogLevel.WARN) {
+            this.log('warn', message, fields);
+        }
+    }
+    error(message, fields) {
+        if (this.level >= LogLevel.ERROR) {
+            this.log('error', message, fields);
+        }
+    }
+    log(level, message, fields) {
+        const timestamp = new Date().toISOString();
+        const sanitizedFields = fields ? this.sanitizeFields(fields) : {};
+        // Format the message
+        const formattedMessage = `${this.prefix} ${timestamp} [${level.toUpperCase()}] ${message}`;
+        // Use console grouping for better readability if enabled
+        if (this.enableGrouping && Object.keys(sanitizedFields).length > 0) {
+            console.groupCollapsed(formattedMessage);
+            Object.entries(sanitizedFields).forEach(([key, value]) => {
+                console.log(`${key}:`, value);
+            });
+            console.groupEnd();
+        }
+        else {
+            // Standard logging with or without fields
+            if (Object.keys(sanitizedFields).length > 0) {
+                console[level](formattedMessage, sanitizedFields);
+            }
+            else {
+                console[level](formattedMessage);
+            }
+        }
+    }
+    /**
+     * Sanitize sensitive data from log fields
+     */
+    sanitizeFields(fields) {
+        const sanitized = {};
+        for (const [key, value] of Object.entries(fields)) {
+            sanitized[key] = this.sanitizeValue(key, value);
+        }
+        return sanitized;
+    }
+    /**
+     * Redact sensitive information based on field name and value patterns
+     */
+    sanitizeValue(key, value) {
+        // List of sensitive field patterns
+        const sensitiveFields = [
+            'apikey', 'api_key', 'apiKey',
+            'token', 'accesstoken', 'access_token', 'accessToken',
+            'password', 'passwd', 'pwd',
+            'secret', 'credential',
+            'authorization', 'auth',
+            'cookie', 'session',
+        ];
+        const lowerKey = key.toLowerCase();
+        // Check if field name indicates sensitive data
+        for (const sensitive of sensitiveFields) {
+            if (lowerKey.includes(sensitive.toLowerCase())) {
+                if (typeof value === 'string' && value.length > 4) {
+                    return value.substring(0, 4) + '****[REDACTED]';
+                }
+                return '****[REDACTED]';
+            }
+        }
+        // Handle specific value patterns
+        if (typeof value === 'string') {
+            // Phone number pattern - show area code only
+            const phoneRegex = /^\+?[1-9]\d{6,14}$/;
+            if (phoneRegex.test(value)) {
+                return value.substring(0, 6) + '****';
+            }
+            // Email pattern - show domain only
+            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+            if (emailRegex.test(value)) {
+                const [, domain] = value.split('@');
+                return '****@' + domain;
+            }
+            // URL with credentials
+            if (value.includes('://') && value.includes('@')) {
+                return value.replace(/\/\/([^:]+):([^@]+)@/, '//****:****@');
+            }
+            // JWT tokens
+            if (value.startsWith('eyJ') && value.split('.').length === 3) {
+                return value.substring(0, 10) + '****[JWT]';
+            }
+            // Credit card numbers
+            const creditCardRegex = /\b\d{13,19}\b/;
+            if (creditCardRegex.test(value)) {
+                return value.substring(0, 4) + '****' + value.substring(value.length - 4);
+            }
+        }
+        // Recursively sanitize objects
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            return this.sanitizeFields(value);
+        }
+        // Sanitize arrays
+        if (Array.isArray(value)) {
+            return value.map((item, index) => this.sanitizeValue(`${key}[${index}]`, item));
+        }
+        return value;
+    }
+}
+/**
+ * No-op logger for when logging is disabled
+ */
+export class NoopLogger {
+    debug(message, fields) { }
+    info(message, fields) { }
+    warn(message, fields) { }
+    error(message, fields) { }
+}
+/**
+ * Remote logger for sending logs to a backend service
+ * Useful for debugging production issues
+ */
+export class RemoteLogger {
+    constructor(endpoint, apiKey, fallbackLogger) {
+        this.buffer = [];
+        this.flushInterval = 5000; // 5 seconds
+        this.maxBufferSize = 100;
+        this.endpoint = endpoint;
+        this.apiKey = apiKey;
+        this.localLogger = fallbackLogger || new ConsoleLogger(LogLevel.ERROR);
+        // Set up automatic flushing
+        if (typeof window !== 'undefined') {
+            setInterval(() => this.flush(), this.flushInterval);
+            // Flush on page unload
+            window.addEventListener('beforeunload', () => this.flush());
+        }
+    }
+    debug(message, fields) {
+        this.log('debug', message, fields);
+    }
+    info(message, fields) {
+        this.log('info', message, fields);
+    }
+    warn(message, fields) {
+        this.log('warn', message, fields);
+    }
+    error(message, fields) {
+        this.log('error', message, fields);
+    }
+    log(level, message, fields) {
+        const logEntry = {
+            timestamp: new Date().toISOString(),
+            level,
+            message,
+            fields,
+            userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : undefined,
+            url: typeof window !== 'undefined' ? window.location.href : undefined,
+        };
+        this.buffer.push(logEntry);
+        // Also log locally for immediate feedback
+        this.localLogger[level](message, fields);
+        // Flush if buffer is full
+        if (this.buffer.length >= this.maxBufferSize) {
+            this.flush();
+        }
+    }
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.buffer.length === 0)
+                return;
+            const logs = [...this.buffer];
+            this.buffer = [];
+            try {
+                yield fetch(this.endpoint, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`,
+                    },
+                    body: JSON.stringify({ logs }),
+                });
+            }
+            catch (error) {
+                // Failed to send logs, log locally
+                this.localLogger.error('Failed to send logs to remote server', { error });
+                // Optionally, put logs back in buffer for retry
+                // this.buffer.unshift(...logs);
+            }
+        });
+    }
+}
+/**
+ * Parse log level from string
+ */
+export function parseLogLevel(level) {
+    switch (level.toLowerCase()) {
+        case 'debug':
+            return LogLevel.DEBUG;
+        case 'info':
+            return LogLevel.INFO;
+        case 'warn':
+        case 'warning':
+            return LogLevel.WARN;
+        case 'error':
+            return LogLevel.ERROR;
+        case 'silent':
+        case 'none':
+        case 'off':
+            return LogLevel.SILENT;
+        default:
+            return LogLevel.SILENT;
+    }
+}
+/**
+ * Get log level from browser environment
+ */
+export function getLogLevelFromEnv() {
+    // Check localStorage
+    if (typeof localStorage !== 'undefined') {
+        const storedLevel = localStorage.getItem('GLIDE_LOG_LEVEL');
+        if (storedLevel) {
+            return parseLogLevel(storedLevel);
+        }
+        const debugFlag = localStorage.getItem('GLIDE_DEBUG');
+        if (debugFlag === 'true' || debugFlag === '1') {
+            return LogLevel.DEBUG;
+        }
+    }
+    // Check URL parameters
+    if (typeof window !== 'undefined' && window.location) {
+        const params = new URLSearchParams(window.location.search);
+        const urlLogLevel = params.get('glide_log_level');
+        if (urlLogLevel) {
+            return parseLogLevel(urlLogLevel);
+        }
+        if (params.has('glide_debug')) {
+            return LogLevel.DEBUG;
+        }
+    }
+    return LogLevel.SILENT;
+}
+/**
+ * Performance timer for measuring operation duration
+ */
+export class PerformanceTimer {
+    constructor(logger) {
+        this.marks = new Map();
+        this.startTime = performance.now();
+        this.logger = logger;
+    }
+    /**
+     * Mark a point in time
+     */
+    mark(name) {
+        this.marks.set(name, performance.now());
+    }
+    /**
+     * Log elapsed time with optional fields
+     */
+    logElapsed(message, fields) {
+        const elapsed = performance.now() - this.startTime;
+        this.logger.debug(message, Object.assign(Object.assign({}, fields), { elapsedMs: elapsed, elapsed: `${elapsed.toFixed(2)}ms` }));
+    }
+    /**
+     * Log time between marks
+     */
+    logMarkDuration(fromMark, toMark, message, fields) {
+        const from = this.marks.get(fromMark);
+        const to = this.marks.get(toMark);
+        if (from && to) {
+            const duration = to - from;
+            this.logger.debug(message, Object.assign(Object.assign({}, fields), { durationMs: duration, duration: `${duration.toFixed(2)}ms`, fromMark,
+                toMark }));
+        }
+    }
+}
+/**
+ * Generate a unique request ID for distributed tracing
+ */
+export function generateRequestId() {
+    return `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+/**
+ * Logger factory for creating loggers with consistent configuration
+ */
+export class LoggerFactory {
+    /**
+     * Set the default log level for all new loggers
+     */
+    static setDefaultLevel(level) {
+        this.defaultLevel = level;
+    }
+    /**
+     * Set a default logger instance to use
+     */
+    static setDefaultLogger(logger) {
+        this.defaultLogger = logger;
+    }
+    /**
+     * Create a logger instance based on configuration
+     */
+    static create(options) {
+        var _a, _b;
+        // Use custom logger if provided
+        if (options === null || options === void 0 ? void 0 : options.custom) {
+            return options.custom;
+        }
+        // Use default logger if set
+        if (this.defaultLogger) {
+            return this.defaultLogger;
+        }
+        // Determine log level
+        const level = (_b = (_a = options === null || options === void 0 ? void 0 : options.level) !== null && _a !== void 0 ? _a : getLogLevelFromEnv()) !== null && _b !== void 0 ? _b : this.defaultLevel;
+        // Create remote logger if configured
+        if (options === null || options === void 0 ? void 0 : options.remote) {
+            const fallbackLogger = new ConsoleLogger(level, options === null || options === void 0 ? void 0 : options.prefix);
+            return new RemoteLogger(options.remote.endpoint, options.remote.apiKey, fallbackLogger);
+        }
+        // Create console logger
+        return new ConsoleLogger(level, options === null || options === void 0 ? void 0 : options.prefix);
+    }
+}
+LoggerFactory.defaultLevel = LogLevel.SILENT;
+LoggerFactory.defaultLogger = null;