axe 9.0.0 → 10.0.1

package/README.md

@@ -5,165 +5,490 @@
 [![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
 [![made with lass](https://img.shields.io/badge/made_with-lass-95CC28.svg)](https://github.com/lassjs/lass)
 [![license](https://img.shields.io/github/license/cabinjs/axe.svg)](LICENSE)
+[![npm downloads](https://img.shields.io/npm/dt/axe.svg)](https://npm.im/axe)
 
-> 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][].
+> 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][forward-email], [Lad][], and [Cabin][].
 
 
 ## Table of Contents
 
+* [Foreword](#foreword)
+* [Application Metadata and Information](#application-metadata-and-information)
 * [Install](#install)
   * [Node](#node)
   * [Browser](#browser)
-* [Approach](#approach)
-* [Application Information](#application-information)
 * [Usage](#usage)
+  * [Options](#options)
+  * [Supported Platforms](#supported-platforms)
   * [Node](#node-1)
   * [Browser](#browser-1)
   * [Custom logger](#custom-logger)
-  * [Custom endpoint](#custom-endpoint)
-  * [Suppress logs](#suppress-logs)
+  * [Silent Logging](#silent-logging)
   * [Stack Traces and Error Handling](#stack-traces-and-error-handling)
-* [Options](#options)
-  * [DEPRECATED](#deprecated)
-* [Aliases](#aliases)
-* [Methods](#methods)
-* [Send Logs To Slack](#send-logs-to-slack)
+  * [Hooks](#hooks)
+  * [Remapping](#remapping)
+  * [Omitting](#omitting)
+  * [Picking](#picking)
+  * [Aliases](#aliases)
+  * [Methods](#methods)
+* [Examples](#examples)
+  * [Send Logs to HTTP Endpoint](#send-logs-to-http-endpoint)
+  * [Send Logs to Slack](#send-logs-to-slack)
+  * [Suppress Logger Data](#suppress-logger-data)
 * [Contributors](#contributors)
-* [Trademark Notice](#trademark-notice)
 * [License](#license)
 
 
-## Install
+## Foreword
 
-### Node
+Axe was built to provide consistency among development teams when it comes to logging. You not only have to worry about your development team using the same approach to writing logs and debugging applications, but you also have to consider that open-source maintainers implement logging differently in their packages.
 
-[npm][]:
+There is no industry standard as to logging style, and developers mix and match arguments without consistency. For example, one developer may use the approach of `console.log('someVariable', someVariable)` and another developer will simply write `console.log(someVariable)`. Even if both developers wrote in the style of `console.log('someVariable', someVariable)`, there still could be an underlying third-party package that logs differently, or uses an entirely different approach. Furthermore, by default there is no consistency of logs with stdout or using any third-party hosted logging dashboard solution. It will also be almost impossible to spot logging outliers as it would be too time intensive.
 
-```sh
-npm install axe
-```
+No matter how your team or underlying packages style arguments when invoked with logger methods, Axe will clean it up and normalize it for you. This is especially helpful as you can see outliers much more easily in your logging dashboards, and pinpoint where in your application you need to do a better job of logging at. Axe makes your logs consistent and organized.
 
-### Browser
+Axe is highly configurable and has built-in functionality to remap, omit, and pick metadata fields with dot-notation support. Instead of using [slow functions](https://medium.com/nerd-for-tech/replacing-lodash-omit-using-object-restructuring-and-the-spread-syntax-d7af1607a390) like `lodash`'s `omit`, we use a more performant approach.
 
-See [Browser](#browser-1) usage below for more information.
-
-
-## Approach
-
-We adhere to the [Log4j][log4j] standard.  This means that you can use any [custom logger](#custom-logger) (or the default `console`), but we strictly support the following log levels:
+Axe adheres to the [Log4j][log4j] log levels, which have been established for 21+ years (since 2001). This means that you can use any [custom logger](#custom-logger) (or the default `console`), but we strictly support the following log levels:
 
 * `trace`
 * `debug`
 * `info`
 * `warn`
 * `error`
-* `fatal` (uses `error`)
+* `fatal`
+
+Axe normalizes invocation of logger methods to be called with *only* two arguments: a String or Error as the first argument and an Object as the second argument. These two arguments are referred to as "message" and "meta" respectively. For example, if you're simply logging a message and some other information:
+
+```js
+logger.info('Hello world', { beep: 'boop', foo: true });
+// Hello world { beep: 'boop', foo: true }
+```
+
+Or if you're logging a user, or a variable in general:
+
+```js
+logger.info('user', { user: { id: '1' } });
+// user { user: { id: '1' } }
+```
+
+```js
+logger.info('someVariable', { someVariable: true });
+// someVariable { someVariable: true }
+```
+
+You might write logs with three arguments `(level, message, meta)` using the `log` method of Axe's returned `logger` instance:
+
+```js
+logger.log('info', 'Hello world', { beep: 'boop', foo: true });
+// Hello world { beep: 'boop', foo: true }
+```
 
-We highly recommend that you follow this approach when logging `(message, meta)`:
+Logging errors is just the same as you might do now:
 
 ```js
-const message = 'Hello world';
-const meta = { beep: 'boop', foo: true };
-axe.info(message, meta);
+logger.error(new Error('Oops!'));
+
+// Error: Oops!
+//     at REPL3:1:14
+//     at Script.runInThisContext (node:vm:129:12)
+//     at REPLServer.defaultEval (node:repl:566:29)
+//     at bound (node:domain:421:15)
+//     at REPLServer.runBound [as eval] (node:domain:432:12)
+//     at REPLServer.onLine (node:repl:893:10)
+//     at REPLServer.emit (node:events:539:35)
+//     at REPLServer.emit (node:domain:475:12)
+//     at REPLServer.Interface._onLine (node:readline:487:10)
+//     at REPLServer.Interface._line (node:readline:864:8)
 ```
 
-You can also make logs with three arguments `(level, message, meta)`:
+You might log errors like this:
 
 ```js
-const level = 'info';
-const message = 'Hello world';
-const meta = { beep: 'boop', foo: true };
-axe.log(level, message, meta);
+logger.error(new Error('Oops!'), new Error('Another Error!'));
+
+// Error: Oops!
+//     at Object.<anonymous> (/Users/user/Projects/axe/test.js:5:14)
+//     at Module._compile (node:internal/modules/cjs/loader:1105:14)
+//     at Object.Module._extensions..js (node:internal/modules/cjs/loader:1159:10)
+//     at Module.load (node:internal/modules/cjs/loader:981:32)
+//     at Function.Module._load (node:internal/modules/cjs/loader:822:12)
+//     at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:77:12)
+//     at node:internal/main/run_main_module:17:47
+//
+// Error: Another Error!
+//     at Object.<anonymous> (/Users/user/Projects/axe/test.js:5:34)
+//     at Module._compile (node:internal/modules/cjs/loader:1105:14)
+//     at Object.Module._extensions..js (node:internal/modules/cjs/loader:1159:10)
+//     at Module.load (node:internal/modules/cjs/loader:981:32)
+//     at Function.Module._load (node:internal/modules/cjs/loader:822:12)
+//     at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:77:12)
+//     at node:internal/main/run_main_module:17:47
 ```
 
-You should also log errors like this:
+Or even multiple errors:
 
 ```js
-const err = new Error('Oops!');
-axe.error(err);
+logger.error(new Error('Oops!'), new Error('Another Error!'), new Error('Woah!'));
+
+// Error: Oops!
+//     at Object.<anonymous> (/Users/user/Projects/axe/test.js:6:3)
+//     at Module._compile (node:internal/modules/cjs/loader:1105:14)
+//     at Object.Module._extensions..js (node:internal/modules/cjs/loader:1159:10)
+//     at Module.load (node:internal/modules/cjs/loader:981:32)
+//     at Function.Module._load (node:internal/modules/cjs/loader:822:12)
+//     at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:77:12)
+//     at node:internal/main/run_main_module:17:47
+//
+// Error: Another Error!
+//     at Object.<anonymous> (/Users/user/Projects/axe/test.js:7:3)
+//     at Module._compile (node:internal/modules/cjs/loader:1105:14)
+//     at Object.Module._extensions..js (node:internal/modules/cjs/loader:1159:10)
+//     at Module.load (node:internal/modules/cjs/loader:981:32)
+//     at Function.Module._load (node:internal/modules/cjs/loader:822:12)
+//     at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:77:12)
+//     at node:internal/main/run_main_module:17:47
+//
+// Error: Woah!
+//     at Object.<anonymous> (/Users/user/Projects/axe/test.js:8:3)
+//     at Module._compile (node:internal/modules/cjs/loader:1105:14)
+//     at Object.Module._extensions..js (node:internal/modules/cjs/loader:1159:10)
+//     at Module.load (node:internal/modules/cjs/loader:981:32)
+//     at Function.Module._load (node:internal/modules/cjs/loader:822:12)
+//     at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:77:12)
+//     at node:internal/main/run_main_module:17:47
 ```
 
-**To recap:** The first argument `message` should be a String, and the second `meta` should be an optional Object.
+As you can see, Axe combines multiple errors into one – for an easy to read stack trace.
 
-If you simply use `axe.log`, then the log level used will be `info`, but it will still use the logger's native `log` method (as opposed to using `info`).
+If you simply use `logger.log`, then the log level used will be `info`, but it will still use the logger's native `log` method (as opposed to using `info`). If you invoke `logger.log` (or any other logging method, e.g. `logger.info`, `logger.warn`, or `logger.error`), then it will consistently invoke the internal logger with these two arguments.
 
-If you invoke `axe.log` (or any other logging method, e.g. `info`), then it will return a consistent value no matter the edge case.
+```js
+logger.log('hello world');
+// hello world
+```
 
-For example, if you log `axe.log('hello world')`, it will output with `console.log` (or your custom logger's `log` method) and `return` the Object:
+```js
+logger.info('hello world');
+// hello world
+```
 
 ```js
-{ message: 'hello world', meta: { level: 'info' } }
+logger.warn('uh oh!', { amount_spent: 50 });
+// uh oh! { amount_spent: 50 }
 ```
 
-And if you were to log `axe.info('hello world')`, it will output with `console.info` (or your custom logger's `info` method) and `return` the Object:
+As you can see - this is exactly what you'd want your logger output to look like. Axe doesn't change anything out of the ordinary. Now here is where Axe is handy - **it will automatically normalize argument style for you:**
+
+```js
+logger.warn({ hello: 'world' }, 'uh oh');
+// uh oh { hello: 'world' }
+```
+
+```js
+logger.warn('uh oh', 'foo bar', 'beep boop');
+// uh oh foo bar beep boop
+```
+
+```js
+logger.warn('hello', new Error('uh oh!'));
+
+// Error: uh oh!
+//     at Object.<anonymous> (/Users/user/Projects/axe/test.js:5:22)
+//     at Module._compile (node:internal/modules/cjs/loader:1105:14)
+//     at Object.Module._extensions..js (node:internal/modules/cjs/loader:1159:10)
+//     at Module.load (node:internal/modules/cjs/loader:981:32)
+//     at Function.Module._load (node:internal/modules/cjs/loader:822:12)
+//     at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:77:12)
+//     at node:internal/main/run_main_module:17:47
+```
 
 ```js
-{ message: 'hello world', meta: { level: 'info' } }
+logger.warn(new Error('uh oh!'), 'hello');
+
+// Error: uh oh!
+//     at Object.<anonymous> (/Users/user/Projects/axe/test.js:9:13)
+//     at Module._compile (node:internal/modules/cjs/loader:1105:14)
+//     at Object.Module._extensions..js (node:internal/modules/cjs/loader:1159:10)
+//     at Module.load (node:internal/modules/cjs/loader:981:32)
+//     at Function.Module._load (node:internal/modules/cjs/loader:822:12)
+//     at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:77:12)
+//     at node:internal/main/run_main_module:17:47
 ```
 
-Lastly if you were to log `axe.warn('uh oh!', { amount_spent: 50 })`, it will output with `console.warn` (or your custom logger's `warn` method) and `return` the Object:
+Axe has support for format specifiers, and you can even use format specifiers in the browser (uses [format-util][] – has limited number of format specifiers) and Node (uses the built-in [util.format][] method – supports all format specifiers). This feature is built-in thanks to smart detection using [format-specifiers][].
 
 ```js
-{ message: 'uh oh!', meta: { amount_spent: 50, level: 'warn' } }
+logger.info('favorite color is %s', 'blue');
+// favorite color is blue
 ```
 
-These returned values will be automatically sent to the endpoint (by default to your [Cabin][] account associated with your API key).
+As you can see, Axe makes your logs consistent in both Node and browser environments.
+
+Axe's goal is to allow you to log in any style, but make your log output more readable, organized, and clean.
+
+The **most impactful feature of Axe** is that it **makes logger output human-friendly and readable** when there are multiple errors.
+
+Normally `console` output (and most other loggers) by default will output the following unreadable stack trace:
+
+```sh
+> console.log(new Error('hello'), new Error('world'));
+Error: hello
+    at REPL6:1:13
+    at Script.runInThisContext (node:vm:129:12)
+    at REPLServer.defaultEval (node:repl:566:29)
+    at bound (node:domain:421:15)
+    at REPLServer.runBound [as eval] (node:domain:432:12)
+    at REPLServer.onLine (node:repl:893:10)
+    at REPLServer.emit (node:events:539:35)
+    at REPLServer.emit (node:domain:475:12)
+    at REPLServer.Interface._onLine (node:readline:487:10)
+    at REPLServer.Interface._line (node:readline:864:8) Error: world
+    at REPL6:1:33
+    at Script.runInThisContext (node:vm:129:12)
+    at REPLServer.defaultEval (node:repl:566:29)
+    at bound (node:domain:421:15)
+    at REPLServer.runBound [as eval] (node:domain:432:12)
+    at REPLServer.onLine (node:repl:893:10)
+    at REPLServer.emit (node:events:539:35)
+    at REPLServer.emit (node:domain:475:12)
+    at REPLServer.Interface._onLine (node:readline:487:10)
+    at REPLServer.Interface._line (node:readline:864:8)
+```
+
+However with Axe, errors and stack traces are much more readable (we use [maybe-combine-errors][] under the hood):
+
+```sh
+> logger.log(new Error('hello'), new Error('world'));
+Error: hello
+    at REPL7:1:12
+    at Script.runInThisContext (node:vm:129:12)
+    at REPLServer.defaultEval (node:repl:566:29)
+    at bound (node:domain:421:15)
+    at REPLServer.runBound [as eval] (node:domain:432:12)
+    at REPLServer.onLine (node:repl:893:10)
+    at REPLServer.emit (node:events:539:35)
+    at REPLServer.emit (node:domain:475:12)
+    at REPLServer.Interface._onLine (node:readline:487:10)
+    at REPLServer.Interface._line (node:readline:864:8)
+
+Error: world
+    at REPL7:1:32
+    at Script.runInThisContext (node:vm:129:12)
+    at REPLServer.defaultEval (node:repl:566:29)
+    at bound (node:domain:421:15)
+    at REPLServer.runBound [as eval] (node:domain:432:12)
+    at REPLServer.onLine (node:repl:893:10)
+    at REPLServer.emit (node:events:539:35)
+    at REPLServer.emit (node:domain:475:12)
+    at REPLServer.Interface._onLine (node:readline:487:10)
+    at REPLServer.Interface._line (node:readline:864:8)
+```
+
+Lastly, Axe works in both server-side and client-side environments (with Node and the browser).
+
 
-You can also use format specifiers in the browser (uses [format-util][] – has limited number of format specifiers) and Node (uses the built-in [util.format][] method – supports all format specifiers).  This feature is built-in thanks to smart detection using [format-specifiers][].
+## Application Metadata and Information
 
-**This consistency among server and browser environments is the beauty of Axe – and when used in combination with [Cabin][], your logs will be beautiful with HTTP request information, user metadata, IP address, User-Agent, and more!**
+If you've read the [Foreword](#foreword), you'll know that Axe invokes logger methods with two normalized arguments, `message` (String or Error) and `meta` (Object).
 
+Axe will automatically add the following metadata and information to the `meta` Object argument passed to logger methods:
 
-## Application Information
+| Property                  | Type   | Description                                                                                                                                                         |
+| ------------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `meta.args`               | Array  | The original arguments passed to the logger method when invoked. **Note that this is hidden by default via `meta.omittedFields` option**.                           |
+| `meta.level`              | String | The log level invoked (e.g. `"info"`).                                                                                                                              |
+| `meta.err`                | Object | Parsed error information using [parse-err][].                                                                                                                       |
+| `meta.original_err`       | Object | If and only if `meta.err` already existed, this field is preserved as `meta.original_err` on the metadata object.                                                   |
+| `meta.original_meta`      | Object | If and only if `meta` already existed as an argument and was not an Object (e.g. an Array), this field is preserved as `meta.original_meta` on the metadata object. |
+| `meta.app`                | Object | Application information parsed using [parse-app-info][]. **This is not added in Browser environments.** See below nested properties.                                |
+| `meta.app.name`           | String | Name of the app from `package.json`.                                                                                                                                |
+| `meta.app.version`        | String | Version of the app `package.json`.                                                                                                                                  |
+| `meta.app.node`           | String | Version if node.js running the app.                                                                                                                                 |
+| `meta.app.hash`           | String | The latest Git commit hash; not available when not in a Git repository or if there is no Git commit hash.                                                           |
+| `meta.app.tag`            | String | The latest Git tag; not available when not in a Git repository or if there is no Git tag.                                                                           |
+| `meta.app.environment`    | String | The value of `process.env.NODE_ENV`.                                                                                                                                |
+| `meta.app.hostname`       | String | Name of the computer.                                                                                                                                               |
+| `meta.app.pid`            | Number | Process ID as in `process.pid`.                                                                                                                                     |
+| `meta.app.cluster`        | Object | Node [cluster](https://nodejs.org/api/cluster.html) information.                                                                                                    |
+| `meta.app.os`             | Object | Node [os](https://nodejs.org/api/os.html) information.                                                                                                              |
+| `meta.app.worker_threads` | Object | Node [worker_threads](https://nodejs.org/api/worker_threads.html) information.                                                                                      |
 
-By default a `meta.app` property is populated in all logs for you using [parse-app-info][].
+:warning: **Note that by default,** **<u>Axe will not output this additional information for you</u>** (since we set the `meta.omittedFields` option to `[ 'level', 'err', 'app', 'args' ]` by default).
 
-At a glance, here are the properties that are automatically populated for you:
+Axe will omit from metadata all properties via the default Array from `meta.omittedFields` option (see [Options](#options) below for more insight).
 
-| Property    | Description                         |
-| ----------- | ----------------------------------- |
-| environment | The value of NODE_ENV               |
-| hostname    | Name of the computer                |
-| name        | Name of the app from `package.json` |
-| node        | Version if node.js running the app  |
-| pid         | Process ID as in `process.pid`      |
-| version     | Version of the app `package.json`   |
+If the argument "meta" is an empty object, then it will not be passed as an argument to logger methods \*ndash; because you don't want to see an empty `{}` polluting your log metadata. Axe keeps your log output tidy.
 
-Additional properties when the app is in a git repository
+If you set `meta.omittedFields` to an empty Array, or alternatively use the environment variable `AXE_OMIT_META_FIELDS=""`, then application information will be visible:
 
-| Property | Description                                                        |
-| -------- | ------------------------------------------------------------------ |
-| hash     | git hash of latest commit if the app                               |
-| tag      | the latest git tag. Property is not available when there is no tag |
+```js
+const Axe = require('axe');
+
+const logger = new Axe({
+  meta: {
+    omittedFields: []
+    // NOTE: the default is `[ 'level', 'err', 'app', 'args' ]`
+  }
+});
+
+// hello world {
+//   args: [ 'info', 'hello world' ],
+//   level: 'info',
+//   app: {
+//     name: 'axe',
+//     version: '10.0.0',
+//     node: 'v16.15.1',
+//     hash: '5ecd389b2523a8e810416f6c4e3ffa0ba6573dc2',
+//     tag: 'v10.0.0',
+//     environment: 'development',
+//     hostname: 'users-MacBook-Air.local',
+//     pid: 3477,
+//     cluster: { isMaster: true, isWorker: false, schedulingPolicy: 2 },
+//     os: {
+//       arch: 'arm64',
+//       cpus: [Array],
+//       endianness: 'LE',
+//       freemem: 271433728,
+//       priority: 0,
+//       homedir: '/Users/user',
+//       hostname: 'users-MacBook-Air.local',
+//       loadavg: [Array],
+//       network_interfaces: [Object],
+//       platform: 'darwin',
+//       release: '21.3.0',
+//       tmpdir: '/var/folders/rl/gz_3j8fx4s98k2kb0hknfygm0000gn/T',
+//       totalmem: 17179869184,
+//       type: 'Darwin',
+//       uptime: 708340,
+//       user: [Object],
+//       version: 'Darwin Kernel Version 21.3.0: Wed Dec  8 00:40:46 PST 2021; root:xnu-8019.80.11.111.1~1/RELEASE_ARM64_T8101'
+//     },
+//     worker_threads: {
+//       isMainThread: true,
+//       resourceLimits: {},
+//       threadId: 0,
+//       workerData: null
+//     }
+//   }
+// }
+```
+
+We recommend that you set `meta.omittedFields` to an empty Array in production environments for verbosity.
+
+Note that you can also combine `meta.omittedFields` with `meta.pickedFields` and `meta.remappedFields` (in case you want to output specific properties from `meta.app` and exclude others – see [Options](#options) for more insight).
+
+
+## Install
+
+### Node
+
+[npm][]:
+
+```sh
+npm install axe
+```
+
+### Browser
+
+See [Browser](#browser-1) usage below for more information.
 
 
 ## Usage
 
-We highly recommend to simply use [Cabin][] as this package is built-in!
+### Options
+
+| Property                | Type              | Default Value                     | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |   |
+| ----------------------- | ----------------- | --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
+| `showStack`             | Boolean           | `true`                            | Attempts to parse a boolean value from `process.env.AXE_SHOW_STACK`). **If this value is `true`, then if `message` is an instance of an Error, it will be invoked as the first argument to logger methods. If this is `false`, then only the `err.message` will be invoked as the first argument to logger methods.** Basically if `true` it will call `logger.method(err)` and if `false` it will call `logger.method(err.message)`. If you pass `err` as the first argument to a logger method, then it will show the stack trace via `err.stack` typically. |   |
+| `meta`                  | Object            | See below                         | Stores all meta config information (see the following nested properties below).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |   |
+| `meta.show`             | Boolean           | `true`                            | Attempts to parse a boolean value from `process.env.AXE_SHOW_META` – meaning you can pass a flag `AXE_SHOW_META=true node app.js` when needed for debugging), whether or not to output metadata to logger methods. If set to `false`, then fields will not be omitted nor picked; the entire meta object will be hidden from logger output.                                                                                                                                                                                                                    |   |
+| `meta.remappedFields`   | Object            | `{}`                              | Attempts to parse an Object mapping from `process.env.AXE_REMAPPED_META_FIELDS` (`,` and `:` delimited, e.g. `REMAPPED_META_FIELDS=foo:bar,beep.boop:beepBoop` to remap `meta.foo` to `meta.bar` and `meta.beep.boop` to `meta.beepBoop`). Note that this will clean up empty objects by default unless you set the option `meta.cleanupRemapping` to `false`). Supports dot-notation.                                                                                                                                                                         |   |
+| `meta.omittedFields`    | Array             | `['level','err','app', 'args']`   | Attempts to parse an array value from `process.env.AXE_OMIT_META_FIELDS` (`,` delimited) - meaning you can pass a flag `OMIT_META_FIELDS=user,id node app.js`), determining which fields to omit in the metadata passed to logger methods. Supports dot-notation.                                                                                                                                                                                                                                                                                              |   |
+| `meta.pickedFields`     | Array             | `[]`                              | Attempts to parse an array value from `process.env.AXE_PICK_META_FIELDS` (`,` delimited) - meaning you can pass a flag, e.g. `PICK_META_FIELDS=request.headers,response.headers node app.js` which would pick from `meta.request` and `meta.response` *only* `meta.request.headers` and `meta.response.headers`), **This takes precedence after fields are omitted, which means this acts as a whitelist.** Supports dot-notation.                                                                                                                             |   |
+| `meta.cleanupRemapping` | Boolean           | `true`                            | Whether or not to cleanup empty objects after remapping operations are completed)                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |   |
+| `silent`                | Boolean           | `false`                           | Whether or not to invoke logger methods. Pre and post hooks will still run even if this option is set to `false`.                                                                                                                                                                                                                                                                                                                                                                                                                                              |   |
+| `logger`                | Object            | `console`                         | Defaults to `console` with [console-polyfill][] added automatically, though **you can bring your own logger**. See [custom logger](#custom-logger) – you can pass an instance of `pino`, `signale`, `winston`, `bunyan`, etc.                                                                                                                                                                                                                                                                                                                                  |   |
+| `name`                  | String or Boolean | `false`                           | The default name for the logger (defaults to `false`, which does not set `logger.name`). If you wish to pass a name such as `os.hostname()`, then set `name: os.hostname()` – this is useful if you are using a logger like `pino` which prefixes log output with the name set here.                                                                                                                                                                                                                                                                           |   |
+| `level`                 | String            | `"info"`                          | The default level of logging to invoke `logger` methods for (defaults to `info`, which includes all logs including info and higher in severity (e.g. `info`, `warn`, `error`, `fatal`)                                                                                                                                                                                                                                                                                                                                                                         |   |
+| `levels`                | Array             | `['info','warn','error','fatal']` | An Array of logging levels to support. You usually shouldn't change this unless you want to prevent logger methods from being invoked or prevent hooks from being run for a certain log level. If an invalid log level is attempted to be invoked, and if it is not in this Array, then no hooks and no logger methods will be invoked.                                                                                                                                                                                                                        |   |
+| `appInfo`               | Boolean           | `true`                            | Attempts to parse a boolean value from `process.env.AXE_APP_INFO`) - whether or not to parse application information (using [parse-app-info][]).                                                                                                                                                                                                                                                                                                                                                                                                               |   |
+
+### Supported Platforms
+
+* Node: v14+
+* Browsers (see [.browserslistrc](.browserslistrc)):
+
+  ```sh
+  npx browserslist
+  ```
+
+  ```sh
+  and_chr 102
+  and_ff 101
+  and_qq 10.4
+  and_uc 12.12
+  android 101
+  chrome 103
+  chrome 102
+  chrome 101
+  chrome 100
+  edge 103
+  edge 102
+  edge 101
+  firefox 101
+  firefox 100
+  firefox 91
+  ios_saf 15.5
+  ios_saf 15.4
+  ios_saf 15.2-15.3
+  ios_saf 15.0-15.1
+  ios_saf 14.5-14.8
+  ios_saf 14.0-14.4
+  ios_saf 12.2-12.5
+  kaios 2.5
+  op_mini all
+  op_mob 64
+  opera 86
+  opera 85
+  safari 15.5
+  safari 15.4
+  samsung 17.0
+  samsung 16.0
+  ```
 
 ### Node
 
 ```js
 const Axe = require('axe');
 
-const axe = new Axe({ key: 'YOUR-CABIN-API-KEY' });
+const logger = new Axe();
 
-axe.info('hello world');
+logger.info('hello world');
 ```
 
 ### Browser
 
+This package requires Promise support, therefore you will need to polyfill if you are using an unsupported browser (namely Opera mini).
+
+**We no longer support IE as of Axe v10.0.0+.**
+
 #### VanillaJS
 
-**The browser-ready bundle is only 36 KB (minified and gzipped)**.
+**The browser-ready bundle is only 18 KB when minified and 6 KB when gzipped**.
 
 ```html
-<script src="https://polyfill.io/v3/polyfill.min.js?features=WeakRef,BigInt"></script>
+<script src="https://polyfill.io/v3/polyfill.min.js?features=Promise"></script>
 <script src="https://unpkg.com/axe"></script>
 <script type="text/javascript">
-  (function() {
-    var Axe = new Axe({ key: 'YOUR-CABIN-API-KEY' });
-    axe.info('hello world');
+  (function () {
+    // make a new logger instance
+    const logger = new Axe();
+    logger.info('hello world');
+
+    // or you can override console everywhere
+    console = new Axe();
+    console.info('hello world');
   });
 </script>
 ```
@@ -173,11 +498,10 @@ axe.info('hello world');
 We recommend using <https://polyfill.io> (specifically with the bundle mentioned in [VanillaJS](#vanillajs) above):
 
 ```html
-<script src="https://polyfill.io/v3/polyfill.min.js?features=WeakRef,BigInt"></script>
+<script src="https://polyfill.io/v3/polyfill.min.js?features=Promise"></script>
 ```
 
-* WeakRef is not supported in Opera 85, iOS Safari 12.2-12.5
-* BigInt is not supported in iOS Safari 12.2-12.5
+* Promise is not supported in op\_mini all
 
 #### Bundler
 
@@ -204,9 +528,9 @@ Loggers supported include, but are not limited to:
 const signale = require('signale');
 const Axe = require('axe');
 
-const axe = new Axe({ logger: signale, key: 'YOUR-CABIN-API-KEY' });
+const logger = new Axe({ logger: signale });
 
-axe.info('hello world');
+logger.info('hello world');
 ```
 
 In [Lad][], we have an approach similar to the following, where non-production environments use [consola][], and production environments use [pino][].
@@ -239,79 +563,260 @@ const logger = new Axe({
 logger.info('hello world');
 ```
 
-### Custom endpoint
+### Silent Logging
+
+Silent logging is useful when you need to disable logging in certain environments for privacy reasons or to simply clean up output on stdout.
+
+For example when you're running tests you can set `logger.config.silent = true`.
+
+```js
+const Axe = require('axe');
+
+const logger = new Axe({ silent: true });
+
+logger.info('hello world');
+```
+
+### Stack Traces and Error Handling
+
+Please see Cabin's documentation for [stack traces and error handling](https://github.com/cabinjs/cabin#stack-traces-and-error-handling) for more information.
+
+> If you're not using `cabin`, you can simply replace instances of the word `cabin` with `axe` in the documentation examples linked above.
+
+### Hooks
+
+You can add synchronous "pre" hooks and/or asynchronous/synchronous "post" hooks with Axe. Both pre and post hooks accept four arguments (`level`, `err`, `message`, and `meta`). Pre hooks are required to be synchronous.
 
-By default we built-in support such that if you provide your [Cabin][] API key, then your logs will be uploaded automatically for you in both server and browser environments.
+Both pre and post hooks execute serially – and while pre hooks are blocking, post-hooks will run in the background after logger methods are invoked (you can have a post hook that's a Promise or async function).
 
-If you decide to [self-host your own Cabin API][cabin-api] (or roll your own logging service) then you can specify your own endpoint under `config.endpoint`.
+Pre hooks require an Array to be returned of `[ err, message, meta ]`.
 
-See [Options](#options) below for more information.
+Pre hooks allow you to manipulate the arguments `err`, `message`, and `meta` that are passed to the internal logger methods. This is useful for masking sensitive data or doing additional custom logic before writing logs.
 
-### Suppress logs
+Post hooks are useful if you want to send logging information to a third-party, store them into a database, or do any sort of custom processing.
 
-This is useful when you want need logging turned off in certain environments.
+You should properly handle any errors in your pre hooks, otherwise they will be thrown and logger methods will not be invoked.
 
-For example when you're running tests you can set `axe.config.silent = true`.
+We will catch errors for post hooks by default and log them as errors with your logger methods' `logger.error` method).
+
+Hooks can be defined in the options passed to an instance of Axe, e.g. `new Axe({ hooks: { pre: [ fn ], post: [ fn ] } });` and/or with the method `logger.pre(level, fn)` or `logger.post(level, fn)`. Here are a few examples below:
 
 ```js
 const Axe = require('axe');
 
-const axe = new Axe({ silent: true, key: 'YOUR-CABIN-API-KEY' });
+const logger = new Axe({
+  hooks: {
+    pre: [
+      function (level, err, message, meta) {
+        message = message.replace(/world/gi, 'planet earth');
+        return [err, message, meta];
+      }
+    ]
+  }
+});
 
-axe.info('hello world');
+logger.info('hello world');
+
+// hello planet earth
 ```
 
-### Stack Traces and Error Handling
+```js
+const Axe = require('axe');
 
-Please see Cabin's documentation for [stack traces and error handling](https://github.com/cabinjs/cabin#stack-traces-and-error-handling) for more information.
+const logger = new Axe();
 
-> If you're not using `cabin`, you can simply replace instances of the word `cabin` with `axe` in the documentation examples linked above.
+logger.pre('error', (err, message, meta) => {
+  if (err instanceof Error) err.is_beep_boop = true;
+  return [err, message, meta];
+});
+
+logger.error(new Error('oops'));
+
+// Error: oops
+//     at Object.<anonymous> (/Users/user/Projects/axe/test.js:39:14)
+//     at Module._compile (node:internal/modules/cjs/loader:1105:14)
+//     at Object.Module._extensions..js (node:internal/modules/cjs/loader:1159:10)
+//     at Module.load (node:internal/modules/cjs/loader:981:32)
+//     at Function.Module._load (node:internal/modules/cjs/loader:822:12)
+//     at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:77:12)
+//     at node:internal/main/run_main_module:17:47 {
+//   is_beep_boop: true
+// }
+```
+
+For more examples of hooks, see our below sections on [Send Logs to HTTP Endpoint](#send-logs-to-http-endpoint), [Send Logs to Slack](#send-logs-to-slack)), and [Suppress Logger Data](#suppress-logger-data) below.
+
+### Remapping
+
+If you would like to remap fields, such as `response.headers` to `responseHeaders`, then you can use environment variables or pass an object with configuration mapping.
+
+```js
+const logger = new Axe({
+  meta: {
+    remappedFields: {
+      'response.headers': 'responseHeaders'
+    }
+  }
+});
+
+logger.info('foo bar', {
+  response: {
+    headers: {
+      'X-Hello-World': true
+    }
+  }
+});
+
+// foo bar { responseHeaders: { 'X-Hello-World': true } }
+```
+
+### Omitting
+
+If you would like to omit fields, such as `response.headers` from a response, so you are only left with the status code:
 
+```js
+const logger = new Axe({
+  meta: {
+    omittedFields: ['level', 'err', 'app', 'args', 'response.headers']
+  }
+});
 
-## Options
+logger.info('foo bar', {
+  response: {
+    status: 200,
+    headers: {
+      'X-Hello-World': true
+    }
+  }
+});
 
-* `key` (String) - defaults to an empty string, so BasicAuth is not used – **this is your Cabin API key**, which you can get for free at [Cabin][] (note you could provide your own API key here if you are self-hosting or rolling your own logging service)
-* `endpoint` (String) - defaults to `https://api.cabinjs.com`
-* `headers` (Object) - HTTP headers to send along with log to the `endpoint`
-* `timeout` (Number) - defaults to `5000`, number of milliseconds to wait for a response
-* `retry` (Number) - defaults to `3`, number of attempts to retry sending log over HTTP
-* `showStack` (Boolean) - defaults to `true` (attempts to parse a boolean value from `process.env.SHOW_STACK`) - whether or not to output a stack trace
-* `meta` (Object) - stores all meta config information
-  * `show` (Boolean) - defaults to `true` (attempts to parse a boolean value from `process.env.SHOW_META` – meaning you can pass a flag `SHOW_META=true node app.js` when needed for debugging), whether or not to output metadata to logger methods.
-  * `showApp` (Boolean) - defaults to `false` (attempts to parse a boolean value from `process.env.SHOW_META_APP` – meaning you can pass a flag `SHOW_META_APP=true node app.js` when needed for debugging), whether or not to output `appInfo` in the metadata to logger methods.
-  * `omittedFields` (Array) - defaults to `[]` (attempts to parse an array value from `process.env.OMIT_META_FIELDS` (`,` delimited) - meaning you can pass a flag `OMIT_META_FIELDS=user,id node app.js`), determining which fields to omit in the metadata passed to logger methods.
-* `silent` (Boolean) - defaults to `false`, whether or not to suppress log output to console
-* `logger` (Object) - defaults to `console` (with [console-polyfill][] added automatically), but you may wish to use a [custom logger](#custom-logger)
-* `name` (String) - the default name for the logger (defaults to `false`, which does not set `logger.name`).  If you wish to pass a name such as `os.hostname()`, then set `name: os.hostname()` – this is useful if you are using a logger like `pino` which prefixes log output with the name set here.
-* `level` (String) - the default level of logging to capture (defaults to `info`, which includes all logs including info and higher in severity (e.g. `info`, `warn`, `error`, `fatal`)
-* `capture` (Boolean) - defaults to `false`, whether or not to `POST` logs to the `endpoint` (takes into consideration the `config.level` to only send valid capture levels)
-* `callback` (Function) - defaults to `false`, but if it is a `Function`, then it will be called with `callback(level, message, meta)` – this is super useful for [sending messages to Slack when errors occur (see below)](#send-logs-to-slack).  Note that if you specify `{ callback: false }` in the meta object when logging, it will prevent the callback function from being invoked (e.g. `axe.error(new Error('Slack callback failed'), { callback: false })` ‐ see below example).  The `callback` property is always purged from `meta` object for sanity.
-* `appInfo` (Boolean) - defaults to `true` (attempts to parse a boolean value from `process.env.APP_INFO`) - whether or not to parse application information (using [parse-app-info][]).
+// foo bar { response: { status: 200 } }
+```
+
+### Picking
+
+If you would like to pick certain fields, such as `response.status` from a response:
 
-### DEPRECATED
+```js
+const logger = new Axe({
+  meta: {
+    pickedFields: [ 'response.status' ]
+  }
+});
 
-* `showMeta` (Boolean) - defaults to `true` (attempts to parse a boolean value from `process.env.SHOW_META` – meaning you can pass a flag `SHOW_META=true node app.js` when needed for debugging), whether or not to output metadata to logger methods.
-  * This will be automatically assigned to `meta.show` when passed as part of config.
+logger.info('foo bar', {
+  response: {
+    status: 200,
+    headers: {
+      'X-Hello-World': true
+    }
+  }
+});
 
+// foo bar { response: { status: 200 } }
+```
 
-## Aliases
+### Aliases
 
 We have provided helper/safety aliases for `logger.warn` and `logger.error` of `logger.warning` and `logger.err` respectively.
 
+### Methods
+
+A few extra methods are available, which were inspired by [Slack's logger][slack-logger] and added for compatibility:
+
+* `logger.setLevel(level)` - sets the log `level` (String) severity to invoke `logger` methods for (must be valid enumerable level)
+* `logger.getNormalizedLevel(level)` - gets the normalized log `level` (String) severity (normalizes to known logger levels, e.g. "warning" => "warn", "err" => "error", "log" => "info")
+* `logger.setName(name)` - sets the `name` (String) property (some loggers like `pino` will prefix logs with the name set here)
 
-## Methods
 
-Two extra methods are available, which were inspired by [Slack's logger][slack-logger] and added for compatibility:
+## Examples
 
-* `axe.setLevel(level)` - sets the log `level` (String) severity to capture (must be valid enumerable level)
-* `axe.getNormalizedLevel(level)` - gets the normalized log `level` (String) severity (normalizes to known logger levels, e.g. "warning" => "warn", "err" => "error", "log" => "info")
-* `axe.setName(name)` - sets the `name` (String) property (some loggers like `pino` will prefix logs with the name set here)
-* `axe.setCallback(callback)` - sets the `callback` (Function) property (see `callback` option above and [Slack example below](#send-logs-to-slack)
+### Send Logs to HTTP Endpoint
 
+This is an example of using hooks to send a POST request to an HTTP endpoint with logs of the "fatal" and "error" levels that occur in your application:
 
-## Send Logs To Slack
+We recommend [superagent](https://github.com/visionmedia/superagent), however there are plenty of alternatives such as [axios](https://github.com/axios/axios) and [ky](https://github.com/sindresorhus/ky).
 
-This is just an example of using the `callback` option to send a message to Slack with errors that occur in your application:
+1. You will need to install the `superagent`, `cuid`, and `fast-safe-stringify` packages:
+
+   ```sh
+   npm install superagent cuid fast-safe-stringify
+   ```
+
+2. Implementation example is provided below:
+
+   ```js
+   const os = require('os');
+
+   const Axe = require('axe');
+   const superagent = require('superagent');
+   const cuid = require('cuid');
+   const safeStringify = require('fast-safe-stringify');
+
+   // create our application logger that uses hooks
+   const logger = new Axe({
+     logger: console, // optional (e.g. pino, signale, consola),
+     level: 'info', // optional (defaults to info)
+     name: process.env.HOSTNAME || os.hostname() // optional
+   });
+
+   async function hook(next, message, meta) {
+     //
+     // return early if we wish to ignore this
+     // (this prevents recursion; see end of this fn)
+     //
+     if (meta.ignore_emit) return next();
+
+     try {
+       //
+       // set the body used in the HTTP request to be consistent object with
+       // two properties sent in the payload of `message` and `meta`
+       // (and also remove circular references)
+       //
+       const body = safeStringify({ message, meta });
+
+       //
+       // send to Cabin or your own custom endpoint here
+       // https://cabinjs.com
+       //
+       const request = superagent
+         .post('https://api.cabinjs.com')
+         .set('X-Request-Id', cuid()) // normalize server/browser request id formatting
+         .timeout(5000);
+
+       request.set('User-Agent', `axe/${logger.version}`);
+
+       // add basic auth header (e.g. if you use Cabin)
+       // if (config.key) request.auth('INSERT-YOUR-KEY');
+
+       // set any additional headers if necessary
+       // request.set({ ... });
+
+       const response = await request
+         .type('application/json')
+         .retry(3)
+         .send(body);
+
+       logger.info('log sent over HTTP', { response });
+     } catch (err) {
+       logger.fatal(err, { ignore_emit: true });
+     }
+
+     // move along to the next hook
+     next();
+   }
+
+   // bind custom hooks for "fatal" and "error" log levels
+   logger.post('error', hook);
+   logger.post('fatal', hook);
+
+   // test out the HTTP integration
+   logger.error(new Error('Uh oh something went wrong!'));
+   ```
+
+### Send Logs to Slack
+
+This is an example of using hooks to send a message to Slack with logs of the "fatal" and "error" levels that occur in your application:
 
 1. You will need to install the `@slack/web-api` package locally:
 
@@ -327,58 +832,37 @@ This is just an example of using the `callback` option to send a message to Slac
 
    ```js
    const os = require('os');
+
    const Axe = require('axe');
    const { WebClient } = require('@slack/web-api');
-   const signale = require('signale');
-   const pino = require('pino')({
-     customLevels: {
-       log: 30
-     },
-     hooks: {
-       // <https://github.com/pinojs/pino/blob/master/docs/api.md#logmethod>
-       logMethod(inputArgs, method) {
-         return method.call(this, {
-           // <https://github.com/pinojs/pino/issues/854>
-           // message: inputArgs[0],
-           msg: inputArgs[0],
-           meta: inputArgs[1]
-         });
-       }
-     }
-   });
-
-   const isProduction = process.env.NODE_ENV === 'production';
-
-   const config = {
-     logger: isProduction ? pino : signale,
-     level: isProduction ? 'warn' : 'info',
-     name: process.env.HOSTNAME || os.hostname()
-   };
 
-   // custom logger for Slack that inherits our Axe config
-   // (with the exception of a `callback` function for logging to Slack)
-   const slackLogger = new Axe(config);
+   // create our application logger that uses hooks
+   const logger = new Axe({
+     logger: console, // optional (e.g. pino, signale, consola)
+     level: 'info', // optional (defaults to info)
+     name: process.env.HOSTNAME || os.hostname() // optional
+   });
 
    // create an instance of the Slack Web Client API for posting messages
    const web = new WebClient('INSERT-YOUR-TOKEN', {
      // <https://slack.dev/node-slack-sdk/web-api#logging>
-     logger: slackLogger,
-     logLevel: config.level
+     logger,
+     logLevel: logger.config.level
    });
 
-   // create our application logger that uses a custom callback function
-   const axe = new Axe({ ...config });
+   async function hook(next, message, meta) {
+     //
+     // return early if we wish to ignore this
+     // (this prevents recursion; see end of this fn)
+     //
+     if (meta.ignore_emit) return next();
 
-   axe.setCallback(async (level, message, meta) => {
+     // otherwise post a message to the slack channel
      try {
-       // if it was not an error then return early
-       if (!['error','fatal'].includes(level)) return;
-
-       // otherwise post a message to the slack channel
        const result = await web.chat.postMessage({
-         channel: 'general',
-         username: 'Cabin',
-         icon_emoji: ':evergreen_tree:',
+         channel: 'monitoring',
+         username: 'Axe',
+         icon_emoji: ':axe:',
          attachments: [
            {
              title: meta.err && meta.err.message ? meta.err.message : message,
@@ -411,29 +895,86 @@ This is just an example of using the `callback` option to send a message to Slac
        });
 
        // finally log the result from slack
-       axe.info('web.chat.postMessage', { result, callback: false });
+       logger.info('slack message sent', { result });
      } catch (err) {
-       axe.error(err, { callback: false });
+       logger.fatal(err, { ignore_emit: true });
      }
-   });
 
-   axe.error(new Error('Uh oh something went wrong!'));
+     // move along to the next hook
+     next();
+   }
+
+   // bind custom hooks for "fatal" and "error" log levels
+   logger.post('error', hook);
+   logger.post('fatal', hook);
+
+   // test out the slack integration
+   logger.error(new Error('Uh oh something went wrong!'));
    ```
 
+### Suppress Logger Data
 
-## Contributors
+This is an example of using a custom hook to manipulate logger arguments to suppress sensitive data.
 
-| Name             | Website                   |
-| ---------------- | ------------------------- |
-| **Nick Baugh**   | <http://niftylettuce.com> |
-| **Alexis Tyler** | <https://wvvw.me/>        |
+```js
+const Axe = require('.');
+
+const logger = new Axe();
+
+for (const level of logger.config.levels) {
+  const fn = logger.config.logger[level];
+  logger.config.logger[level] = function (message, meta) {
+    // replace any messages "beep" -> "boop"
+    if (typeof message === 'string') message = message.replace(/beep/g, 'boop');
+
+    // mask the property "beep" in the meta object "data"
+    if (meta?.data?.beep)
+      meta.data.beep = Array.from({ length: meta.data.beep.length })
+        .fill('*')
+        .join('');
 
+    return Reflect.apply(fn, this, [message, meta]);
+  };
+}
 
-## Trademark Notice
+logger.warn('hello world beep');
 
-Axe, Lad, Lass, and their respective logos are trademarks of Niftylettuce LLC.
-These trademarks may not be reproduced, distributed, transmitted, or otherwise used, except with the prior written permission of Niftylettuce LLC.
-If you are seeking permission to use these trademarks, then please [contact us](mailto:niftylettuce@gmail.com).
+// hello world boop
+
+logger.info('start', {
+  data: {
+    foo: 'bar',
+    beep: 'boop' // <--- we're suppressing "beep" -> "****"
+  }
+});
+
+// start { data: { foo: 'bar', beep: '****' } }
+
+logger.error(new Error('oops!'), {
+  data: {
+    beep: 'beep-boop-beep' // this becomes "**************"
+  }
+});
+
+// Error: oops!
+//     at Object.<anonymous> (/Users/user/Projects/axe/test.js:30:14)
+//     at Module._compile (node:internal/modules/cjs/loader:1105:14)
+//     at Object.Module._extensions..js (node:internal/modules/cjs/loader:1159:10)
+//     at Module.load (node:internal/modules/cjs/loader:981:32)
+//     at Function.Module._load (node:internal/modules/cjs/loader:822:12)
+//     at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:77:12)
+//     at node:internal/main/run_main_module:17:47 { data: { beep: '**************' } }
+```
+
+
+## Contributors
+
+| Name               | Website                           |
+| ------------------ | --------------------------------- |
+| **Nick Baugh**     | <http://niftylettuce.com>         |
+| **Alexis Tyler**   | <https://wvvw.me/>                |
+| **shadowgate15**   | <https://github.com/shadowgate15> |
+| **Spencer Snyder** | <https://spencersnyder.io>        |
 
 
 ## License
@@ -457,8 +998,6 @@ If you are seeking permission to use these trademarks, then please [contact us](
 
 [signale]: https://github.com/klauscfhq/signale
 
-[high-console]: https://github.com/tusharf5/high-console
-
 [pino]: https://github.com/pinojs/pino
 
 [winston]: https://github.com/winstonjs/winston
@@ -467,11 +1006,9 @@ If you are seeking permission to use these trademarks, then please [contact us](
 
 [console-polyfill]: https://github.com/paulmillr/console-polyfill
 
-[cabin-api]: https://github.com/cabinjs/api.cabinjs.com
-
 [consola]: https://github.com/nuxt/consola
 
-[log4j]: https://en.wikipedia.org/wiki/Log4
+[log4j]: https://en.wikipedia.org/wiki/Log4j#Log4j_log_levels
 
 [parse-app-info]: https://github.com/cabinjs/parse-app-info
 
@@ -481,4 +1018,12 @@ If you are seeking permission to use these trademarks, then please [contact us](
 
 [util.format]: https://nodejs.org/api/util.html#util_util_format_format_args
 
-[format-specifiers]: https://github.com/niftylettuce/format-specifiers
+[format-specifiers]: https://github.com/cabinjs/format-specifiers
+
+[forward-email]: https://forwardemail.net
+
+[high-console]: https://github.com/tusharf5/high-console
+
+[maybe-combine-errors]: https://github.com/vweevers/maybe-combine-errors
+
+[parse-err]: https://github.com/cabinjs/parse-err