dd-trace 6.3.0 → 6.5.0

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

@@ -22,18 +22,27 @@ function parseJsonResponse (rawJson) {
 
 function parseSkippableSuitesResponse (
   rawJson,
-  { testLevel = 'suite', isCoverageReportUploadEnabled = false, validateRequiredFields = false } = {}
+  {
+    testLevel = 'suite',
+    isCoverageReportUploadEnabled = false,
+    validateRequiredFields = false,
+    validationMode = false,
+  } = {}
 ) {
   const parsedResponse = parseJsonResponse(rawJson)
   if (validateRequiredFields) {
-    validateSkippableTestsResponse(parsedResponse)
+    validateSkippableTestsResponse(parsedResponse, { validationMode })
+  }
+  const coverage = {}
+  for (const [filename, bitmap] of Object.entries(parsedResponse.meta?.coverage || {})) {
+    coverage[filename.replaceAll('\\', '/')] = bitmap
   }
-  const coverage = parsedResponse.meta?.coverage || {}
 
   const skippableItems = parsedResponse
     .data
     .filter(({ type }) => type === testLevel)
   const skippableSuites = []
+  let numExcludedByMissingLineCoverage = 0
   for (const {
     attributes: {
       suite,
@@ -42,13 +51,58 @@ function parseSkippableSuitesResponse (
     },
   } of skippableItems) {
     // Only reject candidates without backend line coverage when we need that coverage to backfill reports.
-    if (isCoverageReportUploadEnabled && isMissingLineCodeCoverage) continue
+    if (isCoverageReportUploadEnabled && isMissingLineCodeCoverage) {
+      numExcludedByMissingLineCoverage++
+      continue
+    }
 
     skippableSuites.push(testLevel === 'suite' ? suite : { suite, name })
   }
   const correlationId = parsedResponse.meta?.correlation_id
 
-  return { skippableSuites, correlationId, coverage }
+  return {
+    skippableSuites,
+    correlationId,
+    coverage,
+    numReceivedSkippableItems: skippableItems.length,
+    numExcludedByMissingLineCoverage,
+  }
+}
+
+/**
+ * Logs how missing line coverage affected the skippable candidates without logging their contents.
+ *
+ * @param {{
+ *   skippableSuites: Array<string|{suite: string, name: string}>,
+ *   numReceivedSkippableItems?: number,
+ *   numExcludedByMissingLineCoverage?: number
+ * }} result - Parsed skippable response.
+ * @param {'suite'|'test'} testLevel - Test optimization skipping level.
+ * @returns {void}
+ */
+function logSkippableSuitesResponse (result, testLevel) {
+  if (result.numReceivedSkippableItems === undefined) {
+    log.debug('Number of received skippable %ss: %d', testLevel, result.skippableSuites.length)
+    return
+  }
+
+  log.debug(
+    'Received %d skippable %s candidates; excluded %d because line coverage is missing; %d remain.',
+    result.numReceivedSkippableItems,
+    testLevel,
+    result.numExcludedByMissingLineCoverage,
+    result.skippableSuites.length
+  )
+  if (
+    result.numReceivedSkippableItems > 0 &&
+    result.numExcludedByMissingLineCoverage === result.numReceivedSkippableItems
+  ) {
+    log.warn(
+      'All %d skippable %s candidates were excluded: coverage upload is enabled but line coverage is missing.',
+      result.numReceivedSkippableItems,
+      testLevel
+    )
+  }
 }
 
 function getSkippableSuites ({
@@ -96,6 +150,7 @@ function getSkippableSuites ({
     }, cb)
   }, (err, data) => {
     if (err) return done(err)
+    logSkippableSuitesResponse(data, testLevel)
     done(null, data.skippableSuites, data.correlationId, data.coverage)
   })
 }
@@ -203,6 +258,7 @@ function fetchFromApi ({
         const result = parseSkippableSuitesResponse(parsedResponse, {
           testLevel,
           isCoverageReportUploadEnabled,
+          validateRequiredFields: true,
         })
         const skippableItems = parsedResponse.data.filter(({ type }) => type === testLevel)
         incrementCountMetric(
@@ -213,7 +269,6 @@ function fetchFromApi ({
           skippableItems.length
         )
         distributionMetric(TELEMETRY_ITR_SKIPPABLE_TESTS_RESPONSE_BYTES, {}, res.length)
-        log.debug('Number of received skippable %ss:', testLevel, result.skippableSuites.length)
 
         writeToCache(cacheKey, result)
 
@@ -225,4 +280,4 @@ function fetchFromApi ({
   })
 }
 
-module.exports = { getSkippableSuites, parseSkippableSuitesResponse }
+module.exports = { getSkippableSuites, logSkippableSuitesResponse, parseSkippableSuitesResponse }

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

@@ -26,7 +26,7 @@ function parseJsonResponse (rawJson) {
 function parseLibraryConfigurationResponse (rawJson, config = getConfig(), options = {}) {
   const parsedResponse = parseJsonResponse(rawJson)
   if (options.validateRequiredFields) {
-    validateSettingsResponse(parsedResponse)
+    validateSettingsResponse(parsedResponse, options)
   }
   const {
     code_coverage: isCodeCoverageEnabled,
@@ -49,7 +49,7 @@ function parseLibraryConfigurationResponse (rawJson, config = getConfig(), optio
     requireGit,
     isEarlyFlakeDetectionEnabled: isKnownTestsEnabled && (earlyFlakeDetectionConfig?.enabled ?? false),
     earlyFlakeDetectionNumRetries:
-      earlyFlakeDetectionConfig?.slow_test_retries?.['5s'] || DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
+      earlyFlakeDetectionConfig?.slow_test_retries?.['5s'] ?? DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
     earlyFlakeDetectionSlowTestRetries:
       earlyFlakeDetectionConfig?.slow_test_retries ?? DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES,
     earlyFlakeDetectionFaultyThreshold:
@@ -74,6 +74,13 @@ function parseLibraryConfigurationResponse (rawJson, config = getConfig(), optio
     settings.isSuitesSkippingEnabled = true
     log.debug('Dangerously set test skipping to true')
   }
+  if (
+    settings.isCoverageReportUploadEnabled &&
+    !config.testOptimization.DD_CIVISIBILITY_CODE_COVERAGE_REPORT_UPLOAD_ENABLED
+  ) {
+    settings.isCoverageReportUploadEnabled = false
+    log.debug('Code coverage report upload was disabled by the environment variable')
+  }
 
   return settings
 }

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

@@ -24,14 +24,15 @@ const UPLOAD_TIMEOUT_MS = 30_000
  * @param {object} options - Upload options
  * @param {string} options.filePath - Path to the coverage report file
  * @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
  * @param {URL} options.url - The base URL for the coverage report upload
  * @param {boolean} [options.isEvpProxy] - Whether to use EVP proxy for the upload
  * @param {string} [options.evpProxyPrefix] - The EVP proxy prefix (e.g., '/evp_proxy/v4')
- * @param {Function} callback - Callback function (err)
+ * @param {(error: Error|null) => void} callback - Callback function
  */
 function uploadCoverageReport (
-  { filePath, format, testEnvironmentMetadata, url, isEvpProxy, evpProxyPrefix },
+  { filePath, format, flags, testEnvironmentMetadata, url, isEvpProxy, evpProxyPrefix },
   callback
 ) {
   const { DD_API_KEY } = getConfig()
@@ -54,6 +55,9 @@ function uploadCoverageReport (
     format,
     ...testEnvironmentMetadata,
   }
+  if (flags?.length) {
+    eventPayload['report.flags'] = flags
+  }
 
   // Create multipart form
   const form = new FormData()

package/packages/dd-trace/src/ci-visibility/rum.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const RUM_TEST_EXECUTION_ID_COOKIE_NAME = 'datadog-ci-visibility-test-execution-id'
+
+module.exports = {
+  RUM_TEST_EXECUTION_ID_COOKIE_NAME,
+}

package/packages/dd-trace/src/ci-visibility/test-api-manual/test-api-manual-plugin.js

@@ -28,12 +28,16 @@ class TestApiManualPlugin extends CiPlugin {
       const store = legacyStorage.getStore()
       const testSpan = store && store.span
       if (testSpan) {
+        const previousStore = testSpan._store === undefined
+          ? undefined
+          : legacyStorage.getStore(testSpan._store)
         testSpan.setTag(TEST_STATUS, status)
         if (error) {
           testSpan.setTag('error', error)
         }
         testSpan.finish()
         finishAllTraceSpans(testSpan)
+        legacyStorage.enterWith(previousStore)
       }
     })
     this.unconfiguredAddSub('dd-trace:ci:manual:test:addTags', (tags) => {

package/packages/dd-trace/src/ci-visibility/test-management/get-test-management-tests.js

@@ -47,7 +47,7 @@ function parseJsonResponse (rawJson) {
 function parseTestManagementTestsResponse (rawJson, options = {}) {
   const parsedResponse = parseJsonResponse(rawJson)
   if (options.validateRequiredFields) {
-    validateTestManagementTestsResponse(parsedResponse)
+    validateTestManagementTestsResponse(parsedResponse, options)
   }
   const { data: { attributes: { modules: testManagementTests } } } = parsedResponse
   return testManagementTests

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

@@ -13,6 +13,25 @@ const REQUIRED_SETTINGS_KEYS = [
   'impacted_tests_enabled',
   'coverage_report_upload_enabled',
 ]
+const SETTINGS_BOOLEAN_KEYS = [
+  'code_coverage',
+  'tests_skipping',
+  'itr_enabled',
+  'require_git',
+  'flaky_test_retries_enabled',
+  'di_enabled',
+  'known_tests_enabled',
+  'impacted_tests_enabled',
+  'coverage_report_upload_enabled',
+]
+const EARLY_FLAKE_DETECTION_KEYS = ['enabled', 'faulty_session_threshold', 'slow_test_retries']
+const TEST_MANAGEMENT_KEYS = ['attempt_to_fix_retries', 'enabled']
+const RETRY_THRESHOLD_PATTERN = /^\d+(?:ms|s|m|h)$/
+const MAX_VALIDATION_MODULES = 1000
+const MAX_VALIDATION_SUITES = 10_000
+const MAX_VALIDATION_TESTS = 100_000
+const MAX_VALIDATION_RETRIES = 100
+const MAX_VALIDATION_STRING_BYTES = 4096
 
 function isObject (value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value)
@@ -38,7 +57,7 @@ function getAttributes (response, endpoint) {
   return attributes
 }
 
-function validateSettingsResponse (response) {
+function validateSettingsResponse (response, options = {}) {
   const attributes = response?.data?.attributes ?? response
   assertObject(attributes, 'Invalid settings response: attributes must be an object')
   assertHasKeys(attributes, REQUIRED_SETTINGS_KEYS, 'settings')
@@ -46,9 +65,27 @@ function validateSettingsResponse (response) {
   assertObject(attributes.test_management, 'Invalid settings response: test_management must be an object')
   assertHasKeys(attributes.early_flake_detection, ['enabled'], 'settings early_flake_detection')
   assertHasKeys(attributes.test_management, ['enabled'], 'settings test_management')
+  if (!options.validationMode) return
+
+  assertOnlyKeys(attributes, REQUIRED_SETTINGS_KEYS, 'settings')
+  assertOnlyKeys(attributes.early_flake_detection, EARLY_FLAKE_DETECTION_KEYS, 'settings early_flake_detection')
+  assertOnlyKeys(attributes.test_management, TEST_MANAGEMENT_KEYS, 'settings test_management')
+  assertBooleanFields(attributes, SETTINGS_BOOLEAN_KEYS, 'settings')
+  assertBooleanFields(attributes.early_flake_detection, ['enabled'], 'settings early_flake_detection')
+  assertBooleanFields(attributes.test_management, ['enabled'], 'settings test_management')
+  assertOptionalBoundedNumber(
+    attributes.early_flake_detection.faulty_session_threshold,
+    'settings early_flake_detection faulty_session_threshold'
+  )
+  assertRetryMap(attributes.early_flake_detection.slow_test_retries)
+  assertOptionalBoundedNumber(
+    attributes.test_management.attempt_to_fix_retries,
+    'settings test_management attempt_to_fix_retries',
+    { integer: true }
+  )
 }
 
-function validateKnownTestsResponse (response) {
+function validateKnownTestsResponse (response, options = {}) {
   const attributes = getAttributes(response, 'known tests')
   assertHasKeys(attributes, ['tests'], 'known tests')
 
@@ -56,26 +93,46 @@ function validateKnownTestsResponse (response) {
   if (tests === null) return
   assertObject(tests, 'Invalid known tests response: tests must be an object or null')
 
-  for (const suites of Object.values(tests)) {
+  let suiteCount = 0
+  let testCount = 0
+  const modules = Object.entries(tests)
+  if (options.validationMode && modules.length > MAX_VALIDATION_MODULES) {
+    throw new Error('Invalid known tests response: too many modules')
+  }
+  for (const [moduleName, suites] of modules) {
+    if (options.validationMode) assertValidationString(moduleName, 'known tests module')
     assertObject(suites, 'Invalid known tests response: module suites must be objects')
-    for (const testNames of Object.values(suites)) {
+    for (const [suiteName, testNames] of Object.entries(suites)) {
+      suiteCount++
+      if (options.validationMode) {
+        if (suiteCount > MAX_VALIDATION_SUITES) throw new Error('Invalid known tests response: too many suites')
+        assertValidationString(suiteName, 'known tests suite')
+      }
       if (!Array.isArray(testNames)) {
         throw new TypeError('Invalid known tests response: suite tests must be arrays')
       }
       for (const testName of testNames) {
+        testCount++
         if (typeof testName !== 'string') {
           throw new TypeError('Invalid known tests response: test names must be strings')
         }
+        if (options.validationMode) {
+          if (testCount > MAX_VALIDATION_TESTS) throw new Error('Invalid known tests response: too many tests')
+          assertValidationString(testName, 'known test name')
+        }
       }
     }
   }
 }
 
-function validateSkippableTestsResponse (response) {
+function validateSkippableTestsResponse (response, options = {}) {
   assertObject(response, 'Invalid skippable tests response: response must be an object')
   if (!Array.isArray(response.data)) {
     throw new TypeError('Invalid skippable tests response: data must be an array')
   }
+  if (options.validationMode && response.data.length > MAX_VALIDATION_TESTS) {
+    throw new Error('Invalid skippable tests response: too many items')
+  }
   if (response.meta !== undefined) {
     assertObject(response.meta, 'Invalid skippable tests response: meta must be an object')
   }
@@ -91,28 +148,56 @@ function validateSkippableTestsResponse (response) {
     if (typeof item.type !== 'string') {
       throw new TypeError('Invalid skippable tests response: data entry type must be a string')
     }
+    if (options.validationMode) assertValidationString(item.type, 'skippable test type')
     assertObject(item.attributes, 'Invalid skippable tests response: data entry attributes must be an object')
     if ((item.type === 'suite' || item.type === 'test') && typeof item.attributes.suite !== 'string') {
       throw new Error('Invalid skippable tests response: data entry suite must be a string')
     }
+    if (options.validationMode && item.attributes.suite !== undefined) {
+      assertValidationString(item.attributes.suite, 'skippable test suite')
+    }
     if (item.type === 'test' && typeof item.attributes.name !== 'string') {
       throw new Error('Invalid skippable tests response: data entry name must be a string')
     }
+    if (options.validationMode && item.attributes.name !== undefined) {
+      assertValidationString(item.attributes.name, 'skippable test name')
+    }
   }
 }
 
-function validateTestManagementTestsResponse (response) {
+function validateTestManagementTestsResponse (response, options = {}) {
   const attributes = getAttributes(response, 'test management tests')
   assertHasKeys(attributes, ['modules'], 'test management tests')
   assertObject(attributes.modules, 'Invalid test management tests response: modules must be an object')
 
-  for (const testModule of Object.values(attributes.modules)) {
+  let suiteCount = 0
+  let testCount = 0
+  const modules = Object.entries(attributes.modules)
+  if (options.validationMode && modules.length > MAX_VALIDATION_MODULES) {
+    throw new Error('Invalid test management tests response: too many modules')
+  }
+  for (const [moduleName, testModule] of modules) {
+    if (options.validationMode) assertValidationString(moduleName, 'test management module')
     assertObject(testModule, 'Invalid test management tests response: modules entries must be objects')
     assertObject(testModule.suites, 'Invalid test management tests response: module suites must be objects')
-    for (const suite of Object.values(testModule.suites)) {
+    for (const [suiteName, suite] of Object.entries(testModule.suites)) {
+      suiteCount++
+      if (options.validationMode) {
+        if (suiteCount > MAX_VALIDATION_SUITES) {
+          throw new Error('Invalid test management tests response: too many suites')
+        }
+        assertValidationString(suiteName, 'test management suite')
+      }
       assertObject(suite, 'Invalid test management tests response: suites entries must be objects')
       assertObject(suite.tests, 'Invalid test management tests response: suite tests must be objects')
-      for (const test of Object.values(suite.tests)) {
+      for (const [testName, test] of Object.entries(suite.tests)) {
+        testCount++
+        if (options.validationMode) {
+          if (testCount > MAX_VALIDATION_TESTS) {
+            throw new Error('Invalid test management tests response: too many tests')
+          }
+          assertValidationString(testName, 'test management test')
+        }
         assertObject(test, 'Invalid test management tests response: tests entries must be objects')
         assertObject(test.properties, 'Invalid test management tests response: test properties must be objects')
       }
@@ -120,6 +205,49 @@ function validateTestManagementTestsResponse (response) {
   }
 }
 
+function assertBooleanFields (object, keys, endpoint) {
+  for (const key of keys) {
+    if (typeof object[key] !== 'boolean') {
+      throw new TypeError(`Invalid ${endpoint} response: ${key} must be a boolean`)
+    }
+  }
+}
+
+function assertOptionalBoundedNumber (value, endpoint, { integer = false } = {}) {
+  if (value === undefined) return
+  if (!Number.isFinite(value) || (integer && !Number.isInteger(value)) ||
+    value < 0 || value > MAX_VALIDATION_RETRIES) {
+    throw new TypeError(`Invalid ${endpoint}: value must be between 0 and ${MAX_VALIDATION_RETRIES}`)
+  }
+}
+
+function assertRetryMap (retries) {
+  if (retries === undefined) return
+  assertObject(retries, 'Invalid settings response: early_flake_detection slow_test_retries must be an object')
+  for (const [threshold, count] of Object.entries(retries)) {
+    assertValidationString(threshold, 'early flake detection retry threshold')
+    if (!RETRY_THRESHOLD_PATTERN.test(threshold)) {
+      throw new TypeError('Invalid early flake detection retry threshold: expected a duration such as 5s')
+    }
+    assertOptionalBoundedNumber(count, `early flake detection retry count ${threshold}`, { integer: true })
+  }
+}
+
+function assertOnlyKeys (object, keys, endpoint) {
+  const allowed = new Set(keys)
+  for (const key of Object.keys(object)) {
+    if (!allowed.has(key)) {
+      throw new Error(`Invalid ${endpoint} response: unexpected ${key}`)
+    }
+  }
+}
+
+function assertValidationString (value, field) {
+  if (typeof value !== 'string' || Buffer.byteLength(value) > MAX_VALIDATION_STRING_BYTES) {
+    throw new TypeError(`Invalid ${field}: value must be a bounded string`)
+  }
+}
+
 module.exports = {
   validateKnownTestsResponse,
   validateSettingsResponse,