newrelic 13.10.0 → 13.11.0

package/NEWS.md

@@ -1,3 +1,42 @@
+### 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

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-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 = {

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/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

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/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)
-    }
   }
 }