newrelic 9.7.0 → 9.7.2

package/lib/instrumentation/undici.js

@@ -5,8 +5,6 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 53] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-
 const cat = require('../util/cat')
 const recordExternal = require('../metrics/recorders/http_external')
 const logger = require('../logger').child({ component: 'undici' })
@@ -14,6 +12,8 @@ const NAMES = require('../metrics/names')
 const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
 const symbols = require('../symbols')
 const { executionAsyncResource } = require('async_hooks')
+const tls = require('tls')
+const net = require('net')
 
 let diagnosticsChannel = null
 try {
@@ -23,7 +23,7 @@ try {
   // module was not added until v15.x
 }
 
-module.exports = function addUndiciChannels(agent, undici, modName, shim) {
+module.exports = function addUndiciChannels(agent, _undici, _modName, shim) {
   if (!diagnosticsChannel || !agent.config.feature_flag.undici_instrumentation) {
     logger.warn(
       'diagnostics_channel or feature_flag.undici_instrumentation = false. Skipping undici instrumentation.'
@@ -31,209 +31,221 @@ module.exports = function addUndiciChannels(agent, undici, modName, shim) {
     return
   }
 
-  /**
-   * Retrieves the current segment in transaction(parent in our context) from executionAsyncResource
-   * or from `shim.getSegment()` then adds to the executionAsyncResource for future
-   * undici requests within same async context.
-   *
-   * It was found that when running concurrent undici requests
-   * within a transaction that the parent segment would get out of sync
-   * depending on the async context of the transaction.  By using
-   * `async_hooks.executionResource` it is more reliable.
-   *
-   * Note: However, if you have concurrent undici requests in a transaction
-   * and the request to the transaction is using a keep alive there is a chance the
-   * executionAsyncResource may be incorrect because of shared connections.  To revert to a more
-   * naive tracking of parent set `config.feature_flag.undici_async_tracking: false` and
-   * it will just call `shim.getSegment()`
-   */
-  function getParentSegment() {
-    if (agent.config.feature_flag.undici_async_tracking) {
-      const resource = executionAsyncResource()
-
-      if (!resource[symbols.parentSegment]) {
-        const parent = shim.getSegment()
-        resource[symbols.parentSegment] = parent
-      }
-      return resource[symbols.parentSegment]
+  registerHookPoints(shim)
+}
+
+/**
+ * Subscribes to all relevant undici hook points
+ * See: https://github.com/nodejs/undici/blob/main/docs/api/DiagnosticsChannel.md
+ *
+ * @param {Shim} shim instance of shim
+ */
+function registerHookPoints(shim) {
+  diagnosticsChannel.channel('undici:request:create').subscribe(requestCreateHook.bind(null, shim))
+  diagnosticsChannel
+    .channel('undici:client:sendHeaders')
+    .subscribe(responseHeadersHook.bind(null, shim))
+  diagnosticsChannel
+    .channel('undici:request:headers')
+    .subscribe(requestHeadersHook.bind(null, shim))
+  diagnosticsChannel
+    .channel('undici:request:trailers')
+    .subscribe(endAndRestoreSegment.bind(null, shim))
+  diagnosticsChannel
+    .channel('undici:request:error')
+    .subscribe(endAndRestoreSegment.bind(null, shim))
+}
+
+/**
+ * Retrieves the current segment in transaction(parent in our context) from executionAsyncResource
+ * or from `shim.getSegment()` then adds to the executionAsyncResource for future
+ * undici requests within same async context.
+ *
+ * It was found that when running concurrent undici requests
+ * within a transaction that the parent segment would get out of sync
+ * depending on the async context of the transaction.  By using
+ * `async_hooks.executionResource` it is more reliable.
+ *
+ * Note: However, if you have concurrent undici requests in a transaction
+ * and the request to the transaction is using a keep alive there is a chance the
+ * executionAsyncResource may be incorrect because of shared connections.  To revert to a more
+ * naive tracking of parent set `config.feature_flag.undici_async_tracking: false` and
+ * it will just call `shim.getSegment()`
+ *
+ * @param {Shim} shim instance of shim
+ * @returns {TraceSegment} parent segment
+ */
+function getParentSegment(shim) {
+  const { config } = shim.agent
+  if (config.feature_flag.undici_async_tracking) {
+    const resource = executionAsyncResource()
+
+    if (!resource[symbols.parentSegment]) {
+      const parent = shim.getSegment()
+      resource[symbols.parentSegment] = parent
     }
-    return shim.getSegment()
+    return resource[symbols.parentSegment]
   }
+  return shim.getSegment()
+}
 
-  /**
-   * This event occurs after the Undici Request is created
-   * We will check current segment for opaque and also attach
-   * relevant headers to outgoing http request
-   *
-   * @param {object} params
-   * @param {object} params.request undici request object
-   */
-  diagnosticsChannel.channel('undici:request:create').subscribe(({ request }) => {
-    const parent = getParentSegment()
-    request[symbols.parentSegment] = parent
-    if (!parent || (parent && parent.opaque)) {
-      logger.trace(
-        'Not capturing data for outbound request (%s) because parent segment opaque (%s)',
-        request.path,
-        parent && parent.name
-      )
-
-      return
-    }
+/**
+ * This event occurs after the Undici Request is created
+ * We will check current segment for opaque and also attach
+ * relevant headers to outgoing http request
+ *
+ * @param {Shim} shim instance of shim
+ * @param {object} params object from undici hook
+ * @param {object} params.request undici request object
+ */
+function requestCreateHook(shim, { request }) {
+  const { config } = shim.agent
+  const parent = getParentSegment(shim)
+  request[symbols.parentSegment] = parent
+  if (!parent || (parent && parent.opaque)) {
+    logger.trace(
+      'Not capturing data for outbound request (%s) because parent segment opaque (%s)',
+      request.path,
+      parent && parent.name
+    )
 
-    const transaction = parent.transaction
-    const outboundHeaders = Object.create(null)
-    if (agent.config.encoding_key && transaction.syntheticsHeader) {
-      outboundHeaders[NEWRELIC_SYNTHETICS_HEADER] = transaction.syntheticsHeader
-    }
+    return
+  }
 
-    if (agent.config.distributed_tracing.enabled) {
-      transaction.insertDistributedTraceHeaders(outboundHeaders)
-    } else if (agent.config.cross_application_tracer.enabled) {
-      cat.addCatHeaders(agent.config, transaction, outboundHeaders)
-    } else {
-      logger.trace('Both DT and CAT are disabled, not adding headers!')
-    }
+  const transaction = parent.transaction
+  const outboundHeaders = Object.create(null)
+  if (config.encoding_key && transaction.syntheticsHeader) {
+    outboundHeaders[NEWRELIC_SYNTHETICS_HEADER] = transaction.syntheticsHeader
+  }
 
-    // eslint-disable-next-line guard-for-in
-    for (const key in outboundHeaders) {
-      request.addHeader(key, outboundHeaders[key])
-    }
-  })
-
-  /**
-   * This event occurs right before the data is written to the socket.
-   * Undici has some abstracted headers that are only created at this time, one
-   * is the `host` header which we need to name the Undici segment. So in this
-   * handler we create, start and set the segment active, name it, and
-   * attach the url/procedure/request.parameters
-   *
-   * @param {object} params
-   * @param {object} params.request undicie request object
-   * @param {TLSSocket | net.Socket} socket active socket connection
-   */
-  diagnosticsChannel.channel('undici:client:sendHeaders').subscribe(({ request, socket }) => {
-    const parentSegment = request[symbols.parentSegment]
-    if (!parentSegment || (parentSegment && parentSegment.opaque)) {
-      return
-    }
+  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!')
+  }
 
-    const port = socket.remotePort
-    const isHttps = socket.servername
-    let urlString
-    if (isHttps) {
-      urlString = `https://${socket.servername}`
-      urlString += port === 443 ? request.path : `:${port}${request.path}`
-    } else {
-      urlString = `http://${socket._host}`
-      urlString += port === 80 ? request.path : `:${port}${request.path}`
-    }
+  // eslint-disable-next-line guard-for-in
+  for (const key in outboundHeaders) {
+    request.addHeader(key, outboundHeaders[key])
+  }
+}
 
-    const url = new URL(urlString)
+/**
+ * This event occurs right before the data is written to the socket.
+ * Undici has some abstracted headers that are only created at this time, one
+ * is the `host` header which we need to name the Undici segment. So in this
+ * handler we create, start and set the segment active, name it, and
+ * attach the url/procedure/request.parameters
+ *
+ * @param {Shim} shim instance of shim
+ * @param {object} params object from undici hook
+ * @param {object} params.request undici request object
+ * @param {tls.TLSSocket | net.Socket} params.socket active socket connection
+ */
+function responseHeadersHook(shim, { request, socket }) {
+  const parentSegment = request[symbols.parentSegment]
+  if (!parentSegment || (parentSegment && parentSegment.opaque)) {
+    return
+  }
 
-    const name = NAMES.EXTERNAL.PREFIX + url.host + url.pathname
-    const segment = shim.createSegment(name, recordExternal(url.host, 'undici'), parentSegment)
-    if (segment) {
-      segment.start()
-      shim.setActiveSegment(segment)
-      segment.addAttribute('url', `${url.protocol}//${url.host}${url.pathname}`)
+  const port = socket.remotePort
+  const isHttps = socket.servername
+  let urlString
+  if (isHttps) {
+    urlString = `https://${socket.servername}`
+    urlString += port === 443 ? request.path : `:${port}${request.path}`
+  } else {
+    urlString = `http://${socket._host}`
+    urlString += port === 80 ? request.path : `:${port}${request.path}`
+  }
 
-      url.searchParams.forEach((value, key) => {
-        segment.addSpanAttribute(`request.parameters.${key}`, value)
-      })
-      segment.addAttribute('procedure', request.method || 'GET')
-      request[symbols.segment] = segment
-    }
-  })
-
-  /**
-   * This event occurs after the response headers have been received.
-   * We will add the relevant http response attributes to active segment.
-   * Also add CAT specific keys to active segment.
-   *
-   * @param {object} params
-   * @param {object} params.request undici request object
-   * @param {object} params.response { statusCode, headers, statusText }
-   */
-  diagnosticsChannel.channel('undici:request:headers').subscribe(({ request, response }) => {
-    const activeSegment = request[symbols.segment]
-    if (!activeSegment) {
-      return
+  const url = new URL(urlString)
+
+  const name = NAMES.EXTERNAL.PREFIX + url.host + url.pathname
+  const segment = shim.createSegment(name, recordExternal(url.host, 'undici'), parentSegment)
+  if (segment) {
+    segment.start()
+    shim.setActiveSegment(segment)
+    segment.addAttribute('url', `${url.protocol}//${url.host}${url.pathname}`)
+
+    url.searchParams.forEach((value, key) => {
+      segment.addSpanAttribute(`request.parameters.${key}`, value)
+    })
+    segment.addAttribute('procedure', request.method || 'GET')
+    request[symbols.segment] = segment
+  }
+}
+
+/**
+ * This event occurs after the response headers have been received.
+ * We will add the relevant http response attributes to active segment.
+ * Also add CAT specific keys to active segment.
+ *
+ * @param {Shim} shim instance of shim
+ * @param {object} params object from undici hook
+ * @param {object} params.request undici request object
+ * @param {object} params.response { statusCode, headers, statusText }
+ */
+function requestHeadersHook(shim, { request, response }) {
+  const { config } = shim.agent
+  const activeSegment = request[symbols.segment]
+  if (!activeSegment) {
+    return
+  }
+
+  activeSegment.addSpanAttribute('http.statusCode', response.statusCode)
+  activeSegment.addSpanAttribute('http.statusText', response.statusText)
+
+  if (config.cross_application_tracer.enabled && !config.distributed_tracing.enabled) {
+    try {
+      const { appData } = cat.extractCatHeaders(response.headers)
+      const decodedAppData = cat.parseAppData(config, appData)
+      const attrs = activeSegment.getAttributes()
+      const url = new URL(attrs.url)
+      cat.assignCatToSegment(decodedAppData, activeSegment, url.host)
+    } catch (err) {
+      logger.warn(err, 'Cannot add CAT data to segment')
     }
+  }
+}
 
-    activeSegment.addSpanAttribute('http.statusCode', response.statusCode)
-    activeSegment.addSpanAttribute('http.statusText', response.statusText)
-
-    if (
-      agent.config.cross_application_tracer.enabled &&
-      !agent.config.distributed_tracing.enabled
-    ) {
-      try {
-        const { appData } = cat.extractCatHeaders(response.headers)
-        const decodedAppData = cat.parseAppData(agent.config, appData)
-        const attrs = activeSegment.getAttributes()
-        const url = new URL(attrs.url)
-        cat.assignCatToSegment(decodedAppData, activeSegment, url.host)
-      } catch (err) {
-        logger.warn(err, 'Cannot add CAT data to segment')
-      }
+/**
+ * Gets the active and parent from given ctx(request, client connector)
+ * and ends active and restores parent to active.  If an error exists
+ * it will add the error to the transaction
+ *
+ * @param {Shim} shim instance of shim
+ * @param {object} params object from undici hook
+ * @param {object} params.request or client connector
+ * @param {Error} params.error error from undici request
+ */
+function endAndRestoreSegment(shim, { request, error }) {
+  const activeSegment = request[symbols.segment]
+  const parentSegment = request[symbols.parentSegment]
+  if (activeSegment) {
+    activeSegment.end()
+
+    if (error) {
+      handleError(shim, activeSegment, error)
     }
-  })
-
-  /**
-   * This event occurs after the response body has been received.
-   * We will end the active segment and set the active back to parent before request
-   *
-   * @param {object} params.request undici request object
-   */
-  diagnosticsChannel.channel('undici:request:trailers').subscribe(({ request }) => {
-    endAndRestoreSegment(request)
-  })
-
-  /**
-   * This event occurs right before the request emits an error.
-   * We will end the active segment and set the active back to parent before request.
-   * We will also log errors to NR
-   *
-   * Note: This event occurs before the error handler so we will always log it for now.
-   */
-  diagnosticsChannel.channel('undici:request:error').subscribe(({ request, error }) => {
-    endAndRestoreSegment(request, error)
-  })
-
-  /**
-   * Gets the active and parent from given ctx(request, client connector)
-   * and ends active and restores parent to active.  If an error exists
-   * it will add the error to the transaction
-   *
-   * @param {object} ctx request or client connector
-   * @param {Error} error
-   */
-  function endAndRestoreSegment(ctx, error) {
-    const activeSegment = ctx[symbols.segment]
-    const parentSegment = ctx[symbols.parentSegment]
-    if (activeSegment) {
-      activeSegment.end()
-
-      if (error) {
-        handleError(activeSegment, error)
-      }
-
-      if (parentSegment) {
-        shim.setActiveSegment(parentSegment)
-      }
+
+    if (parentSegment) {
+      shim.setActiveSegment(parentSegment)
     }
   }
+}
 
-  /**
-   * Adds the error to the active transaction
-   *
-   * @param {TraceSegment} activeSegment
-   * @param {Error} error
-   */
-  function handleError(activeSegment, error) {
-    logger.trace(error, 'Captured outbound error on behalf of the user.')
-    const tx = activeSegment.transaction
-    shim.agent.errors.add(tx, error)
-  }
+/**
+ * Adds the error to the active transaction
+ *
+ * @param {Shim} shim instance of shim
+ * @param {TraceSegment} activeSegment active segment
+ * @param {Error} error error from undici request
+ */
+function handleError(shim, activeSegment, error) {
+  logger.trace(error, 'Captured outbound error on behalf of the user.')
+  const { transaction } = activeSegment
+  shim.agent.errors.add(transaction, error)
 }

package/lib/instrumentation/{when.js → when/constants.js}

@@ -1,12 +1,10 @@
 /*
- * Copyright 2020 New Relic Corporation. All rights reserved.
+ * Copyright 2022 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
 'use strict'
 
-const promInit = require('./promise')
-
 const STATIC_PROMISE_METHODS = [
   'reject',
   'resolve',
@@ -21,12 +19,22 @@ const STATIC_PROMISE_METHODS = [
 
 const WHEN_SPEC = {
   name: 'when',
+  // name of the property where the Promise constructor lives
   constructor: 'Promise',
+  // wrap The Promise constructor
   executor: true,
+  /**
+   * The mapping for Promise instance method concepts (i.e. `then`). These are
+   * mapped on the Promise class' prototype.
+   */
   $proto: {
     then: ['then', 'done', 'spread', 'finally', 'ensure'],
     catch: ['catch', 'otherwise']
   },
+  /**
+   * The mapping for Promise static method concepts (i.e. `settle`, `race`). These
+   * are mapped on the Promise class itself.
+   */
   $static: {
     cast: STATIC_PROMISE_METHODS,
     $copy: STATIC_PROMISE_METHODS.concat([
@@ -49,15 +57,10 @@ const WHEN_SPEC = {
       'onPotentiallyUnhandledRejection'
     ]
   },
+  // The mapping for library-level static method concepts (i.e. `reject`, `resolve`).
   $library: {
     cast: STATIC_PROMISE_METHODS
   }
 }
 
-module.exports = function initialize(agent, library) {
-  if (!library || !library.Promise) {
-    return false
-  }
-
-  promInit(agent, library, WHEN_SPEC)
-}
+module.exports.WHEN_SPEC = WHEN_SPEC

package/lib/instrumentation/when/contextualizer.js

@@ -0,0 +1,168 @@
+/*
+ * Copyright 2022 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const symbols = require('../../symbols')
+
+function Context(segment) {
+  this.segments = [segment]
+}
+
+Context.prototype = Object.create(null)
+
+Context.prototype.branch = function branch() {
+  return this.segments.push(null) - 1
+}
+
+function Contextualizer(idx, context) {
+  this.parentIdx = -1
+  this.idx = idx
+  this.context = context
+  this.child = null
+}
+
+module.exports = Contextualizer
+
+/**
+ * Manually bind the async context to every
+ * child within the promise chain
+ *
+ * @param {object} ctxlzr current promise
+ * @param {object} next the next link in promise chain
+ * @returns {void}
+ */
+function bindChild(ctxlzr, next) {
+  // If prev has one child already, branch the context and update the child.
+  if (ctxlzr.child) {
+    // When the branch-point is the 2nd through nth link in the chain, it is
+    // necessary to track its segment separately so the branches can parent
+    // their segments on the branch-point.
+    if (ctxlzr.parentIdx !== -1) {
+      ctxlzr.idx = ctxlzr.context.branch()
+    }
+
+    // The first child needs to be updated to have its own branch as well. And
+    // each of that child's children must be updated with the new parent index.
+    // This is the only non-constant-time action for linking, but it only
+    // happens with branching promise chains specifically when the 2nd branch
+    // is added.
+    //
+    // Note: This does not account for branches of branches. That may result
+    // in improperly parented segments.
+    let parent = ctxlzr
+    let child = ctxlzr.child
+    const branchIdx = ctxlzr.context.branch()
+    do {
+      child.parentIdx = parent.idx
+      child.idx = branchIdx
+      parent = child
+      child = child.child
+    } while (child)
+
+    // We set the child to something falsey that isn't `null` so we can
+    // distinguish between having no child, having one child, and having
+    // multiple children.
+    ctxlzr.child = false
+  }
+
+  // If this is a branching link then create a new branch for the next promise.
+  // Otherwise, we can just piggy-back on the previous link's spot.
+  const idx = ctxlzr.child === false ? ctxlzr.context.branch() : ctxlzr.idx
+
+  // Create a new context for this next promise.
+  next[symbols.context] = new Contextualizer(idx, ctxlzr.context)
+  next[symbols.context].parentIdx = ctxlzr.idx
+
+  // If this was our first child, remember it in case we have a 2nd.
+  if (ctxlzr.child === null) {
+    ctxlzr.child = next[symbols.context]
+  }
+}
+
+/**
+ * Binds segment to the entire promise chain
+ *
+ * @param {Function} prev previous function in chain
+ * @param {Function} next next function in chain
+ * @param {object} segment proper segment to bind
+ * @returns {void}
+ */
+Contextualizer.link = function link(prev, next, segment) {
+  let ctxlzr = prev && prev[symbols.context]
+  if (ctxlzr && !ctxlzr.isActive()) {
+    ctxlzr = prev[symbols.context] = null
+  }
+
+  if (ctxlzr) {
+    bindChild(ctxlzr, next)
+  } else if (segment) {
+    // This next promise is the root of a chain. Either there was no previous
+    // promise or the promise was created out of context.
+    next[symbols.context] = new Contextualizer(0, new Context(segment))
+  }
+}
+
+Contextualizer.prototype = Object.create(null)
+
+/**
+ * Checks if segment is currently active
+ *
+ * @returns {boolean} if segment is active
+ */
+Contextualizer.prototype.isActive = function isActive() {
+  const segments = this.context.segments
+  const segment = segments[this.idx] || segments[this.parentIdx] || segments[0]
+  return segment && segment.transaction.isActive()
+}
+
+/**
+ * Gets the segment at the appropriate index.
+ * If there is none it will get the segment at the parent index or the first one
+ * then assign to current index.
+ *
+ * @returns {object} segment by idx or parentIdx or the first one
+ */
+Contextualizer.prototype.getSegment = function getSegment() {
+  const segments = this.context.segments
+  let segment = segments[this.idx]
+  if (segment == null) {
+    segment = segments[this.idx] = segments[this.parentIdx] || segments[0]
+  }
+  return segment
+}
+
+/**
+ * Sets the set to the appropriate index
+ *
+ * @param {object} segment segment to assign to index
+ * @returns {object} same segment passed in
+ */
+Contextualizer.prototype.setSegment = function setSegment(segment) {
+  return (this.context.segments[this.idx] = segment)
+}
+
+/**
+ * Propagates the segment to the finally function
+ *
+ * @param {Function} prom current promise
+ * @returns {Function} current promise or wrapped finally that will propagate the segment
+ */
+Contextualizer.prototype.continue = function continueContext(prom) {
+  const self = this
+  const nextContext = prom[symbols.context]
+  if (!nextContext) {
+    return prom
+  }
+
+  // If we have `finally`, use that to sneak our context update.
+  if (typeof prom.finally === 'function') {
+    return prom.finally(__NR_continueContext)
+  }
+
+  // eslint-disable-next-line camelcase
+  function __NR_continueContext() {
+    self.setSegment(nextContext.getSegment())
+  }
+}