rm-logging/index.js

shell logging wrapper for node.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const rm_elasticsearch_1 = require("rm-elasticsearch");
const timestamp_1 = require("./helpers/timestamp");
var LoggerType;
(function (LoggerType) {
    LoggerType[LoggerType["ES"] = 0] = "ES";
})(LoggerType = exports.LoggerType || (exports.LoggerType = {}));
var LoggerLevel;
(function (LoggerLevel) {
    LoggerLevel[LoggerLevel["debug"] = 0] = "debug";
    LoggerLevel[LoggerLevel["info"] = 1] = "info";
    LoggerLevel[LoggerLevel["warn"] = 2] = "warn";
    LoggerLevel[LoggerLevel["error"] = 3] = "error";
    LoggerLevel[LoggerLevel["critical"] = 4] = "critical";
})(LoggerLevel = exports.LoggerLevel || (exports.LoggerLevel = {}));
class Logger {
    static get(config, level, type) {
        switch (type) {
            case LoggerType.ES:
                return ElasticSearchLogger.createLogger(config, level);
        }
    }
}
exports.Logger = Logger;
class ElasticSearchLogger {
    constructor(config, level) {
        ElasticSearchLogger._connection = new rm_elasticsearch_1.Connection({
            host: config.host,
            port: config.port,
            api: config.api,
            log: config.log,
            requestTimeout: config.requestTimeout
        });
        ElasticSearchLogger._level = level;
    }
    timeout(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }
    static createLogger(config, level) {
        if (!ElasticSearchLogger._instance) {
            ElasticSearchLogger._instance = new ElasticSearchLogger(config, level);
        }
        return ElasticSearchLogger._instance;
    }
    getLogger() {
        if (!ElasticSearchLogger._instance) {
            throw new Error("Please create logger first.");
        }
        return ElasticSearchLogger._instance;
    }
    async createIndex(setting) {
        let isExist = await ElasticSearchLogger._connection
            .indexExist({ index: setting.indexTag })
            .catch(function (error) {
            return false;
        });
        if (!isExist) {
            await ElasticSearchLogger._connection
                .createIndex({ index: setting.indexTag })
                .then(() => {
                console.log(`Index "${setting.indexTag}" has been created.`);
            })
                .catch(function (error) {
            });
            await this.createMapping(setting);
        }
    }
    async createMapping(settings) {
        if (typeof (settings) !== 'undefined' && settings.mapping !== 'undefined' && settings.mapping !== null) {
            return await ElasticSearchLogger._connection
                .putMapping({
                index: settings.indexTag,
                type: settings.type,
                body: settings.mapping
            })
                .then(() => {
                console.log(`Mapping for the index "${settings.indexTag}" has been created.\n`);
            })
                .catch(function (error) {
                console.log(`Error in creating mapping for the index "${settings.indexTag}" --> ${error}`);
            });
        }
    }
    async index(message, setting) {
        await this.createIndex(setting);
        return await ElasticSearchLogger._connection.index({
            index: setting.indexTag,
            type: setting.type,
            body: message
        });
    }
    async error(message, setting) {
        let msg = this.getMessageAsObject('error', message);
        await this.getLogger().index(msg, setting);
    }
    async info(message, setting) {
        let msg = this.getMessageAsObject('info', message);
        await this.getLogger().index(msg, setting);
    }
    async debug(message, setting) {
        let msg = this.getMessageAsObject('debug', message);
        await this.getLogger().index(msg, setting);
    }
    async critical(message, setting) {
        let msg = this.getMessageAsObject('critical', message);
        await this.getLogger().index(msg, setting);
    }
    async warn(message, setting) {
        let msg = this.getMessageAsObject('warn', message);
        await this.getLogger().index(msg, setting);
    }
    async log(level, message, setting) {
        if (level >= ElasticSearchLogger._level) {
            switch (level) {
                case LoggerLevel.debug: {
                    await this.debug(message, setting);
                }
                case LoggerLevel.info: {
                    await this.info(message, setting);
                }
                case LoggerLevel.warn: {
                    await this.warn(message, setting);
                }
                case LoggerLevel.error: {
                    await this.error(message, setting);
                }
                case LoggerLevel.critical: {
                    await this.critical(message, setting);
                }
            }
        }
    }
    getMessageAsObject(level, message) {
        let msg = (typeof (message) === 'object') ? message : { message: JSON.stringify(message) };
        let result = {
            'timestamp': timestamp_1.currentAsUnix(),
            'level': level,
            'message': msg
        };
        return result;
    }
}
exports.ElasticSearchLogger = ElasticSearchLogger;
//# sourceMappingURL=index.js.map