kannon/classes/Logger.js

const moment = require('moment');

// constants
const LOG_PREFIX_DEBUG = 'debug';
const LOG_PREFIX_INFO = 'info';
const LOG_PREFIX_WARNING = 'warning';
const LOG_PREFIX_ERROR = 'error';
const LOGLEVEL_DEBUG = 0;
const LOGLEVEL_INFO = 1;
const LOGLEVEL_WARNING = 2;
const LOGLEVEL_ERROR = 3;


class Logger {

    constructor(loglevel, timestamp) {
        this.setLogLevel(loglevel);
        this.setTimestamp(timestamp);
    }

    // set the loglevel
    setLogLevel(value) {
        switch (value) {
            case LOG_PREFIX_DEBUG:
            case LOGLEVEL_DEBUG:
                this.loglevel = LOGLEVEL_DEBUG;
                break;
            case LOG_PREFIX_INFO:
            case LOGLEVEL_INFO:
                this.loglevel = LOGLEVEL_INFO;
                break;
            case LOG_PREFIX_WARNING:
            case LOGLEVEL_WARNING:
                this.loglevel = LOGLEVEL_WARNING;
                break;
            case LOG_PREFIX_ERROR:
            case LOGLEVEL_ERROR:
                this.loglevel = LOGLEVEL_ERROR;
                break;
            default:
                this.loglevel = LOGLEVEL_INFO;
                break;
        }
    }

    // get the timestamp format
    setTimestamp(value) {
        this.timestamp = value || 'DD.MM.YYYY HH:mm:ss:SS';
    }

    // log a http request - response object
    http(object) {
        if (object === undefined) {
            return;
        }
        let message = '[' + object.request.method + ':' + object.code + '] url: \'' + object.request.url + '\'';
        let counter = 1;
        for (let param in object.request.body) {
            message += ', parameter ' + counter + ': \'' + param + '=' + object.request.body[param] + '\'';
            counter++;
        }
        if (object.request.timestamp) {
            message += ' > ' + (new Date().getTime() - object.request.timestamp) + 'ms';
        }
        if (object.data) {
            message += ' > data: ' + object.data;
        }
        if (object.code != 200) {
            error(message.trim());
            return;
        }
        this.debug(message.trim());
    }

    // prefix log with 'info'
    info(message) {
        if (this.loglevel > LOGLEVEL_INFO) {
            return;
        }
        this.trace(message);
    }

    // prefix log with 'info'
    warn(message) {
        if (this.loglevel > LOGLEVEL_WARNING) {
            return;
        }
        this.trace(message, 'warning');
    }

    // prefix log with 'debug'
    debug(message) {
        if (this.loglevel > LOGLEVEL_DEBUG) {
            return;
        }
        this.trace(message, 'debug');
    }

    // prefix log with 'error'
    error(message) {
        if (this.loglevel > LOGLEVEL_ERROR) {
            return;
        }
        if (message.stack) {
            this.trace(message.stack, 'error');
            return;
        }
        if (message.errors !== undefined) {
            for (let index = 0; index < message.errors.length; index++) {
                this.trace(message.errors[index], 'error');
            }
            return;
        }
        this.trace(message.toString(), 'error');
    }

    // default logging function
    trace(message, prefix) {
        if (message === undefined || message === null || message.length === 0) {
            return;
        }
        if (prefix === undefined || prefix === null || prefix.length === 0) {
            prefix = 'info';
        }
        let print;
        switch (prefix) {
            case 'error':
                print = console.error;
                break;
            case 'debug':
                print = console.debug;
                break;
            case 'warning':
                print = console.warn;
                break;
            default:
                print = console.log;
        }
        message = moment().format(this.timestamp) + ' | ' + prefix + ' > ' + message;
        print(message);
    }

}

module.exports = Logger;