dd-trace 6.11.0 → 6.13.0

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

@@ -1,10 +1,10 @@
 'use strict'
 
 const getConfig = require('../../config')
-const request = require('../requests/request')
+const { EVP_SUBDOMAIN_HEADER_NAME } = require('../../evp_proxy/constants')
+const { joinEVPProxyPath } = require('../../evp_proxy/path')
 const id = require('../../id')
 const log = require('../../log')
-
 const {
   incrementCountMetric,
   distributionMetric,
@@ -14,8 +14,8 @@ const {
   TELEMETRY_KNOWN_TESTS_RESPONSE_TESTS,
   TELEMETRY_KNOWN_TESTS_RESPONSE_BYTES,
 } = require('../../ci-visibility/telemetry')
-
 const { getNumFromKnownTests } = require('../../plugins/util/test')
+const request = require('../requests/request')
 const { buildCacheKey, writeToCache, withCache } = require('../requests/fs-cache')
 const { validateKnownTestsResponse } = require('../test-optimization-http-cache-schema')
 
@@ -162,8 +162,8 @@ function fetchFromApi ({
   }
 
   if (isEvpProxy) {
-    options.path = `${evpProxyPrefix}/api/v2/ci/libraries/tests`
-    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    options.path = joinEVPProxyPath(evpProxyPrefix, '/api/v2/ci/libraries/tests')
+    options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'api'
   } else {
     const { DD_API_KEY } = getConfig()
     if (!DD_API_KEY) {

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

@@ -8,6 +8,8 @@ const request = require('../request')
 const { fetchAgentInfo } = require('../../../agent/info')
 const { DEBUGGER_INPUT_V1 } = require('../../../debugger/constants')
 
+// Product-specific discovery: newest advertised version, skip v3 (citestcycle), gzip if >= v4.
+// Shared `evp_proxy` discovery is an explicit path allowlist and does not cover this contract.
 const AGENT_EVP_PROXY_PATH_PREFIX = '/evp_proxy/v'
 const AGENT_EVP_PROXY_PATH_REGEX = /\/evp_proxy\/v(\d+)\/?/
 

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

@@ -1,7 +1,9 @@
 'use strict'
 const getConfig = require('../../../config')
-const log = require('../../../log')
+const { EVP_SUBDOMAIN_HEADER_NAME } = require('../../../evp_proxy/constants')
+const { joinEVPProxyPath } = require('../../../evp_proxy/path')
 const { safeJSONStringify } = require('../../../exporters/common/util')
+const log = require('../../../log')
 
 const {
   incrementCountMetric,
@@ -53,9 +55,9 @@ class Writer extends BaseWriter {
     }
 
     if (this._evpProxyPrefix) {
-      options.path = `${this._evpProxyPrefix}/api/v2/citestcov`
+      options.path = joinEVPProxyPath(this._evpProxyPrefix, '/api/v2/citestcov')
       delete options.headers['dd-api-key']
-      options.headers['X-Datadog-EVP-Subdomain'] = 'citestcov-intake'
+      options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'citestcov-intake'
     }
 
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style

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

@@ -1,22 +1,21 @@
 'use strict'
 
 const BaseWriter = require('../../../exporters/common/writer')
+const { createFinalFlushTimeoutError } = require('../../final-flush')
 
-const FINAL_FLUSH_TIMEOUT_CODE = 'ERR_DD_TEST_OPTIMIZATION_FLUSH_TIMEOUT'
-
-class TestOptimizationRequestTracker {
-  #writer
+class FinalFlushRequestTracker {
+  #flush
   #pendingRequests = new Set()
   #finalFlushes = new Set()
   #activeFinalFlush
 
   /**
-   * Creates request tracking for a Test Optimization writer.
+   * Creates request tracking for a Test Optimization exporter.
    *
-   * @param {BaseWriter} writer
+   * @param {(done?: (error?: Error) => void, options?: { deadline?: number }) => void} flush
    */
-  constructor (writer) {
-    this.#writer = writer
+  constructor (flush) {
+    this.#flush = flush
   }
 
   /**
@@ -30,7 +29,7 @@ class TestOptimizationRequestTracker {
    */
   flush (done, options) {
     if (options?.deadline === undefined) {
-      BaseWriter.prototype.flush.call(this.#writer, done, options)
+      this.#flush(done, options)
       return
     }
 
@@ -50,8 +49,7 @@ class TestOptimizationRequestTracker {
 
     const remaining = Math.max(0, options.deadline - Date.now())
     finalFlush.timeoutId = setTimeout(() => {
-      const error = new Error('Timed out flushing Test Optimization data')
-      error.code = FINAL_FLUSH_TIMEOUT_CODE
+      const error = createFinalFlushTimeoutError()
 
       finalFlush.error ||= error
       finalFlush.writerDone = true
@@ -72,7 +70,7 @@ class TestOptimizationRequestTracker {
     const previousFinalFlush = this.#activeFinalFlush
     this.#activeFinalFlush = finalFlush
     try {
-      BaseWriter.prototype.flush.call(this.#writer, (error) => {
+      this.#flush((error) => {
         finalFlush.error ||= error
         finalFlush.writerDone = true
         this.#finishFinalFlush(finalFlush)
@@ -100,22 +98,37 @@ class TestOptimizationRequestTracker {
     this.#pendingRequests.add(pendingRequest)
     if (this.#activeFinalFlush) this.#attachRequest(this.#activeFinalFlush, pendingRequest)
 
-    request(data, requestOptions, (error, result, statusCode, headers) => {
-      if (error) {
-        for (const finalFlush of pendingRequest.finalFlushes) finalFlush.error ||= error
-      }
+    try {
+      request(data, requestOptions, (error, result, statusCode, headers) => {
+        if (error) {
+          for (const finalFlush of pendingRequest.finalFlushes) finalFlush.error ||= error
+        }
 
-      try {
-        callback(error, result, statusCode, headers)
-      } finally {
-        this.#pendingRequests.delete(pendingRequest)
-        for (const finalFlush of pendingRequest.finalFlushes) {
-          finalFlush.requests.delete(pendingRequest)
-          this.#finishFinalFlush(finalFlush)
+        try {
+          callback(error, result, statusCode, headers)
+        } finally {
+          this.#dropRequest(pendingRequest)
         }
-        pendingRequest.finalFlushes.clear()
-      }
-    })
+      })
+    } catch (error) {
+      this.#dropRequest(pendingRequest)
+      throw error
+    }
+  }
+
+  /**
+   * Stops tracking a settled request and releases final flushes waiting for it.
+   *
+   * @param {object} pendingRequest
+   * @returns {void}
+   */
+  #dropRequest (pendingRequest) {
+    this.#pendingRequests.delete(pendingRequest)
+    for (const finalFlush of pendingRequest.finalFlushes) {
+      finalFlush.requests.delete(pendingRequest)
+      this.#finishFinalFlush(finalFlush)
+    }
+    pendingRequest.finalFlushes.clear()
   }
 
   /**
@@ -161,4 +174,16 @@ class TestOptimizationRequestTracker {
   }
 }
 
+class TestOptimizationRequestTracker extends FinalFlushRequestTracker {
+  /**
+   * Creates request tracking for a Test Optimization writer.
+   *
+   * @param {BaseWriter} writer
+   */
+  constructor (writer) {
+    super((done, options) => BaseWriter.prototype.flushDirect.call(writer, done, options))
+  }
+}
+
 module.exports = TestOptimizationRequestTracker
+module.exports.FinalFlushRequestTracker = FinalFlushRequestTracker

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

@@ -1,5 +1,7 @@
 'use strict'
 const getConfig = require('../../../config')
+const { EVP_SUBDOMAIN_HEADER_NAME } = require('../../../evp_proxy/constants')
+const { joinEVPProxyPath } = require('../../../evp_proxy/path')
 const { safeJSONStringify } = require('../../../exporters/common/util')
 const log = require('../../../log')
 
@@ -54,9 +56,9 @@ class Writer extends BaseWriter {
     }
 
     if (this._evpProxyPrefix) {
-      options.path = `${this._evpProxyPrefix}/api/v2/citestcycle`
+      options.path = joinEVPProxyPath(this._evpProxyPrefix, '/api/v2/citestcycle')
       delete options.headers['dd-api-key']
-      options.headers['X-Datadog-EVP-Subdomain'] = 'citestcycle-intake'
+      options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'citestcycle-intake'
     }
 
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style

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

@@ -22,6 +22,11 @@ const { getSegment } = require('../../util')
 const BufferingExporter = require('../../exporters/common/buffering-exporter')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../../plugins/util/tags')
 const { TEST_STATUS } = require('../../plugins/util/test')
+const {
+  createFinalFlushTimeoutError,
+  FINAL_FLUSH_FALLBACK_DELAY,
+  FINAL_FLUSH_TIMEOUT,
+} = require('../final-flush')
 const { sendGitMetadata: sendGitMetadataRequest } = require('./git/git_metadata')
 
 const hostname = getHostname()
@@ -60,17 +65,6 @@ function getIsTestSessionTrace (trace) {
 const GIT_UPLOAD_TIMEOUT = 60_000 // 60 seconds
 const CAN_USE_CI_VIS_PROTOCOL_TIMEOUT = GIT_UPLOAD_TIMEOUT
 const MAX_COVERAGE_REPORT_FLAGS = 32
-const FINAL_FLUSH_TIMEOUT = 10_000
-const FINAL_FLUSH_FALLBACK_DELAY = 100
-
-/**
- * @returns {Error}
- */
-function createFinalFlushTimeoutError () {
-  const error = new Error('Timed out waiting for Test Optimization to flush')
-  error.code = 'ERR_DD_TEST_OPTIMIZATION_FLUSH_TIMEOUT'
-  return error
-}
 
 function appendLogTag (tags, key, value) {
   if (value !== undefined) {

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

@@ -4,6 +4,8 @@ const fs = require('fs')
 const path = require('path')
 
 const getConfig = require('../../../config')
+const { EVP_SUBDOMAIN_HEADER_NAME } = require('../../../evp_proxy/constants')
+const { joinEVPProxyPath } = require('../../../evp_proxy/path')
 const FormData = require('../../../exporters/common/form-data')
 const request = require('../../../exporters/common/request')
 
@@ -83,8 +85,8 @@ function getCommitsToUpload ({ url, repositoryUrl, latestCommits, isEvpProxy, ev
   }
 
   if (isEvpProxy) {
-    options.path = `${evpProxyPrefix}/api/v2/git/repository/search_commits`
-    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    options.path = joinEVPProxyPath(evpProxyPrefix, '/api/v2/git/repository/search_commits')
+    options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'api'
     delete options.headers['dd-api-key']
   }
 
@@ -179,8 +181,8 @@ function uploadPackFile ({ url, isEvpProxy, evpProxyPrefix, packFileToUpload, re
   }
 
   if (isEvpProxy) {
-    options.path = `${evpProxyPrefix}/api/v2/git/repository/packfile`
-    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    options.path = joinEVPProxyPath(evpProxyPrefix, '/api/v2/git/repository/packfile')
+    options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'api'
     delete options.headers['dd-api-key']
   }
 

package/packages/dd-trace/src/ci-visibility/final-flush.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const FINAL_FLUSH_TIMEOUT = 10_000
+const FINAL_FLUSH_FALLBACK_DELAY = 100
+const FINAL_FLUSH_TIMEOUT_CODE = 'ERR_DD_TEST_OPTIMIZATION_FLUSH_TIMEOUT'
+
+/**
+ * @returns {Error & { code: string }}
+ */
+function createFinalFlushTimeoutError () {
+  const error = new Error('Timed out waiting for Test Optimization to flush')
+  error.code = FINAL_FLUSH_TIMEOUT_CODE
+  return error
+}
+
+module.exports = {
+  createFinalFlushTimeoutError,
+  FINAL_FLUSH_FALLBACK_DELAY,
+  FINAL_FLUSH_TIMEOUT,
+}

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

@@ -1,7 +1,8 @@
 'use strict'
 
 const getConfig = require('../../config')
-const request = require('../requests/request')
+const { EVP_SUBDOMAIN_HEADER_NAME } = require('../../evp_proxy/constants')
+const { joinEVPProxyPath } = require('../../evp_proxy/path')
 const log = require('../../log')
 const {
   incrementCountMetric,
@@ -13,6 +14,7 @@ const {
   TELEMETRY_ITR_SKIPPABLE_TESTS_RESPONSE_TESTS,
   TELEMETRY_ITR_SKIPPABLE_TESTS_RESPONSE_BYTES,
 } = require('../../ci-visibility/telemetry')
+const request = require('../requests/request')
 const { buildCacheKey, writeToCache, withCache } = require('../requests/fs-cache')
 const { validateSkippableTestsResponse } = require('../test-optimization-http-cache-schema')
 
@@ -227,8 +229,8 @@ function fetchFromApi ({
   }
 
   if (isEvpProxy) {
-    options.path = `${evpProxyPrefix}/api/v2/ci/tests/skippable`
-    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    options.path = joinEVPProxyPath(evpProxyPrefix, '/api/v2/ci/tests/skippable')
+    options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'api'
   } else {
     const { DD_API_KEY } = getConfig()
     if (!DD_API_KEY) {

package/packages/dd-trace/src/ci-visibility/log-submission/log-submission-plugin.js

@@ -1,53 +1,220 @@
 'use strict'
 
-const Plugin = require('../../plugins/plugin')
+const { Writable } = require('node:stream')
+
+const request = require('../../exporters/common/request')
 const log = require('../../log')
+const Plugin = require('../../plugins/plugin')
+const { FinalFlushRequestTracker } = require('../exporters/agentless/request-tracker')
+const { FINAL_FLUSH_TIMEOUT } = require('../final-flush')
 
-function getWinstonLogSubmissionParameters (config) {
-  const { site, service, DD_API_KEY, DD_AGENTLESS_LOG_SUBMISSION_URL } = config
+const MAX_BATCH_BYTES = 5 * 1024 * 1024
+const MAX_BATCH_LOGS = 1000
+const BATCH_FLUSH_INTERVAL = 1000
 
-  const defaultParameters = {
-    host: `http-intake.logs.${site}`,
-    path: `/api/v2/logs?ddsource=winston&service=${service}`,
-    ssl: true,
-    headers: {
-      'DD-API-KEY': DD_API_KEY,
-    },
-  }
+/**
+ * @param {import('../../config/config-base')} config
+ * @returns {URL | undefined}
+ */
+function getLogSubmissionUrl (config) {
+  if (config.DD_AGENTLESS_LOG_SUBMISSION_URL) {
+    try {
+      const url = new URL(config.DD_AGENTLESS_LOG_SUBMISSION_URL)
+      if (url.protocol === 'http:' || url.protocol === 'https:') return url
 
-  if (!DD_AGENTLESS_LOG_SUBMISSION_URL) {
-    return defaultParameters
+      log.error('Unsupported automatic log submission URL protocol: %s', url.protocol)
+    } catch {
+      log.error('Could not parse DD_AGENTLESS_LOG_SUBMISSION_URL')
+    }
+    return
   }
 
+  const hostname = `http-intake.logs.${config.site}`.toLowerCase()
   try {
-    const url = new URL(DD_AGENTLESS_LOG_SUBMISSION_URL)
-    return {
-      host: url.hostname,
-      port: url.port,
-      ssl: url.protocol === 'https:',
-      path: defaultParameters.path,
-      headers: defaultParameters.headers,
-    }
-  } catch {
-    log.error('Could not parse DD_AGENTLESS_LOG_SUBMISSION_URL')
-    return defaultParameters
-  }
+    const url = new URL(`https://${hostname}`)
+    if (url.hostname === hostname) return url
+  } catch {}
+
+  log.error('Could not parse automatic log submission site: %s', config.site)
+}
+
+/**
+ * @param {import('../../config/config-base')} config
+ * @param {string} source
+ * @returns {string}
+ */
+function getLogSubmissionPath (config, source) {
+  return `/api/v2/logs?${new URLSearchParams({ ddsource: source, service: config.service })}`
 }
 
 class LogSubmissionPlugin extends Plugin {
   static id = 'log-submission'
 
+  /** @type {string[]} */
+  #batch = []
+  #batchBytes = 2
+  #batchSource
+  #logSubmissionUrl
+  #requestTracker
+  #timer
+  #beforeExitHandler = () => this.#flushLogs()
+  #createWinstonJsonFormat
+  #winstonStreamClass
+  // Winston formats records inside its transports, not at logger.write time, so (unlike Bunyan/Pino)
+  // the instrumentation can't publish a post-format line. A Stream transport pipes format.json()
+  // output through this Writable into the shared sender, reusing Winston's own cycle-safe serializer.
+  #winstonOutput = new Writable({
+    decodeStrings: false,
+    write: (message, encoding, callback) => {
+      this.#enqueueLog({ source: 'winston', message })
+      callback()
+    },
+  })
+
   constructor (...args) {
     super(...args)
+    this.#requestTracker = new FinalFlushRequestTracker((done) => {
+      this.#flushLogs()
+      done?.()
+    })
+
+    // The main-module hook (configure) and the logger.js hook (add-transport) can fire in either
+    // order depending on how Winston is required, so buffer loggers that arrive before configure.
+    const pendingWinstonLoggers = new Set()
+    const addWinstonTransport = (logger) => {
+      if (!this.#winstonStreamClass || !this.#createWinstonJsonFormat) {
+        pendingWinstonLoggers.add(logger)
+        return
+      }
+
+      logger.add(new this.#winstonStreamClass({
+        format: this.#createWinstonJsonFormat(),
+        stream: this.#winstonOutput,
+      }))
+    }
+
+    this.addSub('ci:log-submission:winston:configure', ({ StreamTransport, createJsonFormat }) => {
+      this.#winstonStreamClass = StreamTransport
+      this.#createWinstonJsonFormat = createJsonFormat
 
-    this.addSub('ci:log-submission:winston:configure', (httpClass) => {
-      this.HttpClass = httpClass
+      for (const logger of pendingWinstonLoggers) {
+        addWinstonTransport(logger)
+      }
+      pendingWinstonLoggers.clear()
     })
 
-    this.addSub('ci:log-submission:winston:add-transport', (logger) => {
-      logger.add(new this.HttpClass(getWinstonLogSubmissionParameters(this.config)))
+    this.addSub('ci:log-submission:winston:add-transport', addWinstonTransport)
+
+    this.addSub('ci:log-submission:log', (payload) => {
+      this.#enqueueLog(payload)
+    })
+    this.addSub('ci:log-submission:flush', ({ onDone } = {}) => {
+      if (!onDone) {
+        this.#flushLogs()
+        return
+      }
+
+      this.#requestTracker.flush(onDone, {
+        deadline: Date.now() + FINAL_FLUSH_TIMEOUT,
+      })
     })
   }
+
+  /**
+   * @param {boolean | (Record<string, unknown> & { enabled: boolean })} config
+   * @returns {void}
+   */
+  configure (config) {
+    if (this._enabled) this.#flushLogs()
+
+    const isEnabled = typeof config === 'boolean' ? config : config.enabled
+    this.#logSubmissionUrl = isEnabled && typeof config !== 'boolean'
+      ? getLogSubmissionUrl(config)
+      : undefined
+    super.configure(config)
+
+    const beforeExitHandlers = globalThis[Symbol.for('dd-trace')].beforeExitHandlers
+    if (this._enabled) {
+      beforeExitHandlers.add(this.#beforeExitHandler)
+    } else {
+      beforeExitHandlers.delete(this.#beforeExitHandler)
+    }
+  }
+
+  /**
+   * @param {{ source: string, message: string | Record<string, unknown> }} payload
+   * @returns {void}
+   */
+  #enqueueLog ({ source, message }) {
+    if (!this.#logSubmissionUrl) return
+
+    let serializedMessage
+    try {
+      serializedMessage = typeof message === 'string' ? message : JSON.stringify(message)
+    } catch (error) {
+      log.error('Could not serialize %s log for automatic submission', source, error)
+      return
+    }
+    if (serializedMessage === undefined) return
+
+    const messageBytes = Buffer.byteLength(serializedMessage)
+    if (messageBytes + 2 > MAX_BATCH_BYTES) {
+      log.error('Could not submit %s log because it exceeds the %d byte payload limit', source, MAX_BATCH_BYTES)
+      return
+    }
+
+    if (this.#batch.length > 0 &&
+        (this.#batchSource !== source || this.#batchBytes + messageBytes + 1 > MAX_BATCH_BYTES)) {
+      this.#flushLogs()
+      if (!this.#logSubmissionUrl) return
+    }
+
+    this.#batchSource = source
+    if (this.#batch.length > 0) this.#batchBytes++
+    this.#batch.push(serializedMessage)
+    this.#batchBytes += messageBytes
+
+    if (this.#batch.length === MAX_BATCH_LOGS || this.#batchBytes === MAX_BATCH_BYTES) {
+      this.#flushLogs()
+    } else if (this.#timer === undefined) {
+      this.#timer = setTimeout(() => this.#flushLogs(), BATCH_FLUSH_INTERVAL)
+      this.#timer.unref?.()
+    }
+  }
+
+  /**
+   * @returns {void}
+   */
+  #flushLogs () {
+    clearTimeout(this.#timer)
+    this.#timer = undefined
+
+    if (this.#batch.length === 0 || !this.#logSubmissionUrl) return
+
+    const source = this.#batchSource
+    const data = `[${this.#batch.join(',')}]`
+    this.#batch = []
+    this.#batchBytes = 2
+    this.#batchSource = undefined
+    const options = {
+      path: getLogSubmissionPath(this.config, source),
+      method: 'POST',
+      headers: {
+        'DD-API-KEY': this.config.DD_API_KEY,
+        'Content-Type': 'application/json',
+      },
+      url: this.#logSubmissionUrl,
+    }
+
+    try {
+      this.#requestTracker.send(request, data, options, error => {
+        if (error) log.error('Error submitting %s logs', source, error)
+      })
+    } catch (error) {
+      this.#logSubmissionUrl = undefined
+      log.error('Error submitting %s logs', source, error)
+    }
+  }
 }
 
 module.exports = LogSubmissionPlugin

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

@@ -1,6 +1,8 @@
 'use strict'
 
 const getConfig = require('../../config')
+const { EVP_SUBDOMAIN_HEADER_NAME } = require('../../evp_proxy/constants')
+const { joinEVPProxyPath } = require('../../evp_proxy/path')
 const id = require('../../id')
 const log = require('../../log')
 const { EARLY_FLAKE_DETECTION_RETRY_BUCKETS, createEfdRetryPolicy } = require('../efd-retry-policy')
@@ -238,8 +240,8 @@ function getLibraryConfiguration ({
   }
 
   if (isEvpProxy) {
-    options.path = `${evpProxyPrefix}/api/v2/libraries/tests/services/setting`
-    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    options.path = joinEVPProxyPath(evpProxyPrefix, '/api/v2/libraries/tests/services/setting')
+    options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'api'
   } else {
     if (!config.DD_API_KEY) {
       return done(new Error('Request to settings endpoint was not done because Datadog API key is not defined.'))

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

@@ -4,6 +4,8 @@ const { closeSync, constants, fstatSync, openSync, readFileSync } = require('nod
 const { gzipSync } = require('node:zlib')
 
 const getConfig = require('../../config')
+const { EVP_SUBDOMAIN_HEADER_NAME } = require('../../evp_proxy/constants')
+const { joinEVPProxyPath } = require('../../evp_proxy/path')
 const FormData = require('../../exporters/common/form-data')
 const request = require('../../exporters/common/request')
 const log = require('../../log')
@@ -98,8 +100,8 @@ function uploadCoverageReport (
   }
 
   if (isEvpProxy) {
-    options.path = `${evpProxyPrefix}/api/v2/cicovreprt`
-    options.headers['X-Datadog-EVP-Subdomain'] = 'ci-intake'
+    options.path = joinEVPProxyPath(evpProxyPrefix, '/api/v2/cicovreprt')
+    options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'ci-intake'
   } else {
     options.path = '/api/v2/cicovreprt'
     options.headers['dd-api-key'] = DD_API_KEY

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

@@ -4,6 +4,8 @@ const { readFileSync } = require('node:fs')
 const { extname } = require('node:path')
 
 const getConfig = require('../../config')
+const { EVP_SUBDOMAIN_HEADER_NAME } = require('../../evp_proxy/constants')
+const { joinEVPProxyPath } = require('../../evp_proxy/path')
 const log = require('../../log')
 const request = require('../exporters/request')
 
@@ -134,8 +136,8 @@ function uploadTestScreenshot (
   if (isEvpProxy) {
     // Agent mode: prefix the evp_proxy path, tell the proxy which subdomain to forward to, and
     // drop the API key — the Agent injects it. The query params survive the proxy.
-    options.path = `${evpProxyPrefix}${basePath}?${query}`
-    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    options.path = `${joinEVPProxyPath(evpProxyPrefix, basePath)}?${query}`
+    options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'api'
   } else {
     options.headers['DD-API-KEY'] = DD_API_KEY
   }

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

@@ -1,10 +1,10 @@
 'use strict'
 
 const getConfig = require('../../config')
-const request = require('../requests/request')
+const { EVP_SUBDOMAIN_HEADER_NAME } = require('../../evp_proxy/constants')
+const { joinEVPProxyPath } = require('../../evp_proxy/path')
 const id = require('../../id')
 const log = require('../../log')
-
 const {
   incrementCountMetric,
   distributionMetric,
@@ -14,7 +14,7 @@ const {
   TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_TESTS,
   TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_BYTES,
 } = require('../telemetry')
-
+const request = require('../requests/request')
 const { buildCacheKey, writeToCache, withCache } = require('../requests/fs-cache')
 const { validateTestManagementTestsResponse } = require('../test-optimization-http-cache-schema')
 
@@ -132,8 +132,8 @@ function fetchFromApi ({
   }
 
   if (isEvpProxy) {
-    options.path = `${evpProxyPrefix}/api/v2/test/libraries/test-management/tests`
-    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    options.path = joinEVPProxyPath(evpProxyPrefix, '/api/v2/test/libraries/test-management/tests')
+    options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'api'
   } else {
     const { DD_API_KEY } = getConfig()
     if (!DD_API_KEY) {