dd-trace 6.4.0 → 6.5.0

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,

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

@@ -48,6 +48,10 @@ const SKIPPABLE_TESTS_FILE_NAME = 'skippable_tests.json'
 const TEST_MANAGEMENT_FILE_NAME = 'test_management.json'
 
 const RUNFILES_MANIFEST_SEPARATOR = ' '
+const DEFAULT_VALIDATION_MAX_FILE_BYTES = 1024 * 1024
+const DEFAULT_VALIDATION_MAX_ENTRIES = 100_000
+const DEFAULT_VALIDATION_MAX_NESTING_DEPTH = 32
+const DEFAULT_VALIDATION_MAX_STRING_BYTES = 4096
 
 function parseManifestVersion (content) {
   // Supported just the number version or 'version=x'
@@ -57,12 +61,22 @@ function parseManifestVersion (content) {
 }
 
 class TestOptimizationHttpCache {
-  constructor ({ cwd = process.cwd(), env } = {}) {
+  constructor ({
+    cwd = process.cwd(),
+    env,
+    validationManifestPath,
+    maxFileBytes = DEFAULT_VALIDATION_MAX_FILE_BYTES,
+  } = {}) {
     this._cwd = cwd
     // This cache intentionally consumes env vars that are not tracer config keys. (??)
     // eslint-disable-next-line eslint-rules/eslint-process-env
     this._env = env ?? process.env
-    this._manifestPath = this._resolveManifestPath()
+    this._validationManifestPath = validationManifestPath
+    this._maxFileBytes = maxFileBytes
+    this._lastError = undefined
+    this._manifestPath = validationManifestPath
+      ? this._resolveValidationManifestPath(validationManifestPath)
+      : this._resolveManifestPath()
     this._testOptimizationPath = undefined
     this._httpCachePath = undefined
     this._available = false
@@ -74,6 +88,10 @@ class TestOptimizationHttpCache {
     return this._available
   }
 
+  getLastError () {
+    return this._lastError
+  }
+
   readSettings () {
     const payload = this._readFile(SETTINGS_FILE_NAME)
     if (payload === CACHE_MISS) {
@@ -82,7 +100,11 @@ class TestOptimizationHttpCache {
     }
 
     try {
-      const settings = parseLibraryConfigurationResponse(payload, undefined, { validateRequiredFields: true })
+      const settings = parseLibraryConfigurationResponse(
+        this._parsePayload(payload, SETTINGS_FILE_NAME),
+        undefined,
+        { validateRequiredFields: true, validationMode: Boolean(this._validationManifestPath) }
+      )
       incrementCountMetric(TELEMETRY_GIT_REQUESTS_SETTINGS_RESPONSE, settings)
       return settings
     } catch (err) {
@@ -97,7 +119,10 @@ class TestOptimizationHttpCache {
     if (payload === CACHE_MISS) return CACHE_MISS
 
     try {
-      const knownTests = parseKnownTestsResponse(payload, { validateRequiredFields: true })
+      const knownTests = parseKnownTestsResponse(
+        this._parsePayload(payload, KNOWN_TESTS_FILE_NAME),
+        { validateRequiredFields: true, validationMode: Boolean(this._validationManifestPath) }
+      )
       distributionMetric(TELEMETRY_KNOWN_TESTS_RESPONSE_TESTS, {}, getNumFromKnownTests(knownTests))
       distributionMetric(TELEMETRY_KNOWN_TESTS_RESPONSE_BYTES, {}, payload.length)
       return knownTests
@@ -112,8 +137,13 @@ class TestOptimizationHttpCache {
     if (payload === CACHE_MISS) return CACHE_MISS
 
     try {
-      const parsedResponse = JSON.parse(payload)
-      const result = parseSkippableSuitesResponse(parsedResponse, { ...options, validateRequiredFields: true })
+      const boundedPayload = this._parsePayload(payload, SKIPPABLE_TESTS_FILE_NAME)
+      const parsedResponse = typeof boundedPayload === 'string' ? JSON.parse(boundedPayload) : boundedPayload
+      const result = parseSkippableSuitesResponse(parsedResponse, {
+        ...options,
+        validateRequiredFields: true,
+        validationMode: Boolean(this._validationManifestPath),
+      })
       const testLevel = options.testLevel || 'suite'
       logSkippableSuitesResponse(result, testLevel)
       const skippableItems = parsedResponse.data.filter(({ type }) => type === testLevel)
@@ -137,7 +167,10 @@ class TestOptimizationHttpCache {
     if (payload === CACHE_MISS) return false
 
     try {
-      parseSkippableSuitesResponse(JSON.parse(payload), { ...options, validateRequiredFields: true })
+      parseSkippableSuitesResponse(
+        this._parsePayload(payload, SKIPPABLE_TESTS_FILE_NAME),
+        { ...options, validateRequiredFields: true, validationMode: Boolean(this._validationManifestPath) }
+      )
       return true
     } catch {
       return false
@@ -149,7 +182,10 @@ class TestOptimizationHttpCache {
     if (payload === CACHE_MISS) return CACHE_MISS
 
     try {
-      const testManagementTests = parseTestManagementTestsResponse(payload, { validateRequiredFields: true })
+      const testManagementTests = parseTestManagementTestsResponse(
+        this._parsePayload(payload, TEST_MANAGEMENT_FILE_NAME),
+        { validateRequiredFields: true, validationMode: Boolean(this._validationManifestPath) }
+      )
       distributionMetric(
         TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_TESTS,
         {},
@@ -165,12 +201,18 @@ class TestOptimizationHttpCache {
 
   _buildReader () {
     if (!this._manifestPath) {
+      if (this._validationManifestPath && !this._lastError) {
+        this._setError('Offline Test Optimization validation manifest was not found.')
+      }
       log.debug('Test Optimization HTTP cache manifest not found')
       return
     }
 
     const version = this._readManifestVersion(this._manifestPath)
     if (version !== SUPPORTED_MANIFEST_VERSION) {
+      if (this._validationManifestPath) {
+        this._setError(`Unsupported offline Test Optimization validation manifest version: ${version || 'missing'}.`)
+      }
       log.debug('Unsupported Test Optimization HTTP cache manifest version %j at %s', version, this._manifestPath)
       return
     }
@@ -184,6 +226,9 @@ class TestOptimizationHttpCache {
 
     const settingsPath = path.join(this._httpCachePath, SETTINGS_FILE_NAME)
     if (!fs.existsSync(settingsPath)) {
+      if (this._validationManifestPath) {
+        this._setError('Offline Test Optimization validation settings fixture is missing.')
+      }
       log.debug('Test Optimization HTTP cache settings file not found at %s', settingsPath)
       return
     }
@@ -207,6 +252,30 @@ class TestOptimizationHttpCache {
     }
   }
 
+  _resolveValidationManifestPath (manifestPath) {
+    if (!path.isAbsolute(manifestPath)) {
+      this._setError('Offline Test Optimization validation manifest path must be absolute.')
+      return
+    }
+
+    const resolvedManifestPath = path.resolve(manifestPath)
+    const testOptimizationPath = path.dirname(resolvedManifestPath)
+    const fixtureRoot = path.dirname(testOptimizationPath)
+    if (path.basename(resolvedManifestPath) !== MANIFEST_FILE_NAME ||
+      path.basename(testOptimizationPath) !== PLAN_FOLDER) {
+      this._setError('Offline Test Optimization validation manifest must use the fixed .testoptimization layout.')
+      return
+    }
+
+    try {
+      assertPathComponentsAreNotSymlinks(fixtureRoot, resolvedManifestPath)
+      assertRegularFixtureFile(resolvedManifestPath)
+      return resolvedManifestPath
+    } catch (err) {
+      this._setError(err.message)
+    }
+  }
+
   _resolveRunfilePath (manifestFile) {
     if (fs.existsSync(manifestFile)) {
       return manifestFile
@@ -257,8 +326,10 @@ class TestOptimizationHttpCache {
 
   _readManifestVersion (manifestPath) {
     try {
+      this._assertValidationFixtureFile(manifestPath)
       return parseManifestVersion(fs.readFileSync(manifestPath, 'utf8'))
     } catch (err) {
+      if (this._validationManifestPath) this._setError(err.message)
       log.debug('Failed to read Test Optimization HTTP cache manifest %s: %s', manifestPath, err.message)
     }
   }
@@ -268,24 +339,113 @@ class TestOptimizationHttpCache {
 
     const filePath = path.join(this._httpCachePath, fileName)
     try {
+      this._assertValidationFixtureFile(filePath)
       log.debug('Reading Test Optimization HTTP cache file %s', filePath)
       return fs.readFileSync(filePath, 'utf8')
     } catch (err) {
+      if (this._validationManifestPath) this._setError(err.message)
       log.debug('Test Optimization HTTP cache file %s could not be read: %s', filePath, err.message)
       return CACHE_MISS
     }
   }
 
   _logInvalidCacheFile (fileName, err) {
+    if (this._validationManifestPath) {
+      this._setError(`Invalid offline Test Optimization ${fileName} fixture: ${err.message}`)
+    }
     log.debug('Test Optimization HTTP cache file %s could not be parsed: %s', fileName, err.message)
   }
 
+  _assertValidationFixtureFile (filePath) {
+    if (!this._validationManifestPath) return
+    const fixtureRoot = path.dirname(path.dirname(this._manifestPath))
+    assertPathComponentsAreNotSymlinks(fixtureRoot, filePath)
+    const stat = assertRegularFixtureFile(filePath)
+    if (stat.size > this._maxFileBytes) {
+      throw new Error(
+        `Offline Test Optimization fixture ${path.basename(filePath)} exceeds ${this._maxFileBytes} bytes.`
+      )
+    }
+  }
+
+  _parsePayload (payload, fileName) {
+    if (!this._validationManifestPath) return payload
+
+    const parsed = JSON.parse(payload)
+    assertBoundedValidationValue(parsed, fileName)
+    return parsed
+  }
+
+  _setError (message) {
+    this._lastError = new Error(message)
+  }
+
   _disable () {
     this._available = false
   }
 }
 
+function assertPathComponentsAreNotSymlinks (root, filename) {
+  const resolvedRoot = path.resolve(root)
+  const resolvedFilename = path.resolve(filename)
+  const rootStat = fs.lstatSync(resolvedRoot)
+  if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
+    throw new Error(`Offline Test Optimization fixture root must be a regular directory: ${resolvedRoot}`)
+  }
+  const relative = path.relative(resolvedRoot, resolvedFilename)
+  if (relative.startsWith('..') || path.isAbsolute(relative)) {
+    throw new Error('Offline Test Optimization fixture path escapes its validation root.')
+  }
+
+  let current = resolvedRoot
+  for (const segment of relative ? relative.split(path.sep) : []) {
+    current = path.join(current, segment)
+    const stat = fs.lstatSync(current)
+    if (stat.isSymbolicLink()) {
+      throw new Error(`Offline Test Optimization fixture path contains a symbolic link: ${current}`)
+    }
+  }
+}
+
+function assertRegularFixtureFile (filename) {
+  const stat = fs.lstatSync(filename)
+  if (!stat.isFile()) {
+    throw new Error(`Offline Test Optimization fixture is not a regular file: ${filename}`)
+  }
+  if (stat.nlink > 1) {
+    throw new Error(`Offline Test Optimization fixture must not be hard-linked: ${filename}`)
+  }
+  return stat
+}
+
+function assertBoundedValidationValue (value, fileName) {
+  const pending = [{ depth: 0, value }]
+  let entries = 0
+
+  while (pending.length > 0) {
+    const current = pending.pop()
+    if (current.depth > DEFAULT_VALIDATION_MAX_NESTING_DEPTH) {
+      throw new Error(`${fileName} exceeds the validation nesting limit.`)
+    }
+    if (typeof current.value === 'string' &&
+      Buffer.byteLength(current.value) > DEFAULT_VALIDATION_MAX_STRING_BYTES) {
+      throw new Error(`${fileName} contains a string that exceeds the validation limit.`)
+    }
+    if (!current.value || typeof current.value !== 'object') continue
+
+    const values = Array.isArray(current.value) ? current.value : Object.values(current.value)
+    entries += values.length
+    if (entries > DEFAULT_VALIDATION_MAX_ENTRIES) {
+      throw new Error(`${fileName} exceeds the validation collection-entry limit.`)
+    }
+    for (const nestedValue of values) {
+      pending.push({ depth: current.depth + 1, value: nestedValue })
+    }
+  }
+}
+
 module.exports = {
   CACHE_MISS,
+  DEFAULT_VALIDATION_MAX_FILE_BYTES,
   TestOptimizationHttpCache,
 }

package/packages/dd-trace/src/ci-visibility/test-screenshot.js

@@ -0,0 +1,90 @@
+'use strict'
+
+const { statSync } = require('node:fs')
+
+const {
+  TEST_FAILURE_SCREENSHOT_UPLOADED,
+  TEST_FAILURE_SCREENSHOT_UPLOAD_ERROR,
+} = require('../plugins/util/test')
+
+const dateNow = Date.now
+
+const SCREENSHOT_UPLOAD_RESULT_UPLOADED = 'uploaded'
+const SCREENSHOT_UPLOAD_RESULT_ERROR = 'error'
+
+/**
+ * Resolves a screenshot's capture time in epoch milliseconds.
+ *
+ * @param {object|string} screenshot - Framework screenshot metadata or its file path
+ * @param {string} filePath - Resolved screenshot file path
+ * @returns {number} Capture time in epoch milliseconds
+ */
+function getScreenshotCapturedAtMs (screenshot, filePath) {
+  const takenAt = screenshot !== null && typeof screenshot === 'object' ? screenshot.takenAt : undefined
+  if (takenAt) {
+    const parsedMs = new Date(takenAt).getTime()
+    if (Number.isInteger(parsedMs) && parsedMs > 0) {
+      return parsedMs
+    }
+  }
+  try {
+    return Math.floor(statSync(filePath).mtimeMs)
+  } catch {
+    return dateNow()
+  }
+}
+
+/**
+ * Combines screenshot upload results, giving errors precedence over successes.
+ *
+ * @param {Array<string|undefined>} uploadResults - Per-screenshot upload results
+ * @returns {string|undefined} Combined upload result
+ */
+function getScreenshotUploadResult (uploadResults) {
+  let hasUploaded = false
+  for (const uploadResult of uploadResults) {
+    if (uploadResult === SCREENSHOT_UPLOAD_RESULT_ERROR) {
+      return SCREENSHOT_UPLOAD_RESULT_ERROR
+    }
+    if (uploadResult === SCREENSHOT_UPLOAD_RESULT_UPLOADED) {
+      hasUploaded = true
+    }
+  }
+  return hasUploaded ? SCREENSHOT_UPLOAD_RESULT_UPLOADED : undefined
+}
+
+/**
+ * Returns the test tag that represents an aggregate screenshot upload outcome.
+ *
+ * @param {string|undefined} uploadResult - Aggregate screenshot upload result
+ * @returns {string|undefined} Screenshot upload result tag
+ */
+function getScreenshotUploadTag (uploadResult) {
+  if (uploadResult === SCREENSHOT_UPLOAD_RESULT_ERROR) {
+    return TEST_FAILURE_SCREENSHOT_UPLOAD_ERROR
+  }
+  if (uploadResult === SCREENSHOT_UPLOAD_RESULT_UPLOADED) {
+    return TEST_FAILURE_SCREENSHOT_UPLOADED
+  }
+}
+
+/**
+ * Tags a test span with the aggregate screenshot upload outcome.
+ *
+ * @param {object} testSpan - Test span to tag
+ * @param {string|undefined} uploadResult - Aggregate screenshot upload result
+ * @returns {void}
+ */
+function setScreenshotUploadTags (testSpan, uploadResult) {
+  const uploadTag = getScreenshotUploadTag(uploadResult)
+  if (uploadTag) testSpan.setTag(uploadTag, 'true')
+}
+
+module.exports = {
+  SCREENSHOT_UPLOAD_RESULT_ERROR,
+  SCREENSHOT_UPLOAD_RESULT_UPLOADED,
+  getScreenshotCapturedAtMs,
+  getScreenshotUploadResult,
+  getScreenshotUploadTag,
+  setScreenshotUploadTags,
+}

package/packages/dd-trace/src/config/generated-config-types.d.ts

@@ -16,6 +16,7 @@ export interface GeneratedConfig {
     DD_API_SECURITY_MAX_DOWNSTREAM_BODY_BYTES: number;
     DD_API_SECURITY_MAX_DOWNSTREAM_REQUEST_BODY_ANALYSIS: number;
     DD_API_SECURITY_SAMPLE_DELAY: number;
+    DD_APPSEC_AGENTIC_ONBOARDING: string;
     DD_APPSEC_SCA_ENABLED: boolean | undefined;
     enabled: boolean | undefined;
     eventTracking: {
@@ -431,6 +432,13 @@ export interface GeneratedConfig {
       };
     };
   };
+  featureFlags: {
+    DD_FEATURE_FLAGS_CONFIGURATION_SOURCE: "agentless" | "remote_config";
+    DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_BASE_URL: string | undefined;
+    DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_POLL_INTERVAL_SECONDS: number;
+    DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_REQUEST_TIMEOUT_SECONDS: number;
+    DD_FEATURE_FLAGS_ENABLED: boolean;
+  };
   flushInterval: number;
   flushMinSpans: number;
   headerTags: string[];
@@ -562,6 +570,7 @@ export interface GeneratedConfig {
     DD_CIVISIBILITY_TEST_COMMAND: string | undefined;
     DD_CIVISIBILITY_TEST_MODULE_ID: string | undefined;
     DD_CIVISIBILITY_TEST_SESSION_ID: string | undefined;
+    DD_CODE_COVERAGE_FLAGS: string | undefined;
     DD_TEST_EARLY_FLAKE_DETECTION_RETRY_COUNT: number | undefined;
     DD_TEST_FAILED_TEST_REPLAY_ENABLED: boolean;
     DD_TEST_FAILURE_SCREENSHOTS_ENABLED: boolean | undefined;
@@ -612,6 +621,7 @@ export interface GeneratedEnvVarConfig {
   DD_APM_FLUSH_DEADLINE_MILLISECONDS: number;
   DD_APM_TRACING_ENABLED: boolean;
   DD_APP_KEY: string | undefined;
+  DD_APPSEC_AGENTIC_ONBOARDING: string;
   DD_APPSEC_AUTO_USER_INSTRUMENTATION_MODE: string;
   DD_APPSEC_AUTOMATED_USER_EVENTS_TRACKING: string;
   DD_APPSEC_COLLECT_ALL_HEADERS: boolean;
@@ -654,6 +664,7 @@ export interface GeneratedEnvVarConfig {
   DD_CIVISIBILITY_TEST_COMMAND: string | undefined;
   DD_CIVISIBILITY_TEST_MODULE_ID: string | undefined;
   DD_CIVISIBILITY_TEST_SESSION_ID: string | undefined;
+  DD_CODE_COVERAGE_FLAGS: string | undefined;
   DD_CODE_ORIGIN_FOR_SPANS_ENABLED: boolean;
   DD_CODE_ORIGIN_FOR_SPANS_EXPERIMENTAL_EXIT_SPANS_ENABLED: boolean;
   DD_CRASHTRACKING_ENABLED: boolean;
@@ -688,6 +699,11 @@ export interface GeneratedEnvVarConfig {
   DD_EXPERIMENTAL_TEST_OPT_VITEST_NO_WORKER_INIT: boolean | undefined;
   DD_EXPERIMENTAL_TEST_REQUESTS_FS_CACHE: boolean;
   DD_EXTERNAL_ENV: string | undefined;
+  DD_FEATURE_FLAGS_CONFIGURATION_SOURCE: "agentless" | "remote_config";
+  DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_BASE_URL: string | undefined;
+  DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_POLL_INTERVAL_SECONDS: number;
+  DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_REQUEST_TIMEOUT_SECONDS: number;
+  DD_FEATURE_FLAGS_ENABLED: boolean;
   DD_GIT_BRANCH: string | undefined;
   DD_GIT_COMMIT_AUTHOR_DATE: string | undefined;
   DD_GIT_COMMIT_AUTHOR_EMAIL: string | undefined;

package/packages/dd-trace/src/config/helper.js

@@ -13,6 +13,7 @@
  * @property {string} [namespace] Nests the canonical env name under this property path (e.g. `telemetry`).
  * @property {string} [transform]
  * @property {string} [allowed]
+ * @property {string} [description]
  * @property {string|boolean} [deprecated]
  * @property {boolean} [sensitive] Excludes the configuration value from configuration telemetry.
  */

package/packages/dd-trace/src/config/index.js

@@ -333,6 +333,16 @@ class Config extends ConfigBase {
   #applyCalculated () {
     undo(this, 'calculated')
 
+    if (this.featureFlags.DD_FEATURE_FLAGS_ENABLED &&
+        !trackedConfigOrigins.has('featureFlags.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE') &&
+        trackedConfigOrigins.has('experimental.flaggingProvider.enabled')) {
+      if (this.experimental.flaggingProvider.enabled) {
+        setAndTrack(this, 'featureFlags.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE', 'remote_config')
+      } else {
+        setAndTrack(this, 'featureFlags.DD_FEATURE_FLAGS_ENABLED', false)
+      }
+    }
+
     if (this.url ||
         os.type() !== 'Windows_NT' &&
         !trackedConfigOrigins.has('hostname') &&