newrelic 11.17.0 → 11.18.0

package/NEWS.md

@@ -1,3 +1,36 @@
+### v11.18.0 (2024-05-29)
+
+#### Features
+
+* Added support for redis v4 legacyMode `client.v4.<command>` ([#2200](https://github.com/newrelic/node-newrelic/pull/2200)) ([b2284c5](https://github.com/newrelic/node-newrelic/commit/b2284c58eb798ab00a141ce08f4072584795c728))
+
+#### Code refactoring
+
+* Updated `shim.recordConsume` to use `shim.record` and added ability to invoke an after hook with callback args ([#2207](https://github.com/newrelic/node-newrelic/pull/2207)) ([4f48fc3](https://github.com/newrelic/node-newrelic/commit/4f48fc3bbd5afce4954019620b112f600b2dfb53))
+
+#### Documentation
+
+* Updated compatibility report ([#2223](https://github.com/newrelic/node-newrelic/pull/2223)) ([a256ca0](https://github.com/newrelic/node-newrelic/commit/a256ca0f2060efe576018527d37718a041ffc925))
+
+#### Miscellaneous chores
+
+* Removed outdated Slack reference ([#2198](https://github.com/newrelic/node-newrelic/pull/2198)) ([8110d42](https://github.com/newrelic/node-newrelic/commit/8110d426f402659d44bf786fec0503ca2413ee6b))
+* Removed package-lock.json ([#2208](https://github.com/newrelic/node-newrelic/pull/2208)) ([b267695](https://github.com/newrelic/node-newrelic/commit/b26769502b4cb38f9133f76f427ee96ce718c15b))
+* Removed unused express5 feature flag ([#2197](https://github.com/newrelic/node-newrelic/pull/2197)) ([366504b](https://github.com/newrelic/node-newrelic/commit/366504ba1e3bfed477a37be5d61f4e30e46b690d))
+
+#### Tests
+
+* Updated langchain versioned tests to separate the vectorstore and other tests. This is to avoid peer resolution of `@langchain/community` package that is being used to test the elasticsearch vectorstore ([#2216](https://github.com/newrelic/node-newrelic/pull/2216)) ([e768955](https://github.com/newrelic/node-newrelic/commit/e7689554aec2a038d5b80c54d4b6b603075856ac))
+* Fixed aws-sdk-v3 bedrock tests ([#2211](https://github.com/newrelic/node-newrelic/pull/2211)) ([050469e](https://github.com/newrelic/node-newrelic/commit/050469ecc59ccc9ba6a6e78527ac392f262ff939))
+* Fixed aws-sdk-v3 bedrock tests (again) ([#2212](https://github.com/newrelic/node-newrelic/pull/2212)) ([330cc4b](https://github.com/newrelic/node-newrelic/commit/330cc4b6ff8e3777b1dfa0fda7f5b4c5b20005af))
+
+#### Continuous integration
+
+* Updated the langchain vectorstore test to reference the correct version of `@langchain/core` getting tested ([#2202](https://github.com/newrelic/node-newrelic/pull/2202)) ([ed81852](https://github.com/newrelic/node-newrelic/commit/ed81852a4b3c582a54c0d274ba9d5887041ebeef))
+* Added updating of docs site with compatibility table ([#2205](https://github.com/newrelic/node-newrelic/pull/2205)) ([c28a938](https://github.com/newrelic/node-newrelic/commit/c28a9387f68feb8fa59d4134828662b3babeb9d0))
+* Fixed CI jobs ([#2215](https://github.com/newrelic/node-newrelic/pull/2215)) ([8b030fb](https://github.com/newrelic/node-newrelic/commit/8b030fbf479cd348e9b75544bc753c1d618bfca7))
+* Fixed should-run CI step ([#2214](https://github.com/newrelic/node-newrelic/pull/2214)) ([d0a481d](https://github.com/newrelic/node-newrelic/commit/d0a481d4b58706c4793fa12fa7706091eaffa0a4))
+
 ### v11.17.0 (2024-05-15)
 
 #### Features

package/lib/feature_flags.js

@@ -7,7 +7,10 @@
 
 // unreleased flags gating an active feature
 exports.prerelease = {
-  express5: false,
+  // internal_test_only is used for testing our feature flag implementation.
+  // It is not used to gate any features.
+  internal_test_only: false,
+
   promise_segments: false,
   reverse_naming_rules: false,
   undici_async_tracking: true,

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

@@ -21,6 +21,10 @@ module.exports = function initialize(_agent, redis, _moduleName, shim) {
       const client = original.apply(this, arguments)
       client[opts] = getRedisParams(client.options)
       CMDS_TO_INSTRUMENT.forEach(instrumentClientCommand.bind(null, shim, client))
+      if (client.options.legacyMode) {
+        client.v4[opts] = getRedisParams(client.options)
+        CMDS_TO_INSTRUMENT.forEach(instrumentClientCommand.bind(null, shim, client.v4))
+      }
       return client
     }
   })

package/lib/instrumentation/amqplib/amqplib.js

@@ -266,18 +266,20 @@ function wrapModel(shim, Model, promiseMode) {
       destinationName: shim.FIRST,
       callback: setCallback(shim, promiseMode),
       promise: promiseMode,
-      messageHandler: function handleConsumedMessage(shim, fn, name, message) {
+      after: function handleConsumedMessage({ shim, result, args, segment }) {
+        if (!shim.agent.config.message_tracer.segment_parameters.enabled) {
+          shim.logger.trace('Not capturing segment parameters')
+          return
+        }
+
         // the message is the param when using the promised based model
-        message = promiseMode ? message : message[1]
+        const message = promiseMode ? result : args?.[1]
         if (!message) {
           shim.logger.trace('No results from consume.')
           return null
         }
         const parameters = getParametersFromMessage(message)
-
-        const headers = message?.properties?.headers
-
-        return { parameters, headers }
+        shim.copySegmentParameters(segment, parameters)
       }
     })
   )
@@ -312,12 +314,10 @@ function wrapModel(shim, Model, promiseMode) {
  *  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) {
+function describeMessage(shim, args) {
   const [message] = args
 
   if (!message?.properties) {

package/lib/instrumentation/aws-sdk/v3/bedrock.js

@@ -197,8 +197,7 @@ function getBedrockSpec({ commandName }, shim, _original, _name, args) {
   return new RecorderSpec({
     promise: true,
     name: `Llm/${modelType}/Bedrock/${commandName}`,
-    // eslint-disable-next-line max-params
-    after: (shim, _fn, _fnName, err, response, segment) => {
+    after: ({ shim, error: err, result: response, segment }) => {
       const passThroughParams = {
         shim,
         err,

package/lib/instrumentation/core/inspector.js

@@ -16,7 +16,7 @@ function initialize(agent, inspector, name, shim) {
   shim.wrap(sessionProto, 'post', function wrapPost(shim, fn) {
     return function wrappedPost() {
       const args = shim.argsToArray.apply(shim, arguments)
-      shim.bindCallbackSegment(args, shim.LAST)
+      shim.bindCallbackSegment(null, args, shim.LAST)
       return fn.apply(this, args)
     }
   })

package/lib/instrumentation/langchain/runnable.js

@@ -61,8 +61,7 @@ function instrumentInvokeChain({ langchain, shim }) {
       return new RecorderSpec({
         name: `${LANGCHAIN.CHAIN}/${fnName}`,
         promise: true,
-        // eslint-disable-next-line max-params
-        after(_shim, _fn, _name, err, output, segment) {
+        after({ error: err, result: output, segment }) {
           recordChatCompletionEvents({
             segment,
             messages: [output],
@@ -97,8 +96,7 @@ function instrumentStream({ langchain, shim }) {
       return new RecorderSpec({
         name: `${LANGCHAIN.CHAIN}/${fnName}`,
         promise: true,
-        // eslint-disable-next-line max-params
-        after(_shim, _fn, _name, err, output, segment) {
+        after({ error: err, result: output, segment }) {
           // Input error occurred which means a stream was not created.
           // Skip instrumenting streaming and create Llm Events from
           // the data we have

package/lib/instrumentation/langchain/tools.js

@@ -31,8 +31,7 @@ module.exports = function initialize(shim, tools) {
     return new RecorderSpec({
       name: `${LANGCHAIN.TOOL}/${name}`,
       promise: true,
-      // eslint-disable-next-line max-params
-      after(_shim, _fn, _name, err, output, segment) {
+      after({ error: err, result: output, segment }) {
         const metadata = mergeMetadata(instanceMeta, paramsMeta)
         const tags = mergeTags(instanceTags, paramsTags)
         segment.end()

package/lib/instrumentation/langchain/vectorstore.js

@@ -89,8 +89,7 @@ module.exports = function initialize(shim, vectorstores) {
       return new RecorderSpec({
         name: `${LANGCHAIN.VECTORSTORE}/${fnName}`,
         promise: true,
-        // eslint-disable-next-line max-params
-        after(_shim, _fn, _name, err, output, segment) {
+        after({ error: err, result: output, segment }) {
           if (!output) {
             // If we get an error, it is possible that `output = null`.
             // In that case, we define it to be an empty array.

package/lib/instrumentation/memcached.js

@@ -76,7 +76,7 @@ module.exports = function initialize(agent, memcached, moduleName, shim) {
     return new OperationSpec({
       name: metacall.type || 'Unknown',
       callback: function wrapCallback(shim, fn, fnName, opSegment) {
-        shim.bindCallbackSegment(metacall, 'callback', opSegment)
+        shim.bindCallbackSegment(null, metacall, 'callback', opSegment)
       },
       parameters
     })

package/lib/instrumentation/openai.js

@@ -262,8 +262,7 @@ module.exports = function initialize(agent, openai, moduleName, shim) {
       return new RecorderSpec({
         name: OPENAI.COMPLETION,
         promise: true,
-        // eslint-disable-next-line max-params
-        after(_shim, _fn, _name, err, response, segment) {
+        after({ error: err, result: response, segment }) {
           if (request.stream) {
             instrumentStream({ agent, shim, request, response, segment })
           } else {
@@ -294,8 +293,7 @@ module.exports = function initialize(agent, openai, moduleName, shim) {
       return new RecorderSpec({
         name: OPENAI.EMBEDDING,
         promise: true,
-        // eslint-disable-next-line max-params
-        after(_shim, _fn, _name, err, response, segment) {
+        after({ error: err, result: response, segment }) {
           addLlmMeta({ agent, segment })
 
           if (!response) {

package/lib/instrumentation/redis.js

@@ -49,7 +49,7 @@ function registerInternalSendCommand(shim, proto) {
         parameters,
         callback: function bindCallback(shim, _f, _n, segment) {
           if (shim.isFunction(commandObject.callback)) {
-            shim.bindCallbackSegment(commandObject, 'callback', segment)
+            shim.bindCallbackSegment(null, commandObject, 'callback', segment)
           } else {
             const self = this
             commandObject.callback = shim.bindSegment(
@@ -87,9 +87,9 @@ function registerSendCommand(shim, proto) {
       callback: function bindCallback(shim, _f, _n, segment) {
         const last = args[args.length - 1]
         if (shim.isFunction(last)) {
-          shim.bindCallbackSegment(args, shim.LAST, segment)
+          shim.bindCallbackSegment(null, args, shim.LAST, segment)
         } else if (shim.isArray(last) && shim.isFunction(last[last.length - 1])) {
-          shim.bindCallbackSegment(last, shim.LAST, segment)
+          shim.bindCallbackSegment(null, last, shim.LAST, segment)
         }
       }
     })

package/lib/instrumentation/superagent.js

@@ -50,7 +50,7 @@ function wrapCallback(shim, callback) {
   return function wrappedCallback() {
     const segment = shim.getSegment(this)
     if (segment && segment.transaction.isActive()) {
-      shim.bindCallbackSegment(this, '_callback', segment)
+      shim.bindCallbackSegment(null, this, '_callback', segment)
     }
     return callback.apply(this, arguments)
   }

package/lib/shim/message-shim/consume.js

@@ -4,7 +4,6 @@
  */
 
 'use strict'
-const TraceSegment = require('../../transaction/trace/segment')
 const genericRecorder = require('../../metrics/recorders/generic')
 const { _nameMessageSegment } = require('./common')
 const specs = require('../specs')
@@ -25,7 +24,7 @@ module.exports = createRecorder
 function updateSpecFromArgs({ shim, fn, fnName, args, spec }) {
   let msgDesc = null
   if (shim.isFunction(spec)) {
-    msgDesc = spec.call(this, shim, fn, fnName, args)
+    msgDesc = spec(shim, fn, fnName, args)
   } else {
     msgDesc = spec
     const destIdx = shim.normalizeIndex(args.length, spec.destinationName)
@@ -37,81 +36,6 @@ function updateSpecFromArgs({ shim, fn, fnName, args, spec }) {
   return msgDesc
 }
 
-/**
- * Binds the consumer callback to the active segment.
- *
- * @private
- * @param {object} params to function
- * @param {MessageShim} params.shim instance of shim
- * @param {Array} params.args arguments passed to original consume function
- * @param {specs.MessageSpec} params.msgDesc spec for the wrapped consume function
- * @param {TraceSegment} params.segment active segment to bind callback
- * @param {boolean} params.getParams flag to copy message parameters to segment
- * @param {Function} params.resHandler function to handle response from callback to obtain the message parameters
- */
-function bindCallback({ shim, args, msgDesc, segment, getParams, resHandler }) {
-  const cbIdx = shim.normalizeIndex(args.length, msgDesc.callback)
-  if (cbIdx !== null) {
-    shim.bindCallbackSegment(args, cbIdx, segment)
-
-    // If we have a callback and a results handler, then wrap the callback so
-    // we can call the results handler and get the message properties.
-    if (resHandler) {
-      shim.wrap(args, cbIdx, function wrapCb(shim, cb, cbName) {
-        if (shim.isFunction(cb)) {
-          return function cbWrapper() {
-            const cbArgs = shim.argsToArray.apply(shim, arguments)
-            const msgProps = resHandler.call(this, shim, cb, cbName, cbArgs)
-            if (getParams && msgProps && msgProps.parameters) {
-              shim.copySegmentParameters(segment, msgProps.parameters)
-            }
-
-            return cb.apply(this, arguments)
-          }
-        }
-      })
-    }
-  }
-}
-
-/**
- * Binds the consumer function to the async context and checks return to possibly
- * bind the promise
- *
- * @private
- * @param {object} params to function
- * @param {MessageShim} params.shim instance of shim
- * @param {Function} params.fn consumer function
- * @param {string} params.fnName name of function
- * @param {Array} params.args arguments passed to original consume function
- * @param {specs.MessageSpec} params.msgDesc spec for the wrapped consume function
- * @param {TraceSegment} params.segment active segment to bind callback
- * @param {boolean} params.getParams flag to copy message parameters to segment
- * @param {Function} params.resHandler function to handle response from callback to obtain the message parameters
- * @returns {Promise|*} response from consume function
- */
-function bindConsumer({ shim, fn, fnName, args, msgDesc, segment, getParams, resHandler }) {
-  // Call the method in the context of our segment.
-  let ret = shim.applySegment(fn, segment, true, this, args)
-
-  if (ret && msgDesc.promise && shim.isPromise(ret)) {
-    ret = shim.bindPromise(ret, segment)
-
-    // Intercept the promise to handle the result.
-    if (resHandler) {
-      ret = ret.then(function interceptValue(res) {
-        const msgProps = resHandler.call(this, shim, fn, fnName, res)
-        if (getParams && msgProps && msgProps.parameters) {
-          shim.copySegmentParameters(segment, msgProps.parameters)
-        }
-        return res
-      })
-    }
-  }
-
-  return ret
-}
-
 /**
  *
  * @private
@@ -119,48 +43,14 @@ function bindConsumer({ shim, fn, fnName, args, msgDesc, segment, getParams, res
  * @param {MessageShim} params.shim instance of shim
  * @param {Function} params.fn function that is being wrapped
  * @param {string} params.fnName name of function
+ * @param params.args
  * @param {specs.MessageSpec} params.spec spec for the wrapped consume function
- * @returns {Function} recorder for consume function
+ * @returns {specs.MessageSpec} updated spec with logic to name segment and apply the genericRecorder
  */
-function createRecorder({ shim, fn, fnName, spec }) {
-  return function consumeRecorder() {
-    const parent = shim.getSegment()
-    if (!parent || !parent.transaction.isActive()) {
-      shim.logger.trace('Not recording consume, no active transaction.')
-      return fn.apply(this, arguments)
-    }
-
-    // Process the message args.
-    const args = shim.argsToArray.apply(shim, arguments)
-    const msgDesc = updateSpecFromArgs.call(this, { shim, fn, fnName, args, spec })
-
-    // Make the segment if we can.
-    if (!msgDesc) {
-      shim.logger.trace('Not recording consume, no message descriptor.')
-      return fn.apply(this, args)
-    }
-
-    const name = _nameMessageSegment(shim, msgDesc, shim._metrics.CONSUME)
-
-    // Adds details needed by createSegment when used with a spec
-    msgDesc.name = name
-    msgDesc.recorder = genericRecorder
-    msgDesc.parent = parent
-
-    const segment = shim.createSegment(msgDesc)
-    const getParams = shim.agent.config.message_tracer.segment_parameters.enabled
-    const resHandler = shim.isFunction(msgDesc.messageHandler) ? msgDesc.messageHandler : null
-
-    bindCallback({ shim, args, msgDesc, segment, getParams, resHandler })
-    return bindConsumer.call(this, {
-      shim,
-      fn,
-      fnName,
-      args,
-      msgDesc,
-      segment,
-      getParams,
-      resHandler
-    })
-  }
+function createRecorder({ spec, shim, fn, fnName, args }) {
+  const msgDesc = updateSpecFromArgs({ shim, fn, fnName, args, spec })
+  // Adds details needed by createSegment when used with a spec
+  msgDesc.name = _nameMessageSegment(shim, msgDesc, shim._metrics.CONSUME)
+  msgDesc.recorder = genericRecorder
+  return msgDesc
 }

package/lib/shim/message-shim/index.js

@@ -287,17 +287,8 @@ function recordConsume(nodule, properties, spec) {
     properties = null
   }
 
-  // This is using wrap instead of record because the spec allows for a messageHandler
-  // which is being used to handle the result of the callback or promise of the
-  // original wrapped consume function.
-  // TODO: https://github.com/newrelic/node-newrelic/issues/981
-  return this.wrap(nodule, properties, function wrapConsume(shim, fn, fnName) {
-    if (!shim.isFunction(fn)) {
-      shim.logger.debug('Not wrapping %s (%s) as consume', fn, fnName)
-      return fn
-    }
-
-    return createRecorder({ shim, fn, fnName, spec })
+  return this.record(nodule, properties, function wrapConsume(shim, fn, fnName, args) {
+    return createRecorder({ spec, shim, fn, fnName, args })
   })
 }
 

package/lib/shim/message-shim/subscribe-consume.js

@@ -84,12 +84,12 @@ function makeWrapConsumer({ spec, queue, destinationName, destNameIsArg }) {
     spec.queue = queue
   }
 
-  return function wrapConsumer(shim, consumer, cName) {
+  return function wrapConsumer(shim, consumer) {
     if (!shim.isFunction(consumer)) {
       return consumer
     }
 
-    const consumerWrapper = createConsumerWrapper({ shim, consumer, cName, spec })
+    const consumerWrapper = createConsumerWrapper({ shim, consumer, spec })
     return shim.bindCreateTransaction(
       consumerWrapper,
       new specs.TransactionSpec({
@@ -108,10 +108,9 @@ function makeWrapConsumer({ spec, queue, destinationName, destNameIsArg }) {
  * @param {MessageShim} params.shim instance of shim
  * @param {specs.MessageSubscribeSpec} params.spec spec for function
  * @param {Function} params.consumer function for consuming message
- * @param {string} params.cName name of consumer function
  * @returns {Function} handler for the transaction being created
  */
-function createConsumerWrapper({ shim, spec, consumer, cName }) {
+function createConsumerWrapper({ shim, spec, consumer }) {
   return function createConsumeTrans() {
     // If there is no transaction or we're in a pre-existing transaction,
     // then don't do anything. Note that the latter should never happen.
@@ -123,7 +122,7 @@ function createConsumerWrapper({ shim, spec, consumer, cName }) {
       return consumer.apply(this, args)
     }
 
-    const msgDesc = spec.messageHandler.call(this, shim, consumer, cName, args)
+    const msgDesc = spec.messageHandler.call(this, shim, args)
 
     // If message could not be handled, immediately kill this transaction.
     if (!msgDesc) {

package/lib/shim/shim.js

@@ -799,12 +799,13 @@ function _applyRecorderSegment({ segment, ctx, args, segDesc, shim, fn, name })
       return ret.then(
         function onThen(val) {
           segment.touch()
-          segDesc.after(shim, fn, name, null, val, segment)
+          // passing in error as some instrumentation checks if it's not equal to `null`
+          segDesc.after({ shim, fn, name, error, result: val, segment })
           return val
         },
         function onCatch(err) {
           segment.touch()
-          segDesc.after(shim, fn, name, err, null, segment)
+          segDesc.after({ shim, fn, name, error: err, segment })
           throw err // NOTE: This is not an error from our instrumentation.
         }
       )
@@ -815,7 +816,7 @@ function _applyRecorderSegment({ segment, ctx, args, segDesc, shim, fn, name })
     throw err // Just rethrowing this error, not our error!
   } finally {
     if (segDesc.after && (error || !promised)) {
-      segDesc.after(shim, fn, name, error, ret, segment)
+      segDesc.after({ shim, fn, name, error, result: ret, segment })
     }
   }
 }
@@ -977,10 +978,11 @@ function bindSegment(nodule, property, segment, full) {
  * Replaces the callback in an arguments array with one that has been bound to
  * the given segment.
  *
- * - `bindCallbackSegment(args, cbIdx [, segment])`
- * - `bindCallbackSegment(obj, property [, segment])`
+ * - `bindCallbackSegment(spec, args, cbIdx [, segment])`
+ * - `bindCallbackSegment(spec, obj, property [, segment])`
  *
  * @memberof Shim.prototype
+ * @param {Spec} spec spec to original wrapped function, used to call after method with arguments passed to callback
  * @param {Array | object} args
  *  The arguments array to pull the cb from.
  * @param {number|string} cbIdx
@@ -990,7 +992,7 @@ function bindSegment(nodule, property, segment, full) {
  *  currently active segment.
  * @see Shim#bindSegment
  */
-function bindCallbackSegment(args, cbIdx, parentSegment) {
+function bindCallbackSegment(spec, args, cbIdx, parentSegment) {
   if (!args) {
     return
   }
@@ -1009,35 +1011,59 @@ function bindCallbackSegment(args, cbIdx, parentSegment) {
     cbIdx = normalizedCBIdx
   }
 
-  // Pull out the callback and make sure it is a function.
+  // Make sure cb is function before wrapping
+  if (this.isFunction(args[cbIdx])) {
+    wrapCallback({ shim: this, args, cbIdx, parentSegment, spec })
+  }
+}
+
+/**
+ * Wraps the callback and creates a segment for the callback function.
+ * It will also call an after hook with the arguments passed to callback
+ *
+ * @private
+ * @param {Object} params to function
+ * @param {Shim} params.shim instance of shim
+ * @param {Array | object} params.args
+ *  The arguments array to pull the cb from.
+ * @param {number|string} params.cbIdx
+ *  The index of the callback.
+ * @param {TraceSegment} [params.parentSegment]
+ *  The segment to use as the callback segment's parent. Defaults to the
+ *  currently active segment.
+ * @param {Spec} params.spec spec to original wrapped function, used to call after method with arguments passed to callback
+ *
+ */
+function wrapCallback({ shim, args, cbIdx, parentSegment, spec }) {
   const cb = args[cbIdx]
-  if (this.isFunction(cb)) {
-    const shim = this
-    const realParent = parentSegment || shim.getSegment()
-    args[cbIdx] = shim.wrap(cb, null, function callbackWrapper(shim, fn, name) {
-      return function wrappedCallback() {
-        if (realParent) {
-          realParent.opaque = false
-        }
-        const segment = _rawCreateSegment(
-          shim,
-          new specs.SegmentSpec({
-            name: 'Callback: ' + name,
-            parent: realParent
-          })
-        )
-
-        if (segment) {
-          segment.async = false
-        }
+  const realParent = parentSegment || shim.getSegment()
+  args[cbIdx] = shim.wrap(cb, null, function callbackWrapper(shim, fn, name) {
+    return function wrappedCallback() {
+      if (realParent) {
+        realParent.opaque = false
+      }
+      const segment = _rawCreateSegment(
+        shim,
+        new specs.SegmentSpec({
+          name: 'Callback: ' + name,
+          parent: realParent
+        })
+      )
 
-        // CB may end the transaction so update the parent's time preemptively.
-        realParent && realParent.touch()
-        return shim.applySegment(cb, segment, true, this, arguments)
+      if (segment) {
+        segment.async = false
       }
-    })
-    shim.storeSegment(args[cbIdx], realParent)
-  }
+
+      if (spec?.after) {
+        spec.after({ shim, fn, name, args: arguments, segment: realParent })
+      }
+
+      // CB may end the transaction so update the parent's time preemptively.
+      realParent && realParent.touch()
+      return shim.applySegment(cb, segment, true, this, arguments)
+    }
+  })
+  shim.storeSegment(args[cbIdx], realParent)
 }
 
 /**
@@ -1792,7 +1818,7 @@ function _bindAllCallbacks(shim, fn, name, args, spec) {
     _bindCallback({
       context: this,
       callback: spec.spec.callback,
-      binder: shim.bindCallbackSegment,
+      binder: shim.bindCallbackSegment.bind(shim, spec.spec),
       shim,
       fn,
       args,
@@ -1806,7 +1832,7 @@ function _bindAllCallbacks(shim, fn, name, args, spec) {
     _bindCallback({
       context: this,
       callback: spec.spec.rowCallback,
-      binder: shim.bindRowCallbackSegment || shim.bindCallbackSegment,
+      binder: shim?.bindRowCallbackSegment || shim?.bindCallbackSegment?.bind(shim, spec.spec),
       shim,
       fn,
       args,
@@ -1954,7 +1980,7 @@ function wrapStreamListeners({ stream, shim, segment, specEvent }) {
     return function wrappedOn(onEvent) {
       if (onEvent !== specEvent && (onEvent === 'end' || onEvent === 'error')) {
         const args = argsToArray.apply(shim, arguments)
-        shim.bindCallbackSegment(args, shim.LAST, segment)
+        shim.bindCallbackSegment(specEvent, args, shim.LAST, segment)
         return fn.apply(this, args)
       }
       return fn.apply(this, arguments)

package/lib/shim/specs/recorder.js

@@ -24,14 +24,17 @@ const WrapSpec = require('./wrap')
  * The instrumented function must have been invoked synchronously.
  *
  * @typedef {Function} SpecAfterFunction
- * @param {object} shim The shim used to instrument the external library.
- * @param {Function} fn The function/method from the external library being
+ * @param {Object} params params to function
+ * @param {object} params.shim The shim used to instrument the external library.
+ * @param {Function} params.fn The function/method from the external library being
  * instrumented.
- * @param {string} name The name of the current function.
- * @param {Error|null} error If the instrumented function threw an error, this
- * will be that error.
- * @param {*} value The result returned by the instrumented function.
- * @param {TraceSegment} segment The segment used while instrumenting the
+ * @param {string} params.name The name of the current function.
+ * @param {Error|null} [params.error] If the instrumented function threw an error, this
+ * will be that error. In the case of a callback this will be omitted.
+ * @param {Array} [params.args] arguments passed to a callback function getting instrumented.
+ * @param {*} [params.result] The result returned by the instrumented function. In the case of a wrapped
+ * callback, the data needed is in `params.args`.
+ * @param {TraceSegment} params.segment The segment used while instrumenting the
  * function.
  */
 

package/lib/shim/webframework-shim/middleware.js

@@ -176,10 +176,10 @@ function middlewareWithCallbackRecorder({ spec, typeDetails, metricName, isError
       parent: txInfo.segmentStack[txInfo.segmentStack.length - 1],
       recorder,
       parameters: params,
-      after: function afterExec(shim, _fn, _name, err) {
-        const errIsError = isError(shim, err)
+      after: function afterExec({ shim, error }) {
+        const errIsError = isError(shim, error)
         if (errIsError) {
-          assignError(txInfo, err)
+          assignError(txInfo, error)
         } else if (!nextWrapper && !isErrorWare && spec.appendPath) {
           txInfo.transaction.nameState.popPath(route)
         }
@@ -243,12 +243,12 @@ function middlewareWithPromiseRecorder({ spec, typeDetails, metricName, isErrorW
       callback: nextWrapper,
       recorder,
       parameters: params,
-      after: function afterExec(shim, _fn, _name, err, result) {
+      after: function afterExec({ shim, error, result }) {
         if (shim._responsePredicate(args, result)) {
           txInfo.transaction.nameState.freeze()
         }
-        if (isError(shim, err)) {
-          assignError(txInfo, err)
+        if (isError(shim, error)) {
+          assignError(txInfo, error)
         } else {
           txInfo.errorHandled = true
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "11.17.0",
+  "version": "11.18.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -161,7 +161,6 @@
     "prepare-test": "npm run ssl && npm run docker-env",
     "lint": "eslint ./*.{js,mjs} lib test bin examples",
     "lint:fix": "eslint --fix, ./*.{js,mjs} lib test bin examples",
-    "lint:lockfile": "lockfile-lint --path package-lock.json --type npm --allowed-hosts npm --validate-https --validate-integrity",
     "public-docs": "jsdoc -c ./jsdoc-conf.jsonc && cp examples/shim/*.png out/",
     "publish-docs": "./bin/publish-docs.sh",
     "services": "docker compose up -d --wait",