@cumulus/logger/dist/index.js

A log library for use on Cumulus

"use strict";
const isError = require("lodash.iserror");
const util = require("util");
class Logger {
    constructor(options = {}) {
        this.asyncOperationId = options.asyncOperationId;
        this.executions = options.executions;
        this.granules = options.granules;
        this.parentArn = options.parentArn;
        this.pretty = options.pretty || false;
        this.sender = options.sender || 'unknown';
        this.stackName = options.stackName;
        this.console = options.console || global.console;
        this.version = options.version;
    }
    buildMessage(level, ...messageArgs) {
        return this.buildLogEventMessage(level, messageArgs);
    }
    /**
     * Log a debug message
     */
    debug(...messageArgs) {
        this.writeLogEvent('debug', messageArgs);
    }
    /**
     * Log an error message
     */
    error(...messageArgs) {
        const lastMessageArg = messageArgs[messageArgs.length - 1];
        if (isError(lastMessageArg)) {
            const error = lastMessageArg;
            let actualMessageArgs = messageArgs.slice(0, messageArgs.length - 1);
            if (actualMessageArgs.length === 0)
                actualMessageArgs = [error.message];
            const additionalKeys = {
                error: {
                    name: error.name,
                    message: error.message,
                },
            };
            if (error.stack)
                additionalKeys.error.stack = error.stack.split('\n');
            this.writeLogEvent('error', actualMessageArgs, additionalKeys);
        }
        else {
            this.writeLogEvent('error', messageArgs);
        }
    }
    /**
     * Log a fatal message
     */
    fatal(...messageArgs) {
        this.writeLogEvent('fatal', messageArgs);
    }
    /**
     * Log an info message
     */
    info(...messageArgs) {
        this.writeLogEvent('info', messageArgs);
    }
    /**
     * Log an event with additional properties
     *
     * @param {Object} additionalKeys
     * @param {Array<any>} messageArgs - the message to log
     */
    infoWithAdditionalKeys(additionalKeys, ...messageArgs) {
        this.writeLogEvent('info', messageArgs, additionalKeys);
    }
    /**
     * Log a trace message
     */
    trace(...messageArgs) {
        this.writeLogEvent('trace', messageArgs);
    }
    /**
     * Log a warning message
     */
    warn(...messageArgs) {
        this.writeLogEvent('warn', messageArgs);
    }
    buildLogEventMessage(level, messageArgs, additionalKeys = {}) {
        let message;
        if (messageArgs.length === 0) {
            message = '';
        }
        else {
            message = util.format(messageArgs[0], ...messageArgs.slice(1));
        }
        const standardLogEvent = {
            asyncOperationId: this.asyncOperationId,
            executions: this.executions,
            granules: this.granules,
            level,
            message,
            parentArn: this.parentArn,
            sender: this.sender,
            stackName: this.stackName,
            timestamp: (new Date()).toISOString(),
            version: this.version,
        };
        const logEvent = {
            ...additionalKeys,
            ...standardLogEvent,
        };
        return this.pretty
            ? JSON.stringify(logEvent, undefined, 2)
            : JSON.stringify(logEvent);
    }
    writeLogEvent(level, messageArgs, additionalKeys = {}) {
        const logEventString = this.buildLogEventMessage(level, messageArgs, additionalKeys);
        if (level === 'error')
            this.console.error(logEventString);
        else
            this.console.log(logEventString);
    }
}
module.exports = Logger;
//# sourceMappingURL=index.js.map