newrelic 4.6.0 → 4.9.0

package/lib/instrumentation/core/fs.js

@@ -1,13 +1,12 @@
 'use strict'
 
-var record = require('../../metrics/recorders/generic')
-var NAMES = require('../../metrics/names')
-var wrap = require('../../shimmer').wrapMethod
+const record = require('../../metrics/recorders/generic')
+const NAMES = require('../../metrics/names')
 
 module.exports = initialize
 
-function initialize(agent, fs) {
-  var methods = [
+function initialize(agent, fs, moduleName, shim) {
+  const methods = [
     'rename',
     'truncate',
     'chown',
@@ -40,52 +39,62 @@ function initialize(agent, fs) {
     'ftruncate'
   ]
 
-  var uninstrumented = [
+  const nonRecordedMethods = [
     'write',
     'read'
   ]
 
-  wrap(fs, 'fs', methods, segment)
-  wrap(fs.realpath, 'fs.realpath', 'native', wrapRealPathNative)
-  wrap(fs, 'fs', uninstrumented, agent.tracer.wrapFunctionNoSegment.bind(agent.tracer))
-  wrap(fs, 'fs', ['watch'], wrapWatch)
-  wrap(fs, 'fs', ['watchFile'], wrapWatchFile)
+  shim.record(fs, methods, recordFs)
 
-  function segment(fn, method) {
-    return agent.tracer.wrapFunctionLast(NAMES.FS.PREFIX + method, record, fn)
-  }
+  const originalExists = shim.getOriginal(fs.exists)
+  Object.getOwnPropertySymbols(originalExists).forEach((symbol) => {
+    fs.exists[symbol] = originalExists[symbol]
+  })
 
-  function wrapRealPathNative(fn) {
-    return segment(fn, 'realpath.native')
-  }
+  fs.realpath.native = shim.getOriginal(fs.realpath).native
 
-  function wrapWatch(fn) {
-    return function wrappedWatch() {
-      var args = agent.tracer.slice(arguments)
-      var last = args.length - 1
+  shim.record(
+    fs.realpath,
+    'native',
+    function recordRealpathNative(shim, fn) {
+      return recordFs(shim, fn, 'realpath.native')
+    }
+  )
 
-      if (typeof args[last] === 'function') {
-        var cb = args[last]
-        args[last] = agent.tracer.bindFunction(cb)
-      }
+  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)
+        }
 
-      return agent.tracer.bindEmitter(fn.apply(this, args))
-    }
-  }
+        const args = shim.argsToArray.apply(shim, arguments)
+        const cbIndex = args.length - 1
 
-  function wrapWatchFile(fn) {
-    return function wrappedWatchFile() {
-      var args = agent.tracer.slice(arguments)
-      var last = args.length - 1
+        shim.bindSegment(args, cbIndex)
 
-      if (typeof args[last] === 'function') {
-        var cb = args[last]
-        args[last] = agent.tracer.bindFunction(cb)
-        // allow unwatchFile to work despite cb being wrapped
-        args[last].listener = cb
+        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')
 
-      return fn.apply(this, args)
+        return result
+      }
     }
+  )
+
+  function recordFs(shim, fn, name) {
+    return {name: NAMES.FS.PREFIX + name, callback: shim.LAST, recorder: record}
   }
 }

package/lib/instrumentation/core/globals.js

@@ -1,33 +1,30 @@
 'use strict'
 
 var asyncHooks = require('./async_hooks')
-var logger = require('../../logger').child({component: 'globals'})
-var shimmer = require('../../shimmer')
 
 module.exports = initialize
 
 
-function initialize(agent) {
+function initialize(agent, nodule, name, shim) {
   let exceptionCallbackRegistered = false
 
   // `_fatalException` is an undocumented feature of domains, introduced in
   // Node.js v0.8. We use `_fatalException` because wrapping it will not
   // potentially change the behavior of the server unlike listening for
   // `uncaughtException`.
-  shimmer.wrapMethod(process, 'process', '_fatalException', function wrapper(original) {
+  shim.wrap(process, '_fatalException', function wrapper(shim, original) {
     return function wrappedFatalException(error) {
       // Only record the error if we are not currently within an instrumented
       // domain.
       if (!process.domain && !exceptionCallbackRegistered) {
         agent.errors.add(null, error)
-        agent.tracer.segment = null
+        shim.setActiveSegment(null)
       }
       return original.apply(this, arguments)
     }
   })
 
-  shimmer.wrapMethod(process, 'process', 'emit', wrapEmit)
-  function wrapEmit(original) {
+  shim.wrap(process, 'emit', function wrapEmit(shim, original) {
     return function wrappedEmit(ev, error, promise) {
       // Check for unhandledRejections here so we don't change the behavior of
       // the event.
@@ -38,23 +35,21 @@ function initialize(agent) {
             ? (asyncHooks.segmentMap.get(promise.__NR_id))
             : (promise.__NR_context && promise.__NR_context.getSegment())
           const tx = segment && segment.transaction
-          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)
         }
       }
 
       return original.apply(this, arguments)
     }
-  }
+  })
 
-  shimmer.wrapMethod(
-    process,
-    'process',
-    'setUncaughtExceptionCaptureCallback',
-    wrapUncaughtExceptionCallback
-  )
+  shim.wrap(process, 'setUncaughtExceptionCaptureCallback', wrapUncaughtExceptionCallback)
 
-  function wrapUncaughtExceptionCallback(original) {
+  function wrapUncaughtExceptionCallback(shim, original) {
     return function wrapped(fn) {
       exceptionCallbackRegistered = fn !== null
       return original.apply(this, arguments)
@@ -63,5 +58,5 @@ function initialize(agent) {
 
   // This will initialize the most optimal native-promise instrumentation that
   // we have available.
-  asyncHooks(agent)
+  asyncHooks(agent, shim)
 }

package/lib/instrumentation/core/http.js

@@ -693,7 +693,7 @@ module.exports = function initialize(agent, http, moduleName) {
  *
  * @param {string} header - The raw X-NewRelic-Synthetics header
  * @param {string} encKey - Encoding key handed down from the server
- * @param {̄Array} trustedIds - Array of accounts to trust the header from.
+ * @param {Array.<number>} trustedIds - Array of accounts to trust the header from.
  * @param {Transaction} transaction - Where the synthetics data is attached to.
  */
 function handleSyntheticsHeader(header, encKey, trustedIds, transaction) {
@@ -711,8 +711,8 @@ function handleSyntheticsHeader(header, encKey, trustedIds, transaction) {
  *
  * @param {string} header - The raw X-NewRelic-Synthetics header
  * @param {string} encKey - Encoding key handed down from the server
- * @param {̄Array} trustedIds - Array of accounts to trust the header from.
- * @return {Object or null} - On successful parse and verification an object of
+ * @param {Array.<number>} trustedIds - Array of accounts to trust the header from.
+ * @return {Object|null} - On successful parse and verification an object of
  *                            synthetics data is returned, otherwise null is
  *                            returned.
  */

package/lib/instrumentation/core/inspector.js

@@ -1,21 +1,22 @@
 'use strict'
 
-var wrap = require('../../shimmer').wrapMethod
-
 module.exports = initialize
 
-function initialize(agent, inspector) {
+function initialize(agent, inspector, name, shim) {
   var sessionProto = inspector && inspector.Session && inspector.Session.prototype
   if (!sessionProto) {
     return false
   }
 
-  wrap(
+  shim.wrap(
     sessionProto,
-    'inspector.Session.prototype',
     'post',
-    function wrapPost(fn) {
-      return agent.tracer.wrapFunctionNoSegment(fn, 'post')
+    function wrapPost(shim, fn) {
+      return function wrappedPost() {
+        var args = shim.argsToArray.apply(shim, arguments)
+        shim.bindCallbackSegment(args, shim.LAST)
+        return fn.apply(this, args)
+      }
     }
   )
 }

package/lib/instrumentation/core/net.js

@@ -1,108 +1,104 @@
 'use strict'
 
-var shimmer = require('../../shimmer')
-
-
-module.exports = function initialize(agent, net) {
-  shimmer.wrapMethod(net, 'net', ['connect', 'createConnection'], wrapCreate)
-  function wrapCreate(original, name) {
+module.exports = function initialize(agent, net, moduleName, shim) {
+  shim.wrap(net, ['connect', 'createConnection'], wrapCreate)
+  function wrapCreate(shim, fn, name) {
     return function wrappedCreateConnection() {
-      if (!agent.getTransaction()) {
-        return original.apply(this, arguments)
+      const segment = shim.getActiveSegment()
+      if (!segment) {
+        return fn.apply(this, arguments)
       }
 
-      var segment = agent.tracer.createSegment('net.' + name)
-      var sock = agent.tracer.bindFunction(original, segment, true).apply(this, arguments)
-      wrapSocket(sock, segment)
+      const child = shim.createSegment('net.' + name, null, segment)
+      const sock = shim.applySegment(fn, child, true, this, arguments)
+      wrapSocket(sock, child)
       return sock
     }
   }
 
-  net.Server.prototype.listen = agent.tracer.wrapFunctionNoSegment(
-    net.Server.prototype.listen,
-    'net.Server.prototype.listen'
-  )
-
-  net.Server.prototype.close = agent.tracer.wrapFunctionNoSegment(
-    net.Server.prototype.close,
-    'net.Server.prototype.close'
-  )
-
-  shimmer.wrapMethod(
-    net.Server.prototype,
-    'net.Server.prototype',
-    '_listen2',
-    wrapListen2
-  )
-  shimmer.wrapMethod(
-    net.Socket.prototype,
-    'net.Socket.prototype',
-    'connect',
-    wrapConnect
-  )
-
-  function wrapListen2(original) {
+  const serverProto = net.Server.prototype
+
+  shim.wrap(serverProto, ['listen', 'close'], function wrapNoRecord(shim, fn) {
+    return function wrappedNoRecord() {
+      if (!shim.getActiveSegment()) {
+        return fn.apply(this, arguments)
+      }
+
+      const args = shim.argsToArray.apply(shim, arguments)
+      const cbIndex = args.length - 1
+
+      shim.bindSegment(args, cbIndex)
+
+      return fn.apply(this, args)
+    }
+  })
+
+  shim.wrap(serverProto, '_listen2', wrapListen2)
+  shim.wrap(net.Socket.prototype, 'connect', wrapConnect)
+
+  function wrapListen2(shim, fn) {
     return function wrappedListen2() {
-      var segment = agent.tracer.getSegment()
-      var emit = this.emit
+      const segment = shim.getActiveSegment()
+      const emit = this.emit
 
-      if (!segment || !emit) return original.apply(this, arguments)
+      if (!segment || !emit) return fn.apply(this, arguments)
 
       this.emit = wrappedEmit
 
-      return original.apply(this, arguments)
+      return fn.apply(this, arguments)
 
       function wrappedEmit(ev, socket) {
         if (ev !== 'connection' || !socket || !socket._handle) {
           return emit.apply(this, arguments)
         }
 
-        var child = agent.tracer.createSegment('net.Server.onconnection', null, segment)
+        const child = shim.createSegment('net.Server.onconnection', segment)
 
         if (socket._handle.onread) {
-          socket._handle.onread = agent.tracer.bindFunction(socket._handle.onread, child)
+          shim.bindSegment(socket._handle, 'onread', child)
         }
 
-        return agent.tracer.bindFunction(emit, child, true).apply(this, arguments)
+        return shim.applySegment(emit, child, true, this, arguments)
       }
     }
   }
 
-  function wrapConnect(original) {
+  function wrapConnect(shim, fn) {
     return function connectWrapper() {
-      if (!agent.getTransaction()) return original.apply(this, arguments)
-      var socket = this
-      var args = normalizeConnectArgs(arguments)
-      return agent.tracer.addSegment(
-        'net.Socket.connect',
-        null,
-        null,
-        true,
-        wrappedConnect
-      )
-
-      function wrappedConnect(child) {
-        if (args[1]) args[1] = agent.tracer.bindFunction(args[1], child)
-        var result = original.apply(socket, args)
-        if (socket._handle) {
-          socket._handle.onread = agent.tracer.bindFunction(socket._handle.onread, child)
-        }
-        agent.tracer.bindEmitter(socket, child)
-        return result
+      if (!agent.getTransaction()) {
+        return fn.apply(this, arguments)
+      }
+
+      const socket = this
+      const args = normalizeConnectArgs(arguments)
+
+      const segment = shim.createSegment('net.Socket.connect')
+
+      if (args[1]) {
+        args[1] = shim.bindSegment(args[1], segment)
       }
+
+      const result = shim.applySegment(fn, segment, true, this, args)
+
+      if (socket._handle) {
+        shim.bindSegment(socket._handle, 'onread', segment)
+      }
+      shim.bindSegment(socket, 'emit', segment)
+
+      return result
     }
   }
 
   function wrapSocket(sock, segment) {
-    shimmer.wrapMethod(sock, 'net.Socket', 'emit', function emitWrapper(emit) {
-      return agent.tracer.bindFunction(emit, segment)
+    shim.wrap(sock, 'emit', function emitWrapper(shim, fn) {
+      return shim.bindSegment(fn, segment)
     })
   }
 }
 
 // taken from node master on 2013/10/30
 function normalizeConnectArgs(args) {
-  var options = Object.create(null)
+  let options = Object.create(null)
 
   function toNumber(x) {
     return (x = Number(x)) >= 0 ? x : false
@@ -121,6 +117,6 @@ function normalizeConnectArgs(args) {
     }
   }
 
-  var cb = args[args.length - 1]
+  const cb = args[args.length - 1]
   return typeof cb === 'function' ? [options, cb] : [options]
 }

package/lib/instrumentation/core/timers.js

@@ -1,60 +1,99 @@
 'use strict'
 
-var wrap = require('../../shimmer').wrapMethod
-var psemver = require('../../util/process-version')
-
 module.exports = initialize
 
-function initialize(agent, timers) {
-  // As of iojs 1.6.3 all timers are on the global object, and do
-  // not need a require('timers') call to access them
-  if (timers !== global && psemver.satisfies('>=1.6.3') &&
-      global.setTimeout && !global.setTimeout.__NR_original) {
-    initialize(agent, global)
+function initialize(agent, timers, moduleName, shim) {
+  const processMethods = ['nextTick', '_nextDomainTick', '_tickDomainCallback']
+
+  shim.wrap(
+    process,
+    processMethods,
+    function wrapProcess(shim, fn) {
+      return function wrappedProcess() {
+        const segment = shim.getActiveSegment()
+        if (!segment) {
+          return fn.apply(this, arguments)
+        }
+
+        // Manual copy because helper methods add significant overhead in some usages
+        var len = arguments.length
+        var args = new Array(len)
+        for (var i = 0; i < len; ++i) {
+          args[i] = arguments[i]
+        }
+
+        shim.bindSegment(args, shim.FIRST, segment)
+
+        return fn.apply(this, args)
+      }
+    }
+  )
+
+  instrumentTimerMethods(timers)
+
+  // If we need to instrument separate references to timers on the global object,
+  // do that now.
+  if (!shim.isWrapped(global.setTimeout)) {
+    instrumentTimerMethods(global)
   }
 
-  var processMethods = ['nextTick', '_nextDomainTick', '_tickDomainCallback']
+  function instrumentTimerMethods(nodule) {
+    const asynchronizers = [
+      'setTimeout',
+      'setInterval'
+    ]
 
-  wrap(process, 'process', processMethods, function bindProcess(original, method) {
-    return agent.tracer.wrapFunctionFirstNoSegment(original, method)
-  })
+    shim.record(nodule, asynchronizers, recordAsynchronizers)
 
-  var asynchronizers = [
-    'setTimeout',
-    'setInterval'
-  ]
+    // We don't want to create segments for setImmediate calls, as the
+    // object allocation may incur too much overhead in some situations
+    shim.wrap(nodule, 'setImmediate', wrapSetImmediate)
 
-  wrap(timers, 'timers', asynchronizers, function wrapTimers(original, method) {
-    return agent.tracer.wrapFunctionFirst('timers.' + method, null, original)
-  })
+    shim.wrap(nodule, 'clearTimeout', wrapClearTimeout)
 
-  // We don't want to create segments for setImmediate calls, as the
-  // object allocation may incur too much overhead in some situations
-  var uninstrumented = [
-    'setImmediate'
-  ]
+    makeWrappedPromisifyCompatible(shim, nodule)
+  }
 
-  wrap(timers, 'timers', uninstrumented, function wrapUninstrumented(original, method) {
-    return agent.tracer.wrapFunctionFirstNoSegment(original, method)
-  })
+  function wrapSetImmediate(shim, fn) {
+    return function wrappedSetImmediate() {
+      const args = shim.argsToArray.apply(shim, arguments)
+      shim.bindSegment(args, shim.FIRST)
 
-  var clearTimeouts = ['clearTimeout']
+      return fn.apply(this, args)
+    }
+  }
 
-  wrap(timers, 'timers', clearTimeouts, function wrapClear(original) {
-    return function wrappedClear(timer) {
-      var segment
+  function wrapClearTimeout(shim, fn) {
+    return function wrappedClearTimeout(timer) {
       if (timer && timer._onTimeout) {
-        segment = agent.tracer.getSegmentFromWrapped(timer._onTimeout)
-        timer._onTimeout = agent.tracer.getOriginal(timer._onTimeout)
+        const segment = timer._onTimeout.__NR_segment
+        if (segment) {
+          segment.ignore = true
+        }
       }
 
-      if (timer && timer._onImmediate) {
-        timer._onImmediate = agent.tracer.getOriginal(timer._onImmediate)
-      }
+      return fn.apply(this, arguments)
+    }
+  }
+
+  function recordAsynchronizers(shim, fn, name) {
+    return {name: 'timers.' + name, callback: shim.FIRST}
+  }
+}
+
+function makeWrappedPromisifyCompatible(shim, timers) {
+  const originalSetTimout = shim.getOriginal(timers.setTimeout)
+  Object.getOwnPropertySymbols(originalSetTimout).forEach((symbol) => {
+    timers.setTimeout[symbol] = originalSetTimout[symbol]
+  })
 
-      if (segment) segment.ignore = true
+  const originalSetInterval = shim.getOriginal(timers.setInterval)
+  Object.getOwnPropertySymbols(originalSetInterval).forEach((symbol) => {
+    timers.setInterval[symbol] = originalSetInterval[symbol]
+  })
 
-      return original.apply(this, arguments)
-    }
+  const originalSetImmediate = shim.getOriginal(timers.setImmediate)
+  Object.getOwnPropertySymbols(originalSetImmediate).forEach((symbol) => {
+    timers.setImmediate[symbol] = originalSetImmediate[symbol]
   })
 }

package/lib/instrumentation/core/zlib.js

@@ -1,6 +1,6 @@
 'use strict'
 
-var wrap = require('../../shimmer').wrapMethod
+const recorder = require('../../metrics/recorders/generic')
 
 module.exports = initialize
 
@@ -14,22 +14,36 @@ var methods = [
   'unzip'
 ]
 
-function initialize(agent, zlib) {
-  var noSegment = agent.tracer.wrapFunctionNoSegment.bind(agent.tracer)
+function initialize(agent, zlib, moduleName, shim) {
+  shim.record(zlib, methods, recordZLib)
+
   if (zlib.Deflate && zlib.Deflate.prototype) {
     var proto = Object.getPrototypeOf(zlib.Deflate.prototype)
     if (proto._transform) {
       // streams2
-      wrap(proto, 'zlib', '_transform', noSegment)
+      shim.wrap(proto, '_transform', wrapNoSegment)
     } else if (proto.write && proto.flush && proto.end) {
       // plain ol' streams
-      wrap(proto, 'zlib', ['write', 'flush', 'end'], noSegment)
+      shim.wrap(proto, ['write', 'flush', 'end'], wrapNoSegment)
     }
   }
 
-  wrap(zlib, 'zlib', methods, segment)
+  function recordZLib(shim, fn, name) {
+    return {name: `zlib.${name}`, callback: shim.LAST, recorder}
+  }
+}
+
+function wrapNoSegment(shim, fn) {
+  return function wrappedZLibNoSegment() {
+    if (!shim.getActiveSegment()) {
+      return fn.apply(this, arguments)
+    }
+
+    const args = shim.argsToArray.apply(shim, arguments)
+    const cbIndex = args.length - 1
+
+    shim.bindSegment(args, cbIndex)
 
-  function segment(fn, method) {
-    return agent.tracer.wrapFunctionLast('zlib.' + method, null, fn)
+    return fn.apply(this, args)
   }
 }