newrelic 4.8.1 → 4.9.0

package/lib/instrumentation/core/timers.js

@@ -1,70 +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)
+      }
+    }
+  )
 
-  var processMethods = ['nextTick', '_nextDomainTick', '_tickDomainCallback']
+  instrumentTimerMethods(timers)
 
-  wrap(process, 'process', processMethods, function bindProcess(original, method) {
-    return agent.tracer.wrapFunctionFirstNoSegment(original, method)
-  })
+  // If we need to instrument separate references to timers on the global object,
+  // do that now.
+  if (!shim.isWrapped(global.setTimeout)) {
+    instrumentTimerMethods(global)
+  }
 
-  var asynchronizers = [
-    'setTimeout',
-    'setInterval'
-  ]
+  function instrumentTimerMethods(nodule) {
+    const asynchronizers = [
+      'setTimeout',
+      'setInterval'
+    ]
 
-  wrap(timers, 'timers', asynchronizers, function wrapTimers(original, method) {
-    var wrapped = agent.tracer.wrapFunctionFirst('timers.' + method, null, original)
+    shim.record(nodule, asynchronizers, recordAsynchronizers)
 
-    Object.getOwnPropertySymbols(original).forEach((symbol) => {
-      wrapped[symbol] = original[symbol]
-    })
-    return wrapped
-  })
+    // 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)
 
-  // 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'
-  ]
+    shim.wrap(nodule, 'clearTimeout', wrapClearTimeout)
 
-  wrap(timers, 'timers', uninstrumented, function wrapUninstrumented(original, method) {
-    var wrapped = agent.tracer.wrapFunctionFirstNoSegment(original, method)
-    Object.getOwnPropertySymbols(original).forEach((symbol) => {
-      wrapped[symbol] = original[symbol]
-    })
+    makeWrappedPromisifyCompatible(shim, nodule)
+  }
 
-    return wrapped
-  })
+  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}
+  }
+}
 
-      if (segment) segment.ignore = true
+function makeWrappedPromisifyCompatible(shim, timers) {
+  const originalSetTimout = shim.getOriginal(timers.setTimeout)
+  Object.getOwnPropertySymbols(originalSetTimout).forEach((symbol) => {
+    timers.setTimeout[symbol] = originalSetTimout[symbol]
+  })
 
-      return original.apply(this, arguments)
-    }
+  const originalSetInterval = shim.getOriginal(timers.setInterval)
+  Object.getOwnPropertySymbols(originalSetInterval).forEach((symbol) => {
+    timers.setInterval[symbol] = originalSetInterval[symbol]
+  })
+
+  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)
   }
 }

package/lib/instrumentations.js

@@ -6,8 +6,9 @@ var MODULE_TYPE = require('./shim/constants').MODULE_TYPE
 module.exports = function instrumentations() {
   return {
     'amqplib': {type: MODULE_TYPE.MESSAGE},
+    'cassandra-driver': {type: MODULE_TYPE.DATASTORE},
     'connect': {type: MODULE_TYPE.WEB_FRAMEWORK},
-    'bluebird': {type: null},
+    'bluebird': {type: MODULE_TYPE.PROMISE},
     'director': {type: MODULE_TYPE.WEB_FRAMEWORK},
     'express': {type: MODULE_TYPE.WEB_FRAMEWORK},
     'generic-pool': {type: MODULE_TYPE.GENERIC},
@@ -18,11 +19,11 @@ module.exports = function instrumentations() {
     'mongodb': {type: MODULE_TYPE.DATASTORE},
     'mysql': {type: MODULE_TYPE.DATASTORE},
     'node-cassandra-cql': {type: MODULE_TYPE.DATASTORE},
-    'cassandra-driver': {type: MODULE_TYPE.DATASTORE},
     'pg': {type: MODULE_TYPE.DATASTORE},
     'q': {type: null},
     'redis': {type: MODULE_TYPE.DATASTORE},
     'restify': {type: MODULE_TYPE.WEB_FRAMEWORK},
+    'superagent': {module: '@newrelic/superagent'},
     'oracle': {type: null},
     'vision': {type: MODULE_TYPE.WEB_FRAMEWORK},
     'when': {type: null}

package/lib/shim/constants.js

@@ -17,6 +17,10 @@ var MODULE_TYPE = {
   /** Messaging module, such as AMQP */
   MESSAGE: 'message',
 
+  /** Promise module, such as Bluebird */
+  PROMISE: 'promise',
+
+  /** @private */
   TRANSACTION: 'transaction',
 
   /** Web server framework module, such as Express or Restify. */

package/lib/shim/datastore-shim.js

@@ -1,7 +1,7 @@
 'use strict'
 
 var hasOwnProperty = require('../util/properties').hasOwn
-var logger = require('../logger.js').child({component: 'DatastoreShim'})
+var logger = require('../logger').child({component: 'DatastoreShim'})
 var metrics = require('../metrics/names')
 var parseSql = require('../db/query-parsers/sql')
 var ParsedStatement = require('../db/parsed-statement')

package/lib/shim/index.js

@@ -1,16 +1,18 @@
 'use strict'
 
-var constants = require('./constants')
+const constants = require('./constants')
 
-var Shim = require('./shim')
-var DatastoreShim = require('./datastore-shim')
-var MessageShim = require('./message-shim')
-var TransactionShim = require('./transaction-shim')
-var WebFrameworkShim = require('./webframework-shim')
+const Shim = require('./shim')
+const DatastoreShim = require('./datastore-shim')
+const MessageShim = require('./message-shim')
+const PromiseShim = require('./promise-shim')
+const TransactionShim = require('./transaction-shim')
+const WebFrameworkShim = require('./webframework-shim')
 
 exports.constants = constants
 exports.Shim = Shim
 exports.DatastoreShim = DatastoreShim
 exports.MessageShim = MessageShim
+exports.PromiseShim = PromiseShim
 exports.TransactionShim = TransactionShim
 exports.WebFrameworkShim = WebFrameworkShim