newrelic 13.0.0 → 13.2.0

package/lib/subscribers/application-logs.js

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const Subscriber = require('./base')
+const { isApplicationLoggingEnabled, isLocalDecoratingEnabled, isLogForwardingEnabled, isMetricsEnabled, createModuleUsageMetric, incrementLoggingLinesMetrics } = require('../util/application-logging')
+
+class ApplicationLogsSubscriber extends Subscriber {
+  constructor({ agent, logger, packageName, channelName, }) {
+    super({ agent, logger, packageName, channelName, })
+    this.requireActiveTx = false
+    this.libMetricCreated = false
+  }
+
+  get enabled() {
+    return super.enabled && isApplicationLoggingEnabled(this.config)
+  }
+
+  /**
+   * The intent of this method is to create a module usage metric
+   * 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
+   */
+  createModuleUsageMetric(lib) {
+    if (this.libMetricCreated === false) {
+      createModuleUsageMetric(lib, this.agent.metrics)
+      this.libMetricCreated = true
+    }
+  }
+
+  decorateLogLine() {
+    if (isLocalDecoratingEnabled(this.config)) {
+      return this.agent.getNRLinkingMetadata()
+    }
+  }
+
+  incrementLinesMetric(level) {
+    if (isMetricsEnabled(this.config)) {
+      incrementLoggingLinesMetrics(level, this.agent.metrics)
+    }
+  }
+
+  forwardLogLine(data) {
+    if (isLogForwardingEnabled(this.config, this.agent)) {
+      const ctx = this.agent.tracer.getContext()
+      const formatLogLine = this.reformatLogLine(data, ctx)
+      this.agent.logs.add(formatLogLine)
+    }
+  }
+}
+
+module.exports = ApplicationLogsSubscriber

package/lib/subscribers/base.js

@@ -0,0 +1,177 @@
+/*
+ * 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 { tracingChannel } = 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 npm installable name for the package
+ * 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 {object} agent A New Relic Node.js agent instance.
+ * @property {object} logger An agent logger instance.
+ * @property {object} config The agent configuration object.
+ * @property {string} packageName The name of the module being instrumented.
+ * This is the same string one would pass to the `require` function.
+ * @property {string} channelName A unique name for the diagnostics channel
+ * that will be registered.
+ * @property {string[]} [events=[]] Set of tracing channel event names to
+ * register handlers for. For any name in the set, a corresponding method
+ * must exist on the subscriber instance. The method will be passed the
+ * event object. Possible event names are `start`, `end`, `asyncStart`,
+ * `asyncEnd`, and `error`. @link https://nodejs.org/api/diagnostics_channel.html#class-tracingchannel
+ * @property {boolean} [opaque=false] If true, any children segments will not be created
+ * @property {boolean} [internal=false] If true, any children segments from the same library will not be created
+ * @property {string} [prefix='orchestrion:'] String to prepend to diagnostics
+ * 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 {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.
+ */
+class Subscriber {
+  constructor({ agent, logger, packageName, channelName }) {
+    this.agent = agent
+    this.logger = logger.child({ component: `${packageName}-subscriber` })
+    this.config = agent.config
+    this.packageName = packageName
+    this.channelName = channelName
+    this.events = []
+    this.opaque = false
+    this.internal = false
+    this.prefix = 'orchestrion:'
+    this.requireActiveTx = true
+    this.id = `${this.prefix}${this.packageName}:${this.channelName}`
+    this.channel = tracingChannel(this.id)
+    this.store = agent.tracer._contextManager._asyncLocalStorage
+  }
+
+  shouldCreateSegment(parent) {
+    return !(parent?.opaque ||
+    (this.internal && this.packageName === parent?.shimId)
+    )
+  }
+
+  /**
+   * 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 {string} params.name - The name of 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
+   */
+  createSegment({ name, recorder, ctx }) {
+    const parent = ctx?.segment
+
+    if (this.shouldCreateSegment(parent) === false) {
+      this.logger.trace('Skipping segment creation for %s, %s(parent) is of the same package: %s and incoming segment is marked as internal', name, parent?.name, this.packageName)
+      return ctx
+    }
+
+    const segment = this.agent.tracer.createSegment({
+      name,
+      parent,
+      recorder,
+      transaction: ctx?.transaction,
+    })
+
+    if (segment) {
+      segment.opaque = this.opaque
+      segment.shimId = this.packageName
+      segment.start()
+      this.logger.trace('Created segment %s', name)
+      this.addAttributes(segment)
+      const newCtx = ctx.enterSegment({ segment })
+      return newCtx
+    } else {
+      this.logger.trace('Failed to create segment for %s', name)
+      return ctx
+    }
+  }
+
+  /**
+   * By default this is a no-op, but can be overridden by subclasses
+   * @param {Segment} segment - The segment to which attributes will be added
+   * @returns {void}
+   */
+  addAttributes(segment) {
+
+  }
+
+  /**
+   * Checks if the subscriber is enabled based on the agent's configuration.
+   */
+  get enabled() {
+    return this.config.instrumentation[this.packageName].enabled === true
+  }
+
+  /**
+   * 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
+   */
+  enable() {
+    this.channel.start.bindStore(this.store, (data) => {
+      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)
+        return ctx
+      }
+
+      return this.handler(data, ctx)
+    })
+  }
+
+  /**
+   * Disables the subscriber by unbinding the store from the channel.
+   */
+  disable() {
+    this.channel.start.unbindStore(this.store)
+  }
+
+  /**
+   * Common handler for when async events end.
+   * It gets the context and touches the segment if it exists.
+   */
+  asyncEnd() {
+    const ctx = this.agent.tracer.getContext()
+    ctx?.segment?.touch()
+  }
+
+  /*
+   * Subscribes to the events defined in the `events` array.
+   */
+  subscribe() {
+    this.subscriptions = this.events.reduce((events, curr) => {
+      events[curr] = this[curr].bind(this)
+      return events
+    }, {})
+
+    this.channel.subscribe(this.subscriptions)
+  }
+
+  /**
+   * Unsubscribes from the events defined in the `events` array..
+   */
+  unsubscribe() {
+    this.channel.unsubscribe(this.subscriptions)
+    this.subscriptions = null
+  }
+}
+
+module.exports = Subscriber

package/lib/subscribers/create-config.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+/**
+ * Builds a set of packages and instrumentaions 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.
+ */
+function createSubscribersConfig (subscribers = []) {
+  const packages = new Set()
+  const instrumentations = []
+  for (const [packageName, subscriberList] of Object.entries(subscribers)) {
+    packages.add(packageName)
+    for (const subscriber of subscriberList) {
+      instrumentations.push(...subscriber.instrumentations)
+    }
+  }
+
+  return { packages, instrumentations }
+}
+
+module.exports = createSubscribersConfig

package/lib/subscribers/db-operation.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const DbSubscriber = require('./db')
+const recordOperationMetrics = require('../metrics/recorders/database-operation')
+const { DB } = require('../metrics/names')
+
+class DbOperationSubscriber extends DbSubscriber {
+  handler(data, ctx) {
+    const name = `${DB.OPERATION}/${this.system}/${this.operation}`
+    return this.createSegment({
+      name,
+      ctx,
+      recorder: recordOperationMetrics.bind(this),
+    })
+  }
+}
+
+module.exports = DbOperationSubscriber

package/lib/subscribers/db-query.js

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const DbSubscriber = require('./db')
+const recordQueryMetrics = require('../metrics/recorders/database')
+const { DB } = require('../metrics/names')
+const ParsedStatement = require('../db/parsed-statement')
+const parseSql = require('../db/query-parsers/sql')
+
+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}`
+    return this.createSegment({
+      name,
+      ctx,
+      recorder: recordQueryMetrics.bind(parsed),
+    })
+  }
+
+  parseQueryString(queryString) {
+    const parsed = this.parseQuery(queryString)
+    let collection = parsed.collection
+    // strip enclosing special characters from collection (table) name
+    if (typeof collection === 'string' && collection.length > 2) {
+      if (/^[[{'"`]/.test(collection)) {
+        collection = collection.substring(1)
+      }
+      if (/[\]}'"`]$/.test(collection)) {
+        collection = collection.substring(0, collection.length - 1)
+      }
+    }
+
+    const queryRecorded =
+      this.config.transaction_tracer.record_sql === 'raw' ||
+      this.config.transaction_tracer.record_sql === 'obfuscated'
+
+    return new ParsedStatement(
+      this._metrics.PREFIX,
+      parsed.operation,
+      collection,
+      queryRecorded ? parsed.query : null
+    )
+  }
+
+  parseQuery(queryString) {
+    return parseSql(queryString)
+  }
+}
+
+module.exports = DbQuerySubscriber

package/lib/subscribers/db.js

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const Subscriber = require('./base')
+const { ALL, DB } = require('../metrics/names')
+const urltils = require('../util/urltils')
+
+class DbSubscriber extends Subscriber {
+  constructor({ agent, logger, packageName, channelName, system }) {
+    super({ agent, logger, packageName, channelName })
+    this.system = system
+    // must be prefixed with `_` as that's what the metrics recorder expects
+    this._metrics = {
+      PREFIX: this.system,
+      ALL: `${DB.PREFIX}${this.system}/${ALL}`
+    }
+    this.instanceKeys = ['host', 'port_path_or_id']
+    this.hostKey = 'host'
+    this.dbNameKey = 'database_name'
+  }
+
+  get instanceReporting() {
+    return this.config.datastore_tracer.instance_reporting.enabled
+  }
+
+  get dbNameReporting() {
+    return this.config.datastore_tracer.database_name_reporting.enabled
+  }
+
+  addAttributes(segment) {
+    for (let [key, value] of Object.entries(this.parameters)) {
+      if (this.instanceKeys.includes(key) && !this.instanceReporting) {
+        continue
+      }
+
+      if (key === this.dbNameKey && !this.dbNameReporting) {
+        continue
+      }
+
+      if (key === this.hostKey && urltils.isLocalhost(value)) {
+        // eslint-disable-next-line sonarjs/updated-loop-counter
+        value = this.config.getHostnameSafe()
+      }
+
+      if (key === this.dbNameKey && typeof value === 'number') {
+        // eslint-disable-next-line sonarjs/updated-loop-counter
+        value = String(value)
+      }
+
+      segment.addAttribute(key, value)
+    }
+  }
+}
+
+module.exports = DbSubscriber

package/lib/subscribers/elasticsearch/config.js

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+module.exports = {
+  '@elastic/elasticsearch': [{
+    path: './elasticsearch/elasticsearch.js',
+    instrumentations: [
+      {
+        channelName: 'nr_request',
+        module: { name: '@elastic/elasticsearch', versionRange: '>=7.16.0', filePath: 'lib/Transport.js' },
+        functionQuery: {
+          className: 'Transport',
+          methodName: 'request',
+          kind: 'Async'
+        }
+      }
+    ]
+  }],
+  '@elastic/transport': [{
+    path: './elasticsearch/transport.js',
+    instrumentations: [
+      {
+        channelName: 'nr_request',
+        module: { name: '@elastic/transport', versionRange: '>=8.0.0', filePath: 'lib/Transport.js' },
+        functionQuery: {
+          className: 'Transport',
+          methodName: 'request',
+          kind: 'Async'
+        }
+      }
+    ]
+  }],
+  '@opensearch-project/opensearch': [{
+    path: './elasticsearch/opensearch.js',
+    instrumentations: [
+      {
+        channelName: 'nr_request',
+        module: { name: '@opensearch-project/opensearch', versionRange: '>=2.1.0', filePath: 'lib/Transport.js' },
+        functionQuery: {
+          className: 'Transport',
+          methodName: 'request',
+          kind: 'Async'
+        }
+      }
+    ]
+  }]
+}

package/lib/subscribers/elasticsearch/elasticsearch.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const DbQuerySubscriber = require('../db-query')
+const stringify = require('json-stringify-safe')
+const { queryParser } = require('../../db/query-parsers/elasticsearch')
+
+class ElasticSearchSubscriber extends DbQuerySubscriber {
+  constructor({ agent, logger, packageName = '@elastic/elasticsearch', channelName = 'nr_request', system = 'ElasticSearch' } = {}) {
+    super({ agent, logger, packageName, channelName, system })
+    this.events = ['asyncEnd']
+    this.opaque = true
+  }
+
+  handler(data, ctx) {
+    const { self, arguments: args } = data
+    this.queryString = stringify(args?.[0])
+    this.setParameters(self)
+    return super.handler(data, ctx)
+  }
+
+  setParameters(self) {
+    this.parameters = {}
+    this.parameters.product = this.system
+    const connectionPool = self?.connectionPool?.connections?.[0]
+    if (connectionPool) {
+      const host = connectionPool?.url?.host?.split(':')
+      const port = connectionPool?.url?.port || host?.[1]
+      this.parameters.host = host?.[0]
+      this.parameters.port_path_or_id = port
+    }
+  }
+
+  parseQuery(queryString) {
+    return queryParser(queryString)
+  }
+}
+
+module.exports = ElasticSearchSubscriber

package/lib/subscribers/elasticsearch/opensearch.js

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const ElasticSearchSubscriber = require('./elasticsearch.js')
+class OpenSearchSubscriber extends ElasticSearchSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: '@opensearch-project/opensearch', channelName: 'nr_request', system: 'OpenSearch' })
+  }
+}
+
+module.exports = OpenSearchSubscriber

package/lib/subscribers/elasticsearch/transport.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const ElasticSearchSubscriber = require('./elasticsearch')
+
+class ElasticSearchTransportSubscriber extends ElasticSearchSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: '@elastic/transport' })
+  }
+}
+
+module.exports = ElasticSearchTransportSubscriber

package/lib/subscribers/ioredis/config.js

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+module.exports = {
+  ioredis: [{
+    path: './ioredis',
+    instrumentations: [
+      {
+        channelName: 'nr_sendCommand',
+        module: { name: 'ioredis', versionRange: '>=4', filePath: 'built/Redis.js' },
+        functionQuery: {
+          className: 'Redis',
+          methodName: 'sendCommand',
+          kind: 'Async'
+        }
+      },
+      {
+        channelName: 'nr_sendCommand',
+        module: { name: 'ioredis', versionRange: '>=4', filePath: 'built/redis.js' },
+        functionQuery: {
+          expressionName: 'sendCommand',
+          kind: 'Async'
+        }
+      },
+      {
+        channelName: 'nr_sendCommand',
+        module: { name: 'ioredis', versionRange: '>=4', filePath: 'built/redis/index.js' },
+        functionQuery: {
+          expressionName: 'sendCommand',
+          kind: 'Async'
+        }
+      }
+    ]
+  }]
+}

package/lib/subscribers/ioredis/index.js

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const DbOperationSubscriber = require('../db-operation')
+const stringify = require('json-stringify-safe')
+
+class IoRedisSubscriber extends DbOperationSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: 'ioredis', channelName: 'nr_sendCommand', system: 'Redis' })
+    this.events = ['asyncEnd']
+  }
+
+  handler(data, ctx) {
+    const { self, arguments: args } = data
+    const [command] = args
+    this.operation = command.name
+    this.setParameters(self, command)
+    return super.handler(data, ctx)
+  }
+
+  setParameters(self, command) {
+    this.parameters = {}
+    this.parameters.product = this.system
+    this.parameters.host = self?.connector?.options?.host
+    this.parameters.port_path_or_id = self?.connector?.options?.port
+    this.parameters.key = this.parseKey(command.args)
+    this.parameters.database_name = self?.condition?.select
+  }
+
+  parseKey(keys) {
+    let key
+    if (keys && typeof keys !== 'function') {
+      try {
+        key = stringify(keys[0])
+      } catch (err) {
+        this.logger.debug(err, 'Failed to stringify ioredis key')
+        key = '<unknown>'
+      }
+    }
+
+    return key
+  }
+}
+
+module.exports = IoRedisSubscriber

package/lib/subscribers/mcp-sdk/client-prompt.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const McpClientSubscriber = require('./client')
+const { MCP } = require('../../metrics/names')
+
+class McpClientPromptSubscriber extends McpClientSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, channelName: 'nr_getPrompt' })
+  }
+
+  handler(data, ctx) {
+    const promptName = data?.arguments?.[0]?.name
+    this.segmentName = `${MCP.PROMPT}/getPrompt/${promptName}`
+    return super.handler(ctx)
+  }
+}
+
+module.exports = McpClientPromptSubscriber

package/lib/subscribers/mcp-sdk/client-resource.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const McpClientSubscriber = require('./client')
+const { MCP } = require('../../metrics/names')
+
+class McpClientResourceSubscriber extends McpClientSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, channelName: 'nr_readResource' })
+  }
+
+  handler(data, ctx) {
+    const uri = data?.arguments?.[0]?.uri
+    const scheme = typeof uri === 'string' ? uri.split('://')[0] : undefined
+    this.segmentName = `${MCP.RESOURCE}/readResource/${scheme}`
+    return super.handler(ctx)
+  }
+}
+
+module.exports = McpClientResourceSubscriber

package/lib/subscribers/mcp-sdk/client-tool.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const McpClientSubscriber = require('./client')
+const { MCP } = require('../../metrics/names')
+
+class McpClientToolSubscriber extends McpClientSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, channelName: 'nr_callTool' })
+  }
+
+  handler(data, ctx) {
+    const toolName = data?.arguments?.[0]?.name
+    this.segmentName = `${MCP.TOOL}/callTool/${toolName}`
+    return super.handler(ctx)
+  }
+}
+
+module.exports = McpClientToolSubscriber