hapi-good-winston/dist/index.js

A hapi good reporter to log events with winston

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.defaultLevels = undefined;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

exports.log = log;
exports.goodWinston = goodWinston;

var _stream = require('stream');

var _stream2 = _interopRequireDefault(_stream);

var _handlers = require('./handlers');

var _handlers2 = _interopRequireDefault(_handlers);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var defaultLevels = exports.defaultLevels = {
    ops: 'debug',
    response: 'info',
    log: 'info',
    error: 'error',
    request: 'info'
};

// Creating a writableObjectStream prototype
var writableObjectStream = new _stream2.default.Writable({ objectMode: true });

// Creating a logger prototype
var loggerStream = _extends(Object.create(writableObjectStream), {
    _write: function _write(event, encoding, callback) {
        var type = event.event;

        // If an handler is available for the event received call the handler and log the message it returns

        if (_handlers2.default[type]) {
            var payload = _handlers2.default[type](event);
            log(this.logger, this.levels[type], payload);
        }

        callback();
    }
});

/**
 * Logs a msg using a logger and a loggin level
 * @param  {Object} logger    winston logger
 * @param  {string} lvl       logging level
 * @param  {Object} payload   message payload containig eventual meta-data
 */
function log(logger, lvl, payload) {
    var _payload$msg = payload.msg,
        msg = _payload$msg === undefined ? '' : _payload$msg,
        _payload$meta = payload.meta,
        meta = _payload$meta === undefined ? '' : _payload$meta;

    logger.log(lvl, msg, meta);
}

function goodWinston(logger) {
    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
        levels = _ref.levels;

    if (!logger || !logger.log || typeof logger.log !== 'function') throw new TypeError('You must pass a valid winston logger');

    // Instantiate a logger with loggerStream prototype and assign local properties logger and levels to the instance
    return _extends(Object.create(loggerStream), {
        logger: logger,
        levels: levels ? _extends({}, defaultLevels, levels) : defaultLevels
    });
}

exports.default = goodWinston;
//# sourceMappingURL=index.js.map