dd-trace 5.96.0 → 5.98.0

package/packages/datadog-instrumentations/src/helpers/hook.js

@@ -1,17 +1,41 @@
 'use strict'
+
 const path = require('path')
+
 const iitm = require('../../../dd-trace/src/iitm')
 const ritm = require('../../../dd-trace/src/ritm')
+const log = require('../../../dd-trace/src/log')
+const requirePackageJson = require('../../../dd-trace/src/require-package-json')
+
+/**
+ * @param {string} moduleBaseDir
+ * @returns {string|undefined}
+ */
+function getVersion (moduleBaseDir) {
+  if (moduleBaseDir) {
+    return requirePackageJson(moduleBaseDir, /** @type {import('module').Module} */ (module)).version
+  }
+
+  return process.version
+}
 
 /**
  * This is called for every package/internal-module that dd-trace supports instrumentation for
  * In practice, `modules` is always an array with a single entry.
  *
+ * @overload
+ * @param {string[]} modules list of modules to hook into
+ * @param {object} hookOptions hook options
+ * @param {Function} onrequire callback to be executed upon encountering module
+ */
+/**
+ * @overload
  * @param {string[]} modules list of modules to hook into
  * @param {object} hookOptions hook options
  * @param {Function} onrequire callback to be executed upon encountering module
  */
 function Hook (modules, hookOptions, onrequire) {
+  // TODO: Rewrite this to use class syntax. The same should be done for ritm.
   if (!(this instanceof Hook)) return new Hook(modules, hookOptions, onrequire)
 
   if (typeof hookOptions === 'function') {
@@ -42,6 +66,13 @@ function Hook (modules, hookOptions, onrequire) {
       return result
     }
 
+    try {
+      moduleVersion ||= getVersion(moduleBaseDir)
+    } catch (error) {
+      log.error('Error getting version for "%s": %s', moduleName, error.message, error)
+      return
+    }
+
     if (
       isIitm &&
       moduleExports.default &&
@@ -66,10 +97,4 @@ function Hook (modules, hookOptions, onrequire) {
   })
 }
 
-Hook.prototype.unhook = function () {
-  this._ritmHook.unhook()
-  this._iitmHook.unhook()
-  this._patched = Object.create(null)
-}
-
 module.exports = Hook

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -1,6 +1,18 @@
 'use strict'
 
 module.exports = {
+  // Only list unprefixed node modules. They will automatically be instrumented as prefixed and unprefixed.
+  child_process: () => require('../child_process'),
+  crypto: () => require('../crypto'),
+  dns: () => require('../dns'),
+  fs: { serverless: false, fn: () => require('../fs') },
+  http: () => require('../http'),
+  http2: () => require('../http2'),
+  https: () => require('../http'),
+  net: () => require('../net'),
+  url: () => require('../url'),
+  vm: () => require('../vm'),
+  // Non Node.js modules
   '@anthropic-ai/sdk': { esmFirst: true, fn: () => require('../anthropic') },
   '@apollo/server': () => require('../apollo-server'),
   '@apollo/gateway': () => require('../apollo'),
@@ -47,31 +59,24 @@ module.exports = {
   bullmq: () => require('../bullmq'),
   bunyan: () => require('../bunyan'),
   'cassandra-driver': () => require('../cassandra-driver'),
-  child_process: () => require('../child_process'),
   connect: () => require('../connect'),
   cookie: () => require('../cookie'),
   'cookie-parser': () => require('../cookie-parser'),
   couchbase: () => require('../couchbase'),
-  crypto: () => require('../crypto'),
   cypress: () => require('../cypress'),
   'dd-trace-api': () => require('../dd-trace-api'),
-  dns: () => require('../dns'),
   elasticsearch: () => require('../elasticsearch'),
   express: () => require('../express'),
   'express-mongo-sanitize': () => require('../express-mongo-sanitize'),
   'express-session': () => require('../express-session'),
   fastify: () => require('../fastify'),
   'find-my-way': () => require('../find-my-way'),
-  fs: { serverless: false, fn: () => require('../fs') },
   'generic-pool': () => require('../generic-pool'),
   graphql: () => require('../graphql'),
   grpc: () => require('../grpc'),
   handlebars: () => require('../handlebars'),
   hapi: () => require('../hapi'),
   hono: { esmFirst: true, fn: () => require('../hono') },
-  http: () => require('../http'),
-  http2: () => require('../http2'),
-  https: () => require('../http'),
   ioredis: () => require('../ioredis'),
   iovalkey: () => require('../iovalkey'),
   'jest-circus': () => require('../jest'),
@@ -103,18 +108,8 @@ module.exports = {
   multer: () => require('../multer'),
   mysql: () => require('../mysql'),
   mysql2: () => require('../mysql2'),
-  net: () => require('../net'),
   next: () => require('../next'),
   'node-serialize': () => require('../node-serialize'),
-  'node:child_process': () => require('../child_process'),
-  'node:crypto': () => require('../crypto'),
-  'node:dns': () => require('../dns'),
-  'node:http': () => require('../http'),
-  'node:http2': () => require('../http2'),
-  'node:https': () => require('../http'),
-  'node:net': () => require('../net'),
-  'node:url': () => require('../url'),
-  'node:vm': () => require('../vm'),
   nyc: () => require('../nyc'),
   oracledb: () => require('../oracledb'),
   openai: { esmFirst: true, fn: () => require('../openai') },
@@ -142,9 +137,7 @@ module.exports = {
   tedious: () => require('../tedious'),
   tinypool: { esmFirst: true, fn: () => require('../vitest') },
   undici: () => require('../undici'),
-  url: () => require('../url'),
   vitest: { esmFirst: true, fn: () => require('../vitest') },
-  vm: () => require('../vm'),
   when: () => require('../when'),
   winston: () => require('../winston'),
   workerpool: () => require('../mocha'),

package/packages/datadog-instrumentations/src/helpers/instrument.js

@@ -1,11 +1,23 @@
 'use strict'
 
 const { AsyncResource } = require('async_hooks')
-const dc = require('dc-polyfill')
+const dc = /** @type {typeof import('node:diagnostics_channel')} */ (require('dc-polyfill'))
 const instrumentations = require('./instrumentations')
 const rewriterInstrumentations = require('./rewriter/instrumentations')
 
+/**
+ * @typedef {import('node:diagnostics_channel').Channel} Channel
+ * @typedef {import('node:diagnostics_channel').TracingChannel} TracingChannel
+ */
+
+/**
+ * @type {Record<string, Channel>}
+ */
 const channelMap = {}
+/**
+ * @param {string} name
+ * @returns {Channel}
+ */
 exports.channel = function (name) {
   const maybe = channelMap[name]
   if (maybe) return maybe
@@ -14,7 +26,14 @@ exports.channel = function (name) {
   return ch
 }
 
+/**
+ * @type {Record<string, TracingChannel>}
+ */
 const tracingChannelMap = {}
+/**
+ * @param {string} name
+ * @returns {TracingChannel}
+ */
 exports.tracingChannel = function (name) {
   const maybe = tracingChannelMap[name]
   if (maybe) return maybe
@@ -34,24 +53,19 @@ exports.getHooks = function getHooks (names) {
 
 /**
  * @param {object} args
- * @param {string|string[]} args.name module name
- * @param {string[]} args.versions array of semver range strings
+ * @param {string} args.name module name
+ * @param {string[]} [args.versions] array of semver range strings
  * @param {string} [args.file='index.js'] path to file within package to instrument
  * @param {string} [args.filePattern] pattern to match files within package to instrument
- * @param {boolean} [args.patchDefault] whether to patch the default export
- * @param {(moduleExports: unknown, version: string) => unknown} hook
+ * @param {boolean} [args.patchDefault=true] whether to patch the default export
+ * @param {(moduleExports: unknown, version: string, isIitm?: boolean) => unknown} [hook] Patches module exports
  */
 exports.addHook = function addHook ({ name, versions, file, filePattern, patchDefault }, hook) {
-  if (typeof name === 'string') {
-    name = [name]
+  if (!instrumentations[name]) {
+    instrumentations[name] = []
   }
 
-  for (const val of name) {
-    if (!instrumentations[val]) {
-      instrumentations[val] = []
-    }
-    instrumentations[val].push({ name: val, versions, file, filePattern, hook, patchDefault })
-  }
+  instrumentations[name].push({ versions, file, filePattern, hook, patchDefault })
 }
 
 exports.AsyncResource = AsyncResource

package/packages/datadog-instrumentations/src/helpers/register.js

@@ -1,9 +1,9 @@
 'use strict'
 
+const { builtinModules } = require('module')
 const path = require('path')
 const { channel } = require('dc-polyfill')
 const satisfies = require('../../../../vendor/dist/semifies')
-const requirePackageJson = require('../../../dd-trace/src/require-package-json')
 const log = require('../../../dd-trace/src/log')
 const telemetry = require('../../../dd-trace/src/guardrails/telemetry')
 const { IS_SERVERLESS } = require('../../../dd-trace/src/serverless')
@@ -36,27 +36,47 @@ if (!disabledInstrumentations.has('process')) {
   require('../process')
 }
 
-const HOOK_SYMBOL = Symbol('hookExportsSet')
-
 if (DD_TRACE_DEBUG && DD_TRACE_DEBUG.toLowerCase() !== 'false') {
   checkRequireCache.checkForRequiredModules()
   setImmediate(checkRequireCache.checkForPotentialConflicts)
 }
 
-const seenCombo = new Set()
-const allInstrumentations = {}
-
 for (const inst of disabledInstrumentations) {
   rewriter.disable(inst)
 }
 
-// TODO: make this more efficient
-for (const packageName of names) {
-  if (disabledInstrumentations.has(packageName)) continue
+/** @type {Map<string, object>} */
+const instrumentedNodeModules = new Map()
+/** @type {Map<string, boolean>} */
+const instrumentedIntegrationsSuccess = new Map()
+/** @type {Set<string>} */
+const alreadyLoggedIncompatibleIntegrations = new Set()
+
+// Always disable prefixed and unprefixed node modules if one is disabled.
+if (disabledInstrumentations.size) {
+  const builtinsSet = new Set(builtinModules)
+  for (const name of disabledInstrumentations) {
+    const hasPrefix = name.startsWith('node:')
+    if (hasPrefix || builtinsSet.has(name)) {
+      if (hasPrefix) {
+        const unprefixedName = name.slice(5)
+        if (!disabledInstrumentations.has(unprefixedName)) {
+          disabledInstrumentations.add(unprefixedName)
+        }
+      } else if (!disabledInstrumentations.has(`node:${name}`)) {
+        disabledInstrumentations.add(`node:${name}`)
+      }
+    }
+  }
+  builtinsSet.clear()
+}
+
+for (const name of names) {
+  if (disabledInstrumentations.has(name)) continue
 
   const hookOptions = {}
 
-  let hook = hooks[packageName]
+  let hook = hooks[name]
 
   if (hook !== null && typeof hook === 'object') {
     if (hook.serverless === false && IS_SERVERLESS) continue
@@ -65,173 +85,114 @@ for (const packageName of names) {
     hook = hook.fn
   }
 
-  // get the instrumentation file name to save all hooked versions
-  const instrumentationFileName = parseHookInstrumentationFileName(packageName)
-
-  Hook([packageName], hookOptions, (moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm) => {
-    moduleName = moduleName.replace(pathSepExpr, '/')
+  Hook([name], hookOptions, (moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm) => {
+    // All loaded versions are first expected to fail instrumentation.
+    if (!instrumentedIntegrationsSuccess.has(`${name}@${moduleVersion}`)) {
+      instrumentedIntegrationsSuccess.set(`${name}@${moduleVersion}`, false)
+    }
 
     // This executes the integration file thus adding its entries to `instrumentations`
     hook()
 
-    if (!instrumentations[packageName]) {
+    if (!instrumentations[name] || moduleExports === instrumentedNodeModules.get(name)) {
       return moduleExports
     }
 
-    const namesAndSuccesses = {}
-    for (const { name, file, versions, hook, filePattern, patchDefault } of instrumentations[packageName]) {
-      if (patchDefault === false && !moduleExports.default && isIitm) {
-        return moduleExports
-      } else if (patchDefault === true && moduleExports.default && isIitm) {
-        moduleExports = moduleExports.default
+    // Used for node: prefixed modules to prevent double instrumentation.
+    if (moduleBaseDir) {
+      moduleName = moduleName.replace(pathSepExpr, '/')
+    } else {
+      instrumentedNodeModules.set(name, moduleExports)
+    }
+
+    for (const { file, versions, hook, filePattern, patchDefault } of instrumentations[name]) {
+      if (isIitm && patchDefault === !!moduleExports.default) {
+        if (patchDefault) {
+          moduleExports = moduleExports.default
+        } else {
+          return moduleExports
+        }
       }
 
-      let fullFilePattern = filePattern
       const fullFilename = filename(name, file)
-      if (fullFilePattern) {
-        fullFilePattern = filename(name, fullFilePattern)
-      }
 
-      // Create a WeakSet associated with the hook function so that patches on the same moduleExport only happens once
-      // for example by instrumenting both dns and node:dns double the spans would be created
-      // since they both patch the same moduleExport, this WeakSet is used to mitigate that
-      // TODO(BridgeAR): Instead of using a WeakSet here, why not just use aliases for the hook in register?
-      // That way it would also not be duplicated. The actual name being used has to be identified else wise.
-      // Maybe it is also not important to know what name was actually used?
-      hook[HOOK_SYMBOL] ??= new WeakSet()
       let matchesFile = moduleName === fullFilename
 
       if (!matchesFile && isRelativeRequire(name)) matchesFile = true
 
+      const fullFilePattern = filePattern && filename(name, filePattern)
       if (fullFilePattern) {
         // Some libraries include a hash in their filenames when installed,
         // so our instrumentation has to include a '.*' to match them for more than a single version.
-        matchesFile = matchesFile || new RegExp(fullFilePattern).test(moduleName)
+        matchesFile ||= new RegExp(fullFilePattern).test(moduleName)
       }
 
-      if (matchesFile) {
-        let version = moduleVersion
+      if (matchesFile && matchVersion(moduleVersion, versions)) {
+        // Do not log in case of an error to prevent duplicate telemetry for the same integration version.
+        instrumentedIntegrationsSuccess.set(`${name}@${moduleVersion}`, true)
         try {
-          version = version || getVersion(moduleBaseDir)
-          allInstrumentations[instrumentationFileName] = allInstrumentations[instrumentationFileName] || false
-        } catch (e) {
-          log.error('Error getting version for "%s": %s', name, e.message, e)
-          continue
-        }
-        if (namesAndSuccesses[`${name}@${version}`] === undefined && !file) {
-          // TODO If `file` is present, we might elsewhere instrument the result of the module
-          // for a version range that actually matches, so we can't assume that we're _not_
-          // going to instrument that. However, the way the data model around instrumentation
-          // works, we can't know either way just yet, so to avoid false positives, we'll just
-          // ignore this if there is a `file` in the hook. The thing to do here is rework
-          // everything so that we can be sure that there are _no_ instrumentations that it
-          // could match.
-          namesAndSuccesses[`${name}@${version}`] = false
-        }
-
-        if (matchVersion(version, versions)) {
-          allInstrumentations[instrumentationFileName] = true
-
-          // Check if the hook already has a set moduleExport
-          if (hook[HOOK_SYMBOL].has(moduleExports)) {
-            namesAndSuccesses[`${name}@${version}`] = true
-            return moduleExports
-          }
-
-          try {
-            loadChannel.publish({ name, version, file })
-            // Send the name and version of the module back to the callback because now addHook
-            // takes in an array of names so by passing the name the callback will know which module name is being used
-            // TODO(BridgeAR): This is only true in case the name is identical
-            // in all loads. If they deviate, the deviating name would not be
-            // picked up due to the unification. Check what modules actually use the name.
-            // TODO(BridgeAR): Only replace moduleExports if the hook returns a new value.
-            // This allows to reduce the instrumentation code (no return needed).
-
-            moduleExports = hook(moduleExports, version, name, isIitm) ?? moduleExports
-            // Set the moduleExports in the hooks WeakSet
-            hook[HOOK_SYMBOL].add(moduleExports)
-          } catch (e) {
-            log.info('Error during ddtrace instrumentation of application, aborting.', e)
-            telemetry('error', [
-              `error_type:${e.constructor.name}`,
-              `integration:${name}`,
-              `integration_version:${version}`,
-            ], {
-              result: 'error',
-              result_class: 'internal_error',
-              result_reason: `Error during instrumentation of ${name}@${version}: ${e.message}`,
-            })
-          }
-          namesAndSuccesses[`${name}@${version}`] = true
+          loadChannel.publish({ name })
+
+          moduleExports = hook(moduleExports, moduleVersion, isIitm) ?? moduleExports
+        } catch (error) {
+          log.info('Error during ddtrace instrumentation of application, aborting.', error)
+          telemetry('error', [
+            `error_type:${error.constructor.name}`,
+            `integration:${name}`,
+            `integration_version:${moduleVersion}`,
+          ], {
+            result: 'error',
+            result_class: 'internal_error',
+            result_reason: `Error during instrumentation of ${name}@${moduleVersion}: ${error.message}`,
+          })
         }
       }
     }
-    for (const nameVersion of Object.keys(namesAndSuccesses)) {
-      const [name, version] = nameVersion.split('@')
-      const success = namesAndSuccesses[nameVersion]
-      // we check allVersions to see if any version of the integration was successfully instrumented
-      if (!success && !seenCombo.has(nameVersion) && !allInstrumentations[instrumentationFileName]) {
-        telemetry('abort.integration', [
-          `integration:${name}`,
-          `integration_version:${version}`,
-        ], {
-          result: 'abort',
-          result_class: 'incompatible_library',
-          result_reason: `Incompatible integration version: ${name}@${version}`,
-        })
-        log.info('Found incompatible integration version: %s', nameVersion)
-        seenCombo.add(nameVersion)
-      }
-    }
 
     return moduleExports
   })
 }
 
-function matchVersion (version, ranges) {
-  return !version || !ranges || ranges.some(range => satisfies(version, range))
-}
+globalThis[Symbol.for('dd-trace')]?.beforeExitHandlers.add(logAbortedIntegrations)
+// TODO: check if we want to stop using channels for single subscriber tasks
+channel('dd-trace:exporter:first-flush').subscribe(logAbortedIntegrations)
 
-function getVersion (moduleBaseDir) {
-  if (moduleBaseDir) {
-    return requirePackageJson(moduleBaseDir, module).version
+function logAbortedIntegrations () {
+  for (const [nameVersion, success] of instrumentedIntegrationsSuccess) {
+    // Only ever log a single version of an integration, even if it is loaded later.
+    if (!success && !alreadyLoggedIncompatibleIntegrations.has(nameVersion)) {
+      const [name, version] = nameVersion.split('@')
+      telemetry('abort.integration', [
+        `integration:${name}`,
+        `integration_version:${version}`,
+      ], {
+        result: 'abort',
+        result_class: 'incompatible_library',
+        result_reason: `Incompatible integration version: ${name}@${version}`,
+      })
+      log.info('Found incompatible integration version: %s', nameVersion)
+      alreadyLoggedIncompatibleIntegrations.add(nameVersion)
+    }
   }
+  // Clear the map to avoid reporting the same integration version again.
+  instrumentedIntegrationsSuccess.clear()
 }
 
-function filename (name, file) {
-  return [name, file].filter(Boolean).join('/')
+/**
+ * @param {string|undefined} version
+ * @param {string[]|undefined} ranges
+ */
+function matchVersion (version, ranges) {
+  return !version || !ranges || ranges.some(range => satisfies(version, range))
 }
 
-// This function captures the instrumentation file name for a given package by parsing the hook require
-// function given the module name. It is used to ensure that instrumentations such as redis
-// that have several different modules being hooked, ie: 'redis' main package, and @redis/client submodule
-// return a consistent instrumentation name. This is used later to ensure that at least some portion of
-// the integration was successfully instrumented. Prevents incorrect `Found incompatible integration version: ` messages
-// Example:
-//                  redis -> "() => require('../redis')" -> redis
-//          @redis/client -> "() => require('../redis')" -> redis
-//
-function parseHookInstrumentationFileName (packageName) {
-  let hook = hooks[packageName]
-  if (hook.fn) {
-    hook = hook.fn
-  }
-  const hookString = hook.toString()
-  const regex = /require\('([^']*)'\)/
-  const match = hookString.match(regex)
-
-  // try to capture the hook require file location.
-  if (match && match[1]) {
-    let moduleName = match[1]
-    // Remove leading '../' if present
-    if (moduleName.startsWith('../')) {
-      moduleName = moduleName.slice(3)
-    }
-    return moduleName
-  }
-
-  return null
+/**
+ * @param {string} name
+ * @param {string} [file]
+ * @returns {string}
+ */
+function filename (name, file) {
+  return file ? `${name}/${file}` : name
 }
 
 module.exports = {

package/packages/datadog-instrumentations/src/http/client.js

@@ -16,9 +16,8 @@ const asyncStartChannel = channel('apm:http:client:request:asyncStart')
 const errorChannel = channel('apm:http:client:request:error')
 const responseFinishChannel = channel('apm:http:client:response:finish')
 
-const names = ['http', 'https', 'node:http', 'node:https']
-
-addHook({ name: names }, hookFn)
+addHook({ name: 'http' }, hookFn)
+addHook({ name: 'https' }, hookFn)
 
 function hookFn (http) {
   patch(http, 'request')

package/packages/datadog-instrumentations/src/http/server.js

@@ -16,10 +16,7 @@ const startSetHeaderCh = channel('datadog:http:server:response:set-header:start'
 
 const requestFinishedSet = new WeakSet()
 
-const httpNames = ['http', 'node:http']
-const httpsNames = ['https', 'node:https']
-
-addHook({ name: httpNames }, http => {
+addHook({ name: 'http' }, http => {
   shimmer.wrap(http.ServerResponse.prototype, 'emit', wrapResponseEmit)
   shimmer.wrap(http.Server.prototype, 'emit', wrapEmit)
   shimmer.wrap(http.ServerResponse.prototype, 'writeHead', wrapWriteHead)
@@ -34,7 +31,7 @@ addHook({ name: httpNames }, http => {
   return http
 })
 
-addHook({ name: httpsNames }, http => {
+addHook({ name: 'https' }, http => {
   // http.ServerResponse not present on https
   shimmer.wrap(http.Server.prototype, 'emit', wrapEmit)
   return http

package/packages/datadog-instrumentations/src/http2/client.js

@@ -10,8 +10,6 @@ const asyncStartChannel = channel('apm:http2:client:request:asyncStart')
 const asyncEndChannel = channel('apm:http2:client:request:asyncEnd')
 const errorChannel = channel('apm:http2:client:request:error')
 
-const names = ['http2', 'node:http2']
-
 function createWrapEmit (ctx) {
   return function wrapEmit (emit) {
     return function (event, arg1) {
@@ -68,7 +66,7 @@ function wrapConnect (connect) {
   }
 }
 
-addHook({ name: names }, http2 => {
+addHook({ name: 'http2' }, http2 => {
   shimmer.wrap(http2, 'connect', wrapConnect)
   if (http2.default) http2.default.connect = http2.connect
 

package/packages/datadog-instrumentations/src/http2/server.js

@@ -13,9 +13,7 @@ const startServerCh = channel('apm:http2:server:request:start')
 const errorServerCh = channel('apm:http2:server:request:error')
 const emitCh = channel('apm:http2:server:response:emit')
 
-const names = ['http2', 'node:http2']
-
-addHook({ name: names }, http2 => {
+addHook({ name: 'http2' }, http2 => {
   shimmer.wrap(http2, 'createSecureServer', wrapCreateServer)
   shimmer.wrap(http2, 'createServer', wrapCreateServer)
 })