dd-trace 5.110.0 → 5.112.0

package/packages/dd-trace/src/appsec/waf/waf_context_wrapper.js

@@ -36,7 +36,7 @@ class WAFContextWrapper {
     }
   }
 
-  run ({ persistent, ephemeral }, raspRule, req) {
+  run ({ persistent, ephemeral }, raspRule, req, rootSpan) {
     if (this.ddwafContext.disposed) {
       log.warn('[ASM] Calling run on a disposed context')
       if (raspRule) {
@@ -156,10 +156,10 @@ class WAFContextWrapper {
       metrics.wafTimeout = result.timeout
 
       if (ruleTriggered) {
-        Reporter.reportAttack(result, req)
+        Reporter.reportAttack(result, req, rootSpan)
       }
 
-      Reporter.reportAttributes(result.attributes, req)
+      Reporter.reportAttributes(result.attributes, req, rootSpan)
 
       return result
     } catch (err) {
@@ -171,7 +171,7 @@ class WAFContextWrapper {
         wafRunFinished.publish({ payload })
       }
 
-      Reporter.reportMetrics(metrics, raspRule, req)
+      Reporter.reportMetrics(metrics, raspRule, req, rootSpan)
     }
   }
 

package/packages/dd-trace/src/ci-visibility/dynamic-instrumentation/index.js

@@ -9,6 +9,7 @@ const getDebuggerConfig = require('../../debugger/config')
 
 const probeIdToResolveBreakpointSet = new Map()
 const probeIdToResolveBreakpointRemove = new Map()
+const drainRequestIdToResolveBreakpointHit = new Map()
 
 class TestVisDynamicInstrumentation {
   /**
@@ -57,6 +58,21 @@ class TestVisDynamicInstrumentation {
     ]
   }
 
+  /**
+   * Waits until all breakpoint hits already being handled by the DI worker have been posted back.
+   *
+   * @returns {Promise<void>}
+   */
+  waitForInFlightBreakpointHits () {
+    if (!this.worker) return Promise.resolve()
+
+    const requestId = randomUUID()
+    return new Promise(resolve => {
+      drainRequestIdToResolveBreakpointHit.set(requestId, resolve)
+      this.breakpointHitChannel.port2.postMessage({ drainRequestId: requestId })
+    })
+  }
+
   isReady () {
     return this._readyPromise
   }
@@ -130,7 +146,16 @@ class TestVisDynamicInstrumentation {
       }
     }).unref?.()
 
-    this.breakpointHitChannel.port2.on('message', ({ snapshot }) => {
+    this.breakpointHitChannel.port2.on('message', ({ snapshot, drainRequestId }) => {
+      if (drainRequestId) {
+        const resolve = drainRequestIdToResolveBreakpointHit.get(drainRequestId)
+        if (resolve) {
+          resolve()
+          drainRequestIdToResolveBreakpointHit.delete(drainRequestId)
+        }
+        return
+      }
+
       const { probe: { id: probeId } } = snapshot
       const onHit = this.onHitBreakpointByProbeId.get(probeId)
       if (onHit) {

package/packages/dd-trace/src/ci-visibility/dynamic-instrumentation/worker/index.js

@@ -28,12 +28,20 @@ const {
   getStackFromCallFrames,
 } = require('../../../debugger/devtools_client/state')
 const log = require('../../../log')
-const processTags = require('../../../process-tags')
+
+let processTags
+if (config.propagateProcessTags?.enabled) {
+  processTags = require('../../../process-tags')
+  processTags.initialize()
+}
 
 let sessionStarted = false
+let inFlightBreakpointHits = 0
+let isBreakpointHitDrainScheduled = false
 
 const breakpointIdToProbe = new Map()
 const probeIdToBreakpointId = new Map()
+const breakpointHitDrainRequests = []
 
 const limits = {
   maxReferenceDepth: DEFAULT_MAX_REFERENCE_DEPTH,
@@ -42,6 +50,55 @@ const limits = {
   maxLength: DEFAULT_MAX_LENGTH,
 }
 
+/**
+ * Remove empty collection arrays before sending snapshots through the Test Optimization logs path.
+ *
+ * @param {object} value - Snapshot object or sub-object.
+ * @returns {void}
+ */
+function removeEmptyCollectionProperties (value) {
+  const stack = [value]
+
+  while (stack.length > 0) {
+    const current = stack.pop()
+    if (!current || typeof current !== 'object') continue
+
+    if (Array.isArray(current)) {
+      for (const item of current) {
+        if (item && typeof item === 'object') {
+          stack.push(item)
+        }
+      }
+      continue
+    }
+
+    if (Array.isArray(current.elements)) {
+      if (current.elements.length === 0) {
+        delete current.elements
+      } else {
+        stack.push(current.elements)
+      }
+    }
+
+    if (Array.isArray(current.entries)) {
+      if (current.entries.length === 0) {
+        delete current.entries
+      } else {
+        stack.push(current.entries)
+      }
+    }
+
+    for (const key of Object.keys(current)) {
+      if (key === 'elements' || key === 'entries') continue
+
+      const child = current[key]
+      if (child && typeof child === 'object') {
+        stack.push(child)
+      }
+    }
+  }
+}
+
 session.on('Debugger.paused', async ({ params: { hitBreakpoints: [hitBreakpoint], callFrames } }) => {
   const probe = breakpointIdToProbe.get(hitBreakpoint)
   if (!probe) {
@@ -49,32 +106,47 @@ session.on('Debugger.paused', async ({ params: { hitBreakpoints: [hitBreakpoint]
     return session.post('Debugger.resume')
   }
 
-  const stack = await getStackFromCallFrames(callFrames)
-
-  const { processLocalState } = await getLocalStateForCallFrame(callFrames[0], limits)
-
-  await session.post('Debugger.resume')
-
-  const snapshot = {
-    id: randomUUID(),
-    timestamp: Date.now(),
-    probe: {
-      id: probe.id,
-      version: '0',
-      location: probe.location,
-    },
-    captures: {
-      lines: { [probe.location.lines[0]]: { locals: processLocalState() } },
-    },
-    stack,
-    language: 'javascript',
-  }
+  inFlightBreakpointHits++
+  try {
+    const stack = await getStackFromCallFrames(callFrames)
+
+    const { processLocalState } = await getLocalStateForCallFrame(callFrames[0], limits)
+
+    await session.post('Debugger.resume')
 
-  if (config.propagateProcessTags?.enabled) {
-    snapshot[processTags.DYNAMIC_INSTRUMENTATION_FIELD_NAME] = processTags.tagsObject
+    const snapshot = {
+      id: randomUUID(),
+      timestamp: Date.now(),
+      probe: {
+        id: probe.id,
+        version: 0,
+        location: probe.location,
+      },
+      captures: {
+        lines: { [probe.location.lines[0]]: { locals: processLocalState() } },
+      },
+      stack,
+      language: 'javascript',
+    }
+
+    removeEmptyCollectionProperties(snapshot.captures)
+
+    if (processTags) {
+      snapshot[processTags.DYNAMIC_INSTRUMENTATION_FIELD_NAME] = processTags.tagsObject
+    }
+
+    breakpointHitChannel.postMessage({ snapshot })
+  } finally {
+    inFlightBreakpointHits--
+    scheduleBreakpointHitDrain()
   }
+})
 
-  breakpointHitChannel.postMessage({ snapshot })
+breakpointHitChannel.on('message', ({ drainRequestId }) => {
+  if (!drainRequestId) return
+
+  breakpointHitDrainRequests.push(drainRequestId)
+  scheduleBreakpointHitDrain()
 })
 
 breakpointRemoveChannel.on('message', async (probeId) => {
@@ -154,3 +226,22 @@ function start () {
   sessionStarted = true
   return session.post('Debugger.enable') // return instead of await to reduce number of promises created
 }
+
+function drainBreakpointHitRequests () {
+  if (inFlightBreakpointHits !== 0) return
+
+  for (const drainRequestId of breakpointHitDrainRequests) {
+    breakpointHitChannel.postMessage({ drainRequestId })
+  }
+  breakpointHitDrainRequests.length = 0
+}
+
+function scheduleBreakpointHitDrain () {
+  if (isBreakpointHitDrainScheduled) return
+
+  isBreakpointHitDrainScheduled = true
+  setImmediate(() => {
+    isBreakpointHitDrainScheduled = false
+    drainBreakpointHitRequests()
+  })
+}

package/packages/dd-trace/src/ci-visibility/early-flake-detection/get-known-tests.js

@@ -17,6 +17,7 @@ const {
 
 const { getNumFromKnownTests } = require('../../plugins/util/test')
 const { buildCacheKey, writeToCache, withCache } = require('../requests/fs-cache')
+const { validateKnownTestsResponse } = require('../test-optimization-http-cache-schema')
 
 const MAX_KNOWN_TESTS_PAGES = 10_000
 
@@ -52,6 +53,19 @@ function mergeKnownTests (aggregate, page) {
   return aggregate
 }
 
+function parseJsonResponse (rawJson) {
+  return typeof rawJson === 'string' ? JSON.parse(rawJson) : rawJson
+}
+
+function parseKnownTestsResponse (rawJson, options = {}) {
+  const parsedResponse = parseJsonResponse(rawJson)
+  if (options.validateRequiredFields) {
+    validateKnownTestsResponse(parsedResponse)
+  }
+  const { data: { attributes: { tests } } } = parsedResponse
+  return tests
+}
+
 function getKnownTests ({
   url,
   isEvpProxy,
@@ -151,12 +165,12 @@ function fetchFromApi ({
     options.path = `${evpProxyPrefix}/api/v2/ci/libraries/tests`
     options.headers['X-Datadog-EVP-Subdomain'] = 'api'
   } else {
-    const { apiKey } = getConfig()
-    if (!apiKey) {
+    const { DD_API_KEY } = getConfig()
+    if (!DD_API_KEY) {
       return done(new Error('Known tests were not fetched because Datadog API key is not defined.'))
     }
 
-    options.headers['dd-api-key'] = apiKey
+    options.headers['dd-api-key'] = DD_API_KEY
   }
 
   const configurations = {
@@ -211,8 +225,9 @@ function fetchFromApi ({
       try {
         totalResponseBytes += res.length
 
-        const { data: { attributes } } = JSON.parse(res)
-        const { tests: pageTests, page_info: responsePageInfo } = attributes
+        const parsedResponse = parseJsonResponse(res)
+        const pageTests = parseKnownTestsResponse(parsedResponse)
+        const { page_info: responsePageInfo } = parsedResponse.data.attributes
 
         aggregateTests = mergeKnownTests(aggregateTests, pageTests)
 
@@ -251,4 +266,4 @@ function fetchFromApi ({
   fetchPage(null)
 }
 
-module.exports = { getKnownTests }
+module.exports = { getKnownTests, parseKnownTestsResponse }

package/packages/dd-trace/src/ci-visibility/exporters/agent-proxy/index.js

@@ -40,7 +40,7 @@ class AgentProxyCiVisibilityExporter extends CiVisibilityExporter {
       lookup,
       protocolVersion,
       headers,
-      isTestDynamicInstrumentationEnabled,
+      testOptimization,
     } = config
 
     fetchAgentInfo(this._url, (err, agentInfo) => {
@@ -68,7 +68,10 @@ class AgentProxyCiVisibilityExporter extends CiVisibilityExporter {
           evpProxyPrefix,
         })
         this._codeCoverageReportUrl = this._url
-        if (isTestDynamicInstrumentationEnabled) {
+        // Screenshot media uploads go through the Agent's evp_proxy: the uploader prefixes the
+        // path with evpProxyPrefix and sets X-Datadog-EVP-Subdomain: api (see uploadTestScreenshot).
+        this._testScreenshotUploadUrl = this._url
+        if (testOptimization.DD_TEST_FAILED_TEST_REPLAY_ENABLED) {
           const canFowardLogs = getCanForwardDebuggerLogs(err, agentInfo)
           if (canFowardLogs) {
             const DynamicInstrumentationLogsWriter = require('../agentless/di-logs-writer')

package/packages/dd-trace/src/ci-visibility/exporters/agentless/coverage-writer.js

@@ -29,7 +29,7 @@ class Writer extends BaseWriter {
       path: '/api/v2/citestcov',
       method: 'POST',
       headers: {
-        'dd-api-key': getConfig().apiKey,
+        'dd-api-key': getConfig().DD_API_KEY,
         ...form.getHeaders(),
       },
       timeout: 15_000,

package/packages/dd-trace/src/ci-visibility/exporters/agentless/di-logs-writer.js

@@ -26,7 +26,7 @@ class DynamicInstrumentationLogsWriter extends BaseWriter {
       path: '/api/v2/logs',
       method: 'POST',
       headers: {
-        'dd-api-key': getConfig().apiKey,
+        'dd-api-key': getConfig().DD_API_KEY,
         'Content-Type': 'application/json',
       },
       timeout: this.timeout,

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

@@ -9,7 +9,8 @@ const CoverageWriter = require('./coverage-writer')
 class AgentlessCiVisibilityExporter extends CiVisibilityExporter {
   constructor (config) {
     super(config)
-    const { tags, site, DD_CIVISIBILITY_AGENTLESS_URL: url, isTestDynamicInstrumentationEnabled } = config
+    const { tags, site, testOptimization } = config
+    const { DD_CIVISIBILITY_AGENTLESS_URL: url } = testOptimization
     // we don't need to request /info because we are using agentless by configuration
     this._isInitialized = true
     this._resolveCanUseCiVisProtocol(true)
@@ -23,13 +24,15 @@ class AgentlessCiVisibilityExporter extends CiVisibilityExporter {
 
     this._codeCoverageReportUrl = url || new URL(`https://ci-intake.${site}`)
 
-    if (isTestDynamicInstrumentationEnabled) {
+    if (testOptimization.DD_TEST_FAILED_TEST_REPLAY_ENABLED) {
       const DynamicInstrumentationLogsWriter = require('./di-logs-writer')
       this._logsUrl = url || new URL(`https://http-intake.logs.${site}`)
       this._logsWriter = new DynamicInstrumentationLogsWriter({ url: this._logsUrl, tags })
     }
 
     this._apiUrl = url || new URL(`https://api.${site}`)
+    // Media uploads (raw bytes + DD-API-KEY) go to the same api.<site> host as the rest of the API.
+    this._testScreenshotUploadUrl = this._apiUrl
     // Agentless is always gzip compatible
     this._isGzipCompatible = true
   }
@@ -39,6 +42,7 @@ class AgentlessCiVisibilityExporter extends CiVisibilityExporter {
     try {
       apiUrl = new URL(apiUrl)
       this._apiUrl = apiUrl
+      this._testScreenshotUploadUrl = apiUrl
     } catch (e) {
       log.error('Error setting CI exporter api url', e)
     }

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

@@ -30,7 +30,7 @@ class Writer extends BaseWriter {
       path: '/api/v2/citestcycle',
       method: 'POST',
       headers: {
-        'dd-api-key': getConfig().apiKey,
+        'dd-api-key': getConfig().DD_API_KEY,
         'Content-Type': 'application/msgpack',
       },
       timeout: 15_000,

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

@@ -1,18 +1,25 @@
 'use strict'
 
+const { hostname: getHostname } = require('node:os')
 const URL = require('url').URL
 
+const { version: tracerVersion } = require('../../../../../package.json')
 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')
 const { getTestManagementTests: getTestManagementTestsRequest } =
   require('../test-management/get-test-management-tests')
+const { writeSettingsToCache } = require('../test-optimization-cache')
+const { CACHE_MISS, TestOptimizationHttpCache } = require('../test-optimization-http-cache')
 const { uploadCoverageReport: uploadCoverageReportRequest } = require('../requests/upload-coverage-report')
+const { uploadTestScreenshot: uploadTestScreenshotRequest } = require('../requests/upload-test-screenshot')
 const log = require('../../log')
 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')
 
+const hostname = getHostname()
+
 function getTestConfigurationTags (tags) {
   if (!tags) {
     return {}
@@ -35,6 +42,34 @@ function getIsTestSessionTrace (trace) {
 const GIT_UPLOAD_TIMEOUT = 60_000 // 60 seconds
 const CAN_USE_CI_VIS_PROTOCOL_TIMEOUT = GIT_UPLOAD_TIMEOUT
 
+function appendLogTag (tags, key, value) {
+  if (value !== undefined) {
+    tags.push(`${key}:${value}`)
+  }
+}
+
+function getLogTags (logMessage, { env, version }, gitRepositoryUrl, gitCommitSha) {
+  const tags = []
+  if (Array.isArray(logMessage.ddtags)) {
+    for (const tag of logMessage.ddtags) {
+      tags.push(tag)
+    }
+  } else if (logMessage.ddtags) {
+    for (const tag of logMessage.ddtags.split(',')) {
+      tags.push(tag)
+    }
+  }
+
+  appendLogTag(tags, 'env', env)
+  appendLogTag(tags, 'version', version)
+  appendLogTag(tags, 'debugger_version', tracerVersion)
+  appendLogTag(tags, 'host_name', hostname)
+  appendLogTag(tags, GIT_COMMIT_SHA, gitCommitSha)
+  appendLogTag(tags, GIT_REPOSITORY_URL, gitRepositoryUrl)
+
+  return tags.join(',')
+}
+
 class CiVisibilityExporter extends BufferingExporter {
   constructor (config) {
     super(config)
@@ -42,10 +77,14 @@ class CiVisibilityExporter extends BufferingExporter {
     this._coverageTimer = undefined
     this._logsTimer = undefined
     this._coverageBuffer = []
+    this._testOptimizationHttpCache = new TestOptimizationHttpCache()
     // The library can use new features like ITR and test suite level visibility
     // AKA CI Vis Protocol
     this._canUseCiVisProtocol = false
 
+    this._isTestFailureScreenshotsEnabled =
+      Boolean(config?.testOptimization?.DD_TEST_FAILURE_SCREENSHOTS_ENABLED)
+
     const gitUploadTimeoutId = setTimeout(() => {
       this._resolveGit(new Error('Timeout while uploading git metadata'))
     }, GIT_UPLOAD_TIMEOUT)
@@ -86,7 +125,7 @@ class CiVisibilityExporter extends BufferingExporter {
   }
 
   shouldRequestSkippableSuites () {
-    return !!(this._config.isIntelligentTestRunnerEnabled &&
+    return !!(this._config.testOptimization.DD_CIVISIBILITY_ITR_ENABLED &&
       this._canUseCiVisProtocol &&
       this._libraryConfig?.isSuitesSkippingEnabled)
   }
@@ -101,7 +140,7 @@ class CiVisibilityExporter extends BufferingExporter {
   shouldRequestTestManagementTests () {
     return !!(
       this._canUseCiVisProtocol &&
-      this._config.isTestManagementEnabled &&
+      this._config.testOptimization.DD_TEST_MANAGEMENT_ENABLED &&
       this._libraryConfig?.isTestManagementEnabled
     )
   }
@@ -133,11 +172,21 @@ class CiVisibilityExporter extends BufferingExporter {
     if (!this.shouldRequestSkippableSuites()) {
       return callback(null, [])
     }
+    const requestConfiguration = this.getRequestConfiguration(testConfiguration)
+    const cachedSkippableSuites = this._testOptimizationHttpCache.readSkippableSuites({
+      testLevel: requestConfiguration.testLevel,
+      isCoverageReportUploadEnabled: requestConfiguration.isCoverageReportUploadEnabled,
+    })
+    if (cachedSkippableSuites !== CACHE_MISS) {
+      const { skippableSuites, correlationId, coverage } = cachedSkippableSuites
+      return callback(null, skippableSuites, correlationId, coverage)
+    }
+
     this._gitUploadPromise.then(gitUploadError => {
       if (gitUploadError) {
         return callback(gitUploadError, [])
       }
-      getSkippableSuitesRequest(this.getRequestConfiguration(testConfiguration), callback)
+      getSkippableSuitesRequest(requestConfiguration, callback)
     })
   }
 
@@ -145,6 +194,10 @@ class CiVisibilityExporter extends BufferingExporter {
     if (!this.shouldRequestKnownTests()) {
       return callback(null)
     }
+    const cachedKnownTests = this._testOptimizationHttpCache.readKnownTests()
+    if (cachedKnownTests !== CACHE_MISS) {
+      return callback(null, cachedKnownTests)
+    }
     getKnownTestsRequest(this.getRequestConfiguration(testConfiguration), callback)
   }
 
@@ -152,6 +205,10 @@ class CiVisibilityExporter extends BufferingExporter {
     if (!this.shouldRequestTestManagementTests()) {
       return callback(null)
     }
+    const cachedTestManagementTests = this._testOptimizationHttpCache.readTestManagementTests()
+    if (cachedTestManagementTests !== CACHE_MISS) {
+      return callback(null, cachedTestManagementTests)
+    }
     getTestManagementTestsRequest(this.getRequestConfiguration(testConfiguration), callback)
   }
 
@@ -161,13 +218,30 @@ class CiVisibilityExporter extends BufferingExporter {
    */
   getLibraryConfiguration (testConfiguration, callback) {
     const { repositoryUrl } = testConfiguration
-    this.sendGitMetadata(repositoryUrl)
     this._canUseCiVisProtocolPromise.then((canUseCiVisProtocol) => {
       if (!canUseCiVisProtocol) {
         return callback(null, {})
       }
       const configuration = this.getRequestConfiguration(testConfiguration)
+      const cachedLibraryConfig = this._testOptimizationHttpCache.readSettings()
+      if (cachedLibraryConfig !== CACHE_MISS) {
+        log.debug('Test Optimization HTTP cache settings found, skipping settings request')
+        writeSettingsToCache(cachedLibraryConfig)
+        this._libraryConfig = this.filterConfiguration(cachedLibraryConfig)
+        const canUseCachedSkippableSuites = !this.shouldRequestSkippableSuites() ||
+          this._testOptimizationHttpCache.hasValidSkippableSuites({
+            testLevel: configuration.testLevel,
+            isCoverageReportUploadEnabled: configuration.isCoverageReportUploadEnabled,
+          })
+        if (this._libraryConfig.requireGit && !canUseCachedSkippableSuites) {
+          this.sendGitMetadata(repositoryUrl)
+        } else {
+          this._resolveGit()
+        }
+        return callback(null, this._libraryConfig)
+      }
 
+      this.sendGitMetadata(repositoryUrl)
       getLibraryConfigurationRequest(configuration, (err, libraryConfig) => {
         /**
          * **Important**: this._libraryConfig remains empty in testing frameworks
@@ -218,29 +292,32 @@ class CiVisibilityExporter extends BufferingExporter {
       isImpactedTestsEnabled,
       isCoverageReportUploadEnabled,
     } = remoteConfiguration
+    const { testOptimization } = this._config
     return {
       isCodeCoverageEnabled,
       isSuitesSkippingEnabled,
       isItrEnabled,
       requireGit,
-      isEarlyFlakeDetectionEnabled: isEarlyFlakeDetectionEnabled && this._config.isEarlyFlakeDetectionEnabled,
+      isEarlyFlakeDetectionEnabled:
+        isEarlyFlakeDetectionEnabled && testOptimization.DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED,
       earlyFlakeDetectionNumRetries,
       earlyFlakeDetectionSlowTestRetries,
       earlyFlakeDetectionFaultyThreshold,
-      isFlakyTestRetriesEnabled: isFlakyTestRetriesEnabled && this._config.isFlakyTestRetriesEnabled,
-      flakyTestRetriesCount: this._config.flakyTestRetriesCount,
-      isDiEnabled: isDiEnabled && this._config.isTestDynamicInstrumentationEnabled,
+      isFlakyTestRetriesEnabled: isFlakyTestRetriesEnabled && testOptimization.DD_CIVISIBILITY_FLAKY_RETRY_ENABLED,
+      flakyTestRetriesCount: testOptimization.DD_CIVISIBILITY_FLAKY_RETRY_COUNT,
+      isDiEnabled: isDiEnabled && testOptimization.DD_TEST_FAILED_TEST_REPLAY_ENABLED,
       isKnownTestsEnabled,
-      isTestManagementEnabled: isTestManagementEnabled && this._config.isTestManagementEnabled,
+      isTestManagementEnabled: isTestManagementEnabled && testOptimization.DD_TEST_MANAGEMENT_ENABLED,
       testManagementAttemptToFixRetries:
-        testManagementAttemptToFixRetries ?? this._config.testManagementAttemptToFixRetries,
-      isImpactedTestsEnabled: isImpactedTestsEnabled && this._config.isImpactedTestsEnabled,
+        testManagementAttemptToFixRetries ?? testOptimization.DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES,
+      isImpactedTestsEnabled:
+        isImpactedTestsEnabled && testOptimization.DD_CIVISIBILITY_IMPACTED_TESTS_DETECTION_ENABLED,
       isCoverageReportUploadEnabled,
     }
   }
 
   sendGitMetadata (repositoryUrl) {
-    if (!this._config.isGitUploadEnabled) {
+    if (!this._config.testOptimization.DD_CIVISIBILITY_GIT_UPLOAD_ENABLED) {
       return
     }
     this._canUseCiVisProtocolPromise.then((canUseCiVisProtocol) => {
@@ -297,28 +374,26 @@ class CiVisibilityExporter extends BufferingExporter {
     const { service, env, version } = this._config
 
     return {
-      ddtags: [
-        ...(logMessage.ddtags || []),
-        `${GIT_REPOSITORY_URL}:${gitRepositoryUrl}`,
-        `${GIT_COMMIT_SHA}:${gitCommitSha}`,
-      ].join(','),
+      ...logMessage,
+      ddtags: getLogTags(logMessage, { env, version }, gitRepositoryUrl, gitCommitSha),
       level: 'error',
       service,
+      hostname,
       dd: {
-        ...(logMessage.dd || []),
+        ...logMessage.dd,
         service,
         env,
         version,
       },
       ddsource: 'dd_debugger',
-      ...logMessage,
     }
   }
 
   // DI logs
   exportDiLogs (testEnvironmentMetadata, logMessage) {
     // TODO: could we lose logs if it's not initialized?
-    if (!this._config.isTestDynamicInstrumentationEnabled || !this._isInitialized || !this._canForwardLogs) {
+    if (!this._config.testOptimization.DD_TEST_FAILED_TEST_REPLAY_ENABLED ||
+      !this._isInitialized || !this._canForwardLogs) {
       return
     }
 
@@ -416,6 +491,41 @@ class CiVisibilityExporter extends BufferingExporter {
       evpProxyPrefix: this.evpProxyPrefix,
     }, callback)
   }
+
+  /**
+   * Returns whether the exporter can upload test failure screenshots.
+   *
+   * @returns {boolean}
+   */
+  canUploadTestScreenshots () {
+    return Boolean(this._testScreenshotUploadUrl) && this._isTestFailureScreenshotsEnabled
+  }
+
+  /**
+   * Uploads a single test screenshot to the Test Optimization media intake.
+   *
+   * @param {object} options - Upload options
+   * @param {string} options.filePath - Path to the screenshot file
+   * @param {string} options.traceId - Test trace id used as the screenshot key
+   * @param {string} options.idempotencyKey - Stable per-artifact key, reused on retry
+   * @param {number} options.capturedAtMs - Capture time in epoch milliseconds
+   * @param {Function} callback - Callback function (err)
+   */
+  uploadTestScreenshot ({ filePath, traceId, idempotencyKey, capturedAtMs }, callback) {
+    if (!this._testScreenshotUploadUrl) {
+      return callback(new Error('Test screenshot upload URL not configured'))
+    }
+
+    uploadTestScreenshotRequest({
+      filePath,
+      traceId,
+      idempotencyKey,
+      capturedAtMs,
+      url: this._testScreenshotUploadUrl,
+      isEvpProxy: !!this._isUsingEvpProxy,
+      evpProxyPrefix: this.evpProxyPrefix,
+    }, callback)
+  }
 }
 
 module.exports = CiVisibilityExporter