axe 8.1.2 → 10.0.0

package/lib/index.js

@@ -1,64 +1,80 @@
 "use strict";
 
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+// eslint-disable-next-line import/no-unassigned-import
+require('console-polyfill');
 
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+const combine = require('maybe-combine-errors');
 
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+const format = require('@ladjs/format-util');
 
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+const formatSpecifiers = require('format-specifiers');
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+const get = require('@strikeentco/get');
 
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+const isError = require('iserror');
 
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+const mergeOptions = require('merge-options');
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+const pMapSeries = require('p-map-series');
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+const parseAppInfo = require('parse-app-info');
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+const parseErr = require('parse-err');
 
-function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+const pickDeep = require('pick-deep');
 
-// eslint-disable-next-line import/no-unassigned-import
-require('console-polyfill');
+const set = require('@strikeentco/set');
 
-var cuid = require('cuid');
+const unset = require('unset-value');
 
-var format = require('@ladjs/format-util');
+const {
+  boolean
+} = require('boolean');
 
-var formatSpecifiers = require('format-specifiers');
+const pkg = require('../package.json');
 
-var isError = require('iserror');
+const omittedLoggerKeys = new Set(['config', 'log']);
+const levels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
+const aliases = {
+  warning: 'warn',
+  err: 'error'
+};
+const levelError = `\`level\` invalid, must be: ${levels.join(', ')}`; // <https://github.com/sindresorhus/is-plain-obj/blob/main/index.js>
 
-var omit = require('lodash.omit');
+function isPlainObject(value) {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
 
-var parseAppInfo = require('parse-app-info');
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+} // <https://github.com/GeenenTijd/dotify/blob/master/dotify.js>
 
-var parseErr = require('parse-err');
 
-var safeStringify = require('fast-safe-stringify');
+function dotifyToArray(obj) {
+  const res = [];
 
-var superagent = require('superagent');
+  function recurse(obj, current) {
+    for (const key of Object.keys(obj)) {
+      const value = obj[key];
+      const newKey = current ? current + '.' + key : key; // joined key with dot
+      // if (value && typeof value === 'object' && !(value instanceof Date) && !ObjectID.isValid(value)) {
 
-var _require = require('boolean'),
-    boolean = _require.boolean;
+      if (isPlainObject(value)) {
+        recurse(value, newKey); // it's a nested object, so do it again
+      } else {
+        res.push(newKey);
+      }
+    }
+  }
 
-var pkg = require('../package.json');
+  recurse(obj);
+  return res;
+} // <https://stackoverflow.com/a/43233163>
 
-var omittedLoggerKeys = new Set(['config', 'log']);
-var levels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
-var aliases = {
-  warning: 'warn',
-  err: 'error'
-};
-var endpoint = 'https://api.cabinjs.com';
-var levelError = "`level` invalid, must be: ".concat(levels.join(', ')); // <https://stackoverflow.com/a/43233163>
 
 function isEmpty(value) {
-  return value === undefined || value === null || _typeof(value) === 'object' && Object.keys(value).length === 0 || typeof value === 'string' && value.trim().length === 0;
+  return value === undefined || value === null || typeof value === 'object' && Object.keys(value).length === 0 || typeof value === 'string' && value.trim().length === 0;
 }
 
 function isNull(value) {
@@ -70,7 +86,7 @@ function isUndefined(value) {
 }
 
 function isObject(value) {
-  return _typeof(value) === 'object' && value !== null && !Array.isArray(value);
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
 function isString(value) {
@@ -81,308 +97,373 @@ function isFunction(value) {
   return typeof value === 'function';
 }
 
-function isBoolean(value) {
-  return typeof value === 'boolean';
-}
-
-var Axe = /*#__PURE__*/function () {
-  function Axe() {
+class Axe {
+  constructor() {
     var _this = this;
 
-    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
-    _classCallCheck(this, Axe);
-
-    this.config = Object.assign({
-      key: '',
-      endpoint: endpoint,
-      headers: {},
-      timeout: 5000,
-      retry: 3,
-      showStack: process.env.SHOW_STACK ? boolean(process.env.SHOW_STACK) : true,
-      meta: {
-        show: process.env.SHOW_META ? boolean(process.env.SHOW_META) : true,
-        showApp: process.env.SHOW_META_APP ? boolean(process.env.SHOW_META_APP) : false,
-        omittedFields: process.env.OMIT_META_FIELDS ? process.env.OMIT_META_FIELDS.split(',').map(function (s) {
-          return s.trim();
-        }) : []
-      },
+    let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const remappedFields = {};
+
+    if (process.env.AXE_REMAPPED_META_FIELDS) {
+      const arr = process.env.AXE_REMAPPED_META_FIELDS.split(',').map(v => v.split(':'));
+
+      for (const [prop, value] of arr) {
+        remappedFields[prop] = value;
+      }
+    }
+
+    this.config = mergeOptions({
+      showStack: process.env.AXE_SHOW_STACK ? boolean(process.env.AXE_SHOW_STACK) : true,
+      meta: Object.assign({
+        show: process.env.AXE_SHOW_META ? boolean(process.env.AXE_SHOW_META) : true,
+        remappedFields,
+        omittedFields: process.env.AXE_OMIT_META_FIELDS ? process.env.AXE_OMIT_META_FIELDS.split(',').map(s => s.trim()) : ['level', 'err', 'app', 'args'],
+        pickedFields: process.env.AXE_PICK_META_FIELDS ? process.env.AXE_PICK_META_FIELDS.split(',').map(s => s.trim()) : [],
+        cleanupRemapping: true
+      }, typeof config.meta === 'object' ? config.meta : {}),
+      version: pkg.version,
       silent: false,
       logger: console,
       name: false,
       level: 'info',
       levels: ['info', 'warn', 'error', 'fatal'],
-      // TODO: if user specifies `key` and it is `process.platform === 'browser' || process.browser || env === 'production'` then set `capture` to `true`
-      capture: false,
-      callback: false,
-      appInfo: process.env.APP_INFO ? boolean(process.env.APP_INFO) : true
-    }, config); // For backwards compatability
-
-    if (this.config.showMeta) {
-      this.config.meta.show = this.config.showMeta;
-      delete this.config.showMeta;
-    }
-
+      appInfo: process.env.AXE_APP_INFO ? boolean(process.env.AXE_APP_INFO) : true,
+      hooks: Object.assign({
+        pre: [],
+        post: []
+      }, typeof config.hooks === 'object' ? config.hooks : {})
+    }, config);
     this.appInfo = this.config.appInfo ? isFunction(parseAppInfo) ? parseAppInfo() : false : false;
     this.log = this.log.bind(this); // Inherit methods from parent logger
 
-    var methods = Object.keys(this.config.logger).filter(function (key) {
-      return !omittedLoggerKeys.has(key);
-    });
-
-    var _iterator = _createForOfIteratorHelper(methods),
-        _step;
+    const methods = Object.keys(this.config.logger).filter(key => !omittedLoggerKeys.has(key));
 
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var element = _step.value;
-        this[element] = this.config.logger[element];
-      } // Bind helper functions for each log level
+    for (const element of methods) {
+      this[element] = this.config.logger[element];
+    } // Bind helper functions for each log level
 
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
-    }
 
-    var _iterator2 = _createForOfIteratorHelper(levels),
-        _step2;
+    for (const element of levels) {
+      // Ensure function exists in logger passed
+      if (typeof this.config.logger[element] !== 'function') {
+        if (element === 'fatal') {
+          this.config.logger.fatal = this.config.logger.error || this.config.logger.info || this.config.logger.log;
+        } else {
+          this.config.logger[element] = this.config.logger.info || this.config.logger.log;
+        }
+      } // Bind log handler which normalizes args and populates meta
 
-    try {
-      var _loop = function _loop() {
-        var element = _step2.value;
 
-        _this[element] = function () {
-          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-            args[_key] = arguments[_key];
-          }
+      this[element] = function () {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
 
-          return _this.log.apply(_this, _toConsumableArray([element].concat(Array.prototype.slice.call(args))));
-        };
+        return _this.log(element, ...Array.prototype.slice.call(args));
       };
-
-      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-        _loop();
-      } // We could have used `auto-bind` but it's not compiled for browser
-
-    } catch (err) {
-      _iterator2.e(err);
-    } finally {
-      _iterator2.f();
     }
 
     this.setLevel = this.setLevel.bind(this);
     this.getNormalizedLevel = this.getNormalizedLevel.bind(this);
-    this.setName = this.setName.bind(this);
-    this.setCallback = this.setCallback.bind(this); // Set the logger name
+    this.setName = this.setName.bind(this); // Set the logger name
 
     if (this.config.name) this.setName(this.config.name); // Set the logger level
 
     this.setLevel(this.config.level); // Aliases
 
     this.err = this.error;
-    this.warning = this.warn;
+    this.warning = this.warn; // Pre and Post Hooks
+
+    this.pre = function (level, fn) {
+      this.config.hooks.pre.push(function (_level) {
+        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+          args[_key2 - 1] = arguments[_key2];
+        }
+
+        if (level !== _level) return [...args];
+        return fn(...args);
+      });
+    };
+
+    this.post = function (level, fn) {
+      this.config.hooks.post.push(function (_level) {
+        for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+          args[_key3 - 1] = arguments[_key3];
+        }
+
+        if (level !== _level) return [...args];
+        return fn(...args);
+      });
+    };
   }
 
-  _createClass(Axe, [{
-    key: "setCallback",
-    value: function setCallback(callback) {
-      this.config.callback = callback;
-    }
-  }, {
-    key: "setLevel",
-    value: function setLevel(level) {
-      if (!isString(level) || !levels.includes(level)) throw new Error(levelError); // Support signale logger and other loggers that use `logLevel`
+  setLevel(level) {
+    if (!isString(level) || levels.indexOf(level) === -1) throw new Error(levelError); // Support signale logger and other loggers that use `logLevel`
 
-      if (isString(this.config.logger.logLevel)) this.config.logger.logLevel = level;else this.config.logger.level = level; // Adjusts `this.config.levels` array
-      // so that it has all proceeding (inclusive)
+    if (isString(this.config.logger.logLevel)) this.config.logger.logLevel = level;else this.config.logger.level = level; // Adjusts `this.config.levels` array
+    // so that it has all proceeding (inclusive)
 
-      this.config.levels = levels.slice(levels.indexOf(level));
+    this.config.levels = levels.slice(levels.indexOf(level));
+  }
+
+  getNormalizedLevel(level) {
+    if (!isString(level)) return 'info';
+    if (isString(aliases[level])) return aliases[level];
+    if (levels.indexOf(level) === -1) return 'info';
+    return level;
+  }
+
+  setName(name) {
+    if (!isString(name)) throw new Error('`name` must be a String'); // Support signale logger and other loggers that use `scope`
+
+    if (isString(this.config.logger.scope)) this.config.logger.scope = name;else this.config.logger.name = name;
+  } // eslint-disable-next-line complexity
+
+
+  log(level, message, meta) {
+    const originalArgs = [];
+    const errors = [];
+    if (!isUndefined(level)) originalArgs.push(level);
+    if (!isUndefined(message)) originalArgs.push(message);
+    if (!isUndefined(meta)) originalArgs.push(meta);
+
+    for (var _len4 = arguments.length, args = new Array(_len4 > 3 ? _len4 - 3 : 0), _key4 = 3; _key4 < _len4; _key4++) {
+      args[_key4 - 3] = arguments[_key4];
     }
-  }, {
-    key: "getNormalizedLevel",
-    value: function getNormalizedLevel(level) {
-      if (!isString(level)) return 'info';
-      if (isString(aliases[level])) return aliases[level];
-      if (!levels.includes(level)) return 'info';
-      return level;
+
+    for (const arg of Array.prototype.slice.call(args)) {
+      originalArgs.push(arg);
     }
-  }, {
-    key: "setName",
-    value: function setName(name) {
-      if (!isString(name)) throw new Error('`name` must be a String'); // Support signale logger and other loggers that use `scope`
-
-      if (isString(this.config.logger.scope)) this.config.logger.scope = name;else this.config.logger.name = name;
-    } // eslint-disable-next-line complexity
-
-  }, {
-    key: "log",
-    value: function log(level, message, meta) {
-      var _this2 = this;
-
-      var originalArgs = [];
-      if (!isUndefined(level)) originalArgs.push(level);
-      if (!isUndefined(message)) originalArgs.push(message);
-      if (!isUndefined(meta)) originalArgs.push(meta);
-
-      for (var _len2 = arguments.length, args = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
-        args[_key2 - 3] = arguments[_key2];
+
+    const {
+      config
+    } = this;
+    let modifier = 0;
+
+    if (isString(level) && isString(aliases[level])) {
+      level = aliases[level];
+    } else if (isError(level)) {
+      meta = message;
+      message = level;
+      level = 'error';
+    } else if (!isString(level) || levels.indexOf(level) === -1) {
+      meta = message;
+      message = level;
+      level = this.getNormalizedLevel(level);
+      modifier = -1;
+    } // Return early if it is not a valid logging level
+
+
+    if (config.levels.indexOf(level) === -1) return; // Bunyan support (meta, message, ...args)
+
+    let isBunyan = false;
+
+    if ((isObject(message) || Array.isArray(message)) && isString(meta)) {
+      isBunyan = true;
+      const _meta = meta;
+      meta = message;
+      message = isString(_meta) && originalArgs.length >= 3 + modifier ? format(...originalArgs.slice(2 + modifier)) : _meta;
+    } // If message was undefined then set it to level
+
+
+    if (isUndefined(message)) message = level; // If only `message` was passed then if it was an Object
+    // preserve it as an Object by setting it as meta
+
+    if (originalArgs.slice(1 + modifier).length === 1 && !isString(message) && !isError(message)) {
+      meta = {
+        message
+      };
+      message = level;
+    } else if (!isBunyan && originalArgs.length >= 4 + modifier) {
+      message = undefined;
+      meta = {};
+      const messages = [];
+
+      for (const arg of originalArgs) {
+        if (isError(arg)) errors.push(arg);else if (isString(arg)) messages.push(arg);
       }
 
-      originalArgs = originalArgs.concat(Array.prototype.slice.call(args));
-      var config = this.config;
-      var modifier = 0;
-
-      if (isString(level) && isString(aliases[level])) {
-        level = aliases[level];
-      } else if (isError(level)) {
-        meta = message;
-        message = level;
-        level = 'error';
-      } else if (!isString(level) || !levels.includes(level)) {
-        meta = message;
-        message = level;
-        level = this.getNormalizedLevel(level);
-        modifier = -1;
-      } // Bunyan support (meta, message, ...args)
-
-
-      var isBunyan = false;
-
-      if ((isObject(message) || Array.isArray(message)) && isString(meta)) {
-        isBunyan = true;
-        var _meta = meta;
-        meta = message;
-        message = isString(_meta) && originalArgs.length >= 3 + modifier ? format.apply(void 0, _toConsumableArray(originalArgs.slice(2 + modifier))) : _meta;
-      } // If message was undefined then set it to level
-
-
-      if (isUndefined(message)) message = level; // If only `message` was passed then if it was an Object
-      // preserve it as an Object by setting it as meta
-
-      if (originalArgs.slice(1 + modifier).length === 1 && !isString(message) && !isError(message)) {
-        meta = {
-          message: message
-        };
-        message = level;
-      } else if (!isBunyan && originalArgs.length >= 4 + modifier) {
-        // If there are four or more args
-        // then infer to use util.format on everything
-        message = format.apply(void 0, _toConsumableArray(originalArgs.slice(1 + modifier)));
+      if (errors.length === 0 && messages.length > 0) message = format(...messages);else if (errors.length > 0 && level === 'log') level = 'error';
+    } else if (!isBunyan && originalArgs.length === 3 + modifier && isString(message) && formatSpecifiers.some(t => message.indexOf(t) !== -1)) {
+      // Otherwise if there are three args and if the `message` contains
+      // a placeholder token (e.g. '%s' or '%d' - see above `formatSpecifiers` variable)
+      // then we can infer that the `meta` arg passed is used for formatting
+      message = format(message, meta);
+      meta = {};
+    } else if (!isError(message)) {
+      if (isError(meta)) {
+        errors.push(meta);
         meta = {};
-      } else if (!isBunyan && originalArgs.length === 3 + modifier && isString(message) && formatSpecifiers.some(function (t) {
-        return message.includes(t);
-      })) {
-        // Otherwise if there are three args and if the `message` contains
-        // a placeholder token (e.g. '%s' or '%d' - see above `formatSpecifiers` variable)
-        // then we can infer that the `meta` arg passed is used for formatting
+      } else if (!isObject(meta) && !isUndefined(meta) && !isNull(meta)) {
+        // If the `meta` variable passed was not an Object then convert it
         message = format(message, meta);
         meta = {};
-      } else if (!isError(message)) {
-        if (isError(meta)) {
-          meta = {
-            err: parseErr(meta)
-          }; // } else if (!isPlainObject(meta) && !isUndefined(meta) && !isNull(meta)) {
-        } else if (!isObject(meta) && !isUndefined(meta) && !isNull(meta)) {
-          // If the `meta` variable passed was not an Object then convert it
-          message = format(message, meta);
-          meta = {};
-        } else if (!isString(message)) {
-          // If the message is not a string then we should run `util.format` on it
-          // assuming we're formatting it like it was another argument
-          // (as opposed to using something like fast-json-stringify)
-          message = format(message);
-        }
-      } // If (!isPlainObject(meta)) meta = {};
-
-
-      if (!isUndefined(meta) && !isObject(meta)) meta = {
-        meta: meta
-      };else if (!isObject(meta)) meta = {};
-      var error;
+      } else if (!isString(message)) {
+        // If the message is not a string then we should run `util.format` on it
+        // assuming we're formatting it like it was another argument
+        // (as opposed to using something like fast-json-stringify)
+        message = format(message);
+      }
+    } else if (isError(meta)) {
+      errors.push(meta); // handle additional args
 
-      if (isError(message)) {
-        error = message;
-        if (!isObject(meta.err)) meta.err = parseErr(error);
-        var _message = message;
-        message = _message.message;
-      } else if (isError(meta.err)) {
-        error = meta.err;
-      } // Omit `callback` from `meta` if it was passed
+      for (const arg of originalArgs.slice(2 + modifier)) {
+        // should skip this better with slice and modifier adjustment
+        if (meta === arg) continue;
+        if (isError(arg)) errors.push(arg);
+      }
 
+      meta = {};
+    }
 
-      var callback = isFunction(config.callback) && (!isBoolean(meta.callback) || meta.callback);
-      meta = omit(meta, ['callback']); // Set default level on meta
+    if (!isUndefined(meta) && !isObject(meta)) meta = {
+      original_meta: meta
+    };else if (!isObject(meta)) meta = {};
 
-      meta.level = level; // Add `app` object to metadata
+    if (isError(message)) {
+      errors.unshift(message);
+      message = undefined;
+    } //
+    // rewrite `meta.err` to `meta.original_err` for consistency
+    // (in case someone has an object with `.err` property on it with an error)
+    //
 
-      if (this.appInfo) meta.app = this.appInfo; // Set the body used for returning with and sending logs
-      // (and also remove circular references)
 
-      var body = safeStringify({
-        message: message,
-        meta: meta
-      }); // Send to Cabin or other logging service here the `message` and `meta`
+    if (isObject(meta.err)) {
+      if (isError(meta.err)) errors.push(meta.err);
+      meta.original_err = isError(meta.err) ? parseErr(meta.err) : meta.err;
+    }
 
-      if (config.capture && config.levels.includes(level) && (!isError(error) || !error._captureFailed)) {
-        // If the user didn't specify a key
-        // and they are using the default endpoint
-        // then we should throw an error to them
-        if (config.endpoint === endpoint && !config.key) throw new Error("Cabin API key required (e.g. `{ key: 'YOUR-CABIN-API-KEY' })`)\n<https://cabinjs.com>"); // Capture the log over HTTP
+    let err;
+
+    if (errors.length > 0) {
+      err = combine(errors);
+      meta.err = parseErr(err);
+      if (!isString(message)) message = err.message;
+    } // Set `args` prop with original arguments passed
+
+
+    meta.args = originalArgs; // Set default level on meta
+
+    meta.level = level; // Add `app` object to metadata
+
+    if (this.appInfo) meta.app = this.appInfo; //
+    // determine log method to use
+    //
+    // if we didn't pass a level as a method
+    // (e.g. console.info), then we should still
+    // use the logger's `log` method to output
+    //
+    // and fatal should use error (e.g. in browser)
+    //
+
+    const method = modifier === -1 ? 'log' : level; //
+    // NOTE: using lodash _.omit and _.pick would have been _very slow_
+    //
+    // const omittedAndPickedFields = {
+    //   ..._.omit(meta, this.config.meta.omittedFields),
+    //   ..._.pick(meta, this.config.meta.pickedFields)
+    // };
+    //
+    // also we don't want to mutate anything in `meta`
+    // and ideally we only want to pick exactly what we need
+    // (and not have two operations, one for omit, and one for pick)
+    //
+
+    if (!isEmpty(this.config.meta.remappedFields)) {
+      for (const key of Object.keys(this.config.meta.remappedFields)) {
+        set(meta, this.config.meta.remappedFields[key], get(meta, key));
+        unset(meta, key); // cleanup empty objects after remapping
+
+        if (this.config.meta.cleanupRemapping) {
+          const index = key.lastIndexOf('.');
+          if (index === -1) continue;
+          const parentKey = key.slice(0, index);
+          if (isEmpty(get(meta, parentKey))) unset(meta, parentKey);
+        }
+      }
+    }
 
-        var request = superagent.post(config.endpoint).set('X-Request-Id', cuid()).timeout(config.timeout);
-        if (!process.browser) request.set('User-Agent', "axe/".concat(pkg.version)); // Basic auth (e.g. Cabin API key)
+    if (!isEmpty(this.config.meta.omittedFields) || !isEmpty(this.config.meta.pickedFields)) {
+      const dotified = dotifyToArray(meta); // dotified = [
+      //   'err.name',
+      //   'err.message',
+      //   'err.stack',
+      //   'level',
+      //   'app.name',
+      //   'app.version',
+      //   'app.node',
+      //   'app.hash',
+      //   // ...
+      // ]
+
+      if (!isEmpty(this.config.meta.omittedFields)) {
+        for (const prop of this.config.meta.omittedFields) {
+          // <https://stackoverflow.com/a/9882349>
+          let i = dotified.length;
+
+          while (i--) {
+            if (dotified[i] === prop || dotified[i].indexOf(`${prop}.`) === 0) dotified.splice(i, 1);
+          }
+        }
+      }
 
-        if (config.key) request.auth(config.key); // Set headers if any
+      if (!isEmpty(this.config.meta.pickedFields)) {
+        for (const prop of this.config.meta.pickedFields) {
+          // response.headers.boop
+          // response.headers.beep
+          // response.body
+          // response.text
+          // response
+          //
+          // so we need to split by the first period and omit any keys from dotified starting with it
+          const index = prop.indexOf('.');
+          const key = prop.slice(0, index + 1);
 
-        if (!isEmpty(config.headers)) request.set(config.headers);
-        request.type('application/json').send(body).retry(config.retry).end(function (error_) {
-          if (error_) {
-            error_._captureFailed = true;
+          if (index !== -1) {
+            let i = dotified.length;
 
-            _this2.config.logger.error(error_);
-          }
-        });
-      } // Custom callback function (e.g. Slack message)
+            while (i--) {
+              if (dotified[i].indexOf(key) === 0) dotified.splice(i, 1);
+            }
+          } // finally add it if it did not already exist
 
 
-      if (callback) config.callback(level, message, meta); // Suppress logs if it was silent
+          if (dotified.indexOf(prop) === -1) dotified.push(prop);
+        }
+      } // now we call pick-deep using the final array
 
-      if (config.silent) return body; // Return early if it is not a valid logging level
 
-      if (!config.levels.includes(level)) return body; //
-      // determine log method to use
-      //
-      // if we didn't pass a level as a method
-      // (e.g. console.info), then we should still
-      // use the logger's `log` method to output
-      //
-      // and fatal should use error (e.g. in browser)
-      //
+      meta = pickDeep(meta, dotified);
+    } // pre-hooks
 
-      var method = level;
-      if (modifier === -1) method = 'log';else if (level === 'fatal') method = 'error'; // If there was meta information then output it
-      // setup ommitted fields
 
-      var omittedFields = ['level', 'err'].concat(this.config.meta.omittedFields); // Omit app is configured
+    for (const hook of this.config.hooks.pre) {
+      [err, message, meta] = hook(method, err, message, meta);
+    } // only invoke logger methods if it was not silent
 
-      if (!this.config.meta.showApp) omittedFields.push('app');
-      var omitted = omit(meta, omittedFields); // Show stack trace if necessary (along with any metadata)
 
-      if (method === 'error' && isError(error) && config.showStack) {
-        if (!config.meta.show || isEmpty(omitted)) this.config.logger.error(error);else this.config.logger.error(error, omitted);
-      } else if (!config.meta.show || isEmpty(omitted)) {
+    if (!config.silent) {
+      // Show stack trace if necessary (along with any metadata)
+      if (isError(err) && config.showStack) {
+        if (!config.meta.show || isEmpty(meta)) {
+          this.config.logger[method](err);
+        } else {
+          this.config.logger[method](err, meta);
+        }
+      } else if (!config.meta.show || isEmpty(meta)) {
         this.config.logger[method](message);
       } else {
-        this.config.logger[method](message, omitted);
-      } // Return the parsed body in case we need it
+        this.config.logger[method](message, meta);
+      }
+    } // post-hooks
 
 
-      return body;
-    }
-  }]);
+    pMapSeries(this.config.hooks.post, hook => hook(method, err, message, meta)).then().catch(err => {
+      this.config.logger.error(err);
+    });
+  }
 
-  return Axe;
-}();
+}
 
 module.exports = Axe;