dd-trace 6.8.0 → 6.9.0

package/packages/dd-trace/src/appsec/sdk/track_event.js

@@ -11,6 +11,10 @@ const { getRootSpan } = require('./utils')
 
 /**
  * @deprecated in favor of trackUserLoginSuccessV2
+ * @param {import('../../tracer')} tracer
+ * @param {import('../../../../../index').User} user
+ * @param {Record<string, string>} [metadata]
+ * @returns {void}
  */
 function trackUserLoginSuccessEvent (tracer, user, metadata) {
   // TODO: better user check here and in _setUser() ?
@@ -40,6 +44,11 @@ function trackUserLoginSuccessEvent (tracer, user, metadata) {
 
 /**
  * @deprecated in favor of trackUserLoginFailureV2
+ * @param {import('../../tracer')} tracer
+ * @param {string} userId
+ * @param {boolean} exists
+ * @param {Record<string, string>} [metadata]
+ * @returns {void}
  */
 function trackUserLoginFailureEvent (tracer, userId, exists, metadata) {
   if (!userId || typeof userId !== 'string') {

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-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')
@@ -23,6 +24,18 @@ 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 {}
@@ -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

@@ -32,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)
 
@@ -62,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)
@@ -127,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()
@@ -245,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,12 +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')
@@ -44,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
 }
 
@@ -67,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
 }
 
@@ -85,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/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)

package/packages/dd-trace/src/ci-visibility/requests/get-library-configuration.js

@@ -3,6 +3,7 @@
 const getConfig = require('../../config')
 const id = require('../../id')
 const log = require('../../log')
+const { EARLY_FLAKE_DETECTION_RETRY_BUCKETS, createEfdRetryPolicy } = require('../efd-retry-policy')
 const {
   incrementCountMetric,
   distributionMetric,
@@ -15,21 +16,20 @@ const { writeSettingsToCache } = require('../test-optimization-cache')
 const { MAX_RETRIES, validateSettingsResponse } = require('../test-optimization-http-cache-schema')
 const request = require('./request')
 
-const DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES = 2
 const DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES = Object.freeze({
   '5s': 10,
   '10s': 5,
   '30s': 3,
   '5m': 2,
 })
+const DEFAULT_EARLY_FLAKE_DETECTION_RETRY_POLICY =
+  createEfdRetryPolicy(DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES)
 const DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD = 30
-const EARLY_FLAKE_DETECTION_RETRY_BUCKETS = Object.keys(DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES)
 
 /**
  * @typedef {object} EarlyFlakeDetectionSettings
  * @property {boolean} enabled
- * @property {number} numRetries
- * @property {Readonly<Record<string, number>>} slowTestRetries
+ * @property {import('../efd-retry-policy').EfdRetryPolicy} retryPolicy
  * @property {number} faultyThreshold
  */
 
@@ -90,20 +90,17 @@ function parseEarlyFlakeDetectionSettings (value, isKnownTestsEnabled) {
   if (!isRecord(value) || value.enabled !== true) {
     return {
       enabled: false,
-      numRetries: DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
-      slowTestRetries: DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES,
+      retryPolicy: DEFAULT_EARLY_FLAKE_DETECTION_RETRY_POLICY,
       faultyThreshold: DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD,
     }
   }
 
   let isValid = true
-  let numRetries = DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES
-  let slowTestRetries = DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES
+  let retryPolicy = DEFAULT_EARLY_FLAKE_DETECTION_RETRY_POLICY
   if (Object.hasOwn(value, 'slow_test_retries')) {
     const parsedSlowTestRetries = parseSlowTestRetries(value.slow_test_retries)
     if (parsedSlowTestRetries) {
-      slowTestRetries = parsedSlowTestRetries
-      numRetries = parsedSlowTestRetries['5s'] ?? DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES
+      retryPolicy = createEfdRetryPolicy(parsedSlowTestRetries)
     } else {
       isValid = false
     }
@@ -120,8 +117,7 @@ function parseEarlyFlakeDetectionSettings (value, isKnownTestsEnabled) {
 
   return {
     enabled: isKnownTestsEnabled && isValid,
-    numRetries,
-    slowTestRetries,
+    retryPolicy,
     faultyThreshold,
   }
 }
@@ -180,8 +176,7 @@ function parseLibraryConfigurationResponse (rawJson, config = getConfig(), optio
     isItrEnabled: attributes.itr_enabled === true,
     requireGit: attributes.require_git === true,
     isEarlyFlakeDetectionEnabled: earlyFlakeDetection.enabled,
-    earlyFlakeDetectionNumRetries: earlyFlakeDetection.numRetries,
-    earlyFlakeDetectionSlowTestRetries: earlyFlakeDetection.slowTestRetries,
+    earlyFlakeDetectionRetryPolicy: earlyFlakeDetection.retryPolicy,
     earlyFlakeDetectionFaultyThreshold: earlyFlakeDetection.faultyThreshold,
     isFlakyTestRetriesEnabled,
     isDiEnabled: attributes.di_enabled === true && isFlakyTestRetriesEnabled,

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { readFileSync } = require('node:fs')
+const { closeSync, constants, fstatSync, openSync, readFileSync } = require('node:fs')
 const { gzipSync } = require('node:zlib')
 
 const getConfig = require('../../config')
@@ -17,12 +17,18 @@ const {
 } = require('../telemetry')
 
 const UPLOAD_TIMEOUT_MS = 30_000
+const COVERAGE_FILE_OPEN_FLAGS = constants.O_RDONLY |
+  (constants.O_NOFOLLOW || 0) |
+  constants.O_NONBLOCK
+const BIGINT_STAT_OPTIONS = { bigint: true }
 
 /**
  * Uploads a single coverage report to the Datadog CI intake.
  * One file per request with field names 'coverage' and 'event'.
  * @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 (e.g., 'lcov', 'cobertura')
  * @param {string[]} [options.flags] - Optional coverage report grouping flags
  * @param {object} options.testEnvironmentMetadata - Test environment metadata containing git/CI tags
@@ -32,7 +38,7 @@ const UPLOAD_TIMEOUT_MS = 30_000
  * @param {(error: Error|null) => void} callback - Callback function
  */
 function uploadCoverageReport (
-  { filePath, format, flags, testEnvironmentMetadata, url, isEvpProxy, evpProxyPrefix },
+  { filePath, fileDevice, fileInode, format, flags, testEnvironmentMetadata, url, isEvpProxy, evpProxyPrefix },
   callback
 ) {
   const { DD_API_KEY } = getConfig()
@@ -43,10 +49,20 @@ function uploadCoverageReport (
 
   let compressedCoverage
   try {
-    const coverageContent = readFileSync(filePath)
+    const fileDescriptor = openSync(filePath, COVERAGE_FILE_OPEN_FLAGS)
+    let coverageContent
+    try {
+      const fileStats = fstatSync(fileDescriptor, BIGINT_STAT_OPTIONS)
+      if (!fileStats.isFile() || fileStats.dev !== fileDevice || fileStats.ino !== fileInode) {
+        throw new Error('Coverage report changed after discovery')
+      }
+      coverageContent = readFileSync(fileDescriptor)
+    } finally {
+      closeSync(fileDescriptor)
+    }
     compressedCoverage = gzipSync(coverageContent)
-  } catch (err) {
-    return callback(new Error(`Failed to read coverage report at ${filePath}: ${err.message}`))
+  } catch (error) {
+    return callback(new Error(`Failed to read coverage report at ${filePath}: ${error.message}`))
   }
 
   // Build the event payload with format, type, and all tags from test environment metadata

package/packages/dd-trace/src/ci-visibility/test-optimization-http-cache-schema.js

@@ -137,7 +137,7 @@ function validateSkippableTestsResponse (response, options = {}) {
   if (response.meta !== undefined) {
     assertObject(response.meta, 'Invalid skippable tests response: meta must be an object')
   }
-  if (response.meta?.coverage !== undefined) {
+  if (response.meta?.coverage !== undefined && response.meta.coverage !== null) {
     assertObject(response.meta.coverage, 'Invalid skippable tests response: meta.coverage must be an object')
   }
   if (response.meta?.correlation_id !== undefined && typeof response.meta.correlation_id !== 'string') {

package/packages/dd-trace/src/ci-visibility/test-optimization-http-cache.js

@@ -145,7 +145,11 @@ class TestOptimizationHttpCache {
         validationMode: Boolean(this._validationManifestPath),
       })
       const testLevel = options.testLevel || 'suite'
-      logSkippableSuitesResponse(result, testLevel)
+      logSkippableSuitesResponse(
+        result,
+        testLevel,
+        options.isCoverageReportUploadEnabled && options.isLineCoverageSupported !== false
+      )
       const skippableItems = parsedResponse.data.filter(({ type }) => type === testLevel)
       incrementCountMetric(
         testLevel === 'test'