newrelic 13.3.3 → 13.5.0

package/lib/shimmer.js

@@ -18,14 +18,15 @@ const { nrEsmProxy } = require('./symbols')
 const isAbsolutePath = require('./util/is-absolute-path')
 const InstrumentationDescriptor = require('./instrumentation-descriptor')
 const InstrumentationTracker = require('./instrumentation-tracker')
-let pkgsToHook = []
-
 const NAMES = require('./metrics/names')
+const INSTRUMENTATION_TRACKING_PREFIX = NAMES.FEATURES.INSTRUMENTATION.ON_REQUIRE
 const symbols = require('./symbols')
-const { unsubscribe } = require('./instrumentation/undici')
 const subscriptions = require('./subscriber-configs')
 const createSubscriberConfigs = require('./subscribers/create-config')
 const ModulePatch = require('@apm-js-collab/tracing-hooks')
+const getPackageVersion = require('./util/get-package-version')
+const trackingPkgs = require('./tracking-packages')
+let pkgsToHook = []
 
 /**
  * Unwrapping is only likely to be used by test code, and is a fairly drastic
@@ -280,7 +281,6 @@ const shimmer = (module.exports = {
    */
   registerCoreInstrumentation(agent) {
     instrumentProcessMethods(agent)
-    instrumentUndiciFetch(agent)
 
     // Instrument each of the core modules.
     for (const [mojule, core] of Object.entries(CORE_INSTRUMENTATION)) {
@@ -311,6 +311,9 @@ const shimmer = (module.exports = {
   },
 
   registerHooks(agent) {
+    // add the packages from the subscriber based instrumentation
+    // this is only added to add tracking metrics
+    pkgsToHook.push(...Object.keys(subscriptions), ...trackingPkgs)
     this._ritm = new Hook(pkgsToHook, function onHook(exports, name, basedir) {
       return _postLoad(agent, exports, name, basedir)
     })
@@ -336,7 +339,6 @@ const shimmer = (module.exports = {
       // `@opentelemetry` packages for slim builds.
       require('./otel/setup').teardownOtel(agent)
     }
-    unsubscribe()
     if (this._subscribers) {
       shimmer.teardownSubscribers()
     }
@@ -492,30 +494,6 @@ const shimmer = (module.exports = {
     // previously it would just call instrumentation
     // and not check the result
     return returnModule ? result : shimmer.isInstrumented(moduleName, resolvedName)
-  },
-
-  /**
-   * Gets the version of a given package by parsing it from package.json
-   *
-   * @param {string} moduleName name of module
-   * @returns {string} version, defaults to Node.js version when it cannot parse
-   */
-  getPackageVersion(moduleName) {
-    try {
-      const trackedItems = shimmer.registeredInstrumentations.getAllByName(moduleName)
-      if (trackedItems === undefined) {
-        throw Error(`no tracked items for module '${moduleName}'`)
-      }
-      const item = trackedItems.find((item) => item.instrumentation.resolvedName !== undefined)
-      if (item === undefined) {
-        return process.version
-      }
-      const pkg = require(path.resolve(item.instrumentation.resolvedName, 'package.json'))
-      return pkg.version
-    } catch (err) {
-      logger.debug('Failed to get version for `%s`, reason: %s', moduleName, err.message)
-      return process.version
-    }
   }
 })
 
@@ -539,16 +517,16 @@ function applyDebugState(shim, nodule, inEsm) {
  * initialization function that takes the agent and the module to be
  * instrumented.
  *
- * @param {object} agent NR agent
- * @param {object} nodule Class or module containing the function to wrap.
- * @param {string} moduleName name of module
- * @param {string} resolvedName fully qualified path to module
- * @param {boolean} esmResolver indicates if it came from esm loader
+ * @param {object} params to function
+ * @param {object} params.agent NR agent
+ * @param {object} params.nodule Class or module containing the function to wrap.
+ * @param {string} params.moduleName name of module
+ * @param {string} params.resolvedName fully qualified path to module
+ * @param {boolean} params.esmResolver indicates if it came from esm loader
+ * @param {string} params.pkgVersion version of package loading instrumentation
  * @returns {object|undefined} returns exported module unless already instrumented
  */
-function instrumentPostLoad(agent, nodule, moduleName, resolvedName, esmResolver) {
-  // default to Node.js version, this occurs for core libraries
-  const pkgVersion = shimmer.getPackageVersion(moduleName)
+function instrumentPostLoad({ agent, nodule, moduleName, resolvedName, pkgVersion, esmResolver }) {
   const trackedInstrumentations = shimmer.registeredInstrumentations.getAllByName(moduleName)
   trackedInstrumentations.forEach((trackedInstrumentation) => {
     const isInstrumented = trackedInstrumentation.meta.instrumented === true
@@ -571,16 +549,6 @@ function instrumentPostLoad(agent, nodule, moduleName, resolvedName, esmResolver
     })
 
     applyDebugState(shim, resolvedNodule, esmResolver)
-    trackInstrumentationUsage(agent, shim, moduleName, NAMES.FEATURES.INSTRUMENTATION.ON_REQUIRE)
-
-    // Tracking instrumentation is only used to add the supportability metrics
-    // that occur directly above this.  No reason to attempt to load instrumentation
-    // as it does not exist.
-    if (instrumentation.type === InstrumentationDescriptor.TYPE_TRACKING) {
-      shimmer.registeredInstrumentations.setHookSuccess(trackedInstrumentation)
-      return
-    }
-
     nodule = loadInstrumentation({
       shim,
       resolvedNodule,
@@ -722,7 +690,7 @@ function _firstPartyInstrumentation(agent, fileName, shim, nodule, moduleName) {
  * @param {string} name The simple name used to load the module.
  * @param {string} resolvedName The full file system path to the module.
  * @param {object} [esmResolver] If the module was loaded via ESM
- * @returns {*|Object|undefined} The instrumented module, or the original
+ * @returns {* | object | undefined} The instrumented module, or the original
  * @private
  */
 function _postLoad(agent, nodule, name, resolvedName, esmResolver) {
@@ -733,21 +701,36 @@ function _postLoad(agent, nodule, name, resolvedName, esmResolver) {
     registeredInstrumentations.length &&
     registeredInstrumentations.filter((ri) => ri.instrumentation.onRequire).length
 
+  if (resolvedName === undefined && isAbsolutePath(name) === true) {
+    // `resolvedName` comes from the `basedir` returned by the `Hook`
+    // function from import-in-the-middle or require-in-the-middle. At least
+    // with IITM, if the path string does not include a `node_modules` then
+    // `basedir` will be `undefined`. But we need it for our instrumentation
+    // to work. We'll only reach this situation if the module being
+    // instrumented has an `absolutePath` defined. So we detect that and
+    // assign appropriately.
+    resolvedName = name
+  }
+
+  let pkgVersion = null
+  // check for resolvedName
+  // core node libs lack this so we do not need to obtain package version
+  if (resolvedName) {
+    pkgVersion = getPackageVersion(resolvedName)
+  }
+  // this currently works because we add subscriber based instrumentation
+  // and packages we want to track that are not instrumented to the `pkgsToHook`
+  // array that get passed to require-in-the-middle and import-in-the-middle
+  // if/once we removed reliance on those packages, we will have to subscribe to the
+  // https://nodejs.org/api/diagnostics_channel.html#modules channels to see when
+  // a module is required/imported and increment the metrics there
+  trackInstrumentationUsage(agent, name, pkgVersion)
+
   // Check if this is a known instrumentation and then run it.
   if (hasPostLoadInstrumentation) {
-    if (resolvedName === undefined && isAbsolutePath(name) === true) {
-      // `resolvedName` comes from the `basedir` returned by the `Hook`
-      // function from import-in-the-middle or require-in-the-middle. At least
-      // with IITM, if the path string does not include a `node_modules` then
-      // `basedir` will be `undefined`. But we need it for our instrumentation
-      // to work. We'll only reach this situation if the module being
-      // instrumented has an `absolutePath` defined. So we detect that and
-      // assign appropriately.
-      resolvedName = name
-    }
     shimmer.registeredInstrumentations.setResolvedName(simpleName, resolvedName)
     logger.trace('Instrumenting %s with onRequire (module loaded) hook.', name)
-    return instrumentPostLoad(agent, nodule, simpleName, resolvedName, esmResolver)
+    return instrumentPostLoad({ agent, nodule, moduleName: simpleName, resolvedName, pkgVersion, esmResolver })
   }
 
   return nodule
@@ -779,18 +762,23 @@ function hasValidRegisterOptions(opts) {
 /**
  * Adds metrics to indicate instrumentation was used for a particular module and
  * what major version the module was at, if possible.
- *
- * @param {*} agent The agent instance.
- * @param {*} shim The instance of the shim used to instrument the module.
+ * Creates the `Supportability/Features/Instrumentation/OnRequire/<packageName>`
+ * and `Supportability/Features/Instrumentation/OnRequire/<packageName>/Version/<majorVersion>`
+ * metrics to track the usage of an instrumented package.
+ * @param {Agent} agent The agent instance.
  * @param {string} moduleName The name of the required module.
- * @param {string} metricPrefix Support metric prefix to prepend to the metrics. Will indicate onRequire
- *
- * from NAMES.FEATURES.INSTRUMENTATION.
+ * @param {string} version version of package
  */
-function trackInstrumentationUsage(agent, shim, moduleName, metricPrefix) {
+function trackInstrumentationUsage(agent, moduleName, version) {
   try {
-    const version = tryGetVersion(shim)
-    const instrumentationMetricName = `${metricPrefix}/${moduleName}`
+    // only save the package name not a file within package
+    if (moduleName.startsWith('@')) {
+      const split = moduleName.split('/')
+      moduleName = `${split[0]}/${split[1]}`
+    } else {
+      moduleName = moduleName.split('/')[0]
+    }
+    const instrumentationMetricName = `${INSTRUMENTATION_TRACKING_PREFIX}/${moduleName}`
 
     agent.metrics.getOrCreateMetric(instrumentationMetricName).incrementCallCount()
 
@@ -805,16 +793,6 @@ function trackInstrumentationUsage(agent, shim, moduleName, metricPrefix) {
   }
 }
 
-function tryGetVersion(shim) {
-  // Indicates it is a built-in where the version is not useful as
-  // it is `process.version`
-  if (shim._moduleRoot === '.') {
-    return
-  }
-
-  return shim.pkgVersion
-}
-
 /**
  * Loads the instrumentation with `./lib/instrumentation/core/globals.js`
  * This instrumentation cannot be disabled by config at the moment as it just
@@ -829,31 +807,6 @@ function instrumentProcessMethods(agent) {
   _firstPartyInstrumentation(agent, globalsFilepath, globalShim, global, 'globals')
 }
 
-/**
- * Checks if undici/fetch instrumentation is enabled.
- * If so, it loads the diagnostics_channel hooks to instrument outbound
- * undici/fetch calls.
- * Since this just registers subscriptions to diagnostics_channel events from undici,
- * we register this as core and it'll work for both fetch and undici
- *
- * @param {Agent} agent the agent instance
- */
-function instrumentUndiciFetch(agent) {
-  if (agent.config.instrumentation?.undici.enabled === false) {
-    logger.warn('Instrumentation for undici/fetch has been disabled via `config.instrumentation.undici.enabled`. Not instrumenting package')
-    return
-  }
-
-  const undiciPath = path.join(__dirname, 'instrumentation', 'undici.js')
-  const undiciShim = shims.createShimFromType({
-    type: InstrumentationDescriptor.TYPE_TRANSACTION,
-    agent,
-    moduleName: 'undici',
-    resolvedName: '.'
-  })
-  _firstPartyInstrumentation(agent, undiciPath, undiciShim)
-}
-
 function instrumentDomain(agent) {
   if (agent.config.instrumentation?.domain.enabled === false) {
     logger.warn('Instrumentation for domain has been disabled via `config.instrumentation.domain.enabled`. Not instrumenting package')

package/lib/spans/span-context.js

@@ -41,7 +41,7 @@ class SpanContext {
    *
    * Last error wins.
    *
-   * @param details
+   * @param {object} details error details
    */
   setError(details) {
     this.hasError = true

package/lib/spans/span-event-aggregator.js

@@ -87,7 +87,7 @@ class SpanEventAggregator extends EventAggregator {
   /**
    * Reconfigure the `SpanEventAggregator` based on values from server
    *
-   * @param {Config} config
+   * @param {Config} config the config to reconfigure with
    */
   reconfigure(config) {
     super.reconfigure(config)
@@ -105,7 +105,7 @@ class SpanEventAggregator extends EventAggregator {
    * When no `span_event_harvest_config` has been received from the server, applies an
    * agent-defined fallback maximum to protect against collecting and sending too many spans.
    *
-   * @param {Config} config
+   * @param {Config} config the config to check
    */
   _getValidSpanConfiguration(config) {
     const spanHarvestConfig = config.span_event_harvest_config

package/lib/spans/span-event.js

@@ -89,11 +89,12 @@ class SpanEvent {
    * The constructed span event will contain extra data depending on the
    * category of the segment.
    *
-   * @param {TraceSegment} segment segment to turn into a span event.
-   * @param {Transaction} transaction active transaction
-   * @param {?string} [parentId] ID of the segment's parent.
-   * @param {boolean} isRoot if segment is root segment
-   * @param {boolean} inProcessSpans if the segment is in-process, create span
+   * @param {object} params params object
+   * @param {TraceSegment} params.segment segment to turn into a span event.
+   * @param {Transaction} params.transaction active transaction
+   * @param {?string} [params.parentId] ID of the segment's parent.
+   * @param {boolean} [params.isRoot] if segment is root segment; defaults to `false`
+   * @param {boolean} params.inProcessSpans if the segment is in-process, create span
    * @returns {SpanEvent} The constructed event.
    */
   static fromSegment({ segment, transaction, parentId = null, isRoot = false, inProcessSpans }) {

package/lib/spans/streaming-span-attributes.js

@@ -46,7 +46,7 @@ class StreamingSpanAttributes {
    *
    * Does not apply filtering/truncation.
    *
-   * @param {object} [attributes]
+   * @param {object} [attributes] Attributes to add.
    * @param {string} [attributes.key] Name of the attribute to be stored.
    * @param {string|boolean|number} [attributes.value] Value of the attribute to be stored.
    */

package/lib/spans/streaming-span-event-aggregator.js

@@ -101,23 +101,25 @@ class StreamingSpanEventAggregator extends Aggregator {
    *
    * @param {object} params to function
    * @param {TraceSegment} params.segment segment to add.
-   * @param {string} [parms.parentId] GUID of the parent span.
    * @param {Transaction} params.transaction active transaction
+   * @param {string} [params.parentId] GUID of the parent span.
    * @param {boolean} params.isRoot is segment root segment
-   * @param params.parentId
    * @returns {boolean} True if the segment was added, or false if it was discarded.
    */
   addSegment({ segment, transaction, parentId, isRoot }) {
     if (!this.started) {
       logger.trace('Aggregator has not yet started, dropping span (%s).', segment.name)
-      return
+      return false
     }
 
     const span = StreamingSpanEvent.fromSegment({ segment, transaction, parentId, isRoot, inProcessSpans: this.inProcessSpans })
 
     if (span) {
       this.stream.write(span)
+      return true
     }
+
+    return false
   }
 
   reconfigure(config) {

package/lib/spans/streaming-span-event.js

@@ -224,7 +224,7 @@ class StreamingHttpSpanEvent extends StreamingSpanEvent {
  * Currently designed to be sent over grpc via the v1.proto definition.
  *
  * @private
- * @class.
+ * @class
  */
 class StreamingDatastoreSpanEvent extends StreamingSpanEvent {
   /**

package/lib/stats/index.js

@@ -84,7 +84,7 @@ Stats.prototype.incrementCallCount = function incrementCallCount(count) {
 /**
  * Fold another summary's statistics into this one.
  *
- * @param other
+ * @param {Stats} other other Stats instance
  */
 Stats.prototype.merge = function merge(other) {
   if (other.count && !other.callCount) {

package/lib/subscriber-configs.js

@@ -8,11 +8,16 @@
 // The expected export of these files is:
 // 'package-name': [ { path: 'subscriberPath', instrumentations: [] }, ... ]
 const subscribers = {
+  ...require('./subscribers/amqplib/config'),
+  ...require('./subscribers/cassandra-driver/config'),
   ...require('./subscribers/elasticsearch/config'),
+  ...require('./subscribers/fastify/config'),
   ...require('./subscribers/ioredis/config'),
   ...require('./subscribers/mcp-sdk/config'),
   ...require('./subscribers/openai/config'),
-  ...require('./subscribers/pino/config')
+  ...require('./subscribers/pino/config'),
+  ...require('./subscribers/pg/config'),
+  ...require('./subscribers/undici/config')
 }
 
 module.exports = subscribers

package/lib/subscribers/amqplib/accept-message.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const PropagationSubscriber = require('../propagation')
+
+class AcceptMessageSubscriber extends PropagationSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: 'amqplib', channelName: 'nr_acceptMessage', callback: 0 })
+  }
+}
+
+module.exports = AcceptMessageSubscriber

package/lib/subscribers/amqplib/callback-model.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const MetaSubscriber = require('../meta-subscriber')
+const CHANNEL_METHODS = [
+  'cb_close',
+  'cb_open',
+  'cb_assertQueue',
+  'cb_checkQueue',
+  'cb_deleteQueue',
+  'cb_bindQueue',
+  'nr_unbindQueue',
+  'cb_assertExchange',
+  'cb_checkExchange',
+  'cb_deleteExchange',
+  'cb_bindExchange',
+  'cb_unbindExchange',
+  'cb_cancel',
+  'cb_prefetch',
+  'cb_recover'
+]
+
+class ChannelModelSubscriber extends MetaSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: 'amqplib', channelName: 'channelModel', channels: CHANNEL_METHODS, events: ['asyncEnd'], callback: -1 })
+  }
+
+  handler(_data, ctx) {
+    const [, name] = this.channelName.split('_')
+    return this.createSegment({
+      name: `Channel#${name}`,
+      ctx
+    })
+  }
+}
+
+module.exports = ChannelModelSubscriber

package/lib/subscribers/amqplib/channel-model.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const MetaSubscriber = require('../meta-subscriber')
+const CHANNEL_METHODS = [
+  'nr_close',
+  'nr_open',
+  'nr_assertQueue',
+  'nr_checkQueue',
+  'nr_deleteQueue',
+  'nr_bindQueue',
+  'nr_unbindQueue',
+  'nr_assertExchange',
+  'nr_checkExchange',
+  'nr_deleteExchange',
+  'nr_bindExchange',
+  'nr_unbindExchange',
+  'nr_cancel',
+  'nr_prefetch',
+  'nr_recover'
+]
+
+class ChannelModelSubscriber extends MetaSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: 'amqplib', channelName: 'channelModel', channels: CHANNEL_METHODS, events: ['asyncEnd'] })
+  }
+
+  handler(data, ctx) {
+    const [, name] = this.channelName.split('_')
+    return this.createSegment({
+      name: `Channel#${name}`,
+      ctx
+    })
+  }
+}
+
+module.exports = ChannelModelSubscriber