dd-trace 6.9.0 → 6.11.0

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

@@ -0,0 +1,356 @@
+'use strict'
+
+/** @typedef {Record<string, unknown>} Carrier */
+/** @typedef {string | Buffer} PathwayValue */
+
+const FIELD_READ = 1
+const FIELD_WRITE = 2
+const FIELD_HAS = 4
+const FIELD_DELETE = 8
+const FIELD_NAME_LENGTH = 16
+
+/** @type {Record<string, unknown>} */
+const carrierOperations = {}
+
+/**
+ * @typedef {object} CarrierCapability
+ * @property {unknown} [read]
+ * @property {unknown} [write]
+ * @property {unknown} [has]
+ * @property {unknown} [delete]
+ * @property {unknown} [nameLength]
+ */
+
+/**
+ * @template Value
+ * @typedef {object} CarrierField
+ * @property {(carrier: Carrier) => Value | undefined} read
+ * @property {(carrier: Carrier, value: Value) => void} write
+ * @property {(carrier: Carrier) => boolean} has
+ * @property {(carrier: Carrier) => void} delete
+ * @property {(carrier: Carrier, target: Carrier) => void} copy
+ * @property {number} nameLength
+ */
+
+/**
+ * @template {CarrierCapability} Capability
+ * @param {string} name
+ * @param {number} operations
+ * @param {Capability} capability
+ * @returns {Capability}
+ */
+function defineCapability (name, operations, capability) {
+  const suffix = name[0].toUpperCase() + name.slice(1)
+  if (operations & FIELD_READ) carrierOperations[`read${suffix}`] = capability.read
+  if (operations & FIELD_WRITE) carrierOperations[`write${suffix}`] = capability.write
+  if (operations & FIELD_HAS) carrierOperations[`has${suffix}`] = capability.has
+  if (operations & FIELD_DELETE) carrierOperations[`delete${suffix}`] = capability.delete
+  if (operations & FIELD_NAME_LENGTH) carrierOperations[`${name}NameLength`] = capability.nameLength
+  return capability
+}
+
+/**
+ * @template Value
+ * @param {string} fieldName
+ * @param {string} headerName
+ * @param {(value: unknown) => Value | undefined} resolve
+ * @param {number} operations
+ * @returns {CarrierField<Value>}
+ */
+function defineField (fieldName, headerName, resolve, operations) {
+  return defineCapability(fieldName, operations, {
+    /**
+     * @param {Carrier} carrier
+     * @returns {Value | undefined}
+     */
+    read (carrier) {
+      return resolve(carrier[headerName])
+    },
+
+    /**
+     * @param {Carrier} carrier
+     * @param {Value} value
+     * @returns {void}
+     */
+    write (carrier, value) {
+      carrier[headerName] = value
+    },
+
+    /**
+     * @param {Carrier} carrier
+     * @returns {boolean}
+     */
+    has (carrier) {
+      return headerName in carrier
+    },
+
+    /**
+     * @param {Carrier} carrier
+     * @returns {void}
+     */
+    delete (carrier) {
+      delete carrier[headerName]
+    },
+
+    /**
+     * @param {Carrier} carrier
+     * @param {Carrier} target
+     * @returns {void}
+     */
+    copy (carrier, target) {
+      if (Object.hasOwn(carrier, headerName)) target[headerName] = carrier[headerName]
+    },
+
+    nameLength: headerName.length,
+  })
+}
+
+/**
+ * Skipping non-strings keeps a Symbol or a throwing `toString` from aborting
+ * extraction, which discards the whole context rather than one field.
+ *
+ * @param {unknown} value
+ * @returns {string | undefined}
+ */
+function readListText (value) {
+  if (typeof value === 'string') return value
+  if (!Array.isArray(value)) return
+
+  let joined = ''
+  let first = true
+
+  for (const item of value) {
+    if (typeof item !== 'string') continue
+    if (first) {
+      joined = item
+      first = false
+    } else {
+      joined += `,${item}`
+    }
+  }
+
+  return joined
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string | undefined}
+ */
+function readLastText (value) {
+  if (typeof value === 'string') return value
+  if (!Array.isArray(value)) return
+
+  let result
+  for (let i = value.length - 1; i >= 0; i--) {
+    if (typeof value[i] === 'string') {
+      result = value[i]
+      break
+    }
+  }
+  return result
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string | undefined}
+ */
+function readUniqueText (value) {
+  let result
+  if (typeof value === 'string') {
+    result = value
+  } else if (Array.isArray(value) && value.length === 1 && typeof value[0] === 'string') {
+    result = value[0]
+  }
+  return result
+}
+
+/**
+ * @param {unknown} value
+ * @returns {PathwayValue | undefined}
+ */
+function readLastPathway (value) {
+  if (typeof value === 'string' || Buffer.isBuffer(value)) return value
+  if (!Array.isArray(value)) return
+
+  let result
+  for (let i = value.length - 1; i >= 0; i--) {
+    const item = value[i]
+    if (typeof item === 'string' || Buffer.isBuffer(item)) {
+      result = item
+      break
+    }
+  }
+  return result
+}
+
+const datadogTraceId = defineField(
+  'datadogTraceId',
+  'x-datadog-trace-id',
+  readLastText,
+  FIELD_READ | FIELD_WRITE
+)
+const datadogParentId = defineField(
+  'datadogParentId',
+  'x-datadog-parent-id',
+  readLastText,
+  FIELD_READ | FIELD_WRITE | FIELD_DELETE
+)
+const datadogOrigin = defineField(
+  'datadogOrigin',
+  'x-datadog-origin',
+  readLastText,
+  FIELD_READ | FIELD_WRITE
+)
+const datadogSamplingPriority = defineField(
+  'datadogSamplingPriority',
+  'x-datadog-sampling-priority',
+  readLastText,
+  FIELD_READ | FIELD_WRITE
+)
+defineField('datadogTags', 'x-datadog-tags', readListText, FIELD_READ | FIELD_WRITE)
+defineField('baggage', 'baggage', readListText, FIELD_READ | FIELD_WRITE)
+const b3TraceId = defineField('b3TraceId', 'x-b3-traceid', readLastText, FIELD_READ | FIELD_WRITE)
+const b3SpanId = defineField('b3SpanId', 'x-b3-spanid', readLastText, FIELD_READ | FIELD_WRITE)
+const b3ParentId = defineField('b3ParentId', 'x-b3-parentspanid', readLastText, FIELD_WRITE)
+const b3Sampled = defineField('b3Sampled', 'x-b3-sampled', readLastText, FIELD_READ | FIELD_WRITE)
+const b3Flags = defineField('b3Flags', 'x-b3-flags', readLastText, FIELD_READ | FIELD_WRITE)
+const b3 = defineField('b3', 'b3', readLastText, FIELD_READ | FIELD_WRITE)
+defineField('sqsd', 'x-aws-sqsd-attr-_datadog', readLastText, FIELD_READ)
+const traceparent = defineField('traceparent', 'traceparent', readUniqueText, FIELD_READ | FIELD_WRITE)
+const tracestate = defineField('tracestate', 'tracestate', readListText, FIELD_READ | FIELD_WRITE)
+const dsmBase64 = defineField(
+  'dsmBase64',
+  'dd-pathway-ctx-base64',
+  readLastPathway,
+  FIELD_READ | FIELD_WRITE | FIELD_HAS | FIELD_NAME_LENGTH
+)
+const dsmBinary = defineField('dsmBinary', 'dd-pathway-ctx', readLastPathway, FIELD_READ | FIELD_HAS)
+
+const legacyBaggagePrefix = 'ot-baggage-'
+// RFC 7230 `token`, compatible with Node.js header-name validation.
+const httpHeaderNameExpr = /^[0-9A-Za-z!#$%&'*+\-.^_`|~]+$/
+
+defineCapability('legacyBaggage', FIELD_READ | FIELD_WRITE, {
+  /**
+   * @param {Record<string, string> | undefined} carrier
+   * @param {string} key
+   * @param {string} value
+   * @returns {Record<string, string> | undefined}
+   */
+  write (carrier, key, value) {
+    const name = legacyBaggagePrefix + key
+    if (!httpHeaderNameExpr.test(name)) return
+
+    carrier ??= {}
+    carrier[name] = value
+    return carrier
+  },
+
+  /**
+   * @param {Carrier} carrier
+   * @param {Record<string, string>} target
+   * @returns {void}
+   */
+  read (carrier, target) {
+    for (const name of Object.keys(carrier)) {
+      if (!name.startsWith(legacyBaggagePrefix)) continue
+      const key = name.slice(legacyBaggagePrefix.length)
+      if (!key) continue
+      const value = readLastText(carrier[name])
+      if (value !== undefined) target[key] = value
+    }
+  },
+})
+
+const textMapLogFields = [
+  datadogTraceId,
+  datadogParentId,
+  datadogSamplingPriority,
+  datadogOrigin,
+  b3TraceId,
+  b3SpanId,
+  b3ParentId,
+  b3Sampled,
+  b3Flags,
+  b3,
+  traceparent,
+  tracestate,
+]
+const dsmLogFields = [dsmBinary, dsmBase64]
+
+/**
+ * @param {Carrier} carrier
+ * @param {Array<Pick<CarrierField<unknown>, 'copy'>>} selectedFields
+ * @returns {Carrier}
+ */
+function pick (carrier, selectedFields) {
+  /** @type {Carrier} */
+  const result = {}
+  for (const field of selectedFields) field.copy(carrier, result)
+  return result
+}
+
+/**
+ * @param {Carrier} carrier
+ * @returns {Carrier}
+ */
+function pickTextMap (carrier) {
+  return pick(carrier, textMapLogFields)
+}
+
+/**
+ * @param {Carrier} carrier
+ * @returns {Carrier}
+ */
+function pickDsm (carrier) {
+  return pick(carrier, dsmLogFields)
+}
+
+/**
+ * @typedef {object} CarrierOperations
+ * @property {typeof datadogParentId.delete} deleteDatadogParentId
+ * @property {typeof dsmBase64.nameLength} dsmBase64NameLength
+ * @property {typeof dsmBase64.has} hasDsmBase64
+ * @property {typeof dsmBinary.has} hasDsmBinary
+ * @property {typeof pickDsm} pickDsm
+ * @property {typeof pickTextMap} pickTextMap
+ * @property {(carrier: Carrier) => string | undefined} readBaggage
+ * @property {typeof b3.read} readB3
+ * @property {typeof b3Flags.read} readB3Flags
+ * @property {typeof b3Sampled.read} readB3Sampled
+ * @property {typeof b3SpanId.read} readB3SpanId
+ * @property {typeof b3TraceId.read} readB3TraceId
+ * @property {typeof datadogOrigin.read} readDatadogOrigin
+ * @property {typeof datadogParentId.read} readDatadogParentId
+ * @property {typeof datadogSamplingPriority.read} readDatadogSamplingPriority
+ * @property {(carrier: Carrier) => string | undefined} readDatadogTags
+ * @property {typeof datadogTraceId.read} readDatadogTraceId
+ * @property {typeof dsmBase64.read} readDsmBase64
+ * @property {typeof dsmBinary.read} readDsmBinary
+ * @property {(carrier: Carrier, target: Record<string, string>) => void} readLegacyBaggage
+ * @property {(carrier: Carrier) => string | undefined} readSqsd
+ * @property {typeof traceparent.read} readTraceparent
+ * @property {typeof tracestate.read} readTracestate
+ * @property {(carrier: Carrier, value: string) => void} writeBaggage
+ * @property {typeof b3.write} writeB3
+ * @property {typeof b3Flags.write} writeB3Flags
+ * @property {typeof b3ParentId.write} writeB3ParentId
+ * @property {typeof b3Sampled.write} writeB3Sampled
+ * @property {typeof b3SpanId.write} writeB3SpanId
+ * @property {typeof b3TraceId.write} writeB3TraceId
+ * @property {typeof datadogOrigin.write} writeDatadogOrigin
+ * @property {typeof datadogParentId.write} writeDatadogParentId
+ * @property {typeof datadogSamplingPriority.write} writeDatadogSamplingPriority
+ * @property {(carrier: Carrier, value: string) => void} writeDatadogTags
+ * @property {typeof datadogTraceId.write} writeDatadogTraceId
+ * @property {typeof dsmBase64.write} writeDsmBase64
+ * @property {(carrier: Record<string, string> | undefined, key: string, value: string) =>
+ *   Record<string, string> | undefined} writeLegacyBaggage
+ * @property {typeof traceparent.write} writeTraceparent
+ * @property {typeof tracestate.write} writeTracestate
+ */
+
+carrierOperations.pickDsm = pickDsm
+carrierOperations.pickTextMap = pickTextMap
+
+module.exports = /** @type {CarrierOperations} */ (carrierOperations)

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

@@ -92,6 +92,7 @@ function removeEmptyCaptureProperties (value) {
       if (current.fields === null || (
         current.fields &&
         typeof current.fields === 'object' &&
+        // eslint-disable-next-line no-restricted-syntax -- snapshot field names are user variables; no key to probe
         Object.keys(current.fields).length === 0
       )) {
         delete current.fields

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

@@ -4,6 +4,7 @@ const AgentWriter = require('../../../exporters/agent/writer')
 const AgentlessWriter = require('../agentless/writer')
 const CoverageWriter = require('../agentless/coverage-writer')
 const CiVisibilityExporter = require('../ci-visibility-exporter')
+const request = require('../request')
 const { fetchAgentInfo } = require('../../../agent/info')
 const { DEBUGGER_INPUT_V1 } = require('../../../debugger/constants')
 
@@ -43,9 +44,21 @@ class AgentProxyCiVisibilityExporter extends CiVisibilityExporter {
       testOptimization,
     } = config
 
+    const initializationController = new AbortController()
+    const initializationOptions = { signal: initializationController.signal }
+    this._initializationRequest = {
+      controller: initializationController,
+      options: initializationOptions,
+    }
+
     fetchAgentInfo(this._url, (err, agentInfo) => {
+      const initializationFinalFlush = this._initializationRequest?.finalFlush
+      this._initializationRequest = undefined
+      const initializationAborted = initializationController.signal.aborted
+      const agentInfoError = err || (initializationAborted ? initializationController.signal.reason : undefined)
+
       this._isInitialized = true
-      let latestEvpProxyVersion = getLatestEvpProxyVersion(err, agentInfo)
+      let latestEvpProxyVersion = getLatestEvpProxyVersion(agentInfoError, agentInfo)
       const isEvpCompatible = latestEvpProxyVersion >= 2
       this._isGzipCompatible = latestEvpProxyVersion >= 4
 
@@ -72,7 +85,7 @@ class AgentProxyCiVisibilityExporter extends CiVisibilityExporter {
         // path with evpProxyPrefix and sets X-Datadog-EVP-Subdomain: api (see uploadTestScreenshot).
         this._testScreenshotUploadUrl = this._url
         if (testOptimization.DD_TEST_FAILED_TEST_REPLAY_ENABLED) {
-          const canFowardLogs = getCanForwardDebuggerLogs(err, agentInfo)
+          const canFowardLogs = getCanForwardDebuggerLogs(agentInfoError, agentInfo)
           if (canFowardLogs) {
             const DynamicInstrumentationLogsWriter = require('../agentless/di-logs-writer')
             this._logsWriter = new DynamicInstrumentationLogsWriter({
@@ -89,14 +102,25 @@ class AgentProxyCiVisibilityExporter extends CiVisibilityExporter {
           lookup,
           protocolVersion,
           headers,
+          isTestOptimization: true,
         })
         // coverages will never be used, so we discard them
         this._coverageBuffer = []
       }
       this._resolveCanUseCiVisProtocol(isEvpCompatible)
+      if (initializationAborted) {
+        this.resetUncodedTraces()
+        this.resetDeferredTestSuiteSpans()
+        return
+      }
+      if (isEvpCompatible) {
+        if (initializationFinalFlush) this.exportDeferredTestSuiteSpans()
+      } else {
+        this.resetDeferredTestSuiteSpans()
+      }
       this.exportUncodedTraces()
       this.exportUncodedCoverages()
-    })
+    }, initializationOptions, request)
   }
 
   setUrl (url, coverageUrl) {

package/packages/dd-trace/src/ci-visibility/exporters/agentless/coverage-writer.js

@@ -1,11 +1,8 @@
 'use strict'
 const getConfig = require('../../../config')
-const request = require('../../../exporters/common/request')
 const log = require('../../../log')
 const { safeJSONStringify } = require('../../../exporters/common/util')
 
-const { CoverageCIVisibilityEncoder } = require('../../../encode/coverage-ci-visibility')
-const BaseWriter = require('../../../exporters/common/writer')
 const {
   incrementCountMetric,
   distributionMetric,
@@ -15,16 +12,34 @@ const {
   TELEMETRY_ENDPOINT_PAYLOAD_REQUESTS_ERRORS,
   TELEMETRY_ENDPOINT_PAYLOAD_DROPPED,
 } = require('../../../ci-visibility/telemetry')
+const { CoverageCIVisibilityEncoder } = require('../../../encode/coverage-ci-visibility')
+const BaseWriter = require('../../../exporters/common/writer')
+const request = require('../request')
+const TestOptimizationRequestTracker = require('./request-tracker')
 
 class Writer extends BaseWriter {
+  #requestTracker
+
   constructor ({ url, evpProxyPrefix = '' }) {
     super(...arguments)
+    this.#requestTracker = new TestOptimizationRequestTracker(this)
     this._url = url
     this._encoder = new CoverageCIVisibilityEncoder(this)
     this._evpProxyPrefix = evpProxyPrefix
   }
 
-  _sendPayload (form, _, done) {
+  /**
+   * Flushes buffered coverage, waiting for tracked requests during finalization.
+   *
+   * @param {(error?: Error) => void} [done]
+   * @param {{ deadline?: number }} [options]
+   * @returns {void}
+   */
+  flush (done, options) {
+    this.#requestTracker.flush(done, options)
+  }
+
+  _sendPayload (form, _, done, flushOptions) {
     const options = {
       path: '/api/v2/citestcov',
       method: 'POST',
@@ -34,6 +49,7 @@ class Writer extends BaseWriter {
       },
       timeout: 15_000,
       url: this._url,
+      deadline: flushOptions?.deadline,
     }
 
     if (this._evpProxyPrefix) {
@@ -50,7 +66,7 @@ class Writer extends BaseWriter {
     incrementCountMetric(TELEMETRY_ENDPOINT_PAYLOAD_REQUESTS, { endpoint: 'code_coverage' })
     distributionMetric(TELEMETRY_ENDPOINT_PAYLOAD_BYTES, { endpoint: 'code_coverage' }, form.size())
 
-    request(form, options, (err, res, statusCode) => {
+    this.#requestTracker.send(request, form, options, (err, res, statusCode) => {
       distributionMetric(
         TELEMETRY_ENDPOINT_PAYLOAD_REQUESTS_MS,
         { endpoint: 'code_coverage' },
@@ -66,7 +82,7 @@ class Writer extends BaseWriter {
           { endpoint: 'code_coverage' }
         )
         log.error('Error sending CI coverage payload', err)
-        done()
+        done(err)
         return
       }
       log.debug('Response from the intake:', res)

package/packages/dd-trace/src/ci-visibility/exporters/agentless/di-logs-writer.js

@@ -1,27 +1,42 @@
 'use strict'
 const getConfig = require('../../../config')
-const request = require('../../../exporters/common/request')
 const log = require('../../../log')
 const { safeJSONStringify } = require('../../../exporters/common/util')
 const { JSONEncoder } = require('../../encode/json-encoder')
 const { DEBUGGER_INPUT_V1 } = require('../../../debugger/constants')
-
 const BaseWriter = require('../../../exporters/common/writer')
 
+const request = require('../request')
+const TestOptimizationRequestTracker = require('./request-tracker')
+
 // Writer used by the integration between Dynamic Instrumentation and Test Visibility
 // It is used to encode and send logs to both the logs intake directly and the
 // `/debugger/v1/input` endpoint in the agent, which is a proxy to the logs intake.
 class DynamicInstrumentationLogsWriter extends BaseWriter {
+  #requestTracker
+
   // TODO: what's a good value for timeout for the logs intake?
   constructor ({ url, timeout = 15_000, isAgentProxy = false }) {
     super(...arguments)
+    this.#requestTracker = new TestOptimizationRequestTracker(this)
     this._url = url
     this._encoder = new JSONEncoder()
     this._isAgentProxy = isAgentProxy
     this.timeout = timeout
   }
 
-  _sendPayload (data, _, done) {
+  /**
+   * Flushes buffered logs, waiting for tracked requests during finalization.
+   *
+   * @param {(error?: Error) => void} [done]
+   * @param {{ deadline?: number }} [options]
+   * @returns {void}
+   */
+  flush (done, options) {
+    this.#requestTracker.flush(done, options)
+  }
+
+  _sendPayload (data, _, done, flushOptions) {
     const options = {
       path: '/api/v2/logs',
       method: 'POST',
@@ -31,6 +46,7 @@ class DynamicInstrumentationLogsWriter extends BaseWriter {
       },
       timeout: this.timeout,
       url: this._url,
+      deadline: flushOptions?.deadline,
     }
 
     if (this._isAgentProxy) {
@@ -41,10 +57,10 @@ class DynamicInstrumentationLogsWriter extends BaseWriter {
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
     log.debug(() => `Request to the logs intake: ${safeJSONStringify(options)}`)
 
-    request(data, options, (err, res) => {
+    this.#requestTracker.send(request, data, options, (err, res) => {
       if (err) {
         log.error('Error sending DI logs payload', err)
-        done()
+        done(err)
         return
       }
       log.debug('Response from the logs intake:', res)