newrelic 13.1.0 → 13.2.0

package/lib/patch-module.js

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const { create } = require('@apm-js-collab/code-transformer')
+const Module = require('node:module')
+const parse = require('module-details-from-path')
+const getPackageVersion = require('./util/get-package-version')
+const logger = require('./logger').child({ component: 'ModulePatch' })
+
+class ModulePatch {
+  constructor({ packages = new Set(), instrumentations = [] } = {}) {
+    this.packages = packages
+    this.instrumentator = create(instrumentations)
+    this.transformers = new Map()
+    this.resolve = Module._resolveFilename
+    this.compile = Module.prototype._compile
+  }
+
+  /**
+   * Patches the Node.js module class methods that are responsible for resolving filePaths and compiling code.
+   * If a module is found that has an instrumentator, it will transform the code before compiling it
+   * with tracing channel methods.
+   */
+  patch() {
+    const self = this
+    Module._resolveFilename = function wrappedResolveFileName() {
+      const resolvedName = self.resolve.apply(this, arguments)
+      const resolvedModule = parse(resolvedName)
+      if (resolvedModule && self.packages.has(resolvedModule.name)) {
+        const version = getPackageVersion(resolvedModule.basedir, resolvedModule.name)
+        const transformer = self.instrumentator.getTransformer(resolvedModule.name, version, resolvedModule.path)
+        if (transformer) {
+          self.transformers.set(resolvedName, transformer)
+        }
+      }
+      return resolvedName
+    }
+
+    Module.prototype._compile = function wrappedCompile(...args) {
+      const [content, filename] = args
+      if (self.transformers.has(filename)) {
+        const transformer = self.transformers.get(filename)
+        try {
+          const transformedCode = transformer.transform(content, 'unknown')
+          args[0] = transformedCode
+        } catch (error) {
+          logger.error({ error }, `Error transforming module ${filename}`)
+        } finally {
+          transformer.free()
+        }
+      }
+
+      return self.compile.apply(this, args)
+    }
+  }
+
+  /**
+   * Clears all the transformers and restores the original Module methods that were wrapped.
+   * **Note**: This is intended to be used in testing only.
+   */
+  unpatch() {
+    this.transformers.clear()
+    Module._resolveFilename = this.resolve
+    Module.prototype._compile = this.compile
+  }
+}
+
+module.exports = ModulePatch

package/lib/serverless/aws-lambda.js

@@ -54,9 +54,7 @@ class AwsLambda {
   }
 
   _detectEventType(event) {
-    const pathMatch = (obj, path) => {
-      return get(obj, path, null) !== null
-    }
+    const pathMatch = (obj, path) => get(obj, path, null) !== null
 
     for (const typeInfo of Object.values(EVENT_SOURCE_INFO)) {
       if (typeInfo.required_keys.every((path) => pathMatch(event, path))) {

package/lib/shim/webframework-shim/middleware-mounter.js

@@ -34,9 +34,7 @@ function wrapMounter(spec, shim, fn, fnName) {
         routeIdx = null
         route = null
       } else if (shim.isArray(route)) {
-        route = route.map((routeArg) => {
-          return shim._routeParser.call(this, shim, fn, fnName, routeArg)
-        })
+        route = route.map((routeArg) => shim._routeParser.call(this, shim, fn, fnName, routeArg))
       } else {
         route = shim._routeParser.call(this, shim, fn, fnName, route)
       }

package/lib/shimmer.js

@@ -23,7 +23,9 @@ let pkgsToHook = []
 const NAMES = require('./metrics/names')
 const symbols = require('./symbols')
 const { unsubscribe } = require('./instrumentation/undici')
-const { setupOtel, teardownOtel } = require('./otel/setup')
+const subscriptions = require('./subscriber-configs')
+const createSubscriberConfigs = require('./subscribers/create-config')
+const ModulePatch = require('./patch-module')
 
 /**
  * Unwrapping is only likely to be used by test code, and is a fairly drastic
@@ -329,14 +331,32 @@ const shimmer = (module.exports = {
     }
 
     pkgsToHook = []
-    teardownOtel(agent)
+    if (agent?.config?.opentelemetry_bridge?.enabled === true) {
+      // We must lazy load the method in order to support stripping of the
+      // `@opentelemetry` packages for slim builds.
+      require('./otel/setup').teardownOtel(agent)
+    }
     unsubscribe()
+    if (this._subscribers) {
+      shimmer.teardownSubscribers()
+    }
+    if (this._modulePatch) {
+      this._modulePatch.unpatch()
+    }
   },
 
   bootstrapInstrumentation: function bootstrapInstrumentation(agent) {
+    const subscriberConfigs = createSubscriberConfigs(subscriptions)
+    this._modulePatch = new ModulePatch(subscriberConfigs)
+    this._modulePatch.patch()
     shimmer.registerCoreInstrumentation(agent)
     shimmer.registerThirdPartyInstrumentation(agent)
-    setupOtel(agent)
+    shimmer.setupSubscribers(agent)
+    if (agent?.config?.opentelemetry_bridge?.enabled === true) {
+      // We must lazy load the method in order to support stripping of the
+      // `@opentelemetry` packages for slim builds.
+      require('./otel/setup').setupOtel(agent)
+    }
   },
 
   registerInstrumentation: function registerInstrumentation(opts) {
@@ -371,6 +391,35 @@ const shimmer = (module.exports = {
 
   registeredInstrumentations: new InstrumentationTracker(),
 
+  setupSubscribers: function setupSubscribers(agent) {
+    this._subscribers = {}
+    for (const subscriberConfigList of Object.values(subscriptions)) {
+      for (const subscriberConfig of subscriberConfigList) {
+        const Subscriber = require(`./subscribers/${subscriberConfig.path}`)
+        const subscriber = new Subscriber({ agent, logger })
+        if (subscriber.enabled === false) {
+          logger.debug(
+            'Skipping subscriber %s because it is disabled in the config',
+            subscriber.id
+          )
+          continue
+        }
+
+        subscriber.enable()
+        subscriber.subscribe()
+        this._subscribers[subscriber.id] = subscriber
+      }
+    }
+  },
+
+  teardownSubscribers: function teardownSubscribers() {
+    for (const subscriber of Object.values(this._subscribers)) {
+      subscriber.disable()
+      subscriber.unsubscribe()
+    }
+    this._subscribers = {}
+  },
+
   /**
    * NOT FOR USE IN PRODUCTION CODE
    *
@@ -432,8 +481,7 @@ const shimmer = (module.exports = {
   isInstrumented(moduleName, resolvedName) {
     const allItems = shimmer.registeredInstrumentations.getAllByName(moduleName)
     const items = allItems.filter(
-      (item) =>
-        item.instrumentation.resolvedName === resolvedName && item.meta.instrumented === true
+      (item) => item.instrumentation.resolvedName === resolvedName && item.meta.instrumented === true
     )
     return items.length === allItems.length
   },
@@ -669,12 +717,12 @@ function _firstPartyInstrumentation(agent, fileName, shim, nodule, moduleName) {
  * to load the module), as well as the `onRequire` and `onError` hooks to
  * attach to the module.
  *
- * @param {object} agent
+ * @param {object} agent agent instance
  * @param {object} nodule The newly loaded module.
  * @param {string} name The simple name used to load the module.
  * @param {string} resolvedName The full file system path to the module.
- * @param {object} [esmResolver]
- * @returns {*|Object|undefined}
+ * @param {object} [esmResolver] If the module was loaded via ESM
+ * @returns {*|Object|undefined} The instrumented module, or the original
  * @private
  */
 function _postLoad(agent, nodule, name, resolvedName, esmResolver) {

package/lib/subscriber-configs.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+// The expected export of these files is:
+// 'package-name': [ { path: 'subscriberPath', instrumentations: [] }, ... ]
+const subscribers = {
+  ...require('./subscribers/elasticsearch/config'),
+  ...require('./subscribers/ioredis/config'),
+  ...require('./subscribers/mcp-sdk/config'),
+  ...require('./subscribers/pino/config'),
+}
+
+module.exports = subscribers

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'
+        }
+      }
+    ]
+  }]
+}