newrelic 7.5.2 → 8.3.0

package/lib/instrumentation/mongodb.js

@@ -6,6 +6,9 @@
 'use strict'
 
 const semver = require('semver')
+const instrument = require('./mongodb/v2-mongo')
+const instrumentV3 = require('./mongodb/v3-mongo')
+const instrumentV4 = require('./mongodb/v4-mongo')
 
 // XXX: When this instrumentation is modularized, update this thread
 // with a cautionary note:
@@ -15,325 +18,30 @@ const semver = require('semver')
 // snippet.  The snippet will break once this file is moved from this
 // location.
 
-// legacy endpoint enumerations
-const DB_OPS = [
-  'addUser',
-  'authenticate',
-  'collection',
-  'collectionNames',
-  'collections',
-  'command',
-  'createCollection',
-  'createIndex',
-  'cursorInfo',
-  'dereference',
-  'dropCollection',
-  'dropDatabase',
-  'dropIndex',
-  'ensureIndex',
-  'eval',
-  'executeDbAdminCommand',
-  'indexInformation',
-  'logout',
-  'open',
-  'reIndex',
-  'removeUser',
-  'renameCollection',
-  'stats',
-  '_executeInsertCommand',
-  '_executeQueryCommand'
-]
-
-const COLLECTION_OPS = [
-  'aggregate',
-  'bulkWrite',
-  'count',
-  'createIndex',
-  'deleteMany',
-  'deleteOne',
-  'distinct',
-  'drop',
-  'dropAllIndexes',
-  'dropIndex',
-  'ensureIndex',
-  'findAndModify',
-  'findAndRemove',
-  'findOne',
-  'findOneAndDelete',
-  'findOneAndReplace',
-  'findOneAndUpdate',
-  'geoHaystackSearch',
-  'geoNear',
-  'group',
-  'indexes',
-  'indexExists',
-  'indexInformation',
-  'insert',
-  'insertMany',
-  'insertOne',
-  'isCapped',
-  'mapReduce',
-  'options',
-  'parallelCollectionScan',
-  'reIndex',
-  'remove',
-  'rename',
-  'replaceOne',
-  'save',
-  'stats',
-  'update',
-  'updateMany',
-  'updateOne'
-]
-
-const GRID_OPS = [
-  'put',
-  'get',
-  'delete'
-]
-
-const CURSOR_OPS = [
-  'nextObject',
-  'next',
-  'toArray',
-  'count',
-  'explain'
-]
-
 module.exports = initialize
 
+/**
+ * Registers the query parser, and relevant instrumentation
+ * based on version of mongodb
+ *
+ * @param {Agent} agent
+ * @param {Object} mongodb resolved package
+ * @param {string} moduleName name of module
+ * @param {Shim} shim
+ */
 function initialize(agent, mongodb, moduleName, shim) {
-  if (!mongodb) return
+  if (!mongodb) {
+    return
+  }
 
   shim.setDatastore(shim.MONGODB)
-  shim.setParser(function mongoQueryParser(operation) {
-    let collection = this.collectionName || 'unknown'
-    if (this.collection && this.collection.collectionName) {
-      collection = this.collection.collectionName
-    } else if (this.s && this.s.name) {
-      collection = this.s.name
-    } else if (this.ns) {
-      collection = this.ns.split(/\./)[1] || collection
-    }
-
-    return {operation, collection}
-  })
 
   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)
+  if (semver.satisfies(mongoVersion, '>=4.0.0')) {
+    instrumentV4(shim, mongodb)
+  } else if (semver.satisfies(mongoVersion, '>=3.0.6')) {
+    instrumentV3(shim, mongodb)
   } else {
-    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
-        .trace('Unable to instrument mongo using the apm api due to error: %s', err)
-      // fallback to legacy instrumentation?
-      return
-    }
-    instrumentations.forEach(instrumentModule)
-  }
-
-  function instrumentModule(module) {
-    var object = module.obj
-    var instrumentations = module.instrumentations
-    for (var i = 0; i < instrumentations.length; i++) {
-      applyInstrumentation(module.name, object, instrumentations[i])
-    }
-  }
-
-  function applyInstrumentation(objectName, object, instrumentation) {
-    var methods = instrumentation.methods
-    var methodOptions = instrumentation.options
-    if (methodOptions.callback) {
-      for (var j = 0; j < methods.length; j++) {
-        var method = methods[j]
-
-        var isQuery = recordDesc[objectName].isQuery
-        var makeDescFunc = recordDesc[objectName].makeDesc
-        var proto = object.prototype
-        if (isQuery) {
-          shim.recordQuery(proto, method, makeDescFunc(shim, method))
-        } else if (isQuery === false) { // could be unset
-          shim.recordOperation(proto, method, makeDescFunc(shim, method))
-        } else {
-          shim.logger.trace('No wrapping method found for %s', objectName)
-        }
-      }
-    }
-
-    // the cursor object implements Readable stream and internally calls nextObject on
-    // each read, in which case we do not want to record each nextObject() call
-    if (/Cursor$/.test(objectName)) {
-      shim.recordOperation(object.prototype, 'pipe')
-    }
-  }
-}
-
-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)
-      }
-    }
-  })
-}
-
-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])
-      )
-    }
-  }
-
-  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})
-    }
-  }
-
-  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})
-  }
-
-  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 makeQueryDescFunc(shim, methodName) {
-  if (methodName === 'each') {
-    return function eachDescFunc() {
-      const parameters = getInstanceAttributeParameters(shim, this)
-      return {query: methodName, parameters, rowCallback: shim.LAST}
-    }
-  }
-
-  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, promise: true, 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)
-    }
-  }
-
-  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'
-    }
-
-    return {
-      host: host,
-      port_path_or_id: port,
-      database_name: database
-    }
+    instrument(shim, mongodb)
   }
 }

package/lib/instrumentation/mysql.js

@@ -8,7 +8,6 @@
 var dbutils = require('../db/utils')
 var properties = require('../util/properties')
 
-
 module.exports = function initialize(agent, mysql, moduleName, shim) {
   shim.setDatastore(shim.MYSQL)
   shim.__wrappedPoolConnection = false
@@ -50,16 +49,15 @@ module.exports = function initialize(agent, mysql, moduleName, shim) {
 }
 
 function wrapGetConnection(shim, connectable) {
-  if (
-    !connectable ||
-    !connectable.getConnection ||
-    shim.isWrapped(connectable.getConnection)
-  ) {
-    shim.logger.trace({
-      connectable: !!connectable,
-      getConnection: !!(connectable && connectable.getConnection),
-      isWrapped: !!(connectable && shim.isWrapped(connectable.getConnection))
-    }, 'Not wrapping getConnection')
+  if (!connectable || !connectable.getConnection || shim.isWrapped(connectable.getConnection)) {
+    shim.logger.trace(
+      {
+        connectable: !!connectable,
+        getConnection: !!(connectable && connectable.getConnection),
+        isWrapped: !!(connectable && shim.isWrapped(connectable.getConnection))
+      },
+      'Not wrapping getConnection'
+    )
     return false
   }
 
@@ -70,9 +68,12 @@ function wrapGetConnection(shim, connectable) {
       var cbIdx = args.length - 1
 
       if (shim.isFunction(args[cbIdx]) && !shim.isWrapped(args[cbIdx])) {
-        shim.logger.trace({
-          hasSegment: !!shim.getSegment()
-        }, 'Wrapping callback with segment')
+        shim.logger.trace(
+          {
+            hasSegment: !!shim.getSegment()
+          },
+          'Wrapping callback with segment'
+        )
         var cb = args[cbIdx]
         if (!shim.__wrappedPoolConnection) {
           cb = shim.wrap(cb, wrapGetConnectionCallback)
@@ -97,7 +98,7 @@ function wrapGetConnectionCallback(shim, cb) {
       }
     } catch (_err) {
       shim.logger.debug(
-        {error: _err},
+        { error: _err },
         'Attempt to wrap PoolConnection#query resulted in thrown error'
       )
     }
@@ -107,11 +108,14 @@ function wrapGetConnectionCallback(shim, cb) {
 
 function wrapQueriable(shim, queriable, isPoolQuery) {
   if (!queriable || !queriable.query || shim.isWrapped(queriable.query)) {
-    shim.logger.debug({
-      queriable: !!queriable,
-      query: !!(queriable && queriable.query),
-      isWrapped: !!(queriable && shim.isWrapped(queriable.query))
-    }, 'Not wrappying queriable')
+    shim.logger.debug(
+      {
+        queriable: !!queriable,
+        query: !!(queriable && queriable.query),
+        isWrapped: !!(queriable && shim.isWrapped(queriable.query))
+      },
+      'Not wrappying queriable'
+    )
     return false
   }
 
@@ -169,11 +173,14 @@ function describeQuery(shim, queryFn, fnName, args) {
   // Pull out instance attributes.
   var parameters = getInstanceParameters(shim, this, extractedArgs.query)
 
-  shim.logger.trace({
-    query: !!extractedArgs.query,
-    callback: !!extractedArgs.callback,
-    parameters: !!parameters
-  }, 'Query segment descriptor')
+  shim.logger.trace(
+    {
+      query: !!extractedArgs.query,
+      callback: !!extractedArgs.callback,
+      parameters: !!parameters
+    },
+    'Query segment descriptor'
+  )
 
   return {
     stream: true,
@@ -197,7 +204,7 @@ function describePoolQuery(shim, queryFn, fnName, args) {
 }
 
 function getInstanceParameters(shim, queryable, query) {
-  var parameters = {host: null, port_path_or_id: null, database_name: null}
+  var parameters = { host: null, port_path_or_id: null, database_name: null }
   var conf = queryable.config
   conf = (conf && conf.connectionConfig) || conf
   var databaseName = queryable.__NR_databaseName || null

package/lib/instrumentation/oracle.js

@@ -5,7 +5,7 @@
 
 'use strict'
 
-var logger = require('../logger').child({component: 'oracle'})
+var logger = require('../logger').child({ component: 'oracle' })
 var shimmer = require('../shimmer')
 var parseSql = require('../db/parse-sql')
 var ORACLE = require('../metrics/names').ORACLE
@@ -16,16 +16,14 @@ module.exports = function initialize(agent, oracle) {
 
   logger.trace('wrapping oracle.connect and oracle.connectSync')
 
-  shimmer.wrapMethod(oracle, 'Oracle', 'connect', function cb_wrapMethod(connect) {
+  shimmer.wrapMethod(oracle, 'Oracle', 'connect', function wrapMethod(connect) {
     return function wrappedConnect(connectData, cb) {
-      return connect.call(
-        this,
-        connectData,
-        tracer.bindFunction(wrapConnection)
-      )
+      return connect.call(this, connectData, tracer.bindFunction(wrapConnection))
 
       function wrapConnection(err, connection) {
-        if (!err) ensureConnectionWrapped(connection)
+        if (!err) {
+          ensureConnectionWrapped(connection)
+        }
         return cb(err, connection)
       }
     }
@@ -41,7 +39,9 @@ module.exports = function initialize(agent, oracle) {
 
   function ensureConnectionWrapped(connection) {
     // return early in case called from an async connect after wrapping
-    if (wrapped) return
+    if (wrapped) {
+      return
+    }
     logger.trace('wrapping oracle connection prototype')
     wrapped = true
 
@@ -78,11 +78,7 @@ function wrapConnectionExecute(connection, tracer) {
     var operation = ps.operation
 
     segment.name = ORACLE.STATEMENT + collection + '/Connection.execute/' + operation
-    logger.trace(
-      'capturing oracle query. collection: %s, Operation: %s',
-      collection,
-      operation
-    )
+    logger.trace('capturing oracle query. collection: %s, Operation: %s', collection, operation)
 
     segment.transaction.addRecorder(ps.recordMetrics.bind(ps, segment))
     args[2] = bind(args[2])

package/lib/instrumentation/pg.js

@@ -5,6 +5,8 @@
 
 'use strict'
 
+const semver = require('semver')
+
 function getQuery(shim, original, name, args) {
   var config = args[0]
   var statement
@@ -20,6 +22,8 @@ function getQuery(shim, original, name, args) {
 }
 
 module.exports = function initialize(agent, pgsql, moduleName, shim) {
+  const pgVersion = shim.require('./package.json').version
+
   shim.setDatastore(shim.POSTGRES)
   // allows for native wrapping to not happen if not necessary
   // when env var is true
@@ -28,6 +32,29 @@ module.exports = function initialize(agent, pgsql, moduleName, shim) {
     return instrumentPGNative(pgsql)
   }
 
+  function wrapJSClientQuery(shim, _, __, queryArgs) {
+    // As of pg v7.0.0, Client.query returns a Promise from an async call.
+    // pg supports event based Client.query when a Query object is passed in,
+    // and works similarly in pg version <7.0.0
+    if (semver.satisfies(pgVersion, '>=7.0.0') && typeof queryArgs[0] === 'string') {
+      return {
+        callback: shim.LAST,
+        query: getQuery,
+        promise: true,
+        parameters: getInstanceParameters(shim, this),
+        internal: false
+      }
+    }
+
+    return {
+      callback: shim.LAST,
+      query: getQuery,
+      stream: 'row',
+      parameters: getInstanceParameters(shim, this),
+      internal: false
+    }
+  }
+
   // wrapping for native
   function instrumentPGNative(pg) {
     shim.wrapReturn(pg, 'Client', clientFactoryWrapper)
@@ -41,7 +68,7 @@ module.exports = function initialize(agent, pgsql, moduleName, shim) {
     // constructor and pg.pools so we can check against pg.pools to only
     // instrument pg.Pool on v6 and later.
     if (!pg.pools) {
-      shim.wrapClass(pg, 'Pool', {post: poolPostConstructor, es6: true})
+      shim.wrapClass(pg, 'Pool', { post: poolPostConstructor, es6: true })
     }
   }
 
@@ -56,13 +83,7 @@ module.exports = function initialize(agent, pgsql, moduleName, shim) {
   }
 
   function clientPostConstructor(shim) {
-    shim.recordQuery(this, 'query', {
-      callback: shim.LAST,
-      query: getQuery,
-      stream: 'row',
-      parameters: getInstanceParameters(shim, this),
-      internal: false
-    })
+    shim.recordQuery(this, 'query', wrapJSClientQuery)
 
     shim.record(this, 'connect', function pgConnectNamer() {
       return {
@@ -90,19 +111,7 @@ module.exports = function initialize(agent, pgsql, moduleName, shim) {
   }
 
   // wrapping for JS
-  shim.recordQuery(
-    pgsql && pgsql.Client && pgsql.Client.prototype,
-    'query',
-    function wrapJSClientQuery(shim) {
-      return {
-        callback: shim.LAST,
-        query: getQuery,
-        stream: 'row',
-        parameters: getInstanceParameters(shim, this),
-        internal: false
-      }
-    }
-  )
+  shim.recordQuery(pgsql && pgsql.Client && pgsql.Client.prototype, 'query', wrapJSClientQuery)
 }
 
 function getInstanceParameters(shim, client) {