dd-trace 5.19.0 → 5.20.0

package/ext/formats.d.ts

@@ -5,6 +5,7 @@ declare const formats: {
   HTTP_HEADERS: typeof opentracing.FORMAT_HTTP_HEADERS
   BINARY: typeof opentracing.FORMAT_BINARY
   LOG: 'log'
+  TEXT_MAP_DSM: 'text_map_dsm'
 }
 
 export = formats

package/ext/formats.js

@@ -4,5 +4,6 @@ module.exports = {
   TEXT_MAP: 'text_map',
   HTTP_HEADERS: 'http_headers',
   BINARY: 'binary',
-  LOG: 'log'
+  LOG: 'log',
+  TEXT_MAP_DSM: 'text_map_dsm'
 }

package/init.js

@@ -2,22 +2,10 @@
 
 const path = require('path')
 const Module = require('module')
-const telemetry = require('./packages/dd-trace/src/telemetry/init-telemetry')
 const semver = require('semver')
-
-function isTrue (envVar) {
-  return ['1', 'true', 'True'].includes(envVar)
-}
-
-// eslint-disable-next-line no-console
-let log = { info: isTrue(process.env.DD_TRACE_DEBUG) ? console.log : () => {} }
-if (semver.satisfies(process.versions.node, '>=16')) {
-  const Config = require('./packages/dd-trace/src/config')
-  log = require('./packages/dd-trace/src/log')
-
-  // eslint-disable-next-line no-new
-  new Config() // we need this to initialize the logger
-}
+const log = require('./packages/dd-trace/src/log')
+const { isTrue } = require('./packages/dd-trace/src/util')
+const telemetry = require('./packages/dd-trace/src/telemetry/init-telemetry')
 
 let initBailout = false
 let clobberBailout = false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.19.0",
+  "version": "5.20.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -33,6 +33,7 @@
     "test:profiler": "tap \"packages/dd-trace/test/profiling/**/*.spec.js\"",
     "test:profiler:ci": "npm run test:profiler -- --coverage --nyc-arg=--include=\"packages/dd-trace/src/profiling/**/*.js\"",
     "test:integration": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/*.spec.js\"",
+    "test:integration:appsec": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/appsec/*.spec.js\"",
     "test:integration:cucumber": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/cucumber/*.spec.js\"",
     "test:integration:cypress": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/cypress/*.spec.js\"",
     "test:integration:jest": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/jest/*.spec.js\"",
@@ -72,7 +73,7 @@
   },
   "dependencies": {
     "@datadog/native-appsec": "8.0.1",
-    "@datadog/native-iast-rewriter": "2.3.1",
+    "@datadog/native-iast-rewriter": "2.4.0",
     "@datadog/native-iast-taint-tracking": "3.0.0",
     "@datadog/native-metrics": "^2.0.0",
     "@datadog/pprof": "5.3.0",

package/packages/datadog-instrumentations/src/helpers/register.js

@@ -29,6 +29,10 @@ if (!disabledInstrumentations.has('fetch')) {
   require('../fetch')
 }
 
+if (!disabledInstrumentations.has('process')) {
+  require('../process')
+}
+
 const HOOK_SYMBOL = Symbol('hookExportsMap')
 
 if (DD_TRACE_DEBUG && DD_TRACE_DEBUG.toLowerCase() !== 'false') {
@@ -88,16 +92,13 @@ for (const packageName of names) {
       if (matchesFile) {
         const version = moduleVersion || getVersion(moduleBaseDir)
         if (!Object.hasOwnProperty(namesAndSuccesses, name)) {
-          namesAndSuccesses[name] = {
-            success: false,
-            version
-          }
+          namesAndSuccesses[`${name}@${version}`] = false
         }
 
         if (matchVersion(version, versions)) {
           // Check if the hook already has a set moduleExport
           if (hook[HOOK_SYMBOL].has(moduleExports)) {
-            namesAndSuccesses[name].success = true
+            namesAndSuccesses[`${name}@${version}`] = true
             return moduleExports
           }
 
@@ -117,19 +118,20 @@ for (const packageName of names) {
               `integration_version:${version}`
             ])
           }
-          namesAndSuccesses[name].success = true
+          namesAndSuccesses[`${name}@${version}`] = true
         }
       }
     }
-    for (const name of Object.keys(namesAndSuccesses)) {
-      const { success, version } = namesAndSuccesses[name]
-      if (!success && !seenCombo.has(`${name}@${version}`)) {
+    for (const nameVersion of Object.keys(namesAndSuccesses)) {
+      const [name, version] = nameVersion.split('@')
+      const success = namesAndSuccesses[nameVersion]
+      if (!success && !seenCombo.has(nameVersion)) {
         telemetry('abort.integration', [
           `integration:${name}`,
           `integration_version:${version}`
         ])
-        log.info(`Found incompatible integration version: ${name}@${version}`)
-        seenCombo.add(`${name}@${version}`)
+        log.info(`Found incompatible integration version: ${nameVersion}`)
+        seenCombo.add(nameVersion)
       }
     }
 

package/packages/datadog-instrumentations/src/http/client.js

@@ -43,7 +43,9 @@ function patch (http, methodName) {
         return request.apply(this, arguments)
       }
 
-      const ctx = { args, http }
+      const abortController = new AbortController()
+
+      const ctx = { args, http, abortController }
 
       return startChannel.runStores(ctx, () => {
         let finished = false
@@ -107,6 +109,10 @@ function patch (http, methodName) {
             return emit.apply(this, arguments)
           }
 
+          if (abortController.signal.aborted) {
+            req.destroy(abortController.signal.reason || new Error('Aborted'))
+          }
+
           return req
         } catch (e) {
           ctx.error = e

package/packages/datadog-instrumentations/src/http/server.js

@@ -12,6 +12,7 @@ const errorServerCh = channel('apm:http:server:request:error')
 const finishServerCh = channel('apm:http:server:request:finish')
 const startWriteHeadCh = channel('apm:http:server:response:writeHead:start')
 const finishSetHeaderCh = channel('datadog:http:server:response:set-header:finish')
+const startSetHeaderCh = channel('datadog:http:server:response:set-header:start')
 
 const requestFinishedSet = new WeakSet()
 
@@ -24,6 +25,12 @@ addHook({ name: httpNames }, http => {
   shimmer.wrap(http.ServerResponse.prototype, 'writeHead', wrapWriteHead)
   shimmer.wrap(http.ServerResponse.prototype, 'write', wrapWrite)
   shimmer.wrap(http.ServerResponse.prototype, 'end', wrapEnd)
+  shimmer.wrap(http.ServerResponse.prototype, 'setHeader', wrapSetHeader)
+  shimmer.wrap(http.ServerResponse.prototype, 'removeHeader', wrapAppendOrRemoveHeader)
+  // Added in node v16.17.0
+  if (http.ServerResponse.prototype.appendHeader) {
+    shimmer.wrap(http.ServerResponse.prototype, 'appendHeader', wrapAppendOrRemoveHeader)
+  }
   return http
 })
 
@@ -65,9 +72,7 @@ function wrapEmit (emit) {
           // TODO: should this always return true ?
           return this.listenerCount(eventName) > 0
         }
-        if (finishSetHeaderCh.hasSubscribers) {
-          wrapSetHeader(res)
-        }
+
         return emit.apply(this, arguments)
       } catch (err) {
         errorServerCh.publish(err)
@@ -81,16 +86,6 @@ function wrapEmit (emit) {
   }
 }
 
-function wrapSetHeader (res) {
-  shimmer.wrap(res, 'setHeader', setHeader => {
-    return function (name, value) {
-      const setHeaderResult = setHeader.apply(this, arguments)
-      finishSetHeaderCh.publish({ name, value, res })
-      return setHeaderResult
-    }
-  })
-}
-
 function wrapWriteHead (writeHead) {
   return function wrappedWriteHead (statusCode, reason, obj) {
     if (!startWriteHeadCh.hasSubscribers) {
@@ -159,6 +154,48 @@ function wrapWrite (write) {
   }
 }
 
+function wrapSetHeader (setHeader) {
+  return function wrappedSetHeader (name, value) {
+    if (!startSetHeaderCh.hasSubscribers && !finishSetHeaderCh.hasSubscribers) {
+      return setHeader.apply(this, arguments)
+    }
+
+    if (startSetHeaderCh.hasSubscribers) {
+      const abortController = new AbortController()
+      startSetHeaderCh.publish({ res: this, abortController })
+
+      if (abortController.signal.aborted) {
+        return
+      }
+    }
+
+    const setHeaderResult = setHeader.apply(this, arguments)
+
+    if (finishSetHeaderCh.hasSubscribers) {
+      finishSetHeaderCh.publish({ name, value, res: this })
+    }
+
+    return setHeaderResult
+  }
+}
+
+function wrapAppendOrRemoveHeader (originalMethod) {
+  return function wrappedAppendOrRemoveHeader () {
+    if (!startSetHeaderCh.hasSubscribers) {
+      return originalMethod.apply(this, arguments)
+    }
+
+    const abortController = new AbortController()
+    startSetHeaderCh.publish({ res: this, abortController })
+
+    if (abortController.signal.aborted) {
+      return this
+    }
+
+    return originalMethod.apply(this, arguments)
+  }
+}
+
 function wrapEnd (end) {
   return function wrappedEnd () {
     if (!startWriteHeadCh.hasSubscribers) {

package/packages/datadog-instrumentations/src/mocha/main.js

@@ -395,9 +395,13 @@ addHook({
       }
 
       const asyncResource = testFileToSuiteAr.get(suite.file)
-      asyncResource.runInAsyncScope(() => {
-        testSuiteFinishCh.publish(status)
-      })
+      if (asyncResource) {
+        asyncResource.runInAsyncScope(() => {
+          testSuiteFinishCh.publish(status)
+        })
+      } else {
+        log.warn(() => `No AsyncResource found for suite ${suite.file}`)
+      }
     })
 
     return run.apply(this, arguments)
@@ -424,23 +428,29 @@ addHook({
   versions: ['>=6.0.0'],
   file: 'src/WorkerHandler.js'
 }, (workerHandlerPackage) => {
-  shimmer.wrap(workerHandlerPackage.prototype, 'exec', exec => function (message, [testSuiteAbsolutePath]) {
+  shimmer.wrap(workerHandlerPackage.prototype, 'exec', exec => function (_, path) {
     if (!testStartCh.hasSubscribers) {
       return exec.apply(this, arguments)
     }
+    if (!path?.length) {
+      return exec.apply(this, arguments)
+    }
+    const [testSuiteAbsolutePath] = path
+    const testSuiteAsyncResource = new AsyncResource('bound-anonymous-fn')
 
-    this.worker.on('message', function (message) {
+    function onMessage (message) {
       if (Array.isArray(message)) {
         const [messageCode, payload] = message
         if (messageCode === MOCHA_WORKER_TRACE_PAYLOAD_CODE) {
-          testSessionAsyncResource.runInAsyncScope(() => {
+          testSuiteAsyncResource.runInAsyncScope(() => {
             workerReportTraceCh.publish(payload)
           })
         }
       }
-    })
+    }
+
+    this.worker.on('message', onMessage)
 
-    const testSuiteAsyncResource = new AsyncResource('bound-anonymous-fn')
     testSuiteAsyncResource.runInAsyncScope(() => {
       testSuiteStartCh.publish({
         testSuiteAbsolutePath
@@ -455,12 +465,14 @@ addHook({
           testSuiteAsyncResource.runInAsyncScope(() => {
             testSuiteFinishCh.publish(status)
           })
+          this.worker.off('message', onMessage)
         },
         (err) => {
           testSuiteAsyncResource.runInAsyncScope(() => {
             testSuiteErrorCh.publish(err)
             testSuiteFinishCh.publish('fail')
           })
+          this.worker.off('message', onMessage)
         }
       )
       return promise
@@ -469,6 +481,7 @@ addHook({
         testSuiteErrorCh.publish(err)
         testSuiteFinishCh.publish('fail')
       })
+      this.worker.off('message', onMessage)
       throw err
     }
   })

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

@@ -0,0 +1,29 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel } = require('dc-polyfill')
+
+const startSetUncaughtExceptionCaptureCallback = channel('datadog:process:setUncaughtExceptionCaptureCallback:start')
+
+if (process.setUncaughtExceptionCaptureCallback) {
+  let currentCallback
+
+  shimmer.wrap(process, 'setUncaughtExceptionCaptureCallback',
+    function wrapSetUncaughtExceptionCaptureCallback (originalSetUncaughtExceptionCaptureCallback) {
+      return function setUncaughtExceptionCaptureCallback (newCallback) {
+        if (startSetUncaughtExceptionCaptureCallback.hasSubscribers) {
+          const abortController = new AbortController()
+          startSetUncaughtExceptionCaptureCallback.publish({ newCallback, currentCallback, abortController })
+          if (abortController.signal.aborted) {
+            return
+          }
+        }
+
+        const result = originalSetUncaughtExceptionCaptureCallback.apply(this, arguments)
+
+        currentCallback = newCallback
+
+        return result
+      }
+    })
+}

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

@@ -32,6 +32,10 @@ function isReporterPackageNew (vitestPackage) {
   return vitestPackage.e?.name === 'BaseSequencer'
 }
 
+function isReporterPackageNewest (vitestPackage) {
+  return vitestPackage.h?.name === 'BaseSequencer'
+}
+
 function getChannelPromise (channelToPublishTo) {
   return new Promise(resolve => {
     sessionAsyncResource.runInAsyncScope(() => {
@@ -146,6 +150,21 @@ function getSortWrapper (sort) {
   }
 }
 
+function getCreateCliWrapper (vitestPackage, frameworkVersion) {
+  shimmer.wrap(vitestPackage, 'c', oldCreateCli => function () {
+    if (!testSessionStartCh.hasSubscribers) {
+      return oldCreateCli.apply(this, arguments)
+    }
+    sessionAsyncResource.runInAsyncScope(() => {
+      const processArgv = process.argv.slice(2).join(' ')
+      testSessionStartCh.publish({ command: `vitest ${processArgv}`, frameworkVersion })
+    })
+    return oldCreateCli.apply(this, arguments)
+  })
+
+  return vitestPackage
+}
+
 addHook({
   name: 'vitest',
   versions: ['>=1.6.0'],
@@ -206,12 +225,25 @@ addHook({
   return vitestPackage
 })
 
+// There are multiple index* files across different versions of vitest,
+// so we check for the existence of BaseSequencer to determine if we are in the right file
+addHook({
+  name: 'vitest',
+  versions: ['>=1.6.0 <2.0.0'],
+  filePattern: 'dist/vendor/index.*'
+}, (vitestPackage) => {
+  if (isReporterPackage(vitestPackage)) {
+    shimmer.wrap(vitestPackage.B.prototype, 'sort', getSortWrapper)
+  }
+
+  return vitestPackage
+})
+
 addHook({
   name: 'vitest',
-  versions: ['>=2.0.0'],
+  versions: ['>=2.0.0 <2.0.5'],
   filePattern: 'dist/vendor/index.*'
 }, (vitestPackage) => {
-  // there are multiple index* files so we have to check the exported values
   if (isReporterPackageNew(vitestPackage)) {
     shimmer.wrap(vitestPackage.e.prototype, 'sort', getSortWrapper)
   }
@@ -221,12 +253,11 @@ addHook({
 
 addHook({
   name: 'vitest',
-  versions: ['>=1.6.0'],
-  filePattern: 'dist/vendor/index.*'
+  versions: ['>=2.0.5'],
+  filePattern: 'dist/chunks/index.*'
 }, (vitestPackage) => {
-  // there are multiple index* files so we have to check the exported values
-  if (isReporterPackage(vitestPackage)) {
-    shimmer.wrap(vitestPackage.B.prototype, 'sort', getSortWrapper)
+  if (isReporterPackageNewest(vitestPackage)) {
+    shimmer.wrap(vitestPackage.h.prototype, 'sort', getSortWrapper)
   }
 
   return vitestPackage
@@ -235,22 +266,15 @@ addHook({
 // Can't specify file because compiled vitest includes hashes in their files
 addHook({
   name: 'vitest',
-  versions: ['>=1.6.0'],
+  versions: ['>=1.6.0 <2.0.5'],
   filePattern: 'dist/vendor/cac.*'
-}, (vitestPackage, frameworkVersion) => {
-  shimmer.wrap(vitestPackage, 'c', oldCreateCli => function () {
-    if (!testSessionStartCh.hasSubscribers) {
-      return oldCreateCli.apply(this, arguments)
-    }
-    sessionAsyncResource.runInAsyncScope(() => {
-      const processArgv = process.argv.slice(2).join(' ')
-      testSessionStartCh.publish({ command: `vitest ${processArgv}`, frameworkVersion })
-    })
-    return oldCreateCli.apply(this, arguments)
-  })
+}, getCreateCliWrapper)
 
-  return vitestPackage
-})
+addHook({
+  name: 'vitest',
+  versions: ['>=2.0.5'],
+  filePattern: 'dist/chunks/cac.*'
+}, getCreateCliWrapper)
 
 // test suite start and finish
 // only relevant for workers
@@ -258,7 +282,7 @@ addHook({
   name: '@vitest/runner',
   versions: ['>=1.6.0'],
   file: 'dist/index.js'
-}, vitestPackage => {
+}, (vitestPackage, frameworkVersion) => {
   shimmer.wrap(vitestPackage, 'startTests', startTests => async function (testPath) {
     let testSuiteError = null
     if (!testSuiteStartCh.hasSubscribers) {
@@ -267,7 +291,7 @@ addHook({
 
     const testSuiteAsyncResource = new AsyncResource('bound-anonymous-fn')
     testSuiteAsyncResource.runInAsyncScope(() => {
-      testSuiteStartCh.publish(testPath[0])
+      testSuiteStartCh.publish({ testSuiteAbsolutePath: testPath[0], frameworkVersion })
     })
     const startTestsResponse = await startTests.apply(this, arguments)
 

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

@@ -4,6 +4,7 @@ const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 const ClientPlugin = require('../../dd-trace/src/plugins/client')
 const { storage } = require('../../datadog-core')
 const { isTrue } = require('../../dd-trace/src/util')
+const coalesce = require('koalas')
 
 class BaseAwsSdkPlugin extends ClientPlugin {
   static get id () { return 'aws' }
@@ -163,9 +164,22 @@ function normalizeConfig (config, serviceIdentifier) {
       break
   }
 
+  // check if AWS batch propagation or AWS_[SERVICE] batch propagation is enabled via env variable
+  const serviceId = serviceIdentifier.toUpperCase()
+  const batchPropagationEnabled = isTrue(
+    coalesce(
+      specificConfig.batchPropagationEnabled,
+      process.env[`DD_TRACE_AWS_SDK_${serviceId}_BATCH_PROPAGATION_ENABLED`],
+      config.batchPropagationEnabled,
+      process.env.DD_TRACE_AWS_SDK_BATCH_PROPAGATION_ENABLED,
+      false
+    )
+  )
+
+  // Merge the specific config back into the main config
   return Object.assign({}, config, specificConfig, {
     splitByAwsService: config.splitByAwsService !== false,
-    batchPropagationEnabled: config.batchPropagationEnabled !== false,
+    batchPropagationEnabled,
     hooks
   })
 }

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

@@ -156,7 +156,7 @@ class Kinesis extends BaseAwsSdkPlugin {
             span,
             params.Records[i],
             stream,
-            i === 0 || (this.config.kinesis && this.config.kinesis.batchPropagationEnabled)
+            i === 0 || (this.config.batchPropagationEnabled)
           )
         }
     }

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

@@ -63,7 +63,7 @@ class Sns extends BaseAwsSdkPlugin {
             span,
             params.PublishBatchRequestEntries[i],
             params.TopicArn,
-            i === 0 || (this.config.sns && this.config.sns.batchPropagationEnabled)
+            i === 0 || (this.config.batchPropagationEnabled)
           )
         }
         break

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

@@ -157,8 +157,8 @@ class Sqs extends BaseAwsSdkPlugin {
       if (attributes.StringValue) {
         const textMap = attributes.StringValue
         return JSON.parse(textMap)
-      } else if (attributes.Type === 'Binary') {
-        const buffer = Buffer.from(attributes.Value, 'base64')
+      } else if (attributes.Type === 'Binary' || attributes.DataType === 'Binary') {
+        const buffer = Buffer.from(attributes.Value ?? attributes.BinaryValue, 'base64')
         return JSON.parse(buffer)
       }
     } catch (e) {
@@ -222,7 +222,7 @@ class Sqs extends BaseAwsSdkPlugin {
             span,
             params.Entries[i],
             params.QueueUrl,
-            i === 0 || (this.config.sqs && this.config.sqs.batchPropagationEnabled)
+            i === 0 || (this.config.batchPropagationEnabled)
           )
         }
         break

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

@@ -258,7 +258,7 @@ class CypressPlugin {
     })
   }
 
-  getTestSpan (testName, testSuite, isUnskippable, isForcedToRun) {
+  getTestSpan ({ testName, testSuite, isUnskippable, isForcedToRun, testSourceFile }) {
     const testSuiteTags = {
       [TEST_COMMAND]: this.command,
       [TEST_COMMAND]: this.command,
@@ -282,8 +282,11 @@ class CypressPlugin {
       ...testSpanMetadata
     } = getTestCommonTags(testName, testSuite, this.cypressConfig.version, TEST_FRAMEWORK_NAME)
 
-    const codeOwners = getCodeOwnersForFilename(testSuite, this.codeOwnersEntries)
+    if (testSourceFile) {
+      testSpanMetadata[TEST_SOURCE_FILE] = testSourceFile
+    }
 
+    const codeOwners = this.getTestCodeOwners({ testSuite, testSourceFile })
     if (codeOwners) {
       testSpanMetadata[TEST_CODE_OWNERS] = codeOwners
     }
@@ -480,12 +483,16 @@ class CypressPlugin {
       const isSkippedByItr = this.testsToSkip.find(test =>
         cypressTestName === test.name && spec.relative === test.suite
       )
-      const skippedTestSpan = this.getTestSpan(cypressTestName, spec.relative)
+      let testSourceFile
+
       if (spec.absolute && this.repositoryRoot) {
-        skippedTestSpan.setTag(TEST_SOURCE_FILE, getTestSuitePath(spec.absolute, this.repositoryRoot))
+        testSourceFile = getTestSuitePath(spec.absolute, this.repositoryRoot)
       } else {
-        skippedTestSpan.setTag(TEST_SOURCE_FILE, spec.relative)
+        testSourceFile = spec.relative
       }
+
+      const skippedTestSpan = this.getTestSpan({ testName: cypressTestName, testSuite: spec.relative, testSourceFile })
+
       skippedTestSpan.setTag(TEST_STATUS, 'skip')
       if (isSkippedByItr) {
         skippedTestSpan.setTag(TEST_SKIPPED_BY_ITR, 'true')
@@ -538,11 +545,21 @@ class CypressPlugin {
         if (this.itrCorrelationId) {
           finishedTest.testSpan.setTag(ITR_CORRELATION_ID, this.itrCorrelationId)
         }
+        let testSourceFile
         if (spec.absolute && this.repositoryRoot) {
-          finishedTest.testSpan.setTag(TEST_SOURCE_FILE, getTestSuitePath(spec.absolute, this.repositoryRoot))
+          testSourceFile = getTestSuitePath(spec.absolute, this.repositoryRoot)
         } else {
-          finishedTest.testSpan.setTag(TEST_SOURCE_FILE, spec.relative)
+          testSourceFile = spec.relative
+        }
+        if (testSourceFile) {
+          finishedTest.testSpan.setTag(TEST_SOURCE_FILE, testSourceFile)
+        }
+        const codeOwners = this.getTestCodeOwners({ testSuite: spec.relative, testSourceFile })
+
+        if (codeOwners) {
+          finishedTest.testSpan.setTag(TEST_CODE_OWNERS, codeOwners)
         }
+
         finishedTest.testSpan.finish(finishedTest.finishTime)
       })
     })
@@ -591,7 +608,12 @@ class CypressPlugin {
         }
 
         if (!this.activeTestSpan) {
-          this.activeTestSpan = this.getTestSpan(testName, testSuite, isUnskippable, isForcedToRun)
+          this.activeTestSpan = this.getTestSpan({
+            testName,
+            testSuite,
+            isUnskippable,
+            isForcedToRun
+          })
         }
 
         return this.activeTestSpan ? { traceId: this.activeTestSpan.context().toTraceId() } : {}
@@ -658,6 +680,13 @@ class CypressPlugin {
       }
     }
   }
+
+  getTestCodeOwners ({ testSuite, testSourceFile }) {
+    if (testSourceFile) {
+      return getCodeOwnersForFilename(testSourceFile, this.codeOwnersEntries)
+    }
+    return getCodeOwnersForFilename(testSuite, this.codeOwnersEntries)
+  }
 }
 
 module.exports = new CypressPlugin()

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

@@ -102,7 +102,8 @@ class VitestPlugin extends CiPlugin {
       ).finish()
     })
 
-    this.addSub('ci:vitest:test-suite:start', (testSuiteAbsolutePath) => {
+    this.addSub('ci:vitest:test-suite:start', ({ testSuiteAbsolutePath, frameworkVersion }) => {
+      this.frameworkVersion = frameworkVersion
       const testSessionSpanContext = this.tracer.extract('text_map', {
         'x-datadog-trace-id': process.env.DD_CIVISIBILITY_TEST_SESSION_ID,
         'x-datadog-parent-id': process.env.DD_CIVISIBILITY_TEST_MODULE_ID