dd-trace 5.75.0 → 5.76.0

package/ci/init.js

@@ -29,6 +29,7 @@ function detectTestWorkerType () {
   if (getEnvironmentVariable('MOCHA_WORKER_ID')) return 'mocha'
   if (getEnvironmentVariable('DD_PLAYWRIGHT_WORKER')) return 'playwright'
   if (getEnvironmentVariable('TINYPOOL_WORKER_ID')) return 'vitest'
+  if (getEnvironmentVariable('DD_VITEST_WORKER')) return 'vitest'
   return null
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.75.0",
+  "version": "5.76.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -125,8 +125,8 @@
     "@datadog/native-appsec": "10.3.0",
     "@datadog/native-iast-taint-tracking": "4.0.0",
     "@datadog/native-metrics": "3.1.1",
-    "@datadog/openfeature-node-server": "0.1.0-preview.12",
-    "@datadog/pprof": "5.11.1",
+    "@datadog/openfeature-node-server": "0.1.0-preview.13",
+    "@datadog/pprof": "5.12.0",
     "@datadog/sketches-js": "2.1.1",
     "@datadog/wasm-js-rewriter": "4.0.1",
     "@isaacs/ttlcache": "^1.4.1",

package/packages/datadog-instrumentations/src/openai.js

@@ -22,6 +22,14 @@ const V4_PACKAGE_SHIMS = [
     methods: ['create'],
     streamedResponse: true
   },
+  {
+    file: 'resources/responses/responses',
+    targetClass: 'Responses',
+    baseResource: 'responses',
+    methods: ['create'],
+    streamedResponse: true,
+    versions: ['>=4.87.0']
+  },
   {
     file: 'resources/embeddings',
     targetClass: 'Embeddings',

package/packages/datadog-instrumentations/src/playwright.js

@@ -68,6 +68,8 @@ let modifiedFiles = {}
 const quarantinedOrDisabledTestsAttemptToFix = []
 let quarantinedButNotAttemptToFixFqns = new Set()
 let rootDir = ''
+let sessionProjects = []
+
 const MINIMUM_SUPPORTED_VERSION_RANGE_EFD = '>=1.38.0' // TODO: remove this once we drop support for v5
 
 function isValidKnownTests (receivedKnownTests) {
@@ -495,6 +497,7 @@ function dispatcherHook (dispatcherExport) {
     const dispatcher = this
     const worker = createWorker.apply(this, arguments)
     const projects = getProjectsFromDispatcher(dispatcher)
+    sessionProjects = projects
 
     // for older versions of playwright, `shouldCreateTestSpan` should always be true,
     // since the `_runTest` function wrapper is not available for older versions
@@ -535,6 +538,7 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
     const dispatcher = this
     const worker = createWorker.apply(this, arguments)
     const projects = getProjectsFromDispatcher(dispatcher)
+    sessionProjects = projects
 
     worker.on('testBegin', ({ testId }) => {
       const test = getTestByTestId(dispatcher, testId)
@@ -1255,3 +1259,46 @@ addHook({
 
   return workerPackage
 })
+
+function generateSummaryWrapper (generateSummary) {
+  return function () {
+    for (const test of this.suite.allTests()) {
+      // https://github.com/microsoft/playwright/blob/bf92ffecff6f30a292b53430dbaee0207e0c61ad/packages/playwright/src/reporters/base.ts#L279
+      const didNotRun = test.outcome() === 'skipped' &&
+        (!test.results.length || test.expectedStatus !== 'skipped')
+      if (didNotRun) {
+        const {
+          _requireFile: testSuiteAbsolutePath,
+          location: { line: testSourceLine },
+        } = test
+        const browserName = getBrowserNameFromProjects(sessionProjects, test)
+
+        testSkipCh.publish({
+          testName: getTestFullname(test),
+          testSuiteAbsolutePath,
+          testSourceLine,
+          browserName,
+        })
+      }
+    }
+    return generateSummary.apply(this, arguments)
+  }
+}
+
+// If a playwright project B has a dependency on project A,
+// and project A fails, the tests in project B will not run.
+// This hook is used to report tests that did not run as skipped.
+// Note: this is different from tests skipped via test.skip() or test.fixme()
+addHook({
+  name: 'playwright',
+  file: 'lib/reporters/base.js',
+  versions: ['>=1.38.0']
+}, (reportersPackage) => {
+  // v1.50.0 changed the name of the base reporter from BaseReporter to TerminalReporter
+  if (reportersPackage.TerminalReporter) {
+    shimmer.wrap(reportersPackage.TerminalReporter.prototype, 'generateSummary', generateSummaryWrapper)
+  } else if (reportersPackage.BaseReporter) {
+    shimmer.wrap(reportersPackage.BaseReporter.prototype, 'generateSummary', generateSummaryWrapper)
+  }
+  return reportersPackage
+})

package/packages/datadog-instrumentations/src/vitest.js

@@ -60,6 +60,7 @@ let testManagementAttemptToFixRetries = 0
 let isDiEnabled = false
 let testCodeCoverageLinesTotal
 let isSessionStarted = false
+let vitestPool = null
 
 const BREAKPOINT_HIT_GRACE_PERIOD_MS = 400
 
@@ -157,6 +158,14 @@ function isTestPackage (testPackage) {
   return testPackage.V?.name === 'VitestTestRunner'
 }
 
+function hasForksPoolWorker (vitestPackage) {
+  return vitestPackage.f?.name === 'ForksPoolWorker'
+}
+
+function hasThreadsPoolWorker (vitestPackage) {
+  return vitestPackage.T?.name === 'ThreadsPoolWorker'
+}
+
 function getSessionStatus (state) {
   if (state.getCountOfFailedTests() > 0) {
     return 'fail'
@@ -389,6 +398,7 @@ function getFinishWrapper (exitOrClose) {
       isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty,
       isTestManagementTestsEnabled,
+      vitestPool,
       onFinish
     })
 
@@ -418,11 +428,27 @@ function getCreateCliWrapper (vitestPackage, frameworkVersion) {
 }
 
 function threadHandler (thread) {
-  if (workerProcesses.has(thread.process)) {
+  const { runtime } = thread
+  let workerProcess
+  if (runtime === 'child_process') {
+    vitestPool = 'child_process'
+    workerProcess = thread.process
+  } else if (runtime === 'worker_threads') {
+    vitestPool = 'worker_threads'
+    workerProcess = thread.thread
+  } else {
+    vitestPool = 'unknown'
+  }
+  if (!workerProcess) {
+    log.error('Vitest error: could not get process or thread from TinyPool#run')
     return
   }
-  workerProcesses.add(thread.process)
-  thread.process.on('message', (message) => {
+
+  if (workerProcesses.has(workerProcess)) {
+    return
+  }
+  workerProcesses.add(workerProcess)
+  workerProcess.on('message', (message) => {
     if (message.__tinypool_worker_message__ && message.data) {
       if (message.interprocessCode === VITEST_WORKER_TRACE_PAYLOAD_CODE) {
         workerReportTraceCh.publish(message.data)
@@ -433,11 +459,7 @@ function threadHandler (thread) {
   })
 }
 
-addHook({
-  name: 'tinypool',
-  versions: ['>=1.0.0'],
-  file: 'dist/index.js'
-}, (TinyPool) => {
+function wrapTinyPoolRun (TinyPool) {
   shimmer.wrap(TinyPool.prototype, 'run', run => async function () {
     // We have to do this before and after because the threads list gets recycled, that is, the processes are re-created
     this.threads.forEach(threadHandler)
@@ -445,15 +467,79 @@ addHook({
     this.threads.forEach(threadHandler)
     return runResult
   })
+}
+
+addHook({
+  name: 'tinypool',
+  // version from tinypool@0.8 was used in vitest@1.6.0
+  versions: ['>=0.8.0 <1.0.0'],
+  file: 'dist/esm/index.js'
+}, (TinyPool) => {
+  wrapTinyPoolRun(TinyPool)
+  return TinyPool
+})
+
+addHook({
+  name: 'tinypool',
+  versions: ['>=1.0.0'],
+  file: 'dist/index.js'
+}, (TinyPool) => {
+  wrapTinyPoolRun(TinyPool)
 
   return TinyPool
 })
 
+function getWrappedOn (on) {
+  return function (event, callback) {
+    if (event !== 'message') {
+      return on.apply(this, arguments)
+    }
+    // `arguments[1]` is the callback function, which
+    // we modify to intercept our messages to not interfere
+    // with vitest's own messages
+    arguments[1] = shimmer.wrapFunction(callback, callback => function (message) {
+      if (message.type !== 'Buffer' && Array.isArray(message)) {
+        const [interprocessCode, data] = message
+        if (interprocessCode === VITEST_WORKER_TRACE_PAYLOAD_CODE) {
+          workerReportTraceCh.publish(data)
+        } else if (interprocessCode === VITEST_WORKER_LOGS_PAYLOAD_CODE) {
+          workerReportLogsCh.publish(data)
+        }
+        // If we execute the callback vitest crashes, as the message is not supported
+        return
+      }
+      return callback.apply(this, arguments)
+    })
+    return on.apply(this, arguments)
+  }
+}
+
 function getStartVitestWrapper (cliApiPackage, frameworkVersion) {
   if (!isCliApiPackage(cliApiPackage)) {
     return cliApiPackage
   }
   shimmer.wrap(cliApiPackage, 's', getCliOrStartVitestWrapper(frameworkVersion))
+
+  if (hasForksPoolWorker(cliApiPackage)) {
+    // function is async
+    shimmer.wrap(cliApiPackage.f.prototype, 'start', start => function () {
+      vitestPool = 'child_process'
+      this.env.DD_VITEST_WORKER = '1'
+
+      return start.apply(this, arguments)
+    })
+    shimmer.wrap(cliApiPackage.f.prototype, 'on', getWrappedOn)
+  }
+
+  if (hasThreadsPoolWorker(cliApiPackage)) {
+    // function is async
+    shimmer.wrap(cliApiPackage.T.prototype, 'start', start => function () {
+      vitestPool = 'worker_threads'
+      this.env.DD_VITEST_WORKER = '1'
+      return start.apply(this, arguments)
+    })
+    shimmer.wrap(cliApiPackage.T.prototype, 'on', getWrappedOn)
+  }
   return cliApiPackage
 }
 

package/packages/datadog-plugin-openai/src/stream-helpers.js

@@ -107,8 +107,33 @@ function constructChatCompletionResponseFromStreamedChunks (chunks, n) {
   })
 }
 
+/**
+ * Constructs the entire response from a stream of OpenAI responses chunks.
+ * The responses API uses event-based streaming with delta chunks.
+ * @param {Array<Record<string, any>>} chunks
+ * @returns {Record<string, any>}
+ */
+function constructResponseResponseFromStreamedChunks (chunks) {
+  // The responses API streams events with different types:
+  // - response.output_text.delta: incremental text deltas
+  // - response.output_text.done: complete text for a content part
+  // - response.output_item.done: complete output item with role
+  // - response.done/response.incomplete/response.completed: final response with output array and usage
+
+  // Find the last chunk with a complete response object (status: done, incomplete, or completed)
+  const responseStatusSet = new Set(['done', 'incomplete', 'completed'])
+
+  for (let i = chunks.length - 1; i >= 0; i--) {
+    const chunk = chunks[i]
+    if (chunk.response && responseStatusSet.has(chunk.response.status)) {
+      return chunk.response
+    }
+  }
+}
+
 module.exports = {
   convertBuffersToObjects,
   constructCompletionResponseFromStreamedChunks,
-  constructChatCompletionResponseFromStreamedChunks
+  constructChatCompletionResponseFromStreamedChunks,
+  constructResponseResponseFromStreamedChunks
 }

package/packages/datadog-plugin-openai/src/tracing.js

@@ -11,7 +11,8 @@ const { MEASURED } = require('../../../ext/tags')
 const {
   convertBuffersToObjects,
   constructCompletionResponseFromStreamedChunks,
-  constructChatCompletionResponseFromStreamedChunks
+  constructChatCompletionResponseFromStreamedChunks,
+  constructResponseResponseFromStreamedChunks
 } = require('./stream-helpers')
 
 const { DD_MAJOR } = require('../../../version')
@@ -59,6 +60,8 @@ class OpenAiTracingPlugin extends TracingPlugin {
         response = constructCompletionResponseFromStreamedChunks(chunks, n)
       } else if (methodName === 'createChatCompletion') {
         response = constructChatCompletionResponseFromStreamedChunks(chunks, n)
+      } else if (methodName === 'createResponse') {
+        response = constructResponseResponseFromStreamedChunks(chunks)
       }
 
       ctx.result = { data: response }
@@ -134,6 +137,10 @@ class OpenAiTracingPlugin extends TracingPlugin {
       case 'createEdit':
         createEditRequestExtraction(tags, payload, openaiStore)
         break
+
+      case 'createResponse':
+        createResponseRequestExtraction(tags, payload, openaiStore)
+        break
     }
 
     span.addTags(tags)
@@ -313,6 +320,10 @@ function normalizeMethodName (methodName) {
     case 'embeddings.create':
       return 'createEmbedding'
 
+    // responses
+    case 'responses.create':
+      return 'createResponse'
+
     // files
     case 'files.create':
       return 'createFile'
@@ -376,6 +387,16 @@ function createEditRequestExtraction (tags, payload, openaiStore) {
   openaiStore.instruction = instruction
 }
 
+function createResponseRequestExtraction (tags, payload, openaiStore) {
+  // Extract model information
+  if (payload.model) {
+    tags['openai.request.model'] = payload.model
+  }
+
+  // Store the full payload for response extraction
+  openaiStore.responseData = payload
+}
+
 function retrieveModelRequestExtraction (tags, payload) {
   tags['openai.request.id'] = payload.id
 }
@@ -410,6 +431,10 @@ function responseDataExtractionByMethod (methodName, tags, body, openaiStore) {
       commonCreateResponseExtraction(tags, body, openaiStore, methodName)
       break
 
+    case 'createResponse':
+      createResponseResponseExtraction(tags, body, openaiStore)
+      break
+
     case 'listFiles':
     case 'listFineTunes':
     case 'listFineTuneEvents':
@@ -513,6 +538,26 @@ function commonCreateResponseExtraction (tags, body, openaiStore, methodName) {
   openaiStore.choices = body.choices
 }
 
+function createResponseResponseExtraction (tags, body, openaiStore) {
+  // Extract response ID if available
+  if (body.id) {
+    tags['openai.response.id'] = body.id
+  }
+
+  // Extract status if available
+  if (body.status) {
+    tags['openai.response.status'] = body.status
+  }
+
+  // Extract model from response if available
+  if (body.model) {
+    tags['openai.response.model'] = body.model
+  }
+
+  // Store the full response for potential future use
+  openaiStore.response = body
+}
+
 // The server almost always responds with JSON
 function coerceResponseBody (body, methodName) {
   switch (methodName) {

package/packages/datadog-plugin-vitest/src/index.js

@@ -6,6 +6,7 @@ const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 
 const {
   TEST_STATUS,
+  VITEST_POOL,
   finishAllTraceSpans,
   getTestSuitePath,
   getTestSuiteCommonTags,
@@ -344,7 +345,6 @@ class VitestPlugin extends CiPlugin {
         finishAllTraceSpans(testSuiteSpan)
       }
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
-      // TODO: too frequent flush - find for method in worker to decrease frequency
       this.tracer._exporter.flush(onFinish)
       if (this.runningTestProbe) {
         this.removeDiProbe(this.runningTestProbe)
@@ -373,6 +373,7 @@ class VitestPlugin extends CiPlugin {
       isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty,
       isTestManagementTestsEnabled,
+      vitestPool,
       onFinish
     }) => {
       this.testSessionSpan.setTag(TEST_STATUS, status)
@@ -394,6 +395,9 @@ class VitestPlugin extends CiPlugin {
       if (isTestManagementTestsEnabled) {
         this.testSessionSpan.setTag(TEST_MANAGEMENT_ENABLED, 'true')
       }
+      if (vitestPool) {
+        this.testSessionSpan.setTag(VITEST_POOL, vitestPool)
+      }
       this.testModuleSpan.finish()
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
       this.testSessionSpan.finish()

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

@@ -29,6 +29,9 @@ function getInterprocessTraceCode () {
   if (getEnvironmentVariable('TINYPOOL_WORKER_ID')) {
     return VITEST_WORKER_TRACE_PAYLOAD_CODE
   }
+  if (getEnvironmentVariable('DD_VITEST_WORKER')) {
+    return VITEST_WORKER_TRACE_PAYLOAD_CODE
+  }
   return null
 }
 
@@ -47,6 +50,9 @@ function getInterprocessLogsCode () {
   if (getEnvironmentVariable('TINYPOOL_WORKER_ID')) {
     return VITEST_WORKER_LOGS_PAYLOAD_CODE
   }
+  if (getEnvironmentVariable('DD_VITEST_WORKER')) {
+    return VITEST_WORKER_LOGS_PAYLOAD_CODE
+  }
   return null
 }
 

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

@@ -1,6 +1,11 @@
 'use strict'
 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) {
@@ -26,24 +31,42 @@ class Writer {
   _sendPayload (data, onDone = () => {}) {
     // ## Jest
     // Only available when `child_process` is used for the jest worker.
-    // https://github.com/facebook/jest/blob/bb39cb2c617a3334bf18daeca66bd87b7ccab28b/packages/jest-worker/README.md#experimental-worker
     // If worker_threads is used, this will not work
-    // TODO: make it compatible with worker_threads
+    // 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:
     // https://github.com/cucumber/cucumber-js/blob/5ce371870b677fe3d1a14915dc535688946f734c/src/runtime/parallel/run_worker.ts#L13
-    if (process.send) { // it only works if process.send is available
-      const isVitestWorker = !!getEnvironmentVariable('TINYPOOL_WORKER_ID')
 
-      const payload = isVitestWorker
-        ? { __tinypool_worker_message__: true, interprocessCode: this._interprocessCode, data }
-        : [this._interprocessCode, data]
+    // Old because vitest@>=4 uses `DD_VITEST_WORKER` and reports arrays just like other frameworks
+    // Before vitest@>=4, we need the `__tinypool_worker_message__` property, or tinypool will crash
+    const isVitestWorkerOld = !!getEnvironmentVariable('TINYPOOL_WORKER_ID')
+    const payload = isVitestWorkerOld
+      ? { __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
+
+    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()
+      }
+      try {
+        parentPort.postMessage(payload)
+      } catch (error) {
+        log.error('Error posting message to parent port', error)
+      } finally {
+        onDone()
+      }
     } else {
       onDone()
     }

package/packages/dd-trace/src/llmobs/plugins/openai.js

@@ -2,6 +2,13 @@
 
 const LLMObsPlugin = require('./base')
 
+const allowedParamKeys = new Set([
+  'max_output_tokens',
+  'temperature',
+  'stream',
+  'reasoning'
+])
+
 function isIterable (obj) {
   if (obj == null) {
     return false
@@ -19,7 +26,7 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
     const methodName = gateResource(normalizeOpenAIResourceName(resource))
     if (!methodName) return // we will not trace all openai methods for llmobs
 
-    const inputs = ctx.args[0] // completion, chat completion, and embeddings take one argument
+    const inputs = ctx.args[0] // completion, chat completion, embeddings, and responses take one argument
     const operation = getOperation(methodName)
     const kind = operation === 'embedding' ? 'embedding' : 'llm'
 
@@ -53,6 +60,8 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
       this._tagChatCompletion(span, inputs, response, error)
     } else if (operation === 'embedding') {
       this._tagEmbedding(span, inputs, response, error)
+    } else if (operation === 'response') {
+      this.#tagResponse(span, inputs, response, error)
     }
 
     if (!error) {
@@ -75,19 +84,30 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
     const tokenUsage = response.usage
 
     if (tokenUsage) {
-      const inputTokens = tokenUsage.prompt_tokens
-      if (inputTokens) metrics.inputTokens = inputTokens
+      // Responses API uses input_tokens, Chat/Completions use prompt_tokens
+      const inputTokens = tokenUsage.input_tokens ?? tokenUsage.prompt_tokens
+      if (inputTokens !== undefined) metrics.inputTokens = inputTokens
 
-      const outputTokens = tokenUsage.completion_tokens
-      if (outputTokens) metrics.outputTokens = outputTokens
+      // Responses API uses output_tokens, Chat/Completions use completion_tokens
+      const outputTokens = tokenUsage.output_tokens ?? tokenUsage.completion_tokens
+      if (outputTokens !== undefined) metrics.outputTokens = outputTokens
 
       const totalTokens = tokenUsage.total_tokens || (inputTokens + outputTokens)
-      if (totalTokens) metrics.totalTokens = totalTokens
-
-      const promptTokensDetails = tokenUsage.prompt_tokens_details
-      if (promptTokensDetails) {
-        const cacheReadTokens = promptTokensDetails.cached_tokens
-        if (cacheReadTokens) metrics.cacheReadTokens = cacheReadTokens
+      if (totalTokens !== undefined) metrics.totalTokens = totalTokens
+
+      // Cache tokens - Responses API uses input_tokens_details, Chat/Completions use prompt_tokens_details
+      // For Responses API, always include cache tokens (even if 0)
+      // For Chat API, only include if > 0
+      if (tokenUsage.input_tokens_details) {
+        // Responses API - always include
+        const cacheReadTokens = tokenUsage.input_tokens_details.cached_tokens
+        if (cacheReadTokens !== undefined) metrics.cacheReadTokens = cacheReadTokens
+      } else if (tokenUsage.prompt_tokens_details) {
+        // Chat/Completions API - only include if > 0
+        const cacheReadTokens = tokenUsage.prompt_tokens_details.cached_tokens
+        if (cacheReadTokens) {
+          metrics.cacheReadTokens = cacheReadTokens
+        }
       }
     }
 
@@ -191,6 +211,183 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
 
     this._tagger.tagMetadata(span, metadata)
   }
+
+  #tagResponse (span, inputs, response, error) {
+    // Tag metadata - use allowlist approach for request parameters
+
+    const { input, model, ...parameters } = inputs
+
+    // Create input messages
+    const inputMessages = []
+
+    // Add system message if instructions exist
+    if (inputs.instructions) {
+      inputMessages.push({ role: 'system', content: inputs.instructions })
+    }
+
+    // Handle input - can be string or array of mixed messages
+    if (Array.isArray(input)) {
+      for (const item of input) {
+        if (item.type === 'function_call') {
+          // Function call: convert to message with tool_calls
+          // Parse arguments if it's a JSON string
+          let parsedArgs = item.arguments
+          if (typeof parsedArgs === 'string') {
+            try {
+              parsedArgs = JSON.parse(parsedArgs)
+            } catch {
+              parsedArgs = {}
+            }
+          }
+          inputMessages.push({
+            role: 'assistant',
+            toolCalls: [{
+              toolId: item.call_id,
+              name: item.name,
+              arguments: parsedArgs,
+              type: item.type
+            }]
+          })
+        } else if (item.type === 'function_call_output') {
+          // Function output: convert to user message with tool_results
+          inputMessages.push({
+            role: 'user',
+            toolResults: [{
+              toolId: item.call_id,
+              result: item.output,
+              name: item.name || '',
+              type: item.type
+            }]
+          })
+        } else if (item.role && item.content) {
+          // Regular message
+          inputMessages.push({ role: item.role, content: item.content })
+        }
+      }
+    } else {
+      // Simple string input
+      inputMessages.push({ role: 'user', content: input })
+    }
+
+    if (error) {
+      this._tagger.tagLLMIO(span, inputMessages, [{ content: '' }])
+      return
+    }
+
+    // Create output messages
+    const outputMessages = []
+
+    // Handle output - can be string (streaming) or array of message objects (non-streaming)
+    if (typeof response.output === 'string') {
+      // Simple text output (streaming)
+      outputMessages.push({ role: 'assistant', content: response.output })
+    } else if (Array.isArray(response.output)) {
+      // Array output - process all items to extract reasoning, messages, and tool calls
+      // Non-streaming: array of items (messages, function_calls, or reasoning)
+      for (const item of response.output) {
+        // Handle reasoning type (reasoning responses)
+        if (item.type === 'reasoning') {
+          // Extract reasoning text from summary
+          let reasoningText = ''
+          if (Array.isArray(item.summary) && item.summary.length > 0) {
+            const summaryItem = item.summary[0]
+            if (summaryItem.type === 'summary_text' && summaryItem.text) {
+              reasoningText = summaryItem.text
+            }
+          }
+          outputMessages.push({
+            role: 'reasoning',
+            content: reasoningText
+          })
+        } else if (item.type === 'function_call') {
+          // Handle function_call type (responses API tool calls)
+          let args = item.arguments
+          // Parse arguments if it's a JSON string
+          if (typeof args === 'string') {
+            try {
+              args = JSON.parse(args)
+            } catch {
+              args = {}
+            }
+          }
+          outputMessages.push({
+            role: 'assistant',
+            toolCalls: [{
+              toolId: item.call_id,
+              name: item.name,
+              arguments: args,
+              type: item.type
+            }]
+          })
+        } else {
+          // Handle regular message objects
+          const outputMsg = { role: item.role || 'assistant', content: '' }
+
+          // Extract content from message
+          if (Array.isArray(item.content)) {
+            // Content is array of content parts
+            // For responses API, text content has type 'output_text', not 'text'
+            const textParts = item.content
+              .filter(c => c.type === 'output_text')
+              .map(c => c.text)
+            outputMsg.content = textParts.join('')
+          } else if (typeof item.content === 'string') {
+            outputMsg.content = item.content
+          }
+
+          // Extract tool calls if present in message.tool_calls
+          if (Array.isArray(item.tool_calls)) {
+            outputMsg.toolCalls = item.tool_calls.map(tc => {
+              let args = tc.function?.arguments || tc.arguments
+              // Parse arguments if it's a JSON string
+              if (typeof args === 'string') {
+                try {
+                  args = JSON.parse(args)
+                } catch {
+                  args = {}
+                }
+              }
+              return {
+                toolId: tc.id,
+                name: tc.function?.name || tc.name,
+                arguments: args,
+                type: tc.type || 'function_call'
+              }
+            })
+          }
+
+          outputMessages.push(outputMsg)
+        }
+      }
+    } else if (response.output_text) {
+      // Fallback: use output_text if available (for simple non-streaming responses without reasoning/tools)
+      outputMessages.push({ role: 'assistant', content: response.output_text })
+    } else {
+      // No output
+      outputMessages.push({ role: 'assistant', content: '' })
+    }
+
+    this._tagger.tagLLMIO(span, inputMessages, outputMessages)
+
+    const metadata = Object.entries(parameters).reduce((obj, [key, value]) => {
+      if (allowedParamKeys.has(key)) {
+        obj[key] = value
+      }
+      return obj
+    }, {})
+
+    // Add fields from response object (convert numbers to floats)
+    if (response.temperature !== undefined) metadata.temperature = Number(response.temperature)
+    if (response.top_p !== undefined) metadata.top_p = Number(response.top_p)
+    if (response.tool_choice !== undefined) metadata.tool_choice = response.tool_choice
+    if (response.truncation !== undefined) metadata.truncation = response.truncation
+    if (response.text !== undefined) metadata.text = response.text
+    if (response.usage?.output_tokens_details?.reasoning_tokens !== undefined) {
+      metadata.reasoning_tokens = response.usage.output_tokens_details.reasoning_tokens
+    }
+
+    this._tagger.tagMetadata(span, metadata)
+  }
 }
 
 // TODO: this will be moved to the APM integration
@@ -207,13 +404,18 @@ function normalizeOpenAIResourceName (resource) {
     // embeddings
     case 'embeddings.create':
       return 'createEmbedding'
+
+    // responses
+    case 'responses.create':
+      return 'createResponse'
+
     default:
       return resource
   }
 }
 
 function gateResource (resource) {
-  return ['createCompletion', 'createChatCompletion', 'createEmbedding'].includes(resource)
+  return ['createCompletion', 'createChatCompletion', 'createEmbedding', 'createResponse'].includes(resource)
     ? resource
     : undefined
 }
@@ -226,6 +428,8 @@ function getOperation (resource) {
       return 'chat'
     case 'createEmbedding':
       return 'embedding'
+    case 'createResponse':
+      return 'response'
     default:
       // should never happen
       return 'unknown'

package/packages/dd-trace/src/llmobs/span_processor.js

@@ -224,7 +224,8 @@ class LLMObsSpanProcessor {
           continue
         }
         if (value !== null && typeof value === 'object') {
-          add(value, carrier[key] = {})
+          carrier[key] = Array.isArray(value) ? [] : {}
+          add(value, carrier[key])
         } else {
           carrier[key] = value
         }

package/packages/dd-trace/src/llmobs/tagger.js

@@ -292,11 +292,17 @@ class LLMObsTagger {
         continue
       }
 
-      const { result, toolId, type } = toolResult
+      const { result, toolId, name = '', type } = toolResult
       const toolResultObj = {}
 
       const condition1 = this.#tagConditionalString(result, 'Tool result', toolResultObj, 'result')
       const condition2 = this.#tagConditionalString(toolId, 'Tool ID', toolResultObj, 'tool_id')
+      // name can be empty string, so always include it
+      if (typeof name === 'string') {
+        toolResultObj.name = name
+      } else {
+        this.#handleFailure(`[LLMObs] Expected tool result name to be a string, instead got "${typeof name}"`)
+      }
       const condition3 = this.#tagConditionalString(type, 'Tool type', toolResultObj, 'type')
 
       if (condition1 && condition2 && condition3) {
@@ -332,13 +338,13 @@ class LLMObsTagger {
       const toolId = message.toolId
       const messageObj = { content }
 
+      let condition = this.#tagConditionalString(role, 'Message role', messageObj, 'role')
+
       const valid = typeof content === 'string'
       if (!valid) {
         this.#handleFailure('Message content must be a string.', 'invalid_io_messages')
       }
 
-      let condition = this.#tagConditionalString(role, 'Message role', messageObj, 'role')
-
       if (toolCalls) {
         const filteredToolCalls = this.#filterToolCalls(toolCalls)
 

package/packages/dd-trace/src/plugins/ci_plugin.js

@@ -34,7 +34,8 @@ const {
   getLibraryCapabilitiesTags,
   getPullRequestDiff,
   getModifiedFilesFromDiff,
-  getPullRequestBaseBranch
+  getPullRequestBaseBranch,
+  TEST_IS_TEST_FRAMEWORK_WORKER
 } = require('./util/test')
 const { getRepositoryRoot } = require('./util/git')
 const Plugin = require('./plugin')
@@ -311,6 +312,7 @@ module.exports = class CiPlugin extends Plugin {
           span.parent_id = id(span.parent_id)
 
           if (span.name?.startsWith(`${this.constructor.id}.`)) {
+            span.meta[TEST_IS_TEST_FRAMEWORK_WORKER] = 'true'
             // augment with git information (since it will not be available in the worker)
             for (const key in this.testEnvironmentMetadata) {
               // CAREFUL: this bypasses the metadata/metrics distinction

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

@@ -92,6 +92,8 @@ const CI_APP_ORIGIN = 'ciapp-test'
 const JEST_TEST_RUNNER = 'test.jest.test_runner'
 const JEST_DISPLAY_NAME = 'test.jest.display_name'
 
+const VITEST_POOL = 'test.vitest.pool'
+
 const CUCUMBER_IS_PARALLEL = 'test.cucumber.is_parallel'
 const MOCHA_IS_PARALLEL = 'test.mocha.is_parallel'
 
@@ -130,6 +132,8 @@ const PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE = 90
 const VITEST_WORKER_TRACE_PAYLOAD_CODE = 100
 const VITEST_WORKER_LOGS_PAYLOAD_CODE = 102
 
+const TEST_IS_TEST_FRAMEWORK_WORKER = 'test.is_test_framework_worker'
+
 // Library Capabilities Tagging
 const DD_CAPABILITIES_TEST_IMPACT_ANALYSIS = '_dd.library_capabilities.test_impact_analysis'
 const DD_CAPABILITIES_EARLY_FLAKE_DETECTION = '_dd.library_capabilities.early_flake_detection'
@@ -203,6 +207,7 @@ module.exports = {
   TEST_FRAMEWORK_VERSION,
   JEST_TEST_RUNNER,
   JEST_DISPLAY_NAME,
+  VITEST_POOL,
   CUCUMBER_IS_PARALLEL,
   MOCHA_IS_PARALLEL,
   TEST_TYPE,
@@ -223,6 +228,7 @@ module.exports = {
   PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE,
   VITEST_WORKER_TRACE_PAYLOAD_CODE,
   VITEST_WORKER_LOGS_PAYLOAD_CODE,
+  TEST_IS_TEST_FRAMEWORK_WORKER,
   TEST_SOURCE_START,
   TEST_SKIPPED_BY_ITR,
   TEST_IS_NEW,

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

@@ -269,9 +269,27 @@ module.exports = { Config }
 function getProfilers ({
   DD_PROFILING_HEAP_ENABLED, DD_PROFILING_WALLTIME_ENABLED, DD_PROFILING_PROFILERS
 }) {
-  // First consider "legacy" DD_PROFILING_PROFILERS env variable, defaulting to wall + space
+  // First consider "legacy" DD_PROFILING_PROFILERS env variable, defaulting to space + wall
   // Use a Set to avoid duplicates
-  const profilers = new Set((DD_PROFILING_PROFILERS ?? 'wall,space').split(','))
+  // NOTE: space profiler is very deliberately in the first position. This way
+  // when profilers are stopped sequentially one after the other to create
+  // snapshots the space profile won't include memory taken by profiles created
+  // before it in the sequence. That memory is ultimately transient and will be
+  // released when all profiles are subsequently encoded.
+  const profilers = new Set((DD_PROFILING_PROFILERS ?? 'space,wall').split(','))
+
+  let spaceExplicitlyEnabled = false
+  // Add/remove space depending on the value of DD_PROFILING_HEAP_ENABLED
+  if (DD_PROFILING_HEAP_ENABLED != null) {
+    if (isTrue(DD_PROFILING_HEAP_ENABLED)) {
+      if (!profilers.has('space')) {
+        profilers.add('space')
+        spaceExplicitlyEnabled = true
+      }
+    } else if (isFalse(DD_PROFILING_HEAP_ENABLED)) {
+      profilers.delete('space')
+    }
+  }
 
   // Add/remove wall depending on the value of DD_PROFILING_WALLTIME_ENABLED
   if (DD_PROFILING_WALLTIME_ENABLED != null) {
@@ -279,19 +297,23 @@ function getProfilers ({
       profilers.add('wall')
     } else if (isFalse(DD_PROFILING_WALLTIME_ENABLED)) {
       profilers.delete('wall')
+      profilers.delete('cpu') // remove alias too
     }
   }
 
-  // Add/remove wall depending on the value of DD_PROFILING_HEAP_ENABLED
-  if (DD_PROFILING_HEAP_ENABLED != null) {
-    if (isTrue(DD_PROFILING_HEAP_ENABLED)) {
-      profilers.add('space')
-    } else if (isFalse(DD_PROFILING_HEAP_ENABLED)) {
-      profilers.delete('space')
+  const profilersArray = [...profilers]
+  // If space was added through DD_PROFILING_HEAP_ENABLED, ensure it is in the
+  // first position. Basically, the only way for it not to be in the first
+  // position is if it was explicitly specified in a different position in
+  // DD_PROFILING_PROFILERS.
+  if (spaceExplicitlyEnabled) {
+    const spaceIdx = profilersArray.indexOf('space')
+    if (spaceIdx > 0) {
+      profilersArray.splice(spaceIdx, 1)
+      profilersArray.unshift('space')
     }
   }
-
-  return [...profilers]
+  return profilersArray
 }
 
 function getExportStrategy (name, options) {

package/packages/dd-trace/src/remote_config/capabilities.js

@@ -16,6 +16,8 @@ module.exports = {
   APM_TRACING_LOGS_INJECTION: 1n << 13n,
   APM_TRACING_HTTP_HEADER_TAGS: 1n << 14n,
   APM_TRACING_CUSTOM_TAGS: 1n << 15n,
+  ASM_PROCESSOR_OVERRIDES: 1n << 16n,
+  ASM_CUSTOM_DATA_SCANNERS: 1n << 17n,
   ASM_EXCLUSION_DATA: 1n << 18n,
   APM_TRACING_ENABLED: 1n << 19n,
   ASM_RASP_SQLI: 1n << 21n,

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

@@ -90,6 +90,8 @@ function enableWafUpdate (appsecConfig) {
     rc.updateCapabilities(RemoteConfigCapabilities.ASM_CUSTOM_RULES, true)
     rc.updateCapabilities(RemoteConfigCapabilities.ASM_CUSTOM_BLOCKING_RESPONSE, true)
     rc.updateCapabilities(RemoteConfigCapabilities.ASM_TRUSTED_IPS, true)
+    rc.updateCapabilities(RemoteConfigCapabilities.ASM_PROCESSOR_OVERRIDES, true)
+    rc.updateCapabilities(RemoteConfigCapabilities.ASM_CUSTOM_DATA_SCANNERS, true)
     rc.updateCapabilities(RemoteConfigCapabilities.ASM_EXCLUSION_DATA, true)
     rc.updateCapabilities(RemoteConfigCapabilities.ASM_ENDPOINT_FINGERPRINT, true)
     rc.updateCapabilities(RemoteConfigCapabilities.ASM_SESSION_FINGERPRINT, true)
@@ -129,6 +131,8 @@ function disableWafUpdate () {
     rc.updateCapabilities(RemoteConfigCapabilities.ASM_CUSTOM_RULES, false)
     rc.updateCapabilities(RemoteConfigCapabilities.ASM_CUSTOM_BLOCKING_RESPONSE, false)
     rc.updateCapabilities(RemoteConfigCapabilities.ASM_TRUSTED_IPS, false)
+    rc.updateCapabilities(RemoteConfigCapabilities.ASM_PROCESSOR_OVERRIDES, false)
+    rc.updateCapabilities(RemoteConfigCapabilities.ASM_CUSTOM_DATA_SCANNERS, false)
     rc.updateCapabilities(RemoteConfigCapabilities.ASM_EXCLUSION_DATA, false)
     rc.updateCapabilities(RemoteConfigCapabilities.ASM_ENDPOINT_FINGERPRINT, false)
     rc.updateCapabilities(RemoteConfigCapabilities.ASM_SESSION_FINGERPRINT, false)

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

@@ -444,6 +444,7 @@
     "DD_VERSION": ["A"],
     "DD_VERTEXAI_SPAN_CHAR_LIMIT": ["A"],
     "DD_VERTEXAI_SPAN_PROMPT_COMPLETION_SAMPLE_RATE": ["A"],
+    "DD_VITEST_WORKER": ["A"],
     "OTEL_LOG_LEVEL": ["A"],
     "OTEL_LOGS_EXPORTER": ["A"],
     "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT": ["A"],