newrelic 11.11.0 → 11.13.0

package/NEWS.md

@@ -1,3 +1,39 @@
+### v11.13.0 (2024-03-13)
+
+#### Features
+
+* Added AI Monitoring(AIM) for OpenAI, Amazon Bedrock, and Langchain.
+  * To enable set `config.ai_monitoring.enabled` or `NEW_RELIC_AI_MONITORING_ENABLED` to `true`.
+  * It is recommended for a full experience to set `config.span_events.max_samples_stored` to `10000`, `config.custom_insights_events.max_samples_stored` to `100000`, and `config.distributed_tracing.enabled` should not be set to false.
+  * **Note**: Enabling [high-security mode](https://docs.newrelic.com/docs/apm/agents/manage-apm-agents/configuration/high-security-mode/) will disable the AIM instrumentation and events. 
+* Added instrumentation for VectorStore.similaritySearch for langchain.js ([#2049](https://github.com/newrelic/node-newrelic/pull/2049)) ([3c50606](https://github.com/newrelic/node-newrelic/commit/3c50606a57a8dc18c91fe36e3b180bafd15a4cbc))
+* Added setLlmTokenCountCallback API endpoint to register a callback for calculating token count when none is provided ([#2065](https://github.com/newrelic/node-newrelic/pull/2065)) ([d2faf1a](https://github.com/newrelic/node-newrelic/commit/d2faf1a4942aacefd8b92e0bc2dc11bd8b687328))
+* Added token_count to LlmEmbedding and LlmChatCompletionMessage for openai ([#2061](https://github.com/newrelic/node-newrelic/pull/2061)) ([47a925e](https://github.com/newrelic/node-newrelic/commit/47a925eccce8e5b5d682b46277bbef5191f8b553))
+* Added tool_id to langchain error event ([#2064](https://github.com/newrelic/node-newrelic/pull/2064)) ([793abe8](https://github.com/newrelic/node-newrelic/commit/793abe8c9854b80fb1cf42f839a7db6a646cdc0b))
+
+#### Miscellaneous chores
+
+* Added flag for verbosity during docs publishing ([#2060](https://github.com/newrelic/node-newrelic/pull/2060)) ([fe0d41a](https://github.com/newrelic/node-newrelic/commit/fe0d41a86cba8da6173f5935e61c62b7dca75344))
+* Added some delays to docs publishing ([#2062](https://github.com/newrelic/node-newrelic/pull/2062)) ([a602fd4](https://github.com/newrelic/node-newrelic/commit/a602fd48e929437e4bc933c4ce276989013c53f1))
+* Changed casing of OpenAI in vendor property ([#2068](https://github.com/newrelic/node-newrelic/pull/2068)) ([64b4ca2](https://github.com/newrelic/node-newrelic/commit/64b4ca2750c9de8d9028fef515c15019e358a5d9))
+* Changed token_count to only use tokenCountCallback ([#2070](https://github.com/newrelic/node-newrelic/pull/2070)) ([66f94b0](https://github.com/newrelic/node-newrelic/commit/66f94b05aa7018af6fa1db1d2d87de9013f23a5b))
+* Removed langchain_instrumentation feature flag as the instrumentation is feature complete ([#2073](https://github.com/newrelic/node-newrelic/pull/2073)) ([925a463](https://github.com/newrelic/node-newrelic/commit/925a463c708b29c78567aecf78ac89ac226b7995))
+* updated @newrelic/aws-sdk and @newrelic/koa to latest ([#2074](https://github.com/newrelic/node-newrelic/pull/2074)) ([0747ca4](https://github.com/newrelic/node-newrelic/commit/0747ca4f0f6615e1fbfcc734a36059960facf23e))
+
+### v11.12.0 (2024-03-04)
+
+#### Features
+
+* Added instrumentation for `chain.stream` for langchain js. ([#2052](https://github.com/newrelic/node-newrelic/pull/2052)) ([03abfce](https://github.com/newrelic/node-newrelic/commit/03abfce666d3c48abd0994c44817bb5cbe8655a9))
+
+#### Miscellaneous chores
+
+* Added @azure/openai and @langchain/community/llms/bedrock as tracking packages so we can measure usage with angler ([#2053](https://github.com/newrelic/node-newrelic/pull/2053)) ([4830ea3](https://github.com/newrelic/node-newrelic/commit/4830ea3285726f8cc8fb60820c4cf2d3790e5250))
+
+#### Tests
+
+* Updated aws-sdk branch to main as the necessary code was merged. ([#2051](https://github.com/newrelic/node-newrelic/pull/2051)) ([1e52a5c](https://github.com/newrelic/node-newrelic/commit/1e52a5cd7a8acc8970dbdc6b1bf774c06aa6f5fb))
+
 ### v11.11.0 (2024-02-27)
 
 #### Features

package/THIRD_PARTY_NOTICES.md

@@ -504,7 +504,7 @@ This product includes source derived from [@grpc/proto-loader](https://github.co
 
 ### @newrelic/aws-sdk
 
-This product includes source derived from [@newrelic/aws-sdk](https://github.com/newrelic/node-newrelic-aws-sdk) ([v7.1.0](https://github.com/newrelic/node-newrelic-aws-sdk/tree/v7.1.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-aws-sdk/blob/v7.1.0/LICENSE):
+This product includes source derived from [@newrelic/aws-sdk](https://github.com/newrelic/node-newrelic-aws-sdk) ([v7.3.0](https://github.com/newrelic/node-newrelic-aws-sdk/tree/v7.3.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-aws-sdk/blob/v7.3.0/LICENSE):
 
 ```
                                  Apache License
@@ -712,7 +712,7 @@ This product includes source derived from [@newrelic/aws-sdk](https://github.com
 
 ### @newrelic/koa
 
-This product includes source derived from [@newrelic/koa](https://github.com/newrelic/node-newrelic-koa) ([v8.0.1](https://github.com/newrelic/node-newrelic-koa/tree/v8.0.1)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-koa/blob/v8.0.1/LICENSE):
+This product includes source derived from [@newrelic/koa](https://github.com/newrelic/node-newrelic-koa) ([v9.0.0](https://github.com/newrelic/node-newrelic-koa/tree/v9.0.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-koa/blob/v9.0.0/LICENSE):
 
 ```
 Apache License

package/api.js

@@ -1839,7 +1839,7 @@ API.prototype.setErrorGroupCallback = function setErrorGroupCallback(callback) {
   )
   metric.incrementCallCount()
 
-  if (!this.shim.isFunction(callback) || this.shim.isPromise(callback)) {
+  if (!this.shim.isFunction(callback) || this.shim.isAsyncFunction(callback)) {
     logger.warn(
       'Error Group callback must be a synchronous function, Error Group attribute will not be added'
     )
@@ -1849,4 +1849,37 @@ API.prototype.setErrorGroupCallback = function setErrorGroupCallback(callback) {
   this.agent.errors.errorGroupCallback = callback
 }
 
+/**
+ * Registers a callback which will be used for calculating token counts on Llm events when they are not
+ * available. This function will typically only be used if `ai_monitoring.record_content.enabled` is false
+ * and you want to still capture token counts for Llm events.
+ *
+ * Provided callbacks must return an integer value for the token count for a given piece of content.
+ *
+ * @param {Function} callback - synchronous function called to calculate token count for content.
+ * @example
+ * // @param {string} model - name of model (i.e. gpt-3.5-turbo)
+ * // @param {string} content - prompt or completion response
+ * function tokenCallback(model, content) {
+ *  // calculate tokens based on model and content
+ *  // return token count
+ *  return 40
+ * }
+ */
+API.prototype.setLlmTokenCountCallback = function setLlmTokenCountCallback(callback) {
+  const metric = this.agent.metrics.getOrCreateMetric(
+    NAMES.SUPPORTABILITY.API + '/setLlmTokenCountCallback'
+  )
+  metric.incrementCallCount()
+
+  if (!this.shim.isFunction(callback) || this.shim.isAsyncFunction(callback)) {
+    logger.warn(
+      'Llm token count callback must be a synchronous function, callback will not be registered.'
+    )
+    return
+  }
+
+  this.agent.llm.tokenCountCallback = callback
+}
+
 module.exports = API

package/lib/config/default.js

@@ -1359,6 +1359,19 @@ defaultConfig.definition = () => ({
       formatter: boolean,
       default: false
     },
+
+    /**
+     * When enabled, the content of LLM messages will be included in the
+     * recorded spans (i.e. delivered to the New Relic collector). This is
+     * enabled by default.
+     */
+    record_content: {
+      enabled: {
+        formatter: boolean,
+        default: true
+      }
+    },
+
     /**
      * Toggles the capturing of Llm events when using streaming
      * based methods in AIM supported libraries(i.e.- openai, AWS bedrock, langchain)
@@ -1390,8 +1403,8 @@ defaultConfig.config = () => {
  *
  * @param {object} definition configuration definition for a given leaf node
  * @param {object} config object that is used to construct the agent config
- * @param {Array} [paths=[]] an array to capture the leaf node keys to properly assign defaults for nested objects
- * @param {int} [objectKeys=1] amount of keys in a given leaf node
+ * @param {Array} [paths] an array to capture the leaf node keys to properly assign defaults for nested objects
+ * @param {int} [objectKeys] amount of keys in a given leaf node
  */
 function buildConfig(definition, config, paths = [], objectKeys = 1) {
   let keysSeen = 0
@@ -1429,7 +1442,7 @@ function buildConfig(definition, config, paths = [], objectKeys = 1) {
  * @param {object} params.config object that is used to construct the agent config
  * @param {string} params.key name of the configuration option
  * @param {string} params.value value the configuration option
- * @param {Array} [params.paths=[]] an array to capture the leaf node keys to properly assign defaults for nested objects
+ * @param {Array} [params.paths] an array to capture the leaf node keys to properly assign defaults for nested objects
  */
 function assignConfigValue({ config, key, value, paths }) {
   if (paths.length) {

package/lib/feature_flags.js

@@ -12,8 +12,7 @@ exports.prerelease = {
   reverse_naming_rules: false,
   undici_async_tracking: true,
   unresolved_promise_cleanup: true,
-  legacy_context_manager: false,
-  langchain_instrumentation: false
+  legacy_context_manager: false
 }
 
 // flags that are no longer used for released features
@@ -35,7 +34,8 @@ exports.released = [
   'certificate_bundle',
   'async_local_context',
   'undici_instrumentation',
-  'aws_bedrock_instrumentation'
+  'aws_bedrock_instrumentation',
+  'langchain_instrumentation'
 ]
 
 // flags that are no longer used for unreleased features

package/lib/instrumentation/langchain/common.js

@@ -59,7 +59,5 @@ common.recordEvent = function recordEvent({ agent, type, msg, pkgVersion }) {
  * @returns {boolean} flag if we should skip instrumentation
  */
 common.shouldSkipInstrumentation = function shouldSkipInstrumentation(config) {
-  return !(
-    config.ai_monitoring.enabled === true && config.feature_flag.langchain_instrumentation === true
-  )
+  return config.ai_monitoring.enabled !== true
 }

package/lib/instrumentation/langchain/nr-hooks.js

@@ -7,6 +7,7 @@
 const toolsInstrumentation = require('./tools')
 const cbManagerInstrumentation = require('./callback-manager')
 const runnableInstrumentation = require('./runnable')
+const vectorstoreInstrumentation = require('./vectorstore')
 
 module.exports = [
   {
@@ -23,5 +24,10 @@ module.exports = [
     type: 'generic',
     moduleName: '@langchain/core/dist/runnables/base',
     onRequire: runnableInstrumentation
+  },
+  {
+    type: 'generic',
+    moduleName: '@langchain/core/vectorstores',
+    onRequire: vectorstoreInstrumentation
   }
 ]

package/lib/instrumentation/langchain/runnable.js

@@ -6,9 +6,8 @@
 'use strict'
 
 const common = require('./common')
-const {
-  AI: { LANGCHAIN }
-} = require('../../metrics/names')
+const { AI } = require('../../metrics/names')
+const { LANGCHAIN } = AI
 const {
   LangChainCompletionMessage,
   LangChainCompletionSummary
@@ -28,10 +27,33 @@ module.exports = function initialize(shim, langchain) {
     return
   }
 
+  instrumentInvokeChain({ langchain, shim })
+
+  if (agent.config.ai_monitoring.streaming.enabled) {
+    instrumentStream({ langchain, shim })
+  } else {
+    shim.logger.warn(
+      '`ai_monitoring.streaming.enabled` is set to `false`, stream will not be instrumented.'
+    )
+    agent.metrics.getOrCreateMetric(AI.STREAMING_DISABLED).incrementCallCount()
+    agent.metrics
+      .getOrCreateMetric(`${LANGCHAIN.TRACKING_PREFIX}/${pkgVersion}`)
+      .incrementCallCount()
+  }
+}
+
+/**
+ * Instruments and records span and relevant LLM events for `chain.invoke`
+ *
+ * @param {object} params function params
+ * @param {object} params.langchain `@langchain/core/runnables/base` export
+ * @param {Shim} params.shim instace of shim
+ */
+function instrumentInvokeChain({ langchain, shim }) {
   shim.record(
     langchain.RunnableSequence.prototype,
     'invoke',
-    function wrapCall(shim, invoke, fnName, args) {
+    function wrapCall(shim, _invoke, fnName, args) {
       const [request, params] = args
       const metadata = params?.metadata ?? {}
       const tags = params?.tags ?? []
@@ -41,53 +63,183 @@ module.exports = function initialize(shim, langchain) {
         promise: true,
         // eslint-disable-next-line max-params
         after(_shim, _fn, _name, err, output, segment) {
-          segment.end()
-          const completionSummary = new LangChainCompletionSummary({
-            agent,
-            messages: [{ output }],
-            metadata,
-            tags,
+          recordChatCompletionEvents({
             segment,
-            error: err != null,
-            runId: segment[langchainRunId]
-          })
-
-          common.recordEvent({
-            agent,
-            type: 'LlmChatCompletionSummary',
-            pkgVersion,
-            msg: completionSummary
-          })
-
-          // output can be BaseMessage with a content property https://js.langchain.com/docs/modules/model_io/concepts#messages
-          // or an output parser https://js.langchain.com/docs/modules/model_io/concepts#output-parsers
-          recordCompletions({
+            messages: [output],
             events: [request, output],
-            completionSummary,
-            agent,
-            segment,
+            metadata,
+            tags,
+            err,
             shim
           })
+        }
+      })
+    }
+  )
+}
+
+/**
+ * Instruments and records span and relevant LLM events for `chain.stream`
+ *
+ * @param {object} params function params
+ * @param {object} params.langchain `@langchain/core/runnables/base` export
+ * @param {Shim} params.shim instace of shim
+ */
+function instrumentStream({ langchain, shim }) {
+  shim.record(
+    langchain.RunnableSequence.prototype,
+    'stream',
+    function wrapStream(shim, _stream, fnName, args) {
+      const [request, params] = args
+      const metadata = params?.metadata ?? {}
+      const tags = params?.tags ?? []
 
-          if (err) {
-            agent.errors.add(
-              segment.transaction,
+      return new RecorderSpec({
+        name: `${LANGCHAIN.CHAIN}/${fnName}`,
+        promise: true,
+        // eslint-disable-next-line max-params
+        after(_shim, _fn, _name, err, output, segment) {
+          // Input error occurred which means a stream was not created.
+          // Skip instrumenting streaming and create Llm Events from
+          // the data we have
+          if (output?.next) {
+            wrapNextHandler({ shim, output, segment, request, metadata, tags })
+          } else {
+            recordChatCompletionEvents({
+              segment,
+              messages: [],
+              events: [request],
+              metadata,
+              tags,
               err,
-              new LlmErrorMessage({
-                response: {},
-                cause: err,
-                summary: completionSummary
-              })
-            )
+              shim
+            })
           }
-
-          segment.transaction.trace.attributes.addAttribute(DESTINATIONS.TRANS_EVENT, 'llm', true)
         }
       })
     }
   )
 }
 
+/**
+ * Wraps the next method on the IterableReadableStream. It will also record the Llm
+ * events when the stream is done processing.
+ *
+ * @param {object} params function params
+ * @param {Shim} params.shim shim instance
+ * @param {TraceSegment} params.segment active segment
+ * @param {function} params.output IterableReadableStream
+ * @param {string} params.request the prompt message
+ * @param {object} params.metadata metadata for the call
+ * @param {Array} params.tags tags for the call
+ */
+function wrapNextHandler({ shim, output, segment, request, metadata, tags }) {
+  shim.wrap(output, 'next', function wrapIterator(shim, orig) {
+    let content = ''
+    return async function wrappedIterator() {
+      try {
+        const result = await orig.apply(this, arguments)
+        // only create Llm events when stream iteration is done
+        if (result?.done) {
+          recordChatCompletionEvents({
+            segment,
+            messages: [content],
+            events: [request, content],
+            metadata,
+            tags,
+            shim
+          })
+        } else {
+          content += result.value
+        }
+        return result
+      } catch (error) {
+        recordChatCompletionEvents({
+          segment,
+          messages: [content],
+          events: [request, content],
+          metadata,
+          tags,
+          err: error,
+          shim
+        })
+        throw error
+      } finally {
+        // update segment duration on every stream iteration to extend
+        // the timer
+        segment.touch()
+      }
+    }
+  })
+}
+
+/**
+ * Ends active segment, creates LlmChatCompletionSummary, and LlmChatCompletionMessage(s), and handles errors if they exists
+ *
+ * @param {object} params function params
+ * @param {TraceSegment} params.segment active segment
+ * @param {Array} params.messages response messages
+ * @param {Array} params.events prompt and response messages
+ * @param {object} params.metadata metadata for the call
+ * @param {Array} params.tags tags for the call
+ * @param {Error} params.err error object from call
+ * @param {Shim} params.shim shim instance
+ */
+function recordChatCompletionEvents({ segment, messages, events, metadata, tags, err, shim }) {
+  const { pkgVersion, agent } = shim
+  segment.end()
+  const completionSummary = new LangChainCompletionSummary({
+    agent,
+    messages,
+    metadata,
+    tags,
+    segment,
+    error: err != null,
+    runId: segment[langchainRunId]
+  })
+
+  common.recordEvent({
+    agent,
+    type: 'LlmChatCompletionSummary',
+    pkgVersion,
+    msg: completionSummary
+  })
+
+  // output can be BaseMessage with a content property https://js.langchain.com/docs/modules/model_io/concepts#messages
+  // or an output parser https://js.langchain.com/docs/modules/model_io/concepts#output-parsers
+  recordCompletions({
+    events,
+    completionSummary,
+    agent,
+    segment,
+    shim
+  })
+
+  if (err) {
+    agent.errors.add(
+      segment.transaction,
+      err,
+      new LlmErrorMessage({
+        response: {},
+        cause: err,
+        summary: completionSummary
+      })
+    )
+  }
+
+  segment.transaction.trace.attributes.addAttribute(DESTINATIONS.TRANS_EVENT, 'llm', true)
+}
+
+/**
+ * Records the LlmChatCompletionMessage(s)
+ *
+ * @param {object} params function params
+ * @param {Array} params.events prompt and response messages
+ * @param {LangChainCompletionSummary} params.completionSummary LlmChatCompletionSummary event
+ * @param {Agent} params.agent instance of agent
+ * @param {TraceSegment} params.segment active segment
+ * @param {Shim} params.shim shim instance
+ */
 function recordCompletions({ events, completionSummary, agent, segment, shim }) {
   for (let i = 0; i < events.length; i += 1) {
     let msg = events[i]

package/lib/instrumentation/langchain/tools.js

@@ -57,7 +57,7 @@ module.exports = function initialize(shim, tools) {
             new LlmErrorMessage({
               response: {},
               cause: err,
-              summary: {}
+              tool: toolEvent
             })
           )
         }

package/lib/instrumentation/langchain/vectorstore.js

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2024 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const {
+  AI: { LANGCHAIN }
+} = require('../../metrics/names')
+const { LangChainVectorSearch, LangChainVectorSearchResult } = require('../../llm-events/langchain')
+const { recordEvent, shouldSkipInstrumentation } = require('./common')
+const { DESTINATIONS } = require('../../config/attribute-filter')
+const { RecorderSpec } = require('../../shim/specs')
+const LlmErrorMessage = require('../../llm-events/error-message')
+
+/**
+ * Generates a LangChainVectorSearch for entire search request.
+ * Also iterates over documents in output and generates a
+ * LangChainVectorSearchResult for each document.
+ *
+ * @param {object} params input params
+ * @param {string} params.request vector search query
+ * @param {number} params.k vector search top k
+ * @param {object} params.output vector search documents
+ * @param {Agent} params.agent NR agent instance
+ * @param {TraceSegment} params.segment active segment from vector search
+ * @param {string} params.pkgVersion langchain version
+ * @param {err} params.err if it exists
+ */
+function recordVectorSearch({ request, k, output, agent, segment, pkgVersion, err }) {
+  const vectorSearch = new LangChainVectorSearch({
+    agent,
+    segment,
+    query: request,
+    k,
+    documents: output,
+    error: err !== null
+  })
+
+  recordEvent({ agent, type: 'LlmVectorSearch', pkgVersion, msg: vectorSearch })
+
+  output.forEach((document, sequence) => {
+    const vectorSearchResult = new LangChainVectorSearchResult({
+      agent,
+      segment,
+      metadata: document.metadata,
+      pageContent: document.pageContent,
+      sequence,
+      search_id: vectorSearch.id
+    })
+
+    recordEvent({
+      agent,
+      type: 'LlmVectorSearchResult',
+      pkgVersion,
+      msg: vectorSearchResult
+    })
+  })
+
+  if (err) {
+    agent.errors.add(
+      segment.transaction,
+      err,
+      new LlmErrorMessage({
+        response: output,
+        cause: err,
+        vectorsearch: vectorSearch
+      })
+    )
+  }
+}
+
+module.exports = function initialize(shim, vectorstores) {
+  const { agent, pkgVersion } = shim
+
+  if (shouldSkipInstrumentation(agent.config)) {
+    shim.logger.debug(
+      'langchain instrumentation is disabled.  To enable set `config.ai_monitoring.enabled` to true'
+    )
+    return
+  }
+
+  shim.record(
+    vectorstores.VectorStore.prototype,
+    'similaritySearch',
+    function wrapCall(shim, similaritySearch, fnName, args) {
+      const [request, k] = args
+
+      return new RecorderSpec({
+        name: `${LANGCHAIN.VECTORSTORE}/${fnName}`,
+        promise: true,
+        // eslint-disable-next-line max-params
+        after(_shim, _fn, _name, err, output, segment) {
+          if (!output) {
+            // If we get an error, it is possible that `output = null`.
+            // In that case, we define it to be an empty array.
+            output = []
+          }
+
+          segment.end()
+          recordVectorSearch({ request, k, output, agent, segment, pkgVersion, err })
+
+          segment.transaction.trace.attributes.addAttribute(DESTINATIONS.TRANS_EVENT, 'llm', true)
+        }
+      })
+    }
+  )
+}

package/lib/instrumentation/restify.js

@@ -93,7 +93,7 @@ function wrapMiddleware(shim, middleware, _name, route) {
   })
 
   const wrappedMw = shim.recordMiddleware(middleware, spec)
-  if (middleware.constructor.name === 'AsyncFunction') {
+  if (shim.isAsyncFunction(middleware)) {
     return async function asyncShim() {
       return wrappedMw.apply(this, arguments)
     }

package/lib/instrumentations.js

@@ -55,6 +55,8 @@ module.exports = function instrumentations() {
     'loglevel': { type: MODULE_TYPE.TRACKING },
     'npmlog': { type: MODULE_TYPE.TRACKING },
     'fancy-log': { type: MODULE_TYPE.TRACKING },
-    'knex': { type: MODULE_TYPE.TRACKING }
+    'knex': { type: MODULE_TYPE.TRACKING },
+    '@azure/openai': { type: MODULE_TYPE.TRACKING },
+    '@langchain/community/llms/bedrock': { type: MODULE_TYPE.TRACKING }
   }
 }

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

@@ -18,14 +18,19 @@ module.exports = class LlmErrorMessage {
    * conversation if it was a chat completion conversation.
    * @param {LlmEmbedding} [params.embedding] Details about the conversation
    * if it was an embedding conversation.
+   * @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.
    */
-  constructor({ response, cause, summary, embedding } = {}) {
+  constructor({ response, cause, summary, embedding, vectorsearch, tool } = {}) {
     this['http.statusCode'] = response?.status ?? cause?.status
     this['error.message'] = cause?.message
     this['error.code'] = response?.code ?? cause?.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
   }
 
   get [Symbol.toStringTag]() {

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

@@ -36,6 +36,7 @@ class LangChainCompletionMessage extends LangChainEvent {
   constructor(params = defaultParams) {
     params = Object.assign({}, defaultParams, params)
     super(params)
+    const { agent } = params
 
     if (params.runId) {
       this.id = `${params.runId}-${params.sequence}`
@@ -43,10 +44,13 @@ class LangChainCompletionMessage extends LangChainEvent {
       this.id = `${this.id}-${params.sequence}`
     }
 
-    this.content = params.content
     this.sequence = params.sequence
     this.completion_id = params.completionId
     this.is_response = params.isResponse ?? false
+
+    if (agent.config.ai_monitoring.record_content.enabled === true) {
+      this.content = params.content
+    }
   }
 }
 

package/lib/llm-events/langchain/event.js

@@ -51,7 +51,6 @@ class LangChainEvent extends BaseEvent {
   ingest_source = 'Node'
   vendor = 'langchain'
   virtual_llm = true
-  error = false
 
   constructor(params = defaultParams) {
     params = Object.assign({}, defaultParams, params)
@@ -66,7 +65,7 @@ class LangChainEvent extends BaseEvent {
     this.langchainMeta = params.metadata
     this.metadata = agent
     this.tags = Array.isArray(params.tags) ? params.tags.join(',') : params.tags
-    this.error = params.error ?? false
+    this.error = params.error ?? null
 
     if (params.virtual !== undefined) {
       if (params.virtual !== true && params.virtual !== false) {

package/lib/llm-events/langchain/tool.js

@@ -9,8 +9,8 @@ const LangChainEvent = require('./event')
 class LangChainTool extends LangChainEvent {
   constructor(params) {
     super(params)
-    this.input = params.input
-    this.output = params.output
+    const { agent } = params
+
     this.name = params.name
     this.description = params.description
     this.duration = params?.segment?.getDurationInMillis()
@@ -18,6 +18,11 @@ class LangChainTool extends LangChainEvent {
     delete this.request_id
     delete this.virtual_llm
     delete this.conversation_id
+
+    if (agent.config.ai_monitoring.record_content.enabled === true) {
+      this.input = params.input
+      this.output = params.output
+    }
   }
 }
 

package/lib/llm-events/langchain/vector-search-result.js

@@ -6,13 +6,13 @@
 'use strict'
 
 const LangChainEvent = require('./event')
-const crypto = require('crypto')
 
 /**
  * @typedef {object} LangChainVectorSearchResultParams
  * @augments LangChainEventParams
  * @property {string} pageContent The stringified contents of the pageContent attribute on each returned search result document.
  * @property {number} [sequence=0] The index of the document in the search result documents list.
+ * @property {string} search_id The identifier from the LangChainVectorSearch event.
  */
 /**
  * @type {LangChainVectorSearchResultParams}
@@ -23,14 +23,17 @@ const defaultParams = {
 }
 
 class LangChainVectorSearchResult extends LangChainEvent {
-  search_id = crypto.randomUUID()
-
   constructor(params) {
     params = Object.assign({}, defaultParams, params)
     super(params)
+    const { agent } = params
 
-    this.page_content = params.pageContent
+    this.search_id = params.search_id
     this.sequence = params.sequence
+
+    if (agent.config.ai_monitoring.record_content.enabled === true) {
+      this.page_content = params.pageContent
+    }
   }
 }
 

package/lib/llm-events/langchain/vector-search.js

@@ -28,12 +28,15 @@ class LangChainVectorSearch extends LangChainEvent {
   constructor(params) {
     params = Object.assign({}, defaultParams, params)
     super(params)
-    const { segment } = params
+    const { agent, segment } = params
 
     this.duration = segment?.getDurationInMillis()
-    this['request.query'] = params.query
     this['request.k'] = params.k
     this['response.number_of_documents'] = params.documents?.length
+
+    if (agent.config.ai_monitoring.record_content.enabled === true) {
+      this['request.query'] = params.query
+    }
   }
 }
 

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

@@ -10,10 +10,24 @@ module.exports = class LlmChatCompletionMessage extends LlmEvent {
   constructor({ agent, segment, request = {}, response = {}, index = 0, message, completionId }) {
     super({ agent, segment, request, response })
     this.id = `${response.id}-${index}`
-    this.content = message?.content
     this.role = message?.role
     this.sequence = index
     this.completion_id = completionId
-    this.is_response = response?.choices?.[0]?.message?.content === this.content
+    this.is_response = response?.choices?.[0]?.message?.content === message?.content
+
+    if (agent.config.ai_monitoring.record_content.enabled === true) {
+      this.content = message?.content
+    }
+
+    const tokenCB = agent.llm?.tokenCountCallback
+    if (typeof tokenCB !== 'function') {
+      return
+    }
+
+    if (this.is_response) {
+      this.token_count = tokenCB(this['response.model'], message?.content)
+    } else {
+      this.token_count = tokenCB(request.model || request.engine, message?.content)
+    }
   }
 }

package/lib/llm-events/openai/embedding.js

@@ -10,6 +10,13 @@ module.exports = class LlmEmbedding extends LlmEvent {
   constructor({ agent, segment, request = {}, response = {}, withError = false }) {
     super({ agent, segment, request, response, responseAttrs: true })
     this.error = withError
-    this.input = request.input?.toString()
+
+    if (agent.config.ai_monitoring.record_content.enabled === true) {
+      this.input = request.input?.toString()
+    }
+    this.token_count = agent.llm?.tokenCountCallback?.(
+      this['request.model'],
+      request.input?.toString()
+    )
   }
 }

package/lib/llm-events/openai/event.js

@@ -19,7 +19,7 @@ module.exports = class LlmEvent extends BaseEvent {
     this.span_id = segment?.id
     this.transaction_id = segment?.transaction?.id
     this['response.model'] = response.model
-    this.vendor = 'openAI'
+    this.vendor = 'openai'
     this.ingest_source = 'Node'
     this.metadata = agent
 

package/lib/metrics/names.js

@@ -170,7 +170,8 @@ const AI = {
   EMBEDDING: 'Llm/embedding',
   COMPLETION: 'Llm/completion',
   TOOL: 'Llm/tool',
-  CHAIN: 'Llm/chain'
+  CHAIN: 'Llm/chain',
+  VECTORSTORE: 'Llm/vectorstore'
 }
 
 AI.OPENAI = {
@@ -184,7 +185,8 @@ AI.LANGCHAIN = {
   EMBEDDING: `${AI.EMBEDDING}/Langchain`,
   COMPLETION: `${AI.COMPLETION}/Langchain`,
   TOOL: `${AI.TOOL}/Langchain`,
-  CHAIN: `${AI.CHAIN}/Langchain`
+  CHAIN: `${AI.CHAIN}/Langchain`,
+  VECTORSTORE: `${AI.VECTORSTORE}/Langchain`
 }
 
 const RESTIFY = {

package/lib/shim/shim.js

@@ -125,6 +125,7 @@ Shim.prototype.getName = getName
 Shim.prototype.isObject = isObject
 Shim.prototype.isFunction = isFunction
 Shim.prototype.isPromise = isPromise
+Shim.prototype.isAsyncFunction = isAsyncFunction
 Shim.prototype.isString = isString
 Shim.prototype.isNumber = isNumber
 Shim.prototype.isBoolean = isBoolean
@@ -1345,6 +1346,20 @@ function isPromise(obj) {
   return obj && typeof obj.then === 'function'
 }
 
+/**
+ * Determines if function is an async function.
+ * Note it does not test if the return value of function is a
+ * promise or async function
+ *
+ * @memberof Shim.prototype
+ * @param fn
+ * @param (function) function to test if async
+ * @returns {boolean} True if the function is an async function
+ */
+function isAsyncFunction(fn) {
+  return fn.constructor.name === 'AsyncFunction'
+}
+
 /**
  * Determines if the given value is null.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "11.11.0",
+  "version": "11.13.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -193,8 +193,8 @@
   "dependencies": {
     "@grpc/grpc-js": "^1.9.4",
     "@grpc/proto-loader": "^0.7.5",
-    "@newrelic/aws-sdk": "^7.1.0",
-    "@newrelic/koa": "^8.0.1",
+    "@newrelic/aws-sdk": "^7.3.0",
+    "@newrelic/koa": "^9.0.0",
     "@newrelic/ritm": "^7.2.0",
     "@newrelic/security-agent": "^1.0.1",
     "@newrelic/superagent": "^7.0.1",