newrelic 13.7.0 → 13.8.0

package/lib/subscribers/google-genai/base.js

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const {
+  LlmChatCompletionMessage,
+  LlmChatCompletionSummary,
+  LlmErrorMessage
+} = require('../../../lib/llm-events/google-genai')
+const { extractLlmContext } = require('../../util/llm-utils')
+const { AI } = require('../../../lib/metrics/names')
+const { GEMINI } = AI
+const { DESTINATIONS } = require('../../config/attribute-filter')
+
+const Subscriber = require('../base')
+
+class GoogleGenAISubscriber extends Subscriber {
+  constructor({ agent, logger, channelName, packageName = '@google/genai' }) {
+    super({ agent, logger, channelName, packageName })
+    this.events = ['asyncEnd']
+  }
+
+  get enabled() {
+    return super.enabled && this.agent.config.ai_monitoring.enabled
+  }
+
+  /**
+   * 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)
+
+    this.agent.customEventAggregator.add([
+      { type, timestamp: Date.now() },
+      Object.assign({}, msg, llmContext)
+    ])
+  }
+
+  /**
+   * Generates LlmChatCompletionSummary for a chat completion creation.
+   * Also iterates over both input messages and the first response message
+   * and creates LlmChatCompletionMessage.
+   *
+   * Also assigns relevant ids by response id for LlmFeedbackEvent creation
+   *
+   * @param {object} params input params
+   * @param {TraceSegment} params.segment active segment from chat completion
+   * @param {object} params.request chat completion params
+   * @param {object} [params.response] chat completion response
+   * @param {boolean} [params.err] err if it exists
+   * @param {Transaction} params.transaction active transaction
+   */
+  recordChatCompletionMessages({
+    segment,
+    request,
+    response = {},
+    err,
+    transaction
+  }) {
+    const agent = this.agent
+
+    // Explicitly end segment to provide consistent duration
+    // for both LLM events and the segment
+    segment.end()
+    const completionSummary = new LlmChatCompletionSummary({
+      agent,
+      segment,
+      transaction,
+      request,
+      response,
+      withError: err != null
+    })
+
+    // 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
+    const messages = responseMessage !== undefined ? [...inputMessages, responseMessage] : inputMessages
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i]
+      const completionMsg = new LlmChatCompletionMessage({
+        agent,
+        segment,
+        transaction,
+        request,
+        response,
+        index: i,
+        completionId: completionSummary.id,
+        message
+      })
+
+      this.recordEvent({ type: 'LlmChatCompletionMessage', msg: completionMsg })
+    }
+
+    this.recordEvent({ type: 'LlmChatCompletionSummary', msg: completionSummary })
+
+    if (err) {
+      const llmError = new LlmErrorMessage({ cause: err, summary: completionSummary, response })
+      agent.errors.add(transaction, err, llmError)
+    }
+  }
+
+  /**
+   * Increments the tracking metric and sets the llm attribute on transactions
+   *
+   * @param {object} params input params
+   * @param {Transaction} params.transaction active transaction
+   * @param {string} params.version package version
+   */
+  addLlmMeta({ transaction, version }) {
+    const TRACKING_METRIC = `${GEMINI.TRACKING_PREFIX}/${version}`
+    this.agent.metrics.getOrCreateMetric(TRACKING_METRIC).incrementCallCount()
+    transaction.trace.attributes.addAttribute(DESTINATIONS.TRANS_EVENT, 'llm', true)
+  }
+}
+
+module.exports = GoogleGenAISubscriber

package/lib/subscribers/google-genai/config.js

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const generateContentInternal = {
+  path: './google-genai/generate-content.js',
+  instrumentations: [
+    {
+      channelName: 'nr_generateContentInternal',
+      module: { name: '@google/genai', versionRange: '>=1.1.0', filePath: 'dist/node/index.cjs' },
+      functionQuery: {
+        className: 'Models',
+        methodName: 'generateContentInternal',
+        kind: 'Async'
+      }
+    },
+    {
+      channelName: 'nr_generateContentInternal',
+      module: { name: '@google/genai', versionRange: '>=1.1.0', filePath: 'dist/node/index.mjs' },
+      functionQuery: {
+        className: 'Models',
+        methodName: 'generateContentInternal',
+        kind: 'Async'
+      }
+    }
+  ]
+}
+
+const generateContentStreamInternal = {
+  path: './google-genai/generate-content-stream.js',
+  instrumentations: [
+    {
+      channelName: 'nr_generateContentStreamInternal',
+      module: { name: '@google/genai', versionRange: '>=1.1.0', filePath: 'dist/node/index.cjs' },
+      functionQuery: {
+        className: 'Models',
+        methodName: 'generateContentStreamInternal',
+        kind: 'Async'
+      }
+    },
+    {
+      channelName: 'nr_generateContentStreamInternal',
+      module: { name: '@google/genai', versionRange: '>=1.1.0', filePath: 'dist/node/index.mjs' },
+      functionQuery: {
+        className: 'Models',
+        methodName: 'generateContentStreamInternal',
+        kind: 'Async'
+      }
+    }
+  ]
+}
+
+const embedContent = {
+  path: './google-genai/embed-content.js',
+  instrumentations: [
+    {
+      channelName: 'nr_embedContent',
+      module: { name: '@google/genai', versionRange: '>=1.1.0', filePath: 'dist/node/index.cjs' },
+      functionQuery: {
+        className: 'Models',
+        methodName: 'embedContent',
+        kind: 'Async'
+      }
+    },
+    {
+      channelName: 'nr_embedContent',
+      module: { name: '@google/genai', versionRange: '>=1.1.0', filePath: 'dist/node/index.mjs' },
+      functionQuery: {
+        className: 'Models',
+        methodName: 'embedContent',
+        kind: 'Async'
+      }
+    }
+  ]
+}
+
+module.exports = {
+  '@google/genai': [
+    generateContentInternal,
+    generateContentStreamInternal,
+    embedContent
+  ]
+}

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

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const GoogleGenAISubscriber = require('./base')
+const { AI } = require('../../../lib/metrics/names')
+const { GEMINI } = AI
+const {
+  LlmErrorMessage,
+  LlmEmbedding
+} = require('../../../lib/llm-events/google-genai')
+
+class GoogleGenAIEmbedContentSubscriber extends GoogleGenAISubscriber {
+  constructor ({ agent, logger }) {
+    super({ agent, logger, channelName: 'nr_embedContent' })
+  }
+
+  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
+    })
+    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 })
+    // 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,
+      request,
+      response,
+      withError: err != null
+    })
+
+    this.recordEvent({ type: 'LlmEmbedding', msg: embedding })
+
+    if (err) {
+      const llmError = new LlmErrorMessage({ cause: err, embedding, response })
+      agent.errors.add(ctx.transaction, err, llmError)
+    }
+  }
+}
+
+module.exports = GoogleGenAIEmbedContentSubscriber

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

@@ -0,0 +1,125 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const GoogleGenAIGenerateContentSubscriber = require('./generate-content')
+const { AI } = require('../../../lib/metrics/names')
+
+class GoogleGenAIGenerateContentStreamSubscriber extends GoogleGenAIGenerateContentSubscriber {
+  constructor({ agent, logger }) {
+    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
+   */
+  instrumentStream({ request, response, segment, transaction }) {
+    const self = this
+    const originalNext = response.next
+    let isDone = false
+    let cachedResult = {}
+    let err
+    let entireMessage = ''
+    response.next = async function wrappedNext(...nextArgs) {
+      let result = {}
+      try {
+        result = await originalNext.apply(response, nextArgs)
+        // When the stream is done we get {value: undefined, done: true}
+        // we need to cache the composed value and add the entire message
+        // back in later
+        if (result.done === true) {
+          isDone = true
+        } else {
+          cachedResult = result.value
+        }
+
+        if (result?.value?.text) {
+          entireMessage += result.value.text // readonly variable that equates to result.value.candidates[0].content.parts[0].text
+        }
+      } catch (streamErr) {
+        err = streamErr
+        throw err
+      } finally {
+        // Update segment duration since we want to extend the
+        // time it took to handle the stream
+        segment.touch()
+
+        // also need to enter this block if there was an
+        // error, so we can record it
+        if (isDone || err) {
+          if (cachedResult?.candidates?.[0]?.content?.parts) {
+            cachedResult.candidates[0].content.parts[0].text = entireMessage
+          }
+          self.recordChatCompletionMessages({
+            segment,
+            transaction,
+            request,
+            response: cachedResult,
+            err
+          })
+        }
+      }
+      return result
+    }
+  }
+
+  asyncEnd(data) {
+    // Check config is ai_monitoring is still enabled
+    if (!this.streamingEnabled) {
+      this.logger.warn(
+        '`ai_monitoring.streaming.enabled` is set to `false`, stream will not be instrumented.'
+      )
+      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({
+      request,
+      response,
+      segment: ctx.segment,
+      transaction: ctx.transaction,
+    })
+
+    this.addLlmMeta({
+      transaction: ctx.transaction,
+      version: data.moduleVersion,
+    })
+  }
+}
+
+module.exports = GoogleGenAIGenerateContentStreamSubscriber

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const GoogleGenAISubscriber = require('./base')
+const { AI } = require('../../metrics/names')
+const { GEMINI } = AI
+
+class GoogleGenAIGenerateContentSubscriber extends GoogleGenAISubscriber {
+  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 })
+  }
+
+  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,
+      request,
+      response,
+      err
+    })
+
+    this.addLlmMeta({
+      transaction: ctx.transaction,
+      version: data.moduleVersion
+    })
+  }
+}
+
+module.exports = GoogleGenAIGenerateContentSubscriber

package/lib/transaction/index.js

@@ -67,6 +67,12 @@ const MULTIPLE_INSERT_MESSAGE =
   'insertDistributedTraceHeaders called on headers object that already contains ' +
   "distributed trace data. These may be overwritten. traceparent? '%s', newrelic? '%s'."
 
+const PARTIAL_TYPES = {
+  REDUCED: 'reduced',
+  ESSENTIAL: 'essential',
+  COMPACT: 'compact'
+}
+
 /**
  * Bundle together the metrics and the trace segment for a single agent
  * transaction.
@@ -166,6 +172,7 @@ Transaction.TYPES_SET = TYPES_SET
 Transaction.TRANSPORT_TYPES = TRANSPORT_TYPES
 Transaction.TRANSPORT_TYPES_SET = TRANSPORT_TYPES_SET
 Transaction.TRACE_CONTEXT_PARENT_HEADER = TRACE_CONTEXT_PARENT_HEADER
+Transaction.PARTIAL_TYPES = PARTIAL_TYPES
 
 /**
  * Add a clear API method for determining whether a transaction is web or

package/lib/transaction/trace/index.js

@@ -63,6 +63,8 @@ function Trace(transaction) {
     this.displayName = displayName
   }
   this.domain = null
+  this.spans = []
+  this.droppedSpans = new Map()
 }
 
 /**
@@ -79,11 +81,86 @@ Trace.prototype.end = function end(node = this.segments.root) {
   }
 }
 
+/**
+ * Adds a span to the trace. 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.
+ *
+ * @param {object} params to function
+ * @param {Span} [params.span] span to add, if present
+ * @param {string} params.id id of dropped span
+ * @param {string} params.parentId parentId of dropped span
+ */
+Trace.prototype.addSpan = function addSpan({ span, id, parentId }) {
+  // span was not dropped, add to trace until all spans have been processed
+  if (span) {
+    this.spans.push(span)
+  // span was dropped so keep track of its id and parent as any spans
+  // whose parent id was dropped needs to update to this new id
+  } else {
+    this.droppedSpans.set(id, parentId)
+  }
+}
+
+/**
+ * Iterates over dropped spans and reparents span if its current parent was dropped.
+ * It'll traverse until it finds a parent that wasn't dropped or there are no more parents to check.
+ *
+ * @param {Span} span the span to potentially reparent
+ */
+Trace.prototype.maybeReparentSpan = function maybeReparentSpan(span) {
+  let result = this.droppedSpans.get(span.parentId)
+  while (this.droppedSpans.has(result)) {
+    result = this.droppedSpans.get(result)
+  }
+
+  if (result) {
+    logger.debug(`Reparenting span ${span.id} from parent ${span.parentId} to ${result}`)
+    span.addIntrinsicAttribute('parentId', result)
+  }
+}
+
+/**
+ * Finalizes span events for partial traces by reparenting spans)
+ * if their parent was dropped, associates `nr.ids` and `nr.duratiosn` intrinsics for
+ * partial traces of type `compact`. Lastly, adds the span events to the span event
+ * aggregator.
+ *
+ * Note: This is a no-op for full traces and traces using infinite tracing.
+ */
+Trace.prototype.finalizeSpanEvents = function finalizeSpanEvents() {
+  if (!this.transaction.partialType) {
+    logger.debug('Trace is full granularity, not finalizing span events.')
+    return
+  }
+
+  if (this.transaction.agent.spanEventAggregator.toString() === 'StreamingSpanEventAggregator') {
+    logger.debug('Infinite tracing is enabled, not finalizing span events.')
+    return
+  }
+
+  for (const span of this.spans) {
+    this.maybeReparentSpan(span)
+    this.transaction.agent.spanEventAggregator.add(span, this.transaction.priority)
+  }
+
+  this.spans.length = 0
+  this.droppedSpans.clear()
+}
+
+/**
+ * Creates span events for all segments in the trace.
+ * Finalizes spans for partial traces by reparenting spans if their parent was dropped,
+ * and applying `compact` logic to assign`nr.ids` and `nr.durations` intrinsics.
+ */
+Trace.prototype.generateSpanEvents = function generateSpanEvents() {
+  this.generateSpans(this.segments.root)
+  this.finalizeSpanEvents()
+}
 /**
  * Iterates over the trace tree and generates a span event for each segment.
  * @param {Node} [node] the node to process the segment and its children
  */
-Trace.prototype.generateSpanEvents = function generateSpanEvents(node = this.segments.root) {
+Trace.prototype.generateSpans = function generateSpans(node = this.segments.root) {
   const config = this.transaction.agent.config
 
   if (!shouldGenerateSpanEvents(config, this.transaction)) {
@@ -127,7 +204,7 @@ Trace.prototype.generateSpanEvents = function generateSpanEvents(node = this.seg
   }
 
   for (let i = 0; i < children.length; ++i) {
-    this.generateSpanEvents(children[i])
+    this.generateSpans(children[i])
   }
 }
 

package/package.json

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