newrelic 13.3.3 → 13.5.0

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

@@ -6,22 +6,20 @@
 'use strict'
 
 /**
- * Builds a set of packages and instrumentaions from a list of subscriber configurations.
+ * Builds a set of packages and instrumentations from a list of subscriber configurations.
  *
  * @param {Array} subscribers - An array of subscriber objects, each containing a package name and an array of instrumentations.
- * @returns {Object} An object containing a Set of unique package names and an array of instrumentations.
+ * @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-operation.js

@@ -7,7 +7,19 @@ const DbSubscriber = require('./db')
 const recordOperationMetrics = require('../metrics/recorders/database-operation')
 const { DB } = require('../metrics/names')
 
+/**
+ * Subscriber for database operation events e.g. `connect`.
+ */
 class DbOperationSubscriber extends DbSubscriber {
+  /**
+   * On a tracing channel event specified by `this.events`,
+   * this handler will create a new segment with the name
+   * `${DB.OPERATION}/${this.system}/${this.operation}`.
+   *
+   * @param {*} data event data
+   * @param {Context} ctx our context
+   * @returns {Context} updated context with the new segment
+   */
   handler(data, ctx) {
     const name = `${DB.OPERATION}/${this.system}/${this.operation}`
     return this.createSegment({

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/dc-base.js

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+// eslint-disable-next-line n/no-unsupported-features/node-builtins
+const dc = require('node:diagnostics_channel')
+
+/**
+ * The baseline parameters available to all subscribers.
+ *
+ * @typedef {object} SubscriberParams
+ * @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.
+ */
+
+/**
+ * @typedef {object} ChannelDescriptor
+ * @property {string} channel The fully qualified name of a diagnostic channel,
+ * e.g. `undici:request:create`.
+ * @property {Function} hook The function to execute when the channel is fired.
+ * This function will be bound to the `Subscriber` instance.
+ */
+
+/**
+ * @property {object} agent A New Relic Node.js agent instance.
+ * @property {ChannelDescriptor[]} channels The channels to subscribe to.
+ * @property {object} logger An agent logger instance.
+ * @property {object} config The agent configuration object.
+ * @property {string} id The name of the module being instrumented.
+ * This is the same string one would pass to the `require` function.
+ */
+class Subscriber {
+  /**
+   * @param {SubscriberParams} params to function
+   */
+  constructor({ agent, logger, packageName }) {
+    this.agent = agent
+    this.logger = logger.child({ component: `${packageName}-subscriber` })
+    this.config = agent.config
+    this.id = packageName
+  }
+
+  set channels(channels) {
+    if (!Array.isArray(channels)) {
+      throw new Error('channels must be a collection of with propertiesof channel and hook')
+    }
+    this._channels = channels
+  }
+
+  get channels() {
+    return this._channels
+  }
+
+  /**
+   * 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.id].enabled === true
+  }
+
+  enable() {
+    return true
+  }
+
+  disable() {
+    return true
+  }
+
+  subscribe() {
+    this.channels.forEach(({ channel, hook }, index) => {
+      const boundHook = hook.bind(this)
+      dc.subscribe(channel, boundHook)
+      this.channels[index].boundHook = boundHook
+    })
+  }
+
+  unsubscribe() {
+    this.channels.forEach(({ channel, boundHook }) => {
+      dc.unsubscribe(channel, boundHook)
+    })
+  }
+}
+
+module.exports = Subscriber

package/lib/subscribers/fastify/add-hook.js

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const Subscriber = require('../base')
+/**
+ * These are the events that occur during a fastify
+ * request
+ * see: https://www.fastify.io/docs/latest/Lifecycle/
+ *
+ * Note: preSerialization and onSend happen after the route handler
+ * executes.  `onResponse` does not execute until after the client
+ * sends the response so it'll never be in scope of the transaction
+ */
+const REQUEST_HOOKS = [
+  'onRequest',
+  'preParsing',
+  'preValidation',
+  'preHandler',
+  'preSerialization',
+  'onSend',
+  'onResponse',
+  'onError'
+]
+const { handlerWrapper } = require('./common')
+
+class FastifyAddHookSubscriber extends Subscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: 'fastify', channelName: 'nr_addHook' })
+    this.requireActiveTx = false
+  }
+
+  handler(data) {
+    const { arguments: args } = data
+    const [hookName, fn] = args
+    if (REQUEST_HOOKS.includes(hookName)) {
+      const wrappedFn = handlerWrapper({ handler: fn, hookName, self: this })
+      data.arguments[1] = wrappedFn
+    }
+  }
+}
+
+module.exports = FastifyAddHookSubscriber