@contrast/agent 3.11.10

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

@@ -0,0 +1,40 @@
+'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('triple-beam'),
+    MESSAGE = _require.MESSAGE;
+
+var Printf = function () {
+  function Printf(templateFn) {
+    _classCallCheck(this, Printf);
+
+    this.template = templateFn;
+  }
+
+  _createClass(Printf, [{
+    key: 'transform',
+    value: function transform(info) {
+      info[MESSAGE] = this.template(info);
+      return info;
+    }
+  }]);
+
+  return Printf;
+}();
+
+/*
+ * function printf (templateFn)
+ * Returns a new instance of the printf Format that creates an
+ * intermediate prototype to store the template string-based formatter
+ * function.
+ */
+
+
+module.exports = function (opts) {
+  return new Printf(opts);
+};
+
+module.exports.Printf = module.exports.Format = Printf;

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

@@ -0,0 +1,36 @@
+/* eslint no-undefined: 0 */
+'use strict';
+
+var format = require('./format');
+
+var _require = require('triple-beam'),
+    MESSAGE = _require.MESSAGE;
+
+var jsonStringify = require('fast-safe-stringify');
+
+/*
+ * function simple (info)
+ * Returns a new instance of the simple format TransformStream
+ * which writes a simple representation of logs.
+ *
+ *    const { level, message, splat, ...rest } = info;
+ *
+ *    ${level}: ${message}                            if rest is empty
+ *    ${level}: ${message} ${JSON.stringify(rest)}    otherwise
+ */
+module.exports = format(function (info) {
+  var stringifiedRest = jsonStringify(Object.assign({}, info, {
+    level: undefined,
+    message: undefined,
+    splat: undefined
+  }));
+
+  var padding = info.padding && info.padding[info.level] || '';
+  if (stringifiedRest !== '{}') {
+    info[MESSAGE] = info.level + ':' + padding + ' ' + info.message + ' ' + stringifiedRest;
+  } else {
+    info[MESSAGE] = info.level + ':' + padding + ' ' + info.message;
+  }
+
+  return info;
+});

package/node_modules/winston-compat/node_modules/logform/dist/splat.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 _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 util = require('util');
+
+var _require = require('triple-beam'),
+    SPLAT = _require.SPLAT;
+
+/**
+ * Captures the number of format (i.e. %s strings) in a given string.
+ * Based on `util.format`, see Node.js source:
+ * https://github.com/nodejs/node/blob/b1c8f15c5f169e021f7c46eb7b219de95fe97603/lib/util.js#L201-L230
+ * @type {RegExp}
+ */
+
+
+var formatRegExp = /%[scdjifoO%]/g;
+
+/**
+ * Captures the number of escaped % signs in a format string (i.e. %s strings).
+ * @type {RegExp}
+ */
+var escapedPercent = /%%/g;
+
+var Splatter = function () {
+  function Splatter(opts) {
+    _classCallCheck(this, Splatter);
+
+    this.options = opts;
+  }
+
+  /**
+     * Check to see if tokens <= splat.length, assign { splat, meta } into the
+     * `info` accordingly, and write to this instance.
+     *
+     * @param  {Info} info Logform info message.
+     * @param  {String[]} tokens Set of string interpolation tokens.
+     * @returns {Info} Modified info message
+     * @private
+     */
+
+
+  _createClass(Splatter, [{
+    key: '_splat',
+    value: function _splat(info, tokens) {
+      var msg = info.message;
+      var splat = info[SPLAT] || info.splat || [];
+      var percents = msg.match(escapedPercent);
+      var escapes = percents && percents.length || 0;
+
+      // The expected splat is the number of tokens minus the number of escapes
+      // e.g.
+      // - { expectedSplat: 3 } '%d %s %j'
+      // - { expectedSplat: 5 } '[%s] %d%% %d%% %s %j'
+      //
+      // Any "meta" will be arugments in addition to the expected splat size
+      // regardless of type. e.g.
+      //
+      // logger.log('info', '%d%% %s %j', 100, 'wow', { such: 'js' }, { thisIsMeta: true });
+      // would result in splat of four (4), but only three (3) are expected. Therefore:
+      //
+      // extraSplat = 3 - 4 = -1
+      // metas = [100, 'wow', { such: 'js' }, { thisIsMeta: true }].splice(-1, -1 * -1);
+      // splat = [100, 'wow', { such: 'js' }]
+      var expectedSplat = tokens.length - escapes;
+      var extraSplat = expectedSplat - splat.length;
+      var metas = extraSplat < 0 ? splat.splice(extraSplat, -1 * extraSplat) : [];
+
+      // Now that { splat } has been separated from any potential { meta }. we
+      // can assign this to the `info` object and write it to our format stream.
+      if (metas.length === 1) {
+        info.meta = metas[0];
+      } else if (metas.length) {
+        info.meta = metas;
+      }
+
+      info.message = util.format.apply(util, [msg].concat(_toConsumableArray(splat)));
+      return info;
+    }
+
+    /**
+       * Transforms the `info` message by using `util.format` to complete
+       * any `info.message` provided it has string interpolation tokens.
+       * If no tokens exist then `info` is immutable.
+       *
+       * @param  {Info} info Logform info message.
+       * @param  {Object} opts Options for this instance.
+       * @returns {Info} Modified info message
+       */
+
+  }, {
+    key: 'transform',
+    value: function transform(info) {
+      var msg = info.message;
+      var splat = info[SPLAT] || info.splat;
+
+      // No need to process anything if splat is undefined
+      if (!splat || !splat.length) {
+        return info;
+      }
+
+      // Extract tokens, if none available default to empty array to
+      // ensure consistancy in expected results
+      var tokens = msg && msg.match && msg.match(formatRegExp);
+
+      // This condition will take care of inputs with info[SPLAT]
+      // but no tokens present
+      if (!tokens && (splat || splat.length)) {
+        var metas = splat.length > 1 ? splat.splice(0) : splat;
+
+        // Now that { splat } has been separated from any potential { meta }. we
+        // can assign this to the `info` object and write it to our format stream.
+        if (metas.length === 1) {
+          info.meta = metas[0];
+        } else if (metas.length) {
+          info.meta = metas;
+        }
+        return info;
+      }
+
+      if (tokens) {
+        return this._splat(info, tokens);
+      }
+
+      return info;
+    }
+  }]);
+
+  return Splatter;
+}();
+
+/*
+ * function splat (info)
+ * Returns a new instance of the splat format TransformStream
+ * which performs string interpolation from `info` objects. This was
+ * previously exposed implicitly in `winston < 3.0.0`.
+ */
+
+
+module.exports = function (opts) {
+  return new Splatter(opts);
+};

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

@@ -0,0 +1,28 @@
+'use strict';
+
+var fecha = require('fecha');
+var format = require('./format');
+
+/*
+ * function timestamp (info)
+ * Returns a new instance of the timestamp Format which adds a timestamp
+ * to the info. It was previously available in winston < 3.0.0 as:
+ *
+ * - { timestamp: true }             // `new Date.toISOString()`
+ * - { timestamp: function:String }  // Value returned by `timestamp()`
+ */
+module.exports = format(function (info, opts) {
+  if (opts.format) {
+    info.timestamp = typeof opts.format === 'function' ? opts.format() : fecha.format(new Date(), opts.format);
+  }
+
+  if (!info.timestamp) {
+    info.timestamp = new Date().toISOString();
+  }
+
+  if (opts.alias) {
+    info[opts.alias] = info.timestamp;
+  }
+
+  return info;
+});

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

@@ -0,0 +1,31 @@
+'use strict';
+
+var colors = require('colors/safe');
+var format = require('./format');
+
+var _require = require('triple-beam'),
+    MESSAGE = _require.MESSAGE;
+
+/*
+ * function uncolorize (info)
+ * Returns a new instance of the uncolorize Format that strips colors
+ * from `info` objects. This was previously exposed as { stripColors: true }
+ * to transports in `winston < 3.0.0`.
+ */
+
+
+module.exports = format(function (info, opts) {
+  if (opts.level !== false) {
+    info.level = colors.strip(info.level);
+  }
+
+  if (opts.message !== false) {
+    info.message = colors.strip(info.message);
+  }
+
+  if (opts.raw !== false && info[MESSAGE]) {
+    info[MESSAGE] = colors.strip(info[MESSAGE]);
+  }
+
+  return info;
+});

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

@@ -0,0 +1,14 @@
+const { format } = require('../');
+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);

package/node_modules/winston-compat/node_modules/logform/examples/filter.js

@@ -0,0 +1,30 @@
+/* eslint no-unused-vars: 0 */
+
+const { format } = require('../');
+const { combine, timestamp, label } = format;
+
+const ignorePrivate = format((info, opts) => {
+  if (info.private) { return false; }
+  return info;
+})();
+
+console.dir(ignorePrivate.transform({
+  level: 'error',
+  message: 'Public error to share'
+}));
+
+console.dir(ignorePrivate.transform({
+  level: 'error',
+  private: true,
+  message: 'This is super secret - hide it.'
+}));
+
+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'
+}));

package/node_modules/winston-compat/node_modules/logform/examples/invalid.js

@@ -0,0 +1,6 @@
+/* eslint no-unused-vars: 0 */
+const { format } = require('../');
+
+const invalid = format(function invalid(just, too, many, args) {
+  return just;
+});

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

@@ -0,0 +1,78 @@
+const { format } = require('../');
+const { combine, json, metadata, timestamp } = format;
+
+// Default Functionality (no options passed)
+const defaultFormatter = combine(
+  timestamp(),
+  metadata(),
+  json()
+);
+
+const defaultMessage = defaultFormatter.transform({
+  level: 'info',
+  message: 'This should be a message.',
+  application: 'Microsoft Office',
+  store: 'Big Box Store',
+  purchaseAmount: '9.99'
+});
+
+console.dir(defaultMessage);
+
+
+// Fill all keys into metadata except those provided
+const formattedLogger = combine(
+  timestamp(),
+  metadata({ fillExcept: ['message', 'level', 'timestamp'] }),
+  json()
+);
+
+const fillExceptMessage = formattedLogger.transform({
+  level: 'info',
+  message: 'This should have attached metadata',
+  category: 'movies',
+  subCategory: 'action'
+});
+
+console.dir(fillExceptMessage);
+
+
+// Fill only the keys provided into the object, and also give it a different key
+const customMetadataLogger = combine(
+  timestamp(),
+  metadata({ fillWith: ['publisher', 'author', 'book'], key: 'bookInfo' }),
+  json()
+);
+
+const fillWithMessage = customMetadataLogger.transform({
+  level: 'debug',
+  message: 'This message should be outside of the bookInfo object',
+  publisher: 'Lorem Press',
+  author: 'Albert Einstein',
+  book: '4D Chess for Dummies',
+  label: 'myCustomLabel'
+});
+
+console.dir(fillWithMessage);
+
+// Demonstrates Metadata 'chaining' to combine multiple datapoints.
+const chainedMetadata = combine(
+  timestamp(),
+  metadata({ fillWith: ['publisher', 'author', 'book'], key: 'bookInfo' }),
+  metadata({ fillWith: ['purchasePrice', 'purchaseDate', 'transactionId'], key: 'transactionInfo' }),
+  metadata({ fillExcept: ['level', 'message', 'label', 'timestamp'] }),
+  json()
+);
+
+const chainedMessage = chainedMetadata.transform({
+  level: 'debug',
+  message: 'This message should be outside of the bookInfo object',
+  publisher: 'Lorem Press',
+  author: 'Albert Einstein',
+  book: '4D Chess for Dummies',
+  label: 'myCustomLabel',
+  purchasePrice: '9.99',
+  purchaseDate: '2.10.2018',
+  transactionId: '123ABC'
+});
+
+console.dir(chainedMessage);

package/node_modules/winston-compat/node_modules/logform/examples/padLevels.js

@@ -0,0 +1,39 @@
+const { format } = require('../');
+const { combine, padLevels, simple } = format;
+
+const { MESSAGE } = require('triple-beam');
+
+const paddedFormat = combine(
+  padLevels({
+    // Uncomment for a custom filler for the padding, defaults to ' '.
+    // filler: 'foo',
+    // Levels has to be defined, same as `winston.createLoggers({ levels })`.
+    levels: {
+      error: 0,
+      warn: 1,
+      info: 2,
+      http: 3,
+      verbose: 4,
+      debug: 5,
+      silly: 6
+    }
+  }),
+  simple()
+);
+
+const info = paddedFormat.transform({
+  level: 'info',
+  message: 'This is an info level message.'
+});
+const error = paddedFormat.transform({
+  level: 'error',
+  message: 'This is an error level message.'
+});
+const verbose = paddedFormat.transform({
+  level: 'verbose',
+  message: 'This is a verbose level message.'
+});
+
+console.dir(info[MESSAGE]);
+console.dir(error[MESSAGE]);
+console.dir(verbose[MESSAGE]);

package/node_modules/winston-compat/node_modules/logform/examples/volume.js

@@ -0,0 +1,25 @@
+const { format } = require('../');
+
+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));
+
+// `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));

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

@@ -0,0 +1,52 @@
+'use strict';
+
+/*
+ * Displays a helpful message and the source of
+ * the format when it is invalid.
+ */
+class InvalidFormatError extends Error {
+  constructor(formatFn) {
+    super(`Format functions must be synchronous taking a two arguments: (info, opts)
+Found: ${formatFn.toString().split('\n')[0]}\n`);
+
+    Error.captureStackTrace(this, InvalidFormatError);
+  }
+}
+
+/*
+ * function format (formatFn)
+ * Returns a create function for the `formatFn`.
+ */
+module.exports = 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(options = {}) {
+    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/index.d.ts

@@ -0,0 +1,53 @@
+// Type definitions for logform 1.2
+// Project: https://github.com/winstonjs/logform
+// Definitions by: DABH <https://github.com/DABH>
+// Definitions: https://github.com/winstonjs/logform
+// TypeScript Version: 2.2
+
+export interface TransformableInfo {
+  level: string;
+  message: string;
+  [key: string]: any;
+}
+
+export type TransformFunction = (info: TransformableInfo, opts?: any) => TransformableInfo | boolean;
+export type Colors = { [key: string]: string | string[] }; // tslint:disable-line interface-over-type-literal
+export type FormatWrap = (opts?: any) => Format;
+
+export class Format {
+  constructor(opts?: object);
+
+  options?: object;
+  transform: TransformFunction;
+}
+
+export class Colorizer extends Format {
+  constructor(opts?: object);
+
+  createColorize: (opts?: object) => Colorizer;
+  addColors: (colors: Colors) => Colors;
+  colorize: (level: string, message: string) => string;
+}
+
+export function format(transform: TransformFunction): FormatWrap;
+
+export function levels(config: object): object;
+
+export namespace format {
+  function align(opts?: object): Format;
+  function cli(opts?: object): Format;
+  function colorize(opts?: object): Colorizer;
+  function combine(...formats: Format[]): Format;
+  function json(opts?: object): Format;
+  function label(opts?: object): Format;
+  function logstash(opts?: object): Format;
+  function metadata(opts?: object): Format;  
+  function ms(opts?: object): Format;
+  function padLevels(opts?: object): Format;
+  function prettyPrint(opts?: object): Format;
+  function printf(templateFunction: (info: TransformableInfo) => string): Format;
+  function simple(opts?: object): Format;
+  function splat(opts?: object): Format;
+  function timestamp(opts?: object): Format;
+  function uncolorize(opts?: object): Format;
+}

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

@@ -0,0 +1,52 @@
+'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');
+
+/*
+ * @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() {
+      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/json.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const format = require('./format');
+const { MESSAGE } = require('triple-beam');
+const 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((info, opts) => {
+  info[MESSAGE] = jsonStringify(info, opts.replacer || replacer, opts.space);
+  return info;
+});

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

@@ -0,0 +1,19 @@
+'use strict';
+
+const 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((info, opts) => {
+  if (opts.message) {
+    info.message = `[${opts.label}] ${info.message}`;
+    return info;
+  }
+
+  info.label = opts.label;
+  return info;
+});