dd-trace 6.0.0 → 6.2.0

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

@@ -152,6 +152,11 @@ class Span extends BridgeSpanBase {
       hostname: _tracer._hostname,
       integrationName: parentTracer?._isOtelLibrary ? 'otel.library' : 'otel',
       tags: {
+        // Apply global/resource tags (DD_TAGS, OTEL_RESOURCE_ATTRIBUTES) as
+        // defaults, mirroring the native path in opentracing/tracer.js. The
+        // explicit service/resource/span.kind below take precedence, and any
+        // user-set OTel attributes applied via setAttributes() still win.
+        ..._tracer._config.tags,
         [SERVICE_NAME]: _tracer._service,
         [RESOURCE_NAME]: spanName,
         [SPAN_KIND]: spanKindNames[kind],

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

@@ -169,6 +169,10 @@ module.exports = class PluginManager {
       clientIpHeader,
       DD_TRACE_MEMCACHED_COMMAND_ENABLED,
       DD_TRACE_OTEL_SEMANTICS_ENABLED,
+      DD_TRACE_GRAPHQL_COLLAPSE,
+      DD_TRACE_GRAPHQL_DEPTH,
+      DD_TRACE_GRAPHQL_VARIABLES,
+      DD_TRACE_GRAPHQL_ERROR_EXTENSIONS,
       DD_TEST_SESSION_NAME,
       DD_AGENTLESS_LOG_SUBMISSION_ENABLED,
       testOptimization,
@@ -225,6 +229,18 @@ module.exports = class PluginManager {
       sharedConfig.middleware = middlewareTracingEnabled
     }
 
+    // The graphql `DD_TRACE_GRAPHQL_*` options are global on purpose: they feed
+    // the plugin config as a base that a programmatic `tracer.use('graphql', …)`
+    // overrides, and stay on the Config singleton so remote config and config
+    // telemetry observe them. Forwarded only for graphql so other plugins do not
+    // carry keys they ignore. The plugin-facing names drop the prefix.
+    if (name === 'graphql') {
+      sharedConfig.collapse = DD_TRACE_GRAPHQL_COLLAPSE
+      sharedConfig.depth = DD_TRACE_GRAPHQL_DEPTH
+      sharedConfig.variables = DD_TRACE_GRAPHQL_VARIABLES
+      sharedConfig.errorExtensions = DD_TRACE_GRAPHQL_ERROR_EXTENSIONS
+    }
+
     return sharedConfig
   }
 }

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

@@ -1,5 +1,11 @@
 'use strict'
 
+// Capture real timers at module load time, before any test can install fake timers.
+const realSetTimeout = setTimeout
+const realClearTimeout = clearTimeout
+
+const { threadId } = require('node:worker_threads')
+
 const { storage } = require('../../../datadog-core')
 const { COMPONENT } = require('../constants')
 const log = require('../log')
@@ -12,6 +18,7 @@ const {
 } = require('../ci-visibility/telemetry')
 const getDiClient = require('../ci-visibility/dynamic-instrumentation')
 const { DD_MAJOR } = require('../../../../version')
+const { version: tracerVersion } = require('../../../../package.json')
 const id = require('../id')
 const { OS_VERSION, OS_PLATFORM, OS_ARCHITECTURE, RUNTIME_NAME, RUNTIME_VERSION } = require('./util/env')
 const {
@@ -84,6 +91,9 @@ const {
 } = require('./util/test')
 
 const legacyStorage = storage('legacy')
+const DI_OPERATION_TIMEOUT_MS = 2000
+const DI_LOGGER_THREAD_ID = threadId === 0 ? `pid:${process.pid}` : `pid:${process.pid};tid:${threadId}`
+const DI_LOGGER_THREAD_NAME = threadId === 0 ? 'MainThread' : `WorkerThread:${threadId}`
 
 const FRAMEWORK_TO_TRIMMED_COMMAND = {
   vitest: 'vitest run',
@@ -108,6 +118,18 @@ const TEST_FRAMEWORKS_TO_SKIP_GIT_METADATA_EXTRACTION = new Set([
   'cucumber',
 ])
 
+function withTimeout (promise, timeoutMs) {
+  return new Promise(resolve => {
+    const timeoutId = realSetTimeout(resolve, timeoutMs)
+
+    const done = () => {
+      realClearTimeout(timeoutId)
+      resolve()
+    }
+    promise.then(done, done)
+  })
+}
+
 function setItrSkippingEnabledTagFromLibraryConfig (plugin, frameworkVersion) {
   const libraryCapabilitiesTags = getDefaultLibraryCapabilitiesTags(plugin.constructor.id, frameworkVersion)
 
@@ -143,6 +165,8 @@ module.exports = class CiPlugin extends Plugin {
     super(...args)
 
     this.fileLineToProbeId = new Map()
+    this.diBreakpointHitPromise = undefined
+    this.diBreakpointHitResolvers = []
     this.rootDir = process.cwd() // fallback in case :session:start events are not emitted
     this._testSuiteSpansByTestSuite = new Map()
     this._pendingWorkerTracesByTestSuite = new Map()
@@ -164,10 +188,6 @@ module.exports = class CiPlugin extends Plugin {
           setItrSkippingEnabledTagFromLibraryConfig(this, frameworkVersion)
         }
 
-        const requestErrorTags = this.testSessionSpan
-          ? getSessionRequestErrorTags(this.testSessionSpan)
-          : Object.fromEntries(this._pendingRequestErrorTags.map(({ tag, value }) => [tag, value]))
-
         const libraryCapabilitiesTags = this.getLibraryCapabilitiesTags(frameworkVersion, ctx)
         const metadataTags = {
           test: {
@@ -175,7 +195,13 @@ module.exports = class CiPlugin extends Plugin {
           },
         }
         this.tracer._exporter.addMetadataTags(metadataTags)
-        onDone({ err, libraryConfig, repositoryRoot: this.repositoryRoot, requestErrorTags })
+        onDone({
+          err,
+          isTestDynamicInstrumentationEnabled: this.config.isTestDynamicInstrumentationEnabled,
+          libraryConfig,
+          repositoryRoot: this.repositoryRoot,
+          requestErrorTags: this._getCurrentRequestErrorTags(),
+        })
       })
     })
 
@@ -307,7 +333,7 @@ module.exports = class CiPlugin extends Plugin {
             this.libraryConfig.isKnownTestsEnabled = false
           }
         }
-        onDone({ err, knownTests })
+        onDone({ err, knownTests, requestErrorTags: this._getCurrentRequestErrorTags() })
       })
     })
 
@@ -327,7 +353,7 @@ module.exports = class CiPlugin extends Plugin {
             this.libraryConfig.isTestManagementEnabled = false
           }
         }
-        onDone({ err, testManagementTests })
+        onDone({ err, testManagementTests, requestErrorTags: this._getCurrentRequestErrorTags() })
       })
     })
 
@@ -459,6 +485,18 @@ module.exports = class CiPlugin extends Plugin {
     }
   }
 
+  /**
+   * Returns the current request error tags, including tags queued before session creation.
+   *
+   * @returns {Record<string, string>}
+   */
+  _getCurrentRequestErrorTags () {
+    if (this.testSessionSpan) {
+      return getSessionRequestErrorTags(this.testSessionSpan)
+    }
+    return Object.fromEntries(this._pendingRequestErrorTags.map(({ tag, value }) => [tag, value]))
+  }
+
   /**
    * Updates repository-root-dependent state when a worker receives the root from
    * the coordinator process after plugin configuration.
@@ -776,6 +814,11 @@ module.exports = class CiPlugin extends Plugin {
   }
 
   onDiBreakpointHit ({ snapshot }) {
+    for (const resolve of this.diBreakpointHitResolvers) {
+      resolve()
+    }
+    this.diBreakpointHitResolvers.length = 0
+
     if (!this.activeTestSpan || this.activeTestSpan.context()._isFinished) {
       // This is unexpected and is caused by a race condition.
       log.warn('Breakpoint snapshot could not be attached to the active test span')
@@ -799,8 +842,17 @@ module.exports = class CiPlugin extends Plugin {
     )
 
     const activeTestSpanContext = this.activeTestSpan.context()
+    const topStackFrame = snapshot.stack?.[0]
 
     this.tracer._exporter.exportDiLogs(this.testEnvironmentMetadata, {
+      message: '',
+      logger: {
+        name: snapshot.probe.location.file,
+        method: topStackFrame?.function || '',
+        version: tracerVersion,
+        thread_id: DI_LOGGER_THREAD_ID,
+        thread_name: DI_LOGGER_THREAD_NAME,
+      },
       debugger: { snapshot },
       dd: {
         trace_id: activeTestSpanContext.toTraceId(),
@@ -809,6 +861,94 @@ module.exports = class CiPlugin extends Plugin {
     })
   }
 
+  /**
+   * Wait for a Dynamic Instrumentation operation without blocking test framework progress forever.
+   *
+   * @param {Promise<void>} promise - Dynamic Instrumentation operation promise.
+   * @returns {Promise<void>}
+   */
+  waitForDiOperation (promise) {
+    return withTimeout(promise, DI_OPERATION_TIMEOUT_MS)
+  }
+
+  /**
+   * Resolve any prepared breakpoint-hit wait when no caller still needs it.
+   */
+  cancelDiBreakpointHitWait () {
+    for (const resolve of this.diBreakpointHitResolvers) {
+      resolve()
+    }
+    this.diBreakpointHitResolvers.length = 0
+  }
+
+  /**
+   * Wait for a prepared breakpoint hit before resolving any unused waiters.
+   *
+   * @returns {Promise<void>}
+   */
+  waitForPreparedDiBreakpointHit () {
+    if (!this.diBreakpointHitPromise) {
+      this.cancelDiBreakpointHitWait()
+      return Promise.resolve()
+    }
+
+    return this.waitForDiOperation(this.diBreakpointHitPromise).then(
+      () => this.cancelDiBreakpointHitWait(),
+      () => this.cancelDiBreakpointHitWait()
+    )
+  }
+
+  /**
+   * Prepare a wait for the next breakpoint hit before the retried test starts.
+   *
+   * @returns {Promise<void>}
+   */
+  prepareDiBreakpointHitWait () {
+    if (!this.di) return Promise.resolve()
+
+    let resolveHit
+    const hitPromise = new Promise(resolve => {
+      resolveHit = resolve
+      this.diBreakpointHitResolvers.push(resolve)
+    })
+
+    const preparedPromise = hitPromise.finally(() => {
+      const resolverIndex = this.diBreakpointHitResolvers.indexOf(resolveHit)
+      if (resolverIndex !== -1) {
+        this.diBreakpointHitResolvers.splice(resolverIndex, 1)
+      }
+      if (this.diBreakpointHitPromise === preparedPromise) {
+        this.diBreakpointHitPromise = undefined
+      }
+    })
+
+    this.diBreakpointHitPromise = preparedPromise
+    return this.diBreakpointHitPromise
+  }
+
+  /**
+   * Wait until the DI worker has posted any breakpoint hits it was already processing.
+   *
+   * @returns {Promise<void>}
+   */
+  waitForDiBreakpointHits () {
+    if (!this.di) return Promise.resolve()
+    if (this.diBreakpointHitPromise) return this.waitForDiOperation(this.diBreakpointHitPromise)
+
+    return this.waitForInFlightDiBreakpointHits()
+  }
+
+  /**
+   * Wait until the DI worker has posted breakpoint hits it was already processing.
+   *
+   * @returns {Promise<void>}
+   */
+  waitForInFlightDiBreakpointHits () {
+    if (!this.di) return Promise.resolve()
+
+    return this.waitForDiOperation(this.di.waitForInFlightBreakpointHits())
+  }
+
   removeAllDiProbes () {
     if (this.fileLineToProbeId.size === 0) {
       return Promise.resolve()

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const plugins = {
+  get '@anthropic-ai/claude-agent-sdk' () { return require('../../../datadog-plugin-claude-agent-sdk/src') },
   get '@anthropic-ai/sdk' () { return require('../../../datadog-plugin-anthropic/src') },
   get '@apollo/gateway' () { return require('../../../datadog-plugin-apollo/src') },
   get '@aws-sdk/smithy-client' () { return require('../../../datadog-plugin-aws-sdk/src') },
@@ -46,6 +47,7 @@ const plugins = {
   get bunyan () { return require('../../../datadog-plugin-bunyan/src') },
   get 'cassandra-driver' () { return require('../../../datadog-plugin-cassandra-driver/src') },
   get child_process () { return require('../../../datadog-plugin-child_process/src') },
+  get 'claude-agent-sdk' () { return require('../../../datadog-plugin-claude-agent-sdk/src') },
   get connect () { return require('../../../datadog-plugin-connect/src') },
   get couchbase () { return require('../../../datadog-plugin-couchbase/src') },
   get cypress () { return require('../../../datadog-plugin-cypress/src') },
@@ -82,6 +84,9 @@ const plugins = {
   get langchain () { return require('../../../datadog-plugin-langchain/src') },
   get mariadb () { return require('../../../datadog-plugin-mariadb/src') },
   get memcached () { return require('../../../datadog-plugin-memcached/src') },
+  // mercurius is traced under the graphql plugin: its instrumentation opens the
+  // top-level graphql.request span handled by the graphql CompositePlugin.
+  get mercurius () { return require('../../../datadog-plugin-graphql/src') },
   get 'microgateway-core' () { return require('../../../datadog-plugin-microgateway-core/src') },
   get mocha () { return require('../../../datadog-plugin-mocha/src') },
   get 'mocha-each' () { return require('../../../datadog-plugin-mocha/src') },

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

@@ -95,6 +95,8 @@ const TEST_IS_RUM_ACTIVE = 'test.is_rum_active'
 const TEST_CODE_OWNERS = 'test.codeowners'
 const TEST_SOURCE_FILE = 'test.source.file'
 const TEST_SOURCE_START = 'test.source.start'
+const TEST_FAILURE_SCREENSHOT_UPLOADED = 'test.failure_screenshot.uploaded'
+const TEST_FAILURE_SCREENSHOT_UPLOAD_ERROR = 'test.failure_screenshot.upload_error'
 const LIBRARY_VERSION = 'library_version'
 const TEST_COMMAND = 'test.command'
 const TEST_MODULE = 'test.module'
@@ -433,6 +435,8 @@ module.exports = {
   TEST_SKIP_REASON,
   TEST_IS_RUM_ACTIVE,
   TEST_SOURCE_FILE,
+  TEST_FAILURE_SCREENSHOT_UPLOADED,
+  TEST_FAILURE_SCREENSHOT_UPLOAD_ERROR,
   CI_APP_ORIGIN,
   LIBRARY_VERSION,
   JEST_WORKER_TRACE_PAYLOAD_CODE,

package/packages/dd-trace/src/profiling/exporters/agent.js

@@ -42,6 +42,19 @@ function sendRequest (options, form, callback) {
   storage('legacy').run({ noop: true }, () => {
     requestCounter.inc()
     const start = perf.now()
+
+    // Ensure the callback runs at most once per request. The 'timeout' handler
+    // below can fire after a response was already received (e.g. on a lingering
+    // keep-alive socket, once it goes idle); without this guard that would
+    // invoke the callback a second time and corrupt the retry accounting in
+    // AgentExporter.export.
+    let settled = false
+    const done = (err, res) => {
+      if (settled) return
+      settled = true
+      callback(err, res)
+    }
+
     const req = request(options, res => {
       durationDistribution.track(perf.now() - start)
       countStatusCode(res.statusCode)
@@ -49,16 +62,28 @@ function sendRequest (options, form, callback) {
         statusCodeErrorCounter.inc()
         const error = new Error(`HTTP Error ${res.statusCode}`)
         error.status = res.statusCode
-        callback(error)
+        done(error)
       } else {
-        callback(null, res)
+        done(null, res)
       }
     })
 
     req.on('error', (err) => {
       networkErrorCounter.inc()
-      callback(err)
+      done(err)
     })
+
+    // `options.timeout` sets the socket's idle timeout, which only emits a
+    // 'timeout' event — per the Node docs it does NOT abort the request. Without
+    // destroying the socket here, a stalled upload hangs indefinitely: no
+    // 'error' fires, so the retry/backoff in AgentExporter.export never runs and
+    // the export promise never settles. Destroying the request makes the
+    // 'error' handler above run, which drives the retry (see the trace exporter
+    // in ../common/request.js, which likewise aborts the request on timeout).
+    req.on('timeout', () => {
+      req.destroy(new Error(`Profiling agent export timed out after ${options.timeout}ms`))
+    })
+
     if (form) {
       sizeDistribution.track(form.size())
       form.pipe(req)

package/packages/dd-trace/src/service-naming/schemas/v0/graphql.js

@@ -8,6 +8,12 @@ const graphql = {
       opName: () => 'graphql.execute',
       serviceName: identityService,
     },
+    // Top-level request span for drivers that funnel through a single entry
+    // point (mercurius). Matches the cross-tracer `graphql.request` v0 name.
+    request: {
+      opName: () => 'graphql.request',
+      serviceName: identityService,
+    },
   },
 }
 

package/packages/dd-trace/src/service-naming/schemas/v1/graphql.js

@@ -8,6 +8,14 @@ const graphql = {
       opName: () => 'graphql.server.request',
       serviceName: identityService,
     },
+    // Top-level request span for drivers that funnel through a single entry
+    // point (mercurius). Matches the cross-tracer `graphql.server.request` v1
+    // name. The v1 overlap with the execute span's name above is a known wart
+    // tracked for a separate cross-tracer unification (breaking) change.
+    request: {
+      opName: () => 'graphql.server.request',
+      serviceName: identityService,
+    },
   },
 }
 

package/vendor/dist/@apm-js-collab/code-transformer/index.js

@@ -8,7 +8,7 @@
     const __apm$${T} = this["${T}"]
     this["${T}"] = function () {}
     if (typeof __apm$${T} === 'function') {
-      Object.defineProperty(this["${T}"], 'length', { 
+      Object.defineProperty(this["${T}"], 'length', {
         value: __apm$${T}.length,
         configurable: true
       })
@@ -94,7 +94,7 @@
           if (typeof promise?.then !== 'function') {
             __apm$ctx.result = promise;
             ${k}
-            return promise;
+            return __apm$ctx.result;
           }
           // Mirror Node.js core diagnostics_channel behaviour: for native Promise
           // instances, chain normally (safe since there is no subclass API to
@@ -109,7 +109,7 @@
                 ${k}
                 ${w}.asyncStart.publish(__apm$ctx);
                 ${w}.asyncEnd.publish(__apm$ctx);
-                return result;
+                return __apm$ctx.result;
               },
               err => {
                 __apm$ctx.error = err;
@@ -151,10 +151,8 @@
 
       return ${w}.start.runStores(__apm$ctx, () => {
         try {
-          const result = __apm$traced();
-          __apm$ctx.result = result;
+          __apm$ctx.result = __apm$traced();
           ${k}
-          return result;
         } catch (err) {
           __apm$ctx.error = err;
           ${w}.error.publish(__apm$ctx);
@@ -163,6 +161,7 @@
          __apm$ctx.self ??= this;
           ${w}.end.publish(__apm$ctx);
         }
+        return __apm$ctx.result;
       });
     }
   `)}function declareIteratorChannel(i,s){let{channelName:k,module:{name:S}}=i,w=formatChannelVariable(k+":next");if(s.body.some(i=>i.declarations?.[0]?.id?.name===w))return;let C=formatChannelVariable(k),T=s.body.findIndex(i=>i.declarations?.[0]?.id?.name===C),_=`const ${w} = tr_ch_apm_tracingChannel("orchestrion:${S}:${k}:next")`;s.body.splice(T+1,0,E(_).body[0])}function generateIterPatch(i,s,k){let{channelName:S}=i,E=formatChannelVariable(S+":next");return declareIteratorChannel(i,k),`