dd-trace 5.45.0 → 5.47.0

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

@@ -2,7 +2,11 @@ const satisfies = require('semifies')
 
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
-const { parseAnnotations, getTestSuitePath } = require('../../dd-trace/src/plugins/util/test')
+const {
+  parseAnnotations,
+  getTestSuitePath,
+  PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE
+} = require('../../dd-trace/src/plugins/util/test')
 const log = require('../../dd-trace/src/log')
 
 const testStartCh = channel('ci:playwright:test:start')
@@ -18,6 +22,9 @@ const testManagementTestsCh = channel('ci:playwright:test-management-tests')
 const testSuiteStartCh = channel('ci:playwright:test-suite:start')
 const testSuiteFinishCh = channel('ci:playwright:test-suite:finish')
 
+const workerReportCh = channel('ci:playwright:worker:report')
+const testPageGotoCh = channel('ci:playwright:test:page-goto')
+
 const testToAr = new WeakMap()
 const testSuiteToAr = new Map()
 const testSuiteToTestStatuses = new Map()
@@ -255,21 +262,19 @@ function getTestFullname (test) {
   return names.join(' ')
 }
 
-function testBeginHandler (test, browserName) {
+function testBeginHandler (test, browserName, isMainProcess) {
   const {
     _requireFile: testSuiteAbsolutePath,
-    _type,
     location: {
       line: testSourceLine
-    }
+    },
+    _type
   } = test
 
   if (_type === 'beforeAll' || _type === 'afterAll') {
     return
   }
 
-  const testName = getTestFullname(test)
-
   const isNewTestSuite = !startedSuites.includes(testSuiteAbsolutePath)
 
   if (isNewTestSuite) {
@@ -286,24 +291,31 @@ function testBeginHandler (test, browserName) {
     test.retries = 0
   }
 
-  const testAsyncResource = new AsyncResource('bound-anonymous-fn')
-  testToAr.set(test, testAsyncResource)
-  testAsyncResource.runInAsyncScope(() => {
-    testStartCh.publish({
-      testName,
-      testSuiteAbsolutePath,
-      testSourceLine,
-      browserName,
-      isDisabled: test._ddIsDisabled
+  // this handles tests that do not go through the worker process (because they're skipped)
+  if (isMainProcess) {
+    const testAsyncResource = new AsyncResource('bound-anonymous-fn')
+    testToAr.set(test, testAsyncResource)
+    const testName = getTestFullname(test)
+
+    testAsyncResource.runInAsyncScope(() => {
+      testStartCh.publish({
+        testName,
+        testSuiteAbsolutePath,
+        testSourceLine,
+        browserName,
+        isDisabled: test._ddIsDisabled
+      })
     })
-  })
+  }
 }
-function testEndHandler (test, annotations, testStatus, error, isTimeout) {
+
+function testEndHandler (test, annotations, testStatus, error, isTimeout, isMainProcess) {
+  const { _requireFile: testSuiteAbsolutePath, results, _type } = test
+
   let annotationTags
   if (annotations.length) {
     annotationTags = parseAnnotations(annotations)
   }
-  const { _requireFile: testSuiteAbsolutePath, results, _type } = test
 
   if (_type === 'beforeAll' || _type === 'afterAll') {
     const hookError = formatTestHookError(error, _type, isTimeout)
@@ -324,35 +336,40 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout) {
     testStatuses.push(testStatus)
   }
 
-  let hasFailedAllRetries = false
-  let hasPassedAttemptToFixRetries = false
-
   if (testStatuses.length === testManagementAttemptToFixRetries + 1) {
     if (testStatuses.every(status => status === 'fail')) {
-      hasFailedAllRetries = true
+      test._ddHasFailedAllRetries = true
     } else if (testStatuses.every(status => status === 'pass')) {
-      hasPassedAttemptToFixRetries = true
+      test._ddHasPassedAttemptToFixRetries = true
     }
   }
 
-  const testResult = results[results.length - 1]
-  const testAsyncResource = testToAr.get(test)
-  testAsyncResource.runInAsyncScope(() => {
-    testFinishCh.publish({
-      testStatus,
-      steps: testResult?.steps || [],
-      isRetry: testResult?.retry > 0,
-      error,
-      extraTags: annotationTags,
-      isNew: test._ddIsNew,
-      isAttemptToFix: test._ddIsAttemptToFix,
-      isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
-      isQuarantined: test._ddIsQuarantined,
-      isEfdRetry: test._ddIsEfdRetry,
-      hasFailedAllRetries,
-      hasPassedAttemptToFixRetries
+  // this handles tests that do not go through the worker process (because they're skipped)
+  if (isMainProcess) {
+    const testResult = results[results.length - 1]
+    const testAsyncResource = testToAr.get(test)
+    const isAtrRetry = testResult?.retry > 0 &&
+      isFlakyTestRetriesEnabled &&
+      !test._ddIsAttemptToFix &&
+      !test._ddIsEfdRetry
+    testAsyncResource.runInAsyncScope(() => {
+      testFinishCh.publish({
+        testStatus,
+        steps: testResult?.steps || [],
+        isRetry: testResult?.retry > 0,
+        error,
+        extraTags: annotationTags,
+        isNew: test._ddIsNew,
+        isAttemptToFix: test._ddIsAttemptToFix,
+        isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
+        isQuarantined: test._ddIsQuarantined,
+        isEfdRetry: test._ddIsEfdRetry,
+        hasFailedAllRetries: test._ddHasFailedAllRetries,
+        hasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
+        isAtrRetry
+      })
     })
-  })
+  }
 
   if (testSuiteToTestStatuses.has(testSuiteAbsolutePath)) {
     testSuiteToTestStatuses.get(testSuiteAbsolutePath).push(testStatus)
@@ -416,7 +433,7 @@ function dispatcherHook (dispatcherExport) {
         const { test } = dispatcher._testById.get(params.testId)
         const projects = getProjectsFromDispatcher(dispatcher)
         const browser = getBrowserNameFromProjects(projects, test)
-        testBeginHandler(test, browser)
+        testBeginHandler(test, browser, true)
       } else if (method === 'testEnd') {
         const { test } = dispatcher._testById.get(params.testId)
 
@@ -424,7 +441,14 @@ function dispatcherHook (dispatcherExport) {
         const testResult = results[results.length - 1]
 
         const isTimeout = testResult.status === 'timedOut'
-        testEndHandler(test, params.annotations, STATUS_TO_TEST_STATUS[testResult.status], testResult.error, isTimeout)
+        testEndHandler(
+          test,
+          params.annotations,
+          STATUS_TO_TEST_STATUS[testResult.status],
+          testResult.error,
+          isTimeout,
+          true
+        )
       }
     })
 
@@ -443,13 +467,34 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
       const test = getTestByTestId(dispatcher, testId)
       const projects = getProjectsFromDispatcher(dispatcher)
       const browser = getBrowserNameFromProjects(projects, test)
-      testBeginHandler(test, browser)
+      testBeginHandler(test, browser, false)
     })
     worker.on('testEnd', ({ testId, status, errors, annotations }) => {
       const test = getTestByTestId(dispatcher, testId)
 
       const isTimeout = status === 'timedOut'
-      testEndHandler(test, annotations, STATUS_TO_TEST_STATUS[status], errors && errors[0], isTimeout)
+      testEndHandler(test, annotations, STATUS_TO_TEST_STATUS[status], errors && errors[0], isTimeout, false)
+      const testResult = test.results[test.results.length - 1]
+      const isAtrRetry = testResult?.retry > 0 &&
+        isFlakyTestRetriesEnabled &&
+        !test._ddIsAttemptToFix &&
+        !test._ddIsEfdRetry
+      // We want to send the ddProperties to the worker
+      worker.process.send({
+        type: 'ddProperties',
+        testId: test.id,
+        properties: {
+          _ddIsDisabled: test._ddIsDisabled,
+          _ddIsQuarantined: test._ddIsQuarantined,
+          _ddIsAttemptToFix: test._ddIsAttemptToFix,
+          _ddIsAttemptToFixRetry: test._ddIsAttemptToFixRetry,
+          _ddIsNew: test._ddIsNew,
+          _ddIsEfdRetry: test._ddIsEfdRetry,
+          _ddHasFailedAllRetries: test._ddHasFailedAllRetries,
+          _ddHasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
+          _ddIsAtrRetry: isAtrRetry
+        }
+      })
     })
 
     return worker
@@ -538,8 +583,8 @@ function runnerHook (runnerExport, playwrightVersion) {
       // because they were skipped
       tests.forEach(test => {
         const browser = getBrowserNameFromProjects(projects, test)
-        testBeginHandler(test, browser)
-        testEndHandler(test, [], 'skip')
+        testBeginHandler(test, browser, true)
+        testEndHandler(test, [], 'skip', null, false, true)
       })
     })
 
@@ -720,3 +765,245 @@ addHook({
 
   return loadUtilsPackage
 })
+
+// main process hook
+addHook({
+  name: 'playwright',
+  file: 'lib/runner/processHost.js',
+  versions: ['>=1.38.0']
+}, (processHostPackage) => {
+  shimmer.wrap(processHostPackage.ProcessHost.prototype, 'startRunner', startRunner => async function () {
+    this._extraEnv = {
+      ...this._extraEnv,
+      // Used to detect that we're in a playwright worker
+      DD_PLAYWRIGHT_WORKER: '1'
+    }
+
+    const res = await startRunner.apply(this, arguments)
+
+    // We add a new listener to `this.process`, which is represents the worker
+    this.process.on('message', (message) => {
+      // These messages are [code, payload]. The payload is test data
+      if (Array.isArray(message) && message[0] === PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE) {
+        workerReportCh.publish(message[1])
+      }
+    })
+
+    return res
+  })
+
+  return processHostPackage
+})
+
+addHook({
+  name: 'playwright-core',
+  file: 'lib/client/page.js',
+  versions: ['>=1.38.0']
+}, (pagePackage) => {
+  shimmer.wrap(pagePackage.Page.prototype, 'goto', goto => async function (url, options) {
+    const response = await goto.apply(this, arguments)
+
+    const page = this
+
+    const isRumActive = await page.evaluate(() => {
+      if (window.DD_RUM && window.DD_RUM.getInternalContext) {
+        return !!window.DD_RUM.getInternalContext()
+      } else {
+        return false
+      }
+    })
+
+    if (isRumActive) {
+      testPageGotoCh.publish({
+        isRumActive,
+        page
+      })
+    }
+
+    return response
+  })
+
+  return pagePackage
+})
+
+// Only in worker
+addHook({
+  name: 'playwright',
+  file: 'lib/worker/workerMain.js',
+  versions: ['>=1.38.0']
+}, (workerPackage) => {
+  // we assume there's only a test running at a time
+  let steps = []
+  const stepInfoByStepId = {}
+
+  shimmer.wrap(workerPackage.WorkerMain.prototype, '_runTest', _runTest => async function (test) {
+    steps = []
+
+    const {
+      _requireFile: testSuiteAbsolutePath,
+      location: {
+        line: testSourceLine
+      }
+    } = test
+    let res
+
+    let testInfo
+    const testName = getTestFullname(test)
+    const browserName = this._project.project.name
+
+    // If test events are created in the worker process I need to stop creating it in the main process
+    // Probably yet another test worker exporter is needed in addition to the ones for mocha, jest and cucumber
+    // it's probably hard to tell that's a playwright worker though, as I don't think there is a specific env variable
+    const testAsyncResource = new AsyncResource('bound-anonymous-fn')
+    // TODO - In the future we may need to implement a mechanism to send test properties
+    // to the worker process before _runTest is called
+    testAsyncResource.runInAsyncScope(() => {
+      testStartCh.publish({
+        testName,
+        testSuiteAbsolutePath,
+        testSourceLine,
+        browserName
+      })
+
+      let existAfterEachHook = false
+
+      // We try to find an existing afterEach hook with _ddHook to avoid adding a new one
+      for (const hook of test.parent._hooks) {
+        if (hook.type === 'afterEach' && hook._ddHook) {
+          existAfterEachHook = true
+          break
+        }
+      }
+
+      // In cases where there is no afterEach hook with _ddHook, we need to add one
+      if (!existAfterEachHook) {
+        test.parent._hooks.push({
+          type: 'afterEach',
+          fn: async function ({ page }) {
+            try {
+              if (page) {
+                const isRumActive = await page.evaluate(() => {
+                  if (window.DD_RUM && window.DD_RUM.stopSession) {
+                    window.DD_RUM.stopSession()
+                    return true
+                  } else {
+                    return false
+                  }
+                })
+
+                if (isRumActive) {
+                  const url = page.url()
+                  if (url) {
+                    const domain = new URL(url).hostname
+                    await page.context().addCookies([{
+                      name: 'datadog-ci-visibility-test-execution-id',
+                      value: '',
+                      domain,
+                      expires: 0,
+                      path: '/'
+                    }])
+                  }
+                }
+              }
+            } catch (e) {
+              // ignore errors
+            }
+          },
+          title: 'afterEach hook',
+          _ddHook: true
+        })
+      }
+
+      res = _runTest.apply(this, arguments)
+
+      testInfo = this._currentTest
+    })
+    await res
+
+    const { status, error, annotations, retry, testId } = testInfo
+
+    // testInfo.errors could be better than "error",
+    // which will only include timeout error (even though the test failed because of a different error)
+
+    let annotationTags
+    if (annotations.length) {
+      annotationTags = parseAnnotations(annotations)
+    }
+
+    let onDone
+
+    const flushPromise = new Promise(resolve => {
+      onDone = resolve
+    })
+
+    // Wait for ddProperties to be received and processed
+    // Create a promise that will be resolved when the properties are received
+    const ddPropertiesPromise = new Promise(resolve => {
+      const messageHandler = ({ type, testId, properties }) => {
+        if (type === 'ddProperties' && testId === test.id) {
+          // Apply the properties to the test object
+          if (properties) {
+            Object.assign(test, properties)
+          }
+          process.removeListener('message', messageHandler)
+          resolve()
+        }
+      }
+
+      // Add the listener
+      process.on('message', messageHandler)
+    })
+
+    // Wait for the properties to be received
+    await ddPropertiesPromise
+
+    testAsyncResource.runInAsyncScope(() => {
+      testFinishCh.publish({
+        testStatus: STATUS_TO_TEST_STATUS[status],
+        steps: steps.filter(step => step.testId === testId),
+        error,
+        extraTags: annotationTags,
+        isNew: test._ddIsNew,
+        isRetry: retry > 0,
+        isEfdRetry: test._ddIsEfdRetry,
+        isAttemptToFix: test._ddIsAttemptToFix,
+        isDisabled: test._ddIsDisabled,
+        isQuarantined: test._ddIsQuarantined,
+        isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
+        hasFailedAllRetries: test._ddHasFailedAllRetries,
+        hasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
+        isAtrRetry: test._ddIsAtrRetry,
+        onDone
+      })
+    })
+
+    await flushPromise
+
+    return res
+  })
+
+  // We reproduce what happens in `Dispatcher#_onStepBegin` and `Dispatcher#_onStepEnd`,
+  // since `startTime` and `duration` are not available directly in the worker process
+  shimmer.wrap(workerPackage.WorkerMain.prototype, 'dispatchEvent', dispatchEvent => function (event, payload) {
+    if (event === 'stepBegin') {
+      stepInfoByStepId[payload.stepId] = {
+        startTime: payload.wallTime,
+        title: payload.title,
+        testId: payload.testId
+      }
+    } else if (event === 'stepEnd') {
+      const stepInfo = stepInfoByStepId[payload.stepId]
+      delete stepInfoByStepId[payload.stepId]
+      steps.push({
+        testId: stepInfo.testId,
+        startTime: new Date(stepInfo.startTime),
+        title: stepInfo.title,
+        duration: payload.wallTime - stepInfo.startTime,
+        error: payload.error
+      })
+    }
+    return dispatchEvent.apply(this, arguments)
+  })
+
+  return workerPackage
+})

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

@@ -19,7 +19,7 @@ function createWrapRouterMethod (name) {
   function wrapLayerHandle (layer, original) {
     original._name = original._name || layer.name
 
-    const handle = shimmer.wrapFunction(original, original => function () {
+    return shimmer.wrapFunction(original, original => function () {
       if (!enterChannel.hasSubscribers) return original.apply(this, arguments)
 
       const matchers = layerMatchers.get(layer)
@@ -59,12 +59,6 @@ function createWrapRouterMethod (name) {
         exitChannel.publish({ req })
       }
     })
-
-    // This is a workaround for the `loopback` library so that it can find the correct express layer
-    // that contains the real handle function
-    handle._datadog_orig = original
-
-    return handle
   }
 
   function wrapStack (stack, offset, matchers) {

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

@@ -82,7 +82,8 @@ function getProvidedContext () {
       isKnownTestsEnabled: false,
       isTestManagementTestsEnabled: false,
       testManagementAttemptToFixRetries: 0,
-      testManagementTests: {}
+      testManagementTests: {},
+      isFlakyTestRetriesEnabled: false
     }
   }
 }
@@ -466,7 +467,8 @@ addHook({
       isEarlyFlakeDetectionEnabled,
       isDiEnabled,
       isTestManagementTestsEnabled,
-      testManagementTests
+      testManagementTests,
+      isFlakyTestRetriesEnabled
     } = getProvidedContext()
 
     if (isKnownTestsEnabled) {
@@ -566,6 +568,11 @@ addHook({
       }
     }
 
+    const isRetryReasonAtr = numAttempt > 0 &&
+      isFlakyTestRetriesEnabled &&
+      !isRetryReasonAttemptToFix &&
+      !isRetryReasonEfd
+
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     taskToAsync.set(task, asyncResource)
 
@@ -580,7 +587,8 @@ addHook({
         mightHitProbe: isDiEnabled && numAttempt > 0,
         isAttemptToFix: attemptToFixTasks.has(task),
         isDisabled: disabledTasks.has(task),
-        isQuarantined
+        isQuarantined,
+        isRetryReasonAtr
       })
     })
     return onBeforeTryTask.apply(this, arguments)

package/packages/datadog-plugin-cucumber/src/index.js

@@ -33,7 +33,8 @@ const {
   TEST_MANAGEMENT_IS_DISABLED,
   TEST_MANAGEMENT_IS_ATTEMPT_TO_FIX,
   TEST_HAS_FAILED_ALL_RETRIES,
-  TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED
+  TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED,
+  TEST_RETRY_REASON_TYPES
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const { COMPONENT, ERROR_MESSAGE } = require('../../dd-trace/src/constants')
@@ -252,11 +253,16 @@ class CucumberPlugin extends CiPlugin {
       }
     })
 
-    this.addSub('ci:cucumber:test:retry', ({ isFirstAttempt, error }) => {
+    this.addSub('ci:cucumber:test:retry', ({ isFirstAttempt, error, isAtrRetry }) => {
       const store = storage('legacy').getStore()
       const span = store.span
       if (!isFirstAttempt) {
         span.setTag(TEST_IS_RETRY, 'true')
+        if (isAtrRetry) {
+          span.setTag(TEST_RETRY_REASON, TEST_RETRY_REASON_TYPES.atr)
+        } else {
+          span.setTag(TEST_RETRY_REASON, TEST_RETRY_REASON_TYPES.ext)
+        }
       }
       span.setTag('error', error)
       if (isFirstAttempt && this.di && error && this.libraryConfig?.isDiEnabled) {
@@ -347,7 +353,7 @@ class CucumberPlugin extends CiPlugin {
         span.setTag(TEST_IS_NEW, 'true')
         if (isEfdRetry) {
           span.setTag(TEST_IS_RETRY, 'true')
-          span.setTag(TEST_RETRY_REASON, 'efd')
+          span.setTag(TEST_RETRY_REASON, TEST_RETRY_REASON_TYPES.efd)
         }
       }
 
@@ -363,6 +369,7 @@ class CucumberPlugin extends CiPlugin {
 
       if (isFlakyRetry > 0) {
         span.setTag(TEST_IS_RETRY, 'true')
+        span.setTag(TEST_RETRY_REASON, TEST_RETRY_REASON_TYPES.atr)
       }
 
       if (hasFailedAllRetries) {
@@ -375,7 +382,7 @@ class CucumberPlugin extends CiPlugin {
 
       if (isAttemptToFixRetry) {
         span.setTag(TEST_IS_RETRY, 'true')
-        span.setTag(TEST_RETRY_REASON, 'attempt_to_fix')
+        span.setTag(TEST_RETRY_REASON, TEST_RETRY_REASON_TYPES.atf)
         if (hasPassedAllRetries) {
           span.setTag(TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED, 'true')
         }

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

@@ -40,7 +40,8 @@ const {
   TEST_MANAGEMENT_IS_ATTEMPT_TO_FIX,
   TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED,
   TEST_HAS_FAILED_ALL_RETRIES,
-  getLibraryCapabilitiesTags
+  getLibraryCapabilitiesTags,
+  TEST_RETRY_REASON_TYPES
 } = require('../../dd-trace/src/plugins/util/test')
 const { isMarkedAsUnskippable } = require('../../datadog-plugin-jest/src/util')
 const { ORIGIN_KEY, COMPONENT } = require('../../dd-trace/src/constants')
@@ -229,6 +230,7 @@ class CypressPlugin {
     this.isTestsSkipped = false
     this.isSuitesSkippingEnabled = false
     this.isCodeCoverageEnabled = false
+    this.isFlakyTestRetriesEnabled = false
     this.isEarlyFlakeDetectionEnabled = false
     this.isKnownTestsEnabled = false
     this.earlyFlakeDetectionNumRetries = 0
@@ -278,6 +280,7 @@ class CypressPlugin {
           this.earlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
           this.isKnownTestsEnabled = isKnownTestsEnabled
           if (isFlakyTestRetriesEnabled) {
+            this.isFlakyTestRetriesEnabled = true
             this.cypressConfig.retries.runMode = flakyTestRetriesCount
           }
           this.isTestManagementTestsEnabled = isTestManagementEnabled
@@ -654,10 +657,18 @@ class CypressPlugin {
         let cypressTestStatus = CYPRESS_STATUS_TO_TEST_STATUS[cypressTest.state]
         if (cypressTest.attempts && cypressTest.attempts[attemptIndex]) {
           cypressTestStatus = CYPRESS_STATUS_TO_TEST_STATUS[cypressTest.attempts[attemptIndex].state]
+          const isAtrRetry = attemptIndex > 0 &&
+            this.isFlakyTestRetriesEnabled &&
+            !finishedTest.isAttemptToFix &&
+            !finishedTest.isEfdRetry
           if (attemptIndex > 0) {
             finishedTest.testSpan.setTag(TEST_IS_RETRY, 'true')
             if (finishedTest.isEfdRetry) {
-              finishedTest.testSpan.setTag(TEST_RETRY_REASON, 'efd')
+              finishedTest.testSpan.setTag(TEST_RETRY_REASON, TEST_RETRY_REASON_TYPES.efd)
+            } else if (isAtrRetry) {
+              finishedTest.testSpan.setTag(TEST_RETRY_REASON, TEST_RETRY_REASON_TYPES.atr)
+            } else {
+              finishedTest.testSpan.setTag(TEST_RETRY_REASON, TEST_RETRY_REASON_TYPES.ext)
             }
           }
         }
@@ -816,14 +827,14 @@ class CypressPlugin {
           this.activeTestSpan.setTag(TEST_IS_NEW, 'true')
           if (isEfdRetry) {
             this.activeTestSpan.setTag(TEST_IS_RETRY, 'true')
-            this.activeTestSpan.setTag(TEST_RETRY_REASON, 'efd')
+            this.activeTestSpan.setTag(TEST_RETRY_REASON, TEST_RETRY_REASON_TYPES.efd)
           }
         }
         if (isAttemptToFix) {
           this.activeTestSpan.setTag(TEST_MANAGEMENT_IS_ATTEMPT_TO_FIX, 'true')
           if (testStatuses.length > 1) {
             this.activeTestSpan.setTag(TEST_IS_RETRY, 'true')
-            this.activeTestSpan.setTag(TEST_RETRY_REASON, 'attempt_to_fix')
+            this.activeTestSpan.setTag(TEST_RETRY_REASON, TEST_RETRY_REASON_TYPES.atf)
           }
           const isLastAttempt = testStatuses.length === this.testManagementAttemptToFixRetries + 1
           if (isLastAttempt) {
@@ -840,7 +851,8 @@ class CypressPlugin {
           testStatus,
           finishTime: this.activeTestSpan._getTime(), // we store the finish time here
           testSpan: this.activeTestSpan,
-          isEfdRetry
+          isEfdRetry,
+          isAttemptToFix
         }
         if (this.finishedTestsByFile[testSuite]) {
           this.finishedTestsByFile[testSuite].push(finishedTest)