dd-trace 6.7.0 → 6.9.0

package/packages/dd-trace/src/ci-visibility/coverage-report-discovery.js

@@ -5,6 +5,8 @@ const path = require('node:path')
 
 const log = require('../log')
 
+const BIGINT_LSTAT_OPTIONS = { bigint: true, throwIfNoEntry: false }
+
 /**
  * Coverage report file patterns to search for
  * Each entry contains the relative path from root and the format identifier
@@ -38,7 +40,7 @@ const COVERAGE_REPORT_PATTERNS = [
 /**
  * Discovers code coverage report files in the given root directory
  * @param {string} rootDir - The root directory to search for coverage reports
- * @returns {Array<{filePath: string, format: string}>} Array of discovered coverage reports
+ * @returns {Array<{filePath: string, fileDevice: bigint, fileInode: bigint, format: string}>}
  */
 function discoverCoverageReports (rootDir) {
   if (!rootDir) {
@@ -46,27 +48,57 @@ function discoverCoverageReports (rootDir) {
     return []
   }
 
+  let resolvedRoot
+  try {
+    const unresolvedRoot = path.resolve(rootDir)
+    const rootStats = fs.lstatSync(unresolvedRoot, BIGINT_LSTAT_OPTIONS)
+    if (rootStats?.isSymbolicLink() || !rootStats?.isDirectory()) {
+      log.debug('Coverage report root is not a regular directory: %s', unresolvedRoot)
+      return []
+    }
+    resolvedRoot = fs.realpathSync(unresolvedRoot)
+    const resolvedRootStats = fs.lstatSync(resolvedRoot, BIGINT_LSTAT_OPTIONS)
+    if (!resolvedRootStats || resolvedRootStats.dev !== rootStats.dev || resolvedRootStats.ino !== rootStats.ino) {
+      log.debug('Coverage report root changed while resolving it: %s', unresolvedRoot)
+      return []
+    }
+  } catch (error) {
+    log.debug('Error checking coverage report root %s: %s', rootDir, error.message)
+    return []
+  }
+
   const discoveredReports = []
 
   for (const pattern of COVERAGE_REPORT_PATTERNS) {
-    const fullPath = path.join(rootDir, pattern.path)
+    let currentPath = resolvedRoot
 
     try {
-      if (fs.existsSync(fullPath)) {
-        const stats = fs.statSync(fullPath)
-
-        // Only include regular files, not directories or symlinks
-        if (stats.isFile()) {
-          discoveredReports.push({
-            filePath: fullPath,
-            format: pattern.format,
-          })
-          log.debug('Found coverage report: %s (format: %s)', fullPath, pattern.format)
+      let stats
+      for (const pathSegment of pattern.path.split('/')) {
+        currentPath = path.join(currentPath, pathSegment)
+        stats = fs.lstatSync(currentPath, BIGINT_LSTAT_OPTIONS)
+        if (!stats || stats.isSymbolicLink()) break
+      }
+
+      // A hard link can name a file outside the root without changing its real path.
+      if (stats?.isFile() && stats.nlink === 1n) {
+        const resolvedPath = fs.realpathSync(currentPath)
+        const pathFromRoot = path.relative(resolvedRoot, resolvedPath)
+        if (pathFromRoot === '..' || pathFromRoot.startsWith(`..${path.sep}`) || path.isAbsolute(pathFromRoot)) {
+          log.debug('Coverage report resolved outside the root directory: %s', currentPath)
+          continue
         }
+        discoveredReports.push({
+          filePath: resolvedPath,
+          fileDevice: stats.dev,
+          fileInode: stats.ino,
+          format: pattern.format,
+        })
+        log.debug('Found coverage report: %s (format: %s)', resolvedPath, pattern.format)
       }
-    } catch (err) {
+    } catch (error) {
       // Log but don't fail if we can't access a file
-      log.debug('Error checking coverage report path %s: %s', fullPath, err.message)
+      log.debug('Error checking coverage report path %s: %s', currentPath, error.message)
     }
   }
 

package/packages/dd-trace/src/ci-visibility/efd-retry-policy.js

@@ -0,0 +1,89 @@
+'use strict'
+
+const EARLY_FLAKE_DETECTION_RETRY_THRESHOLDS = [
+  { limitMs: 5000, key: '5s' },
+  { limitMs: 10_000, key: '10s' },
+  { limitMs: 30_000, key: '30s' },
+  { limitMs: 300_000, key: '5m' },
+]
+
+// A bucket the settings validator accepts but this module ignores silently loses its retries.
+const EARLY_FLAKE_DETECTION_RETRY_BUCKETS =
+  Object.freeze(EARLY_FLAKE_DETECTION_RETRY_THRESHOLDS.map(({ key }) => key))
+
+/**
+ * @typedef {object} EfdDurationRetryCount
+ * @property {number} durationLimitMs
+ * @property {number} retryCount
+ */
+
+/**
+ * @typedef {object} EfdRetryPolicy
+ * @property {readonly EfdDurationRetryCount[]} durationRetryCounts
+ * @property {number} schedulingRetryCount
+ */
+
+/**
+ * @param {number} durationMs
+ * @param {EfdRetryPolicy} retryPolicy
+ * @returns {number}
+ */
+function getEfdRetryCountForDuration (durationMs, retryPolicy) {
+  for (const { durationLimitMs, retryCount } of retryPolicy.durationRetryCounts) {
+    if (durationMs < durationLimitMs) {
+      return retryCount
+    }
+  }
+  return 0
+}
+
+/**
+ * @param {Record<string, unknown> | undefined} retriesByDuration
+ * @returns {EfdRetryPolicy}
+ */
+function createEfdRetryPolicy (retriesByDuration = {}) {
+  const durationRetryCounts = []
+  let schedulingRetryCount = 0
+  for (const { limitMs: durationLimitMs, key } of EARLY_FLAKE_DETECTION_RETRY_THRESHOLDS) {
+    const configuredRetryCount = retriesByDuration[key]
+    const retryCount = Number.isSafeInteger(configuredRetryCount) && configuredRetryCount >= 0
+      ? configuredRetryCount
+      : 0
+    durationRetryCounts.push(Object.freeze({ durationLimitMs, retryCount }))
+    if (retryCount > schedulingRetryCount) {
+      schedulingRetryCount = retryCount
+    }
+  }
+  return Object.freeze({
+    durationRetryCounts: Object.freeze(durationRetryCounts),
+    schedulingRetryCount,
+  })
+}
+
+/**
+ * @param {EfdRetryPolicy | undefined} retryPolicy
+ * @returns {boolean}
+ */
+function hasEfdRetries (retryPolicy) {
+  return (retryPolicy?.schedulingRetryCount ?? 0) > 0
+}
+
+/**
+ * @param {number} retryIndex
+ * @param {number | undefined} retryCount
+ * @returns {boolean}
+ */
+function shouldSkipEfdRetry (retryIndex, retryCount) {
+  return retryCount !== undefined && retryIndex > retryCount
+}
+
+const EMPTY_EFD_RETRY_POLICY = createEfdRetryPolicy()
+
+module.exports = {
+  EARLY_FLAKE_DETECTION_RETRY_BUCKETS,
+  EMPTY_EFD_RETRY_POLICY,
+  createEfdRetryPolicy,
+  getEfdRetryCountForDuration,
+  hasEfdRetries,
+  shouldSkipEfdRetry,
+}

package/packages/dd-trace/src/ci-visibility/exporters/ci-validation/sink.js

@@ -303,10 +303,11 @@ function writeNewFile (filename, payload) {
  *
  * @param {string} directory directory path
  * @param {string} label directory label
- * @returns {{dev: number, ino: number}} stable directory identity
+ * @returns {{dev: bigint, ino: bigint}} stable directory identity
  */
 function captureDirectory (directory, label) {
-  const stat = fs.lstatSync(directory)
+  // Windows file reference numbers exceed 2^53, where distinct directories round to one number.
+  const stat = fs.lstatSync(directory, { bigint: true })
   if (!stat.isDirectory() || stat.isSymbolicLink()) {
     throw new Error(`Offline Test Optimization validation ${label} must be a regular directory.`)
   }
@@ -317,10 +318,10 @@ function captureDirectory (directory, label) {
  * Creates or validates one child directory without accepting symbolic links.
  *
  * @param {string} parent parent directory path
- * @param {{dev: number, ino: number}} parentIdentity expected parent identity
+ * @param {{dev: bigint, ino: bigint}} parentIdentity expected parent identity
  * @param {string} directory child directory path
  * @param {string} label directory label
- * @returns {{dev: number, ino: number}} stable child identity
+ * @returns {{dev: bigint, ino: bigint}} stable child identity
  */
 function createDirectory (parent, parentIdentity, directory, label) {
   assertDirectoryUnchanged(parent, parentIdentity, 'parent output')
@@ -336,7 +337,7 @@ function createDirectory (parent, parentIdentity, directory, label) {
  * Rejects a directory that changed after sink construction.
  *
  * @param {string} directory directory path
- * @param {{dev: number, ino: number}} identity expected directory identity
+ * @param {{dev: bigint, ino: bigint}} identity expected directory identity
  * @param {string} label directory label
  */
 function assertDirectoryUnchanged (directory, identity, label) {
@@ -351,7 +352,7 @@ function assertDirectoryUnchanged (directory, identity, label) {
  *
  * @param {string} filename partial payload path
  * @param {string} directory expected parent directory
- * @param {{dev: number, ino: number}} identity expected parent identity
+ * @param {{dev: bigint, ino: bigint}} identity expected parent identity
  */
 function removePartialFile (filename, directory, identity) {
   try {

package/packages/dd-trace/src/ci-visibility/exporters/ci-visibility-exporter.js

@@ -4,6 +4,7 @@ const { hostname: getHostname } = require('node:os')
 const URL = require('url').URL
 
 const { version: tracerVersion } = require('../../../../../package.json')
+const { EMPTY_EFD_RETRY_POLICY, createEfdRetryPolicy } = require('../efd-retry-policy')
 const { getLibraryConfiguration: getLibraryConfigurationRequest } = require('../requests/get-library-configuration')
 const { getSkippableSuites: getSkippableSuitesRequest } = require('../intelligent-test-runner/get-skippable-suites')
 const { getKnownTests: getKnownTestsRequest } = require('../early-flake-detection/get-known-tests')
@@ -15,6 +16,7 @@ const { uploadCoverageReport: uploadCoverageReportRequest } = require('../reques
 const { uploadTestScreenshot: uploadTestScreenshotRequest } = require('../requests/upload-test-screenshot')
 const { parsers } = require('../../config/parsers')
 const log = require('../../log')
+const { getSegment } = require('../../util')
 const BufferingExporter = require('../../exporters/common/buffering-exporter')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../../plugins/util/tags')
 const { sendGitMetadata: sendGitMetadataRequest } = require('./git/git_metadata')
@@ -22,14 +24,25 @@ const { sendGitMetadata: sendGitMetadataRequest } = require('./git/git_metadata'
 const hostname = getHostname()
 const EMPTY_SETTINGS = Object.freeze({})
 
+/**
+ * Test session identity sent with every request. Fields are optional because the CI provider,
+ * the git repository or the runtime may not expose them.
+ *
+ * @typedef {{
+ *   repositoryUrl?: string, sha?: string, branch?: string, tag?: string, testLevel?: string,
+ *   osVersion?: string, osPlatform?: string, osArchitecture?: string,
+ *   runtimeName?: string, runtimeVersion?: string, commitMessage?: string,
+ *   pullRequestBaseSha?: string, commitHeadSha?: string, commitHeadMessage?: string,
+ * }} TestConfiguration
+ */
+
 function getTestConfigurationTags (tags) {
   if (!tags) {
     return {}
   }
   return Object.keys(tags).reduce((acc, key) => {
     if (key.startsWith('test.configuration.')) {
-      const [, configKey] = key.split('test.configuration.')
-      acc[configKey] = tags[key]
+      acc[getSegment(key, 'test.configuration.', 1)] = tags[key]
     }
     return acc
   }, {})
@@ -190,6 +203,7 @@ class CiVisibilityExporter extends BufferingExporter {
     const cachedSkippableSuites = this._testOptimizationHttpCache.readSkippableSuites({
       testLevel: requestConfiguration.testLevel,
       isCoverageReportUploadEnabled: requestConfiguration.isCoverageReportUploadEnabled,
+      isLineCoverageSupported: requestConfiguration.isLineCoverageSupported,
     })
     if (cachedSkippableSuites !== CACHE_MISS) {
       const { skippableSuites, correlationId, coverage } = cachedSkippableSuites
@@ -238,6 +252,10 @@ class CiVisibilityExporter extends BufferingExporter {
   /**
    * We can't request library configuration until we know whether we can use the
    * CI Visibility Protocol, hence the this._canUseCiVisProtocol promise.
+   *
+   * @param {TestConfiguration} testConfiguration
+   * @param {(error: Error | null, libraryConfig?: Readonly<Record<string, unknown>>) => void} callback
+   * @returns {void}
    */
   getLibraryConfiguration (testConfiguration, callback) {
     const { repositoryUrl } = testConfiguration
@@ -321,21 +339,14 @@ class CiVisibilityExporter extends BufferingExporter {
       DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES: configuredAttemptToFixRetries = 0,
       DD_TEST_MANAGEMENT_ENABLED: isTestManagementAllowed,
     } = testOptimization
-    const hasEarlyFlakeDetectionRetryCount = earlyFlakeDetectionRetryCount !== undefined
-    const configuredSlowTestRetries = remoteConfiguration.earlyFlakeDetectionSlowTestRetries ?? EMPTY_SETTINGS
-    const earlyFlakeDetectionSlowTestRetries = hasEarlyFlakeDetectionRetryCount
-      ? Object.freeze({
+    const earlyFlakeDetectionRetryPolicy = earlyFlakeDetectionRetryCount === undefined
+      ? remoteConfiguration.earlyFlakeDetectionRetryPolicy ?? EMPTY_EFD_RETRY_POLICY
+      : createEfdRetryPolicy({
         '5s': earlyFlakeDetectionRetryCount,
         '10s': earlyFlakeDetectionRetryCount,
         '30s': earlyFlakeDetectionRetryCount,
         '5m': earlyFlakeDetectionRetryCount,
       })
-      : Object.isFrozen(configuredSlowTestRetries)
-        ? configuredSlowTestRetries
-        : Object.freeze({ ...configuredSlowTestRetries })
-    const earlyFlakeDetectionNumRetries = hasEarlyFlakeDetectionRetryCount
-      ? earlyFlakeDetectionRetryCount
-      : remoteConfiguration.earlyFlakeDetectionNumRetries ?? 0
     const testManagementAttemptToFixRetries =
       remoteConfiguration.testManagementAttemptToFixRetries ?? configuredAttemptToFixRetries
 
@@ -346,8 +357,7 @@ class CiVisibilityExporter extends BufferingExporter {
       requireGit: remoteConfiguration.requireGit === true,
       isEarlyFlakeDetectionEnabled:
         remoteConfiguration.isEarlyFlakeDetectionEnabled === true && isEarlyFlakeDetectionAllowed === true,
-      earlyFlakeDetectionNumRetries,
-      earlyFlakeDetectionSlowTestRetries,
+      earlyFlakeDetectionRetryPolicy,
       earlyFlakeDetectionFaultyThreshold: remoteConfiguration.earlyFlakeDetectionFaultyThreshold ?? 30,
       isFlakyTestRetriesEnabled:
         remoteConfiguration.isFlakyTestRetriesEnabled === true && isFlakyTestRetriesAllowed === true,
@@ -521,17 +531,21 @@ class CiVisibilityExporter extends BufferingExporter {
    * Uploads a single coverage report to the CI intake.
    * @param {object} options - Upload options
    * @param {string} options.filePath - Path to the coverage report file
+   * @param {bigint} options.fileDevice - Device containing the discovered report
+   * @param {bigint} options.fileInode - Inode of the discovered report
    * @param {string} options.format - Format of the coverage report
    * @param {object} options.testEnvironmentMetadata - Test environment metadata containing git/CI tags
    * @param {(error: Error|null) => void} callback - Callback function
    */
-  uploadCoverageReport ({ filePath, format, testEnvironmentMetadata }, callback) {
+  uploadCoverageReport ({ filePath, fileDevice, fileInode, format, testEnvironmentMetadata }, callback) {
     if (!this._codeCoverageReportUrl) {
       return callback(new Error('Coverage report upload URL not configured'))
     }
 
     uploadCoverageReportRequest({
       filePath,
+      fileDevice,
+      fileInode,
       format,
       flags: this._coverageReportFlags,
       testEnvironmentMetadata,

package/packages/dd-trace/src/ci-visibility/exporters/git/git_metadata.js

@@ -8,6 +8,7 @@ const FormData = require('../../../exporters/common/form-data')
 const request = require('../../../exporters/common/request')
 
 const log = require('../../../log')
+const { getSegment } = require('../../../util')
 const {
   getLatestCommits,
   getRepositoryUrl,
@@ -31,6 +32,9 @@ const {
   TELEMETRY_GIT_REQUESTS_OBJECT_PACKFILES_BYTES,
 } = require('../../../ci-visibility/telemetry')
 
+/** @typedef {{ isEvpProxy: boolean, evpProxyPrefix: string }} EvpProxyConfiguration */
+/** @typedef {EvpProxyConfiguration & { url: URL, repositoryUrl: string }} GitUploadTarget */
+
 const isValidSha1 = (sha) => /^[0-9a-f]{40}$/.test(sha)
 const isValidSha256 = (sha) => /^[0-9a-f]{64}$/.test(sha)
 
@@ -61,6 +65,10 @@ function getCommonRequestOptions (url) {
  * This function posts the SHAs of the commits of the last month
  * The response are the commits for which the backend already has information
  * This response is used to know which commits can be ignored from there on
+ *
+ * @param {GitUploadTarget & { latestCommits: string[] }} options
+ * @param {(error: Error | null, commitsToUpload?: string[]) => void} callback
+ * @returns {void}
  */
 function getCommitsToUpload ({ url, repositoryUrl, latestCommits, isEvpProxy, evpProxyPrefix }, callback) {
   const commonOptions = getCommonRequestOptions(url)
@@ -126,6 +134,10 @@ function getCommitsToUpload ({ url, repositoryUrl, latestCommits, isEvpProxy, ev
 
 /**
  * This function uploads a git packfile
+ *
+ * @param {GitUploadTarget & { packFileToUpload: string, headCommit: string }} options
+ * @param {(error: Error | null, uploadSize?: number) => void} callback
+ * @returns {void}
  */
 function uploadPackFile ({ url, isEvpProxy, evpProxyPrefix, packFileToUpload, repositoryUrl, headCommit }, callback) {
   const form = new FormData()
@@ -145,7 +157,7 @@ function uploadPackFile ({ url, isEvpProxy, evpProxyPrefix, packFileToUpload, re
   try {
     const packFileContent = fs.readFileSync(packFileToUpload)
     // The original filename includes a random prefix, so we remove it here
-    const [, filename] = path.basename(packFileToUpload).split('-')
+    const filename = getSegment(path.basename(packFileToUpload), '-', 1)
     form.append('packfile', packFileContent, {
       filename,
       contentType: 'application/octet-stream',
@@ -244,6 +256,12 @@ function generateAndUploadPackFiles ({
 
 /**
  * This function uploads git metadata to CI Visibility's backend.
+ *
+ * @param {URL} url
+ * @param {EvpProxyConfiguration} evpProxyConfiguration
+ * @param {string | undefined} configRepositoryUrl repository URL from the configuration, if set
+ * @param {(error?: Error | null) => void} callback
+ * @returns {void}
  */
 function sendGitMetadata (url, { isEvpProxy, evpProxyPrefix }, configRepositoryUrl, callback) {
   if (!isGitAvailable()) {

package/packages/dd-trace/src/ci-visibility/exporters/test-worker/index.js

@@ -5,11 +5,17 @@ const {
   JEST_WORKER_TRACE_PAYLOAD_CODE,
   JEST_WORKER_TELEMETRY_PAYLOAD_CODE,
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
+  CUCUMBER_WORKER_TELEMETRY_PAYLOAD_CODE,
+  MOCHA_WORKER_LOGS_PAYLOAD_CODE,
+  MOCHA_WORKER_TELEMETRY_PAYLOAD_CODE,
   MOCHA_WORKER_TRACE_PAYLOAD_CODE,
   JEST_WORKER_LOGS_PAYLOAD_CODE,
+  PLAYWRIGHT_WORKER_TELEMETRY_PAYLOAD_CODE,
   PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE,
   VITEST_WORKER_TRACE_PAYLOAD_CODE,
+  VITEST_WORKER_COVERAGE_PAYLOAD_CODE,
   VITEST_WORKER_LOGS_PAYLOAD_CODE,
+  VITEST_WORKER_TELEMETRY_PAYLOAD_CODE,
 } = require('../../../plugins/util/test')
 const getConfig = require('../../../config')
 const { getEnvironmentVariable } = require('../../../config/helper')
@@ -43,6 +49,9 @@ function getInterprocessCoverageCode () {
   if (getEnvironmentVariable('JEST_WORKER_ID')) {
     return JEST_WORKER_COVERAGE_PAYLOAD_CODE
   }
+  if (getEnvironmentVariable('TINYPOOL_WORKER_ID') || getConfig().DD_VITEST_WORKER) {
+    return VITEST_WORKER_COVERAGE_PAYLOAD_CODE
+  }
   return null
 }
 
@@ -50,6 +59,9 @@ function getInterprocessLogsCode () {
   if (getEnvironmentVariable('JEST_WORKER_ID')) {
     return JEST_WORKER_LOGS_PAYLOAD_CODE
   }
+  if (getEnvironmentVariable('MOCHA_WORKER_ID') === 'webdriverio') {
+    return MOCHA_WORKER_LOGS_PAYLOAD_CODE
+  }
   if (getEnvironmentVariable('TINYPOOL_WORKER_ID')) {
     return VITEST_WORKER_LOGS_PAYLOAD_CODE
   }
@@ -63,6 +75,19 @@ function getInterprocessTelemetryCode () {
   if (getEnvironmentVariable('JEST_WORKER_ID')) {
     return JEST_WORKER_TELEMETRY_PAYLOAD_CODE
   }
+  if (getEnvironmentVariable('CUCUMBER_WORKER_ID')) {
+    return CUCUMBER_WORKER_TELEMETRY_PAYLOAD_CODE
+  }
+  if (getEnvironmentVariable('MOCHA_WORKER_ID')) {
+    return MOCHA_WORKER_TELEMETRY_PAYLOAD_CODE
+  }
+  const { DD_PLAYWRIGHT_WORKER, DD_VITEST_WORKER } = getConfig()
+  if (DD_PLAYWRIGHT_WORKER) {
+    return PLAYWRIGHT_WORKER_TELEMETRY_PAYLOAD_CODE
+  }
+  if (getEnvironmentVariable('TINYPOOL_WORKER_ID') || DD_VITEST_WORKER) {
+    return VITEST_WORKER_TELEMETRY_PAYLOAD_CODE
+  }
   return null
 }
 
@@ -81,7 +106,6 @@ class TestWorkerCiVisibilityExporter {
     this._writer = new Writer(interprocessTraceCode)
     this._coverageWriter = new Writer(interprocessCoverageCode)
     this._logsWriter = new Writer(interprocessLogsCode)
-    // TODO: add support for test workers other than Jest
     if (interprocessTelemetryCode) {
       this._telemetryWriter = new Writer(interprocessTelemetryCode)
       this.exportTelemetry = function (telemetryEvent) {

package/packages/dd-trace/src/ci-visibility/exporters/test-worker/webdriverio.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const WEBDRIVERIO_WORKER_ENV = '_DD_TEST_OPTIMIZATION_WEBDRIVERIO_WORKER'
+const WEBDRIVERIO_WORKER_EVENT = 'workerEvent'
+const WEBDRIVERIO_WORKER_ORIGIN = 'datadog'
+
+/**
+ * Wraps an internal worker payload in the event WebdriverIO reserves for worker messages.
+ *
+ * @param {unknown} args
+ * @returns {{args: unknown, name: string, origin: string}}
+ */
+function createWebdriverioWorkerMessage (args) {
+  return {
+    origin: WEBDRIVERIO_WORKER_ORIGIN,
+    name: WEBDRIVERIO_WORKER_EVENT,
+    args,
+  }
+}
+
+module.exports = {
+  createWebdriverioWorkerMessage,
+  WEBDRIVERIO_WORKER_ENV,
+  WEBDRIVERIO_WORKER_EVENT,
+  WEBDRIVERIO_WORKER_ORIGIN,
+}

package/packages/dd-trace/src/ci-visibility/exporters/test-worker/writer.js

@@ -2,6 +2,10 @@
 const { JSONEncoder } = require('../../encode/json-encoder')
 const { getEnvironmentVariable } = require('../../../config/helper')
 const log = require('../../../log')
+const {
+  createWebdriverioWorkerMessage,
+  WEBDRIVERIO_WORKER_ENV,
+} = require('./webdriverio')
 
 function getVitestWorkerPort () {
   const port = globalThis.__vitest_worker__?.ctx?.port
@@ -13,6 +17,7 @@ class Writer {
     this._encoder = new JSONEncoder()
     // Code used to identify the type of payload being sent to the main process
     this._interprocessCode = interprocessCode
+    this._isWebdriverioWorker = !!getEnvironmentVariable(WEBDRIVERIO_WORKER_ENV)
   }
 
   /**
@@ -43,9 +48,12 @@ class Writer {
     // Old because vitest@>=4 uses `DD_VITEST_WORKER` and reports arrays just like other frameworks
     // Before vitest@>=4, we need the `__tinypool_worker_message__` property, or tinypool will crash
     const isVitestWorkerOld = !!getEnvironmentVariable('TINYPOOL_WORKER_ID')
-    const payload = isVitestWorkerOld
+    let payload = isVitestWorkerOld
       ? { __tinypool_worker_message__: true, interprocessCode: this._interprocessCode, data }
       : [this._interprocessCode, data]
+    if (this._isWebdriverioWorker) {
+      payload = createWebdriverioWorkerMessage(payload)
+    }
 
     const vitestWorkerPort = getVitestWorkerPort()
     if (vitestWorkerPort) {

package/packages/dd-trace/src/ci-visibility/intelligent-test-runner/get-skippable-suites.js

@@ -25,6 +25,7 @@ function parseSkippableSuitesResponse (
   {
     testLevel = 'suite',
     isCoverageReportUploadEnabled = false,
+    isLineCoverageSupported = true,
     validateRequiredFields = false,
     validationMode = false,
   } = {}
@@ -34,8 +35,11 @@ function parseSkippableSuitesResponse (
     validateSkippableTestsResponse(parsedResponse, { validationMode })
   }
   const coverage = {}
-  for (const [filename, bitmap] of Object.entries(parsedResponse.meta?.coverage || {})) {
-    coverage[filename.replaceAll('\\', '/')] = bitmap
+  const coverageByFilename = parsedResponse.meta?.coverage
+  if (coverageByFilename) {
+    for (const [filename, bitmap] of Object.entries(coverageByFilename)) {
+      coverage[filename.replaceAll('\\', '/')] = bitmap
+    }
   }
 
   const skippableItems = parsedResponse
@@ -51,7 +55,7 @@ function parseSkippableSuitesResponse (
     },
   } of skippableItems) {
     // Only reject candidates without backend line coverage when we need that coverage to backfill reports.
-    if (isCoverageReportUploadEnabled && isMissingLineCodeCoverage) {
+    if (isCoverageReportUploadEnabled && isLineCoverageSupported && isMissingLineCodeCoverage) {
       numExcludedByMissingLineCoverage++
       continue
     }
@@ -78,10 +82,11 @@ function parseSkippableSuitesResponse (
  *   numExcludedByMissingLineCoverage?: number
  * }} result - Parsed skippable response.
  * @param {'suite'|'test'} testLevel - Test optimization skipping level.
+ * @param {boolean} shouldConsiderLineCoverage - Whether line coverage can affect suite skipping.
  * @returns {void}
  */
-function logSkippableSuitesResponse (result, testLevel) {
-  if (result.numReceivedSkippableItems === undefined) {
+function logSkippableSuitesResponse (result, testLevel, shouldConsiderLineCoverage) {
+  if (!shouldConsiderLineCoverage || result.numReceivedSkippableItems === undefined) {
     log.debug('Number of received skippable %ss: %d', testLevel, result.skippableSuites.length)
     return
   }
@@ -122,10 +127,12 @@ function getSkippableSuites ({
   custom,
   testLevel = 'suite',
   isCoverageReportUploadEnabled = false,
+  isLineCoverageSupported = true,
 }, done) {
+  const shouldConsiderLineCoverage = isCoverageReportUploadEnabled && isLineCoverageSupported
   const cacheKey = buildCacheKey('skippable', [
     sha, service, env, repositoryUrl, osPlatform, osVersion, osArchitecture,
-    runtimeName, runtimeVersion, testLevel, custom, isCoverageReportUploadEnabled,
+    runtimeName, runtimeVersion, testLevel, custom, shouldConsiderLineCoverage,
   ])
 
   withCache(cacheKey, (activeCacheKey, cb) => {
@@ -146,11 +153,16 @@ function getSkippableSuites ({
       custom,
       testLevel,
       isCoverageReportUploadEnabled,
+      isLineCoverageSupported,
       cacheKey: activeCacheKey,
     }, cb)
   }, (err, data) => {
     if (err) return done(err)
-    logSkippableSuitesResponse(data, testLevel)
+    logSkippableSuitesResponse(
+      data,
+      testLevel,
+      shouldConsiderLineCoverage
+    )
     done(null, data.skippableSuites, data.correlationId, data.coverage)
   })
 }
@@ -175,6 +187,7 @@ function getSkippableSuites ({
  * @param {object} [params.custom]
  * @param {string} [params.testLevel]
  * @param {boolean} [params.isCoverageReportUploadEnabled]
+ * @param {boolean} [params.isLineCoverageSupported]
  * @param {string | null} params.cacheKey
  * @param {Function} done
  */
@@ -195,6 +208,7 @@ function fetchFromApi ({
   custom,
   testLevel,
   isCoverageReportUploadEnabled,
+  isLineCoverageSupported,
   cacheKey,
 }, done) {
   const options = {
@@ -258,6 +272,7 @@ function fetchFromApi ({
         const result = parseSkippableSuitesResponse(parsedResponse, {
           testLevel,
           isCoverageReportUploadEnabled,
+          isLineCoverageSupported,
           validateRequiredFields: true,
         })
         const skippableItems = parsedResponse.data.filter(({ type }) => type === testLevel)