lib-comfoair/dist/util/logging/logPrinter.js

Library to communicate with Zehnder ComfoAirQ ventilation unit through the ComfoControl gateway

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.FilePrinter = exports.DebugPrinter = exports.ConsolePrinter = exports.BasePrinter = void 0;
const fs = require("fs");
/**
 * Abstract base class for log printers.
 * Provides common functionality for formatting log messages.
 */
class BasePrinter {
    /**
     * Print a log message.
     * @param level - The severity level of the log message.
     * @param name - The name of the logger.
     * @param message - The log message.
     * @param args - Additional arguments to log.
     */
    printLine(level, name, message, ...args) {
        const formattedMessage = this.formatMessage(message, ...args);
        this.output(level, name, formattedMessage);
    }
    /**
     * Format a log message.
     * @param level - The severity level of the log message.
     * @param name - The name of the logger.
     * @param message - The log message.
     * @param args - Additional arguments to log.
     * @returns The formatted log message.
     */
    formatMessage(message, ...args) {
        const evaluatedArgs = args.map((arg) => {
            if (typeof arg === 'function') {
                arg = arg();
            }
            if (typeof arg === 'object' && arg !== null) {
                try {
                    return JSON.stringify(arg);
                }
                catch {
                    // Ignore parse errors, print original object
                }
            }
            return String(arg);
        });
        return `${message} ${evaluatedArgs.join(' ')}`;
    }
}
exports.BasePrinter = BasePrinter;
/**
 * Console printer for logging messages to the console.
 */
class ConsolePrinter extends BasePrinter {
    /**
     * Output a formatted log message to the console.
     * @param level - The severity level of the log message.
     * @param name - The name of the logger.
     * @param message - The formatted log message.
     */
    output(level, name, message) {
        const timestamp = `[${new Date().toISOString()}] `;
        console.log(`${timestamp}[${level}] [${name}] ${message}`);
    }
}
exports.ConsolePrinter = ConsolePrinter;
/**
 * Prints all logging messages using the console.debug function.
 */
class DebugPrinter extends BasePrinter {
    /**
     * Output a formatted log message to the console.
     * @param level - The severity level of the log message.
     * @param name - The name of the logger.
     * @param message - The formatted log message.
     */
    output(level, name, message) {
        const timestamp = `[${new Date().toISOString()}] `;
        console.debug(`${timestamp}[${level}] [${name}] ${message}`);
    }
}
exports.DebugPrinter = DebugPrinter;
/**
 * File printer for logging messages to a file.
 */
class FilePrinter extends BasePrinter {
    logFilePath;
    writeQueue = Promise.resolve();
    fileHandle;
    closeTimeout;
    constructor(logFilePath) {
        super();
        this.logFilePath = logFilePath;
    }
    /**
     * Ensure the log file directory exists.
     */
    async ensureLogFileDirectory() {
        await fs.promises.mkdir(this.logFilePath.substring(0, this.logFilePath.lastIndexOf('/')), { recursive: true });
    }
    /**
     * Initialize the file handle for the log file.
     */
    async getFileHandle() {
        if (!this.fileHandle) {
            try {
                await this.ensureLogFileDirectory();
                const fileExists = await fs.promises
                    .access(this.logFilePath)
                    .then(() => true)
                    .catch(() => false);
                this.fileHandle = await fs.promises.open(this.logFilePath, 'a');
                if (!fileExists) {
                    const header = this.createLogEntry('INFO', 'FilePrinter', '--- Logging session started ---');
                    await this.fileHandle.appendFile(header);
                }
                this.scheduleClose();
            }
            catch (err) {
                console.error('Failed to open log file:', err);
            }
        }
        return this.fileHandle;
    }
    /**
     * Create a log entry string.
     * @param level - The severity level of the log message.
     * @param name - The name of the logger.
     * @param message - The log message.
     * @returns The formatted log entry string.
     */
    createLogEntry(level, name, message) {
        const logEntry = {
            timestamp: Math.floor(Date.now() / 1000),
            level: level,
            name: name,
            message: message,
        };
        return JSON.stringify(logEntry) + '\n';
    }
    /**
     * Close the file handle after a delay.
     */
    scheduleClose() {
        if (this.closeTimeout) {
            clearTimeout(this.closeTimeout);
        }
        this.closeTimeout = setTimeout(async () => {
            if (this.fileHandle) {
                try {
                    await this.fileHandle.close();
                    this.fileHandle = undefined;
                }
                catch (err) {
                    console.error('Failed to close log file:', err);
                }
            }
        }, 5000);
    }
    /**
     * Output a formatted log message to a file asynchronously.
     * @param level - The severity level of the log message.
     * @param name - The name of the logger.
     * @param message - The formatted log message.
     */
    output(level, name, message) {
        const logMessage = this.createLogEntry(level, name, message);
        this.writeQueue = this.writeQueue.then(async () => {
            const handle = await this.getFileHandle();
            if (handle) {
                try {
                    await handle.appendFile(logMessage);
                    this.scheduleClose();
                }
                catch (err) {
                    console.error('Failed to write log message:', err);
                }
            }
        });
    }
}
exports.FilePrinter = FilePrinter;