newrelic 4.6.0 → 4.9.0

package/lib/shim/shim.js

@@ -18,6 +18,10 @@ try {
   logger.debug(err, 'Failed to load es6 shimming methods.')
 }
 
+// Some modules do terrible things, like change the prototype of functions. To
+// avoid crashing things we'll use a cached copy of apply everywhere.
+const fnApply = Function.prototype.apply
+
 /**
  * Constructs a shim associated with the given agent instance.
  *
@@ -105,6 +109,7 @@ Shim.prototype.unwrapOnce = unwrapOnce
 Shim.prototype.getOriginal = getOriginal
 Shim.prototype.getSegment = getSegment
 Shim.prototype.getActiveSegment = getActiveSegment
+Shim.prototype.setActiveSegment = setActiveSegment
 Shim.prototype.storeSegment = storeSegment
 Shim.prototype.bindCallbackSegment = bindCallbackSegment
 Shim.prototype.applySegment = applySegment
@@ -117,6 +122,7 @@ Shim.prototype.isString = isString
 Shim.prototype.isNumber = isNumber
 Shim.prototype.isBoolean = isBoolean
 Shim.prototype.isArray = isArray
+Shim.prototype.isNull = isNull
 Shim.prototype.toArray = toArray
 Shim.prototype.argsToArray = argsToArray
 Shim.prototype.normalizeIndex = normalizeIndex
@@ -490,6 +496,11 @@ Shim.prototype.__NR_unwrap = unwrapAll
  *  If the function synchronously threw an error, that error will be handed to
  *  this function.
  *
+ * @property {bool} [callbackRequired]
+ *  When `true`, a recorded method must be called with a callback for a segment
+ *  to be created. Does not apply if a custom callback method has been assigned
+ *  via {@link callback}.
+ *
  * @see SegmentSpec
  * @see RecorderFunction
  */
@@ -586,7 +597,7 @@ function wrap(nodule, properties, spec, args) {
   spec = this.setDefaults(spec, {matchArity: false})
 
   // If we're just wrapping one thing, just wrap it and return.
-  if (!properties) {
+  if (properties == null) {
     this.logger.trace('Wrapping nodule itself.')
     return _wrap(this, nodule, this.getName(nodule), spec, args)
   }
@@ -690,7 +701,7 @@ function wrapReturn(nodule, properties, spec, args) {
         fnArgs.unshift(fn) // `unshift` === `push_front`
         ctx = ret = new (fn.bind.apply(fn, fnArgs))()
       } else {
-        ret = fn.apply(ctx, arguments)
+        ret = fnApply.call(fn, ctx, arguments)
       }
 
       // Assemble the arguments to hand to the spec.
@@ -883,7 +894,7 @@ function record(nodule, properties, recordNamer) {
       var segDesc = recordNamer.call(this, shim, fn, name, args)
       if (!segDesc) {
         shim.logger.trace('No segment descriptor for "%s", not recording.', name)
-        return fn.apply(this, args)
+        return fnApply.call(fn, this, args)
       }
       segDesc = new specs.RecorderSpec(segDesc)
 
@@ -899,7 +910,14 @@ function record(nodule, properties, recordNamer) {
 
       if (!parent) {
         shim.logger.debug('Not recording function %s, not in a transaction.', name)
-        return fn.apply(this, arguments)
+        return fnApply.call(fn, this, arguments)
+      }
+
+      if (
+        segDesc.callbackRequired &&
+        !_hasValidCallbackArg(shim, args, segDesc.callback)
+      ) {
+        return fnApply.call(fn, this, arguments)
       }
 
       // Only create a segment if:
@@ -913,6 +931,20 @@ function record(nodule, properties, recordNamer) {
       return _doRecord.call(this, segment, args, segDesc, shouldCreateSegment)
     }
 
+    function _hasValidCallbackArg(shim, args, specCallback) {
+      if (shim.isNumber(specCallback)) {
+        const cbIdx = normalizeIndex(args.length, specCallback)
+        if (cbIdx === null) {
+          return false
+        }
+
+        const callback = args[cbIdx]
+        return shim.isFunction(callback)
+      }
+
+      return true
+    }
+
     function _doRecord(segment, args, segDesc, shouldCreateSegment) {
       // Now bind any callbacks specified in the segment descriptor.
       _bindAllCallbacks.call(this, shim, fn, name, args, {
@@ -946,7 +978,7 @@ function record(nodule, properties, recordNamer) {
       var promised = false
       var ret
       try {
-        ret = shim.applySegment(fn, segment, true, ctx, args)
+        ret = shim.applySegment(fn, segment, true, ctx, args, segDesc.inContext)
         if (segDesc.after && segDesc.promise && shim.isPromise(ret)) {
           promised = true
           return ret.then(function onThen(val) {
@@ -1266,6 +1298,22 @@ function getActiveSegment(obj) {
   return null
 }
 
+/**
+ * Explicitly sets the active segment to the one passed in. This method
+ * should only be used if there is no function to tie a segment's timing
+ * to.
+ *
+ * - `setActiveSegment(segment)`
+ *
+ * @memberof Shim.prototype
+ *
+ * @param {TraceSegment} segment - The segment to set as the active segment.
+ *
+ */
+function setActiveSegment(segment) {
+  return this.tracer.segment = segment
+}
+
 /**
  * Associates a segment with the given object.
  *
@@ -1286,7 +1334,7 @@ function storeSegment(obj, segment) {
  * Sets the given segment as the active one for the duration of the function's
  * execution.
  *
- * - `applySegment(func, segment, full, context, args)`
+ * - `applySegment(func, segment, full, context, args[, inContextCB])`
  *
  * @memberof Shim.prototype
  *
@@ -1305,9 +1353,15 @@ function storeSegment(obj, segment) {
  * @param {Array.<*>} args
  *  The arguments to be passed into the function.
  *
+ * @param {Function} [inContextCB]
+ *  The function used to do more instrumentation work. This function is
+ *  guaranteed to be executed with the segment associated with.
+ *
+ *
  * @return {*} Whatever value `func` returned.
  */
-function applySegment(func, segment, full, context, args) {
+/* eslint-disable max-params */
+function applySegment(func, segment, full, context, args, inContextCB) {
   // Exist fast for bad arguments.
   if (!this.isFunction(func)) {
     return
@@ -1315,7 +1369,7 @@ function applySegment(func, segment, full, context, args) {
 
   if (!segment) {
     this.logger.trace('No segment to apply to function.')
-    return func.apply(context, args)
+    return fnApply.call(func, context, args)
   }
   this.logger.trace('Applying segment %s', segment.name)
 
@@ -1327,9 +1381,19 @@ function applySegment(func, segment, full, context, args) {
     segment.start()
   }
 
+  if (typeof inContextCB === 'function') {
+    inContextCB()
+  }
+
   // Execute the function and then return the tracer segment to the old one.
   try {
-    return func.apply(context, args)
+    return fnApply.call(func, context, args)
+  } catch (error) {
+    if (prevSegment === null && process.domain != null) {
+      process.domain.__NR_segment = tracer.segment
+    }
+
+    throw error // Rethrowing application error, this is not an agent error.
   } finally {
     if (full) {
       segment.touch()
@@ -1337,6 +1401,7 @@ function applySegment(func, segment, full, context, args) {
     tracer.segment = prevSegment
   }
 }
+/* eslint-enable max-params */
 
 /**
  * Creates a new segment.
@@ -1364,9 +1429,10 @@ function createSegment(name, recorder, parent) {
   var opts = null
   if (this.isString(name)) {
     // createSegment(name [, recorder] [, parent])
-    opts = new specs.SegmentSpec({name: name})
+    opts = new specs.SegmentSpec({name})
 
-    if (this.isFunction(recorder)) {
+    // if the recorder arg is not used, it can either be omitted or null
+    if (this.isFunction(recorder) || this.isNull(recorder)) {
       // createSegment(name, recorder [, parent])
       opts.recorder = recorder
       opts.parent = parent
@@ -1504,6 +1570,19 @@ function isPromise(obj) {
   return obj && typeof obj.then === 'function'
 }
 
+/**
+ * Determines if the given value is null.
+ *
+ * @memberof Shim.prototype
+ *
+ * @param {*} val - The value to check.
+ *
+ * @return {bool} True if the value is null, else false.
+ */
+function isNull(val) {
+  return val === null
+}
+
 /**
  * Converts an array-like object into an array.
  *

package/lib/shim/specs/index.js

@@ -45,6 +45,7 @@ function WrapSpec(spec) {
 function SegmentSpec(spec) {
   this.name       = hasOwnProperty(spec, 'name') ? spec.name : null
   this.recorder   = hasOwnProperty(spec, 'recorder') ? spec.recorder : null
+  this.inContext  = hasOwnProperty(spec, 'inContext') ? spec.inContext : null
   this.parent     = hasOwnProperty(spec, 'parent') ? spec.parent : null
   this.parameters = hasOwnProperty(spec, 'parameters') ? spec.parameters : null
   this.internal   = hasOwnProperty(spec, 'internal') ? spec.internal : false
@@ -53,11 +54,13 @@ function SegmentSpec(spec) {
 
 function RecorderSpec(spec) {
   SegmentSpec.call(this, spec)
-  this.stream       = hasOwnProperty(spec, 'stream') ? spec.stream : null
-  this.promise      = hasOwnProperty(spec, 'promise') ? spec.promise : null
-  this.callback     = hasOwnProperty(spec, 'callback') ? spec.callback : null
-  this.rowCallback  = hasOwnProperty(spec, 'rowCallback') ? spec.rowCallback : null
-  this.after        = hasOwnProperty(spec, 'after') ? spec.after : null
+  this.stream           = hasOwnProperty(spec, 'stream') ? spec.stream : null
+  this.promise          = hasOwnProperty(spec, 'promise') ? spec.promise : null
+  this.callback         = hasOwnProperty(spec, 'callback') ? spec.callback : null
+  this.rowCallback      = hasOwnProperty(spec, 'rowCallback') ? spec.rowCallback : null
+  this.after            = hasOwnProperty(spec, 'after') ? spec.after : null
+  this.callbackRequired = hasOwnProperty(spec, 'callbackRequired') ?
+                            spec.callbackRequired : null
 }
 util.inherits(RecorderSpec, SegmentSpec)
 

package/lib/shimmer.js

@@ -7,29 +7,63 @@ var INSTRUMENTATIONS = require('./instrumentations')()
 var properties = require('./util/properties')
 var shims = require('./shim')
 
-
-var CORE_INSTRUMENTATION = {
-  child_process: 'child_process.js',
-  crypto: 'crypto.js',
-  // domain: 'domain.js', // XXX Do not include domains in this list! The core
-  dns: 'dns.js',          // instrumentations are run at startup by requiring
-  fs: 'fs.js',            // each of their modules. Loading `domain` has side
-  http: 'http.js',        // effects that we should try to avoid.
-  https: 'http.js',
-  inspector: 'inspector.js',
-  net: 'net.js',
-  timers: 'timers.js',
-  zlib: 'zlib.js'
-}
-
 var MODULE_TYPE = shims.constants.MODULE_TYPE
 
 var SHIM_TYPE_MAP = Object.create(null)
 SHIM_TYPE_MAP[MODULE_TYPE.GENERIC] = shims.Shim
 SHIM_TYPE_MAP[MODULE_TYPE.DATASTORE] = shims.DatastoreShim
 SHIM_TYPE_MAP[MODULE_TYPE.MESSAGE] = shims.MessageShim
+SHIM_TYPE_MAP[MODULE_TYPE.PROMISE] = shims.PromiseShim
+SHIM_TYPE_MAP[MODULE_TYPE.TRANSACTION] = shims.TransactionShim
 SHIM_TYPE_MAP[MODULE_TYPE.WEB_FRAMEWORK] = shims.WebFrameworkShim
 
+var CORE_INSTRUMENTATION = {
+  child_process: {
+    type: MODULE_TYPE.GENERIC,
+    file: 'child_process.js'
+  },
+  crypto: {
+    type: MODULE_TYPE.GENERIC,
+    file: 'crypto.js'
+  },
+  // domain: {                     // XXX Do not include domains in this list! The
+  //   type: MODULE_TYPE.GENERIC,  // core instrumentations are run at startup by
+  //   file: 'domain.js'           // requiring each of their modules. Loading
+  // },                            // `domain` has side effects that we try to avoid.
+  dns: {
+    type: MODULE_TYPE.GENERIC,
+    file: 'dns.js'
+  },
+  fs: {
+    type: MODULE_TYPE.GENERIC,
+    file: 'fs.js'
+  },
+  http: {
+    type: MODULE_TYPE.TRANSACTION,
+    file: 'http.js'
+  },
+  https: {
+    type: MODULE_TYPE.TRANSACTION,
+    file: 'http.js'
+  },
+  inspector: {
+    type: MODULE_TYPE.GENERIC,
+    file: 'inspector.js'
+  },
+  net: {
+    type: MODULE_TYPE.GENERIC,
+    file: 'net.js'
+  },
+  timers: {
+    type: MODULE_TYPE.GENERIC,
+    file: 'timers.js'
+  },
+  zlib: {
+    type: MODULE_TYPE.GENERIC,
+    file: 'zlib.js'
+  }
+}
+
 /**
  * Unwrapping is only likely to be used by test code, and is a fairly drastic
  * maneuver, but it should be pretty safe if there's a desire to reboot the
@@ -40,6 +74,17 @@ SHIM_TYPE_MAP[MODULE_TYPE.WEB_FRAMEWORK] = shims.WebFrameworkShim
  */
 var instrumented = []
 
+function applyDebugState(shimmer, shim, nodule) {
+  if (shimmer.debug) {
+    shim.enableDebug()
+    instrumented.push(shim)
+    instrumented.push({__NR_unwrap: function unwrapNodule() {
+      delete nodule.__NR_instrumented
+    }})
+    nodule.__NR_shim = shim
+  }
+}
+
 /**
  * All instrumentation files must export the same interface: a single
  * initialization function that takes the agent and the module to be
@@ -63,14 +108,7 @@ function instrument(agent, nodule, moduleName, resolvedName) {
     shim = new shims.Shim(agent, moduleName, resolvedName)
   }
 
-  if (shimmer.debug) {
-    shim.enableDebug()
-    instrumented.push(shim)
-    instrumented.push({__NR_unwrap: function unwrapNodule() {
-      delete nodule.__NR_instrumented
-    }})
-    nodule.__NR_shim = shim
-  }
+  applyDebugState(shimmer, shim, nodule)
 
   try {
     if (instrumentation.onRequire(shim, nodule, moduleName) !== false) {
@@ -339,14 +377,16 @@ var shimmer = module.exports = {
 
   bootstrapInstrumentation: function bootstrapInstrumentation(agent) {
     // Instrument global.
+    const globalShim = new shims.Shim(agent, 'globals', 'globals')
+    applyDebugState(shimmer, globalShim, global)
     var globalsFilepath = path.join(__dirname, 'instrumentation', 'core', 'globals.js')
-    _firstPartyInstrumentation(agent, globalsFilepath, shimmer, global, 'globals')
+    _firstPartyInstrumentation(agent, globalsFilepath, globalShim, global, 'globals')
 
     // Instrument each of the core modules.
     Object.keys(CORE_INSTRUMENTATION).forEach(function forEachCore(mojule) {
-      var fileName = CORE_INSTRUMENTATION[mojule]
-      var filePath = path.join(__dirname, 'instrumentation', 'core', fileName)
-      var uninstrumented
+      const core = CORE_INSTRUMENTATION[mojule]
+      const filePath = path.join(__dirname, 'instrumentation', 'core', core.file)
+      let uninstrumented = null
 
       try {
         uninstrumented = require(mojule)
@@ -358,7 +398,9 @@ var shimmer = module.exports = {
         )
       }
 
-      var shim = new shims.Shim(agent, mojule, mojule)
+      const ShimClass = SHIM_TYPE_MAP[core.type]
+      const shim = new ShimClass(agent, mojule, mojule)
+      applyDebugState(shimmer, shim, core)
       _firstPartyInstrumentation(agent, filePath, shim, uninstrumented, mojule)
     })
 

package/lib/transaction/dt-payload.js

@@ -7,6 +7,12 @@ const DT_VERSION_MAJOR = 0
 const DT_VERSION_MINOR = 1
 
 module.exports = class DistributedTracePayload {
+  /**
+   * The class reponsible for producing distributed trace payloads.
+   * Created by calling {@link TransactionHandle#createDistributedTracePayload}.
+   *
+   * @constructor
+   */
   constructor(payload) {
     logger.trace('DistributedTracePayload created with %s', payload)
     this.plainTextPayload = JSON.stringify({
@@ -16,11 +22,21 @@ module.exports = class DistributedTracePayload {
     this.base64Payload = null
   }
 
+  /**
+   * @returns {String} The base64 encoded JSON representation of the
+   * distributed trace payload.
+   */
   text() {
     logger.trace('DistributedTracePayload text: %s', this.plainTextPayload)
     return this.plainTextPayload
   }
 
+  /**
+   * Construct a payload suitable for HTTP transport.
+   *
+   * @returns {String} The base64 encoded JSON representation of the
+   * distributed trace payload.
+   */
   httpSafe() {
     if (!this.base64Payload) {
       this.base64Payload = makeBuffer(this.plainTextPayload, 'utf-8').toString('base64')

package/lib/transaction/handle.js

@@ -33,7 +33,7 @@ module.exports = class TransactionHandle {
   *
   * Proxy method for Transaction#createDistrubtedTracePayload.
   *
-  * @returns {DistributedTracePayload} The created payload.
+  * @returns {DistributedTracePayload} The created payload object.
   *
   */
   createDistributedTracePayload() {

package/lib/transaction/index.js

@@ -193,6 +193,10 @@ Transaction.prototype.end = function end(done) {
       transaction.record()
     }
 
+    // This is function currently must be called after all recorders have been fired due
+    // to some of the recorders (namely the db recorders) add parameters to the segments.
+    transaction.trace.generateSpanEvents()
+
     transaction.agent.emit('transactionFinished', transaction)
     if (typeof done === 'function') {
       done(transaction)
@@ -751,11 +755,16 @@ function acceptDistributedTracePayload(payload, transport) {
 
   const config = this.agent.config
   const distTraceEnabled = config.distributed_tracing.enabled
-  const catEnabled = config.cross_application_tracer.enabled
   const trustedAccount = config.trusted_account_key || config.account_id
 
-  if (!distTraceEnabled || !catEnabled || !trustedAccount) {
-    logger.warn('Invalid configuration for distributed trace payload, not accepting')
+  if (!distTraceEnabled || !trustedAccount) {
+    logger.debug(
+      'Invalid configuration for distributed trace payload, not accepting ' +
+      '(distributed_tracing.enabled: %s, trustKey: %s',
+      distTraceEnabled,
+      trustedAccount
+    )
+
     this.agent.recordSupportability('DistributedTrace/AcceptPayload/Exception')
     return
   }
@@ -894,15 +903,20 @@ Transaction.prototype.createDistributedTracePayload = createDistributedTracePayl
 function createDistributedTracePayload() {
   const config = this.agent.config
   const accountId = config.account_id
-  const appId = config.application_id
+  const appId = config.primary_application_id
   const distTraceEnabled = config.distributed_tracing.enabled
-  const catEnabled = config.cross_application_tracer.enabled
 
-  if (!accountId || !appId || !distTraceEnabled || !catEnabled) {
-    logger.warn(
-      'Invalid configuration for distributed trace payload in transaction %s',
+  if (!accountId || !appId || !distTraceEnabled) {
+    logger.debug(
+      'Invalid configuration for distributed trace payload ' +
+      '(distributed_tracing.enabled: %s, account_id: %s, application_id: %s) ' +
+      'in transaction %s',
+      distTraceEnabled,
+      accountId,
+      appId,
       this.id
     )
+
     return new DTPayloadStub()
   }
 

package/lib/transaction/trace/aggregator.js

@@ -126,12 +126,12 @@ TraceAggregator.prototype.isBetter = function isBetter(name, duration, apdexT) {
   var isOverThreshold
 
   if (config &&
-      config.transaction_threshold &&
+      config.transaction_threshold != null &&
       config.transaction_threshold !== 'apdex_f' &&
       typeof config.transaction_threshold === 'number') {
-    isOverThreshold = duration > config.transaction_threshold * TO_MILLIS
+    isOverThreshold = duration >= config.transaction_threshold * TO_MILLIS
   } else {
-    isOverThreshold = duration > 4 * TO_MILLIS * apdexT
+    isOverThreshold = duration >= 4 * TO_MILLIS * apdexT
   }
   if (!isOverThreshold) return false
 

package/lib/transaction/trace/index.js

@@ -49,30 +49,48 @@ function Trace(transaction) {
  * segments that support recording.
  */
 Trace.prototype.end = function end() {
+  var segments = [this.root]
+
+  while (segments.length) {
+    var segment = segments.pop()
+    _softEndSegment(segment)
+    Array.prototype.push.apply(segments, segment.getChildren())
+  }
+}
+
+/**
+ * Iterates over the trace tree and generates a span event for each segment.
+ */
+Trace.prototype.generateSpanEvents = function generateSpanEvents() {
   var config = this.transaction.agent.config
-  var segments = []
-  var processFn
 
   if (
     this.transaction.sampled &&
     config.span_events.enabled &&
     config.distributed_tracing.enabled
   ) {
+    var toProcess = []
     // Root segment does not become a span, so we need to process it separately.
-    _softEndSegment(this.root)
+    const spanAggregator = this.transaction.agent.spans
     const children = this.root.getChildren()
     for (let i = 0; i < children.length; ++i) {
-      segments.push(new DTTraceNode(children[i], this.transaction.parentSpanId))
+      toProcess.push(new DTTraceNode(children[i], this.transaction.parentSpanId))
     }
-    processFn = makeDTNodeProcessor(this.transaction.agent.spans)
-  } else {
-    segments.push(this.root)
-    processFn = processNode
-  }
 
-  while (segments.length) {
-    var segment = segments.pop()
-    processFn(segment, segments)
+    while (toProcess.length) {
+      var segmentInfo = toProcess.pop()
+      var segment = segmentInfo.segment
+
+      // Even though at some point we might want to stop adding events
+      // because all the priorities should be the same, we need to count
+      // the spans as seen.
+      spanAggregator.addSegment(segment, segmentInfo.parentId)
+
+      Array.prototype.push.apply(
+        toProcess,
+        segment.getChildren().map(child => new DTTraceNode(child, segment.id))
+      )
+    }
   }
 }
 
@@ -90,31 +108,6 @@ function _softEndSegment(segment) {
   }
 }
 
-function makeDTNodeProcessor(spanAggregator) {
-  var addMoreSpans = true
-  return function processNodeDT(segmentInfo, segments) {
-    var segment = segmentInfo.segment
-    _softEndSegment(segment)
-
-    // This assumes that spans will have their transaction's priority. If insertion of
-    // one event fails, all following will fail due to having the same priority.
-    if (addMoreSpans && segment.name !== 'ROOT') {
-      addMoreSpans = spanAggregator.addSegment(segment, segmentInfo.parentId)
-    }
-
-    var children = segment.getChildren()
-    Array.prototype.push.apply(
-      segments,
-      children.map(child => new DTTraceNode(child, segment.id))
-    )
-  }
-}
-
-function processNode(segment, segments) {
-  _softEndSegment(segment)
-  Array.prototype.push.apply(segments, segment.getChildren())
-}
-
 /**
  * Add a child to the list of segments.
  *

package/lib/util/codec.js

@@ -45,11 +45,14 @@ module.exports = {
     zlib.inflate(new Buffer(encoded, 'base64'), function cb_inflate(err, raw) {
       if (err) return callback(err)
 
+      let json
       try {
-        return callback(null, JSON.parse(raw))
+        json = JSON.parse(raw)
       } catch (error) {
         return callback(error)
       }
+
+      return callback(null, json)
     })
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "4.6.0",
+  "version": "4.9.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "licenses": [
     {
@@ -83,6 +83,11 @@
       "name": "Peter Svetlichny",
       "email": "psvetlichny@newrelic.com",
       "web": "https://newrelic.com"
+    },
+    {
+      "name": "Michael Goin",
+      "email": "mgoin@newrelic.com",
+      "web": "https://newrelic.com"
     }
   ],
   "description": "New Relic agent",
@@ -96,7 +101,7 @@
   ],
   "homepage": "http://github.com/newrelic/node-newrelic",
   "engines": {
-    "node": ">=4.0.0",
+    "node": ">=4.0.0 <11.0.0",
     "npm": ">=2.0.0"
   },
   "directories": {
@@ -105,6 +110,7 @@
   "scripts": {
     "bench": "node ./bin/run-bench.js",
     "versioned-tests": "./bin/run-versioned-tests.sh",
+    "versioned": "./bin/run-versioned-tests.sh",
     "test": "make test"
   },
   "bin": {
@@ -112,6 +118,7 @@
   },
   "dependencies": {
     "@newrelic/koa": "^1.0.0",
+    "@newrelic/superagent": "^1.0.0",
     "@tyriar/fibonacci-heap": "^2.0.7",
     "async": "^2.1.4",
     "concat-stream": "^1.5.0",
@@ -132,13 +139,12 @@
     "chai": "^4.1.2",
     "connect": "*",
     "cover": "*",
-    "ejs": "0.8.5",
+    "ejs": "2.5.5",
     "eslint": "^4.19.1",
     "express": "*",
     "generic-pool": "*",
     "glob": "^7.1.2",
     "got": "^8.0.1",
-    "ioredis": "*",
     "jsdoc": "^3.4.0",
     "lodash": "^4.17.5",
     "memcached": ">=0.2.8",