dd-trace 6.10.0 → 6.12.0

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

@@ -9,6 +9,23 @@ const FIELD_HAS = 4
 const FIELD_DELETE = 8
 const FIELD_NAME_LENGTH = 16
 
+const b3FlagsHeader = 'x-b3-flags'
+const b3Header = 'b3'
+const b3SampledHeader = 'x-b3-sampled'
+const b3SpanIdHeader = 'x-b3-spanid'
+const b3TraceIdHeader = 'x-b3-traceid'
+const baggageHeader = 'baggage'
+const datadogOriginHeader = 'x-datadog-origin'
+const datadogParentIdHeader = 'x-datadog-parent-id'
+const datadogSamplingPriorityHeader = 'x-datadog-sampling-priority'
+const datadogTagsHeader = 'x-datadog-tags'
+const datadogTraceIdHeader = 'x-datadog-trace-id'
+const dsmBase64Header = 'dd-pathway-ctx-base64'
+const dsmBinaryHeader = 'dd-pathway-ctx'
+const sqsdHeader = 'x-aws-sqsd-attr-_datadog'
+const traceparentHeader = 'traceparent'
+const tracestateHeader = 'tracestate'
+
 /** @type {Record<string, unknown>} */
 const carrierOperations = {}
 
@@ -24,7 +41,7 @@ const carrierOperations = {}
 /**
  * @template Value
  * @typedef {object} CarrierField
- * @property {(carrier: Carrier) => Value | undefined} read
+ * @property {((carrier: Carrier) => Value | undefined) | undefined} read
  * @property {(carrier: Carrier, value: Value) => void} write
  * @property {(carrier: Carrier) => boolean} has
  * @property {(carrier: Carrier) => void} delete
@@ -53,19 +70,13 @@ function defineCapability (name, operations, capability) {
  * @template Value
  * @param {string} fieldName
  * @param {string} headerName
- * @param {(value: unknown) => Value | undefined} resolve
+ * @param {((carrier: Carrier) => Value | undefined) | undefined} read
  * @param {number} operations
  * @returns {CarrierField<Value>}
  */
-function defineField (fieldName, headerName, resolve, operations) {
+function defineField (fieldName, headerName, read, operations) {
   return defineCapability(fieldName, operations, {
-    /**
-     * @param {Carrier} carrier
-     * @returns {Value | undefined}
-     */
-    read (carrier) {
-      return resolve(carrier[headerName])
-    },
+    read,
 
     /**
      * @param {Carrier} carrier
@@ -183,48 +194,96 @@ function readLastPathway (value) {
   return result
 }
 
+/** @param {Carrier} carrier */
+function readB3Flags (carrier) { return readLastText(carrier[b3FlagsHeader]) }
+
+/** @param {Carrier} carrier */
+function readB3 (carrier) { return readLastText(carrier[b3Header]) }
+
+/** @param {Carrier} carrier */
+function readB3Sampled (carrier) { return readLastText(carrier[b3SampledHeader]) }
+
+/** @param {Carrier} carrier */
+function readB3SpanId (carrier) { return readLastText(carrier[b3SpanIdHeader]) }
+
+/** @param {Carrier} carrier */
+function readB3TraceId (carrier) { return readLastText(carrier[b3TraceIdHeader]) }
+
+/** @param {Carrier} carrier */
+function readBaggage (carrier) { return readListText(carrier[baggageHeader]) }
+
+/** @param {Carrier} carrier */
+function readDatadogOrigin (carrier) { return readLastText(carrier[datadogOriginHeader]) }
+
+/** @param {Carrier} carrier */
+function readDatadogParentId (carrier) { return readLastText(carrier[datadogParentIdHeader]) }
+
+/** @param {Carrier} carrier */
+function readDatadogSamplingPriority (carrier) { return readLastText(carrier[datadogSamplingPriorityHeader]) }
+
+/** @param {Carrier} carrier */
+function readDatadogTags (carrier) { return readListText(carrier[datadogTagsHeader]) }
+
+/** @param {Carrier} carrier */
+function readDatadogTraceId (carrier) { return readLastText(carrier[datadogTraceIdHeader]) }
+
+/** @param {Carrier} carrier */
+function readDsmBase64 (carrier) { return readLastPathway(carrier[dsmBase64Header]) }
+
+/** @param {Carrier} carrier */
+function readDsmBinary (carrier) { return readLastPathway(carrier[dsmBinaryHeader]) }
+
+/** @param {Carrier} carrier */
+function readSqsd (carrier) { return readLastText(carrier[sqsdHeader]) }
+
+/** @param {Carrier} carrier */
+function readTraceparent (carrier) { return readUniqueText(carrier[traceparentHeader]) }
+
+/** @param {Carrier} carrier */
+function readTracestate (carrier) { return readListText(carrier[tracestateHeader]) }
+
 const datadogTraceId = defineField(
   'datadogTraceId',
-  'x-datadog-trace-id',
-  readLastText,
+  datadogTraceIdHeader,
+  readDatadogTraceId,
   FIELD_READ | FIELD_WRITE
 )
 const datadogParentId = defineField(
   'datadogParentId',
-  'x-datadog-parent-id',
-  readLastText,
+  datadogParentIdHeader,
+  readDatadogParentId,
   FIELD_READ | FIELD_WRITE | FIELD_DELETE
 )
 const datadogOrigin = defineField(
   'datadogOrigin',
-  'x-datadog-origin',
-  readLastText,
+  datadogOriginHeader,
+  readDatadogOrigin,
   FIELD_READ | FIELD_WRITE
 )
 const datadogSamplingPriority = defineField(
   'datadogSamplingPriority',
-  'x-datadog-sampling-priority',
-  readLastText,
+  datadogSamplingPriorityHeader,
+  readDatadogSamplingPriority,
   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)
+defineField('datadogTags', datadogTagsHeader, readDatadogTags, FIELD_READ | FIELD_WRITE)
+defineField('baggage', baggageHeader, readBaggage, FIELD_READ | FIELD_WRITE)
+const b3TraceId = defineField('b3TraceId', b3TraceIdHeader, readB3TraceId, FIELD_READ | FIELD_WRITE)
+const b3SpanId = defineField('b3SpanId', b3SpanIdHeader, readB3SpanId, FIELD_READ | FIELD_WRITE)
+const b3ParentId = defineField('b3ParentId', 'x-b3-parentspanid', undefined, FIELD_WRITE)
+const b3Sampled = defineField('b3Sampled', b3SampledHeader, readB3Sampled, FIELD_READ | FIELD_WRITE)
+const b3Flags = defineField('b3Flags', b3FlagsHeader, readB3Flags, FIELD_READ | FIELD_WRITE)
+const b3 = defineField('b3', b3Header, readB3, FIELD_READ | FIELD_WRITE)
+defineField('sqsd', sqsdHeader, readSqsd, FIELD_READ)
+const traceparent = defineField('traceparent', traceparentHeader, readTraceparent, FIELD_READ | FIELD_WRITE)
+const tracestate = defineField('tracestate', tracestateHeader, readTracestate, FIELD_READ | FIELD_WRITE)
 const dsmBase64 = defineField(
   'dsmBase64',
-  'dd-pathway-ctx-base64',
-  readLastPathway,
+  dsmBase64Header,
+  readDsmBase64,
   FIELD_READ | FIELD_WRITE | FIELD_HAS | FIELD_NAME_LENGTH
 )
-const dsmBinary = defineField('dsmBinary', 'dd-pathway-ctx', readLastPathway, FIELD_READ | FIELD_HAS)
+const dsmBinary = defineField('dsmBinary', dsmBinaryHeader, readDsmBinary, FIELD_READ | FIELD_HAS)
 
 const legacyBaggagePrefix = 'ot-baggage-'
 // RFC 7230 `token`, compatible with Node.js header-name validation.
@@ -314,23 +373,23 @@ function pickDsm (carrier) {
  * @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 {typeof readBaggage} readBaggage
+ * @property {typeof readB3} readB3
+ * @property {typeof readB3Flags} readB3Flags
+ * @property {typeof readB3Sampled} readB3Sampled
+ * @property {typeof readB3SpanId} readB3SpanId
+ * @property {typeof readB3TraceId} readB3TraceId
+ * @property {typeof readDatadogOrigin} readDatadogOrigin
+ * @property {typeof readDatadogParentId} readDatadogParentId
+ * @property {typeof readDatadogSamplingPriority} readDatadogSamplingPriority
+ * @property {typeof readDatadogTags} readDatadogTags
+ * @property {typeof readDatadogTraceId} readDatadogTraceId
+ * @property {typeof readDsmBase64} readDsmBase64
+ * @property {typeof readDsmBinary} 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 {typeof readSqsd} readSqsd
+ * @property {typeof readTraceparent} readTraceparent
+ * @property {typeof readTracestate} readTracestate
  * @property {(carrier: Carrier, value: string) => void} writeBaggage
  * @property {typeof b3.write} writeB3
  * @property {typeof b3Flags.write} writeB3Flags

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/early-flake-detection/get-known-tests.js

@@ -1,10 +1,10 @@
 'use strict'
 
 const getConfig = require('../../config')
-const request = require('../requests/request')
+const { EVP_SUBDOMAIN_HEADER_NAME } = require('../../evp_proxy/constants')
+const { joinEVPProxyPath } = require('../../evp_proxy/path')
 const id = require('../../id')
 const log = require('../../log')
-
 const {
   incrementCountMetric,
   distributionMetric,
@@ -14,8 +14,8 @@ const {
   TELEMETRY_KNOWN_TESTS_RESPONSE_TESTS,
   TELEMETRY_KNOWN_TESTS_RESPONSE_BYTES,
 } = require('../../ci-visibility/telemetry')
-
 const { getNumFromKnownTests } = require('../../plugins/util/test')
+const request = require('../requests/request')
 const { buildCacheKey, writeToCache, withCache } = require('../requests/fs-cache')
 const { validateKnownTestsResponse } = require('../test-optimization-http-cache-schema')
 
@@ -162,8 +162,8 @@ function fetchFromApi ({
   }
 
   if (isEvpProxy) {
-    options.path = `${evpProxyPrefix}/api/v2/ci/libraries/tests`
-    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    options.path = joinEVPProxyPath(evpProxyPrefix, '/api/v2/ci/libraries/tests')
+    options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'api'
   } else {
     const { DD_API_KEY } = getConfig()
     if (!DD_API_KEY) {

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

@@ -4,9 +4,12 @@ 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')
 
+// Product-specific discovery: newest advertised version, skip v3 (citestcycle), gzip if >= v4.
+// Shared `evp_proxy` discovery is an explicit path allowlist and does not cover this contract.
 const AGENT_EVP_PROXY_PATH_PREFIX = '/evp_proxy/v'
 const AGENT_EVP_PROXY_PATH_REGEX = /\/evp_proxy\/v(\d+)\/?/
 
@@ -43,9 +46,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 +87,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 +104,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,10 @@
 'use strict'
 const getConfig = require('../../../config')
-const request = require('../../../exporters/common/request')
-const log = require('../../../log')
+const { EVP_SUBDOMAIN_HEADER_NAME } = require('../../../evp_proxy/constants')
+const { joinEVPProxyPath } = require('../../../evp_proxy/path')
 const { safeJSONStringify } = require('../../../exporters/common/util')
+const log = require('../../../log')
 
-const { CoverageCIVisibilityEncoder } = require('../../../encode/coverage-ci-visibility')
-const BaseWriter = require('../../../exporters/common/writer')
 const {
   incrementCountMetric,
   distributionMetric,
@@ -15,16 +14,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,12 +51,13 @@ class Writer extends BaseWriter {
       },
       timeout: 15_000,
       url: this._url,
+      deadline: flushOptions?.deadline,
     }
 
     if (this._evpProxyPrefix) {
-      options.path = `${this._evpProxyPrefix}/api/v2/citestcov`
+      options.path = joinEVPProxyPath(this._evpProxyPrefix, '/api/v2/citestcov')
       delete options.headers['dd-api-key']
-      options.headers['X-Datadog-EVP-Subdomain'] = 'citestcov-intake'
+      options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'citestcov-intake'
     }
 
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
@@ -50,7 +68,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 +84,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)

package/packages/dd-trace/src/ci-visibility/exporters/agentless/request-tracker.js

@@ -0,0 +1,164 @@
+'use strict'
+
+const BaseWriter = require('../../../exporters/common/writer')
+
+const FINAL_FLUSH_TIMEOUT_CODE = 'ERR_DD_TEST_OPTIMIZATION_FLUSH_TIMEOUT'
+
+class TestOptimizationRequestTracker {
+  #writer
+  #pendingRequests = new Set()
+  #finalFlushes = new Set()
+  #activeFinalFlush
+
+  /**
+   * Creates request tracking for a Test Optimization writer.
+   *
+   * @param {BaseWriter} writer
+   */
+  constructor (writer) {
+    this.#writer = writer
+  }
+
+  /**
+   * Flushes queued payloads and, for a final flush, waits for requests that were
+   * already in flight. The absolute deadline prevents Test Optimization from
+   * keeping the test process alive indefinitely.
+   *
+   * @param {(error?: Error) => void} [done]
+   * @param {{ deadline?: number }} [options]
+   * @returns {void}
+   */
+  flush (done, options) {
+    if (options?.deadline === undefined) {
+      BaseWriter.prototype.flush.call(this.#writer, done, options)
+      return
+    }
+
+    const finalFlush = {
+      deadline: options.deadline,
+      done: done || (() => {}),
+      error: undefined,
+      requests: new Set(),
+      timeoutId: undefined,
+      writerDone: false,
+    }
+    this.#finalFlushes.add(finalFlush)
+
+    for (const pendingRequest of this.#pendingRequests) {
+      this.#attachRequest(finalFlush, pendingRequest)
+    }
+
+    const remaining = Math.max(0, options.deadline - Date.now())
+    finalFlush.timeoutId = setTimeout(() => {
+      const error = new Error('Timed out flushing Test Optimization data')
+      error.code = FINAL_FLUSH_TIMEOUT_CODE
+
+      finalFlush.error ||= error
+      finalFlush.writerDone = true
+
+      for (const pendingRequest of finalFlush.requests) {
+        pendingRequest.finalFlushes.delete(finalFlush)
+        if (pendingRequest.finalFlushes.size === 0) {
+          pendingRequest.controller.abort(error)
+          this.#pendingRequests.delete(pendingRequest)
+        } else {
+          this.#updateRequestDeadline(pendingRequest)
+        }
+      }
+      finalFlush.requests.clear()
+      this.#finishFinalFlush(finalFlush)
+    }, remaining)
+
+    const previousFinalFlush = this.#activeFinalFlush
+    this.#activeFinalFlush = finalFlush
+    try {
+      BaseWriter.prototype.flush.call(this.#writer, (error) => {
+        finalFlush.error ||= error
+        finalFlush.writerDone = true
+        this.#finishFinalFlush(finalFlush)
+      }, options)
+    } finally {
+      this.#activeFinalFlush = previousFinalFlush
+    }
+    this.#finishFinalFlush(finalFlush)
+  }
+
+  /**
+   * Sends and tracks a request so a later final flush can wait for or abort it.
+   *
+   * @param {Function} request
+   * @param {Buffer|string|object} data
+   * @param {object} options
+   * @param {(error: Error|null, result?: string|null, statusCode?: number,
+   *   headers?: import('node:http').IncomingHttpHeaders) => void} callback
+   * @returns {void}
+   */
+  send (request, data, options, callback) {
+    const controller = new AbortController()
+    const requestOptions = { ...options, signal: controller.signal }
+    const pendingRequest = { controller, finalFlushes: new Set(), options: requestOptions }
+    this.#pendingRequests.add(pendingRequest)
+    if (this.#activeFinalFlush) this.#attachRequest(this.#activeFinalFlush, pendingRequest)
+
+    request(data, requestOptions, (error, result, statusCode, headers) => {
+      if (error) {
+        for (const finalFlush of pendingRequest.finalFlushes) finalFlush.error ||= error
+      }
+
+      try {
+        callback(error, result, statusCode, headers)
+      } finally {
+        this.#pendingRequests.delete(pendingRequest)
+        for (const finalFlush of pendingRequest.finalFlushes) {
+          finalFlush.requests.delete(pendingRequest)
+          this.#finishFinalFlush(finalFlush)
+        }
+        pendingRequest.finalFlushes.clear()
+      }
+    })
+  }
+
+  /**
+   * Associates a request with the final flush boundary that must wait for it.
+   *
+   * @param {object} finalFlush
+   * @param {object} pendingRequest
+   * @returns {void}
+   */
+  #attachRequest (finalFlush, pendingRequest) {
+    finalFlush.requests.add(pendingRequest)
+    pendingRequest.finalFlushes.add(finalFlush)
+    this.#updateRequestDeadline(pendingRequest)
+  }
+
+  /**
+   * Gives a shared request the latest deadline of the flushes waiting for it.
+   *
+   * @param {object} pendingRequest
+   * @returns {void}
+   */
+  #updateRequestDeadline (pendingRequest) {
+    let deadline = 0
+    for (const finalFlush of pendingRequest.finalFlushes) {
+      deadline = Math.max(deadline, finalFlush.deadline)
+    }
+    pendingRequest.options.deadline = deadline
+  }
+
+  /**
+   * Completes a final flush callback once its writer and associated requests
+   * have settled.
+   *
+   * @param {object} finalFlush
+   * @returns {void}
+   */
+  #finishFinalFlush (finalFlush) {
+    if (!this.#finalFlushes.has(finalFlush) || !finalFlush.writerDone || finalFlush.requests.size !== 0) return
+
+    this.#finalFlushes.delete(finalFlush)
+    clearTimeout(finalFlush.timeoutId)
+    finalFlush.done(finalFlush.error)
+  }
+}
+
+module.exports = TestOptimizationRequestTracker