newrelic 9.14.1 → 10.0.0

package/NEWS.md

@@ -1,19 +1,64 @@
-### 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).
-
-### v9.13.0 (2023-03-20)
-
-* Updated http instrumentation to no longer remove the `x-new-relic-disable-dt` header when using AWS SDK v3.  This was done to prevent the "The request signature we calculated does not match the signature you provided. Check your key and signing method." error from AWS SDK.
-
-* Added an API method `setUserID` to provide an ability to associate a unique identifier with a transaction event, transaction trace and errors within transaction.  The attribute will be `enduser.id`.
-
-* Added default configuration for security agent.
-
+### v10.0.0 (2023-04-19)
+
+* **BREAKING** - Updated the default of `config.transaction_tracer.record_sql` from `off` to `obfuscated`. This means that sql statements will be captured but obfuscated.
+
+* **BREAKING** - Route (URL) parameters are now stored as `request.parameters.route.*` attributes on Transactions, root Segments and Spans.
+
+    After this change, the following becomes true:
+
+    - Query parameters will be available as attributes prefixed with request.parameters.* on Transactions and Spans.
+
+    - Route parameters will be available as attributes prefixed with request.parameters.route.* on Transactions and Spans.
+
+    - Route parameters (aka url parameters) are a common feature of various web frameworks, where you can create a placeholder as part of an API route definition.
+
+    For example, given the following Express route definition and request url:
+
+    ```js
+    app.get('/api/users/:id', myMiddleware, myController)
+    ```
+
+    ```sh
+    curl http://localhost:3000/api/users/abc123?id=true
+    ```
+
+    The route parameter is `id`, and has a value of `abc123`. This would become `request.parameters.route.id: abc123` on the Transaction, root Segment, and Span attributes. This example also has a query parameter of `id`, which has a value of true. This would become `request.parameters.id: true` on the Transaction, root Segment, and Span attributes.
+
+* **BREAKING** - Removed `captureUrlParams` from `WebFrameworkShim` class.
+  
+* **DEPRECATION NOTICE**: `shim.unwrap` and `shim.unwrapOnce` will no longer function if you attempt to unwrap an item that has been wrapped multiple times.
+    * This is because since we now allow instrumenting the same module more than once, you cannot safely unwrap without breaking all registered instrumentation.  We plan to remove `shim.unwrap` and `shim.unwrapOnce` in the next major release.
+
+* Added the ability to register instrumentation multiple hooks (onRequire, onResolved) for the same resolved moduleName.
+    * This has been a limitation of the agent from the beginning.  
+    * If you used the api to instrument `api.instrument`, `api.instrumentDatastore`, `api.instrumentWebframework`, `api.instrumentMessages`, or `api.instrumentConglomerate`, it would override existing instrumentation hooks.  The effect was that the Node.js agent would not function as designed.  
+
+* Refactored lib/transaction/tracecontext.js to reduce cognitive complexity.
+
+* Refactored lib/transaction/trace/index.js to reduce cognitive complexity.
+
+* Upgraded devDependencies jsdoc, and lean-jsdoc-theme. 
+
+### 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).
+
+### v9.13.0 (2023-03-20)
+
+* Updated http instrumentation to no longer remove the `x-new-relic-disable-dt` header when using AWS SDK v3.  This was done to prevent the "The request signature we calculated does not match the signature you provided. Check your key and signing method." error from AWS SDK.
+
+* Added an API method `setUserID` to provide an ability to associate a unique identifier with a transaction event, transaction trace and errors within transaction.  The attribute will be `enduser.id`.
+
+* Added default configuration for security agent.
+
 ### v9.12.1 (2023-03-15)
 
 * Added ability to mark errors as expected when using `newrelic.noticeError`, by adding an optional boolean: 

package/README.md

@@ -133,9 +133,6 @@ For more information on getting started, [check the Node.js docs](https://docs.n
 There are several modules that can be installed and configured to accompany the Node.js agent:
 
  * [@newrelic/apollo-server-plugin](https://github.com/newrelic/newrelic-node-apollo-server-plugin): New Relic's official Apollo Server plugin for use with the Node.js agent.
- * [@newrelic/winston-enricher](https://github.com/newrelic/newrelic-node-log-extensions/tree/main/packages/winston-log-enricher): Provides distributed trace and span information output as JSON-formatted log messages in Winston.  This is most commonly used with the New Relic Logs product.
- * [@newrelic/pino-enricher](https://github.com/newrelic/newrelic-node-log-extensions/tree/main/packages/pino-log-enricher): Provides distributed trace and span information output as JSON-formatted log messages in Pino.  This is most commonly used with the New Relic Logs product.
- * [@newrelic/mysql](https://github.com/newrelic/node-newrelic-mysql)(**Experimental**): Standalone instrumentation for [mysql2](https://github.com/sidorares/node-mysql2#readme) and [mysql2/promise](https://github.com/sidorares/node-mysql2/blob/master/documentation/Promise-Wrapper.md) as well as the same instrumentation for [mysql](https://github.com/mysqljs/mysql#readme) within the Node.js agent.
  * [@newrelic/next](https://github.com/newrelic/newrelic-node-nextjs): Provides instrumentation for the [Next.js](https://github.com/vercel/next.js/) npm package.
 
 There are several modules included within the Node.js agent to add more instrumentation for 3rd party modules:

package/THIRD_PARTY_NOTICES.md

@@ -1800,7 +1800,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 ### @newrelic/test-utilities
 
-This product includes source derived from [@newrelic/test-utilities](https://github.com/newrelic/node-test-utilities) ([v7.2.0](https://github.com/newrelic/node-test-utilities/tree/v7.2.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-test-utilities/blob/v7.2.0/LICENSE):
+This product includes source derived from [@newrelic/test-utilities](https://github.com/newrelic/node-test-utilities) ([v7.3.0](https://github.com/newrelic/node-test-utilities/tree/v7.3.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-test-utilities/blob/v7.3.0/LICENSE):
 
 ```
                                  Apache License
@@ -2177,7 +2177,7 @@ SOFTWARE.
 
 ### clean-jsdoc-theme
 
-This product includes source derived from [clean-jsdoc-theme](https://github.com/ankitskvmdam/clean-jsdoc-theme) ([v4.2.4](https://github.com/ankitskvmdam/clean-jsdoc-theme/tree/v4.2.4)), distributed under the [MIT License](https://github.com/ankitskvmdam/clean-jsdoc-theme/blob/v4.2.4/LICENSE):
+This product includes source derived from [clean-jsdoc-theme](https://github.com/ankitskvmdam/clean-jsdoc-theme) ([v4.2.7](https://github.com/ankitskvmdam/clean-jsdoc-theme/tree/v4.2.7)), distributed under the [MIT License](https://github.com/ankitskvmdam/clean-jsdoc-theme/blob/v4.2.7/LICENSE):
 
 ```
 MIT License
@@ -2709,7 +2709,7 @@ SOFTWARE.
 
 ### jsdoc
 
-This product includes source derived from [jsdoc](https://github.com/jsdoc/jsdoc) ([v4.0.0](https://github.com/jsdoc/jsdoc/tree/v4.0.0)), distributed under the [Apache-2.0 License](https://github.com/jsdoc/jsdoc/blob/v4.0.0/LICENSE.md):
+This product includes source derived from [jsdoc](https://github.com/jsdoc/jsdoc) ([v4.0.2](https://github.com/jsdoc/jsdoc/tree/v4.0.2)), distributed under the [Apache-2.0 License](https://github.com/jsdoc/jsdoc/blob/v4.0.2/LICENSE.md):
 
 ```
 # License

package/esm-loader.mjs

@@ -68,19 +68,18 @@ export async function resolve(specifier, context, nextResolve) {
 
     if (format === 'commonjs') {
       // ES Modules translate import statements into fully qualified filepaths, so we create a copy of our instrumentation under this filepath
-      const instrumentationDefinitionCopy = Object.assign({}, instrumentationDefinition)
-
-      // Stripping the prefix is necessary because the code downstream gets this url without it
-      instrumentationDefinitionCopy.moduleName = fileURLToPath(url)
-
-      // Added to keep our Supportability metrics from exploding/including customer info via full filepath
-      instrumentationDefinitionCopy.specifier = specifier
-
-      shimmer.registerInstrumentation(instrumentationDefinitionCopy)
-
-      logger.debug(
-        `Registered CommonJS instrumentation for ${specifier} under ${instrumentationDefinitionCopy.moduleName}`
-      )
+      const instrumentationDefinitionCopy = [...instrumentationDefinition]
+      instrumentationDefinitionCopy.forEach((copy) => {
+        // Stripping the prefix is necessary because the code downstream gets this url without it
+        copy.moduleName = fileURLToPath(url)
+
+        // Added to keep our Supportability metrics from exploding/including customer info via full filepath
+        copy.specifier = specifier
+        shimmer.registerInstrumentation(copy)
+        logger.debug(
+          `Registered CommonJS instrumentation for ${specifier} under ${copy.moduleName}`
+        )
+      })
     } else if (format === 'module') {
       registeredSpecifiers.set(url, specifier)
       const modifiedUrl = new URL(url)

package/lib/config/default.js

@@ -573,7 +573,7 @@ defaultConfig.definition = () => ({
      */
     record_sql: {
       formatter: allowList.bind(null, ['off', 'obfuscated', 'raw']),
-      default: 'off',
+      default: 'obfuscated',
       env: 'NEW_RELIC_RECORD_SQL'
     },
 
@@ -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/instrumentation/@hapi/vision.js

@@ -20,13 +20,11 @@ module.exports = function initialize(agent, vision, moduleName, shim) {
 
   shim.wrap(plugin, 'register', function wrapRegister(shim, register) {
     return function wrappedRegister(server) {
-      shim.wrap(server, 'decorate', wrapDecorate)
+      if (!shim.isWrapped(server, 'decorate')) {
+        shim.wrap(server, 'decorate', wrapDecorate)
+      }
 
-      const ret = register.apply(this, arguments)
-
-      shim.unwrapOnce(server, 'decorate')
-
-      return ret
+      return register.apply(this, arguments)
     }
   })
 }

package/lib/instrumentation/mysql/mysql.js

@@ -11,40 +11,52 @@ const symbols = require('../../symbols')
 
 exports.callbackInitialize = function callbackInitialize(shim, mysql) {
   shim.setDatastore(shim.MYSQL)
-  shim.__wrappedPoolConnection = false
+  shim[symbols.wrappedPoolConnection] = true
 
   shim.wrapReturn(mysql, 'createConnection', wrapCreateConnection)
   function wrapCreateConnection(shim, fn, fnName, connection) {
+    if (shim[symbols.unwrapConnection]) {
+      return
+    }
     shim.logger.debug('Wrapping Connection#query')
     if (wrapQueryable(shim, connection, false)) {
       const connProto = Object.getPrototypeOf(connection)
       connProto[symbols.storeDatabase] = true
-      shim.unwrap(mysql, 'createConnection')
+      shim[symbols.unwrapConnection] = true
     }
   }
 
   shim.wrapReturn(mysql, 'createPool', wrapCreatePool)
   function wrapCreatePool(shim, fn, fnName, pool) {
+    if (shim[symbols.unwrapPool]) {
+      return
+    }
     shim.logger.debug('Wrapping Pool#query and Pool#getConnection')
     if (wrapQueryable(shim, pool, true) && wrapGetConnection(shim, pool)) {
-      shim.unwrap(mysql, 'createPool')
+      shim[symbols.unwrapPool] = true
     }
   }
 
   shim.wrapReturn(mysql, 'createPoolCluster', wrapCreatePoolCluster)
   function wrapCreatePoolCluster(shim, fn, fnName, poolCluster) {
+    if (shim[symbols.createPoolCluster]) {
+      return
+    }
     shim.logger.debug('Wrapping PoolCluster#of')
     const proto = Object.getPrototypeOf(poolCluster)
     shim.wrapReturn(proto, 'of', wrapPoolClusterOf)
     function wrapPoolClusterOf(shim, of, _n, poolNamespace) {
+      if (shim[symbols.clusterOf]) {
+        return
+      }
       if (wrapGetConnection(shim, poolNamespace)) {
-        shim.unwrap(proto, 'of')
+        shim[symbols.clusterOf] = true
       }
     }
 
     shim.logger.debug('Wrapping PoolCluster#getConnection')
     if (wrapGetConnection(shim, poolCluster)) {
-      shim.unwrap(mysql, 'createPoolCluster')
+      shim[symbols.createPoolCluster] = true
     }
   }
 }
@@ -83,7 +95,7 @@ function wrapGetConnection(shim, connectable) {
           'Wrapping callback with segment'
         )
         let cb = args[cbIdx]
-        if (!shim.__wrappedPoolConnection) {
+        if (!shim[symbols.wrappedPoolConnection]) {
           cb = shim.wrap(cb, wrapGetConnectionCallback)
         }
         args[cbIdx] = shim.bindSegment(cb)
@@ -102,7 +114,7 @@ function wrapGetConnectionCallback(shim, cb) {
       if (!err && wrapQueryable(shim, conn, false)) {
         // Leave getConnection wrapped in order to maintain TX state, but we can
         // simplify the wrapping of its callback in future calls.
-        shim.__wrappedPoolConnection = true
+        shim[symbols.wrappedPoolConnection] = true
       }
     } catch (_err) {
       shim.logger.debug(

package/lib/instrumentation/mysql/nr-hooks.js

@@ -6,17 +6,17 @@
 'use strict'
 const instrumentation = require('./mysql')
 
-/**
- * We only need to register the instrumentation once for both mysql and mysql2
- *  because there is some 🪄 in shimmer
- * See: https://github.com/newrelic/node-newrelic/blob/main/lib/shimmer.js#L459
- */
 module.exports = [
   {
     type: 'datastore',
     moduleName: 'mysql',
     onRequire: instrumentation.callbackInitialize
   },
+  {
+    type: 'datastore',
+    moduleName: 'mysql2',
+    onRequire: instrumentation.callbackInitialize
+  },
   {
     type: 'datastore',
     moduleName: 'mysql2/promise',

package/lib/serverless/aws-lambda.js

@@ -328,6 +328,7 @@ function setWebRequest(shim, transaction, request) {
 
   transaction.port = request.url.port
 
+  // These are only query parameters, from lib/serverless/api-gateway.js
   transaction.addRequestParameters(request.url.requestParameters)
 
   // URL is sent as an agent attribute with transaction events

package/lib/shim/conglomerate-shim.js

@@ -23,10 +23,14 @@ const SHIM_CLASSES = {
  *
  * @private
  * @augments Shim
+ * @param {Agent} agent The agent this shim will use.
+ * @param {string} moduleName The name of the module being instrumented.
+ * @param {string} resolvedName The full path to the loaded module.
+ * @param {string} shimName Used to persist shim ids across different shim instances.
  */
 class ConglomerateShim extends Shim {
-  constructor(agent, moduleName, resolvedName) {
-    super(agent, moduleName, resolvedName)
+  constructor(agent, moduleName, resolvedName, shimName) {
+    super(agent, moduleName, resolvedName, shimName)
     this._logger = logger.child({ module: moduleName })
     this._resolvedName = resolvedName
   }

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' })
@@ -16,7 +14,6 @@ const ParsedStatement = require('../db/parsed-statement')
 const Shim = require('./shim')
 const urltils = require('../util/urltils')
 const util = require('util')
-const symbols = require('../symbols')
 
 /**
  * An enumeration of well-known datastores so that new instrumentations can use
@@ -73,28 +70,17 @@ const QUERY_PARSERS = {
  *
  * @class
  * @augments Shim
- * @classdesc
- *  A helper class for wrapping datastore modules.
- * @param {Agent} agent
- *  The agent this shim will use.
- * @param {string} moduleName
- *  The name of the module being instrumented.
- * @param {string} resolvedName
- *  The full path to the loaded module.
- * @param {string} [datastoreId]
- *  The name of the datastore being instrumented. If available, use one of the
- *  values from {@link DatastoreShim.DATASTORE_NAMES}.
- *  Calls {@link DatastoreShim#setDatastore} if datastoreId is
- *  specified.
+ * @classdesc A helper class for wrapping datastore modules.
+ * @param {Agent} agent The agent this shim will use.
+ * @param {string} moduleName The name of the module being instrumented.
+ * @param {string} resolvedName The full path to the loaded module.
+ * @param {string} shimName Used to persist shim ids across different shim instances.
  * @see Shim
  * @see DatastoreShim.DATASTORE_NAMES
  */
-function DatastoreShim(agent, moduleName, resolvedName, datastoreId) {
-  Shim.call(this, agent, moduleName, resolvedName)
+function DatastoreShim(agent, moduleName, resolvedName, shimName) {
+  Shim.call(this, agent, moduleName, resolvedName, shimName)
   this._logger = logger.child({ module: moduleName })
-  if (datastoreId) {
-    this.setDatastore(datastoreId)
-  }
   this.queryParser = defaultParsers[this.SQL_PARSER]
 }
 module.exports = DatastoreShim
@@ -357,19 +343,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')) {
@@ -549,8 +533,7 @@ function bindRowCallbackSegment(args, cbIdx, parentSegment) {
     return shim.applySegment(cb, segment, true, this, arguments)
   }, parentSegment)
 
-  // Mark this as wrapped and put it in the args array.
-  wrapper[symbols.original] = cb
+  shim.assignOriginal(wrapper, cb, true)
   args[idx] = wrapper
 }
 
@@ -648,26 +631,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 +671,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 +789,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 +812,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 +844,4 @@ function _normalizeParameters(parameters) {
       }
     }
   }
-
-  return parameters
 }

package/lib/shim/index.js

@@ -30,14 +30,15 @@ SHIM_TYPE_MAP[constants.MODULE_TYPE.WEB_FRAMEWORK] = WebFrameworkShim
  * @param agent
  * @param moduleName
  * @param resolvedName
+ * @param shimName
  */
-function createShimFromType(type, agent, moduleName, resolvedName) {
+function createShimFromType(type, agent, moduleName, resolvedName, shimName) {
   let shim = null
   if (properties.hasOwn(SHIM_TYPE_MAP, type)) {
     const ShimClass = SHIM_TYPE_MAP[type]
-    shim = new ShimClass(agent, moduleName, resolvedName)
+    shim = new ShimClass(agent, moduleName, resolvedName, shimName)
   } else {
-    shim = new Shim(agent, moduleName, resolvedName)
+    shim = new Shim(agent, moduleName, resolvedName, shimName)
   }
   return shim
 }

package/lib/shim/message-shim.js

@@ -66,19 +66,16 @@ const DESTINATION_TYPES = {
  *
  * @class
  * @augments TransactionShim
- * @classdesc
- *  Used for instrumenting message broker client libraries.
- * @param {Agent} agent
- *  The agent this shim will use.
- * @param {string} moduleName
- *  The name of the module being instrumented.
- * @param {string} resolvedName
- *  The full path to the loaded module.
+ * @classdesc Used for instrumenting message broker client libraries.
+ * @param {Agent} agent The agent this shim will use.
+ * @param {string} moduleName The name of the module being instrumented.
+ * @param {string} resolvedName The full path to the loaded module.
+ * @param {string} shimName Used to persist shim ids across different shim instances.
  * @see Shim
  * @see TransactionShim
  */
-function MessageShim(agent, moduleName, resolvedName) {
-  TransactionShim.call(this, agent, moduleName, resolvedName)
+function MessageShim(agent, moduleName, resolvedName, shimName) {
+  TransactionShim.call(this, agent, moduleName, resolvedName, shimName)
   this._logger = logger.child({ module: moduleName })
   this._metrics = null
   this._transportType = TransactionShim.TRANSPORT_TYPES.UNKNOWN

package/lib/shim/promise-shim.js

@@ -22,16 +22,15 @@ class PromiseShim extends Shim {
    * Constructs a shim associated with the given agent instance, specialized for
    * instrumenting promise libraries.
    *
-   * @param {Agent} agent
-   *  The agent this shim will use.
-   * @param {string} moduleName
-   *  The name of the module being instrumented.
-   * @param {string} resolvedName
-   *  The full path to the loaded module.
+   * @param {Agent} agent The agent this shim will use.
+   * @param {string} moduleName The name of the module being instrumented.
+   * @param {string} resolvedName The full path to the loaded module.
+   * @param {string} shimName Used to persist shim ids across different shim instances.
+   * @param shimName
    * @see Shim
    */
-  constructor(agent, moduleName, resolvedName) {
-    super(agent, moduleName, resolvedName)
+  constructor(agent, moduleName, resolvedName, shimName) {
+    super(agent, moduleName, resolvedName, shimName)
     this._logger = logger.child({ module: moduleName })
     this._class = null
   }