dd-trace 6.4.0 → 6.6.0

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

@@ -4,27 +4,12 @@ const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
 const { storage } = require('../../datadog-core')
 
 const {
-  TEST_IS_RUM_ACTIVE,
+  setRumTestCorrelation,
   TEST_BROWSER_DRIVER,
   TEST_BROWSER_DRIVER_VERSION,
   TEST_BROWSER_NAME,
-  TEST_BROWSER_VERSION,
   TEST_TYPE,
 } = require('../../dd-trace/src/plugins/util/test')
-const { SPAN_TYPE } = require('../../../ext/tags')
-
-function isTestSpan (span) {
-  return span.context().getTag(SPAN_TYPE) === 'test'
-}
-
-function getTestSpanFromTrace (trace) {
-  for (const span of trace.started) {
-    if (isTestSpan(span)) {
-      return span
-    }
-  }
-  return null
-}
 
 class SeleniumPlugin extends CiPlugin {
   static id = 'selenium'
@@ -32,32 +17,16 @@ class SeleniumPlugin extends CiPlugin {
   constructor (...args) {
     super(...args)
 
-    this.addSub('ci:selenium:driver:get', ({
-      setTraceId,
-      seleniumVersion,
-      browserName,
-      browserVersion,
-      isRumActive,
-    }) => {
-      const store = storage('legacy').getStore()
-      const span = store?.span
-      if (!span) {
-        return
-      }
-      const testSpan = isTestSpan(span) ? span : getTestSpanFromTrace(span.context()._trace)
+    this.addSub('ci:selenium:driver:get', (ctx) => {
+      const { seleniumVersion, browserName } = ctx
+      const activeSpan = storage('legacy').getStore()?.span
+      const testSpan = setRumTestCorrelation(ctx, activeSpan)
       if (!testSpan) {
         return
       }
-      if (setTraceId) {
-        setTraceId(testSpan.context().toTraceId())
-      }
-      if (isRumActive) {
-        testSpan.setTag(TEST_IS_RUM_ACTIVE, 'true')
-      }
       testSpan.setTag(TEST_BROWSER_DRIVER, 'selenium')
       testSpan.setTag(TEST_BROWSER_DRIVER_VERSION, seleniumVersion)
       testSpan.setTag(TEST_BROWSER_NAME, browserName)
-      testSpan.setTag(TEST_BROWSER_VERSION, browserVersion)
       testSpan.setTag(TEST_TYPE, 'browser')
     })
   }

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

@@ -400,7 +400,7 @@ class VitestPlugin extends CiPlugin {
       return ctx.currentStore
     })
 
-    this.addSub('ci:vitest:test-suite:finish', ({ testSuiteSpan, status, deferFlush, onFinish }) => {
+    this.addSub('ci:vitest:test-suite:finish', ({ testSuiteSpan, status, deferFlush, onDone }) => {
       if (testSuiteSpan) {
         testSuiteSpan.setTag(TEST_STATUS, status)
         testSuiteSpan.finish()
@@ -408,10 +408,10 @@ class VitestPlugin extends CiPlugin {
       }
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
       if (deferFlush) {
-        onFinish()
+        onDone()
         return
       }
-      this.tracer._exporter.flush(onFinish)
+      this.tracer._exporter.flush(onDone)
       if (this.runningTestProbe) {
         this.removeDiProbe(this.runningTestProbe)
       }
@@ -442,7 +442,7 @@ class VitestPlugin extends CiPlugin {
       requestErrorTags,
       vitestPool,
       isVitestNoWorkerInitActive,
-      onFinish,
+      onDone,
     }) => {
       for (const [tag, value] of Object.entries(requestErrorTags || {})) {
         this.testSessionSpan.setTag(tag, value)
@@ -481,7 +481,7 @@ class VitestPlugin extends CiPlugin {
         provider: this.ciProviderName,
         autoInjected: !!this._tracerConfig.testOptimization.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
       })
-      this.tracer._exporter.flush(onFinish)
+      this.tracer._exporter.flush(onDone)
     })
 
     this.addSub('ci:vitest:coverage-report', ({ rootDir, onDone }) => {

package/packages/datadog-plugin-ws/src/close.js

@@ -6,6 +6,7 @@ const {
   SPAN_POINTER_DIRECTION,
   SPAN_POINTER_DIRECTION_NAME,
 } = require('../../dd-trace/src/constants')
+const { getSegment } = require('../../dd-trace/src/util')
 const {
   incrementWebSocketCounter,
   buildWebSocketSpanPointerHash,
@@ -29,7 +30,7 @@ class WSClosePlugin extends TracingPlugin {
 
     const spanKind = isPeerClose ? 'consumer' : 'producer'
     const spanTags = socket.spanTags
-    const path = spanTags['resource.name'].split(' ')[1]
+    const path = getSegment(spanTags['resource.name'], ' ', 1)
     const service = this.serviceName({ pluginConfig: this.config })
     const span = this.startSpan(this.operationName(), {
       service,

package/packages/datadog-plugin-ws/src/producer.js

@@ -6,6 +6,7 @@ const {
   SPAN_POINTER_DIRECTION,
   SPAN_POINTER_DIRECTION_NAME,
 } = require('../../dd-trace/src/constants')
+const { getSegment } = require('../../dd-trace/src/util')
 const {
   incrementWebSocketCounter,
   buildWebSocketSpanPointerHash,
@@ -23,7 +24,7 @@ class WSProducerPlugin extends TracingPlugin {
     if (!socket.spanContext) return
 
     const spanTags = socket.spanTags
-    const path = spanTags['resource.name'].split(' ')[1]
+    const path = getSegment(spanTags['resource.name'], ' ', 1)
     const opCode = binary ? 'binary' : 'text'
     const service = this.serviceName({ pluginConfig: this.config })
     const span = this.startSpan(this.operationName(), {

package/packages/datadog-plugin-ws/src/receiver.js

@@ -6,6 +6,7 @@ const {
   SPAN_POINTER_DIRECTION,
   SPAN_POINTER_DIRECTION_NAME,
 } = require('../../dd-trace/src/constants')
+const { getSegment } = require('../../dd-trace/src/util')
 const {
   incrementWebSocketCounter,
   buildWebSocketSpanPointerHash,
@@ -28,7 +29,7 @@ class WSReceiverPlugin extends TracingPlugin {
     if (!socket.spanContext) return
 
     const spanTags = socket.spanTags
-    const path = spanTags['resource.name'].split(' ')[1]
+    const path = getSegment(spanTags['resource.name'], ' ', 1)
     const opCode = binary ? 'binary' : 'text'
 
     const service = this.serviceName({ pluginConfig: this.config })

package/packages/datadog-plugin-ws/src/server.js

@@ -3,6 +3,7 @@
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing.js')
 const tags = require('../../../ext/tags.js')
 const { HTTP_HEADERS } = require('../../../ext/formats')
+const { getSegment } = require('../../dd-trace/src/util')
 const {
   createWebSocketSpanContext,
   hasTraceHeaders,
@@ -94,7 +95,7 @@ function getRequestProtocol (req, fallback = 'ws') {
 
   // 2. Check for a trusted header set by a proxy
   if (req.headers && req.headers['x-forwarded-proto']) {
-    const proto = req.headers['x-forwarded-proto'].split(',')[0].trim()
+    const proto = getSegment(req.headers['x-forwarded-proto'], ',', 0).trim()
     if (proto === 'https') return 'wss'
     if (proto === 'http') return 'ws'
   }

package/packages/dd-trace/src/aiguard/sdk.js

@@ -230,7 +230,7 @@ class AIGuard extends NoopAIGuard {
     // still applies for SDK callers that don't supply an explicit parent.
     const traceOpts = childOf ? { childOf } : {}
     return this.#tracer.trace(TAGS.RESOURCE, traceOpts, async (span) => {
-      const last = messages[messages.length - 1]
+      const last = messages.at(-1)
       const target = this.#isToolCall(last) ? 'tool' : 'prompt'
       span.setTag(TAGS.TARGET_TAG_KEY, target)
       if (target === 'tool') {

package/packages/dd-trace/src/appsec/iast/taint-tracking/plugin.js

@@ -190,7 +190,7 @@ class TaintTrackingPlugin extends SourceIastPlugin {
   }
 
   addURLParsingSubscriptions () {
-    const urlResultTaintedProperties = ['host', 'origin', 'hostname']
+    const urlResultTaintedProperties = new Set(['host', 'origin', 'hostname'])
     this.addSub(
       { channelName: 'datadog:url:parse:finish' },
       ({ input, base, parsed, isURL }) => {
@@ -212,7 +212,7 @@ class TaintTrackingPlugin extends SourceIastPlugin {
     this.addSub(
       { channelName: 'datadog:url:getter:finish' },
       (context) => {
-        if (!urlResultTaintedProperties.includes(context.property)) return
+        if (!urlResultTaintedProperties.has(context.property)) return
 
         const origRange = this._taintedURLs.get(context.urlObject)
         if (!origRange) return

package/packages/dd-trace/src/appsec/iast/telemetry/span-tags.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const { getSegment } = require('../../../util')
+
 function addMetricsToSpan (rootSpan, metrics, tagPrefix) {
   if (!rootSpan?.addTags || !metrics) return
 
@@ -44,7 +46,7 @@ function filterTags (tags) {
 }
 
 function processTagValue (tags) {
-  return tags.map(tag => tag.includes(':') ? tag.split(':')[1] : tag)
+  return tags.map(tag => tag.includes(':') ? getSegment(tag, ':', 1) : tag)
     .join('_').replaceAll('.', '_')
 }
 

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

@@ -6,10 +6,11 @@ const os = require('os')
 const getConfig = require('./config')
 const { getEnvironmentVariable } = require('./config/helper')
 const { getIsAzureFunction } = require('./serverless')
+const { getSegment } = require('./util')
 
 function extractSubscriptionID (ownerName) {
   if (ownerName !== undefined) {
-    const subId = ownerName.split('+')[0].trim()
+    const subId = getSegment(ownerName, '+', 0).trim()
     if (subId.length > 0) {
       return subId
     }

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

@@ -7,11 +7,25 @@ const log = require('../../log')
 const { getEnvironmentVariables } = require('../../config/helper')
 const getDebuggerConfig = require('../../debugger/config')
 
-const probeIdToResolveBreakpointSet = new Map()
-const probeIdToResolveBreakpointRemove = new Map()
 const drainRequestIdToResolveBreakpointHit = new Map()
 
+/**
+ * @typedef {object} ProbeState
+ * @property {string} locationKey
+ * @property {(breakpoint: object) => void} onHitBreakpoint
+ * @property {Promise<void>|undefined} removePromise
+ * @property {(() => void)|undefined} resolveRemove
+ * @property {(() => void)|undefined} resolveSet
+ * @property {Promise<void>} setPromise
+ * @property {boolean} setPosted
+ */
+
 class TestVisDynamicInstrumentation {
+  /** @type {Map<string, Promise<void>>} */
+  #pendingProbeRemovalByLocation = new Map()
+  /** @type {Map<string, ProbeState>} */
+  #probeStateById = new Map()
+
   /**
    * @param {import('../../config/config-base')} config - Tracer configuration
    */
@@ -24,37 +38,88 @@ class TestVisDynamicInstrumentation {
     this.breakpointSetChannel = new MessageChannel()
     this.breakpointHitChannel = new MessageChannel()
     this.breakpointRemoveChannel = new MessageChannel()
-    this.onHitBreakpointByProbeId = new Map()
   }
 
+  /**
+   * @param {string|undefined} probeId
+   */
   removeProbe (probeId) {
-    return new Promise(resolve => {
-      this.breakpointRemoveChannel.port2.postMessage(probeId)
+    const probeState = probeId === undefined ? undefined : this.#probeStateById.get(probeId)
+    if (!probeState) return Promise.resolve()
+    if (probeState.removePromise) return probeState.removePromise
+
+    if (!probeState.setPosted) {
+      this.#probeStateById.delete(probeId)
+      probeState.resolveSet?.()
+      probeState.resolveSet = undefined
+      return Promise.resolve()
+    }
 
-      probeIdToResolveBreakpointRemove.set(probeId, resolve)
+    const postRemoval = () => new Promise(resolve => {
+      probeState.resolveRemove = resolve
+      this.breakpointRemoveChannel.port2.postMessage(probeId)
+    })
+    const removeAcknowledgedPromise = probeState.setPromise.then(postRemoval)
+    const removePromise = removeAcknowledgedPromise.then(() => this.waitForInFlightBreakpointHits())
+    probeState.removePromise = removePromise
+    this.#pendingProbeRemovalByLocation.set(probeState.locationKey, removeAcknowledgedPromise)
+    removeAcknowledgedPromise.then(() => {
+      if (this.#pendingProbeRemovalByLocation.get(probeState.locationKey) === removeAcknowledgedPromise) {
+        this.#pendingProbeRemovalByLocation.delete(probeState.locationKey)
+      }
     })
+    removePromise.then(() => {
+      if (this.#probeStateById.get(probeId) === probeState) {
+        this.#probeStateById.delete(probeId)
+      }
+    })
+    return removePromise
   }
 
-  // Return 2 elements:
-  // 1. Probe ID
-  // 2. Promise that's resolved when the breakpoint is set
+  /**
+   * @param {{ file: string, line: number }} location
+   * @param {(breakpoint: object) => void} onHitBreakpoint
+   */
   addLineProbe ({ file, line }, onHitBreakpoint) {
     if (!this.worker) { // not init yet
       this.start()
     }
     const probeId = randomUUID()
+    const locationKey = `${file}:${line}`
+    const pendingRemoval = this.#pendingProbeRemovalByLocation.get(locationKey)
 
-    this.breakpointSetChannel.port2.postMessage(
-      { id: probeId, file, line }
-    )
-
-    this.onHitBreakpointByProbeId.set(probeId, onHitBreakpoint)
+    let resolveSet
+    const setProbePromise = new Promise(resolve => {
+      resolveSet = resolve
+    })
+    const probeState = {
+      locationKey,
+      onHitBreakpoint,
+      removePromise: undefined,
+      resolveRemove: undefined,
+      resolveSet,
+      setPromise: setProbePromise,
+      setPosted: false,
+    }
+    this.#probeStateById.set(probeId, probeState)
+
+    const setProbe = () => {
+      if (this.#probeStateById.get(probeId) === probeState) {
+        probeState.setPosted = true
+        this.breakpointSetChannel.port2.postMessage(
+          { id: probeId, file, line }
+        )
+      }
+    }
+    if (pendingRemoval) {
+      pendingRemoval.then(setProbe)
+    } else {
+      setProbe()
+    }
 
     return [
       probeId,
-      new Promise(resolve => {
-        probeIdToResolveBreakpointSet.set(probeId, resolve)
-      }),
+      setProbePromise,
     ]
   }
 
@@ -139,10 +204,10 @@ class TestVisDynamicInstrumentation {
     this.worker.unref?.()
 
     this.breakpointSetChannel.port2.on('message', (probeId) => {
-      const resolve = probeIdToResolveBreakpointSet.get(probeId)
-      if (resolve) {
-        resolve()
-        probeIdToResolveBreakpointSet.delete(probeId)
+      const probeState = this.#probeStateById.get(probeId)
+      if (probeState?.resolveSet) {
+        probeState.resolveSet()
+        probeState.resolveSet = undefined
       }
     }).unref?.()
 
@@ -157,19 +222,19 @@ class TestVisDynamicInstrumentation {
       }
 
       const { probe: { id: probeId } } = snapshot
-      const onHit = this.onHitBreakpointByProbeId.get(probeId)
-      if (onHit) {
-        onHit({ snapshot })
+      const probeState = this.#probeStateById.get(probeId)
+      if (probeState) {
+        probeState.onHitBreakpoint({ snapshot })
       } else {
         log.warn('Received a breakpoint hit for an unknown probe')
       }
     }).unref?.()
 
     this.breakpointRemoveChannel.port2.on('message', (probeId) => {
-      const resolve = probeIdToResolveBreakpointRemove.get(probeId)
-      if (resolve) {
-        resolve()
-        probeIdToResolveBreakpointRemove.delete(probeId)
+      const probeState = this.#probeStateById.get(probeId)
+      if (probeState?.resolveRemove) {
+        probeState.resolveRemove()
+        probeState.resolveRemove = undefined
       }
     }).unref?.()
   }

package/packages/dd-trace/src/ci-visibility/early-flake-detection/get-known-tests.js

@@ -60,7 +60,7 @@ function parseJsonResponse (rawJson) {
 function parseKnownTestsResponse (rawJson, options = {}) {
   const parsedResponse = parseJsonResponse(rawJson)
   if (options.validateRequiredFields) {
-    validateKnownTestsResponse(parsedResponse)
+    validateKnownTestsResponse(parsedResponse, options)
   }
   const { data: { attributes: { tests } } } = parsedResponse
   return tests

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

@@ -0,0 +1,160 @@
+'use strict'
+
+/* eslint-disable eslint-rules/eslint-process-env */
+
+const TestOptimizationHttpCache = require('../../test-optimization-http-cache').TestOptimizationHttpCache
+const CiVisibilityExporter = require('../ci-visibility-exporter')
+const { CiValidationSink } = require('./sink')
+const CiValidationWriter = require('./writer')
+
+const VALIDATION_MANIFEST_ENV = '_DD_TEST_OPTIMIZATION_VALIDATION_MANIFEST_FILE'
+const VALIDATION_OUTPUT_ENV = '_DD_TEST_OPTIMIZATION_VALIDATION_OUTPUT_DIR'
+const VALIDATION_CAPTURE_MODE_ENV = '_DD_TEST_OPTIMIZATION_VALIDATION_CAPTURE_MODE'
+
+class CiValidationExporter extends CiVisibilityExporter {
+  /**
+   * Creates an immediately available cache-only Test Optimization exporter.
+   *
+   * @param {object} config tracer configuration
+   */
+  constructor (config) {
+    const validationManifestPath = process.env[VALIDATION_MANIFEST_ENV]
+    const validationOutputRoot = process.env[VALIDATION_OUTPUT_ENV]
+    if (!validationManifestPath) {
+      throw new Error('Offline Test Optimization validation requires an explicit private manifest path.')
+    }
+    if (!validationOutputRoot) {
+      throw new Error('Offline Test Optimization validation requires an explicit private output root.')
+    }
+    const cache = new TestOptimizationHttpCache({
+      validationManifestPath,
+    })
+    super(config, { cacheOnly: true, testOptimizationHttpCache: cache })
+
+    this._sink = new CiValidationSink(validationOutputRoot, {
+      captureMode: process.env[VALIDATION_CAPTURE_MODE_ENV] || 'strict',
+    })
+    this._writer = new CiValidationWriter({ sink: this._sink, tags: config.tags })
+    this._isInitialized = true
+    this._isGzipCompatible = false
+    this._resolveCanUseCiVisProtocol(true)
+    this._resolveGit()
+    this.exportUncodedTraces()
+
+    this._finalizeValidation = () => this.flush(() => this._sink.writeSummary())
+    globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(this._finalizeValidation)
+    process.once('exit', this._finalizeValidation)
+  }
+
+  /**
+   * Loads library settings from the validator-controlled cache.
+   *
+   * @param {object} testConfiguration test configuration identity
+   * @param {Function} callback completion callback
+   */
+  getLibraryConfiguration (testConfiguration, callback) {
+    super.getLibraryConfiguration(testConfiguration, (err, configuration) => {
+      this._sink.writeInputResult('settings', err)
+      if (err) process.exitCode = 1
+      callback(err, configuration)
+    })
+  }
+
+  /**
+   * Loads known tests from the validator-controlled cache.
+   *
+   * @param {object} testConfiguration test configuration identity
+   * @param {Function} callback completion callback
+   */
+  getKnownTests (testConfiguration, callback) {
+    super.getKnownTests(testConfiguration, (err, tests) => {
+      this._sink.writeInputResult('known_tests', err)
+      if (err) process.exitCode = 1
+      callback(err, tests)
+    })
+  }
+
+  /**
+   * Loads skippable suites from the validator-controlled cache.
+   *
+   * @param {object} testConfiguration test configuration identity
+   * @param {Function} callback completion callback
+   */
+  getSkippableSuites (testConfiguration, callback) {
+    super.getSkippableSuites(testConfiguration, (err, suites, correlationId, coverage) => {
+      this._sink.writeInputResult('skippable_tests', err)
+      if (err) process.exitCode = 1
+      callback(err, suites, correlationId, coverage)
+    })
+  }
+
+  /**
+   * Loads managed tests from the validator-controlled cache.
+   *
+   * @param {object} testConfiguration test configuration identity
+   * @param {Function} callback completion callback
+   */
+  getTestManagementTests (testConfiguration, callback) {
+    super.getTestManagementTests(testConfiguration, (err, tests) => {
+      this._sink.writeInputResult('test_management', err)
+      if (err) process.exitCode = 1
+      callback(err, tests)
+    })
+  }
+
+  /**
+   * Resolves the inherited git-upload gate without performing an upload.
+   *
+   * @returns {void}
+   */
+  sendGitMetadata () {
+    this._resolveGit()
+  }
+
+  /**
+   * Drops debugger logs in offline validation mode.
+   *
+   * @returns {void}
+   */
+  exportDiLogs () {}
+
+  /**
+   * Reports that code coverage is outside the offline validator's scope.
+   *
+   * @returns {boolean} always false
+   */
+  canReportCodeCoverage () {
+    return false
+  }
+
+  /**
+   * Rejects coverage report upload in offline validation mode.
+   *
+   * @param {object} options ignored upload options
+   * @param {Function} callback completion callback
+   */
+  uploadCoverageReport (options, callback) {
+    callback(new Error('Coverage report upload is disabled during offline Test Optimization validation.'))
+  }
+
+  /**
+   * Reports that screenshot upload is unavailable.
+   *
+   * @returns {boolean} always false
+   */
+  canUploadTestScreenshots () {
+    return false
+  }
+
+  /**
+   * Rejects screenshot upload in offline validation mode.
+   *
+   * @param {object} options ignored upload options
+   * @param {Function} callback completion callback
+   */
+  uploadTestScreenshot (options, callback) {
+    callback(new Error('Screenshot upload is disabled during offline Test Optimization validation.'))
+  }
+}
+
+module.exports = CiValidationExporter