newrelic 13.3.2 → 13.4.0

package/lib/subscribers/amqplib/connect.js

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const Subscriber = require('../base')
+const { amqpConnection } = require('#agentlib/symbols.js')
+const isString = require('#agentlib/util/is-string.js')
+
+/**
+ * This subscriber is two-fold:
+ *  1. capture the connection arguments and assign to symbol on connection to be used for all other amqplib subscribers
+ *  2. create a segment for the connect. Not this will attempt to create a segment but the base subscriber will decide if it is created or not, otherwise it'll return the current context
+ */
+class ConnectSubscriber extends Subscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: 'amqplib', channelName: 'nr_connect' })
+    this.events = ['asyncStart', 'asyncEnd']
+    this.requireActiveTx = false
+    this.callback = -1
+  }
+
+  handler(data, ctx) {
+    this.parameters = this.parseConnectionArgs(data.arguments)
+    return this.createSegment({
+      name: 'amqplib.connect',
+      ctx
+    })
+  }
+
+  asyncStart(data) {
+    if (this.parameters && data.result) {
+      data.result[amqpConnection] = this.parameters
+    }
+    super.asyncStart(data)
+  }
+
+  /**
+   * Parses the connection args to return host/port
+   *
+   * @param {array} args arguments passed to connect
+   * @returns {object} {host, port }
+   */
+  parseConnectionArgs(args = []) {
+    const [connArgs] = args
+    const params = {}
+    if (isString(connArgs)) {
+      try {
+        const parsedUrl = new URL(connArgs)
+        params.host = parsedUrl.hostname
+        if (parsedUrl.port) {
+          params.port = parseInt(parsedUrl.port, 10)
+        }
+      } catch (err) {
+        this.logger.error('Failed to parse connection string: %s', err.message)
+      }
+    } else {
+      params.port = connArgs.port || (connArgs.protocol === 'amqp' ? 5672 : 5671)
+      params.host = connArgs.hostname
+    }
+
+    return params
+  }
+
+  addAttributes(segment) {
+    for (let [key, value] of Object.entries(this.parameters)) {
+      // eslint-disable-next-line sonarjs/updated-loop-counter
+      key = key === 'port' ? 'port_path_or_id' : key
+      segment.addAttribute(key, value)
+    }
+  }
+}
+
+module.exports = ConnectSubscriber

package/lib/subscribers/amqplib/consume.js

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const MessageConsumer = require('../message-consumer')
+const { getParameters, getParametersFromMessage, TEMP_RE } = require('./utils')
+
+class ConsumeSubscriber extends MessageConsumer {
+  constructor({ agent, logger, channelName = 'nr_consume' }) {
+    super({ agent, logger, packageName: 'amqplib', channelName, system: 'RabbitMQ', type: 'Exchange', callback: 1, transport: 'AMQP' })
+    this.segmentName = 'amqplib.Channel#consume'
+  }
+
+  /**
+   * Handles the consumption of a message(s),
+   * this will create a new transaction every time this function is called.
+   * @param {object} data the data associated with the `asyncStart` event
+   */
+  asyncStart(data) {
+    const [queue] = data?.arguments
+    const message = data?.error
+    this.consumerParameters = getParametersFromMessage.call(this, { channel: data?.self, message })
+    this.headers = message?.properties?.headers
+    this.destination = this.getExchange(message?.fields)
+    this.queue = queue
+
+    super.asyncStart(data)
+  }
+
+  getExchange(fields = {}) {
+    const isDefault = fields.exchange === ''
+    let exchange = 'Default'
+    if (!isDefault) {
+      exchange = TEMP_RE.test(fields.exchange) ? null : fields.exchange
+    }
+
+    return exchange
+  }
+
+  /**
+   * Handles the creation of the segment if `channel.consume` is made within
+   * an active transaction.
+   * @param {object} data the data associated with the subscribed event
+   * @param {object} ctx context
+   */
+  handler(data, ctx) {
+    this.parameters = {}
+    getParameters.call(this, { params: this.parameters, channel: data.self })
+    return super.handler(data, ctx)
+  }
+}
+
+module.exports = ConsumeSubscriber

package/lib/subscribers/amqplib/get-cb.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const GetMessageSubscriber = require('./get')
+
+class GetMessageCbSubscriber extends GetMessageSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: 'amqplib', channelName: 'cb_get' })
+    this.events = ['asyncStart', 'asyncEnd']
+    this.callback = -1
+  }
+}
+
+module.exports = GetMessageCbSubscriber

package/lib/subscribers/amqplib/get.js

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const Subscriber = require('../base')
+const genericRecorder = require('#agentlib/metrics/recorders/generic.js')
+const { getParametersFromMessage, EXCHANGE_PREFIX } = require('./utils')
+
+class GetMessageSubscriber extends Subscriber {
+  constructor({ agent, logger, channelName = 'nr_get' }) {
+    super({ agent, logger, packageName: 'amqplib', channelName })
+    this.events = ['asyncEnd']
+  }
+
+  handler(data, ctx) {
+    const queue = this.extractQueue(data.arguments)
+    const name = `${EXCHANGE_PREFIX}/Consume/${queue}`
+    return this.createSegment({
+      name,
+      ctx,
+      recorder: genericRecorder
+    })
+  }
+
+  asyncEnd(data) {
+    const ctx = this.agent.tracer.getContext()
+    const segment = ctx?.segment
+    const { result: message } = data
+    if (!(message?.fields || message?.properties) || !segment) {
+      this.logger.trace('No message from consume, not capturing segment parameters')
+      super.asyncEnd(data)
+      return
+    }
+
+    const params = getParametersFromMessage.call(this, { message, channel: data?.self })
+    for (const [key, value] of Object.entries(params)) {
+      segment.addAttribute(key, value)
+    }
+
+    super.asyncEnd(data)
+  }
+
+  extractQueue(args) {
+    const [queue] = args
+    return `Named/${queue}`
+  }
+}
+
+module.exports = GetMessageSubscriber

package/lib/subscribers/amqplib/purge-queue-cb.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const PurgeQueueSubscriber = require('./purge-queue')
+
+class PurgeQueueCbSubscriber extends PurgeQueueSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, channelName: 'cb_purgeQueue' })
+    this.events = ['asyncStart', 'asyncEnd']
+    this.callback = -1
+  }
+}
+
+module.exports = PurgeQueueCbSubscriber

package/lib/subscribers/amqplib/purge-queue.js

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const Subscriber = require('../base')
+const genericRecorder = require('#agentlib/metrics/recorders/generic.js')
+const { TEMP_RE, QUEUE_PREFIX } = require('./utils')
+
+class PurgeQueueSubscriber extends Subscriber {
+  constructor({ agent, logger, channelName = 'nr_purgeQueue' }) {
+    super({ agent, logger, packageName: 'amqplib', channelName })
+    this.events = ['asyncEnd']
+  }
+
+  handler(data, ctx) {
+    const queue = this.extractQueue(data.arguments)
+    const name = `${QUEUE_PREFIX}/Purge/${queue}`
+    return this.createSegment({
+      name,
+      ctx,
+      recorder: genericRecorder
+    })
+  }
+
+  extractQueue(args) {
+    let [queue] = args
+
+    if (TEMP_RE.test(queue)) {
+      queue = null
+    }
+
+    return queue ? `Named/${queue}` : 'Temp'
+  }
+}
+
+module.exports = PurgeQueueSubscriber

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const MessageProducerSubscriber = require('../message-producer')
+const { getParameters, TEMP_RE } = require('./utils')
+
+class ChannelSubscriber extends MessageProducerSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: 'amqplib', channelName: 'nr_sendMessage', system: 'RabbitMQ', type: 'Exchange' })
+    this.events = ['end']
+  }
+
+  handler(data, ctx) {
+    const [fields] = data.arguments
+
+    if (!fields) {
+      return ctx
+    }
+
+    this.destination = this.getExchange(fields)
+    this.parameters = this.getParameters({ fields, channel: data.self })
+    this.headers = fields?.headers
+    return super.handler(data, ctx)
+  }
+
+  getParameters({ fields = {}, channel = {} }) {
+    const params = {}
+    getParameters.call(this, { fields, channel, params })
+    return params
+  }
+
+  getExchange(fields = {}) {
+    const isDefault = fields.exchange === ''
+    let exchange = 'Default'
+    if (!isDefault) {
+      exchange = TEMP_RE.test(fields.exchange) ? null : fields.exchange
+    }
+    return exchange
+  }
+}
+
+module.exports = ChannelSubscriber

package/lib/subscribers/amqplib/send-or-enqueue.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const PropagationSubscriber = require('../propagation')
+
+/**
+ * This subscriber is purely for propagation of async context.
+ * It breaks without binding the transaction and segment from the result of the previous handler.
+ * It attaches transaction because `propagateTx` is true
+ *
+ */
+class SendOrEnqueueSubscriber extends PropagationSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: 'amqplib', channelName: 'nr_sendOrEnqueue', callback: -1 })
+  }
+}
+
+module.exports = SendOrEnqueueSubscriber

package/lib/subscribers/amqplib/utils.js

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const { amqpConnection } = require('#agentlib/symbols.js')
+
+const TEMP_RE = /^amq\./
+const RMQ_PREFIX = 'MessageBroker/RabbitMQ'
+const EXCHANGE_PREFIX = `${RMQ_PREFIX}/Exchange`
+const QUEUE_PREFIX = `${RMQ_PREFIX}/Queue`
+
+function getParametersFromMessage({ message, channel }) {
+  const params = {}
+  getParameters.call(this, { channel, fields: message.fields, params })
+  getParameters.call(this, { channel, fields: message.properties, params })
+  return params
+}
+
+function getParameters({ fields = {}, channel = {}, params }) {
+  if (this.config.message_tracer.segment_parameters.enabled === false) {
+    this.logger.trace('Not capturing segment parameters, `message_tracer.segments_parameters.enabled` is false')
+    return
+  }
+
+  const { host, port } = channel?.connection?.[amqpConnection]
+
+  if (fields.routingKey) {
+    params.routing_key = fields.routingKey
+  }
+  if (fields.correlationId) {
+    params.correlation_id = fields.correlationId
+  }
+  if (fields.replyTo) {
+    params.reply_to = fields.replyTo
+  }
+  if (host) {
+    params.host = host
+  }
+
+  if (port) {
+    params.port = port
+  }
+}
+
+module.exports = {
+  getParameters,
+  getParametersFromMessage,
+  EXCHANGE_PREFIX,
+  QUEUE_PREFIX,
+  TEMP_RE
+}

package/lib/subscribers/application-logs.js

@@ -22,7 +22,7 @@ class ApplicationLogsSubscriber extends Subscriber {
    * but only once. You should call this in your handler.
    * We cannot recreate creating this metric on require of a logging library
    * because we no longer monkey patch but subscribe to events.
-   * @param lib
+   * @param {string} lib name of library
    */
   createModuleUsageMetric(lib) {
     if (this.libMetricCreated === false) {

package/lib/subscribers/base.js

@@ -7,7 +7,14 @@
 // eslint-disable-next-line n/no-unsupported-features/node-builtins
 const { tracingChannel } = require('node:diagnostics_channel')
 const semver = require('semver')
-const NAMES = require('../metrics/names')
+const NAMES = require('#agentlib/metrics/names.js')
+const cat = require('#agentlib/util/cat.js')
+// Used for the `traceCallback` work.
+// This can be removed when we add true support into orchestrion
+const makeCall = (fn) => (...args) => fn.call(...args)
+const ArrayPrototypeAt = makeCall(Array.prototype.at)
+const ArrayPrototypeSplice = makeCall(Array.prototype.splice)
+// End temp work
 
 /**
  * The baseline parameters available to all subscribers.
@@ -15,9 +22,8 @@ const NAMES = require('../metrics/names')
  * @typedef {object} SubscriberParams
  * @property {object} agent A New Relic Node.js agent instance.
  * @property {object} logger An agent logger instance.
- * @property {string} packageName The npm installable name for the package
- * being instrumented. This is what a developer would provide to the `require`
- * function.
+ * @property {string} packageName The package name being instrumented.
+ * This is what a developer would provide to the `require` function.
  * @property {string} channelName A unique name for the diagnostics channel
  * that will be created and monitored.
  */
@@ -41,9 +47,11 @@ const NAMES = require('../metrics/names')
  * channel event names. This provides a namespace for the events we are
  * injecting into a module.
  * @property {boolean} [requireActiveTx=true] If true, the subscriber will only handle events when there is an active transaction.
+ * @property {boolean} [propagateTx=false] If true, it will assign the transaction from the `start.bindStore` to the context that is passed to all tracing channel events
  * @property {string} id A unique identifier for the subscriber, combining the prefix, package name, and channel name.
  * @property {TracingChannel} channel The tracing channel instance this subscriber will be monitoring.
  * @property {AsyncLocalStorage} store The async local storage instance used for context management.
+ * @property {number} callback position of callback if it needs to be wrapped for instrumentation. -1 means last argument
  */
 class Subscriber {
   constructor({ agent, logger, packageName, channelName }) {
@@ -57,9 +65,11 @@ class Subscriber {
     this.internal = false
     this.prefix = 'orchestrion:'
     this.requireActiveTx = true
+    this.propagateTx = false
     this.id = `${this.prefix}${this.packageName}:${this.channelName}`
     this.channel = tracingChannel(this.id)
     this.store = agent.tracer._contextManager._asyncLocalStorage
+    this.callback = null
   }
 
   shouldCreateSegment(parent) {
@@ -68,6 +78,49 @@ class Subscriber {
     )
   }
 
+  /**
+   * Note: This is a temporary patch until we can get the correct implementation
+   * of `tracingChannel.traceCallback` into orchestrion-js.
+   *
+   * This will wrap a callback at a given position and reassign the callback argument to the wrapped one
+   *
+   * @param {number} position index of the callback, you can specify -1 to be the last
+   * @param {object} context the event passed to the tracing channel hooks
+   */
+  traceCallback(position, context) {
+    this.logger.trace('Wrapping the callback at position %s', position)
+    const { asyncStart, asyncEnd, error } = this.channel
+    function wrappedCallback(err, res) {
+      // assigning a boolean to the context so we know that the
+      // `error`, `asyncStart`, and `asyncEnd` are coming from the wrapped callback
+      context.callback = true
+      if (err) {
+        context.error = err
+        error.publish(context)
+      } else {
+        context.result = res
+      }
+
+      // Using runStores here enables manual context failure recovery
+      asyncStart.runStores(context, () => {
+        try {
+          if (callback) {
+            return Reflect.apply(callback, this, arguments)
+          }
+        } finally {
+          asyncEnd.publish(context)
+        }
+      })
+    }
+
+    const callback = ArrayPrototypeAt(context.arguments, position)
+    if (typeof callback !== 'function') {
+      this.logger.trace('Callback is not present, not wrapping')
+    } else {
+      ArrayPrototypeSplice(context.arguments, position, 1, wrappedCallback)
+    }
+  }
+
   /**
    * Creates the `Supportability/Features/Instrumentation/OnRequire/<packageName>`
    * and `Supportability/Features/Instrumentation/OnRequire/<packageName>/Version/<majorVersion>`
@@ -123,12 +176,12 @@ class Subscriber {
       segment.opaque = this.opaque
       segment.shimId = this.packageName
       segment.start()
-      this.logger.trace('Created segment %s', name)
+      this.logger.trace('Created segment %s, returning new context', name)
       this.addAttributes(segment)
       const newCtx = ctx.enterSegment({ segment })
       return newCtx
     } else {
-      this.logger.trace('Failed to create segment for %s', name)
+      this.logger.trace('Failed to create segment for %s, returning existing context', name)
       return ctx
     }
   }
@@ -142,8 +195,20 @@ class Subscriber {
 
   }
 
+  /**
+   * Not all subscribers need change the context on `start`.
+   * This is defined on base to fulfill those use cases
+   * @param {object} data event passed to handler
+   * @param {Context} ctx context passed to handler
+   * @returns {Context} either new context or existing
+   */
+  handler(data, ctx) {
+    return ctx
+  }
+
   /**
    * Checks if the subscriber is enabled based on the agent's configuration.
+   * @returns boolean if subscriber is enabled
    */
   get enabled() {
     return this.config.instrumentation[this.packageName].enabled === true
@@ -156,14 +221,31 @@ class Subscriber {
    */
   enable() {
     this.channel.start.bindStore(this.store, (data) => {
+      // only wrap the callback if a subscriber has a callback property defined
+      if (this.callback !== null) {
+        this.traceCallback(this.callback, data)
+      }
       this.trackInstrumentationUsage(data?.moduleVersion)
       const ctx = this.agent.tracer.getContext()
       if (this.requireActiveTx && !ctx?.transaction?.isActive()) {
-        this.logger.debug('Not recording event for %s, transaction is not active', this.package)
+        this.logger.trace('Not recording event for %s, transaction is not active', this.package)
         return ctx
       }
 
-      return this.handler(data, ctx)
+      const result = this.handler(data, ctx)
+      // we cannot rely on the context manager to obtain the active segment
+      // in the `asyncStart` and `asyncEnd` events. This is because other instrumented
+      // functions are being executed at times. so we assign the active segment on the data
+      // so it can be used later to properly touch the segment in `asyncStart` and `asyncEnd`
+      if (this.callback !== null) {
+        data.segment = result?.segment
+        this.logger.trace('Adding segment %s to event context', data?.segment?.name)
+      }
+
+      if (this.propagateTx) {
+        data.transaction = result?.transaction
+      }
+      return result
     })
   }
 
@@ -174,15 +256,91 @@ class Subscriber {
     this.channel.start.unbindStore(this.store)
   }
 
+  /**
+   * This should only be used for callback based functions to touch the segment for the function
+   * that implements a callback.
+   * @param {object} data event passed to asyncStart hook
+   */
+  asyncStart(data) {
+    const ctx = this.agent.tracer.getContext()
+    if (data.callback !== true || this.internal === true || (this.requireActiveTx && !ctx?.transaction?.isActive())) {
+      this.logger.trace('Not touching parent in asyncStart for %s, transaction is not active? %s, segment is internal? %s, or no callback to bind', this.id, ctx?.transaction?.isActive(), this.internal)
+      return
+    }
+
+    this.logger.trace('touching segment %s, in asyncStart', data?.segment?.name)
+    data?.segment?.touch()
+  }
+
   /**
    * Common handler for when async events end.
    * It gets the context and touches the segment if it exists.
+   * @param {object} data event passed to asyncEnd hook
    */
-  asyncEnd() {
+  asyncEnd(data) {
+    const ctx = this.agent.tracer.getContext()
+    if (this.internal === true) {
+      this.logger.trace('asyncEnd occurring for %s internal event, not touching segment', this.id)
+      return
+    }
+
+    if (data?.callback === true) {
+      this.logger.trace('touching callback segment %s, in asyncEnd', data?.segment?.name)
+      data?.segment?.touch()
+    } else {
+      this.logger.trace('touching segment %s, in asyncEnd', ctx?.segment?.name)
+      ctx?.segment?.touch()
+    }
+  }
+
+  end() {
     const ctx = this.agent.tracer.getContext()
     ctx?.segment?.touch()
   }
 
+  /**
+   * Handles injecting w3c tracecontext in outgoing headers. If DT is disabled, and CAT is enabled
+   * it properly handles CAT.
+   *
+   * **Note**: This passes in the trace, segment and trace flags manually because this is called in the `start`
+   * right before a function is bound to context but segment is created for the function.
+   *
+   * @param {object} params to function
+   * @param {Context} params.ctx current context, not yet bound to context manager
+   * @param {object} params.headers headers for outgoing call
+   * @param {boolean} params.useMqNames flag to indicate use the MQ specific CAT header names
+   * @returns {void}
+   */
+  insertDTHeaders({ ctx, headers, useMqNames } = {}) {
+    const crossAppTracingEnabled = this.config.cross_application_tracer.enabled
+    const distributedTracingEnabled = this.config.distributed_tracing.enabled
+
+    if (!distributedTracingEnabled && !crossAppTracingEnabled) {
+      this.logger.trace('Distributed Tracing and CAT are both disabled, not adding headers.')
+      return
+    }
+
+    if (!headers) {
+      this.logger.debug('Missing headers object, not adding headers!')
+      return
+    }
+
+    const tx = ctx?.transaction
+    if (!tx?.isActive()) {
+      this.logger.trace('No active transaction found, not adding headers.')
+      return
+    }
+
+    if (distributedTracingEnabled) {
+      // we have to pass in traceId, segment id, and hard code traceFlags to 1
+      // because we're inserting headers right before the original function is bound.
+      const traceFlags = tx.sampled === true ? 1 : 0
+      tx.insertDistributedTraceHeaders(headers, null, { traceId: tx.traceId, spanId: ctx?.segment?.id, traceFlags })
+    } else {
+      cat.addCatHeaders(this.config, tx, headers, useMqNames)
+    }
+  }
+
   /*
    * Subscribes to the events defined in the `events` array.
    */

package/lib/subscribers/cassandra-driver/client-batch.js

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const DbQuerySubscriber = require('../db-query')
+
+/**
+ * Given the arguments for Cassandra's `batch` method, this finds the first
+ * query in the batch.
+ *
+ * @param {Array} args - original arguments passed to the batch function
+ * @returns {string} The query for this batch request.
+ */
+function findBatchQueryArg(args) {
+  const sql = (args[0] && args[0][0]) || ''
+  return sql.query || sql
+}
+
+/**
+ * Subscribes to the `batch` event in `cassandra-driver`
+ * and extracts relevant information from the queries.
+ */
+class CassandraBatchSubscriber extends DbQuerySubscriber {
+  constructor({ agent, logger, channelName = 'nr_batch' }) {
+    super({ agent, logger, channelName, packageName: 'cassandra-driver', system: 'Cassandra' })
+    this.events = ['asyncEnd']
+    this.isBatch = true
+  }
+
+  handler(data, ctx) {
+    const { self, arguments: args } = data
+    this.queryString = findBatchQueryArg(args)
+    this.setParameters(self)
+    return super.handler(data, ctx)
+  }
+
+  setParameters(self) {
+    this.parameters = {}
+    this.parameters.product = this.system
+    this.parameters.database_name = self?.keyspace
+    this.parameters.host = self?.options?.contactPoints?.[0]
+    this.parameters.port_path_or_id = self?.options?.protocolOptions?.port
+  }
+}
+
+module.exports = CassandraBatchSubscriber