newrelic 13.6.5 → 13.6.6

package/NEWS.md

@@ -1,3 +1,17 @@
+### v13.6.6 (2025-11-19)
+
+#### Bug fixes
+
+* Updated `app.use` or `router.use` Express instrumentation to properly wrap all middleware defined ([#3520](https://github.com/newrelic/node-newrelic/pull/3520)) ([d3b20d0](https://github.com/newrelic/node-newrelic/commit/d3b20d09a9c3d21bff081771d8c11caff9c6a6e5))
+
+#### Documentation
+
+* Updated compatibility report ([#3522](https://github.com/newrelic/node-newrelic/pull/3522)) ([72ec652](https://github.com/newrelic/node-newrelic/commit/72ec65252700ab5f3831dab35d05b607a0723aa6)) ([#3516](https://github.com/newrelic/node-newrelic/pull/3516)) ([35defb0](https://github.com/newrelic/node-newrelic/commit/35defb009b7d3bbec0ffe084b434e368aa1cbc7c))
+
+#### Tests
+
+* Pinned next.js to skip 11.0.10 and 11.0.11 ([#3521](https://github.com/newrelic/node-newrelic/pull/3521)) ([20977ee](https://github.com/newrelic/node-newrelic/commit/20977eeb8552b7a445f5407d8df272aae49ea873))
+
 ### v13.6.5 (2025-11-17)
 
 #### Bug fixes
@@ -8064,3 +8078,4 @@ Special thanks to Ryan Copley (@RyanCopley) for the contribution.
 
 
 
+

package/lib/config/default.js

@@ -8,6 +8,7 @@
 const defaultConfig = module.exports
 const { array, int, float, boolean, object, objectList, allowList, regex } = require('./formatters')
 const pkgInstrumentation = require('./build-instrumentation-config')
+const { config: samplerConfigs } = require('./samplers')
 
 /**
  * A function that returns the definition of the agent configuration
@@ -1156,6 +1157,7 @@ defaultConfig.definition = () => {
       },
 
       sampler: {
+        ...samplerConfigs,
         /**
          * The sampling target for adaptive sampling is controlled via this attribute when configuring the default/adaptive sampler.
          * The default sampling target is 10 transactions/min when it is not specified but **MUST** be within the range of [1, 120] (inclusive).
@@ -1166,77 +1168,23 @@ defaultConfig.definition = () => {
           formatter: int,
           default: 10
         },
-        // The root sampling options are defined in an unusual way compared to the rest of our configuration but this is done to
-        // allow compatibility with how OpenTelemetry sets their samplers and be backwards compatible as well. Root can either be
-        // a string or an object.
-        //
-        // Example setting root sampler via config to a string value -
-        // root: 'always_on'
-        //
-        // Example setting root sampler via config to trace id ratio based -
-        // root: {
-        //   trace_id_ratio_based: {
-        //     ratio: 0.5
-        //   }
-        // }
-        //
-        root: {
-          formatter: allowList.bind(null, ['trace_id_ratio_based', 'adaptive', 'always_on', 'always_off', 'default']),
-          default: 'default',
-          // if setting root to trace_id_ratio_based via env vars, set NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_ROOT: 'trace_id_ratio_based'
-          // and then set NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_ROOT_TRACE_ID_RATIO_BASED_RATIO to the desired ratio
-          trace_id_ratio_based: {
-            ratio: {
-              formatter: float,
-              env: 'NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_ROOT_TRACE_ID_RATIO_BASED_RATIO'
-            }
-          }
-        },
-
-        /**
-         * When set to `always_on`, the sampled flag in the `traceparent` header
-         * being set to "true" will result in the local transaction being sampled
-         * with a priority value of "2". When set to `always_off`, the local
-         * transaction will never be sampled. At the default setting, the sampling
-         * decision will be determined according to the normal algorithm.
-         *
-         * This setting takes precedence over the `remote_parent_not_sampled`
-         * setting.
-         */
-        remote_parent_sampled: {
-          formatter: allowList.bind(null, ['trace_id_ratio_based', 'adaptive', 'always_on', 'always_off', 'default']),
-          default: 'default',
-          // if setting remote_parent_sampled to trace_id_ratio_based via env vars, set NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_REMOTE_PARENT_SAMPLED: 'trace_id_ratio_based'
-          // and then set NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_REMOTE_PARENT_SAMPLED_TRACE_ID_RATIO_BASED_RATIO to the desired ratio
-          trace_id_ratio_based: {
-            ratio: {
-              formatter: float,
-              env: 'NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_REMOTE_PARENT_SAMPLED_TRACE_ID_RATIO_BASED_RATIO'
-            }
-          }
+        full_granularity: {
+          enabled: {
+            default: true,
+            formatter: boolean
+          },
+          ...samplerConfigs
         },
-
-        /**
-         * When set to `always_on`, the local transaction will be sampled with a
-         * priority of "2".
-         * When set to `always_off`, the local transaction will never be sampled.
-         * At the default setting, the sampling decision will be determined
-         * according to the normal algorithm.
-         *
-         * This setting only affects decisions when the traceparent sampled flag
-         * is set to 0.
-         */
-        remote_parent_not_sampled: {
-          formatter: allowList.bind(null, ['trace_id_ratio_based', 'adaptive', 'always_on', 'always_off', 'default']),
-          default: 'default',
-          // if setting remote_parent_not_sampled to trace_id_ratio_based via env vars, set NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_REMOTE_PARENT_NOT_SAMPLED: 'trace_id_ratio_based'
-          // and then set NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_REMOTE_PARENT_NOT_SAMPLED_TRACE_ID_RATIO_BASED_RATIO to the desired ratio
-          trace_id_ratio_based: {
-            ratio: {
-              formatter: float,
-              env: 'NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_REMOTE_PARENT_NOT_SAMPLED_TRACE_ID_RATIO_BASED_RATIO'
-            }
-          }
+        partial_granularity: {
+          enabled: {
+            default: false,
+            formatter: boolean
+          },
+          type: {
+            formatter: allowList.bind(null, ['compact', 'essential', 'reduced']),
+            default: 'essential'
+          },
+          ...samplerConfigs
         }
       }
     },
@@ -1909,4 +1857,5 @@ function setNestedKey(obj, keys, value) {
 
   obj[keys[len - 1]] = value
 }
+
 defaultConfig.setNestedKey = setNestedKey

package/lib/config/index.js

@@ -25,6 +25,7 @@ const mergeServerConfig = new MergeServerConfig()
 const { boolean: isTruthular } = require('./formatters')
 const configDefinition = definition()
 const parseLabels = require('../util/label-parser')
+const { buildTraceIdRatioSamplers, setTraceIdRatioSamplerFromEnv } = require('./samplers')
 
 /**
  * CONSTANTS -- we gotta lotta 'em
@@ -1065,7 +1066,7 @@ Config.prototype._fromPassed = function _fromPassed(external, internal, arbitrar
     }
 
     // Handle trace_id_ratio_based for distributed tracing sampler configuration
-    this._buildTraceIdRatioSamplers(key, internal, external[key])
+    buildTraceIdRatioSamplers({ config: external, key, incomingConfig: internal, logger })
 
     if (key === 'ssl' && !isTruthular(external.ssl)) {
       logger.warn(SSL_WARNING)
@@ -1090,54 +1091,6 @@ Config.prototype._fromPassed = function _fromPassed(external, internal, arbitrar
   }
 }
 
-/**
- * Builds the trace_id_ratio_based for distributed tracing sampler configuration structure
- *
- * @param {string} key - The configuration key being processed
- * @param {object} internal - The internal configuration object being modified
- * @param {object} samplerConfig - Sampler configuration object from defaultsConfig
- */
-Config.prototype._buildTraceIdRatioSamplers = function _buildTraceIdRatioSamplers(key, internal, samplerConfig) {
-  if (key !== 'sampler') {
-    return
-  }
-
-  const samplers = Object.keys(samplerConfig)
-
-  // user can set multiple samplers
-  for (const sampler of samplers) {
-    if (this._isTraceIdRatioBasedConfig(sampler, samplerConfig)) {
-      const ratioValue = samplerConfig[sampler].trace_id_ratio_based.ratio
-      if (ratioValue) {
-        internal[key][sampler] = {
-          trace_id_ratio_based: {
-            ratio: ratioValue
-          }
-        }
-        logger.trace('Setting trace id ratio based sampler on %s', samplers)
-      } else {
-        logger.error('Not setting trace id ratio based sampler on %s.', samplers)
-      }
-    }
-  }
-}
-
-/**
- * Checks if the external config contains a trace_id_ratio_based for distributed tracing
- * sampler configuration
- *
- * @param {string} selectedSampler - The selected sampler key
- * @param {object} samplerConfig - The sampler configuration object
- * @returns {boolean} true if it's a trace_id_ratio_based config
- */
-Config.prototype._isTraceIdRatioBasedConfig = function _isTraceIdRatioBasedConfig(selectedSampler, samplerConfig) {
-  const samplers = ['root', 'remote_parent_sampled', 'remote_parent_not_sampled']
-
-  return samplers.includes(selectedSampler) &&
-   typeof samplerConfig[selectedSampler] === 'object' &&
-    'trace_id_ratio_based' in samplerConfig[selectedSampler]
-}
-
 /**
  * Some values should be picked up only if they're not otherwise set, like
  * the Windows / Azure application name. Don't set it if there's already
@@ -1214,53 +1167,6 @@ function setFromEnv({ config, key, envVar, formatter, paths }) {
   }
 }
 
-/**
- * Assigns the value of the distributed tracing sampler env var as an trace_id_ratio_based
- * object to the sampler in the config.
- *
- * @param {object} params object passed to fn
- * @param {string} params.key key of the sampler
- * Example: 'root' or 'remote_parent_sampled'
- * @param {object} params.value value of the sampler
- * Example: { default: 'default', formatter: someFunc, trace_id_ratio_based: {ratio} }
- * @param {object} params.config agent config
- * @param {Array} params.paths list of leaf nodes leading to the sampling configuration value
- * Example: ['distributed_tracing', 'sampler']
- */
-function setTraceIDRatioSampler({ key, value, config, paths }) {
-  // trace id ratio based sampler is nested in leaf nodes under distributed_tracing > samplers > key
-  // so don't continue if path is empty
-  if (paths.length === 0) {
-    return
-  }
-
-  const samplers = ['root', 'remote_parent_sampled', 'remote_parent_not_sampled']
-  if (samplers.includes(key) && paths[paths.length - 1] === 'sampler') {
-    // config.distributed_tracing.sampler.[TYPE OF SAMPLER] needs to be set to trace_id_ratio_based
-    // in order to continue
-    if (config.distributed_tracing.sampler[key] !== 'trace_id_ratio_based') {
-      return
-    }
-
-    // set the trace id based ratio
-    const envVar = value.trace_id_ratio_based.ratio.env
-    const formatter = value.trace_id_ratio_based.ratio.formatter
-    const setting = process.env[envVar]
-    if (setting) {
-      const formattedSetting = formatter(setting)
-      config.distributed_tracing.sampler[key] = {
-        trace_id_ratio_based: {
-          ratio: formattedSetting
-        }
-      }
-      logger.trace('Setting %s environment variable', envVar)
-    } else {
-      logger.error('Not setting %s environment variable. Setting sampler root to default.', envVar)
-      config.distributed_tracing.sampler.root = 'default'
-    }
-  }
-}
-
 /**
  * Recursively visit the nodes of the config definition and look for environment variable names, overriding any configuration values that are found.
  *
@@ -1304,11 +1210,12 @@ Config.prototype._fromEnvironment = function _fromEnvironment(
       // since sampler was set to a string but now has to be converted to an object.
       // This is called here because we need set the sampler to a value first in config before setting
       // trace id ratio sampler (if the user set that)
-      setTraceIDRatioSampler({
+      setTraceIdRatioSamplerFromEnv({
         key,
-        value,
         config,
-        paths
+        paths,
+        logger,
+        setNestedKey
       })
       continue
     }

package/lib/config/samplers.js

@@ -0,0 +1,196 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const { allowList, float } = require('./formatters')
+
+/**
+ * This configuration is currently the same for `distributed_tracing.sampler`,
+ * `distributed_tracing.sampler.full_granularity` and `distributed_tracing.sampler.partial_granularity`
+ * Note: This also just defines the outer structure.  These values are mixed data types. Most of the time
+ * it is just a string. But if you want to use the `trace_id_ratio_based` sampler, then you need to
+ * provide an object with a `ratio` property. All of that mapping is done in `lib/config/index.js`
+ * This is done to allow compatibility with how OpenTelemetry sets their samplers and be backwards compatible as well.
+ */
+const config = {
+  /**
+   * Example setting root sampler via config to a string value -
+   *  root: 'always_on'
+   *
+   * Example setting root sampler via config to trace id ratio based -
+   * root: {
+   *   trace_id_ratio_based: {
+   *    ratio: 0.5
+   *   }
+   * }
+   */
+  root: {
+    formatter: allowList.bind(null, ['trace_id_ratio_based', 'adaptive', 'always_on', 'always_off', 'default']),
+    default: 'default',
+  },
+
+  /**
+   * When set to `always_on`, the sampled flag in the `traceparent` header
+   * being set to "true" will result in the local transaction being sampled
+   * with a priority value of "2". When set to `always_off`, the local
+   * transaction will never be sampled. At the default setting, the sampling
+   * decision will be determined according to the normal algorithm.
+   *
+   * This setting takes precedence over the `remote_parent_not_sampled`
+   * setting.
+   */
+  remote_parent_sampled: {
+    formatter: allowList.bind(null, ['trace_id_ratio_based', 'adaptive', 'always_on', 'always_off', 'default']),
+    default: 'default',
+  },
+
+  /**
+   * When set to `always_on`, the local transaction will be sampled with a
+   * priority of "2".
+   * When set to `always_off`, the local transaction will never be sampled.
+   * At the default setting, the sampling decision will be determined
+   * according to the normal algorithm.
+   *
+   * This setting only affects decisions when the traceparent sampled flag
+   * is set to 0.
+   */
+  remote_parent_not_sampled: {
+    formatter: allowList.bind(null, ['trace_id_ratio_based', 'adaptive', 'always_on', 'always_off', 'default']),
+    default: 'default',
+  }
+}
+
+/**
+ * Builds the trace_id_ratio_based for distributed tracing sampler configuration structure
+ *
+ * @param {object} params to function
+ * @param {object} params.config - The full configuration object
+ * @param {string} params.key - The configuration key being processed
+ * @param {object} params.incomingConfig The internal configuration object being modified
+ * @param {Logger} params.logger - The logger instance
+ */
+function buildTraceIdRatioSamplers({ config, key, incomingConfig, logger }) {
+  if (!isValidDTSampler(key)) {
+    return
+  }
+
+  const samplerConfig = config[key]
+  const samplers = Object.keys(samplerConfig)
+
+  // user can set multiple samplers
+  for (const sampler of samplers) {
+    if (isTraceIdRatioBasedConfig(sampler, samplerConfig)) {
+      const ratioValue = samplerConfig[sampler].trace_id_ratio_based.ratio
+      if (ratioValue) {
+        incomingConfig[key][sampler] = {
+          trace_id_ratio_based: {
+            ratio: ratioValue
+          }
+        }
+        logger.trace('Setting trace_id_ratio_based.ratio on %s.%s', key, sampler)
+      } else {
+        logger.trace('Not setting trace_id_ratio_based on %s.%s as ratio value is not present.', key, sampler)
+      }
+    }
+  }
+}
+
+/**
+ * Checks if the external config contains a trace_id_ratio_based for distributed tracing
+ * sampler configuration
+ *
+ * @param {string} sampler - The selected sampler key
+ * @param {object} samplerConfig - The sampler configuration object
+ * @returns {boolean} true if it's a trace_id_ratio_based config
+ */
+function isTraceIdRatioBasedConfig(sampler, samplerConfig) {
+  return isValidDTSamplerType(sampler) &&
+   typeof samplerConfig[sampler] === 'object' &&
+    'trace_id_ratio_based' in samplerConfig[sampler]
+}
+
+/**
+ * Check if the sampler is a valid value of either 'sampler', 'full_granularity', or 'partial_granularity'
+ * @param {string} sampler - The sampler key to validate
+ * @returns {boolean} true if valid, false otherwise
+ */
+function isValidDTSampler(sampler) {
+  return ['sampler', 'full_granularity', 'partial_granularity'].includes(sampler)
+}
+
+/**
+ * Check if the sampler type is a valid value of either 'root', 'remote_parent_sampled', or 'remote_parent_not_sampled'.
+ * @param {string} samplerType - The sampler type to validate
+ * @returns {boolean} true if valid, false otherwise
+ */
+function isValidDTSamplerType(samplerType) {
+  return ['root', 'remote_parent_sampled', 'remote_parent_not_sampled'].includes(samplerType)
+}
+
+/**
+ * Assigns the value of the distributed tracing samplers env var as an trace_id_ratio_based
+ * object to the sampler in the config.
+ *
+ * @param {object} params object passed to fn
+ * @param {string} params.key key of the sampler
+ * Example: 'root' or 'remote_parent_sampled'
+ * @param {object} params.config agent config
+ * @param {Array} params.paths list of leaf nodes leading to the sampling configuration value
+ * Example: ['distributed_tracing', 'sampler']
+ * @param {Function} params.setNestedKey function to set nested key in config
+ * @param {Logger} params.logger logger instance
+ */
+function setTraceIdRatioSamplerFromEnv({ key, config, paths, setNestedKey, logger }) {
+  // trace id ratio based sampler is nested in leaf nodes under distributed_tracing > samplers > key
+  // so don't continue if path is empty
+  if (paths.length === 0) {
+    return
+  }
+
+  const lastPath = paths[paths.length - 1]
+  if (isValidDTSampler(lastPath) && isValidDTSamplerType(key)) {
+    // Get the value of `config.distributed_tracing.sampler[key]` or `config.distributed_tracing.sampler.full_granularity[key]` or `config.distributed_tracing.sampler.partial_granularity[key]`
+    const nestedValue = getNestedValue(config, [...paths, key])
+    if (nestedValue !== 'trace_id_ratio_based') {
+      return
+    }
+
+    // set the trace id based ratio
+    const envVar = `NEW_RELIC_${[...paths, key, 'trace_id_ratio_based', 'ratio'].join('_').toUpperCase()}`
+    const setting = process.env[envVar]
+    if (setting) {
+      const formattedSetting = float(setting)
+      setNestedKey(config, [...paths, key], { trace_id_ratio_based: { ratio: formattedSetting } })
+      logger.trace('Setting %s environment variable to %s', envVar, formattedSetting)
+    } else {
+      logger.trace('Not setting %s environment variable. Setting %s.%s to `default`', envVar, paths.join('.'), key)
+      setNestedKey(config, [...paths, key], 'default')
+    }
+  }
+}
+/**
+ * Retrieves a value from a nested object by providing the list of parent keys.
+ * @param {object} obj object to assign value to
+ * @param {Array} keys list of parent keys
+ * @returns {*} value of the nested object key
+ */
+function getNestedValue(obj, keys) {
+  const len = keys.length
+  for (let i = 0; i < len - 1; i++) {
+    const elem = keys[i]
+    if (!obj[elem]) {
+      obj[elem] = {}
+    }
+
+    obj = obj[elem]
+  }
+  return obj[keys[len - 1]]
+}
+
+module.exports = {
+  config,
+  buildTraceIdRatioSamplers,
+  setTraceIdRatioSamplerFromEnv
+}

package/lib/subscribers/express/use.js

@@ -14,32 +14,83 @@ class ExpressUseSubscriber extends ExpressSubscriber {
 
   handler(data) {
     const { arguments: args } = data
-    let [route, fn] = args
-    let fnIndex = 1
-    let method = null
-    if (typeof route === 'function') {
-      fn = route
-      route = null
-      fnIndex = 0
-    }
-    let segmentName = null
+    const route = this.routeParser(args[0])
     // sometimes route is undefined, default to `/` for segmentName only
     const routeName = route || '/'
-    // Pre v5 these were marked as `lazyrouter`
-    // check for both
-    if (fn.lazyrouter || fn.name === 'mounted_app') {
-      segmentName = `${this.wrapper.system}/Mounted App: ${routeName}`
-    } else if (fn.stack) {
-      segmentName = `${this.wrapper.system}/Router: ${routeName}`
-      method = 'handle'
+    this.wrapAllMiddleware({
+      middlewares: args,
+      route,
+      routeName
+    })
+  }
+
+  /**
+   * Iterates over all arguments passed to `.use` and wraps any middleware functions
+   * They can be:
+   *  1. single middleware
+   *  2. series of middleware
+   *  3. array of middleware
+   *  4. combination of any mentioned above
+   *
+   * @param {object} params to function
+   * @param {Array} params.middlewares array of middleware to wrap
+   * @param {string|null} params.route route defined in `.use`
+   * @param {string} params.routeName route name for segment naming
+   */
+  wrapAllMiddleware({ middlewares, route, routeName }) {
+    for (let i = 0; i < middlewares.length; i++) {
+      const middleware = middlewares[i]
+      if (Array.isArray(middleware)) {
+        this.wrapAllMiddleware({ middlewares: middleware, route })
+        continue
+      }
+
+      // we only want to wrap functions
+      // This is the route definition not middleware
+      if (typeof middleware !== 'function') {
+        continue
+      }
+
+      let segmentName = null
+      let method = null
+      // Pre v5 these were marked as `lazyrouter`
+      // check for both
+      if (middleware?.lazyrouter || middleware?.name === 'mounted_app') {
+        segmentName = `${this.wrapper.system}/Mounted App: ${routeName}`
+      } else if (middleware?.stack) {
+        segmentName = `${this.wrapper.system}/Router: ${routeName}`
+        method = 'handle'
+      }
+
+      const wrappedMw = this.wrapper.wrap({
+        handler: middleware[method] ?? middleware,
+        route,
+        segmentName
+      })
+      if (method) {
+        middlewares[i][method] = wrappedMw
+      } else {
+        middlewares[i] = wrappedMw
+      }
     }
+  }
 
-    const wrappedFn = this.wrapper.wrap({ handler: fn[method] ?? fn, route, segmentName })
-    if (method) {
-      data.arguments[fnIndex][method] = wrappedFn
-    } else {
-      data.arguments[fnIndex] = wrappedFn
+  /**
+   * Handles extracting the route from a `.use` method.
+   * If a route is not defined it defaults to `null`
+   *
+   * @param {*} route first arg passed to `.use`
+   * @returns {*} route or null
+   */
+  routeParser(route) {
+    if (route instanceof RegExp) {
+      return `/${route.source}/`
+    } else if (typeof route === 'string') {
+      return route
+    } else if (Array.isArray(route) && typeof route[0] !== 'function') {
+      return route.join(',')
     }
+    return null
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "13.6.5",
+  "version": "13.6.6",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [