dd-trace 5.53.0 → 5.54.0

package/packages/datadog-instrumentations/src/cassandra-driver.js

@@ -73,6 +73,10 @@ addHook({ name: 'cassandra-driver', versions: ['>=4.4'] }, cassandra => {
   return cassandra
 })
 
+const isValid = (args) => {
+  return args.length === 4 || typeof args[3] === 'function'
+}
+
 addHook({ name: 'cassandra-driver', versions: ['3 - 4.3'] }, cassandra => {
   shimmer.wrap(cassandra.Client.prototype, '_innerExecute', _innerExecute =>
     function (query, params, execOptions, callback) {
@@ -81,9 +85,6 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 4.3'] }, cassandra => {
       }
       const callbackResource = new AsyncResource('bound-anonymous-fn')
       const asyncResource = new AsyncResource('bound-anonymous-fn')
-      const isValid = (args) => {
-        return args.length === 4 || typeof args[3] === 'function'
-      }
 
       if (!isValid(arguments)) {
         return _innerExecute.apply(this, arguments)
@@ -176,7 +177,7 @@ function finish (finishCh, errorCh, error) {
   if (error) {
     errorCh.publish(error)
   }
-  finishCh.publish(undefined)
+  finishCh.publish()
 }
 
 function wrapCallback (finishCh, errorCh, asyncResource, callback) {

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

@@ -233,8 +233,7 @@ function wrapChildProcessAsyncMethod (ChildProcess, shell = false) {
             childProcessChannel.error.publish(e)
           })
 
-          childProcess.on('close', (code) => {
-            code = code || 0
+          childProcess.on('close', (code = 0) => {
             if (!errorExecuted && code !== 0) {
               childProcessChannel.error.publish()
             }

package/packages/datadog-instrumentations/src/confluentinc-kafka-javascript.js

@@ -2,8 +2,7 @@
 
 const {
   addHook,
-  channel,
-  AsyncResource
+  channel
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -32,7 +31,6 @@ const disabledHeaderWeakSet = new WeakSet()
 // we need to store the offset per partition per topic for the consumer to track offsets for DSM
 const latestConsumerOffsets = new Map()
 
-// Customize the instrumentation for Confluent Kafka JavaScript
 addHook({ name: '@confluentinc/kafka-javascript', versions: ['>=1.0.0'] }, (module) => {
   // Hook native module classes first
   instrumentBaseModule(module)
@@ -55,30 +53,32 @@ function instrumentBaseModule (module) {
         // Hook the produce method
         if (typeof producer?.produce === 'function') {
           shimmer.wrap(producer, 'produce', function wrapProduce (produce) {
-            return function wrappedProduce (topic, partition, message, key, timestamp, opaque) {
+            return function wrappedProduce (topic, partition, message, key, timestamp, opaque, headers) {
               if (!channels.producerStart.hasSubscribers) {
                 return produce.apply(this, arguments)
               }
 
               const brokers = this.globalConfig?.['bootstrap.servers']
 
-              const asyncResource = new AsyncResource('bound-anonymous-fn')
-              return asyncResource.runInAsyncScope(() => {
-                try {
-                  channels.producerStart.publish({
-                    topic,
-                    messages: [{ key, value: message }],
-                    bootstrapServers: brokers
-                  })
+              const ctx = {
+                topic,
+                messages: [{ key, value: message }],
+                bootstrapServers: brokers
+              }
 
-                  const result = produce.apply(this, arguments)
+              return channels.producerStart.runStores(ctx, () => {
+                try {
+                  const headers = convertHeaders(ctx.messages[0].headers)
+                  const result = produce.apply(this, [topic, partition, message, key, timestamp, opaque, headers])
 
-                  channels.producerCommit.publish(undefined)
-                  channels.producerFinish.publish(undefined)
+                  ctx.result = result
+                  channels.producerCommit.publish(ctx)
+                  channels.producerFinish.publish(ctx)
                   return result
                 } catch (error) {
-                  channels.producerError.publish(error)
-                  channels.producerFinish.publish(undefined)
+                  ctx.error = error
+                  channels.producerError.publish(ctx)
+                  channels.producerFinish.publish(ctx)
                   throw error
                 }
               })
@@ -110,32 +110,39 @@ function instrumentBaseModule (module) {
                 callback = numMessages
               }
 
+              const ctx = {
+                groupId
+              }
               // Handle callback-based consumption
               if (typeof callback === 'function') {
                 return consume.call(this, numMessages, function wrappedCallback (err, messages) {
                   if (messages && messages.length > 0) {
                     messages.forEach(message => {
-                      channels.consumerStart.publish({
-                        topic: message?.topic,
-                        partition: message?.partition,
-                        message,
-                        groupId
-                      })
+                      ctx.topic = message?.topic
+                      ctx.partition = message?.partition
+                      ctx.message = message
+
+                      // TODO: We should be using publish here instead of runStores but we need bindStart to be called
+                      channels.consumerStart.runStores(ctx, () => {})
                       updateLatestOffset(message?.topic, message?.partition, message?.offset, groupId)
                     })
                   }
 
                   if (err) {
-                    channels.consumerError.publish(err)
+                    ctx.error = err
+                    channels.consumerError.publish(ctx)
                   }
 
                   try {
                     const result = callback.apply(this, arguments)
-                    channels.consumerFinish.publish(undefined)
+                    if (messages && messages.length > 0) {
+                      channels.consumerFinish.publish(ctx)
+                    }
                     return result
                   } catch (error) {
-                    channels.consumerError.publish(error)
-                    channels.consumerFinish.publish(undefined)
+                    ctx.error = error
+                    channels.consumerError.publish(ctx)
+                    channels.consumerFinish.publish(ctx)
                     throw error
                   }
                 })
@@ -204,45 +211,44 @@ function instrumentKafkaJS (kafkaJS) {
                       return send.apply(this, arguments)
                     }
 
-                    const asyncResource = new AsyncResource('bound-anonymous-fn')
-                    return asyncResource.runInAsyncScope(() => {
-                      try {
-                        channels.producerStart.publish({
-                          topic: payload?.topic,
-                          messages: payload?.messages || [],
-                          bootstrapServers: kafka._ddBrokers,
-                          disableHeaderInjection: disabledHeaderWeakSet.has(producer)
-                        })
+                    const ctx = {
+                      topic: payload?.topic,
+                      messages: payload?.messages || [],
+                      bootstrapServers: kafka._ddBrokers,
+                      disableHeaderInjection: disabledHeaderWeakSet.has(producer)
+                    }
 
+                    return channels.producerStart.runStores(ctx, () => {
+                      try {
                         const result = send.apply(this, arguments)
 
-                        result.then(
-                          asyncResource.bind(res => {
-                            channels.producerCommit.publish(res)
-                            channels.producerFinish.publish(undefined)
-                          }),
-                          asyncResource.bind(err => {
-                            if (err) {
-                              // Fixes bug where we would inject message headers for kafka brokers
-                              // that don't support headers (version <0.11). On the error, we disable
-                              // header injection. Tnfortunately the error name / type is not more specific.
-                              // This approach is implemented by other tracers as well.
-                              if (err.name === 'KafkaJSError' && err.type === 'ERR_UNKNOWN') {
-                                disabledHeaderWeakSet.add(producer)
-                                log.error('Kafka Broker responded with UNKNOWN_SERVER_ERROR (-1). ' +
-                                  'Please look at broker logs for more information. ' +
-                                  'Tracer message header injection for Kafka is disabled.')
-                              }
-                              channels.producerError.publish(err)
+                        result.then((res) => {
+                          ctx.result = res
+                          channels.producerCommit.publish(ctx)
+                          channels.producerFinish.publish(ctx)
+                        }, (err) => {
+                          if (err) {
+                            // Fixes bug where we would inject message headers for kafka brokers
+                            // that don't support headers (version <0.11). On the error, we disable
+                            // header injection. Tnfortunately the error name / type is not more specific.
+                            // This approach is implemented by other tracers as well.
+                            if (err.name === 'KafkaJSError' && err.type === 'ERR_UNKNOWN') {
+                              disabledHeaderWeakSet.add(producer)
+                              log.error('Kafka Broker responded with UNKNOWN_SERVER_ERROR (-1). ' +
+                                'Please look at broker logs for more information. ' +
+                                'Tracer message header injection for Kafka is disabled.')
                             }
-                            channels.producerFinish.publish(undefined)
-                          })
-                        )
+                            ctx.error = err
+                            channels.producerError.publish(ctx)
+                          }
+                          channels.producerFinish.publish(ctx)
+                        })
 
                         return result
                       } catch (e) {
-                        channels.producerError.publish(e)
-                        channels.producerFinish.publish(undefined)
+                        ctx.error = e
+                        channels.producerError.publish(ctx)
+                        channels.producerFinish.publish(ctx)
                         throw e
                       }
                     })
@@ -350,10 +356,11 @@ function wrapKafkaCallback (callback, { startCh, commitCh, finishCh, errorCh },
   return function wrappedKafkaCallback (payload) {
     const commitPayload = getPayload(payload)
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish(commitPayload)
+    const ctx = {
+      extractedArgs: commitPayload
+    }
 
+    return startCh.runStores(ctx, () => {
       updateLatestOffset(commitPayload?.topic, commitPayload?.partition, commitPayload?.offset, commitPayload?.groupId)
 
       try {
@@ -361,22 +368,25 @@ function wrapKafkaCallback (callback, { startCh, commitCh, finishCh, errorCh },
 
         if (result && typeof result.then === 'function') {
           return result
-            .then(asyncResource.bind(res => {
-              finishCh.publish(undefined)
+            .then((res) => {
+              ctx.result = res
+              finishCh.publish(ctx)
               return res
-            }))
-            .catch(asyncResource.bind(err => {
-              errorCh.publish(err)
-              finishCh.publish(undefined)
+            })
+            .catch((err) => {
+              ctx.error = err
+              errorCh.publish(ctx)
+              finishCh.publish(ctx)
               throw err
-            }))
+            })
         } else {
-          finishCh.publish(undefined)
+          finishCh.publish(ctx)
           return result
         }
       } catch (error) {
-        errorCh.publish(error)
-        finishCh.publish(undefined)
+        ctx.error = error
+        errorCh.publish(ctx)
+        finishCh.publish(ctx)
         throw error
       }
     })
@@ -402,5 +412,10 @@ function updateLatestOffset (topic, partition, offset, groupId) {
 }
 
 function getLatestOffsets () {
-  return Array.from(latestConsumerOffsets.values())
+  return [...latestConsumerOffsets.values()]
+}
+
+function convertHeaders (headers) {
+  // convert headers from object to array of objects with 1 key and value per array entry
+  return Object.entries(headers).map(([key, value]) => ({ [key.toString()]: value.toString() }))
 }

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

@@ -32,7 +32,7 @@ function wrapMaybeInvoke (_maybeInvoke) {
     const callbackIndex = args.length - 1
     const callback = args[callbackIndex]
 
-    if (callback instanceof Function) {
+    if (typeof callback === 'function') {
       args[callbackIndex] = AsyncResource.bind(callback)
     }
 
@@ -184,12 +184,12 @@ addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.12'] }, Buc
       startCh.publish({ resource: n1qlQuery, bucket: { name: this.name || this._name }, seedNodes: this._dd_hosts })
 
       emitter.once('rows', asyncResource.bind(() => {
-        finishCh.publish(undefined)
+        finishCh.publish()
       }))
 
       emitter.once(errorMonitor, asyncResource.bind((error) => {
         errorCh.publish(error)
-        finishCh.publish(undefined)
+        finishCh.publish()
       }))
 
       try {

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

@@ -24,6 +24,8 @@ const skippableSuitesCh = channel('ci:cucumber:test-suite:skippable')
 const sessionStartCh = channel('ci:cucumber:session:start')
 const sessionFinishCh = channel('ci:cucumber:session:finish')
 const testManagementTestsCh = channel('ci:cucumber:test-management-tests')
+const impactedTestsCh = channel('ci:cucumber:modified-tests')
+const isModifiedCh = channel('ci:cucumber:is-modified-test')
 
 const workerReportTraceCh = channel('ci:cucumber:worker-report:trace')
 
@@ -42,7 +44,7 @@ const {
 } = require('../../dd-trace/src/plugins/util/test')
 
 const isMarkedAsUnskippable = (pickle) => {
-  return !!pickle.tags.find(tag => tag.name === '@datadog:unskippable')
+  return pickle.tags.some(tag => tag.name === '@datadog:unskippable')
 }
 
 // We'll preserve the original coverage here
@@ -55,6 +57,7 @@ const lastStatusByPickleId = new Map()
 const numRetriesByPickleId = new Map()
 const numAttemptToCtx = new Map()
 const newTestsByTestFullname = new Map()
+const modifiedTestsByPickleId = new Map()
 
 let eventDataCollector = null
 let pickleByFile = {}
@@ -74,15 +77,17 @@ let isEarlyFlakeDetectionFaulty = false
 let isFlakyTestRetriesEnabled = false
 let isKnownTestsEnabled = false
 let isTestManagementTestsEnabled = false
+let isImpactedTestsEnabled = false
 let testManagementAttemptToFixRetries = 0
 let testManagementTests = {}
+let modifiedTests = {}
 let numTestRetries = 0
 let knownTests = []
 let skippedSuites = []
 let isSuitesSkipped = false
 
 function getSuiteStatusFromTestStatuses (testStatuses) {
-  if (testStatuses.some(status => status === 'fail')) {
+  if (testStatuses.includes('fail')) {
     return 'fail'
   }
   if (testStatuses.every(status => status === 'skip')) {
@@ -133,7 +138,7 @@ function getTestStatusFromRetries (testStatuses) {
   if (testStatuses.every(status => status === 'fail')) {
     return 'fail'
   }
-  if (testStatuses.some(status => status === 'pass')) {
+  if (testStatuses.includes('pass')) {
     return 'pass'
   }
   return 'pass'
@@ -246,7 +251,7 @@ function wrapRun (pl, isLatestVersion) {
     }
     const ctx = testStartPayload
     numAttemptToCtx.set(numAttempt, ctx)
-    testStartCh.runStores(ctx, () => { })
+    testStartCh.runStores(ctx, () => {})
     const promises = {}
     try {
       this.eventBroadcaster.on('envelope', shimmer.wrapFunction(null, () => async (testCase) => {
@@ -258,7 +263,7 @@ function wrapRun (pl, isLatestVersion) {
             try {
               const cucumberResult = this.getWorstStepResult()
               error = getErrorFromCucumberResult(cucumberResult)
-            } catch (e) {
+            } catch {
               // ignore error
             }
 
@@ -276,7 +281,7 @@ function wrapRun (pl, isLatestVersion) {
             const newCtx = { ...testStartPayload, promises }
             numAttemptToCtx.set(numAttempt, newCtx)
 
-            testStartCh.runStores(newCtx, () => { })
+            testStartCh.runStores(newCtx, () => {})
           }
         }
       }))
@@ -305,6 +310,7 @@ function wrapRun (pl, isLatestVersion) {
         let hasFailedAttemptToFix = false
         let isDisabled = false
         let isQuarantined = false
+        let isModified = false
 
         if (isTestManagementTestsEnabled) {
           const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
@@ -329,10 +335,17 @@ function wrapRun (pl, isLatestVersion) {
           }
         }
 
-        if (isKnownTestsEnabled && status !== 'skip' && !isAttemptToFix) {
-          const numRetries = numRetriesByPickleId.get(this.pickle.id)
+        const numRetries = numRetriesByPickleId.get(this.pickle.id)
+
+        if (isImpactedTestsEnabled) {
+          isModified = modifiedTestsByPickleId.get(this.pickle.id)
+        }
 
+        if (isKnownTestsEnabled && status !== 'skip') {
           isNew = numRetries !== undefined
+        }
+
+        if (isNew || isModified) {
           isEfdRetry = numRetries > 0
         }
 
@@ -357,6 +370,7 @@ function wrapRun (pl, isLatestVersion) {
           hasFailedAttemptToFix,
           isDisabled,
           isQuarantined,
+          isModified,
           ...attemptCtx.currentStore
         })
       })
@@ -451,14 +465,15 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     isKnownTestsEnabled = configurationResponse.libraryConfig?.isKnownTestsEnabled
     isTestManagementTestsEnabled = configurationResponse.libraryConfig?.isTestManagementEnabled
     testManagementAttemptToFixRetries = configurationResponse.libraryConfig?.testManagementAttemptToFixRetries
+    isImpactedTestsEnabled = configurationResponse.libraryConfig?.isImpactedTestsEnabled
 
     if (isKnownTestsEnabled) {
       const knownTestsResponse = await getChannelPromise(knownTestsCh)
-      if (!knownTestsResponse.err) {
-        knownTests = knownTestsResponse.knownTests
-      } else {
+      if (knownTestsResponse.err) {
         isEarlyFlakeDetectionEnabled = false
         isKnownTestsEnabled = false
+      } else {
+        knownTests = knownTestsResponse.knownTests
       }
     }
 
@@ -488,7 +503,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
           this.pickleIds = picklesToRun
         }
 
-        skippedSuites = Array.from(filteredPickles.skippedSuites)
+        skippedSuites = [...filteredPickles.skippedSuites]
         itrCorrelationId = skippableResponse.itrCorrelationId
       }
     }
@@ -510,10 +525,17 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
 
     if (isTestManagementTestsEnabled) {
       const testManagementTestsResponse = await getChannelPromise(testManagementTestsCh)
-      if (!testManagementTestsResponse.err) {
-        testManagementTests = testManagementTestsResponse.testManagementTests
-      } else {
+      if (testManagementTestsResponse.err) {
         isTestManagementTestsEnabled = false
+      } else {
+        testManagementTests = testManagementTestsResponse.testManagementTests
+      }
+    }
+
+    if (isImpactedTestsEnabled) {
+      const impactedTestsResponse = await getChannelPromise(impactedTestsCh)
+      if (!impactedTestsResponse.err) {
+        modifiedTests = impactedTestsResponse.modifiedTests
       }
     }
 
@@ -547,7 +569,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
           originalCoverageMap.merge(fromCoverageMapToCoverage(untestedCoverage))
         }
         testCodeCoverageLinesTotal = originalCoverageMap.getCoverageSummary().lines.pct
-      } catch (e) {
+      } catch {
         // ignore errors
       }
       // restore the original coverage
@@ -577,12 +599,15 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
 // Handles EFD in both the main process and the worker process.
 function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = false, isWorker = false) {
   return async function () {
-    let pickle
-    if (isNewerCucumberVersion) {
-      pickle = arguments[0].pickle
-    } else {
-      pickle = this.eventDataCollector.getPickle(arguments[0])
-    }
+    const pickle = isNewerCucumberVersion
+      ? arguments[0].pickle
+      : this.eventDataCollector.getPickle(arguments[0])
+    const testCase = isNewerCucumberVersion
+      ? arguments[0].testCase
+      : arguments[1]
+    const gherkinDocument = isNewerCucumberVersion
+      ? arguments[0].gherkinDocument
+      : this.eventDataCollector.getGherkinDocument(pickle.uri)
 
     const testFileAbsolutePath = pickle.uri
     const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
@@ -604,6 +629,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     let isAttemptToFix = false
     let isDisabled = false
     let isQuarantined = false
+    let isModified = false
 
     if (isTestManagementTestsEnabled) {
       const testProperties = getTestProperties(testSuitePath, pickle.name)
@@ -616,6 +642,24 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       }
     }
 
+    if (isImpactedTestsEnabled) {
+      const setIsModified = (receivedIsModified) => { isModified = receivedIsModified }
+      const scenarios = gherkinDocument.feature?.children?.filter(
+        children => pickle.astNodeIds.includes(children.scenario.id)
+      ).map(scenario => scenario.scenario)
+      const stepIds = testCase?.testSteps?.flatMap(testStep => testStep.stepDefinitionIds)
+
+      isModifiedCh.publish({
+        scenarios,
+        testFileAbsolutePath: gherkinDocument.uri,
+        modifiedTests,
+        stepIds,
+        stepDefinitions: this.supportCodeLibrary.stepDefinitions,
+        setIsModified
+      })
+      modifiedTestsByPickleId.set(pickle.id, isModified)
+    }
+
     if (isKnownTestsEnabled && !isAttemptToFix) {
       isNew = isNewTest(testSuitePath, pickle.name)
       if (isNew) {
@@ -626,7 +670,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     let runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
 
     const testStatuses = lastStatusByPickleId.get(pickle.id)
-    const lastTestStatus = testStatuses[testStatuses.length - 1]
+    const lastTestStatus = testStatuses.at(-1)
 
     // New tests should not be marked as attempt to fix, so EFD + Attempt to fix should not be enabled at the same time
     if (isAttemptToFix && lastTestStatus !== 'skip') {
@@ -637,7 +681,7 @@ 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) {
+    if (isEarlyFlakeDetectionEnabled && lastTestStatus !== 'skip' && (isNew || isModified)) {
       for (let retryIndex = 0; retryIndex < earlyFlakeDetectionNumRetries; retryIndex++) {
         numRetriesByPickleId.set(pickle.id, retryIndex + 1)
         runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
@@ -646,7 +690,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     let testStatus = lastTestStatus
     let shouldBePassedByEFD = false
     let shouldBePassedByTestManagement = false
-    if (isNew && isEarlyFlakeDetectionEnabled) {
+    if ((isNew || isModified) && isEarlyFlakeDetectionEnabled) {
       /**
        * 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.
@@ -667,10 +711,10 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       shouldBePassedByTestManagement = true
     }
 
-    if (!pickleResultByFile[testFileAbsolutePath]) {
-      pickleResultByFile[testFileAbsolutePath] = [testStatus]
-    } else {
+    if (pickleResultByFile[testFileAbsolutePath]) {
       pickleResultByFile[testFileAbsolutePath].push(testStatus)
+    } else {
+      pickleResultByFile[testFileAbsolutePath] = [testStatus]
     }
 
     // If it's a worker, suite events are handled in `getWrappedParseWorkerMessage`
@@ -694,7 +738,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       testSuiteFinishCh.publish({ status: testSuiteStatus, testSuitePath })
     }
 
-    if (isNewerCucumberVersion && isEarlyFlakeDetectionEnabled && isNew) {
+    if (isNewerCucumberVersion && isEarlyFlakeDetectionEnabled && (isNew || isModified)) {
       return shouldBePassedByEFD
     }
 
@@ -721,13 +765,7 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
       }
     }
 
-    let envelope
-
-    if (isNewVersion) {
-      envelope = message.envelope
-    } else {
-      envelope = message.jsonEnvelope
-    }
+    const envelope = isNewVersion ? message.envelope : message.jsonEnvelope
 
     if (!envelope) {
       return parseWorkerMessageFunction.apply(this, arguments)
@@ -737,7 +775,7 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
     if (typeof parsed === 'string') {
       try {
         parsed = JSON.parse(envelope)
-      } catch (e) {
+      } catch {
         // ignore errors and continue
         return parseWorkerMessageFunction.apply(this, arguments)
       }
@@ -790,11 +828,11 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
       if (isEarlyFlakeDetectionEnabled && isNew) {
         const testFullname = `${pickle.uri}:${pickle.name}`
         let testStatuses = newTestsByTestFullname.get(testFullname)
-        if (!testStatuses) {
+        if (testStatuses) {
+          testStatuses.push(status)
+        } else {
           testStatuses = [status]
           newTestsByTestFullname.set(testFullname, testStatuses)
-        } else {
-          testStatuses.push(status)
         }
         // We have finished all retries
         if (testStatuses.length === earlyFlakeDetectionNumRetries + 1) {
@@ -947,6 +985,11 @@ addHook({
       this.options.worldParameters._ddEarlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
     }
 
+    if (isImpactedTestsEnabled) {
+      this.options.worldParameters._ddImpactedTestsEnabled = isImpactedTestsEnabled
+      this.options.worldParameters._ddModifiedTests = modifiedTests
+    }
+
     return startWorker.apply(this, arguments)
   })
   return adapterPackage
@@ -973,6 +1016,10 @@ addHook({
       if (isEarlyFlakeDetectionEnabled) {
         earlyFlakeDetectionNumRetries = this.options.worldParameters._ddEarlyFlakeDetectionNumRetries
       }
+      isImpactedTestsEnabled = !!this.options.worldParameters._ddImpactedTestsEnabled
+      if (isImpactedTestsEnabled) {
+        modifiedTests = this.options.worldParameters._ddModifiedTests
+      }
     }
   )
   return workerPackage

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

@@ -1,8 +1,9 @@
 const { addHook } = require('./helpers/instrument')
+const { DD_MAJOR } = require('../../../version')
 
 // No handler because this is only useful for testing.
 // Cypress plugin does not patch any library.
 addHook({
   name: 'cypress',
-  versions: ['>=6.7.0']
+  versions: DD_MAJOR >= 6 ? ['>=10.2.0'] : ['>=6.7.0']
 }, lib => lib)