dd-trace 6.10.0 → 6.11.0

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

@@ -127,7 +127,7 @@ class TestWorkerCiVisibilityExporter {
   }
 
   /**
-   * @param {() => void} [onDone]
+   * @param {(error?: Error) => void} [onDone]
    */
   flush (onDone) {
     if (!onDone) {
@@ -141,9 +141,11 @@ class TestWorkerCiVisibilityExporter {
     }
 
     let pendingWriters = this._telemetryWriter ? 4 : 3
-    const onWriterFlushed = () => {
+    let flushError
+    const onWriterFlushed = (error) => {
+      flushError ||= error
       pendingWriters--
-      if (pendingWriters === 0) onDone()
+      if (pendingWriters === 0) onDone(flushError)
     }
 
     this._writer.flush(onWriterFlushed)

package/packages/dd-trace/src/ci-visibility/exporters/test-worker/writer.js

@@ -21,7 +21,7 @@ class Writer {
   }
 
   /**
-   * @param {() => void} [onDone]
+   * @param {(error?: Error) => void} [onDone]
    */
   flush (onDone) {
     const count = this._encoder.count()
@@ -69,8 +69,9 @@ class Writer {
 
     // child_process workers (jest default, cucumber)
     if (process.send) {
-      process.send(payload, () => {
-        onDone()
+      process.send(payload, (error) => {
+        if (error) log.error('Error sending message to parent process', error)
+        onDone(error)
       })
       return
     }
@@ -82,9 +83,12 @@ class Writer {
         parentPort.postMessage(payload)
       } catch (error) {
         log.error('Error posting message to parent port', error)
-      } finally {
-        onDone()
+        onDone(error)
+        return
       }
+      // postMessage has no acknowledgement callback. Completion means the
+      // message was accepted by the local port, not processed by the parent.
+      onDone()
       return
     }
 

package/packages/dd-trace/src/ci-visibility/intelligent-test-runner/get-skippable-suites.js

@@ -34,10 +34,11 @@ function parseSkippableSuitesResponse (
   if (validateRequiredFields) {
     validateSkippableTestsResponse(parsedResponse, { validationMode })
   }
-  const coverage = {}
+  let coverage
   const coverageByFilename = parsedResponse.meta?.coverage
   if (coverageByFilename) {
     for (const [filename, bitmap] of Object.entries(coverageByFilename)) {
+      coverage ??= {}
       coverage[filename.replaceAll('\\', '/')] = bitmap
     }
   }

package/packages/dd-trace/src/ci-visibility/requests/rate-limit.js

@@ -0,0 +1,39 @@
+'use strict'
+
+const EPOCH_SECONDS_THRESHOLD = 1_000_000_000
+
+/**
+ * Returns the delay requested by a Test Optimization intake rate-limit response.
+ *
+ * @param {import('node:http').IncomingHttpHeaders} [headers]
+ * @returns {number}
+ */
+function getRateLimitResetDelay (headers) {
+  let retryAfter = headers?.['retry-after']
+  if (Array.isArray(retryAfter)) retryAfter = retryAfter[0]
+  if (typeof retryAfter === 'string' && retryAfter.trim() !== '') {
+    const delaySeconds = Number(retryAfter)
+    if (Number.isFinite(delaySeconds)) {
+      if (delaySeconds >= 0) return delaySeconds * 1000
+    } else {
+      const resetTimestamp = Date.parse(retryAfter)
+      if (Number.isFinite(resetTimestamp)) return Math.max(0, resetTimestamp - Date.now())
+    }
+  }
+
+  let reset = headers?.['x-ratelimit-reset']
+  if (Array.isArray(reset)) reset = reset[0]
+  if (typeof reset !== 'string' || reset.trim() === '') return NaN
+
+  const resetSeconds = Number(reset)
+  if (!Number.isFinite(resetSeconds) || resetSeconds < 0) return NaN
+
+  // Datadog defines this header as delay seconds. Preserve compatibility with
+  // realistic Unix timestamps without confusing ordinary durations with epochs.
+  if (resetSeconds >= EPOCH_SECONDS_THRESHOLD) {
+    return Math.max(0, resetSeconds * 1000 - Date.now())
+  }
+  return resetSeconds * 1000
+}
+
+module.exports = { getRateLimitResetDelay }

package/packages/dd-trace/src/ci-visibility/requests/request.js

@@ -13,12 +13,13 @@ const {
   singleJitteredDelay,
 } = require('../../exporters/common/retry')
 const { parseUrl } = require('../../exporters/common/url')
+const { getRateLimitResetDelay } = require('./rate-limit')
 
 const legacyStorage = storage('legacy')
 
 /**
  * Simplified HTTP request for test optimization (library config). Uses common HTTP agents.
- * Retries: 429 (with X-ratelimit-reset, max 30s wait),
+ * Retries: 429 (with Retry-After or X-RateLimit-Reset, max 30s wait),
  * >=500 and transient network errors (5–7.5s delay with jitter). Max one retry.
  * Destroys connections on errors to prevent reuse of bad connections. Preserves
  * original status code across retries for telemetry.
@@ -98,11 +99,7 @@ function request (data, options, callback) {
           }
 
           if (res.statusCode === 429 && !hasRetried) {
-            const resetHeader = res.headers['x-ratelimit-reset']
-            const resetTs = (resetHeader === null || resetHeader === undefined)
-              ? NaN
-              : Number.parseInt(resetHeader, 10)
-            const waitMs = Number.isFinite(resetTs) ? Math.max(0, resetTs * 1000 - Date.now()) : NaN
+            const waitMs = getRateLimitResetDelay(res.headers)
 
             if (Number.isFinite(waitMs) && waitMs <= RATE_LIMIT_MAX_WAIT_MS) {
               hasRetried = true

package/packages/dd-trace/src/ci-visibility/requests/upload-test-screenshot.js

@@ -4,8 +4,8 @@ const { readFileSync } = require('node:fs')
 const { extname } = require('node:path')
 
 const getConfig = require('../../config')
-const request = require('../../exporters/common/request')
 const log = require('../../log')
+const request = require('../exporters/request')
 
 const UPLOAD_TIMEOUT_MS = 30_000
 const TEST_SCREENSHOT_ENDPOINT_PREFIX = '/api/v2/ci/test-runs/'
@@ -74,10 +74,12 @@ function toIdempotencyQueryValue (idempotencyKey) {
  * @param {URL} options.url - The base URL for the screenshot upload
  * @param {boolean} [options.isEvpProxy] - Whether to upload through the Agent's evp_proxy
  * @param {string} [options.evpProxyPrefix] - The evp_proxy path prefix (e.g. '/evp_proxy/v4')
+ * @param {number} [options.deadline] - Absolute finalization deadline in epoch milliseconds
+ * @param {AbortSignal} [options.signal] - Signal used to cancel the upload
  * @param {Function} callback - Callback function (err)
  */
 function uploadTestScreenshot (
-  { filePath, traceId, idempotencyKey, capturedAtMs, url, isEvpProxy, evpProxyPrefix },
+  { filePath, traceId, idempotencyKey, capturedAtMs, url, isEvpProxy, evpProxyPrefix, deadline, signal },
   callback
 ) {
   const { DD_API_KEY } = getConfig()
@@ -125,6 +127,8 @@ function uploadTestScreenshot (
     path: `${basePath}?${query}`,
     timeout: UPLOAD_TIMEOUT_MS,
     url,
+    deadline,
+    signal,
   }
 
   if (isEvpProxy) {

package/packages/dd-trace/src/config/generated-config-types.d.ts

@@ -209,6 +209,7 @@ export interface GeneratedConfig {
   DD_TRACE_BEAUTIFUL_LOGS: boolean;
   DD_TRACE_BLUEBIRD_ENABLED: boolean;
   DD_TRACE_BODY_PARSER_ENABLED: boolean;
+  DD_TRACE_BROWSER_BUNYAN_ENABLED: boolean;
   DD_TRACE_BSON_ENABLED: boolean;
   DD_TRACE_BULLMQ_ENABLED: boolean;
   DD_TRACE_BUNYAN_ENABLED: boolean;
@@ -340,6 +341,7 @@ export interface GeneratedConfig {
   DD_TRACE_OPENSEARCH_PROJECT_OPENSEARCH_ENABLED: boolean;
   DD_TRACE_OPENTELEMETRY_SDK_TRACE_NODE_ENABLED: boolean;
   DD_TRACE_ORACLEDB_ENABLED: boolean;
+  DD_TRACE_OTEL_CTX_ENABLED: boolean;
   DD_TRACE_OTEL_ENABLED: boolean;
   DD_TRACE_OTEL_SEMANTICS_ENABLED: boolean;
   DD_TRACE_PASSPORT_ENABLED: boolean;
@@ -894,6 +896,7 @@ export interface GeneratedEnvVarConfig {
   DD_TRACE_BEAUTIFUL_LOGS: boolean;
   DD_TRACE_BLUEBIRD_ENABLED: boolean;
   DD_TRACE_BODY_PARSER_ENABLED: boolean;
+  DD_TRACE_BROWSER_BUNYAN_ENABLED: boolean;
   DD_TRACE_BSON_ENABLED: boolean;
   DD_TRACE_BULLMQ_ENABLED: boolean;
   DD_TRACE_BUNYAN_ENABLED: boolean;
@@ -1040,6 +1043,7 @@ export interface GeneratedEnvVarConfig {
   DD_TRACE_OPENSEARCH_PROJECT_OPENSEARCH_ENABLED: boolean;
   DD_TRACE_OPENTELEMETRY_SDK_TRACE_NODE_ENABLED: boolean;
   DD_TRACE_ORACLEDB_ENABLED: boolean;
+  DD_TRACE_OTEL_CTX_ENABLED: boolean;
   DD_TRACE_OTEL_ENABLED: boolean;
   DD_TRACE_OTEL_SEMANTICS_ENABLED: boolean;
   DD_TRACE_PARTIAL_FLUSH_MIN_SPANS: number;

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

@@ -15,6 +15,7 @@ const { isTrue } = require('../util')
 const telemetry = require('../telemetry')
 const telemetryMetrics = require('../telemetry/metrics')
 const {
+  getServerlessPlatformTags,
   IS_SERVERLESS,
   getIsGCPFunction,
   getIsAzureFunction,
@@ -477,9 +478,13 @@ class Config extends ConfigBase {
 
     // Apply the OTel sampler when the user opted into OTel traces or explicitly set the sampler.
     // OTEL_TRACES_SAMPLER has `default: parentbased_always_on` (per OTel spec), so opt-in users
-    // that don't set the sampler still get parent-based sampling.
+    // that don't set the sampler still get parent-based sampling. Electron exporter spans go over
+    // the Electron SDK's IPC bridge rather than OTLP (see opentracing/tracer.js), so an
+    // OTEL_TRACES_EXPORTER=otlp set for an unrelated telemetry pipeline shouldn't also override
+    // dd-trace's own sampling policy in that case.
     if (!trackedConfigOrigins.has('sampleRate') &&
-        (trackedConfigOrigins.has('OTEL_TRACES_SAMPLER') || this.OTEL_TRACES_EXPORTER === 'otlp')) {
+        (trackedConfigOrigins.has('OTEL_TRACES_SAMPLER') ||
+          (this.OTEL_TRACES_EXPORTER === 'otlp' && this.experimental.exporter !== 'electron'))) {
       setAndTrack(this, 'sampleRate',
         getFromOtelSamplerMap(this.OTEL_TRACES_SAMPLER, this.OTEL_TRACES_SAMPLER_ARG))
     }
@@ -597,6 +602,12 @@ class Config extends ConfigBase {
       this.tags.version = this.version
     }
     this.tags['runtime-id'] = RUNTIME_ID
+    const platformTags = getServerlessPlatformTags()
+    if (platformTags) {
+      for (let i = 0; i < platformTags.length; i += 2) {
+        this.tags[platformTags[i]] ??= platformTags[i + 1]
+      }
+    }
 
     if (IS_SERVERLESS) {
       setAndTrack(this, 'telemetry.DD_INSTRUMENTATION_TELEMETRY_ENABLED', false)

package/packages/dd-trace/src/config/major-overrides.js

@@ -58,6 +58,13 @@ function applyMajorOverrides (supportedConfigurations, majorVersion) {
   delete supportedConfigurations.DD_TRACE_EXPERIMENTAL_RUNTIME_ID_ENABLED
   // eslint-disable-next-line eslint-rules/eslint-env-aliases
   dropAlias(supportedConfigurations.DD_RUNTIME_METRICS_RUNTIME_ID_ENABLED, 'DD_TRACE_EXPERIMENTAL_RUNTIME_ID_ENABLED')
+
+  if (majorVersion >= 7) {
+    // The Electron plugin moved to the Electron SDK and is opt-in (disabled by default) from v7 on,
+    // while remaining enabled by default on earlier majors (see ElectronPlugin.optIn).
+    const electronEntry = supportedConfigurations.DD_TRACE_ELECTRON_ENABLED?.[0]
+    if (electronEntry) electronEntry.default = 'false'
+  }
 }
 
 /**

package/packages/dd-trace/src/config/supported-configurations.json

@@ -2452,6 +2452,13 @@
         "default": "true"
       }
     ],
+    "DD_TRACE_BROWSER_BUNYAN_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "true"
+      }
+    ],
     "DD_TRACE_BSON_ENABLED": [
       {
         "implementation": "A",
@@ -3518,6 +3525,13 @@
         "default": "false"
       }
     ],
+    "DD_TRACE_OTEL_CTX_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "false"
+      }
+    ],
     "DD_TRACE_PARTIAL_FLUSH_MIN_SPANS": [
       {
         "implementation": "B",

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

@@ -5,6 +5,7 @@ const {
   getHeadersSize,
   getMessageSize,
   getSizeOrZero,
+  PATHWAY_FIELD_BYTES,
 } = require('./size')
 
 // This is only needed because DSM code is spread across existing tracing
@@ -121,6 +122,7 @@ module.exports = {
   DataStreamsManager,
   DataStreamsProcessor,
   SchemaBuilder,
+  PATHWAY_FIELD_BYTES,
 
   // These are small functions so they are exposed directly and not lazy loaded.
   getAmqpMessageSize,

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

@@ -8,9 +8,16 @@ class DataStreamsManager {
     this._dataStreamsProcessor = processor
   }
 
-  setCheckpoint (edgeTags, span, payloadSize = 0) {
+  /**
+   * @param {string[]} edgeTags
+   * @param {import('../opentracing/span')|null} span
+   * @param {number} [payloadSize]
+   * @param {number} [pathwayContextSize] See `DataStreamsProcessor#setCheckpoint`.
+   * @returns {object|undefined}
+   */
+  setCheckpoint (edgeTags, span, payloadSize = 0, pathwayContextSize) {
     const ctx = this._dataStreamsProcessor.setCheckpoint(
-      edgeTags, span, DataStreamsContext.getDataStreamsContext(), payloadSize
+      edgeTags, span, DataStreamsContext.getDataStreamsContext(), payloadSize, pathwayContextSize
     )
     DataStreamsContext.setDataStreamsContext(ctx)
     return ctx

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/devtools_client/index.js

@@ -23,7 +23,6 @@ require('./remote_config')
 
 /** @typedef {import('node:inspector').Debugger.EvaluateOnCallFrameReturnType} EvaluateOnCallFrameResult */
 
-// 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 = {
@@ -34,8 +33,10 @@ const templateExpressionSetupCode = `
     breakLength: Infinity
   };
 `
+
+// Expression to run on a call frame of the paused thread to get its active trace and span id.
 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/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

package/packages/dd-trace/src/exporters/common/buffering-exporter.js

@@ -24,23 +24,25 @@ class BufferingExporter {
     this._export(trace)
   }
 
-  _export (payload, writer = this._writer, timerKey = '_timer') {
+  _export (payload, writer = this._writer, timerKey = '_timer', deferImmediateFlush = false) {
     if (this._config.isCiVisibility) {
       incrementCountMetric(TELEMETRY_EVENTS_ENQUEUED_FOR_SERIALIZATION, {}, payload.length)
     }
-    writer.append(payload)
+    const appended = writer.append(payload)
 
     const { flushInterval } = this._config
 
-    if (flushInterval === 0) {
+    if (flushInterval === 0 && !deferImmediateFlush) {
       writer.flush()
-    } else if (this[timerKey] === undefined) {
+    } else if (flushInterval !== 0 && this[timerKey] === undefined) {
       this[timerKey] = setTimeout(() => {
         writer.flush()
         this[timerKey] = undefined
       }, flushInterval)
       this[timerKey].unref?.()
     }
+
+    return appended
   }
 
   getUncodedTraces () {

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

@@ -17,10 +17,10 @@ class Writer {
 
   #isFirstFlush = true
 
-  flush (done = () => {}) {
+  flush (done = () => {}, options) {
     const count = this._encoder.count()
 
-    if (!request.writable) {
+    if (!request.writable && options?.deadline === undefined) {
       this._encoder.reset()
       done()
     } else if (count > 0) {
@@ -44,23 +44,28 @@ class Writer {
         done()
         return
       }
-      this._sendPayload(payload, count, done)
+      if (options === undefined) {
+        this._sendPayload(payload, count, done)
+      } else {
+        this._sendPayload(payload, count, done, options)
+      }
     } else {
       done()
     }
   }
 
-  append (payload) {
-    if (!request.writable) {
+  append (payload, options) {
+    if (!request.writable && options?.deadline === undefined) {
       // eslint-disable-next-line eslint-rules/eslint-log-printf-style
       log.debug(() => `Maximum number of active requests reached. Payload discarded: ${safeJSONStringify(payload)}`)
-      return
+      return false
     }
 
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
     log.debug(() => `Encoding payload: ${safeJSONStringify(payload)}`)
 
     this._encode(payload)
+    return true
   }
 
   _encode (payload) {