newrelic 13.3.3 → 13.5.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,18 @@
+/*
+ * 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.
+ */
+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

@@ -6,8 +6,7 @@
 'use strict'
 // 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 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)
@@ -46,6 +45,7 @@ const ArrayPrototypeSplice = makeCall(Array.prototype.splice)
  * 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} [propagateContext=false] If true, it will bind `asyncStart` to the store and re-propagate the active context. It will also attach the `transaction` to the event in `start.bindStore`. This is used for functions that queue async code and context is lost.
  * @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.
@@ -63,6 +63,7 @@ class Subscriber {
     this.internal = false
     this.prefix = 'orchestrion:'
     this.requireActiveTx = true
+    this.propagateContext = false
     this.id = `${this.prefix}${this.packageName}:${this.channelName}`
     this.channel = tracingChannel(this.id)
     this.store = agent.tracer._contextManager._asyncLocalStorage
@@ -119,38 +120,35 @@ class Subscriber {
   }
 
   /**
-   * Creates the `Supportability/Features/Instrumentation/OnRequire/<packageName>`
-   * and `Supportability/Features/Instrumentation/OnRequire/<packageName>/Version/<majorVersion>`
-   * metrics to track the usage of an instrumented package.
-   * We only want to increment this once per package, so we check the call count
+   * Wraps an event emitter and runs the wrap in the new context
+   * If the event is `end` or `error` it'll touch the active segment
    *
-   * @param {string} [version] - The version of the package being instrumented.
-   * @returns {void}
+   * @param {object} params to function
+   * @param {Array} params.args arguments to function
+   * @param {number} params.index index of argument to wrap
+   * @param {string} params.name name of emit function
+   * @param {Context} params.ctx context to bind wrapped emit to
    */
-  trackInstrumentationUsage(version) {
-    const prefix = NAMES.FEATURES.INSTRUMENTATION.ON_REQUIRE
-    const instrumentationMetric = `${prefix}/${this.packageName}`
-    const metric = this.agent.metrics.getOrCreateMetric(instrumentationMetric)
-    if (metric.callCount === 0) {
-      metric.incrementCallCount()
-    }
-
-    if (version) {
-      const majorVersion = semver.major(version)
-      const versionMetricName = `${instrumentationMetric}/Version/${majorVersion}`
-      const versionMetric = this.agent.metrics.getOrCreateMetric(versionMetricName)
-      if (versionMetric.callCount === 0) {
-        versionMetric.incrementCallCount()
+  wrapEventEmitter({ args, index, name, ctx }) {
+    const orig = args[index][name]
+    const self = this
+    function wrapEmit(...emitArgs) {
+      const ctx = self.agent.tracer.getContext()
+      const [evnt] = emitArgs
+      if (evnt === 'end' || evnt === 'error') {
+        ctx?.segment?.touch()
       }
+      return orig.apply(this, emitArgs)
     }
+    args[index][name] = this.agent.tracer.bindFunction(wrapEmit, ctx, false)
   }
 
   /**
    * Creates a segment with a name, parent, transaction and optional recorder.
    * If the segment is successfully created, it will be started and added to the context.
-   * @param {Object} params - Parameters for creating the segment
+   * @param {object} params - Parameters for creating the segment
    * @param {string} params.name - The name of the segment
-   * @param {Object} params.recorder - Optional recorder for the segment
+   * @param {object} params.recorder - Optional recorder for the segment
    * @param {Context} params.ctx - The context containing the parent segment and transaction
    * @returns {Context} - The updated context with the new segment or existing context if segment creation fails
    */
@@ -192,9 +190,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
+   * @returns {boolean} if subscriber is enabled
    */
   get enabled() {
     return this.config.instrumentation[this.packageName].enabled === true
@@ -203,15 +212,19 @@ class Subscriber {
   /**
    * Enables the subscriber by binding the store to the channel and setting up the handler.
    * If the subscriber requires an active transaction, it will check the context before passing the event to the handler.
-   * @returns {Context} - The context after processing the event
+   * @returns {void} The `bindStore` function with our handler.
    */
   enable() {
-    this.channel.start.bindStore(this.store, (data) => {
+    /**
+     * Event handler for processing incoming events.
+     * @param {object} data Event data
+     * @returns {Context} The context after processing the event
+     */
+    const handler = (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.trace('Not recording event for %s, transaction is not active', this.package)
@@ -227,8 +240,28 @@ class Subscriber {
         data.segment = result?.segment
         this.logger.trace('Adding segment %s to event context', data?.segment?.name)
       }
+
+      // attach to event as it will be used to re-bind context in `asyncStart.bindStore`
+      if (this.propagateContext) {
+        data.transaction = result?.transaction
+      }
       return result
-    })
+    }
+
+    this.channel.start.bindStore(this.store, handler)
+    if (this.propagateContext) {
+      this.channel.asyncStart.bindStore(this.store, (data) => {
+        const { transaction, segment } = data
+        const ctx = this.agent.tracer.getContext()
+
+        if (!(transaction && segment)) {
+          this.logger.trace('No active transaction/segment, returning existing context')
+          return ctx
+        }
+        const newCtx = ctx.enterSegment({ transaction, segment })
+        return newCtx
+      })
+    }
   }
 
   /**
@@ -236,6 +269,9 @@ class Subscriber {
    */
   disable() {
     this.channel.start.unbindStore(this.store)
+    if (this.propagateContext) {
+      this.channel.asyncStart.unbindStore(this.store)
+    }
   }
 
   /**
@@ -275,6 +311,54 @@ class Subscriber {
     }
   }
 
+  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

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const DbOperationSubscriber = require('../db-operation')
+
+/**
+ * Subscribes to the `connect` event in `cassandra-driver`'s `Client`.
+ */
+class CassandraConnectSubscriber extends DbOperationSubscriber {
+  constructor({ agent, logger, channelName = 'nr_connect' }) {
+    super({ agent, logger, channelName, packageName: 'cassandra-driver', system: 'Cassandra' })
+    this.events = ['asyncEnd']
+    this.operation = 'connect'
+  }
+
+  handler(data, ctx) {
+    const { self } = data
+    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 = CassandraConnectSubscriber