newrelic 13.3.2 → 13.4.0

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

package/lib/subscribers/cassandra-driver/config.js

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// there are diff subscribers for handling callback based code. In 4.4.0+ you can specify callbacks but they're all wrapped around promises so you don't have to wrap the callback in that case
+const legacyBatchConfig = {
+  path: './cassandra-driver/legacy-client-batch.js',
+  instrumentations: [
+    {
+      channelName: 'nr_legacyBatch',
+      module: { name: 'cassandra-driver', versionRange: '>=3.4.0 <4.4.0', filePath: 'lib/client.js' },
+      functionQuery: {
+        expressionName: 'batch',
+        kind: 'Async'
+      }
+    },
+  ]
+}
+
+const legacyConnectConfig = {
+  path: './cassandra-driver/legacy-client-connect.js',
+  instrumentations: [
+    {
+      channelName: 'nr_legacyConnect',
+      module: { name: 'cassandra-driver', versionRange: '>=3.4.0 <4.4.0', filePath: 'lib/client.js' },
+      functionQuery: {
+        expressionName: 'connect',
+        kind: 'Async'
+      }
+    },
+  ]
+}
+
+const legacyExecuteConfig = {
+  path: './cassandra-driver/legacy-client-execute.js',
+  instrumentations: [
+    {
+      channelName: 'nr_legacyExecute',
+      module: { name: 'cassandra-driver', versionRange: '>=3.4.0 <4.4.0', filePath: 'lib/client.js' },
+      functionQuery: {
+        expressionName: 'execute',
+        kind: 'Async'
+      }
+    }
+  ]
+}
+
+const legacyEachRowConfig = {
+  path: './cassandra-driver/legacy-client-each-row.js',
+  instrumentations: [
+    {
+      channelName: 'nr_legacyEachRow',
+      module: { name: 'cassandra-driver', versionRange: '>=3.4.0 <4.4.0', filePath: 'lib/client.js' },
+      functionQuery: {
+        expressionName: 'eachRow',
+        kind: 'Async'
+      }
+    },
+  ]
+}
+
+const legacyShutdownConfig = {
+  path: './cassandra-driver/legacy-client-shutdown.js',
+  instrumentations: [
+    {
+      channelName: 'nr_legacyShutdown',
+      module: { name: 'cassandra-driver', versionRange: '>=3.4.0 <4.4.0', filePath: 'lib/client.js' },
+      functionQuery: {
+        expressionName: 'shutdown',
+        kind: 'Async'
+      }
+    },
+  ]
+}
+
+const batchConfig = {
+  path: './cassandra-driver/client-batch.js',
+  instrumentations: [
+    {
+      channelName: 'nr_batch',
+      module: { name: 'cassandra-driver', versionRange: '>=4.4.0', filePath: 'lib/client.js' },
+      functionQuery: {
+        expressionName: '_batch',
+        kind: 'Async'
+      }
+    },
+  ]
+}
+
+const connectConfig = {
+  path: './cassandra-driver/client-connect.js',
+  instrumentations: [
+    {
+      channelName: 'nr_connect',
+      module: { name: 'cassandra-driver', versionRange: '>=4.4.0', filePath: 'lib/client.js' },
+      functionQuery: {
+        expressionName: 'connect',
+        kind: 'Async'
+      }
+    },
+  ]
+}
+
+const executeConfig = {
+  path: './cassandra-driver/client-execute.js',
+  instrumentations: [
+    {
+      channelName: 'nr_execute',
+      module: { name: 'cassandra-driver', versionRange: '>=4.4.0', filePath: 'lib/client.js' },
+      functionQuery: {
+        expressionName: '_execute',
+        kind: 'Async'
+      }
+    }
+  ]
+}
+
+const shutdownConfig = {
+  path: './cassandra-driver/client-shutdown.js',
+  instrumentations: [
+    {
+      channelName: 'nr_shutdown',
+      module: { name: 'cassandra-driver', versionRange: '>=4.4.0', filePath: 'lib/client.js' },
+      functionQuery: {
+        expressionName: 'shutdown',
+        kind: 'Async'
+      }
+    },
+  ]
+}
+
+module.exports = {
+  'cassandra-driver': [
+    batchConfig,
+    connectConfig,
+    executeConfig,
+    shutdownConfig,
+    legacyBatchConfig,
+    legacyEachRowConfig,
+    legacyConnectConfig,
+    legacyExecuteConfig,
+    legacyShutdownConfig
+  ]
+}

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

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const CassandraBatchSubscriber = require('./client-batch')
+
+/**
+ * Subscribes to the `batch` event in `cassandra-driver`
+ * and extracts relevant information from the queries.
+ */
+class LegacyCassandraBatchSubscriber extends CassandraBatchSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, channelName: 'nr_legacyBatch' })
+    this.events = ['asyncStart', 'asyncEnd']
+    this.callback = -1
+  }
+}
+
+module.exports = LegacyCassandraBatchSubscriber

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

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const CassandraConnectSubscriber = require('./client-connect')
+
+/**
+ * Subscribes to the `connect` event in `cassandra-driver`'s `Client`.
+ */
+class LegacyCassandraConnectSubscriber extends CassandraConnectSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, channelName: 'nr_legacyConnect' })
+    this.events = ['asyncStart', 'asyncEnd']
+    this.internal = true
+    this.callback = -1
+  }
+}
+
+module.exports = LegacyCassandraConnectSubscriber

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

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const CassandraEachRowSubscriber = require('./client-each-row')
+
+/**
+ * Subscribes to the `execute` event in `cassandra-driver`
+ * and extracts relevant information from the query.
+ */
+class LegacyCassandraEachRowSubscriber extends CassandraEachRowSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, channelName: 'nr_legacyEachRow' })
+    this.events = ['asyncStart', 'asyncEnd']
+    this.callback = -1
+  }
+}
+
+module.exports = LegacyCassandraEachRowSubscriber

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

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const CassandraExecuteSubscriber = require('./client-execute')
+/**
+ * Subscribes to the `execute` event in `cassandra-driver`
+ * and extracts relevant information from the query.
+ */
+class LegacyCassandraExecuteSubscriber extends CassandraExecuteSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, channelName: 'nr_legacyExecute' })
+    this.events = ['asyncStart', 'asyncEnd']
+    this.callback = -1
+  }
+}
+
+module.exports = LegacyCassandraExecuteSubscriber

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

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

package/lib/subscribers/create-config.js

@@ -12,16 +12,14 @@
  * @returns {Object} An object containing a Set of unique package names and an array of instrumentations.
  */
 function createSubscribersConfig (subscribers = []) {
-  const packages = new Set()
   const instrumentations = []
-  for (const [packageName, subscriberList] of Object.entries(subscribers)) {
-    packages.add(packageName)
+  for (const subscriberList of Object.values(subscribers)) {
     for (const subscriber of subscriberList) {
       instrumentations.push(...subscriber.instrumentations)
     }
   }
 
-  return { packages, instrumentations }
+  return { instrumentations }
 }
 
 module.exports = createSubscribersConfig

package/lib/subscribers/db-query.js

@@ -13,7 +13,11 @@ class DbQuerySubscriber extends DbSubscriber {
   handler(data, ctx) {
     const queryString = this.queryString
     const parsed = this.parseQueryString(queryString)
-    const name = `${DB.STATEMENT}/${this.system}/${parsed.collection}/${parsed.operation}`
+    let name = `${DB.STATEMENT}/${this.system}/${parsed.collection}/${parsed.operation}`
+    if (this.isBatch) {
+      name += '/batch'
+    }
+
     return this.createSegment({
       name,
       ctx,

package/lib/subscribers/message-consumer.js

@@ -0,0 +1,146 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const Subscriber = require('./base')
+const Transaction = require('#agentlib/transaction/index.js')
+const messageTransactionRecorder = require('#agentlib/metrics/recorders/message-transaction.js')
+const isString = require('#agentlib/util/is-string.js')
+
+/**
+ * A message consumer does the following:
+ *  1. Calling consume creates a segment if in an active transaction
+ *  2. For every consumption, typically registered as a callback, it will create a transaction of type `message`, create a baseSegment, add both segment and trace attributes, and assign the `message-transaction` timeslice metrics
+ *
+ * @typedef {object} MessageConsumerParams
+ * @property {object} agent A New Relic Node.js agent instance.
+ * @property {object} logger An agent logger instance.
+ * @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.
+ * @property {string} system canonical mapping of system(i.e. - Kafka, RabbitMq, SNS, SQS)
+ * @property {string} type destinationType: Exchange, Queue, Topic
+ * @property {number} callback if consumer is callback based, indicates index of callback
+ * @property {string} transport identifier of the transport(see Transaction.TRANSPORT_TYPES)
+ */
+class MessageConsumer extends Subscriber {
+  constructor({ agent, logger, packageName, channelName, system, type, callback, transport }) {
+    super({ agent, logger, packageName, channelName })
+    this.system = system
+    this.type = type
+    this.callback = callback
+    this.transport = transport
+    this.events = ['asyncStart', 'asyncEnd']
+  }
+
+  /**
+   * Used to create the consume segment if in an active transaction
+   * @param {object} data event passed to handler
+   * @param {Context} ctx agent context
+   * @returns {Context} new context or existing if not in active transaction
+   */
+  handler(data, ctx) {
+    return this.createSegment({
+      name: this.segmentName,
+      ctx
+    })
+  }
+
+  /**
+   * Used to add parameters to the consume segment
+   *
+   * @param {TraceSegment} segment to add attributes to
+   */
+  addAttributes(segment) {
+    for (const [key, value] of Object.entries(this.parameters)) {
+      segment.addAttribute(key, value)
+    }
+  }
+
+  enable() {
+    super.enable()
+    this.channel.asyncStart.bindStore(this.store, (data) => {
+      const ctx = this.agent.tracer.getContext()
+      const transaction = new Transaction(this.agent)
+      transaction.type = 'message'
+      return ctx.enterTransaction(transaction)
+    })
+  }
+
+  disable() {
+    super.disable()
+    this.channel.asyncStart.unbindStore(this.store)
+  }
+
+  /**
+   * Used to create a transaction for every consumption callback.
+   *
+   * @param {object} data event passed to asyncStart handler
+   */
+  asyncStart(data) {
+    const ctx = this.agent.tracer.getContext()
+    const tx = ctx?.transaction
+    tx.setPartialName(this.name)
+    // Note: this is not using `Subscriber.createSegment`
+    // this is because it enters the segment and returns a new ctx
+    // since this isn't in bindStore entering a new context doesn't
+    // bind it to the store
+    tx.baseSegment = this.agent.tracer.createSegment({
+      name: tx.getFullName(),
+      recorder: messageTransactionRecorder,
+      parent: tx.trace.root,
+      transaction: tx
+    })
+
+    this.addConsumeParameters(tx)
+
+    if (this.headers) {
+      tx.addDtCatHeaders({ headers: this.headers, transport: this.transport })
+    }
+  }
+
+  /**
+   * Used to add parameters to trace and baseSegment of a consumption callback.
+   *
+   * @param {Transaction} tx to add attributes to
+   */
+  addConsumeParameters(tx) {
+    for (const [key, value] of Object.entries(this.consumerParameters)) {
+      if (['host', 'port'].includes(key)) {
+        tx.baseSegment.addAttribute(key, value)
+      } else {
+        tx.trace.attributes.addAttribute(Transaction.DESTINATIONS.NONE, `message.parameters.${key}`, value)
+        tx.baseSegment.attributes.addAttribute(Transaction.DESTINATIONS.NONE, `message.parameters.${key}`, value)
+      }
+
+      if (key === 'routing_key' && this.config.high_security === false) {
+        tx.trace.attributes.addAttribute(Transaction.DESTINATIONS.TRANS_COMMON, 'message.routingKey', value)
+        tx.baseSegment.addSpanAttribute('message.routingKey', value)
+      }
+    }
+    if (isString(this.queue) && this.config.high_security === false) {
+      tx.trace.attributes.addAttribute(Transaction.DESTINATIONS.TRANS_COMMON, 'message.queueName', this.queue)
+      tx.baseSegment.addSpanAttribute('message.queueName', this.queue)
+    }
+  }
+
+  /**
+   * Used to name the transaction for every consumption callback.
+   *
+   * @returns {string} partial transaction name
+   */
+  get name() {
+    let name = `${this.system}/${this.type}`
+    if (this.destination) {
+      name += `/Named/${this.destination}`
+    } else {
+      name += '/Temp'
+    }
+    return name
+  }
+}
+
+module.exports = MessageConsumer

package/lib/subscribers/message-producer.js

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const Subscriber = require('./base')
+const genericRecorder = require('#agentlib/metrics/recorders/generic.js')
+
+/**
+ *
+ * Creates the segment for a message producer call. Injects appropriate DT/CAT
+ * headers if enabled.
+ *
+ *  @typedef {object} MessageProducerParams
+ * @property {object} agent A New Relic Node.js agent instance.
+ * @property {object} logger An agent logger instance.
+ * @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.
+ * @property {string} system canonical mapping of system(i.e. - Kafka, RabbitMq, SNS, SQS)
+ * @property {string} type destinationType: Exchange, Queue, Topic
+ */
+class MessageProducerSubscriber extends Subscriber {
+  constructor({ agent, logger, packageName, channelName, system, type }) {
+    super({ agent, logger, packageName, channelName })
+    this.system = system
+    this.prefix = 'MessageBroker'
+    this.type = type
+  }
+
+  handler(data, ctx) {
+    const newCtx = this.createSegment({
+      name: this.name,
+      ctx,
+      recorder: genericRecorder
+    })
+    this.insertDTHeaders({ ctx: newCtx, headers: this.headers, useMqNames: true })
+    return newCtx
+  }
+
+  get name() {
+    let name = `${this.prefix}/${this.system}/${this.type}/Produce`
+    if (this.destination) {
+      name += `/Named/${this.destination}`
+    } else {
+      name += '/Temp'
+    }
+    return name
+  }
+
+  addAttributes(segment) {
+    for (const [key, value] of Object.entries(this.parameters)) {
+      segment.addAttribute(key, value)
+    }
+  }
+}
+
+module.exports = MessageProducerSubscriber