newrelic 13.9.2 → 13.11.0

package/NEWS.md

@@ -1,3 +1,68 @@
+### v13.11.0 (2026-01-29)
+
+#### Features
+
+* Added `timestamp` to AIM `LlmChatCompletionMessage` messages
+    * Added `timestamp` to AWS Bedrock `LlmChatCompletionMessage` ([#3685](https://github.com/newrelic/node-newrelic/pull/3685)) ([ea297c8](https://github.com/newrelic/node-newrelic/commit/ea297c86772c1ae377a16e636db8bbcf53ef1547))
+    * Added `timestamp` to Google Gen AI `LlmChatCompletionMessage` ([#3686](https://github.com/newrelic/node-newrelic/pull/3686)) ([f4dd09e](https://github.com/newrelic/node-newrelic/commit/f4dd09ec332c47396277f6aaeff2f6f15daad97a))
+    * Added `timestamp` to LangChain input `LlmChatCompletionMessage` ([#3658](https://github.com/newrelic/node-newrelic/pull/3658)) ([0bce235](https://github.com/newrelic/node-newrelic/commit/0bce235ce02f772bc089bf947afadf312c735c1b))
+* Added timestamp to OpenAI `LlmChatCompletionSummary` ([#3689](https://github.com/newrelic/node-newrelic/pull/3689)) ([55b0310](https://github.com/newrelic/node-newrelic/commit/55b03100323eefb3578816cff69f2b919e4b7bdd))
+* Additional support for partial granularity traces (Not available for production use)
+    * Added essential tracing mode for span links ([#3670](https://github.com/newrelic/node-newrelic/pull/3670)) ([83dfb84](https://github.com/newrelic/node-newrelic/commit/83dfb84b842e0245392425ce61e92a2789fcaf06))
+    * Updated `Supportability/Nodejs/PartialGranularity/NrIds/Dropped` metric to only keep track of spans that got dropped when `nr.ids` execeeded 63 spans. ([#3684](https://github.com/newrelic/node-newrelic/pull/3684)) ([9797cf3](https://github.com/newrelic/node-newrelic/commit/9797cf38aa2808b29da9623158edb221b1819548))
+
+#### Bug fixes
+
+* Added defensive code in `lib/subscribers/middleware-wrapper.js` to prevent crash when attempting to associate an error on an incoming http request ([#3697](https://github.com/newrelic/node-newrelic/pull/3697)) ([658e78b](https://github.com/newrelic/node-newrelic/commit/658e78ba564eae996d790bb3334bda6847c7e2bd))
+* Updated `pg` instrumentation to properly capture the TraceSegment duration for promise based queries ([#3695](https://github.com/newrelic/node-newrelic/pull/3695)) ([0051697](https://github.com/newrelic/node-newrelic/commit/005169776a3f3fe9d988174857b3c96e6131aea3))
+
+#### Code refactoring
+
+* Added AIM abstract subscribers and updated all AIM subscribers to use them ([#3676](https://github.com/newrelic/node-newrelic/pull/3676)) ([08cd38b](https://github.com/newrelic/node-newrelic/commit/08cd38b5b34b4f1a2636ccc12d359484af6b3e83))
+
+#### Documentation
+
+* Updated compatibility report ([#3675](https://github.com/newrelic/node-newrelic/pull/3675)) ([cc898f4](https://github.com/newrelic/node-newrelic/commit/cc898f4d8b0f520e120f330ff9e90fe7baaebedc))
+
+#### Miscellaneous chores
+
+* Added TimedEvent limit of 100 ([#3683](https://github.com/newrelic/node-newrelic/pull/3683)) ([0d595d8](https://github.com/newrelic/node-newrelic/commit/0d595d8579b5a58e49908bc24321ce7b526ddff2))
+* Added supportability metrics `Supportability/Nodejs/SpanEvent/<Links|Events>/Dropped` when limit of 100 is exceeded ([#3688](https://github.com/newrelic/node-newrelic/pull/3688)) ([a247d31](https://github.com/newrelic/node-newrelic/commit/a247d31fc9c24752be50a73d4ddfc7a088a68ce6))
+* Removed eslint disable next line for `sonarjs/no-dead-store` ([#3692](https://github.com/newrelic/node-newrelic/pull/3692)) ([593fa15](https://github.com/newrelic/node-newrelic/commit/593fa15a033437b95fe375cf6034b8453c7d2b36))
+
+#### Continuous Integration
+* Fixed CI issue when sec-agent present ([#3677](https://github.com/newrelic/node-newrelic/pull/3677)) ([23da654](https://github.com/newrelic/node-newrelic/commit/23da6547e72f49bf798046330e8cfa74a0b4d2af))
+
+#### Tests
+
+* Assert that span events drop in partial traces ([#3680](https://github.com/newrelic/node-newrelic/pull/3680)) ([25e3781](https://github.com/newrelic/node-newrelic/commit/25e3781098343b9ca9e4aed0cd5c9e0f94266926))
+
+### 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
@@ -8233,3 +8298,4 @@ Special thanks to Ryan Copley (@RyanCopley) for the contribution.
 
 
 
+

package/lib/instrumentation/aws-sdk/v3/bedrock.js

@@ -75,9 +75,10 @@ function isStreamingEnabled({ commandName, config }) {
 function recordEvent({ agent, type, msg }) {
   msg.serialize()
   const llmContext = extractLlmContext(agent)
+  const timestamp = msg?.timestamp ?? Date.now()
 
   agent.customEventAggregator.add([
-    { type, timestamp: Date.now() },
+    { type, timestamp },
     Object.assign({}, msg, llmContext)
   ])
 }

package/lib/instrumentation/when/index.js

@@ -296,7 +296,6 @@ module.exports = function initialize(shim, when) {
         ret = agent.tracer.bindFunction(fn, context, true).apply(this, arguments)
       } finally {
         if (ret && typeof ret.then === 'function') {
-          // eslint-disable-next-line sonarjs/no-dead-store
           ret = ctx.next[symbols.context].continue(ret)
         }
       }

package/lib/llm-events/aws-bedrock/chat-completion-message.js

@@ -38,7 +38,7 @@ class LlmChatCompletionMessage extends LlmEvent {
     params = Object.assign({}, defaultParams, params)
     super(params)
 
-    const { agent, content, isResponse, index, completionId, role } = params
+    const { agent, content, isResponse, index, completionId, role, segment } = params
     const recordContent = agent.config?.ai_monitoring?.record_content?.enabled
 
     this.is_response = isResponse
@@ -46,6 +46,10 @@ class LlmChatCompletionMessage extends LlmEvent {
     this.sequence = index
     this.content = recordContent === true ? content : undefined
     this.role = role
+    if (this.is_response === false) {
+      // Only record for request/input messages
+      this.timestamp = segment.timer.start
+    }
 
     this.#setId(index)
     this.setTokenCount(agent)

package/lib/llm-events/google-genai/chat-completion-message.js

@@ -33,6 +33,11 @@ module.exports = class LlmChatCompletionMessage extends LlmEvent {
       this.content = this.is_response ? message?.parts?.[0]?.text : message
     }
 
+    // only add timestamp for request/input messages
+    if (this.is_response === false) {
+      this.timestamp = segment.timer.start
+    }
+
     this.setTokenCount(agent, request, response)
   }
 

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

@@ -38,19 +38,25 @@ class LangChainCompletionMessage extends LangChainEvent {
   constructor(params = defaultParams) {
     params = Object.assign({}, defaultParams, params)
     super(params)
-    const { agent } = params
+    const { agent, runId, segment, sequence, role, content, completionId, isResponse } = params
 
-    if (params.runId) {
-      this.id = `${params.runId}-${params.sequence}`
+    if (runId) {
+      this.id = `${runId}-${sequence}`
     } else {
-      this.id = `${this.id}-${params.sequence}`
+      this.id = `${this.id}-${sequence}`
     }
 
-    this.sequence = params.sequence
-    this.completion_id = params.completionId
-    this.is_response = params.isResponse ?? false
-    if (params.role) {
-      this.role = params.role
+    this.sequence = sequence
+    this.completion_id = completionId
+
+    this.is_response = isResponse ?? false
+    if (this.is_response === false) {
+      // `timestamp` is only required for input/request messages.
+      this.timestamp = segment.timer.start
+    }
+
+    if (role) {
+      this.role = role
     } else {
       // As a backup, we can infer the role based on if it
       // is a response or not.
@@ -58,7 +64,7 @@ class LangChainCompletionMessage extends LangChainEvent {
     }
 
     if (agent.config.ai_monitoring.record_content.enabled === true) {
-      this.content = params.content
+      this.content = content
     }
   }
 }

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/llm-events/openai/chat-completion-summary.js

@@ -14,17 +14,19 @@ module.exports = class LlmChatCompletionSummary extends LlmEvent {
     this['request.temperature'] = request.temperature
 
     if (request?.input) {
-      // `responses.create` logic
+      // `responses.create` api logic
       // `request.input` can be an array or a string.
       const requestLength = Array.isArray(request?.input) ? request.input.length : 1
       this['response.number_of_messages'] = requestLength + (response?.output?.length ?? 0)
       this['response.choices.finish_reason'] = response?.status
     } else {
-      // `chat.completions.create` logic
+      // `chat.completions.create` api logic
       this['response.number_of_messages'] = request?.messages?.length + response?.choices?.length
       this['response.choices.finish_reason'] = response?.choices?.[0]?.finish_reason
     }
 
+    this.timestamp = segment.timer.start
+
     this.setTokens(agent, request, response)
   }
 

package/lib/metrics/names.js

@@ -325,7 +325,9 @@ const SPAN_EVENTS = {
   SEEN: SUPPORTABILITY.PREFIX + SPAN_EVENT_PREFIX + 'TotalEventsSeen',
   SENT: SUPPORTABILITY.PREFIX + SPAN_EVENT_PREFIX + 'TotalEventsSent',
   DROPPED: SUPPORTABILITY.PREFIX + SPAN_EVENT_PREFIX + 'Discarded',
-  LIMIT: SUPPORTABILITY.PREFIX + SPAN_EVENT_PREFIX + 'Limit'
+  LIMIT: SUPPORTABILITY.PREFIX + SPAN_EVENT_PREFIX + 'Limit',
+  LINKS_DROPPED: SUPPORTABILITY.NODEJS + '/' + SPAN_EVENT_PREFIX + 'Links/Dropped',
+  EVENTS_DROPPED: SUPPORTABILITY.NODEJS + '/' + SPAN_EVENT_PREFIX + 'Events/Dropped'
 }
 
 const INFINITE_TRACING = {
@@ -353,7 +355,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/otel/traces/span-processor.js

@@ -23,6 +23,7 @@ const {
   transformTemplate
 } = require('./utils.js')
 const defaultLogger = require('#agentlib/logger.js').child({ component: 'span-processor' })
+const { SPAN_EVENTS } = require('#agentlib/metrics/names.js')
 
 const {
   SPAN_STATUS_CODE
@@ -155,7 +156,10 @@ module.exports = class NrSpanProcessor {
         event: span.events[i],
         spanContext
       })
-      segment.addTimedEvent(event)
+      const added = segment.addTimedEvent(event)
+      if (!added) {
+        this.agent.metrics.getOrCreateMetric(SPAN_EVENTS.EVENTS_DROPPED).incrementCallCount()
+      }
     }
   }
 
@@ -181,7 +185,10 @@ module.exports = class NrSpanProcessor {
         spanContext,
         timestamp
       })
-      segment.addSpanLink(link)
+      const added = segment.addSpanLink(link)
+      if (!added) {
+        this.agent.metrics.getOrCreateMetric(SPAN_EVENTS.LINKS_DROPPED).incrementCallCount()
+      }
     }
   }
 

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/spans/span-event.js

@@ -60,6 +60,8 @@ class SpanIntrinsics {
     this.duration = null
     this['nr.entryPoint'] = null
     this['nr.pg'] = null
+    this['nr.durations'] = null
+    this['nr.ids'] = null
     this['span.kind'] = null
     this.trustedParentId = null
     this.tracingVendors = null

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

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const Subscriber = require('../base')
+const { DESTINATIONS } = require('#agentlib/config/attribute-filter.js')
+const { extractLlmContext } = require('#agentlib/util/llm-utils.js')
+
+class AiMonitoringSubscriber extends Subscriber {
+  /**
+   * @param {object} params constructor params object
+   * @param {object} params.agent A New Relic Node.js agent instance.
+   * @param {object} params.logger An agent logger instance.
+   * @param {string} params.packageName The package name being instrumented.
+   * This is what a developer would provide to the `require` function.
+   * @param {string} params.channelName A unique name for the diagnostics channel
+   * that will be created and monitored.
+   * @param {string} params.name name of segment for a given subscriber
+   * @param {string} params.trackingPrefix prefix for the tracking metric for a given subscriber
+   */
+  constructor({ agent, logger, packageName, channelName, name, trackingPrefix }) {
+    super({ agent, logger, packageName, channelName })
+    this.name = name
+    this.trackingPrefix = trackingPrefix
+  }
+
+  get enabled() {
+    return super.enabled && this.agent.config.ai_monitoring.enabled === true
+  }
+
+  set name(name) {
+    if (!name) {
+      throw new Error('subscriber must pass in `name`')
+    }
+    this._name = name
+  }
+
+  get name() {
+    return this._name
+  }
+
+  set trackingPrefix(prefix) {
+    if (!prefix) {
+      throw new Error('subscriber must pass in `trackingPrefix`')
+    }
+    this._prefix = prefix
+  }
+
+  get trackingPrefix() {
+    return this._prefix
+  }
+
+  /**
+   * Increments the tracking metric and sets the llm attribute on transactions
+   *
+   * @param {object} params input params
+   * @param {Transaction} params.ctx active context
+   * @param {string} params.version package version
+   */
+  addLlmMeta({ ctx, version }) {
+    if (!ctx?.transaction) {
+      return
+    }
+
+    const transaction = ctx.transaction
+    const trackingMetric = `${this.trackingPrefix}/${version}`
+    this.agent.metrics.getOrCreateMetric(trackingMetric).incrementCallCount()
+    transaction.trace.attributes.addAttribute(DESTINATIONS.TRANS_EVENT, 'llm', true)
+  }
+
+  /**
+   * Enqueues a LLM event to the custom event aggregator
+   *
+   * @param {object} params input params
+   * @param {string} params.type LLM event type
+   * @param {object} params.msg LLM event
+   */
+  recordEvent({ type, msg }) {
+    const llmContext = extractLlmContext(this.agent)
+    // prefer timestamp on event if present, otherwise use `Date.now`
+    const timestamp = msg?.timestamp ?? Date.now()
+    this.agent.customEventAggregator.add([
+      { type, timestamp },
+      Object.assign({}, msg, llmContext)
+    ])
+  }
+
+  /**
+   * Defines the common handler for all AIM calls.
+   * All of these calls simply create a segment with a name
+   * The `this.name` must be defined in the inherited subscriber
+   * @param {object} data event passed to handler
+   * @param {Context} ctx context passed to handler
+   * @returns {Context} either new context or existing
+   */
+  handler(data, ctx) {
+    if (!this.enabled) {
+      this.logger.debug('`ai_monitoring.enabled` is set to false, not creating segment.')
+      return ctx
+    }
+
+    this.addLlmMeta({ ctx, version: data.moduleVersion })
+
+    return this.createSegment({
+      name: this.name,
+      ctx
+    })
+  }
+}
+
+module.exports = AiMonitoringSubscriber

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

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const AiMonitoringSubscriber = require('./base')
+const LlmErrorMessage = require('#agentlib/llm-events/error-message.js')
+
+class AiMonitoringChatSubscriber extends AiMonitoringSubscriber {
+  /**
+   * @param {object} params constructor params object
+   * @param {object} params.agent A New Relic Node.js agent instance.
+   * @param {object} params.logger An agent logger instance.
+   * @param {string} params.packageName The package name being instrumented.
+   * This is what a developer would provide to the `require` function.
+   * @param {string} params.channelName A unique name for the diagnostics channel
+   * that will be created and monitored.
+   * @param {string} params.name name of segment for a given subscriber
+   * @param {string} params.trackingPrefix prefix for the tracking metric for a given subscriber
+   */
+  constructor({ agent, logger, packageName, channelName, name, trackingPrefix }) {
+    super({ agent, logger, packageName, channelName, name, trackingPrefix })
+  }
+
+  get streamingEnabled() {
+    return this.agent.config.ai_monitoring.streaming.enabled === true
+  }
+
+  /**
+   * Function that must be implemented by inherited subscriber to create an llm completion message.
+   *
+   * @param {object} params to function
+   * @param {Context} params.ctx active context
+   * @param {object} params.request request made to method on a given llm library
+   * @param {object} params.response response from method on a given llm library
+   * @param {object|string} params.message the message object/string used to create llm completion message
+   * @param {string} params.completionId the id of the llm completion summary for a given conversation
+   * @param {number} params.index index of message for a given conversation
+   * returns {object} a llm completion message instance for the given LLM
+   */
+  createCompletionMessage({ ctx, request, response, message, completionId, index }) {
+    throw new Error('createCompletionMessage must be implemented by your subscriber')
+  }
+
+  /**
+   * Function that must be implemented by inherited subscriber to create the llm completion summary.
+   *
+   * @param {object} params to function
+   * @param {Context} params.ctx active context
+   * @param {object} params.request request made to method on a given llm library
+   * @param {object} params.response response from method on a given llm library
+   * @param {object} params.err error if present
+   * @param {object} params.metadata used only for langchain events at the moment
+   * @param {Array} params.tags used only for langchain events at the moment
+   * returns {object} a llm completion summary instance for the given LLM
+   */
+  createCompletionSummary({ ctx, request, response, err, metadata, tags }) {
+    throw new Error('createCompletionSummary must be implemented by your subscriber')
+  }
+
+  /**
+   * Function that must be implemented by inherited subscriber to retrieve the relevant
+   * messages for a given chat conversation.
+   *
+   * @param {object} params to function
+   * @param {object} params.request request to instrumented function
+   * @param {object} params.response response to instrumented function
+   * returns {Array} an array of relevant messages used to construct llm completion messages
+   */
+  getMessages({ request, response }) {
+    throw new Error('getMessages must be implemented by your subscriber')
+  }
+
+  /**
+   * Function to create both llm completion summary and messages
+   *  as well as assign errors to transaction if present
+   * @param {object} params to function
+   * @param {Context} params.ctx active context
+   * @param {object} params.request request made to method on a given llm library
+   * @param {object} params.response response from method on a given llm library
+   * @param {object} params.err error if present
+   * @param {object} params.metadata used only for langchain events at the moment
+   * @param {Array} params.tags used only for langchain events at the moment
+   */
+  recordChatCompletionEvents({ ctx, request, response, err, metadata = {}, tags = [] }) {
+    if (!this.enabled) {
+      this.logger.debug('config.ai_monitoring.enabled is set to false, not creating chat completion events.')
+      return
+    }
+
+    if (!(ctx?.segment || ctx?.transaction)) {
+      this.logger.debug('Empty context, not creating completion events.')
+      return
+    }
+
+    // Explicitly end segment to provide consistent duration
+    // for both LLM events and the segment
+    ctx.segment.end()
+    const completionSummary = this.createCompletionSummary({ ctx, request, response, err, metadata, tags })
+    this.recordEvent({ type: 'LlmChatCompletionSummary', msg: completionSummary })
+
+    const messages = this.getMessages({ request, response })
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i]
+      const completionMessage = this.createCompletionMessage({ ctx, completionId: completionSummary.id, index: i, message, request, response })
+      this.recordEvent({ type: 'LlmChatCompletionMessage', msg: completionMessage })
+    }
+
+    if (err) {
+      const llmError = new LlmErrorMessage({ cause: err, summary: completionSummary, response })
+      this.agent.errors.add(ctx.transaction, err, llmError)
+    }
+  }
+}
+
+module.exports = AiMonitoringChatSubscriber

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

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const AiMonitoringSubscriber = require('./base')
+const LlmErrorMessage = require('#agentlib/llm-events/error-message.js')
+
+class AiMonitoringEmbeddingSubscriber extends AiMonitoringSubscriber {
+  /**
+   * @param {object} params constructor params object
+   * @param {object} params.agent A New Relic Node.js agent instance.
+   * @param {object} params.logger An agent logger instance.
+   * @param {string} params.packageName The package name being instrumented.
+   * This is what a developer would provide to the `require` function.
+   * @param {string} params.channelName A unique name for the diagnostics channel
+   * that will be created and monitored.
+   * @param {string} params.name name of segment for a given subscriber
+   * @param {string} params.trackingPrefix prefix for the tracking metric for a given subscriber
+   */
+  constructor({ agent, logger, packageName, channelName, name, trackingPrefix }) {
+    super({ agent, logger, packageName, channelName, name, trackingPrefix })
+  }
+
+  /**
+   * Function that must be implemented by inherited subscriber to create an llm embedding.
+   *
+   * @param {object} params to function
+   * @param {Context} params.ctx active context
+   * @param {object} params.request request made to method on a given llm library
+   * @param {object} params.response response from method on a given llm library
+   * @param {object} params.err error if present
+   * returns {object} a llm embedding instance for the given LLM
+   */
+  createEmbedding({ ctx, request, response, err }) {
+    throw new Error('createEmbedding must be implemented by your subscriber')
+  }
+
+  /**
+   * Function to create embedding as well as assign errors to transaction if present
+   * @param {object} params to function
+   * @param {Context} params.ctx active context
+   * @param {object} params.request request made to method on a given llm library
+   * @param {object} params.response response from method on a given llm library
+   * @param {object} params.err error if present
+   */
+  recordEmbedding({ ctx, request, response, err }) {
+    if (!this.enabled) {
+      this.logger.debug('config.ai_monitoring.enabled is set to false, not creating embedding event.')
+      return
+    }
+
+    if (!(ctx?.segment || ctx?.transaction)) {
+      this.logger.debug('Empty context, not creating embedding event.')
+      return
+    }
+
+    // Explicitly end segment to provide consistent duration
+    // for both LLM events and the segment
+    ctx.segment.end()
+    const embedding = this.createEmbedding({ ctx, request, response, err })
+    this.recordEvent({ type: 'LlmEmbedding', msg: embedding })
+
+    if (err) {
+      const llmError = new LlmErrorMessage({ cause: err, embedding, response })
+      this.agent.errors.add(ctx.transaction, err, llmError)
+    }
+  }
+}
+
+module.exports = AiMonitoringEmbeddingSubscriber