@contrast/agent 3.11.10

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

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

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

@@ -0,0 +1,29 @@
+'use strict';
+
+const format = require('./format');
+const { MESSAGE } = require('triple-beam');
+const 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(info => {
+  const 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/metadata.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const format = require('./format');
+
+function fillExcept(info, fillExceptKeys, metadataKey) {
+  const savedKeys = fillExceptKeys.reduce((acc, key) => {
+    acc[key] = info[key];
+    delete info[key];
+    return acc;
+  }, {});
+  const metadata = Object.keys(info).reduce((acc, key) => {
+    acc[key] = info[key];
+    delete info[key];
+    return acc;
+  }, {});
+
+  Object.assign(info, savedKeys, {
+    [metadataKey]: metadata
+  });
+  return info;
+}
+
+function fillWith(info, fillWithKeys, metadataKey) {
+  info[metadataKey] = fillWithKeys.reduce((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((info, opts = {}) => {
+  let metadataKey = 'metadata';
+  if (opts.key) {
+    metadataKey = opts.key;
+  }
+
+  let 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/ms.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const format = require('./format');
+const 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(info => {
+  const curr = +new Date();
+  this.diff = curr - (this.prevTime || curr);
+  this.prevTime = curr;
+  info.ms = `+${ms(this.diff)}`;
+
+  return info;
+});

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

@@ -0,0 +1,51 @@
+{
+  "name": "logform",
+  "version": "1.10.0",
+  "description": "An mutable object-based log format designed for chaining & objectMode streams.",
+  "main": "index.js",
+  "browser": "dist/browser.js",
+  "scripts": {
+    "lint": "populist *.js test/*.js examples/*.js",
+    "pretest": "npm run lint && npm run build",
+    "test": "nyc mocha test/*.test.js",
+    "build": "rimraf dist && babel *.js -d ./dist",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/winstonjs/logform.git"
+  },
+  "keywords": [
+    "winston",
+    "logging",
+    "format",
+    "winstonjs"
+  ],
+  "author": "Charlie Robbins <charlie.robbins@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/winstonjs/logform/issues"
+  },
+  "homepage": "https://github.com/winstonjs/logform#readme",
+  "dependencies": {
+    "colors": "^1.2.1",
+    "fast-safe-stringify": "^2.0.4",
+    "fecha": "^2.3.3",
+    "ms": "^2.1.1",
+    "triple-beam": "^1.2.0"
+  },
+  "devDependencies": {
+    "assume": "^2.0.1",
+    "babel-cli": "^6.26.0",
+    "babel-preset-env": "^1.7.0",
+    "eslint-config-populist": "^4.1.0",
+    "mocha": "^5.1.1",
+    "nyc": "^11.7.1",
+    "rimraf": "^2.6.2"
+  },
+  "types": "./index.d.ts"
+
+,"_resolved": "https://registry.npmjs.org/logform/-/logform-1.10.0.tgz"
+,"_integrity": "sha512-em5ojIhU18fIMOw/333mD+ZLE2fis0EzXl1ZwHx4iQzmpQi6odNiY/t+ITNr33JZhT9/KEaH+UPIipr6a9EjWg=="
+,"_from": "logform@1.10.0"
+}

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

@@ -0,0 +1,83 @@
+/* eslint no-unused-vars: 0 */
+'use strict';
+
+const { configs, LEVEL, MESSAGE } = require('triple-beam');
+
+class Padder {
+  constructor(opts = { levels: configs.npm.levels }) {
+    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.
+   */
+  static getLongestLevel(levels) {
+    const lvls = Object.keys(levels).map(level => level.length);
+    return Math.max(...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`
+   */
+  static paddingForLevel(level, filler, maxLength) {
+    const targetLen = maxLength + 1 - level.length;
+    const rep = Math.floor(targetLen / filler.length);
+    const 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.
+   */
+  static paddingForLevels(levels, filler = ' ') {
+    const maxLength = Padder.getLongestLevel(levels);
+    return Object.keys(levels).reduce((acc, level) => {
+      acc[level] = Padder.paddingForLevel(level, filler, maxLength);
+      return acc;
+    }, {});
+  }
+
+  /**
+   * 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.
+   */
+  transform(info, opts) {
+    info.message = `${this.paddings[info[LEVEL]]}${info.message}`;
+    if (info[MESSAGE]) {
+      info[MESSAGE] = `${this.paddings[info[LEVEL]]}${info[MESSAGE]}`;
+    }
+
+    return info;
+  }
+}
+
+/*
+ * 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 = opts => new Padder(opts);
+
+module.exports.Padder
+  = module.exports.Format
+  = Padder;

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

@@ -0,0 +1,16 @@
+'use strict';
+
+const inspect = require('util').inspect;
+const format = require('./format');
+const { MESSAGE } = require('triple-beam');
+
+/*
+ * 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((info, opts) => {
+  info[MESSAGE] = inspect(info, false, opts.depth || null, opts.colorize);
+  return info;
+});

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

@@ -0,0 +1,26 @@
+'use strict';
+
+const { MESSAGE } = require('triple-beam');
+
+class Printf {
+  constructor(templateFn) {
+    this.template = templateFn;
+  }
+
+  transform(info) {
+    info[MESSAGE] = this.template(info);
+    return info;
+  }
+}
+
+/*
+ * 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 = opts => new Printf(opts);
+
+module.exports.Printf
+  = module.exports.Format
+  = Printf;

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

@@ -0,0 +1,33 @@
+/* eslint no-undefined: 0 */
+'use strict';
+
+const format = require('./format');
+const { MESSAGE } = require('triple-beam');
+const 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(info => {
+  const stringifiedRest = jsonStringify(Object.assign({}, info, {
+    level: undefined,
+    message: undefined,
+    splat: undefined
+  }));
+
+  const 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/splat.js

@@ -0,0 +1,125 @@
+'use strict';
+
+const util = require('util');
+const { SPLAT } = require('triple-beam');
+
+/**
+ * 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}
+ */
+const formatRegExp = /%[scdjifoO%]/g;
+
+/**
+ * Captures the number of escaped % signs in a format string (i.e. %s strings).
+ * @type {RegExp}
+ */
+const escapedPercent = /%%/g;
+
+class Splatter {
+  constructor(opts) {
+    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
+     */
+  _splat(info, tokens) {
+    const msg = info.message;
+    const splat = info[SPLAT] || info.splat || [];
+    const percents = msg.match(escapedPercent);
+    const 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' }]
+    const expectedSplat = tokens.length - escapes;
+    const extraSplat = expectedSplat - splat.length;
+    const 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(msg, ...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
+     */
+  transform(info) {
+    const msg = info.message;
+    const 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
+    const 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)) {
+      const 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;
+  }
+}
+
+/*
+ * 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 = opts => new Splatter(opts);

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

@@ -0,0 +1,30 @@
+'use strict';
+
+const fecha = require('fecha');
+const 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((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/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "lib": [
+      "es6"
+    ],
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "baseUrl": "../",
+    "typeRoots": [
+      "../"
+    ],
+    "types": [],
+    "noEmit": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "files": [
+    "index.d.ts"
+  ]
+}

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

@@ -0,0 +1,27 @@
+'use strict';
+
+const colors = require('colors/safe');
+const format = require('./format');
+const { MESSAGE } = require('triple-beam');
+
+/*
+ * 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((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/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "winston-compat",
+  "version": "0.1.5",
+  "description": "Core functionality from winston < 3.0.0 commonly used by user-created transports.",
+  "main": "index.js",
+  "scripts": {
+    "test": "nyc mocha test/*.test.js",
+    "preversion": "npm test",
+    "postversion": "git push && git push --tags && npm publish"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/winstonjs/winston-compat.git"
+  },
+  "keywords": [
+    "winston",
+    "winston2",
+    "winston1"
+  ],
+  "author": "Charlie Robbins <charlie.robbins@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/winstonjs/winston-compat/issues"
+  },
+  "homepage": "https://github.com/winstonjs/winston-compat#readme",
+  "dependencies": {
+    "cycle": "~1.0.3",
+    "logform": "^1.6.0",
+    "triple-beam": "^1.2.0"
+  },
+  "devDependencies": {
+    "assume": "^1.3.1",
+    "eslint-config-populist": "^4.2.0",
+    "mocha": "^7.1.0",
+    "nyc": "^15.0.0",
+    "vows": "^0.8.3",
+    "winston": "^2.1.1"
+  },
+  "engines": {
+    "node": ">= 6.4.0"
+  }
+
+,"_resolved": "https://registry.npmjs.org/winston-compat/-/winston-compat-0.1.5.tgz"
+,"_integrity": "sha512-EPvPcHT604AV3Ji6d3+vX8ENKIml9VSxMRnPQ+cuK/FX6f3hvPP2hxyoeeCOCFvDrJEujalfcKWlWPvAnFyS9g=="
+,"_from": "winston-compat@0.1.5"
+}

package/node_modules/winston-compat/test/clone.test.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var assume = require('assume'),
+    compat = require('../');
+
+describe('clone()', function () {
+  it('clone(Error)', function () {
+    var original = new Error("foo"),
+        copy;
+
+    original.name = "bar";
+    copy = compat.clone(original);
+    assume(original).not.equals(copy);
+    assume(original.message).equals(copy.message);
+    assume(original.name).equals(copy.name);
+  });
+
+  it('clone(Date)', function () {
+    var original = new Date(1000);
+    var copy = compat.clone(original);
+
+    assume(original).not.equals(copy);
+    assume(original.getTime()).equals(copy.getTime());
+  });
+});