newrelic 13.3.3 → 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,8 @@
 // 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)
@@ -46,6 +47,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} [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.
@@ -63,6 +65,7 @@ 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
@@ -192,6 +195,17 @@ 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
@@ -227,6 +241,10 @@ class Subscriber {
         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
     })
   }
@@ -275,6 +293,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

package/lib/subscribers/cassandra-driver/client-each-row.js

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const DbQuerySubscriber = require('../db-query')
+
+/**
+ * Subscribes to the `execute` event in `cassandra-driver`
+ * and extracts relevant information from the query.
+ */
+class CassandraEachRowSubscriber extends DbQuerySubscriber {
+  constructor({ agent, logger, channelName = 'nr_eachRow' }) {
+    super({ agent, logger, channelName, packageName: 'cassandra-driver', system: 'Cassandra' })
+    this.events = ['asyncEnd']
+  }
+
+  handler(data, ctx) {
+    const { self, arguments: args } = data
+    this.queryString = args?.[0]
+    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?.controlConnection?.connection?.address
+    this.parameters.port_path_or_id = self?.controlConnection?.connection?.port
+  }
+}
+
+module.exports = CassandraEachRowSubscriber

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const DbQuerySubscriber = require('../db-query')
+
+/**
+ * Subscribes to the `execute` event in `cassandra-driver`
+ * and extracts relevant information from the query.
+ */
+class CassandraExecuteSubscriber extends DbQuerySubscriber {
+  constructor({ agent, logger, channelName = 'nr_execute' }) {
+    super({ agent, logger, channelName, packageName: 'cassandra-driver', system: 'Cassandra' })
+    this.events = ['asyncEnd']
+  }
+
+  handler(data, ctx) {
+    const { self, arguments: args } = data
+    this.queryString = args?.[0]
+    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?.controlConnection?.connection?.address
+    this.parameters.port_path_or_id = self?.controlConnection?.connection?.port
+  }
+}
+
+module.exports = CassandraExecuteSubscriber

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

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const DbOperationSubscriber = require('../db-operation')
+
+/**
+ * Subscribes to the `shutdown` event in `cassandra-driver`.
+ */
+class CassandraShutdownSubscriber extends DbOperationSubscriber {
+  constructor({ agent, logger, channelName = 'nr_shutdown' }) {
+    super({ agent, logger, channelName, packageName: 'cassandra-driver', system: 'Cassandra' })
+    this.events = ['asyncStart', 'asyncEnd']
+    this.operation = 'shutdown'
+  }
+
+  handler(data, ctx) {
+    const { self } = data
+    this.setParameters(self)
+    return super.handler(data, ctx)
+  }
+
+  setParameters() {
+    this.parameters = {}
+    this.parameters.product = this.system
+  }
+}
+
+module.exports = CassandraShutdownSubscriber