@contrast/agent 3.11.10

package/node_modules/winston-compat/node_modules/logform/README.md

@@ -0,0 +1,170 @@
+# logform
+
+An mutable object-based log format designed for chaining & objectMode streams.
+
+``` js
+const { format } = require('logform');
+
+const alignedWithColorsAndTime = format.combine(
+  format.colorize(),
+  format.timestamp(),
+  format.align(),
+  format.printf(info => `${info.timestamp} ${info.level}: ${info.message}`)
+);
+```
+
+- [`info` Objects](#info-objects)
+- [Understanding formats](#understanding-formats)
+  - [Combining formats](#combining-formats)
+  - [Filtering `info` objects](#filtering-info-objects)
+
+## `info` Objects
+
+The `info` parameter provided to a given format represents a single log message. The object itself is mutable. Every `info` must have at least the `level` and `message` properties:
+
+``` js
+{
+  level: 'info',                 // Level of the logging message  
+  message: 'Hey! Log something?' // Descriptive message being logged.
+}
+```
+
+`logform` itself exposes several additional properties:
+
+- `splat`: string interpolation splat for `%d %s`-style messages.
+- `timestamp`: timestamp the message was received.
+- `label`: custom label associated with each message.
+
+As a consumer you may add whatever properties you wish – _internal state is maintained by `Symbol` properties:_
+
+- `Symbol.for('level')` _**(READ-ONLY)**:_ equal to `level` property. Is treated as immutable by all code.
+- `Symbol.for('message'):` complete string message set by "finalizing formats": `json`, `logstash`, `printf`, `prettyPrint`, and `simple`. 
+
+## Understanding formats
+
+Formats are prototypal objects (i.e. class instances) that define a single method: `transform(info, opts)` and return the mutated `info`
+
+- `info`: an object representing the log message.
+- `opts`: setting specific to the current instance of the format.
+
+They are expected to return one of two things:
+
+- **An `info` Object** representing the modified `info` argument. Object references need not be preserved if immutability is preferred. All current built-in formats consider `info` mutable, but [immutablejs] is being considered for future releases.
+- **A falsey value** indicating that the `info` argument should be ignored by the caller. (See: [Filtering `info` Objects](#filtering-info-objects)) below.
+
+`logform.format`  is designed to be as simple as possible. To define a new format simple pass it a `transform(info, opts)` function to get a new `Format`. 
+
+The named `Format` returned can be used to create as many copies of the given `Format` as desired:
+
+``` js
+const { format } = require('logform');
+
+const volume = format((info, opts) => {
+  if (opts.yell) {
+    info.message = info.message.toUpperCase(); 
+  } else if (opts.whisper) {
+    info.message = info.message.toLowerCase();
+  }
+
+  return info;
+});
+
+// `volume` is now a function that returns instances of the format.
+const scream = volume({ yell: true });
+console.dir(scream.transform({
+  level: 'info',
+  message: `sorry for making you YELL in your head!`
+}, scream.options));
+// {
+//   level: 'info'
+//   message: 'SORRY FOR MAKING YOU YELL IN YOUR HEAD!'
+// }
+
+// `volume` can be used multiple times to create different formats.
+const whisper = volume({ whisper: true });
+console.dir(whisper.transform({ 
+  level: 'info', 
+  message: `WHY ARE THEY MAKING US YELL SO MUCH!` 
+}), whisper.options);
+// {
+//   level: 'info'
+//   message: 'why are they making us yell so much!'
+// }
+```
+
+### Combining formats
+
+Any number of formats may be combined into a single format using `format.combine`. Since `format.combine` takes no `opts`, as a convenience it returns pre-created instance of the combined format.
+
+``` js
+const { format } = require('logform');
+const { combine, timestamp, label } = format;
+
+const labelTimestamp = combine(
+  label({ label: 'right meow!' }),
+  timestamp()
+);
+
+const info = labelTimestamp.transform({
+  level: 'info',
+  message: 'What time is the testing at?'
+});
+
+console.dir(info);
+// { level: 'info',
+//   message: 'What time is the testing at?',
+//   label: 'right meow!',
+//   timestamp: '2017-09-30T03:57:26.875Z' }
+```
+
+### Filtering `info` Objects
+
+If you wish to filter out a given `info` Object completely then simply return a falsey value.
+
+``` js
+const ignorePrivate = format((info, opts) => {
+  if (info.private) { return false; }
+  return info;
+});
+
+console.dir(ignorePrivate.transform({
+  level: 'error',
+  message: 'Public error to share'
+}));
+// { level: 'error', message: 'Public error to share' }
+
+console.dir(ignorePrivate.transform({
+  level: 'error',
+  private: true,
+  message: 'This is super secret - hide it.'
+}));
+// false
+```
+
+Use of `format.combine` will respect any falsey values return and stop evaluation of later formats in the series. For example:
+
+``` js
+const { format } = require('logform');
+const { combine, timestamp, label } = format;
+
+const willNeverThrow = format.combine(
+  format(info => { return false })(), // Ignores everything
+  format(info => { throw new Error('Never reached') })()
+);
+
+console.dir(willNeverThrow.transform({
+  level: 'info',
+  message: 'wow such testing'
+}))
+```
+
+## Tests
+
+Tests are written with `mocha`, `assume`, and `nyc`. They can be run with `npm`:
+
+```
+npm test
+```
+
+##### LICENSE: MIT
+##### AUTHOR: [Charlie Robbins](https://github.com/indexzero)

package/node_modules/winston-compat/node_modules/logform/align.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const format = require('./format');
+
+/*
+ * function align (info)
+ * Returns a new instance of the align Format which adds a `\t`
+ * delimiter before the message to properly align it in the same place.
+ * It was previously { align: true } in winston < 3.0.0
+ */
+module.exports = format(info => {
+  info.message = `\t${info.message}`;
+  return info;
+});

package/node_modules/winston-compat/node_modules/logform/browser.js

@@ -0,0 +1,36 @@
+'use strict';
+
+/*
+ * @api public
+ * @property {function} format
+ * Both the construction method and set of exposed
+ * formats.
+ */
+const format = exports.format = require('././format');
+
+/*
+ * @api public
+ * @method {function} levels
+ * Registers the specified levels with logform.
+ */
+exports.levels = require('././levels');
+
+//
+// Setup all transports as eager-loaded exports
+// so that they are static for the bundlers.
+//
+Object.defineProperty(format, 'align',       { value: require('./align') });
+Object.defineProperty(format, 'cli',         { value: require('./cli') });
+Object.defineProperty(format, 'combine',     { value: require('./combine') });
+Object.defineProperty(format, 'colorize',    { value: require('./colorize') });
+Object.defineProperty(format, 'json',        { value: require('./json') });
+Object.defineProperty(format, 'label',       { value: require('./label') });
+Object.defineProperty(format, 'logstash',    { value: require('./logstash') });
+Object.defineProperty(format, 'metadata',    { value: require('./metadata') });
+Object.defineProperty(format, 'padLevels',   { value: require('./pad-levels') });
+Object.defineProperty(format, 'prettyPrint', { value: require('./pretty-print') });
+Object.defineProperty(format, 'printf',      { value: require('./printf') });
+Object.defineProperty(format, 'simple',      { value: require('./simple') });
+Object.defineProperty(format, 'splat',       { value: require('./splat') });
+Object.defineProperty(format, 'timestamp',   { value: require('./timestamp') });
+Object.defineProperty(format, 'uncolorize',  { value: require('./uncolorize') });

package/node_modules/winston-compat/node_modules/logform/cli.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const { Colorizer } = require('./colorize');
+const { Padder } = require('./pad-levels');
+const { configs, MESSAGE } = require('triple-beam');
+
+
+/**
+ * Cli format class that handles initial state for a a separate
+ * Colorizer and Padder instance.
+ */
+class CliFormat {
+  constructor(opts = {}) {
+    if (!opts.levels) {
+      opts.levels = configs.npm.levels;
+    }
+
+    this.colorizer = new Colorizer(opts);
+    this.padder = new Padder(opts);
+    this.options = opts;
+  }
+
+  /*
+   * function transform (info, opts)
+   * Attempts to both:
+   * 1. Pad the { level }
+   * 2. Colorize the { level, message }
+   * of the given `logform` info object depending on the `opts`.
+   */
+  transform(info, opts) {
+    this.colorizer.transform(
+      this.padder.transform(info, opts),
+      opts
+    );
+
+    info[MESSAGE] = `${info.level}:${info.message}`;
+    return info;
+  }
+}
+
+/*
+ * function cli (opts)
+ * Returns a new instance of the CLI format that turns a log
+ * `info` object into the same format previously available
+ * in `winston.cli()` in `winston < 3.0.0`.
+ */
+module.exports = opts => new CliFormat(opts);
+
+//
+// Attach the CliFormat for registration purposes
+//
+module.exports.Format = CliFormat;

package/node_modules/winston-compat/node_modules/logform/colorize.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const colors = require('colors/safe');
+const { LEVEL } = require('triple-beam');
+
+//
+// Fix colors not appearing in non-tty environments
+//
+colors.enabled = true;
+
+/**
+ * @property {RegExp} hasSpace
+ * Simple regex to check for presence of spaces.
+ */
+const hasSpace = /\s+/;
+
+/*
+ * Colorizer format. Wraps the `level` and/or `message` properties
+ * of the `info` objects with ANSI color codes based on a few options.
+ */
+class Colorizer {
+  constructor(opts = {}) {
+    if (opts.colors) {
+      this.addColors(opts.colors);
+    }
+
+    this.options = opts;
+  }
+
+  /*
+   * Adds the colors Object to the set of allColors
+   * known by the Colorizer
+   *
+   * @param {Object} colors Set of color mappings to add.
+   */
+  static addColors(clrs) {
+    const nextColors = Object.keys(clrs).reduce((acc, level) => {
+      acc[level] = hasSpace.test(clrs[level])
+        ? clrs[level].split(hasSpace)
+        : clrs[level];
+
+      return acc;
+    }, {});
+
+    Colorizer.allColors = Object.assign({}, Colorizer.allColors || {}, nextColors);
+    return Colorizer.allColors;
+  }
+
+  /*
+   * Adds the colors Object to the set of allColors
+   * known by the Colorizer
+   *
+   * @param {Object} colors Set of color mappings to add.
+   */
+  addColors(clrs) {
+    return Colorizer.addColors(clrs);
+  }
+
+  /*
+   * function colorize (lookup, level, message)
+   * Performs multi-step colorization using colors/safe
+   */
+  colorize(lookup, level, message) {
+    if (typeof message === 'undefined') {
+      message = level;
+    }
+
+    //
+    // If the color for the level is just a string
+    // then attempt to colorize the message with it.
+    //
+    if (!Array.isArray(Colorizer.allColors[lookup])) {
+      return colors[Colorizer.allColors[lookup]](message);
+    }
+
+    //
+    // If it is an Array then iterate over that Array, applying
+    // the colors function for each item.
+    //
+    for (let i = 0, len = Colorizer.allColors[lookup].length; i < len; i++) {
+      message = colors[Colorizer.allColors[lookup][i]](message);
+    }
+
+    return message;
+  }
+
+  /*
+   * function transform (info, opts)
+   * Attempts to colorize the { level, message } of the given
+   * `logform` info object.
+   */
+  transform(info, opts) {
+    if (opts.level || opts.all || !opts.message) {
+      info.level = this.colorize(info[LEVEL], info.level);
+    }
+
+    if (opts.all || opts.message) {
+      info.message = this.colorize(info[LEVEL], info.level, info.message);
+    }
+
+    return info;
+  }
+}
+
+/*
+ * function colorize (info)
+ * Returns a new instance of the colorize Format that applies
+ * level colors to `info` objects. This was previously exposed
+ * as { colorize: true } to transports in `winston < 3.0.0`.
+ */
+module.exports = opts => new Colorizer(opts);
+
+//
+// Attach the Colorizer for registration purposes
+//
+module.exports.Colorizer
+  = module.exports.Format
+  = Colorizer;

package/node_modules/winston-compat/node_modules/logform/combine.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const format = require('./format');
+
+/*
+ * function cascade(formats)
+ * Returns a function that invokes the `._format` function in-order
+ * for the specified set of `formats`. In this manner we say that Formats
+ * are "pipe-like", but not a pure pumpify implementation. Since there is no back
+ * pressure we can remove all of the "readable" plumbing in Node streams.
+ */
+function cascade(formats) {
+  if (!formats.every(isValidFormat)) {
+    return;
+  }
+
+  return info => {
+    let obj = info;
+    for (let i = 0; i < formats.length; i++) {
+      obj = formats[i].transform(obj, formats[i].options);
+      if (!obj) {
+        return false;
+      }
+    }
+
+    return obj;
+  };
+}
+
+/*
+ * function isValidFormat(format)
+ * If the format does not define a `transform` function throw an error
+ * with more detailed usage.
+ */
+function isValidFormat(fmt) {
+  if (typeof fmt.transform !== 'function') {
+    throw new Error([
+      'No transform function found on format. Did you create a format instance?',
+      'const myFormat = format(formatFn);',
+      'const instance = myFormat();'
+    ].join('\n'));
+  }
+
+  return true;
+}
+
+/*
+ * function combine (info)
+ * Returns a new instance of the combine Format which combines the specified
+ * formats into a new format. This is similar to a pipe-chain in transform streams.
+ * We choose to combine the prototypes this way because there is no back pressure in
+ * an in-memory transform chain.
+ */
+module.exports = (...formats) => {
+  const combinedFormat = format(cascade(formats));
+  const instance = combinedFormat();
+  instance.Format = combinedFormat.Format;
+  return instance;
+};
+
+//
+// Export the cascade method for use in cli and other
+// combined formats that should not be assumed to be
+// singletons.
+//
+module.exports.cascade = cascade;

package/node_modules/winston-compat/node_modules/logform/dist/align.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var format = require('./format');
+
+/*
+ * function align (info)
+ * Returns a new instance of the align Format which adds a `\t`
+ * delimiter before the message to properly align it in the same place.
+ * It was previously { align: true } in winston < 3.0.0
+ */
+module.exports = format(function (info) {
+  info.message = '\t' + info.message;
+  return info;
+});

package/node_modules/winston-compat/node_modules/logform/dist/browser.js

@@ -0,0 +1,37 @@
+'use strict';
+
+/*
+ * @api public
+ * @property {function} format
+ * Both the construction method and set of exposed
+ * formats.
+ */
+
+var format = exports.format = require('././format');
+
+/*
+ * @api public
+ * @method {function} levels
+ * Registers the specified levels with logform.
+ */
+exports.levels = require('././levels');
+
+//
+// Setup all transports as eager-loaded exports
+// so that they are static for the bundlers.
+//
+Object.defineProperty(format, 'align', { value: require('./align') });
+Object.defineProperty(format, 'cli', { value: require('./cli') });
+Object.defineProperty(format, 'combine', { value: require('./combine') });
+Object.defineProperty(format, 'colorize', { value: require('./colorize') });
+Object.defineProperty(format, 'json', { value: require('./json') });
+Object.defineProperty(format, 'label', { value: require('./label') });
+Object.defineProperty(format, 'logstash', { value: require('./logstash') });
+Object.defineProperty(format, 'metadata', { value: require('./metadata') });
+Object.defineProperty(format, 'padLevels', { value: require('./pad-levels') });
+Object.defineProperty(format, 'prettyPrint', { value: require('./pretty-print') });
+Object.defineProperty(format, 'printf', { value: require('./printf') });
+Object.defineProperty(format, 'simple', { value: require('./simple') });
+Object.defineProperty(format, 'splat', { value: require('./splat') });
+Object.defineProperty(format, 'timestamp', { value: require('./timestamp') });
+Object.defineProperty(format, 'uncolorize', { value: require('./uncolorize') });

package/node_modules/winston-compat/node_modules/logform/dist/cli.js

@@ -0,0 +1,75 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var _require = require('./colorize'),
+    Colorizer = _require.Colorizer;
+
+var _require2 = require('./pad-levels'),
+    Padder = _require2.Padder;
+
+var _require3 = require('triple-beam'),
+    configs = _require3.configs,
+    MESSAGE = _require3.MESSAGE;
+
+/**
+ * Cli format class that handles initial state for a a separate
+ * Colorizer and Padder instance.
+ */
+
+
+var CliFormat = function () {
+  function CliFormat() {
+    var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, CliFormat);
+
+    if (!opts.levels) {
+      opts.levels = configs.npm.levels;
+    }
+
+    this.colorizer = new Colorizer(opts);
+    this.padder = new Padder(opts);
+    this.options = opts;
+  }
+
+  /*
+   * function transform (info, opts)
+   * Attempts to both:
+   * 1. Pad the { level }
+   * 2. Colorize the { level, message }
+   * of the given `logform` info object depending on the `opts`.
+   */
+
+
+  _createClass(CliFormat, [{
+    key: 'transform',
+    value: function transform(info, opts) {
+      this.colorizer.transform(this.padder.transform(info, opts), opts);
+
+      info[MESSAGE] = info.level + ':' + info.message;
+      return info;
+    }
+  }]);
+
+  return CliFormat;
+}();
+
+/*
+ * function cli (opts)
+ * Returns a new instance of the CLI format that turns a log
+ * `info` object into the same format previously available
+ * in `winston.cli()` in `winston < 3.0.0`.
+ */
+
+
+module.exports = function (opts) {
+  return new CliFormat(opts);
+};
+
+//
+// Attach the CliFormat for registration purposes
+//
+module.exports.Format = CliFormat;