sl-cia/lib/sl-logger.js

var bunyan = require('bunyan');
var bformat = require('bunyan-format');
var formatStdOut = bformat({levelInString: true}, process.stdout);
var SlJsInfra = require('sl-js-infra').SlJsInfra;
var blackholeLogger = require('bunyan-blackhole');

var TRACE = 10;
var DEBUG = 20;
var INFO = 30;
var WARN = 40;
var ERROR = 50;
var FATAL = 60;

function mapLevelToName(level) {
  switch (level) {
    case TRACE:
      return 'TRACE';
    case DEBUG:
      return 'DEBUG';
    case INFO:
      return 'INFO';
    case WARN:
      return 'WARN';
    case ERROR:
      return 'ERROR';
    case FATAL:
      return 'FATAL';
  }
}

function BunyanLogger(config){
    this.buffer = [];
    this.bufferLength = config.bufferLength || 50;
    this.bufferTimeout = config.bufferTimeout || 3000;
    this.maxConnections = 10;
    this.currentConnections = 0;
    this.config = config;
}

BunyanLogger.prototype.write = function(data){
    data.level = mapLevelToName(data.level);
    this.buffer.push(data);
    this.checkBuffer(false, function (err) {});
};

BunyanLogger.prototype.processBuffer = function(callback){
    clearTimeout(this._timeoutId);

    var entries = this.buffer.slice();
    this.buffer = [];
    if (this.currentConnections == this.maxConnections) {
        return callback(null);
    }

    this._sendLogs(entries, function (err) {
        if (err){
            console.error("[LOG SUBMISSION] Failed to send logs to Sealights. Error: " + err);
            callback(err);
        }
        else {
            callback(null);
        }
    });
};

BunyanLogger.prototype.checkBuffer = function(isLastProcess, callback){
    var bunyanLogger = this;

    if (isLastProcess) { // This flag is true only on shutdown
        this.bufferLength = 1;
        this.bufferTimeout = 0;
    }

    if (!this.buffer.length) {
        return callback(null);
    }

    if(this.buffer.length >= this.bufferLength){
        return this.processBuffer(callback);
    }

    if(this.bufferTimeout){
        clearTimeout(this._timeoutId);

        this._timeoutId = setTimeout(
            function(){
                bunyanLogger.processBuffer(callback);
            },
            this.bufferTimeout
        );
    }
};

BunyanLogger.prototype._sendLogs = function sendLogs(entries, callback) {
    var data = {
        customerId: this.config.customerId,
        appName: this.config.appName,
        creationTime: new Date().valueOf(),
        environment: {
            environmentName: this.config.environment || "null"
        },
        log: entries.map(function (entry) {
            return JSON.stringify(entry)
        }).join("\n")
    };
    if (!data.customerId || !data.appName) {
        return callback(new Error("[LOG SUBMISSION] customerId and appName are required to send logs"))
    }

    this.currentConnections += 1;
    
    var that = this;
    var backendProxy = new SlJsInfra.BackendProxy(this.config, nullLogger());
    backendProxy.submitLogs(data, function(err, body){
        that.currentConnections -= 1;
        callback(err);
    });
};

var nullLogger = function () {
    return blackholeLogger();
};

function getLogLevel(){
    return process.env.SL_LOG_LEVEL || "info";;
}

var consoleFileLogger = function (name) {
    var loggerConfig = {
        name: name || "CIA",
        streams: []
    };
    var logLevel  = getLogLevel();
    if (process.env.NODE_DEBUG == "sl" || process.env.NODE_DEBUG == "sl-console") {
        loggerConfig.streams.push({level: logLevel, stream: formatStdOut})
    }
    if (process.env.NODE_DEBUG == "sl-file") {
        loggerConfig.streams.push({level: logLevel, path: "sl.node.log"})
    }
    return bunyan.createLogger(loggerConfig);
};

var logger = function (config) {
    var remoteStream;
    var environment = {environmentName: "null"};
    if (config.environmentName) {
        environment = {environmentName: config.environmentName}
    }
    if (config.environment && config.environment.environmentName) {
        environment = config.environment;
    }
    var loggerConfig = {
        name: "CIA",
        streams: []
    };

    var logLevel  = getLogLevel();
    if (process.env.NODE_DEBUG == "sl" || process.env.NODE_DEBUG == "sl-console" || config.NODE_DEBUG == "sl") {
        loggerConfig.streams.push({level: logLevel, stream: formatStdOut})
    }
    if (process.env.NODE_DEBUG == "sl-file" || config.NODE_DEBUG == "sl-file") {
        loggerConfig.streams.push({level: logLevel, path: "sl.node.log"})
    }
    if (config.sendLogs) {
        remoteStream = new BunyanLogger(config);
        loggerConfig.streams.push({level: logLevel, type: "raw", stream: remoteStream});
    }
    var bunyanLogger = bunyan.createLogger(loggerConfig);
    bunyanLogger.remoteStream = remoteStream;
    return bunyanLogger
};

module.exports.BunyanLogger = BunyanLogger;
module.exports.logger = logger;
module.exports.nullLogger = nullLogger;
module.exports.consoleFileLogger = consoleFileLogger;