newrelic 13.5.0 → 13.6.0

package/lib/harvester.js

@@ -18,11 +18,11 @@ module.exports = class Harvester {
    * Calls start on every registered aggregator that is enabled.
    */
   start() {
-    this.aggregators.forEach((aggregator) => {
+    for (const aggregator of this.aggregators) {
       if (aggregator.enabled) {
         aggregator.start()
       }
-    })
+    }
   }
 
   /**
@@ -57,7 +57,9 @@ module.exports = class Harvester {
    * Calls stop on every registered aggregator.
    */
   stop() {
-    this.aggregators.forEach((aggregator) => aggregator.stop())
+    for (const aggregator of this.aggregators) {
+      aggregator.stop()
+    }
   }
 
   /**
@@ -66,9 +68,9 @@ module.exports = class Harvester {
    * @param {object} config updated agent configuration
    */
   update(config) {
-    this.aggregators.forEach((aggregator) => {
+    for (const aggregator of this.aggregators) {
       aggregator.reconfigure(config)
-    })
+    }
   }
 
   /**

package/lib/header-attributes.js

@@ -78,9 +78,9 @@ _setHeaderAttrNames(REQUEST_HEADER_NAMES, REQUEST_HEADER_PREFIX)
 _setHeaderAttrNames(RESPONSE_HEADER_NAMES, RESPONSE_HEADER_PREFIX)
 
 function _setHeaderAttrNames(dest, prefix) {
-  Object.keys(HEADER_ATTR_NAMES).forEach(function forEachHeader(h) {
-    dest[h] = prefix + HEADER_ATTR_NAMES[h]
-  })
+  for (const header of Object.keys(HEADER_ATTR_NAMES)) {
+    dest[header] = prefix + HEADER_ATTR_NAMES[header]
+  }
 }
 
 function _headerToCamelCase(header) {

package/lib/instrumentation/@google/genai.js

@@ -57,7 +57,6 @@ function addLlmMeta({ agent, transaction }) {
  *
  * @param {object} params input params
  * @param {Agent} params.agent NR agent instance
- * @param {Shim} params.shim the current shim instance
  * @param {TraceSegment} params.segment active segment from chat completion
  * @param {object} params.request chat completion params
  * @param {object} params.response chat completion response
@@ -66,7 +65,6 @@ function addLlmMeta({ agent, transaction }) {
  */
 function recordChatCompletionMessages({
   agent,
-  shim,
   segment,
   request,
   response,
@@ -97,20 +95,21 @@ function recordChatCompletionMessages({
   const inputMessages = Array.isArray(request.contents) ? request.contents : [request.contents]
   const responseMessage = response?.candidates?.[0]?.content
   const messages = responseMessage !== undefined ? [...inputMessages, responseMessage] : inputMessages
-  messages.forEach((message, index) => {
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i]
     const completionMsg = new LlmChatCompletionMessage({
       agent,
       segment,
       transaction,
       request,
       response,
-      index,
+      index: i,
       completionId: completionSummary.id,
       message
     })
 
     recordEvent({ agent, type: 'LlmChatCompletionMessage', msg: completionMsg })
-  })
+  }
 
   recordEvent({ agent, type: 'LlmChatCompletionSummary', msg: completionSummary })
 
@@ -120,7 +119,7 @@ function recordChatCompletionMessages({
   }
 }
 
-function instrumentStream ({ agent, shim, request, response, segment, transaction }) {
+function instrumentStream ({ shim, request, response, segment, transaction }) {
   let err
   let content
   let modelVersion
@@ -167,7 +166,6 @@ function instrumentStream ({ agent, shim, request, response, segment, transactio
 
           recordChatCompletionMessages({
             agent: shim.agent,
-            shim,
             segment,
             transaction,
             request,
@@ -208,7 +206,6 @@ module.exports = function initialize(agent, googleGenAi, moduleName, shim) {
         after({ error: err, result: response, segment, transaction }) {
           recordChatCompletionMessages({
             agent,
-            shim,
             segment,
             transaction,
             request,
@@ -241,7 +238,7 @@ module.exports = function initialize(agent, googleGenAi, moduleName, shim) {
         name: GEMINI.COMPLETION,
         promise: true,
         after({ result: response, segment, transaction }) {
-          instrumentStream({ agent, shim, request, response, segment, transaction })
+          instrumentStream({ shim, request, response, segment, transaction })
           addLlmMeta({ agent, transaction })
         }
       })

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

@@ -110,7 +110,7 @@ function addLlmMeta({ agent, segment, transaction }) {
  * @param {BedrockCommand} params.bedrockCommand parsed input
  * @param {Error|null} params.err error from request if exists
  * @param {BedrockResponse} params.bedrockResponse parsed response
- * @param {Shim} params.shim shim instace
+ * @param {Shim} params.shim shim instance
  * @param {Transaction} params.transaction active transaction
  */
 function recordChatCompletionMessages({
@@ -138,7 +138,8 @@ function recordChatCompletionMessages({
 
   // Record context message(s)
   const promptContextMessages = bedrockCommand.prompt
-  promptContextMessages.forEach((contextMessage, promptIndex) => {
+  for (let i = 0; i < promptContextMessages.length; i++) {
+    const contextMessage = promptContextMessages[i]
     const msg = new LlmChatCompletionMessage({
       agent,
       segment,
@@ -147,13 +148,14 @@ function recordChatCompletionMessages({
       content: contextMessage.content,
       role: contextMessage.role,
       bedrockResponse,
-      index: promptIndex,
+      index: i,
       completionId: summary.id
     })
     recordEvent({ agent, type: 'LlmChatCompletionMessage', msg })
-  })
+  }
 
-  bedrockResponse.completions.forEach((content, completionIndex) => {
+  for (let i = 0; i < bedrockResponse.completions.length; i++) {
+    const content = bedrockResponse.completions[i]
     const chatCompletionMessage = new LlmChatCompletionMessage({
       agent,
       segment,
@@ -161,13 +163,13 @@ function recordChatCompletionMessages({
       bedrockCommand,
       bedrockResponse,
       isResponse: true,
-      index: promptContextMessages.length + completionIndex,
+      index: promptContextMessages.length + i,
       content,
       role: 'assistant',
       completionId: summary.id
     })
     recordEvent({ agent, type: 'LlmChatCompletionMessage', msg: chatCompletionMessage })
-  })
+  }
 
   recordEvent({ agent, type: 'LlmChatCompletionSummary', msg: summary })
 
@@ -214,9 +216,9 @@ function recordEmbeddingMessage({
     isError: err !== null
   }))
 
-  embeddings.forEach((embedding) => {
+  for (const embedding of embeddings) {
     recordEvent({ agent, type: 'LlmEmbedding', msg: embedding })
-  })
+  }
 
   if (err) {
     const llmError = new LlmError({ bedrockResponse, err, embedding: embeddings.length === 1 ? embeddings[0] : undefined })

package/lib/instrumentation/bunyan.js

@@ -38,11 +38,7 @@ function augmentLogData(originalLog, agent, nameFromLevel) {
 
   // Add the metadata to the object being logged
   const metadata = agent.getLinkingMetadata(true)
-  Object.keys(metadata).forEach((m) => {
-    newLog[m] = metadata[m]
-  })
-
-  return newLog
+  return Object.assign({}, newLog, metadata)
 }
 
 function createLoggerWrapper(shim, fn, fnName, bunyanLogger, nameFromLevel) {

package/lib/instrumentation/core/child_process.js

@@ -56,12 +56,12 @@ function initialize(agent, childProcess, moduleName, shim) {
 
 function makePromisifyCompatible(shim, childProcess) {
   const originalExec = shim.getOriginal(childProcess.exec)
-  Object.getOwnPropertySymbols(originalExec).forEach((symbol) => {
+  for (const symbol of Object.getOwnPropertySymbols(originalExec)) {
     childProcess.exec[symbol] = originalExec[symbol]
-  })
+  }
 
   const originalExecFile = shim.getOriginal(childProcess.execFile)
-  Object.getOwnPropertySymbols(originalExecFile).forEach((symbol) => {
+  for (const symbol of Object.getOwnPropertySymbols(originalExecFile)) {
     childProcess.execFile[symbol] = originalExecFile[symbol]
-  })
+  }
 }

package/lib/instrumentation/core/fs.js

@@ -55,9 +55,9 @@ function initialize(agent, fs, moduleName, shim) {
   shim.record(fs, methods, recordFs)
 
   const originalExists = shim.getOriginal(fs.exists)
-  Object.getOwnPropertySymbols(originalExists).forEach((symbol) => {
+  for (const symbol of Object.getOwnPropertySymbols(originalExists)) {
     fs.exists[symbol] = originalExists[symbol]
-  })
+  }
 
   fs.realpath.native = shim.getOriginal(fs.realpath).native
 

package/lib/instrumentation/core/http2.js

@@ -0,0 +1,266 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const NAMES = require('../../metrics/names')
+const recordExternal = require('../../metrics/recorders/http_external')
+const logger = require('../../logger').child({ component: 'http2' })
+const synthetics = require('../../synthetics')
+const urltils = require('../../util/urltils.js')
+const cat = require('#agentlib/util/cat.js')
+const http2ConnectUrl = Symbol('http2ConnectUrl')
+module.exports = initialize
+
+function initialize(agent, http2, moduleName, shim) {
+  shim.wrap(http2, 'connect', wrapConnect)
+
+  /**
+   * Wraps the http2 connect method in instrumentation, and saves the connect URL.
+   * The .request() method's argument doesn't retain the protocol of the connection,
+   * but it's available here as arg[0]
+   *
+   * @param {object} shim the generic shim with which the agent instruments
+   * @param {Function} fn the original connect function
+   * @returns {Function} an instrumented connect function
+   */
+  function wrapConnect(shim, fn) {
+    return function wrappedConnect(...args) {
+      const session = fn.apply(this, args)
+      session[http2ConnectUrl] = args[0]
+      return shim.wrap(session, ['request'], wrapRequest)
+    }
+  }
+
+  /**
+   * Wraps the request and creates an external segment for it
+   *
+   * @param {object} _shim shim passed in from wrapConnect
+   * @param {Function} fn the ClientHttp2Session returned from .connect()
+   * @returns {Function} wrapped request function, which returns a ClientHttp2Stream
+   */
+  function wrapRequest(_shim, fn) {
+    return function wrappedRequest(...args) {
+      const txn = agent.tracer.getTransaction()
+      if (!txn) {
+        logger.trace('Not in a transaction; not recording http2 external')
+        return fn.apply(this, args)
+      }
+      const activeSegment = agent.tracer.getSegment()
+
+      const [headers] = args
+      args[0] = addDTHeaders({
+        transaction: txn,
+        config: agent.config,
+        headers
+      })
+
+      // we are not creating the segment before calling the original function
+      // this is because we can pull of the origin from the symbols on stream
+      // to parse the outgoing URL more accurately
+      // We are not missing much by starting the segment after the stream is created
+      const stream = fn.apply(this, args)
+      const externalAttrs = extractExternalAttrs({ stream, config: agent.config, headers, authority: this[http2ConnectUrl] })
+      const name = NAMES.EXTERNAL.PREFIX + externalAttrs.host + externalAttrs.path
+
+      const segment = agent.tracer.createSegment({
+        name,
+        recorder: recordExternal(externalAttrs.host, 'http2'),
+        parent: activeSegment,
+        transaction: txn
+      })
+
+      if (segment) {
+        segment.start()
+        segment.captureExternalAttributes(externalAttrs)
+        instrumentStream(stream, segment)
+      }
+
+      return stream
+    }
+  }
+
+  /**
+   * Wraps the ClientHttp2Stream to listen for response/header or for errors.
+   * Of the events emitted by Http2Stream, we're interested in 'error', 'frameError', and 'timeout'
+   * Of the events emitted by ClientHttp2Stream, we're interested in 'response', to get headers
+   *
+   * @param {object} stream the ClientHttp2Stream returned from .request()
+   * @param {Segment} segment the external segment created for this request
+   */
+  function instrumentStream(stream, segment) {
+    shim.wrap(stream, 'emit', function wrapStreamEmit(_shim, emit) {
+      const context = agent.tracer.getContext()
+      const transaction = agent.tracer.getTransaction()
+      const newContext = context.enterSegment({ segment })
+      const boundEmit = agent.tracer.bindFunction(emit, newContext)
+
+      return function wrappedEmit(event, arg) {
+        const isErrorEvent = ['error', 'frameError', 'timeout'].indexOf(event) > -1
+        if (isErrorEvent) {
+          handleError({ transaction, stream: this, error: arg })
+        } else if (event === 'response') {
+          handleResponse({ segment, response: arg })
+        }
+        if (isErrorEvent || event === 'end' || event === 'close') {
+          segment.touch()
+        }
+        return boundEmit.apply(this, arguments)
+      }
+    })
+  }
+}
+
+/**
+ * Parses out the :path and :method from the headers,
+ * handle whether headers are raw (array) or object
+ *
+ * @param {object|Array} headers request headers
+ * @param {object} externalAttrs object to populate with path and method
+ */
+function parseAttrsFromHeaders(headers, externalAttrs) {
+  // headers can be raw which are an array in the format of
+  // [<key>, <value>, <key-2>, <value-2>]
+  // attempt to extract `:path` and `:method` from raw headers
+  // otherwise fallback to extracting from object
+  if (Array.isArray(headers)) {
+    for (let i = 0; i < headers.length; i += 2) {
+      const header = headers[i]
+      const value = headers[i + 1]
+      if (header === ':path') {
+        externalAttrs.path = value
+      }
+
+      if (header === ':method') {
+        externalAttrs.method = value
+      }
+    }
+  } else {
+    if (headers[':path']) {
+      externalAttrs.path = headers[':path']
+    }
+
+    if (headers[':method']) {
+      externalAttrs.method = headers[':method']
+    }
+  }
+}
+
+/**
+ * Extracts the authority, path, method from the session.request headers
+ * It then constructs a URL and parses, obfuscates, and scrubs it
+ * and returns the necessary keys to capture it as an external web request
+ *
+ * @param {object} params to function
+ * @param {object} params.config agent config
+ * @param {object|Array} params.headers request headers
+ * @param {string} params.authority the authority (protocol + host + port) from the session.connect
+ * @param {object} params.stream the ClientHttp2Stream
+ * @returns {object} externalAttrs with protocol, hostname, host, method, port, path, queryParams
+ */
+function extractExternalAttrs({ config, headers, authority, stream }) {
+  for (const symbol of Object.getOwnPropertySymbols(stream)) {
+    if (symbol.toString() === 'Symbol(origin)') {
+      authority = stream[symbol]
+    }
+  }
+
+  const externalAttrs = {
+    protocol: 'https:',
+    hostname: null,
+    host: 'unknown',
+    method: 'GET',
+    port: 443,
+    path: '/',
+    queryParams: {},
+  }
+
+  parseAttrsFromHeaders(headers, externalAttrs)
+
+  let parsedUrl
+  try {
+    parsedUrl = new URL(`${authority}${externalAttrs.path}`)
+  } catch (err) {
+    logger.trace('Could not parse URL from request headers: %s', err.message)
+  }
+
+  if (parsedUrl) {
+    externalAttrs.host = parsedUrl.host
+    externalAttrs.hostname = parsedUrl.hostname
+    externalAttrs.port = parseInt(parsedUrl.port, 10)
+    externalAttrs.protocol = parsedUrl.protocol
+    const scrubbedUrl = urltils.scrubAndParseParameters(parsedUrl) // to get parameters in the format we want
+    externalAttrs.path = urltils.obfuscatePath(config, scrubbedUrl.path)
+    externalAttrs.queryParams = scrubbedUrl?.parameters
+  }
+
+  return externalAttrs
+}
+
+/**
+ * Notices the given error if there is no listener for the `error` event on the
+ * request object.
+ *
+ * @param {object} params to function
+ * @param {Transaction} params.transaction active transaction
+ * @param {object} params.stream wrapped ClientHttp2Stream, the closest analog of request
+ * @param {Error} params.error If provided, unhandled error that occurred during request
+ * @returns {void}
+ */
+function handleError({ transaction, stream, error }) {
+  if (stream?.listenerCount('error') > 0) {
+    logger.trace(error, 'Not capturing http2 client error because user has already handled it.')
+    return
+  }
+
+  logger.trace(error, 'Captured outbound error on behalf of the user.')
+  transaction.agent.errors.add(transaction, error)
+}
+
+/**
+ * Ties the ClientHttp2Stream response to the session.request() segment.
+ *
+ * @param {object} params to function
+ * @param {object} params.response ClientHttp2Stream response header
+ * @param {TraceSegment} params.segment external segment created for this request
+ */
+function handleResponse({ segment, response }) {
+  // Add response attributes for spans
+  const status = response?.[':status']
+  const statusHeader = 'http.statusCode'
+  segment.addSpanAttribute(statusHeader, status)
+}
+
+/**
+ * Injects relevant tracing headers for the external request
+ *
+ * @param {object} params object to fn
+ * @param {Shim} params.transaction current transaction
+ * @param {object} params.headers outbound ClientHttp2Session request headers
+ * @param {object} params.config agent config
+ * @returns {object} headers with DT inserted, if enabled, or the original headers
+ */
+function addDTHeaders({ transaction, config, headers }) {
+  const outboundHeaders = Object.create(null)
+  synthetics.assignHeadersToOutgoingRequest(config, transaction, outboundHeaders)
+
+  if (config.distributed_tracing.enabled) {
+    transaction.insertDistributedTraceHeaders(outboundHeaders)
+  } else if (config.cross_application_tracer.enabled) {
+    cat.addCatHeaders(config, transaction, outboundHeaders)
+  } else {
+    logger.trace('Both DT and CAT are disabled, not adding headers!')
+  }
+
+  for (const key in outboundHeaders) {
+    if (Array.isArray(headers)) {
+      headers.push(key)
+      headers.push(outboundHeaders[key])
+    } else {
+      headers[key] = outboundHeaders[key]
+    }
+  }
+  return headers
+}

package/lib/instrumentation/core/timers.js

@@ -22,7 +22,7 @@ function initialize(_agent, timers, _moduleName, shim) {
  * @param {Array<Timers,global>} pkgs array with references to timers and global
  */
 function instrumentTimerMethods(shim, pkgs) {
-  pkgs.forEach((nodule) => {
+  for (const nodule of pkgs) {
     if (shim.isWrapped(nodule.setTimeout)) {
       return
     }
@@ -31,7 +31,7 @@ function instrumentTimerMethods(shim, pkgs) {
     shim.record(nodule, asynchronizers, recordAsynchronizers)
     shim.wrap(nodule, 'clearTimeout', wrapClearTimeout)
     makeWrappedPromisifyCompatible(shim, nodule)
-  })
+  }
 }
 
 /**
@@ -86,7 +86,7 @@ function makeWrappedPromisifyCompatible(shim, nodule) {
  */
 function copySymbols(shim, nodule, name) {
   const originalFunction = shim.getOriginal(nodule[name])
-  Object.getOwnPropertySymbols(originalFunction).forEach((symbol) => {
+  for (const symbol of Object.getOwnPropertySymbols(originalFunction)) {
     nodule[name][symbol] = originalFunction[symbol]
-  })
+  }
 }

package/lib/instrumentation/fastify.js

@@ -35,7 +35,7 @@ function setupRouteHandler(shim, fastify) {
      * recordMiddleware handler call
      *
      * The WebFramework shim treats the main route handler like any other
-     * i.e. dont be confused by the call to recordMiddleware -- we don't
+     * i.e. don't be confused by the call to recordMiddleware -- we don't
      * have a recordRouteHandler, everything goes through recordMiddleware
      */
     const newRouteHandler = shim.recordMiddleware(

package/lib/instrumentation/grpc-js/grpc.js

@@ -70,9 +70,9 @@ function wrapStart(shim, original) {
       const outboundAgentHeaders = Object.create(null)
       if (shim.agent.config.distributed_tracing.enabled) {
         transaction.insertDistributedTraceHeaders(outboundAgentHeaders)
-        Object.keys(outboundAgentHeaders).forEach((key) => {
-          nrMetadata.add(key, outboundAgentHeaders[key])
-        })
+        for (const [key, value] of Object.entries(outboundAgentHeaders)) {
+          nrMetadata.add(key, value)
+        }
       } else {
         shim.logger.debug('Distributed tracing disabled by instrumentation.')
       }
@@ -109,8 +109,8 @@ function wrapStart(shim, original) {
         })
 
         if (originalListener && originalListener.onReceiveStatus) {
-          const onReceiveStatuts = shim.bindSegment(originalListener.onReceiveStatus, segment)
-          onReceiveStatuts(status)
+          const onReceiveStatus = shim.bindSegment(originalListener.onReceiveStatus, segment)
+          onReceiveStatus(status)
         }
         segment.end()
       }
@@ -192,9 +192,9 @@ function wrapRegister(shim, original) {
 
     function acceptDTHeaders(stream, transaction) {
       const metadata = stream.metadata
-      Object.entries(metadata.getMap()).forEach(([key, value]) => {
+      for (const [key, value] of Object.entries(metadata.getMap())) {
         transaction.trace.attributes.addAttribute(DESTINATION, `request.headers.${key}`, value)
-      })
+      }
 
       const headers = Object.create(null)
       headers.tracestate = metadata.get('tracestate').join(',')

package/lib/instrumentation/koa/route-instrumentation.js

@@ -11,23 +11,21 @@ const { MiddlewareSpec } = require('../../shim/specs')
 module.exports = function instrumentRoute(shim, route) {
   shim.setFramework(shim.KOA)
 
-  METHODS.forEach(function wrap(method) {
-    shim.wrap(route, method, function wrapMethod(shim, methodFn) {
-      return function wrappedMethod() {
-        const middleware = methodFn.apply(route, arguments)
-        return shim.recordMiddleware(
-          middleware,
-          new MiddlewareSpec({
-            route: arguments[0],
-            next: shim.LAST,
-            name: shim.getName(arguments[1]),
-            promise: true,
-            req: function getReq(shim, fn, fnName, args) {
-              return args[0] && args[0].req
-            }
-          })
-        )
-      }
-    })
+  shim.wrap(route, METHODS, function wrapMethod(shim, methodFn) {
+    return function wrappedMethod() {
+      const middleware = methodFn.apply(route, arguments)
+      return shim.recordMiddleware(
+        middleware,
+        new MiddlewareSpec({
+          route: arguments[0],
+          next: shim.LAST,
+          name: shim.getName(arguments[1]),
+          promise: true,
+          req: function getReq(shim, fn, fnName, args) {
+            return args[0] && args[0].req
+          }
+        })
+      )
+    }
   })
 }

package/lib/instrumentation/langchain/runnable.js

@@ -48,7 +48,7 @@ module.exports = function initialize(shim, langchain) {
  *
  * @param {object} params function params
  * @param {object} params.langchain `@langchain/core/runnables/base` export
- * @param {Shim} params.shim instace of shim
+ * @param {Shim} params.shim instance of shim
  */
 function instrumentInvokeChain({ langchain, shim }) {
   shim.record(
@@ -84,7 +84,7 @@ function instrumentInvokeChain({ langchain, shim }) {
  *
  * @param {object} params function params
  * @param {object} params.langchain `@langchain/core/runnables/base` export
- * @param {Shim} params.shim instace of shim
+ * @param {Shim} params.shim instance of shim
  */
 function instrumentStream({ langchain, shim }) {
   shim.record(

package/lib/instrumentation/langchain/vectorstore.js

@@ -52,7 +52,8 @@ function recordVectorSearch({
 
   recordEvent({ agent, shim, type: 'LlmVectorSearch', pkgVersion, msg: vectorSearch })
 
-  output.forEach((document, sequence) => {
+  for (let sequence = 0; sequence < output.length; sequence++) {
+    const document = output[sequence]
     const vectorSearchResult = new LangChainVectorSearchResult({
       agent,
       segment,
@@ -70,7 +71,7 @@ function recordVectorSearch({
       pkgVersion,
       msg: vectorSearchResult
     })
-  })
+  }
 
   if (err) {
     agent.errors.add(