newrelic 13.9.2 → 13.11.0

package/lib/subscribers/ai-monitoring/index.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const AiMonitoringChatSubscriber = require('./chat')
+const AiMonitoringEmbeddingSubscriber = require('./embedding')
+const AiMonitoringSubscriber = require('./base')
+
+module.exports = {
+  AiMonitoringSubscriber,
+  AiMonitoringChatSubscriber,
+  AiMonitoringEmbeddingSubscriber
+}

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/google-genai/embed-content.js

@@ -3,67 +3,41 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-const GoogleGenAISubscriber = require('./base')
+const { AiMonitoringEmbeddingSubscriber } = require('../ai-monitoring')
 const { AI } = require('../../../lib/metrics/names')
 const { GEMINI } = AI
-const {
-  LlmErrorMessage,
-  LlmEmbedding
-} = require('../../../lib/llm-events/google-genai')
+const { LlmEmbedding } = require('#agentlib/llm-events/google-genai/index.js')
 
-class GoogleGenAIEmbedContentSubscriber extends GoogleGenAISubscriber {
+class GoogleGenAIEmbedContentSubscriber extends AiMonitoringEmbeddingSubscriber {
   constructor ({ agent, logger }) {
-    super({ agent, logger, channelName: 'nr_embedContent' })
+    super({ agent, logger, packageName: '@google/genai', channelName: 'nr_embedContent', trackingPrefix: GEMINI.TRACKING_PREFIX, name: GEMINI.EMBEDDING })
+    this.events = ['asyncEnd']
   }
 
-  handler(data, ctx) {
-    if (!this.enabled) {
-      this.logger.debug('`ai_monitoring.enabled` is set to false, not creating segment.')
-      return ctx
-    }
-    const segment = this.agent.tracer.createSegment({
-      name: GEMINI.EMBEDDING,
-      parent: ctx.segment,
-      transaction: ctx.transaction
+  createEmbedding({ ctx, request, response = {}, err }) {
+    const { segment, transaction } = ctx
+    return new LlmEmbedding({
+      agent: this.agent,
+      segment,
+      transaction,
+      request,
+      response,
+      withError: !!err
     })
-    return ctx.enterSegment({ segment })
   }
 
   asyncEnd(data) {
-    const agent = this.agent
-    if (!this.enabled) {
-      this.logger.debug('`ai_monitoring.enabled` is set to false, not recording Llm events.')
-      return
-    }
-    const ctx = agent.tracer.getContext()
-    if (!ctx?.segment || !ctx?.transaction) {
-      return
-    }
-    this.addLlmMeta({ transaction: ctx.transaction, version: data.moduleVersion })
+    const ctx = this.agent.tracer.getContext()
     // If we get an error, it is possible that `response = null`.
     // In that case, we define it to be an empty object.
     const { result: response = {}, arguments: args, error: err } = data
     const [request] = args
-
-    // Explicitly end segment to get consistent duration
-    // for both LLM events and the segment
-    ctx.segment.end()
-
-    const embedding = new LlmEmbedding({
-      agent,
-      segment: ctx.segment,
-      transaction: ctx.transaction,
+    this.recordEmbedding({
+      ctx,
       request,
       response,
-      withError: err != null
+      err
     })
-
-    this.recordEvent({ type: 'LlmEmbedding', msg: embedding })
-
-    if (err) {
-      const llmError = new LlmErrorMessage({ cause: err, embedding, response })
-      agent.errors.add(ctx.transaction, err, llmError)
-    }
   }
 }
 

package/lib/subscribers/google-genai/generate-content-stream.js

@@ -11,32 +11,19 @@ class GoogleGenAIGenerateContentStreamSubscriber extends GoogleGenAIGenerateCont
     super({ agent, logger, channelName: 'nr_generateContentStreamInternal' })
   }
 
-  get enabled() {
-    return super.enabled && this.streamingEnabled
-  }
-
-  get streamingEnabled() {
-    return this.agent.config.ai_monitoring.streaming.enabled
-  }
-
-  handler(data, ctx) {
-    if (!this.enabled) {
-      this.logger.debug('`ai_monitoring.enabled` or `ai_monitoring.streaming.enabled` is set to false, not creating segment.')
-      return ctx
-    }
-
-    return super.handler(data, ctx)
-  }
-
   /**
    * Instruments the streaming response by wrapping the next function.
    * @param {object} params function params
    * @param {object} params.request the original request object
    * @param {object} params.response the original response object
-   * @param {TraceSegment} params.segment the active trace segment
-   * @param {Transaction} params.transaction the active transaction
+   * @param {object} params.ctx active context
    */
-  instrumentStream({ request, response, segment, transaction }) {
+  instrumentStream({ request, response, ctx }) {
+    if (!(ctx?.segment || ctx?.transaction)) {
+      this.logger.debug('Empty context, not instrumenting stream')
+      return
+    }
+
     const self = this
     const originalNext = response.next
     let isDone = false
@@ -65,7 +52,7 @@ class GoogleGenAIGenerateContentStreamSubscriber extends GoogleGenAIGenerateCont
       } finally {
         // Update segment duration since we want to extend the
         // time it took to handle the stream
-        segment.touch()
+        ctx.segment.touch()
 
         // also need to enter this block if there was an
         // error, so we can record it
@@ -73,9 +60,8 @@ class GoogleGenAIGenerateContentStreamSubscriber extends GoogleGenAIGenerateCont
           if (cachedResult?.candidates?.[0]?.content?.parts) {
             cachedResult.candidates[0].content.parts[0].text = entireMessage
           }
-          self.recordChatCompletionMessages({
-            segment,
-            transaction,
+          self.recordChatCompletionEvents({
+            ctx,
             request,
             response: cachedResult,
             err
@@ -87,7 +73,11 @@ class GoogleGenAIGenerateContentStreamSubscriber extends GoogleGenAIGenerateCont
   }
 
   asyncEnd(data) {
-    // Check config is ai_monitoring is still enabled
+    // Check config to see if ai_monitoring is still enabled
+    if (!this.enabled) {
+      this.logger.debug('`ai_monitoring.enabled` is set to false, stream will not be instrumented.')
+      return
+    }
     if (!this.streamingEnabled) {
       this.logger.warn(
         '`ai_monitoring.streaming.enabled` is set to `false`, stream will not be instrumented.'
@@ -95,29 +85,16 @@ class GoogleGenAIGenerateContentStreamSubscriber extends GoogleGenAIGenerateCont
       this.agent.metrics.getOrCreateMetric(AI.STREAMING_DISABLED).incrementCallCount()
       return
     }
-    if (!this.enabled) {
-      this.logger.debug('`ai_monitoring.enabled` is set to false, not recording Llm events.')
-      return
-    }
 
     // Instrument the stream
     const ctx = this.agent.tracer.getContext()
-    if (!ctx?.segment || !ctx?.transaction) {
-      return
-    }
     const { result: response, arguments: args } = data
     const [request] = args
 
     this.instrumentStream({
+      ctx,
       request,
       response,
-      segment: ctx.segment,
-      transaction: ctx.transaction,
-    })
-
-    this.addLlmMeta({
-      transaction: ctx.transaction,
-      version: data.moduleVersion,
     })
   }
 }

package/lib/subscribers/google-genai/generate-content.js

@@ -3,51 +3,62 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-const GoogleGenAISubscriber = require('./base')
+const { AiMonitoringChatSubscriber } = require('../ai-monitoring')
 const { AI } = require('../../metrics/names')
 const { GEMINI } = AI
+const { LlmChatCompletionSummary, LlmChatCompletionMessage } = require('#agentlib/llm-events/google-genai/index.js')
 
-class GoogleGenAIGenerateContentSubscriber extends GoogleGenAISubscriber {
+class GoogleGenAIGenerateContentSubscriber extends AiMonitoringChatSubscriber {
   constructor({ agent, logger, channelName = 'nr_generateContentInternal' }) {
-    super({ agent, logger, channelName })
-  }
-
-  handler(data, ctx) {
-    if (!this.enabled) {
-      this.logger.debug('`ai_monitoring.enabled` is set to false, not creating segment.')
-      return ctx
-    }
-    const segment = this.agent.tracer.createSegment({
-      name: GEMINI.COMPLETION,
-      parent: ctx.segment,
-      transaction: ctx.transaction
-    })
-    return ctx.enterSegment({ segment })
+    super({ agent, logger, channelName, packageName: '@google/genai', name: GEMINI.COMPLETION, trackingPrefix: GEMINI.TRACKING_PREFIX })
+    this.events = ['asyncEnd']
   }
 
   asyncEnd(data) {
-    if (!this.enabled) {
-      this.logger.debug('`ai_monitoring.enabled` is set to false, not recording Llm events.')
-      return
-    }
     const ctx = this.agent.tracer.getContext()
-    if (!ctx?.segment || !ctx?.transaction) {
-      return
-    }
     const { result: response, arguments: args, error: err } = data
     const [request] = args
 
-    this.recordChatCompletionMessages({
-      segment: ctx.segment,
-      transaction: ctx.transaction,
+    this.recordChatCompletionEvents({
+      ctx,
       request,
       response,
       err
     })
+  }
 
-    this.addLlmMeta({
-      transaction: ctx.transaction,
-      version: data.moduleVersion
+  getMessages({ request, response }) {
+    // Only take the first response message and append to input messages
+    // request.contents can be a string or an array of strings
+    // response.candidates is an array of candidates (choices); we only take the first one
+    const inputMessages = Array.isArray(request.contents) ? request.contents : [request.contents]
+    const responseMessage = response?.candidates?.[0]?.content
+    return responseMessage !== undefined ? [...inputMessages, responseMessage] : inputMessages
+  }
+
+  createCompletionSummary({ ctx, request, response = {}, err }) {
+    const { transaction, segment } = ctx
+    return new LlmChatCompletionSummary({
+      agent: this.agent,
+      segment,
+      transaction,
+      request,
+      response,
+      withError: !!err
+    })
+  }
+
+  createCompletionMessage({ ctx, request, response, index, completionId, message }) {
+    const { segment, transaction } = ctx
+    return new LlmChatCompletionMessage({
+      agent: this.agent,
+      segment,
+      transaction,
+      request,
+      response,
+      index,
+      completionId,
+      message
     })
   }
 }

package/lib/subscribers/ioredis/index.js

@@ -6,6 +6,7 @@
 'use strict'
 const DbOperationSubscriber = require('../db-operation')
 const stringify = require('json-stringify-safe')
+const { wrapPromise } = require('../utils')
 
 class IoRedisSubscriber extends DbOperationSubscriber {
   constructor({ agent, logger, packageName = 'ioredis', system = 'Redis' }) {
@@ -30,18 +31,7 @@ class IoRedisSubscriber extends DbOperationSubscriber {
    * @param {object} data the data associated with the `end` event
    */
   end(data) {
-    const promise = data?.result
-    if (typeof promise.then !== 'function') {
-      return promise
-    }
-
-    promise.then((result) => {
-      data.result = result
-      this.channel.asyncEnd.publish(data)
-    }, (err) => {
-      data.error = err
-      this.channel.asyncEnd.publish(data)
-    })
+    wrapPromise.call(this, data)
   }
 
   setParameters(self, command) {