newrelic 13.3.3 → 13.4.0

package/lib/instrumentation/undici.js

@@ -25,7 +25,7 @@ const channels = [
  * Subscribes to all relevant undici hook points
  * See: https://github.com/nodejs/undici/blob/main/docs/api/DiagnosticsChannel.md
  *
- * @param agent
+ * @param {Agent} agent instance
  */
 module.exports = function addUndiciChannels(agent) {
   channels.forEach(({ channel, hook }, index) => {
@@ -72,8 +72,8 @@ function addDTHeaders({ transaction, config, request }) {
  *
  * @param {object} params object to fn
  * @param {Agent} params.agent NR agent instance
+ * @param {object} params.request undici request object
  * @param {object} params.context active context
- * @param params.request
  */
 function createExternalSegment({ agent, request, context }) {
   const url = new URL(request.origin + request.path)
@@ -155,7 +155,7 @@ function requestCreateHook(agent, { request }) {
  * We will add the relevant http response attributes to active segment.
  * Also add CAT specific keys to active segment.
  *
- * @param {object} agent
+ * @param {Agent} agent instance
  * @param {object} params object from undici hook
  * @param {object} params.response { statusCode, headers, statusText }
  */

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 },

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/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/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/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/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)

package/lib/serverless/aws-lambda.js

@@ -105,8 +105,8 @@ class AwsLambda {
   /**
    * Response-streaming handlers are identified by symbol properties on the function.
    * We propagate any symbols if they're present, so that the handler keeps its signatue for any AWS features that rely on symbols
-   * @param handler
-   * @param nrHandler
+   * @param {Object} handler original handler
+   * @param {Object} nrHandler our copy of the handler
    */
   propagateSymbols(handler, nrHandler) {
     for (const symbol of Object.getOwnPropertySymbols(handler)) {
@@ -191,7 +191,7 @@ class AwsLambda {
      * **Note**: AWS doesn't support response streaming with API gateway invoked lambdas.
      * This means we do not handle that as it would require intercepting the stream to parse
      * the response code and headers.
-     * @param {...any} args
+     * @param {...any} args Original arguments
      */
     function wrappedStreamHandler(...args) {
       const transaction = shim.tracer.getTransaction()
@@ -229,7 +229,7 @@ class AwsLambda {
      * adds handlers if api gateway to wrap request/response
      * wraps the callback(if present), wraps the context `done`, `succeed`, `fail methods`, intercepts promise
      * and properly ends transaction
-     * @param {...any} args
+     * @param {...any} args Original arguments
      */
     function wrappedHandler(...args) {
       const transaction = shim.tracer.getTransaction()

package/lib/shim/datastore-shim.js

@@ -500,7 +500,7 @@ function captureInstanceAttributes(host, port, database) {
 /**
  * Parses the database name from a `USE` SQL query.
  *
- * @memberof DatastoreShim.prototype
+ * @this DatastoreShim
  * @param {string} query - The SQL query to parse the database name from.
  * @returns {?string} The name of the database if it could be parsed, otherwise
  *  `null`.

package/lib/shim/message-shim/consume.js

@@ -49,7 +49,7 @@ function updateSpecFromArgs({ shim, fn, fnName, args, spec, ctx }) {
  * @param {MessageShim} params.shim instance of shim
  * @param {Function} params.fn function that is being wrapped
  * @param {string} params.fnName name of function
- * @param params.args
+ * @param {Array} params.args arguments passed to original consume function
  * @param {specs.MessageSpec} params.spec spec for the wrapped consume function
  * @returns {specs.MessageSpec} updated spec with logic to name segment and apply the genericRecorder
  */

package/lib/shim/message-shim/subscribe-consume.js

@@ -37,8 +37,7 @@ function _nameMessageTransaction(shim, msgDesc) {
  * @param {MessageShim} params.shim instance of shim
  * @param {Function} params.fn subscriber function
  * @param {specs.MessageSubscribeSpec} params.spec spec for subscriber
- * @param params.name
- * @param {boolean} params.destNameIsArg flag to state if destination is an argument
+ * @param {string} params.name function name
  * @returns {Function} wrapped subscribe function
  */
 function createSubscriberWrapper({ shim, fn, spec, name }) {

package/lib/shim/promise-shim.js

@@ -366,9 +366,7 @@ function _wrapExecutorContext(shim, args) {
 
   /**
    *
-   * @param {Function} resolve function of promise
-   * @param {Function} reject function of promise
-   * @param {...any} args
+   * @param {Object} args contains the `resolve` and `reject` functions of a promise
    */
   function contextExporter(...args) {
     const [resolve, reject] = args

package/lib/shim/shim.js

@@ -1453,8 +1453,7 @@ function isPromise(obj) {
  * promise or async function
  *
  * @memberof Shim.prototype
- * @param fn
- * @param (function) function to test if async
+ * @param {function} fn function to test if async
  * @returns {boolean} True if the function is an async function
  */
 function isAsyncFunction(fn) {
@@ -1871,8 +1870,8 @@ function _makeBindWrapper(shim, func, context, full) {
  * (i.e. `bindRowCallbackSegment` for `rowCallback`), but will fall back to the
  * generic callback binding method, `bindCallbackSegment`, otherwise.
  *
- * @this *
  * @private
+ * @this *
  * @param {Shim} shim
  *  The shim performing this binding.
  * @param {Function} fn
@@ -2129,7 +2128,7 @@ function _es5WrapClass(shim, Base, fnName, spec, args) {
   /**
    * Wraps the es5 class in a function
    *
-   * @param {...any} cnstrctArgs
+   * @param {...any} cnstrctArgs class constructor arguments
    * @returns {Function|undefined} a function if not already wrapped in WrappedClass
    */
   function WrappedClass(...cnstrctArgs) {

package/lib/shim/transaction-shim.js

@@ -19,7 +19,6 @@ const TRANSACTION_TYPES_SET = Transaction.TYPES_SET
  * @class
  * @augments Shim
  * @classdesc
- * @param shimName
  *  A helper class for working with transactions.
  * @param {Agent}   agent         - The agent the shim will use.
  * @param {string}  moduleName    - The name of the module being instrumented.

package/lib/shim/webframework-shim/common.js

@@ -46,8 +46,6 @@ common.getTransactionInfo = function getTransactionInfo(shim, req) {
  * Adds the given error to the transaction information if it is actually an error.
  *
  * @private
- * @param {WebFrameworkShim} shim
- *  The shim used for this web framework.
  * @param {TransactionInfo} txInfo
  *  The transaction context information for the request.
  * @param {*} err
@@ -73,8 +71,8 @@ common.isError = function isError(shim, err) {
 }
 
 /**
- * @param shim
- * @param req
+ * @param {Object} shim instance
+ * @param {Object} req request
  */
 common.makeGetReq = function makeGetReq(shim, req) {
   return function getReqFromArgs(shim, fn, name, args) {

package/lib/shim/webframework-shim/middleware.js

@@ -331,14 +331,14 @@ module.exports._recordMiddleware = function _recordMiddleware(shim, middleware,
  * push the name state if there is a next so that we can safely remove it
  * if context leaves this middleware.
  *
- * @param root0
- * @param root0.shim
- * @param root0.spec
- * @param root0.route
- * @param root0.args
- * @param root0.isErrorWare
- * @param root0.isPromise
- * @param root0.txInfo
+ * @param {Object} params params object
+ * @param {Shim} params.shim shim instance
+ * @param {Object} params.spec middleware spec, should contain a next function
+ * @param {string} params.route route
+ * @param {Array} params.args arguments
+ * @param {boolean} params.isErrorWare is this error ware
+ * @param {boolean} params.isPromise is this a promise
+ * @param {Object} params.txInfo transaction information
  * @private
  */
 function wrapNextHandler({ shim, spec, route, args, isErrorWare, isPromise, txInfo }) {

package/lib/spans/span-context.js

@@ -41,7 +41,7 @@ class SpanContext {
    *
    * Last error wins.
    *
-   * @param details
+   * @param {Obejct} details error details
    */
   setError(details) {
     this.hasError = true

package/lib/spans/span-event-aggregator.js

@@ -87,7 +87,7 @@ class SpanEventAggregator extends EventAggregator {
   /**
    * Reconfigure the `SpanEventAggregator` based on values from server
    *
-   * @param {Config} config
+   * @param {Config} config the config to reconfigure with
    */
   reconfigure(config) {
     super.reconfigure(config)
@@ -105,7 +105,7 @@ class SpanEventAggregator extends EventAggregator {
    * When no `span_event_harvest_config` has been received from the server, applies an
    * agent-defined fallback maximum to protect against collecting and sending too many spans.
    *
-   * @param {Config} config
+   * @param {Config} config the config to check
    */
   _getValidSpanConfiguration(config) {
     const spanHarvestConfig = config.span_event_harvest_config

package/lib/spans/span-event.js

@@ -89,11 +89,12 @@ class SpanEvent {
    * The constructed span event will contain extra data depending on the
    * category of the segment.
    *
-   * @param {TraceSegment} segment segment to turn into a span event.
-   * @param {Transaction} transaction active transaction
-   * @param {?string} [parentId] ID of the segment's parent.
-   * @param {boolean} isRoot if segment is root segment
-   * @param {boolean} inProcessSpans if the segment is in-process, create span
+   * @param {Object} params params object
+   * @param {TraceSegment} params.segment segment to turn into a span event.
+   * @param {Transaction} params.transaction active transaction
+   * @param {?string} [params.parentId] ID of the segment's parent.
+   * @param {boolean} [params.isRoot] if segment is root segment; defaults to `false`
+   * @param {boolean} params.inProcessSpans if the segment is in-process, create span
    * @returns {SpanEvent} The constructed event.
    */
   static fromSegment({ segment, transaction, parentId = null, isRoot = false, inProcessSpans }) {

package/lib/spans/streaming-span-attributes.js

@@ -46,7 +46,7 @@ class StreamingSpanAttributes {
    *
    * Does not apply filtering/truncation.
    *
-   * @param {object} [attributes]
+   * @param {object} [attributes] Attributes to add.
    * @param {string} [attributes.key] Name of the attribute to be stored.
    * @param {string|boolean|number} [attributes.value] Value of the attribute to be stored.
    */

package/lib/spans/streaming-span-event-aggregator.js

@@ -101,10 +101,9 @@ class StreamingSpanEventAggregator extends Aggregator {
    *
    * @param {object} params to function
    * @param {TraceSegment} params.segment segment to add.
-   * @param {string} [parms.parentId] GUID of the parent span.
    * @param {Transaction} params.transaction active transaction
+   * @param {string} [params.parentId] GUID of the parent span.
    * @param {boolean} params.isRoot is segment root segment
-   * @param params.parentId
    * @returns {boolean} True if the segment was added, or false if it was discarded.
    */
   addSegment({ segment, transaction, parentId, isRoot }) {

package/lib/stats/index.js

@@ -84,7 +84,7 @@ Stats.prototype.incrementCallCount = function incrementCallCount(count) {
 /**
  * Fold another summary's statistics into this one.
  *
- * @param other
+ * @param {Stats} other other Stats instance
  */
 Stats.prototype.merge = function merge(other) {
   if (other.count && !other.callCount) {

package/lib/subscriber-configs.js

@@ -8,6 +8,8 @@
 // The expected export of these files is:
 // 'package-name': [ { path: 'subscriberPath', instrumentations: [] }, ... ]
 const subscribers = {
+  ...require('./subscribers/amqplib/config'),
+  ...require('./subscribers/cassandra-driver/config'),
   ...require('./subscribers/elasticsearch/config'),
   ...require('./subscribers/ioredis/config'),
   ...require('./subscribers/mcp-sdk/config'),

package/lib/subscribers/amqplib/accept-message.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const PropagationSubscriber = require('../propagation')
+
+class AcceptMessageSubscriber extends PropagationSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: 'amqplib', channelName: 'nr_acceptMessage', callback: 0 })
+  }
+}
+
+module.exports = AcceptMessageSubscriber

package/lib/subscribers/amqplib/callback-model.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const MetaSubscriber = require('../meta-subscriber')
+const CHANNEL_METHODS = [
+  'cb_close',
+  'cb_open',
+  'cb_assertQueue',
+  'cb_checkQueue',
+  'cb_deleteQueue',
+  'cb_bindQueue',
+  'nr_unbindQueue',
+  'cb_assertExchange',
+  'cb_checkExchange',
+  'cb_deleteExchange',
+  'cb_bindExchange',
+  'cb_unbindExchange',
+  'cb_cancel',
+  'cb_prefetch',
+  'cb_recover'
+]
+
+class ChannelModelSubscriber extends MetaSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: 'amqplib', channelName: 'channelModel', channels: CHANNEL_METHODS, events: ['asyncEnd'], callback: -1 })
+  }
+
+  handler(_data, ctx) {
+    const [, name] = this.channelName.split('_')
+    return this.createSegment({
+      name: `Channel#${name}`,
+      ctx
+    })
+  }
+}
+
+module.exports = ChannelModelSubscriber

package/lib/subscribers/amqplib/channel-model.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const MetaSubscriber = require('../meta-subscriber')
+const CHANNEL_METHODS = [
+  'nr_close',
+  'nr_open',
+  'nr_assertQueue',
+  'nr_checkQueue',
+  'nr_deleteQueue',
+  'nr_bindQueue',
+  'nr_unbindQueue',
+  'nr_assertExchange',
+  'nr_checkExchange',
+  'nr_deleteExchange',
+  'nr_bindExchange',
+  'nr_unbindExchange',
+  'nr_cancel',
+  'nr_prefetch',
+  'nr_recover'
+]
+
+class ChannelModelSubscriber extends MetaSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: 'amqplib', channelName: 'channelModel', channels: CHANNEL_METHODS, events: ['asyncEnd'] })
+  }
+
+  handler(data, ctx) {
+    const [, name] = this.channelName.split('_')
+    return this.createSegment({
+      name: `Channel#${name}`,
+      ctx
+    })
+  }
+}
+
+module.exports = ChannelModelSubscriber