dd-trace 6.13.0 → 6.14.0

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

@@ -45,10 +45,16 @@ function formatMetricTags (tagsDictionary) {
   return Object.keys(tagsDictionary).reduce((/** @type {string[]} */ acc, tagKey) => {
     if (tagKey === 'statusCode') {
       const statusCode = tagsDictionary[tagKey]
-      if (isStatusCode400(statusCode)) {
-        acc.push(`status_code:${statusCode}`)
+      if (statusCode) {
+        acc.push(`status_code:${statusCode}`, `error_type:${getErrorTypeFromStatusCode(statusCode)}`)
+      } else if (!tagsDictionary.errorType) {
+        acc.push('error_type:network')
       }
-      acc.push(`error_type:${getErrorTypeFromStatusCode(statusCode)}`)
+      return acc
+    }
+    if (tagKey === 'errorType') {
+      const errorType = tagsDictionary[tagKey]
+      if (errorType) acc.push(`error_type:${errorType}`)
       return acc
     }
     const formattedTagKey = /** @type {string} */(formattedTags[tagKey] || tagKey)
@@ -129,11 +135,8 @@ const TELEMETRY_TEST_MANAGEMENT_TESTS_ERRORS = 'test_management_tests.request_er
 const TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_TESTS = 'test_management_tests.response_tests'
 const TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_BYTES = 'test_management_tests.response_bytes'
 
-function isStatusCode400 (statusCode) {
-  return statusCode >= 400 && statusCode < 500
-}
-
 function getErrorTypeFromStatusCode (statusCode) {
+  if (typeof statusCode !== 'number') return 'network'
   if (statusCode >= 400 && statusCode < 500) {
     return 'status_code_4xx_response'
   }

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

@@ -0,0 +1,61 @@
+'use strict'
+
+const {
+  TEST_FAILURE_VIDEO_SCOPE,
+  TEST_FAILURE_VIDEO_UPLOADED,
+  TEST_FAILURE_VIDEO_UPLOAD_ERROR,
+} = require('../plugins/util/test')
+
+const VIDEO_UPLOAD_RESULT_UPLOADED = 'uploaded'
+const VIDEO_UPLOAD_RESULT_ERROR = 'error'
+const VIDEO_UPLOAD_SCOPE_TEST_SUITE = 'test_suite'
+
+/**
+ * Combines video upload results, giving errors precedence over successes.
+ *
+ * @param {Array<string|undefined>} uploadResults - Per-video upload results
+ * @returns {string|undefined} Combined upload result
+ */
+function getVideoUploadResult (uploadResults) {
+  let hasUploaded = false
+  for (const uploadResult of uploadResults) {
+    if (uploadResult === VIDEO_UPLOAD_RESULT_ERROR) return VIDEO_UPLOAD_RESULT_ERROR
+    if (uploadResult === VIDEO_UPLOAD_RESULT_UPLOADED) hasUploaded = true
+  }
+  return hasUploaded ? VIDEO_UPLOAD_RESULT_UPLOADED : undefined
+}
+
+/**
+ * Returns the tag that represents an aggregate video upload outcome.
+ *
+ * @param {string|undefined} uploadResult - Aggregate video upload result
+ * @returns {string|undefined} Video upload result tag
+ */
+function getVideoUploadTag (uploadResult) {
+  if (uploadResult === VIDEO_UPLOAD_RESULT_ERROR) return TEST_FAILURE_VIDEO_UPLOAD_ERROR
+  if (uploadResult === VIDEO_UPLOAD_RESULT_UPLOADED) return TEST_FAILURE_VIDEO_UPLOADED
+}
+
+/**
+ * Tags a test or test suite span with its video upload outcome and optional scope.
+ *
+ * @param {object} span - Test or test suite span to tag
+ * @param {string|undefined} uploadResult - Aggregate video upload result
+ * @param {string} [scope] - Media lookup scope
+ * @returns {void}
+ */
+function setVideoUploadTags (span, uploadResult, scope) {
+  const uploadTag = getVideoUploadTag(uploadResult)
+  if (!uploadTag) return
+  span.setTag(uploadTag, 'true')
+  if (scope) span.setTag(TEST_FAILURE_VIDEO_SCOPE, scope)
+}
+
+module.exports = {
+  VIDEO_UPLOAD_RESULT_ERROR,
+  VIDEO_UPLOAD_RESULT_UPLOADED,
+  VIDEO_UPLOAD_SCOPE_TEST_SUITE,
+  getVideoUploadResult,
+  getVideoUploadTag,
+  setVideoUploadTags,
+}

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

@@ -65,6 +65,7 @@ export interface GeneratedConfig {
   };
   dbmPropagationMode: "disabled" | "service" | "full" | "dynamic_service";
   DD_ACTION_EXECUTION_ID: string | undefined;
+  DD_AGENTLESS_ENABLED: boolean;
   DD_AGENTLESS_LOG_SUBMISSION_ENABLED: boolean;
   DD_AGENTLESS_LOG_SUBMISSION_URL: string | undefined;
   DD_API_KEY: string | undefined;
@@ -581,6 +582,7 @@ export interface GeneratedConfig {
     DD_TEST_EARLY_FLAKE_DETECTION_RETRY_COUNT: number | undefined;
     DD_TEST_FAILED_TEST_REPLAY_ENABLED: boolean;
     DD_TEST_FAILURE_SCREENSHOTS_ENABLED: boolean | undefined;
+    DD_TEST_FAILURE_VIDEOS_ENABLED: boolean | undefined;
     DD_TEST_FLEET_CONFIG_PATH: string | undefined;
     DD_TEST_LOCAL_CONFIG_PATH: string | undefined;
     DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES: number;
@@ -610,6 +612,7 @@ export interface GeneratedEnvVarConfig {
   DATADOG_API_KEY: string | undefined;
   DD_ACTION_EXECUTION_ID: string | undefined;
   DD_AGENT_HOST: string;
+  DD_AGENTLESS_ENABLED: boolean;
   DD_AGENTLESS_LOG_SUBMISSION_ENABLED: boolean;
   DD_AGENTLESS_LOG_SUBMISSION_URL: string | undefined;
   DD_AI_GUARD_BLOCK: boolean;
@@ -827,6 +830,7 @@ export interface GeneratedEnvVarConfig {
   DD_TEST_EARLY_FLAKE_DETECTION_RETRY_COUNT: number | undefined;
   DD_TEST_FAILED_TEST_REPLAY_ENABLED: boolean;
   DD_TEST_FAILURE_SCREENSHOTS_ENABLED: boolean | undefined;
+  DD_TEST_FAILURE_VIDEOS_ENABLED: boolean | undefined;
   DD_TEST_FLEET_CONFIG_PATH: string | undefined;
   DD_TEST_LOCAL_CONFIG_PATH: string | undefined;
   DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES: number;

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

@@ -4,8 +4,10 @@ const fs = require('node:fs')
 const os = require('node:os')
 const { URL, format } = require('node:url')
 
+const { channel } = require('dc-polyfill')
+
 const exporters = require('../../../../ext/exporters')
-const rfdc = require('../../../../vendor/dist/rfdc')({ proto: false, circles: false })
+const createRfdc = require('../../../../vendor/dist/rfdc')
 const uuid = require('../../../../vendor/dist/crypto-randomuuid') // we need to keep the old uuid dep because of cypress
 const set = require('../../../datadog-core/src/utils/src/set')
 const { DD_MAJOR, NODE_MAJOR } = require('../../../../version')
@@ -42,7 +44,12 @@ const {
 const { normalizeService } = require('./normalize-service')
 const { programmaticTypeCoercions, transformers } = require('./parsers')
 
-const RUNTIME_ID = uuid()
+const rfdc = createRfdc({
+  proto: false,
+  circles: false,
+  constructorHandlers: [[RegExp, transformers.toCamelCase]],
+})
+
 const TEST_OPTIMIZATION_WORKER_EXPORTERS = new Set([
   exporters.CUCUMBER_WORKER,
   exporters.JEST_WORKER,
@@ -51,6 +58,21 @@ const TEST_OPTIMIZATION_WORKER_EXPORTERS = new Set([
   exporters.VITEST_WORKER,
 ])
 
+let runtimeId
+
+channel('datadog:identity:update').subscribe(refreshRuntimeId)
+
+/**
+ * Lazily generates the process-wide runtime ID on first access instead of at module load,
+ * so modules that merely require this file without constructing a Config never pay for it.
+ *
+ * @returns {string}
+ */
+function getRuntimeId () {
+  runtimeId ??= uuid()
+  return runtimeId
+}
+
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
 
 /**
@@ -390,11 +412,6 @@ class Config extends ConfigBase {
     if (!trackedConfigOrigins.has('dogstatsd.hostname')) {
       setAndTrack(this, 'dogstatsd.hostname', agentHostname)
     }
-    // Disable log injection when OTEL logs are enabled
-    // OTEL logs and DD log injection are mutually exclusive
-    if (this.DD_LOGS_OTEL_ENABLED) {
-      setAndTrack(this, 'logInjection', false)
-    }
     if (this.DD_METRICS_OTEL_ENABLED &&
         trackedConfigOrigins.has('OTEL_METRICS_EXPORTER') &&
         this.OTEL_METRICS_EXPORTER === 'none') {
@@ -476,6 +493,12 @@ class Config extends ConfigBase {
       setAndTrack(this, 'runtimeMetrics.enabled', false)
     }
 
+    const agentlessTracingEnabled = this.DD_AGENTLESS_ENABLED ||
+      isTrue(getEnvironmentVariable('_DD_APM_TRACING_AGENTLESS_ENABLED'))
+    if (agentlessTracingEnabled && !this.isCiVisibility) {
+      setAndTrack(this, 'OTEL_TRACES_EXPORTER', 'none')
+    }
+
     // Apply the OTel sampler when the user opted into OTel traces or explicitly set the sampler.
     // OTEL_TRACES_SAMPLER has `default: parentbased_always_on` (per OTel spec), so opt-in users
     // that don't set the sampler still get parent-based sampling. Electron exporter spans go over
@@ -602,7 +625,7 @@ class Config extends ConfigBase {
     if (this.version) {
       this.tags.version = this.version
     }
-    this.tags['runtime-id'] = RUNTIME_ID
+    this.tags['runtime-id'] = getRuntimeId()
     const platformTags = getServerlessPlatformTags()
     if (platformTags) {
       for (let i = 0; i < platformTags.length; i += 2) {
@@ -622,11 +645,30 @@ class Config extends ConfigBase {
       setAndTrack(this, 'telemetry.DD_INSTRUMENTATION_TELEMETRY_ENABLED', false)
     }
 
-    // Experimental agentless APM span intake
-    // When enabled, sends spans directly to Datadog intake without an agent
-    // TODO: Replace this with a proper configuration
-    const agentlessEnabled = isTrue(getEnvironmentVariable('_DD_APM_TRACING_AGENTLESS_ENABLED'))
-    if (agentlessEnabled) {
+    if (this.DD_AGENTLESS_ENABLED) {
+      if (!trackedConfigOrigins.has('DD_AGENTLESS_LOG_SUBMISSION_ENABLED') && !this.DD_LOGS_OTEL_ENABLED) {
+        setAndTrack(this, 'DD_AGENTLESS_LOG_SUBMISSION_ENABLED', true)
+      }
+      setAndTrack(this, 'testOptimization.DD_CIVISIBILITY_AGENTLESS_ENABLED', true)
+      setAndTrack(this, 'llmobs.agentlessEnabled', true)
+      setAndTrack(this, 'featureFlags.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE', 'agentless')
+      if (this.DD_API_KEY === undefined) {
+        setAndTrack(this, 'dynamicInstrumentation.enabled', false)
+      }
+      setAndTrack(this, 'runtimeMetrics.enabled', false)
+      setAndTrack(this, 'dsmEnabled', false)
+      const profilingExporters = this.DD_PROFILING_EXPORTERS.filter(exporter => exporter !== 'agent')
+      setAndTrack(this, 'DD_PROFILING_EXPORTERS', profilingExporters)
+      if (profilingExporters.length === 0) {
+        setAndTrack(this, 'profiling.DD_PROFILING_ENABLED', 'false')
+      }
+    }
+
+    if (this.DD_AGENTLESS_LOG_SUBMISSION_ENABLED && this.DD_LOGS_OTEL_ENABLED) {
+      setAndTrack(this, 'DD_LOGS_OTEL_ENABLED', false)
+    }
+
+    if (agentlessTracingEnabled && !this.isCiVisibility) {
       setAndTrack(this, 'experimental.exporter', 'agentless')
       // Disable client-side stats computation
       setAndTrack(this, 'stats.DD_TRACE_STATS_COMPUTATION_ENABLED', false)
@@ -642,6 +684,12 @@ class Config extends ConfigBase {
       }
     }
 
+    // Disable log injection when OTEL logs are enabled
+    // OTEL logs and DD log injection are mutually exclusive
+    if (this.DD_LOGS_OTEL_ENABLED) {
+      setAndTrack(this, 'logInjection', false)
+    }
+
     // Apply all fallbacks to the calculated config.
     for (const [configName, alias] of fallbackConfigurations) {
       if (!trackedConfigOrigins.has(configName) && trackedConfigOrigins.has(alias)) {
@@ -788,3 +836,15 @@ function getConfig (options) {
   }
   return configInstance
 }
+
+/**
+ * Regenerates the runtime ID.
+ *
+ * Used for Lambda MicroVM `/run` lifecycle hooks, giving each clone a distinct runtime identity.
+ *
+ * @param {import('./config-base')} config
+ */
+function refreshRuntimeId (config) {
+  runtimeId = uuid()
+  config.tags['runtime-id'] = runtimeId
+}

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const fs = require('fs')
+const { isRegExp } = require('node:util').types
 
 const { DD_MAJOR, NODE_MAJOR } = require('../../../../version')
 const tagger = require('../tagger')
@@ -72,6 +73,9 @@ const transformers = {
   toUpperCase (value) {
     return toCase(value, 'toUpperCase')
   },
+  /**
+   * @param {unknown} value
+   */
   toCamelCase (value) {
     if (Array.isArray(value)) {
       return value.map(item => {
@@ -79,6 +83,10 @@ const transformers = {
       })
     }
     if (typeof value === 'object' && value !== null) {
+      // RegExp matchers are supported configuration leaves and need their own clone.
+      if (isRegExp(value)) {
+        return new RegExp(value)
+      }
       const result = {}
       for (const [key, innerValue] of Object.entries(value)) {
         const camelCaseKey = key.replaceAll(/_(\w)/g, (_, letter) => letter.toUpperCase())
@@ -90,8 +98,10 @@ const transformers = {
   },
   parseOtelTags (object) {
     const tags = {}
+    const environment = object['deployment.environment.name'] ?? object['deployment.environment']
     for (const [key, value] of Object.entries(object)) {
-      tags[RENAMED_OTEL_TAGS.get(key) ?? key] = value
+      const renamedKey = RENAMED_OTEL_TAGS.get(key)
+      tags[renamedKey ?? key] = renamedKey === 'env' ? environment : value
     }
     return tags
   },

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

@@ -22,16 +22,16 @@ class StableConfig {
 
     // Note: we don't enforce loading because there may be cases where the library is not available and we
     // want to avoid breaking the application. In those cases, we will not have the file-based configuration.
-    let libdatadog
+    let libdatadogExtras
     try {
-      libdatadog = require('@datadog/libdatadog')
+      libdatadogExtras = require('@datadog/libdatadog-extras')
       this.wasm_loaded = true
     } catch {
       this.warnings.push('Can\'t load libdatadog library')
       return
     }
 
-    const libconfig = libdatadog.maybeLoad('library_config')
+    const libconfig = libdatadogExtras.maybeLoad('library_config')
     if (libconfig === undefined) {
       this.warnings.push('Can\'t load library_config library')
       return

package/packages/dd-trace/src/config/supported-configurations.json

@@ -8,18 +8,28 @@
         "default": null
       }
     ],
+    "DD_AGENTLESS_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "false",
+        "description": "Enable agentless mode for supported features and disable Agent-only features."
+      }
+    ],
     "DD_AGENTLESS_LOG_SUBMISSION_ENABLED": [
       {
         "implementation": "A",
         "type": "boolean",
-        "default": "false"
+        "default": "false",
+        "description": "Submit supported logger output directly to the Datadog logs intake."
       }
     ],
     "DD_AGENTLESS_LOG_SUBMISSION_URL": [
       {
         "implementation": "A",
         "type": "string",
-        "default": null
+        "default": null,
+        "description": "Override the automatic log submission intake URL."
       }
     ],
     "_DD_APM_TRACING_AGENTLESS_ENABLED": [
@@ -1929,6 +1939,14 @@
         "namespace": "testOptimization"
       }
     ],
+    "DD_TEST_FAILURE_VIDEOS_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": null,
+        "namespace": "testOptimization"
+      }
+    ],
     "DD_TEST_FLEET_CONFIG_PATH": [
       {
         "implementation": "A",

package/packages/dd-trace/src/crashtracking/crashtracker.js

@@ -3,12 +3,61 @@
 const { EOL, platform } = require('node:os')
 
 // Load binding first to not import other modules if it throws
-const libdatadog = require('@datadog/libdatadog')
-const binding = libdatadog.load('crashtracker')
+const libdatadogExtras = require('@datadog/libdatadog-extras')
+const binding = libdatadogExtras.load('crashtracker')
 
+const { channel } = require('dc-polyfill')
+const { getEnvironmentVariable } = require('../config/helper')
 const log = require('../log')
 const pkg = require('../../../../package.json')
 const processTags = require('../process-tags')
+const getAgentlessTelemetryUrl = require('../telemetry/agentless-url')
+
+const identityRefreshChannel = channel('datadog:identity:refresh')
+const INHERITED_RECEIVER_ENVIRONMENT_VARIABLES = [
+  'HTTP_PROXY',
+  'HTTPS_PROXY',
+  'NO_PROXY',
+  'http_proxy',
+  'https_proxy',
+  'no_proxy',
+  'SSL_CERT_FILE',
+  'SSL_CERT_DIR',
+]
+
+/**
+ * Builds the minimal receiver environment libdatadog needs to select its two direct crash
+ * destinations independently: instrumentation telemetry and Errors Tracking intake.
+ *
+ * @param {import('../config/config-base')} config - Tracer configuration
+ * @returns {Array<[string, string]>}
+ */
+function getAgentlessReceiverEnvironment (config) {
+  if (!config.DD_API_KEY) {
+    throw new Error('DD_API_KEY is required for agentless crash tracking')
+  }
+
+  const site = config.site.toLowerCase()
+  const telemetryUrl = getAgentlessTelemetryUrl(site).origin
+
+  const environment = /** @type {Array<[string, string]>} */ ([
+    ['_DD_DIRECT_SUBMISSION_ENABLED', 'true'],
+    ['DD_API_KEY', config.DD_API_KEY],
+    ['DD_SITE', site],
+    ['DD_APM_TELEMETRY_DD_URL', telemetryUrl],
+    // libdatadog v43 parses the dedicated URL above but does not use it when constructing the
+    // endpoint. Keep this compatibility fallback until its telemetry config honors that setting.
+    ['DD_TRACE_AGENT_URL', telemetryUrl],
+  ])
+
+  // The receiver environment does not inherit from this process.
+  for (const name of INHERITED_RECEIVER_ENVIRONMENT_VARIABLES) {
+    const value = getEnvironmentVariable(name)
+    if (value) environment.push([name, value])
+  }
+
+  return environment
+}
 
 class Crashtracker {
   #started = false
@@ -33,11 +82,12 @@ class Crashtracker {
     try {
       binding.init(
         this.#getConfig(config),
-        this.#getReceiverConfig(),
+        this.#getReceiverConfig(config),
         this.#getMetadata(config)
       )
       this.#started = true
       this.#trackUnhandledExceptions()
+      identityRefreshChannel.subscribe((config) => this.configure(config))
     } catch (e) {
       log.error('Error initializing crashtracker', e)
     }
@@ -67,7 +117,21 @@ class Crashtracker {
    * @param {import('../config/config-base')} config - Tracer configuration
    */
   #getConfig (config) {
-    const url = config.url
+    let endpoint = null
+    if (!config.DD_AGENTLESS_ENABLED) {
+      const url = config.url
+      endpoint = {
+        // TODO: Use the string directly when deserialization is fixed.
+        url: {
+          scheme: url.protocol.slice(0, -1),
+          authority: url.protocol === 'unix:'
+            ? Buffer.from(url.pathname).toString('hex')
+            : url.host,
+          path_and_query: '',
+        },
+        timeout_ms: 3000,
+      }
+    }
 
     // Out-of-process symbolication currently works on
     // Linux only, does not work on Mac.
@@ -80,17 +144,7 @@ class Crashtracker {
       collect_all_threads: true,
       create_alt_stack: true,
       use_alt_stack: true,
-      endpoint: {
-        // TODO: Use the string directly when deserialization is fixed.
-        url: {
-          scheme: url.protocol.slice(0, -1),
-          authority: url.protocol === 'unix:'
-            ? Buffer.from(url.pathname).toString('hex')
-            : url.host,
-          path_and_query: '',
-        },
-        timeout_ms: 3000,
-      },
+      endpoint,
       timeout: { secs: 5, nanos: 0 },
       demangle_names: true,
       signals: [],
@@ -124,11 +178,21 @@ class Crashtracker {
     }
   }
 
-  #getReceiverConfig () {
+  /**
+   * @param {import('../config/config-base')} config - Tracer configuration
+   * @returns {{
+   *   args: string[],
+   *   env: Array<[string, string]>,
+   *   path_to_receiver_binary: string,
+   *   stderr_filename: null,
+   *   stdout_filename: null
+   * }}
+   */
+  #getReceiverConfig (config) {
     return {
       args: [],
-      env: [],
-      path_to_receiver_binary: libdatadog.find('crashtracker-receiver', true),
+      env: config.DD_AGENTLESS_ENABLED ? getAgentlessReceiverEnvironment(config) : [],
+      path_to_receiver_binary: libdatadogExtras.find('crashtracker-receiver', true),
       stderr_filename: null,
       stdout_filename: null,
     }

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

@@ -1,10 +1,21 @@
 'use strict'
 
+const { createSiteUrl } = require('../exporters/common/url')
 const getGitMetadata = require('../git_metadata')
 
+/**
+ * @param {ReturnType<import('../config')>} config
+ * @param {string} [inputPath]
+ */
 module.exports = function getDebuggerConfig (config, inputPath) {
   const { commitSHA, repositoryUrl } = getGitMetadata(config)
+  const agentless = config.DD_AGENTLESS_ENABLED
+  const agentlessUrl = agentless ? createSiteUrl(config.site, 'debugger-intake') : undefined
+  if (agentless && agentlessUrl === undefined) return
+
   return {
+    agentless,
+    apiKey: agentless ? config.DD_API_KEY : undefined,
     commitSHA,
     debug: config.debug,
     dynamicInstrumentation: config.dynamicInstrumentation,
@@ -16,7 +27,7 @@ module.exports = function getDebuggerConfig (config, inputPath) {
     repositoryUrl,
     runtimeId: config.tags['runtime-id'],
     service: config.service,
-    url: config.url.toString(),
+    url: agentless ? agentlessUrl.origin : config.url.toString(),
     version: config.version,
     inputPath,
   }

package/packages/dd-trace/src/debugger/constants.js

@@ -1,6 +1,7 @@
 'use strict'
 
 module.exports = {
+  DEBUGGER_INPUT_DIRECT: '/api/v2/debugger',
   DEBUGGER_DIAGNOSTICS_V1: '/debugger/v1/diagnostics',
   DEBUGGER_INPUT_V1: '/debugger/v1/input',
   DEBUGGER_INPUT_V2: '/debugger/v2/input',

package/packages/dd-trace/src/debugger/devtools_client/breakpoints.js

@@ -1,6 +1,7 @@
 'use strict'
 
-const mutex = require('../../../../../vendor/dist/mutexify/promise')()
+const createMutex = require('../../../../../vendor/dist/mutexify/promise')
+const mutex = createMutex()
 const { getGeneratedPosition } = require('./source-maps')
 const session = require('./session')
 const { compile, compileSegments, templateRequiresEvaluation } = require('./condition')

package/packages/dd-trace/src/debugger/devtools_client/request-options.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const { getHttpsProxyAgent } = require('../../evp_proxy/direct')
+
+/**
+ * @param {ReturnType<import('../config')>} config - Debugger configuration
+ * @param {string} path - Request path
+ * @param {Record<string, string>} headers - Payload headers
+ * @returns {{
+ *   method: 'POST',
+ *   url: string | URL,
+ *   path: string,
+ *   headers: Record<string, string>,
+ *   agent?: import('node:https').Agent
+ * }}
+ */
+module.exports = function getRequestOptions (config, path, headers) {
+  const options = {
+    method: 'POST',
+    url: config.url,
+    path,
+    headers,
+  }
+
+  if (config.agentless) {
+    if (config.apiKey !== undefined) headers['DD-API-KEY'] = config.apiKey
+    headers['DD-EVP-ORIGIN'] = 'agent-debugger'
+    const agent = getHttpsProxyAgent(config.url.href)
+    if (agent !== undefined) options.agent = agent
+  }
+
+  return options
+}