newrelic 9.14.0 → 9.15.0

package/NEWS.md

@@ -1,3 +1,11 @@
+### v9.15.0 (2023-04-04)
+
+* Added a new configuration option `heroku.use_dyno_names` to specify whether or not to use `process.env.DYNO` for naming the host name and display host.  This option defaults to true.  If you are on heroku and do not want this functionality set `heroku.use_dyno_names` to `false`.  You can also control this configuration options with the environment variable of `NEW_RELIC_HEROKU_USE_DYNO_NAMES`. Thanks @benney-au-le  for your contribution 🚀
+
+### v9.14.1 (2023-03-23)
+
+* Restored assigning loaded version of agent to require.cache as `__NR_cache` instead of a symbol to properly detect attempts at loading agent twice.
+
 ### v9.14.0 (2023-03-23)
 
 * Added new API function called `setErrorGroupCallback`, which provides a way for you to customize the `error.group.name` attribute of errors that are captured by the agent. This attribute controls how the Errors Inbox functionality groups similar errors together. To learn more about this function, please refer to our [example app](https://github.com/newrelic/newrelic-node-examples).

package/index.js

@@ -14,7 +14,6 @@ require('./lib/util/unwrapped-core')
 
 const featureFlags = require('./lib/feature_flags').prerelease
 const psemver = require('./lib/util/process-version')
-const symbols = require('./lib/symbols')
 let logger = require('./lib/logger') // Gets re-loaded after initialization.
 
 const pkgJSON = require('./package.json')
@@ -24,15 +23,15 @@ logger.info(
   process.version
 )
 
-if (require.cache[symbols.cache]) {
+if (require.cache.__NR_cache) {
   logger.warn(
     'Attempting to load a second copy of newrelic from %s, using cache instead',
     __dirname
   )
-  if (require.cache[symbols.cache].agent) {
-    require.cache[symbols.cache].agent.recordSupportability('Agent/DoubleLoad')
+  if (require.cache.__NR_cache.agent) {
+    require.cache.__NR_cache.agent.recordSupportability('Agent/DoubleLoad')
   }
-  module.exports = require.cache[symbols.cache]
+  module.exports = require.cache.__NR_cache
 } else {
   initialize()
 }
@@ -99,7 +98,7 @@ function initialize() {
     API = require('./stub_api')
   }
 
-  require.cache[symbols.cache] = module.exports = new API(agent)
+  require.cache.__NR_cache = module.exports = new API(agent)
 
   // If we loaded an agent, record a startup time for the agent.
   // NOTE: Metrics are recorded in seconds, so divide the value by 1000.

package/lib/config/default.js

@@ -1318,6 +1318,13 @@ defaultConfig.definition = () => ({
         }
       }
     }
+  },
+
+  heroku: {
+    use_dyno_names: {
+      default: true,
+      formatter: boolean
+    }
   }
 })
 

package/lib/config/index.js

@@ -914,11 +914,17 @@ Config.prototype.getIPAddresses = function getIPAddresses() {
 
 function getHostnameSafe() {
   let _hostname
+  const config = this
   this.getHostnameSafe = function getCachedHostname() {
     return _hostname
   }
   try {
-    _hostname = os.hostname()
+    if (config.heroku.use_dyno_names) {
+      const dynoName = process.env.DYNO
+      _hostname = dynoName || os.hostname()
+    } else {
+      _hostname = os.hostname()
+    }
     return _hostname
   } catch (e) {
     const addresses = this.getIPAddresses()

package/lib/shim/datastore-shim.js

@@ -5,8 +5,6 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 57] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-
 const dbutil = require('../db/utils')
 const hasOwnProperty = require('../util/properties').hasOwn
 const logger = require('../logger').child({ component: 'DatastoreShim' })
@@ -357,19 +355,17 @@ function recordOperation(nodule, properties, opSpec) {
   return this.record(nodule, properties, function opRecorder(shim, fn, fnName, args) {
     shim.logger.trace('Recording datastore operation "%s"', fnName)
 
-    // Derive the segment information.
+    // Derive the segment information, starting from some defaults
     let segDesc = null
     if (shim.isFunction(opSpec)) {
       segDesc = opSpec.call(this, shim, fn, fnName, args)
     } else {
       segDesc = {
-        name: opSpec.name || fnName || 'other',
-        parameters: opSpec.parameters,
-        callback: opSpec.callback,
-        after: 'after' in opSpec ? opSpec.after : null,
-        promise: 'promise' in opSpec ? opSpec.promise : null,
-        record: opSpec.record,
-        opaque: opSpec.opaque || false
+        name: fnName || 'other',
+        opaque: false,
+        after: null,
+        promise: null,
+        ...opSpec
       }
     }
     if (hasOwnProperty(segDesc, 'parameters')) {
@@ -648,26 +644,31 @@ function _recordQuery(suffix, nodule, properties, querySpec) {
 
     let queryDesc = querySpec
     if (shim.isFunction(querySpec)) {
-      queryDesc = querySpec.call(this, shim, fn, fnName, args)
+      queryDesc = querySpec.call(this, shim, fn, fnName, args) || Object.create(null)
+    }
+
+    // Set some default values, in case they're missing.
+    queryDesc = {
+      name: fnName,
+      callback: null,
+      rowCallback: null,
+      stream: null,
+      after: null,
+      promise: null,
+      opaque: false,
+      inContext: null,
+      ...queryDesc
     }
 
+    const parameters = _normalizeParameters.call(shim, queryDesc.parameters || Object.create(null))
+
     // If we're not actually recording this, then just return the segment
     // descriptor now.
-    if (hasOwnProperty(queryDesc, 'record') && queryDesc.record === false) {
-      const parameters = _normalizeParameters.call(
-        shim,
-        queryDesc.parameters || Object.create(null)
-      )
+    if (queryDesc?.record === false) {
       return {
-        name: queryDesc.name || fnName,
-        parameters,
-        callback: 'callback' in queryDesc ? queryDesc.callback : null,
-        rowCallback: 'rowCallback' in queryDesc ? queryDesc.rowCallback : null,
-        stream: 'stream' in queryDesc ? queryDesc.stream : null,
-        after: 'after' in queryDesc ? queryDesc.after : null,
-        promise: 'promise' in queryDesc ? queryDesc.promise : null,
-        internal: 'internal' in queryDesc ? queryDesc.internal : false,
-        opaque: 'opaque' in queryDesc ? queryDesc.opaque : false
+        internal: false,
+        ...queryDesc,
+        parameters
       }
     }
 
@@ -683,18 +684,13 @@ function _recordQuery(suffix, nodule, properties, querySpec) {
     shim.logger.trace('Found and parsed query %s -> %s', parsed.type, name)
 
     // Return the segment descriptor.
-    const parameters = _normalizeParameters.call(shim, queryDesc.parameters || Object.create(null))
     return {
+      internal: true,
+      ...queryDesc,
+      // This name and parameters might override those in the original
+      // queryDesc.
       name: shim._metrics.STATEMENT + name,
       parameters,
-      callback: 'callback' in queryDesc ? queryDesc.callback : null,
-      rowCallback: 'rowCallback' in queryDesc ? queryDesc.rowCallback : null,
-      stream: 'stream' in queryDesc ? queryDesc.stream : null,
-      after: 'after' in queryDesc ? queryDesc.after : null,
-      promise: 'promise' in queryDesc ? queryDesc.promise : null,
-      internal: 'internal' in queryDesc ? queryDesc.internal : true,
-      opaque: 'opaque' in queryDesc ? queryDesc.opaque : false,
-      inContext: 'inContext' in queryDesc ? queryDesc.inContext : null,
       recorder: function queryRecorder(segment, scope) {
         if (segment) {
           parsed.recordMetrics(segment, scope)
@@ -806,6 +802,20 @@ function _normalizeParameters(parameters) {
 
   parameters.product = parameters.product || this._datastore
 
+  _normalizeDatabaseName(parameters, dsTracerConf)
+  _normalizeInstanceInformation(parameters, dsTracerConf, config)
+
+  return parameters
+}
+
+/**
+ * Normalizes the database name from segment parameter values.
+ *
+ * @private
+ * @param {object} parameters   - The segment parameters to clean up.
+ * @param {object} dsTracerConf - The datastore tracer configuration
+ */
+function _normalizeDatabaseName(parameters, dsTracerConf) {
   // Add database name if provided and enabled.
   if (!dsTracerConf.database_name_reporting.enabled) {
     delete parameters.database_name
@@ -815,7 +825,18 @@ function _normalizeParameters(parameters) {
         ? String(parameters.database_name)
         : parameters.database_name || INSTANCE_UNKNOWN
   }
+}
 
+/**
+ * Normalizes the database instance information from segment parameter
+ * values: host and the port/path/id.
+ *
+ * @private
+ * @param {object} parameters   - The segment parameters to clean up.
+ * @param {object} dsTracerConf - The datastore tracer configuration
+ * @param {object} config       - The agent configuration
+ */
+function _normalizeInstanceInformation(parameters, dsTracerConf, config) {
   // Add instance information if enabled.
   if (!dsTracerConf.instance_reporting.enabled) {
     delete parameters.host
@@ -836,6 +857,4 @@ function _normalizeParameters(parameters) {
       }
     }
   }
-
-  return parameters
 }

package/lib/symbols.js

@@ -6,7 +6,6 @@
 'use strict'
 
 module.exports = {
-  cache: Symbol('cache'),
   clm: Symbol('codeLevelMetrics'),
   context: Symbol('context'),
   databaseName: Symbol('databaseName'),

package/lib/transaction/index.js

@@ -5,8 +5,6 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 29] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-
 const errorHelper = require('../errors/helper')
 const hashes = require('../util/hashes')
 const logger = require('../logger').child({ component: 'transaction' })
@@ -187,7 +185,7 @@ Transaction.prototype.isWeb = function isWeb() {
 }
 
 /**
- * @returns {bool} Is this transaction still alive?
+ * @returns {boolean} Is this transaction still alive?
  */
 Transaction.prototype.isActive = function isActive() {
   return this.timer.isActive()
@@ -196,6 +194,8 @@ Transaction.prototype.isActive = function isActive() {
 /**
  * Close out the current transaction and its associated trace. Remove any
  * instances of this transaction annotated onto the call stack.
+ *
+ * @returns {(Transaction|undefined)} this transaction, or undefined
  */
 Transaction.prototype.end = function end() {
   if (!this.timer.isActive()) {
@@ -259,6 +259,8 @@ Transaction.prototype._cleanUneededReferences = function _cleanUneededReferences
  * For web transactions, this represents the time from when the request was received
  * to when response was sent.  For background transactions, it is equal to duration
  * of the transaction trace (until last segment ended).
+ *
+ * @returns {number} timer or trace duration in milliseconds
  */
 Transaction.prototype.getResponseTimeInMillis = function getResponseTimeInMillis() {
   if (this.isWeb()) {
@@ -408,6 +410,7 @@ Transaction.prototype.isIgnored = function getIgnore() {
  * @param {number} statusCode - The response status code.
  */
 Transaction.prototype.finalizeNameFromUri = finalizeNameFromUri
+
 function finalizeNameFromUri(requestURL, statusCode) {
   if (logger.traceEnabled()) {
     logger.trace(
@@ -427,24 +430,7 @@ function finalizeNameFromUri(requestURL, statusCode) {
 
   // If a namestate stack exists, copy route parameters over to the trace.
   if (!this.nameState.isEmpty() && this.baseSegment) {
-    this.nameState.forEachParams(function forEachRouteParams(params) {
-      for (const key in params) {
-        if (props.hasOwn(params, key)) {
-          this.trace.attributes.addAttribute(DESTS.NONE, REQUEST_PARAMS_PATH + key, params[key])
-
-          const segment = this.agent.tracer.getSegment()
-
-          if (!segment) {
-            logger.trace(
-              'Active segment not available, not adding request.parameters attribute for %s',
-              key
-            )
-          } else {
-            segment.attributes.addAttribute(DESTS.NONE, REQUEST_PARAMS_PATH + key, params[key])
-          }
-        }
-      }
-    }, this)
+    this.nameState.forEachParams(forEachRouteParams, this)
   }
 
   // Allow the API to explicitly set the ignored status.
@@ -468,6 +454,25 @@ function finalizeNameFromUri(requestURL, statusCode) {
   }
 }
 
+function forEachRouteParams(params) {
+  for (const key in params) {
+    if (props.hasOwn(params, key)) {
+      this.trace.attributes.addAttribute(DESTS.NONE, REQUEST_PARAMS_PATH + key, params[key])
+
+      const segment = this.agent.tracer.getSegment()
+
+      if (!segment) {
+        logger.trace(
+          'Active segment not available, not adding request.parameters attribute for %s',
+          key
+        )
+      } else {
+        segment.attributes.addAttribute(DESTS.NONE, REQUEST_PARAMS_PATH + key, params[key])
+      }
+    }
+  }
+}
+
 Transaction.prototype._copyNameToActiveSpan = function _copyNameToActiveSpan(name) {
   const spanContext = this.agent.tracer.getSpanContext()
   if (!spanContext) {
@@ -512,6 +517,7 @@ Transaction.prototype._markAsWeb = function _markAsWeb(rawURL) {
  * @param {string} [name]
  *  Optional. The partial name to use for the finalized transaction. If omitted
  *  the current partial name is used.
+ * @returns {undefined} undefined, finalizing name as a side effect
  */
 Transaction.prototype.finalizeName = function finalizeName(name) {
   // If no name is given, and this is a web transaction with a url, then
@@ -564,6 +570,8 @@ Transaction.prototype.finalizeName = function finalizeName(name) {
  * cause extra performance overhead. Once this is refactored we can make the
  * caching better and eliminate this extra overhead. Be mindful of if/when this
  * is called.
+ *
+ * @returns {string} finalized name value or partial name
  */
 Transaction.prototype.getName = function getName() {
   if (this.isWeb() && this.url) {
@@ -620,7 +628,7 @@ Transaction.prototype.getFullName = function getFullName() {
  * otherwise it will parse .url, store it on .parsedUrl, then scrub the URL and
  * store it in the cache.
  *
- * Returns a string or undefined.
+ * @returns {(string|undefined)} Returns a string or undefined.
  */
 Transaction.prototype.getScrubbedUrl = function getScrubbedUrl() {
   if (!this.isWeb()) {
@@ -703,18 +711,17 @@ Transaction.prototype.measure = function measure(name, scope, duration, exclusiv
  *
  * @param {string} name     Metric name.
  * @param {number} duration Duration of the transaction, in milliseconds.
- * @param {number} keyApdex A key transaction apdexT, in milliseconds
- *                          (optional).
- * @param keyApdexInMillis
+ * @param {number} keyApdexInMillis Duration sent to the metrics getOrCreateApdexMetric method, to
+ *                                  derive apdex from timing in milliseconds
  */
 Transaction.prototype._setApdex = function _setApdex(name, duration, keyApdexInMillis) {
   const apdexStats = this.metrics.getOrCreateApdexMetric(name, null, keyApdexInMillis)
 
   // if we have an error-like status code, and all the errors are
   // expected, we know the status code was caused by an expected
-  // error, so we will not report "frustrating".  Otherwise, we
+  // error, so we will not report "frustrating."  Otherwise, we
   // don't know which error triggered the error-like status code,
-  // and will still incrementing frustrating.  If this is an issue,
+  // and will still increment "frustrating."  If this is an issue,
   // users can either set a status code as expected, or ignore the
   // specific error to avoid incrementing to frustrating
   if (
@@ -732,6 +739,7 @@ Transaction.prototype._setApdex = function _setApdex(name, duration, keyApdexInM
  * Store first 10 unique path hashes calculated for a transaction.
  *
  * @param {string} pathHash Path hash
+ * @returns {undefined}
  */
 Transaction.prototype.pushPathHash = function pushPathHash(pathHash) {
   if (this.pathHashes.length >= 10 || this.pathHashes.indexOf(pathHash) !== -1) {
@@ -742,6 +750,8 @@ Transaction.prototype.pushPathHash = function pushPathHash(pathHash) {
 
 /**
  * Return whether transaction spawned any outbound requests.
+ *
+ * @returns {boolean} if there are more than zero pathHashes
  */
 Transaction.prototype.includesOutboundRequests = function includesOutboundRequests() {
   return this.pathHashes.length > 0
@@ -750,6 +760,8 @@ Transaction.prototype.includesOutboundRequests = function includesOutboundReques
 /**
  * Get unique previous path hashes for a transaction. Does not include
  * current path hash.
+ *
+ * @returns {(string|null)} Returns sorted altHashes joined by commas, or null.
  */
 Transaction.prototype.alternatePathHashes = function alternatePathHashes() {
   const curHash = hashes.calculatePathHash(
@@ -771,7 +783,7 @@ Transaction.prototype.alternatePathHashes = function alternatePathHashes() {
  * Add the error information to the current segment and add the segment ID as
  * an attribute onto the exception.
  *
- * @param {Exception}   exception  The exception object to be collected.
+ * @param {Exception} exception  The exception object to be collected.
  */
 Transaction.prototype._linkExceptionToSegment = _linkExceptionToSegment
 
@@ -817,7 +829,7 @@ function _addException(exception) {
  * When the transaction ends, the exception will be collected along with the transaction
  * details.
  *
- * @param {Exception}   exception  The exception object to be collected.
+ * @param {Exception}  exception  The exception object to be collected.
  */
 Transaction.prototype.addUserError = _addUserError
 
@@ -832,7 +844,7 @@ function _addUserError(exception) {
 }
 
 /**
- * Returns if the transaction's current status code is errored
+ * @returns {boolean} true if the transaction's current status code is errored
  * but considered ignored via the config.
  */
 Transaction.prototype.hasIgnoredErrorStatusCode = function _hasIgnoredErrorStatusCode() {
@@ -840,7 +852,7 @@ Transaction.prototype.hasIgnoredErrorStatusCode = function _hasIgnoredErrorStatu
 }
 
 /**
- * Returns true if an error happened during the transaction or if the transaction itself is
+ * @returns {boolean} true if an error happened during the transaction or if the transaction itself is
  * considered to be an error.
  */
 Transaction.prototype.hasErrors = function _hasErrors() {
@@ -850,7 +862,9 @@ Transaction.prototype.hasErrors = function _hasErrors() {
   return transactionHasExceptions || transactionHasuserErrors || isErroredTransaction
 }
 
-// Returns true if all the errors/exceptions collected so far are expected errors
+/**
+ * @returns {boolean} true if all the errors/exceptions collected so far are expected errors
+ */
 Transaction.prototype.hasOnlyExpectedErrors = function hasOnlyExpectedErrors() {
   if (0 === this.exceptions.length) {
     return false
@@ -871,7 +885,7 @@ Transaction.prototype.hasOnlyExpectedErrors = function hasOnlyExpectedErrors() {
 }
 
 /**
- * Returns agent intrinsic attribute for this transaction.
+ * @returns {object} agent intrinsic attribute for this transaction.
  */
 Transaction.prototype.getIntrinsicAttributes = function getIntrinsicAttributes() {
   if (!this._intrinsicAttributes.totalTime) {
@@ -909,7 +923,7 @@ Transaction.prototype.getIntrinsicAttributes = function getIntrinsicAttributes()
  * W3C TraceContext format is preferred over the NewRelic DT format.
  * NewRelic DT format will be used if no `traceparent` header is found.
  *
- * @param @param {string} [transport='Unknown'] - The transport type that delivered the trace.
+ * @param {string} [transport='Unknown'] - The transport type that delivered the trace.
  * @param {object} headers - Headers to search for supported trace formats. Keys must be lowercase.
  */
 Transaction.prototype.acceptDistributedTraceHeaders = acceptDistributedTraceHeaders
@@ -1025,32 +1039,33 @@ function acceptTraceContextPayload(traceparent, tracestate, transport) {
   }
 }
 
-/**
- * Parses incoming distributed trace header payload.
- *
- * @param {object} payload                - The distributed trace payload to accept.
- * @param {string} [transport='Unknown']  - The transport type that delivered the payload.
+/*
+  The following underscored functions are used exclusively by the
+  _acceptDistributedTracePayload method. They're broken out to reduce
+  its cognitive complexity.
  */
-Transaction.prototype._acceptDistributedTracePayload = _acceptDistributedTracePayload
-function _acceptDistributedTracePayload(payload, transport) {
+const _dtPayloadTest = function _dtPayloadTest(payload) {
   if (!payload) {
     this.agent.recordSupportability('DistributedTrace/AcceptPayload/Ignored/Null')
-    return
   }
-
+  return !!payload
+}
+const _isDtTest = function _isDtTest() {
   if (this.isDistributedTrace) {
     logger.warn(
       'Already accepted or created a distributed trace payload for transaction %s, ignoring call',
       this.id
     )
+    let supportabilityMetric = 'DistributedTrace/AcceptPayload/Ignored/CreateBeforeAccept'
     if (this.parentId) {
-      this.agent.recordSupportability('DistributedTrace/AcceptPayload/Ignored/Multiple')
-    } else {
-      this.agent.recordSupportability('DistributedTrace/AcceptPayload/Ignored/CreateBeforeAccept')
+      supportabilityMetric = 'DistributedTrace/AcceptPayload/Ignored/Multiple'
     }
-    return
+    this.agent.recordSupportability(supportabilityMetric)
+    return true
   }
-
+  return false
+}
+const _dtConfigTest = function _dtConfigTest() {
   const config = this.agent.config
   const distTraceEnabled = config.distributed_tracing.enabled
   const trustedAccount = config.trusted_account_key || config.account_id
@@ -1064,60 +1079,56 @@ function _acceptDistributedTracePayload(payload, transport) {
     )
 
     this.agent.recordSupportability(DT_ACCEPT_PAYLOAD_EXCEPTION_METRIC)
-    return
+    return false
   }
-
+  return trustedAccount
+}
+const _dtParseTest = function _dtParseTest(payload) {
   const parsed = this._getParsedPayload(payload)
 
   if (!parsed) {
-    return
+    return false
   }
 
+  if (!parsed.v) {
+    logger.warn('Received a distributed trace payload with no version field', this.id)
+  }
+  if (!parsed.d) {
+    logger.warn('Received a distributed trace payload with no data field', this.id)
+  }
   if (!parsed.v || !parsed.d) {
-    if (!parsed.v) {
-      logger.warn('Received a distributed trace payload with no version field', this.id)
-    }
-    if (!parsed.d) {
-      logger.warn('Received a distributed trace payload with no data field', this.id)
-    }
     this.agent.recordSupportability(DT_ACCEPT_PAYLOAD_PARSE_EXCEPTION_METRIC)
-    return
+    return false
   }
-
+  return parsed
+}
+const _dtVersionTest = function _dtVersionTest(parsed) {
   const majorVersion = parsed.v && typeof parsed.v[0] === 'number' && parsed.v[0]
-  if (majorVersion == null) {
+
+  if (majorVersion === null) {
     logger.warn('Invalid distributed trace payload, not accepting')
     this.agent.recordSupportability(DT_ACCEPT_PAYLOAD_EXCEPTION_METRIC)
   }
   if (majorVersion > 0) {
     // TODO: Add DistributedTracePayload class?
     this.agent.recordSupportability('DistributedTrace/AcceptPayload/Ignored/MajorVersion')
-    return
   }
-
-  const data = parsed.d
-
-  if (!data) {
-    logger.warn('No distributed trace data received, not accepting payload')
-    this.agent.recordSupportability(DT_ACCEPT_PAYLOAD_EXCEPTION_METRIC)
-    return
-  }
-
-  const requiredKeysExist = REQUIRED_DT_KEYS.every(function checkExists(key) {
+  return majorVersion
+}
+const _dtRequiredKeyTest = function _dtRequiredKeyTest(data) {
+  return REQUIRED_DT_KEYS.every(function checkExists(key) {
     return data[key] != null
   })
+}
+const _dtSpanParentTest = function _dtSpanParentTest(requiredKeysExist, data) {
   // Either parentSpanId or parentId are required.
   if (!requiredKeysExist || (data.tx == null && data.id == null)) {
     this.agent.recordSupportability(DT_ACCEPT_PAYLOAD_PARSE_EXCEPTION_METRIC)
-    return
-  }
-
-  const trustedAccountKey = data.tk || data.ac
-  if (trustedAccountKey !== trustedAccount) {
-    this.agent.recordSupportability(`DistributedTrace/AcceptPayload/Ignored/UntrustedAccount`)
-    return
+    return false
   }
-
+  return true
+}
+const _dtDefineAttrsFromTraceData = function _dtDefineAttrsFromTraceData(data, transport) {
   this.parentType = data.ty
   this.parentApp = data.ap
   this.parentAcct = data.ac
@@ -1147,11 +1158,75 @@ function _acceptDistributedTracePayload(payload, transport) {
   this.agent.recordSupportability('DistributedTrace/AcceptPayload/Success')
 }
 
+/**
+ * Parses incoming distributed trace header payload.
+ *
+ * @param {object} payload                - The distributed trace payload to accept.
+ * @param {string} [transport='Unknown']  - The transport type that delivered the payload.
+ */
+Transaction.prototype._acceptDistributedTracePayload = _acceptDistributedTracePayload
+function _acceptDistributedTracePayload(payload, transport) {
+  const payloadTest = _dtPayloadTest.bind(this)
+  if (!payloadTest(payload)) {
+    return
+  }
+
+  const isDtTest = _isDtTest.bind(this)
+  if (isDtTest()) {
+    return
+  }
+
+  const configTest = _dtConfigTest.bind(this)
+  const configTestResult = configTest()
+  if (!configTestResult) {
+    return
+  }
+
+  const traceParseTest = _dtParseTest.bind(this)
+  const parsed = traceParseTest(payload)
+  if (!parsed) {
+    return
+  }
+
+  const traceVersionTest = _dtVersionTest.bind(this)
+  if (traceVersionTest(parsed) > 0) {
+    return
+  }
+
+  const data = parsed.d
+
+  if (!data) {
+    logger.warn('No distributed trace data received, not accepting payload')
+    this.agent.recordSupportability(DT_ACCEPT_PAYLOAD_EXCEPTION_METRIC)
+    return
+  }
+
+  const requiredKeyTest = _dtRequiredKeyTest.bind(this)
+  const requiredKeysExist = requiredKeyTest(data)
+  const spanParentTest = _dtSpanParentTest.bind(this)
+  const spanParentResult = spanParentTest(requiredKeysExist, data)
+
+  if (!spanParentResult) {
+    return
+  }
+
+  const trustedAccount = configTestResult
+  const trustedAccountKey = data.tk || data.ac
+  if (trustedAccountKey !== trustedAccount) {
+    this.agent.recordSupportability(`DistributedTrace/AcceptPayload/Ignored/UntrustedAccount`)
+    return
+  }
+
+  const defineAttrsFromTraceData = _dtDefineAttrsFromTraceData.bind(this)
+  defineAttrsFromTraceData(data, transport)
+}
+
 /**
  * Returns parsed payload object after attempting to decode it from base64,
  * and parsing the JSON string.
  *
- * @param payload
+ * @param {string} payload Payload string to be JSON.parsed
+ * @returns {(object|null)} parsed JSON payload or null
  */
 Transaction.prototype._getParsedPayload = function _getParsedPayload(payload) {
   let parsed = payload
@@ -1305,7 +1380,7 @@ Transaction.prototype.addRequestParameters = addRequestParameters
  * 'request.parameters.{key}'. These attributes will only be created
  * when 'request.parameters.*' is included in the attribute config.
  *
- * @param {Object<string, string>} requestParameters
+ * @param {Object<string, string>} requestParameters of the request object
  */
 function addRequestParameters(requestParameters) {
   for (const key in requestParameters) {

package/package.json

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