dd-trace 6.8.0 → 6.10.0

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

@@ -5,12 +5,17 @@ const {
   JEST_WORKER_TRACE_PAYLOAD_CODE,
   JEST_WORKER_TELEMETRY_PAYLOAD_CODE,
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
+  CUCUMBER_WORKER_TELEMETRY_PAYLOAD_CODE,
   MOCHA_WORKER_LOGS_PAYLOAD_CODE,
+  MOCHA_WORKER_TELEMETRY_PAYLOAD_CODE,
   MOCHA_WORKER_TRACE_PAYLOAD_CODE,
   JEST_WORKER_LOGS_PAYLOAD_CODE,
+  PLAYWRIGHT_WORKER_TELEMETRY_PAYLOAD_CODE,
   PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE,
   VITEST_WORKER_TRACE_PAYLOAD_CODE,
+  VITEST_WORKER_COVERAGE_PAYLOAD_CODE,
   VITEST_WORKER_LOGS_PAYLOAD_CODE,
+  VITEST_WORKER_TELEMETRY_PAYLOAD_CODE,
 } = require('../../../plugins/util/test')
 const getConfig = require('../../../config')
 const { getEnvironmentVariable } = require('../../../config/helper')
@@ -44,6 +49,9 @@ function getInterprocessCoverageCode () {
   if (getEnvironmentVariable('JEST_WORKER_ID')) {
     return JEST_WORKER_COVERAGE_PAYLOAD_CODE
   }
+  if (getEnvironmentVariable('TINYPOOL_WORKER_ID') || getConfig().DD_VITEST_WORKER) {
+    return VITEST_WORKER_COVERAGE_PAYLOAD_CODE
+  }
   return null
 }
 
@@ -67,6 +75,19 @@ function getInterprocessTelemetryCode () {
   if (getEnvironmentVariable('JEST_WORKER_ID')) {
     return JEST_WORKER_TELEMETRY_PAYLOAD_CODE
   }
+  if (getEnvironmentVariable('CUCUMBER_WORKER_ID')) {
+    return CUCUMBER_WORKER_TELEMETRY_PAYLOAD_CODE
+  }
+  if (getEnvironmentVariable('MOCHA_WORKER_ID')) {
+    return MOCHA_WORKER_TELEMETRY_PAYLOAD_CODE
+  }
+  const { DD_PLAYWRIGHT_WORKER, DD_VITEST_WORKER } = getConfig()
+  if (DD_PLAYWRIGHT_WORKER) {
+    return PLAYWRIGHT_WORKER_TELEMETRY_PAYLOAD_CODE
+  }
+  if (getEnvironmentVariable('TINYPOOL_WORKER_ID') || DD_VITEST_WORKER) {
+    return VITEST_WORKER_TELEMETRY_PAYLOAD_CODE
+  }
   return null
 }
 
@@ -85,7 +106,6 @@ class TestWorkerCiVisibilityExporter {
     this._writer = new Writer(interprocessTraceCode)
     this._coverageWriter = new Writer(interprocessCoverageCode)
     this._logsWriter = new Writer(interprocessLogsCode)
-    // TODO: add support for test workers other than Jest
     if (interprocessTelemetryCode) {
       this._telemetryWriter = new Writer(interprocessTelemetryCode)
       this.exportTelemetry = function (telemetryEvent) {

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

@@ -25,6 +25,7 @@ function parseSkippableSuitesResponse (
   {
     testLevel = 'suite',
     isCoverageReportUploadEnabled = false,
+    isLineCoverageSupported = true,
     validateRequiredFields = false,
     validationMode = false,
   } = {}
@@ -34,8 +35,11 @@ function parseSkippableSuitesResponse (
     validateSkippableTestsResponse(parsedResponse, { validationMode })
   }
   const coverage = {}
-  for (const [filename, bitmap] of Object.entries(parsedResponse.meta?.coverage || {})) {
-    coverage[filename.replaceAll('\\', '/')] = bitmap
+  const coverageByFilename = parsedResponse.meta?.coverage
+  if (coverageByFilename) {
+    for (const [filename, bitmap] of Object.entries(coverageByFilename)) {
+      coverage[filename.replaceAll('\\', '/')] = bitmap
+    }
   }
 
   const skippableItems = parsedResponse
@@ -51,7 +55,7 @@ function parseSkippableSuitesResponse (
     },
   } of skippableItems) {
     // Only reject candidates without backend line coverage when we need that coverage to backfill reports.
-    if (isCoverageReportUploadEnabled && isMissingLineCodeCoverage) {
+    if (isCoverageReportUploadEnabled && isLineCoverageSupported && isMissingLineCodeCoverage) {
       numExcludedByMissingLineCoverage++
       continue
     }
@@ -78,10 +82,11 @@ function parseSkippableSuitesResponse (
  *   numExcludedByMissingLineCoverage?: number
  * }} result - Parsed skippable response.
  * @param {'suite'|'test'} testLevel - Test optimization skipping level.
+ * @param {boolean} shouldConsiderLineCoverage - Whether line coverage can affect suite skipping.
  * @returns {void}
  */
-function logSkippableSuitesResponse (result, testLevel) {
-  if (result.numReceivedSkippableItems === undefined) {
+function logSkippableSuitesResponse (result, testLevel, shouldConsiderLineCoverage) {
+  if (!shouldConsiderLineCoverage || result.numReceivedSkippableItems === undefined) {
     log.debug('Number of received skippable %ss: %d', testLevel, result.skippableSuites.length)
     return
   }
@@ -122,10 +127,12 @@ function getSkippableSuites ({
   custom,
   testLevel = 'suite',
   isCoverageReportUploadEnabled = false,
+  isLineCoverageSupported = true,
 }, done) {
+  const shouldConsiderLineCoverage = isCoverageReportUploadEnabled && isLineCoverageSupported
   const cacheKey = buildCacheKey('skippable', [
     sha, service, env, repositoryUrl, osPlatform, osVersion, osArchitecture,
-    runtimeName, runtimeVersion, testLevel, custom, isCoverageReportUploadEnabled,
+    runtimeName, runtimeVersion, testLevel, custom, shouldConsiderLineCoverage,
   ])
 
   withCache(cacheKey, (activeCacheKey, cb) => {
@@ -146,11 +153,16 @@ function getSkippableSuites ({
       custom,
       testLevel,
       isCoverageReportUploadEnabled,
+      isLineCoverageSupported,
       cacheKey: activeCacheKey,
     }, cb)
   }, (err, data) => {
     if (err) return done(err)
-    logSkippableSuitesResponse(data, testLevel)
+    logSkippableSuitesResponse(
+      data,
+      testLevel,
+      shouldConsiderLineCoverage
+    )
     done(null, data.skippableSuites, data.correlationId, data.coverage)
   })
 }
@@ -175,6 +187,7 @@ function getSkippableSuites ({
  * @param {object} [params.custom]
  * @param {string} [params.testLevel]
  * @param {boolean} [params.isCoverageReportUploadEnabled]
+ * @param {boolean} [params.isLineCoverageSupported]
  * @param {string | null} params.cacheKey
  * @param {Function} done
  */
@@ -195,6 +208,7 @@ function fetchFromApi ({
   custom,
   testLevel,
   isCoverageReportUploadEnabled,
+  isLineCoverageSupported,
   cacheKey,
 }, done) {
   const options = {
@@ -258,6 +272,7 @@ function fetchFromApi ({
         const result = parseSkippableSuitesResponse(parsedResponse, {
           testLevel,
           isCoverageReportUploadEnabled,
+          isLineCoverageSupported,
           validateRequiredFields: true,
         })
         const skippableItems = parsedResponse.data.filter(({ type }) => type === testLevel)

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

@@ -3,6 +3,7 @@
 const getConfig = require('../../config')
 const id = require('../../id')
 const log = require('../../log')
+const { EARLY_FLAKE_DETECTION_RETRY_BUCKETS, createEfdRetryPolicy } = require('../efd-retry-policy')
 const {
   incrementCountMetric,
   distributionMetric,
@@ -15,21 +16,20 @@ const { writeSettingsToCache } = require('../test-optimization-cache')
 const { MAX_RETRIES, validateSettingsResponse } = require('../test-optimization-http-cache-schema')
 const request = require('./request')
 
-const DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES = 2
 const DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES = Object.freeze({
   '5s': 10,
   '10s': 5,
   '30s': 3,
   '5m': 2,
 })
+const DEFAULT_EARLY_FLAKE_DETECTION_RETRY_POLICY =
+  createEfdRetryPolicy(DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES)
 const DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD = 30
-const EARLY_FLAKE_DETECTION_RETRY_BUCKETS = Object.keys(DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES)
 
 /**
  * @typedef {object} EarlyFlakeDetectionSettings
  * @property {boolean} enabled
- * @property {number} numRetries
- * @property {Readonly<Record<string, number>>} slowTestRetries
+ * @property {import('../efd-retry-policy').EfdRetryPolicy} retryPolicy
  * @property {number} faultyThreshold
  */
 
@@ -90,20 +90,17 @@ function parseEarlyFlakeDetectionSettings (value, isKnownTestsEnabled) {
   if (!isRecord(value) || value.enabled !== true) {
     return {
       enabled: false,
-      numRetries: DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
-      slowTestRetries: DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES,
+      retryPolicy: DEFAULT_EARLY_FLAKE_DETECTION_RETRY_POLICY,
       faultyThreshold: DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD,
     }
   }
 
   let isValid = true
-  let numRetries = DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES
-  let slowTestRetries = DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES
+  let retryPolicy = DEFAULT_EARLY_FLAKE_DETECTION_RETRY_POLICY
   if (Object.hasOwn(value, 'slow_test_retries')) {
     const parsedSlowTestRetries = parseSlowTestRetries(value.slow_test_retries)
     if (parsedSlowTestRetries) {
-      slowTestRetries = parsedSlowTestRetries
-      numRetries = parsedSlowTestRetries['5s'] ?? DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES
+      retryPolicy = createEfdRetryPolicy(parsedSlowTestRetries)
     } else {
       isValid = false
     }
@@ -120,8 +117,7 @@ function parseEarlyFlakeDetectionSettings (value, isKnownTestsEnabled) {
 
   return {
     enabled: isKnownTestsEnabled && isValid,
-    numRetries,
-    slowTestRetries,
+    retryPolicy,
     faultyThreshold,
   }
 }
@@ -180,8 +176,7 @@ function parseLibraryConfigurationResponse (rawJson, config = getConfig(), optio
     isItrEnabled: attributes.itr_enabled === true,
     requireGit: attributes.require_git === true,
     isEarlyFlakeDetectionEnabled: earlyFlakeDetection.enabled,
-    earlyFlakeDetectionNumRetries: earlyFlakeDetection.numRetries,
-    earlyFlakeDetectionSlowTestRetries: earlyFlakeDetection.slowTestRetries,
+    earlyFlakeDetectionRetryPolicy: earlyFlakeDetection.retryPolicy,
     earlyFlakeDetectionFaultyThreshold: earlyFlakeDetection.faultyThreshold,
     isFlakyTestRetriesEnabled,
     isDiEnabled: attributes.di_enabled === true && isFlakyTestRetriesEnabled,

package/packages/dd-trace/src/ci-visibility/requests/upload-coverage-report.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { readFileSync } = require('node:fs')
+const { closeSync, constants, fstatSync, openSync, readFileSync } = require('node:fs')
 const { gzipSync } = require('node:zlib')
 
 const getConfig = require('../../config')
@@ -17,12 +17,18 @@ const {
 } = require('../telemetry')
 
 const UPLOAD_TIMEOUT_MS = 30_000
+const COVERAGE_FILE_OPEN_FLAGS = constants.O_RDONLY |
+  (constants.O_NOFOLLOW || 0) |
+  constants.O_NONBLOCK
+const BIGINT_STAT_OPTIONS = { bigint: true }
 
 /**
  * Uploads a single coverage report to the Datadog CI intake.
  * One file per request with field names 'coverage' and 'event'.
  * @param {object} options - Upload options
  * @param {string} options.filePath - Path to the coverage report file
+ * @param {bigint} options.fileDevice - Device containing the discovered report
+ * @param {bigint} options.fileInode - Inode of the discovered report
  * @param {string} options.format - Format of the coverage report (e.g., 'lcov', 'cobertura')
  * @param {string[]} [options.flags] - Optional coverage report grouping flags
  * @param {object} options.testEnvironmentMetadata - Test environment metadata containing git/CI tags
@@ -32,7 +38,7 @@ const UPLOAD_TIMEOUT_MS = 30_000
  * @param {(error: Error|null) => void} callback - Callback function
  */
 function uploadCoverageReport (
-  { filePath, format, flags, testEnvironmentMetadata, url, isEvpProxy, evpProxyPrefix },
+  { filePath, fileDevice, fileInode, format, flags, testEnvironmentMetadata, url, isEvpProxy, evpProxyPrefix },
   callback
 ) {
   const { DD_API_KEY } = getConfig()
@@ -43,10 +49,20 @@ function uploadCoverageReport (
 
   let compressedCoverage
   try {
-    const coverageContent = readFileSync(filePath)
+    const fileDescriptor = openSync(filePath, COVERAGE_FILE_OPEN_FLAGS)
+    let coverageContent
+    try {
+      const fileStats = fstatSync(fileDescriptor, BIGINT_STAT_OPTIONS)
+      if (!fileStats.isFile() || fileStats.dev !== fileDevice || fileStats.ino !== fileInode) {
+        throw new Error('Coverage report changed after discovery')
+      }
+      coverageContent = readFileSync(fileDescriptor)
+    } finally {
+      closeSync(fileDescriptor)
+    }
     compressedCoverage = gzipSync(coverageContent)
-  } catch (err) {
-    return callback(new Error(`Failed to read coverage report at ${filePath}: ${err.message}`))
+  } catch (error) {
+    return callback(new Error(`Failed to read coverage report at ${filePath}: ${error.message}`))
   }
 
   // Build the event payload with format, type, and all tags from test environment metadata

package/packages/dd-trace/src/ci-visibility/test-optimization-http-cache-schema.js

@@ -137,7 +137,7 @@ function validateSkippableTestsResponse (response, options = {}) {
   if (response.meta !== undefined) {
     assertObject(response.meta, 'Invalid skippable tests response: meta must be an object')
   }
-  if (response.meta?.coverage !== undefined) {
+  if (response.meta?.coverage !== undefined && response.meta.coverage !== null) {
     assertObject(response.meta.coverage, 'Invalid skippable tests response: meta.coverage must be an object')
   }
   if (response.meta?.correlation_id !== undefined && typeof response.meta.correlation_id !== 'string') {

package/packages/dd-trace/src/ci-visibility/test-optimization-http-cache.js

@@ -145,7 +145,11 @@ class TestOptimizationHttpCache {
         validationMode: Boolean(this._validationManifestPath),
       })
       const testLevel = options.testLevel || 'suite'
-      logSkippableSuitesResponse(result, testLevel)
+      logSkippableSuitesResponse(
+        result,
+        testLevel,
+        options.isCoverageReportUploadEnabled && options.isLineCoverageSupported !== false
+      )
       const skippableItems = parsedResponse.data.filter(({ type }) => type === testLevel)
       incrementCountMetric(
         testLevel === 'test'

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

@@ -272,6 +272,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;
@@ -579,6 +580,7 @@ export interface GeneratedConfig {
     DD_TEST_LOCAL_CONFIG_PATH: string | undefined;
     DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES: number;
     DD_TEST_MANAGEMENT_ENABLED: boolean;
+    DD_TEST_MANAGEMENT_REPORT_ENABLED: boolean | undefined;
   };
   traceId128BitGenerationEnabled: boolean;
   traceId128BitLoggingEnabled: boolean;
@@ -726,6 +728,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;
@@ -821,6 +824,7 @@ export interface GeneratedEnvVarConfig {
   DD_TEST_LOCAL_CONFIG_PATH: string | undefined;
   DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES: number;
   DD_TEST_MANAGEMENT_ENABLED: boolean;
+  DD_TEST_MANAGEMENT_REPORT_ENABLED: boolean | undefined;
   DD_TEST_SESSION_NAME: string | undefined;
   DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED: boolean;
   DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED: boolean;
@@ -964,6 +968,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;

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

@@ -307,6 +307,8 @@ module.exports = {
    *
    * This should only be called once in config.js to avoid copying the object frequently.
    *
+   * @param {typeof process.env} [source] The environment to read from
+   * @param {boolean} [internalOnly] Only return configurations marked as internal
    * @returns {TracerEnv} The environment variables
    */
   getEnvironmentVariables (source = process.env, internalOnly = false) {

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

@@ -4,6 +4,7 @@ const fs = require('node:fs')
 const os = require('node:os')
 const { URL, format } = require('node:url')
 
+const exporters = require('../../../../ext/exporters')
 const rfdc = require('../../../../vendor/dist/rfdc')({ proto: false, circles: false })
 const uuid = require('../../../../vendor/dist/crypto-randomuuid') // we need to keep the old uuid dep because of cypress
 const set = require('../../../datadog-core/src/utils/src/set')
@@ -41,6 +42,13 @@ const { normalizeService } = require('./normalize-service')
 const { programmaticTypeCoercions, transformers } = require('./parsers')
 
 const RUNTIME_ID = uuid()
+const TEST_OPTIMIZATION_WORKER_EXPORTERS = new Set([
+  exporters.CUCUMBER_WORKER,
+  exporters.JEST_WORKER,
+  exporters.MOCHA_WORKER,
+  exporters.PLAYWRIGHT_WORKER,
+  exporters.VITEST_WORKER,
+])
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
 
@@ -194,8 +202,11 @@ class Config extends ConfigBase {
     this.debug = log.configure(options)
 
     // Process stable config warnings, if any
-    for (const warning of this.stableConfig?.warnings ?? []) {
-      log.warn(warning)
+    const stableConfigWarnings = this.stableConfig?.warnings
+    if (stableConfigWarnings) {
+      for (const warning of stableConfigWarnings) {
+        log.warn(warning)
+      }
     }
 
     this.#applyDefaults()
@@ -593,9 +604,9 @@ class Config extends ConfigBase {
       setAndTrack(this, 'remoteConfig.DD_REMOTE_CONFIGURATION_ENABLED', false)
     }
 
-    // TODO: Should this unconditionally be disabled?
-    if (getEnvironmentVariable('JEST_WORKER_ID') &&
-        !trackedConfigOrigins.has('telemetry.DD_INSTRUMENTATION_TELEMETRY_ENABLED')) {
+    const isTestOptimizationWorker = this.isCiVisibility &&
+      TEST_OPTIMIZATION_WORKER_EXPORTERS.has(this.experimental.exporter)
+    if (isTestOptimizationWorker) {
       setAndTrack(this, 'telemetry.DD_INSTRUMENTATION_TELEMETRY_ENABLED', false)
     }
 

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

@@ -236,7 +236,7 @@ const optionLookupTable = {
 
 const transformers = {
   tracing_sampling_rules (samplingRules) {
-    for (const rule of (samplingRules || [])) {
+    for (const rule of samplingRules) {
       if (rule.tags) {
         const reformattedTags = {}
         for (const tag of rule.tags) {

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

@@ -1941,6 +1941,14 @@
         "namespace": "testOptimization"
       }
     ],
+    "DD_TEST_MANAGEMENT_REPORT_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": null,
+        "namespace": "testOptimization"
+      }
+    ],
     "DD_TEST_SESSION_NAME": [
       {
         "implementation": "A",
@@ -2991,6 +2999,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",

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/manager.js

@@ -16,9 +16,13 @@ class DataStreamsManager {
     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

@@ -5,10 +5,11 @@ 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 { CONTEXT_PROPAGATION_KEY_BASE64, computePathwayHash } = require('./pathway')
+const { computePathwayHash } = require('./pathway')
 const { DataStreamsWriter } = require('./writer')
 const { getAmqpMessageSize, getHeadersSize, getMessageSize, getSizeOrZero } = require('./size')
 const { SchemaBuilder } = require('./schemas/schema_builder')
@@ -21,7 +22,7 @@ const ENTRY_PARENT_HASH = Buffer.from('0000000000000000', 'hex')
 // 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
+const PATHWAY_HEADER_BYTES = dsmBase64NameLength + 28 + 6
 
 class StatsPoint {
   constructor (hash, parentHash, edgeTags) {

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

@@ -32,7 +32,7 @@ const STATUSES = {
   INSTALLED: 'INSTALLED',
   EMITTING: 'EMITTING',
   ERROR: 'ERROR',
-  BLOCKED: 'BLOCKED', // TODO: Implement once support for allow list, deny list or max probe limit has been added
+  // TODO: Add BLOCKED once support for allow list, deny list or max probe limit has been added
 }
 
 function ackReceived ({ id: probeId, version }) {

package/packages/dd-trace/src/encode/coverage-ci-visibility.js

@@ -110,7 +110,6 @@ class CoverageCIVisibilityEncoder extends AgentEncoder {
   _encodePayloadStart (bytes) {
     const payload = {
       version: COVERAGE_PAYLOAD_VERSION,
-      coverages: [],
     }
     bytes.writeMapPrefix(COVERAGE_KEYS_LENGTH)
     this._encodeString(bytes, 'version')

package/packages/dd-trace/src/guardrails/apply-pm2-env.js

@@ -0,0 +1,16 @@
+'use strict'
+
+// In PM2 cluster mode, per-app env vars arrive as a `pm2_env`
+// JSON string after preloads have run, so extract them first.
+var pm2EnvStr = process.env.pm2_env
+if (typeof pm2EnvStr === 'string') {
+  try {
+    var pm2Config = JSON.parse(pm2EnvStr)
+    var pm2Keys = Object.keys(pm2Config)
+    for (var i = 0; i < pm2Keys.length; i++) {
+      var key = pm2Keys[i]
+      var value = pm2Config[key]
+      process.env[key] = String(value)
+    }
+  } catch (error) {}
+}

package/packages/dd-trace/src/guardrails/log.js

@@ -2,21 +2,12 @@
 
 /* eslint-disable no-console */
 
+var logLevels = require('../log/levels')
 var isTrue = require('./util').isTrue
 
 var DD_TRACE_DEBUG = process.env.DD_TRACE_DEBUG
 var DD_TRACE_LOG_LEVEL = process.env.DD_TRACE_LOG_LEVEL
 
-var logLevels = {
-  trace: 20,
-  debug: 20,
-  info: 30,
-  warn: 40,
-  error: 50,
-  critical: 50,
-  off: 100
-}
-
 var logLevel = isTrue(DD_TRACE_DEBUG)
   ? Number(DD_TRACE_LOG_LEVEL) || logLevels.debug
   : logLevels.off