newrelic 9.7.0 → 9.7.2

package/lib/instrumentation/@node-redis/client.js

@@ -3,61 +3,70 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-/* eslint sonarjs/cognitive-complexity: ["error", 20] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-
 'use strict'
 const CLIENT_COMMANDS = ['select', 'quit', 'SELECT', 'QUIT']
+const opts = Symbol('clientOptions')
 
-module.exports = function initialize(agent, redis, moduleName, shim) {
+module.exports = function initialize(_agent, redis, _moduleName, shim) {
   shim.setDatastore(shim.REDIS)
   const COMMANDS = Object.keys(shim.require('dist/lib/client/commands.js').default)
   const CMDS_TO_INSTRUMENT = [...COMMANDS, ...CLIENT_COMMANDS]
   shim.wrap(redis, 'createClient', function wrapCreateClient(shim, original) {
     return function wrappedCreateClient() {
       const client = original.apply(this, arguments)
-      const clientOptions = getRedisParams(client.options)
-      CMDS_TO_INSTRUMENT.forEach((cmd) => {
-        shim.recordOperation(client, cmd, function wrapCommand(shim, fn, fnName, args) {
-          const [key, value] = args
-          const parameters = Object.assign({}, clientOptions)
-          // If selecting a database, subsequent commands
-          // will be using said database, update the clientOptions
-          // but not the current parameters(feature parity with v3)
-          if (cmd.toLowerCase() === 'select') {
-            clientOptions.database_name = key
-          }
-          if (agent.config.attributes.enabled) {
-            if (key) {
-              parameters.key = JSON.stringify(key)
-            }
-            if (value) {
-              parameters.value = JSON.stringify(value)
-            }
-          }
-
-          return {
-            name: (cmd && cmd.toLowerCase()) || 'other',
-            parameters,
-            promise: true
-          }
-        })
-      })
-
+      client[opts] = getRedisParams(client.options)
+      CMDS_TO_INSTRUMENT.forEach(instrumentClientCommand.bind(null, shim, client))
       return client
     }
   })
+}
+
+/**
+ * Instruments a given command on the client by calling `shim.recordOperation`
+ *
+ * @param {Shim} shim shim instance
+ * @param {object} client redis client instance
+ * @param {string} cmd command to instrument
+ */
+function instrumentClientCommand(shim, client, cmd) {
+  const { agent } = shim
+
+  shim.recordOperation(client, cmd, function wrapCommand(_shim, _fn, _fnName, args) {
+    const [key, value] = args
+    const parameters = Object.assign({}, client[opts])
+    // If selecting a database, subsequent commands
+    // will be using said database, update the clientOptions
+    // but not the current parameters(feature parity with v3)
+    if (cmd.toLowerCase() === 'select') {
+      client[opts].database_name = key
+    }
+    if (agent.config.attributes.enabled) {
+      if (key) {
+        parameters.key = JSON.stringify(key)
+      }
+      if (value) {
+        parameters.value = JSON.stringify(value)
+      }
+    }
 
-  /**
-   * Extracts the datastore parameters from the client options
-   *
-   * @param {object} opts client.options
-   * @returns {object} params
-   */
-  function getRedisParams(opts) {
     return {
-      host: (opts.socket && opts.socket.host) || 'localhost',
-      port_path_or_id: (opts.socket && (opts.socket.path || opts.socket.port)) || '6379',
-      database_name: opts.database || 0
+      name: (cmd && cmd.toLowerCase()) || 'other',
+      parameters,
+      promise: true
     }
+  })
+}
+
+/**
+ * Extracts the datastore parameters from the client options
+ *
+ * @param {object} clientOpts client.options
+ * @returns {object} params
+ */
+function getRedisParams(clientOpts) {
+  return {
+    host: clientOpts?.socket?.host || 'localhost',
+    port_path_or_id: clientOpts?.socket?.path || clientOpts?.socket?.port || '6379',
+    database_name: clientOpts.database || 0
   }
 }

package/lib/instrumentation/amqplib.js

@@ -5,17 +5,8 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 16] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252*/
-
 const url = require('url')
 
-// TODO: Make this an external module.
-// var newrelic = require('newrelic')
-// newrelic.instrumentMessages('amqplib', instrumentChannelAPI)
-// newrelic.instrumentMessages('amqplib/channel_api', instrumentChannelAPI)
-// newrelic.instrumentMessages('amqplib/channel_api.js', instrumentChannelAPI)
-// newrelic.instrumentMessages('amqplib/callback_api', instrumentCallbackAPI)
-// newrelic.instrumentMessages('amqplib/callback_api.js', instrumentCallbackAPI)
 module.exports.selfRegister = function selfRegister(shimmer) {
   shimmer.registerInstrumentation({
     moduleName: 'amqplib',
@@ -67,20 +58,47 @@ const CHANNEL_METHODS = [
 
 const TEMP_RE = /^amq\./
 
+/**
+ * Register all the necessary instrumentation when using
+ * promise based methods
+ *
+ * @param {Shim} shim instance of shim
+ * @param {object} amqp amqplib object
+ */
 function instrumentChannelAPI(shim, amqp) {
   instrumentAMQP(shim, amqp, true)
-  wrapPromiseChannel(shim)
+  // 👀 take note the model is channel not callback 👀
+  const model = shim.require('./lib/channel_model')
+  wrapModel(shim, model, true)
 }
 
+/**
+ * Register all the necessary instrumentation when using
+ * callback based methods
+ *
+ * @param {Shim} shim instance of shim
+ * @param {object} amqp amqplib object
+ */
 function instrumentCallbackAPI(shim, amqp) {
   instrumentAMQP(shim, amqp, false)
-  wrapCallbackChannel(shim)
+  // 👀 take note the model is callback not channel 👀
+  const model = shim.require('./lib/callback_model')
+  wrapModel(shim, model, false)
 }
 
+/**
+ *
+ * Instruments the connect method and channel prototype of amqplib
+ *
+ * @param {Shim} shim instance of shim
+ * @param {object} amqp amqplib object
+ * @param {boolean} promiseMode is this promise based?
+ * @returns {void}
+ */
 function instrumentAMQP(shim, amqp, promiseMode) {
   if (!amqp || !amqp.connect) {
     shim.logger.debug("This module is not the amqplib we're looking for.")
-    return false
+    return
   }
 
   if (shim.isWrapped(amqp.connect)) {
@@ -89,8 +107,33 @@ function instrumentAMQP(shim, amqp, promiseMode) {
   }
   shim.setLibrary(shim.RABBITMQ)
 
+  wrapConnect(shim, amqp, promiseMode)
+  wrapChannel(shim)
+}
+
+/**
+ * Helper to set the appropriate value of the callback property
+ * in the spec. If it's a promise set to null otherwise set it to `shim.LAST`
+ *
+ * @param {Shim} shim instance of shim
+ * @param {boolean} promiseMode is this promise based?
+ * @returns {string|null} appropriate value
+ */
+function setCallback(shim, promiseMode) {
+  return promiseMode ? null : shim.LAST
+}
+
+/**
+ *
+ * Instruments the connect method
+ *
+ * @param {Shim} shim instance of shim
+ * @param {object} amqp amqplib object
+ * @param {boolean} promiseMode is this promise based?
+ */
+function wrapConnect(shim, amqp, promiseMode) {
   shim.record(amqp, 'connect', function recordConnect(shim, connect, name, args) {
-    let connArgs = args[0]
+    let [connArgs] = args
     let params = null
 
     if (shim.isString(connArgs)) {
@@ -103,21 +146,24 @@ function instrumentAMQP(shim, amqp, promiseMode) {
 
     return {
       name: 'amqplib.connect',
-      callback: promiseMode ? null : shim.LAST,
+      callback: setCallback(shim, promiseMode),
       promise: promiseMode,
       parameters: params,
-
       stream: null,
       recorder: null
     }
   })
-
-  wrapChannel(shim)
 }
 
+/**
+ *
+ * Instruments the sendOrEnqueue and sendMessage methods of the ampqlib channel.
+ *
+ * @param {Shim} shim instance of shim
+ */
 function wrapChannel(shim) {
   const libChannel = shim.require('./lib/channel')
-  if (!libChannel || !libChannel.Channel || !libChannel.Channel.prototype) {
+  if (!libChannel?.Channel?.prototype) {
     shim.logger.debug('Could not get Channel class to instrument.')
     return
   }
@@ -149,29 +195,7 @@ function wrapChannel(shim) {
     }
   })
 
-  // Example fields:
-  // { exchange: 'test-exchange-topic',
-  //   routingKey: 'routing.key',
-  //   mandatory: false,
-  //   immediate: false,
-  //   ticket: undefined,
-  //   contentType: undefined,
-  //   contentEncoding: undefined,
-  //   headers: {},
-  //   deliveryMode: undefined,
-  //   priority: undefined,
-  //   correlationId: undefined,
-  //   replyTo: undefined,
-  //   expiration: undefined,
-  //   messageId: undefined,
-  //   timestamp: undefined,
-  //   type: undefined,
-  //   userId: undefined,
-  //   appId: undefined,
-  //   clusterId: undefined }
-
-  shim.recordProduce(proto, 'sendMessage', recordSendMessage)
-  function recordSendMessage(shim, fn, n, args) {
+  shim.recordProduce(proto, 'sendMessage', function recordSendMessage(shim, fn, n, args) {
     const fields = args[0]
     if (!fields) {
       return null
@@ -189,9 +213,16 @@ function wrapChannel(shim) {
       headers: fields.headers,
       parameters: getParameters(Object.create(null), fields)
     }
-  }
+  })
 }
 
+/**
+ * Sets the relevant message parameters
+ *
+ * @param {object} parameters object used to store the message parameters
+ * @param {object} fields fields from the sendMessage method
+ * @returns {object} parameters updated parameters
+ */
 function getParameters(parameters, fields) {
   if (fields.routingKey) {
     parameters.routing_key = fields.routingKey
@@ -206,29 +237,42 @@ function getParameters(parameters, fields) {
   return parameters
 }
 
-function wrapPromiseChannel(shim) {
-  const libPModel = shim.require('./lib/channel_model')
-  if (!libPModel || !libPModel.Channel || !libPModel.Channel.prototype) {
-    shim.logger.debug('Could not get promise model Channel to instrument')
+/**
+ *
+ * Instruments the relevant channel callback_model or channel_model.
+ *
+ * @param {Shim} shim instance of shim
+ * @param {object} Model either channel or callback model
+ * @param {boolean} promiseMode is this promise based?
+ */
+function wrapModel(shim, Model, promiseMode) {
+  if (!Model.Channel?.prototype) {
+    shim.logger.debug(
+      `Could not get ${promiseMode ? 'promise' : 'callback'} model Channel to instrument.`
+    )
   }
 
-  const proto = libPModel.Channel.prototype
+  const proto = Model.Channel.prototype
   if (shim.isWrapped(proto.consume)) {
-    shim.logger.trace('Promise model already instrumented.')
+    shim.logger.trace(`${promiseMode ? 'promise' : 'callback'} model already instrumented.`)
     return
   }
 
   shim.record(proto, CHANNEL_METHODS, function recordChannelMethod(shim, fn, name) {
     return {
       name: 'Channel#' + name,
-      promise: true
+      callback: setCallback(shim, promiseMode),
+      promise: promiseMode
     }
   })
 
   shim.recordConsume(proto, 'get', {
     destinationName: shim.FIRST,
-    promise: true,
+    callback: setCallback(shim, promiseMode),
+    promise: promiseMode,
     messageHandler: function handleConsumedMessage(shim, fn, name, message) {
+      // the message is the param when using the promised based model
+      message = promiseMode ? message : message[1]
       if (!message) {
         shim.logger.trace('No results from consume.')
         return null
@@ -237,95 +281,9 @@ function wrapPromiseChannel(shim) {
       getParameters(parameters, message.fields)
       getParameters(parameters, message.properties)
 
-      let headers = null
-      if (message.properties && message.properties.headers) {
-        headers = message.properties.headers
-      }
-
-      return { parameters: parameters, headers: headers }
-    }
-  })
-
-  shim.recordPurgeQueue(proto, 'purgeQueue', function recordPurge(shim, fn, name, args) {
-    let queue = args[0] || null
-    if (TEMP_RE.test(queue)) {
-      queue = null
-    }
-
-    return { queue: queue, promise: true }
-  })
-
-  shim.recordSubscribedConsume(proto, 'consume', {
-    name: 'amqplib.Channel#consume',
-    queue: shim.FIRST,
-    consumer: shim.SECOND,
-    promise: true,
-    messageHandler: describeMessage
-  })
-}
-
-function wrapCallbackChannel(shim) {
-  const libCbModel = shim.require('./lib/callback_model')
-  if (!libCbModel || !libCbModel.Channel || !libCbModel.Channel.prototype) {
-    shim.logger.debug('Could not get callback model Channel to instrument')
-    return
-  }
-
-  const proto = libCbModel.Channel.prototype
-  if (shim.isWrapped(proto.consume)) {
-    return
-  }
-
-  // Example message:
-  // { fields:
-  //  { consumerTag: 'amq.ctag-8oZE10ovvyAP8e-vgbOnSA',
-  //    deliveryTag: 1,
-  //    redelivered: false,
-  //    exchange: 'test-exchange-topic',
-  //    routingKey: 'routing.key' },
-  // properties:
-  //  { contentType: undefined,
-  //    contentEncoding: undefined,
-  //    headers: {},
-  //    deliveryMode: undefined,
-  //    priority: undefined,
-  //    correlationId: undefined,
-  //    replyTo: undefined,
-  //    expiration: undefined,
-  //    messageId: undefined,
-  //    timestamp: undefined,
-  //    type: undefined,
-  //    userId: undefined,
-  //    appId: undefined,
-  //    clusterId: undefined },
-  // content: Buffer [ 97 ] }
-
-  shim.record(proto, CHANNEL_METHODS, function recordChannelMethod(shim, fn, name) {
-    return {
-      name: 'Channel#' + name,
-      callback: shim.LAST
-    }
-  })
-
-  shim.recordConsume(proto, 'get', {
-    destinationName: shim.FIRST,
-    callback: shim.LAST,
-    messageHandler: function handleConsumedMessage(shim, fn, name, args) {
-      const message = args[1]
-      if (!message) {
-        shim.logger.trace('No results from consume.')
-        return null
-      }
-      const parameters = Object.create(null)
-      getParameters(parameters, message.fields)
-      getParameters(parameters, message.properties)
-
-      let headers = null
-      if (message.properties && message.properties.headers) {
-        headers = message.properties.headers
-      }
+      const headers = message?.properties?.headers
 
-      return { parameters: parameters, headers: headers }
+      return { parameters, headers }
     }
   })
 
@@ -334,42 +292,49 @@ function wrapCallbackChannel(shim) {
     if (TEMP_RE.test(queue)) {
       queue = null
     }
-
-    return { queue: queue, callback: shim.LAST }
+    return { queue, promise: promiseMode, callback: setCallback(shim, promiseMode) }
   })
 
   shim.recordSubscribedConsume(proto, 'consume', {
     name: 'amqplib.Channel#consume',
     queue: shim.FIRST,
     consumer: shim.SECOND,
-    callback: shim.FOURTH,
-    promise: false,
+    promise: promiseMode,
+    callback: promiseMode ? null : shim.FOURTH,
     messageHandler: describeMessage
   })
 }
 
-function describeMessage(shim, consumer, name, args) {
-  const message = args[0]
-  if (!message || !message.properties) {
+/**
+ *  Extracts the appropriate messageHandler parameters for the consume method.
+ *
+ *  @param {Shim} shim instance of shim
+ *  @param {object} _consumer not used
+ *  @param {string} _name not used
+ *  @param {Array} args arguments passed to the consume method
+ *  @returns {object} message params
+ */
+function describeMessage(shim, _consumer, _name, args) {
+  const [message] = args
+
+  if (!message?.properties) {
     shim.logger.debug({ message: message }, 'Failed to find message in consume arguments.')
     return null
   }
 
-  let exchangeName = message.fields.exchange
   const parameters = getParameters(Object.create(null), message.fields)
   getParameters(parameters, message.properties)
+  let exchangeName = message?.fields?.exchange || 'Default'
 
-  if (!exchangeName) {
-    exchangeName = 'Default'
-  } else if (TEMP_RE.test(exchangeName)) {
+  if (TEMP_RE.test(exchangeName)) {
     exchangeName = null
   }
 
   return {
     destinationName: exchangeName,
     destinationType: shim.EXCHANGE,
-    routingKey: message.fields.routingKey,
+    routingKey: message?.fields?.routingKey,
     headers: message.properties.headers,
-    parameters: parameters
+    parameters
   }
 }

package/lib/instrumentation/core/{async_hooks.js → async-hooks.js}

@@ -5,8 +5,6 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 18] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-
 const logger = require('../../logger').child({ component: 'async_hooks' })
 const asyncHooks = require('async_hooks')
 
@@ -26,7 +24,8 @@ function initialize(agent, shim) {
   const segmentMap = new Map()
   module.exports.segmentMap = segmentMap
 
-  const hookHandlers = getPromiseResolveStyleHooks(segmentMap, agent, shim)
+  const hookHandlers = getHookHandlers(segmentMap, agent, shim)
+  maybeRegisterDestroyHook(segmentMap, agent, hookHandlers)
 
   const hook = asyncHooks.createHook(hookHandlers)
   hook.enable()
@@ -38,8 +37,18 @@ function initialize(agent, shim) {
   return true
 }
 
-function getPromiseResolveStyleHooks(segmentMap, agent, shim) {
-  const hooks = {
+/**
+ * Registers the async hooks events
+ *
+ * Note: The init only fires when the type is PROMISE.
+ *
+ * @param {Map} segmentMap map of async ids and segments
+ * @param {Agent} agent New Relic APM agent
+ * @param {Shim} shim instance of shim
+ * @returns {object} event handlers for async hooks
+ */
+function getHookHandlers(segmentMap, agent, shim) {
+  return {
     init: function initHook(id, type, triggerId) {
       if (type !== 'PROMISE') {
         return
@@ -101,17 +110,23 @@ function getPromiseResolveStyleHooks(segmentMap, agent, shim) {
       }
     }
   }
+}
 
-  // Clean up any unresolved promises that have been destroyed.
-  // This defaults to true but does have a significant performance impact
-  // when customers have a lot of promises.
-  // See: https://github.com/newrelic/node-newrelic/issues/760
+/**
+ * Adds the destroy async hook event that will lean up any unresolved promises that have been destroyed.
+ * This defaults to true but does have a significant performance impact
+ * when customers have a lot of promises.
+ * See: https://github.com/newrelic/node-newrelic/issues/760
+ *
+ * @param {Map} segmentMap map of async ids and segments
+ * @param {Agent} agent New Relic APM agent
+ * @param {object} hooks async-hook events
+ */
+function maybeRegisterDestroyHook(segmentMap, agent, hooks) {
   if (agent.config.feature_flag.unresolved_promise_cleanup) {
     logger.info('Adding destroy hook to clean up unresolved promises.')
     hooks.destroy = function destroyHandler(id) {
       segmentMap.delete(id)
     }
   }
-
-  return hooks
 }

package/lib/instrumentation/core/globals.js

@@ -5,7 +5,7 @@
 
 'use strict'
 
-const asyncHooks = require('./async_hooks')
+const asyncHooks = require('./async-hooks')
 const symbols = require('../../symbols')
 
 module.exports = initialize