A lightweight node log library

lynx_node_logger.js

var clc = require('cli-color');
var _ = require('underscore');

var _default_log = console.log.bind(console);
var _log_type_array = [];

var log_type = function() {
    var name = 'internal';
    var prefix_text = '';
    var default_handler = function() {
        _default_log.apply(this, arguments);
    };

    this.background = -1;
    this.color = -1;
    this.level = 0;
    this.prefix = {
        color: -1,
        background: -1
    };
    this.handler = function() {
        default_handler.apply(this, arguments);
    };

    Object.defineProperty(this, 'name', {
        get: function() {
            return name;
        },

        set: function(value) {
            name = value;
            prefix_text = (prefix_text === '' ? value : prefix_text);
        }
    });

    Object.defineProperty(this.prefix, 'text', {
        get: function() {
            return (prefix_text === '' ? name : prefix_text);
        },

        set: function(value) {
            prefix_text = value;
        }
    });

    Object.defineProperty(this, 'default_handler', {
        writable: false,
        value: default_handler
    });
};

function _process_log_type() {
    var args = Array.prototype.slice.call(arguments);
    var type = {};
    var prefix = "";

    if (args && args[0]) {
        if (args[0].name) {
            type = args.shift();

            if (type.color !== -1) {
                args = _.map(args, function(item) {
                    return clc.xterm(parseInt(type.color, 10))(item);
                });
            }

            if (type.background !== -1) {
                args = _.map(args, function(item) {
                    return clc.bgXterm(parseInt(type.background, 10))(item);
                });
            }

            if (type.prefix.text) {
                prefix = '[' + type.prefix.text + ']';

                if (type.prefix.color !== -1) {
                    prefix = clc.xterm(parseInt(type.prefix.color, 10))(prefix);
                }

                if (type.prefix.background !== -1) {
                    prefix = clc.bgXterm(parseInt(type.prefix.background, 10))(prefix);
                }

                args.unshift(prefix);
            }

            if (type.handler) {
                type.handler.apply(this, args);
            } else {
                _default_log.apply(this, args);
            }
        } else {
            logger.warn('Cannot call _process_log_type with non log type first parameter.');
        }
    } else {
        logger.warn('Cannot call _process_log_type with empty parameters');
    }

    return logger;
};

function _log() {
    var args = Array.prototype.slice.call(arguments);

    if (args && args[0]) {
        if (args[0] instanceof log_type) {
            return _process_log_type.apply(this, args);
        }

        _default_log.apply(this, args);
    } else {
        this.warn('Cannot call log with empty parameters');
    }

    return logger;
};

var logger = {
    threshold: 0,
    create_log_type: function(options) {
        var lt = new log_type();
        var prefix = _.defaults(_.extend(lt.prefix, options.prefix), options.prefix);

        // There has to be a better way of doing this...
        lt = _.extend(lt, options);
        lt = _.defaults(lt, options);
        lt.prefix = prefix;

        if (!_log_type_array[lt.name]) {
            _log_type_array[lt.name] = lt;
        } else {
            this.warn('A log type that has already been defined cannot be overwritten. Tried overwriting ' + lt.name);
        }

        if (lt.hasOwnProperty('_cmd')) {
            if (typeof lt._cmd === 'string') {
                lt._cmd = [lt._cmd];
            }

            // Add the command(s) to the Logger object
            _.each(lt._cmd, function bind_log_commands(command) {
                logger[command] = function custom_log_command() {
                    var args = Array.prototype.slice.call(arguments);
                    args.unshift(lt);
                    _log.apply(this, args);
                };
            });

            delete lt._cmd;
        }

        _log_type_array.push(lt);

        return lt;
    }
};

Object.defineProperty(logger, 'log_type', {
    get: function() {
        return _log_type_array;
    },

    set: function() {
        logger.warn("You cannot overwrite the value of the logger.log_type global.");
    }
});

// Initialize the logger with basic types
logger.create_log_type({
    name: 'debug',
    level: 2,
    _cmd: ['debug'],
    prefix: {
        text: 'DEBUG',
        color: '14',
        background: '0'
    }
});

logger.create_log_type({
    name: 'info',
    level: 2,
    _cmd: ['info', 'log'],
    prefix: {
        text: 'INFO'
    }
});

logger.create_log_type({
    name: 'warning',
    level: 3,
    _cmd: ['warn'],
    prefix: {
        text: 'WARNING',
        color: "209"
    }
});

(function define_error_log_type() {
    var error_log_type = logger.create_log_type({
        name: 'error',
        level: 4,
        _cmd: ['error'],
        prefix: {
            text: 'ERROR',
            color: "196"
        },
        handler: function() {
            var args = Array.prototype.slice.call(arguments);
            var stack = new Error().stack;
            var splitted = stack.split("\n");
            var limit = 0;

            splitted.splice(0, 5); // Remove mr bot trace
            limit = splitted.length - logger.trace_limit;
            if (limit > 0) {
                splitted.splice(logger.trace_limit - 1, limit);
                splitted[splitted.length - 1] = splitted[splitted.length - 1] + "...";
            }

            stack = splitted.join('\r\n');

            error_log_type.default_handler.apply(this, args);
            error_log_type.default_handler(stack);
        }
    });

    logger.trace_limit = 4;
})();


module.exports = logger;