dd-trace 6.10.0 → 6.12.0

package/packages/dd-trace/src/datastreams/processor.js

@@ -5,25 +5,17 @@ const pkg = require('../../../../package.json')
 
 const { LogCollapsingLowestDenseDDSketch } = require('../../../../vendor/dist/@datadog/sketches-js')
 const { PATHWAY_HASH, DSM_TRANSACTION_ID, DSM_TRANSACTION_CHECKPOINT } = require('../../../../ext/tags')
-const { dsmBase64NameLength } = require('../carrier')
 const log = require('../log')
 const processTags = require('../process-tags')
 const propagationHash = require('../propagation-hash')
 const { computePathwayHash } = require('./pathway')
 const { DataStreamsWriter } = require('./writer')
-const { getAmqpMessageSize, getHeadersSize, getMessageSize, getSizeOrZero } = require('./size')
+const { getAmqpMessageSize, getHeadersSize, getMessageSize, getSizeOrZero, PATHWAY_FIELD_BYTES } = require('./size')
 const { SchemaBuilder } = require('./schemas/schema_builder')
 const { SchemaSampler } = require('./schemas/schema_sampler')
 
 const ENTRY_PARENT_HASH = Buffer.from('0000000000000000', 'hex')
 
-// A direction:out checkpoint estimates the size cost of the header the
-// producer plugin will inject. The pathway context is always 20 binary
-// bytes, encoded as 28 base64 chars; together with the header key and
-// JSON framing (matching the prior `JSON.stringify({key: value})` byte
-// count minus 1), this is a fixed value.
-const PATHWAY_HEADER_BYTES = dsmBase64NameLength + 28 + 6
-
 class StatsPoint {
   constructor (hash, parentHash, edgeTags) {
     this.hash = hash.readBigUInt64LE()
@@ -290,10 +282,19 @@ class DataStreamsProcessor {
     if (this.flushInterval === 0) this.onInterval()
   }
 
-  setCheckpoint (edgeTags, span, ctx, payloadSize = 0) {
+  /**
+   * @param {string[]} edgeTags Direction tag first.
+   * @param {import('../opentracing/span')|null} span
+   * @param {object|null|undefined} ctx Parent pathway context.
+   * @param {number} [payloadSize] Bytes the caller built, before any propagation context.
+   * @param {number} [pathwayContextSize] Bytes the pathway context adds to an outbound payload.
+   *   Most producers size their payload before this call hands them the context to inject, so they
+   *   cannot measure it and take the default estimate. Pass `0` to report the payload alone.
+   * @returns {object|undefined}
+   */
+  setCheckpoint (edgeTags, span, ctx, payloadSize = 0, pathwayContextSize = PATHWAY_FIELD_BYTES) {
     if (!this.enabled) return
     const nowNs = Date.now() * 1e6
-    // Callers must place the direction tag at index 0.
     const direction = edgeTags[0]
     let pathwayStartNs = nowNs
     let edgeStartNs = nowNs
@@ -338,14 +339,15 @@ class DataStreamsProcessor {
     const pathwayLatencyNs = nowNs - pathwayStartNs
     const dataStreamsContext = {
       hash,
-      edgeStartNs,
+      // start the next hop's edge clock here so edge latency stays per-hop
+      edgeStartNs: nowNs,
       pathwayStartNs,
       previousDirection: direction,
       closestOppositeDirectionHash,
       closestOppositeDirectionEdgeStart,
     }
     if (direction === 'direction:out') {
-      payloadSize += PATHWAY_HEADER_BYTES
+      payloadSize += pathwayContextSize
     }
     const checkpoint = {
       currentTimestamp: nowNs,

package/packages/dd-trace/src/datastreams/size.js

@@ -2,6 +2,10 @@
 
 const { types } = require('util')
 
+// Byte cost of the `,"dd-pathway-ctx-base64":"<28 chars>"` field a producer adds to a JSON carrier.
+// A literal so eager `size` consumers don't pull in `./pathway`; `pathway.spec.js` pins it there.
+const PATHWAY_FIELD_BYTES = 55
+
 function getSizeOrZero (obj) {
   if (typeof obj === 'string') {
     return Buffer.byteLength(obj, 'utf8')
@@ -54,4 +58,5 @@ module.exports = {
   getHeadersSize,
   getSizeOrZero,
   getAmqpMessageSize,
+  PATHWAY_FIELD_BYTES,
 }

package/packages/dd-trace/src/debugger/constants.js

@@ -4,4 +4,5 @@ module.exports = {
   DEBUGGER_DIAGNOSTICS_V1: '/debugger/v1/diagnostics',
   DEBUGGER_INPUT_V1: '/debugger/v1/input',
   DEBUGGER_INPUT_V2: '/debugger/v2/input',
+  INSPECT_SEGMENT_GLOBAL_PROPERTY: 'debuggerInspectSegment',
 }

package/packages/dd-trace/src/debugger/devtools_client/condition.js

@@ -55,7 +55,7 @@ function compileSegments (segments) {
       ? `(() => {
           try {
             const result = ${compile(json)}
-            return typeof result === 'string' ? result : $dd_inspect(result, $dd_segmentInspectOptions)
+            return typeof result === 'string' ? result : $dd_inspectSegment(result)
           } catch (e) {
             return { expr: ${JSON.stringify(dsl)}, message: \`\${e.name}: \${e.message}\` }
           }

package/packages/dd-trace/src/debugger/devtools_client/index.js

@@ -4,6 +4,7 @@ const { randomUUID } = require('crypto')
 const { workerData: { probeSamplerBuffer } } = require('worker_threads')
 const { version } = require('../../../../../package.json')
 const processTags = require('../../process-tags')
+const { INSPECT_SEGMENT_GLOBAL_PROPERTY } = require('../constants')
 const {
   MAX_SAMPLED_PROBES_PER_PAUSE,
   SAMPLED_PROBE_COUNT_INDEX,
@@ -23,19 +24,12 @@ require('./remote_config')
 
 /** @typedef {import('node:inspector').Debugger.EvaluateOnCallFrameReturnType} EvaluateOnCallFrameResult */
 
+const templateExpressionSetupCode = 'const $dd_inspectSegment = ' +
+  `globalThis[Symbol.for('dd-trace')][${JSON.stringify(INSPECT_SEGMENT_GLOBAL_PROPERTY)}];`
+
 // Expression to run on a call frame of the paused thread to get its active trace and span id.
-const templateExpressionSetupCode = `
-  const $dd_inspect = global.require('node:util').inspect;
-  const $dd_segmentInspectOptions = {
-    depth: 0,
-    customInspect: false,
-    maxArrayLength: 3,
-    maxStringLength: 8 * 1024,
-    breakLength: Infinity
-  };
-`
 const getDDTagsExpression = `(() => {
-  const context = global.require('dd-trace').scope().active()?.context();
+  const context = globalThis._ddtrace.scope().active()?.context();
   return { trace_id: context?.toTraceId(), span_id: context?.toSpanId() }
 })()`
 

package/packages/dd-trace/src/debugger/index.js

@@ -7,7 +7,7 @@ const { Worker, MessageChannel, threadId: parentThreadId } = require('worker_thr
 const log = require('../log')
 const { fetchAgentInfo } = require('../agent/info')
 const getDebuggerConfig = require('./config')
-const { DEBUGGER_DIAGNOSTICS_V1, DEBUGGER_INPUT_V2 } = require('./constants')
+const { DEBUGGER_DIAGNOSTICS_V1, DEBUGGER_INPUT_V2, INSPECT_SEGMENT_GLOBAL_PROPERTY } = require('./constants')
 const { installProbeSampler, uninstallProbeSampler } = require('./probe_sampler')
 
 /**
@@ -64,7 +64,9 @@ function start (config, rcInstance) {
   const logChannel = new MessageChannel()
   configChannel = new MessageChannel()
 
-  globalThis[Symbol.for('dd-trace')].utilTypes = types
+  const debuggerGlobals = globalThis[Symbol.for('dd-trace')]
+  debuggerGlobals.utilTypes = types
+  debuggerGlobals[INSPECT_SEGMENT_GLOBAL_PROPERTY] = require('./inspect-segment')
 
   const probeSamplerBuffer = installProbeSampler()
 

package/packages/dd-trace/src/debugger/inspect-segment.js

@@ -0,0 +1,154 @@
+'use strict'
+
+const { inspect, types } = require('node:util')
+
+const { NODE_MAJOR } = require('../../../../version')
+
+/** @typedef {NonNullable<ReturnType<typeof globalThis.Object.getOwnPropertyDescriptor>>} PropertyDescriptor */
+/** @typedef {Map<unknown, unknown> | Set<unknown>} Collection */
+
+const mapEntries = Map.prototype.entries
+const mapSet = Map.prototype.set
+const mapSizeGetter = Object.getOwnPropertyDescriptor(Map.prototype, 'size').get
+const setAdd = Set.prototype.add
+const setSizeGetter = Object.getOwnPropertyDescriptor(Set.prototype, 'size').get
+const setValues = Set.prototype.values
+const mapIteratorNext = Object.getPrototypeOf(mapEntries.call(new Map())).next
+const setIteratorNext = Object.getPrototypeOf(setValues.call(new Set())).next
+
+const maxCollectionEntries = 3
+const maxProperties = 5
+const segmentInspectOptions = {
+  depth: 0,
+  customInspect: false,
+  maxArrayLength: maxCollectionEntries,
+  maxStringLength: 8 * 1024,
+  breakLength: Infinity,
+}
+
+module.exports = inspectSegment
+
+/**
+ * Inspect a dynamic-instrumentation template value without invoking user code.
+ * Unlike collections, `util.inspect` has no option for limiting the number of object properties, so this function
+ * truncates objects before inspecting them.
+ *
+ * @param {unknown} value
+ * @returns {string}
+ */
+function inspectSegment (value) {
+  if (value === null || (typeof value !== 'object' && typeof value !== 'function')) {
+    return inspect(value, segmentInspectOptions)
+  }
+  if (types.isProxy(value)) return '[Proxy]'
+  if (types.isMap(value)) return inspectCollection(value, true)
+  if (types.isSet(value)) return inspectCollection(value, false)
+  if (
+    Array.isArray(value) ||
+    types.isTypedArray(value) ||
+    types.isAnyArrayBuffer(value) ||
+    types.isDataView(value) ||
+    types.isWeakMap(value) ||
+    types.isWeakSet(value) ||
+    types.isMapIterator(value) ||
+    types.isSetIterator(value)
+  ) {
+    return inspect(value, segmentInspectOptions)
+  }
+
+  /** @type {(string | symbol)[]} */
+  const keys = Object.keys(value)
+  let propertyCount = keys.length
+  const symbols = Object.getOwnPropertySymbols(value)
+  for (let i = 0; i < symbols.length; i++) {
+    if (Object.getOwnPropertyDescriptor(value, symbols[i])?.enumerable === true) {
+      propertyCount++
+      if (keys.length < maxProperties) keys.push(symbols[i])
+    }
+  }
+
+  if (propertyCount <= maxProperties) {
+    // TODO: Decide whether allowing util.inspect to invoke Symbol.toStringTag getters is acceptable. If it is,
+    // remove inspectionCanRunUserCode and the related omission paths.
+    if (inspectionCanRunUserCode(value)) {
+      return '[Value omitted: inspection may execute user code]'
+    }
+    return inspect(value, segmentInspectOptions)
+  }
+
+  const truncated = {}
+  for (let i = 0; i < maxProperties; i++) {
+    const descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(value, keys[i]))
+    if (
+      (keys[i] === Symbol.toStringTag && descriptor.get !== undefined) ||
+      (descriptor.value !== value && inspectionCanRunUserCode(descriptor.value))
+    ) {
+      return '[Value omitted: inspection may execute user code]'
+    }
+    if (descriptor.value === value) descriptor.value = truncated
+    Object.defineProperty(truncated, keys[i], descriptor)
+  }
+
+  const omitted = propertyCount - maxProperties
+  const inspected = inspect(truncated, segmentInspectOptions)
+  return `${inspected.slice(0, -2)}, ... ${omitted} more ${omitted === 1 ? 'property' : 'properties'} }`
+}
+
+/**
+ * Inspect a Map or Set while bounding the number of entries on Node.js 18, where `util.inspect` does not.
+ *
+ * @param {Collection} value
+ * @param {boolean} isMap
+ * @returns {string}
+ */
+function inspectCollection (value, isMap) {
+  if (NODE_MAJOR !== 18) return inspect(value, segmentInspectOptions)
+
+  const size = (isMap ? mapSizeGetter : setSizeGetter).call(value)
+  if (size <= maxCollectionEntries) return inspect(value, segmentInspectOptions)
+
+  const truncated = isMap ? new Map() : new Set()
+  const iterator = (isMap ? mapEntries : setValues).call(value)
+  const iteratorNext = isMap ? mapIteratorNext : setIteratorNext
+
+  for (let i = 0; i < maxCollectionEntries; i++) {
+    const result = iteratorNext.call(iterator)
+    if (result.done) break
+
+    if (isMap) {
+      const entry = result.value
+      const key = entry[0] === value ? truncated : entry[0]
+      const entryValue = entry[1] === value ? truncated : entry[1]
+      mapSet.call(truncated, key, entryValue)
+    } else {
+      const entryValue = result.value === value ? truncated : result.value
+      setAdd.call(truncated, entryValue)
+    }
+  }
+
+  const type = isMap ? 'Map' : 'Set'
+  const inspected = inspect(truncated, segmentInspectOptions)
+  const normalized = inspected.replace(`${type}(${maxCollectionEntries})`, `${type}(${size})`)
+  const remaining = size - maxCollectionEntries
+  return `${normalized.slice(0, -2)}, ... ${remaining} more item${remaining === 1 ? '' : 's'} }`
+}
+
+/**
+ * Determine whether inspecting a value could invoke a proxy trap or toStringTag getter.
+ *
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+function inspectionCanRunUserCode (value) {
+  const type = typeof value
+  if (value === null || (type !== 'object' && type !== 'function')) return false
+  if (types.isProxy(value)) return true
+
+  let current = value
+  while (current !== null) {
+    if (Object.getOwnPropertyDescriptor(current, Symbol.toStringTag)?.get !== undefined) return true
+    current = Object.getPrototypeOf(current)
+    if (types.isProxy(current)) return true
+  }
+  return false
+}

package/packages/dd-trace/src/evp_proxy/constants.js

@@ -0,0 +1,8 @@
+'use strict'
+
+module.exports = {
+  EVP_PROXY_PATH_V2: '/evp_proxy/v2',
+  EVP_PROXY_PATH_V4: '/evp_proxy/v4',
+  EVP_SUBDOMAIN_HEADER_NAME: 'X-Datadog-EVP-Subdomain',
+  EVP_EVENT_PLATFORM_SUBDOMAIN: 'event-platform-intake',
+}

package/packages/dd-trace/src/evp_proxy/direct.js

@@ -0,0 +1,64 @@
+'use strict'
+
+const { format } = require('node:url')
+
+const { HttpsProxyAgent } = require('../../../../vendor/dist/https-proxy-agent')
+const { getProxyForUrl } = require('../../../../vendor/dist/proxy-from-env')
+const log = require('../log')
+
+/**
+ * @typedef {object} DirectEVPRoute
+ * @property {URL} url - Direct intake URL
+ * @property {string} basePath - Direct intake base path
+ * @property {object} headers - Direct intake authentication headers
+ * @property {import('node:https').Agent} [agent] - Optional HTTPS proxy agent
+ */
+
+/**
+ * Creates an authenticated direct EVP intake route.
+ *
+ * This helper does not perform local receiver discovery.
+ *
+ * @param {import('../config/config-base')} config - Tracer configuration
+ * @param {string} intake - EVP intake subdomain
+ * @returns {DirectEVPRoute|undefined} Direct route when credentials and site are available
+ */
+function createDirectEVPRoute (config, intake) {
+  const apiKey = config.DD_API_KEY
+  if (!apiKey || !config.site) return
+
+  try {
+    const hostname = `${intake}.${config.site}`.toLowerCase()
+    const url = new URL(format({
+      protocol: 'https:',
+      hostname,
+    }))
+    if (
+      url.hostname !== hostname ||
+      url.username ||
+      url.password ||
+      url.port ||
+      url.pathname !== '/' ||
+      url.search ||
+      url.hash
+    ) {
+      throw new Error('Invalid direct EVP intake URL')
+    }
+
+    const proxyUrl = getProxyForUrl(url.href)
+    const agent = proxyUrl ? new HttpsProxyAgent(proxyUrl) : undefined
+
+    return {
+      url,
+      basePath: '',
+      headers: {
+        'DD-API-KEY': apiKey,
+      },
+      ...(agent && { agent }),
+    }
+  } catch (error) {
+    log.debug('Unable to configure direct EVP intake: %s', error.message)
+  }
+}
+
+module.exports = { createDirectEVPRoute }

package/packages/dd-trace/src/evp_proxy/discovery.js

@@ -0,0 +1,133 @@
+'use strict'
+
+const { fetchAgentInfo } = require('../agent/info')
+const log = require('../log')
+
+const TRAILING_SLASHES = /\/+$/
+
+/**
+ * Receiver discovery contract
+ *
+ * The tracer sends `GET /info` to its configured local Agent URL. An
+ * Agent-compatible trace receiver produces the response. The tracer does not.
+ *
+ * The full Agent and serverless-init embed the same trace receiver. A future
+ * in-process receiver can expose the same contract. Callers can therefore
+ * select capabilities without detecting the receiver implementation.
+ *
+ * For EVP discovery, `endpoints` advertises registered proxy paths.
+ * `evp_proxy_allowed_headers` advertises headers that the proxy forwards to
+ * intake. It does not include routing headers that the proxy consumes, such as
+ * `X-Datadog-EVP-Subdomain`.
+ *
+ * An advertised route is not a health check. The receiver can register an EVP
+ * route while configuration disables its handler. The request then returns
+ * `405`. The `/info` version also identifies the embedded Agent code, not a
+ * serverless-init image or deployment type.
+ *
+ * This module only discovers a candidate route. A missing or unresponsive
+ * `/info` endpoint returns an error through the shared request timeout and
+ * retry policy. A valid response without a compatible path returns no route.
+ * Discovery sends no events, so the caller can safely select direct intake
+ * after either result. The caller also owns later delivery failures. Exposure
+ * delivery uses retries and can therefore produce duplicates. After local
+ * retries fail, the caller can retry through direct intake and use that route
+ * for future batches.
+ *
+ * Reference implementations:
+ *
+ * Agent `/info` and EVP proxy:
+ * https://github.com/DataDog/datadog-agent/tree/main/pkg/trace/api
+ *
+ * serverless-init entry point and embedded trace receiver:
+ * https://github.com/DataDog/datadog-agent/blob/main/cmd/serverless-init/main.go
+ * https://github.com/DataDog/datadog-agent/blob/main/pkg/serverless/trace/trace.go
+ */
+
+/**
+ * Selects the first advertised EVP proxy path that the caller supports.
+ *
+ * @param {object} agentInfo - Agent `/info` response
+ * @param {object} options - Selection options
+ * @param {string[]} options.supportedPaths - Supported paths in preference order
+ * @param {string[]} [options.requiredHeaders] - Headers that the proxy must forward unchanged to intake. Each
+ * header must appear in `evp_proxy_allowed_headers`. Do not include routing headers that the Agent consumes.
+ * @returns {string|undefined} Selected normalized path
+ */
+function selectEVPProxyPath (agentInfo, { supportedPaths, requiredHeaders = [] } = {}) {
+  if (!Array.isArray(agentInfo?.endpoints) ||
+      !Array.isArray(supportedPaths) ||
+      !Array.isArray(requiredHeaders) ||
+      requiredHeaders.some(header => typeof header !== 'string')) {
+    return
+  }
+
+  const allowedHeaders = agentInfo.evp_proxy_allowed_headers
+  if (allowedHeaders !== undefined) {
+    if (!Array.isArray(allowedHeaders)) return
+
+    const normalizedHeaders = new Set()
+    for (const header of allowedHeaders) {
+      if (typeof header === 'string') {
+        normalizedHeaders.add(header.toLowerCase())
+      }
+    }
+
+    if (requiredHeaders.some(header => !normalizedHeaders.has(header.toLowerCase()))) {
+      return
+    }
+  }
+
+  const advertisedPaths = new Set()
+  for (const endpoint of agentInfo.endpoints) {
+    if (typeof endpoint === 'string') {
+      advertisedPaths.add(endpoint.replace(TRAILING_SLASHES, ''))
+    }
+  }
+
+  for (const supportedPath of supportedPaths) {
+    if (typeof supportedPath !== 'string') continue
+
+    const normalizedPath = supportedPath.replace(TRAILING_SLASHES, '')
+    if (advertisedPaths.has(normalizedPath)) {
+      return normalizedPath
+    }
+  }
+}
+
+/**
+ * Discovers an EVP proxy route through the configured Agent URL.
+ *
+ * This function performs discovery only when the caller invokes it. It stores
+ * no state. The Agent information client owns its existing response cache.
+ *
+ * @param {URL} url - Configured Agent URL
+ * @param {object} options - Selection options
+ * @param {string[]} options.supportedPaths - Supported paths in preference order
+ * @param {string[]} [options.requiredHeaders] - Headers that the proxy must forward unchanged to intake. Each
+ * header must appear in `evp_proxy_allowed_headers`. Do not include routing headers that the Agent consumes.
+ * @param {(error: Error|null, route?: {url: URL, basePath: string}) => void} callback - Result callback
+ * @returns {void}
+ */
+function discoverEVPProxy (url, options, callback) {
+  fetchAgentInfo(url, (error, agentInfo) => {
+    if (error) {
+      callback(error)
+      return
+    }
+
+    const basePath = selectEVPProxyPath(agentInfo, options)
+    if (basePath === undefined) {
+      callback(null)
+      return
+    }
+
+    log.debug('EVP proxy route %s discovered through the configured local receiver', basePath)
+    callback(null, { url, basePath })
+  })
+}
+
+module.exports = {
+  discoverEVPProxy,
+  selectEVPProxyPath,
+}

package/packages/dd-trace/src/evp_proxy/path.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const LEADING_SLASHES = /^\/+/
+const TRAILING_SLASHES = /\/+$/
+
+/**
+ * Joins a caller-supplied EVP proxy path and product endpoint.
+ *
+ * This utility does not perform EVP proxy discovery.
+ *
+ * @param {string} basePath - EVP proxy base path
+ * @param {string} endpoint - Product intake endpoint
+ * @returns {string} Joined request path
+ */
+function joinEVPProxyPath (basePath, endpoint) {
+  const normalizedBasePath = basePath.replace(TRAILING_SLASHES, '')
+  const normalizedEndpoint = endpoint.replace(LEADING_SLASHES, '')
+
+  return `${normalizedBasePath}/${normalizedEndpoint}`
+}
+
+module.exports = { joinEVPProxyPath }

package/packages/dd-trace/src/exporters/agent/writer.js

@@ -3,7 +3,7 @@
 const { inspect } = require('node:util')
 const { channel } = require('dc-polyfill')
 
-const request = require('../common/request')
+const commonRequest = require('../common/request')
 const { logIntegrations, logAgentError } = require('../../startup-log')
 const runtimeMetrics = require('../../runtime_metrics')
 const log = require('../../log')
@@ -15,12 +15,15 @@ const METRIC_PREFIX = 'datadog.tracer.node.exporter.agent'
 const firstFlushChannel = channel('dd-trace:exporter:first-flush')
 
 class AgentWriter extends BaseWriter {
+  #request = commonRequest
+  #requestTracker
+
   constructor (...args) {
     super({
       ...args[0],
       beforeFirstFlush: () => firstFlushChannel.publish(),
     })
-    const { prioritySampler, lookup, protocolVersion, headers } = args[0]
+    const { prioritySampler, lookup, protocolVersion, headers, isTestOptimization } = args[0]
     const AgentEncoder = getEncoder(protocolVersion)
 
     this._prioritySampler = prioritySampler
@@ -28,13 +31,33 @@ class AgentWriter extends BaseWriter {
     this._protocolVersion = protocolVersion
     this._headers = headers
     this._encoder = new AgentEncoder(this)
+    if (isTestOptimization) {
+      this.#request = require('../../ci-visibility/exporters/request')
+      const TestOptimizationRequestTracker = require('../../ci-visibility/exporters/agentless/request-tracker')
+      this.#requestTracker = new TestOptimizationRequestTracker(this)
+    }
+  }
+
+  /**
+   * Flushes payloads, including requests already in flight during Test Optimization finalization.
+   *
+   * @param {(error?: Error) => void} [done]
+   * @param {{ deadline?: number }} [options]
+   * @returns {void}
+   */
+  flush (done, options) {
+    if (this.#requestTracker) {
+      this.#requestTracker.flush(done, options)
+      return
+    }
+    super.flush(done, options)
   }
 
-  _sendPayload (data, count, done) {
+  _sendPayload (data, count, done, flushOptions) {
     runtimeMetrics.increment(`${METRIC_PREFIX}.requests`, true)
 
     const { _headers, _lookup, _protocolVersion, _url } = this
-    makeRequest(_protocolVersion, data, count, _url, _headers, _lookup, (err, res, status, headers) => {
+    const onResponse = (err, res, status, headers) => {
       if (status) {
         runtimeMetrics.increment(`${METRIC_PREFIX}.responses`, true)
         runtimeMetrics.increment(`${METRIC_PREFIX}.responses.by.status`, `status:${status}`, true)
@@ -49,7 +72,7 @@ class AgentWriter extends BaseWriter {
 
       if (err) {
         log.errorWithoutTelemetry('Error sending payload to the agent (status code: %s)', err.status, err)
-        done()
+        done(flushOptions?.deadline === undefined ? undefined : err)
         return
       }
 
@@ -74,7 +97,19 @@ class AgentWriter extends BaseWriter {
         runtimeMetrics.increment(`${METRIC_PREFIX}.errors.by.name`, `name:${e.name}`, true)
       }
       done()
-    })
+    }
+    makeRequest(
+      _protocolVersion,
+      data,
+      count,
+      _url,
+      _headers,
+      _lookup,
+      flushOptions,
+      this.#request,
+      this.#requestTracker,
+      onResponse
+    )
   }
 }
 
@@ -84,7 +119,7 @@ function getEncoder (protocolVersion) {
     : require('../../encode/0.4').AgentEncoder
 }
 
-function makeRequest (version, data, count, url, headers, lookup, cb) {
+function makeRequest (version, data, count, url, headers, lookup, flushOptions, request, requestTracker, cb) {
   const options = {
     path: `/v${version}/traces`,
     method: 'PUT',
@@ -100,16 +135,21 @@ function makeRequest (version, data, count, url, headers, lookup, cb) {
     lookup,
     url,
   }
+  if (flushOptions?.deadline !== undefined) {
+    options.deadline = flushOptions.deadline
+  }
 
   log.debug('Request to the agent: %j', options)
 
-  request(data, options, (err, res, status, headers) => {
+  const onResponse = (err, res, status, headers) => {
     logIntegrations()
     if (status !== 404 && status !== 200 && err) {
       logAgentError({ status, message: err.message ?? inspect(err) })
     }
     cb(err, res, status, headers)
-  })
+  }
+  if (requestTracker) requestTracker.send(request, data, options, onResponse)
+  else request(data, options, onResponse)
 }
 
 module.exports = AgentWriter