newrelic 4.6.0 → 4.9.0

package/lib/instrumentation/mongodb.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const semver = require('semver')
+
 // XXX: When this instrumentation is modularized, update this thread
 // with a cautionary note:
 // https://discuss.newrelic.com/t/feature-idea-using-mongoose-cursors-memory-leaking-very-quickly/49270/14
@@ -9,7 +11,7 @@
 // location.
 
 // legacy endpoint enumerations
-var DB_OPS = [
+const DB_OPS = [
   'addUser',
   'authenticate',
   'collection',
@@ -37,7 +39,7 @@ var DB_OPS = [
   '_executeQueryCommand'
 ]
 
-var COLLECTION_OPS = [
+const COLLECTION_OPS = [
   'aggregate',
   'bulkWrite',
   'count',
@@ -79,13 +81,13 @@ var COLLECTION_OPS = [
   'updateOne'
 ]
 
-var GRID_OPS = [
+const GRID_OPS = [
   'put',
   'get',
   'delete'
 ]
 
-var CURSOR_OPS = [
+const CURSOR_OPS = [
   'nextObject',
   'next',
   'toArray',
@@ -97,24 +99,10 @@ module.exports = initialize
 
 function initialize(agent, mongodb, moduleName, shim) {
   if (!mongodb) return
-  var 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}
-    }}
-  }
 
   shim.setDatastore(shim.MONGODB)
   shim.setParser(function mongoQueryParser(operation) {
-    var collection = this.collectionName || 'unknown'
+    let collection = this.collectionName || 'unknown'
     if (this.collection && this.collection.collectionName) {
       collection = this.collection.collectionName
     } else if (this.s && this.s.name) {
@@ -123,36 +111,51 @@ function initialize(agent, mongodb, moduleName, shim) {
       collection = this.ns.split(/\./)[1] || collection
     }
 
-    return {
-      operation: operation,
-      collection: collection
-    }
+    return {operation, collection}
   })
 
-  // instrument using the apm api
-  if (mongodb.instrument) {
-    var instrumenter = mongodb.instrument(Object.create(null), instrumentModules)
-    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.
-      var 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 (connId.domainSocket) {
-          shim.captureInstanceAttributes('localhost', connId.host, evnt.databaseName)
-        } else {
-          shim.captureInstanceAttributes(connId.host, connId.port, evnt.databaseName)
-        }
-      }
-    })
+  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)
   } else {
-    // fallback to legacy enumerations
-    legacyInstrumentation()
+    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
@@ -182,9 +185,9 @@ function initialize(agent, mongodb, moduleName, shim) {
         var makeDescFunc = recordDesc[objectName].makeDesc
         var proto = object.prototype
         if (isQuery) {
-          shim.recordQuery(proto, method, makeDescFunc(method))
+          shim.recordQuery(proto, method, makeDescFunc(shim, method))
         } else if (isQuery === false) { // could be unset
-          shim.recordOperation(proto, method, makeDescFunc(method))
+          shim.recordOperation(proto, method, makeDescFunc(shim, method))
         } else {
           shim.logger.trace('No wrapping method found for %s', objectName)
         }
@@ -197,95 +200,135 @@ function initialize(agent, mongodb, moduleName, shim) {
       shim.recordOperation(object.prototype, 'pipe')
     }
   }
+}
 
-  function makeQueryDescFunc(methodName) {
-    return function queryDescFunc() {
-      var parameters = getInstanceAttributeParameters(this)
-      var callback = shim.LAST
-      if (methodName === 'each') {
-        return {query: methodName, parameters: parameters, rowCallback: callback}
+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)
       }
-
-      // segment name does not actually use query string
-      // method name is set as query so the query parser has access to the op name
-      return {query: methodName, callback: callback, parameters: parameters}
     }
-  }
+  })
+}
 
-  function getInstanceAttributeParameters(obj) {
-    if (obj.db && obj.db.serverConfig) {
-      shim.logger.trace('Adding datastore instance attributes from obj.db.serverConfig')
-      var serverConfig = obj.db.serverConfig
-      var 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'
+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])
       )
-      var databaseName = obj.s.db.databaseName || null
-      var 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
+  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})
     }
+  }
 
-    function doCapture(conf, database) {
-      var host = conf.host
-      var 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'
-      }
+  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})
+  }
 
-      return {
-        host: host,
-        port_path_or_id: port,
-        database_name: database
+  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 legacyInstrumentation() {
-    if (mongodb.Cursor && mongodb.Cursor.prototype) {
-      var proto = mongodb.Cursor.prototype
-      for (var i = 0; i < CURSOR_OPS.length; i++) {
-        shim.recordQuery(proto, CURSOR_OPS[i], makeQueryDescFunc(CURSOR_OPS[i]))
-      }
-
-      shim.recordQuery(proto, 'each', makeQueryDescFunc('each'))
+function makeQueryDescFunc(shim, methodName) {
+  if (methodName === 'each') {
+    return function eachDescFunc() {
+      const parameters = getInstanceAttributeParameters(shim, this)
+      return {query: methodName, parameters, rowCallback: shim.LAST}
     }
+  }
 
-    if (mongodb.Collection && mongodb.Collection.prototype) {
-      var proto = mongodb.Collection.prototype
-      for (var i = 0; i < COLLECTION_OPS.length; i++) {
-        shim.recordQuery(proto, COLLECTION_OPS[i], makeQueryDescFunc(COLLECTION_OPS[i]))
-      }
+  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}
+  }
+}
+
+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)
     }
+  }
 
-    if (mongodb.Grid && mongodb.Grid.prototype) {
-      var proto = mongodb.Grid.prototype
-      for (var i = 0; i < CURSOR_OPS.length; i++) {
-        shim.recordOperation(proto, GRID_OPS[i],
-          {name:'GridFS-' + GRID_OPS[i], callback: shim.LAST})
-      }
+  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'
     }
 
-    if (mongodb.Db && mongodb.Db.prototype) {
-      var proto = mongodb.Db.prototype
-      shim.recordOperation(proto, DB_OPS, {callback: shim.LAST})
-      shim.recordOperation(mongodb.Db, 'connect', {callback: shim.LAST})
+    return {
+      host: host,
+      port_path_or_id: port,
+      database_name: database
     }
   }
 }

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/priority-queue.js

@@ -3,7 +3,7 @@
 var Heap = require('@tyriar/fibonacci-heap').FibonacciHeap
 
 function PriorityQueue(limit) {
-  this.limit = limit || 10
+  this.limit = limit == null ? 10 : limit
   this.seen = 0
   this._data = new Heap()
 
@@ -24,8 +24,11 @@ PriorityQueue.prototype.getMinimumPriority = function getMinimumPriority() {
 }
 
 PriorityQueue.prototype.add = function add(value, priority) {
-  priority = priority || Math.random()
   this.seen++
+  if (this.limit <= 0) {
+    return false
+  }
+  priority = priority || Math.random()
   if (this.length === this.limit) {
     return this._replace(value, priority)
   }

package/lib/shim/constants.js

@@ -17,6 +17,12 @@ 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. */
   WEB_FRAMEWORK: 'web-framework'
 }

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,14 +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 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

package/lib/shim/message-shim.js

@@ -333,10 +333,6 @@ function recordProduce(nodule, properties, recordNamer) {
     }
 
     var name = _nameMessageSegment(shim, msgDesc, shim._metrics.PRODUCE)
-    if (msgDesc.headers) {
-      shim.insertCATRequestHeaders(msgDesc.headers, true)
-    }
-
     if (!shim.agent.config.message_tracer.segment_parameters.enabled) {
       delete msgDesc.parameters
     } else if (msgDesc.routingKey) {
@@ -350,6 +346,11 @@ function recordProduce(nodule, properties, recordNamer) {
       promise: msgDesc.promise || false,
       callback: msgDesc.callback || null,
       recorder: genericRecorder,
+      inContext: function generateCATHeaders() {
+        if (msgDesc.headers) {
+          shim.insertCATRequestHeaders(msgDesc.headers, true)
+        }
+      },
       parameters: msgDesc.parameters || null
     }
   })