Default instrumentation of node built in libraries

Author: pabloerhard

packages/datadog-esbuild/index.js

@@ -24,27 +24,38 @@ for (const hook of Object.values(hooks)) {
   }
 }
 
+function moduleOfInterestKey (name, file) {
+  return file ? `${name}/${file}` : name
+}
+
+const builtinModules = new Set(require('module').builtinModules)
+
+function addModuleOfInterest (name, file) {
+  if (!name) return
+
+  modulesOfInterest.add(moduleOfInterestKey(name, file))
+
+  if (builtinModules.has(name)) {
+    modulesOfInterest.add(moduleOfInterestKey(`node:${name}`, file))
+  }
+}
+
 const modulesOfInterest = new Set()
 
-for (const [name, instrumentation] of Object.entries(instrumentations)) {
+for (const instrumentation of Object.values(instrumentations)) {
   for (const entry of instrumentation) {
-    if (!entry.file) {
-      modulesOfInterest.add(name) // e.g. "redis"
-    } else {
-      modulesOfInterest.add(`${name}/${entry.file}`) // e.g. "redis/my/file.js"
-    }
+    addModuleOfInterest(entry.name, entry.file)
   }
 }
 
-const RAW_BUILTINS = require('module').builtinModules
 const CHANNEL = 'dd-trace:bundler:load'
 const path = require('path')
 const fs = require('fs')
 const { execSync } = require('child_process')
 
 const builtins = new Set()
 
-for (const builtin of RAW_BUILTINS) {
+for (const builtin of builtinModules) {
   builtins.add(builtin)
   builtins.add(`node:${builtin}`)
 }

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

@@ -82,7 +82,7 @@ dc.subscribe(CHANNEL, (message) => {
     return
   }
 
-  for (const { file, versions, hook } of instrumentation) {
+  for (const { name, file, versions, hook } of instrumentation) {
     if (payload.path !== filename(name, file) || !matchVersion(payload.version, versions)) {
       continue
     }

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

@@ -51,11 +51,16 @@ exports.tracingChannel = function (name) {
  * @param {import('./instrumentations').Hook} hook
  */
 exports.addHook = function addHook ({ name, versions, file, filePattern, patchDefault }, hook) {
-  if (!instrumentations[name]) {
-    instrumentations[name] = []
+  if (typeof name === 'string') {
+    name = [name]
   }
 
-  instrumentations[name].push({ versions, file, filePattern, hook, patchDefault })
+  for (const val of name) {
+    if (!instrumentations[val]) {
+      instrumentations[val] = []
+    }
+    instrumentations[val].push({ name: val, versions, file, filePattern, hook, patchDefault })
+  }
 }
 
 exports.AsyncResource = AsyncResource

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

@@ -30,6 +30,7 @@ const disabledInstrumentations = new Set(
 )
 
 const loadChannel = channel('dd-trace:instrumentation:load')
+const HOOK_SYMBOL = Symbol('hookExportsSet')
 
 // Globals
 if (!disabledInstrumentations.has('fetch')) {
@@ -124,6 +125,7 @@ for (const name of names) {
         }
       }
 
+      hook[HOOK_SYMBOL] ??= new WeakSet()
       const fullFilename = filename(name, file)
 
       let matchesFile = moduleName === fullFilename
@@ -136,12 +138,16 @@ for (const name of names) {
       }
 
       if (matchesFile && matchVersion(moduleVersion, versions)) {
+        if (hook[HOOK_SYMBOL].has(moduleExports)) {
+          return moduleExports
+        }
         // Do not log in case of an error to prevent duplicate telemetry for the same integration version.
         instrumentedIntegrationsSuccess.set(`${name}@${moduleVersion}`, true)
         try {
           loadChannel.publish({ name })
 
           moduleExports = hook(moduleExports, moduleVersion) ?? moduleExports
+          hook[HOOK_SYMBOL].add(moduleExports)
         } catch (error) {
           log.info('Error during ddtrace instrumentation of application, aborting.', error)
           telemetry('error', [

packages/dd-trace/src/ritm.js

@@ -19,6 +19,24 @@ let patchedRequire = null
 const moduleLoadStartChannel = dc.channel('dd-trace:moduleLoadStart')
 const moduleLoadEndChannel = dc.channel('dd-trace:moduleLoadEnd')
 
+function stripNodePrefix (name) {
+  if (typeof name !== 'string') return name
+  return name.startsWith('node:') ? name.slice(5) : name
+}
+
+const builtinModules = new Set(Module.builtinModules.map(stripNodePrefix))
+
+function isBuiltinModuleName (name) {
+  if (typeof name !== 'string') return false
+  return builtinModules.has(stripNodePrefix(name))
+}
+
+function normalizeModuleName (name) {
+  if (typeof name !== 'string') return name
+  const stripped = stripNodePrefix(name)
+  return builtinModules.has(stripped) ? stripped : name
+}
+
 /**
  * @overload
  * @param {string[]} modules list of modules to hook into
@@ -73,27 +91,28 @@ function Hook (modules, options, onrequire) {
       return _origRequire.apply(this, arguments)
     }
 
-    const core = !filename.includes(path.sep)
+    const builtin = isBuiltinModuleName(filename)
+    const moduleId = builtin ? normalizeModuleName(filename) : filename
     let name, basedir, hooks
     // return known patched modules immediately
-    if (cache[filename]) {
+    if (cache[moduleId]) {
       // require.cache was potentially altered externally
       const cacheEntry = require.cache[filename]
       if (cacheEntry && cacheEntry.exports !== cache[filename].original) {
         return cacheEntry.exports
       }
 
-      return cache[filename].exports
+      return cache[moduleId].exports
     }
 
     // Check if this module has a patcher in-progress already.
     // Otherwise, mark this module as patching in-progress.
-    const patched = patching[filename]
+    const patched = patching[moduleId]
     if (patched) {
       // If it's already patched, just return it as-is.
       return origRequire.apply(this, arguments)
     }
-    patching[filename] = true
+    patching[moduleId] = true
 
     const payload = {
       filename,
@@ -112,12 +131,12 @@ function Hook (modules, options, onrequire) {
 
     // The module has already been loaded,
     // so the patching mark can be cleaned up.
-    delete patching[filename]
+    delete patching[moduleId]
 
-    if (core) {
-      hooks = moduleHooks[filename]
+    if (builtin) {
+      hooks = moduleHooks[moduleId]
       if (!hooks) return exports // abort if module name isn't on whitelist
-      name = filename
+      name = moduleId
     } else {
       const inAWSLambda = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined
       const hasLambdaHandler = getEnvironmentVariable('DD_LAMBDA_HANDLER') !== undefined
@@ -159,14 +178,14 @@ function Hook (modules, options, onrequire) {
 
     // ensure that the cache entry is assigned a value before calling
     // onrequire, in case calling onrequire requires the same module.
-    cache[filename] = { exports }
-    cache[filename].original = exports
+    cache[moduleId] = { exports }
+    cache[moduleId].original = exports
 
     for (const hook of hooks) {
-      cache[filename].exports = hook(cache[filename].exports, name, basedir)
+      cache[moduleId].exports = hook(cache[moduleId].exports, name, basedir)
     }
 
-    return cache[filename].exports
+    return cache[moduleId].exports
   }
 }