dd-trace 5.75.0 → 5.77.0

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

@@ -203,8 +203,8 @@ class LLMObsSpanProcessor {
   // This function can be reused for other fields if needed
   // Messages, Documents, and Metrics are safeguarded in `llmobs/tagger.js`
   #addObject (obj, carrier) {
-    const seenObjects = new WeakSet()
-    seenObjects.add(obj) // capture root object
+    // Capture root object by default
+    const seenObjects = new WeakSet([obj])
 
     const isCircular = value => {
       if (typeof value !== 'object') return false
@@ -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/llmobs/util.js

@@ -6,7 +6,7 @@ function encodeUnicode (str = '') {
   let result = ''
   for (let i = 0; i < str.length; i++) {
     const code = str.charCodeAt(i)
-    result += code > 127 ? `\\u${code.toString(16).padStart(4, '0')}` : str[i]
+    result += code > 127 ? String.raw`\u${code.toString(16).padStart(4, '0')}` : str[i]
   }
   return result
 }

package/packages/dd-trace/src/openfeature/writers/exposures.js

@@ -27,7 +27,7 @@ const {
 
 /**
  * @typedef {Object} ExposureContext
- * @property {string} service_name - Service name
+ * @property {string} service - Service name
  * @property {string} [version] - Service version
  * @property {string} [env] - Service environment
  */
@@ -127,7 +127,7 @@ class ExposuresWriter extends BaseFFEWriter {
    */
   _buildContext () {
     const context = {
-      service_name: this._config.service || 'unknown'
+      service: this._config.service || 'unknown'
     }
 
     // Only include version and env if they are defined

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

@@ -10,7 +10,7 @@ const { timeInputToHrTime } = require('@opentelemetry/core')
 const tracer = require('../../')
 const DatadogSpan = require('../opentracing/span')
 const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK, IGNORE_OTEL_ERROR } = require('../constants')
-const { SERVICE_NAME, RESOURCE_NAME } = require('../../../../ext/tags')
+const { SERVICE_NAME, RESOURCE_NAME, SPAN_KIND } = require('../../../../ext/tags')
 const kinds = require('../../../../ext/kinds')
 
 const SpanContext = require('./span_context')
@@ -146,7 +146,8 @@ class Span {
       integrationName: parentTracer?._isOtelLibrary ? 'otel.library' : 'otel',
       tags: {
         [SERVICE_NAME]: _tracer._service,
-        [RESOURCE_NAME]: spanName
+        [RESOURCE_NAME]: spanName,
+        [SPAN_KIND]: spanKindNames[kind]
       },
       links
     }, _tracer._debug)

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/serverless.js

@@ -3,7 +3,6 @@
 const types = require('../../../../../ext/types')
 const web = require('./web')
 
-const serverless = { ...web }
-serverless.TYPE = types.SERVERLESS
+const serverless = { ...web, TYPE: types.SERVERLESS }
 
 module.exports = serverless

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,
@@ -621,20 +627,29 @@ function getCodeOwnersFileEntries (rootDir) {
   return entries.reverse()
 }
 
+const codeOwnersPerFileName = new Map()
+
 function getCodeOwnersForFilename (filename, entries) {
   if (!entries) {
     return null
   }
+  if (codeOwnersPerFileName.has(filename)) {
+    return codeOwnersPerFileName.get(filename)
+  }
   for (const entry of entries) {
     try {
       const isResponsible = ignore().add(entry.pattern).ignores(filename)
       if (isResponsible) {
-        return JSON.stringify(entry.owners)
+        const codeOwners = JSON.stringify(entry.owners)
+        codeOwnersPerFileName.set(filename, codeOwners)
+        return codeOwners
       }
     } catch {
+      codeOwnersPerFileName.set(filename, null)
       return null
     }
   }
+  codeOwnersPerFileName.set(filename, null)
   return null
 }
 

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

@@ -577,13 +577,17 @@ function getHeadersToRecord (config) {
   return []
 }
 
+function isNot500ErrorCode (code) {
+  return code < 500
+}
+
 function getStatusValidator (config) {
   if (typeof config.validateStatus === 'function') {
     return config.validateStatus
   } else if (config.hasOwnProperty('validateStatus')) {
     log.error('Expected `validateStatus` to be a function.')
   }
-  return code => code < 500
+  return isNot500ErrorCode
 }
 
 const noop = () => {}

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/proxy.js

@@ -1,7 +1,7 @@
 'use strict'
 const NoopProxy = require('./noop/proxy')
 const DatadogTracer = require('./tracer')
-const Config = require('./config')
+const getConfig = require('./config')
 const runtimeMetrics = require('./runtime_metrics')
 const log = require('./log')
 const { setStartupLogPluginManager } = require('./startup-log')
@@ -98,7 +98,7 @@ class Tracer extends NoopProxy {
     this._initialized = true
 
     try {
-      const config = new Config(options) // TODO: support dynamic code config
+      const config = getConfig(options) // TODO: support dynamic code config
 
       if (config.crashtracking.enabled) {
         require('./crashtracking').start(config)

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/runtime_metrics/runtime_metrics.js

@@ -22,7 +22,7 @@ let nativeMetrics = null
 let gcObserver = null
 let interval = null
 let client = null
-let lastTime = 0n
+let lastTime = 0
 let lastCpuUsage = null
 let eventLoopDelayObserver = null
 
@@ -103,7 +103,6 @@ module.exports = {
     interval = null
 
     client = null
-    lastTime = 0n
     lastCpuUsage = null
 
     gcObserver?.disconnect()
@@ -339,6 +338,7 @@ function startGCObserver () {
 
   gcObserver = new PerformanceObserver(list => {
     for (const entry of list.getEntries()) {
+      // @ts-expect-error - entry.detail?.kind and entry.kind are not typed
       const type = gcType(entry.detail?.kind || entry.kind)
       const duration = entry.duration * 1_000_000
 

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

@@ -47,11 +47,14 @@ class SpanProcessor {
       this._spanSampler.sample(spanContext)
       this._gitMetadataTagger.tagGitMetadata(spanContext)
 
+      let isChunkRoot = true
+
       for (const span of started) {
         if (span._duration === undefined) {
           active.push(span)
         } else {
-          const formattedSpan = format(span)
+          const formattedSpan = format(span, isChunkRoot)
+          isChunkRoot = false
           this._stats?.onSpanFinished(formattedSpan)
           formatted.push(formattedSpan)