axe 9.0.0 → 10.0.0

package/lib/index.js

@@ -3,23 +3,29 @@
 // eslint-disable-next-line import/no-unassigned-import
 require('console-polyfill');
 
-const cuid = require('cuid');
+const combine = require('maybe-combine-errors');
 
 const format = require('@ladjs/format-util');
 
 const formatSpecifiers = require('format-specifiers');
 
+const get = require('@strikeentco/get');
+
 const isError = require('iserror');
 
-const omit = require('lodash.omit');
+const mergeOptions = require('merge-options');
+
+const pMapSeries = require('p-map-series');
 
 const parseAppInfo = require('parse-app-info');
 
 const parseErr = require('parse-err');
 
-const safeStringify = require('fast-safe-stringify');
+const pickDeep = require('pick-deep');
+
+const set = require('@strikeentco/set');
 
-const superagent = require('superagent');
+const unset = require('unset-value');
 
 const {
   boolean
@@ -33,8 +39,39 @@ const aliases = {
   warning: 'warn',
   err: 'error'
 };
-const endpoint = 'https://api.cabinjs.com';
-const levelError = "`level` invalid, must be: ".concat(levels.join(', ')); // <https://stackoverflow.com/a/43233163>
+const levelError = `\`level\` invalid, must be: ${levels.join(', ')}`; // <https://github.com/sindresorhus/is-plain-obj/blob/main/index.js>
+
+function isPlainObject(value) {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+
+  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>
+
+
+function dotifyToArray(obj) {
+  const res = [];
+
+  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)) {
+
+      if (isPlainObject(value)) {
+        recurse(value, newKey); // it's a nested object, so do it again
+      } else {
+        res.push(newKey);
+      }
+    }
+  }
+
+  recurse(obj);
+  return res;
+} // <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;
@@ -60,43 +97,42 @@ function isFunction(value) {
   return typeof value === 'function';
 }
 
-function isBoolean(value) {
-  return typeof value === 'boolean';
-}
-
 class Axe {
   constructor() {
     var _this = this;
 
     let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    this.config = Object.assign({
-      key: '',
-      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(s => s.trim()) : []
-      },
+    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
 
@@ -108,6 +144,16 @@ class Axe {
 
 
     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
+
+
       this[element] = function () {
         for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
           args[_key] = arguments[_key];
@@ -115,28 +161,44 @@ class Axe {
 
         return _this.log(element, ...Array.prototype.slice.call(args));
       };
-    } // We could have used `auto-bind` but it's not compiled for browser
-
+    }
 
     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
 
-  setCallback(callback) {
-    this.config.callback = callback;
+    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);
+      });
+    };
   }
 
   setLevel(level) {
-    if (!isString(level) || !levels.includes(level)) throw new Error(levelError); // Support signale logger and other loggers that use `logLevel`
+    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)
@@ -147,7 +209,7 @@ class Axe {
   getNormalizedLevel(level) {
     if (!isString(level)) return 'info';
     if (isString(aliases[level])) return aliases[level];
-    if (!levels.includes(level)) return 'info';
+    if (levels.indexOf(level) === -1) return 'info';
     return level;
   }
 
@@ -160,12 +222,13 @@ class Axe {
 
   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 _len2 = arguments.length, args = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
-      args[_key2 - 3] = arguments[_key2];
+    for (var _len4 = arguments.length, args = new Array(_len4 > 3 ? _len4 - 3 : 0), _key4 = 3; _key4 < _len4; _key4++) {
+      args[_key4 - 3] = arguments[_key4];
     }
 
     for (const arg of Array.prototype.slice.call(args)) {
@@ -183,13 +246,15 @@ class Axe {
       meta = message;
       message = level;
       level = 'error';
-    } else if (!isString(level) || !levels.includes(level)) {
+    } else if (!isString(level) || levels.indexOf(level) === -1) {
       meta = message;
       message = level;
       level = this.getNormalizedLevel(level);
       modifier = -1;
-    } // Bunyan support (meta, message, ...args)
+    } // 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;
 
@@ -210,11 +275,16 @@ class Axe {
       };
       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(...originalArgs.slice(1 + modifier));
+      message = undefined;
       meta = {};
-    } else if (!isBunyan && originalArgs.length === 3 + modifier && isString(message) && formatSpecifiers.some(t => message.includes(t))) {
+      const messages = [];
+
+      for (const arg of originalArgs) {
+        if (isError(arg)) errors.push(arg);else if (isString(arg)) messages.push(arg);
+      }
+
+      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
@@ -222,9 +292,8 @@ class Axe {
       meta = {};
     } else if (!isError(message)) {
       if (isError(meta)) {
-        meta = {
-          err: parseErr(meta)
-        }; // } else if (!isPlainObject(meta) && !isUndefined(meta) && !isNull(meta)) {
+        errors.push(meta);
+        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);
@@ -235,65 +304,50 @@ class Axe {
         // (as opposed to using something like fast-json-stringify)
         message = format(message);
       }
-    } // If (!isPlainObject(meta)) meta = {};
+    } else if (isError(meta)) {
+      errors.push(meta); // handle additional args
 
+      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 = {};
+    }
 
     if (!isUndefined(meta) && !isObject(meta)) meta = {
-      meta
+      original_meta: meta
     };else if (!isObject(meta)) meta = {};
-    const hadErrorInMeta = isObject(meta.err);
-    let error;
 
     if (isError(message)) {
-      error = message;
-      if (!hadErrorInMeta) meta.err = parseErr(error);
-      ({
-        message
-      } = message);
-    } else if (isError(meta.err)) {
-      error = meta.err;
-    } // Omit `callback` from `meta` if it was passed
-
-
-    const callback = isFunction(config.callback) && (!isBoolean(meta.callback) || meta.callback);
-    meta = omit(meta, ['callback']); // Set default level on meta
-
-    meta.level = level; // Add `app` object to metadata
-
-    if (this.appInfo) meta.app = this.appInfo; // Set the body used for returning with and sending logs
-    // (and also remove circular references)
-
-    const body = safeStringify({
-      message,
-      meta
-    }); // Send to Cabin or other logging service here the `message` and `meta`
+      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 (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
 
-      const 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 (isObject(meta.err)) {
+      if (isError(meta.err)) errors.push(meta.err);
+      meta.original_err = isError(meta.err) ? parseErr(meta.err) : meta.err;
+    }
 
-      if (config.key) request.auth(config.key); // Set headers if any
+    let err;
 
-      if (!isEmpty(config.headers)) request.set(config.headers);
-      request.type('application/json').send(body).retry(config.retry).end(error_ => {
-        if (error_) {
-          error_._captureFailed = true;
-          this.config.logger.error(error_);
-        }
-      });
-    } // Custom callback function (e.g. Slack message)
+    if (errors.length > 0) {
+      err = combine(errors);
+      meta.err = parseErr(err);
+      if (!isString(message)) message = err.message;
+    } // Set `args` prop with original arguments passed
 
 
-    if (callback) config.callback(level, message, meta); // Suppress logs if it was silent
+    meta.args = originalArgs; // Set default level on meta
 
-    if (config.silent) return body; // Return early if it is not a valid logging level
+    meta.level = level; // Add `app` object to metadata
 
-    if (!config.levels.includes(level)) return body; //
+    if (this.appInfo) meta.app = this.appInfo; //
     // determine log method to use
     //
     // if we didn't pass a level as a method
@@ -303,27 +357,111 @@ class Axe {
     // and fatal should use error (e.g. in browser)
     //
 
-    let method = level;
-    if (modifier === -1) method = 'log';else if (level === 'fatal') method = 'error'; // If there was meta information then output it
-    // setup ommitted fields
+    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);
+        }
+      }
+    }
+
+    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 (!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);
 
-    const omittedFields = [...this.config.meta.omittedFields];
-    omittedFields.push('level');
-    if (!hadErrorInMeta) omittedFields.push('err'); // Omit app is configured
+          if (index !== -1) {
+            let i = dotified.length;
 
-    if (!this.config.meta.showApp) omittedFields.push('app');
-    const omitted = omit(meta, omittedFields); // Show stack trace if necessary (along with any metadata)
+            while (i--) {
+              if (dotified[i].indexOf(key) === 0) dotified.splice(i, 1);
+            }
+          } // finally add it if it did not already exist
 
-    if (isError(error) && config.showStack) {
-      if (!config.meta.show || isEmpty(omitted)) this.config.logger[method](error);else this.config.logger[method](error, omitted);
-    } else if (!config.meta.show || isEmpty(omitted)) {
-      this.config.logger[method](message);
-    } else {
-      this.config.logger[method](message, omitted);
-    } // Return the parsed body in case we need it
+
+          if (dotified.indexOf(prop) === -1) dotified.push(prop);
+        }
+      } // now we call pick-deep using the final array
+
+
+      meta = pickDeep(meta, dotified);
+    } // pre-hooks
+
+
+    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 (!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, meta);
+      }
+    } // post-hooks
 
 
-    return body;
+    pMapSeries(this.config.hooks.post, hook => hook(method, err, message, meta)).then().catch(err => {
+      this.config.logger.error(err);
+    });
   }
 
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "axe",
-  "description": "Logging add-on to send logs over HTTP to your server in Node and Browser environments. Works with any logger! Chop up your logs consistently! Made for Cabin and Lad.",
-  "version": "9.0.0",
+  "description": "Axe is a logger-agnostic wrapper that normalizes logs regardless of argument style. Great for large development teams, old and new projects, and works with Pino, Bunyan, Winston, console, and more. It is lightweight, performant, highly-configurable, and automatically adds OS, CPU, and Git information to your logs. It supports hooks (useful for masking sensitive data) and dot-notation remapping, omitting, and picking of log metadata properties. Made for Forward Email, Lad, and Cabin.",
+  "version": "10.0.0",
   "author": "Nick Baugh <niftylettuce@gmail.com> (http://niftylettuce.com)",
   "browser": {
     "parse-app-info": false
@@ -11,20 +11,25 @@
   },
   "contributors": [
     "Nick Baugh <niftylettuce@gmail.com> (http://niftylettuce.com)",
-    "Alexis Tyler <xo@wvvw.me> (https://wvvw.me/)"
+    "Alexis Tyler <xo@wvvw.me> (https://wvvw.me/)",
+    "shadowgate15 (https://github.com/shadowgate15)",
+    "Spencer Snyder <sasnyde2@gmail.com> (https://spencersnyder.io)"
   ],
   "dependencies": {
     "@ladjs/format-util": "^1.0.4",
-    "boolean": "^3.2.0",
-    "console-polyfill": "^0.3.0",
-    "cuid": "^2.1.8",
-    "fast-safe-stringify": "^2.1.1",
+    "@strikeentco/get": "1.0.1",
+    "@strikeentco/set": "1.0.2",
+    "boolean": "3.2.0",
+    "console-polyfill": "0.3.0",
     "format-specifiers": "^1.0.0",
-    "iserror": "^0.0.2",
-    "lodash.omit": "^4.5.0",
+    "iserror": "0.0.2",
+    "maybe-combine-errors": "1.0.0",
+    "merge-options": "3.0.4",
+    "p-map-series": "2",
     "parse-app-info": "^4.0.3",
     "parse-err": "^0.0.12",
-    "superagent": "^8.0.0"
+    "pick-deep": "1.0.0",
+    "unset-value": "2.0.1"
   },
   "devDependencies": {
     "@babel/cli": "^7.17.10",
@@ -111,16 +116,16 @@
   },
   "scripts": {
     "ava": "cross-env NODE_ENV=test ava",
-    "browserify": "browserify src/index.js -o dist/axe.js -s Axe -g [ babelify --configFile ./.dist.babelrc ]",
+    "browserify": "browserify src/index.js -o dist/axe.js -s Axe -g [ babelify --configFile ./.dist.babelrc.json ]",
     "build": "npm run build:clean && npm run build:lib && npm run build:dist",
     "build:clean": "rimraf lib dist",
     "build:dist": "npm run browserify && npm run minify",
-    "build:lib": "babel --config-file ./.lib.babelrc src --out-dir lib",
+    "build:lib": "babel --config-file ./.lib.babelrc.json src --out-dir lib",
     "lint": "xo --fix && remark . -qfo && fixpack",
     "lint-build": "npm run lint-lib && npm run lint-dist",
-    "lint-dist": "eslint --no-inline-config -c .dist.eslintrc dist",
-    "lint-lib": "eslint --no-inline-config -c .lib.eslintrc lib",
-    "minify": "cross-env NODE_ENV=production browserify src/index.js -o dist/axe.min.js -s Axe -g [ babelify --configFile ./.dist.babelrc ] -p tinyify",
+    "lint-dist": "eslint --no-inline-config -c .dist.eslintrc.json dist",
+    "lint-lib": "eslint --no-inline-config -c .lib.eslintrc.json lib",
+    "minify": "cross-env NODE_ENV=production browserify src/index.js -o dist/axe.min.js -s Axe -g [ babelify --configFile ./.dist.babelrc.json ] -p tinyify",
     "nyc": "cross-env NODE_ENV=test nyc ava",
     "prepare": "husky install",
     "pretest": "npm run lint",