dd-trace 6.7.0 → 6.9.0

package/packages/datadog-instrumentations/src/claude-agent-sdk.js

@@ -13,6 +13,66 @@ const LOCAL_LIFECYCLE_LOOKAHEAD = 4
 
 const chunkEmitTimes = new WeakMap()
 
+/**
+ * @typedef {{ session_id?: string } & Record<string, unknown>} Chunk
+ */
+
+/**
+ * @typedef {{
+ *   id: string,
+ *   name?: string,
+ *   input?: unknown,
+ *   output?: unknown,
+ *   error?: unknown,
+ *   isInterrupt?: boolean,
+ *   sessionId?: string,
+ *   hookStartTime?: number,
+ *   hookFinishTime?: number,
+ * }} ToolState
+ */
+
+/**
+ * @typedef {{ taskStartedChunk?: Chunk, toolResultIndex?: number }} ToolLifecycle
+ */
+
+/**
+ * @typedef {(startIndex: number, toolUseId: string) => ToolLifecycle} GetLifecycle
+ */
+
+/**
+ * @typedef {{
+ *   tools: Map<string, ToolState>,
+ *   subagents: Map<string, Record<string, unknown>>,
+ *   prompt?: string,
+ *   model?: string,
+ *   resume?: string,
+ *   maxTurns?: number,
+ *   permissionMode?: string,
+ *   sessionId?: string,
+ *   source?: string,
+ *   cwd?: string,
+ *   transcriptPath?: string,
+ *   agentType?: string,
+ *   endReason?: string,
+ *   stopReason?: string,
+ *   lastAssistantMessage?: string,
+ * }} SessionContext
+ */
+
+/**
+ * @typedef {{
+ *   stepIndex: number,
+ *   startTime?: number,
+ *   finishTime?: number,
+ *   parentToolUseId?: string,
+ *   sessionId?: string,
+ *   chunks?: Chunk[],
+ *   llmStartIdx?: number,
+ *   llmEndIdx?: number,
+ *   toolOutputs?: unknown[],
+ * }} StepContext
+ */
+
 function hasDownstreamSubscribers () {
   return queryChannel.asyncEnd.hasSubscribers ||
     queryChannel.error.hasSubscribers ||
@@ -54,7 +114,7 @@ function buildTracerHooks (sessionCtx) {
     sessionCtx.cwd = input.cwd
     sessionCtx.transcriptPath = input.transcript_path
     sessionCtx.agentType = input.agent_type
-    sessionCtx.permissionMode = sessionCtx.permissionMode || input.permission_mode
+    sessionCtx.permissionMode ||= input.permission_mode
     return {}
   }
 
@@ -64,8 +124,8 @@ function buildTracerHooks (sessionCtx) {
   }
 
   function onUserPromptSubmit (input) {
-    sessionCtx.sessionId = sessionCtx.sessionId || input.session_id
-    sessionCtx.prompt = sessionCtx.prompt || input.prompt
+    sessionCtx.sessionId ||= input.session_id
+    sessionCtx.prompt ||= input.prompt
     return {}
   }
 
@@ -254,7 +314,7 @@ function createStreamLookup (chunks) {
     scanLocalLifecycle(chunks, startIndex, toolUseId, localLifecycle)
     if (localLifecycle.toolResultIndex !== undefined) return localLifecycle
 
-    streamIndex = streamIndex || buildStreamIndex(chunks)
+    streamIndex ||= buildStreamIndex(chunks)
     const indexedLifecycle = streamIndex.get(toolUseId)
     return {
       taskStartedChunk: localLifecycle.taskStartedChunk || indexedLifecycle?.taskStartedChunk,
@@ -287,10 +347,12 @@ function getToolResultContent (chunk, toolUseId) {
 }
 
 /**
- *
- * @param {Array<Record<string, unknown>>} chunks
+ * @param {Chunk[]} chunks
  * @param {number} startIndex
  * @param {string} toolUseId
+ * @param {SessionContext | null | undefined} sessionCtx
+ * @param {GetLifecycle} getLifecycle
+ * @param {ToolLifecycle} lifecycle
  * @returns {number} index in chunks where the next step should start iteration
  */
 function processTool (chunks, startIndex, toolUseId, sessionCtx, getLifecycle, lifecycle) {
@@ -342,9 +404,14 @@ function processTool (chunks, startIndex, toolUseId, sessionCtx, getLifecycle, l
 }
 
 /**
- *
- * @param {Array<Record<string, unknown>>} chunks
+ * @param {Chunk[]} chunks
  * @param {number} startIndex
+ * @param {number | undefined} stepStartTime
+ * @param {string | null | undefined} parentToolUseId
+ * @param {string | undefined} initialPrompt
+ * @param {StepContext | null | undefined} stepCtx
+ * @param {SessionContext | null | undefined} sessionCtx
+ * @param {GetLifecycle} getLifecycle
  * @returns {number} index in chunks where the next step should start iteration
  */
 function processStep (
@@ -447,7 +514,16 @@ function processStep (
 }
 
 /**
- * @param {Array<Record<string, unknown>>} chunks
+ * @param {Chunk[]} chunks
+ * @param {{
+ *   sessionCtx?: SessionContext,
+ *   session_id?: string,
+ *   cwd?: string,
+ *   permissionMode?: string,
+ *   output?: unknown,
+ *   arguments?: Array<{ prompt?: string }>,
+ *   runInContext?: (fn: () => number) => number,
+ * }} agentCtx
  */
 function processChunks (chunks, agentCtx) {
   let chunkIndex = 0

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

@@ -6,6 +6,12 @@ const { createCoverageMap } = require('../../../vendor/dist/istanbul-lib-coverag
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
 const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
+const { getSegment } = require('../../dd-trace/src/util')
+const {
+  EMPTY_EFD_RETRY_POLICY,
+  getEfdRetryCountForDuration,
+  hasEfdRetries,
+} = require('../../dd-trace/src/ci-visibility/efd-retry-policy')
 const {
   getCoveredFilesFromCoverage,
   getExecutableFilesFromCoverage,
@@ -15,15 +21,16 @@ const {
   getTestSuitePath,
   getRelativeCoverageFiles,
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
+  CUCUMBER_WORKER_TELEMETRY_PAYLOAD_CODE,
   getIsFaultyEarlyFlakeDetection,
-  getEfdRetryCount,
-  getMaxEfdRetryCount,
   applySkippedCoverageToCoverage,
   getTestCoverageLinesPercentage,
+  recordTestManagementExecution,
   recordAttemptToFixExecution,
-  collectAttemptToFixExecutionsFromTraces,
+  collectTestOptimizationSummariesFromTraces,
   logAttemptToFixTestExecution,
   logTestOptimizationSummary,
+  TEST_IMPACT_ANALYSIS_ALL_TESTS_SKIPPED_MESSAGE,
   getTestOptimizationRequestResults,
 } = require('../../dd-trace/src/plugins/util/test')
 const { writeCoverageBackfillToCache } = require('../../dd-trace/src/ci-visibility/test-optimization-cache')
@@ -56,12 +63,25 @@ const modifiedFilesCh = channel('ci:cucumber:modified-files')
 const isModifiedCh = channel('ci:cucumber:is-modified-test')
 
 const workerReportTraceCh = channel('ci:cucumber:worker-report:trace')
+const workerReportTelemetryCh = channel('ci:cucumber:worker-report:telemetry')
 
 const itrSkippedSuitesCh = channel('ci:cucumber:itr:skipped-suites')
 
 const getCodeCoverageCh = channel('ci:nyc:get-coverage')
 
 const DD_EFD_RETRY_COUNT_MESSAGE = '_ddEfdRetryCount'
+const CUCUMBER_RETRY_NAME_SUFFIX = / ?\(attempt \d+(?:, retried)?\) ?$/
+
+/**
+ * Removes Cucumber's generated retry suffix without changing literal scenario names.
+ *
+ * @param {string} testName
+ * @param {boolean} isRetry
+ * @returns {string}
+ */
+function getCucumberTestName (testName, isRetry) {
+  return isRetry ? testName.replace(CUCUMBER_RETRY_NAME_SUFFIX, '') : testName
+}
 
 const isMarkedAsUnskippable = (pickle) => {
   return pickle.tags.some(tag => tag.name === '@datadog:unskippable')
@@ -105,8 +125,7 @@ let isItrEnabled = false
 let isSuitesSkippingEnabled = false
 let isCoverageReportUploadEnabled = false
 let isEarlyFlakeDetectionEnabled = false
-let earlyFlakeDetectionNumRetries = 0
-let earlyFlakeDetectionSlowTestRetries = {}
+let earlyFlakeDetectionRetryPolicy = EMPTY_EFD_RETRY_POLICY
 let earlyFlakeDetectionFaultyThreshold = 0
 let isEarlyFlakeDetectionFaulty = false
 let isFlakyTestRetriesEnabled = false
@@ -120,8 +139,16 @@ let numTestRetries = 0
 let knownTests = {}
 let skippedSuites = []
 let isSuitesSkipped = false
+let areAllSuitesSkipped = false
 let repositoryRoot
 
+/**
+ * @returns {boolean}
+ */
+function shouldRunEarlyFlakeDetection () {
+  return isEarlyFlakeDetectionEnabled && hasEfdRetries(earlyFlakeDetectionRetryPolicy)
+}
+
 function isValidKnownTests (receivedKnownTests) {
   return !!receivedKnownTests.cucumber
 }
@@ -165,6 +192,7 @@ function resetSuiteSkippingRunState () {
   skippedSuitesCoverage = {}
   skippedSuites = []
   isSuitesSkipped = false
+  areAllSuitesSkipped = false
   repositoryRoot = undefined
   writeCoverageBackfillToCache({})
 }
@@ -179,11 +207,6 @@ function getSuiteStatusFromTestStatuses (testStatuses) {
   return 'pass'
 }
 
-function getConfiguredEfdRetryCount () {
-  const maxSlowTestRetryCount = getMaxEfdRetryCount(earlyFlakeDetectionSlowTestRetries)
-  return maxSlowTestRetryCount ?? earlyFlakeDetectionNumRetries
-}
-
 function publishWorkerEfdRetryCount (pickle, retryCount) {
   const message = {
     [DD_EFD_RETRY_COUNT_MESSAGE]: {
@@ -220,15 +243,13 @@ function configureParallelWorkerWorldParameters (options) {
     options.worldParameters._ddIsKnownTestsEnabled = true
     options.worldParameters._ddIsEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
     options.worldParameters._ddKnownTests = knownTests
-    options.worldParameters._ddEarlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
-    options.worldParameters._ddEarlyFlakeDetectionSlowTestRetries = earlyFlakeDetectionSlowTestRetries
+    options.worldParameters._ddEarlyFlakeDetectionRetryPolicy = earlyFlakeDetectionRetryPolicy
   } else {
     isEarlyFlakeDetectionEnabled = false
     isKnownTestsEnabled = false
     options.worldParameters._ddIsEarlyFlakeDetectionEnabled = false
     options.worldParameters._ddIsKnownTestsEnabled = false
-    options.worldParameters._ddEarlyFlakeDetectionNumRetries = 0
-    options.worldParameters._ddEarlyFlakeDetectionSlowTestRetries = {}
+    options.worldParameters._ddEarlyFlakeDetectionRetryPolicy = EMPTY_EFD_RETRY_POLICY
   }
 
   if (isImpactedTestsEnabled) {
@@ -260,10 +281,9 @@ function readParallelWorkerWorldParameters (options) {
     }
   }
   isEarlyFlakeDetectionEnabled = !!worldParameters._ddIsEarlyFlakeDetectionEnabled
-  if (isEarlyFlakeDetectionEnabled) {
-    earlyFlakeDetectionNumRetries = worldParameters._ddEarlyFlakeDetectionNumRetries
-    earlyFlakeDetectionSlowTestRetries = worldParameters._ddEarlyFlakeDetectionSlowTestRetries ?? {}
-  }
+  earlyFlakeDetectionRetryPolicy = isEarlyFlakeDetectionEnabled
+    ? worldParameters._ddEarlyFlakeDetectionRetryPolicy ?? EMPTY_EFD_RETRY_POLICY
+    : EMPTY_EFD_RETRY_POLICY
   isImpactedTestsEnabled = !!worldParameters._ddImpactedTestsEnabled
   if (isImpactedTestsEnabled) {
     modifiedFiles = worldParameters._ddModifiedFiles
@@ -281,10 +301,14 @@ function handleDdWorkerMessage (message) {
   if (Array.isArray(message)) {
     const [messageCode, payload] = message
     if (messageCode === CUCUMBER_WORKER_TRACE_PAYLOAD_CODE) {
-      collectAttemptToFixExecutionsFromTraces(payload, attemptToFixExecutions)
+      collectTestOptimizationSummariesFromTraces(payload, { attemptToFixExecutions })
       workerReportTraceCh.publish(payload)
       return true
     }
+    if (messageCode === CUCUMBER_WORKER_TELEMETRY_PAYLOAD_CODE) {
+      workerReportTelemetryCh.publish(payload)
+      return true
+    }
   }
 
   if (message?.[DD_EFD_RETRY_COUNT_MESSAGE]) {
@@ -333,8 +357,10 @@ function maybeStartParallelSuite (pickle) {
   })
 }
 
-function handleParallelTestCaseFinished (pickle, worstTestStepResult) {
-  const { status } = getStatusFromResultLatest(worstTestStepResult)
+function handleParallelTestCaseFinished (pickle, worstTestStepResult, usesNumericStatus = false) {
+  const { status } = usesNumericStatus
+    ? getStatusFromResult(worstTestStepResult)
+    : getStatusFromResultLatest(worstTestStepResult)
   let isNew = false
 
   if (isKnownTestsEnabled) {
@@ -342,9 +368,9 @@ function handleParallelTestCaseFinished (pickle, worstTestStepResult) {
   }
 
   const testFileAbsolutePath = pickle.uri
-  const finished = pickleResultByFile[testFileAbsolutePath] || (pickleResultByFile[testFileAbsolutePath] = [])
+  const finished = (pickleResultByFile[testFileAbsolutePath] ||= [])
 
-  if (isEarlyFlakeDetectionEnabled && isNew) {
+  if (shouldRunEarlyFlakeDetection() && isNew) {
     const testFullname = `${pickle.uri}:${pickle.name}`
     let testStatuses = newTestsByTestFullname.get(testFullname)
     if (testStatuses) {
@@ -357,7 +383,7 @@ function handleParallelTestCaseFinished (pickle, worstTestStepResult) {
     if (efdRetryCount === undefined) {
       efdRetryCount = status === 'skip'
         ? 0
-        : getConfiguredEfdRetryCount()
+        : earlyFlakeDetectionRetryPolicy.schedulingRetryCount
       efdRetryCountByPickleId.set(pickle.id, efdRetryCount)
       if (efdRetryCount === 0 && status !== 'skip') {
         efdSlowAbortedPickleIds.add(pickle.id)
@@ -555,8 +581,7 @@ function getErrorFromCucumberResult (cucumberResult) {
     return
   }
 
-  const [message] = cucumberResult.message.split('\n')
-  const error = new Error(message)
+  const error = new Error(getSegment(cucumberResult.message, '\n', 0))
   if (cucumberResult.exception) {
     error.type = cucumberResult.exception.type
   }
@@ -696,7 +721,7 @@ function publishRetriedAttempt (runner, state) {
 
   // 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 nameForKey = getCucumberTestName(runner.pickle.name, currentAttempt > 0)
     const atrKey = `${runner.pickle.uri}:${nameForKey}`
     if (atrStatusesByScenarioKey.has(atrKey)) {
       atrStatusesByScenarioKey.get(atrKey).push('fail')
@@ -793,7 +818,7 @@ function wrapRun (pl, isLatestVersion, version) {
       testFnCh.runStores(ctx, () => {
         promise = run.apply(this, args)
       })
-      promise.finally(async () => {
+      const finalize = async () => {
         if (!canAwaitRetries) {
           this.eventBroadcaster.removeListener('envelope', onEnvelope)
         }
@@ -802,6 +827,7 @@ function wrapRun (pl, isLatestVersion, version) {
         const { status, skipReason } = isLatestVersion
           ? getStatusFromResultLatest(result)
           : getStatusFromResult(result)
+        const testName = getCucumberTestName(this.pickle.name, state.numAttempt > 0)
 
         if (lastStatusByPickleId.has(this.pickle.id)) {
           lastStatusByPickleId.get(this.pickle.id).push(status)
@@ -821,7 +847,7 @@ function wrapRun (pl, isLatestVersion, version) {
 
         if (isTestManagementTestsEnabled) {
           const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
-          const testProperties = getTestProperties(testSuitePath, this.pickle.name)
+          const testProperties = getTestProperties(testSuitePath, testName)
           const numRetries = numRetriesByPickleId.get(this.pickle.id)
           isAttemptToFix = testProperties.attemptToFix
           isAttemptToFixRetry = isAttemptToFix && numRetries > 0
@@ -857,20 +883,24 @@ function wrapRun (pl, isLatestVersion, version) {
         }
 
         if (
-          isEarlyFlakeDetectionEnabled &&
+          shouldRunEarlyFlakeDetection() &&
           status !== 'skip' &&
           (isNew || isModified) &&
           !isEfdRetry &&
           !efdRetryCountByPickleId.has(this.pickle.id)
         ) {
-          const retryCount = getEfdRetryCount(performance.now() - executionStart, earlyFlakeDetectionSlowTestRetries)
+          const retryCount = getEfdRetryCountForDuration(
+            performance.now() - executionStart,
+            earlyFlakeDetectionRetryPolicy
+          )
           efdRetryCountByPickleId.set(this.pickle.id, retryCount)
           if (retryCount === 0) {
             efdSlowAbortedPickleIds.add(this.pickle.id)
           }
         }
 
-        const efdRetryCount = efdRetryCountByPickleId.get(this.pickle.id) ?? earlyFlakeDetectionNumRetries
+        const efdRetryCount = efdRetryCountByPickleId.get(this.pickle.id) ??
+          earlyFlakeDetectionRetryPolicy.schedulingRetryCount
 
         // Check if all EFD retries failed
         if (isEfdRetry && (isNew || isModified)) {
@@ -889,8 +919,7 @@ function wrapRun (pl, isLatestVersion, version) {
         // ATR: accumulate statuses by stable scenario key (uri:name) so retries are grouped.
         // Cucumber appends " (attempt N)" or " (attempt N, retried)" to the scenario name; normalize for keying.
         if (isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry && numTestRetries > 0) {
-          const nameForKey = this.pickle.name.replace(/\s*\(attempt \d+(?:, retried)?\)\s*$/, '')
-          const atrKey = `${this.pickle.uri}:${nameForKey}`
+          const atrKey = `${this.pickle.uri}:${testName}`
           if (atrStatusesByScenarioKey.has(atrKey)) {
             atrStatusesByScenarioKey.get(atrKey).push(status)
           } else {
@@ -909,10 +938,21 @@ function wrapRun (pl, isLatestVersion, version) {
 
         const error = getErrorFromCucumberResult(result)
 
+        if (!testStartPayload.isParallel) {
+          recordTestManagementExecution({
+            testSuite: testSuitePath,
+            testName,
+            status,
+            isAttemptToFix,
+            isDisabled,
+            isQuarantined,
+          })
+        }
+
         if (isAttemptToFix) {
           recordAttemptToFixExecution(attemptToFixExecutions, {
             testSuite: testSuitePath,
-            testName: this.pickle.name,
+            testName,
             status,
             isDisabled,
             isQuarantined,
@@ -953,7 +993,8 @@ function wrapRun (pl, isLatestVersion, version) {
           error,
           isNew,
           isEfdRetry,
-          isFlakyRetry: state.numAttempt > 0,
+          isFlakyRetry: state.numAttempt > 0 && isFlakyTestRetriesEnabled,
+          isExternalRetry: state.numAttempt > 0 && !isFlakyTestRetriesEnabled,
           isAttemptToFix,
           isAttemptToFixRetry,
           hasFailedAllRetries,
@@ -966,6 +1007,9 @@ function wrapRun (pl, isLatestVersion, version) {
           ...attemptCtx.currentStore,
           finalStatus,
         })
+      }
+      promise.then(finalize, finalize).catch(error => {
+        log.error('Cucumber test finalization error', error)
       })
       return promise
     } catch (err) {
@@ -1056,8 +1100,8 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     repositoryRoot = configurationResponse.repositoryRoot
     isItrEnabled = configurationResponse.libraryConfig?.isItrEnabled
     isEarlyFlakeDetectionEnabled = configurationResponse.libraryConfig?.isEarlyFlakeDetectionEnabled
-    earlyFlakeDetectionNumRetries = configurationResponse.libraryConfig?.earlyFlakeDetectionNumRetries
-    earlyFlakeDetectionSlowTestRetries = configurationResponse.libraryConfig?.earlyFlakeDetectionSlowTestRetries ?? {}
+    earlyFlakeDetectionRetryPolicy = configurationResponse.libraryConfig?.earlyFlakeDetectionRetryPolicy ??
+      EMPTY_EFD_RETRY_POLICY
     earlyFlakeDetectionFaultyThreshold = configurationResponse.libraryConfig?.earlyFlakeDetectionFaultyThreshold
     isSuitesSkippingEnabled = isItrEnabled && configurationResponse.libraryConfig?.isSuitesSkippingEnabled
     isCoverageReportUploadEnabled = configurationResponse.libraryConfig?.isCoverageReportUploadEnabled
@@ -1110,6 +1154,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
         const oldPickles = isCoordinator ? this.sourcedPickles : this.pickleIds
 
         isSuitesSkipped = picklesToRun.length !== oldPickles.length
+        areAllSuitesSkipped = oldPickles.length > 0 && picklesToRun.length === 0
 
         log.debug('%s out of %s suites are going to run.', picklesToRun.length, oldPickles.length)
 
@@ -1226,7 +1271,10 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       isParallel,
     })
 
-    logTestOptimizationSummary({ attemptToFixExecutions })
+    logTestOptimizationSummary({
+      attemptToFixExecutions,
+      extraSections: areAllSuitesSkipped ? [TEST_IMPACT_ANALYSIS_ALL_TESTS_SKIPPED_MESSAGE] : [],
+    })
     loggedAttemptToFixTests.clear()
     eventDataCollector = null
     await flushPromise
@@ -1314,7 +1362,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       }
     }
     const originalRetry = this.options.retry
-    const isManagedRetry = isAttemptToFix || (isEarlyFlakeDetectionEnabled && (isNew || isModified))
+    const isManagedRetry = isAttemptToFix || (shouldRunEarlyFlakeDetection() && (isNew || isModified))
     if (isManagedRetry) {
       this.options.retry = 0
     }
@@ -1339,10 +1387,10 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     }
 
     // If it's a new test and it hasn't been skipped, we run it again
-    if (isEarlyFlakeDetectionEnabled && lastTestStatus !== 'skip' && (isNew || isModified)) {
+    if (shouldRunEarlyFlakeDetection() && lastTestStatus !== 'skip' && (isNew || isModified)) {
       let efdRetryCount = efdRetryCountByPickleId.get(pickle.id)
       if (efdRetryCount === undefined) {
-        efdRetryCount = getEfdRetryCount(firstExecutionDurationMs, earlyFlakeDetectionSlowTestRetries)
+        efdRetryCount = getEfdRetryCountForDuration(firstExecutionDurationMs, earlyFlakeDetectionRetryPolicy)
         efdRetryCountByPickleId.set(pickle.id, efdRetryCount)
         if (efdRetryCount === 0) {
           efdSlowAbortedPickleIds.add(pickle.id)
@@ -1361,7 +1409,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     let shouldBePassedByEFD = false
     let shouldBePassedByTestManagement = false
     let shouldBeFailedByAttemptToFix = false
-    if ((isNew || isModified) && isEarlyFlakeDetectionEnabled) {
+    if ((isNew || isModified) && shouldRunEarlyFlakeDetection()) {
       /**
        * If Early Flake Detection (EFD) is enabled the logic is as follows:
        * - If all attempts for a test are failing, the test has failed and we will let the test process fail.
@@ -1419,7 +1467,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
 
     this.options.retry = originalRetry
 
-    if (isNewerCucumberVersion && isEarlyFlakeDetectionEnabled && (isNew || isModified)) {
+    if (isNewerCucumberVersion && shouldRunEarlyFlakeDetection() && (isNew || isModified)) {
       return shouldBePassedByEFD
     }
 
@@ -1448,7 +1496,7 @@ function patchCucumberWorkerRunTestCase (runtimeExecutorPackage, isWorker) {
   )
 }
 
-function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion) {
+function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion, usesNumericStatus = false) {
   return function (worker, message) {
     if (!testSuiteFinishCh.hasSubscribers) {
       return parseWorkerMessageFunction.apply(this, arguments)
@@ -1499,13 +1547,31 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
         pickle = testCase.pickle
       }
 
-      handleParallelTestCaseFinished(pickle, worstTestStepResult)
+      handleParallelTestCaseFinished(pickle, worstTestStepResult, usesNumericStatus)
     }
 
     return parseWorkerResponse
   }
 }
 
+/**
+ * Adapts Cucumber 7's callback-based parallel coordinator to the Promise contract used by getWrappedStart.
+ *
+ * @param {Function} run
+ * @param {string} frameworkVersion
+ * @returns {Function}
+ */
+function getWrappedCoordinatorRun (run, frameworkVersion) {
+  const runAsPromise = function (numberOfWorkers) {
+    return new Promise(resolve => run.call(this, numberOfWorkers, resolve))
+  }
+  const wrappedStart = getWrappedStart(runAsPromise, frameworkVersion, true)
+
+  return function (numberOfWorkers, done) {
+    return wrappedStart.call(this, numberOfWorkers).then(done)
+  }
+}
+
 module.exports.patchCucumberWorkerRunTestCase = patchCucumberWorkerRunTestCase
 
 // Test start / finish for older versions. The only hook executed in workers when in parallel mode
@@ -1553,19 +1619,33 @@ addHook({
   return runtimePackage
 })
 
-// Only executed in parallel mode.
-// `getWrappedStart` generates session start and finish events
+// Only executed in parallel mode in Cucumber 7 through 10.
+// `getWrappedCoordinatorRun` or `getWrappedStart` generates session start and finish events
 // `getWrappedParseWorkerMessage` generates suite start and finish events
+// Shimmer is required because the coordinator must be changed before it starts workers and exposes no lifecycle hook.
 addHook({
   name: '@cucumber/cucumber',
-  versions: ['>=8.0.0 <11.0.0'],
+  versions: ['>=7.0.0 <11.0.0'],
   file: 'lib/runtime/parallel/coordinator.js',
 }, (coordinatorPackage, frameworkVersion) => {
-  shimmer.wrap(coordinatorPackage.default.prototype, 'start', start => getWrappedStart(start, frameworkVersion, true))
+  const isCucumber7 = satisfies(frameworkVersion, '<8.0.0')
+  if (isCucumber7) {
+    shimmer.wrap(
+      coordinatorPackage.default.prototype,
+      'run',
+      run => getWrappedCoordinatorRun(run, frameworkVersion)
+    )
+  } else {
+    shimmer.wrap(
+      coordinatorPackage.default.prototype,
+      'start',
+      start => getWrappedStart(start, frameworkVersion, true)
+    )
+  }
   shimmer.wrap(
     coordinatorPackage.default.prototype,
     'parseWorkerMessage',
-    parseWorkerMessage => getWrappedParseWorkerMessage(parseWorkerMessage)
+    parseWorkerMessage => getWrappedParseWorkerMessage(parseWorkerMessage, false, isCucumber7)
   )
   return coordinatorPackage
 })

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

@@ -9,6 +9,7 @@ const rrtypes = {
   resolveAny: 'ANY',
   resolve4: 'A',
   resolve6: 'AAAA',
+  resolveCaa: 'CAA',
   resolveCname: 'CNAME',
   resolveMx: 'MX',
   resolveNs: 'NS',
@@ -17,6 +18,7 @@ const rrtypes = {
   resolvePtr: 'PTR',
   resolveNaptr: 'NAPTR',
   resolveSoa: 'SOA',
+  resolveTlsa: 'TLSA',
 }
 
 // `dns.promises` and `require('dns/promises')` resolve to the same exports object. Both
@@ -81,7 +83,7 @@ function buildCallbackArgsContext (rrtype) {
     const captured = [...args]
     captured.pop() // remove the callback
     if (rrtype) {
-      captured.push(rrtype)
+      insertRrtype(captured, rrtype)
     }
     return { args: captured }
   }
@@ -91,8 +93,25 @@ function buildPromiseArgsContext (rrtype) {
   return function (_, args) {
     const captured = [...args]
     if (rrtype) {
-      captured.push(rrtype)
+      insertRrtype(captured, rrtype)
     }
     return { args: captured }
   }
 }
+
+/**
+ * @param {unknown[]} captured
+ * @param {string} rrtype
+ */
+function insertRrtype (captured, rrtype) {
+  if (captured.length === 0) {
+    captured.push(rrtype)
+    return
+  }
+
+  captured.push(rrtype)
+  for (let index = captured.length - 1; index > 1; index--) {
+    captured[index] = captured[index - 1]
+  }
+  captured[1] = rrtype
+}

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

@@ -149,6 +149,7 @@ function wrapBrowserWindow (electron) {
 
       // BrowserWindow doesn't support subclassing because it's all native code
       // so we return an instance of it instead of the subclass.
+      // eslint-disable-next-line no-constructor-return
       return win
     }
   }

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

@@ -25,6 +25,8 @@ const bodyPublished = new WeakSet()
 let lastPublishedError
 let lastPublishedReq
 
+/** @typedef {{ length: number, [index: number]: unknown } & Iterable<unknown>} ArgumentsLike */
+
 function wrapFastify (fastify, hasParsingEvents) {
   if (typeof fastify !== 'function') return fastify
 
@@ -81,7 +83,7 @@ function wrapAddHook (addHook) {
  * @param {string} name Lifecycle phase the hook was registered against.
  * @param {Function} fn User-supplied hook.
  * @param {unknown} thisArg `this` Fastify passes to the hook.
- * @param {ArrayLike<unknown>} args Fastify's positional args; the dispatcher always
+ * @param {ArgumentsLike} args Fastify's positional args; the dispatcher always
  *   places `done` as the trailing positional (see fastify/lib/hooks.js hookIterator,
  *   onSendHookRunner, preParsingHookRunner, onRequestAbortHookRunner).
  */