dd-trace 5.22.0 → 5.23.0

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

@@ -53,14 +53,15 @@ function wrapQuery (query) {
     }
 
     return asyncResource.runInAsyncScope(() => {
+      const abortController = new AbortController()
+
       startCh.publish({
         params: this.connectionParameters,
         query: pgQuery,
-        processId
+        processId,
+        abortController
       })
 
-      arguments[0] = pgQuery
-
       const finish = asyncResource.bind(function (error) {
         if (error) {
           errorCh.publish(error)
@@ -68,6 +69,43 @@ function wrapQuery (query) {
         finishCh.publish()
       })
 
+      if (abortController.signal.aborted) {
+        const error = abortController.signal.reason || new Error('Aborted')
+
+        // eslint-disable-next-line max-len
+        // Based on: https://github.com/brianc/node-postgres/blob/54eb0fa216aaccd727765641e7d1cf5da2bc483d/packages/pg/lib/client.js#L510
+        const reusingQuery = typeof pgQuery.submit === 'function'
+        const callback = arguments[arguments.length - 1]
+
+        finish(error)
+
+        if (reusingQuery) {
+          if (!pgQuery.callback && typeof callback === 'function') {
+            pgQuery.callback = callback
+          }
+
+          if (pgQuery.callback) {
+            pgQuery.callback(error)
+          } else {
+            process.nextTick(() => {
+              pgQuery.emit('error', error)
+            })
+          }
+
+          return pgQuery
+        }
+
+        if (typeof callback === 'function') {
+          callback(error)
+
+          return
+        }
+
+        return Promise.reject(error)
+      }
+
+      arguments[0] = pgQuery
+
       const retval = query.apply(this, arguments)
       const queryQueue = this.queryQueue || this._queryQueue
       const activeQuery = this.activeQuery || this._activeQuery
@@ -112,8 +150,11 @@ function wrapPoolQuery (query) {
     const pgQuery = arguments[0] !== null && typeof arguments[0] === 'object' ? arguments[0] : { text: arguments[0] }
 
     return asyncResource.runInAsyncScope(() => {
+      const abortController = new AbortController()
+
       startPoolQueryCh.publish({
-        query: pgQuery
+        query: pgQuery,
+        abortController
       })
 
       const finish = asyncResource.bind(function () {
@@ -121,6 +162,20 @@ function wrapPoolQuery (query) {
       })
 
       const cb = arguments[arguments.length - 1]
+
+      if (abortController.signal.aborted) {
+        const error = abortController.signal.reason || new Error('Aborted')
+        finish()
+
+        if (typeof cb === 'function') {
+          cb(error)
+
+          return
+        } else {
+          return Promise.reject(error)
+        }
+      }
+
       if (typeof cb === 'function') {
         arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function () {
           finish()

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

@@ -1,5 +1,6 @@
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
+const log = require('../../dd-trace/src/log')
 
 // test hooks
 const testStartCh = channel('ci:vitest:test:start')
@@ -7,6 +8,7 @@ const testFinishTimeCh = channel('ci:vitest:test:finish-time')
 const testPassCh = channel('ci:vitest:test:pass')
 const testErrorCh = channel('ci:vitest:test:error')
 const testSkipCh = channel('ci:vitest:test:skip')
+const isNewTestCh = channel('ci:vitest:test:is-new')
 
 // test suite hooks
 const testSuiteStartCh = channel('ci:vitest:test-suite:start')
@@ -17,9 +19,13 @@ const testSuiteErrorCh = channel('ci:vitest:test-suite:error')
 const testSessionStartCh = channel('ci:vitest:session:start')
 const testSessionFinishCh = channel('ci:vitest:session:finish')
 const libraryConfigurationCh = channel('ci:vitest:library-configuration')
+const knownTestsCh = channel('ci:vitest:known-tests')
+const isEarlyFlakeDetectionFaultyCh = channel('ci:vitest:is-early-flake-detection-faulty')
 
 const taskToAsync = new WeakMap()
-
+const taskToStatuses = new WeakMap()
+const newTasks = new WeakSet()
+const switchedStatuses = new WeakSet()
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
 function isReporterPackage (vitestPackage) {
@@ -108,20 +114,61 @@ function getSortWrapper (sort) {
     // will not work. This will be a known limitation.
     let isFlakyTestRetriesEnabled = false
     let flakyTestRetriesCount = 0
+    let isEarlyFlakeDetectionEnabled = false
+    let earlyFlakeDetectionNumRetries = 0
+    let isEarlyFlakeDetectionFaulty = false
+    let knownTests = {}
 
     try {
       const { err, libraryConfig } = await getChannelPromise(libraryConfigurationCh)
       if (!err) {
         isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
         flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
+        isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
+        earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
       }
     } catch (e) {
       isFlakyTestRetriesEnabled = false
+      isEarlyFlakeDetectionEnabled = false
     }
+
     if (isFlakyTestRetriesEnabled && !this.ctx.config.retry && flakyTestRetriesCount > 0) {
       this.ctx.config.retry = flakyTestRetriesCount
     }
 
+    if (isEarlyFlakeDetectionEnabled) {
+      const knownTestsResponse = await getChannelPromise(knownTestsCh)
+      if (!knownTestsResponse.err) {
+        knownTests = knownTestsResponse.knownTests
+        const testFilepaths = await this.ctx.getTestFilepaths()
+
+        isEarlyFlakeDetectionFaultyCh.publish({
+          knownTests: knownTests.vitest || {},
+          testFilepaths,
+          onDone: (isFaulty) => {
+            isEarlyFlakeDetectionFaulty = isFaulty
+          }
+        })
+        if (isEarlyFlakeDetectionFaulty) {
+          isEarlyFlakeDetectionEnabled = false
+          log.warn('Early flake detection is disabled because the number of new tests is too high.')
+        } else {
+          // TODO: use this to pass session and module IDs to the worker, instead of polluting process.env
+          // Note: setting this.ctx.config.provide directly does not work because it's cached
+          try {
+            const workspaceProject = this.ctx.getCoreWorkspaceProject()
+            workspaceProject._provided._ddKnownTests = knownTests.vitest
+            workspaceProject._provided._ddIsEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
+            workspaceProject._provided._ddEarlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
+          } catch (e) {
+            log.warn('Could not send known tests to workers so Early Flake Detection will not work.')
+          }
+        }
+      } else {
+        isEarlyFlakeDetectionEnabled = false
+      }
+    }
+
     let testCodeCoverageLinesTotal
 
     if (this.ctx.coverageProvider?.generateCoverage) {
@@ -154,6 +201,8 @@ function getSortWrapper (sort) {
           status: getSessionStatus(this.state),
           testCodeCoverageLinesTotal,
           error,
+          isEarlyFlakeDetectionEnabled,
+          isEarlyFlakeDetectionFaulty,
           onFinish
         })
       })
@@ -188,12 +237,83 @@ addHook({
   file: 'dist/runners.js'
 }, (vitestPackage) => {
   const { VitestTestRunner } = vitestPackage
+
+  // `onBeforeRunTask` is run before any repetition or attempt is run
+  shimmer.wrap(VitestTestRunner.prototype, 'onBeforeRunTask', onBeforeRunTask => async function (task) {
+    const testName = getTestName(task)
+    try {
+      const {
+        _ddKnownTests: knownTests,
+        _ddIsEarlyFlakeDetectionEnabled: isEarlyFlakeDetectionEnabled,
+        _ddEarlyFlakeDetectionNumRetries: numRepeats
+      } = globalThis.__vitest_worker__.providedContext
+
+      if (isEarlyFlakeDetectionEnabled) {
+        isNewTestCh.publish({
+          knownTests,
+          testSuiteAbsolutePath: task.file.filepath,
+          testName,
+          onDone: (isNew) => {
+            if (isNew) {
+              task.repeats = numRepeats
+              newTasks.add(task)
+              taskToStatuses.set(task, [])
+            }
+          }
+        })
+      }
+    } catch (e) {
+      log.error('Vitest workers could not parse known tests, so Early Flake Detection will not work.')
+    }
+
+    return onBeforeRunTask.apply(this, arguments)
+  })
+
+  // `onAfterRunTask` is run after all repetitions or attempts are run
+  shimmer.wrap(VitestTestRunner.prototype, 'onAfterRunTask', onAfterRunTask => async function (task) {
+    const {
+      _ddIsEarlyFlakeDetectionEnabled: isEarlyFlakeDetectionEnabled
+    } = globalThis.__vitest_worker__.providedContext
+
+    if (isEarlyFlakeDetectionEnabled && taskToStatuses.has(task)) {
+      const statuses = taskToStatuses.get(task)
+      // If the test has passed at least once, we consider it passed
+      if (statuses.includes('pass')) {
+        if (task.result.state === 'fail') {
+          switchedStatuses.add(task)
+        }
+        task.result.state = 'pass'
+      }
+    }
+
+    return onAfterRunTask.apply(this, arguments)
+  })
+
   // test start (only tests that are not marked as skip or todo)
+  // `onBeforeTryTask` is run for every repetition and attempt of the test
   shimmer.wrap(VitestTestRunner.prototype, 'onBeforeTryTask', onBeforeTryTask => async function (task, retryInfo) {
     if (!testStartCh.hasSubscribers) {
       return onBeforeTryTask.apply(this, arguments)
     }
-    const { retry: numAttempt } = retryInfo
+    const testName = getTestName(task)
+    let isNew = false
+    let isEarlyFlakeDetectionEnabled = false
+
+    try {
+      const {
+        _ddIsEarlyFlakeDetectionEnabled
+      } = globalThis.__vitest_worker__.providedContext
+
+      isEarlyFlakeDetectionEnabled = _ddIsEarlyFlakeDetectionEnabled
+
+      if (isEarlyFlakeDetectionEnabled) {
+        isNew = newTasks.has(task)
+      }
+    } catch (e) {
+      log.error('Vitest workers could not parse known tests, so Early Flake Detection will not work.')
+    }
+    const { retry: numAttempt, repeats: numRepetition } = retryInfo
+
     // We finish the previous test here because we know it has failed already
     if (numAttempt > 0) {
       const asyncResource = taskToAsync.get(task)
@@ -205,14 +325,58 @@ addHook({
       }
     }
 
+    const lastExecutionStatus = task.result.state
+
+    // These clauses handle task.repeats, whether EFD is enabled or not
+    // The only thing that EFD does is to forcefully pass the test if it has passed at least once
+    if (numRepetition > 0 && numRepetition < task.repeats) { // it may or may have not failed
+      // Here we finish the earlier iteration,
+      // as long as it's not the _last_ iteration (which will be finished normally)
+
+      // TODO: check test duration (not to repeat if it's too slow)
+      const asyncResource = taskToAsync.get(task)
+      if (asyncResource) {
+        if (lastExecutionStatus === 'fail') {
+          const testError = task.result?.errors?.[0]
+          asyncResource.runInAsyncScope(() => {
+            testErrorCh.publish({ error: testError })
+          })
+        } else {
+          asyncResource.runInAsyncScope(() => {
+            testPassCh.publish({ task })
+          })
+        }
+        if (isEarlyFlakeDetectionEnabled) {
+          const statuses = taskToStatuses.get(task)
+          statuses.push(lastExecutionStatus)
+          // If we don't "reset" the result.state to "pass", once a repetition fails,
+          // vitest will always consider the test as failed, so we can't read the actual status
+          task.result.state = 'pass'
+        }
+      }
+    } else if (numRepetition === task.repeats) {
+      const asyncResource = taskToAsync.get(task)
+      if (lastExecutionStatus === 'fail') {
+        const testError = task.result?.errors?.[0]
+        asyncResource.runInAsyncScope(() => {
+          testErrorCh.publish({ error: testError })
+        })
+      } else {
+        asyncResource.runInAsyncScope(() => {
+          testPassCh.publish({ task })
+        })
+      }
+    }
+
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     taskToAsync.set(task, asyncResource)
 
     asyncResource.runInAsyncScope(() => {
       testStartCh.publish({
-        testName: getTestName(task),
+        testName,
         testSuiteAbsolutePath: task.file.filepath,
-        isRetry: numAttempt > 0
+        isRetry: numAttempt > 0 || numRepetition > 0,
+        isNew
       })
     })
     return onBeforeTryTask.apply(this, arguments)
@@ -230,7 +394,7 @@ addHook({
       const asyncResource = taskToAsync.get(task)
 
       if (asyncResource) {
-        // We don't finish here because the test might fail in a later hook
+        // We don't finish here because the test might fail in a later hook (afterEach)
         asyncResource.runInAsyncScope(() => {
           testFinishTimeCh.publish({ status, task })
         })
@@ -270,7 +434,16 @@ addHook({
 
 addHook({
   name: 'vitest',
-  versions: ['>=2.0.5'],
+  versions: ['>=2.1.0'],
+  filePattern: 'dist/chunks/RandomSequencer.*'
+}, (randomSequencerPackage) => {
+  shimmer.wrap(randomSequencerPackage.B.prototype, 'sort', getSortWrapper)
+  return randomSequencerPackage
+})
+
+addHook({
+  name: 'vitest',
+  versions: ['>=2.0.5 <2.1.0'],
   filePattern: 'dist/chunks/index.*'
 }, (vitestPackage) => {
   if (isReporterPackageNewest(vitestPackage)) {
@@ -323,19 +496,21 @@ addHook({
     testTasks.forEach(task => {
       const testAsyncResource = taskToAsync.get(task)
       const { result } = task
+      // We have to trick vitest into thinking that the test has passed
+      // but we want to report it as failed if it did fail
+      const isSwitchedStatus = switchedStatuses.has(task)
 
       if (result) {
         const { state, duration, errors } = result
         if (state === 'skip') { // programmatic skip
           testSkipCh.publish({ testName: getTestName(task), testSuiteAbsolutePath: task.file.filepath })
-        } else if (state === 'pass') {
+        } else if (state === 'pass' && !isSwitchedStatus) {
           if (testAsyncResource) {
             testAsyncResource.runInAsyncScope(() => {
               testPassCh.publish({ task })
             })
           }
-        } else if (state === 'fail') {
-          // If it's failing, we have no accurate finish time, so we have to use `duration`
+        } else if (state === 'fail' || isSwitchedStatus) {
           let testError
 
           if (errors?.length) {

package/packages/datadog-plugin-amqplib/src/consumer.js

@@ -3,7 +3,6 @@
 const { TEXT_MAP } = require('../../../ext/formats')
 const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
 const { getAmqpMessageSize } = require('../../dd-trace/src/datastreams/processor')
-const { DsmPathwayCodec } = require('../../dd-trace/src/datastreams/pathway')
 const { getResourceName } = require('./util')
 
 class AmqplibConsumerPlugin extends ConsumerPlugin {
@@ -30,8 +29,7 @@ class AmqplibConsumerPlugin extends ConsumerPlugin {
     })
 
     if (
-      this.config.dsmEnabled && message?.properties?.headers &&
-      DsmPathwayCodec.contextExists(message.properties.headers)
+      this.config.dsmEnabled && message?.properties?.headers
     ) {
       const payloadSize = getAmqpMessageSize({ headers: message.properties.headers, content: message.content })
       const queue = fields.queue ? fields.queue : fields.routingKey

package/packages/datadog-plugin-aws-sdk/src/base.js

@@ -5,9 +5,11 @@ const ClientPlugin = require('../../dd-trace/src/plugins/client')
 const { storage } = require('../../datadog-core')
 const { isTrue } = require('../../dd-trace/src/util')
 const coalesce = require('koalas')
+const { tagsFromRequest, tagsFromResponse } = require('../../dd-trace/src/payload-tagging')
 
 class BaseAwsSdkPlugin extends ClientPlugin {
   static get id () { return 'aws' }
+  static get isPayloadReporter () { return false }
 
   get serviceIdentifier () {
     const id = this.constructor.id.toLowerCase()
@@ -20,6 +22,14 @@ class BaseAwsSdkPlugin extends ClientPlugin {
     return id
   }
 
+  get cloudTaggingConfig () {
+    return this._tracerConfig.cloudPayloadTagging
+  }
+
+  get payloadTaggingRules () {
+    return this.cloudTaggingConfig.rules.aws?.[this.constructor.id]
+  }
+
   constructor (...args) {
     super(...args)
 
@@ -51,6 +61,12 @@ class BaseAwsSdkPlugin extends ClientPlugin {
 
       this.requestInject(span, request)
 
+      if (this.constructor.isPayloadReporter && this.cloudTaggingConfig.requestsEnabled) {
+        const maxDepth = this.cloudTaggingConfig.maxDepth
+        const requestTags = tagsFromRequest(this.payloadTaggingRules, request.params, { maxDepth })
+        span.addTags(requestTags)
+      }
+
       const store = storage.getStore()
 
       this.enter(span, store)
@@ -116,6 +132,7 @@ class BaseAwsSdkPlugin extends ClientPlugin {
     const params = response.request.params
     const operation = response.request.operation
     const extraTags = this.generateTags(params, operation, response) || {}
+
     const tags = Object.assign({
       'aws.response.request_id': response.requestId,
       'resource.name': operation,
@@ -123,6 +140,22 @@ class BaseAwsSdkPlugin extends ClientPlugin {
     }, extraTags)
 
     span.addTags(tags)
+
+    if (this.constructor.isPayloadReporter && this.cloudTaggingConfig.responsesEnabled) {
+      const maxDepth = this.cloudTaggingConfig.maxDepth
+      const responseBody = this.extractResponseBody(response)
+      const responseTags = tagsFromResponse(this.payloadTaggingRules, responseBody, { maxDepth })
+      span.addTags(responseTags)
+    }
+  }
+
+  extractResponseBody (response) {
+    if (response.hasOwnProperty('data')) {
+      return response.data
+    }
+    return Object.fromEntries(
+      Object.entries(response).filter(([key]) => !['request', 'requestId', 'error', '$metadata'].includes(key))
+    )
   }
 
   generateTags () {

package/packages/datadog-plugin-aws-sdk/src/services/kinesis.js

@@ -113,7 +113,7 @@ class Kinesis extends BaseAwsSdkPlugin {
       const parsedAttributes = JSON.parse(Buffer.from(record.Data).toString())
 
       if (
-        parsedAttributes?._datadog && streamName && DsmPathwayCodec.contextExists(parsedAttributes._datadog)
+        parsedAttributes?._datadog && streamName
       ) {
         const payloadSize = getSizeOrZero(record.Data)
         this.tracer.decodeDataStreamsContext(parsedAttributes._datadog)

package/packages/datadog-plugin-aws-sdk/src/services/sns.js

@@ -7,6 +7,7 @@ const BaseAwsSdkPlugin = require('../base')
 class Sns extends BaseAwsSdkPlugin {
   static get id () { return 'sns' }
   static get peerServicePrecursors () { return ['topicname'] }
+  static get isPayloadReporter () { return true }
 
   generateTags (params, operation, response) {
     if (!params) return {}
@@ -20,6 +21,7 @@ class Sns extends BaseAwsSdkPlugin {
 
     // Get the topic name from the last part of the ARN
     const topicName = arnParts[arnParts.length - 1]
+
     return {
       'resource.name': `${operation} ${params.TopicArn || response.data.TopicArn}`,
       'aws.sns.topic_arn': TopicArn,

package/packages/datadog-plugin-aws-sdk/src/services/sqs.js

@@ -194,7 +194,7 @@ class Sqs extends BaseAwsSdkPlugin {
           parsedAttributes = this.parseDatadogAttributes(message.MessageAttributes._datadog)
         }
       }
-      if (parsedAttributes && DsmPathwayCodec.contextExists(parsedAttributes)) {
+      if (parsedAttributes) {
         const payloadSize = getHeadersSize({
           Body: message.Body,
           MessageAttributes: message.MessageAttributes

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

@@ -17,6 +17,7 @@ const {
   ITR_CORRELATION_ID,
   TEST_SOURCE_FILE,
   TEST_EARLY_FLAKE_ENABLED,
+  TEST_EARLY_FLAKE_ABORT_REASON,
   TEST_IS_NEW,
   TEST_IS_RETRY,
   TEST_SUITE_ID,
@@ -79,6 +80,7 @@ class CucumberPlugin extends CiPlugin {
       hasUnskippableSuites,
       hasForcedToRunSuites,
       isEarlyFlakeDetectionEnabled,
+      isEarlyFlakeDetectionFaulty,
       isParallel
     }) => {
       const { isSuitesSkippingEnabled, isCodeCoverageEnabled } = this.libraryConfig || {}
@@ -99,6 +101,9 @@ class CucumberPlugin extends CiPlugin {
       if (isEarlyFlakeDetectionEnabled) {
         this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ENABLED, 'true')
       }
+      if (isEarlyFlakeDetectionFaulty) {
+        this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ABORT_REASON, 'faulty')
+      }
       if (isParallel) {
         this.testSessionSpan.setTag(CUCUMBER_IS_PARALLEL, 'true')
       }
@@ -116,7 +121,15 @@ class CucumberPlugin extends CiPlugin {
       this.tracer._exporter.flush()
     })
 
-    this.addSub('ci:cucumber:test-suite:start', ({ testSuitePath, isUnskippable, isForcedToRun, itrCorrelationId }) => {
+    this.addSub('ci:cucumber:test-suite:start', ({
+      testFileAbsolutePath,
+      isUnskippable,
+      isForcedToRun,
+      itrCorrelationId
+    }) => {
+      const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
+      const testSourceFile = getTestSuitePath(testFileAbsolutePath, this.repositoryRoot)
+
       const testSuiteMetadata = getTestSuiteCommonTags(
         this.command,
         this.frameworkVersion,
@@ -134,6 +147,16 @@ class CucumberPlugin extends CiPlugin {
       if (itrCorrelationId) {
         testSuiteMetadata[ITR_CORRELATION_ID] = itrCorrelationId
       }
+      if (testSourceFile) {
+        testSuiteMetadata[TEST_SOURCE_FILE] = testSourceFile
+        testSuiteMetadata[TEST_SOURCE_START] = 1
+      }
+
+      const codeOwners = this.getCodeOwners(testSuiteMetadata)
+      if (codeOwners) {
+        testSuiteMetadata[TEST_CODE_OWNERS] = codeOwners
+      }
+
       const testSuiteSpan = this.tracer.startSpan('cucumber.test_suite', {
         childOf: this.testModuleSpan,
         tags: {

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

@@ -28,7 +28,10 @@ const {
   TEST_SOURCE_FILE,
   TEST_IS_NEW,
   TEST_IS_RETRY,
-  TEST_EARLY_FLAKE_ENABLED
+  TEST_EARLY_FLAKE_ENABLED,
+  getTestSessionName,
+  TEST_SESSION_NAME,
+  TEST_LEVEL_EVENT_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')
@@ -245,10 +248,22 @@ class CypressPlugin {
     return this.libraryConfigurationPromise
   }
 
-  getTestSuiteSpan (suite) {
+  getTestSuiteSpan ({ testSuite, testSuiteAbsolutePath }) {
     const testSuiteSpanMetadata =
-      getTestSuiteCommonTags(this.command, this.frameworkVersion, suite, TEST_FRAMEWORK_NAME)
+      getTestSuiteCommonTags(this.command, this.frameworkVersion, testSuite, TEST_FRAMEWORK_NAME)
+
     this.ciVisEvent(TELEMETRY_EVENT_CREATED, 'suite')
+
+    if (testSuiteAbsolutePath) {
+      const testSourceFile = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
+      testSuiteSpanMetadata[TEST_SOURCE_FILE] = testSourceFile
+      testSuiteSpanMetadata[TEST_SOURCE_START] = 1
+      const codeOwners = this.getTestCodeOwners({ testSuite, testSourceFile })
+      if (codeOwners) {
+        testSuiteSpanMetadata[TEST_CODE_OWNERS] = codeOwners
+      }
+    }
+
     return this.tracer.startSpan(`${TEST_FRAMEWORK_NAME}.test_suite`, {
       childOf: this.testModuleSpan,
       tags: {
@@ -387,6 +402,18 @@ class CypressPlugin {
       testSessionSpanMetadata[TEST_EARLY_FLAKE_ENABLED] = 'true'
     }
 
+    const testSessionName = getTestSessionName(this.tracer._tracer._config, this.command, this.testEnvironmentMetadata)
+
+    if (this.tracer._tracer._exporter?.setMetadataTags) {
+      const metadataTags = {}
+      for (const testLevel of TEST_LEVEL_EVENT_TYPES) {
+        metadataTags[testLevel] = {
+          [TEST_SESSION_NAME]: testSessionName
+        }
+      }
+      this.tracer._tracer._exporter.setMetadataTags(metadataTags)
+    }
+
     this.testSessionSpan = this.tracer.startSpan(`${TEST_FRAMEWORK_NAME}.test_session`, {
       childOf,
       tags: {
@@ -473,7 +500,10 @@ class CypressPlugin {
       // dd:testSuiteStart hasn't been triggered for whatever reason
       // We will create the test suite span on the spot if that's the case
       log.warn('There was an error creating the test suite event.')
-      this.testSuiteSpan = this.getTestSuiteSpan(spec.relative)
+      this.testSuiteSpan = this.getTestSuiteSpan({
+        testSuite: spec.relative,
+        testSuiteAbsolutePath: spec.absolute
+      })
     }
 
     // Get tests that didn't go through `dd:afterEach`
@@ -584,7 +614,7 @@ class CypressPlugin {
 
   getTasks () {
     return {
-      'dd:testSuiteStart': (testSuite) => {
+      'dd:testSuiteStart': ({ testSuite, testSuiteAbsolutePath }) => {
         const suitePayload = {
           isEarlyFlakeDetectionEnabled: this.isEarlyFlakeDetectionEnabled,
           knownTestsForSuite: this.knownTestsByTestSuite?.[testSuite] || [],
@@ -594,7 +624,7 @@ class CypressPlugin {
         if (this.testSuiteSpan) {
           return suitePayload
         }
-        this.testSuiteSpan = this.getTestSuiteSpan(testSuite)
+        this.testSuiteSpan = this.getTestSuiteSpan({ testSuite, testSuiteAbsolutePath })
         return suitePayload
       },
       'dd:beforeEach': (test) => {

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

@@ -61,7 +61,10 @@ beforeEach(function () {
 })
 
 before(function () {
-  cy.task('dd:testSuiteStart', Cypress.mocha.getRootSuite().file).then((suiteConfig) => {
+  cy.task('dd:testSuiteStart', {
+    testSuite: Cypress.mocha.getRootSuite().file,
+    testSuiteAbsolutePath: Cypress.spec && Cypress.spec.absolute
+  }).then((suiteConfig) => {
     if (suiteConfig) {
       isEarlyFlakeDetectionEnabled = suiteConfig.isEarlyFlakeDetectionEnabled
       knownTestsForSuite = suiteConfig.knownTestsForSuite