newrelic 7.5.2 → 8.3.0

package/lib/instrumentation/bluebird.js

@@ -26,37 +26,78 @@ module.exports = function initialize(agent, bluebird, moduleName, shim) {
   // _execute is in bluebird 3.x
   shim.wrapExecutorCaller(proto, ['_execute', '_resolveFromResolver'])
   shim.wrapThen(proto, [
-    'asCallback', 'done', 'each', 'filter', 'finally', 'lastly', 'map',
-    'mapSeries', 'nodeify', 'reduce', 'spread', 'tap', 'tapCatch', 'then'
+    'asCallback',
+    'done',
+    'each',
+    'filter',
+    'finally',
+    'lastly',
+    'map',
+    'mapSeries',
+    'nodeify',
+    'reduce',
+    'spread',
+    'tap',
+    'tapCatch',
+    'then'
   ])
   shim.wrapCatch(proto, ['catch', 'caught', 'error'])
   shim.wrapCast(proto, [
-    'all', 'any', 'bind', 'call', 'catchReturn', 'catchThrow', 'delay', 'get',
-    'props', 'race', 'reflect', 'return', 'some', 'thenReturn', 'thenThrow',
-    'throw', 'timeout'
+    'all',
+    'any',
+    'bind',
+    'call',
+    'catchReturn',
+    'catchThrow',
+    'delay',
+    'get',
+    'props',
+    'race',
+    'reflect',
+    'return',
+    'some',
+    'thenReturn',
+    'thenThrow',
+    'throw',
+    'timeout'
   ])
 
   shim.wrapCast(Promise, [
-    'all', 'allSettled', 'any', 'attempt', 'bind', 'cast', 'delay', 'each',
-    'filter', 'fromCallback', 'fromNode', 'fulfilled', 'join', 'map',
-    'mapSeries', 'props', 'race', 'reduce', 'reject', 'rejected', 'resolve',
-    'some', 'try'
+    'all',
+    'allSettled',
+    'any',
+    'attempt',
+    'bind',
+    'cast',
+    'delay',
+    'each',
+    'filter',
+    'fromCallback',
+    'fromNode',
+    'fulfilled',
+    'join',
+    'map',
+    'mapSeries',
+    'props',
+    'race',
+    'reduce',
+    'reject',
+    'rejected',
+    'resolve',
+    'some',
+    'try'
   ])
   shim.wrapPromisify(Promise, ['coroutine', 'method', 'promisify'])
 
   // Using `getNewLibraryCopy` needs to trigger re-instrumenting.
-  shim.wrap(
-    bluebird.Promise,
-    'getNewLibraryCopy',
-    function wrapNewCopy(shim, original) {
-      return function wrappedNewCopy() {
-        shim.logger.trace('Instrumenting new library copy...')
-        var copy = original.apply(this, arguments)
-        module.exports(agent, copy, moduleName, shim)
-        return copy
-      }
+  shim.wrap(bluebird.Promise, 'getNewLibraryCopy', function wrapNewCopy(shim, original) {
+    return function wrappedNewCopy() {
+      shim.logger.trace('Instrumenting new library copy...')
+      var copy = original.apply(this, arguments)
+      module.exports(agent, copy, moduleName, shim)
+      return copy
     }
-  )
+  })
 
   // Need to copy over `coroutine.addYieldHandler`
   var coroutine = Promise && Promise.coroutine

package/lib/instrumentation/cassandra-driver.js

@@ -8,8 +8,8 @@
 module.exports = function initialize(agent, cassandra, moduleName, shim) {
   var proto = cassandra.Client.prototype
   shim.setDatastore(shim.CASSANDRA)
-  shim.recordOperation(proto, ['connect', 'shutdown'], {callback: shim.LAST})
-  shim.recordQuery(proto, '_innerExecute', {query: shim.FIRST, callback: shim.LAST})
+  shim.recordOperation(proto, ['connect', 'shutdown'], { callback: shim.LAST })
+  shim.recordQuery(proto, '_innerExecute', { query: shim.FIRST, callback: shim.LAST })
   shim.recordBatchQuery(proto, 'batch', {
     query: findBatchQueryArg,
     callback: shim.LAST

package/lib/instrumentation/connect.js

@@ -14,11 +14,12 @@ module.exports = function initialize(agent, connect, moduleName, shim) {
   shim.setFramework(shim.CONNECT)
 
   shim.setRouteParser(function parseRoute(shim, fn, fnName, route) {
-    return route.url
+    return route
   })
 
-  var proto = (connect && connect.HTTPServer && connect.HTTPServer.prototype) || // v1
-              (connect && connect.proto) // v2
+  var proto =
+    (connect && connect.HTTPServer && connect.HTTPServer.prototype) || // v1
+    (connect && connect.proto) // v2
 
   shim.wrapMiddlewareMounter(proto, 'use', {
     route: shim.FIRST,

package/lib/instrumentation/core/async_hooks.js

@@ -5,7 +5,7 @@
 
 'use strict'
 
-var logger = require('../../logger').child({component: 'async_hooks'})
+var logger = require('../../logger').child({ component: 'async_hooks' })
 var promInit = require('../promise')
 
 module.exports = initialize
@@ -191,9 +191,16 @@ function getPromiseResolveStyleHooks(segmentMap, agent, shim) {
       if (hookSegment === null) {
         shim.setActiveSegment(hookSegment)
       }
-    },
-    destroy: function destroyHandler(id) {
-      // Clean up any unresolved promises that have been destroyed.
+    }
+  }
+
+  // Clean up any unresolved promises that have been destroyed.
+  // This defaults to true but does have a significant performance impact
+  // when customers have a lot of promises.
+  // See: https://github.com/newrelic/node-newrelic/issues/760
+  if (agent.config.feature_flag.unresolved_promise_cleanup) {
+    logger.info('Adding destroy hook to clean up unresolved promises.')
+    hooks.destroy = function destroyHandler(id) {
       segmentMap.delete(id)
     }
   }

package/lib/instrumentation/core/child_process.js

@@ -15,13 +15,9 @@ function initialize(agent, childProcess, moduleName, shim) {
 
   const methods = ['exec', 'execFile']
 
-  shim.record(
-    childProcess,
-    methods,
-    function recordExec(shim, fn, name) {
-      return {name: 'child_process.' + name, callback: shim.LAST}
-    }
-  )
+  shim.record(childProcess, methods, function recordExec(shim, fn, name) {
+    return { name: 'child_process.' + name, callback: shim.LAST }
+  })
 
   if (childProcess.ChildProcess) {
     wrapChildProcessClass(shim, childProcess.ChildProcess)
@@ -30,32 +26,28 @@ function initialize(agent, childProcess, moduleName, shim) {
   }
 
   function wrapChildProcessClass(shim, childProcessClass) {
-    shim.wrap(
-      childProcessClass.prototype,
-      'on',
-      function wrapChildProcessClassOn(shim, fn) {
-        return function wrappedChildProcessOn() {
-          const args = shim.argsToArray.apply(shim, arguments)
-          const cbIndex = args.length - 1
+    shim.wrap(childProcessClass.prototype, 'on', function wrapChildProcessClassOn(shim, fn) {
+      return function wrappedChildProcessOn() {
+        const args = shim.argsToArray.apply(shim, arguments)
+        const cbIndex = args.length - 1
 
-          const originalListener = args[cbIndex]
-          if (!shim.isFunction(originalListener)) {
-            return fn.apply(this, arguments)
-          }
+        const originalListener = args[cbIndex]
+        if (!shim.isFunction(originalListener)) {
+          return fn.apply(this, arguments)
+        }
 
-          shim.bindSegment(args, cbIndex)
+        shim.bindSegment(args, cbIndex)
 
-          // Leverage events.removeListener() mechanism that checks listener
-          // property to allow our wrapped listeners to match and remove appropriately.
-          // Avoids having to instrument removeListener() and potentially doubling
-          // lookup. Since our wrapping will only be referenced by the events
-          // collection, we should not need to unwrap.
-          args[cbIndex].listener = originalListener
+        // Leverage events.removeListener() mechanism that checks listener
+        // property to allow our wrapped listeners to match and remove appropriately.
+        // Avoids having to instrument removeListener() and potentially doubling
+        // lookup. Since our wrapping will only be referenced by the events
+        // collection, we should not need to unwrap.
+        args[cbIndex].listener = originalListener
 
-          return fn.apply(this, args)
-        }
+        return fn.apply(this, args)
       }
-    )
+    })
   }
 
   makePromisifyCompatible(shim, childProcess)

package/lib/instrumentation/core/crypto.js

@@ -10,13 +10,7 @@ module.exports = initialize
 function initialize(agent, crypto, moduleName, shim) {
   shim.record(
     crypto,
-    [
-      'pbkdf2',
-      'randomBytes',
-      'pseudoRandomBytes',
-      'randomFill',
-      'scrypt'
-    ],
+    ['pbkdf2', 'randomBytes', 'pseudoRandomBytes', 'randomFill', 'scrypt'],
     function recordCryptoMethod(shim, fn, name) {
       return {
         name: 'crypto.' + name,

package/lib/instrumentation/core/dns.js

@@ -23,11 +23,7 @@ function initialize(agent, dns, moduleName, shim) {
     'reverse'
   ]
 
-  shim.record(
-    dns,
-    methods,
-    function recordDnsMethod(shim, fn, name) {
-      return { name: 'dns.' + name, callback: shim.LAST }
-    }
-  )
+  shim.record(dns, methods, function recordDnsMethod(shim, fn, name) {
+    return { name: 'dns.' + name, callback: shim.LAST }
+  })
 }

package/lib/instrumentation/core/domain.js

@@ -9,18 +9,12 @@ module.exports = initialize
 
 function initialize(agent, domain, name, shim) {
   var proto = domain.Domain.prototype
-  shim.wrap(
-    proto,
-    'emit',
-    wrapEmit
-  )
+  shim.wrap(proto, 'emit', wrapEmit)
 
   function wrapEmit(shim, original) {
     return function wrappedEmit(ev) {
       var shouldRestoreContext =
-        ev === 'error' &&
-        shim.getActiveSegment() === null &&
-        shim.getSegment(this)
+        ev === 'error' && shim.getActiveSegment() === null && shim.getSegment(this)
 
       if (!shouldRestoreContext) {
         return original.apply(this, arguments)

package/lib/instrumentation/core/fs.js

@@ -44,10 +44,7 @@ function initialize(agent, fs, moduleName, shim) {
     'ftruncate'
   ]
 
-  const nonRecordedMethods = [
-    'write',
-    'read'
-  ]
+  const nonRecordedMethods = ['write', 'read']
 
   shim.record(fs, methods, recordFs)
 
@@ -58,48 +55,36 @@ function initialize(agent, fs, moduleName, shim) {
 
   fs.realpath.native = shim.getOriginal(fs.realpath).native
 
-  shim.record(
-    fs.realpath,
-    'native',
-    function recordRealpathNative(shim, fn) {
-      return recordFs(shim, fn, 'realpath.native')
-    }
-  )
+  shim.record(fs.realpath, 'native', function recordRealpathNative(shim, fn) {
+    return recordFs(shim, fn, 'realpath.native')
+  })
 
-  shim.wrap(
-    fs,
-    nonRecordedMethods,
-    function wrapNonRecordedFs(shim, fn) {
-      return function wrappedNonRecordedFs() {
-        // these are called in tight loops so opting out early
-        if (!shim.getActiveSegment()) {
-          return fn.apply(this, arguments)
-        }
+  shim.wrap(fs, nonRecordedMethods, function wrapNonRecordedFs(shim, fn) {
+    return function wrappedNonRecordedFs() {
+      // these are called in tight loops so opting out early
+      if (!shim.getActiveSegment()) {
+        return fn.apply(this, arguments)
+      }
 
-        const args = shim.argsToArray.apply(shim, arguments)
-        const cbIndex = args.length - 1
+      const args = shim.argsToArray.apply(shim, arguments)
+      const cbIndex = args.length - 1
 
-        shim.bindSegment(args, cbIndex)
+      shim.bindSegment(args, cbIndex)
 
-        return fn.apply(this, args)
-      }
+      return fn.apply(this, args)
     }
-  )
+  })
 
-  shim.wrap(
-    fs,
-    ['watch', 'watchFile'],
-    function wrapFsWatch(shim, fn) {
-      return function wrappedFsWatch() {
-        const result = fn.apply(this, arguments)
-        shim.bindSegment(result, 'emit')
+  shim.wrap(fs, ['watch', 'watchFile'], function wrapFsWatch(shim, fn) {
+    return function wrappedFsWatch() {
+      const result = fn.apply(this, arguments)
+      shim.bindSegment(result, 'emit')
 
-        return result
-      }
+      return result
     }
-  )
+  })
 
   function recordFs(shim, fn, name) {
-    return {name: NAMES.FS.PREFIX + name, callback: shim.LAST, recorder: record}
+    return { name: NAMES.FS.PREFIX + name, callback: shim.LAST, recorder: record }
   }
 }

package/lib/instrumentation/core/globals.js

@@ -9,7 +9,6 @@ var asyncHooks = require('./async_hooks')
 
 module.exports = initialize
 
-
 function initialize(agent, nodule, name, shim) {
   let exceptionCallbackRegistered = false
 
@@ -42,13 +41,10 @@ function initialize(agent, nodule, name, shim) {
         if (process.listenerCount('unhandledRejection') === 0) {
           // If there are no unhandledRejection handlers report the error.
           const segment = promise.__NR_id
-            ? (asyncHooks.segmentMap.get(promise.__NR_id))
-            : (promise.__NR_context && promise.__NR_context.getSegment())
+            ? asyncHooks.segmentMap.get(promise.__NR_id)
+            : promise.__NR_context && promise.__NR_context.getSegment()
           const tx = segment && segment.transaction
-          shim.logger.trace(
-            'Captured unhandled rejection for transaction %s',
-            tx && tx.id
-          )
+          shim.logger.trace('Captured unhandled rejection for transaction %s', tx && tx.id)
           agent.errors.add(tx, error)
         }
       }

package/lib/instrumentation/core/http-outbound.js

@@ -8,7 +8,7 @@
 var recordExternal = require('../../metrics/recorders/http_external')
 var urltils = require('../../util/urltils')
 var hashes = require('../../util/hashes')
-var logger = require('../../logger').child({component: 'outbound'})
+var logger = require('../../logger').child({ component: 'outbound' })
 var shimmer = require('../../shimmer')
 var url = require('url')
 var copy = require('../../util/copy')
@@ -43,14 +43,11 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
   let hostname = opts.hostname || opts.host || DEFAULT_HOST
   let port = opts.port || opts.defaultPort
   if (!port) {
-    port = (!opts.protocol || opts.protocol === 'http:') ? DEFAULT_PORT : DEFAULT_SSL_PORT
+    port = !opts.protocol || opts.protocol === 'http:' ? DEFAULT_PORT : DEFAULT_SSL_PORT
   }
 
   if (!hostname || port < 1) {
-    logger.warn(
-      'Invalid host name (%s) or port (%s) for outbound request.',
-      hostname, port
-    )
+    logger.warn('Invalid host name (%s) or port (%s) for outbound request.', hostname, port)
     return makeRequest(opts)
   }
 
@@ -75,7 +72,6 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
     return makeRequest(opts)
   }
 
-
   return agent.tracer.addSegment(
     name,
     recordExternal(hostname, 'http'),
@@ -118,11 +114,7 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
         })
       )
     } else {
-      opts.headers = Object.assign(
-        Object.create(null),
-        opts.headers,
-        outboundHeaders
-      )
+      opts.headers = Object.assign(Object.create(null), opts.headers, outboundHeaders)
     }
 
     segment.start()
@@ -136,7 +128,8 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
 
     if (parsed.parameters) {
       // Scrub and parse returns on object with a null prototype.
-      for (let key in parsed.parameters) { // eslint-disable-line guard-for-in
+      // eslint-disable-next-line guard-for-in
+      for (let key in parsed.parameters) {
         segment.addSpanAttribute(`request.parameters.${key}`, parsed.parameters[key])
       }
     }
@@ -177,10 +170,7 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
  */
 function handleError(segment, req, error) {
   if (req.listenerCount('error') > 0) {
-    logger.trace(
-      error,
-      'Not capturing outbound error because user has already handled it.'
-    )
+    logger.trace(error, 'Not capturing outbound error because user has already handled it.')
     return false
   }
 
@@ -205,10 +195,7 @@ function handleResponse(segment, hostname, req, res) {
 
   // If CAT is enabled, grab those headers!
   const agent = segment.transaction.agent
-  if (
-    agent.config.cross_application_tracer.enabled &&
-    !agent.config.distributed_tracing.enabled
-  ) {
+  if (agent.config.cross_application_tracer.enabled && !agent.config.distributed_tracing.enabled) {
     pullCatHeaders(agent.config, segment, hostname, res.headers['x-newrelic-app-data'])
   }
 
@@ -232,9 +219,7 @@ function pullCatHeaders(config, segment, host, obfAppData) {
   }
 
   if (!config.trusted_account_ids) {
-    logger.trace(
-      'config.trusted_account_ids is not set - not parsing response CAT headers'
-    )
+    logger.trace('config.trusted_account_ids is not set - not parsing response CAT headers')
     return
   }
 
@@ -244,8 +229,7 @@ function pullCatHeaders(config, segment, host, obfAppData) {
   } else {
     var appData = null
     try {
-      appData =
-        JSON.parse(hashes.deobfuscateNameUsingKey(obfAppData, config.encoding_key))
+      appData = JSON.parse(hashes.deobfuscateNameUsingKey(obfAppData, config.encoding_key))
     } catch (e) {
       logger.warn('Got an unparsable CAT header x-newrelic-app-data: %s', obfAppData)
       return
@@ -259,13 +243,12 @@ function pullCatHeaders(config, segment, host, obfAppData) {
       } else {
         segment.catId = appData[0]
         segment.catTransaction = appData[1]
-        segment.name = NAMES.EXTERNAL.TRANSACTION + host + '/' +
-                       segment.catId + '/' + segment.catTransaction
+        segment.name =
+          NAMES.EXTERNAL.TRANSACTION + host + '/' + segment.catId + '/' + segment.catTransaction
         if (appData.length >= 6) {
           segment.addAttribute('transaction_guid', appData[5])
         }
-        logger.trace('Got inbound response CAT headers in transaction %s',
-          segment.transaction.id)
+        logger.trace('Got inbound response CAT headers in transaction %s', segment.transaction.id)
       }
     }
   }
@@ -294,19 +277,11 @@ function _addCATHeaders(agent, tx, outboundHeaders) {
   tx.pushPathHash(pathHash)
 
   try {
-    let txData = JSON.stringify([
-      tx.id,
-      false,
-      tx.tripId || tx.id,
-      pathHash
-    ])
+    let txData = JSON.stringify([tx.id, false, tx.tripId || tx.id, pathHash])
     txData = hashes.obfuscateNameUsingKey(txData, agent.config.encoding_key)
     outboundHeaders[NEWRELIC_TRANSACTION_HEADER] = txData
 
-    logger.trace(
-      'Added outbound request CAT headers in transaction %s',
-      tx.id
-    )
+    logger.trace('Added outbound request CAT headers in transaction %s', tx.id)
   } catch (err) {
     logger.trace(err, 'Failed to create CAT payload')
   }