nodejs-event-manager/build/lib/logger.js

A nodeJS Event Manager to emit, and listen event through nodeJS

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const logform = require("logform");
const stream_1 = require("stream");
const tripleBeam = require("triple-beam");
const winston = require("winston");
const EventManagerError_1 = require("./EventManagerError");
const { format } = winston;
const { combine, printf, metadata, timestamp, label, colorize, prettyPrint } = format;
/**
 * Add error to info regarding the parameters
 */
const errorHunter = logform.format(info => {
    if (info.error) {
        return info;
    }
    const splat = info[tripleBeam.SPLAT] || [];
    info.error = splat.find((obj) => obj instanceof Error);
    if (!info.error && splat.length === 1) {
        const obj = splat[0];
        const keyIsError = Object.keys(obj).find(k => {
            return obj[k] instanceof Error;
        });
        if (keyIsError) {
            info.error = obj[keyIsError];
        }
    }
    return info;
});
const errorPrinter = logform.format(info => {
    if (!info.error) {
        return info;
    }
    // Handle case where Error has no stack.
    const errorMsg = info.error.stack || info.error.toString();
    info.message += `\n${errorMsg.padStart()}`;
    return info;
});
const myFormat = printf(info => {
    let meta = "";
    if (info.metadata && Object.keys(info.metadata).length > 0) {
        // remove error instances
        const filtered = Object.entries(info.metadata).filter(([k, m]) => !(m instanceof Error));
        if (filtered.length > 0) {
            meta = filtered.reduce((str, [k, v], index) => {
                if (!(info.error && k === "stack")) {
                    str += `${k}:${JSON.stringify(v)}, `;
                }
                return str;
            }, "\n");
        }
    }
    const out = `${info.timestamp} [${info.label}] ${info.level}: ${info.message}`;
    return `${out}${meta}`;
});
function createFormat(prefix) {
    return combine(errorHunter(), timestamp(), label({ label: prefix }), colorize(), metadata({
        fillExcept: ["message", "label", "timestamp", "level", "error"]
    }), errorPrinter(), myFormat);
}
let currentLogger = null;
function createLogger({ prefix = "[RABBITMQ]", level = "error", transportMode = "console" }) {
    if (currentLogger === null) {
        const transports = []; // winston interface are not that useful
        if (transportMode === "mute") {
            transports.push(new winston.transports.Stream({
                stream: new stream_1.Writable({
                    write: () => {
                        /* do nothing */
                    }
                })
            }));
        }
        else {
            // transports === 'console'
            transports.push(new winston.transports.Console({
                level,
                format: createFormat(prefix)
            }));
        }
        currentLogger = winston.createLogger({
            level,
            format: winston.format.json(),
            transports
        });
    }
}
exports.createLogger = createLogger;
exports.LOGGER = new Proxy({}, {
    get: (_, prop) => {
        if (currentLogger === null) {
            throw new EventManagerError_1.EventManagerError("Logger has not been inititialized");
        }
        else {
            return currentLogger[prop.toString()];
        }
    }
});
function setLogger(logger) {
    currentLogger = logger;
}
exports.setLogger = setLogger;
//# sourceMappingURL=logger.js.map