dd-trace 5.109.0 → 5.111.0

package/packages/datadog-esbuild/src/utils.js

@@ -6,6 +6,9 @@ const fs = require('node:fs')
 const path = require('node:path')
 const { NODE_MAJOR, NODE_MINOR } = require('../../../version.js')
 
+const LOAD_OPERATION = 0
+const RESOLVE_OPERATION = 1
+
 const getExportsImporting = (url) => import(url).then(Object.keys)
 let getExportsModulePromise
 
@@ -19,7 +22,11 @@ const loadGetExportsModule = () => {
 const getExports = NODE_MAJOR >= 20 || (NODE_MAJOR === 18 && NODE_MINOR >= 19)
   ? async (srcUrl, context, getSource) => {
     const mod = await loadGetExportsModule()
-    return mod.getExports(srcUrl, context, getSource)
+    const exportNames = mod.getExports(srcUrl, context, getSource)
+    if (exportNames?.next) {
+      return driveGetExportsGenerator(exportNames, getSource)
+    }
+    return exportNames
   }
   : getExportsImporting
 
@@ -78,14 +85,50 @@ function getSource (url, { format }) {
   }
 }
 
+/**
+ * Drives the generator returned by import-in-the-middle >=3.1.0 export discovery.
+ *
+ * @param {Generator<Array, Set<string>>} exportsGenerator Generator returned by getExports
+ * @param {(url: URL, context: object) => { source: string, format: string }} getSource
+ * Function that loads module source
+ * @returns {Set<string>}
+ */
+function driveGetExportsGenerator (exportsGenerator, getSource) {
+  let next = exportsGenerator.next()
+  while (next.done === false) {
+    let result
+    let error
+    let threw = false
+
+    try {
+      const operation = next.value
+      const operationType = operation[0]
+
+      if (operationType === LOAD_OPERATION) {
+        result = getSource(operation[1], operation[2])
+      } else if (operationType === RESOLVE_OPERATION) {
+        result = resolve(operation[1], operation[2])
+      } else {
+        throw new Error(`Unsupported import-in-the-middle getExports operation: ${operationType}`)
+      }
+    } catch (err) {
+      threw = true
+      error = err
+    }
+
+    next = threw ? exportsGenerator.throw(error) : exportsGenerator.next(result)
+  }
+  return next.value
+}
+
 /**
  * Generates the pieces of code for the proxy module before the path
  *
  * @param {object} moduleData
  * @param {string} moduleData.path
- * @param {boolean} [moduleData.internal]
+ * @param {boolean} [moduleData.internal]
  * @param {object} moduleData.context
- * @param {boolean} [moduleData.excludeDefault]
+ * @param {boolean} [moduleData.excludeDefault]
  * @returns {Promise<Map>}
  */
 async function processModule ({ path, internal = false, context, excludeDefault = false }) {

package/packages/datadog-instrumentations/src/connect.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
-const { addHook, channel } = require('./helpers/instrument')
+const { addHook, channel, createErrorPublisher } = require('./helpers/instrument')
 
 const enterChannel = channel('apm:connect:middleware:enter')
 const exitChannel = channel('apm:connect:middleware:exit')
@@ -9,6 +9,7 @@ const errorChannel = channel('apm:connect:middleware:error')
 const nextChannel = channel('apm:connect:middleware:next')
 const finishChannel = channel('apm:connect:middleware:finish')
 const handleChannel = channel('apm:connect:request:handle')
+const publishError = createErrorPublisher(errorChannel)
 
 function wrapConnect (connect) {
   if (typeof connect !== 'function') return connect
@@ -78,7 +79,7 @@ function wrapLayerHandle (layer) {
     try {
       return original.apply(this, args)
     } catch (error) {
-      errorChannel.publish({ req, error })
+      publishError({ req, error })
       nextChannel.publish({ req })
       finishChannel.publish({ req })
 
@@ -93,7 +94,7 @@ function wrapNext (req, next) {
   // Mirror next's name/arity so wrapCallback skips its per-call identity rewrite.
   return shimmer.wrapCallback(next, original => function next (error) {
     if (error) {
-      errorChannel.publish({ req, error })
+      publishError({ req, error })
     }
 
     nextChannel.publish({ req })

package/packages/datadog-instrumentations/src/fastify.js

@@ -1,9 +1,10 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
-const { addHook, channel } = require('./helpers/instrument')
+const { addHook, channel, createErrorPublisher } = require('./helpers/instrument')
 
 const errorChannel = channel('apm:fastify:middleware:error')
+const publishErrorChannel = createErrorPublisher(errorChannel)
 const handleChannel = channel('apm:fastify:request:handle')
 const routeAddedChannel = channel('apm:fastify:route:added')
 const bodyParserReadCh = channel('datadog:fastify:body-parser:finish')
@@ -303,18 +304,9 @@ function getRouteConfig (request) {
   return request?.routeOptions?.config
 }
 
-let publishingError = false
-
 function publishError (ctx) {
-  // `errorChannel` is public: a subscriber that re-enters the hook pipeline while
-  // handling the error republishes here and recurses until the stack overflows.
-  if (ctx.error && !publishingError) {
-    publishingError = true
-    try {
-      errorChannel.publish(ctx)
-    } finally {
-      publishingError = false
-    }
+  if (ctx.error) {
+    publishErrorChannel(ctx)
   }
 
   return ctx.error

package/packages/datadog-instrumentations/src/fs.js

@@ -88,8 +88,10 @@ addHook({ name: 'fs' }, fs => {
   const asyncMethods = Object.keys(paramsByMethod)
   const syncMethods = asyncMethods.map(name => `${name}Sync`)
 
-  massWrap(fs, asyncMethods, createWrapFunction())
-  massWrap(fs, syncMethods, createWrapFunction())
+  // Node 20 defines `fs.opendir` / `fs.opendirSync` as lazy accessor properties;
+  // `replaceGetter` resolves the method so the call is wrapped, not the accessor.
+  massWrap(fs, asyncMethods, createWrapFunction(), { replaceGetter: true })
+  massWrap(fs, syncMethods, createWrapFunction(), { replaceGetter: true })
   massWrap(fs.promises, asyncMethods, createWrapFunction('promises.'))
 
   wrap(fs.realpath, 'native', createWrapFunction('', 'realpath.native'))
@@ -355,15 +357,15 @@ function getMessage (operation, params, args, self) {
   return { operation, ...metadata }
 }
 
-function massWrap (target, methods, wrapper) {
+function massWrap (target, methods, wrapper, options) {
   for (const method of methods) {
-    wrap(target, method, wrapper)
+    wrap(target, method, wrapper, options)
   }
 }
 
-function wrap (target, method, wrapper) {
+function wrap (target, method, wrapper, options) {
   try {
-    shimmer.wrap(target, method, wrapper)
+    shimmer.wrap(target, method, wrapper, options)
   } catch {
     // skip unavailable method
   }