newrelic 13.9.1 → 13.10.0

package/NEWS.md

@@ -1,14 +1,58 @@
-### v13.9.1 (2026-01-12)
-
-#### Bug fixes
-
-* Updated `getHostnameSafe` to invalidate the cache is trying to assign the host based on the gcp cloud run id ([#3650](https://github.com/newrelic/node-newrelic/pull/3650)) ([d395c76](https://github.com/newrelic/node-newrelic/commit/d395c76d5612a7e562efa1a807c35e805a38ab14))
-* Updated logic to properly assign content and role in LangChain chat completion messages ([#3638](https://github.com/newrelic/node-newrelic/pull/3638)) ([407bcb6](https://github.com/newrelic/node-newrelic/commit/407bcb66b7e3be1b6f1d28bcf6e3b022a7022c96))
-
-#### Documentation
-
-* Updated compatibility report ([#3643](https://github.com/newrelic/node-newrelic/pull/3643)) ([8929ab3](https://github.com/newrelic/node-newrelic/commit/8929ab3ae6cc28edbef4bee41a2084154361d6e0))
-
+### v13.10.0 (2026-01-20)
+
+#### Features
+
+* Add `timestamp` to OpenAI input `LlmChatCompletionMessage`s ([#3657](https://github.com/newrelic/node-newrelic/pull/3657)) ([099e20e](https://github.com/newrelic/node-newrelic/commit/099e20eaa380615b7e8aae7eaa12e2754a931041))
+* Added reduced tracing mode for span links ([#3649](https://github.com/newrelic/node-newrelic/pull/3649)) ([2414331](https://github.com/newrelic/node-newrelic/commit/24143313e2d894a5e11e42116f33ef4be18f2fb4))
+
+#### Bug fixes
+
+* Updated OpenAI instrumentation to properly parse headers when a call fails ([#3665](https://github.com/newrelic/node-newrelic/pull/3665)) ([641b7a8](https://github.com/newrelic/node-newrelic/commit/641b7a8c8015855d82574e8173cb6e9fd082b4a0))
+
+#### Documentation
+
+* Updated compatibility report ([#3669](https://github.com/newrelic/node-newrelic/pull/3669)) ([ec922ae](https://github.com/newrelic/node-newrelic/commit/ec922ae6b0cecfa4ecbce86a789c308d6876ecd7)) ([#3668](https://github.com/newrelic/node-newrelic/pull/3668)) ([85c601f](https://github.com/newrelic/node-newrelic/commit/85c601fe2eaaacd82c0abac81eba96ce6718f2f1)) ([#3663](https://github.com/newrelic/node-newrelic/pull/3663)) ([82b3ac8](https://github.com/newrelic/node-newrelic/commit/82b3ac8cf6f69d0609b7fbaaf8be2a35f6552485))
+
+#### Miscellaneous chores
+
+* Lazy load OTEL dependencies ([#3667](https://github.com/newrelic/node-newrelic/pull/3667)) ([0b0c764](https://github.com/newrelic/node-newrelic/commit/0b0c7647f3f0bc3093b9ffbf7596c1654ba6113d))
+* Record subscriber usage metric ([#3626](https://github.com/newrelic/node-newrelic/pull/3626)) ([5796574](https://github.com/newrelic/node-newrelic/commit/57965740acd053e6c99a88d861a876bcf2601c07))
+* Update `ai-support.json` ([#3666](https://github.com/newrelic/node-newrelic/pull/3666)) ([562b403](https://github.com/newrelic/node-newrelic/commit/562b403a3414430cdd0afab261d3d119d3d9b4db))
+* Updated OpenAI instrumentation to skip creating a `LlmChatCompletionMessage` for an outgoing tool call response ([#3655](https://github.com/newrelic/node-newrelic/pull/3655)) ([572c3a1](https://github.com/newrelic/node-newrelic/commit/572c3a1741ebd13d77d857c262b050aeb0c801fc))
+
+#### Tests
+
+* Updated mock response to avoid retries on OpenAI LangChain vectorstore calls ([#3664](https://github.com/newrelic/node-newrelic/pull/3664)) ([bc1faf3](https://github.com/newrelic/node-newrelic/commit/bc1faf30654d920e31ad4ddc205560e56b6c796c))
+
+### v13.9.2 (2026-01-14)
+
+#### Bug fixes
+
+* Updated message consumer subscribers to properly time the consumption actions ([#3660](https://github.com/newrelic/node-newrelic/pull/3660)) ([ef1b611](https://github.com/newrelic/node-newrelic/commit/ef1b611a7c3b45f5fc8d483661859c1595bbe4ab))
+
+#### Documentation
+
+* Updated compatibility report ([#3654](https://github.com/newrelic/node-newrelic/pull/3654)) ([ca16dae](https://github.com/newrelic/node-newrelic/commit/ca16daefe4da1c17253e165c68d198d607c72d0b))
+
+#### Miscellaneous chores
+
+* Update OTEL metrics test ([#3661](https://github.com/newrelic/node-newrelic/pull/3661)) ([ae84b62](https://github.com/newrelic/node-newrelic/commit/ae84b62a3c7ef753d4ace8836f38405b4cbbfd88))
+
+#### Tests
+
+* Added cross agent tests for sampler configuration and sampling rate scenarios ([#3648](https://github.com/newrelic/node-newrelic/pull/3648)) ([fa0e2d1](https://github.com/newrelic/node-newrelic/commit/fa0e2d1bd78051c7f716ebc65bd7f3842698103e))
+
+### v13.9.1 (2026-01-12)
+
+#### Bug fixes
+
+* Updated `getHostnameSafe` to invalidate the cache is trying to assign the host based on the gcp cloud run id ([#3650](https://github.com/newrelic/node-newrelic/pull/3650)) ([d395c76](https://github.com/newrelic/node-newrelic/commit/d395c76d5612a7e562efa1a807c35e805a38ab14))
+* Updated logic to properly assign content and role in LangChain chat completion messages ([#3638](https://github.com/newrelic/node-newrelic/pull/3638)) ([407bcb6](https://github.com/newrelic/node-newrelic/commit/407bcb66b7e3be1b6f1d28bcf6e3b022a7022c96))
+
+#### Documentation
+
+* Updated compatibility report ([#3643](https://github.com/newrelic/node-newrelic/pull/3643)) ([8929ab3](https://github.com/newrelic/node-newrelic/commit/8929ab3ae6cc28edbef4bee41a2084154361d6e0))
+
 ### v13.9.0 (2026-01-08)
 
 #### Features
@@ -8214,3 +8258,5 @@ Special thanks to Ryan Copley (@RyanCopley) for the contribution.
 
 
 
+
+

package/lib/llm-events/openai/chat-completion-message.js

@@ -26,13 +26,18 @@ module.exports = class LlmChatCompletionMessage extends LlmEvent {
     // Check if the given message is from the response.
     // The response object differs based on the API called.
     // If it's `responses.create`, we check against `response.output`.
-    // If it's `chat.completions.create` or langchain, we check against `response.choices`.
+    // If it's `chat.completions.create`, we check against `response.choices`.
     if (response?.object === 'response') {
       this.is_response = message.content === response?.output?.[0]?.content?.[0]?.text
     } else {
       this.is_response = message.content === response?.choices?.[0]?.message?.content
     }
 
+    // Spec 771: `timestamp` is only required for input/request messages.
+    if (this.is_response === false) {
+      this.timestamp = segment.timer.start
+    }
+
     // Assign content to the event.
     const content = message?.content
     if (agent.config.ai_monitoring.record_content.enabled === true) {

package/lib/metrics/names.js

@@ -353,7 +353,8 @@ const FEATURES = {
   SOURCE_MAPS: `${SUPPORTABILITY.FEATURES}/EnableSourceMaps`,
   CERTIFICATES: SUPPORTABILITY.FEATURES + '/Certificates',
   INSTRUMENTATION: {
-    ON_REQUIRE: SUPPORTABILITY.FEATURES + '/Instrumentation/OnRequire'
+    ON_REQUIRE: SUPPORTABILITY.FEATURES + '/Instrumentation/OnRequire',
+    SUBSCRIBER_USED: SUPPORTABILITY.FEATURES + '/Instrumentation/SubscriberUsed'
   }
 }
 

package/lib/otel/setup.js

@@ -5,16 +5,11 @@
 
 'use strict'
 
-const opentelemetry = require('@opentelemetry/api')
-
-const SetupLogs = require('./logs/index.js')
-const SetupMetrics = require('./metrics/index.js')
-const SetupTraces = require('./traces/index.js')
-const ContextManager = require('./context-manager')
-const TracePropagator = require('./trace-propagator')
+// The majority of dependencies in this module are lazy loaded in order to
+// limit the impact on memory usage. In general, the OTEL dependencies are
+// only loaded when they are needed, because they can have a significant
+// impact once loaded.
 const defaultLogger = require('../logger').child({ component: 'opentelemetry-bridge' })
-const createOtelLogger = require('./logger')
-const interceptSpanKey = require('./span-key-interceptor')
 
 const signals = []
 
@@ -26,6 +21,12 @@ function setupOtel(agent, logger = defaultLogger) {
     return
   }
 
+  const opentelemetry = require('@opentelemetry/api')
+  const ContextManager = require('./context-manager')
+  const TracePropagator = require('./trace-propagator')
+  const createOtelLogger = require('./logger')
+  const interceptSpanKey = require('./span-key-interceptor')
+
   // When bridge mode is enabled, our context manager must utilize the OTEL
   // context manager. Otherwise, traces within, e.g. logs, will not be
   // captured correctly. The internal OTEL logger also must be configured
@@ -37,6 +38,7 @@ function setupOtel(agent, logger = defaultLogger) {
   opentelemetry.propagation.setGlobalPropagator(new TracePropagator(agent))
 
   if (agent.config.opentelemetry.traces.enabled === true) {
+    const SetupTraces = require('./traces/index.js')
     const signal = new SetupTraces({ agent })
     signals.push(signal)
   } else {
@@ -47,6 +49,7 @@ function setupOtel(agent, logger = defaultLogger) {
   }
 
   if (agent.config.opentelemetry.metrics.enabled === true) {
+    const SetupMetrics = require('./metrics/index.js')
     const signal = new SetupMetrics({ agent })
     signals.push(signal)
   } else {
@@ -57,6 +60,7 @@ function setupOtel(agent, logger = defaultLogger) {
   }
 
   if (agent.config.opentelemetry.logs.enabled === true) {
+    const SetupLogs = require('./logs/index.js')
     const signal = new SetupLogs({ agent })
     signals.push(signal)
   } else {
@@ -68,7 +72,7 @@ function setupOtel(agent, logger = defaultLogger) {
     .incrementCallCount()
 }
 
-function teardownOtel(agent) {
+function teardownOtel(agent, { opentelemetry = require('@opentelemetry/api') } = {}) {
   if (agent?.config?.opentelemetry?.enabled !== true) {
     return
   }

package/lib/shimmer.js

@@ -306,7 +306,7 @@ 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)
+    Array.prototype.push.apply(pkgsToHook, trackingPkgs)
     this._ritm = new Hook(pkgsToHook, function onHook(exports, name, basedir) {
       return _postLoad(agent, exports, name, basedir)
     })

package/lib/subscribers/base.js

@@ -7,6 +7,8 @@
 // eslint-disable-next-line n/no-unsupported-features/node-builtins
 const { tracingChannel } = require('node:diagnostics_channel')
 const cat = require('#agentlib/util/cat.js')
+const recordSupportabilityMetric = require('./record-supportability-metric.js')
+
 // Used for the `traceCallback` work.
 // This can be removed when we add true support into orchestrion
 const makeCall = (fn) => (...args) => fn.call(...args)
@@ -28,38 +30,45 @@ const ArrayPrototypeSplice = makeCall(Array.prototype.splice)
 
 /**
  * @property {object} agent A New Relic Node.js agent instance.
- * @property {object} logger An agent logger instance.
+ * @property {TracingChannel} channel The tracing channel instance this subscriber will be monitoring.
+ * @property {string} channelName A unique name for the diagnostics channel
+ * that will be registered.
  * @property {object} config The agent configuration object.
+ * @property {string} id A unique identifier for the subscriber, combining the prefix, package
+ * name, and channel name.
+ * @property {object} logger An agent logger instance.
  * @property {string} packageName The name of the module being instrumented.
  * This is the same string one would pass to the `require` function.
- * @property {string} channelName A unique name for the diagnostics channel
- * that will be registered.
+ * @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[]} [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
  * event object. Possible event names are `start`, `end`, `asyncStart`,
  * `asyncEnd`, and `error`.
- *
- *  See {@link https://nodejs.org/api/diagnostics_channel.html#class-tracingchannel}
- * @property {boolean} [opaque=false] If true, any children segments will not be created.
+ * See {@link https://nodejs.org/api/diagnostics_channel.html#class-tracingchannel}
  * @property {boolean} [internal=false] If true, any children segments from the same library
  * will not be created.
+ * @property {boolean} [opaque=false] If true, any children segments will not be created.
  * @property {string} [prefix='orchestrion:'] String to prepend to diagnostics
  * channel event names. This provides a namespace for the events we are
  * injecting into a module.
- * @property {boolean} [requireActiveTx=true] If true, the subscriber will only handle events
- * when there is an active transaction.
  * @property {boolean} [propagateContext=false] If true, it will bind `asyncStart` to the store
  * and re-propagate the active context. It will also attach the `transaction` to the event in
  * `start.bindStore`. This is used for functions that queue async code and context is lost.
- * @property {string} id A unique identifier for the subscriber, combining the prefix, package
- * name, and channel name.
- * @property {TracingChannel} channel The tracing channel instance this subscriber will be monitoring.
- * @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 {boolean} [requireActiveTx=true] If true, the subscriber will only handle events
+ * when there is an active transaction.
+ * @property {object} [targetModuleMeta] Defines the target module's name and
+ * version string, i.e. is an object `{ name, version }`. This is only necessary
+ * when target instrumentation can surface an unexpected name for the
+ * `packageName` property. For example, `express` uses multiple modules to
+ * compose its core functionality. We want to track things under the `express`
+ * name, but `packageName` will be set to `router` is most cases.
  */
 class Subscriber {
+  #usageMetricRecorded = false
+
   /**
    * @param {SubscriberParams} params the subscriber constructor params
    */
@@ -234,6 +243,15 @@ class Subscriber {
      * @returns {Context} The context after processing the event
      */
     const handler = (data) => {
+      if (this.#usageMetricRecorded === false) {
+        recordSupportabilityMetric({
+          agent: this.agent,
+          moduleName: this.packageName,
+          moduleVersion: data.moduleVersion
+        })
+        this.#usageMetricRecorded = true
+      }
+
       // only wrap the callback if a subscriber has a callback property defined
       if (this.callback !== null) {
         this.traceCallback(this.callback, data)

package/lib/subscribers/dc-base.js

@@ -4,8 +4,11 @@
  */
 
 'use strict'
+
 // eslint-disable-next-line n/no-unsupported-features/node-builtins
 const dc = require('node:diagnostics_channel')
+const recordSupportabilityMetric = require('./record-supportability-metric.js')
+const resolvePackageVersion = require('./resolve-package-version.js')
 
 /**
  * The baseline parameters available to all subscribers.
@@ -15,6 +18,13 @@ const dc = require('node:diagnostics_channel')
  * @property {object} logger An agent logger instance.
  * @property {string} packageName The package name being instrumented.
  * This is what a developer would provide to the `require` function.
+ * @property {boolean} [skipUsageMetricRecording=false] When set to `true`, the
+ * instrumentation will not attempt to record the usage metric. This is useful
+ * when the module being instrumented is also being instrumented via the
+ * Orchestrion based subscriber system. It is much cheaper to record the metric
+ * via Orchestrion based subscribers than through this direct diagnostics
+ * channel method (Orchestrion provides the module version, whereas we have
+ * to perform expensive operations here to get the same information).
  */
 
 /**
@@ -34,19 +44,25 @@ const dc = require('node:diagnostics_channel')
  * This is the same string one would pass to the `require` function.
  */
 class Subscriber {
+  #usageMetricRecorded = false
+
   /**
    * @param {SubscriberParams} params to function
    */
-  constructor({ agent, logger, packageName }) {
+  constructor({ agent, logger, packageName, skipUsageMetricRecording = false }) {
     this.agent = agent
     this.logger = logger.child({ component: `${packageName}-subscriber` })
     this.config = agent.config
     this.id = packageName
+
+    if (skipUsageMetricRecording === true) {
+      this.#usageMetricRecorded = true
+    }
   }
 
   set channels(channels) {
     if (!Array.isArray(channels)) {
-      throw new Error('channels must be a collection of with propertiesof channel and hook')
+      throw new Error('channels must be a collection of objects with properties channel and hook')
     }
     this._channels = channels
   }
@@ -73,18 +89,43 @@ class Subscriber {
 
   subscribe() {
     for (let index = 0; index < this.channels.length; index++) {
+      const chan = this.channels[index]
       const { hook, channel } = this.channels[index]
       const boundHook = hook.bind(this)
-      dc.subscribe(channel, boundHook)
-      this.channels[index].boundHook = boundHook
+      chan.boundHook = boundHook
+      chan.eventHandler = (message, name) => {
+        this.#supportability()
+        boundHook(message, name)
+      }
+      dc.subscribe(channel, chan.eventHandler)
     }
   }
 
   unsubscribe() {
     for (let index = 0; index < this.channels.length; index++) {
-      const { channel, boundHook } = this.channels[index]
-      dc.unsubscribe(channel, boundHook)
+      const { channel, eventHandler } = this.channels[index]
+      dc.unsubscribe(channel, eventHandler)
+    }
+  }
+
+  /**
+   * Since this class subscribes to diagnostics channels natively published by
+   * target modules, we do not get the package metadata that Orchestrion
+   * provides in its channel events. So we have to try and find the package
+   * manifest and get the version out of it in order to record our
+   * supportability metric.
+   */
+  #supportability() {
+    if (this.#usageMetricRecorded === true) {
+      return
     }
+    const version = resolvePackageVersion(this.id)
+    recordSupportabilityMetric({
+      agent: this.agent,
+      moduleName: this.id,
+      moduleVersion: version
+    })
+    this.#usageMetricRecorded = true
   }
 }
 

package/lib/subscribers/fastify/index.js

@@ -10,7 +10,7 @@ const MiddlewareWrapper = require('../middleware-wrapper')
 
 class FastifyInitialization extends DcBase {
   constructor({ agent, logger }) {
-    super({ agent, logger, packageName: 'fastify' })
+    super({ agent, logger, packageName: 'fastify', skipUsageMetricRecording: true })
     this.channels = [
       { channel: initChannel, hook: this.handler }
     ]
@@ -24,7 +24,10 @@ class FastifyInitialization extends DcBase {
         return
       }
 
-      routeOptions.handler = self.wrapper.wrap({ handler: routeOptions.handler, route: routeOptions.path })
+      routeOptions.handler = self.wrapper.wrap({
+        handler: routeOptions.handler,
+        route: routeOptions.path
+      })
     })
   }
 }

package/lib/subscribers/message-consumer.js

@@ -105,7 +105,7 @@ class MessageConsumerSubscriber extends Subscriber {
    */
   asyncStart() {
     const ctx = this.agent.tracer.getContext()
-    const tx = ctx?.transaction
+    const tx = ctx.transaction
     tx.setPartialName(this.name)
     // Note: this is not using `Subscriber.createSegment`
     // this is because it enters the segment and returns a new ctx
@@ -117,6 +117,7 @@ class MessageConsumerSubscriber extends Subscriber {
       parent: tx.trace.root,
       transaction: tx
     })
+    tx.baseSegment.start()
 
     this.addConsumeParameters(tx)
 

package/lib/subscribers/openai/chat.js

@@ -37,13 +37,10 @@ class OpenAIChatCompletions extends OpenAISubscriber {
       return
     }
 
-    const segment = this.agent.tracer.createSegment({
+    return this.createSegment({
       name: OPENAI.COMPLETION,
-      parent: ctx.segment,
-      transaction: ctx.transaction
+      ctx
     })
-    const newCtx = ctx.enterSegment({ segment })
-    return newCtx
   }
 
   asyncEnd(data) {

package/lib/subscribers/openai/client.js

@@ -17,12 +17,18 @@ class OpenAIClientSubscriber extends OpenAISubscriber {
   }
 
   asyncEnd(data) {
-    const { result } = data
+    const { result, error } = data
     const ctx = this.agent.tracer.getContext()
     if (ctx?.segment) {
-      const headers = result?.response?.headers
-        ? Object.fromEntries(result.response.headers)
-        : { ...result?.headers }
+      const responseHeaders = result?.response?.headers
+      let headers = {}
+      if (responseHeaders) {
+        headers = Object.fromEntries(responseHeaders)
+      } else if (error?.headers) {
+        // In openai v5 they made error headers consistent with response headers
+        // they are now some custom class that can retrieve headers via `Object.fromEntries`
+        headers = error?.headers?.values ? Object.fromEntries(error.headers) : { ...error.headers }
+      }
       ctx.extras = { headers }
     }
   }

package/lib/subscribers/openai/embeddings.js

@@ -22,13 +22,10 @@ class OpenAIEmbeddings extends OpenAISubscriber {
       this.logger.debug('OpenAI instrumentation is disabled, not creating segment.')
       return
     }
-    const segment = this.agent.tracer.createSegment({
+    return this.createSegment({
       name: OPENAI.EMBEDDING,
-      parent: ctx.segment,
-      transaction: ctx.transaction
+      ctx
     })
-    const newCtx = ctx.enterSegment({ segment })
-    return newCtx
   }
 
   asyncEnd(data) {

package/lib/subscribers/openai/utils.js

@@ -21,7 +21,8 @@ let TRACKING_METRIC = OPENAI.TRACKING_PREFIX
  * Parses the response from OpenAI and extracts the message content and role.
  *
  * @param {object} response The OpenAI SDK response object
- * @returns {{ content: string, role: string }} the message object with fields `content` and `role`
+ * @returns {object[]} an array with the message object with fields `content`
+ * and `role` or [] if response invalid
  */
 function getMessageFromResponse(response) {
   let content
@@ -30,11 +31,17 @@ function getMessageFromResponse(response) {
     content = response?.output?.[0]?.content?.[0]?.text
     role = response?.output?.[0]?.role
   } else {
-    content = response?.choices?.[0]?.message?.content
-    role = response?.choices?.[0]?.message?.role
+    const choice = response?.choices?.[0]
+    if (choice?.finish_reason === 'tool_calls') {
+      // A false response. Don't create a LlmChatCompletionMessage
+      // for this -- the full conversation isn't done yet.
+      return []
+    }
+    content = choice?.message?.content
+    role = choice?.message?.role
   }
 
-  return { content, role }
+  return [{ content, role }]
 }
 
 /**
@@ -73,7 +80,10 @@ function getMessagesFromRequest(request, logger) {
 }
 
 /**
- * Enqueues a LLM event to the custom event aggregator
+ * Enqueues a LLM event to the custom event aggregator.
+ *
+ * Will use `msg.timestamp` instead of the current time
+ * for `timestamp` if present.
  *
  * @param {object} params input params
  * @param {Agent} params.agent NR agent instance
@@ -82,9 +92,12 @@ function getMessagesFromRequest(request, logger) {
  */
 function recordEvent({ agent, type, msg }) {
   const llmContext = extractLlmContext(agent)
-
+  // Spec 771: The `timestamp` attribute MUST be used to override
+  // the timestamp value attached to the intrinsics of the custom
+  // LlmChatCompletionMessage event before it is recorded using
+  // record_custom_event().
   agent.customEventAggregator.add([
-    { type, timestamp: Date.now() },
+    { type, timestamp: msg?.timestamp ?? Date.now() },
     Object.assign({}, msg, llmContext)
   ])
 }
@@ -159,7 +172,7 @@ function recordChatCompletionMessages({
   // the response message.
   const messages = [
     ...getMessagesFromRequest(request, logger),
-    getMessageFromResponse(response)
+    ...getMessageFromResponse(response)
   ]
 
   for (let i = 0; i < messages.length; i++) {

package/lib/subscribers/record-supportability-metric.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+module.exports = recordSupportabilityMetric
+
+const semver = require('semver')
+const {
+  FEATURES: {
+    INSTRUMENTATION: { SUBSCRIBER_USED }
+  }
+} = require('#agentlib/metrics/names.js')
+
+function recordSupportabilityMetric({
+  agent,
+  moduleName,
+  moduleVersion = 'unknown'
+} = {}) {
+  const major = moduleVersion === 'unknown'
+    ? semver.major(process.version)
+    : semver.major(moduleVersion)
+
+  let metric = agent.metrics.getOrCreateMetric(
+    `${SUBSCRIBER_USED}/${moduleName}/${major}`
+  )
+  if (metric.callCount === 0) {
+    metric.incrementCallCount()
+  }
+
+  metric = agent.metrics.getOrCreateMetric(
+    `${SUBSCRIBER_USED}/${moduleName}`
+  )
+  if (metric.callCount === 0) {
+    metric.incrementCallCount()
+  }
+}

package/lib/subscribers/resolve-package-version.js

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const path = require('node:path')
+const defaultLogger = require('#agentlib/logger.js').child({
+  component: 'resolve-module-version'
+})
+
+const dcFuncFrame = /^\s*at Channel\.publish/
+const modPathReg = /at .+ \((.+):\d+:\d+\)/
+
+module.exports = resolveModuleVersion
+
+/**
+ * Given a module name, attempt to read the version string from its
+ * associated package manifest. If the module is a built-in, or one that has
+ * been bundled with Node.js (e.g. `undici`), a package manifest will not be
+ * available. In this case, the string "unknown" will be returned.
+ *
+ * This version resolver assumes that it will be invoked through our
+ * diagnostics channel subscriber instrumentations. That is, it expects the
+ * call tree to be similar to:
+ *
+ * 1. some-module.function()
+ * 2. diagnostics_channel.publish()
+ * 3. subscriber.handler()
+ *
+ * @param {string} moduleSpecifier What would be passed to `resolve()`.
+ * @param {object} [deps] Optional dependencies.
+ * @param {object} [deps.logger] Agent logger instance.
+ *
+ * @returns {string} The version string from the package manifest or "unknown".
+ */
+function resolveModuleVersion(moduleSpecifier, { logger = defaultLogger } = {}) {
+  let pkgPath
+  // We'd prefer to use `require.resolve(moduleSpecifier)` here, but it gets
+  // a bit confused when there are non-standard module directories in play.
+  // Once we are able to refactor our "on require" metric recording to
+  // utilize `module.registerHooks`, we should be able to eliminate this
+  // slow algorithm.
+  const err = Error()
+  const stack = err.stack.split('\n')
+  do {
+    stack.shift()
+  } while (dcFuncFrame.test(stack[0]) === false && stack.length > 0)
+  const matches = modPathReg.exec(stack[1])
+  pkgPath = matches?.[1]
+
+  if (!pkgPath) {
+    logger.warn(
+      { moduleSpecifier },
+      'Could not resolve module path. Possibly a built-in or Node.js bundled module.'
+    )
+    return 'unknown'
+  }
+
+  const cwd = process.cwd()
+  let reachedCwd = false
+  let pkg
+  let base = path.dirname(pkgPath)
+  do {
+    try {
+      pkgPath = path.join(base, 'package.json')
+      pkg = require(pkgPath)
+    } catch {
+      base = path.resolve(path.join(base, '..'))
+      if (base === cwd) {
+        reachedCwd = true
+      } else if (reachedCwd === true) {
+        // We reached the supposed app root, attempted to load a manifest
+        // file in that location, and still couldn't find one. So we give up.
+        pkg = {}
+      }
+    }
+  } while (!pkg)
+
+  const version = pkg.version ?? 'unknown'
+  logger.trace({ moduleSpecifier, version }, 'Resolved package version.')
+  return version
+}

package/lib/tracking-packages.js

@@ -19,15 +19,7 @@ const trackingPkgs = [
   'fancy-log',
   'knex',
   'loglevel',
-  'npmlog',
-  // These packages are required for the tracking metrics
-  // for @langchain/core to be created. Ideally, these
-  // should not be here.
-  // TODO: will be addressed in https://github.com/newrelic/node-newrelic/issues/3575
-  '@langchain/core/prompts',
-  '@langchain/core/tools',
-  '@langchain/core/runnables',
-  '@langchain/core/vectorstores',
+  'npmlog'
 ]
 
 module.exports = trackingPkgs

package/lib/transaction/trace/partial-trace.js

@@ -65,6 +65,7 @@ class PartialTrace {
   addSpan({ span, isEntry }) {
     const id = span.id
     const parentId = span.parentId
+    const spanLinks = span.spanLinks
     span = span.applyPartialTraceRules({ isEntry, partialTrace: this })
     this.createMetrics(!!span)
     if (span) {
@@ -76,7 +77,32 @@ class PartialTrace {
       // unless compact where all parentIds are assigned to the entry span
       // in finalizeSpanEvents
       this.droppedSpans.set(id, parentId)
+
+      // span was dropped but we still need to move its span links to the last kept span
+      // spanLinks were captured before the span was dropped
+      if (spanLinks && spanLinks.length > 0) {
+        this.reparentSpanLinks(spanLinks)
+      }
+    }
+  }
+
+  /**
+   * Iterates over the span links from a dropped span and reassigns them to the last kept span.
+   * The id intrinsic attribute will also be updated to the value of the last kept span id.
+   *
+   * @param {SpanLink[]} spanLinks an array of span links to reparent to last kept span
+   */
+  reparentSpanLinks(spanLinks) {
+    const lastSpan = this.spans.at(-1)
+
+    // The id intrinsics attribute needs to be updated to equal the id of the new span the
+    // span links are moving to.
+    for (const link of spanLinks) {
+      link.intrinsics.id = lastSpan.id
     }
+
+    // move the span links events to the last kept span
+    Array.prototype.push.apply(lastSpan.spanLinks, spanLinks)
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "13.9.1",
+  "version": "13.10.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -198,6 +198,7 @@
   "imports": {
     "#agentlib/*.js": "./lib/*.js",
     "#testlib/*.js": "./test/lib/*.js",
+    "#testlib/*.json": "./test/lib/*.json",
     "#test/assert": "./test/lib/custom-assertions/index.js"
   },
   "dependencies": {