newrelic 11.6.0 → 11.6.1

package/NEWS.md

@@ -1,3 +1,24 @@
+### v11.6.1 (2023-12-07)
+
+#### Bug fixes
+
+* **deps:** Updated @newrelic/aws-sdk to 7.0.3 ([#1902](https://github.com/newrelic/node-newrelic/pull/1902)) ([bf22ae5](https://github.com/newrelic/node-newrelic/commit/bf22ae502ee74d5071dc5578cc77c38039e68778))
+* Updated shimmer to handle instrumenting named and default exports of CommonJS modules in ESM ([#1894](https://github.com/newrelic/node-newrelic/pull/1894)) ([9f7979c](https://github.com/newrelic/node-newrelic/commit/9f7979cd41dcb3735e553cbd4837ad455836e3ff))
+
+#### Code refactoring
+
+* Fixed cognitive complexity violations of openai instrumentation by moving functions outside of the parent function scope ([#1895](https://github.com/newrelic/node-newrelic/pull/1895)) ([31dc717](https://github.com/newrelic/node-newrelic/commit/31dc71797c4798793b1bba8ca15733482ba3e7d6))
+* Updated span names of openai actions to allow AI O11y team to locate relevant spans ([#1896](https://github.com/newrelic/node-newrelic/pull/1896)) ([b7a644d](https://github.com/newrelic/node-newrelic/commit/b7a644d1ef56bf88171fb74868ae78d24745dd19))
+
+#### Miscellaneous chores
+
+* Improve OpenAI mock server streams ([#1890](https://github.com/newrelic/node-newrelic/pull/1890)) ([d12bfe4](https://github.com/newrelic/node-newrelic/commit/d12bfe45f2c8d01277a1f8186844f0dd3598cbd7))
+
+#### Tests
+
+* Fix winston-esm versioned tests ([#1898](https://github.com/newrelic/node-newrelic/pull/1898)) ([6e02e57](https://github.com/newrelic/node-newrelic/commit/6e02e57a2b4ed8351e39e5fb8d47e2702bcafde0))
+* pin undici versioned to <6.0.0 on Node 16 ([#1900](https://github.com/newrelic/node-newrelic/pull/1900)) ([9973b24](https://github.com/newrelic/node-newrelic/commit/9973b24067211f5fcc06adae79e02df8f599d735))
+
 ### v11.6.0 (2023-11-29)
 
 #### Features

package/THIRD_PARTY_NOTICES.md

@@ -510,7 +510,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.0.2](https://github.com/newrelic/node-newrelic-aws-sdk/tree/v7.0.2)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-aws-sdk/blob/v7.0.2/LICENSE):
+This product includes source derived from [@newrelic/aws-sdk](https://github.com/newrelic/node-newrelic-aws-sdk) ([v7.0.3](https://github.com/newrelic/node-newrelic-aws-sdk/tree/v7.0.3)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-aws-sdk/blob/v7.0.3/LICENSE):
 
 ```
                                  Apache License

package/lib/instrumentation/openai.js

@@ -15,10 +15,12 @@ const LlmTrackedIds = require('../../lib/llm-events/tracked-ids')
 
 const MIN_VERSION = '4.0.0'
 const MIN_STREAM_VERSION = '4.12.2'
-const { AI } = require('../../lib/metrics/names')
+const {
+  AI: { OPENAI }
+} = require('../../lib/metrics/names')
 const semver = require('semver')
 
-let TRACKING_METRIC = AI.TRACKING_PREFIX
+let TRACKING_METRIC = OPENAI.TRACKING_PREFIX
 
 /**
  * Checks if we should skip instrumentation.
@@ -39,7 +41,178 @@ function shouldSkipInstrumentation(config, shim) {
   return semver.lt(pkgVersion, MIN_VERSION)
 }
 
-// eslint-disable-next-line sonarjs/cognitive-complexity
+/**
+ * Adds apiKey and response headers to the active segment
+ * on symbols
+ *
+ * @param {object} params input params
+ * @param {Shim} params.shim instance of shim
+ * @param {object} params.result from openai request
+ * @param {string} params.apiKey api key from openai client
+ */
+function decorateSegment({ shim, result, apiKey }) {
+  const segment = shim.getActiveSegment()
+
+  if (segment) {
+    segment[openAiApiKey] = apiKey
+
+    // If the result is an error, which is an OpenAI client error, then
+    // the headers are provided via a proxy attached to `result.headers`.
+    // Otherwise, result is a typical response-like object.
+    const headers = result?.response?.headers
+      ? Object.fromEntries(result.response.headers)
+      : { ...result?.headers }
+    segment[openAiHeaders] = headers
+  }
+}
+
+/**
+ * Enqueues a LLM event to the custom event aggregator
+ *
+ * @param {object} params input params
+ * @param {Agent} params.agent NR agent instance
+ * @param {string} params.type LLM event type
+ * @param {object} params.msg LLM event
+ */
+function recordEvent({ agent, type, msg }) {
+  agent.metrics.getOrCreateMetric(TRACKING_METRIC).incrementCallCount()
+  msg = agent?.llm?.metadata ? { ...agent.llm.metadata, ...msg } : msg
+  agent.customEventAggregator.add([{ type, timestamp: Date.now() }, msg])
+}
+
+/**
+ * Assigns requestId, conversationId and messageIds for a given
+ * chat completion response on the active transaction.
+ * This is used for generating LlmFeedbackEvent via `api.recordLlmFeedbackEvent`
+ *
+ * @param {object} params input params
+ * @param {Transaction} params.tx active transaction
+ * @param {LlmChatCompletionMessage} params.completionMsg chat completion message
+ * @param {string} params.responseId id of response
+ */
+function assignIdsToTx({ tx, completionMsg, responseId }) {
+  const tracker = tx.llm.responses
+  const trackedIds =
+    tracker.get(responseId) ??
+    new LlmTrackedIds({
+      requestId: completionMsg.request_id,
+      conversationId: completionMsg.conversation_id
+    })
+  trackedIds.message_ids.push(completionMsg.id)
+  tracker.set(responseId, trackedIds)
+}
+
+/**
+ * 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 {Agent} params.agent NR agent instance
+ * @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
+ */
+function recordChatCompletionMessages({ agent, segment, request, response, err }) {
+  if (!response) {
+    // If we get an error, it is possible that `response = null`.
+    // In that case, we define it to be an empty object.
+    response = {}
+  }
+
+  response.headers = segment[openAiHeaders]
+  response.api_key = segment[openAiApiKey]
+  const tx = segment.transaction
+  // explicitly end segment to consistent duration
+  // for both LLM events and the segment
+  segment.end()
+  const completionSummary = new LlmChatCompletionSummary({
+    agent,
+    segment,
+    request,
+    response,
+    withError: err != null
+  })
+
+  // Only take the first response message and append to input messages
+  const messages = [...request.messages, response?.choices?.[0]?.message]
+  messages.forEach((message, index) => {
+    const completionMsg = new LlmChatCompletionMessage({
+      agent,
+      segment,
+      request,
+      response,
+      index,
+      completionId: completionSummary.id,
+      message
+    })
+
+    assignIdsToTx({ tx, completionMsg, responseId: response.id })
+    recordEvent({ agent, type: 'LlmChatCompletionMessage', msg: completionMsg })
+  })
+
+  recordEvent({ agent, type: 'LlmChatCompletionSummary', msg: completionSummary })
+
+  if (err) {
+    const llmError = new LlmErrorMessage({ cause: err, summary: completionSummary, response })
+    agent.errors.add(segment.transaction, err, llmError)
+  }
+
+  delete response.headers
+  delete response.api_key
+}
+
+/*
+ * Chat completions create can return a stream once promise resolves
+ * This wraps the iterator which is a generator function
+ * We will call the original iterator, intercept chunks and yield
+ * to the original. On complete we will construct the new message object
+ * with what we have seen in the stream and create the chat completion
+ * messages
+ *
+ */
+function instrumentStream({ shim, request, response, segment }) {
+  shim.wrap(response, 'iterator', function wrapIterator(shim, orig) {
+    return async function* wrappedIterator() {
+      let content = ''
+      let role = ''
+      let chunk
+      let err
+      try {
+        const iterator = orig.apply(this, arguments)
+
+        for await (chunk of iterator) {
+          if (chunk.choices?.[0]?.delta?.role) {
+            role = chunk.choices[0].delta.role
+          }
+
+          content += chunk.choices?.[0]?.delta?.content ?? ''
+          yield chunk
+        }
+      } catch (streamErr) {
+        err = streamErr
+        throw err
+      } finally {
+        chunk.choices[0].message = { role, content }
+        // update segment duration since we want to extend the time it took to
+        // handle the stream
+        segment.touch()
+
+        recordChatCompletionMessages({
+          agent: shim.agent,
+          segment,
+          request,
+          response: chunk,
+          err
+        })
+      }
+    }
+  })
+}
+
 module.exports = function initialize(agent, openai, moduleName, shim) {
   if (shouldSkipInstrumentation(agent.config, shim)) {
     shim.logger.debug(
@@ -51,42 +224,7 @@ module.exports = function initialize(agent, openai, moduleName, shim) {
   // Update the tracking metric name with the version of the library
   // being instrumented. We do not have access to the version when
   // initially declaring the variable.
-  TRACKING_METRIC = `${TRACKING_METRIC}OpenAI/${shim.pkgVersion}`
-
-  /**
-   * Adds apiKey and response headers to the active segment
-   * on symbols
-   *
-   * @param {object} result from openai request
-   * @param {string} apiKey api key from openai client
-   */
-  function decorateSegment(result, apiKey) {
-    const segment = shim.getActiveSegment()
-
-    if (segment) {
-      segment[openAiApiKey] = apiKey
-
-      // If the result is an error, which is an OpenAI client error, then
-      // the headers are provided via a proxy attached to `result.headers`.
-      // Otherwise, result is a typical response-like object.
-      const headers = result?.response?.headers
-        ? Object.fromEntries(result.response.headers)
-        : { ...result?.headers }
-      segment[openAiHeaders] = headers
-    }
-  }
-
-  /**
-   * Enqueues a LLM event to the custom event aggregator
-   *
-   * @param {string} type of LLM event
-   * @param {object} msg LLM event
-   */
-  function recordEvent(type, msg) {
-    agent.metrics.getOrCreateMetric(TRACKING_METRIC).incrementCallCount()
-    msg = agent?.llm?.metadata ? { ...agent.llm.metadata, ...msg } : msg
-    agent.customEventAggregator.add([{ type, timestamp: Date.now() }, msg])
-  }
+  TRACKING_METRIC = `${TRACKING_METRIC}/${shim.pkgVersion}`
 
   /**
    * Instrumentation is only done to get the response headers and attach
@@ -96,152 +234,21 @@ module.exports = function initialize(agent, openai, moduleName, shim) {
   shim.wrap(openai.prototype, 'makeRequest', function wrapRequest(shim, makeRequest) {
     return function wrappedRequest() {
       const apiKey = this.apiKey
-      const result = makeRequest.apply(this, arguments)
-      result.then(
-        (data) => {
+      const request = makeRequest.apply(this, arguments)
+      request.then(
+        (result) => {
           // add headers on resolve
-          decorateSegment(data, apiKey)
+          decorateSegment({ shim, result, apiKey })
         },
-        (data) => {
+        (result) => {
           // add headers on reject
-          decorateSegment(data, apiKey)
+          decorateSegment({ shim, result, apiKey })
         }
       )
-      return result
+      return request
     }
   })
 
-  /**
-   * Assigns requestId, conversationId and messageIds for a given
-   * chat completion response on the active transaction.
-   * This is used for generating LlmFeedbackEvent via `api.recordLlmFeedbackEvent`
-   *
-   * @param {object} params input params
-   * @param {Transaction} params.tx active transaction
-   * @param {LlmChatCompletionMessage} params.completionMsg chat completion message
-   * @param {string} params.responseId id of response
-   */
-  function assignIdsToTx({ tx, completionMsg, responseId }) {
-    const tracker = tx.llm.responses
-    const trackedIds =
-      tracker.get(responseId) ??
-      new LlmTrackedIds({
-        requestId: completionMsg.request_id,
-        conversationId: completionMsg.conversation_id
-      })
-    trackedIds.message_ids.push(completionMsg.id)
-    tracker.set(responseId, trackedIds)
-  }
-
-  /**
-   * 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
-   */
-  function recordChatCompletionMessages({ segment, request, response, err }) {
-    if (!response) {
-      // If we get an error, it is possible that `response = null`.
-      // In that case, we define it to be an empty object.
-      response = {}
-    }
-
-    response.headers = segment[openAiHeaders]
-    response.api_key = segment[openAiApiKey]
-    const tx = segment.transaction
-    // explicitly end segment to consistent duration
-    // for both LLM events and the segment
-    segment.end()
-    const completionSummary = new LlmChatCompletionSummary({
-      agent,
-      segment,
-      request,
-      response,
-      withError: err != null
-    })
-
-    // Only take the first response message and append to input messages
-    const messages = [...request.messages, response?.choices?.[0]?.message]
-    messages.forEach((message, index) => {
-      const completionMsg = new LlmChatCompletionMessage({
-        agent,
-        segment,
-        request,
-        response,
-        index,
-        completionId: completionSummary.id,
-        message
-      })
-
-      assignIdsToTx({ tx, completionMsg, responseId: response.id })
-      recordEvent('LlmChatCompletionMessage', completionMsg)
-    })
-
-    recordEvent('LlmChatCompletionSummary', completionSummary)
-
-    if (err) {
-      const llmError = new LlmErrorMessage({ cause: err, summary: completionSummary, response })
-      shim.agent.errors.add(segment.transaction, err, llmError)
-    }
-
-    delete response.headers
-    delete response.api_key
-  }
-
-  /*
-   * Chat completions create can return a stream once promise resolves
-   * This wraps the iterator which is a generator function
-   * We will call the original iterator, intercept chunks and yield
-   * to the original. On complete we will construct the new message object
-   * with what we have seen in the stream and create the chat completion
-   * messages
-   *
-   */
-  function instrumentStream({ request, response, segment }) {
-    shim.wrap(response, 'iterator', function wrapIterator(shim, orig) {
-      return async function* wrappedIterator() {
-        let content = ''
-        let role = ''
-        let chunk
-        let err
-        try {
-          const iterator = orig.apply(this, arguments)
-
-          for await (chunk of iterator) {
-            if (chunk.choices?.[0]?.delta?.role) {
-              role = chunk.choices[0].delta.role
-            }
-
-            content += chunk.choices?.[0]?.delta?.content ?? ''
-            yield chunk
-          }
-        } catch (streamErr) {
-          err = streamErr
-          throw err
-        } finally {
-          chunk.choices[0].message = { role, content }
-          // update segment duration since we want to extend the time it took to
-          // handle the stream
-          segment.touch()
-
-          recordChatCompletionMessages({
-            segment,
-            request,
-            response: chunk,
-            err
-          })
-        }
-      }
-    })
-  }
-
   /**
    * Instruments chat completion creation
    * and creates the LLM events
@@ -261,14 +268,15 @@ module.exports = function initialize(agent, openai, moduleName, shim) {
       }
 
       return {
-        name: `${AI.OPEN_AI}/Chat/Completions/Create`,
+        name: OPENAI.COMPLETION,
         promise: true,
         // eslint-disable-next-line max-params
         after(_shim, _fn, _name, err, response, segment) {
           if (request.stream) {
-            instrumentStream({ request, response, segment })
+            instrumentStream({ shim, request, response, segment })
           } else {
             recordChatCompletionMessages({
+              agent,
               segment,
               request,
               response,
@@ -290,7 +298,7 @@ module.exports = function initialize(agent, openai, moduleName, shim) {
     function wrapEmbeddingCreate(shim, embeddingCreate, name, args) {
       const [request] = args
       return {
-        name: `${AI.OPEN_AI}/Embeddings/Create`,
+        name: OPENAI.EMBEDDING,
         promise: true,
         // eslint-disable-next-line max-params
         after(_shim, _fn, _name, err, response, segment) {
@@ -312,7 +320,7 @@ module.exports = function initialize(agent, openai, moduleName, shim) {
             withError: err != null
           })
 
-          recordEvent('LlmEmbedding', embedding)
+          recordEvent({ agent, type: 'LlmEmbedding', msg: embedding })
 
           if (err) {
             const llmError = new LlmErrorMessage({ cause: err, embedding, response })

package/lib/instrumentation/pg.js

@@ -5,6 +5,8 @@
 
 'use strict'
 
+const { nrEsmProxy } = require('../symbols')
+
 function getQuery(shim, original, name, args) {
   const config = args[0]
   let statement
@@ -78,27 +80,52 @@ module.exports = function initialize(agent, pgsql, moduleName, shim) {
     })
   }
 
-  // The pg module defines "native" getter which sets up the native client lazily
-  // (only when called).  We replace the getter, so that we can instrument the native
-  // client.  The original getter replaces itself with the instance of the native
-  // client, so only instrument if the getter exists (otherwise assume already
-  // instrumented).
-  const origGetter = pgsql.__lookupGetter__('native')
-  if (origGetter) {
-    delete pgsql.native
-    pgsql.__defineGetter__('native', function getNative() {
-      const temp = origGetter()
-      if (temp != null) {
-        instrumentPGNative(temp)
-      }
-      return temp
-    })
-  }
+  updateNative(pgsql, instrumentPGNative)
 
   // wrapping for JS
   shim.recordQuery(pgsql && pgsql.Client && pgsql.Client.prototype, 'query', wrapJSClientQuery)
 }
 
+/**
+ * Determines if the `pg` module is a plain CJS module or a CJS module that
+ * has been imported via ESM's import. After making the determination, it will
+ * update the `native` export of the module to be instrumented.
+ *
+ * @param {object} pg The module to inspect.
+ * @param {Function} instrumentPGNative A function that will apply instrumentation
+ * to the `native` export.
+ */
+function updateNative(pg, instrumentPGNative) {
+  if (pg[nrEsmProxy] === true) {
+    // When pg is imported via an ESM import statement, then our proxy will
+    // make our non-ESM native getter wrapper not work correctly. Basically,
+    // the getter will get evaluated by the proxy, and we never gain access to
+    // replace the getter with our own implementation. Luckily, we get to
+    // simplify in this scenario.
+    const native = pg.default.native
+    if (native !== null) {
+      instrumentPGNative(native)
+    }
+  } else {
+    // The pg module defines a "native" getter which sets up the native client lazily
+    // (only when called).  We replace the getter, so that we can instrument the native
+    // client.  The original getter replaces itself with the instance of the native
+    // client, so only instrument if the getter exists (otherwise assume already
+    // instrumented).
+    const origGetter = pg.__lookupGetter__('native')
+    if (origGetter) {
+      delete pg.native
+      pg.__defineGetter__('native', function getNative() {
+        const temp = origGetter()
+        if (temp != null) {
+          instrumentPGNative(temp)
+        }
+        return temp
+      })
+    }
+  }
+}
+
 function getInstanceParameters(shim, client) {
   return {
     host: client.host || null,

package/lib/instrumentation/winston.js

@@ -101,7 +101,12 @@ function registerFormatter({ opts, agent, winston }) {
   if (opts.format) {
     opts.format = winston.format.combine(instrumentedFormatter(), opts.format)
   } else {
-    opts.format = instrumentedFormatter()
+    // The default formatter for Winston is the JSON formatter. If the user
+    // has not provided a formatter through opts.format, we must emulate the
+    // default. Otherwise, the message symbol will not get attached to log
+    // messages and transports, e.g. the "Console" transport, will not be able
+    // to output logs correctly.
+    opts.format = winston.format.combine(instrumentedFormatter(), winston.format.json())
   }
 }
 

package/lib/metrics/names.js

@@ -166,7 +166,14 @@ const EXPRESS = {
 
 const AI = {
   TRACKING_PREFIX: 'Nodejs/ML/',
-  OPEN_AI: 'AI/OpenAI'
+  EMBEDDING: 'Llm/embedding',
+  COMPLETION: 'Llm/completion'
+}
+
+AI.OPENAI = {
+  TRACKING_PREFIX: `${AI.TRACKING_PREFIX}/OpenAI`,
+  EMBEDDING: `${AI.EMBEDDING}/OpenAI/create`,
+  COMPLETION: `${AI.COMPLETION}/OpenAI/create`
 }
 
 const RESTIFY = {

package/lib/shimmer.js

@@ -13,6 +13,7 @@ const INSTRUMENTATIONS = require('./instrumentations')()
 const shims = require('./shim')
 const { Hook } = require('require-in-the-middle')
 const IitmHook = require('import-in-the-middle')
+const { nrEsmProxy } = require('./symbols')
 let pkgsToHook = []
 
 const NAMES = require('./metrics/names')
@@ -537,10 +538,7 @@ function instrumentPostLoad(agent, nodule, moduleName, resolvedName, esmResolver
       return
     }
 
-    // We only return the .default when we're a CJS module in the import-in-the-middle(ESM)
-    // callback hook
-    const resolvedNodule = instrumentation.isEsm || !esmResolver ? nodule : nodule.default
-
+    const resolvedNodule = resolveNodule({ nodule, instrumentation, esmResolver })
     const shim = shims.createShimFromType({
       type: instrumentation.type,
       agent,
@@ -579,6 +577,60 @@ function instrumentPostLoad(agent, nodule, moduleName, resolvedName, esmResolver
   return nodule
 }
 
+/**
+ * If a module that is being shimmed was loaded via a typical `require` then
+ * we can use it as normal. If was loaded via an ESM import, then we need to
+ * handle it with some extra care. This function inspects the module,
+ * the conditions around its loading, and returns an appropriate object for
+ * subsequent shimming methods.
+ *
+ * @param {object} params Input parameters.
+ * @param {object} params.nodule The nodule being instrumented.
+ * @param {object} params.instrumentation The configuration for the nodule
+ * to be instrumented.
+ * @param {boolean|null} params.esmResolver Indicates if the nodule was loaded
+ * via an ESM import.
+ * @returns {object} The nodule or a Proxy.
+ */
+function resolveNodule({ nodule, instrumentation, esmResolver }) {
+  if (instrumentation.isEsm === true || !esmResolver) {
+    return nodule
+  }
+
+  // We have a CJS module wrapped by import-in-the-middle having been
+  // imported through ESM syntax. Due to the way CJS modules are parsed by
+  // ESM's import, we can have the same "export" attached to the `default`
+  // export and as a top-level named export. In order to shim things such
+  // that our users don't need to know to access `something.default.foo`
+  // when they have done `import * as something from 'something'`, we need
+  // to proxy the proxy in order to set our wrappers on both instances.
+  const noduleDefault = nodule.default
+  const origNodule = nodule
+  return new Proxy(
+    { origNodule, noduleDefault },
+    {
+      get(target, name) {
+        if (name === nrEsmProxy) {
+          return true
+        }
+        if (target.noduleDefault[name]) {
+          return target.noduleDefault[name]
+        }
+        return target.origNodule[name]
+      },
+      set(target, name, value) {
+        if (target.origNodule[name]) {
+          target.origNodule[name] = value
+        }
+        if (target.noduleDefault[name]) {
+          target.noduleDefault[name] = value
+        }
+        return true
+      }
+    }
+  )
+}
+
 /**
  * Attempts to execute an onRequire hook for a given module.
  * If it fails it will call an onError hook and log warnings accordingly

package/lib/symbols.js

@@ -34,5 +34,10 @@ module.exports = {
   unwrapPool: Symbol('unwrapPool'),
   clusterOf: Symbol('clusterOf'),
   createPoolCluster: Symbol('createPoolCluster'),
-  wrappedPoolConnection: Symbol('wrappedPoolConnection')
+  wrappedPoolConnection: Symbol('wrappedPoolConnection'),
+
+  // Used to "decorate" the proxy returned during ESM importing so that
+  // instrumentations can determine if the module looks like an ESM module
+  // or not.
+  nrEsmProxy: Symbol('nr-esm-proxy')
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "11.6.0",
+  "version": "11.6.1",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -183,7 +183,7 @@
   "dependencies": {
     "@grpc/grpc-js": "^1.9.4",
     "@grpc/proto-loader": "^0.7.5",
-    "@newrelic/aws-sdk": "^7.0.2",
+    "@newrelic/aws-sdk": "^7.0.3",
     "@newrelic/koa": "^8.0.1",
     "@newrelic/security-agent": "0.5.0",
     "@newrelic/superagent": "^7.0.1",