newrelic 11.6.1 → 11.7.0

package/NEWS.md

@@ -1,3 +1,29 @@
+### v11.7.0 (2023-12-14)
+
+#### Features
+
+* Added deserialized X-NewRelic-Synthetics-Info header to transaction and transaction trace intrinsic attributes ([#1912](https://github.com/newrelic/node-newrelic/pull/1912)) ([7ed64bd](https://github.com/newrelic/node-newrelic/commit/7ed64bd1410d7eed6c4dbf153e0a67754e7bcdef))
+    * The attributes in transactions are: `nr.syntheticsType`, `nr.syntheticsInitiator`, and `nr.synthetics<attributeKey(s)>` 
+    * The attributes in transaction traces are: `synthetics_type`, `synthetics_initiator`, and `synthetics_<attribute_key(s)>` 
+    * It will also include the `X-NewRelic-Synthetics-Info` header in outgoing http requests
+* Added instrumentation for Restify async handlers ([#1910](https://github.com/newrelic/node-newrelic/pull/1910)) ([1a3f87f](https://github.com/newrelic/node-newrelic/commit/1a3f87ff10dea1c25b35c349550338f327446cb1))
+
+#### Bug fixes
+
+* Update import-in-the-middle to fix ESM on Node 18.19.0 ([#1906](https://github.com/newrelic/node-newrelic/pull/1906)) ([e9c3748](https://github.com/newrelic/node-newrelic/commit/e9c37487a606d986d3568c11a014f6397f4f379e))
+
+#### Code refactoring
+
+* change dynamic import to work with bundlers ([#1905](https://github.com/newrelic/node-newrelic/pull/1905)) ([ee81429](https://github.com/newrelic/node-newrelic/commit/ee81429f5c34491392ed79026e6f716c76e2d735))
+
+#### Miscellaneous chores
+
+* Add AWS Bedrock feature flag ([#1913](https://github.com/newrelic/node-newrelic/pull/1913)) ([91019b0](https://github.com/newrelic/node-newrelic/commit/91019b0a45dcf8399cd8eadbe4e111e72ceab512))
+
+#### Continuous integration
+
+* removed step in post release process to update an internal system with the latest agent version ([#1909](https://github.com/newrelic/node-newrelic/pull/1909)) ([2080b1f](https://github.com/newrelic/node-newrelic/commit/2080b1fe03e65a4c6aaa073e8e338835c708680d))
+
 ### v11.6.1 (2023-12-07)
 
 #### Bug fixes

package/index.js

@@ -40,7 +40,7 @@ if (require.cache.__NR_cache) {
 }
 
 function initApi({ agent, apiPath }) {
-  const API = require(apiPath)
+  const API = require(`./${apiPath}`)
 
   const api = new API(agent)
   require.cache.__NR_cache = module.exports = api
@@ -115,7 +115,7 @@ function initialize() {
     /* eslint-enable no-console */
   }
 
-  const api = agent ? initApi({ agent, apiPath: './api' }) : initApi({ apiPath: './stub_api' })
+  const api = agent ? initApi({ agent, apiPath: 'api' }) : initApi({ apiPath: 'stub_api' })
 
   // 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/agent.js

@@ -36,9 +36,9 @@ const {
   addRequiredCATAttributes,
   maybeAddExtraCATAttributes,
   maybeAddParentAttributes,
-  maybeAddQueueAttributes,
-  maybeAddSyntheticAttributes
+  maybeAddQueueAttributes
 } = require('./util/attributes')
+const synthetics = require('./synthetics')
 
 // Map of valid states to whether or not data collection is valid
 const STATES = {
@@ -747,7 +747,7 @@ function _addIntrinsicAttrsFromTransaction(transaction) {
   maybeAddQueueAttributes(transaction, intrinsicAttributes)
   maybeAddExternalAttributes(transaction, intrinsicAttributes)
   maybeAddDatabaseAttributes(transaction, intrinsicAttributes)
-  maybeAddSyntheticAttributes(transaction, intrinsicAttributes)
+  synthetics.assignTransactionAttrs(transaction, intrinsicAttributes)
 
   if (this.config.distributed_tracing.enabled) {
     transaction.addDistributedTraceIntrinsics(intrinsicAttributes)

package/lib/errors/index.js

@@ -13,9 +13,9 @@ const errorHelper = require('../errors/helper')
 const {
   maybeAddQueueAttributes,
   maybeAddExternalAttributes,
-  maybeAddDatabaseAttributes,
-  maybeAddSyntheticAttributes
+  maybeAddDatabaseAttributes
 } = require('../util/attributes')
+const synthetics = require('../synthetics')
 const Transaction = require('../transaction')
 const ERROR_EXPECTED_PATH = 'error.expected'
 
@@ -230,7 +230,7 @@ function _getErrorEventIntrinsicAttrs(transaction, errorClass, message, expected
     maybeAddQueueAttributes(transaction, attributes)
     maybeAddExternalAttributes(transaction, attributes)
     maybeAddDatabaseAttributes(transaction, attributes)
-    maybeAddSyntheticAttributes(transaction, attributes)
+    synthetics.assignTransactionAttrs(transaction, attributes)
 
     if (transaction.agent.config.distributed_tracing.enabled) {
       transaction.addDistributedTraceIntrinsics(attributes)

package/lib/feature_flags.js

@@ -12,7 +12,8 @@ exports.prerelease = {
   reverse_naming_rules: false,
   undici_async_tracking: true,
   unresolved_promise_cleanup: true,
-  legacy_context_manager: false
+  legacy_context_manager: false,
+  aws_bedrock_instrumentation: false
 }
 
 // flags that are no longer used for released features

package/lib/header-attributes.js

@@ -60,6 +60,7 @@ const HEADER_ATTR_NAMES = {
   'x-newrelic-app-data': 'xNewrelicAppData',
   'x-newrelic-id': 'xNewrelicId',
   'x-newrelic-synthetics': 'xNewrelicSynthetics',
+  'x-newrelic-synthetics-info': 'xNewrelicSyntheticsInfo',
   'x-newrelic-transaction': 'xNewrelicTransaction',
   'x-powered-by': 'xPoweredBy',
   'x-queue-start': 'xQueueStart',

package/lib/instrumentation/core/http-outbound.js

@@ -14,6 +14,7 @@ const url = require('url')
 const copy = require('../../util/copy')
 const symbols = require('../../symbols')
 const http = require('http')
+const synthetics = require('../../synthetics')
 
 const NAMES = require('../../metrics/names')
 
@@ -21,8 +22,6 @@ const DEFAULT_HOST = 'localhost'
 const DEFAULT_HTTP_PORT = 80
 const DEFAULT_SSL_PORT = 443
 
-const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
-
 /**
  * Determines the default port to 80 if protocol is undefined or http:
  * Otherwise it assigns it as 443
@@ -139,10 +138,7 @@ function instrumentRequest(agent, opts, makeRequest, hostname, segment) {
   const transaction = segment.transaction
   const outboundHeaders = Object.create(null)
 
-  if (agent.config.encoding_key && transaction.syntheticsHeader) {
-    outboundHeaders[NEWRELIC_SYNTHETICS_HEADER] = transaction.syntheticsHeader
-  }
-
+  synthetics.assignHeadersToOutgoingRequest(agent.config, transaction, outboundHeaders)
   maybeAddDtCatHeaders(agent, transaction, outboundHeaders, opts?.headers)
   opts.headers = assignOutgoingHeaders(opts.headers, outboundHeaders)
 

package/lib/instrumentation/core/http.js

@@ -10,26 +10,19 @@
 const shimmer = require('../../shimmer')
 const logger = require('../../logger').child({ component: 'http' })
 const recordWeb = require('../../metrics/recorders/http')
-const hashes = require('../../util/hashes')
 const cat = require('../../util/cat')
 const instrumentOutbound = require('./http-outbound')
 const url = require('url')
 const urltils = require('../../util/urltils')
 const headerAttributes = require('../../header-attributes')
 const headerProcessing = require('../../header-processing')
+const synthetics = require('../../synthetics')
 
 const NAMES = require('../../metrics/names')
 const DESTS = require('../../config/attribute-filter').DESTINATIONS
 
 const symbols = require('../../symbols')
 
-/*
- *
- * CONSTANTS
- *
- */
-const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
-
 // For incoming requests this instrumentation functions by wrapping
 // `http.createServer` and `http.Server#addListener`. The former merely sets the
 // agent dispatcher to 'http' and the latter wraps any event handlers bound to
@@ -119,16 +112,7 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
       transaction.queueTime = Date.now() - queueTimeStamp
     }
 
-    const synthHeader = request.headers[NEWRELIC_SYNTHETICS_HEADER]
-
-    if (synthHeader && agent.config.trusted_account_ids && agent.config.encoding_key) {
-      handleSyntheticsHeader(
-        synthHeader,
-        agent.config.encoding_key,
-        agent.config.trusted_account_ids,
-        transaction
-      )
-    }
+    synthetics.assignHeadersToTransaction(agent.config, transaction, request.headers)
 
     if (agent.config.distributed_tracing.enabled) {
       // Node http headers are automatically lowercase
@@ -278,9 +262,8 @@ function wrapWriteHead(agent, writeHead) {
       logger.trace('No transaction - not adding response CAT headers')
       return writeHead.apply(this, arguments)
     }
-    if (transaction.syntheticsHeader) {
-      this.setHeader(NEWRELIC_SYNTHETICS_HEADER, transaction.syntheticsHeader)
-    }
+
+    synthetics.assignHeadersToResponse(this, transaction)
 
     if (!transaction.incomingCatId) {
       logger.trace('No incoming CAT ID - not adding response CAT headers')
@@ -487,104 +470,3 @@ module.exports = function initialize(agent, http, moduleName) {
     }
   )
 }
-
-/**
- * Take the X-NewRelic-Synthetics header and apply any appropriate data to the
- * transaction for later use. This is the gate keeper for attributes being
- * added onto the transaction object for synthetics.
- *
- * @param {string} header - The raw X-NewRelic-Synthetics header
- * @param {string} encKey - Encoding key handed down from the server
- * @param {Array.<number>} trustedIds - Array of accounts to trust the header from.
- * @param {object} transaction - Where the synthetics data is attached to.
- */
-function handleSyntheticsHeader(header, encKey, trustedIds, transaction) {
-  const synthData = parseSyntheticsHeader(header, encKey, trustedIds)
-  if (!synthData) {
-    return
-  }
-
-  transaction.syntheticsData = synthData
-  transaction.syntheticsHeader = header
-}
-
-/**
- * Parse out and verify the the pieces of the X-NewRelic-Synthetics header.
- *
- * @param {string} header - The raw X-NewRelic-Synthetics header
- * @param {string} encKey - Encoding key handed down from the server
- * @param {Array.<number>} trustedIds - Array of accounts to trust the header from.
- * @returns {object | null} - On successful parse and verification an object of
- *                            synthetics data is returned, otherwise null is
- *                            returned.
- */
-function parseSyntheticsHeader(header, encKey, trustedIds) {
-  // Eagerly declare this object because we know what it should look like and
-  // can use that for header verification.
-  const parsedData = {
-    version: null,
-    accountId: null,
-    resourceId: null,
-    jobId: null,
-    monitorId: null
-  }
-  let synthData = null
-  try {
-    synthData = JSON.parse(hashes.deobfuscateNameUsingKey(header, encKey))
-  } catch (e) {
-    logger.trace(e, 'Got unparsable synthetics header: %s', header)
-    return
-  }
-
-  if (!Array.isArray(synthData)) {
-    logger.trace('Synthetics data is not an array: %s (%s)', synthData, typeof synthData)
-    return
-  }
-
-  if (synthData.length < Object.keys(parsedData).length) {
-    logger.trace(
-      'Synthetics header length is %s, expected at least %s',
-      synthData.length,
-      Object.keys(parsedData).length
-    )
-  }
-
-  parsedData.version = synthData[0]
-  if (parsedData.version !== 1) {
-    logger.trace('Synthetics header version is not 1, got: %s (%s)', parsedData.version, synthData)
-    return
-  }
-
-  parsedData.accountId = synthData[1]
-  if (parsedData.accountId) {
-    if (trustedIds.indexOf(parsedData.accountId) === -1) {
-      logger.trace(
-        'Synthetics header account ID is not in trusted account IDs: %s (%s)',
-        parsedData.accountId,
-        trustedIds
-      )
-      return
-    }
-  } else {
-    logger.trace('Synthetics header account ID missing.')
-    return
-  }
-
-  parsedData.resourceId = synthData[2]
-  if (!parsedData.resourceId) {
-    logger.trace('Synthetics resource ID is missing.')
-    return
-  }
-
-  parsedData.jobId = synthData[3]
-  if (!parsedData.jobId) {
-    logger.trace('Synthetics job ID is missing.')
-  }
-
-  parsedData.monitorId = synthData[4]
-  if (!parsedData.monitorId) {
-    logger.trace('Synthetics monitor ID is missing.')
-  }
-
-  return parsedData
-}

package/lib/instrumentation/restify.js

@@ -55,12 +55,20 @@ module.exports = function initialize(agent, restify, moduleName, shim) {
         if (shim.isWrapped(middleware)) {
           return middleware
         }
-        return shim.recordMiddleware(middleware, {
+        const spec = {
           matchArity: true,
           route,
           req: shim.FIRST,
           next: shim.LAST
-        })
+        }
+
+        const wrappedMw = shim.recordMiddleware(middleware, spec)
+        if (middleware.constructor.name === 'AsyncFunction') {
+          return async function asyncShim() {
+            return wrappedMw.apply(this, arguments)
+          }
+        }
+        return wrappedMw
       }
     })
 
@@ -70,11 +78,18 @@ module.exports = function initialize(agent, restify, moduleName, shim) {
       if (shim.isWrapped(middleware)) {
         return middleware
       }
-      return shim.recordMiddleware(middleware, {
+      const spec = {
         matchArity: true,
         req: shim.FIRST,
         next: shim.LAST
-      })
+      }
+      const wrappedMw = shim.recordMiddleware(middleware, spec)
+      if (middleware.constructor.name === 'AsyncFunction') {
+        return async function asyncShim() {
+          return wrappedMw.apply(this, arguments)
+        }
+      }
+      return wrappedMw
     })
   }
 }

package/lib/instrumentation/undici.js

@@ -9,10 +9,10 @@ const cat = require('../util/cat')
 const recordExternal = require('../metrics/recorders/http_external')
 const logger = require('../logger').child({ component: 'undici' })
 const NAMES = require('../metrics/names')
-const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
 const symbols = require('../symbols')
 const { executionAsyncResource } = require('async_hooks')
 const diagnosticsChannel = require('diagnostics_channel')
+const synthetics = require('../synthetics')
 
 const channels = [
   { channel: diagnosticsChannel.channel('undici:request:create'), hook: requestCreateHook },
@@ -89,9 +89,7 @@ function getParentSegment(shim) {
  */
 function addDTHeaders({ transaction, config, request }) {
   const outboundHeaders = Object.create(null)
-  if (config.encoding_key && transaction.syntheticsHeader) {
-    outboundHeaders[NEWRELIC_SYNTHETICS_HEADER] = transaction.syntheticsHeader
-  }
+  synthetics.assignHeadersToOutgoingRequest(config, transaction, outboundHeaders)
 
   if (config.distributed_tracing.enabled) {
     transaction.insertDistributedTraceHeaders(outboundHeaders)

package/lib/synthetics.js

@@ -0,0 +1,255 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const logger = require('./logger').child({ component: 'synthetics' })
+const hashes = require('./util/hashes')
+const { isNotEmpty } = require('./util/objects')
+const toSnakeCase = require('./util/snake-case')
+const toCamelCase = require('./util/camel-case')
+const synthetics = module.exports
+const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
+const NEWRELIC_SYNTHETICS_INFO_HEADER = 'x-newrelic-synthetics-info'
+
+const KEYS = ['version', 'accountId', 'resourceId', 'jobId', 'monitorId']
+
+/**
+ * Decode the X-NewRelic-Synthetics and X-NewRelic-Synthetics-Info headers
+ * and assign to transactions as properties both the raw and decoded values
+ *
+ * @param {object} config agent config
+ * @param {object} transaction The current transaction
+ * @param {object} headers raw http headers
+ */
+synthetics.assignHeadersToTransaction = function processHeaders(config, transaction, headers) {
+  const synthHeader = headers[NEWRELIC_SYNTHETICS_HEADER]
+  const synthInfoHeader = headers[NEWRELIC_SYNTHETICS_INFO_HEADER]
+
+  if (synthHeader && config.trusted_account_ids && config.encoding_key) {
+    assignSyntheticsHeader(
+      synthHeader,
+      config.encoding_key,
+      config.trusted_account_ids,
+      transaction
+    )
+  }
+
+  if (synthInfoHeader && config.encoding_key) {
+    assignSyntheticsInfoHeader(synthInfoHeader, config.encoding_key, transaction)
+  }
+}
+
+/**
+ * Take the X-NewRelic-Synthetics header and apply any appropriate data to the
+ * transaction for later use. This is the gate keeper for attributes being
+ * added onto the transaction object for synthetics.
+ *
+ * @param {string} header - The raw X-NewRelic-Synthetics header
+ * @param {string} encKey - Encoding key handed down from the server
+ * @param {Array.<number>} trustedIds - Array of accounts to trust the header from.
+ * @param {object} transaction - Where the synthetics data is attached to.
+ */
+function assignSyntheticsHeader(header, encKey, trustedIds, transaction) {
+  const synthData = parseSyntheticsHeader(header, encKey, trustedIds)
+  if (!synthData) {
+    return
+  }
+
+  transaction.syntheticsData = synthData
+  transaction.syntheticsHeader = header
+}
+
+/**
+ * Take the X-NewRelic-Synthetics-Info header and apply any appropriate data to the
+ * transaction for later use. This is the gate keeper for attributes being
+ * added onto the transaction object for synthetics info.
+ *
+ * @param {string} header - The raw X-NewRelic-Synthetics-Info header
+ * @param {string} encKey - Encoding key handed down from the server
+ * @param {object} transaction - Where the synthetics data is attached to.
+ */
+function assignSyntheticsInfoHeader(header, encKey, transaction) {
+  const synthInfoData = parseSyntheticsInfoHeader(header, encKey)
+  if (!synthInfoData) {
+    return
+  }
+
+  transaction.syntheticsInfoData = synthInfoData
+  transaction.syntheticsInfoHeader = header
+}
+
+/**
+ * Parse out and verify the the pieces of the X-NewRelic-Synthetics-Info header.
+ *
+ * @param {string} header - The raw X-NewRelic-Synthetics-Info header
+ * @param {string} encKey - Encoding key handed down from the server
+ * @returns {object | null} - On successful parse and verification an object of
+ *                            synthetics info data is returned, otherwise null is
+ *                            returned.
+ */
+function parseSyntheticsInfoHeader(header, encKey) {
+  let synthInfoData = null
+  try {
+    synthInfoData = JSON.parse(hashes.deobfuscateNameUsingKey(header, encKey))
+    logger.trace('Parsed synthetics info header: %s', synthInfoData)
+  } catch (e) {
+    logger.trace(e, 'Cannot parse synthetics info header: %s', header)
+    return
+  }
+
+  if (!isNotEmpty(synthInfoData)) {
+    logger.trace('Synthetics info data is not an object.')
+    return
+  }
+
+  const { version } = synthInfoData
+
+  if (version !== 1) {
+    logger.trace('Synthetics info header version is not 1, got: %s', version)
+    return
+  }
+
+  return synthInfoData
+}
+
+/**
+ * Parse out and verify the the pieces of the X-NewRelic-Synthetics header.
+ *
+ * @param {string} header - The raw X-NewRelic-Synthetics header
+ * @param {string} encKey - Encoding key handed down from the server
+ * @param {Array.<number>} trustedIds - Array of accounts to trust the header from.
+ * @returns {object | null} - On successful parse and verification an object of
+ *                            synthetics data is returned, otherwise null is
+ *                            returned.
+ */
+function parseSyntheticsHeader(header, encKey, trustedIds) {
+  let synthData = null
+  try {
+    synthData = JSON.parse(hashes.deobfuscateNameUsingKey(header, encKey))
+    logger.trace('Parsed synthetics header: %s', synthData)
+  } catch (e) {
+    logger.trace(e, 'Cannot parse synthetics header: %s', header)
+    return
+  }
+
+  if (!Array.isArray(synthData)) {
+    logger.trace('Synthetics data is not an array.')
+    return
+  }
+
+  if (synthData.length < KEYS.length) {
+    logger.trace(
+      'Synthetics header length is %s, expected at least %s',
+      synthData.length,
+      KEYS.length
+    )
+  }
+
+  const [version, accountId, resourceId, jobId, monitorId] = synthData
+
+  if (version !== 1) {
+    logger.trace('Synthetics header version is not 1, got: %s', version)
+    return
+  }
+
+  if (accountId && !trustedIds.includes(accountId)) {
+    logger.trace(
+      'Synthetics header account ID is not in trusted account IDs: %s (%s)',
+      accountId,
+      trustedIds.toString()
+    )
+    return
+  }
+
+  return {
+    version,
+    accountId,
+    resourceId,
+    jobId,
+    monitorId
+  }
+}
+
+/**
+ * Helper method for adding relevant synthetics intrinsics to transaction traces
+ *
+ * @param {object} transaction The current transaction
+ */
+synthetics.assignIntrinsicsToTransaction = function assignIntrinsicsToTransaction(transaction) {
+  if (transaction.syntheticsData) {
+    transaction._intrinsicAttributes.synthetics_resource_id = transaction.syntheticsData?.resourceId
+    transaction._intrinsicAttributes.synthetics_job_id = transaction.syntheticsData?.jobId
+    transaction._intrinsicAttributes.synthetics_monitor_id = transaction.syntheticsData?.monitorId
+
+    if (transaction.syntheticsInfoData) {
+      transaction._intrinsicAttributes.synthetics_type = transaction.syntheticsInfoData?.type
+      transaction._intrinsicAttributes.synthetics_initiator =
+        transaction.syntheticsInfoData?.initiator
+
+      for (const [key, value] of Object.entries(transaction.syntheticsInfoData.attributes)) {
+        transaction._intrinsicAttributes[`synthetics_${toSnakeCase(key)}`] = value
+      }
+    }
+  }
+}
+
+/**
+ * Helper method for modifying attributes by reference if transaction has Synthetics metrics
+ *
+ * @param {object} transaction The current transaction
+ * @param {object} attributes The attributes object to modify (by reference)
+ */
+synthetics.assignTransactionAttrs = function assignTransactionAttrs(transaction, attributes) {
+  if (transaction.syntheticsData) {
+    attributes['nr.syntheticsResourceId'] = transaction.syntheticsData?.resourceId
+    attributes['nr.syntheticsJobId'] = transaction.syntheticsData?.jobId
+    attributes['nr.syntheticsMonitorId'] = transaction.syntheticsData?.monitorId
+
+    if (transaction.syntheticsInfoData) {
+      attributes['nr.syntheticsType'] = transaction.syntheticsInfoData?.type
+      attributes['nr.syntheticsInitiator'] = transaction.syntheticsInfoData?.initiator
+      for (const [key, value] of Object.entries(transaction.syntheticsInfoData.attributes)) {
+        const attr = toCamelCase(`synthetics_${key}`)
+        attributes[`nr.${attr}`] = value
+      }
+    }
+  }
+}
+
+/**
+ * Helper method for assign the X-NewRelic-Synthetics and X-NewRelic-Synthetics-Info headers to outbound http requests
+ *
+ * @param {object} config agent config
+ * @param {object} transaction The current transaction
+ * @param {object} headers outgoing headers
+ */
+synthetics.assignHeadersToOutgoingRequest = function addHeadersToOutgoingRequest(
+  config,
+  transaction,
+  headers
+) {
+  if (config.encoding_key && transaction.syntheticsHeader) {
+    headers[NEWRELIC_SYNTHETICS_HEADER] = transaction.syntheticsHeader
+
+    if (transaction.syntheticsInfoHeader) {
+      headers[NEWRELIC_SYNTHETICS_INFO_HEADER] = transaction.syntheticsInfoHeader
+    }
+  }
+}
+
+/**
+ * Helper method for assigning the X-NewRelic-Synthetics and X-NewRelic-Synthetics-Info headers to the response
+ *
+ * @param {object} response http response object
+ * @param {object} transaction The current transaction
+ */
+synthetics.assignHeadersToResponse = function assignHeadersToResponse(response, transaction) {
+  if (transaction.syntheticsHeader) {
+    response.setHeader(NEWRELIC_SYNTHETICS_HEADER, transaction.syntheticsHeader)
+    if (transaction.syntheticsInfoHeader) {
+      response.setHeader(NEWRELIC_SYNTHETICS_INFO_HEADER, transaction.syntheticsInfoHeader)
+    }
+  }
+}

package/lib/transaction/index.js

@@ -14,6 +14,7 @@ const NameState = require('./name-state')
 const props = require('../util/properties')
 const Timer = require('../timer')
 const Trace = require('./trace')
+const synthetics = require('../synthetics')
 const url = require('url')
 const urltils = require('../util/urltils')
 const TraceContext = require('./tracecontext').TraceContext
@@ -120,7 +121,9 @@ function Transaction(agent) {
   this.invalidIncomingExternalTransaction = false
   this.statusCode = null
   this.syntheticsHeader = null
+  this.syntheticsInfoHeader = null
   this.syntheticsData = null
+  this.syntheticsInfoData = null
   this.url = null
   this.parsedUrl = null
   this.verb = null
@@ -916,11 +919,7 @@ Transaction.prototype.getIntrinsicAttributes = function getIntrinsicAttributes()
       }
     }
 
-    if (this.syntheticsData) {
-      this._intrinsicAttributes.synthetics_resource_id = this.syntheticsData.resourceId
-      this._intrinsicAttributes.synthetics_job_id = this.syntheticsData.jobId
-      this._intrinsicAttributes.synthetics_monitor_id = this.syntheticsData.monitorId
-    }
+    synthetics.assignIntrinsicsToTransaction(this)
   }
   return Object.assign(Object.create(null), this._intrinsicAttributes)
 }

package/lib/util/attributes.js

@@ -134,26 +134,11 @@ function calculateApdexZone(duration, apdexT) {
   return 'F' // frustrated
 }
 
-/**
- * Helper method for modifying attributes by reference if transaction has Synthetics metrics
- *
- * @param {object} transaction The current transaction
- * @param {object} attributes The attributes object to modify (by reference)
- */
-function maybeAddSyntheticAttributes(transaction, attributes) {
-  if (transaction.syntheticsData) {
-    attributes['nr.syntheticsResourceId'] = transaction.syntheticsData.resourceId
-    attributes['nr.syntheticsJobId'] = transaction.syntheticsData.jobId
-    attributes['nr.syntheticsMonitorId'] = transaction.syntheticsData.monitorId
-  }
-}
-
 module.exports = {
   maybeAddQueueAttributes,
   maybeAddExternalAttributes,
   maybeAddDatabaseAttributes,
   maybeAddParentAttributes,
   addRequiredCATAttributes,
-  maybeAddExtraCATAttributes,
-  maybeAddSyntheticAttributes
+  maybeAddExtraCATAttributes
 }

package/lib/util/camel-case.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+// lodash ripoff: https://github.com/Tcdian/Lodash/blob/master/source/string/words.ts
+const wordPattern = new RegExp(
+  ['[A-Z][a-z]+', '[A-Z]+(?=[A-Z][a-z])', '[A-Z]+', '[a-z]+', '[0-9]+'].join('|'),
+  'g'
+)
+const words = (string) => string.match(wordPattern) || []
+
+/**
+ * Converts a string to camelCase
+ *
+ * @param {string} string value to convert to camel case
+ * @returns {string} camel cased string
+ */
+module.exports = function toCamelCase(string) {
+  return words(string)
+    .map((word, index) =>
+      index === 0 ? word.toLowerCase() : word.slice(0, 1).toUpperCase() + word.slice(1)
+    )
+    .join('')
+}

package/lib/util/logger.js

@@ -261,7 +261,7 @@ Logger.prototype.write = function write(level, args, extra) {
     data = stringify(entry) + '\n'
   } catch (err) {
     // eslint-disable-line no-unused-vars
-    this.debug('Unabled to stringify log message')
+    this.debug('Unable to stringify log message')
   }
 
   if (this.reading) {

package/lib/util/snake-case.js

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+// lodash ripoff: https://github.com/Tcdian/Lodash/blob/master/source/string/words.ts
+const wordPattern = new RegExp(
+  ['[A-Z][a-z]+', '[A-Z]+(?=[A-Z][a-z])', '[A-Z]+', '[a-z]+', '[0-9]+'].join('|'),
+  'g'
+)
+const words = (string) => string.match(wordPattern) || []
+
+/**
+ * Converts a string to snake_case
+ *
+ * @param {string} string value to convert to snake case
+ * @returns {string} snake cased string
+ */
+
+module.exports = function toSnakeCase(string) {
+  return words(string)
+    .map((word) => word.toLowerCase())
+    .join('_')
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "11.6.1",
+  "version": "11.7.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -190,7 +190,7 @@
     "@tyriar/fibonacci-heap": "^2.0.7",
     "concat-stream": "^2.0.0",
     "https-proxy-agent": "^7.0.1",
-    "import-in-the-middle": "^1.4.2",
+    "import-in-the-middle": "^1.6.0",
     "json-bigint": "^1.0.0",
     "json-stringify-safe": "^5.0.0",
     "module-details-from-path": "^1.0.3",