logify/dist/index.js

Logging framework for node and the browser

'use strict';

var _createClass = require('babel-runtime/helpers/create-class')['default'];

var _classCallCheck = require('babel-runtime/helpers/class-call-check')['default'];

var _getIterator = require('babel-runtime/core-js/get-iterator')['default'];

var _Promise = require('babel-runtime/core-js/promise')['default'];

var _interopRequireDefault = require('babel-runtime/helpers/interop-require-default')['default'];

var _util = require('util');

var _os = require('os');

var _os2 = _interopRequireDefault(_os);

var _serializerError = require('./serializer/error');

var _serializerError2 = _interopRequireDefault(_serializerError);

var _serializerReq = require('./serializer/req');

var _serializerReq2 = _interopRequireDefault(_serializerReq);

var _serializerRes = require('./serializer/res');

var _serializerRes2 = _interopRequireDefault(_serializerRes);

var _libExtend = require('./lib/extend');

var _libExtend2 = _interopRequireDefault(_libExtend);

var _libMakeLogLevel = require('./lib/make-log-level');

var _libMakeLogLevel2 = _interopRequireDefault(_libMakeLogLevel);

var Logger = (function () {
  function Logger(context, parent) {
    if (context === undefined) context = {};

    _classCallCheck(this, Logger);

    this.context = context;
    this.parent = parent;
    this.serializers = [];
    this.transports = parent ? parent.transports : [];
    context.pid = process.pid;
    context.hostname = _os2['default'].hostname();
    context.arch = process.arch;
    context.platform = process.platform;

    if (!this.parent) {
      this.transform(_serializerError2['default']).transform(_serializerReq2['default']).transform(_serializerRes2['default']);
    }
  }

  _createClass(Logger, [{
    key: 'serialize',
    value: function serialize(entry) {
      if (this.parent) {
        entry = this.parent.serialize(entry);
      }
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        for (var _iterator = _getIterator(this.serializers), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var serializer = _step.value;

          entry = serializer(entry);
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator['return']) {
            _iterator['return']();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }

      return entry;
    }
  }, {
    key: 'log',
    value: function log(entry) {
      entry = this.serialize(entry);
      return _Promise.all(this.transports.map(function (transport) {
        return transport(entry);
      }));
    }
  }, {
    key: 'transform',
    value: function transform(field, fn, always) {
      if (typeof field === 'function') {
        this.serializers.push(field);
        return this;
      } else if (always) {
        this.serializers.push(function (entry) {
          entry[field] = fn(entry[field]);
          return entry;
        });
      } else {
        this.serializers.push(function (entry) {
          if (entry[field]) {
            entry[field] = fn(entry[field]);
          }
          return entry;
        });
      }
      return this;
    }
  }, {
    key: 'add',
    value: function add(transport) {
      this.transports.push(transport);
      return this;
    }
  }, {
    key: 'child',
    value: function child(context) {
      var logger = new Logger((0, _libExtend2['default'])({}, this.context, context), this);
      return logger;
    }
  }, {
    key: 'component',
    value: function component(name) {
      return this.child({
        component: this.context.component ? this.context.component + '.' + name : name
      });
    }
  }, {
    key: 'use',
    value: function use(plugin) {
      return plugin(this);
    }
  }]);

  return Logger;
})();

['trace', 'debug', 'info', 'notice', 'warn', 'error', 'critical'].forEach(function (level) {
  Logger.prototype[level] = (0, _libMakeLogLevel2['default'])(level);
});

module.exports = Logger;