@contrast/agent 4.2.0

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

@@ -0,0 +1,147 @@
+'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 colors = require('colors/safe');
+
+var _require = require('triple-beam'),
+    LEVEL = _require.LEVEL;
+
+//
+// Fix colors not appearing in non-tty environments
+//
+
+
+colors.enabled = true;
+
+/**
+ * @property {RegExp} hasSpace
+ * Simple regex to check for presence of spaces.
+ */
+var hasSpace = /\s+/;
+
+/*
+ * Colorizer format. Wraps the `level` and/or `message` properties
+ * of the `info` objects with ANSI color codes based on a few options.
+ */
+
+var Colorizer = function () {
+  function Colorizer() {
+    var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, Colorizer);
+
+    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.
+   */
+
+
+  _createClass(Colorizer, [{
+    key: 'addColors',
+
+
+    /*
+     * Adds the colors Object to the set of allColors
+     * known by the Colorizer
+     *
+     * @param {Object} colors Set of color mappings to add.
+     */
+    value: function addColors(clrs) {
+      return Colorizer.addColors(clrs);
+    }
+
+    /*
+     * function colorize (lookup, level, message)
+     * Performs multi-step colorization using colors/safe
+     */
+
+  }, {
+    key: 'colorize',
+    value: function 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 (var 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.
+     */
+
+  }, {
+    key: 'transform',
+    value: function 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;
+    }
+  }], [{
+    key: 'addColors',
+    value: function addColors(clrs) {
+      var nextColors = Object.keys(clrs).reduce(function (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;
+    }
+  }]);
+
+  return Colorizer;
+}();
+
+/*
+ * 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 = function (opts) {
+  return new Colorizer(opts);
+};
+
+//
+// Attach the Colorizer for registration purposes
+//
+module.exports.Colorizer = module.exports.Format = Colorizer;

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

@@ -0,0 +1,66 @@
+'use strict';
+
+var 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 function (info) {
+    var obj = info;
+    for (var 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 = function () {
+  for (var _len = arguments.length, formats = Array(_len), _key = 0; _key < _len; _key++) {
+    formats[_key] = arguments[_key];
+  }
+
+  var combinedFormat = format(cascade(formats));
+  var 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/format.js

@@ -0,0 +1,69 @@
+'use strict';
+
+/*
+ * Displays a helpful message and the source of
+ * the format when it is invalid.
+ */
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var InvalidFormatError = function (_Error) {
+  _inherits(InvalidFormatError, _Error);
+
+  function InvalidFormatError(formatFn) {
+    _classCallCheck(this, InvalidFormatError);
+
+    var _this = _possibleConstructorReturn(this, (InvalidFormatError.__proto__ || Object.getPrototypeOf(InvalidFormatError)).call(this, 'Format functions must be synchronous taking a two arguments: (info, opts)\nFound: ' + formatFn.toString().split('\n')[0] + '\n'));
+
+    Error.captureStackTrace(_this, InvalidFormatError);
+    return _this;
+  }
+
+  return InvalidFormatError;
+}(Error);
+
+/*
+ * function format (formatFn)
+ * Returns a create function for the `formatFn`.
+ */
+
+
+module.exports = function (formatFn) {
+  if (formatFn.length > 2) {
+    throw new InvalidFormatError(formatFn);
+  }
+
+  /*
+   * function Format (options)
+   * Base prototype which calls a `_format`
+   * function and pushes the result.
+   */
+  function Format() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    this.options = options;
+  }
+
+  Format.prototype.transform = formatFn;
+
+  //
+  // Create a function which returns new instances of
+  // FormatWrap for simple syntax like:
+  //
+  // require('winston').formats.json();
+  //
+  function createFormatWrap(opts) {
+    return new Format(opts);
+  }
+
+  //
+  // Expose the FormatWrap through the create function
+  // for testability.
+  //
+  createFormatWrap.Format = Format;
+  return createFormatWrap;
+};

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

@@ -0,0 +1,54 @@
+'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');
+
+/*
+ * @api private
+ * method {function} exposeFormat
+ * Exposes a sub-format on the main format object
+ * as a lazy-loaded getter.
+ */
+function exposeFormat(name, path) {
+  path = path || name;
+  Object.defineProperty(format, name, {
+    get: function get() {
+      return require('./' + path + '.js');
+    },
+
+    configurable: true
+  });
+}
+
+//
+// Setup all transports as lazy-loaded getters.
+//
+exposeFormat('align');
+exposeFormat('cli');
+exposeFormat('combine');
+exposeFormat('colorize');
+exposeFormat('json');
+exposeFormat('label');
+exposeFormat('logstash');
+exposeFormat('metadata');
+exposeFormat('ms');
+exposeFormat('padLevels', 'pad-levels');
+exposeFormat('prettyPrint', 'pretty-print');
+exposeFormat('printf');
+exposeFormat('simple');
+exposeFormat('splat');
+exposeFormat('timestamp');
+exposeFormat('uncolorize');

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

@@ -0,0 +1,27 @@
+'use strict';
+
+var format = require('./format');
+
+var _require = require('triple-beam'),
+    MESSAGE = _require.MESSAGE;
+
+var jsonStringify = require('fast-safe-stringify');
+
+/*
+ * function replacer (key, value)
+ * Handles proper stringification of Buffer output.
+ */
+function replacer(key, value) {
+  return value instanceof Buffer ? value.toString('base64') : value;
+}
+
+/*
+ * function json (info)
+ * Returns a new instance of the JSON format that turns a log `info`
+ * object into pure JSON. This was previously exposed as { json: true }
+ * to transports in `winston < 3.0.0`.
+ */
+module.exports = format(function (info, opts) {
+  info[MESSAGE] = jsonStringify(info, opts.replacer || replacer, opts.space);
+  return info;
+});

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var format = require('./format');
+
+/*
+ * function label (info)
+ * Returns a new instance of the label Format which adds the specified
+ * `opts.label` before the message. This was previously exposed as
+ * { label: 'my label' } to transports in `winston < 3.0.0`.
+ */
+module.exports = format(function (info, opts) {
+  if (opts.message) {
+    info.message = '[' + opts.label + '] ' + info.message;
+    return info;
+  }
+
+  info.label = opts.label;
+  return info;
+});

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

@@ -0,0 +1,15 @@
+'use strict';
+
+var _require = require('./colorize'),
+    Colorizer = _require.Colorizer;
+
+/*
+ * Simple method to register colors with a simpler require
+ * path within the module.
+ */
+
+
+module.exports = function (config) {
+  Colorizer.addColors(config.colors || config);
+  return config;
+};

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

@@ -0,0 +1,32 @@
+'use strict';
+
+var format = require('./format');
+
+var _require = require('triple-beam'),
+    MESSAGE = _require.MESSAGE;
+
+var jsonStringify = require('fast-safe-stringify');
+
+/*
+ * function logstash (info)
+ * Returns a new instance of the LogStash Format that turns a
+ * log `info` object into pure JSON with the appropriate logstash
+ * options. This was previously exposed as { logstash: true }
+ * to transports in `winston < 3.0.0`.
+ */
+module.exports = format(function (info) {
+  var logstash = {};
+  if (info.message) {
+    logstash['@message'] = info.message;
+    delete info.message;
+  }
+
+  if (info.timestamp) {
+    logstash['@timestamp'] = info.timestamp;
+    delete info.timestamp;
+  }
+
+  logstash['@fields'] = info;
+  info[MESSAGE] = jsonStringify(logstash);
+  return info;
+});

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

@@ -0,0 +1,63 @@
+'use strict';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var format = require('./format');
+
+function fillExcept(info, fillExceptKeys, metadataKey) {
+  var savedKeys = fillExceptKeys.reduce(function (acc, key) {
+    acc[key] = info[key];
+    delete info[key];
+    return acc;
+  }, {});
+  var metadata = Object.keys(info).reduce(function (acc, key) {
+    acc[key] = info[key];
+    delete info[key];
+    return acc;
+  }, {});
+
+  Object.assign(info, savedKeys, _defineProperty({}, metadataKey, metadata));
+  return info;
+}
+
+function fillWith(info, fillWithKeys, metadataKey) {
+  info[metadataKey] = fillWithKeys.reduce(function (acc, key) {
+    acc[key] = info[key];
+    delete info[key];
+    return acc;
+  }, {});
+  return info;
+}
+
+/**
+ * Adds in a "metadata" object to collect extraneous data, similar to the metadata
+ * object in winston 2.x.
+ */
+module.exports = format(function (info) {
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  var metadataKey = 'metadata';
+  if (opts.key) {
+    metadataKey = opts.key;
+  }
+
+  var fillExceptKeys = [];
+  if (!opts.fillExcept && !opts.fillWith) {
+    fillExceptKeys.push('level');
+    fillExceptKeys.push('message');
+  }
+
+  if (opts.fillExcept) {
+    fillExceptKeys = opts.fillExcept;
+  }
+
+  if (fillExceptKeys.length > 0) {
+    return fillExcept(info, fillExceptKeys, metadataKey);
+  }
+
+  if (opts.fillWith) {
+    return fillWith(info, opts.fillWith, metadataKey);
+  }
+
+  return info;
+});

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

@@ -0,0 +1,18 @@
+'use strict';
+
+var format = require('./format');
+var ms = require('ms');
+
+/*
+ * function ms (info)
+ * Returns an `info` with a `ms` property. The `ms` property holds the Value
+ * of the time difference between two calls in milliseconds.
+ */
+module.exports = format(function (info) {
+  var curr = +new Date();
+  undefined.diff = curr - (undefined.prevTime || curr);
+  undefined.prevTime = curr;
+  info.ms = '+' + ms(undefined.diff);
+
+  return info;
+});

package/node_modules/winston-compat/node_modules/logform/dist/pad-levels.js

@@ -0,0 +1,118 @@
+/* eslint no-unused-vars: 0 */
+'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 _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var _require = require('triple-beam'),
+    configs = _require.configs,
+    LEVEL = _require.LEVEL,
+    MESSAGE = _require.MESSAGE;
+
+var Padder = function () {
+  function Padder() {
+    var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { levels: configs.npm.levels };
+
+    _classCallCheck(this, Padder);
+
+    this.paddings = Padder.paddingForLevels(opts.levels, opts.filler);
+    this.options = opts;
+  }
+
+  /**
+   * Returns the maximum length of keys in the specified `levels` Object.
+   * @param  {Object} levels Set of all levels to calculate longest level against.
+   * @returns {Number} Maximum length of the longest level string.
+   */
+
+
+  _createClass(Padder, [{
+    key: 'transform',
+
+
+    /**
+     * Prepends the padding onto the `message` based on the `LEVEL` of
+     * the `info`. This is based on the behavior of `winston@2` which also
+     * prepended the level onto the message.
+     *
+     * See: https://github.com/winstonjs/winston/blob/2.x/lib/winston/logger.js#L198-L201
+     *
+     * @param  {Info} info Logform info object
+     * @param  {Object} opts Options passed along to this instance.
+     * @returns {Info} Modified logform info object.
+     */
+    value: function transform(info, opts) {
+      info.message = '' + this.paddings[info[LEVEL]] + info.message;
+      if (info[MESSAGE]) {
+        info[MESSAGE] = '' + this.paddings[info[LEVEL]] + info[MESSAGE];
+      }
+
+      return info;
+    }
+  }], [{
+    key: 'getLongestLevel',
+    value: function getLongestLevel(levels) {
+      var lvls = Object.keys(levels).map(function (level) {
+        return level.length;
+      });
+      return Math.max.apply(Math, _toConsumableArray(lvls));
+    }
+
+    /**
+     * Returns the padding for the specified `level` assuming that the
+     * maximum length of all levels it's associated with is `maxLength`.
+     * @param  {String} level Level to calculate padding for.
+     * @param  {String} filler Repeatable text to use for padding.
+     * @param  {Number} maxLength Length of the longest level
+     * @returns {String} Padding string for the `level`
+     */
+
+  }, {
+    key: 'paddingForLevel',
+    value: function paddingForLevel(level, filler, maxLength) {
+      var targetLen = maxLength + 1 - level.length;
+      var rep = Math.floor(targetLen / filler.length);
+      var padding = '' + filler + filler.repeat(rep);
+      return padding.slice(0, targetLen);
+    }
+
+    /**
+     * Returns an object with the string paddings for the given `levels`
+     * using the specified `filler`.
+     * @param  {Object} levels Set of all levels to calculate padding for.
+     * @param  {String} filler Repeatable text to use for padding.
+     * @returns {Object} Mapping of level to desired padding.
+     */
+
+  }, {
+    key: 'paddingForLevels',
+    value: function paddingForLevels(levels) {
+      var filler = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ' ';
+
+      var maxLength = Padder.getLongestLevel(levels);
+      return Object.keys(levels).reduce(function (acc, level) {
+        acc[level] = Padder.paddingForLevel(level, filler, maxLength);
+        return acc;
+      }, {});
+    }
+  }]);
+
+  return Padder;
+}();
+
+/*
+ * function padLevels (info)
+ * Returns a new instance of the padLevels Format which pads
+ * levels to be the same length. This was previously exposed as
+ * { padLevels: true } to transports in `winston < 3.0.0`.
+ */
+
+
+module.exports = function (opts) {
+  return new Padder(opts);
+};
+
+module.exports.Padder = module.exports.Format = Padder;

package/node_modules/winston-compat/node_modules/logform/dist/pretty-print.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var inspect = require('util').inspect;
+var format = require('./format');
+
+var _require = require('triple-beam'),
+    MESSAGE = _require.MESSAGE;
+
+/*
+ * function prettyPrint (info)
+ * Returns a new instance of the prettyPrint Format that "prettyPrint"
+ * serializes `info` objects. This was previously exposed as
+ * { prettyPrint: true } to transports in `winston < 3.0.0`.
+ */
+
+
+module.exports = format(function (info, opts) {
+  info[MESSAGE] = inspect(info, false, opts.depth || null, opts.colorize);
+  return info;
+});