dd-trace 6.2.0 → 6.4.0

package/packages/datadog-plugin-modelcontextprotocol-sdk/src/tracing.js

@@ -1,55 +1,173 @@
 'use strict'
 
+const Plugin = require('../../dd-trace/src/plugins/plugin')
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
 
-class McpToolCallPlugin extends TracingPlugin {
-  static id = 'modelcontextprotocol_client'
-  static prefix = 'tracing:orchestrion:@modelcontextprotocol/sdk:Client_callTool'
+const {
+  DISTRIBUTED_TRACE_META_KEY,
+  tagErrorResult,
+} = require('./utils')
 
-  bindStart (ctx) {
-    const params = ctx.arguments?.[0]
-    const toolName = params?.name
+const MCP_REQUEST_SPAN_NAME = 'mcp.request'
+const CLIENT_TOOL_CALL_RESOURCE = 'client_tool_call'
+const CLIENT_LIST_TOOLS_RESOURCE = 'ClientSession.list_tools'
+const SERVER_TOOL_CALL_RESOURCE = 'server_tool_call'
 
-    this.startSpan('mcp.client.tool.call', {
-      resource: toolName,
+function getServerRequestResource (request) {
+  if (request?.method === 'tools/call') return SERVER_TOOL_CALL_RESOURCE
+  return request?.method
+}
+
+class McpPlugin extends TracingPlugin {
+  bindStart (ctx) {
+    const spanOptions = {
+      resource: this.getResource(ctx),
       type: 'mcp',
-      kind: 'client',
-    }, ctx)
+      kind: this.constructor.kind,
+    }
+    const childOf = this.getChildOf(ctx)
+    if (childOf) spanOptions.childOf = childOf
 
+    this.startSpan(this.constructor.spanName, spanOptions, ctx)
+    const span = ctx.currentStore?.span
+    if (span) this.onStart(span, ctx)
     return ctx.currentStore
   }
 
   asyncEnd (ctx) {
-    const result = ctx.result
-    if (result?.isError) {
-      const span = ctx.currentStore?.span
-      const errorText = result.content?.find?.(c => c.type === 'text')?.text || 'Tool call returned isError: true'
-      span?.setTag('error', new Error(errorText))
-    }
+    const span = ctx.currentStore?.span
+    if (span) this.onEnd(span, ctx)
     super.finish(ctx)
   }
+
+  getResource () {}
+  getChildOf () {}
+  onStart () {}
+  onEnd () {}
 }
 
-class McpListToolsPlugin extends TracingPlugin {
+class McpPropagationPlugin extends Plugin {
+  static id = 'modelcontextprotocol_propagation'
+
+  constructor (...args) {
+    super(...args)
+    this.addSub('apm:mcp:client:request:inject', this.injectTraceContext.bind(this))
+  }
+
+  injectTraceContext (ctx) {
+    const span = this.tracer.scope().active()
+    if (!span) return
+
+    const traceContext = {}
+    this.tracer.inject(span, 'text_map', traceContext)
+    ctx.traceContext = traceContext
+  }
+}
+
+class McpToolCallPlugin extends McpPlugin {
+  static id = 'modelcontextprotocol_client'
+  static prefix = 'tracing:orchestrion:@modelcontextprotocol/sdk:Client_callTool'
+  static spanName = MCP_REQUEST_SPAN_NAME
+  static kind = 'client'
+  getResource () { return CLIENT_TOOL_CALL_RESOURCE }
+  onEnd (span, ctx) { tagErrorResult(span, ctx.result) }
+}
+
+class McpListToolsPlugin extends McpPlugin {
   static id = 'modelcontextprotocol_list_tools'
   static prefix = 'tracing:orchestrion:@modelcontextprotocol/sdk:Client_listTools'
+  static spanName = MCP_REQUEST_SPAN_NAME
+  static kind = 'client'
+  getResource () { return CLIENT_LIST_TOOLS_RESOURCE }
+}
 
-  bindStart (ctx) {
-    this.startSpan('mcp.tools.list', {
-      resource: 'tools/list',
-      type: 'mcp',
-      kind: 'client',
-    }, ctx)
+class McpListResourcesPlugin extends McpPlugin {
+  static id = 'modelcontextprotocol_list_resources'
+  static prefix = 'tracing:orchestrion:@modelcontextprotocol/sdk:Client_listResources'
+  static spanName = 'mcp.resources.list'
+  static kind = 'client'
+  getResource () { return 'resources/list' }
+}
 
-    return ctx.currentStore
+class McpReadResourcePlugin extends McpPlugin {
+  static id = 'modelcontextprotocol_read_resource'
+  static prefix = 'tracing:orchestrion:@modelcontextprotocol/sdk:Client_readResource'
+  static spanName = 'mcp.resource.read'
+  static kind = 'client'
+  getResource () { return 'resources/read' }
+}
+
+class McpListPromptsPlugin extends McpPlugin {
+  static id = 'modelcontextprotocol_list_prompts'
+  static prefix = 'tracing:orchestrion:@modelcontextprotocol/sdk:Client_listPrompts'
+  static spanName = 'mcp.prompts.list'
+  static kind = 'client'
+  getResource () { return 'prompts/list' }
+}
+
+class McpGetPromptPlugin extends McpPlugin {
+  static id = 'modelcontextprotocol_get_prompt'
+  static prefix = 'tracing:orchestrion:@modelcontextprotocol/sdk:Client_getPrompt'
+  static spanName = 'mcp.prompt.get'
+  static kind = 'client'
+  getResource () { return 'prompts/get' }
+}
+
+class McpServerRequestPlugin extends McpPlugin {
+  static id = 'modelcontextprotocol_server'
+  static prefix = 'tracing:apm:mcp:server:request'
+  static spanName = MCP_REQUEST_SPAN_NAME
+  static kind = 'server'
+  getResource (ctx) { return getServerRequestResource(ctx.request) }
+  getChildOf (ctx) {
+    const traceContext = ctx.request?.params?._meta?.[DISTRIBUTED_TRACE_META_KEY]
+    if (!traceContext || typeof traceContext !== 'object') return
+
+    const childOf = this.tracer.extract('text_map', traceContext)
+    const activeSpan = this.activeSpan
+    if (!childOf || activeSpan?.context().toTraceId() === childOf.toTraceId()) return
+
+    return childOf
   }
 
-  asyncEnd (ctx) {
-    super.finish(ctx)
+  onEnd (span, ctx) {
+    if (ctx.error) {
+      span.setTag('error', ctx.error)
+    } else {
+      tagErrorResult(span, ctx.result)
+    }
   }
 }
 
+class McpServerToolCallPlugin extends McpPlugin {
+  static id = 'modelcontextprotocol_server_tool'
+  static prefix = 'tracing:orchestrion:@modelcontextprotocol/sdk:McpServer_executeToolHandler'
+  static spanName = 'mcp.server.tool.call'
+  static kind = 'internal'
+
+  /**
+   * @param {...unknown} args Plugin constructor arguments.
+   */
+  constructor (...args) {
+    super(...args)
+    this.toolNames = new WeakMap()
+    this.addSub('apm:mcp:server:tool:registered', ({ tool, name }) => {
+      this.toolNames.set(tool, name)
+    })
+  }
+
+  getResource (ctx) { return this.toolNames.get(ctx.arguments?.[0]) }
+  onEnd (span, ctx) { tagErrorResult(span, ctx.result) }
+}
+
 module.exports = [
+  McpPropagationPlugin,
   McpToolCallPlugin,
   McpListToolsPlugin,
+  McpListResourcesPlugin,
+  McpReadResourcePlugin,
+  McpListPromptsPlugin,
+  McpGetPromptPlugin,
+  McpServerRequestPlugin,
+  McpServerToolCallPlugin,
 ]

package/packages/datadog-plugin-modelcontextprotocol-sdk/src/utils.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const { ERROR_MESSAGE, ERROR_TYPE } = require('../../dd-trace/src/constants')
+
+const DISTRIBUTED_TRACE_META_KEY = '_dd_trace_context'
+
+function getFirstTextContent (content) {
+  if (!Array.isArray(content)) return
+
+  for (const item of content) {
+    if (item.type === 'text' && item.text) return item.text
+  }
+}
+
+function setErrorTags (span, message) {
+  span.setTag('error', 1)
+  span.setTag(ERROR_TYPE, 'Error')
+  span.setTag(ERROR_MESSAGE, message)
+}
+
+function tagErrorResult (span, result) {
+  if (result?.isError) {
+    setErrorTags(span, getFirstTextContent(result.content) || 'Tool call returned isError: true')
+  }
+}
+
+module.exports = {
+  DISTRIBUTED_TRACE_META_KEY,
+  tagErrorResult,
+}

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

@@ -68,7 +68,7 @@ class PlaywrightPlugin extends CiPlugin {
     }) => {
       const testSuite = getTestSuitePath(filePath, this.repositoryRoot)
       const isModified = isModifiedTest(testSuite, 0, 0, modifiedFiles, this.constructor.id)
-      onDone({ isModified })
+      onDone(isModified)
     })
 
     this.addSub('ci:playwright:session:finish', ({

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

@@ -264,8 +264,10 @@ class VitestPlugin extends CiPlugin {
         span.setTag(TEST_EARLY_FLAKE_ABORT_REASON, earlyFlakeAbortReason)
       }
       const finish = () => {
-        if (duration) {
-          span.finish(span._startTime + duration - MILLISECONDS_TO_SUBTRACT_FROM_FAILED_TEST_DURATION) // milliseconds
+        if (Number.isFinite(duration) && duration >= 0) {
+          span.finish(
+            span._startTime + Math.max(duration - MILLISECONDS_TO_SUBTRACT_FROM_FAILED_TEST_DURATION, 0)
+          ) // milliseconds
         } else {
           span.finish() // `duration` is empty for retries, so we'll use clock time
         }

package/packages/datadog-shimmer/src/shimmer.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const { isModuleNamespaceObject } = require('node:util').types
+
 /**
  * @type {Set<string | symbol>}
  */
@@ -168,14 +170,19 @@ function wrap (target, name, wrapper, options) {
 
   copyProperties(original, wrapped)
 
-  if (descriptor.writable) {
+  const immutableModuleNamespace = descriptor.configurable === false &&
+    descriptor.writable && isModuleNamespaceObject(target)
+
+  if (descriptor.writable && !immutableModuleNamespace) {
     if (descriptor.configurable && descriptor.enumerable) {
       target[name] = wrapped
       return target
     }
     descriptor.value = wrapped
   } else {
-    if (descriptor.set && options?.replaceGetter) {
+    if (immutableModuleNamespace) {
+      descriptor.value = wrapped
+    } else if (descriptor.set && options?.replaceGetter) {
       // A lazy accessor pair (e.g. Node 20's `fs.opendir`). `original` already
       // resolved the value through the getter. Keep the property an accessor pair
       // so the shape stays observationally identical — a downstream consumer may

package/packages/dd-trace/index.electron.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./src/bootstrap')

package/packages/dd-trace/index.js

@@ -1,39 +1,4 @@
 'use strict'
 
-if (!global._ddtrace) {
-  const ddTraceSymbol = Symbol.for('dd-trace')
-
-  // Set up beforeExitHandlers before loading the tracer so that modules loaded
-  // during require('./src') can register handlers.
-  Object.defineProperty(globalThis, ddTraceSymbol, {
-    value: {
-      beforeExitHandlers: new Set(),
-    },
-    enumerable: false,
-    configurable: true,
-    writable: false,
-  })
-
-  process.once('beforeExit', function mainBeforeExit () {
-    if (globalThis[ddTraceSymbol]?.beforeExitHandlers) {
-      for (const handler of globalThis[ddTraceSymbol].beforeExitHandlers) {
-        handler()
-      }
-    }
-  })
-
-  const TracerProxy = require('./src')
-
-  Object.defineProperty(global, '_ddtrace', {
-    value: new TracerProxy(),
-    enumerable: false,
-    configurable: true,
-    writable: true,
-  })
-}
-
-module.exports = global._ddtrace
-// Static aliases so cjs-module-lexer surfaces them as ESM named exports
-// (`import { tracer } from 'dd-trace'`).
-module.exports.tracer = global._ddtrace
-module.exports.default = global._ddtrace
+require('./src/openfeature/register')
+module.exports = require('./src/bootstrap')

package/packages/dd-trace/src/appsec/channels.js

@@ -25,6 +25,7 @@ module.exports = {
   httpClientRequestStart: dc.channel('apm:http:client:request:start'),
   httpClientResponseStart: dc.channel('apm:http:client:response:start'),
   httpClientResponseFinish: dc.channel('apm:http:client:response:finish'),
+  informationalResponse: dc.channel('datadog:http:server:informational-response:start'),
   incomingHttpRequestEnd: dc.channel('dd-trace:incomingHttpRequestEnd'),
   incomingHttpRequestStart: dc.channel('dd-trace:incomingHttpRequestStart'),
   lambdaStartInvocation: dc.channel('datadog:lambda:start-invocation'),

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

@@ -29,6 +29,7 @@ const {
   responseBody,
   responseWriteHead,
   responseSetHeader,
+  informationalResponse,
   routerParam,
   fastifyResponseChannel,
   fastifyPathParams,
@@ -98,7 +99,8 @@ function enable (_config) {
     responseBody.subscribe(onResponseBody)
     fastifyResponseChannel.subscribe(onResponseBody)
     responseWriteHead.subscribe(onResponseWriteHead)
-    responseSetHeader.subscribe(onResponseSetHeader)
+    responseSetHeader.subscribe(onResponseOperation)
+    informationalResponse.subscribe(onResponseOperation)
     stripeCheckoutSessionCreate.subscribe(onStripeCheckoutSessionCreate)
     stripePaymentIntentCreate.subscribe(onStripePaymentIntentCreate)
     stripeConstructEvent.subscribe(onStripeConstructEvent)
@@ -403,7 +405,7 @@ function onResponseWriteHead ({ req, res, abortController, statusCode, responseH
   handleResults(results?.actions, req, res, rootSpan, abortController)
 }
 
-function onResponseSetHeader ({ res, abortController }) {
+function onResponseOperation ({ res, abortController }) {
   if (isBlocked(res)) {
     abortController?.abort()
   }
@@ -547,7 +549,8 @@ function disable () {
   if (responseBody.hasSubscribers) responseBody.unsubscribe(onResponseBody)
   if (fastifyResponseChannel.hasSubscribers) fastifyResponseChannel.unsubscribe(onResponseBody)
   if (responseWriteHead.hasSubscribers) responseWriteHead.unsubscribe(onResponseWriteHead)
-  if (responseSetHeader.hasSubscribers) responseSetHeader.unsubscribe(onResponseSetHeader)
+  if (responseSetHeader.hasSubscribers) responseSetHeader.unsubscribe(onResponseOperation)
+  if (informationalResponse.hasSubscribers) informationalResponse.unsubscribe(onResponseOperation)
   if (stripeCheckoutSessionCreate.hasSubscribers) stripeCheckoutSessionCreate.unsubscribe(onStripeCheckoutSessionCreate)
   if (stripePaymentIntentCreate.hasSubscribers) stripePaymentIntentCreate.unsubscribe(onStripePaymentIntentCreate)
   if (stripeConstructEvent.hasSubscribers) stripeConstructEvent.unsubscribe(onStripeConstructEvent)

package/packages/dd-trace/src/appsec/waf/waf_manager.js

@@ -42,7 +42,7 @@ class WAFManager {
       this.ddwafVersion = this.ddwafVersion || 'unknown'
       Reporter.reportWafInit(this.ddwafVersion, 'unknown')
 
-      log.error('[ASM] AppSec could not load native package. In-app WAF features will not be available.')
+      log.error('[ASM] AppSec could not load native package. In-app WAF features will not be available.', err)
 
       throw err
     }

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

@@ -0,0 +1,39 @@
+'use strict'
+
+if (!global._ddtrace) {
+  const ddTraceSymbol = Symbol.for('dd-trace')
+
+  // Set up beforeExitHandlers before loading the tracer so that modules loaded
+  // during require('./src') can register handlers.
+  Object.defineProperty(globalThis, ddTraceSymbol, {
+    value: {
+      beforeExitHandlers: new Set(),
+    },
+    enumerable: false,
+    configurable: true,
+    writable: false,
+  })
+
+  process.once('beforeExit', function mainBeforeExit () {
+    if (globalThis[ddTraceSymbol]?.beforeExitHandlers) {
+      for (const handler of globalThis[ddTraceSymbol].beforeExitHandlers) {
+        handler()
+      }
+    }
+  })
+
+  const TracerProxy = require('.')
+
+  Object.defineProperty(global, '_ddtrace', {
+    value: new TracerProxy(),
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  })
+}
+
+module.exports = global._ddtrace
+// Static aliases so cjs-module-lexer surfaces them as ESM named exports
+// (`import { tracer } from 'dd-trace'`).
+module.exports.tracer = global._ddtrace
+module.exports.default = global._ddtrace

package/packages/dd-trace/src/ci-visibility/dynamic-instrumentation/worker/index.js

@@ -51,12 +51,20 @@ const limits = {
 }
 
 /**
- * Remove empty collection arrays before sending snapshots through the Test Optimization logs path.
+ * @param {object} value - Snapshot object or sub-object.
+ * @returns {boolean}
+ */
+function isCapturedValue (value) {
+  return typeof value.type === 'string'
+}
+
+/**
+ * Remove empty capture containers before sending snapshots through the Test Optimization logs path.
  *
  * @param {object} value - Snapshot object or sub-object.
  * @returns {void}
  */
-function removeEmptyCollectionProperties (value) {
+function removeEmptyCaptureProperties (value) {
   const stack = [value]
 
   while (stack.length > 0) {
@@ -72,26 +80,25 @@ function removeEmptyCollectionProperties (value) {
       continue
     }
 
-    if (Array.isArray(current.elements)) {
-      if (current.elements.length === 0) {
+    if (isCapturedValue(current)) {
+      if (current.elements === null || (Array.isArray(current.elements) && current.elements.length === 0)) {
         delete current.elements
-      } else {
-        stack.push(current.elements)
       }
-    }
 
-    if (Array.isArray(current.entries)) {
-      if (current.entries.length === 0) {
+      if (current.entries === null || (Array.isArray(current.entries) && current.entries.length === 0)) {
         delete current.entries
-      } else {
-        stack.push(current.entries)
       }
-    }
 
-    for (const key of Object.keys(current)) {
-      if (key === 'elements' || key === 'entries') continue
+      if (current.fields === null || (
+        current.fields &&
+        typeof current.fields === 'object' &&
+        Object.keys(current.fields).length === 0
+      )) {
+        delete current.fields
+      }
+    }
 
-      const child = current[key]
+    for (const child of Object.values(current)) {
       if (child && typeof child === 'object') {
         stack.push(child)
       }
@@ -129,7 +136,7 @@ session.on('Debugger.paused', async ({ params: { hitBreakpoints: [hitBreakpoint]
       language: 'javascript',
     }
 
-    removeEmptyCollectionProperties(snapshot.captures)
+    removeEmptyCaptureProperties(snapshot.captures)
 
     if (processTags) {
       snapshot[processTags.DYNAMIC_INSTRUMENTATION_FIELD_NAME] = processTags.tagsObject

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

@@ -293,6 +293,9 @@ class CiVisibilityExporter extends BufferingExporter {
       isCoverageReportUploadEnabled,
     } = remoteConfiguration
     const { testOptimization } = this._config
+    const earlyFlakeDetectionRetryCount =
+      testOptimization.DD_TEST_EARLY_FLAKE_DETECTION_RETRY_COUNT
+    const hasEarlyFlakeDetectionRetryCount = earlyFlakeDetectionRetryCount !== undefined
     return {
       isCodeCoverageEnabled,
       isSuitesSkippingEnabled,
@@ -300,8 +303,16 @@ class CiVisibilityExporter extends BufferingExporter {
       requireGit,
       isEarlyFlakeDetectionEnabled:
         isEarlyFlakeDetectionEnabled && testOptimization.DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED,
-      earlyFlakeDetectionNumRetries,
-      earlyFlakeDetectionSlowTestRetries,
+      earlyFlakeDetectionNumRetries:
+        hasEarlyFlakeDetectionRetryCount ? earlyFlakeDetectionRetryCount : earlyFlakeDetectionNumRetries,
+      earlyFlakeDetectionSlowTestRetries: hasEarlyFlakeDetectionRetryCount
+        ? {
+            '5s': earlyFlakeDetectionRetryCount,
+            '10s': earlyFlakeDetectionRetryCount,
+            '30s': earlyFlakeDetectionRetryCount,
+            '5m': earlyFlakeDetectionRetryCount,
+          }
+        : earlyFlakeDetectionSlowTestRetries,
       earlyFlakeDetectionFaultyThreshold,
       isFlakyTestRetriesEnabled: isFlakyTestRetriesEnabled && testOptimization.DD_CIVISIBILITY_FLAKY_RETRY_ENABLED,
       flakyTestRetriesCount: testOptimization.DD_CIVISIBILITY_FLAKY_RETRY_COUNT,
@@ -318,6 +329,7 @@ class CiVisibilityExporter extends BufferingExporter {
 
   sendGitMetadata (repositoryUrl) {
     if (!this._config.testOptimization.DD_CIVISIBILITY_GIT_UPLOAD_ENABLED) {
+      this._resolveGit()
       return
     }
     this._canUseCiVisProtocolPromise.then((canUseCiVisProtocol) => {

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

@@ -102,14 +102,30 @@ class TestWorkerCiVisibilityExporter {
     this._logsWriter.append({ testEnvironmentMetadata, logMessage })
   }
 
-  // TODO: add to other writers
+  /**
+   * @param {() => void} [onDone]
+   */
   flush (onDone) {
-    this._writer.flush(onDone)
-    this._coverageWriter.flush()
-    this._logsWriter.flush()
-    if (this._telemetryWriter) {
-      this._telemetryWriter.flush()
+    if (!onDone) {
+      this._writer.flush()
+      this._coverageWriter.flush()
+      this._logsWriter.flush()
+      if (this._telemetryWriter) {
+        this._telemetryWriter.flush()
+      }
+      return
+    }
+
+    let pendingWriters = this._telemetryWriter ? 4 : 3
+    const onWriterFlushed = () => {
+      pendingWriters--
+      if (pendingWriters === 0) onDone()
     }
+
+    this._writer.flush(onWriterFlushed)
+    this._coverageWriter.flush(onWriterFlushed)
+    this._logsWriter.flush(onWriterFlushed)
+    this._telemetryWriter?.flush(onWriterFlushed)
   }
 }
 

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

@@ -15,6 +15,9 @@ class Writer {
     this._interprocessCode = interprocessCode
   }
 
+  /**
+   * @param {() => void} [onDone]
+   */
   flush (onDone) {
     const count = this._encoder.count()
 
@@ -22,6 +25,8 @@ class Writer {
       const payload = this._encoder.makePayload()
 
       this._sendPayload(payload, onDone)
+    } else {
+      onDone?.()
     }
   }