@contrast/agent 3.11.10

package/node_modules/winston/node_modules/readable-stream/lib/internal/streams/pipeline.js

@@ -0,0 +1,97 @@
+// Ported from https://github.com/mafintosh/pump with
+// permission from the author, Mathias Buus (@mafintosh).
+'use strict';
+
+var eos;
+
+function once(callback) {
+  var called = false;
+  return function () {
+    if (called) return;
+    called = true;
+    callback.apply(void 0, arguments);
+  };
+}
+
+var _require$codes = require('../../../errors').codes,
+    ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
+    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
+
+function noop(err) {
+  // Rethrow the error if it exists to avoid swallowing it
+  if (err) throw err;
+}
+
+function isRequest(stream) {
+  return stream.setHeader && typeof stream.abort === 'function';
+}
+
+function destroyer(stream, reading, writing, callback) {
+  callback = once(callback);
+  var closed = false;
+  stream.on('close', function () {
+    closed = true;
+  });
+  if (eos === undefined) eos = require('./end-of-stream');
+  eos(stream, {
+    readable: reading,
+    writable: writing
+  }, function (err) {
+    if (err) return callback(err);
+    closed = true;
+    callback();
+  });
+  var destroyed = false;
+  return function (err) {
+    if (closed) return;
+    if (destroyed) return;
+    destroyed = true; // request.destroy just do .end - .abort is what we want
+
+    if (isRequest(stream)) return stream.abort();
+    if (typeof stream.destroy === 'function') return stream.destroy();
+    callback(err || new ERR_STREAM_DESTROYED('pipe'));
+  };
+}
+
+function call(fn) {
+  fn();
+}
+
+function pipe(from, to) {
+  return from.pipe(to);
+}
+
+function popCallback(streams) {
+  if (!streams.length) return noop;
+  if (typeof streams[streams.length - 1] !== 'function') return noop;
+  return streams.pop();
+}
+
+function pipeline() {
+  for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
+    streams[_key] = arguments[_key];
+  }
+
+  var callback = popCallback(streams);
+  if (Array.isArray(streams[0])) streams = streams[0];
+
+  if (streams.length < 2) {
+    throw new ERR_MISSING_ARGS('streams');
+  }
+
+  var error;
+  var destroys = streams.map(function (stream, i) {
+    var reading = i < streams.length - 1;
+    var writing = i > 0;
+    return destroyer(stream, reading, writing, function (err) {
+      if (!error) error = err;
+      if (err) destroys.forEach(call);
+      if (reading) return;
+      destroys.forEach(call);
+      callback(error);
+    });
+  });
+  return streams.reduce(pipe);
+}
+
+module.exports = pipeline;

package/node_modules/winston/node_modules/readable-stream/lib/internal/streams/state.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;
+
+function highWaterMarkFrom(options, isDuplex, duplexKey) {
+  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
+}
+
+function getHighWaterMark(state, options, duplexKey, isDuplex) {
+  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
+
+  if (hwm != null) {
+    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
+      var name = isDuplex ? duplexKey : 'highWaterMark';
+      throw new ERR_INVALID_OPT_VALUE(name, hwm);
+    }
+
+    return Math.floor(hwm);
+  } // Default value
+
+
+  return state.objectMode ? 16 : 16 * 1024;
+}
+
+module.exports = {
+  getHighWaterMark: getHighWaterMark
+};

package/node_modules/winston/node_modules/readable-stream/lib/internal/streams/stream-browser.js

@@ -0,0 +1 @@
+module.exports = require('events').EventEmitter;

package/node_modules/winston/node_modules/readable-stream/lib/internal/streams/stream.js

@@ -0,0 +1 @@
+module.exports = require('stream');

package/node_modules/winston/node_modules/readable-stream/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "readable-stream",
+  "version": "3.6.0",
+  "description": "Streams3, a user-land copy of the stream library from Node.js",
+  "main": "readable.js",
+  "engines": {
+    "node": ">= 6"
+  },
+  "dependencies": {
+    "inherits": "^2.0.3",
+    "string_decoder": "^1.1.1",
+    "util-deprecate": "^1.0.1"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.2.0",
+    "@babel/core": "^7.2.0",
+    "@babel/polyfill": "^7.0.0",
+    "@babel/preset-env": "^7.2.0",
+    "airtap": "0.0.9",
+    "assert": "^1.4.0",
+    "bl": "^2.0.0",
+    "deep-strict-equal": "^0.2.0",
+    "events.once": "^2.0.2",
+    "glob": "^7.1.2",
+    "gunzip-maybe": "^1.4.1",
+    "hyperquest": "^2.1.3",
+    "lolex": "^2.6.0",
+    "nyc": "^11.0.0",
+    "pump": "^3.0.0",
+    "rimraf": "^2.6.2",
+    "tap": "^12.0.0",
+    "tape": "^4.9.0",
+    "tar-fs": "^1.16.2",
+    "util-promisify": "^2.1.0"
+  },
+  "scripts": {
+    "test": "tap -J --no-esm test/parallel/*.js test/ours/*.js",
+    "ci": "TAP=1 tap --no-esm test/parallel/*.js test/ours/*.js | tee test.tap",
+    "test-browsers": "airtap --sauce-connect --loopback airtap.local -- test/browser.js",
+    "test-browser-local": "airtap --open --local -- test/browser.js",
+    "cover": "nyc npm test",
+    "report": "nyc report --reporter=lcov",
+    "update-browser-errors": "babel -o errors-browser.js errors.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/nodejs/readable-stream"
+  },
+  "keywords": [
+    "readable",
+    "stream",
+    "pipe"
+  ],
+  "browser": {
+    "util": false,
+    "worker_threads": false,
+    "./errors": "./errors-browser.js",
+    "./readable.js": "./readable-browser.js",
+    "./lib/internal/streams/from.js": "./lib/internal/streams/from-browser.js",
+    "./lib/internal/streams/stream.js": "./lib/internal/streams/stream-browser.js"
+  },
+  "nyc": {
+    "include": [
+      "lib/**.js"
+    ]
+  },
+  "license": "MIT"
+
+,"_resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz"
+,"_integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA=="
+,"_from": "readable-stream@3.6.0"
+}

package/node_modules/winston/node_modules/readable-stream/readable-browser.js

@@ -0,0 +1,9 @@
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Stream = exports;
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');
+exports.finished = require('./lib/internal/streams/end-of-stream.js');
+exports.pipeline = require('./lib/internal/streams/pipeline.js');

package/node_modules/winston/node_modules/readable-stream/readable.js

@@ -0,0 +1,16 @@
+var Stream = require('stream');
+if (process.env.READABLE_STREAM === 'disable' && Stream) {
+  module.exports = Stream.Readable;
+  Object.assign(module.exports, Stream);
+  module.exports.Stream = Stream;
+} else {
+  exports = module.exports = require('./lib/_stream_readable.js');
+  exports.Stream = Stream || exports;
+  exports.Readable = exports;
+  exports.Writable = require('./lib/_stream_writable.js');
+  exports.Duplex = require('./lib/_stream_duplex.js');
+  exports.Transform = require('./lib/_stream_transform.js');
+  exports.PassThrough = require('./lib/_stream_passthrough.js');
+  exports.finished = require('./lib/internal/streams/end-of-stream.js');
+  exports.pipeline = require('./lib/internal/streams/pipeline.js');
+}

package/node_modules/winston/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "winston",
+  "description": "A logger for just about everything.",
+  "version": "3.3.3",
+  "author": "Charlie Robbins <charlie.robbins@gmail.com>",
+  "maintainers": [
+    "Jarrett Cruger <jcrugzz@gmail.com>",
+    "Chris Alderson <chrisalderson@protonmail.com>",
+    "David Hyde <dabh@stanford.edu>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/winstonjs/winston.git"
+  },
+  "keywords": [
+    "winston",
+    "logger",
+    "logging",
+    "logs",
+    "sysadmin",
+    "bunyan",
+    "pino",
+    "loglevel",
+    "tools",
+    "json",
+    "stream"
+  ],
+  "dependencies": {
+    "async": "^3.1.0",
+    "@dabh/diagnostics": "^2.0.2",
+    "is-stream": "^2.0.0",
+    "logform": "^2.2.0",
+    "one-time": "^1.0.0",
+    "readable-stream": "^3.4.0",
+    "stack-trace": "0.0.x",
+    "triple-beam": "^1.3.0",
+    "winston-transport": "^4.4.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.10.3",
+    "@babel/core": "^7.10.3",
+    "@babel/preset-env": "^7.10.3",
+    "@types/node": "^14.0.13",
+    "abstract-winston-transport": "^0.5.1",
+    "assume": "^2.2.0",
+    "colors": "^1.4.0",
+    "cross-spawn-async": "^2.2.5",
+    "eslint-config-populist": "^4.2.0",
+    "hock": "^1.4.1",
+    "mocha": "^8.0.1",
+    "nyc": "^15.1.0",
+    "rimraf": "^3.0.2",
+    "split2": "^3.1.1",
+    "std-mocks": "^1.0.1",
+    "through2": "^3.0.1",
+    "winston-compat": "^0.1.5"
+  },
+  "main": "./lib/winston",
+  "browser": "./dist/winston",
+  "types": "./index.d.ts",
+  "scripts": {
+    "lint": "populist lib/*.js lib/winston/*.js lib/winston/**/*.js",
+    "pretest": "npm run lint",
+    "test": "nyc --reporter=text --reporter lcov npm run test:mocha",
+    "test:mocha": "mocha test/*.test.js test/**/*.test.js --exit",
+    "build": "./node_modules/.bin/rimraf dist && babel lib -d dist",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">= 6.4.0"
+  },
+  "license": "MIT"
+
+,"_resolved": "https://registry.npmjs.org/winston/-/winston-3.3.3.tgz"
+,"_integrity": "sha512-oEXTISQnC8VlSAKf1KYSSd7J6IWuRPQqDdo8eoRNaYKLvwSb5+79Z3Yi1lrl6KDpU6/VWaxpakDAtb1oQ4n9aw=="
+,"_from": "winston@3.3.3"
+}

package/node_modules/winston-compat/.gitattributes

@@ -0,0 +1 @@
+package-lock.json binary

package/node_modules/winston-compat/.node-version

@@ -0,0 +1 @@
+10.15.1

package/node_modules/winston-compat/CHANGELOG.md

@@ -0,0 +1,17 @@
+# CHANGELOG
+
+### 0.1.2
+
+- [#7] require `'util'`.
+
+### 0.1.1
+
+- Move `vows` to `devDependencies`.
+
+### 0.1.0
+
+- Add legacy `vows`-based test helpers.
+
+### 0.0.1
+
+- Initial release

package/node_modules/winston-compat/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Charlie Robbins & the contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/node_modules/winston-compat/README.md

@@ -0,0 +1,2 @@
+# winston-compat
+Core functionality from winston < 3.0.0 commonly used by user-created transports.

package/node_modules/winston-compat/index.js

@@ -0,0 +1,295 @@
+'use strict';
+
+var cycle = require('cycle');
+var util = require('util');
+var { levels, format } = require('logform');
+var { configs } = require('triple-beam');
+var { colorize } = format;
+
+levels(configs.cli);
+levels(configs.npm);
+levels(configs.syslog);
+
+//
+// Expose base Transport
+//
+exports.Transport = require('./lib/transport');
+
+//
+// ### function clone (obj)
+// #### @obj {Object} Object to clone.
+// Helper method for deep cloning pure JSON objects
+// i.e. JSON objects that are either literals or objects (no Arrays, etc)
+//
+exports.clone = function (obj) {
+  //
+  // We only need to clone reference types (Object)
+  //
+  var copy = {};
+
+  if (obj instanceof Error) {
+    // With potential custom Error objects, this might not be exactly correct,
+    // but probably close-enough for purposes of this lib.
+    copy = new Error(obj.message);
+    Object.getOwnPropertyNames(obj).forEach(function (key) {
+      copy[key] = obj[key];
+    });
+
+    return copy;
+  }
+  else if (!(obj instanceof Object)) {
+    return obj;
+  }
+  else if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+
+  for (var i in obj) {
+    if (obj.hasOwnProperty(i)) {
+      if (Array.isArray(obj[i])) {
+        copy[i] = obj[i].slice(0);
+      }
+      else if (obj[i] instanceof Buffer) {
+        copy[i] = obj[i].slice(0);
+      }
+      else if (typeof obj[i] != 'function') {
+        copy[i] = obj[i] instanceof Object ? exports.clone(obj[i]) : obj[i];
+      }
+      else if (typeof obj[i] === 'function') {
+        copy[i] = obj[i];
+      }
+    }
+  }
+
+  return copy;
+};
+
+//
+// ### function log (options)
+// #### @options {Object} All information about the log serialization.
+// Generic logging function for returning timestamped strings
+// with the following options:
+//
+//    {
+//      level:     'level to add to serialized message',
+//      message:   'message to serialize',
+//      meta:      'additional logging metadata to serialize',
+//      colorize:  false, // Colorizes output (only if `.json` is false)
+//      align:     false  // Align message level.
+//      timestamp: true   // Adds a timestamp to the serialized message
+//      label:     'label to prepend the message'
+//    }
+//
+exports.log = function (options) {
+  var timestampFn = typeof options.timestamp === 'function'
+        ? options.timestamp
+        : exports.timestamp,
+      timestamp   = options.timestamp ? timestampFn() : null,
+      showLevel   = options.showLevel === undefined ? true : options.showLevel,
+      meta        = options.meta !== null && options.meta !== undefined && !(options.meta instanceof Error)
+        ? exports.clone(cycle.decycle(options.meta))
+        : options.meta || null,
+      output;
+
+  //
+  // raw mode is intended for outputing winston as streaming JSON to STDOUT
+  //
+  if (options.raw) {
+    if (typeof meta !== 'object' && meta != null) {
+      meta = { meta: meta };
+    }
+    output         = exports.clone(meta) || {};
+    output.level   = options.level;
+    //
+    // Remark (jcrugzz): This used to be output.message = options.message.stripColors.
+    // I do not know why this is, it does not make sense but im handling that
+    // case here as well as handling the case that does make sense which is to
+    // make the `output.message = options.message`
+    //
+    output.message = options.message.stripColors
+      ? options.message.stripColors
+      : options.message;
+
+    return JSON.stringify(output);
+  }
+
+  //
+  // json mode is intended for pretty printing multi-line json to the terminal
+  //
+  if (options.json || true === options.logstash) {
+    if (typeof meta !== 'object' && meta != null) {
+      meta = { meta: meta };
+    }
+
+    output         = exports.clone(meta) || {};
+    output.level   = options.level;
+    output.message = output.message || '';
+
+    if (options.label) { output.label = options.label; }
+    if (options.message) { output.message = options.message; }
+    if (timestamp) { output.timestamp = timestamp; }
+
+    if (options.logstash === true) {
+      // use logstash format
+      var logstashOutput = {};
+      if (output.message !== undefined) {
+        logstashOutput['@message'] = output.message;
+        delete output.message;
+      }
+
+      if (output.timestamp !== undefined) {
+        logstashOutput['@timestamp'] = output.timestamp;
+        delete output.timestamp;
+      }
+
+      logstashOutput['@fields'] = exports.clone(output);
+      output = logstashOutput;
+    }
+
+    if (typeof options.stringify === 'function') {
+      return options.stringify(output);
+    }
+
+    return JSON.stringify(output, function (key, value) {
+      return value instanceof Buffer
+        ? value.toString('base64')
+        : value;
+    });
+  }
+
+  //
+  // Remark: this should really be a call to `util.format`.
+  //
+  if (typeof options.formatter == 'function') {
+    return String(options.formatter(exports.clone(options)));
+  }
+
+  output = timestamp ? timestamp + ' - ' : '';
+  if (showLevel) {
+    var opts = {};
+    opts.level = options.colorize === 'level';
+    opts.all = options.colorize === 'all' || options.colorize === true;
+
+    output += opts.level || opts.all
+      ? colorize().transform(options, opts).level
+      : options.level;
+  }
+
+  output += (options.align) ? '\t' : '';
+  output += (timestamp || showLevel) ? ': ' : '';
+  output += options.label ? ('[' + options.label + '] ') : '';
+  var opts = {};
+  opts.message = options.colorize === 'message';
+  opts.all = options.colorize === 'all';
+
+  output += opts.all || opts.message
+    ? colorize.transform(options, opts).message
+    : options.message;
+
+  if (meta !== null && meta !== undefined) {
+    if (meta && meta instanceof Error && meta.stack) {
+      meta = meta.stack;
+    }
+
+    if (typeof meta !== 'object') {
+      output += ' ' + meta;
+    }
+    else if (Object.keys(meta).length > 0) {
+      if (typeof options.prettyPrint === 'function') {
+        output += ' ' + options.prettyPrint(meta);
+      } else if (options.prettyPrint) {
+        output += ' ' + '\n' + util.inspect(meta, false, options.depth || null, options.colorize);
+      } else if (
+        options.humanReadableUnhandledException
+          && Object.keys(meta).length === 5
+          && meta.hasOwnProperty('date')
+          && meta.hasOwnProperty('process')
+          && meta.hasOwnProperty('os')
+          && meta.hasOwnProperty('trace')
+          && meta.hasOwnProperty('stack')) {
+
+        //
+        // If meta carries unhandled exception data serialize the stack nicely
+        //
+        var stack = meta.stack;
+        delete meta.stack;
+        delete meta.trace;
+        output += ' ' + exports.serialize(meta);
+
+        if (stack) {
+          output += '\n' + stack.join('\n');
+        }
+      } else {
+        output += ' ' + exports.serialize(meta);
+      }
+    }
+  }
+
+  return output;
+};
+
+//
+// ### function serialize (obj, key)
+// #### @obj {Object|literal} Object to serialize
+// #### @key {string} **Optional** Optional key represented by obj in a larger object
+// Performs simple comma-separated, `key=value` serialization for Loggly when
+// logging to non-JSON inputs.
+//
+exports.serialize = function (obj, key) {
+  if (obj === null) {
+    obj = 'null';
+  }
+  else if (obj === undefined) {
+    obj = 'undefined';
+  }
+  else if (obj === false) {
+    obj = 'false';
+  }
+
+  if (typeof obj !== 'object') {
+    return key ? key + '=' + obj : obj;
+  }
+
+  if (obj instanceof Buffer) {
+    return key ? key + '=' + obj.toString('base64') : obj.toString('base64');
+  }
+
+  var msg = '',
+      keys = Object.keys(obj),
+      length = keys.length;
+
+  for (var i = 0; i < length; i++) {
+    if (Array.isArray(obj[keys[i]])) {
+      msg += keys[i] + '=[';
+
+      for (var j = 0, l = obj[keys[i]].length; j < l; j++) {
+        msg += exports.serialize(obj[keys[i]][j]);
+        if (j < l - 1) {
+          msg += ', ';
+        }
+      }
+
+      msg += ']';
+    }
+    else if (obj[keys[i]] instanceof Date) {
+      msg += keys[i] + '=' + obj[keys[i]];
+    }
+    else {
+      msg += exports.serialize(obj[keys[i]], keys[i]);
+    }
+
+    if (i < length - 1) {
+      msg += ', ';
+    }
+  }
+
+  return msg;
+};
+
+//
+// ### function timestamp ()
+// Returns a timestamp string for the current time.
+//
+exports.timestamp = function () {
+  return new Date().toISOString();
+};