dd-trace 6.9.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;
@@ -272,6 +273,7 @@ export interface GeneratedConfig {
   DD_TRACE_HAPI_HAPI_ENABLED: boolean;
   DD_TRACE_HONO_ENABLED: boolean;
   DD_TRACE_HTTP_ENABLED: boolean;
+  DD_TRACE_HTTP_SERVER_ERROR_STATUSES: string;
   DD_TRACE_HTTP2_ENABLED: boolean;
   DD_TRACE_HTTPS_ENABLED: boolean;
   DD_TRACE_IOREDIS_ENABLED: boolean;
@@ -339,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;
@@ -727,6 +730,7 @@ export interface GeneratedEnvVarConfig {
   DD_HEAP_SNAPSHOT_COUNT: number;
   DD_HEAP_SNAPSHOT_DESTINATION: string;
   DD_HEAP_SNAPSHOT_INTERVAL: number;
+  DD_HTTP_SERVER_ERROR_STATUSES: string;
   DD_IAST_DB_ROWS_TO_TAINT: number;
   DD_IAST_DEDUPLICATION_ENABLED: boolean;
   DD_IAST_ENABLED: boolean;
@@ -892,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;
@@ -966,6 +971,7 @@ export interface GeneratedEnvVarConfig {
   DD_TRACE_HEADER_TAGS: string[];
   DD_TRACE_HONO_ENABLED: boolean;
   DD_TRACE_HTTP_ENABLED: boolean;
+  DD_TRACE_HTTP_SERVER_ERROR_STATUSES: string;
   DD_TRACE_HTTP2_ENABLED: boolean;
   DD_TRACE_HTTPS_ENABLED: boolean;
   DD_TRACE_INFERRED_PROXY_SERVICES_ENABLED: boolean;
@@ -1037,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",
@@ -2999,6 +3006,16 @@
         "default": "true"
       }
     ],
+    "DD_TRACE_HTTP_SERVER_ERROR_STATUSES": [
+      {
+        "implementation": "A",
+        "type": "string",
+        "default": "500-599",
+        "aliases": [
+          "DD_HTTP_SERVER_ERROR_STATUSES"
+        ]
+      }
+    ],
     "DD_TRACE_INFERRED_PROXY_SERVICES_ENABLED": [
       {
         "implementation": "A",
@@ -3508,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/context.js

@@ -13,7 +13,12 @@ function getDataStreamsContext () {
 function setDataStreamsContext (dataStreamsContext) {
   log.debug('Setting new DSM Context: %j.', dataStreamsContext)
 
-  if (dataStreamsContext) legacyStorage.enterWith({ ...legacyStorage.getStore(), dataStreamsContext })
+  // `undefined` clears: a message that carries no context must not inherit the previous message's.
+  // The identity check keeps the common no-context case from allocating a store per message.
+  const store = legacyStorage.getStore()
+  if (store?.dataStreamsContext !== dataStreamsContext) {
+    legacyStorage.enterWith({ ...store, dataStreamsContext })
+  }
 }
 
 module.exports = {

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,17 +8,28 @@ 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
   }
 
+  /**
+   * @param {Record<string, string>|undefined} carrier Pass every message's carrier, including the
+   *   ones without a context: that is what starts a new pathway instead of extending the previous
+   *   message's.
+   */
   decodeDataStreamsContext (carrier) {
     const ctx = DsmPathwayCodec.decode(carrier)
-    // we erase the previous context everytime we decode a new one
     DataStreamsContext.setDataStreamsContext(ctx)
     return ctx
   }

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

@@ -5,23 +5,25 @@
 // this inconsistency is ok because hashes do not need to be consistent across services
 const crypto = require('crypto')
 const { LRUCache } = require('../../../../vendor/dist/lru-cache')
+const {
+  hasDsmBase64,
+  hasDsmBinary,
+  pickDsm,
+  readDsmBase64,
+  readDsmBinary,
+  writeDsmBase64,
+} = require('../carrier')
 const log = require('../log')
-const pick = require('../../../datadog-core/src/utils/src/pick')
 const { encodeVarintInto, decodeVarint } = require('./encoding')
 
 const cache = new LRUCache({ max: 500 })
 
-const CONTEXT_PROPAGATION_KEY = 'dd-pathway-ctx'
-const CONTEXT_PROPAGATION_KEY_BASE64 = 'dd-pathway-ctx-base64'
-
 const PATHWAY_CONTEXT_BYTES = 20
 
 // Reused across `encodePathwayContext` calls; the buffer is fully rewritten before each
 // `Buffer.from(...)` copy-out so callers never observe mutation between checkpoints.
 const pathwayScratch = Buffer.allocUnsafe(PATHWAY_CONTEXT_BYTES)
 
-const logKeys = [CONTEXT_PROPAGATION_KEY, CONTEXT_PROPAGATION_KEY_BASE64]
-
 function shaHash (checkpointString) {
   // Copy out of the 32-byte digest so the LRU cache doesn't retain it.
   return Buffer.from(crypto.createHash('sha256').update(checkpointString).digest().subarray(0, 8))
@@ -114,7 +116,7 @@ function decodePathwayContext (pathwayContext) {
 }
 
 /**
- * @param {string} pathwayContext
+ * @param {string | Buffer} pathwayContext
  * @returns {ReturnType<typeof decodePathwayContext>|undefined}
  */
 function decodePathwayContextBase64 (pathwayContext) {
@@ -142,10 +144,10 @@ const DsmPathwayCodec = {
   encode (dataStreamsContext, carrier) {
     if (!dataStreamsContext || !dataStreamsContext.hash) return
     carrier ??= {}
-    carrier[CONTEXT_PROPAGATION_KEY_BASE64] = encodePathwayContextBase64(dataStreamsContext)
+    writeDsmBase64(carrier, encodePathwayContextBase64(dataStreamsContext))
 
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
-    log.debug(() => `Injected into DSM carrier: ${JSON.stringify(pick(carrier, logKeys))}.`)
+    log.debug(() => `Injected into DSM carrier: ${JSON.stringify(pickDsm(carrier))}.`)
 
     return carrier
   },
@@ -155,25 +157,25 @@ const DsmPathwayCodec = {
    * @returns {ReturnType<typeof decodePathwayContext>|undefined}
    */
   decode (carrier) {
-    // eslint-disable-next-line eslint-rules/eslint-log-printf-style
-    log.debug(() => `Attempting extract from DSM carrier: ${JSON.stringify(pick(carrier, logKeys))}.`)
-
     if (carrier == null) return
 
+    // eslint-disable-next-line eslint-rules/eslint-log-printf-style
+    log.debug(() => `Attempting extract from DSM carrier: ${JSON.stringify(pickDsm(carrier))}.`)
+
     let ctx
-    if (CONTEXT_PROPAGATION_KEY_BASE64 in carrier) {
+    if (hasDsmBase64(carrier)) {
       // decode v2 encoding of base64
-      ctx = decodePathwayContextBase64(carrier[CONTEXT_PROPAGATION_KEY_BASE64])
-    } else if (CONTEXT_PROPAGATION_KEY in carrier) {
-      try {
+      const encoded = readDsmBase64(carrier)
+      if (encoded !== undefined) ctx = decodePathwayContextBase64(encoded)
+    } else if (hasDsmBinary(carrier)) {
+      const encoded = readDsmBinary(carrier)
+      if (Buffer.isBuffer(encoded)) {
         // decode v1 encoding
-        ctx = decodePathwayContext(carrier[CONTEXT_PROPAGATION_KEY])
-      } catch {
-        // pass
+        ctx = decodePathwayContext(encoded)
       }
       // cover case where base64 context was received under wrong key
-      if (!ctx && CONTEXT_PROPAGATION_KEY in carrier) {
-        ctx = decodePathwayContextBase64(carrier[CONTEXT_PROPAGATION_KEY])
+      if (!ctx && encoded !== undefined) {
+        ctx = decodePathwayContextBase64(encoded)
       }
     }
 
@@ -182,7 +184,6 @@ const DsmPathwayCodec = {
 }
 
 module.exports = {
-  CONTEXT_PROPAGATION_KEY_BASE64,
   computePathwayHash: computeHash,
   encodePathwayContext,
   decodePathwayContext,

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

@@ -8,21 +8,14 @@ const { PATHWAY_HASH, DSM_TRANSACTION_ID, DSM_TRANSACTION_CHECKPOINT } = require
 const log = require('../log')
 const processTags = require('../process-tags')
 const propagationHash = require('../propagation-hash')
-const { CONTEXT_PROPAGATION_KEY_BASE64, computePathwayHash } = require('./pathway')
+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 = CONTEXT_PROPAGATION_KEY_BASE64.length + 28 + 6
-
 class StatsPoint {
   constructor (hash, parentHash, edgeTags) {
     this.hash = hash.readBigUInt64LE()
@@ -289,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
@@ -337,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() }
 })()`