dd-trace 6.10.0 → 6.12.0

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

@@ -0,0 +1,201 @@
+'use strict'
+
+const { Readable } = require('node:stream')
+
+const commonRequest = require('../../exporters/common/request')
+const {
+  RATE_LIMIT_MAX_WAIT_MS,
+  getMaxAttempts,
+  getRetryDelay,
+  isRetriableNetworkError,
+} = require('../../exporters/common/retry')
+const { getRateLimitResetDelay } = require('../requests/rate-limit')
+
+/**
+ * @param {AbortSignal} signal
+ * @returns {Error}
+ */
+function getAbortError (signal) {
+  return signal.reason || Object.assign(new Error('Request aborted'), { code: 'ABORT_ERR' })
+}
+
+/**
+ * Buffers a stream once so a Test Optimization exporter request can safely retry it.
+ *
+ * @param {Readable} data
+ * @param {AbortSignal} [signal]
+ * @param {(error: Error|null, data?: Buffer) => void} callback
+ * @returns {void}
+ */
+function bufferReadable (data, signal, callback) {
+  const chunks = []
+  let settled = false
+
+  const cleanup = (keepErrorListener = false) => {
+    data.removeListener('data', onData)
+    data.removeListener('end', onEnd)
+    if (!keepErrorListener) data.removeListener('error', onError)
+    signal?.removeEventListener('abort', onAbort)
+  }
+  const onData = chunk => chunks.push(chunk)
+  const onEnd = () => {
+    if (settled) return
+    settled = true
+    cleanup()
+    callback(null, Buffer.concat(chunks))
+  }
+  const onError = error => {
+    if (settled) return
+    settled = true
+    cleanup()
+    callback(error)
+  }
+  const onAbort = () => {
+    if (settled) return
+    settled = true
+    cleanup(true)
+    data.once('close', () => data.removeListener('error', onError))
+    data.destroy()
+    callback(getAbortError(signal))
+  }
+
+  data.on('data', onData)
+  data.once('end', onEnd)
+  data.once('error', onError)
+  signal?.addEventListener('abort', onAbort, { once: true })
+  if (signal?.aborted) onAbort()
+}
+
+/**
+ * Sends Test Optimization exporter data through the common single-attempt transport while
+ * keeping retry and finalization policy scoped to Test Optimization.
+ *
+ * @param {Buffer|string|Readable|Array<Buffer|string>} data
+ * @param {object} options
+ * @param {(error: Error|null, result?: string|null, statusCode?: number,
+ *   headers?: import('node:http').IncomingHttpHeaders) => void} callback
+ * @returns {void}
+ */
+function request (data, options, callback) {
+  const { signal } = options
+  if (signal?.aborted) return callback(getAbortError(signal))
+
+  if (data instanceof Readable) {
+    bufferReadable(data, signal, (error, bufferedData) => {
+      if (error) return callback(error)
+      requestBuffered(bufferedData, options, callback)
+    })
+    return
+  }
+
+  requestBuffered(data, options, callback)
+}
+
+/**
+ * Applies the Test Optimization retry policy to replayable request data.
+ *
+ * @param {Buffer|string|Array<Buffer|string>} data
+ * @param {object} options
+ * @param {(error: Error|null, result?: string|null, statusCode?: number,
+ *   headers?: import('node:http').IncomingHttpHeaders) => void} callback
+ * @returns {void}
+ */
+function requestBuffered (data, options, callback) {
+  const { signal } = options
+  const timeout = options.timeout || 2000
+  let retryTimer
+  let settled = false
+
+  const complete = (error, result, statusCode, headers) => {
+    if (settled) return
+    settled = true
+    clearTimeout(retryTimer)
+    signal?.removeEventListener('abort', onAbort)
+    callback(error, result, statusCode, headers)
+  }
+  const onAbort = () => complete(getAbortError(signal))
+
+  signal?.addEventListener('abort', onAbort, { once: true })
+  if (signal?.aborted) return onAbort()
+
+  /** @param {number} attemptIndex */
+  const attempt = attemptIndex => {
+    if (settled) return
+    if (signal?.aborted) return onAbort()
+
+    const deadline = options.deadline
+    const remaining = deadline === undefined ? Infinity : deadline - Date.now()
+    if (remaining <= 0) {
+      const error = new Error('Test Optimization request reached its finalization deadline')
+      error.code = 'ERR_DD_TEST_OPTIMIZATION_FLUSH_TIMEOUT'
+      complete(error)
+      return
+    }
+
+    if (deadline !== undefined && !commonRequest.writable) {
+      retryTimer = setTimeout(attempt, Math.min(50, remaining), attemptIndex)
+      retryTimer.unref?.()
+      return
+    }
+
+    const attemptOptions = {
+      ...options,
+      headers: options.headers ? { ...options.headers } : undefined,
+      retry: false,
+    }
+    if (deadline !== undefined) attemptOptions.timeout = Math.max(1, Math.min(timeout, remaining))
+
+    commonRequest(data, attemptOptions, (error, result, statusCode, headers) => {
+      if (settled) return
+      if (!error) {
+        complete(null, result, statusCode, headers)
+        return
+      }
+
+      const responseStatus = statusCode ?? error.status
+      const isRetriableHttpError = options.deadline !== undefined &&
+        (responseStatus === 429 || responseStatus >= 500)
+      if (options.retry === false || (attemptIndex >= getMaxAttempts(attemptOptions) &&
+        (isRetriableNetworkError(error) || isRetriableHttpError))) {
+        complete(error, result, statusCode, headers)
+        return
+      }
+
+      if (!isRetriableNetworkError(error) && !isRetriableHttpError) {
+        complete(error, result, statusCode, headers)
+        return
+      }
+
+      let retryDelay
+      if (responseStatus === 429) {
+        const resetDelay = getRateLimitResetDelay(headers)
+        if (Number.isFinite(resetDelay)) {
+          const retryRemaining = options.deadline - Date.now()
+          if (resetDelay > RATE_LIMIT_MAX_WAIT_MS || resetDelay >= retryRemaining) {
+            complete(error, result, statusCode, headers)
+            return
+          }
+          retryDelay = resetDelay
+        }
+      }
+
+      let delay = retryDelay ?? getRetryDelay(attemptOptions, attemptIndex)
+      if (options.deadline !== undefined && retryDelay === undefined) {
+        const retryRemaining = options.deadline - Date.now()
+        if (retryRemaining <= 0) {
+          complete(error, result, statusCode, headers)
+          return
+        }
+        const retryAttemptTimeout = timeout < retryRemaining ? timeout : Math.ceil(retryRemaining / 2)
+        delay = Math.min(delay, Math.max(0, retryRemaining - retryAttemptTimeout))
+      }
+
+      retryTimer = setTimeout(attempt, delay, attemptIndex + 1)
+      retryTimer.unref?.()
+    })
+  }
+
+  attempt(1)
+}
+
+module.exports = request

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

@@ -1,7 +1,8 @@
 '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 log = require('../../log')
 const {
   incrementCountMetric,
@@ -13,6 +14,7 @@ const {
   TELEMETRY_ITR_SKIPPABLE_TESTS_RESPONSE_TESTS,
   TELEMETRY_ITR_SKIPPABLE_TESTS_RESPONSE_BYTES,
 } = require('../../ci-visibility/telemetry')
+const request = require('../requests/request')
 const { buildCacheKey, writeToCache, withCache } = require('../requests/fs-cache')
 const { validateSkippableTestsResponse } = require('../test-optimization-http-cache-schema')
 
@@ -34,10 +36,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
     }
   }
@@ -226,8 +229,8 @@ function fetchFromApi ({
   }
 
   if (isEvpProxy) {
-    options.path = `${evpProxyPrefix}/api/v2/ci/tests/skippable`
-    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    options.path = joinEVPProxyPath(evpProxyPrefix, '/api/v2/ci/tests/skippable')
+    options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'api'
   } else {
     const { DD_API_KEY } = getConfig()
     if (!DD_API_KEY) {

package/packages/dd-trace/src/ci-visibility/requests/get-library-configuration.js

@@ -1,6 +1,8 @@
 'use strict'
 
 const getConfig = require('../../config')
+const { EVP_SUBDOMAIN_HEADER_NAME } = require('../../evp_proxy/constants')
+const { joinEVPProxyPath } = require('../../evp_proxy/path')
 const id = require('../../id')
 const log = require('../../log')
 const { EARLY_FLAKE_DETECTION_RETRY_BUCKETS, createEfdRetryPolicy } = require('../efd-retry-policy')
@@ -238,8 +240,8 @@ function getLibraryConfiguration ({
   }
 
   if (isEvpProxy) {
-    options.path = `${evpProxyPrefix}/api/v2/libraries/tests/services/setting`
-    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    options.path = joinEVPProxyPath(evpProxyPrefix, '/api/v2/libraries/tests/services/setting')
+    options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'api'
   } else {
     if (!config.DD_API_KEY) {
       return done(new Error('Request to settings endpoint was not done because Datadog API key is not defined.'))

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-coverage-report.js

@@ -4,6 +4,8 @@ const { closeSync, constants, fstatSync, openSync, readFileSync } = require('nod
 const { gzipSync } = require('node:zlib')
 
 const getConfig = require('../../config')
+const { EVP_SUBDOMAIN_HEADER_NAME } = require('../../evp_proxy/constants')
+const { joinEVPProxyPath } = require('../../evp_proxy/path')
 const FormData = require('../../exporters/common/form-data')
 const request = require('../../exporters/common/request')
 const log = require('../../log')
@@ -98,8 +100,8 @@ function uploadCoverageReport (
   }
 
   if (isEvpProxy) {
-    options.path = `${evpProxyPrefix}/api/v2/cicovreprt`
-    options.headers['X-Datadog-EVP-Subdomain'] = 'ci-intake'
+    options.path = joinEVPProxyPath(evpProxyPrefix, '/api/v2/cicovreprt')
+    options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'ci-intake'
   } else {
     options.path = '/api/v2/cicovreprt'
     options.headers['dd-api-key'] = DD_API_KEY

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

@@ -4,8 +4,10 @@ const { readFileSync } = require('node:fs')
 const { extname } = require('node:path')
 
 const getConfig = require('../../config')
-const request = require('../../exporters/common/request')
+const { EVP_SUBDOMAIN_HEADER_NAME } = require('../../evp_proxy/constants')
+const { joinEVPProxyPath } = require('../../evp_proxy/path')
 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 +76,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,13 +129,15 @@ function uploadTestScreenshot (
     path: `${basePath}?${query}`,
     timeout: UPLOAD_TIMEOUT_MS,
     url,
+    deadline,
+    signal,
   }
 
   if (isEvpProxy) {
     // Agent mode: prefix the evp_proxy path, tell the proxy which subdomain to forward to, and
     // drop the API key — the Agent injects it. The query params survive the proxy.
-    options.path = `${evpProxyPrefix}${basePath}?${query}`
-    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    options.path = `${joinEVPProxyPath(evpProxyPrefix, basePath)}?${query}`
+    options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'api'
   } else {
     options.headers['DD-API-KEY'] = DD_API_KEY
   }

package/packages/dd-trace/src/ci-visibility/test-management/get-test-management-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,7 +14,7 @@ const {
   TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_TESTS,
   TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_BYTES,
 } = require('../telemetry')
-
+const request = require('../requests/request')
 const { buildCacheKey, writeToCache, withCache } = require('../requests/fs-cache')
 const { validateTestManagementTestsResponse } = require('../test-optimization-http-cache-schema')
 
@@ -132,8 +132,8 @@ function fetchFromApi ({
   }
 
   if (isEvpProxy) {
-    options.path = `${evpProxyPrefix}/api/v2/test/libraries/test-management/tests`
-    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    options.path = joinEVPProxyPath(evpProxyPrefix, '/api/v2/test/libraries/test-management/tests')
+    options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'api'
   } else {
     const { DD_API_KEY } = getConfig()
     if (!DD_API_KEY) {

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