@nrchkb/logger/build/index.js

Unified Logger for Node-RED nodes (using debug)

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.logger = exports.loggerSetup = void 0;
const helpers_1 = require("./helpers");
const types_1 = require("./types/types");
const Debug = require('debug');
let LOGGER_DEBUG_COLOR = process.env.LOGGER_DEBUG_COLOR || '4';
let LOGGER_ERROR_COLOR = process.env.LOGGER_ERROR_COLOR || '9';
let LOGGER_TRACE_COLOR = process.env.LOGGER_TRACE_COLOR || '15';
let LOGGER_DEBUG_ENABLED = (process.env.LOGGER_DEBUG_ENABLED &&
    process.env.LOGGER_DEBUG_ENABLED === 'true') ||
    false;
let LOGGER_ERROR_ENABLED = (process.env.LOGGER_ERROR_ENABLED &&
    process.env.LOGGER_ERROR_ENABLED === 'true') ||
    true;
let LOGGER_TRACE_ENABLED = (process.env.LOGGER_TRACE_ENABLED &&
    process.env.LOGGER_TRACE_ENABLED === 'true') ||
    false;
let LOGGER_TIMESTAMP_ENABLED = process.env.LOGGER_TIMESTAMP_ENABLED || false;
const loggerSetup = ({ debugColor, debugEnabled, errorColor, errorEnabled, traceColor, traceEnabled, timestampEnabled, }) => {
    if (debugColor !== undefined) {
        LOGGER_DEBUG_COLOR = debugColor;
    }
    if (debugEnabled !== undefined) {
        LOGGER_DEBUG_ENABLED = debugEnabled;
    }
    if (errorColor !== undefined) {
        LOGGER_ERROR_COLOR = errorColor;
    }
    if (errorEnabled !== undefined) {
        LOGGER_ERROR_ENABLED = errorEnabled;
    }
    if (traceColor !== undefined) {
        LOGGER_TRACE_COLOR = traceColor;
    }
    if (traceEnabled !== undefined) {
        LOGGER_TRACE_ENABLED = traceEnabled;
    }
    if (timestampEnabled !== undefined) {
        if (typeof timestampEnabled === 'boolean') {
            LOGGER_TIMESTAMP_ENABLED = timestampEnabled;
        }
        else {
            timestampEnabled.split(',').forEach((n) => {
                (0, helpers_1.setTimestamp)(Debug, true, n);
            });
        }
    }
};
exports.loggerSetup = loggerSetup;
const logMessage = (callback, prefix, node) => {
    return (message) => {
        const messagePrefix = node ? `${node.name}:${node.id}` : prefix;
        if (messagePrefix) {
            return callback(`[${messagePrefix}] ${message}`);
        }
        else {
            return callback(`${message}`);
        }
    };
};
const logger = (namespacePrefix, namespace, messagePrefix, node) => {
    (0, helpers_1.setTimestamp)(Debug, LOGGER_TIMESTAMP_ENABLED, namespacePrefix);
    const debug = Debug(namespace ? `${namespacePrefix}:${namespace}` : namespacePrefix);
    debug.color = LOGGER_DEBUG_COLOR;
    if (LOGGER_DEBUG_ENABLED) {
        debug.enabled = LOGGER_DEBUG_ENABLED;
    }
    const logDebug = logMessage(debug, messagePrefix, node);
    const error = Debug(namespace
        ? `${namespacePrefix}-Error:${namespace}`
        : `${namespacePrefix}-Error`);
    error.color = LOGGER_ERROR_COLOR;
    error.enabled = LOGGER_ERROR_ENABLED;
    const logError = (message, nodeError = true, injectedNode) => {
        const nodeToUse = injectedNode || node;
        if (nodeToUse && nodeError) {
            nodeToUse.error(message);
        }
        logMessage(error, messagePrefix, nodeToUse)(message);
    };
    const trace = Debug(namespace
        ? `${namespacePrefix}-Trace:${namespace}`
        : `${namespacePrefix}-Trace`);
    trace.color = LOGGER_TRACE_COLOR;
    if (LOGGER_TRACE_ENABLED) {
        trace.enabled = LOGGER_TRACE_ENABLED;
    }
    const logTrace = logMessage(trace, messagePrefix, node);
    const logLevel = (level) => {
        switch (level) {
            case types_1.LogLevel.DISABLED:
                return () => { };
            case types_1.LogLevel.DEBUG:
                return logDebug;
            case types_1.LogLevel.ERROR:
                return logError;
            case types_1.LogLevel.TRACE:
                return logTrace;
        }
    };
    return {
        debug: logDebug,
        error: logError,
        trace: logTrace,
        level: logLevel,
    };
};
exports.logger = logger;
module.exports = { logger: exports.logger, loggerSetup: exports.loggerSetup };