newrelic 7.5.2 → 8.3.0

package/lib/instrumentation/memcached.js

@@ -29,51 +29,47 @@ module.exports = function initialize(agent, memcached, moduleName, shim) {
   }
 
   shim.setDatastore(shim.MEMCACHED)
-  shim.recordOperation(
-    proto,
-    'command',
-    function commandWrapper(shim, original, name, args) {
-      // The `command` method takes two arguments: a query generator and a server
-      // address. The query generator returns a simple object describing the
-      // memcached call. The server parameter is only provided for multi-calls.
-      // When not provided, it can be derived from the key being interacted with.
-      var metacall = args[0]()
-      var server = args[1]
-      var keys = wrapKeys(metacall)
-      var parameters = Object.create(null)
-      try {
-        parameters.key = stringify(keys[0])
-      } catch (err) {
-        shim.logger.debug(err, 'Unable to stringify memcache key')
-        parameters.key = '<unknown>'
-      }
+  shim.recordOperation(proto, 'command', function commandWrapper(shim, original, name, args) {
+    // The `command` method takes two arguments: a query generator and a server
+    // address. The query generator returns a simple object describing the
+    // memcached call. The server parameter is only provided for multi-calls.
+    // When not provided, it can be derived from the key being interacted with.
+    var metacall = args[0]()
+    var server = args[1]
+    var keys = wrapKeys(metacall)
+    var parameters = Object.create(null)
+    try {
+      parameters.key = stringify(keys[0])
+    } catch (err) {
+      shim.logger.debug(err, 'Unable to stringify memcache key')
+      parameters.key = '<unknown>'
+    }
 
-      // Capture connection info for datastore instance metric.
-      var location = null
-      if (typeof server === 'string') {
-        location = server
-      } else if (this.HashRing && this.HashRing.get && metacall.key) {
-        location = this.HashRing.get(metacall.key)
-      }
-      if (location) {
-        location = location.split(':')
-        parameters.host = location[0]
-        parameters.port_path_or_id = location[1]
-      }
+    // Capture connection info for datastore instance metric.
+    var location = null
+    if (typeof server === 'string') {
+      location = server
+    } else if (this.HashRing && this.HashRing.get && metacall.key) {
+      location = this.HashRing.get(metacall.key)
+    }
+    if (location) {
+      location = location.split(':')
+      parameters.host = location[0]
+      parameters.port_path_or_id = location[1]
+    }
 
-      // rewrap the metacall for the command object
-      args[0] = function rewrapped() {
-        return metacall
-      }
+    // rewrap the metacall for the command object
+    args[0] = function rewrapped() {
+      return metacall
+    }
 
-      // finally, execute the original command
-      return {
-        name: metacall.type || 'Unknown',
-        callback: function wrapCallback(shim, fn, fnName, opSegment) {
-          shim.bindCallbackSegment(metacall, 'callback', opSegment)
-        },
-        parameters: parameters
-      }
+    // finally, execute the original command
+    return {
+      name: metacall.type || 'Unknown',
+      callback: function wrapCallback(shim, fn, fnName, opSegment) {
+        shim.bindCallbackSegment(metacall, 'callback', opSegment)
+      },
+      parameters: parameters
     }
-  )
+  })
 }

package/lib/instrumentation/mongodb/common.js

@@ -0,0 +1,218 @@
+/*
+ * 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 common = module.exports
+common.NR_ATTRS = Symbol('NR_ATTRS')
+
+/**
+ * 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', { opaque: true })
+  }
+}
+
+/**
+ * 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) {
+      // used in v3 when connection is a cluster pool
+      if (typeof connId === 'number') {
+        setHostPort(shim, evnt.address, evnt.databaseName, this.$MongoClient)
+        // used in v3 when connection is to 1 host
+      } else if (typeof connId === 'string') {
+        setHostPort(shim, connId, evnt.databaseName)
+        // v2 contains `domainSocket`, get socket connection from `host`
+      } else if (connId.domainSocket) {
+        shim.captureInstanceAttributes('localhost', connId.host, evnt.databaseName)
+        // v2 remote connection get `host` `port` from respective properties
+      } else {
+        shim.captureInstanceAttributes(connId.host, connId.port, evnt.databaseName)
+      }
+    }
+  })
+}
+
+/**
+ * Extracts the host and port from a connection string
+ * This also handles if connection string is a domain socket
+ * 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.
+ *
+ * @param {Shim} shim
+ * @param {string} connStr
+ * @param {string} db database name
+ * @param {Object} client mongo client instance
+ */
+function setHostPort(shim, connStr, db, client) {
+  const parts = connStr.split(':')
+  // in v3 when running with a cluster of socket connections
+  // the address is `undefined:undefined`. we will instead attempt
+  // to get connection details from the client symbol NR_ATTRS
+  // added in `lib/instrumentation/mongodb/v3-mongo` when a client connects
+  // with a URL string
+  if (parts.includes('undefined')) {
+    try {
+      const attrs = client[common.NR_ATTRS]
+      const socket = decodeURIComponent(attrs.split(',')[0].split('mongodb://')[1])
+      shim.captureInstanceAttributes('localhost', socket, db)
+    } catch (err) {
+      shim.logger.debug(err, 'Could not extract host/port from mongo command')
+    }
+    // connected using domain socket but the "host"(e.g: /path/to/mongo-socket-port.sock)
+  } else if (parts.length && parts[0][0] === '/') {
+    shim.captureInstanceAttributes('localhost', parts[0], db)
+  } else {
+    shim.captureInstanceAttributes(parts[0], parts[1], db)
+  }
+}
+
+/**
+ * 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.options &&
+    obj.s.db.s.client.s.options.hosts &&
+    obj.s.db.s.client.s.options.hosts.length
+  ) {
+    // hosts is an array but we will always pull the first for consistency
+    let [{ host, port, socketPath }] = obj.s.db.s.client.s.options.hosts
+
+    if (socketPath) {
+      port = socketPath
+      host = 'localhost'
+    }
+    return {
+      host,
+      port_path_or_id: port,
+      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 = null
+    let port = null
+
+    // servers is an array but we will always pull the first for consistency
+    if (conf.servers && conf.servers.length) {
+      ;[{ host, port }] = conf.servers
+    }
+
+    // host is a domain socket. set host as localhost and use the domain
+    // socket host as the port
+    if (host && host.endsWith('.sock')) {
+      port = host
+      host = 'localhost'
+    }
+
+    return {
+      host: host,
+      port_path_or_id: port,
+      database_name: database
+    }
+  }
+}

package/lib/instrumentation/mongodb/constants.js

@@ -0,0 +1,87 @@
+/*
+ * 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,110 @@
+/*
+ * 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,80 @@
+/*
+ * Copyright 2021 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const {
+  captureAttributesOnStarted,
+  instrumentCollection,
+  instrumentCursor,
+  instrumentDb,
+  NR_ATTRS
+} = 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 }
+}
+
+/**
+ * Records the `mongo.MongoClient.connect` operations. It also adds the first arg of connect(url)
+ * to a Symbol on the MongoClient to be used later to extract the host/port in cases where the topology
+ * is a cluster of domain sockets
+ *
+ * @param {Shim} shim
+ * @param {Object} mongodb resolved package
+ */
+function instrumentClient(shim, mongodb) {
+  shim.recordOperation(mongodb.MongoClient, 'connect', function wrappedConnect(shim, _, __, args) {
+    // Add the connection url to the MongoClient to retrieve later in the `lib/instrumentation/mongo/common`
+    // captureAttributesOnStarted listener
+    this[NR_ATTRS] = args[0]
+    return { callback: shim.LAST }
+  })
+}
+
+/**
+ * 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)
+  instrumentClient(shim, mongodb)
+  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,90 @@
+/*
+ * 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 1st host
+    // socketPath property
+    // which looks like mongodb:///tmp/mongodb-27017.sock"
+    if (['undefined'].includes(host, port)) {
+      host = 'localhost'
+      const hosts = this.s.options.hosts
+      if (hosts && hosts.length && hosts[0].socketPath) {
+        port = hosts[0].socketPath
+      }
+    } 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)
+}