dd-trace 6.0.0 → 6.1.0

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') },

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)