dd-trace 5.110.0 → 5.112.0

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

@@ -84,6 +84,7 @@ const numAttemptToCtx = new Map()
 const newTestsByTestFullname = new Map()
 const attemptToFixTestsByTestFullname = new Map()
 const modifiedTestsByPickleId = new Map()
+const runnerToRetryState = new WeakMap()
 // Pickle IDs for tests that are genuinely new (not in known tests list).
 const newTestPickleIds = new Set()
 const attemptToFixExecutions = new Map()
@@ -662,18 +663,97 @@ function getFinalStatus ({
   }
 }
 
+async function handleRetriedAttempt (runner, state) {
+  const { promises } = state
+  if (promises.hitBreakpointPromise) {
+    await promises.hitBreakpointPromise
+  }
+
+  const setProbePromise = publishRetriedAttempt(runner, state)
+  if (setProbePromise) {
+    await setProbePromise
+    promises.setProbePromise = undefined
+  }
+
+  startRetriedAttempt(state)
+}
+
+function handleRetriedAttemptFromEnvelope (runner, state) {
+  publishRetriedAttempt(runner, state)
+  startRetriedAttempt(state)
+}
+
+function publishRetriedAttempt (runner, state) {
+  const { promises } = state
+  let error
+  try {
+    const cucumberResult = runner.getWorstStepResult()
+    error = getErrorFromCucumberResult(cucumberResult)
+  } catch {
+    // ignore error
+  }
+
+  const currentAttempt = state.numAttempt
+  const nextAttempt = currentAttempt + 1
+  const failedAttemptCtx = numAttemptToCtx.get(currentAttempt)
+  const isFirstAttempt = currentAttempt === 0
+  const isAtrRetry = !isFirstAttempt && isFlakyTestRetriesEnabled
+
+  // ATR: record this attempt as failed so when run().finally runs (after retry) we have all statuses
+  if (isFlakyTestRetriesEnabled) {
+    const nameForKey = runner.pickle.name.replace(/\s*\(attempt \d+(?:, retried)?\)\s*$/, '')
+    const atrKey = `${runner.pickle.uri}:${nameForKey}`
+    if (atrStatusesByScenarioKey.has(atrKey)) {
+      atrStatusesByScenarioKey.get(atrKey).push('fail')
+    } else {
+      atrStatusesByScenarioKey.set(atrKey, ['fail'])
+    }
+  }
+
+  // the current span will be finished and a new one will be created
+  testRetryCh.publish({
+    isFirstAttempt,
+    error,
+    isAtrRetry,
+    promises,
+    canWaitForDi: state.testStartPayload.canWaitForDi,
+    ...failedAttemptCtx.currentStore,
+  })
+
+  state.numAttempt = nextAttempt
+  return promises.setProbePromise
+}
+
+function startRetriedAttempt (state) {
+  const { promises, testStartPayload } = state
+  const newCtx = { ...testStartPayload, promises }
+  numAttemptToCtx.set(state.numAttempt, newCtx)
+
+  testStartCh.runStores(newCtx, () => {})
+}
+
 function wrapRun (pl, isLatestVersion, version) {
   if (patched.has(pl)) return
 
   patched.add(pl)
 
+  const canAwaitRetries = typeof pl.prototype.runAttempt === 'function'
+  if (canAwaitRetries) {
+    shimmer.wrap(pl.prototype, 'runAttempt', runAttempt => async function (...args) {
+      const willBeRetried = await runAttempt.apply(this, args)
+      const state = runnerToRetryState.get(this)
+      if (willBeRetried && state) {
+        await handleRetriedAttempt(this, state)
+      }
+      return willBeRetried
+    })
+  }
+
   shimmer.wrap(pl.prototype, 'run', run => function (...args) {
     if (!testFinishCh.hasSubscribers) {
       return run.apply(this, args)
     }
 
-    let numAttempt = 0
-
     const testFileAbsolutePath = this.pickle.uri
     const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
 
@@ -684,58 +764,34 @@ function wrapRun (pl, isLatestVersion, version) {
       testFileAbsolutePath,
       testSourceLine,
       isParallel: !!getEnvironmentVariable('CUCUMBER_WORKER_ID'),
+      // Older Cucumber runners do not expose an awaited retry boundary. Failed Test Replay
+      // intentionally skips DI setup there instead of bringing back the synchronous wait.
+      canWaitForDi: canAwaitRetries,
     }
     const ctx = testStartPayload
-    numAttemptToCtx.set(numAttempt, ctx)
+    const promises = {}
+    const state = { numAttempt: 0, promises, testStartPayload }
+    numAttemptToCtx.set(state.numAttempt, ctx)
+    runnerToRetryState.set(this, state)
     if (isTestManagementTestsEnabled && getTestProperties(testSuitePath, this.pickle.name).attemptToFix) {
       logAttemptToFixTestExecution(testSuitePath, this.pickle.name, loggedAttemptToFixTests)
     }
     testStartCh.runStores(ctx, () => {})
-    const promises = {}
     try {
-      const onEnvelope = async (testCase) => {
+      const onEnvelope = (testCase) => {
+        if (canAwaitRetries) return
+
         // Only supported from >=8.0.0
         if (testCase?.testCaseFinished) {
           const { testCaseFinished: { willBeRetried } } = testCase
           if (willBeRetried) { // test case failed and will be retried
-            let error
-            try {
-              const cucumberResult = this.getWorstStepResult()
-              error = getErrorFromCucumberResult(cucumberResult)
-            } catch {
-              // ignore error
-            }
-
-            const failedAttemptCtx = numAttemptToCtx.get(numAttempt)
-            const isFirstAttempt = numAttempt++ === 0
-            const isAtrRetry = !isFirstAttempt && isFlakyTestRetriesEnabled
-
-            // ATR: record this attempt as failed so when run().finally runs (after retry) we have all statuses
-            if (isFlakyTestRetriesEnabled) {
-              const nameForKey = this.pickle.name.replace(/\s*\(attempt \d+(?:, retried)?\)\s*$/, '')
-              const atrKey = `${this.pickle.uri}:${nameForKey}`
-              if (atrStatusesByScenarioKey.has(atrKey)) {
-                atrStatusesByScenarioKey.get(atrKey).push('fail')
-              } else {
-                atrStatusesByScenarioKey.set(atrKey, ['fail'])
-              }
-            }
-
-            if (promises.hitBreakpointPromise) {
-              await promises.hitBreakpointPromise
-            }
-
-            // the current span will be finished and a new one will be created
-            testRetryCh.publish({ isFirstAttempt, error, isAtrRetry, ...failedAttemptCtx.currentStore })
-
-            const newCtx = { ...testStartPayload, promises }
-            numAttemptToCtx.set(numAttempt, newCtx)
-
-            testStartCh.runStores(newCtx, () => {})
+            handleRetriedAttemptFromEnvelope(this, state)
           }
         }
       }
-      this.eventBroadcaster.on('envelope', onEnvelope)
+      if (!canAwaitRetries) {
+        this.eventBroadcaster.on('envelope', onEnvelope)
+      }
       let promise
       const executionStart = performance.now()
 
@@ -743,7 +799,10 @@ function wrapRun (pl, isLatestVersion, version) {
         promise = run.apply(this, args)
       })
       promise.finally(async () => {
-        this.eventBroadcaster.removeListener('envelope', onEnvelope)
+        if (!canAwaitRetries) {
+          this.eventBroadcaster.removeListener('envelope', onEnvelope)
+        }
+        runnerToRetryState.delete(this)
         const result = this.getWorstStepResult()
         const { status, skipReason } = isLatestVersion
           ? getStatusFromResultLatest(result)
@@ -851,7 +910,7 @@ function wrapRun (pl, isLatestVersion, version) {
           }
         }
 
-        const attemptCtx = numAttemptToCtx.get(numAttempt)
+        const attemptCtx = numAttemptToCtx.get(state.numAttempt)
 
         const error = getErrorFromCucumberResult(result)
 
@@ -899,7 +958,7 @@ function wrapRun (pl, isLatestVersion, version) {
           error,
           isNew,
           isEfdRetry,
-          isFlakyRetry: numAttempt > 0,
+          isFlakyRetry: state.numAttempt > 0,
           isAttemptToFix,
           isAttemptToFixRetry,
           hasFailedAllRetries,

package/packages/datadog-instrumentations/src/cypress-config.js

@@ -113,9 +113,10 @@ function injectSupportFile (config) {
  * @param {object} config Cypress resolved config object
  * @param {Function[]} userAfterSpecHandlers user's after:spec handlers collected from wrappedOn
  * @param {Function[]} userAfterRunHandlers user's after:run handlers collected from wrappedOn
+ * @param {Function[]} userAfterScreenshotHandlers user's after:screenshot handlers collected from wrappedOn
  * @returns {object} the config object (possibly modified)
  */
-function registerDdTraceHooks (on, config, userAfterSpecHandlers, userAfterRunHandlers) {
+function registerDdTraceHooks (on, config, userAfterSpecHandlers, userAfterRunHandlers, userAfterScreenshotHandlers) {
   const wrapperFile = injectSupportFile(config)
 
   const cleanupWrapper = () => {
@@ -136,6 +137,7 @@ function registerDdTraceHooks (on, config, userAfterSpecHandlers, userAfterRunHa
 
   const registerNoopHandlers = () => {
     for (const h of userAfterSpecHandlers) on('after:spec', h)
+    for (const h of userAfterScreenshotHandlers) on('after:screenshot', h)
     registerAfterRunWithCleanup()
     on('task', noopTask)
   }
@@ -153,6 +155,7 @@ function registerDdTraceHooks (on, config, userAfterSpecHandlers, userAfterRunHa
     config,
     userAfterSpecHandlers,
     userAfterRunHandlers,
+    userAfterScreenshotHandlers,
     cleanupWrapper,
     registered: false,
     configPromise: undefined,
@@ -176,12 +179,15 @@ function wrapSetupNodeEvents (originalSetupNodeEvents) {
   return function ddSetupNodeEvents (on, config) {
     const userAfterSpecHandlers = []
     const userAfterRunHandlers = []
+    const userAfterScreenshotHandlers = []
 
     const wrappedOn = (event, handler) => {
       if (event === 'after:spec') {
         userAfterSpecHandlers.push(handler)
       } else if (event === 'after:run') {
         userAfterRunHandlers.push(handler)
+      } else if (event === 'after:screenshot') {
+        userAfterScreenshotHandlers.push(handler)
       } else {
         on(event, handler)
       }
@@ -197,7 +203,8 @@ function wrapSetupNodeEvents (originalSetupNodeEvents) {
           on,
           mergeReturnedConfig(config, result),
           userAfterSpecHandlers,
-          userAfterRunHandlers
+          userAfterRunHandlers,
+          userAfterScreenshotHandlers
         )
       })
     }
@@ -206,7 +213,8 @@ function wrapSetupNodeEvents (originalSetupNodeEvents) {
       on,
       mergeReturnedConfig(config, maybePromise),
       userAfterSpecHandlers,
-      userAfterRunHandlers
+      userAfterRunHandlers,
+      userAfterScreenshotHandlers
     )
   }
 }

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

@@ -22,6 +22,8 @@ const callbackFinishCh = channel('datadog:fastify:callback:execute')
 const parsingContexts = new WeakMap()
 const cookiesPublished = new WeakSet()
 const bodyPublished = new WeakSet()
+let lastPublishedError
+let lastPublishedReq
 
 function wrapFastify (fastify, hasParsingEvents) {
   if (typeof fastify !== 'function') return fastify
@@ -110,16 +112,20 @@ function invokeHookWithContext (name, fn, thisArg, args) {
     const promise = fn.apply(thisArg, args)
 
     if (promise && typeof promise.catch === 'function') {
-      return promise.catch(error => {
+      // Observe the rejection to publish, then hand back the original promise so
+      // the rejection keeps propagating untouched. Returning the handler's
+      // promise instead would resolve with `undefined` and swallow the rejection.
+      promise.catch(error => {
         ctx.error = error
-        return publishError(ctx)
+        publishError(ctx)
       })
     }
 
     return promise
   } catch (error) {
     ctx.error = error
-    throw publishError(ctx)
+    publishError(ctx)
+    throw error
   }
 }
 
@@ -305,11 +311,24 @@ function getRouteConfig (request) {
 }
 
 function publishError (ctx) {
-  if (ctx.error) {
-    publishErrorChannel(ctx)
-  }
-
-  return ctx.error
+  const error = ctx.error
+  if (!error) return
+
+  // avvio's boot loop (`_encapsulateThreeParam`) re-invokes the same encapsulated
+  // hook after it throws, re-throwing the same error object on every sequential
+  // re-drive (#9099), recursing the subscriber until boot overflows the stack.
+  // The subscribers tag once per request, so the guard collapses only a re-drive
+  // of the same error against the same request; a distinct request reusing a
+  // cached error object still publishes. Boot hooks carry no request, so their
+  // re-drives share the same `undefined` req and collapse after the first. The
+  // re-drive re-throws the one caught error on the trailing hop, so a compare
+  // against the previous publish bounds it without a per-error side table.
+  const req = ctx.req
+  if (error === lastPublishedError && req === lastPublishedReq) return
+  lastPublishedError = error
+  lastPublishedReq = req
+
+  publishErrorChannel(ctx)
 }
 
 function onRoute (routeOptions) {

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
   }