@atomist/automation-client/lib/util/logger.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const appRoot = require("app-root-path");
const cluster = require("cluster");
const fs = require("fs-extra");
const _ = require("lodash");
const os = require("os");
const p = require("path");
const serializeError = require("serialize-error");
const trace = require("stack-trace");
const winston = require("winston");
const context = require("../internal/util/cls");
const redact_1 = require("./redact");
const winstonLogger = winston.createLogger({
    level: "debug",
    exitOnError: false,
    silent: true,
});
/**
 * Global logger instance
 * By default all logging to this logger will be suppressed.
 * Call configureLogging to set up console and file transports.
 */
exports.logger = winstonLogger;
/* tslint:disable:no-console */
// Save console log methods
const GlobalConsoleMethods = {
    error: console.error,
    warn: console.warn,
    info: console.info,
    debug: console.debug,
    log: console.log,
    trace: console.trace,
};
/* tslint:enable:no-console */
/**
 * Constants for the logging format
 */
var LoggingFormat;
(function (LoggingFormat) {
    /**
     * Print only the message provided to the logger methods
     */
    LoggingFormat[LoggingFormat["None"] = 0] = "None";
    /**
     * Print level and message
     */
    LoggingFormat[LoggingFormat["Simple"] = 1] = "Simple";
    /**
     * Print the full client related metadata
     */
    LoggingFormat[LoggingFormat["Full"] = 2] = "Full";
})(LoggingFormat = exports.LoggingFormat || (exports.LoggingFormat = {}));
/**
 * Logging configuration suppress all logger logging
 */
exports.NoLogging = {
    console: {
        enabled: false,
    },
    file: {
        enabled: false,
    },
    redact: true,
    color: true,
};
/**
 * Logging configuration to simply pass through log message to the console
 */
exports.PlainLogging = {
    console: {
        enabled: true,
        level: "info",
        format: LoggingFormat.None,
        redirect: false,
    },
    file: {
        enabled: false,
    },
    redact: true,
    color: true,
};
/**
 * CLI-style logging configuration
 */
exports.MinimalLogging = {
    console: {
        enabled: true,
        level: "info",
        format: LoggingFormat.Simple,
        redirect: false,
    },
    file: {
        enabled: false,
    },
    redact: true,
    color: true,
};
/**
 * Default logging configuration for running automation clients
 */
exports.ClientLogging = {
    console: {
        enabled: true,
        level: process.env.ATOMIST_CONFIG_LOGGING_LEVEL ? process.env.ATOMIST_CONFIG_LOGGING_LEVEL : "info",
        format: LoggingFormat.Full,
        redirect: true,
    },
    file: {
        enabled: false,
    },
    redact: true,
    color: true,
};
/**
 * Configure the logging sub-system with the provided LoggingConfiguration
 * It is safe to call this method several times to re-configure the logger.
 * @param config
 */
function configureLogging(config) {
    try {
        winstonLogger.silent = true;
        winstonLogger.clear();
        // Set up console logging
        if (config.console.enabled === true) {
            const ct = new winston.transports.Console({
                level: validateLevel(config.console.level || "info"),
                format: getFormat(config.console.format, config.redact, config.callsites, config.color),
            });
            if (config.console.redirect === true) {
                redirectConsoleLogging();
            }
            else {
                unRedirectConsoleLogging();
            }
            winstonLogger.add(ct);
            winstonLogger.silent = false;
        }
        // Set up file logging
        if (config.file.enabled) {
            let filename = config.file.filename;
            if (!filename) {
                const appDir = __dirname.split(p.join("node_modules", "@atomist", "automation-client"))[0];
                let pj;
                try {
                    pj = require(p.join(appDir, "package.json"));
                }
                catch (e) {
                    pj = { name: "atm-client" };
                }
                filename = p.join(os.homedir(), ".atomist", "log", `${pj.name.replace(/@/g, "").replace(/\//g, "_")}_local.log`);
            }
            const path = p.resolve(filename);
            fs.mkdirsSync(p.dirname(path));
            const ft = new winston.transports.File({
                filename: p.basename(path),
                dirname: p.dirname(path),
                level: validateLevel(config.file.level || config.console.level),
                maxsize: 10 * 1024 * 1024,
                maxFiles: 10,
                tailable: true,
                // zippedArchive: true, // see https://github.com/winstonjs/winston/issues/1128
                format: winston.format.combine(getFormat(config.file.format, config.redact, config.callsites, config.color), winston.format.uncolorize()),
            });
            winstonLogger.add(ft);
            winstonLogger.silent = false;
        }
        // Set up custom transports
        if (config.custom && config.custom.length > 0) {
            config.custom.forEach(t => winstonLogger.add(t));
            winstonLogger.silent = false;
        }
    }
    catch (e) {
        // If we catch an error during logging initialization, we have to play it
        // safe and write straight to stderr as logging might be silentest.
        process.stderr.write(`Error occurred during logging initialization: ${e.stack}`);
        throw e;
    }
}
exports.configureLogging = configureLogging;
/**
 * Configure the logging sub-system based on the provided Configuration object
 * @param configuration
 */
function clientLoggingConfiguration(configuration) {
    const lc = Object.assign({}, exports.ClientLogging);
    if (configuration.logging) {
        if (configuration.logging.level) {
            lc.console = {
                enabled: true,
                level: configuration.logging.level,
                format: LoggingFormat.Full,
            };
        }
        if (_.get(configuration, "logging.file.enabled") === true) {
            let filename = p.join(".", "log", `${configuration.name.replace(/@/g, "").replace(/\//g, "_")}.log`);
            if (configuration.logging.file.name) {
                filename = configuration.logging.file.name;
            }
            lc.file = {
                enabled: true,
                level: configuration.logging.file.level || configuration.logging.level,
                filename,
                format: LoggingFormat.Full,
            };
        }
        lc.custom = _.get(configuration, "logging.custom.transports");
        lc.callsites = _.get(configuration, "logging.callsite");
        lc.color = _.get(configuration, "logging.color");
    }
    lc.redact = configuration.redact.log;
    return lc;
}
exports.clientLoggingConfiguration = clientLoggingConfiguration;
function validateLevel(level) {
    const levels = ["silly", "debug", "verbose", "info", "warn", "error"];
    if (!levels.includes(level)) {
        throw new Error(`Log level '${level}' is invalid. Only levels '${levels.join(", ")}' are allowed`);
    }
    return level;
}
function callsite(logInfo) {
    const oldLimit = Error.stackTraceLimit;
    try {
        Error.stackTraceLimit = Infinity;
        throw new Error();
    }
    catch (e) {
        const root = appRoot.path;
        const callsites = trace.parse(e).map(l => ({
            fileName: l.getFileName(),
            lineNumber: l.getLineNumber(),
        })).filter(cs => !!cs.fileName).reverse();
        const callsite = callsites[callsites.findIndex(cs => cs.fileName.includes("node_modules/winston")) - 1];
        if (!!callsite) {
            return Object.assign(Object.assign({}, logInfo), { callsite: Object.assign(Object.assign({}, callsite), { fileName: callsite.fileName.split(root)[1].slice(1) }) });
        }
    }
    finally {
        Error.stackTraceLimit = oldLimit;
    }
    return logInfo;
}
exports.callsite = callsite;
/* tslint:disable:cyclomatic-complexity */
const clientFormat = info => {
    const c = winston.format.colorize();
    const executionContext = context.get();
    let ctx;
    if (cluster.isMaster) {
        ctx = c.colorize(info.level, "m");
    }
    else {
        ctx = c.colorize(info.level, "w");
    }
    ctx += ":" + c.colorize(info.level, process.pid.toString());
    if (executionContext) {
        if (executionContext.invocationId) {
            ctx += ":" + c.colorize(info.level, executionContext.invocationId);
        }
        if (executionContext.workspaceName) {
            ctx += ":" + c.colorize(info.level, executionContext.workspaceName);
        }
        else if (executionContext.workspaceId) {
            ctx += ":" + c.colorize(info.level, executionContext.workspaceId);
        }
        if (executionContext.operation) {
            ctx += ":" + c.colorize(info.level, executionContext.operation);
        }
        if (executionContext.ts) {
            const duration = _.padStart((Date.now() - executionContext.ts).toString(), 3, "0");
            ctx += ":" + c.colorize(info.level, duration);
        }
    }
    let callsite;
    if (!!info.callsite) {
        callsite = ` [${c.colorize(info.level, info.callsite.fileName)}:${c.colorize(info.level, info.callsite.lineNumber || -1)}]`;
    }
    const level = c.colorize(info.level, _.padEnd(info.level, 5));
    let formatted = info.timestamp + (!!callsite ? callsite : "") + (!!ctx ? " [" + ctx + "]" : "")
        + " [" + level + "] " + (info.message ? info.message : "");
    if (info.meta) {
        const meta = info.meta;
        if (meta instanceof Error) {
            const err = meta;
            if (err.stack && err.stack.includes(err.message)) {
                formatted = `${formatted}${formatted.endsWith(":") ? " " : ": "}
${err.stack}`;
            }
            else if (err.stack) {
                formatted = `${formatted}${formatted.endsWith(":") ? " " : ": "}${err.message}
${err.stack}`;
            }
            else {
                formatted = `${formatted}${formatted.endsWith(":") ? " " : ": "}${err.message}`;
            }
        }
        else if (meta.stack) {
            if (meta.stack && meta.stack.includes(meta.message)) {
                formatted = `${formatted}${formatted.endsWith(":") ? " " : ": "}
${meta.stack}`;
            }
            else {
                formatted = `${formatted}${formatted.endsWith(":") ? " " : ": "}${meta.message ? meta.message : ""}
${meta.stack}`;
            }
        }
        else if (!(Array.isArray(meta) && meta.length === 0)) {
            formatted = `${formatted}${formatted.endsWith(":") ? " " : ": "}${JSON.stringify(serializeError(info.meta))}`;
        }
    }
    return formatted;
};
/* tslint:enable:cyclomatic-complexity */
/* tslint:disable:no-console */
function unRedirectConsoleLogging() {
    console.error = GlobalConsoleMethods.error;
    console.info = GlobalConsoleMethods.info;
    console.log = GlobalConsoleMethods.log;
    console.trace = GlobalConsoleMethods.trace;
    console.warn = GlobalConsoleMethods.warn;
}
function redirectConsoleLogging() {
    console.error = (message, ...optionalParams) => {
        winstonLogger.error(message, ...optionalParams);
    };
    console.info = (message, ...optionalParams) => {
        winstonLogger.info(message, ...optionalParams);
    };
    console.log = (message, ...optionalParams) => {
        winstonLogger.info(message, ...optionalParams);
    };
    console.trace = (message, ...optionalParams) => {
        winstonLogger.debug(message, ...optionalParams);
    };
    console.warn = (message, ...optionalParams) => {
        winstonLogger.warn(message, ...optionalParams);
    };
}
/* tslint:enable:no-console */
function getFormat(format, redact, callsites, color) {
    switch (format) {
        case LoggingFormat.Full:
            return winston.format.combine(...(redact ? [winston.format(redact_1.redactLog)()] : []), winston.format.timestamp(), ...(callsites ? [winston.format(callsite)()] : []), winston.format.splat(), winston.format.printf(clientFormat), ...(color ? [] : [winston.format.uncolorize()]));
        case LoggingFormat.Simple:
            return winston.format.combine(...(redact ? [winston.format(redact_1.redactLog)()] : []), winston.format.colorize(), winston.format.splat(), ...(callsites ? [winston.format(callsite)()] : []), winston.format.simple(), ...(color ? [] : [winston.format.uncolorize()]));
        case LoggingFormat.None:
        default:
            return winston.format.combine(...(redact ? [winston.format(redact_1.redactLog)()] : []), winston.format.splat(), ...(callsites ? [winston.format(callsite)()] : []), winston.format.printf(info => info.message), ...(color ? [] : [winston.format.uncolorize()]));
    }
}
process.on("uncaughtException", err => {
    exports.logger.error(serializeError(err));
});
//# sourceMappingURL=logger.js.map