newrelic 12.11.1 → 12.11.3

package/NEWS.md

@@ -1,3 +1,44 @@
+### v12.11.3 (2025-01-29)
+
+#### Bug fixes
+
+* Fixed issue with `bluebird` and `when` instrumentation where checking active context crashed when transaction prematurely ends ([#2909](https://github.com/newrelic/node-newrelic/pull/2909)) ([4a30d5c](https://github.com/newrelic/node-newrelic/commit/4a30d5c5082e963cca3664f2ed152017f6360d21))
+* Fixed transaction-shim to properly create new transactions when the existing transaction is not active ([#2912](https://github.com/newrelic/node-newrelic/pull/2912)) ([3ad8c59](https://github.com/newrelic/node-newrelic/commit/3ad8c59e15e037a366ddf6803729b61ecfa701f3))
+
+#### Documentation
+
+* Updated compatibility report ([#2902](https://github.com/newrelic/node-newrelic/pull/2902)) ([cb16516](https://github.com/newrelic/node-newrelic/commit/cb16516e90a3dc2cefb98e6131a7243412aefbfc))
+
+#### Miscellaneous chores
+
+* Updated lint rule suppression comment ([#2895](https://github.com/newrelic/node-newrelic/pull/2895)) ([559dc98](https://github.com/newrelic/node-newrelic/commit/559dc98e18c8ba8280b73779780f3efc1c946ed7))
+
+#### Continuous integration
+
+* Move init container release from lambda to GHA ([#2848](https://github.com/newrelic/node-newrelic/pull/2848)) ([8d8608d](https://github.com/newrelic/node-newrelic/commit/8d8608d1089cafaeb8c17354034c96fe1b49597a))
+
+### v12.11.2 (2025-01-23)
+
+#### Features
+
+* Added support for Claude 3+ Chat API in Bedrock ([#2870](https://github.com/newrelic/node-newrelic/pull/2870)) ([6a83abf](https://github.com/newrelic/node-newrelic/commit/6a83abf8b1a0cb0f993e9d9285566a09677d7d2e))
+
+#### Bug fixes
+
+* Added defensive code in shim to prevent crashing when checking parent segment ([#2898](https://github.com/newrelic/node-newrelic/pull/2898)) ([751eb96](https://github.com/newrelic/node-newrelic/commit/751eb9608d7401d1123a0e810eac9dc554127e4e))
+
+#### Documentation
+
+* Updated compatibility report ([#2888](https://github.com/newrelic/node-newrelic/pull/2888)) ([dce9deb](https://github.com/newrelic/node-newrelic/commit/dce9debeda6c5ed30c0ed6dbc00f73cf11c8f40f))
+
+#### Miscellaneous chores
+
+* Replaced backtracking regex with new algorithm ([#2887](https://github.com/newrelic/node-newrelic/pull/2887)) ([46462d0](https://github.com/newrelic/node-newrelic/commit/46462d00b68c4a4cedd60d46d531b2f31800df98))
+
+#### Tests
+
+* Improved test coverage of normalizing claude 3 messages ([#2893](https://github.com/newrelic/node-newrelic/pull/2893)) ([cc65763](https://github.com/newrelic/node-newrelic/commit/cc657633b81daf4b372e5715e696ed3c23ecb678))
+
 ### v12.11.1 (2025-01-16)
 
 #### Bug fixes

package/lib/db/utils.js

@@ -11,9 +11,9 @@ function extractDatabaseChangeFromUse(sql) {
   // The character ranges for this were pulled from
   // http://dev.mysql.com/doc/refman/5.7/en/identifiers.html
 
-  // Suppressing a warning on this regex because it is not obvious what this
-  // regex does, and we don't want to break anything.
-  // eslint-disable-next-line sonarjs/slow-regex, sonarjs/duplicates-in-character-class
-  const match = /^\s*use[^\w`]+([\w$_\u0080-\uFFFF]+|`[^`]+`)[\s;]*$/i.exec(sql)
+  // The lint rule being suppressed here has been evaluated, and it has been
+  // determined that the regular expression is sufficient for our use case.
+  // eslint-disable-next-line sonarjs/slow-regex
+  const match = /^\s*use[^\w`]+([\w$\u0080-\uFFFF]+|`[^`]+`)[\s;]*$/i.exec(sql)
   return (match && match[1]) || null
 }

package/lib/header-attributes.js

@@ -95,10 +95,10 @@ function _headerToCamelCase(header) {
   const newHeader = header.charAt(0).toLowerCase() + header.slice(1)
 
   // Converts headers in the form 'header-name' to be in the form 'headerName'
-  // eslint-disable-next-line sonarjs/slow-regex
-  return newHeader.replace(/[\W_]+(\w)/g, function capitalize(m, $1) {
-    return $1.toUpperCase()
-  })
+  return newHeader.split(/[\W_]/).map((ele, i) => {
+    if (i === 0) return ele
+    return ele.slice(0, 1).toUpperCase() + ele.slice(1)
+  }).join('')
 }
 
 function _collectHeaders(headers, nameMap, prefix, transaction) {

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

@@ -118,18 +118,24 @@ function recordChatCompletionMessages({
     isError: err !== null
   })
 
-  const msg = new LlmChatCompletionMessage({
-    agent,
-    segment,
-    bedrockCommand,
-    bedrockResponse,
-    transaction,
-    index: 0,
-    completionId: summary.id
+  // Record context message(s)
+  const promptContextMessages = bedrockCommand.prompt
+  promptContextMessages.forEach((contextMessage, promptIndex) => {
+    const msg = new LlmChatCompletionMessage({
+      agent,
+      segment,
+      transaction,
+      bedrockCommand,
+      content: contextMessage.content,
+      role: contextMessage.role,
+      bedrockResponse,
+      index: promptIndex,
+      completionId: summary.id
+    })
+    recordEvent({ agent, type: 'LlmChatCompletionMessage', msg })
   })
-  recordEvent({ agent, type: 'LlmChatCompletionMessage', msg })
 
-  bedrockResponse.completions.forEach((content, index) => {
+  bedrockResponse.completions.forEach((content, completionIndex) => {
     const chatCompletionMessage = new LlmChatCompletionMessage({
       agent,
       segment,
@@ -137,8 +143,9 @@ function recordChatCompletionMessages({
       bedrockCommand,
       bedrockResponse,
       isResponse: true,
-      index: index + 1,
+      index: promptContextMessages.length + completionIndex,
       content,
+      role: 'assistant',
       completionId: summary.id
     })
     recordEvent({ agent, type: 'LlmChatCompletionMessage', msg: chatCompletionMessage })
@@ -179,18 +186,22 @@ function recordEmbeddingMessage({
     return
   }
 
-  const embedding = new LlmEmbedding({
+  const embeddings = bedrockCommand.prompt.map(prompt => new LlmEmbedding({
     agent,
     segment,
     transaction,
     bedrockCommand,
+    input: prompt.content,
     bedrockResponse,
     isError: err !== null
+  }))
+
+  embeddings.forEach(embedding => {
+    recordEvent({ agent, type: 'LlmEmbedding', msg: embedding })
   })
 
-  recordEvent({ agent, type: 'LlmEmbedding', msg: embedding })
   if (err) {
-    const llmError = new LlmError({ bedrockResponse, err, embedding })
+    const llmError = new LlmError({ bedrockResponse, err, embedding: embeddings.length === 1 ? embeddings[0] : undefined })
     agent.errors.add(transaction, err, llmError)
   }
 }

package/lib/instrumentation/when/contextualizer.js

@@ -116,7 +116,8 @@ Contextualizer.prototype = Object.create(null)
 Contextualizer.prototype.isActive = function isActive() {
   const segments = this.context.segments
   const segment = segments[this.idx] || segments[this.parentIdx] || segments[0]
-  return segment && this.context.transaction.isActive()
+  const transaction = this.getTransaction()
+  return segment && transaction?.isActive()
 }
 
 /**

package/lib/llm-events/aws-bedrock/bedrock-command.js

@@ -5,6 +5,8 @@
 
 'use strict'
 
+const { stringifyClaudeChunkedMessage } = require('./utils')
+
 /**
  * Parses an AWS invoke command instance into a re-usable entity.
  */
@@ -68,37 +70,34 @@ class BedrockCommand {
   /**
    * The question posed to the LLM.
    *
-   * @returns {string|string[]|undefined}
+   * @returns {object[]} The array of context messages passed to the LLM (or a single user prompt for legacy "non-chat" models)
    */
   get prompt() {
-    let result
     if (this.isTitan() === true || this.isTitanEmbed() === true) {
-      result = this.#body.inputText
+      return [
+        {
+          role: 'user',
+          content: this.#body.inputText
+        }
+      ]
     } else if (this.isCohereEmbed() === true) {
-      result = this.#body.texts.join(' ')
+      return [
+        {
+          role: 'user',
+          content: this.#body.texts.join(' ')
+        }
+      ]
     } else if (
-      this.isClaude() === true ||
+      this.isClaudeTextCompletionApi() === true ||
       this.isAi21() === true ||
       this.isCohere() === true ||
       this.isLlama() === true
     ) {
-      result = this.#body.prompt
-    } else if (this.isClaude3() === true) {
-      const collected = []
-      for (const message of this.#body?.messages) {
-        if (message?.role === 'assistant') {
-          continue
-        }
-        if (typeof message?.content === 'string') {
-          collected.push(message?.content)
-          continue
-        }
-        const mappedMsgObj = message?.content.map((msgContent) => msgContent.text)
-        collected.push(mappedMsgObj)
-      }
-      result = collected.join(' ')
+      return [{ role: 'user', content: this.#body.prompt }]
+    } else if (this.isClaudeMessagesApi() === true) {
+      return normalizeClaude3Messages(this.#body?.messages)
     }
-    return result
+    return []
   }
 
   /**
@@ -151,6 +150,41 @@ class BedrockCommand {
   isTitanEmbed() {
     return this.#modelId.startsWith('amazon.titan-embed')
   }
+
+  isClaudeMessagesApi() {
+    return (this.isClaude3() === true || this.isClaude() === true) && 'messages' in this.#body
+  }
+
+  isClaudeTextCompletionApi() {
+    return this.isClaude() === true && 'prompt' in this.#body
+  }
+}
+
+/**
+ * Claude v3 requests in Bedrock can have two different "chat" flavors. This function normalizes them into a consistent
+ * format per the AIM agent spec
+ *
+ * @param messages - The raw array of messages passed to the invoke API
+ * @returns {number|undefined} - The normalized messages
+ */
+function normalizeClaude3Messages(messages) {
+  const result = []
+  for (const message of messages ?? []) {
+    if (message == null) {
+      continue
+    }
+    if (typeof message.content === 'string') {
+      // Messages can be specified with plain string content
+      result.push({ role: message.role, content: message.content })
+    } else if (Array.isArray(message.content)) {
+      // Or in a "chunked" format for multi-modal support
+      result.push({
+        role: message.role,
+        content: stringifyClaudeChunkedMessage(message.content)
+      })
+    }
+  }
+  return result
 }
 
 module.exports = BedrockCommand

package/lib/llm-events/aws-bedrock/bedrock-response.js

@@ -5,6 +5,8 @@
 
 'use strict'
 
+const { stringifyClaudeChunkedMessage } = require('./utils')
+
 /**
  * @typedef {object} AwsBedrockMiddlewareResponse
  * @property {object} response Has a `body` property that is an IncomingMessage,
@@ -63,7 +65,7 @@ class BedrockResponse {
         // Streamed response
         this.#completions = body.completions
       } else {
-        this.#completions = body?.content?.map((c) => c.text)
+        this.#completions = [stringifyClaudeChunkedMessage(body?.content)]
       }
       this.#id = body.id
     } else if (cmd.isCohere() === true) {

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

@@ -39,7 +39,7 @@ class LlmChatCompletionMessage extends LlmEvent {
     params = Object.assign({}, defaultParams, params)
     super(params)
 
-    const { agent, content, isResponse, index, completionId } = params
+    const { agent, content, isResponse, index, completionId, role } = params
     const recordContent = agent.config?.ai_monitoring?.record_content?.enabled
     const tokenCB = agent?.llm?.tokenCountCallback
 
@@ -47,20 +47,11 @@ class LlmChatCompletionMessage extends LlmEvent {
     this.completion_id = completionId
     this.sequence = index
     this.content = recordContent === true ? content : undefined
-    this.role = ''
+    this.role = role
 
     this.#setId(index)
-    if (this.is_response === true) {
-      this.role = 'assistant'
-      if (typeof tokenCB === 'function') {
-        this.token_count = tokenCB(this.bedrockCommand.modelId, content)
-      }
-    } else {
-      this.role = 'user'
-      this.content = recordContent === true ? this.bedrockCommand.prompt : undefined
-      if (typeof tokenCB === 'function') {
-        this.token_count = tokenCB(this.bedrockCommand.modelId, this.bedrockCommand.prompt)
-      }
+    if (typeof tokenCB === 'function') {
+      this.token_count = tokenCB(this.bedrockCommand.modelId, content)
     }
   }
 

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

@@ -36,7 +36,7 @@ class LlmChatCompletionSummary extends LlmEvent {
     const cmd = this.bedrockCommand
     this[cfr] = this.bedrockResponse.finishReason
     this[rt] = cmd.temperature
-    this[nm] = 1 + this.bedrockResponse.completions.length
+    this[nm] = (this.bedrockCommand.prompt.length) + this.bedrockResponse.completions.length
   }
 }
 

package/lib/llm-events/aws-bedrock/embedding.js

@@ -10,7 +10,7 @@ const LlmEvent = require('./event')
 /**
  * @typedef {object} LlmEmbeddingParams
  * @augments LlmEventParams
- * @property
+ * @property {string} input - The input message for the embedding call
  */
 /**
  * @type {LlmEmbeddingParams}
@@ -20,16 +20,18 @@ const defaultParams = {}
 class LlmEmbedding extends LlmEvent {
   constructor(params = defaultParams) {
     super(params)
-    const { agent } = params
+    const { agent, input } = params
     const tokenCb = agent?.llm?.tokenCountCallback
 
     this.input = agent.config?.ai_monitoring?.record_content?.enabled
-      ? this.bedrockCommand.prompt
+      ? input
       : undefined
     this.error = params.isError
     this.duration = params.segment.getDurationInMillis()
+
+    // Even if not recording content, we should use the local token counting callback to record token usage
     if (typeof tokenCb === 'function') {
-      this.token_count = tokenCb(this.bedrockCommand.modelId, this.bedrockCommand.prompt)
+      this.token_count = tokenCb(this.bedrockCommand.modelId, input)
     }
   }
 }

package/lib/llm-events/aws-bedrock/utils.js

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+/**
+ *
+ * @param {object[]} chunks - The "chunks" that make up a single conceptual message. In a multi-modal scenario, a single message
+ * might have a number of different-typed chunks interspersed
+ * @returns {string} - A stringified version of the message. We make a best-effort effort attempt to represent non-text chunks. In the future
+ * we may want to extend the agent to support these non-text chunks in a richer way. Placeholders are represented in an XML-like format but
+ * are NOT intended to be parsed as valid XML
+ */
+function stringifyClaudeChunkedMessage(chunks) {
+  const stringifiedChunks = chunks.map((msgContent) => {
+    switch (msgContent.type) {
+      case 'text':
+        return msgContent.text
+      case 'image':
+        return '<image>'
+      case 'tool_use':
+        return `<tool_use>${msgContent.name}</tool_use>`
+      case 'tool_result':
+        return `<tool_result>${msgContent.content}</tool_result>`
+      default:
+        return '<unknown_chunk>'
+    }
+  })
+  return stringifiedChunks.join('\n\n')
+}
+
+module.exports = {
+  stringifyClaudeChunkedMessage
+}

package/lib/shim/promise-shim.js

@@ -121,7 +121,7 @@ class PromiseShim extends Shim {
           const transaction = shim.tracer.getTransaction()
           // This extra property is added by `_wrapExecutorContext` in the pre step.
           const executor = args[0]
-          const context = executor && executor[symbols.executorContext]
+          const context = executor?.[symbols.executorContext]
           if (!context || !shim.isFunction(context.executor)) {
             return
           }
@@ -387,9 +387,7 @@ function _wrapExecutorContext(shim, args) {
 function _wrapResolver(context, fn) {
   return function wrappedResolveReject(val) {
     const promise = context.promise
-    if (promise && promise[symbols.context]) {
-      promise[symbols.context].getSegment().touch()
-    }
+    promise?.[symbols.context]?.getSegment()?.touch()
     fn(val)
   }
 }
@@ -416,7 +414,7 @@ function wrapHandler({ handler, index, argsLength, useAllParams, ctx, shim }) {
   }
 
   return function __NR_wrappedThenHandler() {
-    if (!ctx.handler || !ctx.handler[symbols.context]) {
+    if (!ctx?.handler?.[symbols.context]) {
       return handler.apply(this, arguments)
     }
 
@@ -591,7 +589,8 @@ class Contextualizer {
   isActive() {
     const segments = this.context.segments
     const segment = segments[this.idx] || segments[this.parentIdx] || segments[0]
-    return segment && this.context.transaction.isActive()
+    const transaction = this.getTransaction()
+    return segment && transaction?.isActive()
   }
 
   getTransaction() {

package/lib/shim/shim.js

@@ -677,7 +677,7 @@ function recordWrapper({ shim, fn, name, recordNamer }) {
       return fnApply.call(fn, this, args)
     }
 
-    // middleweare recorders pass in parent segment
+    // middleware recorders pass in parent segment
     // we need to destructure this as it is not needed past this function
     // and will overwhelm trace level loggers with logging the entire spec
     const { parent: specParent, ...segDesc } = spec
@@ -686,7 +686,7 @@ function recordWrapper({ shim, fn, name, recordNamer }) {
     const transaction = context.transaction
     const parent = transaction?.isActive() && specParent ? specParent : context.segment
 
-    if (!transaction?.isActive()) {
+    if (!transaction?.isActive() || !parent) {
       shim.logger.debug('Not recording function %s, not in a transaction.', name)
       return fnApply.call(fn, this, arguments)
     }

package/lib/shim/transaction-shim.js

@@ -372,12 +372,13 @@ function _makeNestedTransWrapper(shim, func, name, spec) {
     }
 
     let context = shim.tracer.getContext()
+    let transaction = shim.tracer.getTransaction()
 
     // Only create a new transaction if we either do not have a current
     // transaction _or_ the current transaction is not of the type we want.
-    if (!context?.transaction || spec.type !== context?.transaction?.type) {
+    if (!transaction || spec.type !== transaction?.type) {
       shim.logger.trace('Creating new nested %s transaction for %s', spec.type, name)
-      const transaction = new Transaction(shim.agent)
+      transaction = new Transaction(shim.agent)
       transaction.type = spec.type
       context = context.enterTransaction(transaction)
     }
@@ -405,10 +406,11 @@ function _makeNestedTransWrapper(shim, func, name, spec) {
  */
 function _makeTransWrapper(shim, func, name, spec) {
   return function transactionWrapper() {
-    // Don't nest transactions, reuse existing ones!
     let context = shim.tracer.getContext()
-    const existingTransaction = context.transaction
+    // Don't nest transactions, reuse existing ones!
+    const existingTransaction = shim.tracer.getTransaction()
     if (!shim.agent.canCollectData() || existingTransaction) {
+      shim.logger.trace('Transaction %s exists, not creating new transaction %s for %s', existingTransaction?.id, spec.type, name)
       return func.apply(this, arguments)
     }
 

package/package.json

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