dd-trace 5.124.0 → 5.126.0

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

@@ -0,0 +1,180 @@
+'use strict'
+
+const http = require('node:http')
+const https = require('node:https')
+
+const { storage } = require('../../../../datadog-core')
+const log = require('../../log')
+const { markEndpointReached } = require('../../exporters/common/retry')
+const { getHttpsProxyAgent } = require('../../exporters/common/proxy')
+const { isLoopbackHost, parseUrl } = require('../../exporters/common/url')
+
+const legacyStorage = storage('legacy')
+const MAX_ACTIVE_REQUESTS = 16
+
+let activeRequests = 0
+
+/**
+ * Streams one video request attempt. Test Optimization retry policy stays in the exporter request wrapper.
+ *
+ * @param {import('node:stream').Readable} body - Video stream for this attempt
+ * @param {object} options - HTTP request options
+ * @param {(error: Error|null, result?: string|null, statusCode?: number,
+ *   headers?: import('node:http').IncomingHttpHeaders) => void} callback
+ * @returns {void}
+ */
+function requestVideo (body, options, callback) {
+  if (activeRequests >= MAX_ACTIVE_REQUESTS) {
+    if (!body.destroyed) body.destroy()
+    const error = new log.NoTransmitError('Maximum active video request count reached.')
+    error.code = 'ERR_DD_VIDEO_REQUEST_LIMIT'
+    callback(error)
+    return
+  }
+
+  let requestOptions
+  try {
+    requestOptions = getRequestOptions(options)
+  } catch (error) {
+    if (!body.destroyed) body.destroy()
+    callback(error)
+    return
+  }
+
+  activeRequests++
+  legacyStorage.run({ noop: true }, () => {
+    const timeout = options.timeout || 2000
+    const client = requestOptions.protocol === 'https:' ? https : http
+    let finished = false
+    let req = null
+
+    const complete = (error, result, statusCode, headers) => {
+      if (finished) return
+      finished = true
+      activeRequests--
+      options.signal?.removeEventListener('abort', onAbort)
+      body.unpipe(req)
+      if (!body.destroyed) body.destroy()
+      if (req && !req.destroyed && (error || !req.writableFinished)) req.destroy()
+      callback(error, result, statusCode, headers)
+    }
+    const onAbort = () => complete(getAbortError(options.signal))
+
+    try {
+      req = client.request(requestOptions, res => {
+        markEndpointReached(requestOptions)
+        const chunks = []
+
+        res.setTimeout(timeout)
+        res.on('data', chunk => chunks.push(chunk))
+        res.once('aborted', () => complete(Object.assign(new Error('Response aborted'), { code: 'ECONNRESET' })))
+        res.once('error', complete)
+        res.once('timeout', () => complete(Object.assign(new Error('Response timed out'), { code: 'ETIMEDOUT' })))
+        res.once('end', () => {
+          const result = Buffer.concat(chunks).toString()
+          if (res.statusCode >= 200 && res.statusCode <= 299) {
+            complete(null, result, res.statusCode, res.headers)
+          } else {
+            complete(buildError(res, result, requestOptions), null, res.statusCode, res.headers)
+          }
+        })
+      })
+    } catch (error) {
+      activeRequests--
+      if (!body.destroyed) body.destroy()
+      callback(error)
+      return
+    }
+
+    req.once('error', complete)
+    req.setTimeout(timeout, () => complete(Object.assign(new Error('Request timed out'), { code: 'ETIMEDOUT' })))
+    body.once('error', error => {
+      error.retryable = false
+      complete(error)
+    })
+    options.signal?.addEventListener('abort', onAbort, { once: true })
+    if (options.signal?.aborted) return onAbort()
+    body.pipe(req)
+  })
+}
+
+/**
+ * @param {object} options
+ * @returns {object}
+ */
+function getRequestOptions (options) {
+  const requestOptions = {
+    ...options,
+    headers: options.headers ? { ...options.headers } : {},
+  }
+
+  if (options.url) {
+    const url = parseUrl(options.url)
+    if (url.protocol === 'unix:') {
+      requestOptions.socketPath = url.pathname
+    } else {
+      requestOptions.protocol = url.protocol
+      requestOptions.hostname = url.hostname
+      requestOptions.port = url.port
+      requestOptions.path ??= url.path
+    }
+  }
+
+  const hasApiKey = requestOptions.headers['dd-api-key'] !== undefined ||
+    requestOptions.headers['DD-API-KEY'] !== undefined
+  if (hasApiKey && requestOptions.protocol === 'http:' && !isLoopbackHost(requestOptions.hostname)) {
+    log.error(
+      'Not sending the Datadog API key over a non-TLS connection to %s. Configure an https intake URL.',
+      requestOptions.hostname
+    )
+    delete requestOptions.headers['dd-api-key']
+    delete requestOptions.headers['DD-API-KEY']
+  }
+  if (hasApiKey && requestOptions.protocol === 'https:') {
+    requestOptions.agent = getHttpsProxyAgent(requestOptions, requestOptions.agent)
+  }
+
+  delete requestOptions.deadline
+  delete requestOptions.retry
+  delete requestOptions.retryUntilDeadline
+  delete requestOptions.signal
+  delete requestOptions.url
+  return requestOptions
+}
+
+/**
+ * @param {AbortSignal} signal
+ * @returns {Error}
+ */
+function getAbortError (signal) {
+  return signal?.reason || Object.assign(new Error('Request aborted'), { code: 'ABORT_ERR' })
+}
+
+/**
+ * @param {import('node:http').IncomingMessage} res
+ * @param {string} responseData
+ * @param {object} options
+ * @returns {Error}
+ */
+function buildError (res, responseData, options) {
+  let errorMessage = ''
+  try {
+    const port = options.port ? `:${options.port}` : ''
+    const baseUrl = `${options.protocol || 'http:'}//${options.hostname || 'localhost'}${port}`
+    const fullUrl = new URL(options.path, baseUrl).href
+    errorMessage = `Error from ${fullUrl}: ${res.statusCode} ${http.STATUS_CODES[res.statusCode]}.`
+  } catch {
+    // ignore
+  }
+  if (responseData) errorMessage += ` Response from the endpoint: "${responseData}"`
+
+  const error = new log.NoTransmitError(errorMessage)
+  error.status = res.statusCode
+  return error
+}
+
+Object.defineProperty(requestVideo, 'writable', {
+  get () { return activeRequests < MAX_ACTIVE_REQUESTS },
+})
+
+module.exports = requestVideo

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": [
@@ -734,6 +744,7 @@
         "configurationNames": [
           "dogstatsd.port"
         ],
+        "allowed": "[1-9]\\d{0,3}|[1-5]\\d{4}|6[0-4]\\d{3}|65[0-4]\\d{2}|655[0-2]\\d|6553[0-5]",
         "default": "8125"
       }
     ],
@@ -1929,6 +1940,14 @@
         "namespace": "testOptimization"
       }
     ],
+    "DD_TEST_FAILURE_VIDEOS_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": null,
+        "namespace": "testOptimization"
+      }
+    ],
     "DD_TEST_FLEET_CONFIG_PATH": [
       {
         "implementation": "A",
@@ -2010,6 +2029,7 @@
         "configurationNames": [
           "port"
         ],
+        "allowed": "[1-9]\\d{0,3}|[1-5]\\d{4}|6[0-4]\\d{3}|65[0-4]\\d{2}|655[0-2]\\d|6553[0-5]",
         "default": "8126"
       }
     ],