dd-trace 5.87.0 → 5.89.0

package/packages/dd-trace/src/appsec/iast/vulnerabilities-formatter/utils.js

@@ -1,7 +1,8 @@
 'use strict'
 
 const crypto = require('crypto')
-const { DEFAULT_IAST_REDACTION_VALUE_PATTERN } = require('./evidence-redaction/sensitive-regex')
+
+const defaults = require('../../../config/defaults')
 
 const STRINGIFY_RANGE_KEY = 'DD_' + crypto.randomBytes(20).toString('hex')
 const STRINGIFY_SENSITIVE_KEY = STRINGIFY_RANGE_KEY + 'SENSITIVE'
@@ -11,7 +12,7 @@ const STRINGIFY_SENSITIVE_NOT_STRING_KEY = STRINGIFY_SENSITIVE_KEY + 'NOTSTRING'
 const KEYS_REGEX_WITH_SENSITIVE_RANGES = new RegExp(String.raw`(?:"(${STRINGIFY_RANGE_KEY}_\d+_))|(?:"(${STRINGIFY_SENSITIVE_KEY}_\d+_(\d+)_))|("${STRINGIFY_SENSITIVE_NOT_STRING_KEY}_\d+_([\s0-9.a-zA-Z]*)")`, 'gm')
 const KEYS_REGEX_WITHOUT_SENSITIVE_RANGES = new RegExp(String.raw`"(${STRINGIFY_RANGE_KEY}_\d+_)`, 'gm')
 
-const sensitiveValueRegex = new RegExp(DEFAULT_IAST_REDACTION_VALUE_PATTERN, 'gmi')
+const sensitiveValueRegex = new RegExp(/** @type {string} */ (defaults['iast.redactionValuePattern']), 'gmi')
 
 function iterateObject (target, fn, levelKeys = [], depth = 10, visited = new Set()) {
   for (const key of Object.keys(target)) {

package/packages/dd-trace/src/azure_metadata.js

@@ -58,7 +58,6 @@ function buildMetadata () {
     WEBSITE_SITE_NAME,
   } = getEnvironmentVariables()
 
-  const DD_AAS_DOTNET_EXTENSION_VERSION = getValueFromEnvSources('DD_AAS_DOTNET_EXTENSION_VERSION')
   const DD_AZURE_RESOURCE_GROUP = getValueFromEnvSources('DD_AZURE_RESOURCE_GROUP')
 
   const subscriptionID = extractSubscriptionID(WEBSITE_OWNER_NAME)
@@ -77,7 +76,6 @@ function buildMetadata () {
     : (WEBSITE_RESOURCE_GROUP ?? extractResourceGroup(WEBSITE_OWNER_NAME))
 
   return trimObject({
-    extensionVersion: DD_AAS_DOTNET_EXTENSION_VERSION,
     functionRuntimeVersion: FUNCTIONS_EXTENSION_VERSION,
     instanceID: WEBSITE_INSTANCE_ID,
     instanceName: COMPUTERNAME,

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const request = require('../../exporters/common/request')
+const request = require('../requests/request')
 const id = require('../../id')
 const log = require('../../log')
 const { getValueFromEnvSources } = require('../../config/helper')

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

@@ -206,6 +206,7 @@ class CiVisibilityExporter extends BufferingExporter {
       requireGit,
       isEarlyFlakeDetectionEnabled,
       earlyFlakeDetectionNumRetries,
+      earlyFlakeDetectionSlowTestRetries,
       earlyFlakeDetectionFaultyThreshold,
       isFlakyTestRetriesEnabled,
       isDiEnabled,
@@ -222,6 +223,7 @@ class CiVisibilityExporter extends BufferingExporter {
       requireGit,
       isEarlyFlakeDetectionEnabled: isEarlyFlakeDetectionEnabled && this._config.isEarlyFlakeDetectionEnabled,
       earlyFlakeDetectionNumRetries,
+      earlyFlakeDetectionSlowTestRetries,
       earlyFlakeDetectionFaultyThreshold,
       isFlakyTestRetriesEnabled: isFlakyTestRetriesEnabled && this._config.isFlakyTestRetriesEnabled,
       flakyTestRetriesCount: this._config.flakyTestRetriesCount,
@@ -232,6 +234,7 @@ class CiVisibilityExporter extends BufferingExporter {
         testManagementAttemptToFixRetries ?? this._config.testManagementAttemptToFixRetries,
       isImpactedTestsEnabled: isImpactedTestsEnabled && this._config.isImpactedTestsEnabled,
       isCoverageReportUploadEnabled,
+      isKeepingCoverageConfiguration: this._config.isKeepingCoverageConfiguration,
     }
   }
 

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const request = require('../../exporters/common/request')
+const request = require('../requests/request')
 const log = require('../../log')
 const { getValueFromEnvSources } = require('../../config/helper')
 const {

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

@@ -1,6 +1,5 @@
 'use strict'
 
-const request = require('../../exporters/common/request')
 const id = require('../../id')
 const log = require('../../log')
 const { getValueFromEnvSources } = require('../../config/helper')
@@ -13,8 +12,10 @@ const {
   TELEMETRY_GIT_REQUESTS_SETTINGS_RESPONSE,
 } = require('../telemetry')
 const { writeSettingsToCache } = require('../test-optimization-cache')
+const request = require('./request')
 
 const DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES = 2
+const DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES = { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
 const DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD = 30
 
 function getLibraryConfiguration ({
@@ -115,6 +116,8 @@ function getLibraryConfiguration ({
           isEarlyFlakeDetectionEnabled: isKnownTestsEnabled && (earlyFlakeDetectionConfig?.enabled ?? false),
           earlyFlakeDetectionNumRetries:
             earlyFlakeDetectionConfig?.slow_test_retries?.['5s'] || DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
+          earlyFlakeDetectionSlowTestRetries:
+            earlyFlakeDetectionConfig?.slow_test_retries ?? DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES,
           earlyFlakeDetectionFaultyThreshold:
             earlyFlakeDetectionConfig?.faulty_session_threshold ?? DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD,
           isFlakyTestRetriesEnabled,

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

@@ -0,0 +1,236 @@
+'use strict'
+
+const http = require('http')
+const https = require('https')
+const zlib = require('zlib')
+
+const { storage } = require('../../../../datadog-core')
+const log = require('../../log')
+const { httpAgent, httpsAgent } = require('../../exporters/common/agents')
+const { urlToHttpOptions } = require('../../exporters/common/url-to-http-options-polyfill')
+
+const RATE_LIMIT_MAX_WAIT_MS = 30_000
+const RETRY_BASE_MS = 5000
+const RETRY_JITTER_MS = 2500
+
+/**
+ * Calculates retry delay with jitter to prevent thundering herd.
+ * Delay is RETRY_BASE_MS + random(0, RETRY_JITTER_MS) (e.g. 5–7.5 seconds).
+ *
+ * @returns {number} Delay in milliseconds
+ */
+function getRetryDelay () {
+  return RETRY_BASE_MS + (Math.random() * RETRY_JITTER_MS)
+}
+
+/**
+ * Determines if a network error is retriable (transient failures only).
+ * ECONNREFUSED is retried because it can be transient (service starting up,
+ * restarts, rolling deploys, k8s pod/readiness transitions). ENOTFOUND is
+ * excluded as it indicates DNS failure or wrong host and is usually not transient.
+ *
+ * @param {Error} err - The error to check
+ * @returns {boolean}
+ */
+function isRetriableNetworkError (err) {
+  if (!err.code) return false
+  return err.code === 'ECONNREFUSED' ||
+    err.code === 'ECONNRESET' ||
+    err.code === 'ETIMEDOUT' ||
+    err.code === 'EPIPE'
+}
+
+function parseUrl (urlObjOrString) {
+  if (urlObjOrString !== null && typeof urlObjOrString === 'object') {
+    return urlToHttpOptions(urlObjOrString)
+  }
+
+  const url = urlToHttpOptions(new URL(urlObjOrString))
+
+  if (url.protocol === 'unix:' && url.hostname === '.') {
+    const udsPath = urlObjOrString.slice(5)
+    url.path = udsPath
+    url.pathname = udsPath
+  }
+
+  return url
+}
+
+/**
+ * Simplified HTTP request for test optimization (library config). Uses common HTTP agents.
+ * Retries: 429 (with X-ratelimit-reset, max 30s wait),
+ * >=500 and transient network errors (5–7.5s delay with jitter). Max one retry.
+ * Destroys connections on errors to prevent reuse of bad connections. Preserves
+ * original status code across retries for telemetry.
+ *
+ * @param {string} data - Request body (e.g. JSON string)
+ * @param {object} options - { url, path?, method?, headers?, timeout? } (may be mutated)
+ * @param {Function} callback - (err, res, statusCode) => void
+ */
+function request (data, options, callback) {
+  const headers = options.headers ? { ...options.headers } : {}
+  headers['Content-Length'] = Buffer.byteLength(data, 'utf8')
+
+  const opts = { ...options, method: 'POST', headers }
+
+  if (opts.url) {
+    const url = parseUrl(opts.url)
+    if (url.protocol === 'unix:') {
+      opts.socketPath = url.pathname
+    } else {
+      opts.path = opts.path ?? url.path
+      opts.protocol = url.protocol
+      opts.hostname = url.hostname
+      opts.port = url.port
+    }
+  }
+
+  const timeout = opts.timeout || 2000
+  const isSecure = opts.protocol === 'https:'
+  const client = isSecure ? https : http
+
+  if (!opts.socketPath) {
+    opts.agent = isSecure ? httpsAgent : httpAgent
+  }
+
+  let hasRetried = false
+  let firstStatusCode = null
+
+  const makeRequest = () => {
+    storage('legacy').run({ noop: true }, () => {
+      const req = client.request(opts, (res) => {
+        // Capture non-2xx status code as soon as we see it so telemetry preserves it if the retry
+        // fails with a network error (no HTTP response) before 'end' fires
+        if (res.statusCode >= 400 && firstStatusCode === null) {
+          firstStatusCode = res.statusCode
+        }
+
+        const chunks = []
+
+        res.setTimeout(timeout)
+
+        res.on('data', chunk => {
+          chunks.push(chunk)
+        })
+
+        res.once('end', () => {
+          const buffer = Buffer.concat(chunks)
+
+          if (res.statusCode >= 200 && res.statusCode <= 299) {
+            const isGzip = res.headers['content-encoding'] === 'gzip'
+            if (isGzip) {
+              zlib.gunzip(buffer, (err, result) => {
+                if (err) {
+                  log.error('Could not gunzip response: %s', err.message)
+                  callback(null, '', res.statusCode)
+                } else {
+                  callback(null, result.toString(), res.statusCode)
+                }
+              })
+            } else {
+              callback(null, buffer.toString(), res.statusCode)
+            }
+            return
+          }
+
+          if (res.statusCode === 429 && !hasRetried) {
+            const resetHeader = res.headers['x-ratelimit-reset']
+            const resetTs = (resetHeader === null || resetHeader === undefined)
+              ? Number.NaN
+              : Number.parseInt(resetHeader, 10)
+            const waitMs = Number.isFinite(resetTs) ? Math.max(0, resetTs * 1000 - Date.now()) : Number.NaN
+
+            if (Number.isFinite(waitMs) && waitMs <= RATE_LIMIT_MAX_WAIT_MS) {
+              hasRetried = true
+              setTimeout(makeRequest, waitMs)
+              return
+            }
+
+            if (!Number.isFinite(waitMs) || waitMs > RATE_LIMIT_MAX_WAIT_MS) {
+              log.debug('Rate limited (429): drop payload (wait %sms > %sms or invalid header)',
+                Number.isFinite(waitMs) ? waitMs : 'N/A', RATE_LIMIT_MAX_WAIT_MS)
+            }
+          } else if (res.statusCode >= 500 && !hasRetried) {
+            try {
+              if (req.socket) req.socket.destroy()
+            } catch {
+              // ignore
+            }
+            hasRetried = true
+            setTimeout(makeRequest, getRetryDelay())
+            return
+          }
+
+          const error = buildError(res, buffer, opts)
+          // Use original status code if this is a failed retry
+          callback(error, null, firstStatusCode === null ? res.statusCode : firstStatusCode)
+        })
+      })
+
+      req.once('error', err => {
+        try {
+          if (req.socket) req.socket.destroy()
+        } catch {
+          // ignore
+        }
+
+        // Retry on retriable network errors
+        if (!hasRetried && isRetriableNetworkError(err)) {
+          hasRetried = true
+          setTimeout(makeRequest, getRetryDelay())
+          return
+        }
+
+        // Pass original status code (if any) for accurate telemetry
+        callback(err, null, firstStatusCode)
+      })
+
+      req.setTimeout(timeout, () => {
+        try {
+          if (typeof req.abort === 'function') {
+            req.abort()
+          } else {
+            req.destroy()
+          }
+        } catch {
+          // ignore
+        }
+      })
+
+      req.write(data, 'utf8')
+      req.end()
+    })
+  }
+
+  makeRequest()
+}
+
+/**
+ * @param {object} res - IncomingMessage
+ * @param {Buffer} buffer - Response body
+ * @param {object} options - Request options
+ * @returns {Error}
+ */
+function buildError (res, buffer, options) {
+  let errorMessage = ''
+  try {
+    const fullUrl = new URL(
+      options.path,
+      options.url || options.hostname || `http://localhost:${options.port}`
+    ).href
+    errorMessage = `Error from ${fullUrl}: ${res.statusCode} ${http.STATUS_CODES[res.statusCode]}.`
+  } catch {
+    // ignore
+  }
+
+  const responseData = buffer.toString()
+  if (responseData) {
+    errorMessage += ` Response from the endpoint: "${responseData}"`
+  }
+
+  const error = new log.NoTransmitError(errorMessage)
+  error.status = res.statusCode
+  return error
+}
+
+module.exports = request

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const request = require('../../exporters/common/request')
+const request = require('../requests/request')
 const id = require('../../id')
 const { getValueFromEnvSources } = require('../../config/helper')
 const log = require('../../log')