newrelic 13.3.3 → 13.5.0

package/lib/instrumentation/fastify.js

@@ -7,30 +7,8 @@
 
 const semver = require('semver')
 const {
-  buildMiddlewareSpecForRouteHandler,
-  buildMiddlewareSpecForMiddlewareFunction
+  buildMiddlewareSpecForRouteHandler
 } = require('./fastify/spec-builders')
-const { MiddlewareMounterSpec } = require('../shim/specs')
-
-/**
- * These are the events that occur during a fastify
- * request
- * see: https://www.fastify.io/docs/latest/Lifecycle/
- *
- * Note: preSerialization and onSend happen after the route handler
- * executes.  `onResponse` does not execute until after the client
- * sends the response so it'll never be in scope of the transaction
- */
-const REQUEST_HOOKS = [
-  'onRequest',
-  'preParsing',
-  'preValidation',
-  'preHandler',
-  'preSerialization',
-  'onSend',
-  'onResponse',
-  'onError'
-]
 
 /**
  * Sets up fastify route handler
@@ -44,14 +22,15 @@ const REQUEST_HOOKS = [
  * at them would require a lot of gymnastics and hard to
  * maintain code
  *
- * @param shim
- * @param fastify
+ * @param {WebFrameworkShim} shim instance
+ * @param {object} fastify Fastify instance
  */
-const setupRouteHandler = (shim, fastify) => {
+function setupRouteHandler(shim, fastify) {
   fastify.addHook('onRoute', (routeOptions) => {
     if (!routeOptions.handler) {
       return
     }
+
     /**
      * recordMiddleware handler call
      *
@@ -66,88 +45,38 @@ const setupRouteHandler = (shim, fastify) => {
 
     routeOptions.handler = newRouteHandler
   })
-
-  shim.wrap(fastify, 'addHook', function addWrapHook(shim, fn) {
-    return function wrappedAddHook(...args) {
-      const hookName = args[0]
-      if (REQUEST_HOOKS.includes(hookName)) {
-        const middlewareFunction = args[1]
-        const name = `${hookName}/${shim.getName(middlewareFunction)}`
-        const middlewareSpec = buildMiddlewareSpecForMiddlewareFunction(shim, name)
-        const newMiddlewareFunction = shim.recordMiddleware(middlewareFunction, middlewareSpec)
-
-        args[1] = newMiddlewareFunction
-      }
-      return fn.apply(this, args)
-    }
-  })
 }
 
 module.exports = function initialize(agent, fastify, moduleName, shim) {
   shim.setFramework(shim.FASTIFY)
 
   const fastifyVersion = shim.pkgVersion
+  const noDiagChannel = semver.lt(fastifyVersion, '3.21.0')
   const isv3Plus = semver.satisfies(fastifyVersion, '>=3.0.0')
 
-  /**
-   * Fastify exports a function, so we need to use wrapExport
-   */
-  const wrappedExport = shim.wrapExport(fastify, function wrapFastifyModule(shim, fn) {
-    return function wrappedFastifyModule() {
-      // call original function to get the fastify object (which is singleton-ish)
-      const fastifyForWrapping = fn.apply(this, arguments)
-
-      setupRouteHandler(shim, fastifyForWrapping)
-
-      setupMiddlewareHandlers(shim, fastifyForWrapping, isv3Plus)
-
-      return fastifyForWrapping
-    }
-  })
-
-  if (isv3Plus) {
-    setupExports(fastify, wrappedExport)
+  if (!isv3Plus) {
+    shim.logger.warn('Fastify version: %s is unsupported, minimum supported version is `3.0.0`', fastifyVersion)
+    return
   }
-}
-
-function setupMiddlewareHandlers(shim, fastify, isv3Plus) {
-  const mounterSpec = new MiddlewareMounterSpec({
-    route: shim.FIRST,
-    wrapper: wrapMiddleware
-  })
 
-  if (isv3Plus) {
-    // Fastify v3+ does not ship with traditional Node.js middleware mounting.
-    // This style is accomplished leveraging decorators. Both middie (which was built-in in v2)
-    // and fastify-express mount a 'use' function for mounting middleware.
-    shim.wrap(fastify, 'decorate', function wrapDecorate(shim, fn) {
-      return function wrappedDecorate(...args) {
-        const name = args[0]
-        if (name !== 'use') {
-          return fn.apply(this, args)
-        }
+  // In 3.21.0+ fastify emits events via diagnostics channel.
+  // we are subscribing to one of those events in `lib/subscribers/fastify/index.js`.
+  // This code is for any customers using <3.21.0, which hopefully should be very few.
+  // TODO: Remove <3.21.0 support in 14.0.0 of Node.js agent
+  if (noDiagChannel) {
+    const wrappedExport = shim.wrapExport(fastify, function wrapFastifyModule(shim, fn) {
+      return function wrappedFastifyModule() {
+        // call original function to get the fastify object (which is singleton-ish)
+        const fastifyForWrapping = fn.apply(this, arguments)
 
-        args[1] = shim.wrapMiddlewareMounter(args[1], mounterSpec)
+        setupRouteHandler(shim, fastifyForWrapping)
 
-        return fn.apply(this, args)
+        return fastifyForWrapping
       }
     })
-  } else {
-    shim.wrapMiddlewareMounter(fastify, 'use', mounterSpec)
-  }
-}
 
-function wrapMiddleware(shim, middleware, name, route) {
-  if (shim.isWrapped(middleware)) {
-    return middleware
+    setupExports(fastify, wrappedExport)
   }
-
-  // prefixing the segment name for middleware execution
-  // with the Fastify lifecycle hook
-  const segmentName = `onRequest/${name}`
-  const spec = buildMiddlewareSpecForMiddlewareFunction(shim, segmentName, route)
-
-  return shim.recordMiddleware(middleware, spec)
 }
 
 /**
@@ -155,8 +84,8 @@ function wrapMiddleware(shim, middleware, name, route) {
  * module.exports.fastify = fastify
  * module.exports.default = fastify
  *
- * @param original
- * @param wrappedExport
+ * @param {object} original original fastify export
+ * @param {object} wrappedExport wrapped fastify export
  */
 function setupExports(original, wrappedExport) {
   wrappedExport.fastify = original.fastify

package/lib/instrumentation/kafkajs/consumer.js

@@ -87,7 +87,7 @@ function wrapRun(shim, fn) {
  *
  * @param {object} params to function
  * @param {object} params.consumer consumer being instrumented
- * @returns {function} message handler for setting metrics and spec for the consumer transaction
+ * @returns {Function} message handler for setting metrics and spec for the consumer transaction
  */
 function handler({ consumer }) {
   /**

package/lib/instrumentation/koa/instrumentation.js

@@ -79,7 +79,7 @@ function wrapMiddleware(shim, middleware) {
  * See: https://github.com/koajs/koa/blob/master/lib/context.js#L186-L241
  *
  * @param {Shim} shim instance of shim
- * @param {function} _fn createContext function
+ * @param {Function} _fn createContext function
  * @param {string} _fnName name of function
  * @param {object} context koa ctx object
  */

package/lib/instrumentation/langchain/runnable.js

@@ -129,7 +129,7 @@ function instrumentStream({ langchain, shim }) {
  * @param {object} params function params
  * @param {Shim} params.shim shim instance
  * @param {TraceSegment} params.segment active segment
- * @param {function} params.output IterableReadableStream
+ * @param {Function} params.output IterableReadableStream
  * @param {string} params.request the prompt message
  * @param {object} params.metadata metadata for the call
  * @param {Array} params.tags tags for the call

package/lib/instrumentation/memcached.js

@@ -24,10 +24,10 @@ function wrapKeys(metacall) {
  *
  * instrument the memcached driver to intercept calls and keep stats on them.
  *
- * @param agent
- * @param memcached
- * @param moduleName
- * @param shim
+ * @param {Agent} agent instance
+ * @param {object} memcached library
+ * @param {string} moduleName name of module
+ * @param {Shim} shim instance
  */
 module.exports = function initialize(agent, memcached, moduleName, shim) {
   const proto = memcached && memcached.prototype

package/lib/instrumentation/mongodb.js

@@ -22,10 +22,10 @@ module.exports = initialize
  * Registers the query parser, and relevant instrumentation
  * based on version of mongodb
  *
- * @param {Agent} agent
+ * @param {Agent} agent instance
  * @param {object} mongodb resolved package
  * @param {string} moduleName name of module
- * @param {Shim} shim
+ * @param {Shim} shim instance
  */
 function initialize(agent, mongodb, moduleName, shim) {
   if (!mongodb) {

package/lib/instrumentation/nextjs/next-server.js

@@ -124,12 +124,10 @@ module.exports = function initialize(shim, nextServer) {
 function assignParameters(shim, parameters) {
   const transaction = shim.tracer.getTransaction()
   if (transaction) {
-    const prefixedParameters = shim.prefixRouteParameters(parameters)
-
     // We have to add params because this framework doesn't
     // follow the traditional middleware/middleware mounter pattern
     // where we'd pull these from middleware.
-    transaction.nameState.appendPath('/', prefixedParameters)
+    transaction.nameState.appendPath('/', parameters)
   }
 }
 

package/lib/instrumentation/nextjs/utils.js

@@ -15,9 +15,9 @@ const utils = module.exports
  * with its file structure and function names. We're providing relative paths to Next.js files
  * based on the Next.js page.  The function is also hardcoded to align with the conventions of Next.js.
  *
- * @param {Object} config agent config
+ * @param {object} config agent config
  * @param {TraceSegment} segment active segment to add CLM attrs to
- * @param {Object} attrs list of CLM attrs to add to segment
+ * @param {object} attrs list of CLM attrs to add to segment
  */
 utils.assignCLMAttrs = function assignCLMAttrs(config, segment, attrs) {
   // config is optionally accessed because agent could be older than

package/lib/instrumentation/restify.js

@@ -76,10 +76,10 @@ module.exports = function initialize(_agent, restify, _moduleName, shim) {
  * route is not defined.
  *
  * @param {object} shim instance of shim
- * @param {function} middleware function to record
+ * @param {Function} middleware function to record
  * @param {string} _name name of middleware
  * @param {object|null} route name of route
- * @returns {function} wrapped middleware function
+ * @returns {Function} wrapped middleware function
  */
 function wrapMiddleware(shim, middleware, _name, route) {
   if (shim.isWrapped(middleware)) {

package/lib/instrumentation/when/contextualizer.js

@@ -160,7 +160,7 @@ Contextualizer.prototype.setSegment = function setSegment(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
+ * @returns {Function|undefined} current promise or wrapped finally that will propagate the segment
  */
 Contextualizer.prototype.continue = function continueContext(prom) {
   const self = this

package/lib/instrumentation-descriptor.js

@@ -9,7 +9,7 @@ const IdGen = require('./util/idgen')
 const idGen = new IdGen()
 
 /**
- * @typedef {function} InstrumentationOnRequire
+ * @typedef {Function} InstrumentationOnRequire
  * @param {Shim} shim The shim instance to use for the instrumentation.
  * @param {object} resolvedNodule The module being instrumented as returned by
  * Node's `require` function.
@@ -19,7 +19,7 @@ const idGen = new IdGen()
  */
 
 /**
- * @typedef {function} InstrumentationOnError
+ * @typedef {Function} InstrumentationOnError
  * @param {Error|object} error The error thrown by `onRequire` when there was
  * an issue registering the instrumentation.
  */
@@ -86,14 +86,6 @@ class InstrumentationDescriptor {
    */
   static TYPE_WEB_FRAMEWORK = 'web-framework'
 
-  /**
-   * Used to load supportability metrics on installed versions of packages
-   * that the Node.js agent does not instrument (e.g. OTEL instrumentation or
-   * top logging libraries).
-   * @type {string}
-   */
-  static TYPE_TRACKING = 'tracking'
-
   /**
    * The type of the module being instrumented. See the static `TYPE_` fields.
    * @type {string|null}
@@ -207,7 +199,6 @@ module.exports.TYPES = {
   PROMISE: InstrumentationDescriptor.TYPE_PROMISE,
 
   WEB_FRAMEWORK: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK,
-  TRACKING: InstrumentationDescriptor.TYPE_TRACKING,
   /** @private */
   CONGLOMERATE: InstrumentationDescriptor.TYPE_CONGLOMERATE,
   /** @private */

package/lib/instrumentations.js

@@ -19,11 +19,9 @@ module.exports = function instrumentations() {
     '@node-redis/client': { type: InstrumentationDescriptor.TYPE_DATASTORE },
     '@prisma/client': { type: InstrumentationDescriptor.TYPE_DATASTORE },
     '@redis/client': { type: InstrumentationDescriptor.TYPE_DATASTORE },
-    amqplib: { module: './instrumentation/amqplib' },
     'aws-sdk': { module: './instrumentation/aws-sdk' },
     bluebird: { type: InstrumentationDescriptor.TYPE_PROMISE },
     bunyan: { type: InstrumentationDescriptor.TYPE_GENERIC },
-    'cassandra-driver': { type: InstrumentationDescriptor.TYPE_DATASTORE },
     connect: { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
     express: { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
     fastify: { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
@@ -35,28 +33,11 @@ module.exports = function instrumentations() {
     mongodb: { type: InstrumentationDescriptor.TYPE_DATASTORE },
     mysql: { module: './instrumentation/mysql' },
     next: { module: './instrumentation/nextjs' },
-    pg: { type: InstrumentationDescriptor.TYPE_DATASTORE },
     q: { type: null },
     redis: { type: InstrumentationDescriptor.TYPE_DATASTORE },
     restify: { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
     superagent: { type: InstrumentationDescriptor.TYPE_GENERIC },
     when: { module: './instrumentation/when' },
-    winston: { type: InstrumentationDescriptor.TYPE_GENERIC },
-
-    /**
-     * The modules below are listed here purely to take
-     * advantage of the Supportability/Features/onRequire/<module>
-     * metrics for libraries we want to track for some reason or another.
-     * The big uses cases are:
-     *  Logging libraries we want to instrument in the future
-     *  Libraries that have OpenTelemetry instrumentation we want to register
-     *  or have already registered.
-     */
-    '@azure/openai': { type: InstrumentationDescriptor.TYPE_TRACKING },
-    '@langchain/community/llms/bedrock': { type: InstrumentationDescriptor.TYPE_TRACKING },
-    'fancy-log': { type: InstrumentationDescriptor.TYPE_TRACKING },
-    knex: { type: InstrumentationDescriptor.TYPE_TRACKING },
-    loglevel: { type: InstrumentationDescriptor.TYPE_TRACKING },
-    npmlog: { type: InstrumentationDescriptor.TYPE_TRACKING },
+    winston: { type: InstrumentationDescriptor.TYPE_GENERIC }
   }
 }

package/lib/llm-events/aws-bedrock/bedrock-response.js

@@ -34,10 +34,10 @@ class BedrockResponse {
   #isConverse
 
   /**
-   * @param {object} params
-   * @param {AwsBedrockMiddlewareResponse} params.response
-   * @param {BedrockCommand} params.bedrockCommand
-   * @param {boolean} params.isError
+   * @param {object} params params object
+   * @param {AwsBedrockMiddlewareResponse} params.response AWS Bedrock middleware response
+   * @param {BedrockCommand} params.bedrockCommand AWS Bedrock command
+   * @param {boolean} params.isError is there an error
    */
   constructor({ response, bedrockCommand, isError = false }) {
     this.#originalResponse = response
@@ -146,8 +146,8 @@ class BedrockResponse {
 
   /**
    * Extracts and sets #completions and #id from the InvokeModel response body.
-   * @param {BedrockCommand} cmd
-   * @param {*} body
+   * @param {BedrockCommand} cmd AWS Bedrock Command
+   * @param {*} body InvokeModel response body
    */
   #extractCompletionsAndId(cmd, body) {
     if (cmd.isClaude() === true) {

package/lib/llm-events/aws-bedrock/chat-completion-summary.js

@@ -10,7 +10,8 @@ const LlmEvent = require('./event')
 /**
  * @typedef {object} LlmChatCompletionSummaryParams
  * @augments LlmEventParams
- * @property
+ * @property {string} segment the segment associated with this LlmChatCompletionSummary
+ * @property {boolean} isError whether this event represents an error
  */
 /**
  * @type {LlmChatCompletionSummaryParams}

package/lib/llm-events/aws-bedrock/converse-stream-handler.js

@@ -101,7 +101,7 @@ class ConverseStreamHandler {
    * If the given event is the last event in the stream, update the response
    * headers with the metrics data from the event.
    *
-   * @param {object} parsedEvent
+   * @param {object} parsedEvent parsed stream event
    */
   updateHeaders(parsedEvent) {
     this.response.response.headers = {

package/lib/llm-events/aws-bedrock/stream-handler.js

@@ -145,8 +145,8 @@ class StreamHandler {
    * Finds the reason for the end of the stream based upon the model's known
    * stop reason key.
    *
-   * @param {object} event
-   * @returns {string}
+   * @param {object} event stream event
+   * @returns {string} the stop reason
    */
   getStopReason(event) {
     if (this.stopReasonKey.includes('.')) {
@@ -164,7 +164,7 @@ class StreamHandler {
   /**
    * Decodes the Uint8Array that represents a model response.
    *
-   * @param {object} event
+   * @param {object} event stream event
    *
    * @returns {object}
    */
@@ -177,7 +177,7 @@ class StreamHandler {
    * If the given event is the last event in the stream, update the response
    * headers with the metrics data from the event.
    *
-   * @param {object} parsedEvent
+   * @param {object} parsedEvent the parsed stream event
    */
   updateHeaders(parsedEvent) {
     if (this.getStopReason(parsedEvent) === null) {

package/lib/metrics/index.js

@@ -44,7 +44,7 @@ const FROM_MILLIS = 1e-3
  * @param {number} apdexT The apdex-tolerating value, for use in creating apdex
  *                        statistics.
  * @param {MetricMapper} mapper The mapper that turns metric names into IDs.
- * @param normalizer
+ * @param {NameNormalizer} normalizer The normalizer that standardizes metric names.
  */
 function Metrics(apdexT, mapper, normalizer) {
   if (apdexT == null || apdexT === '') {
@@ -268,7 +268,7 @@ Metrics.prototype._getUnscopedData = function _getUnscopedData(name) {
  * mappings along the way. Split from _getUnscopedData for performance.
  *
  * @param {string} name The string to look up.
- * @param scope
+ * @param {string} scope The scope to map with.
  */
 Metrics.prototype._getScopedData = function _getScopedData(name, scope) {
   if (!this.scoped[scope][name]) {

package/lib/metrics/normalizer/rule.js

@@ -10,7 +10,7 @@ const logger = require('../../logger').child({ component: 'normalizer_rule' })
 /**
  * JavaScript just has to do things slightly differently.
  *
- * @param input
+ * @param {string} input the input string
  */
 const replaceReplacer = function replaceReplacer(input) {
   return input.replace(/\\/g, '$')

package/lib/metrics/normalizer.js

@@ -48,7 +48,7 @@ function plain(normalized, path) {
  * @param {object} config The agent's configuration blob, which has a parameter
  *                        that indicates whether to enforce the normalization
  *                        backstop.
- * @param type
+ * @param {string} type The type of normalization to apply.
  */
 function MetricNormalizer(config, type) {
   if (!config) {
@@ -88,9 +88,8 @@ util.inherits(MetricNormalizer, EventEmitter)
  * Convert the raw, de-serialized JSON response into a set of
  * NormalizationRules.
  *
- * @param object json The de-serialized JSON response sent on collector
+ * @param {object} json The de-serialized JSON response sent on collector
  *                    connection.
- * @param json
  */
 MetricNormalizer.prototype.load = function load(json) {
   if (json) {
@@ -118,8 +117,8 @@ MetricNormalizer.prototype.load = function load(json) {
 /**
  *  Helper for loadFromConfig
  *
- * @param rule {object} from this.config.rules
- * @param ctx {object} context from the calling function
+ * @param {object} rule from this.config.rules
+ * @param {object} ctx context from the calling function
  */
 function processNameRule(rule, ctx) {
   if (!rule.pattern) {

package/lib/metrics/recorders/database-operation.js

@@ -12,13 +12,12 @@ const metrics = require('../names')
  *
  * - `recordOperationMetrics(segment [, scope])`
  *
+ * This function is an implementation of {@link MetricFunction} (see #agentlib/shim/shim.js)
  * @private
- * @this DatastoreShim
- * @implements {MetricFunction}
  * @param {TraceSegment}  segment - The segment being recorded.
  * @param {string}        [scope] - The scope of the segment.
+ * @param {Transaction}   transaction - The transaction associated with the segment.
  * @see DatastoreShim#recordOperation
- * @see MetricFunction
  */
 function recordOperationMetrics(segment, scope, transaction) {
   const duration = segment.getDurationInMillis()

package/lib/metrics/recorders/message-transaction.js

@@ -8,9 +8,9 @@
 const NAMES = require('../../metrics/names.js')
 
 /**
- * @param {TraceSegment} segment
- * @param {object} scope
- * @param {Transaction} tx
+ * @param {TraceSegment} segment segment
+ * @param {object} [scope] scope
+ * @param {Transaction} tx transaction
  */
 function recordMessageTransaction(segment, scope, tx) {
   if (tx.type !== 'message' || tx.baseSegment !== segment) {

package/lib/metrics/recorders/middleware.js

@@ -9,11 +9,10 @@
  * Creates a recorder for middleware metrics.
  *
  * @private
- * @param {object} _shim instance of shim
  * @param {string} metricName name of metric
  * @returns {Function} recorder for middleware
  */
-function makeMiddlewareRecorder(_shim, metricName) {
+function makeMiddlewareRecorder(metricName) {
   return function middlewareMetricRecorder(segment, scope, transaction) {
     const duration = segment.getDurationInMillis()
     const exclusive = segment.getExclusiveDurationInMillis(transaction.trace)

package/lib/otel/context-manager.js

@@ -31,10 +31,10 @@ class ContextManager {
    * Runs the callback within the provided context, optionally
    * bound with a provided `this`.
    *
-   * @param context
-   * @param callback
-   * @param thisRef
-   * @param args
+   * @param {object} context context
+   * @param {Function} callback callback
+   * @param {object} thisRef `this` reference
+   * @param {...any} args arguments
    */
   with(context, callback, thisRef, ...args) {
     return this.#ctxMgr.runInContext(context, callback, thisRef, args)

package/lib/otel/trace-propagator.js

@@ -25,7 +25,7 @@ class TraceState {
 
 /**
  * Parses information from the [traceparent] span tag and converts it into {@link SpanContext}
- * @param traceParent - A meta property that comes from server.
+ * @param {string} traceParent - A meta property that comes from server.
  *     It should be dynamically generated server side to have the server's request trace Id,
  *     a parent span Id that was set on the server's request span,
  *     and the trace flags to indicate the server's sampling decision

package/lib/otel/traces/segments/database.js

@@ -68,7 +68,7 @@ module.exports = function createDbSegment(agent, otelSpan, rule) {
  * @param {ParsedStatement} params.parsed parsed statement of call
  * @param {boolean} params.operation if span is an operation
  * @param {string} params.system `db.system` value of otel span
- * @returns {function} returns a timeslice metrics recorder function based on span
+ * @returns {Function} returns a timeslice metrics recorder function based on span
  */
 function getRecorder({ parsed, operation, system }) {
   if (operation) {

package/lib/otel/traces/utils.js

@@ -12,8 +12,8 @@ const { DESTINATIONS } = require('#agentlib/config/attribute-filter.js')
  * If a key is not found in the data object, it returns 'unknown'.
  * If a key is found in the rules object, it applies the corresponding function to the value.
  * @param {string} template - The template string containing placeholders in the format ${key}.
- * @param {Object} data - An object containing key-value pairs to replace in the template.
- * @param {Object} rules - An optional object containing functions to apply to specific keys.
+ * @param {object} data - An object containing key-value pairs to replace in the template.
+ * @param {object} rules - An optional object containing functions to apply to specific keys.
  * @returns {string} - The transformed string with placeholders replaced by corresponding values.
  */
 function transformTemplate(template, data, rules = {}) {
@@ -35,7 +35,7 @@ function transformTemplate(template, data, rules = {}) {
  * Each mapping should have a key, arguments, and body.
  * The body should be a string that can be evaluated as a function.
  * @param {Array} mappings - Array of mappings with key, arguments, and body.
- * @returns {Object} - An object where each key maps to a function.
+ * @returns {object} - An object where each key maps to a function.
  */
 function buildRuleMappings(mappings = []) {
   return mappings.reduce((acc, attr) => {
@@ -111,11 +111,11 @@ function processRegexGroups({ segment, transaction, groups = [], regexMatch }) {
  * If the attribute has a key, it will be used to get the value from the span's attributes.
  * If the attribute has a value, it will be used directly.
  * If the attribute has a template, it will be transformed using the span's attributes and any provided mappings.
- * @param {Object} params - The parameters for extracting the attribute value.
+ * @param {object} params - The parameters for extracting the attribute value.
  * @param {string} params.accountId - The value of agent.config.cloud.account_id
- * @param {Object} params.attribute - The attribute object containing key, value, or template.
+ * @param {object} params.attribute - The attribute object containing key, value, or template.
  * @param {Set} params.excludeAttributes - A set to keep track of excluded attributes.
- * @param {Object} params.span - The span object containing attributes.
+ * @param {object} params.span - The span object containing attributes.
  * @returns {string} - The extracted value of the attribute.
  */
 function extractAttributeValue({ accountId, attribute, excludeAttributes, span }) {
@@ -137,10 +137,10 @@ function extractAttributeValue({ accountId, attribute, excludeAttributes, span }
 
 /**
  * Assigns a value to a target based on the specified target type.
- * @param {Object} params - The parameters for assigning the value.
- * @param {Object} params.segment - The segment to add the attribute to.
+ * @param {object} params - The parameters for assigning the value.
+ * @param {object} params.segment - The segment to add the attribute to.
  * @param {string} params.target - The target type ('transaction', 'trace', or 'segment').
- * @param {Object} params.transaction - The transaction object.
+ * @param {object} params.transaction - The transaction object.
  * @param {string} params.name - The name of the attribute.
  * @param {string} params.value - The value of the attribute.
  */

package/lib/prioritized-attributes.js

@@ -139,8 +139,8 @@ class PrioritizedAttributes {
    * Returns true if a given key is valid for any of the
    * provided destinations.
    *
-   * @param {DESTINATIONS} destinations
-   * @param {string} key
+   * @param {DESTINATIONS} destinations destinations to check against
+   * @param {string} key key to check
    */
   hasValidDestination(destinations, key) {
     const validDestinations = this.filter(destinations, key)