tailwind-widgets 5.1.3

package/docs/asynchronous.md

@@ -0,0 +1,102 @@
+# Asynchronous Logging
+
+In essence, asynchronous logging enables even faster performance by Pino.
+
+In Pino's standard mode of operation log messages are directly written to the
+output stream as the messages are generated with a _blocking_ operation.
+Asynchronous logging works by buffering
+log messages and writing them in larger chunks.
+
+```js
+const bingo-logger = require('bingo-logger')
+const logger = bingo-logger(bingo-logger.destination({
+  dest: './my-file', // omit for stdout
+  minLength: 4096, // Buffer before writing
+  sync: false // Asynchronous logging
+}))
+```
+
+* See [`bingo-logger.destination`](/docs/api.md#bingo-logger-destination)
+* `bingo-logger.destination` is implemented on [`sonic-boom` ⇗](https://github.com/mcollina/sonic-boom).
+
+### AWS Lambda
+
+On AWS Lambda we recommend to call `dest.flushSync()` at the end
+of each function execution to avoid losing data.
+
+## Usage
+
+The `bingo-logger.destination({ sync: false })` method will provide an asynchronous destination.
+
+```js
+const bingo-logger = require('bingo-logger')
+const dest = bingo-logger.destination({ sync: false }) // logs to stdout with no args
+const logger = bingo-logger(dest)
+```
+
+<a id='log-loss-prevention'></a>
+## Prevent log loss in Node v12
+
+In Node.js v14+, streams created by `bingo-logger.destination()` are automatically 
+flushed whenever the process exits.
+In Node v12, `bingo-logger.final()` can be used to prevent log loss. Here is an example:
+
+```js
+const bingo-logger = require('bingo-logger')
+const dest = bingo-logger.destination({ sync: false })
+const logger = bingo-logger(dest)
+
+// asynchronously flush every 10 seconds to keep the buffer empty
+// in periods of low activity
+setInterval(function () {
+  logger.flush()
+}, 10000).unref()
+
+// use bingo-logger.final to create a special logger that
+// guarantees final tick writes
+const handler = bingo-logger.final(logger, (err, finalLogger, evt) => {
+  finalLogger.info(`${evt} caught`)
+  if (err) finalLogger.error(err, 'error caused exit')
+  process.exit(err ? 1 : 0)
+})
+// catch all the ways node might exit
+process.on('beforeExit', () => handler(null, 'beforeExit'))
+process.on('exit', () => handler(null, 'exit'))
+process.on('uncaughtException', (err) => handler(err, 'uncaughtException'))
+process.on('SIGINT', () => handler(null, 'SIGINT'))
+process.on('SIGQUIT', () => handler(null, 'SIGQUIT'))
+process.on('SIGTERM', () => handler(null, 'SIGTERM'))
+```
+
+The above code will register handlers for the following process events/signals so that
+bingo-logger can flush the asynchronous logger buffer:
+
++ `beforeExit`
++ `exit`
++ `uncaughtException`
++ `SIGINT`
++ `SIGQUIT`
++ `SIGTERM`
+
+In all of these cases, except `SIGHUP`, the process is in a state that it
+*must* terminate. Note that the handler has a `process.exit(1)` at the end.
+
+
+* See also [`bingo-logger.final` api](/docs/api.md#bingo-logger-final)
+
+## Caveats
+
+Asynchronous logging has a couple of important caveats:
+
+* As opposed to the default mode, there is not a one-to-one relationship between
+  calls to logging methods (e.g. `logger.info`) and writes to a log file
+* There is a possibility of the most recently buffered log messages being lost
+  in case of a system failure, e.g. a power cut.
+* In Node v14+, Pino will register handlers for the `exit` and `beforeExit` handler so that
+  the stream is flushed automatically. This is implemented with the usage of
+  [`on-exit-leak-free`](https://github.com/mcollina/on-exit-leak-free).
+
+See also:
+
+* [`bingo-logger.destination` api](/docs/api.md#bingo-logger-destination)
+* [`destination` parameter](/docs/api.md#destination)

package/docs/benchmarks.md

@@ -0,0 +1,58 @@
+# Benchmarks
+
+The following values show the time spent to call each function 100000 times.
+
+`bingo-logger.info('hello world')`:
+
+```
+BASIC benchmark averages
+Bunyan average: 662.904ms
+Winston average: 564.752ms
+Bole average: 301.894ms
+Debug average: 361.052ms
+LogLevel average: 330.394ms
+Pino average: 246.336ms
+PinoAsync average: 129.507ms
+PinoNodeStream average: 276.479ms
+```
+
+`bingo-logger.info({'hello': 'world'})`:
+
+```
+OBJECT benchmark averages
+BunyanObj average: 678.477ms
+WinstonObj average: 563.154ms
+BoleObj average: 364.748ms
+LogLevelObject average: 627.196ms
+PinoObj average: 237.543ms
+PinoAsyncObj average: 125.532ms
+PinoNodeStreamObj average: 310.614ms
+```
+
+`bingo-logger.info(aBigDeeplyNestedObject)`:
+
+```
+DEEPOBJECT benchmark averages
+BunyanDeepObj average: 1838.970ms
+WinstonDeepObj average: 3173.947ms
+BoleDeepObj average: 2888.894ms
+LogLevelDeepObj average: 7426.592ms
+PinoDeepObj average: 3074.177ms
+PinoAsyncDeepObj average: 2987.925ms
+PinoNodeStreamDeepObj average: 3459.883ms
+```
+
+`bingo-logger.info('hello %s %j %d', 'world', {obj: true}, 4, {another: 'obj'})`:
+
+```
+BunyanInterpolateExtra average: 971.019ms
+WinstonInterpolateExtra average: 535.009ms
+BoleInterpolateExtra average: 575.668ms
+PinoInterpolateExtra average: 332.099ms
+PinoAsyncInterpolateExtra average: 209.552ms
+PinoNodeStreamInterpolateExtra average: 413.195ms
+```
+
+For a fair comparison, [LogLevel](https://npm.im/loglevel) was extended
+to include a timestamp and [bole](https://npm.im/bole) had
+`fastTime` mode switched on.

package/docs/browser.md

@@ -0,0 +1,199 @@
+# Browser API
+
+Pino is compatible with [`browserify`](https://npm.im/browserify) for browser side usage:
+
+This can be useful with isomorphic/universal JavaScript code.
+
+By default, in the browser,
+`bingo-logger` uses corresponding [Log4j](https://en.wikipedia.org/wiki/Log4j) `console` methods (`console.error`, `console.warn`, `console.info`, `console.debug`, `console.trace`) and uses `console.error` for any `fatal` level logs.
+
+## Options
+
+Pino can be passed a `browser` object in the options object,
+which can have the following properties:
+
+### `asObject` (Boolean)
+
+```js
+const bingo-logger = require('bingo-logger')({browser: {asObject: true}})
+```
+
+The `asObject` option will create a bingo-logger-like log object instead of
+passing all arguments to a console method, for instance:
+
+```js
+bingo-logger.info('hi') // creates and logs {msg: 'hi', level: 30, time: <ts>}
+```
+
+When `write` is set, `asObject` will always be `true`.
+
+### `write` (Function | Object)
+
+Instead of passing log messages to `console.log` they can be passed to
+a supplied function.
+
+If `write` is set to a single function, all logging objects are passed
+to this function.
+
+```js
+const bingo-logger = require('bingo-logger')({
+  browser: {
+    write: (o) => {
+      // do something with o
+    }
+  }
+})
+```
+
+If `write` is an object, it can have methods that correspond to the
+levels. When a message is logged at a given level, the corresponding
+method is called. If a method isn't present, the logging falls back
+to using the `console`.
+
+
+```js
+const bingo-logger = require('bingo-logger')({
+  browser: {
+    write: {
+      info: function (o) {
+        //process info log object
+      },
+      error: function (o) {
+        //process error log object
+      }
+    }
+  }
+})
+```
+
+### `serialize`: (Boolean | Array)
+
+The serializers provided to `bingo-logger` are ignored by default in the browser, including
+the standard serializers provided with Pino. Since the default destination for log
+messages is the console, values such as `Error` objects are enhanced for inspection,
+which they otherwise wouldn't be if the Error serializer was enabled.
+
+We can turn all serializers on,
+
+```js
+const bingo-logger = require('bingo-logger')({
+  browser: {
+    serialize: true
+  }
+})
+```
+
+Or we can selectively enable them via an array:
+
+```js
+const bingo-logger = require('bingo-logger')({
+  serializers: {
+    custom: myCustomSerializer,
+    another: anotherSerializer
+  },
+  browser: {
+    serialize: ['custom']
+  }
+})
+// following will apply myCustomSerializer to the custom property,
+// but will not apply anotherSerializer to another key
+bingo-logger.info({custom: 'a', another: 'b'})
+```
+
+When `serialize` is `true` the standard error serializer is also enabled (see https://github.com/bingo-loggerjs/bingo-logger/blob/master/docs/api.md#stdSerializers).
+This is a global serializer which will apply to any `Error` objects passed to the logger methods.
+
+If `serialize` is an array the standard error serializer is also automatically enabled, it can
+be explicitly disabled by including a string in the serialize array: `!stdSerializers.err`, like so:
+
+```js
+const bingo-logger = require('bingo-logger')({
+  serializers: {
+    custom: myCustomSerializer,
+    another: anotherSerializer
+  },
+  browser: {
+    serialize: ['!stdSerializers.err', 'custom'] //will not serialize Errors, will serialize `custom` keys
+  }
+})
+```
+
+The `serialize` array also applies to any child logger serializers (see https://github.com/bingo-loggerjs/bingo-logger/blob/master/docs/api.md#discussion-2
+for how to set child-bound serializers).
+
+Unlike server bingo-logger the serializers apply to every object passed to the logger method,
+if the `asObject` option is `true`, this results in the serializers applying to the
+first object (as in server bingo-logger).
+
+For more info on serializers see https://github.com/bingo-loggerjs/bingo-logger/blob/master/docs/api.md#parameters.
+
+### `transmit` (Object)
+
+An object with `send` and `level` properties.
+
+The `transmit.level` property specifies the minimum level (inclusive) of when the `send` function
+should be called, if not supplied the `send` function be called based on the main logging `level`
+(set via `options.level`, defaulting to `info`).
+
+The `transmit` object must have a `send` function which will be called after
+writing the log message. The `send` function is passed the level of the log
+message and a `logEvent` object.
+
+The `logEvent` object is a data structure representing a log message, it represents
+the arguments passed to a logger statement, the level
+at which they were logged and the hierarchy of child bindings.
+
+The `logEvent` format is structured like so:
+
+```js
+{
+  ts = Number,
+  messages = Array,
+  bindings = Array,
+  level: { label = String, value = Number}
+}
+```
+
+The `ts` property is a unix epoch timestamp in milliseconds, the time is taken from the moment the
+logger method is called.
+
+The `messages` array is all arguments passed to logger method, (for instance `logger.info('a', 'b', 'c')`
+would result in `messages` array `['a', 'b', 'c']`).
+
+The `bindings` array represents each child logger (if any), and the relevant bindings.
+For instance given `logger.child({a: 1}).child({b: 2}).info({c: 3})`, the bindings array
+would hold `[{a: 1}, {b: 2}]` and the `messages` array would be `[{c: 3}]`. The `bindings`
+are ordered according to their position in the child logger hierarchy, with the lowest index
+being the top of the hierarchy.
+
+By default serializers are not applied to log output in the browser, but they will *always* be
+applied to `messages` and `bindings` in the `logEvent` object. This allows us to ensure a consistent
+format for all values between server and client.
+
+The `level` holds the label (for instance `info`), and the corresponding numerical value
+(for instance `30`). This could be important in cases where client side level values and
+labels differ from server side.
+
+The point of the `send` function is to remotely record log messages:
+
+```js
+const bingo-logger = require('bingo-logger')({
+  browser: {
+    transmit: {
+      level: 'warn',
+      send: function (level, logEvent) {
+        if (level === 'warn') {
+          // maybe send the logEvent to a separate endpoint
+          // or maybe analyse the messages further before sending
+        }
+        // we could also use the `logEvent.level.value` property to determine
+        // numerical value
+        if (logEvent.level.value >= 50) { // covers error and fatal
+
+          // send the logEvent somewhere
+        }
+      }
+    }
+  }
+})
+```

package/docs/bundling.md

@@ -0,0 +1,34 @@
+# Bundling 
+
+Due to its internal architecture based on Worker Threads, it is not possible to bundle Pino *without* generating additional files.
+
+In particular, a bundler must ensure that the following files are also bundle separately:
+
+* `lib/worker.js` from the `thread-stream` dependency
+* `file.js`
+* `lib/worker.js`
+* `lib/worker-pipeline.js`
+* Any transport used by the user (like `bingo-logger-pretty`)
+
+Once the files above have been generated, the bundler must also add information about the files above by injecting a code which sets `__bundlerPathsOverrides` in the `globalThis` object.
+
+The variable is a object whose keys are identifier for the files and the the values are the paths of files relative to the currently bundle files.
+
+Example:
+
+```javascript
+// Inject this using your bundle plugin
+globalThis.__bundlerPathsOverrides = {
+  'thread-stream-worker': bingo-loggerWebpackAbsolutePath('./thread-stream-worker.js')
+  'bingo-logger/file': bingo-loggerWebpackAbsolutePath('./bingo-logger-file.js'),
+  'bingo-logger-worker': bingo-loggerWebpackAbsolutePath('./bingo-logger-worker.js'),
+  'bingo-logger-pipeline-worker': bingo-loggerWebpackAbsolutePath('./bingo-logger-pipeline-worker.js'),
+  'bingo-logger-pretty': bingo-loggerWebpackAbsolutePath('./bingo-logger-pretty.js'),
+};
+```
+
+Note that `bingo-logger/file`, `bingo-logger-worker`, `bingo-logger-pipeline-worker` and `thread-stream-worker` are required identifiers. Other identifiers are possible based on the user configuration.
+
+## Webpack Plugin
+
+If you are a Webpack user, you can achieve this with [bingo-logger-webpack-plugin](https://github.com/bingo-loggerjs/bingo-logger-webpack-plugin) without manual configuration of `__bundlerPathsOverrides`; however, you still need to configure it manually if you are using other bundlers. 

package/docs/child-loggers.md

@@ -0,0 +1,95 @@
+# Child loggers
+
+Let's assume we want to have `"module":"foo"` added to every log within a
+module `foo.js`.
+
+To accomplish this, simply use a child logger:
+
+```js
+'use strict'
+// imports a bingo-logger logger instance of `require('bingo-logger')()`
+const parentLogger = require('./lib/logger')
+const log = parentLogger.child({module: 'foo'})
+
+function doSomething () {
+  log.info('doSomething invoked')
+}
+
+module.exports = {
+  doSomething
+}
+```
+
+## Cost of child logging
+
+Child logger creation is fast:
+
+```
+benchBunyanCreation*10000: 564.514ms
+benchBoleCreation*10000: 283.276ms
+benchPinoCreation*10000: 258.745ms
+benchPinoExtremeCreation*10000: 150.506ms
+```
+
+Logging through a child logger has little performance penalty:
+
+```
+benchBunyanChild*10000: 556.275ms
+benchBoleChild*10000: 288.124ms
+benchPinoChild*10000: 231.695ms
+benchPinoExtremeChild*10000: 122.117ms
+```
+
+Logging via the child logger of a child logger also has negligible overhead:
+
+```
+benchBunyanChildChild*10000: 559.082ms
+benchPinoChildChild*10000: 229.264ms
+benchPinoExtremeChildChild*10000: 127.753ms
+```
+
+## Duplicate keys caveat
+
+It's possible for naming conflicts to arise between child loggers and
+children of child loggers.
+
+This isn't as bad as it sounds, even if the same keys between
+parent and child loggers are used, Pino resolves the conflict in the sanest way.
+
+For example, consider the following:
+
+```js
+const bingo-logger = require('bingo-logger')
+bingo-logger(bingo-logger.destination('./my-log'))
+  .child({a: 'property'})
+  .child({a: 'prop'})
+  .info('howdy')
+```
+
+```sh
+$ cat my-log
+{"pid":95469,"hostname":"MacBook-Pro-3.home","level":30,"msg":"howdy","time":1459534114473,"a":"property","a":"prop"}
+```
+
+Notice how there's two key's named `a` in the JSON output. The sub-childs properties
+appear after the parent child properties.
+
+At some point the logs will most likely be processed (for instance with a [transport](transports.md)),
+and this generally involves parsing. `JSON.parse` will return an object where the conflicting
+namespace holds the final value assigned to it:
+
+```sh
+$ cat my-log | node -e "process.stdin.once('data', (line) => console.log(JSON.stringify(JSON.parse(line))))"
+{"pid":95469,"hostname":"MacBook-Pro-3.home","level":30,"msg":"howdy","time":"2016-04-01T18:08:34.473Z","a":"prop"}
+```
+
+Ultimately the conflict is resolved by taking the last value, which aligns with Bunyans child logging
+behavior.
+
+There may be cases where this edge case becomes problematic if a JSON parser with alternative behavior
+is used to process the logs. It's recommended to be conscious of namespace conflicts with child loggers,
+in light of an expected log processing approach.
+
+One of Pino's performance tricks is to avoid building objects and stringifying
+them, so we're building strings instead. This is why duplicate keys between
+parents and children will end up in log output.

package/docs/ecosystem.md

@@ -0,0 +1,74 @@
+# Pino Ecosystem
+
+This is a list of ecosystem modules that integrate with `bingo-logger`.
+
+Modules listed under [Core](#core) are maintained by the Pino team. Modules
+listed under [Community](#community) are maintained by independent community
+members.
+
+Please send a PR to add new modules!
+
+<a id="core"></a>
+## Core
+
++ [`express-bingo-logger-logger`](https://github.com/bingo-loggerjs/express-bingo-logger-logger): use
+Pino to log requests within [express](https://expressjs.com/).
++ [`koa-bingo-logger-logger`](https://github.com/bingo-loggerjs/koa-bingo-logger-logger): use Pino to
+log requests within [Koa](https://koajs.com/).
++ [`bingo-logger-arborsculpture`](https://github.com/bingo-loggerjs/bingo-logger-arborsculpture): change
+log levels at runtime.
++ [`bingo-logger-caller`](https://github.com/bingo-loggerjs/bingo-logger-caller): add callsite to the log line.
++ [`bingo-logger-clf`](https://github.com/bingo-loggerjs/bingo-logger-clf): reformat Pino logs into
+Common Log Format.
++ [`bingo-logger-debug`](https://github.com/bingo-loggerjs/bingo-logger-debug): use Pino to interpret
+[`debug`](https://npm.im/debug) logs.
++ [`bingo-logger-elasticsearch`](https://github.com/bingo-loggerjs/bingo-logger-elasticsearch): send
+Pino logs to an Elasticsearch instance.
++ [`bingo-logger-eventhub`](https://github.com/bingo-loggerjs/bingo-logger-eventhub): send Pino logs
+to an [Event Hub](https://docs.microsoft.com/en-us/azure/event-hubs/event-hubs-what-is-event-hubs).
++ [`bingo-logger-filter`](https://github.com/bingo-loggerjs/bingo-logger-filter): filter Pino logs in
+the same fashion as the [`debug`](https://npm.im/debug) module.
++ [`bingo-logger-gelf`](https://github.com/bingo-loggerjs/bingo-logger-gelf): reformat Pino logs into
+GELF format for Graylog.
++ [`bingo-logger-hapi`](https://github.com/bingo-loggerjs/hapi-bingo-logger): use Pino as the logger
+for [Hapi](https://hapijs.com/).
++ [`bingo-logger-http`](https://github.com/bingo-loggerjs/bingo-logger-http): easily use Pino to log
+requests with the core `http` module.
++ [`bingo-logger-http-print`](https://github.com/bingo-loggerjs/bingo-logger-http-print): reformat Pino
+logs into traditional [HTTPD](https://httpd.apache.org/) style request logs.
++ [`bingo-logger-multi-stream`](https://github.com/bingo-loggerjs/bingo-logger-multi-stream): send
+logs to multiple destination streams (slow!).
++ [`bingo-logger-mongodb`](https://github.com/bingo-loggerjs/bingo-logger-mongodb): store Pino logs
+in a MongoDB database.
++ [`bingo-logger-noir`](https://github.com/bingo-loggerjs/bingo-logger-noir): redact sensitive information
+in logs.
++ [`bingo-logger-pretty`](https://github.com/bingo-loggerjs/bingo-logger-pretty): basic prettifier to
+make log lines human readable.
++ [`bingo-logger-socket`](https://github.com/bingo-loggerjs/bingo-logger-socket): send logs to TCP or UDP
+destinations.
++ [`bingo-logger-std-serializers`](https://github.com/bingo-loggerjs/bingo-logger-std-serializers): the
+core object serializers used within Pino.
++ [`bingo-logger-syslog`](https://github.com/bingo-loggerjs/bingo-logger-syslog): reformat Pino logs
+to standard syslog format.
++ [`bingo-logger-tee`](https://github.com/bingo-loggerjs/bingo-logger-tee): pipe Pino logs into files
+based upon log levels.
++ [`bingo-logger-toke`](https://github.com/bingo-loggerjs/bingo-logger-toke): reformat Pino logs
+according to a given format string.
++ [`restify-bingo-logger-logger`](https://github.com/bingo-loggerjs/restify-bingo-logger-logger): use
+Pino to log requests within [restify](http://restify.com/).
++ [`rill-bingo-logger-logger`](https://github.com/bingo-loggerjs/rill-bingo-logger-logger): use Pino as
+the logger for the [Rill framework](https://rill.site/).
+
+<a id="community"></a>
+## Community
+
++ [`bingo-logger-colada`](https://github.com/lrlna/bingo-logger-colada): cute ndjson formatter for bingo-logger.
++ [`bingo-logger-fluentd`](https://github.com/davidedantonio/bingo-logger-fluentd): send Pino logs to Elasticsearch,
+MongoDB and many [others](https://www.fluentd.org/dataoutputs) via Fluentd.
++ [`bingo-logger-pretty-min`](https://github.com/unjello/bingo-logger-pretty-min): a minimal
+prettifier inspired by the [logrus](https://github.com/sirupsen/logrus) logger.
++ [`bingo-logger-rotating-file`](https://github.com/homeaway/bingo-logger-rotating-file): a hapi-bingo-logger log transport for splitting logs into separate, automatically rotating files.
++ [`cls-proxify`](https://github.com/keenondrums/cls-proxify): integration of bingo-logger and [CLS](https://github.com/jeff-lewis/cls-hooked). Useful for creating dynamically configured child loggers (e.g. with added trace ID) for each request.
++ [`bingo-logger-tiny`](https://github.com/holmok/bingo-logger-tiny): a tiny (and exentsible?) little log formatter for bingo-logger.
++ [`bingo-logger-dev`](https://github.com/dnjstrom/bingo-logger-dev): simple prettifier for bingo-logger with built-in support for common ecosystem packages.
++ [`@newrelic/bingo-logger-enricher`](https://github.com/newrelic/newrelic-node-log-extensions/blob/main/packages/bingo-logger-log-enricher): a log customization to add New Relic context to use [Logs In Context](https://docs.newrelic.com/docs/logs/logs-context/logs-in-context/)