dd-trace 5.120.0 → 5.121.0

package/ci/vitest-no-worker-init-setup.mjs

@@ -3,16 +3,19 @@ import { afterEach, beforeAll, beforeEach, inject } from 'vitest'
 // Instrumentation-less setup for DD_EXPERIMENTAL_TEST_OPT_VITEST_NO_WORKER_INIT.
 // It applies Test Optimization execution changes without initializing dd-trace and also supports Browser Mode.
 const VITEST_NO_WORKER_INIT_ACTIVE_ENV = 'DD_TEST_OPT_VITEST_NO_WORKER_INIT_ACTIVE'
+const SERIALIZED_CONTEXT_PREFIX = '\u0000dd-vitest-context:'
 const providedContext = getProvidedContext()
 const isNoWorkerInitActive = providedContext.isActive ?? getIsNoWorkerInitActive()
 const attemptToFixTests = providedContext.attemptToFixTests || {}
 const attemptToFixRetries = providedContext.attemptToFixRetries || 0
 const disabledTests = providedContext.disabledTests || {}
+const efdSuiteAdmissionBrowserCommand = providedContext.efdSuiteAdmissionBrowserCommand
 const earlyFlakeDetectionRetryPolicy = providedContext.earlyFlakeDetectionRetryPolicy || {
   durationRetryCounts: [],
   schedulingRetryCount: 0,
 }
 const earlyFlakeDetectionRetries = earlyFlakeDetectionRetryPolicy.schedulingRetryCount
+const isEfdSuiteAdmissionEnabled = providedContext.isEfdSuiteAdmissionEnabled === true
 const isEarlyFlakeDetectionEnabled = providedContext.isEarlyFlakeDetectionEnabled === true
 const knownTests = providedContext.knownTests || {}
 const modifiedFiles = providedContext.modifiedFiles || {}
@@ -34,6 +37,7 @@ const earlyFlakeDetectionStartByTask = new WeakMap()
 const nextAttemptIndexByTask = new WeakMap()
 const retryAttemptIndexByTask = new WeakMap()
 const usedRumTestExecutionIds = new Set()
+let browserCommands
 let now
 let timeOrigin
 // Use an unfaked monotonic clock in Node and Vitest's parent frame in Browser Mode.
@@ -48,18 +52,42 @@ if (typeof globalThis.process?.uptime === 'function') {
   timeOrigin = Number.isFinite(clock?.timeOrigin) ? clock.timeOrigin : Date.now() - now()
 }
 
+/**
+ * Requests permission from the Vitest main process to schedule Browser Mode EFD retries for one suite.
+ *
+ * @param {string} testSuite
+ * @param {boolean} hasNewTest
+ * @returns {Promise<boolean>}
+ */
+async function requestBrowserEfdSuiteAdmission (testSuite, hasNewTest) {
+  try {
+    if (!browserCommands) {
+      const vitestBrowser = await import('@vitest/browser/context')
+      browserCommands = vitestBrowser.commands
+    }
+    return await browserCommands[efdSuiteAdmissionBrowserCommand](testSuite, hasNewTest) === true
+  } catch (error) {
+    // Browser Mode setup runs without dd-trace, so the tracer logger is unavailable.
+    globalThis.console?.error('Datadog Test Optimization could not request Vitest EFD suite admission.', error)
+    return false
+  }
+}
+
 if (isNoWorkerInitActive) {
   // eslint-disable-next-line no-empty-pattern
-  beforeAll(function ({}, suite) {
+  beforeAll(async function ({}, suite) {
     suite ||= arguments[0]
-    applyExecutionChanges(suite)
+    const efdSuiteCandidate = getEarlyFlakeDetectionSuiteCandidate(suite)
+    const isEfdSuiteAdmissionAllowed = !efdSuiteCandidate || !isEfdSuiteAdmissionEnabled ||
+      await requestBrowserEfdSuiteAdmission(efdSuiteCandidate.testSuite, efdSuiteCandidate.hasNewTest)
+    applyExecutionChanges(suite, isEfdSuiteAdmissionAllowed)
   })
 
   beforeEach(function ({ onTestFinished, task, skip }) {
     const testSuite = getTestSuite(task)
     const testName = getTestName(task)
     const isAttemptToFixTest = attemptToFixTests[testSuite]?.[testName]
-    const isEarlyFlakeDetectionTestAttempt = isEarlyFlakeDetectionTest(testSuite, testName)
+    const isEarlyFlakeDetectionTestAttempt = isEarlyFlakeDetectionTask(task)
     const isQuarantinedTest = quarantinedTests[testSuite]?.[testName] && !isAttemptToFixTest
     const attemptIndex = getNextAttemptIndex(task)
     const attemptStart = now()
@@ -108,12 +136,12 @@ if (isNoWorkerInitActive) {
   })
 }
 
-function applyExecutionChanges (suite) {
+function applyExecutionChanges (suite, isEfdSuiteAdmissionAllowed) {
   const tasks = suite?.tasks
   if (tasks) {
     for (const task of tasks) {
       if (task.type === 'suite') {
-        applyExecutionChanges(task)
+        applyExecutionChanges(task, isEfdSuiteAdmissionAllowed)
         continue
       }
 
@@ -125,7 +153,7 @@ function applyExecutionChanges (suite) {
         task.meta.__ddTestOptAtfRetries = attemptToFixRetries
       } else if (disabledTests[testSuite]?.[testName]) {
         task.mode = 'skip'
-      } else if (isEarlyFlakeDetectionTest(testSuite, testName)) {
+      } else if (isEfdSuiteAdmissionAllowed && isEarlyFlakeDetectionTest(testSuite, testName)) {
         task.retry = 0
         task.repeats = earlyFlakeDetectionRetries
         task.meta.__ddTestOptEfdRetries = earlyFlakeDetectionRetries
@@ -333,7 +361,7 @@ function recordTestOptimizationStatus (task, attemptIndex = task.result?.repeatC
 
   if (attemptToFixTests[testSuite]?.[testName]) {
     recordAttemptToFixStatus(task, attemptIndex, onlyIfNewErrors)
-  } else if (isEarlyFlakeDetectionTest(testSuite, testName)) {
+  } else if (isEarlyFlakeDetectionTask(task)) {
     recordEarlyFlakeDetectionStatus(task, attemptIndex, onlyIfNewErrors)
   } else if (task.repeats > 0) {
     recordManualRepeatStatus(task, attemptIndex)
@@ -510,7 +538,7 @@ function getFinalAttemptIndex (task) {
   if (attemptToFixTests[testSuite]?.[testName]) {
     return getAttemptToFixRetryCount(task)
   }
-  if (isEarlyFlakeDetectionTest(testSuite, testName)) {
+  if (isEarlyFlakeDetectionTask(task)) {
     return getEarlyFlakeDetectionRetryCountForTask(task)
   }
 
@@ -671,6 +699,64 @@ function isEarlyFlakeDetectionTest (testSuite, testName) {
   return !testsForSuite.includes(testName)
 }
 
+/**
+ * Returns whether Datadog admitted this task for EFD retries.
+ *
+ * @param {object} task
+ * @returns {boolean}
+ */
+function isEarlyFlakeDetectionTask (task) {
+  return task.meta.__ddTestOptEfdRetries !== undefined
+}
+
+/**
+ * Returns suite admission data when a collected suite contains an EFD candidate.
+ *
+ * @param {object} suite
+ * @returns {{ hasNewTest: boolean, testSuite: string }|undefined}
+ */
+function getEarlyFlakeDetectionSuiteCandidate (suite) {
+  const tasks = suite?.tasks
+  if (!tasks) return
+
+  let candidate
+  for (const task of tasks) {
+    if (task.type === 'suite') {
+      const nestedCandidate = getEarlyFlakeDetectionSuiteCandidate(task)
+      if (nestedCandidate) {
+        candidate ||= nestedCandidate
+        candidate.hasNewTest ||= nestedCandidate.hasNewTest
+      }
+      continue
+    }
+
+    if (task.mode === 'skip' || task.mode === 'todo') continue
+
+    const testSuite = getTestSuite(task)
+    const testName = getTestName(task)
+    if (attemptToFixTests[testSuite]?.[testName] || disabledTests[testSuite]?.[testName]) continue
+    if (!isEarlyFlakeDetectionTest(testSuite, testName)) continue
+
+    candidate ||= {
+      hasNewTest: false,
+      testSuite,
+    }
+    candidate.hasNewTest ||= isNewTest(testSuite, testName)
+  }
+  return candidate
+}
+
+/**
+ * Returns whether a collected test is absent from the known-tests response.
+ *
+ * @param {string} testSuite
+ * @param {string} testName
+ * @returns {boolean}
+ */
+function isNewTest (testSuite, testName) {
+  return !(knownTests[testSuite] || []).includes(testName)
+}
+
 function isModifiedTest (testSuite) {
   return modifiedFiles[testSuite]?.length > 0
 }
@@ -712,12 +798,28 @@ function getIsNoWorkerInitActive () {
 
 function getProvidedContext () {
   try {
-    return inject('_ddVitestWorkerSetup') || {}
+    return parseProvidedContextValue(inject('_ddVitestWorkerSetup'))
   } catch {
     try {
-      return globalThis.__vitest_worker__.providedContext._ddVitestWorkerSetup || {}
+      return parseProvidedContextValue(globalThis.__vitest_worker__.providedContext._ddVitestWorkerSetup)
     } catch {
       return {}
     }
   }
 }
+
+/**
+ * Restore context serialized to keep Vitest's inline browser bootstrap script valid.
+ *
+ * @param {object|string|undefined} value
+ * @returns {object}
+ */
+function parseProvidedContextValue (value) {
+  if (typeof value !== 'string' || !value.startsWith(SERIALIZED_CONTEXT_PREFIX)) return value || {}
+
+  try {
+    return JSON.parse(value.slice(SERIALIZED_CONTEXT_PREFIX.length))
+  } catch {
+    return {}
+  }
+}

package/index.d.ts

@@ -4296,6 +4296,11 @@ declare namespace tracer {
        * Audio segments attached to the message (e.g. speech input/output)
        */
       audioParts?: AudioPart[],
+
+      /**
+       * Images attached to the message (e.g. vision input, generated output)
+       */
+      imageParts?: ImagePart[],
     }
 
     /**
@@ -4313,6 +4318,43 @@ declare namespace tracer {
       content: string,
     }
 
+    /**
+     * Represents an image attached to an LLM chat model message, carrying exactly
+     * one of inline `content` or an `attachmentKey`. Supplying neither or both is
+     * rejected by the tagger, and the union keeps both shapes from type-checking.
+     */
+    type ImagePart = {
+      /**
+       * The MIME type of the image (e.g. "image/png", "image/jpeg")
+       */
+      mimeType: string,
+
+      /**
+       * The image content as a base64-encoded string
+       */
+      content: string,
+
+      /**
+       * Explicitly excluded when inline content is present to maintain type safety.
+       */
+      attachmentKey?: never,
+    } | {
+      /**
+       * The MIME type of the image (e.g. "image/png", "image/jpeg")
+       */
+      mimeType: string,
+
+      /**
+       * Key of an already-uploaded image, in place of inline content
+       */
+      attachmentKey: string,
+
+      /**
+       * Explicitly excluded when an attachment key is present to maintain type safety.
+       */
+      content?: never,
+    }
+
     /**
      * Represents a single tool call for an LLM chat model message
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.120.0",
+  "version": "5.121.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -22,8 +22,9 @@
     "type:check": "tsc --noEmit -p tsconfig.dev.json",
     "type:doc:build": "cd docs && yarn && yarn build",
     "type:doc:test": "cd docs && yarn && yarn test",
-    "lint": "node scripts/check_licenses.js && node scripts/check-no-coverage-artifacts.js && node scripts/check-no-mcr-images.js && node scripts/check-docker-image-shas.js && eslint . --concurrency=auto --max-warnings 0 && npm run lint:codeowners:ci && npm run verify-exercised-tests",
+    "lint": "node scripts/check_licenses.js && node scripts/check-no-coverage-artifacts.js && node scripts/check-no-mcr-images.js && node scripts/check-docker-image-shas.js && eslint . --concurrency=auto --max-warnings 0 && npm run verify:carrier-fields && npm run lint:codeowners:ci && npm run verify-exercised-tests",
     "lint:fix": "node scripts/check_licenses.js && node scripts/check-no-coverage-artifacts.js && node scripts/check-no-mcr-images.js && node scripts/check-docker-image-shas.js && eslint . --concurrency=auto --max-warnings 0 --fix",
+    "verify:carrier-fields": "node scripts/verify-carrier-fields.mjs",
     "lint:inspect": "npx @eslint/config-inspector@latest",
     "lint:codeowners": "codeowners-audit",
     "lint:codeowners:ci": "codeowners-audit --glob='**/*.spec.js' --glob='benchmark/sirun/**' --glob='.agents/**' --glob='.claude/**' --glob='integration-tests/**' --glob='packages/dd-trace/src/guardrails/**'",
@@ -39,7 +40,7 @@
     "test:appsec:plugins:ci": "yarn services && node scripts/c8-ci.js test:appsec:plugins",
     "test:debugger": "mocha \"packages/dd-trace/test/debugger/**/*.spec.js\"",
     "test:debugger:ci": "node scripts/c8-ci.js test:debugger",
-    "test:eslint-rules": "node eslint-rules/*.test.mjs",
+    "test:eslint-rules": "node scripts/run-eslint-rule-tests.mjs eslint-rules/*.test.mjs",
     "test:trace:core": "node scripts/mocha-parallel-files.js --expose-gc --timeout 30000 -- \"packages/dd-trace/test/*.spec.js\" \"packages/dd-trace/test/{agent,ci-visibility,config,crashtracking,datastreams,encode,exporters,msgpack,opentelemetry,opentracing,payload-tagging,plugins,remote_config,service-naming,standalone,telemetry,external-logger}/**/*.spec.js\"",
     "test:trace:core:ci": "node scripts/c8-ci.js test:trace:core",
     "test:trace:guardrails": "mocha \"packages/dd-trace/test/guardrails/**/*.spec.js\"",

package/packages/datadog-instrumentations/src/confluentinc-kafka-javascript.js

@@ -29,6 +29,17 @@ const channels = {
 
 const disabledHeaderWeakSet = new WeakSet()
 
+const EMPTY_CARRIER = Object.create(null)
+/** @type {string[]} */
+const NO_MERGEABLE_KEYS = []
+
+/** @typedef {string | Buffer} NativeHeaderValue */
+/** @typedef {Array<Record<string, NativeHeaderValue>>} NativeHeaders */
+/** @typedef {Record<string, NativeHeaderValue | NativeHeaderValue[]>} NativeHeaderCarrier */
+
+/** @type {NativeHeaders} */
+const EMPTY_NATIVE_HEADERS = []
+
 // we need to store the offset per partition per topic for the consumer to track offsets for DSM
 const latestConsumerOffsets = new Map()
 
@@ -60,17 +71,47 @@ function instrumentBaseModule (module) {
               }
 
               const brokers = this.globalConfig?.['bootstrap.servers']
+              const nativeHeaders = Array.isArray(headers) ? headers : EMPTY_NATIVE_HEADERS
+
+              let carrier
+              let forwardCallerHeaders = false
+              let applicationValues = EMPTY_CARRIER
+              let headerKeys = NO_MERGEABLE_KEYS
+              if (nativeHeaders.length !== 0) {
+                // `__proto__` is a legal Kafka header key and propagation never
+                // writes it, so only the seeded carrier needs a null prototype.
+                const candidateCarrier = Object.create(null)
+                const candidateValues = Object.create(null)
+                const candidateKeys = seedNativeHeaderCarrier(nativeHeaders, candidateCarrier, candidateValues)
+                if (candidateKeys === undefined) {
+                  forwardCallerHeaders = true
+                } else if (candidateKeys.length !== 0) {
+                  carrier = candidateCarrier
+                  applicationValues = candidateValues
+                  headerKeys = candidateKeys
+                }
+              }
 
               const ctx = {
                 topic,
-                messages: [{ key, value: message }],
+                messages: [{
+                  key,
+                  value: message,
+                  headers: carrier,
+                }],
                 bootstrapServers: brokers,
               }
 
               return channels.producerStart.runStores(ctx, () => {
                 try {
-                  const headers = convertHeaders(ctx.messages[0].headers)
-                  const result = produce.apply(this, [topic, partition, message, key, timestamp, opaque, headers])
+                  const producedHeaders = forwardCallerHeaders
+                    ? nativeHeaders
+                    : mergeNativeHeaders(
+                      nativeHeaders, headerKeys, applicationValues, ctx.messages[0].headers ?? EMPTY_CARRIER
+                    )
+                  const result = produce.apply(this, [
+                    topic, partition, message, key, timestamp, opaque, producedHeaders,
+                  ])
 
                   ctx.result = result
                   channels.producerCommit.publish(ctx)
@@ -432,7 +473,71 @@ function getLatestOffsets () {
   return [...latestConsumerOffsets.values()]
 }
 
-function convertHeaders (headers) {
-  // convert headers from object to array of objects with 1 key and value per array entry
-  return Object.entries(headers).map(([key, value]) => ({ [key.toString()]: value.toString() }))
+/**
+ * `Producer::NodeProduce` reads the first *enumerable* own key of each entry and
+ * validates the value itself. A `null` or `undefined` entry aborts the process
+ * there, so those are the only entries we refuse to hand back to it.
+ *
+ * @param {NativeHeaders} headers Caller-owned.
+ * @param {NativeHeaderCarrier} carrier
+ * @param {NativeHeaderCarrier} applicationValues
+ * @returns {string[] | undefined} `undefined` when the binding has to reject the
+ *   array itself; empty when it cannot consume the array at all.
+ * @see https://github.com/confluentinc/confluent-kafka-javascript/blob/v1.9.1/src/producer.cc
+ */
+function seedNativeHeaderCarrier (headers, carrier, applicationValues) {
+  const keys = new Array(headers.length)
+  for (let i = 0; i < headers.length; i++) {
+    const header = headers[i]
+    if (header === null || header === undefined) return NO_MERGEABLE_KEYS
+
+    const key = Object.keys(header)[0]
+    if (key === undefined) return
+
+    keys[i] = key
+    const value = header[key]
+    if (typeof value !== 'string' && !Buffer.isBuffer(value)) return
+
+    if (i === 0) {
+      carrier[key] = value
+      applicationValues[key] = value
+      continue
+    }
+
+    const previousValue = carrier[key]
+    if (previousValue === undefined) {
+      carrier[key] = value
+    } else if (Array.isArray(previousValue)) {
+      previousValue.push(value)
+    } else {
+      carrier[key] = [previousValue, value]
+    }
+    applicationValues[key] = carrier[key]
+  }
+  return keys
+}
+
+/**
+ * @param {NativeHeaders} headers Caller-owned; surviving entries are forwarded
+ *   by reference, never copied or mutated.
+ * @param {string[]} headerKeys Parallel to `headers`.
+ * @param {NativeHeaderCarrier} applicationValues Carrier contents before
+ *   propagation ran.
+ * @param {NativeHeaderCarrier} carrier
+ */
+function mergeNativeHeaders (headers, headerKeys, applicationValues, carrier) {
+  const merged = []
+  for (let i = 0; i < headerKeys.length; i++) {
+    const key = headerKeys[i]
+    if (carrier[key] === applicationValues[key]) {
+      merged.push(headers[i])
+    }
+  }
+
+  for (const key of Object.keys(carrier)) {
+    if (carrier[key] !== applicationValues[key]) {
+      merged.push({ [key]: carrier[key] })
+    }
+  }
+  return merged
 }