newrelic 13.11.0 → 13.12.0

package/NEWS.md

@@ -1,3 +1,22 @@
+### v13.12.0 (2026-02-02)
+
+#### Features
+
+* Added instrumentation support for `@langchain/langgraph` ([#3645](https://github.com/newrelic/node-newrelic/pull/3645)) ([f339675](https://github.com/newrelic/node-newrelic/commit/f3396754fb182a3f0af09488a8abb1981b6f3e3f))
+* Added `timestamp` to `LlmChatCompletionSummary` messages
+    * Added `timestamp` to AWS Bedrock `LlmChatCompletionSummary` ([#3702](https://github.com/newrelic/node-newrelic/pull/3702)) ([430d1dd](https://github.com/newrelic/node-newrelic/commit/430d1dd5ef847203045486a054142df3a02c7c1c))
+    * Added `timestamp` to Google Gen AI `LlmChatCompletionSummary` ([#3690](https://github.com/newrelic/node-newrelic/pull/3690)) ([7748e26](https://github.com/newrelic/node-newrelic/commit/7748e26aceb7b050b13dc686c852513026f043ac))
+    * Added `timestamp` to LangChain `LlmChatCompletionSummary` ([#3701](https://github.com/newrelic/node-newrelic/pull/3701)) ([7472118](https://github.com/newrelic/node-newrelic/commit/747211814396e4bf52dc63d249c0ec045b35457a))
+* Added compact mode for span links ([#3681](https://github.com/newrelic/node-newrelic/pull/3681)) ([6ff6961](https://github.com/newrelic/node-newrelic/commit/6ff6961e6b46feb14638da97a95d0891a0d88645))
+
+#### Bug fixes
+
+* Updated langchain tool instrumentation to properly redefine the segment name on every call ([#3691](https://github.com/newrelic/node-newrelic/pull/3691)) ([4df6068](https://github.com/newrelic/node-newrelic/commit/4df6068d23b5da276486bd3d3f0c3af4b748c4a8))
+
+#### Documentation
+
+* Updated compatibility report ([#3699](https://github.com/newrelic/node-newrelic/pull/3699)) ([40b6b81](https://github.com/newrelic/node-newrelic/commit/40b6b813e7b6490c2e866a33cb1a7492b35d2a36))
+
 ### v13.11.0 (2026-01-29)
 
 #### Features

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

@@ -37,6 +37,7 @@ class LlmChatCompletionSummary extends LlmEvent {
     this['request.temperature'] = cmd.temperature
     this['response.number_of_messages'] = (cmd.prompt.length ?? 0) + (res.completions.length ?? 0)
 
+    this.timestamp = segment.timer.start
     this.setTokens(agent)
   }
 

package/lib/llm-events/error-message.js

@@ -21,20 +21,26 @@ module.exports = class LlmErrorMessage {
    * @param {LlmVectorStoreSearch} [params.vectorsearch] Details about the vector
    * search if it was a vector search event.
    * @param {LlmTool} [params.tool] Details about the tool event if it was a tool event.
+   * @param {object} [params.aiAgent] Details about the AI agent event if it was an AI agent event.
    * @param {boolean} [params.useNameAsCode] defaults to false, only Bedrock sets it to true so far
    */
-  constructor({ response, cause, summary = {}, embedding = {}, vectorsearch = {}, tool = {}, useNameAsCode = false } = {}) {
+  constructor({ response, cause, summary = {}, embedding = {}, vectorsearch = {}, tool = {}, aiAgent = {}, useNameAsCode = false } = {}) {
     this['http.statusCode'] = response?.statusCode ?? response?.status ?? cause?.status
     this['error.message'] = cause?.message
-    this['error.code'] = response?.code ?? cause?.error?.code
+    this['error.code'] = response?.code ?? cause?.error?.code ?? cause?.code
     if (useNameAsCode) {
       this['error.code'] = cause?.name
     }
+    if (cause?.['lc_error_code']) {
+      // this is where langchain error codes live
+      this['error.code'] = cause['lc_error_code']
+    }
     this['error.param'] = response?.param ?? cause?.error?.param
     this.completion_id = summary?.id
     this.embedding_id = embedding?.id
     this.vector_store_id = vectorsearch?.id
     this.tool_id = tool?.id
+    this.agent_id = aiAgent?.id
 
     if (embedding?.vendor === 'gemini' || summary?.vendor === 'gemini') {
       this._handleGemini(cause)

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

@@ -21,6 +21,7 @@ module.exports = class LlmChatCompletionSummary extends LlmEvent {
     this['request.max_tokens'] = request.config?.maxOutputTokens
     this['request.temperature'] = request.config?.temperature
 
+    this.timestamp = segment.timer.start
     this.setTokens(agent, request, response)
   }
 

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

@@ -33,8 +33,9 @@ class LangChainCompletionSummary extends LangChainEvent {
     super(params)
     const { segment } = params
 
-    this.duration = segment?.getDurationInMillis()
+    this.duration = segment.getDurationInMillis()
     this['response.number_of_messages'] = params.messages?.length
+    this.timestamp = segment.timer.start
   }
 }
 

package/lib/llm-events/langgraph/agent.js

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const BaseLlmEvent = require('../event')
+const { makeId } = require('../../util/hashes')
+
+/**
+ * @typedef {object} LangGraphAgentEventParams
+ * @property {Agent} agent The New Relic agent instance.
+ * @property {string} name The name of the LangGraph agent, defaults to 'agent'.
+ * @property {object} segment The associated NR segment.
+ * @property {object} transaction The associated NR transaction.
+ * @property {boolean} error A boolean flag to indicate if an error occurred.
+ */
+
+module.exports = class LangGraphAgentEvent extends BaseLlmEvent {
+  id = makeId(36)
+  span_id
+  trace_id
+  ingest_source = 'Node'
+  vendor = 'langgraph'
+
+  /**
+   * @param {LangGraphAgentEventParams} params should contain all necessary and optional LangGraph data
+   */
+  constructor(params) {
+    super(params)
+    const { agent, segment, transaction, error = false, name = 'agent' } = params
+
+    this.name = name
+    this.span_id = segment.id
+    this.trace_id = transaction.traceId
+    this.error = error
+
+    // Setting `metadata` as the NR agent instance will allow `BaseLlmEvent`
+    // to extract the relevant `llm.<user_defined_metadata>`.
+    this.metadata = agent
+  }
+}

package/lib/metrics/names.js

@@ -171,7 +171,8 @@ const AI = {
   COMPLETION: 'Llm/completion',
   TOOL: 'Llm/tool',
   CHAIN: 'Llm/chain',
-  VECTORSTORE: 'Llm/vectorstore'
+  VECTORSTORE: 'Llm/vectorstore',
+  AGENT: 'Llm/agent'
 }
 
 AI.GEMINI = {
@@ -199,6 +200,11 @@ AI.LANGCHAIN = {
   VECTORSTORE: `${AI.VECTORSTORE}/LangChain`
 }
 
+AI.LANGGRAPH = {
+  TRACKING_PREFIX: `${AI.TRACKING_PREFIX}/LangGraph`,
+  AGENT: `${AI.AGENT}/LangGraph`
+}
+
 const MCP = {
   TRACKING_PREFIX: `${AI.TRACKING_PREFIX}/MCP`,
   TOOL: `${AI.TOOL}/MCP`,

package/lib/spans/span-event.js

@@ -318,6 +318,14 @@ class SpanEvent {
    *  @returns {SpanEvent|null} the span after applying the rules, or null if dropped
    */
   applyPartialTraceRules({ isEntry, partialTrace }) {
+    // in essential and compact mode - we need to remove the non intrinsic attributes from span links early in this process because there can be an entry span,
+    // llm span exit span or span with no entity relationship attributes can have non intrinsics on it.
+    if (partialTrace.type !== PARTIAL_TYPES.REDUCED) {
+      for (const link of this.spanLinks) {
+        link.removeNonIntrinsicsAttrs()
+      }
+    }
+
     if (isEntry) {
       this.addIntrinsicAttribute('nr.pg', true)
       logger.trace('Span %s is an entry point, keeping span unchanged.', this.intrinsics.name)

package/lib/spans/span-link.js

@@ -86,6 +86,11 @@ class SpanLink {
       filterNulls(this.agentAttributes.get(DESTINATIONS.TRANS_SEGMENT))
     ]
   }
+
+  removeNonIntrinsicsAttrs() {
+    this.userAttributes = Object.create(null)
+    this.agentAttributes = Object.create(null)
+  }
 }
 
 function filterNulls(inputObj) {

package/lib/subscriber-configs.js

@@ -18,6 +18,7 @@ const subscribers = {
   ...require('./subscribers/ioredis/config'),
   ...require('./subscribers/iovalkey/config'),
   ...require('./subscribers/langchain/config'),
+  ...require('./subscribers/langgraph/config'),
   ...require('./subscribers/mcp-sdk/config'),
   ...require('./subscribers/mysql/config'),
   ...require('./subscribers/mysql2/config'),

package/lib/subscribers/langchain/runnable-stream.js

@@ -16,7 +16,6 @@ class LangchainRunnableStreamSubscriber extends LangchainRunnableSubscriber {
       this.logger.debug('`ai_monitoring.enabled` is set to false, stream will not be instrumented.')
       return
     }
-
     if (!this.streamingEnabled) {
       this.logger.debug('`ai_monitoring.streaming.enabled` is set to false, stream will not be instrumented.')
       this.agent.metrics.getOrCreateMetric(STREAMING_DISABLED).incrementCallCount()
@@ -24,29 +23,32 @@ class LangchainRunnableStreamSubscriber extends LangchainRunnableSubscriber {
     }
 
     const ctx = this.agent.tracer.getContext()
-
     const { transaction } = ctx
     if (transaction?.isActive() !== true) {
       return
     }
 
-    // Extract data.
     const request = data?.arguments?.[0]
+    // Requests via LangGraph API have the `messages` property with the
+    // information we need, otherwise it just lives on the `request`
+    // object directly.
+    const userRequest = request?.messages ? request.messages?.[0] : request
     const params = data?.arguments?.[1] || {}
     const metadata = params?.metadata ?? {}
     const tags = params?.tags ?? []
     const { result: response, error: err } = data
 
-    // Instrument stream.
-    if (response?.next) {
-      this.wrapNextHandler({ response, ctx, request, metadata, tags })
+    // Note: as of 18.x `ReadableStream` is a global
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins
+    if (response instanceof ReadableStream) {
+      this.instrumentStream({ response, ctx, request: userRequest, metadata, tags })
     } else {
       // Input error occurred which means a stream was not created.
       // Skip instrumenting streaming and create Llm Events from
       // the data we have
       this.recordChatCompletionEvents({
         ctx,
-        request,
+        request: userRequest,
         err,
         metadata,
         tags
@@ -55,7 +57,7 @@ class LangchainRunnableStreamSubscriber extends LangchainRunnableSubscriber {
   }
 
   /**
-   * Wraps the next method on the IterableReadableStream. It will also record the Llm
+   * Wraps `read` method on the ReadableStream reader. It will also record the Llm
    * events when the stream is done processing.
    *
    * @param {object} params function params
@@ -65,56 +67,82 @@ class LangchainRunnableStreamSubscriber extends LangchainRunnableSubscriber {
    * @param {object} params.metadata metadata for the call
    * @param {Array} params.tags tags for the call
    */
-  wrapNextHandler({ ctx, response, request, metadata, tags }) {
+  instrumentStream({ ctx, response, request, metadata, tags }) {
     const self = this
-    const orig = response.next
-    let content = ''
-    const { segment } = ctx
-
-    async function wrappedIterator(...args) {
-      try {
-        const result = await orig.apply(this, args)
-        // only create Llm events when stream iteration is done
-        if (result?.done) {
+    const orig = response.getReader
+    response.getReader = function wrapedGetReader() {
+      const reader = orig.apply(this, arguments)
+      const origRead = reader.read
+      let responseContent = ''
+      reader.read = async function wrappedRead(...args) {
+        try {
+          const result = await origRead.apply(this, args)
+          if (result?.done) {
+            // only create Llm events when stream iteration is done
+            self.recordChatCompletionEvents({
+              ctx,
+              response: responseContent,
+              request,
+              metadata,
+              tags
+            })
+          } else {
+            // Concat the streamed content
+            responseContent = self.concatResponseContent(result, responseContent)
+          }
+          return result
+        } catch (error) {
           self.recordChatCompletionEvents({
             ctx,
             request,
-            response: content,
+            response: responseContent,
             metadata,
-            tags
+            tags,
+            err: error
           })
-        } else {
-          // Concat the streamed content
-          if (typeof result?.value?.content === 'string') {
-            // LangChain BaseMessageChunk case
-            content += result.value.content
-          } else if (typeof result?.value === 'string') {
-            // Base LangChain case
-            content += result.value
-          } else if (typeof result?.value?.[0] === 'string') {
-            // Array parser case
-            content += result.value[0]
-          }
+          throw error
+        } finally {
+          // update segment duration on every stream
+          // iteration to extend the timer
+          ctx.segment.touch()
         }
-        return result
-      } catch (error) {
-        self.recordChatCompletionEvents({
-          ctx,
-          request,
-          response: content,
-          metadata,
-          tags,
-          err: error
-        })
-        throw error
-      } finally {
-        // update segment duration on every stream iteration to extend
-        // the timer
-        segment.touch()
       }
+      return reader
+    }
+  }
+
+  /**
+   * Concats streamed content from various LangChain/LangGraph result formats.
+   *
+   * @param {object} result the stream result chunk
+   * @param {string|object} content the response so far
+   * @returns {string|object} updated response content. For LangGraph, it will return an object
+   * (e.g. AIMessage), so we have more info if we need to drop this response if it is incomplete
+   * (e.g outgoing tool call).
+   */
+  concatResponseContent(result, content) {
+    if (result?.value?.messages || result?.value?.agent?.messages) {
+      // LangGraph case:
+      // The result.value.%messages field contains all messages,
+      // request and response, and appends new events at the
+      // end of the array. Therefore, the last message is the
+      // relevant response object.
+      const langgraphMessages = result?.value?.messages ?? result?.value?.agent?.messages
+      if (langgraphMessages.length > 0) {
+        content = langgraphMessages[langgraphMessages.length - 1]
+      }
+    } else if (typeof result?.value?.content === 'string') {
+      // LangChain MessageChunk case
+      content += result.value.content
+    } else if (typeof result?.value === 'string') {
+      // Base LangChain case
+      content += result.value
+    } else if (typeof result?.value?.[0] === 'string') {
+      // LangChain array parser case
+      content += result.value[0]
     }
 
-    response.next = this.agent.tracer.bindFunction(wrappedIterator, ctx, false)
+    return content
   }
 }
 

package/lib/subscribers/langchain/runnable.js

@@ -21,10 +21,15 @@ class LangchainRunnableSubscriber extends AiMonitoringChatSubscriber {
     const ctx = this.agent.tracer.getContext()
     const request = data?.arguments?.[0]
     const params = data?.arguments?.[1] || {}
-    const { result: response, error: err } = data
+    const { result, error: err } = data
+    // Requests and responses via LangGraph API have the `messages`
+    // property with the information we need, otherwise it just
+    // lives on the `request`/`result` object directly.
+    const userRequest = request?.messages ? request.messages?.[0] : request
+    const response = result?.messages ? result.messages?.[0] : result
     this.recordChatCompletionEvents({
       ctx,
-      request,
+      request: userRequest,
       response,
       err,
       metadata: params?.metadata,
@@ -49,16 +54,26 @@ class LangchainRunnableSubscriber extends AiMonitoringChatSubscriber {
     })
   }
 
+  /**
+   * Determines if the LangChain request and response should be stored and
+   * later captured as `LlmChatCompletionMessage`s.
+   * @param {object} params function parameters
+   * @param {object|string} params.request request object (`{ content, role, ... }`) or string
+   * @param {object|string} params.response response object (`{ content, role, ... }`) or string
+   * @returns {object[]} an array with all of the valid request and response objects/strings
+   */
   getMessages({ request, response }) {
     const messages = []
-    // check if request is truthy and an empty string
     if (request || request === '') {
       messages.push(request)
     }
 
-    // check if response is truthy and an empty string
     if (response || response === '') {
-      messages.push(response)
+      // Add the response if it is NOT an outgoing
+      // tool call with no result yet
+      if (!(response?.content === '' && response?.tool_calls?.length > 0)) {
+        messages.push(response)
+      }
     }
 
     return messages
@@ -68,23 +83,13 @@ class LangchainRunnableSubscriber extends AiMonitoringChatSubscriber {
     const { segment, transaction } = ctx
     // check before grabbing a key from it in the AiMessageChunk case
     const isResponse = message === response
-    if (message?.content) {
-      message = message.content
-    }
-
-    let msgString
-    try {
-      msgString = typeof message === 'string' ? message : JSON.stringify(message)
-    } catch (error) {
-      this.logger.error(error, 'Failed to stringify message')
-      msgString = ''
-    }
+    const { content, role } = this.extractContentAndRole(message)
 
     return new LangChainCompletionMessage({
       sequence: index,
       agent: this.agent,
-      content: msgString,
-      role: message?.role,
+      content,
+      role,
       completionId,
       segment,
       transaction,
@@ -92,6 +97,46 @@ class LangchainRunnableSubscriber extends AiMonitoringChatSubscriber {
       isResponse
     })
   }
+
+  /**
+   * Grabs the message content and conversation role from the given
+   * LangChain message object.
+   * @param {object|string} msg The message, can be a variety of different types.
+   * @returns {object} an object with `content` (string) and `role` (string)
+   */
+  extractContentAndRole(msg) {
+    // Get message content
+    let content = ''
+    if (typeof msg === 'string') {
+      content = msg
+    } else if (typeof msg?.content === 'string') {
+      // If msg is a BaseMessage
+      content = msg.content
+    } else {
+      // Fallback for different kind of message
+      try {
+        content = JSON.stringify(msg)
+      } catch (error) {
+        this.logger.error(error, 'Failed to stringify message')
+      }
+    }
+
+    // Get conversation role
+    let role = msg?.role
+    if (msg?.type) {
+      // LangGraph defines this for us
+      if (msg.type === 'human') {
+        role = 'user'
+      } else if (msg.type === 'ai') {
+        role = 'assistant'
+      } else {
+        // e.g. tool
+        role = msg.type
+      }
+    }
+
+    return { content, role }
+  }
 }
 
 module.exports = LangchainRunnableSubscriber

package/lib/subscribers/langchain/tool.js

@@ -14,18 +14,19 @@ const LlmErrorMessage = require('../../llm-events/error-message')
 
 class LangchainToolSubscriber extends AiMonitoringSubscriber {
   constructor({ agent, logger }) {
-    super({ agent, logger, packageName: '@langchain/core', channelName: 'nr_call', trackingPrefix: LANGCHAIN.TRACKING_PREFIX, name: LANGCHAIN.TOOL })
+    super({ agent, logger, packageName: '@langchain/core', channelName: 'nr_call', trackingPrefix: LANGCHAIN.TRACKING_PREFIX, name: 'unknown' })
     this.events = ['asyncEnd']
     this.trackingPrefix = LANGCHAIN.TRACKING_PREFIX
   }
 
   handler(data, ctx) {
     const tool = data?.self
-    this.name = `${this.name}/${tool?.name}`
+    this.name = `${LANGCHAIN.TOOL}/${tool?.name}`
     return super.handler(data, ctx)
   }
 
   asyncEnd(data) {
+    // Extract data and exit early if need be.
     const { agent, logger } = this
     if (!this.enabled) {
       logger.debug('Langchain instrumentation is disabled, not recording Llm events.')
@@ -38,12 +39,23 @@ class LangchainToolSubscriber extends AiMonitoringSubscriber {
     }
     const { result, error: err } = data
     const { name, metadata: instanceMeta, description, tags: instanceTags } = data?.self
-    const request = data?.arguments?.[0]
+
+    // Get metadata and tags
     const params = data?.arguments?.[1] || {}
     const { metadata: paramsMeta, tags: paramsTags } = params
     const metadata = this.mergeMetadata(instanceMeta, paramsMeta)
     const tags = this.mergeTags(instanceTags, paramsTags)
 
+    // Get tool output and input
+    const request = data?.arguments?.[0]
+    const output = result?.content ?? result
+    let input
+    if (request?.input) {
+      input = request.input.toString()
+    } else if (request) {
+      input = JSON.stringify(request)
+    }
+
     segment.end()
 
     const toolEvent = new LangChainTool({
@@ -54,8 +66,8 @@ class LangchainToolSubscriber extends AiMonitoringSubscriber {
       metadata,
       transaction,
       tags,
-      input: request?.input,
-      output: result,
+      input,
+      output,
       segment,
       error: err != null
     })

package/lib/subscribers/langgraph/config.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// `Pregel` is the base class of the `CompiledStateGraph` (and others),
+// which is the class encapsulating a LangGraph agent.
+
+const graphStream = {
+  path: './langgraph/graph-stream.js',
+  instrumentations: [
+    // CommonJs
+    {
+      channelName: 'nr_stream',
+      module: { name: '@langchain/langgraph', versionRange: '>=1.0.0', filePath: 'dist/pregel/index.cjs' },
+      functionQuery: {
+        index: 1,
+        methodName: 'stream',
+        kind: 'Async'
+      }
+    },
+    // ESM
+    {
+      channelName: 'nr_stream',
+      module: { name: '@langchain/langgraph', versionRange: '>=1.0.0', filePath: 'dist/pregel/index.js' },
+      functionQuery: {
+        index: 1,
+        methodName: 'stream',
+        kind: 'Async'
+      }
+    },
+  ]
+}
+
+module.exports = {
+  '@langchain/langgraph': [
+    graphStream
+  ]
+}

package/lib/subscribers/langgraph/graph-stream.js

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const AiMonitoringSubscriber = require('../ai-monitoring/base')
+const LlmErrorMessage = require('#agentlib/llm-events/error-message.js')
+const LangGraphAgentEvent = require('#agentlib/llm-events/langgraph/agent.js')
+const { AI: { LANGGRAPH, STREAMING_DISABLED } } = require('#agentlib/metrics/names.js')
+
+class LangGraphStreamSubscriber extends AiMonitoringSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent,
+      logger,
+      packageName: '@langchain/langgraph',
+      channelName: 'nr_stream',
+      // 'agent' is the default name for an unknown AI
+      // agent or one with no name
+      name: `${LANGGRAPH.AGENT}/stream/agent`,
+      trackingPrefix: LANGGRAPH.TRACKING_PREFIX })
+    this.events = ['asyncEnd']
+  }
+
+  get streamingEnabled() {
+    return this.agent.config.ai_monitoring.streaming.enabled
+  }
+
+  handler(data, ctx) {
+    // Store LangGraph AI agent name and update
+    // segment name to use it.
+    this.aiAgentName = data?.self?.name ?? 'agent'
+    this.name = `${LANGGRAPH.AGENT}/stream/${this.aiAgentName}`
+    return super.handler(data, ctx)
+  }
+
+  asyncEnd(data) {
+    const { agent, logger, aiAgentName } = this
+    if (!this.enabled) {
+      logger.debug('LangGraph instrumentation is disabled, not instrumenting stream.')
+      return
+    }
+    if (!this.streamingEnabled) {
+      logger.debug('LangGraph streaming instrumentation is disabled, not instrumenting stream.')
+      this.agent.metrics.getOrCreateMetric(STREAMING_DISABLED).incrementCallCount()
+      return
+    }
+    const ctx = agent.tracer.getContext()
+    const { segment, transaction } = ctx
+    if (!(segment || transaction) || (transaction?.isActive() !== true)) {
+      return
+    }
+
+    const { error: initialErr, result: stream } = data
+    segment.addSpanAttribute('subcomponent', `{"type": "APM-AI_AGENT", "name": ${aiAgentName}}`)
+
+    if (initialErr) {
+      this.recordAiAgentEvent({ aiAgentName, transaction, segment, error: initialErr })
+      return
+    }
+
+    // Note: as of 18.x `ReadableStream` is a global
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins
+    if (stream instanceof ReadableStream) {
+      this.instrumentStream({ stream, segment, transaction, aiAgentName })
+    }
+  }
+
+  instrumentStream({ stream, segment, transaction, aiAgentName }) {
+    const self = this
+    const orig = stream.getReader
+    stream.getReader = function wrappedGetReaderLangGraph() {
+      const reader = orig.apply(this, arguments)
+      const origRead = reader.read
+      reader.read = async function wrappedLangGraphRead(...args) {
+        try {
+          const result = await origRead.apply(this, args)
+          if (result?.done) {
+            self.recordAiAgentEvent({ aiAgentName, transaction, segment, error: false })
+          }
+          return result
+        } catch (err) {
+          self.recordAiAgentEvent({ aiAgentName, transaction, segment, error: err })
+          throw err
+        } finally {
+          // update segment duration on every stream
+          // iteration to extend the timer
+          segment.touch()
+        }
+      }
+      return reader
+    }
+  }
+
+  /**
+   * Records a LangGraph `LlmAgent` event and a `LlmErrorMessage` event
+   * if an error occurred.
+   *
+   * @param {object} params function parameters
+   * @param {string} params.aiAgentName LangGraph AI agent name
+   * @param {object} params.transaction current transaction
+   * @param {object} params.segment current segment
+   * @param {object} [params.error] an error if it occurred
+   */
+  recordAiAgentEvent({ aiAgentName, transaction, segment, error }) {
+    const { agent } = this
+    segment.end()
+    const agentEvent = new LangGraphAgentEvent({
+      agent,
+      name: aiAgentName,
+      transaction,
+      segment,
+      error: !!error
+    })
+
+    this.recordEvent({ type: 'LlmAgent', msg: agentEvent })
+
+    if (error) {
+      agent.errors.add(
+        transaction,
+        error,
+        new LlmErrorMessage({
+          response: {},
+          cause: error,
+          aiAgent: agentEvent
+        })
+      )
+    }
+  }
+}
+
+module.exports = LangGraphStreamSubscriber

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

@@ -7,8 +7,7 @@
 
 const logger = require('../../logger').child({ component: 'partial-trace' })
 const { PARTIAL_TRACE } = require('../../metrics/names')
-const { Attributes } = require('#agentlib/attributes.js')
-
+const { SPAN_EVENTS } = require('#agentlib/metrics/names.js')
 /**
  * A PartialTrace manages span processing for partial granularity traces.
  * It handles span reparenting, compaction logic, and finalization of span events.
@@ -58,6 +57,7 @@ class PartialTrace {
    * Runs a span through partial tracing rules.
    * If the span is null, it indicates that the span was dropped,
    * and we must keep track of its id and parentId for potential reparenting.
+   * Also reparents span links from dropped spans.
    *
    * @param {object} params to function
    * @param {string} params.span to apply partial rules to
@@ -66,16 +66,15 @@ class PartialTrace {
   addSpan({ span, isEntry }) {
     const id = span.id
     const parentId = span.parentId
+
+    // capture necessary information for reparenting span links before span is potentially dropped
     const spanLinks = span.spanLinks
+    const exitSpan = span.isExitSpan
+    const hasEntityAttrs = span.hasEntityRelationshipAttrs
+
     span = span.applyPartialTraceRules({ isEntry, partialTrace: this })
     this.createMetrics(!!span)
 
-    if (spanLinks && spanLinks.length > 0) {
-      if (this.type === 'essential') {
-        this.removeNonIntrinsicsAttrs(spanLinks)
-      }
-    }
-
     if (span) {
       // span was not dropped, add to trace until all spans have been processed
       this.spans.push(span)
@@ -88,41 +87,34 @@ class PartialTrace {
 
       // 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)
-      }
+      this.reparentSpanLinks(this.spans.at(-1), spanLinks)
+    } else if ((this.type === 'compact') && (!exitSpan || !hasEntityAttrs)) {
+      // we still need to reparent links for dropped spans in compact mode that are not exit
+      // span or spans without entity relationship attributes
+      this.reparentSpanLinks(this.spans.at(-1), spanLinks)
     }
   }
 
   /**
-   * Iterates over the span links from a span and removes all non-intrinsic attributes.
-   *
-   * @param {SpanLink[]} spanLinks an array of span links to reparent to last kept span
-   */
-  removeNonIntrinsicsAttrs(spanLinks) {
-    for (const link of spanLinks) {
-      link.userAttributes = new Attributes({ scope: Attributes.SCOPE_SEGMENT })
-      link.agentAttributes = new Attributes({ scope: Attributes.SCOPE_SEGMENT })
-    }
-  }
-
-  /**
-   * Iterates over the span links from a dropped span and reassigns them to the last kept span.
+   * Iterates over the span links from a dropped span and reassigns them to the span to reparent to.
    * 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
+   * @param {SpanEvent} span the span to reparent span links to
+   * @param {SpanLink[]} spanLinksToReparent an array of span links to reparent to last kept span
    */
-  reparentSpanLinks(spanLinks) {
-    const lastSpan = this.spans.at(-1)
-
+  reparentSpanLinks(span, spanLinksToReparent = []) {
     // 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
-    }
+    for (const link of spanLinksToReparent) {
+      if (span.spanLinks.length === 100) {
+        logger.trace('Span links limit reached. Not moving additional span links.')
+        this.transaction.agent.metrics.getOrCreateMetric(SPAN_EVENTS.LINKS_DROPPED).incrementCallCount()
+        return
+      }
 
-    // move the span links events to the last kept span
-    Array.prototype.push.apply(lastSpan.spanLinks, spanLinks)
+      link.intrinsics.id = span.id
+      span.spanLinks.push(link)
+    }
   }
 
   /**
@@ -195,7 +187,7 @@ class PartialTrace {
   /**
    * Checks if span was the retained exit span for a given entity and it has other spans that talked to the same
    * entity. It will then sort all timestamps for spans that got dropped and calculate the `nr.durations` and assign
-   * `nr.ids` for all dropped spans to same entity.
+   * `nr.ids` for all dropped spans to same entity. It will also reparent the span links from dropped spans to the retained exit span.
    *
    * @param {SpanEvent} span to check if it has to calculate `nr.durations` and `nr.ids`
    */
@@ -221,7 +213,8 @@ class PartialTrace {
       totalDuration: 0,
       currentStart: null,
       currentEnd: null,
-      errorSpan: null
+      errorSpan: null,
+      spanLinks: []
     }
 
     // timestamps must be sorted to accurately calculate overlapping durations
@@ -238,6 +231,8 @@ class PartialTrace {
         } else {
           meta.droppedIds++
         }
+
+        Array.prototype.push.apply(meta.spanLinks, sameEntitySpan.spanLinks)
       }
 
       this.compactionError(meta, sameEntitySpan)
@@ -245,6 +240,8 @@ class PartialTrace {
     }
 
     this.assignCompactAttrs({ span, meta })
+
+    this.reparentSpanLinks(span, meta.spanLinks)
   }
 
   assignCompactAttrs({ span, meta }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "13.11.0",
+  "version": "13.12.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [