newrelic 13.15.0 → 13.16.0

package/NEWS.md

@@ -1,3 +1,22 @@
+### v13.16.0 (2026-03-11)
+
+#### Bug fixes
+
+* Updated `@apm-js-collab/tracing-hooks` to `0.5.0`, to allow instrumentation on windows environments. ([#3819](https://github.com/newrelic/node-newrelic/pull/3819)) ([d8f6d0f](https://github.com/newrelic/node-newrelic/commit/d8f6d0f6ac7f3ff17a667391269c41e6e57dc2fb))
+	* This version of `@apm-js-collab/tracing-hooks` includes the windows path fix for `@apm-js-collab/code-transformer`, [see](https://github.com/apm-js-collab/tracing-hooks/issues/19).
+
+#### Code refactoring
+
+* Updated `redis` v3 instrumentation to subscribe to events emitted ([#3802](https://github.com/newrelic/node-newrelic/pull/3802)) ([4d18302](https://github.com/newrelic/node-newrelic/commit/4d1830237c91d3e60c6b4e898f2c82ff131ebd57))
+
+#### Documentation
+
+* Updated compatibility report ([#3813](https://github.com/newrelic/node-newrelic/pull/3813)) ([27cb0a5](https://github.com/newrelic/node-newrelic/commit/27cb0a5e7a4c6047cce54483bd18d1337023efd3))
+
+#### Tests
+
+* Add `redis-client` and `node-redis-client` segment duration timing tests ([#3810](https://github.com/newrelic/node-newrelic/pull/3810)) ([f07bcfe](https://github.com/newrelic/node-newrelic/commit/f07bcfecf06453c846e12f030fbf7d8c055da139))
+
 ### v13.15.0 (2026-03-09)
 
 #### Features
@@ -8431,6 +8450,8 @@ Special thanks to Ryan Copley (@RyanCopley) for the contribution.
 
 
 
+
+
 
 
 

package/lib/instrumentations.js

@@ -25,7 +25,6 @@ module.exports = function instrumentations() {
     mongodb: { type: InstrumentationDescriptor.TYPE_DATASTORE },
     next: { module: './instrumentation/nextjs' },
     q: { type: null },
-    redis: { type: InstrumentationDescriptor.TYPE_DATASTORE },
     restify: { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
     when: { module: './instrumentation/when' },
     winston: { type: InstrumentationDescriptor.TYPE_GENERIC }

package/lib/subscriber-configs.js

@@ -27,6 +27,7 @@ const subscribers = {
   ...require('./subscribers/openai/config'),
   ...require('./subscribers/pino/config'),
   ...require('./subscribers/pg/config'),
+  ...require('./subscribers/redis/config'),
   ...require('./subscribers/redis-client/config'),
   ...require('./subscribers/undici/config')
 }

package/lib/subscribers/base.js

@@ -42,6 +42,9 @@ const ArrayPrototypeSplice = makeCall(Array.prototype.splice)
  * @property {AsyncLocalStorage} store The async local storage instance used for context management.
  * @property {number} [callback=null] Position of callback if it needs to be wrapped for instrumentation.
  * -1 means last argument.
+ * @property {string} [callbackKey=null] Property name on the argument at `callback` position
+ * that holds the actual callback function. Used when the callback is not a direct argument but a
+ * property on an object argument (e.g. `args[0].callback` when callback=0 and callbackKey='callback').
  * @property {string[]} [events=[]] Set of tracing channel event names to
  * register handlers for. For any name in the set, a corresponding method
  * must exist on the subscriber instance. The method will be passed the
@@ -88,6 +91,7 @@ class Subscriber {
     this.channel = tracingChannel(this.id)
     this.store = agent.tracer._contextManager._asyncLocalStorage
     this.callback = null
+    this.callbackKey = null
   }
 
   shouldCreateSegment(parent) {
@@ -103,11 +107,23 @@ class Subscriber {
    * This will wrap a callback at a given position and reassign the callback argument to the wrapped one
    *
    * @param {number} position index of the callback, you can specify -1 to be the last
+   * @param {string} [key] property name to look up on the argument at `position` when the
+   * callback is not a direct argument but a property on an object argument
+   * (e.g. `args[0].callback` when position=0 and key='callback')
    * @param {object} context the event passed to the tracing channel hooks
    */
-  traceCallback(position, context) {
+  traceCallback(position, key, context) {
     this.logger.trace('Wrapping the callback at position %s', position)
     const { asyncStart, asyncEnd, error } = this.channel
+
+    const holder = ArrayPrototypeAt(context.arguments, position)
+    const callback = key ? holder?.[key] : holder
+
+    if (typeof callback !== 'function') {
+      this.logger.trace('Callback is not present, not wrapping')
+      return
+    }
+
     function wrappedCallback(err, res) {
       // assigning a boolean to the context so we know that the
       // `error`, `asyncStart`, and `asyncEnd` are coming from the wrapped callback
@@ -133,9 +149,8 @@ class Subscriber {
       })
     }
 
-    const callback = ArrayPrototypeAt(context.arguments, position)
-    if (typeof callback !== 'function') {
-      this.logger.trace('Callback is not present, not wrapping')
+    if (key) {
+      context.arguments[position][key] = wrappedCallback
     } else {
       ArrayPrototypeSplice(context.arguments, position, 1, wrappedCallback)
     }
@@ -254,7 +269,7 @@ class Subscriber {
 
       // only wrap the callback if a subscriber has a callback property defined
       if (this.callback !== null) {
-        this.traceCallback(this.callback, data)
+        this.traceCallback(this.callback, this.callbackKey, data)
       }
       const ctx = this.agent.tracer.getContext()
       if (this.requireActiveTx && !ctx?.transaction?.isActive()) {

package/lib/subscribers/redis/config.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const internalSendCommand = {
+  path: './redis/internal-send-command',
+  instrumentations: [{
+    channelName: 'nr_internalSendCommand',
+    module: { name: 'redis', versionRange: '>=2.6.0 <4', filePath: 'index.js' },
+    functionQuery: {
+      // RedisClient.prototype.internal_send_command
+      expressionName: 'internal_send_command',
+      kind: 'Sync'
+    }
+  }]
+}
+
+module.exports = {
+  redis: [
+    internalSendCommand
+  ]
+}

package/lib/subscribers/redis/internal-send-command.js

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const DbOperationSubscriber = require('../db-operation')
+const stringify = require('json-stringify-safe')
+
+module.exports = class RedisInternalSendCommandSubscriber extends DbOperationSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: 'redis', channelName: 'nr_internalSendCommand', system: 'Redis' })
+    this.events = ['asyncEnd', 'end']
+    this.propagateContext = true
+    this.callback = 0
+    this.callbackKey = 'callback'
+  }
+
+  handler(data, ctx) {
+    const { arguments: args, self: client } = data
+    const commandObject = args[0]
+    const keys = commandObject.args
+    this.parameters = this.#getInstanceParameters(client, keys)
+    this.operation = commandObject.command || 'other'
+
+    return super.handler(data, ctx)
+  }
+
+  /**
+   * Captures the necessary datastore parameters from redis v3 client
+   *
+   * @param {object} client instance of redis v3 client
+   * @param {string[]} keys list of keys
+   * @returns {object} datastore parameters: host, port_path_or_id, database_name, product, key
+   */
+  #getInstanceParameters(client, keys) {
+    const opts = client?.connection_options
+
+    return {
+      host: opts.host || 'localhost',
+      port_path_or_id: opts.path || opts.port || '6379',
+      database_name: client.selected_db || opts.db || 0,
+      product: this.system,
+      key: this.#stringifyKeys(keys)
+    }
+  }
+
+  #stringifyKeys(keys) {
+    let key = null
+    if (keys && keys.length) {
+      try {
+        key = stringify(keys[0])
+      } catch (err) {
+        this.logger.debug(err, 'Failed to stringify redis key for send command')
+        key = '<unknown>'
+      }
+    }
+
+    return key
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "13.15.0",
+  "version": "13.16.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -202,7 +202,7 @@
     "#test/assert": "./test/lib/custom-assertions/index.js"
   },
   "dependencies": {
-    "@apm-js-collab/tracing-hooks": "^0.4.0",
+    "@apm-js-collab/tracing-hooks": "^0.5.0",
     "@grpc/grpc-js": "^1.13.2",
     "@grpc/proto-loader": "^0.7.5",
     "@newrelic/security-agent": "^3.0.0",

package/lib/instrumentation/redis.js

@@ -1,104 +0,0 @@
-/*
- * Copyright 2020 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-'use strict'
-
-const stringify = require('json-stringify-safe')
-const {
-  OperationSpec,
-  params: { DatastoreParameters }
-} = require('../shim/specs')
-
-module.exports = function initialize(_agent, redis, _moduleName, shim) {
-  const proto = redis?.RedisClient?.prototype
-  if (!proto) {
-    // This will happen when redis >= 4.0.0
-    shim.logger.warn('Skipping redis instrumentation due to unrecognized module shape')
-    return false
-  }
-
-  shim.setDatastore(shim.REDIS)
-
-  if (!proto.internal_send_command) {
-    shim.logger.warn(
-      'New Relic Node.js agent no longer supports redis < 2.6.0, current version %s. Please downgrade to v11 for support, if needed',
-      shim.pkgVersion
-    )
-    return
-  }
-
-  registerInternalSendCommand(shim, proto)
-}
-
-/**
- * Instrumentation used in versions of redis >= 2.6.0 < 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(this)
-
-      parameters.key = stringifyKeys(shim, keys)
-
-      return new OperationSpec({
-        name: commandObject.command || 'other',
-        parameters,
-        callback: function bindCallback(shim, _f, _n, segment) {
-          if (shim.isFunction(commandObject.callback)) {
-            shim.bindCallbackSegment(null, 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 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 from redis client
- *
- * @param {object} client instance of redis client
- * @returns {object} datastore parameters
- */
-function getInstanceParameters(client = {}) {
-  const opts = client?.connection_options
-
-  return new DatastoreParameters({
-    host: opts.host || 'localhost',
-    port_path_or_id: opts.path || opts.port || '6379',
-    database_name: client.selected_db || opts.db || 0
-  })
-}