dd-trace 6.6.0 → 6.8.0

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

@@ -12,12 +12,145 @@ const {
   TELEMETRY_GIT_REQUESTS_SETTINGS_RESPONSE,
 } = require('../telemetry')
 const { writeSettingsToCache } = require('../test-optimization-cache')
-const { validateSettingsResponse } = require('../test-optimization-http-cache-schema')
+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 = { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
+const DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES = Object.freeze({
+  '5s': 10,
+  '10s': 5,
+  '30s': 3,
+  '5m': 2,
+})
 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 {number} faultyThreshold
+ */
+
+/**
+ * @typedef {object} TestManagementSettings
+ * @property {boolean} enabled
+ * @property {number|undefined} attemptToFixRetries
+ */
+
+/**
+ * @param {unknown} value
+ * @returns {value is Record<string, unknown>}
+ */
+function isRecord (value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is number}
+ */
+function isNonNegativeInteger (value) {
+  return Number.isInteger(value) && value >= 0
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is number}
+ */
+function isRetryCount (value) {
+  return isNonNegativeInteger(value) && value <= MAX_RETRIES
+}
+
+/**
+ * @param {unknown} value
+ * @returns {Readonly<Record<string, number>>|undefined}
+ */
+function parseSlowTestRetries (value) {
+  if (!isRecord(value)) return
+
+  const slowTestRetries = {}
+  for (const bucket of EARLY_FLAKE_DETECTION_RETRY_BUCKETS) {
+    if (!Object.hasOwn(value, bucket)) continue
+
+    const retries = value[bucket]
+    if (!isRetryCount(retries)) return
+    slowTestRetries[bucket] = retries
+  }
+  return Object.freeze(slowTestRetries)
+}
+
+/**
+ * @param {unknown} value
+ * @param {boolean} isKnownTestsEnabled
+ * @returns {EarlyFlakeDetectionSettings}
+ */
+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,
+      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
+  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
+    } else {
+      isValid = false
+    }
+  }
+
+  let faultyThreshold = DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD
+  if (Object.hasOwn(value, 'faulty_session_threshold')) {
+    if (isNonNegativeInteger(value.faulty_session_threshold) && value.faulty_session_threshold <= 100) {
+      faultyThreshold = value.faulty_session_threshold
+    } else {
+      isValid = false
+    }
+  }
+
+  return {
+    enabled: isKnownTestsEnabled && isValid,
+    numRetries,
+    slowTestRetries,
+    faultyThreshold,
+  }
+}
+
+/**
+ * @param {unknown} value
+ * @returns {TestManagementSettings}
+ */
+function parseTestManagementSettings (value) {
+  if (!isRecord(value) || value.enabled !== true) {
+    return {
+      enabled: false,
+      attemptToFixRetries: undefined,
+    }
+  }
+
+  const attemptToFixRetries = value.attempt_to_fix_retries
+  if (attemptToFixRetries !== undefined && !isRetryCount(attemptToFixRetries)) {
+    return {
+      enabled: false,
+      attemptToFixRetries: undefined,
+    }
+  }
+
+  return {
+    enabled: true,
+    attemptToFixRetries,
+  }
+}
 
 function parseJsonResponse (rawJson) {
   return typeof rawJson === 'string' ? JSON.parse(rawJson) : rawJson
@@ -28,40 +161,35 @@ function parseLibraryConfigurationResponse (rawJson, config = getConfig(), optio
   if (options.validateRequiredFields) {
     validateSettingsResponse(parsedResponse, options)
   }
-  const {
-    code_coverage: isCodeCoverageEnabled,
-    tests_skipping: isSuitesSkippingEnabled,
-    itr_enabled: isItrEnabled,
-    require_git: requireGit,
-    early_flake_detection: earlyFlakeDetectionConfig,
-    flaky_test_retries_enabled: isFlakyTestRetriesEnabled,
-    di_enabled: isDiEnabled,
-    known_tests_enabled: isKnownTestsEnabled,
-    test_management: testManagementConfig,
-    impacted_tests_enabled: isImpactedTestsEnabled,
-    coverage_report_upload_enabled: isCoverageReportUploadEnabled,
-  } = parsedResponse?.data?.attributes ?? parsedResponse
+  const parsedAttributes = parsedResponse?.data?.attributes ?? parsedResponse
+  if (!isRecord(parsedAttributes)) {
+    throw new TypeError('Invalid settings response: attributes must be an object')
+  }
+  const attributes = parsedAttributes
+  const isKnownTestsEnabled = attributes.known_tests_enabled === true
+  const isFlakyTestRetriesEnabled = attributes.flaky_test_retries_enabled === true
+  const earlyFlakeDetection = parseEarlyFlakeDetectionSettings(
+    attributes.early_flake_detection,
+    isKnownTestsEnabled
+  )
+  const testManagement = parseTestManagementSettings(attributes.test_management)
 
   const settings = {
-    isCodeCoverageEnabled,
-    isSuitesSkippingEnabled,
-    isItrEnabled,
-    requireGit,
-    isEarlyFlakeDetectionEnabled: isKnownTestsEnabled && (earlyFlakeDetectionConfig?.enabled ?? false),
-    earlyFlakeDetectionNumRetries:
-      earlyFlakeDetectionConfig?.slow_test_retries?.['5s'] ?? DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
-    earlyFlakeDetectionSlowTestRetries:
-      earlyFlakeDetectionConfig?.slow_test_retries ?? DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES,
-    earlyFlakeDetectionFaultyThreshold:
-      earlyFlakeDetectionConfig?.faulty_session_threshold ?? DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD,
+    isCodeCoverageEnabled: attributes.code_coverage === true,
+    isSuitesSkippingEnabled: attributes.tests_skipping === true,
+    isItrEnabled: attributes.itr_enabled === true,
+    requireGit: attributes.require_git === true,
+    isEarlyFlakeDetectionEnabled: earlyFlakeDetection.enabled,
+    earlyFlakeDetectionNumRetries: earlyFlakeDetection.numRetries,
+    earlyFlakeDetectionSlowTestRetries: earlyFlakeDetection.slowTestRetries,
+    earlyFlakeDetectionFaultyThreshold: earlyFlakeDetection.faultyThreshold,
     isFlakyTestRetriesEnabled,
-    isDiEnabled: isDiEnabled && isFlakyTestRetriesEnabled,
+    isDiEnabled: attributes.di_enabled === true && isFlakyTestRetriesEnabled,
     isKnownTestsEnabled,
-    isTestManagementEnabled: (testManagementConfig?.enabled ?? false),
-    testManagementAttemptToFixRetries:
-      testManagementConfig?.attempt_to_fix_retries,
-    isImpactedTestsEnabled,
-    isCoverageReportUploadEnabled: isCoverageReportUploadEnabled ?? false,
+    isTestManagementEnabled: testManagement.enabled,
+    testManagementAttemptToFixRetries: testManagement.attemptToFixRetries,
+    isImpactedTestsEnabled: attributes.impacted_tests_enabled === true,
+    isCoverageReportUploadEnabled: attributes.coverage_report_upload_enabled === true,
   }
 
   log.debug('Remote settings: %j', settings)
@@ -82,7 +210,7 @@ function parseLibraryConfigurationResponse (rawJson, config = getConfig(), optio
     log.debug('Code coverage report upload was disabled by the environment variable')
   }
 
-  return settings
+  return Object.freeze(settings)
 }
 
 function getLibraryConfiguration ({

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

@@ -42,7 +42,7 @@ function request (data, options, callback) {
     if (url.protocol === 'unix:') {
       opts.socketPath = url.pathname
     } else {
-      opts.path = opts.path ?? url.path
+      opts.path ??= url.path
       opts.protocol = url.protocol
       opts.hostname = url.hostname
       opts.port = url.port
@@ -100,9 +100,9 @@ function request (data, options, callback) {
           if (res.statusCode === 429 && !hasRetried) {
             const resetHeader = res.headers['x-ratelimit-reset']
             const resetTs = (resetHeader === null || resetHeader === undefined)
-              ? Number.NaN
+              ? NaN
               : Number.parseInt(resetHeader, 10)
-            const waitMs = Number.isFinite(resetTs) ? Math.max(0, resetTs * 1000 - Date.now()) : Number.NaN
+            const waitMs = Number.isFinite(resetTs) ? Math.max(0, resetTs * 1000 - Date.now()) : NaN
 
             if (Number.isFinite(waitMs) && waitMs <= RATE_LIMIT_MAX_WAIT_MS) {
               hasRetried = true

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

@@ -26,11 +26,11 @@ const SETTINGS_BOOLEAN_KEYS = [
 ]
 const EARLY_FLAKE_DETECTION_KEYS = ['enabled', 'faulty_session_threshold', 'slow_test_retries']
 const TEST_MANAGEMENT_KEYS = ['attempt_to_fix_retries', 'enabled']
-const RETRY_THRESHOLD_PATTERN = /^\d+(?:ms|s|m|h)$/
+const RETRY_THRESHOLD_PATTERN = /^\d+(?:ms|[smh])$/
 const MAX_VALIDATION_MODULES = 1000
 const MAX_VALIDATION_SUITES = 10_000
 const MAX_VALIDATION_TESTS = 100_000
-const MAX_VALIDATION_RETRIES = 100
+const MAX_RETRIES = 100
 const MAX_VALIDATION_STRING_BYTES = 4096
 
 function isObject (value) {
@@ -75,7 +75,8 @@ function validateSettingsResponse (response, options = {}) {
   assertBooleanFields(attributes.test_management, ['enabled'], 'settings test_management')
   assertOptionalBoundedNumber(
     attributes.early_flake_detection.faulty_session_threshold,
-    'settings early_flake_detection faulty_session_threshold'
+    'settings early_flake_detection faulty_session_threshold',
+    { integer: true }
   )
   assertRetryMap(attributes.early_flake_detection.slow_test_retries)
   assertOptionalBoundedNumber(
@@ -216,8 +217,8 @@ function assertBooleanFields (object, keys, endpoint) {
 function assertOptionalBoundedNumber (value, endpoint, { integer = false } = {}) {
   if (value === undefined) return
   if (!Number.isFinite(value) || (integer && !Number.isInteger(value)) ||
-    value < 0 || value > MAX_VALIDATION_RETRIES) {
-    throw new TypeError(`Invalid ${endpoint}: value must be between 0 and ${MAX_VALIDATION_RETRIES}`)
+    value < 0 || value > MAX_RETRIES) {
+    throw new TypeError(`Invalid ${endpoint}: value must be between 0 and ${MAX_RETRIES}`)
   }
 }
 
@@ -249,6 +250,7 @@ function assertValidationString (value, field) {
 }
 
 module.exports = {
+  MAX_RETRIES,
   validateKnownTestsResponse,
   validateSettingsResponse,
   validateSkippableTestsResponse,

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

@@ -32,18 +32,26 @@ const parseErrors = new Map()
  * @param {string} source - The source of the value.
  * @param {string} baseMessage - The base message to use for the warning.
  * @param {Error} [error] - An error that was thrown while parsing the value.
+ * @param {string} [outcome] - The outcome after the invalid value is rejected.
  */
-function warnInvalidValue (value, optionName, source, baseMessage, error) {
-  const canonicalName = (optionsTable[optionName]?.canonicalName ?? optionName) + source
+function warnInvalidValue (value, optionName, source, baseMessage, error, outcome = 'picked default') {
+  const canonicalName = optionsTable[optionName]?.canonicalName ?? optionName
+  const telemetryKey = canonicalName + source
+  const telemetryEntry = configWithOrigin.get(telemetryKey)
   // Lazy load log module to avoid circular dependency
-  if (!parseErrors.has(canonicalName)) {
-    // TODO: Rephrase: It will fallback to former source (or default if not set)
-    let message = `${baseMessage}: ${util.inspect(value)} for ${optionName} (source: ${source}), picked default`
+  if (!parseErrors.has(telemetryKey) && !telemetryEntry?.error) {
+    // TODO: Report the prior source when an invalid value does not use the default.
+    let message = `${baseMessage}: ${util.inspect(value)} for ${optionName} (source: ${source})`
+    if (outcome) message += `, ${outcome}`
     if (error) {
       error.stack = error.toString()
       message += `\n\n${util.inspect(error)}`
     }
-    parseErrors.set(canonicalName, { message })
+    if (telemetryEntry) {
+      telemetryEntry.error = { message }
+    } else {
+      parseErrors.set(telemetryKey, { message })
+    }
     log ??= require('../log')
     const logLevel = error ? 'error' : 'warn'
     log[logLevel](message)

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

@@ -333,6 +333,7 @@ export interface GeneratedConfig {
   DD_TRACE_NODE_SERIALIZE_ENABLED: boolean;
   DD_TRACE_NYC_ENABLED: boolean;
   DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP: string;
+  DD_TRACE_OPENAI_AGENTS_ENABLED: boolean;
   DD_TRACE_OPENAI_ENABLED: boolean;
   DD_TRACE_OPENSEARCH_ENABLED: boolean;
   DD_TRACE_OPENSEARCH_PROJECT_OPENSEARCH_ENABLED: boolean;
@@ -433,7 +434,7 @@ export interface GeneratedConfig {
     };
   };
   featureFlags: {
-    DD_FEATURE_FLAGS_CONFIGURATION_SOURCE: "agentless" | "remote_config";
+    DD_FEATURE_FLAGS_CONFIGURATION_SOURCE: string;
     DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_BASE_URL: string | undefined;
     DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_POLL_INTERVAL_SECONDS: number;
     DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_REQUEST_TIMEOUT_SECONDS: number;
@@ -699,7 +700,7 @@ export interface GeneratedEnvVarConfig {
   DD_EXPERIMENTAL_TEST_OPT_VITEST_NO_WORKER_INIT: boolean | undefined;
   DD_EXPERIMENTAL_TEST_REQUESTS_FS_CACHE: boolean;
   DD_EXTERNAL_ENV: string | undefined;
-  DD_FEATURE_FLAGS_CONFIGURATION_SOURCE: "agentless" | "remote_config";
+  DD_FEATURE_FLAGS_CONFIGURATION_SOURCE: string;
   DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_BASE_URL: string | undefined;
   DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_POLL_INTERVAL_SECONDS: number;
   DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_REQUEST_TIMEOUT_SECONDS: number;
@@ -1028,6 +1029,7 @@ export interface GeneratedEnvVarConfig {
   DD_TRACE_NODE_SERIALIZE_ENABLED: boolean;
   DD_TRACE_NYC_ENABLED: boolean;
   DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP: string;
+  DD_TRACE_OPENAI_AGENTS_ENABLED: boolean;
   DD_TRACE_OPENAI_ENABLED: boolean;
   DD_TRACE_OPENSEARCH_ENABLED: boolean;
   DD_TRACE_OPENSEARCH_PROJECT_OPENSEARCH_ENABLED: boolean;

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

@@ -343,6 +343,21 @@ class Config extends ConfigBase {
       }
     }
 
+    const configurationSource = this.featureFlags.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE
+    if (this.featureFlags.DD_FEATURE_FLAGS_ENABLED &&
+        configurationSource !== 'agentless' &&
+        configurationSource !== 'remote_config') {
+      warnInvalidValue(
+        configurationSource,
+        'DD_FEATURE_FLAGS_CONFIGURATION_SOURCE',
+        this.getOrigin('featureFlags.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE'),
+        'Unsupported Feature Flagging configuration source',
+        undefined,
+        'provider disabled'
+      )
+      setAndTrack(this, 'featureFlags.DD_FEATURE_FLAGS_ENABLED', false)
+    }
+
     if (this.url ||
         os.type() !== 'Windows_NT' &&
         !trackedConfigOrigins.has('hostname') &&

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

@@ -58,6 +58,17 @@ const transformers = {
   toLowerCase (value) {
     return toCase(value, 'toLowerCase')
   },
+  /**
+   * Normalizes a Feature Flagging configuration source.
+   * A blank value is treated as unset so legacy configuration can still apply.
+   *
+   * @param {string} value
+   * @returns {string | undefined}
+   */
+  configurationSource (value) {
+    const normalized = value.trim().toLowerCase()
+    return normalized || undefined
+  },
   toUpperCase (value) {
     return toCase(value, 'toUpperCase')
   },
@@ -161,7 +172,14 @@ const transformers = {
         return transformers.stripColonWhitespace(item)
       })
     }
-    return value.replaceAll(/\s*:\s*/g, ':')
+    // Only whitespace adjacent to a colon is removed; the outer whitespace of the first and
+    // last segment stays.
+    const parts = value.split(':')
+    for (let i = 0; i < parts.length; i++) {
+      if (i !== 0) parts[i] = parts[i].trimStart()
+      if (i !== parts.length - 1) parts[i] = parts[i].trimEnd()
+    }
+    return parts.join(':')
   },
   /**
    * @param {string} value

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

@@ -849,10 +849,9 @@
         "implementation": "A",
         "type": "string",
         "default": "agentless",
-        "allowed": "agentless|remote_config",
-        "description": "Experimental: Select where Feature Flagging loads Universal Flag Configuration. Supported values are agentless and remote_config.",
+        "description": "Select where Feature Flagging loads Universal Flag Configuration. Supported values are agentless and remote_config; offline is reserved and currently unsupported.",
         "namespace": "featureFlags",
-        "transform": "toLowerCase"
+        "transform": "configurationSource"
       }
     ],
     "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_BASE_URL": [
@@ -860,7 +859,7 @@
         "implementation": "A",
         "type": "string",
         "default": null,
-        "description": "Experimental: Override the agentless Feature Flagging UFC endpoint or base URL.",
+        "description": "Override the agentless Feature Flagging UFC endpoint or base URL.",
         "namespace": "featureFlags",
         "sensitive": true
       }
@@ -870,7 +869,7 @@
         "implementation": "A",
         "type": "int",
         "default": "30",
-        "description": "Experimental: Set the agentless Feature Flagging UFC polling interval in seconds, capped at one hour.",
+        "description": "Set the agentless Feature Flagging UFC polling interval in seconds, capped at one hour.",
         "allowed": "[1-9]\\d*",
         "namespace": "featureFlags"
       }
@@ -880,7 +879,7 @@
         "implementation": "A",
         "type": "int",
         "default": "5",
-        "description": "Experimental: Set the agentless Feature Flagging UFC request timeout in seconds.",
+        "description": "Set the agentless Feature Flagging UFC request timeout in seconds.",
         "allowed": "[1-9]\\d*",
         "namespace": "featureFlags"
       }
@@ -3452,6 +3451,13 @@
         "default": "true"
       }
     ],
+    "DD_TRACE_OPENAI_AGENTS_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "true"
+      }
+    ],
     "DD_TRACE_OPENSEARCH_ENABLED": [
       {
         "implementation": "A",

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

@@ -40,7 +40,7 @@ function encodeVarintInto (target, offset, value) {
   let i = offset
   const limit = offset + maxVarLen64 - 1
   // if first byte is 1, the number is negative in javascript, but we want to interpret it as positive
-  while ((high !== 0 || low < 0 || low > 0x80) && i < limit) {
+  while ((high !== 0 || low < 0 || low > 0x7F) && i < limit) {
     target[i] = (low & 0x7F) | 0x80
     low >>>= 7
     low |= (high & 0x7F) << 25
@@ -88,7 +88,7 @@ function decodeUvarint64 (
         low |= n << s
       }
       if (s > 0) {
-        high |= s - 32 > 0 ? n << (s - 32) : n >> (32 - s)
+        high |= s > 32 ? n << (s - 32) : n >> (32 - s)
       }
       return [low, high, bytes]
     }
@@ -96,8 +96,7 @@ function decodeUvarint64 (
       low |= (n & 0x7F) << s
     }
     if (s > 0) {
-      high |=
-        s - 32 > 0 ? (n & 0x7F) << (s - 32) : (n & 0x7F) >> (32 - s)
+      high |= s > 32 ? (n & 0x7F) << (s - 32) : (n & 0x7F) >> (32 - s)
     }
     s += 7
   }

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

@@ -20,11 +20,12 @@ const on = (level, ...args) => {
 const off = () => {}
 
 const threshold = LEVELS.indexOf(logLevel)
+const isEnabled = debug && typeof logPort?.postMessage === 'function'
 
 /** @type {Logger} */
 module.exports = Object.fromEntries(
   LEVELS.map(level => [
     level,
-    debug && threshold >= LEVELS.indexOf(level) ? on.bind(null, level) : off,
+    isEnabled && threshold >= LEVELS.indexOf(level) ? on.bind(null, level) : off,
   ])
 )

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

@@ -36,10 +36,7 @@ function getRemoveProbeExpression (id) {
  * @returns {string}
  */
 function compileBreakpointCondition (probes) {
-  const probeConditions = []
-  for (const probe of probes) {
-    probeConditions.push(compileProbeCondition(probe))
-  }
+  const probeConditions = probes.map(compileProbeCondition)
 
   // NOTE: $dd_sampler is read from the realm-local `globalThis` where it was installed (the main
   // realm). A probe whose code runs in a different V8 realm (e.g. a `vm.createContext` script with a

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

@@ -67,14 +67,13 @@ function send (message, logger, dd, snapshot, processTags) {
 
     if (pruned) {
       json = pruned
-      size = Buffer.byteLength(json)
     } else {
       // Fallback if pruning fails
       const line = Object.keys(snapshot.captures.lines)[0]
       snapshot.captures.lines[line] = { pruned: true }
       json = JSON.stringify(payload)
-      size = Buffer.byteLength(json)
     }
+    size = Buffer.byteLength(json)
   }
 
   jsonBuffer.write(json, size)

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

@@ -61,7 +61,7 @@ async function getLocalStateForCallFrame (callFrame, limits, deadlineNs = BIGINT
   // Delay calling `processRawState` so caller can resume the main thread before processing `rawState`
   return {
     processLocalState () {
-      processedState = processedState ?? processRawState(rawState, maxLength)
+      processedState ??= processRawState(rawState, maxLength)
       return processedState
     },
     fatalErrors: ctx.fatalErrors,
@@ -155,7 +155,7 @@ async function evaluateCaptureExpressions (callFrame, expressions, deadlineNs =
           fatalErrors.push(...ctx.fatalErrors)
         }
 
-        if (ctx.deadlineReached === true) {
+        if (ctx.deadlineReached) {
           // Add the current expression (properties may be incomplete due to timeout)
           rawResults.push({ name, remoteObject: result, maxLength })
           // Add stub entries for remaining uncaptured expressions

package/packages/dd-trace/src/debugger/devtools_client/snapshot/redaction.js

@@ -97,10 +97,24 @@ const REDACTED_IDENTIFIERS = new Set(
     'XSRF-TOKEN',
     ...config.dynamicInstrumentation.redactedIdentifiers,
   ]
-    .map((name) => normalizeName(name))
-    .filter((name) => excludedIdentifiers.has(name) === false)
+    .map(normalizeIdentifier)
+    .filter(isIncludedIdentifier)
 )
 
+/**
+ * @param {string} name
+ */
+function normalizeIdentifier (name) {
+  return normalizeName(name)
+}
+
+/**
+ * @param {string} name
+ */
+function isIncludedIdentifier (name) {
+  return !excludedIdentifiers.has(name)
+}
+
 function normalizeName (name, isSymbol) {
   if (isSymbol) name = name.slice(7, -1) // Remove `Symbol(` and `)`
   return name.toLowerCase().replaceAll(/[-_@$.]/g, '')

package/packages/dd-trace/src/encode/span-stats.js

@@ -31,7 +31,7 @@ class SpanStatsEncoder extends AgentEncoder {
   }
 
   _encodeStat (bytes, stat) {
-    bytes.writeMapPrefix(15)
+    bytes.writeMapPrefix(17)
 
     this._encodeString(bytes, 'Service')
     const service = stat.Service || DEFAULT_SERVICE_NAME
@@ -79,6 +79,12 @@ class SpanStatsEncoder extends AgentEncoder {
 
     this._encodeString(bytes, 'srv_src')
     this._encodeString(bytes, stat.srv_src || '')
+
+    this._encodeString(bytes, 'SpanKind')
+    this._encodeString(bytes, stat.SpanKind || '')
+
+    this._encodeString(bytes, 'GRPCStatusCode')
+    this._encodeString(bytes, stat.GRPCStatusCode || '')
   }
 
   _encodeBucket (bytes, bucket) {

package/packages/dd-trace/src/encode/tags-processors.js

@@ -60,11 +60,11 @@ function eventTimeNano (event) {
 }
 
 function normalizeSpan (span) {
-  span.service = span.service || DEFAULT_SERVICE_NAME
+  span.service ||= DEFAULT_SERVICE_NAME
   if (span.service.length > MAX_SERVICE_LENGTH) {
     span.service = span.service.slice(0, MAX_SERVICE_LENGTH)
   }
-  span.name = span.name || DEFAULT_SPAN_NAME
+  span.name ||= DEFAULT_SPAN_NAME
   if (span.name.length > MAX_NAME_LENGTH) {
     span.name = span.name.slice(0, MAX_NAME_LENGTH)
   }

package/packages/dd-trace/src/exporter.js

@@ -4,6 +4,7 @@ const fs = require('fs')
 const exporters = require('../../../ext/exporters')
 const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
 const constants = require('./constants')
+const { isTrue } = require('./util')
 
 module.exports = function getExporter (name) {
   switch (name) {
@@ -20,20 +21,26 @@ module.exports = function getExporter (name) {
     case exporters.AGENT_PROXY:
       return require('./ci-visibility/exporters/agent-proxy')
     case exporters.CI_VALIDATION:
-      return require('./ci-visibility/exporters/ci-validation')
+      if (hasCiValidationEnvironment()) return require('./ci-visibility/exporters/ci-validation')
+      break
     case exporters.JEST_WORKER:
     case exporters.CUCUMBER_WORKER:
     case exporters.MOCHA_WORKER:
     case exporters.PLAYWRIGHT_WORKER:
     case exporters.VITEST_WORKER:
       return require('./ci-visibility/exporters/test-worker')
-    default: {
-      const inAWSLambda = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined
-      const usingAgent = inAWSLambda && (
-        fs.existsSync(constants.DATADOG_LAMBDA_EXTENSION_PATH) ||
-        fs.existsSync(constants.DATADOG_MINI_AGENT_PATH)
-      )
-      return inAWSLambda && !usingAgent ? require('./exporters/log') : require('./exporters/agent')
-    }
   }
+
+  const inAWSLambda = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined
+  const usingAgent = inAWSLambda && (
+    fs.existsSync(constants.DATADOG_LAMBDA_EXTENSION_PATH) ||
+    fs.existsSync(constants.DATADOG_MINI_AGENT_PATH)
+  )
+  return inAWSLambda && !usingAgent ? require('./exporters/log') : require('./exporters/agent')
+}
+
+function hasCiValidationEnvironment () {
+  return isTrue(getEnvironmentVariable('_DD_TEST_OPTIMIZATION_VALIDATION_MODE')) &&
+    getEnvironmentVariable('_DD_TEST_OPTIMIZATION_VALIDATION_MANIFEST_FILE') &&
+    getEnvironmentVariable('_DD_TEST_OPTIMIZATION_VALIDATION_OUTPUT_DIR')
 }