newrelic 9.7.0 → 9.7.2

package/lib/instrumentation/mongodb/common.js

@@ -5,8 +5,6 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 18] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-
 const { CURSOR_OPS, COLLECTION_OPS, DB_OPS } = require('./constants')
 const common = module.exports
 common.NR_ATTRS = Symbol('NR_ATTRS')
@@ -15,8 +13,8 @@ common.NR_ATTRS = Symbol('NR_ATTRS')
  * Instruments all methods from constants.CURSOR_OPS on a given
  * cursor class
  *
- * @param {Shim} shim
- * @param {Cursor} Cursor
+ * @param {Shim} shim instance of shim
+ * @param {Cursor} Cursor mongodb Cursor prototype
  */
 common.instrumentCursor = function instrumentCursor(shim, Cursor) {
   if (Cursor && Cursor.prototype) {
@@ -34,8 +32,8 @@ common.instrumentCursor = function instrumentCursor(shim, Cursor) {
  * Instruments all methods from constants.COLLECTION_OPS on
  * the Collection class
  *
- * @param {Shim} shim
- * @param {Collection} Collection
+ * @param {Shim} shim instance of shim
+ * @param {Collection} Collection mongodb Collection prototype
  */
 common.instrumentCollection = function instrumentCollection(shim, Collection) {
   if (Collection && Collection.prototype) {
@@ -50,15 +48,12 @@ common.instrumentCollection = function instrumentCollection(shim, Collection) {
  * Instruments the execute method on
  * the BulkOperationBase class
  *
- * @param {Shim} shim
- * @param {BulkOperationModule} bulk operation module, typically from mongodb/lib/bulk/common
- * @param BulkOperationModule
+ * @param {Shim} shim instance of shim
+ * @param {BulkOperationModule} BulkOperationModule operation module, typically from mongodb/lib/bulk/common
  */
 common.instrumentBulkOperation = function instrumentBulkOperation(shim, BulkOperationModule) {
-  const BulkOperationBase = BulkOperationModule && BulkOperationModule.BulkOperationBase
-
-  if (BulkOperationBase && BulkOperationBase.prototype) {
-    const proto = BulkOperationBase.prototype
+  if (BulkOperationModule?.BulkOperationBase?.prototype) {
+    const proto = BulkOperationModule.BulkOperationBase.prototype
     shim.recordBatchQuery(proto, 'execute', common.makeBulkDescFunc(shim, 'execute'))
   }
 }
@@ -67,11 +62,8 @@ common.instrumentBulkOperation = function instrumentBulkOperation(shim, BulkOper
  * Instruments all methods from constants.DB_OPS on
  * the Db class.
  *
- * @param {object} params
- * @param {Shim} params.shim
- * @param {Db} params.Db
- * @param shim
- * @param Db
+ * @param {Shim} shim instance of shim
+ * @param {Db} Db mongodb Db prototype
  */
 common.instrumentDb = function instrumentDb(shim, Db) {
   if (Db && Db.prototype) {
@@ -85,8 +77,9 @@ common.instrumentDb = function instrumentDb(shim, Db) {
 /**
  * Sets up the desc for all instrumented query methods
  *
- * @param {Shim} shim
- * @param {string} methodName
+ * @param {Shim} shim instance of shim
+ * @param {string} methodName name of method getting executed
+ * @returns {object} query spec
  */
 common.makeQueryDescFunc = function makeQueryDescFunc(shim, methodName) {
   if (methodName === 'each') {
@@ -107,8 +100,8 @@ common.makeQueryDescFunc = function makeQueryDescFunc(shim, methodName) {
 /**
  * Sets up the desc for all instrumented bulk operations
  *
- * @param {Shim} shim
- * @param {string} methodName
+ * @param {Shim} shim instance of shim
+ * @returns {object} query spec
  */
 common.makeBulkDescFunc = function makeBulkDescFunc(shim) {
   return function bulkDescFunc() {
@@ -128,8 +121,8 @@ common.makeBulkDescFunc = function makeBulkDescFunc(shim) {
  * 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
+ * @param {Shim} shim instance of shim
+ * @param {object} instrumenter instance of mongo APM class
  * @param {object} [options={}] provide command names to skip updating host/port as they are unrelated to the active query.  This is only in v3 because after every command is runs `endSessions` which runs on the admin database
  */
 common.captureAttributesOnStarted = function captureAttributesOnStarted(
@@ -171,8 +164,8 @@ common.captureAttributesOnStarted = function captureAttributesOnStarted(
  * 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 {Shim} shim instance of shim
+ * @param {string} connStr mongo connection string
  * @param {string} db database name
  * @param {object} client mongo client instance
  */
@@ -205,75 +198,84 @@ function setHostPort(shim, connStr, db, client) {
  * 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
  *
- * @param shim
- * @param obj
+ * @param {Shim} shim instance of shim
+ * @param {object} mongo instance of mongo
+ * @returns {object} db params
  */
-function getInstanceAttributeParameters(shim, obj) {
-  if (obj.s && obj.s.topology) {
-    shim.logger.trace('Adding datastore instance attributes from obj.s.db + obj.s.topology')
-    const databaseName =
-      (obj.s.db && obj.s.db.databaseName) || (obj.s.namespace && obj.s.namespace.db) || null
-    const topology = obj.s.topology
-    if (topology) {
-      return doCapture(topology, 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
-    const hosts = obj.s.db.s.client.s.options.hosts
-    let host = hosts[0].host
-    let port = hosts[0].port
-    const socketPath = hosts[0].socketPath
+function getInstanceAttributeParameters(shim, mongo) {
+  let params = {
+    host: null,
+    port_path_or_id: null,
+    database_name: null
+  }
 
-    if (socketPath) {
-      port = socketPath
-      host = 'localhost'
-    }
-    return {
-      host,
-      port_path_or_id: port,
-      database_name: obj.s.db.databaseName
-    }
+  if (mongo?.s?.topology) {
+    shim.logger.trace('Adding datastore instance attributes from mongo.s.db + mongo.s.topology')
+    const databaseName = mongo?.s?.db?.databaseName || mongo?.s?.namespace?.db || null
+    const topology = mongo.s.topology
+    params = getParametersFromTopology(topology, databaseName)
+  } else if (mongo?.s?.db?.s?.client?.s?.options?.hosts?.length) {
+    const databaseName = mongo?.s?.db?.databaseName || null
+    const hosts = mongo.s.db.s.client.s.options.hosts
+    params = getParametersFromHosts(hosts, databaseName)
+  } else {
+    shim.logger.trace('Could not find datastore instance attributes.')
   }
 
-  shim.logger.trace('Could not find datastore instance attributes.')
+  return params
+}
+
+/**
+ * Extracts the database parameters from the first host.
+ *
+ * @param {Array} hosts mongodb connected hosts
+ * @param {string} database name of database
+ * @returns {object} db params
+ */
+function getParametersFromHosts(hosts, database) {
+  let [{ host, port }] = hosts
+  const [{ socketPath }] = hosts
+
+  if (socketPath) {
+    port = socketPath
+    host = 'localhost'
+  }
   return {
-    host: null,
-    port_path_or_id: null,
-    database_name: null
+    host,
+    port_path_or_id: port,
+    database_name: database
   }
+}
 
-  function doCapture(conf, database) {
-    // in older versions of 3.x the host/port
-    // lived directly on the topology
-    let host = conf.host
-    let port = conf.port
+/**
+ * Extracts the database parameters from the relevant
+ * topology configuration
+ *
+ * @param {object} conf topology configuration
+ * @param {string} database name of database
+ * @returns {object} db params
+ */
+function getParametersFromTopology(conf, database) {
+  // in older versions of 3.x the host/port
+  // lived directly on the topology
+  let { host, port } = conf
 
-    // servers is an array but we will always pull the first for consistency
-    if (conf.s && conf.s.options && conf.s.options.servers && conf.s.options.servers.length) {
-      ;[{ host, port }] = conf.s.options.servers
-    }
+  // servers is an array but we will always pull the first for consistency
+  if (conf?.s?.options?.servers?.length) {
+    ;[{ host, port }] = conf.s.options.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'
-    }
+  // 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
-    }
+  return {
+    host: host,
+    port_path_or_id: port,
+    database_name: database
   }
 }
 

package/lib/instrumentation/redis.js

@@ -5,118 +5,140 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 52] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-
 const hasOwnProperty = require('../util/properties').hasOwn
 const stringify = require('json-stringify-safe')
 
-module.exports = function initialize(agent, redis, moduleName, shim) {
-  const proto = redis && redis.RedisClient && redis.RedisClient.prototype
+module.exports = function initialize(_agent, redis, _moduleName, shim) {
+  const proto = redis?.RedisClient?.prototype
   if (!proto) {
     return false
   }
 
   shim.setDatastore(shim.REDIS)
-  if (proto.internal_send_command) {
-    shim.recordOperation(
-      proto,
-      'internal_send_command',
-      function wrapInternalSendCommand(shim, _, __, args) {
-        const commandObject = args[0]
-        const keys = commandObject.args
-        const parameters = getInstanceParameters(this)
-
-        if (keys && keys.length > 0) {
-          try {
-            parameters.key = stringify(keys[0])
-          } catch (err) {
-            shim.logger.debug(err, 'Failed to stringify internal send command redis key')
-            parameters.key = '<unknown>'
-          }
-        }
 
-        return {
-          name: commandObject.command || 'other',
-          parameters: parameters,
-          callback: function bindCallback(shim, _f, _n, segment) {
-            if (shim.isFunction(commandObject.callback)) {
-              shim.bindCallbackSegment(commandObject, 'callback', segment)
-            } else {
-              const self = this
-              commandObject.callback = shim.bindSegment(
-                function NRCallback(err) {
-                  if (err && self.emit instanceof Function) {
-                    self.emit('error', err)
-                  }
-                },
-                segment,
-                true
-              )
-            }
-          }
-        }
-      }
-    )
+  if (proto.internal_send_command) {
+    registerInternalSendCommand(shim, proto)
   } else {
-    // For redis versions <2.6.1
-    shim.recordOperation(proto, 'send_command', function wrapSendCommand(shim, _, __, args) {
-      const keys = args[1]
-      const parameters = getInstanceParameters(this)
+    registerSendCommand(shim, proto)
+  }
+}
 
-      if (keys && !shim.isFunction(keys)) {
-        try {
-          parameters.key = stringify(keys[0])
-        } catch (err) {
-          shim.logger.debug(err, 'Failed to stringify redis key for send command')
-          parameters.key = '<unknown>'
-        }
-      }
+/**
+ * Instrumentation used in versions of redis > 2.6.1 < 4 to record all redis commands
+ *
+ * @param {Shim} shim instance of shim
+ * @param {object} proto RedisClient prototype
+ */
+function registerInternalSendCommand(shim, proto) {
+  shim.recordOperation(
+    proto,
+    'internal_send_command',
+    function wrapInternalSendCommand(shim, _, __, args) {
+      const commandObject = args[0]
+      const keys = commandObject.args
+      const parameters = getInstanceParameters(shim, this)
+
+      parameters.key = stringifyKeys(shim, keys)
 
       return {
-        name: args[0] || 'other',
-        parameters: parameters,
+        name: commandObject.command || 'other',
+        parameters,
         callback: function bindCallback(shim, _f, _n, segment) {
-          const last = args[args.length - 1]
-          if (shim.isFunction(last)) {
-            shim.bindCallbackSegment(args, shim.LAST, segment)
-          } else if (shim.isArray(last) && shim.isFunction(last[last.length - 1])) {
-            shim.bindCallbackSegment(last, shim.LAST, segment)
+          if (shim.isFunction(commandObject.callback)) {
+            shim.bindCallbackSegment(commandObject, 'callback', segment)
+          } else {
+            const self = this
+            commandObject.callback = shim.bindSegment(
+              function NRCallback(err) {
+                if (err && self.emit instanceof Function) {
+                  self.emit('error', err)
+                }
+              },
+              segment,
+              true
+            )
           }
         }
       }
-    })
-  }
-
-  function getInstanceParameters(client) {
-    if (hasOwnProperty(client, 'port') && hasOwnProperty(client, 'host')) {
-      // for redis <=0.11
-      return doCapture(client)
-    } else if (hasOwnProperty(client, 'connection_options')) {
-      // for redis 2.4.0 - 2.6.2
-      return doCapture(client.connection_options)
-    } else if (hasOwnProperty(client, 'connectionOption')) {
-      // for redis 0.12 - 2.2.5
-      return doCapture(client.connectionOption)
-    } else if (hasOwnProperty(client, 'options')) {
-      // for redis 2.3.0 - 2.3.1
-      return doCapture(client.options)
     }
+  )
+}
 
-    shim.logger.debug('Could not access instance attributes on connection.')
-    return {
-      host: null,
-      port_path_or_id: null,
-      database_name: null
-    }
+/**
+ * Instrumentation used in versions of redis < 2.6.1 to record all redis commands
+ *
+ * @param {Shim} shim instance of shim
+ * @param {object} proto RedisClient prototype
+ */
+function registerSendCommand(shim, proto) {
+  shim.recordOperation(proto, 'send_command', function wrapSendCommand(shim, _, __, args) {
+    const [command, keys] = args
+    const parameters = getInstanceParameters(shim, this)
 
-    function doCapture(opts) {
-      const db = (hasOwnProperty(client, 'selected_db') ? client.selected_db : opts.db) || 0
+    parameters.key = stringifyKeys(shim, keys)
 
-      return {
-        host: opts.host || 'localhost',
-        port_path_or_id: opts.path || opts.port || '6379',
-        database_name: db
+    return {
+      name: command || 'other',
+      parameters,
+      callback: function bindCallback(shim, _f, _n, segment) {
+        const last = args[args.length - 1]
+        if (shim.isFunction(last)) {
+          shim.bindCallbackSegment(args, shim.LAST, segment)
+        } else if (shim.isArray(last) && shim.isFunction(last[last.length - 1])) {
+          shim.bindCallbackSegment(last, shim.LAST, segment)
+        }
       }
     }
+  })
+}
+
+function stringifyKeys(shim, keys) {
+  let key = null
+  if (keys && keys.length && !shim.isFunction(keys)) {
+    try {
+      key = stringify(keys[0])
+    } catch (err) {
+      shim.logger.debug(err, 'Failed to stringify redis key for send command')
+      key = '<unknown>'
+    }
+  }
+
+  return key
+}
+
+/**
+ * Captures the necessary datastore parameters based on the specific version of redis
+ *
+ * @param {Shim} shim instance of shim
+ * @param {object} client instance of redis client
+ * @returns {object} datastore parameters
+ */
+function getInstanceParameters(shim, client) {
+  if (hasOwnProperty(client, 'connection_options')) {
+    // for redis 2.4.0 - 2.6.2
+    return doCapture(client, client.connection_options)
+  } else if (hasOwnProperty(client, 'connectionOption')) {
+    // for redis 0.12 - 2.2.5
+    return doCapture(client, client.connectionOption)
+  } else if (hasOwnProperty(client, 'options')) {
+    // for redis 2.3.0 - 2.3.1
+    return doCapture(client, client.options)
+  }
+  shim.logger.debug('Could not access instance attributes on connection.')
+  return doCapture()
+}
+
+/**
+ * Extracts the relevant datastore parameters
+ *
+ * @param {object} client instance of redis client
+ * @param {object} opts options for the client instance
+ * @returns {object} datastore parameters
+ */
+function doCapture(client = {}, opts = {}) {
+  return {
+    host: opts.host || 'localhost',
+    port_path_or_id: opts.path || opts.port || '6379',
+    database_name: client.selected_db || opts.db || 0
   }
 }