@contrast/agent 4.2.0

package/node_modules/logform/dist/splat.js

@@ -0,0 +1,159 @@
+'use strict';
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+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 = /*#__PURE__*/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 the additional metas are **NOT** objects or **LACK** enumerable properties
+      // you are going to have a bad time.
+
+      var metalen = metas.length;
+
+      if (metalen) {
+        for (var i = 0; i < metalen; i++) {
+          Object.assign(info, metas[i]);
+        }
+      }
+
+      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 the additional metas are **NOT** objects or **LACK** enumerable properties
+        // you are going to have a bad time.
+
+        var metalen = metas.length;
+
+        if (metalen) {
+          for (var i = 0; i < metalen; i++) {
+            Object.assign(info, metas[i]);
+          }
+        }
+
+        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/logform/dist/timestamp.js

@@ -0,0 +1,32 @@
+'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) {
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  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/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/logform/errors.js

@@ -0,0 +1,39 @@
+/* eslint no-undefined: 0 */
+'use strict';
+
+const format = require('./format');
+const { LEVEL, MESSAGE } = require('triple-beam');
+
+/*
+ * function errors (info)
+ * If the `message` property of the `info` object is an instance of `Error`,
+ * replace the `Error` object its own `message` property.
+ *
+ * Optionally, the Error's `stack` property can also be appended to the `info` object.
+ */
+module.exports = format((einfo, { stack }) => {
+  if (einfo instanceof Error) {
+    const info = Object.assign({}, einfo, {
+      level: einfo.level,
+      [LEVEL]: einfo[LEVEL] || einfo.level,
+      message: einfo.message,
+      [MESSAGE]: einfo[MESSAGE] || einfo.message
+    });
+
+    if (stack) info.stack = einfo.stack;
+    return info;
+  }
+
+  if (!(einfo.message instanceof Error)) return einfo;
+
+  // Assign all enumerable properties and the
+  // message property from the error provided.
+  Object.assign(einfo, einfo.message);
+  const err = einfo.message;
+  einfo.message = err.message;
+  einfo[MESSAGE] = err.message;
+
+  // Assign the stack if requested.
+  if (stack) einfo.stack = err.stack;
+  return einfo;
+});

package/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/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/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/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/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/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/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/logform/index.d.ts

@@ -0,0 +1,161 @@
+// 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(): Format;
+  function cli(opts?: CliOptions): Format;
+  function colorize(opts?: ColorizeOptions): Colorizer;
+  function combine(...formats: Format[]): Format;
+  function errors(opts?: object): Format;
+  function json(opts?: JsonOptions): Format;
+  function label(opts?: LabelOptions): Format;
+  function logstash(): Format;
+  function metadata(opts?: MetadataOptions): Format;
+  function ms(): Format;
+  function padLevels(opts?: PadLevelsOptions): Format;
+  function prettyPrint(opts?: PrettyPrintOptions): Format;
+  function printf(templateFunction: (info: TransformableInfo) => string): Format;
+  function simple(): Format;
+  function splat(): Format;
+  function timestamp(opts?: TimestampOptions): Format;
+  function uncolorize(opts?: UncolorizeOptions): Format;
+}
+
+export interface CliOptions extends ColorizeOptions, PadLevelsOptions {}
+
+export interface ColorizeOptions {
+  /**
+   * If set to `true` the color will be applied to the `level`.
+   */
+  level?: boolean;
+  /**
+   * If set to `true` the color will be applied to the `message` and `level`.
+   */
+  all?: boolean;
+  /**
+   * If set to `true` the color will be applied to the `message`.
+   */
+  message?: boolean;
+  /**
+   * An object containing the colors for the log levels. For example: `{ info: 'blue', error: 'red' }`.
+   */
+  colors?: Record<string, string>;
+}
+
+export interface JsonOptions {
+  /**
+   * A function that influences how the `info` is stringified.
+   */
+  replacer?: (this: any, key: string, value: any) => any;
+  /**
+   * The number of white space used to format the json.
+   */
+  space?: number;
+}
+
+export interface LabelOptions {
+  /**
+   * A label to be added before the message.
+   */
+  label?: string;
+  /**
+   * If set to `true` the `label` will be added to `info.message`. If set to `false` the `label`
+   * will be added as `info.label`.
+   */
+  message?: boolean;
+}
+
+export interface MetadataOptions {
+  /**
+   * The name of the key used for the metadata object. Defaults to `metadata`.
+   */
+  key?: string;
+  /**
+   * An array of keys that should not be added to the metadata object.
+   */
+  fillExcept?: string[];
+  /**
+   * An array of keys that will be added to the metadata object.
+   */
+  fillWith?: string[];
+}
+
+export interface PadLevelsOptions {
+  /**
+   * Log levels. Defaults to `configs.npm.levels` from [triple-beam](https://github.com/winstonjs/triple-beam)
+   * module.
+   */
+  levels?: Record<string, number>;
+}
+
+export interface PrettyPrintOptions {
+  /**
+   * A `number` that specifies the maximum depth of the `info` object being stringified by
+   * `util.inspect`. Defaults to `2`.
+   */
+  depth?: number;
+  /**
+   * Colorizes the message if set to `true`. Defaults to `false`.
+   */
+  colorize?: boolean;
+}
+
+export interface TimestampOptions {
+  /**
+   * Either the format as a string accepted by the [fecha](https://github.com/taylorhakes/fecha)
+   * module or a function that returns a formatted date. If no format is provided `new
+   * Date().toISOString()` will be used.
+   */
+  format?: string | (() => string);
+  /**
+   * The name of an alias for the timestamp property, that will be added to the `info` object.
+   */
+  alias?: string;
+}
+
+export interface UncolorizeOptions {
+  /**
+   * Disables the uncolorize format for `info.level` if set to `false`.
+   */
+  level?: boolean;
+  /**
+   * Disables the uncolorize format for `info.message` if set to `false`.
+   */
+  message?: boolean;
+  /**
+   * Disables the uncolorize format for `info[MESSAGE]` if set to `false`.
+   */
+  raw?: boolean;
+}