dd-trace 5.92.0 → 5.94.0

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

@@ -17,6 +17,36 @@ const {
 
 const { getNumFromKnownTests } = require('../../plugins/util/test')
 
+const MAX_KNOWN_TESTS_PAGES = 10_000
+
+/**
+ * Deep-merges page tests into aggregate.
+ * Structure: { module: { suite: [testName, ...] } }
+ */
+function mergeKnownTests (aggregate, page) {
+  if (!page) return aggregate
+  if (!aggregate) return page
+
+  for (const [moduleName, suites] of Object.entries(page)) {
+    if (!suites) continue
+
+    if (!aggregate[moduleName]) {
+      aggregate[moduleName] = suites
+      continue
+    }
+
+    for (const [suiteName, tests] of Object.entries(suites)) {
+      if (!tests || tests.length === 0) continue
+
+      aggregate[moduleName][suiteName] = aggregate[moduleName][suiteName]
+        ? [...aggregate[moduleName][suiteName], ...tests]
+        : tests
+    }
+  }
+
+  return aggregate
+}
+
 function getKnownTests ({
   url,
   isEvpProxy,
@@ -59,53 +89,94 @@ function getKnownTests ({
     options.headers['dd-api-key'] = apiKey
   }
 
-  const data = JSON.stringify({
-    data: {
-      id: id().toString(10),
-      type: 'ci_app_libraries_tests_request',
-      attributes: {
-        configurations: {
-          'os.platform': osPlatform,
-          'os.version': osVersion,
-          'os.architecture': osArchitecture,
-          'runtime.name': runtimeName,
-          'runtime.version': runtimeVersion,
-          custom,
-        },
-        service,
-        env,
-        repository_url: repositoryUrl,
-        sha,
-      },
-    },
-  })
+  const configurations = {
+    'os.platform': osPlatform,
+    'os.version': osVersion,
+    'os.architecture': osArchitecture,
+    'runtime.name': runtimeName,
+    'runtime.version': runtimeVersion,
+    custom,
+  }
 
   incrementCountMetric(TELEMETRY_KNOWN_TESTS)
 
   const startTime = Date.now()
+  let aggregateTests = null
+  let totalResponseBytes = 0
+  let pageNumber = 0
+
+  function fetchPage (pageState) {
+    pageNumber++
+
+    if (pageNumber > MAX_KNOWN_TESTS_PAGES) {
+      log.error('Known tests pagination exceeded maximum of %d pages. Aborting.', MAX_KNOWN_TESTS_PAGES)
+      distributionMetric(TELEMETRY_KNOWN_TESTS_MS, {}, Date.now() - startTime)
+      return done(new Error(`Known tests pagination exceeded maximum of ${MAX_KNOWN_TESTS_PAGES} pages`))
+    }
+
+    const pageInfo = pageState ? { page_state: pageState } : {}
+
+    const data = JSON.stringify({
+      data: {
+        id: id().toString(10),
+        type: 'ci_app_libraries_tests_request',
+        attributes: {
+          configurations,
+          service,
+          env,
+          repository_url: repositoryUrl,
+          sha,
+          page_info: pageInfo,
+        },
+      },
+    })
+
+    request(data, options, (err, res, statusCode) => {
+      if (err) {
+        distributionMetric(TELEMETRY_KNOWN_TESTS_MS, {}, Date.now() - startTime)
+        incrementCountMetric(TELEMETRY_KNOWN_TESTS_ERRORS, { statusCode })
+        return done(err)
+      }
 
-  request(data, options, (err, res, statusCode) => {
-    distributionMetric(TELEMETRY_KNOWN_TESTS_MS, {}, Date.now() - startTime)
-    if (err) {
-      incrementCountMetric(TELEMETRY_KNOWN_TESTS_ERRORS, { statusCode })
-      done(err)
-    } else {
       try {
-        const { data: { attributes: { tests: knownTests } } } = JSON.parse(res)
+        totalResponseBytes += res.length
+
+        const { data: { attributes } } = JSON.parse(res)
+        const { tests: pageTests, page_info: responsePageInfo } = attributes
 
-        const numTests = getNumFromKnownTests(knownTests)
+        aggregateTests = mergeKnownTests(aggregateTests, pageTests)
+
+        // Check if there are more pages
+        if (responsePageInfo && responsePageInfo.has_next) {
+          if (!responsePageInfo.cursor) {
+            log.error(
+              'Known tests response has has_next=true but no cursor on page %d. Aborting pagination.', pageNumber
+            )
+            distributionMetric(TELEMETRY_KNOWN_TESTS_MS, {}, Date.now() - startTime)
+            return done(new Error('Known tests pagination: has_next=true but no cursor'))
+          }
+          return fetchPage(responsePageInfo.cursor)
+        }
+
+        // Done — no more pages
+        distributionMetric(TELEMETRY_KNOWN_TESTS_MS, {}, Date.now() - startTime)
+
+        const numTests = getNumFromKnownTests(aggregateTests)
 
         distributionMetric(TELEMETRY_KNOWN_TESTS_RESPONSE_TESTS, {}, numTests)
-        distributionMetric(TELEMETRY_KNOWN_TESTS_RESPONSE_BYTES, {}, res.length)
+        distributionMetric(TELEMETRY_KNOWN_TESTS_RESPONSE_BYTES, {}, totalResponseBytes)
 
         log.debug('Number of received known tests:', numTests)
 
-        done(null, knownTests)
+        done(null, aggregateTests)
       } catch (err) {
+        distributionMetric(TELEMETRY_KNOWN_TESTS_MS, {}, Date.now() - startTime)
         done(err)
       }
-    }
-  })
+    })
+  }
+
+  fetchPage(null)
 }
 
 module.exports = { getKnownTests }

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

@@ -2,10 +2,6 @@
 const { JSONEncoder } = require('../../encode/json-encoder')
 const { getEnvironmentVariable } = require('../../../config/helper')
 const log = require('../../../log')
-const {
-  VITEST_WORKER_TRACE_PAYLOAD_CODE,
-  VITEST_WORKER_LOGS_PAYLOAD_CODE,
-} = require('../../../plugins/util/test')
 
 class Writer {
   constructor (interprocessCode) {
@@ -29,12 +25,6 @@ class Writer {
   }
 
   _sendPayload (data, onDone = () => {}) {
-    // ## Jest
-    // Only available when `child_process` is used for the jest worker.
-    // If worker_threads is used, this will not work
-    // TODO: make `jest` instrumentation compatible with worker_threads
-    // https://github.com/facebook/jest/blob/bb39cb2c617a3334bf18daeca66bd87b7ccab28b/packages/jest-worker/README.md#experimental-worker
-
     // ## Cucumber
     // This reports to the test's main process the same way test data is reported by Cucumber
     // See cucumber code:
@@ -47,19 +37,17 @@ class Writer {
       ? { __tinypool_worker_message__: true, interprocessCode: this._interprocessCode, data }
       : [this._interprocessCode, data]
 
-    const isVitestTestWorker =
-      this._interprocessCode === VITEST_WORKER_TRACE_PAYLOAD_CODE ||
-      this._interprocessCode === VITEST_WORKER_LOGS_PAYLOAD_CODE
-
+    // child_process workers (jest default, cucumber)
     if (process.send) {
       process.send(payload, () => {
         onDone()
       })
-    } else if (isVitestTestWorker) { // TODO: worker_threads are only supported in vitest right now
-      const { isMainThread, parentPort } = require('worker_threads')
-      if (isMainThread) {
-        return onDone()
-      }
+      return
+    }
+
+    // worker_threads (jest --workerThreads, vitest)
+    const { isMainThread, parentPort } = require('node:worker_threads')
+    if (!isMainThread && parentPort) {
       try {
         parentPort.postMessage(payload)
       } catch (error) {
@@ -67,9 +55,10 @@ class Writer {
       } finally {
         onDone()
       }
-    } else {
-      onDone()
+      return
     }
+
+    onDone()
   }
 }
 

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

@@ -744,9 +744,9 @@
     ],
     "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED": [
       {
-        "implementation": "A",
+        "implementation": "B",
         "type": "boolean",
-        "default": "false",
+        "default": "true",
         "configurationNames": [
           "propagateProcessTags.enabled"
         ]

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

@@ -1,9 +1,15 @@
 'use strict'
 
+const { existsSync } = require('node:fs')
 const { isMainThread } = require('worker_threads')
 const log = require('../log')
 
-if (isMainThread) {
+// libdatadog v29 crashtracker segfaults during init on ARM64 musl (Alpine).
+// The segfault bypasses JS try/catch so we must avoid loading it entirely.
+// See: https://github.com/DataDog/libdatadog-nodejs/issues/114
+const isArm64Musl = process.arch === 'arm64' && existsSync('/etc/alpine-release')
+
+if (isMainThread && !isArm64Musl) {
   try {
     module.exports = require('./crashtracker')
   } catch (e) {

package/packages/dd-trace/src/exporters/common/docker.js

@@ -35,6 +35,7 @@ if (inodePath) {
 const entityId = containerId ? `ci-${containerId}` : inode && `in-${inode}`
 
 module.exports = {
+  containerId,
   entityId,
 
   inject (carrier) {

package/packages/dd-trace/src/exporters/common/request.js

@@ -14,9 +14,9 @@ const { urlToHttpOptions } = require('./url-to-http-options-polyfill')
 const docker = require('./docker')
 const { httpAgent, httpsAgent } = require('./agents')
 
-const maxActiveRequests = 8
+const maxActiveBufferSize = 1024 * 1024 * 64
 
-let activeRequests = 0
+let activeBufferSize = 0
 
 function parseUrl (urlObjOrString) {
   if (urlObjOrString !== null && typeof urlObjOrString === 'object') return urlToHttpOptions(urlObjOrString)
@@ -50,7 +50,22 @@ function request (data, options, callback) {
     }
   }
 
-  const isReadable = data instanceof Readable
+  if (data instanceof Readable) {
+    const chunks = []
+
+    data
+      .on('data', (data) => {
+        chunks.push(data)
+      })
+      .on('end', () => {
+        request(Buffer.concat(chunks), options, callback)
+      })
+      .on('error', (err) => {
+        callback(err)
+      })
+
+    return
+  }
 
   // The timeout should be kept low to avoid excessive queueing.
   const timeout = options.timeout || 2000
@@ -58,12 +73,10 @@ function request (data, options, callback) {
   const client = isSecure ? https : http
   let dataArray = data
 
-  if (!isReadable) {
-    if (!Array.isArray(data)) {
-      dataArray = [data]
-    }
-    options.headers['Content-Length'] = byteLength(dataArray)
+  if (!Array.isArray(data)) {
+    dataArray = [data]
   }
+  options.headers['Content-Length'] = byteLength(dataArray)
 
   docker.inject(options.headers)
 
@@ -126,14 +139,14 @@ function request (data, options, callback) {
       return callback(null)
     }
 
-    activeRequests++
+    activeBufferSize += options.headers['Content-Length'] ?? 0
 
     storage('legacy').run({ noop: true }, () => {
       let finished = false
       const finalize = () => {
         if (finished) return
         finished = true
-        activeRequests--
+        activeBufferSize -= options.headers['Content-Length'] ?? 0
       }
 
       const req = client.request(options, (res) => onResponse(res, finalize))
@@ -158,12 +171,8 @@ function request (data, options, callback) {
         }
       })
 
-      if (isReadable) {
-        data.pipe(req) // TODO: Validate whether this is actually retriable.
-      } else {
-        for (const buffer of dataArray) req.write(buffer)
-        req.end()
-      }
+      for (const buffer of dataArray) req.write(buffer)
+      req.end()
     })
   }
 
@@ -183,7 +192,7 @@ function byteLength (data) {
 
 Object.defineProperty(request, 'writable', {
   get () {
-    return activeRequests < maxActiveRequests
+    return activeBufferSize < maxActiveBufferSize
   },
 })
 

package/packages/dd-trace/src/opentracing/span.js

@@ -35,6 +35,7 @@ const integrationCounters = {
 
 const startCh = channel('dd-trace:span:start')
 const finishCh = channel('dd-trace:span:finish')
+const tagsUpdateCh = channel('dd-trace:span:tags:update')
 
 function getIntegrationCounter (event, integration) {
   const counters = integrationCounters[event]
@@ -399,6 +400,10 @@ class DatadogSpan {
     tagger.add(this._spanContext._tags, keyValuePairs)
 
     this._prioritySampler.sample(this, false)
+
+    if (tagsUpdateCh.hasSubscribers) {
+      tagsUpdateCh.publish(this)
+    }
   }
 }
 

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

@@ -18,13 +18,6 @@ const TEST_OPTIMIZATION_PLUGINS = new Set([
 
 const loadChannel = channel('dd-trace:instrumentation:load')
 
-// instrument everything that needs Plugin System V2 instrumentation
-require('../../datadog-instrumentations')
-if (getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined) {
-  // instrument lambda environment
-  require('./lambda')
-}
-
 const DD_TRACE_DISABLED_PLUGINS = getValueFromEnvSources('DD_TRACE_DISABLED_PLUGINS')
 
 const disabledPlugins = new Set(
@@ -35,10 +28,20 @@ const disabledPlugins = new Set(
 
 const pluginClasses = {}
 
+// Subscribe before requiring instrumentations so that loadChannel events fired
+// during instrumentation initialization (e.g. re-requires in bundler contexts)
+// are captured and populate pluginClasses correctly.
 loadChannel.subscribe(({ name }) => {
   maybeEnable(plugins[name])
 })
 
+// instrument everything that needs Plugin System V2 instrumentation
+require('../../datadog-instrumentations')
+if (getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined) {
+  // instrument lambda environment
+  require('./lambda')
+}
+
 function maybeEnable (Plugin) {
   if (!Plugin || typeof Plugin !== 'function') return
   if (!pluginClasses[Plugin.id]) {

package/packages/dd-trace/src/plugins/util/test.js

@@ -88,8 +88,24 @@ const TEST_EARLY_FLAKE_ABORT_REASON = 'test.early_flake.abort_reason'
 const TEST_RETRY_REASON = 'test.retry_reason'
 const TEST_HAS_FAILED_ALL_RETRIES = 'test.has_failed_all_retries'
 const TEST_IS_MODIFIED = 'test.is_modified'
+const TEST_HAS_DYNAMIC_NAME = '_dd.has_dynamic_name'
 const CI_APP_ORIGIN = 'ciapp-test'
 
+// Matches patterns that are almost certainly runtime-generated values in test names:
+// - Unix timestamps in ms (13 digits, years ~2020-2090) or s (10 digits)
+// - UUIDs (8-4-4-4-12 hex)
+// - ISO 8601 dates (2024-03-23) or date-times (2024-03-23T14:30)
+// - Random ports on localhost, 127.0.0.1, or 0.0.0.0
+// - Math.random() float values (10+ decimal digits after 0.)
+const DYNAMIC_NAME_RE = new RegExp(
+  String.raw`\b1[6-9]\d{8,11}\b|` +
+  String.raw`[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|` +
+  String.raw`\b\d{4}-\d{2}-\d{2}|` +
+  String.raw`(?:localhost|127\.0\.0\.1|0\.0\.0\.0):\d{4,5}\b|` +
+  String.raw`\b0\.\d{10,}`,
+  'i'
+)
+
 const JEST_TEST_RUNNER = 'test.jest.test_runner'
 const JEST_DISPLAY_NAME = 'test.jest.display_name'
 
@@ -260,6 +276,7 @@ module.exports = {
   TEST_RETRY_REASON,
   TEST_HAS_FAILED_ALL_RETRIES,
   TEST_IS_MODIFIED,
+  TEST_HAS_DYNAMIC_NAME,
   getTestEnvironmentMetadata,
   getTestParametersString,
   finishAllTraceSpans,
@@ -337,6 +354,9 @@ module.exports = {
   POSSIBLE_BASE_BRANCHES,
   GIT_COMMIT_SHA,
   GIT_REPOSITORY_URL,
+  DYNAMIC_NAME_RE,
+  collectDynamicNamesFromTraces,
+  logDynamicNamesWarning,
 }
 
 // Returns pkg manager and its version, separated by '-', e.g. npm-8.15.0 or yarn-1.22.19
@@ -1178,6 +1198,62 @@ function getModifiedFilesFromDiff (diff) {
   return result
 }
 
+/**
+ * Scans serialized worker trace payloads for tests tagged with TEST_HAS_DYNAMIC_NAME
+ * and populates the provided Set. Silently ignores parse errors.
+ *
+ * @param {string} data - JSON-serialized traces from a worker
+ * @param {Set<string>} newTestsWithDynamicNames - Set to populate with "suite › name" strings
+ */
+function collectDynamicNamesFromTraces (data, newTestsWithDynamicNames) {
+  try {
+    const traces = JSON.parse(data)
+    for (const trace of traces) {
+      for (const span of trace) {
+        if (span.meta?.[TEST_HAS_DYNAMIC_NAME] === 'true') {
+          const suite = span.meta[TEST_SUITE]
+          const name = span.meta[TEST_NAME]
+          if (suite && name) {
+            newTestsWithDynamicNames.add(`${suite} › ${name}`)
+          }
+        }
+      }
+    }
+  } catch {
+    // ignore parse errors
+  }
+}
+
+/**
+ * Logs a "Datadog Test Optimization" warning about new tests with dynamic names.
+ * Clears the Set after logging. No-op if the Set is empty.
+ *
+ * @param {Set<string>} newTestsWithDynamicNames
+ */
+function logDynamicNamesWarning (newTestsWithDynamicNames) {
+  if (newTestsWithDynamicNames.size === 0) return
+
+  const MAX_SHOWN = 10
+  const names = [...newTestsWithDynamicNames]
+  const shown = names.slice(0, MAX_SHOWN)
+  const more = names.length - shown.length
+  const moreSuffix = more > 0 ? `\n  ... and ${more} more` : ''
+  const nameList = shown.map(n => `  • ${n}`).join('\n') + moreSuffix
+
+  const line = '-'.repeat(50)
+  // eslint-disable-next-line no-console -- Intentional user-facing session summary
+  console.warn(
+    `\n${line}\nDatadog Test Optimization\n${line}\n` +
+    `${newTestsWithDynamicNames.size} test(s) detected as new but their names contain ` +
+    'dynamic data (timestamps, UUIDs, etc.).\n' +
+    'Tests with changing names are always treated as new on every run, ' +
+    'causing unnecessary Early Flake Detection retries and preventing correct new test detection.\n' +
+    'Consider using stable, deterministic test names.\n\n' +
+    `${nameList}\n`
+  )
+  newTestsWithDynamicNames.clear()
+}
+
 function isModifiedTest (testPath, testStartLine, testEndLine, modifiedFiles, testFramework) {
   if (modifiedFiles === undefined) {
     return false

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

@@ -37,13 +37,16 @@ const {
 const DEFAULT_KEY = 'service:,env:'
 
 /**
- * Formats a sampling rate as a string with up to 6 significant digits and no trailing zeros.
+ * Formats a sampling rate as a string with up to 6 decimal digits and no trailing zeros.
  *
  * @param {number} rate
- * @returns {string}
  */
 function formatKnuthRate (rate) {
-  return Number(rate.toPrecision(6)).toString()
+  const string = Number(rate).toFixed(6)
+  for (let i = string.length - 1; i > 0; i--) {
+    if (string[i] === '0') continue
+    return string.slice(0, i + (string[i] === '.' ? 0 : 1))
+  }
 }
 
 const defaultSampler = new Sampler(AUTO_KEEP)