newrelic 7.5.0 → 8.1.0

package/lib/instrumentation/mongodb.js

@@ -6,6 +6,9 @@
 'use strict'
 
 const semver = require('semver')
+const instrument = require('./mongodb/v2-mongo')
+const instrumentV3 = require('./mongodb/v3-mongo')
+const instrumentV4 = require('./mongodb/v4-mongo')
 
 // XXX: When this instrumentation is modularized, update this thread
 // with a cautionary note:
@@ -15,325 +18,29 @@ const semver = require('semver')
 // snippet.  The snippet will break once this file is moved from this
 // location.
 
-// legacy endpoint enumerations
-const DB_OPS = [
-  'addUser',
-  'authenticate',
-  'collection',
-  'collectionNames',
-  'collections',
-  'command',
-  'createCollection',
-  'createIndex',
-  'cursorInfo',
-  'dereference',
-  'dropCollection',
-  'dropDatabase',
-  'dropIndex',
-  'ensureIndex',
-  'eval',
-  'executeDbAdminCommand',
-  'indexInformation',
-  'logout',
-  'open',
-  'reIndex',
-  'removeUser',
-  'renameCollection',
-  'stats',
-  '_executeInsertCommand',
-  '_executeQueryCommand'
-]
-
-const COLLECTION_OPS = [
-  'aggregate',
-  'bulkWrite',
-  'count',
-  'createIndex',
-  'deleteMany',
-  'deleteOne',
-  'distinct',
-  'drop',
-  'dropAllIndexes',
-  'dropIndex',
-  'ensureIndex',
-  'findAndModify',
-  'findAndRemove',
-  'findOne',
-  'findOneAndDelete',
-  'findOneAndReplace',
-  'findOneAndUpdate',
-  'geoHaystackSearch',
-  'geoNear',
-  'group',
-  'indexes',
-  'indexExists',
-  'indexInformation',
-  'insert',
-  'insertMany',
-  'insertOne',
-  'isCapped',
-  'mapReduce',
-  'options',
-  'parallelCollectionScan',
-  'reIndex',
-  'remove',
-  'rename',
-  'replaceOne',
-  'save',
-  'stats',
-  'update',
-  'updateMany',
-  'updateOne'
-]
-
-const GRID_OPS = [
-  'put',
-  'get',
-  'delete'
-]
-
-const CURSOR_OPS = [
-  'nextObject',
-  'next',
-  'toArray',
-  'count',
-  'explain'
-]
-
 module.exports = initialize
 
+/**
+ * Registers the query parser, and relevant instrumentation
+ * based on version of mongodb
+ *
+ * @param {Agent} agent
+ * @param {Object} mongodb resolved package
+ * @param {string} moduleName name of module
+ * @param {Shim} shim
+ */
 function initialize(agent, mongodb, moduleName, shim) {
   if (!mongodb) return
 
   shim.setDatastore(shim.MONGODB)
-  shim.setParser(function mongoQueryParser(operation) {
-    let collection = this.collectionName || 'unknown'
-    if (this.collection && this.collection.collectionName) {
-      collection = this.collection.collectionName
-    } else if (this.s && this.s.name) {
-      collection = this.s.name
-    } else if (this.ns) {
-      collection = this.ns.split(/\./)[1] || collection
-    }
-
-    return {operation, collection}
-  })
 
   const mongoVersion = shim.require('./package.json').version
-  if (semver.satisfies(mongoVersion, '>=3.0.6') && mongodb.instrument) {
-    instrument306(shim, mongodb)
-  } else if (mongodb.instrument) {
-    instrumentInstrument(shim, mongodb)
+  if (semver.satisfies(mongoVersion, '>=4.0.0')) {
+    instrumentV4(shim, mongodb)
+  } else if (semver.satisfies(mongoVersion, '>=3.0.6')) {
+    instrumentV3(shim, mongodb)
   } else {
-    instrumentLegacy(shim, mongodb)
-  }
-}
-
-function instrument306(shim, mongodb) {
-  const instrumenter = mongodb.instrument(Object.create(null), () => {})
-  captureAttributesOnStarted(shim, instrumenter)
-  instrumentLegacy(shim, mongodb)
-
-  if (shim.isFunction(instrumenter.uninstrument)) {
-    shim.agent.once('unload', function uninstrumentMongo() {
-      instrumenter.uninstrument()
-    })
-  }
-}
-
-function instrumentInstrument(shim, mongodb) {
-  const recordDesc = {
-    'Gridstore': {isQuery: false, makeDesc: function makeGridDesc(opName) {
-      return {name:'GridFS-' + opName, callback: shim.LAST}
-    }},
-    'OrderedBulkOperation': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'UnorderedBulkOperation': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'CommandCursor': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'AggregationCursor': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'Cursor': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'Collection': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'Db': {isQuery: false, makeDesc: function makeDbDesc() {
-      return {callback: shim.LAST}
-    }}
-  }
-
-  // instrument using the apm api
-  const instrumenter = mongodb.instrument(Object.create(null), instrumentModules)
-  captureAttributesOnStarted(shim, instrumenter)
-
-  function instrumentModules(err, instrumentations) {
-    if (err) {
-      shim.logger
-        .trace('Unable to instrument mongo using the apm api due to error: %s', err)
-      // fallback to legacy instrumentation?
-      return
-    }
-    instrumentations.forEach(instrumentModule)
-  }
-
-  function instrumentModule(module) {
-    var object = module.obj
-    var instrumentations = module.instrumentations
-    for (var i = 0; i < instrumentations.length; i++) {
-      applyInstrumentation(module.name, object, instrumentations[i])
-    }
-  }
-
-  function applyInstrumentation(objectName, object, instrumentation) {
-    var methods = instrumentation.methods
-    var methodOptions = instrumentation.options
-    if (methodOptions.callback) {
-      for (var j = 0; j < methods.length; j++) {
-        var method = methods[j]
-
-        var isQuery = recordDesc[objectName].isQuery
-        var makeDescFunc = recordDesc[objectName].makeDesc
-        var proto = object.prototype
-        if (isQuery) {
-          shim.recordQuery(proto, method, makeDescFunc(shim, method))
-        } else if (isQuery === false) { // could be unset
-          shim.recordOperation(proto, method, makeDescFunc(shim, method))
-        } else {
-          shim.logger.trace('No wrapping method found for %s', objectName)
-        }
-      }
-    }
-
-    // the cursor object implements Readable stream and internally calls nextObject on
-    // each read, in which case we do not want to record each nextObject() call
-    if (/Cursor$/.test(objectName)) {
-      shim.recordOperation(object.prototype, 'pipe')
-    }
-  }
-}
-
-function captureAttributesOnStarted(shim, instrumenter) {
-  instrumenter.on('started', function onMongoEventStarted(evnt) {
-    // This assumes that this `started` event is fired _after_ our wrapper
-    // starts and creates the segment. We perform a check of the segment name
-    // out of an excess of caution.
-    const connId = evnt.connectionId
-    if (connId) {
-      // Mongo sticks the path to the domain socket in the "host" slot, but we
-      // want it in the "port", so if we have a domain socket we need to change
-      // the order of our parameters.
-      if (typeof connId === 'string') {
-        const parts = connId.split(':')
-        if (parts.length && parts[0][0] === '/') {
-          shim.captureInstanceAttributes('localhost', parts[0], evnt.databaseName)
-        } else {
-          shim.captureInstanceAttributes(parts[0], parts[1], evnt.databaseName)
-        }
-      } else if (connId.domainSocket) {
-        shim.captureInstanceAttributes('localhost', connId.host, evnt.databaseName)
-      } else {
-        shim.captureInstanceAttributes(connId.host, connId.port, evnt.databaseName)
-      }
-    }
-  })
-}
-
-function instrumentLegacy(shim, mongodb) {
-  instrumentCursor(mongodb.Cursor)
-  instrumentCursor(shim.require('./lib/aggregation_cursor'))
-  instrumentCursor(shim.require('./lib/command_cursor'))
-
-  if (mongodb.Collection && mongodb.Collection.prototype) {
-    const proto = mongodb.Collection.prototype
-    for (let i = 0; i < COLLECTION_OPS.length; i++) {
-      shim.recordQuery(
-        proto,
-        COLLECTION_OPS[i],
-        makeQueryDescFunc(shim, COLLECTION_OPS[i])
-      )
-    }
-  }
-
-  if (mongodb.Grid && mongodb.Grid.prototype) {
-    const proto = mongodb.Grid.prototype
-    for (let i = 0; i < CURSOR_OPS.length; i++) {
-      shim.recordOperation(proto, GRID_OPS[i],
-        {name:'GridFS-' + GRID_OPS[i], callback: shim.LAST})
-    }
-  }
-
-  if (mongodb.Db && mongodb.Db.prototype) {
-    const proto = mongodb.Db.prototype
-    shim.recordOperation(proto, DB_OPS, {callback: shim.LAST})
-    shim.recordOperation(mongodb.Db, 'connect', {callback: shim.LAST})
-  }
-
-  function instrumentCursor(Cursor) {
-    if (Cursor && Cursor.prototype) {
-      const proto = Cursor.prototype
-      for (let i = 0; i < CURSOR_OPS.length; i++) {
-        shim.recordQuery(proto, CURSOR_OPS[i], makeQueryDescFunc(shim, CURSOR_OPS[i]))
-      }
-
-      shim.recordQuery(proto, 'each', makeQueryDescFunc(shim, 'each'))
-      shim.recordOperation(proto, 'pipe')
-    }
-  }
-}
-
-function makeQueryDescFunc(shim, methodName) {
-  if (methodName === 'each') {
-    return function eachDescFunc() {
-      const parameters = getInstanceAttributeParameters(shim, this)
-      return {query: methodName, parameters, rowCallback: shim.LAST}
-    }
-  }
-
-  return function queryDescFunc() {
-    // segment name does not actually use query string
-    // method name is set as query so the query parser has access to the op name
-    const parameters = getInstanceAttributeParameters(shim, this)
-    return {query: methodName, parameters, callback: shim.LAST}
+    instrument(shim, mongodb)
   }
 }
 
-function getInstanceAttributeParameters(shim, obj) {
-  if (obj.db && obj.db.serverConfig) {
-    shim.logger.trace('Adding datastore instance attributes from obj.db.serverConfig')
-    const serverConfig = obj.db.serverConfig
-    const db = serverConfig.db || serverConfig.dbInstance
-    return doCapture(serverConfig, db && db.databaseName)
-  } else if (obj.s && obj.s.db && obj.s.topology) {
-    shim.logger.trace(
-      'Adding datastore instance attributes from obj.s.db + obj.s.topology'
-    )
-    const databaseName = obj.s.db.databaseName || null
-    const topology = obj.s.topology
-    if (topology.s && topology.s.options) {
-      return doCapture(topology.s.options, databaseName)
-    }
-  }
-
-  shim.logger.trace('Could not find datastore instance attributes.')
-  return {
-    host: null,
-    port_path_or_id: null,
-    database_name: null
-  }
-
-  function doCapture(conf, database) {
-    let host = conf.host
-    let port = conf.port
-
-    // If using a domain socket, mongo stores the path as the host name, but we
-    // pass it through the port value.
-    if (
-      (conf.socketOptions && conf.socketOptions.domainSocket) ||
-      /\.sock$/.test(host)
-    ) {
-      port = host
-      host = 'localhost'
-    }
-
-    return {
-      host: host,
-      port_path_or_id: port,
-      database_name: database
-    }
-  }
-}

package/lib/instrumentation/pg.js

@@ -5,6 +5,8 @@
 
 'use strict'
 
+const semver = require('semver')
+
 function getQuery(shim, original, name, args) {
   var config = args[0]
   var statement
@@ -20,6 +22,8 @@ function getQuery(shim, original, name, args) {
 }
 
 module.exports = function initialize(agent, pgsql, moduleName, shim) {
+  const pgVersion = shim.require('./package.json').version
+
   shim.setDatastore(shim.POSTGRES)
   // allows for native wrapping to not happen if not necessary
   // when env var is true
@@ -28,6 +32,30 @@ module.exports = function initialize(agent, pgsql, moduleName, shim) {
     return instrumentPGNative(pgsql)
   }
 
+  function wrapJSClientQuery(shim, _, __, queryArgs) {
+    // As of pg v7.0.0, Client.query returns a Promise from an async call.
+    // pg supports event based Client.query when a Query object is passed in,
+    // and works similarly in pg version <7.0.0
+    if (semver.satisfies(pgVersion, '>=7.0.0') &&
+      typeof queryArgs[0] === 'string') {
+      return {
+        callback: shim.LAST,
+        query: getQuery,
+        promise: true,
+        parameters: getInstanceParameters(shim, this),
+        internal: false
+      }
+    }
+
+    return {
+      callback: shim.LAST,
+      query: getQuery,
+      stream: 'row',
+      parameters: getInstanceParameters(shim, this),
+      internal: false
+    }
+  }
+
   // wrapping for native
   function instrumentPGNative(pg) {
     shim.wrapReturn(pg, 'Client', clientFactoryWrapper)
@@ -56,13 +84,11 @@ module.exports = function initialize(agent, pgsql, moduleName, shim) {
   }
 
   function clientPostConstructor(shim) {
-    shim.recordQuery(this, 'query', {
-      callback: shim.LAST,
-      query: getQuery,
-      stream: 'row',
-      parameters: getInstanceParameters(shim, this),
-      internal: false
-    })
+    shim.recordQuery(
+      this,
+      'query',
+      wrapJSClientQuery
+    )
 
     shim.record(this, 'connect', function pgConnectNamer() {
       return {
@@ -93,18 +119,11 @@ module.exports = function initialize(agent, pgsql, moduleName, shim) {
   shim.recordQuery(
     pgsql && pgsql.Client && pgsql.Client.prototype,
     'query',
-    function wrapJSClientQuery(shim) {
-      return {
-        callback: shim.LAST,
-        query: getQuery,
-        stream: 'row',
-        parameters: getInstanceParameters(shim, this),
-        internal: false
-      }
-    }
+    wrapJSClientQuery
   )
 }
 
+
 function getInstanceParameters(shim, client) {
   return {
     host: client.host || null,

package/lib/spans/create-span-event-aggregator.js

@@ -5,29 +5,32 @@
 
 'use strict'
 
-const psemver = require('../util/process-version')
 const logger = require('../logger')
 const SpanEventAggregator = require('./span-event-aggregator')
 const StreamingSpanEventAggregator = require('./streaming-span-event-aggregator')
 
 function createSpanEventAggregator(config, collector, metrics) {
-  let shouldCreateStreaming = false
-  if (config.infinite_tracing.trace_observer.host) {
-    // TODO: ideally this validation and configuration clearing would happen
-    // in the config. Since we don't currently have a way to generate
-    // support metrics in the config, keeping this related logic together here.
-    // If logic happened prior, could merely check for existence of trace_observer.host.
-    shouldCreateStreaming = validateInfiniteTracing(config.infinite_tracing.trace_observer)
+  const trace_observer = config.infinite_tracing.trace_observer
 
-    if (!shouldCreateStreaming) {
-      // Explicitly disable for any downstream consumers
-      config.infinite_tracing.trace_observer.host = ''
-      config.infinite_tracing.trace_observer.port = ''
-    }
-  }
+  if (trace_observer.host) {
+    trace_observer.host = trace_observer.host.trim()
 
-  if (shouldCreateStreaming) {
-    return createStreamingAggregator(config, collector, metrics)
+    if (typeof trace_observer.port !== 'string') {
+      trace_observer.port = String(trace_observer.port)
+    }
+    trace_observer.port = trace_observer.port.trim()
+
+    try {
+      return createStreamingAggregator(config, collector, metrics)
+    } catch (err) {
+      logger.warn(err, 'Failed to create streaming span event aggregator for infinite tracing. ' +
+        'Reverting to standard span event aggregator and disabling infinite tracing')
+      config.infinite_tracing.trace_observer = {
+        host: '',
+        port: ''
+      }
+      return createStandardAggregator(config, collector, metrics)
+    }
   }
 
   return createStandardAggregator(config, collector, metrics)
@@ -35,12 +38,10 @@ function createSpanEventAggregator(config, collector, metrics) {
 
 function createStreamingAggregator(config, collector, metrics) {
   logger.trace('Creating streaming span event aggregator for infinite tracing.')
-
-  // loading the class here to ensure its behind a feature flag
-  // and won't trigger a grpc load in node 8
   const GrpcConnection = require('../grpc/connection')
-  const connection = new GrpcConnection(config.infinite_tracing.trace_observer, metrics)
   const SpanStreamer = require('./span-streamer')
+
+  const connection = new GrpcConnection(config.infinite_tracing.trace_observer, metrics)
   const spanStreamer = new SpanStreamer(
     config.license_key,
     connection,
@@ -54,9 +55,7 @@ function createStreamingAggregator(config, collector, metrics) {
     span_streamer: spanStreamer
   }
 
-  const aggregator = new StreamingSpanEventAggregator(opts, collector, metrics)
-
-  return aggregator
+  return new StreamingSpanEventAggregator(opts, collector, metrics)
 }
 
 function createStandardAggregator(config, collector, metrics) {
@@ -67,53 +66,7 @@ function createStandardAggregator(config, collector, metrics) {
     limit: config.event_harvest_config.harvest_limits.span_event_data
   }
 
-  const aggregator = new SpanEventAggregator(opts, collector, metrics)
-  return aggregator
-}
-
-function validateInfiniteTracing(trace_observer) {
-  // TODO: Remove semver check when Node 10 support dropped.
-  if (!psemver.satisfies('>=10.10.0')) {
-    logger.warn(
-      'Infinite tracing disabled: this version of Node is not supported (must be >=10.10.0)'
-    )
-    return false
-  }
-
-  trace_observer.host = trace_observer.host.trim()
-
-  if (!validateHostName(trace_observer.host)) {
-    logger.warn('Infinite tracing disabled: invalid infinite_tracing.trace_observer.host value')
-
-    return false
-  }
-
-  if (typeof trace_observer.port !== 'string') {
-    trace_observer.port = String(trace_observer.port)
-  }
-
-  trace_observer.port = trace_observer.port.trim()
-
-  if (!validatePortValue(trace_observer.port)) {
-    logger.warn('Infinite tracing disabled: invalid infinite_tracing.trace_observer.port value')
-
-    return false
-  }
-
-  return true
-}
-
-function validateHostName(host) {
-  // Regular expression for validating a hostname
-  const hostReg = /(?=^.{4,253}$)(^((?!-)[a-zA-Z0-9-]{0,62}[a-zA-Z0-9]\.)+[a-zA-Z]{2,63}$)/
-
-  return hostReg.test(host)
-}
-
-function validatePortValue(port) {
-  if (port.length === 0) return false
-
-  return !isNaN(port)
+  return new SpanEventAggregator(opts, collector, metrics)
 }
 
 module.exports = createSpanEventAggregator

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "7.5.0",
+  "version": "8.1.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -98,6 +98,11 @@
       "name": "Nick Tzaperas",
       "email": "ntzaperas@newrelic.com",
       "web": "https://newrelic.com"
+    },
+    {
+      "name": "Bob Evans",
+      "email": "revans@newrelic.com",
+      "web": "https://newrelic.com"
     }
   ],
   "description": "New Relic agent",
@@ -109,10 +114,10 @@
     "debugging",
     "profiling"
   ],
-  "homepage": "http://github.com/newrelic/node-newrelic",
+  "homepage": "https://github.com/newrelic/node-newrelic",
   "engines": {
-    "node": ">=10.0.0",
-    "npm": ">=3.0.0"
+    "node": ">=12.0.0",
+    "npm": ">=6.0.0"
   },
   "directories": {
     "lib": "lib"
@@ -120,24 +125,25 @@
   "scripts": {
     "bench": "node ./bin/run-bench.js",
     "ca-gen": "./bin/update-ca-bundle.sh",
-    "clean": "./bin/clean.sh",
     "docker-env": "./bin/docker-env-vars.sh",
     "docs": "npm ci && jsdoc -c ./jsdoc-conf.json --private -r .",
-    "integration": "npm run prepare-test && npm run sub-install && time tap --no-esm test/integration/**/**/*.tap.js --timeout=180 --no-coverage",
-    "prepare-test": "npm ci && npm run ca-gen && npm run ssl && npm run docker-env",
+    "integration": "npm run prepare-test && npm run sub-install && time tap test/integration/**/**/*.tap.js --timeout=180 --no-coverage --reporter classic",
+    "prepare-test": "npm run ca-gen && npm run ssl && npm run docker-env",
     "lint": "eslint ./*.js lib test bin",
     "public-docs": "npm ci && jsdoc -c ./jsdoc-conf.json --tutorials examples/shim api.js lib/shim/ lib/transaction/handle.js && cp examples/shim/*.png out/",
     "publish-docs": "./bin/publish-docs.sh",
     "services": "./bin/docker-services.sh",
-    "smoke": "npm run clean && ./bin/smoke.sh",
+    "smoke": "npm run ssl && time tap test/smoke/**/**/*.tap.js --timeout=180 --no-coverage",
     "ssl": "./bin/ssl.sh",
     "sub-install": "node test/bin/install_sub_deps",
     "test": "npm run integration && npm run unit",
-    "unit": "rm -f newrelic_agent.log && time tap --test-regex='(\\/|^test\\/unit\\/.*\\.test\\.js)$' --timeout=180 --no-coverage",
+    "unit": "rm -f newrelic_agent.log && time tap --test-regex='(\\/|^test\\/unit\\/.*\\.test\\.js)$' --timeout=180 --no-coverage --reporter classic",
     "update-cross-agent-tests": "./bin/update-cats.sh",
     "versioned-tests": "./bin/run-versioned-tests.sh",
     "update-changelog-version": "node ./bin/update-changelog-version",
-    "versioned": "npm run prepare-test && time ./bin/run-versioned-tests.sh",
+    "versioned": "npm run versioned:npm7",
+    "versioned:npm6": "npm run prepare-test && time ./bin/run-versioned-tests.sh",
+    "versioned:npm7": "npm run prepare-test && NPM7=1 time ./bin/run-versioned-tests.sh",
     "prepare": "husky install"
   },
   "bin": {
@@ -146,31 +152,31 @@
   "dependencies": {
     "@grpc/grpc-js": "^1.2.11",
     "@grpc/proto-loader": "^0.5.6",
-    "@newrelic/aws-sdk": "^3.1.0",
-    "@newrelic/koa": "^5.0.0",
-    "@newrelic/superagent": "^4.0.0",
+    "@newrelic/aws-sdk": "^4.0.1",
+    "@newrelic/koa": "^6.0.1",
+    "@newrelic/superagent": "^5.0.1",
     "@tyriar/fibonacci-heap": "^2.0.7",
     "async": "^3.2.0",
     "concat-stream": "^2.0.0",
-    "https-proxy-agent": "^4.0.0",
+    "https-proxy-agent": "^5.0.0",
     "json-stringify-safe": "^5.0.0",
     "readable-stream": "^3.6.0",
     "semver": "^5.3.0"
   },
   "optionalDependencies": {
-    "@newrelic/native-metrics": "^6.0.0"
+    "@newrelic/native-metrics": "^7.0.1"
   },
   "devDependencies": {
     "@newrelic/proxy": "^2.0.0",
-    "@newrelic/test-utilities": "^5.1.0",
+    "@newrelic/test-utilities": "^6.0.0",
     "@octokit/rest": "^18.0.15",
-    "JSV": "~4.0.2",
     "architect": "*",
     "benchmark": "^2.1.4",
     "bluebird": "^3.4.7",
     "chai": "^4.1.2",
     "commander": "^7.0.0",
-    "eslint": "^6.8.0",
+    "eslint": "^7.32.0",
+    "eslint-plugin-header": "^3.1.1",
     "express": "*",
     "fastify": "^2.15.3",
     "generic-pool": "^3.6.1",
@@ -179,6 +185,7 @@
     "http-errors": "^1.7.3",
     "husky": "^6.0.0",
     "jsdoc": "^3.6.3",
+    "JSV": "~4.0.2",
     "lint-staged": "^11.0.0",
     "memcached": ">=0.2.8",
     "minami": "^1.1.1",
@@ -193,7 +200,7 @@
     "rimraf": "^2.6.3",
     "should": "*",
     "sinon": "^4.5.0",
-    "tap": "^14.10.8",
+    "tap": "^15.0.9",
     "temp": "^0.8.1",
     "through": "^2.3.6",
     "when": "*"