newrelic 7.5.0 → 8.1.0

package/lib/instrumentation/mongodb/common.js

@@ -0,0 +1,186 @@
+/*
+ * Copyright 2021 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const {
+  CURSOR_OPS,
+  COLLECTION_OPS,
+  DB_OPS
+} = require('./constants')
+const { URL } = require('url')
+
+const common = module.exports
+
+/**
+ * Instruments all methods from constants.CURSOR_OPS on a given
+ * cursor class
+ *
+ * @param {Shim} shim
+ * @param {Cursor} Cursor
+ */
+common.instrumentCursor = function instrumentCursor(shim, Cursor) {
+  if (Cursor && Cursor.prototype) {
+    const proto = Cursor.prototype
+    for (let i = 0; i < CURSOR_OPS.length; i++) {
+      shim.recordQuery(proto, CURSOR_OPS[i], common.makeQueryDescFunc(shim, CURSOR_OPS[i]))
+    }
+
+    shim.recordQuery(proto, 'each', common.makeQueryDescFunc(shim, 'each'))
+    shim.recordOperation(proto, 'pipe')
+  }
+}
+
+/**
+ * Instruments all methods from constants.COLLECTION_OPS on
+ * the Collection class
+ *
+ * @param {Shim} shim
+ * @param {Collection} Collection
+ */
+common.instrumentCollection = function instrumentCollection(shim, Collection) {
+  if (Collection && Collection.prototype) {
+    const proto = Collection.prototype
+    for (let i = 0; i < COLLECTION_OPS.length; i++) {
+      shim.recordQuery(
+        proto,
+        COLLECTION_OPS[i],
+        common.makeQueryDescFunc(shim, COLLECTION_OPS[i])
+      )
+    }
+  }
+}
+
+/**
+ * Instruments all methods from constants.DB_OPS on
+ * the Db class.
+ *
+ * @param {Object} params
+ * @param {Shim} params.shim
+ * @param {Db} params.Db
+ */
+common.instrumentDb = function instrumentDb(shim, Db) {
+  if (Db && Db.prototype) {
+    const proto = Db.prototype
+    shim.recordOperation(proto, DB_OPS, {callback: shim.LAST, opaque: true })
+    // link to client.connect(removed in v4.0)
+    shim.recordOperation(Db, 'connect', {callback: shim.LAST})
+  }
+}
+
+/**
+ * Sets up the desc for all instrumented query methods
+ * @param {Shim} shim
+ * @param {string} methodName
+ */
+common.makeQueryDescFunc = function makeQueryDescFunc(shim, methodName) {
+  if (methodName === 'each') {
+    return function eachDescFunc() {
+      const parameters = getInstanceAttributeParameters(shim, this)
+      return {query: methodName, parameters, rowCallback: shim.LAST, opaque: true }
+    }
+  }
+
+  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, opaque: true}
+  }
+}
+
+/**
+ * Sets up a listener for `started` on instrumenter(mongo APM). This applies to
+ * mongo <4. The listener adds the following attributes to the active segment:
+ * host, port_path_or_id, and database_name
+ *
+ * @param {Shim} shim
+ * @param {Instrumentation} instrumenter instance of mongo APM class
+ */
+common.captureAttributesOnStarted = 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)
+      }
+    }
+  })
+}
+
+/**
+ * Get the database_name, host, port_path_or_id
+ * for the query segment. v4 refactored where the toplogy is stored.
+ * You can now get the details via the client obj that's deeply nested
+ * See: https://github.com/mongodb/node-mongodb-native/pull/2594/files#diff-1d214e57ddda9095d296e5700ebce701333bfefcf417e234c584d14091b2f50dR168
+ */
+function getInstanceAttributeParameters(shim, obj) {
+  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)
+    }
+  } else if (obj.s && obj.s.db && obj.s.db.s && obj.s.db.s.client &&
+    obj.s.db.s.client.s && obj.s.db.s.client.s.url) {
+    let { hostname: host, port: port_path_or_id } = new URL(obj.s.db.s.client.s.url)
+    if (host.endsWith('.sock')) {
+      // socket path is uri encoded
+      // decode it to properly name attrs
+      port_path_or_id = decodeURIComponent(host)
+      host = 'localhost'
+    }
+    return {
+      host,
+      port_path_or_id,
+      database_name: obj.s.db.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
+    }
+  }
+}

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)
+}