solive-winston-logger/lib/index.js

handle logs for solive projects

'use strict';

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

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

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; };

var _winston = require('winston');

var _winston2 = _interopRequireDefault(_winston);

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _parse = require('./parse');

var _parse2 = _interopRequireDefault(_parse);

var _constants = require('./constants');

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Logger = function Logger(_ref) {
	var env = _ref.env,
	    onNewLog = _ref.onNewLog;
	var fields = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

	_classCallCheck(this, Logger);

	_initialiseProps.call(this);

	this.logger = this.createLogger(env);
	this.env = env;
	this.fields = _extends({}, fields);
	this.onNewLog = onNewLog;

	this.populateLogger();
};

var _initialiseProps = function _initialiseProps() {
	var _this = this;

	this.createLogger = function (env) {
		return new _winston2.default.Logger({
			colors: _constants.colors,
			levels: _constants.levels,
			transports: [new _winston2.default.transports.Console({
				timestamp: false,
				colorize: env !== 'production',
				prettyPrint: true,
				level: env === 'production' ? 'info' : 'trace'
			})]
		});
	};

	this.populateLogger = function () {
		return _lodash2.default.forEach(_constants.levels, function (level, key) {
			_this[key] = _this.log(key);
		});
	};

	this.log = function (key) {
		return function (message) {
			var fields = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

			var log = _extends({
				message: message
			}, _this.fields, fields, {
				date: new Date()
			});
			if ((typeof fields === 'undefined' ? 'undefined' : _typeof(fields)) !== _typeof({})) {
				var error = 'fields should be an object';
				console.error(new Error(error));
				return error;
			}
			var err = (0, _parse2.default)(key, log);

			if (err) {
				console.error(new Error(err));
				return err;
			}

			_this.logger.log.call(_this.logger, key, message, _lodash2.default.omit(log, ['message']));

			if (_this.onNewLog) {
				_this.onNewLog(log);
			}
		};
	};

	this.create = function (fields) {
		return new Logger({ env: _this.env, onNewLog: _this.onNewLog }, _extends({}, _this.fields, fields));
	};
};

exports.default = function (_ref2) {
	var env = _ref2.env,
	    onNewLog = _ref2.onNewLog;
	return new Logger({ env: env, onNewLog: onNewLog });
};
//# sourceMappingURL=index.js.map