dd-trace 6.3.0 → 6.5.0

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/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/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