nightingale-logger 11.7.0 → 11.8.0

package/.eslintrc.json

@@ -1,5 +1,5 @@
 {
   "root": true,
-  "extends": ["@pob/eslint-config/root", "@pob/eslint-config-node"],
+  "extends": ["@pob/eslint-config/root-commonjs"],
   "ignorePatterns": ["*.d.ts", "/dist"]
 }

package/CHANGELOG.md

@@ -3,6 +3,47 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [11.8.0](https://github.com/christophehurpeau/nightingale/compare/v11.7.4...v11.8.0) (2021-11-27)
+
+
+### Features
+
+* **nightingale-logger:** support passing Error to any of the basic methods ([c1fda3e](https://github.com/christophehurpeau/nightingale/commit/c1fda3e5686f4c86f96d2cb2581239d2394bcf39))
+
+
+
+
+
+## [11.7.4](https://github.com/christophehurpeau/nightingale/compare/v11.7.3...v11.7.4) (2021-11-27)
+
+
+### Bug Fixes
+
+* build all packages ([dbb4785](https://github.com/christophehurpeau/nightingale/commit/dbb4785cbb8c75942935c4a5935df32fd2e93690))
+
+
+
+
+
+## [11.7.2](https://github.com/christophehurpeau/nightingale/compare/v11.7.1...v11.7.2) (2021-11-27)
+
+**Note:** Version bump only for package nightingale-logger
+
+
+
+
+
+## [11.7.1](https://github.com/christophehurpeau/nightingale/compare/v11.7.0...v11.7.1) (2021-06-29)
+
+
+### Bug Fixes
+
+* update pob-babel to bring back webpack 4 support ([4887431](https://github.com/christophehurpeau/nightingale/commit/4887431b3b272496511f879af022638723b9056e))
+
+
+
+
+
 # [11.7.0](https://github.com/christophehurpeau/nightingale/compare/v11.6.0...v11.7.0) (2021-03-29)
 
 **Note:** Version bump only for package nightingale-logger

package/babel.config.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+const path = require('path');
+
+module.exports = function babelConfig(api) {
+  const isTest = api.env('test');
+
+  if (!isTest) return {};
+
+  return {
+    only: [path.resolve(__dirname, 'src')],
+    presets: [require.resolve('pob-babel/preset')],
+  };
+};

package/dist/index-browser-dev.cjs.js

@@ -3,28 +3,31 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _extends = require('@babel/runtime/helpers/esm/extends');
-var Level = require('nightingale-levels');
+var nightingaleLevels = require('nightingale-levels');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e['default'] : e; }
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
 
 var _extends__default = /*#__PURE__*/_interopDefaultLegacy(_extends);
-var Level__default = /*#__PURE__*/_interopDefaultLegacy(Level);
 
 if (!global.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER) {
-  global.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER = () => ({
-    handlers: [],
-    processors: []
-  });
+  global.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER = function () {
+    return {
+      handlers: [],
+      processors: []
+    };
+  };
 }
 
 if (!global.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER_RECORD) {
-  global.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER_RECORD = (key, level) => {
-    const _global$__NIGHTINGALE = global.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER(key),
-          handlers = _global$__NIGHTINGALE.handlers,
-          processors = _global$__NIGHTINGALE.processors;
+  global.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER_RECORD = function (key, level) {
+    var _global$__NIGHTINGALE = global.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER(key),
+        handlers = _global$__NIGHTINGALE.handlers,
+        processors = _global$__NIGHTINGALE.processors;
 
     return {
-      handlers: handlers.filter(handler => level >= handler.minLevel && (!handler.isHandling || handler.isHandling(level, key))),
+      handlers: handlers.filter(function (handler) {
+        return level >= handler.minLevel && (!handler.isHandling || handler.isHandling(level, key));
+      }),
       processors
     };
   };
@@ -35,20 +38,24 @@ if (!global.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER_RECORD) {
 function getConfigForLoggerRecord(key, recordLevel) {
   return global.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER_RECORD(key, recordLevel);
 }
+
+function isError(messageOrError) {
+  return messageOrError instanceof Error;
+}
 /**
  * Interface that allows you to log records.
  * This records are treated by handlers
  */
 
 
-class Logger {
+var Logger = /*#__PURE__*/function () {
   /**
    * Create a new Logger
    *
    * @param {string} key
    * @param {string} [displayName]
    */
-  constructor(key, displayName) {
+  function Logger(key, displayName) {
     this.key = key;
     this.displayName = displayName;
 
@@ -59,21 +66,23 @@ class Logger {
   /** @private */
 
 
-  getHandlersAndProcessors(recordLevel) {
+  var _proto = Logger.prototype;
+
+  _proto.getHandlersAndProcessors = function getHandlersAndProcessors(recordLevel) {
     return getConfigForLoggerRecord(this.key, recordLevel);
   }
   /** @private */
+  ;
 
-
-  getConfig() {
+  _proto.getConfig = function getConfig() {
     return global.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER(this.key);
   }
   /**
    * Create a child logger
    */
+  ;
 
-
-  child(childSuffixKey, childDisplayName) {
+  _proto.child = function child(childSuffixKey, childDisplayName) {
     return new Logger(`${this.key}:${childSuffixKey}`, childDisplayName);
   }
   /**
@@ -93,19 +102,19 @@ class Logger {
    * ```
    *
    */
+  ;
 
-
-  context(context) {
-    const logger = new Logger(this.key);
-    logger.setContext(context);
+  _proto.context = function context(_context) {
+    var logger = new Logger(this.key);
+    logger.setContext(_context);
     return logger;
   }
   /**
    * Get the context of this logger
    */
+  ;
 
-
-  getContextObject() {
+  _proto.getContextObject = function getContextObject() {
     return this.contextObject;
   }
   /**
@@ -113,17 +122,17 @@ class Logger {
    *
    * @param {Object} context
    */
+  ;
 
-
-  setContext(context) {
+  _proto.setContext = function setContext(context) {
     this.contextObject = context;
   }
   /**
    * Extends existing context of this logger
    */
+  ;
 
-
-  extendsContext(extendedContext) {
+  _proto.extendsContext = function extendsContext(extendedContext) {
     Object.assign(this.contextObject, extendedContext);
   }
   /**
@@ -131,15 +140,15 @@ class Logger {
    *
    * Use this only if you know what you are doing.
    */
+  ;
 
-
-  addRecord(record) {
-    const _this$getHandlersAndP = this.getHandlersAndProcessors(record.level),
-          handlers = _this$getHandlersAndP.handlers,
-          processors = _this$getHandlersAndP.processors;
+  _proto.addRecord = function addRecord(record) {
+    var _this$getHandlersAndP = this.getHandlersAndProcessors(record.level),
+        handlers = _this$getHandlersAndP.handlers,
+        processors = _this$getHandlersAndP.processors;
 
     if (handlers.length === 0) {
-      if (record.level > Level__default.ERROR) {
+      if (record.level > nightingaleLevels.Level.ERROR) {
         // eslint-disable-next-line no-console
         console.log('[nightingale] no logger for > error level.', {
           key: record.key,
@@ -151,31 +160,45 @@ class Logger {
     }
 
     if (processors) {
-      processors.forEach(process => process(record, record.context));
+      processors.forEach(function (process) {
+        process(record, record.context);
+      });
     }
 
-    handlers.some(handler => handler.handle(record) === false);
+    handlers.some(function (handler) {
+      return handler.handle(record) === false;
+    });
   }
   /**
    * Log a message
    */
+  ;
 
+  _proto.log = function log(messageOrError, metadata, level, options) {
+    if (level === void 0) {
+      level = nightingaleLevels.Level.INFO;
+    }
 
-  log(message, metadata, level = Level__default.INFO, options) {
-    const context = metadata == null ? void 0 : metadata.context;
+    var isMessageError = isError(messageOrError);
+    var message = isMessageError ? `${messageOrError.name}: ${messageOrError.message}` : messageOrError;
+    var extendedMetadata = isMessageError && // eslint-disable-next-line unicorn/prefer-object-has-own
+    !Object.prototype.hasOwnProperty.call(metadata, 'error') ? _extends__default({}, metadata, {
+      error: messageOrError
+    }) : metadata;
+    var context = extendedMetadata == null ? void 0 : extendedMetadata.context;
 
-    if (metadata) {
-      delete metadata.context;
+    if (extendedMetadata) {
+      delete extendedMetadata.context;
     }
 
-    const record = _extends__default({
+    var record = _extends__default({
       level,
       key: this.key,
       displayName: this.displayName,
       datetime: new Date(),
       message,
       context: context || this.contextObject,
-      metadata,
+      metadata: extendedMetadata,
       extra: {}
     }, options);
 
@@ -184,50 +207,50 @@ class Logger {
   /**
    * Log a trace message
    */
+  ;
 
-
-  trace(message, metadata, metadataStyles) {
-    this.log(message, metadata, Level__default.TRACE, {
+  _proto.trace = function trace(messageOrError, metadata, metadataStyles) {
+    this.log(messageOrError, metadata, nightingaleLevels.Level.TRACE, {
       metadataStyles
     });
   }
   /**
    * Log a debug message
    */
+  ;
 
-
-  debug(message, metadata, metadataStyles) {
-    this.log(message, metadata, Level__default.DEBUG, {
+  _proto.debug = function debug(messageOrError, metadata, metadataStyles) {
+    this.log(messageOrError, metadata, nightingaleLevels.Level.DEBUG, {
       metadataStyles
     });
   }
   /**
    * Notice an info message
    */
+  ;
 
-
-  notice(message, metadata, metadataStyles) {
-    this.log(message, metadata, Level__default.NOTICE, {
+  _proto.notice = function notice(messageOrError, metadata, metadataStyles) {
+    this.log(messageOrError, metadata, nightingaleLevels.Level.NOTICE, {
       metadataStyles
     });
   }
   /**
    * Log an info message
    */
+  ;
 
-
-  info(message, metadata, metadataStyles) {
-    this.log(message, metadata, Level__default.INFO, {
+  _proto.info = function info(messageOrError, metadata, metadataStyles) {
+    this.log(messageOrError, metadata, nightingaleLevels.Level.INFO, {
       metadataStyles
     });
   }
   /**
    * Log a warn message
    */
+  ;
 
-
-  warn(message, metadata, metadataStyles) {
-    this.log(message, metadata, Level__default.WARN, {
+  _proto.warn = function warn(messageOrError, metadata, metadataStyles) {
+    this.log(messageOrError, metadata, nightingaleLevels.Level.WARN, {
       metadataStyles
     });
   }
@@ -244,31 +267,20 @@ class Logger {
    * }
    * ```
    */
+  ;
 
-
-  error(message, metadata, metadataStyles) {
-    if (message instanceof Error) {
-      const extendedMetadata = _extends__default({}, metadata, {
-        error: message
-      });
-
-      message = `${extendedMetadata.error.name}: ${extendedMetadata.error.message}`;
-      this.log(message, extendedMetadata, Level__default.ERROR, {
-        metadataStyles
-      });
-    } else {
-      this.log(message, metadata, Level__default.ERROR, {
-        metadataStyles
-      });
-    }
+  _proto.error = function error(messageOrError, metadata, metadataStyles) {
+    this.log(messageOrError, metadata, nightingaleLevels.Level.ERROR, {
+      metadataStyles
+    });
   }
   /**
    * Log an critical message
    */
+  ;
 
-
-  critical(message, metadata, metadataStyles) {
-    this.log(message, metadata, Level__default.CRITICAL, {
+  _proto.critical = function critical(messageOrError, metadata, metadataStyles) {
+    this.log(messageOrError, metadata, nightingaleLevels.Level.CRITICAL, {
       metadataStyles
     });
   }
@@ -285,54 +297,54 @@ class Logger {
    *   process.exit(1);
    * }
    */
+  ;
 
-
-  fatal(message, metadata, metadataStyles) {
-    this.log(message, metadata, Level__default.FATAL, {
+  _proto.fatal = function fatal(messageOrError, metadata, metadataStyles) {
+    this.log(messageOrError, metadata, nightingaleLevels.Level.FATAL, {
       metadataStyles
     });
   }
   /**
    * Log an alert message
    */
+  ;
 
-
-  alert(message, metadata, metadataStyles) {
-    this.log(message, metadata, Level__default.ALERT, {
+  _proto.alert = function alert(messageOrError, metadata, metadataStyles) {
+    this.log(messageOrError, metadata, nightingaleLevels.Level.ALERT, {
       metadataStyles
     });
   }
   /**
    * Log an inspected value
    */
+  ;
 
-
-  inspectValue() {
+  _proto.inspectValue = function inspectValue() {
     throw new Error('Not supported for the browser. Prefer `debugger;`');
   }
   /**
    * Log a debugged var
    */
+  ;
 
-
-  inspectVar() {
+  _proto.inspectVar = function inspectVar() {
     throw new Error('Not supported for the browser. Prefer `debugger;`');
   }
   /**
    * Alias for infoSuccess
    */
+  ;
 
-
-  success(message, metadata, metadataStyles) {
+  _proto.success = function success(message, metadata, metadataStyles) {
     this.infoSuccess(message, metadata, metadataStyles);
   }
   /**
    * Log an info success message
    */
+  ;
 
-
-  infoSuccess(message, metadata, metadataStyles) {
-    this.log(message, metadata, Level__default.INFO, {
+  _proto.infoSuccess = function infoSuccess(message, metadata, metadataStyles) {
+    this.log(message, metadata, nightingaleLevels.Level.INFO, {
       metadataStyles,
       symbol: '✔',
       styles: ['green', 'bold']
@@ -341,10 +353,10 @@ class Logger {
   /**
    * Log an debug success message
    */
+  ;
 
-
-  debugSuccess(message, metadata, metadataStyles) {
-    this.log(message, metadata, Level__default.DEBUG, {
+  _proto.debugSuccess = function debugSuccess(message, metadata, metadataStyles) {
+    this.log(message, metadata, nightingaleLevels.Level.DEBUG, {
       metadataStyles,
       symbol: '✔',
       styles: ['green']
@@ -353,18 +365,18 @@ class Logger {
   /**
    * Alias for infoFail
    */
+  ;
 
-
-  fail(message, metadata, metadataStyles) {
-    this.infoFail(message, metadata, metadataStyles);
+  _proto.fail = function fail(messageOrError, metadata, metadataStyles) {
+    this.infoFail(messageOrError, metadata, metadataStyles);
   }
   /**
    * Log an info fail message
    */
+  ;
 
-
-  infoFail(message, metadata, metadataStyles) {
-    this.log(message, metadata, Level__default.INFO, {
+  _proto.infoFail = function infoFail(messageOrError, metadata, metadataStyles) {
+    this.log(messageOrError, metadata, nightingaleLevels.Level.INFO, {
       metadataStyles,
       symbol: '✖',
       styles: ['red', 'bold']
@@ -373,10 +385,10 @@ class Logger {
   /**
    * Log an debug fail message
    */
+  ;
 
-
-  debugFail(message, metadata, metadataStyles) {
-    this.log(message, metadata, Level__default.DEBUG, {
+  _proto.debugFail = function debugFail(messageOrError, metadata, metadataStyles) {
+    this.log(messageOrError, metadata, nightingaleLevels.Level.DEBUG, {
       metadataStyles,
       symbol: '✖',
       styles: ['red']
@@ -385,9 +397,13 @@ class Logger {
   /**
    * @returns {number} time to pass to timeEnd
    */
+  ;
 
+  _proto.time = function time(message, metadata, metadataStyles, level) {
+    if (level === void 0) {
+      level = nightingaleLevels.Level.DEBUG;
+    }
 
-  time(message, metadata, metadataStyles, level = Level__default.DEBUG) {
     if (message) {
       this.log(message, metadata, level, {
         metadataStyles
@@ -395,10 +411,10 @@ class Logger {
     }
 
     return Date.now();
-  }
+  };
 
-  infoTime(message, metadata, metadataStyles) {
-    return this.time(message, metadata, metadataStyles, Level__default.INFO);
+  _proto.infoTime = function infoTime(message, metadata, metadataStyles) {
+    return this.time(message, metadata, metadataStyles, nightingaleLevels.Level.INFO);
   }
   /**
    * Finds difference between when this method
@@ -406,21 +422,25 @@ class Logger {
    * was called, then logs out the difference
    * and deletes the original record
    */
+  ;
 
+  _proto.timeEnd = function timeEnd(startTime, message, metadata, metadataStyles, level, options) {
+    if (level === void 0) {
+      level = nightingaleLevels.Level.DEBUG;
+    }
 
-  timeEnd(startTime, message, metadata, metadataStyles, level = Level__default.DEBUG, options) {
-    const now = Date.now();
-    const diffTime = now - startTime;
-    let readableTime;
+    var now = Date.now();
+    var diffTime = now - startTime;
+    var readableTime;
 
     if (diffTime < 1000) {
       readableTime = `${diffTime}ms`;
     } else {
-      const seconds = diffTime > 1000 ? Math.floor(diffTime / 1000) : 0;
+      var seconds = diffTime > 1000 ? Math.floor(diffTime / 1000) : 0;
       readableTime = `${seconds ? `${seconds}s and ` : ''}${diffTime - seconds * 1000}ms`;
     }
 
-    const extendedMetadata = _extends__default({}, metadata, {
+    var extendedMetadata = _extends__default({}, metadata, {
       readableTime,
       timeMs: diffTime
     });
@@ -432,18 +452,18 @@ class Logger {
   /**
    * Like timeEnd, but with INFO level
    */
+  ;
 
-
-  infoTimeEnd(time, message, metadata, metadataStyles) {
-    this.timeEnd(time, message, metadata, metadataStyles, Level__default.INFO);
+  _proto.infoTimeEnd = function infoTimeEnd(time, message, metadata, metadataStyles) {
+    this.timeEnd(time, message, metadata, metadataStyles, nightingaleLevels.Level.INFO);
   }
   /**
    * Like timeEnd, but with INFO level
    */
+  ;
 
-
-  infoSuccessTimeEnd(time, message, metadata, metadataStyles) {
-    this.timeEnd(time, message, metadata, metadataStyles, Level__default.INFO, {
+  _proto.infoSuccessTimeEnd = function infoSuccessTimeEnd(time, message, metadata, metadataStyles) {
+    this.timeEnd(time, message, metadata, metadataStyles, nightingaleLevels.Level.INFO, {
       symbol: '✔',
       styles: ['green', 'bold']
     });
@@ -462,14 +482,14 @@ class Logger {
    * ```
    *
    */
+  ;
 
-
-  enter(fn, metadata, metadataStyles) {
-    const extendedMetadata = _extends__default({}, metadata, {
+  _proto.enter = function enter(fn, metadata, metadataStyles) {
+    var extendedMetadata = _extends__default({}, metadata, {
       functionName: fn.name
     });
 
-    this.log('enter', extendedMetadata, Level__default.TRACE, {
+    this.log('enter', extendedMetadata, nightingaleLevels.Level.TRACE, {
       metadataStyles
     });
   }
@@ -487,14 +507,14 @@ class Logger {
    * }
    * ```
    */
+  ;
 
-
-  exit(fn, metadata, metadataStyles) {
-    const extendedMetadata = _extends__default({}, metadata, {
+  _proto.exit = function exit(fn, metadata, metadataStyles) {
+    var extendedMetadata = _extends__default({}, metadata, {
       functionName: fn.name
     });
 
-    this.log('exit', extendedMetadata, Level__default.TRACE, {
+    this.log('exit', extendedMetadata, nightingaleLevels.Level.TRACE, {
       metadataStyles
     });
   }
@@ -513,11 +533,11 @@ class Logger {
    * }
    * ```
    */
+  ;
 
-
-  wrap(fn, option1, option2, callback) {
-    let metadata;
-    let metadataStyles;
+  _proto.wrap = function wrap(fn, option1, option2, callback) {
+    var metadata;
+    var metadataStyles;
 
     if (typeof option1 === 'function') {
       callback = option1;
@@ -534,11 +554,12 @@ class Logger {
     this.enter(fn, metadata, metadataStyles);
     callback();
     this.exit(fn);
-  }
+  };
 
-}
+  return Logger;
+}();
 
-exports.Level = Level__default;
+exports.Level = nightingaleLevels.Level;
 exports.Logger = Logger;
-exports.default = Logger;
+exports["default"] = Logger;
 //# sourceMappingURL=index-browser-dev.cjs.js.map