@contiva/sap-integration-suite-client/dist/utils/cache-logger.js

SAP Cloud Platform Integration API Client

"use strict";
/**
 * Structured logging utility for cache operations
 *
 * Provides structured logging with log levels (INFO, DEBUG, WARN, ERROR)
 * and support for metrics (counts, durations, etc.)
 *
 * @module cache-logger
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.cacheLogger = exports.LogLevel = void 0;
/**
 * Log levels
 */
var LogLevel;
(function (LogLevel) {
    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
    LogLevel[LogLevel["INFO"] = 1] = "INFO";
    LogLevel[LogLevel["WARN"] = 2] = "WARN";
    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
})(LogLevel || (exports.LogLevel = LogLevel = {}));
/**
 * Structured logger for cache operations
 */
class CacheLogger {
    constructor() {
        this.debugMode = process.env.DEBUG === 'true';
        this.config = {
            minLevel: this.debugMode ? LogLevel.DEBUG : LogLevel.INFO,
            enableStructured: true,
            enableConsole: true,
        };
    }
    /**
     * Logs a message with the specified level
     */
    log(level, message, context, metrics, error) {
        if (level < this.config.minLevel) {
            return;
        }
        const entry = {
            level,
            message,
            context,
            metrics,
            error,
            timestamp: Date.now(),
        };
        // Console output (backward compatible)
        if (this.config.enableConsole) {
            this.logToConsole(entry);
        }
        // Structured output (JSON format)
        if (this.config.enableStructured && this.shouldLogStructured(level)) {
            this.logStructured(entry);
        }
    }
    /**
     * Logs to console in a human-readable format (backward compatible)
     */
    logToConsole(entry) {
        const prefix = entry.context ? `[${entry.context}]` : '[CacheLogger]';
        const metricsStr = entry.metrics ? ` ${JSON.stringify(entry.metrics)}` : '';
        const errorStr = entry.error ? ` Error: ${entry.error.message}` : '';
        switch (entry.level) {
            case LogLevel.DEBUG:
                console.debug(`${prefix} ${entry.message}${metricsStr}${errorStr}`);
                break;
            case LogLevel.INFO:
                console.log(`${prefix} ${entry.message}${metricsStr}${errorStr}`);
                break;
            case LogLevel.WARN:
                console.warn(`${prefix} ${entry.message}${metricsStr}${errorStr}`);
                break;
            case LogLevel.ERROR:
                console.error(`${prefix} ${entry.message}${metricsStr}${errorStr}`, entry.error || '');
                break;
        }
    }
    /**
     * Logs structured output (JSON format)
     */
    logStructured(entry) {
        const levelName = LogLevel[entry.level];
        const structured = {
            level: levelName,
            message: entry.message,
            context: entry.context,
            ...entry.metrics,
            timestamp: new Date(entry.timestamp).toISOString(),
            ...(entry.error && {
                error: {
                    message: entry.error.message,
                    stack: entry.error.stack,
                },
            }),
        };
        // Output as JSON (can be parsed by log aggregation tools)
        console.log(JSON.stringify(structured));
    }
    /**
     * Determines if structured logging should be used for this level
     */
    shouldLogStructured(level) {
        // Only log structured for INFO and above (DEBUG is too verbose)
        return level >= LogLevel.INFO;
    }
    /**
     * Logs a DEBUG message
     */
    debug(message, context, metrics) {
        this.log(LogLevel.DEBUG, message, context, metrics);
    }
    /**
     * Logs an INFO message with optional metrics
     */
    info(message, context, metrics) {
        this.log(LogLevel.INFO, message, context, metrics);
    }
    /**
     * Logs a WARN message
     */
    warn(message, context, metrics) {
        this.log(LogLevel.WARN, message, context, metrics);
    }
    /**
     * Logs an ERROR message
     */
    error(message, context, metrics, error) {
        this.log(LogLevel.ERROR, message, context, metrics, error);
    }
}
// Export singleton instance
exports.cacheLogger = new CacheLogger();