@testim/testim-cli/commons/logger.js

'use strict';

const bunyan = require('bunyan');

const runnerVersion = getRunnerVersion();
const config = require('./config');

const isLocal = 'false';


const loggerConfig = {
    privateKey: 'd0eb01da-f966-1663-63c6-8871225d7c39',
    applicationName: 'testim',
    subsystemName: 'runner',
};

function getRunnerVersion() {
    try {
        const pack = require(`${__dirname}/../package.json`);
        return pack.version;
    } catch (err) {
        return '';
    }
}

function getStreamsAndWaitForFlushPromise() {
    const level = config.LOGGER_DEBUG ? 'debug' : 'info';
    const streams = [];

    let waitForFlush = () => Promise.resolve();

    if (!config.IS_ON_PREM) {
        const CoralogixBunyan = require('../lib/coralogix-bunyan.stream');

        waitForFlush = CoralogixBunyan.CoralogixStream.waitForFlush;

        CoralogixBunyan.CoralogixStream.configure(loggerConfig);
        streams.push({
            level,
            stream: new CoralogixBunyan.CoralogixStream({ category: 'ROOT' }),
            type: 'raw',
        });
    }

    if (config.LOGGER_CONSOLE) {
        const PrettyStream = require('bunyan-prettystream');
        const prettyStdOut = new PrettyStream();
        prettyStdOut.pipe(process.stdout);
        streams.push({
            level,
            stream: prettyStdOut,
            type: 'raw',
        });
    }
    return [streams, waitForFlush];
}

const [streams, waitForFlush] = getStreamsAndWaitForFlushPromise();

const bunyanMainLogger = bunyan.createLogger({
    name: 'runner',
    streams,
});

let executionId = null;
let projectId = null;

function setExecutionId(execId) {
    executionId = execId;
}

function setProjectId(projId) {
    projectId = projId;
}

function releaseFlags() {
    return {
        release: true,
        branch: 'production',
    };
}

function devFlags() {
    return {
        release: false,
        branch: 'test',
    };
}

function localFlags() {
    return {
        release: false,
        branch: 'local',
    };
}

function addExecutionId(logData = {}) {
    if (executionId && !logData.executionId) {
        logData.executionId = executionId;
    }

    logData.runnerVersion = runnerVersion;
    logData.projectId = projectId;
    logData.nodeVersion = process.version;

    if (isLocal.indexOf('@echo') === -1) {
        Object.assign(logData, devFlags());


        return logData;
    }

    Object.assign(logData, localFlags());
    return logData;
}

class Logger {
    constructor(logger) {
        this._logger = logger;
    }

    trace(msg, data = {}) {
        this._logger.trace(addExecutionId(data), msg);
    }

    debug(msg, data = {}) {
        this._logger.debug(addExecutionId(data), msg);
    }

    info(msg, data = {}) {
        this._logger.info(addExecutionId(data), msg);
    }

    warn(msg, data = {}) {
        this._logger.warn(addExecutionId(data), msg);
    }

    error(msg, data = {}) {
        this._logger.error(addExecutionId(data), msg);
    }

    fatal(msg, data = {}) {
        this._logger.fatal(addExecutionId(data), msg);
    }

    waitForFlush() {
        return waitForFlush();
    }
}

function getLogger(loggerName) {
    return new Logger(bunyanMainLogger.child({ category: loggerName }));
}

module.exports = {
    getLogger,
    setExecutionId,
    setProjectId,
};