dd-trace 5.132.0 → 5.134.0

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

@@ -5,6 +5,7 @@ const path = require('node:path')
 
 const log = require('../log')
 const { getNumFromKnownTests } = require('../plugins/util/test')
+const resolveRunfilePath = require('./resolve-runfile-path')
 const { parseKnownTestsResponse } = require('./early-flake-detection/get-known-tests')
 const {
   logSkippableSuitesResponse,
@@ -38,16 +39,12 @@ const HTTP_CACHE_FOLDER_NAME = 'http'
 
 const ENV_MANIFEST_FILE = 'TEST_OPTIMIZATION_MANIFEST_FILE'
 const ENV_MANIFEST_FILE_ALIAS = 'DD_TEST_OPTIMIZATION_MANIFEST_FILE'
-const ENV_RUNFILES_DIR = 'RUNFILES_DIR'
-const ENV_RUNFILES_MANIFEST_FILE = 'RUNFILES_MANIFEST_FILE'
-const ENV_TEST_SRCDIR = 'TEST_SRCDIR'
 
 const SETTINGS_FILE_NAME = 'settings.json'
 const KNOWN_TESTS_FILE_NAME = 'known_tests.json'
 const SKIPPABLE_TESTS_FILE_NAME = 'skippable_tests.json'
 const TEST_MANAGEMENT_FILE_NAME = 'test_management.json'
 
-const RUNFILES_MANIFEST_SEPARATOR = ' '
 const DEFAULT_VALIDATION_MAX_FILE_BYTES = 1024 * 1024
 const DEFAULT_VALIDATION_MAX_ENTRIES = 100_000
 const DEFAULT_VALIDATION_MAX_NESTING_DEPTH = 32
@@ -250,7 +247,7 @@ class TestOptimizationHttpCache {
     const manifestFile = this._env[ENV_MANIFEST_FILE] || this._env[ENV_MANIFEST_FILE_ALIAS]
     if (!manifestFile) return
 
-    const resolvedManifestPath = this._resolveRunfilePath(manifestFile)
+    const resolvedManifestPath = resolveRunfilePath(manifestFile, this._env)
     if (fs.existsSync(resolvedManifestPath)) {
       return resolvedManifestPath
     }
@@ -280,54 +277,6 @@ class TestOptimizationHttpCache {
     }
   }
 
-  _resolveRunfilePath (manifestFile) {
-    if (fs.existsSync(manifestFile)) {
-      return manifestFile
-    }
-
-    const runfilesDir = this._env[ENV_RUNFILES_DIR]
-    if (runfilesDir) {
-      const candidate = path.join(runfilesDir, manifestFile)
-      if (fs.existsSync(candidate)) {
-        return candidate
-      }
-    }
-
-    const runfilesManifestCandidate = this._resolveRunfilePathFromManifest(manifestFile)
-    if (runfilesManifestCandidate) {
-      return runfilesManifestCandidate
-    }
-
-    const testSrcdir = this._env[ENV_TEST_SRCDIR]
-    if (testSrcdir) {
-      const candidate = path.join(testSrcdir, manifestFile)
-      if (fs.existsSync(candidate)) {
-        return candidate
-      }
-    }
-
-    return manifestFile
-  }
-
-  _resolveRunfilePathFromManifest (manifestFile) {
-    const runfilesManifest = this._env[ENV_RUNFILES_MANIFEST_FILE]
-    if (!runfilesManifest || !fs.existsSync(runfilesManifest)) return
-
-    try {
-      const lines = fs.readFileSync(runfilesManifest, 'utf8').split('\n')
-      for (const line of lines) {
-        const separatorIndex = line.indexOf(RUNFILES_MANIFEST_SEPARATOR)
-        if (separatorIndex <= 0) continue
-        if (line.slice(0, separatorIndex) !== manifestFile) continue
-
-        const resolvedPath = line.slice(separatorIndex + 1).trim()
-        if (resolvedPath) return resolvedPath
-      }
-    } catch (err) {
-      log.debug('Failed to resolve Test Optimization HTTP cache manifest from %s: %s', runfilesManifest, err.message)
-    }
-  }
-
   _readManifestVersion (manifestPath) {
     try {
       this._assertValidationFixtureFile(manifestPath)

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

@@ -72,9 +72,9 @@ export type ConfigPathValue<TPath extends ConfigPath> = ConfigPathValueFor<Confi
 export type ConfigDefaults = Partial<{ [TPath in ConfigPath]: ConfigPathValue<TPath> }>
 export type ConfigurationOption = {
   property?: string
-  parser?: (value: unknown, optionName: string, source: string) => unknown
+  parser?: (value: unknown, optionName: string, source: string, reportInvalid?: boolean) => unknown
   type: string
   canonicalName?: string
-  transformer?: (value: unknown, optionName: string, source: string) => unknown
+  transformer?: (value: unknown, optionName: string, source: string, reportInvalid?: boolean) => unknown
   telemetryTransformer?: (value: unknown) => unknown
 }

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

@@ -191,10 +191,10 @@ const optionsTable = {
   },
 }
 
-const parser = (value, optionName, source) => {
+const parser = (value, optionName, source, reportInvalid = true) => {
   const { type, canonicalName = optionName } = configurationsTable[optionName]
   const parsed = parsers[type](value, canonicalName)
-  if (parsed === undefined) {
+  if (parsed === undefined && reportInvalid) {
     warnInvalidValue(value, optionName, source, `Invalid ${type} input`)
   }
   return parsed
@@ -249,13 +249,13 @@ for (const [canonicalName, entries] of Object.entries(supportedConfigurations))
       regExps[entry.allowed] ??= new RegExp(`^(${entry.allowed})$`, 'i')
       const allowed = regExps[entry.allowed]
       const originalTransform = transformer
-      transformer = (value, optionName, source) => {
+      transformer = (value, optionName, source, reportInvalid = true) => {
         if (!allowed.test(value)) {
-          warnInvalidValue(value, optionName, source, 'Invalid value')
+          if (reportInvalid) warnInvalidValue(value, optionName, source, 'Invalid value')
           return
         }
         if (originalTransform) {
-          value = originalTransform(value)
+          value = originalTransform(value, optionName, source, reportInvalid)
         }
         return value
       }

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

@@ -3,6 +3,8 @@
 
 export interface GeneratedConfig {
   _DD_APM_TRACING_AGENTLESS_ENABLED: boolean;
+  _DD_TEST_PARALLELIZATION_ENABLED: boolean | undefined;
+  _DD_TEST_PARALLELIZATION_METADATA_FILE: string | undefined;
   _DD_TRACE_METRICS_OTEL_FLUSH_INTERVAL: number;
   aiguard: {
     DD_AI_GUARD_ANALYZE_STREAM_RESPONSES_ENABLED: boolean;
@@ -75,6 +77,7 @@ export interface GeneratedConfig {
   DD_APM_FLUSH_DEADLINE_MILLISECONDS: number;
   DD_APP_KEY: string | undefined;
   DD_AZURE_RESOURCE_GROUP: string | undefined;
+  DD_BUNDLER_INJECT_GIT_METADATA: boolean;
   DD_CRASHTRACKING_ENABLED: boolean;
   DD_CUSTOM_PARENT_ID: string | undefined;
   DD_CUSTOM_TRACE_ID: string | undefined;
@@ -435,6 +438,8 @@ export interface GeneratedConfig {
     DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_POLL_INTERVAL_SECONDS: number;
     DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_REQUEST_TIMEOUT_SECONDS: number;
     DD_FEATURE_FLAGS_ENABLED: boolean;
+    DD_FEATURE_FLAGS_EVALUATION_TELEMETRY_PER_SUBJECT_OPT_OUT_ENABLED: boolean;
+    DD_FEATURE_FLAGS_EXPOSURES_DATADOG_LOGGING_ENABLED: boolean;
     DD_FLAGGING_EVALUATION_COUNTS_ENABLED: boolean;
   };
   flushInterval: number;
@@ -606,6 +611,8 @@ export interface GeneratedConfig {
 
 export interface GeneratedEnvVarConfig {
   _DD_APM_TRACING_AGENTLESS_ENABLED: boolean;
+  _DD_TEST_PARALLELIZATION_ENABLED: boolean | undefined;
+  _DD_TEST_PARALLELIZATION_METADATA_FILE: string | undefined;
   _DD_TRACE_METRICS_OTEL_FLUSH_INTERVAL: number;
   DATADOG_API_KEY: string | undefined;
   DD_ACTION_EXECUTION_ID: string | undefined;
@@ -656,6 +663,7 @@ export interface GeneratedEnvVarConfig {
   DD_APPSEC_TRACE_RATE_LIMIT: number;
   DD_APPSEC_WAF_TIMEOUT: number;
   DD_AZURE_RESOURCE_GROUP: string | undefined;
+  DD_BUNDLER_INJECT_GIT_METADATA: boolean;
   DD_CIVISIBILITY_AGENTLESS_ENABLED: boolean;
   DD_CIVISIBILITY_AGENTLESS_URL: URL | undefined;
   DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER: string | undefined;
@@ -718,6 +726,8 @@ export interface GeneratedEnvVarConfig {
   DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_POLL_INTERVAL_SECONDS: number;
   DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_REQUEST_TIMEOUT_SECONDS: number;
   DD_FEATURE_FLAGS_ENABLED: boolean;
+  DD_FEATURE_FLAGS_EVALUATION_TELEMETRY_PER_SUBJECT_OPT_OUT_ENABLED: boolean;
+  DD_FEATURE_FLAGS_EXPOSURES_DATADOG_LOGGING_ENABLED: boolean;
   DD_FLAGGING_EVALUATION_COUNTS_ENABLED: boolean;
   DD_GIT_BRANCH: string | undefined;
   DD_GIT_COMMIT_AUTHOR_DATE: string | undefined;

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

@@ -180,14 +180,17 @@ function loadConfigurationsTable () {
  * @param {string} name Canonical or alias environment variable name.
  * @param {string} value Raw value read from an environment source.
  * @param {'env_var'|'fleet_stable_config'|'local_stable_config'} source Source the value was read from.
+ * @param {boolean} [reportInvalid] Whether invalid values should produce configuration diagnostics.
  * @returns {string | number | boolean | object | undefined}
  */
-function parseConfigurationValue (name, value, source) {
+function parseConfigurationValue (name, value, source, reportInvalid = true) {
   loadConfigurationsTable()
   const canonical = aliasToCanonical[name] ?? name
   const entry = configurationsTable[canonical]
-  const parsed = entry.parser(value, canonical, source)
-  return parsed !== undefined && entry.transformer ? entry.transformer(parsed, canonical, source) : parsed
+  const parsed = entry.parser(value, canonical, source, reportInvalid)
+  return parsed !== undefined && entry.transformer
+    ? entry.transformer(parsed, canonical, source, reportInvalid)
+    : parsed
 }
 
 /**
@@ -376,4 +379,32 @@ module.exports = {
       }
     }
   },
+
+  /**
+   * Returns the environment variable name from the highest-priority source whose value is valid.
+   *
+   * @param {string} name Environment variable name
+   */
+  getValidatedConfiguredEnvName (name) {
+    validateAccess(name)
+
+    if (!stableConfigLoaded) {
+      loadStableConfig()
+    }
+
+    const sources = [
+      [fleetStableConfig, 'fleet_stable_config'],
+      [process.env, 'env_var'],
+      [localStableConfig, 'local_stable_config'],
+    ]
+    for (const [source, sourceName] of sources) {
+      if (source !== undefined) {
+        const fromSource = getEnvNameFromSource(name, source)
+        if (fromSource !== undefined &&
+          parseConfigurationValue(fromSource, source[fromSource], sourceName, false) !== undefined) {
+          return fromSource
+        }
+      }
+    }
+  },
 }

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

@@ -12,6 +12,7 @@ const uuid = require('../../../../vendor/dist/crypto-randomuuid') // we need to
 const set = require('../../../datadog-core/src/utils/src/set')
 const { DD_MAJOR, NODE_MAJOR } = require('../../../../version')
 const log = require('../log')
+const { warn } = require('../log/writer')
 const pkg = require('../pkg')
 const { isTrue } = require('../util')
 const telemetry = require('../telemetry')
@@ -25,6 +26,7 @@ const {
 const { ORIGIN_KEY, DATADOG_MINI_AGENT_PATH } = require('../constants')
 const { appendRules } = require('../payload-tagging/config')
 const { createSiteUrl } = require('../exporters/common/url')
+const { getUnsupportedRuntime } = require('../debugger/unsupported-runtime')
 const ConfigBase = require('./config-base')
 const {
   getEnvironmentVariable,
@@ -124,6 +126,8 @@ const changeTracker = {
  */
 function undo (config, source) {
   for (const name of changeTracker[source]) {
+    if (trackedConfigOrigins.get(name) !== source) continue
+
     const entry = changeTracker.baseValuesByPath[name] ?? { source: 'default', value: defaults[name] }
     setAndTrack(config, name, entry.value, undefined, entry.source)
   }
@@ -198,6 +202,12 @@ class Config extends ConfigBase {
    */
   #parsedDdTags
 
+  /**
+   * Options already explained as deactivated, so recalculating the config doesn't repeat the explanation
+   * @type {Set<ConfigPath>}
+   */
+  #explainedDeactivations = new Set()
+
   /**
    * @type {Record<string, string>}
    */
@@ -248,9 +258,9 @@ class Config extends ConfigBase {
     const { experimental, ...rest } = options
     if (experimental) {
       // @ts-expect-error - Difficult to type this correctly.
-      this.#applyOptions(experimental, 'code', 'experimental')
+      this.#applyOptions(experimental, 'experimental')
     }
-    this.#applyOptions(rest, 'code')
+    this.#applyOptions(rest)
     this.#applyCalculated()
 
     warnWrongOtelSettings()
@@ -280,10 +290,9 @@ class Config extends ConfigBase {
 
   /**
    * @param {TracerOptions} options
-   * @param {'code'} source
    * @param {string} [root]
    */
-  #applyOptions (options, source, root = '') {
+  #applyOptions (options, root = '') {
     for (const [name, value] of Object.entries(options)) {
       const fullName = root ? `${root}.${name}` : name
       let entry = optionsTable[fullName]
@@ -300,7 +309,7 @@ class Config extends ConfigBase {
             // Defining an option that receives an object as value may not contain a property that is also
             // potentially a nested property!
             if (Object.hasOwn(value, nestedProperty)) {
-              this.#applyOptions(value, source, fullName)
+              this.#applyOptions(value, fullName)
               matched = true
               break
             }
@@ -316,7 +325,7 @@ class Config extends ConfigBase {
             // TracePropagationStyle is special. It is a single option that is used to set both inject and extract.
             // TODO: Consider what to do with this later
             // @ts-expect-error - Difficult to type this correctly.
-            this.#applyOptions({ inject: value, extract: value }, source, 'tracePropagationStyle')
+            this.#applyOptions({ inject: value, extract: value }, 'tracePropagationStyle')
           } else {
             log.warn('Unknown option %s with value %o', fullName, value)
           }
@@ -325,12 +334,12 @@ class Config extends ConfigBase {
       }
       const coerced = programmaticTypeCoercions[entry.type](value)
       if (coerced === undefined && value !== undefined) {
-        warnInvalidValue(value, fullName, source, `Invalid ${entry.type} input`)
+        warnInvalidValue(value, fullName, 'code', `Invalid ${entry.type} input`)
       }
       const transformed = coerced !== undefined && entry.transformer
-        ? entry.transformer(coerced, fullName, source)
+        ? entry.transformer(coerced, fullName, 'code')
         : coerced
-      setAndTrack(this, entry.property ?? name, transformed, value, source)
+      setAndTrack(this, entry.property ?? name, transformed, value, 'code')
     }
   }
 
@@ -638,6 +647,12 @@ class Config extends ConfigBase {
       setAndTrack(this, 'remoteConfig.DD_REMOTE_CONFIGURATION_ENABLED', false)
     }
 
+    if (this.isCiVisibility) {
+      // Test Optimization reports its metrics through instrumentation telemetry, not DogStatsD.
+      set(this, 'dogstatsd', undefined)
+      setAndTrack(this, 'runtimeMetrics.enabled', false)
+    }
+
     const isTestOptimizationWorker = this.isCiVisibility &&
       TEST_OPTIMIZATION_WORKER_EXPORTERS.has(this.tracing.DD_TRACE_EXPERIMENTAL_EXPORTER)
     if (isTestOptimizationWorker) {
@@ -749,11 +764,42 @@ class Config extends ConfigBase {
       deactivateIfEnabledAndWarnOnWindows(this, 'DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED')
     }
 
+    const unsupportedRuntime = getUnsupportedRuntime()
+    if (unsupportedRuntime !== undefined) {
+      this.#deactivateOnUnsupportedRuntime(
+        'dynamicInstrumentation.DD_DYNAMIC_INSTRUMENTATION_ENABLED',
+        `Live Debugger/Dynamic Instrumentation is disabled, because it is not supported on ${unsupportedRuntime}.`
+      )
+      this.#deactivateOnUnsupportedRuntime(
+        'testOptimization.DD_TEST_FAILED_TEST_REPLAY_ENABLED',
+        'Failed Test Replay is disabled, ' +
+          `because Live Debugger/Dynamic Instrumentation is not supported on ${unsupportedRuntime}.`
+      )
+    }
+
     // Single tags update is tracked as a calculated value.
     setAndTrack(this, 'tags', this.tags)
 
     telemetry.updateConfig([...configWithOrigin.values()], this)
   }
+
+  /**
+   * Only explains the deactivation of an option that was explicitly set, since Failed Test Replay is enabled by
+   * default.
+   *
+   * @param {ConfigPath} name
+   * @param {string} reason
+   */
+  #deactivateOnUnsupportedRuntime (name, reason) {
+    if (!get(this, name)) return
+
+    if (this.startupLogs && trackedConfigOrigins.has(name) && !this.#explainedDeactivations.has(name)) {
+      this.#explainedDeactivations.add(name)
+      // `log.warn` only prints with debug logging enabled, so write the diagnostic like the startup logs do
+      warn(`DATADOG TRACER DIAGNOSTIC - ${reason}`)
+    }
+    setAndTrack(this, name, false)
+  }
 }
 
 /**

package/packages/dd-trace/src/config/normalize-service.js

@@ -11,7 +11,7 @@ const MAX_SERVICE_LENGTH = 100
  * `_scope/name` in runtime metrics. Pre-normalizing pins both consumers
  * (and telemetry / process tags) to the same value.
  *
- * @see https://github.com/DataDog/datadog-agent/blob/main/pkg/trace/traceutil/normalize.go
+ * @see https://github.com/DataDog/datadog-agent/blob/main/pkg/trace/traceutil/normalize/normalize.go
  * @param {string | undefined} name
  */
 function normalizeService (name) {

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

@@ -227,12 +227,12 @@ const transformers = {
     if (url?.protocol === 'http:' || url?.protocol === 'https:') return value
     warnInvalidValue(value, optionName, source, 'Invalid HTTP URL')
   },
-  validatePropagationStyles (value, optionName) {
+  validatePropagationStyles (value, optionName, _source, reportInvalid = true) {
     value = transformers.toLowerCase(value)
     for (let index = 0; index < value.length; index++) {
       const propagator = value[index]
       if (!VALID_PROPAGATION_STYLES.has(propagator)) {
-        warnInvalidValue(propagator, optionName, optionName, 'Invalid propagator')
+        if (reportInvalid) warnInvalidValue(propagator, optionName, optionName, 'Invalid propagator')
         return
       }
       if (DD_MAJOR >= 6 && propagator === 'b3 single header') {

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

@@ -508,6 +508,14 @@
         "default": null
       }
     ],
+    "DD_BUNDLER_INJECT_GIT_METADATA": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "true",
+        "description": "When using the Datadog esbuild or webpack plugin, inject DD_GIT_COMMIT_SHA and DD_GIT_REPOSITORY_URL into the bundle. Set to false for stable artifact hashes across commits."
+      }
+    ],
     "DD_CIVISIBILITY_AGENTLESS_ENABLED": [
       {
         "implementation": "A",
@@ -937,6 +945,17 @@
         "default": "false"
       }
     ],
+    "DD_FEATURE_FLAGS_EVALUATION_TELEMETRY_PER_SUBJECT_OPT_OUT_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "namespace": "featureFlags",
+        "configurationNames": [
+          "featureFlags.enableEvaluationTelemetryOptOutParameter"
+        ],
+        "default": "false"
+      }
+    ],
     "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE": [
       {
         "implementation": "A",
@@ -985,6 +1004,15 @@
         "namespace": "featureFlags"
       }
     ],
+    "DD_FEATURE_FLAGS_EXPOSURES_DATADOG_LOGGING_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "true",
+        "description": "Enable Feature Flagging exposure delivery to Datadog independently of flag evaluation and evaluation telemetry.",
+        "namespace": "featureFlags"
+      }
+    ],
     "DD_FLAGGING_EVALUATION_COUNTS_ENABLED": [
       {
         "implementation": "A",
@@ -2130,6 +2158,22 @@
         "namespace": "testOptimization"
       }
     ],
+    "_DD_TEST_PARALLELIZATION_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": null,
+        "description": "Internal: Identifies test processes started by ddtest run."
+      }
+    ],
+    "_DD_TEST_PARALLELIZATION_METADATA_FILE": [
+      {
+        "implementation": "A",
+        "type": "string",
+        "default": null,
+        "description": "Internal: Absolute path to planning metadata supplied by ddtest run."
+      }
+    ],
     "DD_TEST_SESSION_NAME": [
       {
         "implementation": "A",

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

@@ -28,8 +28,9 @@ class StatsPoint {
   }
 
   addLatencies (checkpoint) {
-    const edgeLatencySec = checkpoint.edgeLatencyNs / 1e9
-    const pathwayLatencySec = checkpoint.pathwayLatencyNs / 1e9
+    // Start times can come from another host's clock, so skew can make these negative.
+    const edgeLatencySec = Math.max(0, checkpoint.edgeLatencyNs / 1e9)
+    const pathwayLatencySec = Math.max(0, checkpoint.pathwayLatencyNs / 1e9)
     this.edgeLatency.accept(edgeLatencySec)
     this.pathwayLatency.accept(pathwayLatencySec)
     this.payloadSize.accept(checkpoint.payloadSize)

package/packages/dd-trace/src/datastreams/schemas/schema_builder.js

@@ -54,10 +54,7 @@ class SchemaBuilder {
   }
 
   shouldExtractSchema (schemaName, depth) {
-    if (depth > maxDepth) {
-      return false
-    }
-    if (schemaName in this.schema.components.schemas) {
+    if (depth > maxDepth || schemaName in this.schema.components.schemas) {
       return false
     }
     this.schema.components.schemas[schemaName] = new OpenApiSchema.SCHEMA()

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

@@ -103,14 +103,14 @@ async function addBreakpoint (probe) {
       file, lineNumber, columnNumber, probe.id, probe.version
     )
     const position = await getGeneratedPosition(url, source, lineNumber, sourceMapURL)
-    if (position.line !== null && position.column !== null) {
-      lineNumber = position.line
-      columnNumber = position.column
-    } else {
+    if (position.line === null || position.column === null) {
       throw new Error(
         // eslint-disable-next-line @stylistic/max-len
         `Could not find generated position for ${url}:${lineNumber}:${columnNumber} (probe: ${probe.id}, version: ${probe.version})`
       )
+    } else {
+      lineNumber = position.line
+      columnNumber = position.column
     }
   }
 
@@ -357,9 +357,10 @@ async function reEvaluateProbe (probe) {
 }
 
 async function start () {
-  sessionStarted = true
   log.debug('[debugger:devtools_client] Starting debugger')
   await session.post('Debugger.enable')
+  // Only flag the session as started once enabled, so the next probe retries a failed start and reports its cause
+  sessionStarted = true
 
   // Wait until there's a pause in script-loading to avoid accidentally adding probes to incorrect scripts. This is not
   // a guarantee, but best effort.

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

@@ -312,9 +312,9 @@ function isInstanceOfCoreType (type, variable, fallback = `${variable} instanceo
 function getSize (variable) {
   return `((val) => {
     if (${isString('val')} || ${isArrayOrTypedArray('val')}) {
-      return ${guardAgainstPropertyAccessSideEffects('val', '"length"')}
+      return ${guardAgainstPropertyAccessSideEffects('"length"')}
     } else if (${isInstanceOfCoreType('Set', 'val')} || ${isInstanceOfCoreType('Map', 'val')}) {
-      return ${guardAgainstPropertyAccessSideEffects('val', '"size"')}
+      return ${guardAgainstPropertyAccessSideEffects('"size"')}
     } else if (${isInstanceOfCoreType('WeakSet', 'val')} || ${isInstanceOfCoreType('WeakMap', 'val')}) {
       throw new TypeError('Cannot get size of WeakSet or WeakMap')
     } else if (typeof val === 'object' && val !== null) {
@@ -338,12 +338,12 @@ function accessProperty (variable, keyOrIndex, allowMapAccess) {
     } else if (${isInstanceOfCoreType('Set', 'val')} || ${isInstanceOfCoreType('WeakSet', 'val')}) {
       throw new Error('Accessing a Set or WeakSet is not allowed')
     } else {
-      return ${guardAgainstPropertyAccessSideEffects('val', 'key')}
+      return ${guardAgainstPropertyAccessSideEffects('key')}
     }
   })(${variable}, ${keyOrIndex})`
 }
 
-function guardAgainstPropertyAccessSideEffects (variable, propertyName) {
+function guardAgainstPropertyAccessSideEffects (propertyName) {
   return `((val, key) => {
     if (
       ${isInstanceOfCoreType('Proxy', 'val', 'true')} ||
@@ -353,7 +353,7 @@ function guardAgainstPropertyAccessSideEffects (variable, propertyName) {
     } else {
       return val[key]
     }
-  })(${variable}, ${propertyName})`
+  })(val, ${propertyName})`
 }
 
 function guardAgainstCoercionSideEffects (variable) {

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

@@ -61,6 +61,7 @@ function send (message, logger, dd, snapshot, processTags, eventType, incomplete
     ddsource,
     hostname,
     service,
+    timestamp: snapshot.timestamp,
     message,
     logger,
     dd,

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

@@ -126,8 +126,8 @@ async function traverseGetPropertiesResult (props, opts, depth) {
     if (prop.value === undefined) continue
     const { value: { type, objectId, subtype, description } } = prop
     if (type === 'object') {
-      if (objectId === undefined) continue // if `subtype` is "null"
-      if (LEAF_SUBTYPES.has(subtype)) continue // don't waste time with these subtypes
+      // if `subtype` is "null"
+      if (objectId === undefined || LEAF_SUBTYPES.has(subtype)) continue // don't waste time with these subtypes
       const size = parseLengthFromDescription(description, subtype)
       if (size !== null && size >= LARGE_OBJECT_SKIP_THRESHOLD) {
         const empty = []
@@ -310,8 +310,7 @@ function removeNonEnumerableProperties (props) {
 }
 
 function parseLengthFromDescription (description, subtype) {
-  if (typeof description !== 'string') return null
-  if (!SIZE_IN_DESCRIPTION_SUBTYPES.has(subtype)) return null
+  if (typeof description !== 'string' || !SIZE_IN_DESCRIPTION_SUBTYPES.has(subtype)) return null
 
   const open = description.lastIndexOf('(')
   if (open === -1) return null
@@ -323,8 +322,7 @@ function parseLengthFromDescription (description, subtype) {
   if (s === '') return null
 
   const n = Number(s)
-  if (!Number.isSafeInteger(n) || n < 0) return null
-  if (String(n) !== s) return null
+  if (!Number.isSafeInteger(n) || n < 0 || String(n) !== s) return null
 
   return n
 }

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

@@ -129,6 +129,7 @@ function statusPayload (probeId, probeVersion, status) {
   return {
     ddsource,
     service,
+    timestamp: Date.now(),
     debugger: {
       diagnostics: { probeId, runtimeId, probeVersion, status },
     },

package/packages/dd-trace/src/debugger/guardrail-metrics.js

@@ -9,10 +9,10 @@
  * atomics, and the main thread periodically drains the counters into instrumentation telemetry metrics.
  *
  * The metric names, tags and reason codes are defined by the "Debugger Observability for GA" specification and are
- * shared with the other tracers. All metrics are counts in the `live_debugger` telemetry namespace.
+ * shared with the other tracers. All metrics are counts in the `debugger` telemetry namespace.
  */
 
-const TELEMETRY_NAMESPACE = 'live_debugger'
+const TELEMETRY_NAMESPACE = 'debugger'
 
 const EVENT_TYPE = Object.freeze({
   SNAPSHOT: 0,

package/packages/dd-trace/src/debugger/unsupported-runtime.js

@@ -0,0 +1,16 @@
+'use strict'
+
+/**
+ * Get the name of the runtime if it can't run Live Debugger/Dynamic Instrumentation, or `undefined` if it can.
+ *
+ * Live Debugger/Dynamic Instrumentation needs the Debugger domain of the `node:inspector` module. Bun only implements a
+ * few of its methods, never returns their results, and never emits its events. Deno doesn't let worker threads
+ * connect to the main thread inspector. Deno reports a Node.js `process.version`, so both runtimes are detected by
+ * their own `process.versions` entry instead.
+ */
+function getUnsupportedRuntime () {
+  if (process.versions.bun !== undefined) return 'Bun'
+  if (process.versions.deno !== undefined) return 'Deno'
+}
+
+module.exports = { getUnsupportedRuntime }