newrelic 8.0.0 → 8.1.0

package/lib/instrumentation/mongodb/constants.js

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+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 = {
+  COLLECTION_OPS,
+  CURSOR_OPS,
+  DB_OPS,
+  GRID_OPS
+}

package/lib/instrumentation/mongodb/v2-mongo.js

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2021 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const {
+  captureAttributesOnStarted,
+  makeQueryDescFunc
+} = require('./common')
+
+/**
+ * parser used to grab the collection and operation
+ * from a running query
+ *
+ * @param {Object} operation
+ */
+function queryParser(operation) {
+  let collection = this.collectionName || 'unknown'
+  if (this.ns) {
+    collection = this.ns.split(/\./)[1] || collection
+  }
+
+  return {operation, collection}
+}
+/**
+ * Registers relevant instrumentation for mongo <= 3.0.6
+ * and >= 2. This relies on the built-in "APM" hook points
+ * to instrument their provided objects as well as sets
+ * up a listener for when commands start to properly
+ * add necessary attributes to segments
+ *
+ * @param {Shim} shim
+ * @param {Object} mongodb resolved package
+ */
+module.exports = function instrument(shim, mongodb) {
+  shim.setParser(queryParser)
+
+  const recordDesc = {
+    'Gridstore': {isQuery: false, makeDescFunc: function makeGridDesc(opName) {
+      return {name:'GridFS-' + opName, callback: shim.LAST}
+    }},
+    'OrderedBulkOperation': {isQuery: true, makeDescFunc: makeQueryDescFunc},
+    'UnorderedBulkOperation': {isQuery: true, makeDescFunc: makeQueryDescFunc},
+    'CommandCursor': {isQuery: true, makeDescFunc: makeQueryDescFunc},
+    'AggregationCursor': {isQuery: true, makeDescFunc: makeQueryDescFunc},
+    'Cursor': {isQuery: true, makeDescFunc: makeQueryDescFunc},
+    'Collection': {isQuery: true, makeDescFunc: makeQueryDescFunc},
+    'Db': {isQuery: false, makeDescFunc: function makeDbDesc() {
+      return {callback: shim.LAST}
+    }}
+  }
+
+  // instrument using the apm api
+  const instrumenter = mongodb.instrument(Object.create(null), instrumentModules)
+  captureAttributesOnStarted(shim, instrumenter)
+
+  /**
+   * Every module groups instrumentations by their
+   * promise, callback, return permutations
+   * Iterate over permutations and properly
+   * wrap depending on the `recordDesc` above
+   * See: https://github.com/mongodb/node-mongodb-native/blob/v3.0.5/lib/collection.js#L384
+   */
+  function instrumentModules(_, modules) {
+    modules.forEach((module) => {
+      const { obj, instrumentations, name } = module
+      instrumentations.forEach((meta) => {
+        applyInstrumentation(name, obj, meta)
+      })
+    })
+  }
+
+  /**
+   * Iterate over methods on object and lookup in `recordDesc` to decide
+   * if it needs to be wrapped as an operation or query
+   *
+   * @param {string} objectName name of class getting instrumented
+   * @param {Object} object reference to the class getting instrumented
+   * @param {Define} meta describes the methods and if they are callbacks
+   * promises, and return values
+   */
+  function applyInstrumentation(objectName, object, meta) {
+    const { methods, options } = meta
+    if (options.callback) {
+      methods.forEach((method) => {
+        const { isQuery, makeDescFunc } = recordDesc[objectName]
+        const 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')
+    }
+  }
+}
+
+

package/lib/instrumentation/mongodb/v3-mongo.js

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2021 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const {
+  captureAttributesOnStarted,
+  instrumentCollection,
+  instrumentCursor,
+  instrumentDb
+} = require('./common')
+
+/**
+ * parser used to grab the collection and operation
+ * on every mongo operation
+ *
+ * @param {Object} operation
+ */
+function queryParser(operation) {
+  let collection = this.collectionName || 'unknown'
+  // in v3.3.0 aggregate commands added the collection
+  // to target
+  if (this.operation && this.operation.target) {
+    collection = this.operation.target
+  } else if (this.ns) {
+    collection = this.ns.split(/\./)[1] || collection
+  }
+  return {operation, collection}
+}
+
+/**
+ * Registers relevant instrumentation for mongo >= 3.0.6
+ * In 3.0.6 they refactored their "APM" module which removed
+ * a lot of niceities around instrumentation classes.
+ * see: https://github.com/mongodb/node-mongodb-native/pull/1675/files
+ * This reverts back to instrumenting pre-canned methods on classes
+ * as well as sets up a listener for when commands start to properly
+ * add necessary attributes to segments
+ *
+ * @param {Shim} shim
+ * @param {Object} mongodb resolved package
+ */
+module.exports = function instrument(shim, mongodb) {
+  shim.setParser(queryParser)
+  const instrumenter = mongodb.instrument(Object.create(null), () => {})
+  captureAttributesOnStarted(shim, instrumenter)
+  instrumentCursor(shim, mongodb.Cursor)
+  instrumentCursor(shim, shim.require('./lib/aggregation_cursor'))
+  instrumentCursor(shim, shim.require('./lib/command_cursor'))
+  instrumentCollection(shim, mongodb.Collection)
+  instrumentDb(shim, mongodb.Db)
+
+  // calling instrument sets up listeners for a few events
+  // we should restore this on unload to avoid leaking
+  // event emitters
+  shim.agent.once('unload', function uninstrumentMongo() {
+    instrumenter.uninstrument()
+  })
+}

package/lib/instrumentation/mongodb/v4-mongo.js

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2021 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const {
+  instrumentCollection,
+  instrumentCursor,
+  instrumentDb
+} = require('./common')
+
+/**
+ * parser used to grab the collection and operation
+ * from a running query
+ *
+ * @param {Object} operation
+ */
+function queryParser(operation) {
+  let collection = this.collectionName || 'unknown'
+
+  // cursor methods have collection on namespace.collection
+  if (this.namespace && this.namespace.collection) {
+    collection = this.namespace.collection
+  }
+
+  return {operation, collection}
+}
+
+/**
+ * `commandStarted` handler used to
+ * update host, port and database_name
+ * on segment attributes
+ *
+ * @param {Shim} shim
+ * @param {CommandStartedEvent} evnt
+ */
+function cmdStartedHandler(shim, evnt) {
+  if (evnt.connectionId) {
+    let [host,port] = evnt.address.split(':')
+
+    // connection via socket get port from client.url
+    // which looks like "mongodb://%2Ftmp%2Fmongodb-27017.sock"
+    if (['undefined'].includes(host, port)) {
+      host = 'localhost'
+      // socket path is uri encoded
+      // decode it to properly name attrs
+      const socketPath = this.s.url.split(':')
+      if (socketPath.length && socketPath[1].startsWith('//')) {
+        port = decodeURIComponent(socketPath[1].substr(2))
+      }
+    } else if (host === '127.0.0.1') {
+      host = 'localhost'
+    }
+
+    shim.captureInstanceAttributes(host, port, evnt.databaseName)
+  }
+}
+
+/**
+ * function executed when client.connect is called
+ * enable APM(monitorCommands) and add the
+ * `commandStarted` listener
+ *
+ * @param {Shim} shim
+ */
+function wrapConnect(shim) {
+  this.monitorCommands = true
+  this.on('commandStarted', cmdStartedHandler.bind(this, shim))
+  return { callback: shim.LAST }
+}
+
+/**
+ * Wraps connect to record as operation but also to add a listener
+ * for `commandStarted`.  This will be emitted before every command starts
+ * so we can properly update the segment attributes with a more accurate
+ * host/port/database name
+ *
+ * @param {Shim} shim
+ * @param {MongoClient} MongoClient reference
+ */
+function instrumentMongoClient(shim, MongoClient) {
+  shim.recordOperation(MongoClient.prototype, 'connect', wrapConnect)
+}
+
+
+module.exports = function instrument(shim, mongodb) {
+  shim.setParser(queryParser)
+  instrumentMongoClient(shim, mongodb.MongoClient)
+  instrumentCursor(shim, mongodb.AbstractCursor)
+  instrumentCursor(shim, mongodb.FindCursor)
+  instrumentCursor(shim, mongodb.AggregationCursor)
+  instrumentCollection(shim, mongodb.Collection)
+  instrumentDb(shim, mongodb.Db)
+}

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,29 @@ 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
 
   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}
+    instrument(shim, mongodb)
   }
 }
 
-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
-    }
-  }
-}