dd-trace 5.110.0 → 5.111.0

package/packages/dd-trace/src/plugins/util/test.js

@@ -112,6 +112,12 @@ const TEST_RETRY_REASON = 'test.retry_reason'
 const TEST_HAS_FAILED_ALL_RETRIES = 'test.has_failed_all_retries'
 const TEST_IS_MODIFIED = 'test.is_modified'
 const TEST_HAS_DYNAMIC_NAME = '_dd.has_dynamic_name'
+const EARLY_FLAKE_DETECTION_RETRY_THRESHOLDS = [
+  { limitMs: 5 * 1000, key: '5s' },
+  { limitMs: 10 * 1000, key: '10s' },
+  { limitMs: 30 * 1000, key: '30s' },
+  { limitMs: 5 * 60 * 1000, key: '5m' },
+]
 const CI_APP_ORIGIN = 'ciapp-test'
 
 // Matches patterns that are almost certainly runtime-generated values in test names:
@@ -493,6 +499,7 @@ module.exports = {
   removeInvalidMetadata,
   parseAnnotations,
   getIsFaultyEarlyFlakeDetection,
+  EARLY_FLAKE_DETECTION_RETRY_THRESHOLDS,
   getEfdRetryCount,
   getMaxEfdRetryCount,
   TEST_BROWSER_DRIVER,
@@ -1447,13 +1454,7 @@ function parseAnnotations (annotations) {
  * @returns {number}
  */
 function getEfdRetryCount (durationMs, slowTestRetries) {
-  const thresholds = [
-    { limitMs: 5 * 1000, key: '5s' },
-    { limitMs: 10 * 1000, key: '10s' },
-    { limitMs: 30 * 1000, key: '30s' },
-    { limitMs: 5 * 60 * 1000, key: '5m' },
-  ]
-  for (const { limitMs, key } of thresholds) {
+  for (const { limitMs, key } of EARLY_FLAKE_DETECTION_RETRY_THRESHOLDS) {
     if (durationMs < limitMs) {
       return slowTestRetries[key] ?? 0
     }
@@ -1616,7 +1617,7 @@ function isFailedTestReplaySupported (testFramework, frameworkVersion) {
     : true
 }
 
-function getLibraryCapabilitiesTags (testFramework, frameworkVersion) {
+function getLibraryCapabilitiesTags (testFramework, frameworkVersion, options = {}) {
   return {
     [DD_CAPABILITIES_TEST_IMPACT_ANALYSIS]: isTiaSupported(testFramework)
       ? '1'
@@ -1638,7 +1639,8 @@ function getLibraryCapabilitiesTags (testFramework, frameworkVersion) {
       isAttemptToFixSupported(testFramework, frameworkVersion)
         ? '5'
         : undefined,
-    [DD_CAPABILITIES_FAILED_TEST_REPLAY]: isFailedTestReplaySupported(testFramework, frameworkVersion)
+    [DD_CAPABILITIES_FAILED_TEST_REPLAY]: !options.omitFailedTestReplay &&
+      isFailedTestReplaySupported(testFramework, frameworkVersion)
       ? '1'
       : undefined,
   }

package/packages/dd-trace/src/profiling/exporter_cli.js

@@ -18,7 +18,7 @@ function exporterFromURL (url) {
     return new FileExporter({}, fileURLToPath(url))
   }
   // The subprocess has no tracer config, so mirror the canonical config property
-  // names the exporters read. Normalize the raw env to the parsed profiling.enabled
+  // names the exporters read. Normalize the raw env to the parsed profiling.DD_PROFILING_ENABLED
   // values ('true' | 'false' | 'auto') the main process would have produced.
   const profilingEnabled = (getValueFromEnvSources('DD_PROFILING_ENABLED') ?? '').toLowerCase()
   const enabled = profilingEnabled === 'auto'
@@ -28,7 +28,7 @@ function exporterFromURL (url) {
     url,
     DD_PROFILING_UPLOAD_TIMEOUT: timeoutMs,
     DD_INJECTION_ENABLED: getValueFromEnvSources('DD_INJECTION_ENABLED'),
-    profiling: { enabled },
+    profiling: { DD_PROFILING_ENABLED: enabled },
   })
 }
 

package/packages/dd-trace/src/profiling/exporters/event_serializer.js

@@ -11,10 +11,10 @@ const processTags = require('../../process-tags')
 /** @typedef {import('../../config/config-base')} TracerConfig */
 
 /**
- * Maps the canonical profiling.enabled value to the activation reported in the
+ * Maps the canonical profiling.DD_PROFILING_ENABLED value to the activation reported in the
  * profile event.
  *
- * @param {string} [enabled] - config.profiling.enabled ('true' | 'false' | 'auto')
+ * @param {string} [enabled] - config.profiling.DD_PROFILING_ENABLED ('true' | 'false' | 'auto')
  * @returns {string}
  */
 function getActivation (enabled) {
@@ -38,7 +38,7 @@ class EventSerializer {
     this.#service = config.service
     this.#appVersion = config.version
     this.#libraryInjected = !!config.DD_INJECTION_ENABLED
-    this.#activation = getActivation(config.profiling?.enabled)
+    this.#activation = getActivation(config.profiling?.DD_PROFILING_ENABLED)
   }
 
   /**

package/packages/dd-trace/src/profiling/profilers/wall.js

@@ -148,7 +148,7 @@ class NativeWallProfiler {
     this.#endpointCollectionEnabled = config.DD_PROFILING_ENDPOINT_COLLECTION_ENABLED
     this.#flushIntervalMillis = flushInterval
     this.#samplingIntervalMicros = SAMPLING_INTERVAL * 1000
-    this.#telemetryHeartbeatIntervalMillis = config.telemetry.heartbeatInterval
+    this.#telemetryHeartbeatIntervalMillis = config.telemetry.DD_TELEMETRY_HEARTBEAT_INTERVAL
     this.#timelineEnabled = config.DD_PROFILING_TIMELINE_ENABLED
     this.#v8ProfilerBugWorkaroundEnabled = config.DD_PROFILING_V8_PROFILER_BUG_WORKAROUND
 

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

@@ -138,7 +138,7 @@ class Tracer extends NoopProxy {
         spanleak.startScrubber()
       }
 
-      if (config.remoteConfig.enabled && !config.isCiVisibility) {
+      if (config.remoteConfig.DD_REMOTE_CONFIGURATION_ENABLED && !config.isCiVisibility) {
         const RemoteConfig = require('./remote_config')
         const rc = new RemoteConfig(config)
 
@@ -180,11 +180,11 @@ class Tracer extends NoopProxy {
         openfeatureRemoteConfig.enable(rc, config, () => this.openfeature)
       }
 
-      if (config.profiling.enabled === 'true') {
+      if (config.profiling.DD_PROFILING_ENABLED === 'true') {
         this._profilerStarted = this._startProfiler(config)
       } else {
         this._profilerStarted = false
-        if (config.profiling.enabled === 'auto') {
+        if (config.profiling.DD_PROFILING_ENABLED === 'auto') {
           const { SSIHeuristics } = require('./profiling/ssi-heuristics')
           const ssiHeuristics = new SSIHeuristics(config)
           ssiHeuristics.start()
@@ -216,7 +216,7 @@ class Tracer extends NoopProxy {
 
       this._modules.rewriter.enable(config)
 
-      if (config.tracing && config.DD_CIVISIBILITY_MANUAL_API_ENABLED) {
+      if (config.DD_TRACE_ENABLED && config.testOptimization.DD_CIVISIBILITY_MANUAL_API_ENABLED) {
         const TestApiManualPlugin = require('./ci-visibility/test-api-manual/test-api-manual-plugin')
         this._testApiManualPlugin = new TestApiManualPlugin(this)
         // `shouldGetEnvironmentData` is passed as false so that we only lazily calculate it
@@ -225,7 +225,7 @@ class Tracer extends NoopProxy {
         this._testApiManualPlugin.configure({ ...config, enabled: true }, false)
       }
       if (config.DD_AGENTLESS_LOG_SUBMISSION_ENABLED) {
-        if (config.apiKey) {
+        if (config.DD_API_KEY) {
           const LogSubmissionPlugin = require('./ci-visibility/log-submission/log-submission-plugin')
           const automaticLogPlugin = new LogSubmissionPlugin(this)
           automaticLogPlugin.configure({ ...config, enabled: true })
@@ -237,7 +237,7 @@ class Tracer extends NoopProxy {
         }
       }
 
-      if (config.isTestDynamicInstrumentationEnabled) {
+      if (config.testOptimization.DD_TEST_FAILED_TEST_REPLAY_ENABLED) {
         const getDynamicInstrumentationClient = require('./ci-visibility/dynamic-instrumentation')
         // We instantiate the client but do not start the Worker here. The worker is started lazily
         getDynamicInstrumentationClient(config)
@@ -270,11 +270,11 @@ class Tracer extends NoopProxy {
    * @param {import('./config/config-base')} config - Tracer configuration
    */
   #updateTracing (config) {
-    if (config.tracing !== false) {
+    if (config.DD_TRACE_ENABLED !== false) {
       if (config.appsec.enabled) {
         this._modules.appsec.enable(config)
       }
-      if (config.llmobs.enabled) {
+      if (config.llmobs.DD_LLMOBS_ENABLED) {
         this._modules.llmobs.enable(config)
       }
       if (!this._tracingInitialized) {

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

@@ -11,16 +11,15 @@ const startedSpans = new WeakSet()
 const finishedSpans = new WeakSet()
 
 class SpanProcessor {
-  constructor (exporter, prioritySampler, config) {
+  constructor (exporter, prioritySampler, config, otlpStatsExporter) {
     this._exporter = exporter
     this._prioritySampler = prioritySampler
     this._config = config
     this._killAll = false
 
-    // TODO: This should already have been calculated in `config.js`.
-    if (config.stats?.enabled && !config.appsec?.standalone?.enabled) {
+    if (config.stats?.DD_TRACE_STATS_COMPUTATION_ENABLED && !config.appsec?.standalone?.enabled) {
       const { SpanStatsProcessor } = require('./span_stats')
-      this._stats = new SpanStatsProcessor(config)
+      this._stats = new SpanStatsProcessor(config, otlpStatsExporter)
     }
 
     this._spanSampler = new SpanSampler(config.sampler)
@@ -42,11 +41,11 @@ class SpanProcessor {
     const active = []
     const formatted = []
     const trace = spanContext._trace
-    const { flushMinSpans, tracing } = this._config
+    const { flushMinSpans, DD_TRACE_ENABLED } = this._config
     const { started, finished } = trace
 
     if (trace.record === false) return
-    if (tracing === false) {
+    if (DD_TRACE_ENABLED === false) {
       this._erase(trace, active)
       return
     }

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

@@ -10,8 +10,10 @@ const {
   HTTP_ENDPOINT,
   HTTP_ROUTE,
   HTTP_METHOD,
+  SPAN_KIND,
+  GRPC_STATUS_CODE,
 } = require('../../../ext/tags')
-const { ORIGIN_KEY, TOP_LEVEL_KEY, SVC_SRC_KEY } = require('./constants')
+const { ORIGIN_KEY, TOP_LEVEL_KEY, SVC_SRC_KEY, GRPC_STATUS_NAMES } = require('./constants')
 const { version } = require('./pkg')
 const processTags = require('./process-tags')
 
@@ -27,43 +29,32 @@ class SpanAggStats {
     this.aggKey = aggKey
     this.hits = 0
     this.topLevelHits = 0
-    this.errors = 0
-    this.duration = 0
-    this.okDistribution = new LogCollapsingLowestDenseDDSketch()
-    this.errorDistribution = new LogCollapsingLowestDenseDDSketch()
+    this.topLevelOkDistribution = new LogCollapsingLowestDenseDDSketch()
+    this.topLevelErrorDistribution = new LogCollapsingLowestDenseDDSketch()
+    this.nonTopLevelOkDistribution = new LogCollapsingLowestDenseDDSketch()
+    this.nonTopLevelErrorDistribution = new LogCollapsingLowestDenseDDSketch()
   }
 
   record (span) {
     const durationNs = span.duration
     this.hits++
-    this.duration += durationNs
-
-    if (span.metrics[TOP_LEVEL_KEY]) {
-      this.topLevelHits++
-    }
-
+    const isTopLevel = Boolean(span.metrics[TOP_LEVEL_KEY])
+    if (isTopLevel) this.topLevelHits++
     if (span.error) {
-      this.errors++
-      this.errorDistribution.accept(durationNs)
+      if (isTopLevel) this.topLevelErrorDistribution.accept(durationNs)
+      else this.nonTopLevelErrorDistribution.accept(durationNs)
     } else {
-      this.okDistribution.accept(durationNs)
+      if (isTopLevel) this.topLevelOkDistribution.accept(durationNs)
+      else this.nonTopLevelOkDistribution.accept(durationNs)
     }
   }
 
   toJSON () {
     const {
-      name,
-      service,
-      resource,
-      type,
-      statusCode,
-      synthetics,
-      method,
-      endpoint,
-      srvSrc,
+      name, service, resource, type, statusCode, synthetics, method, endpoint, srvSrc,
+      spanKind, rpcStatusCode,
     } = this.aggKey
-
-    return {
+    const base = {
       Name: name,
       Service: service,
       Resource: resource,
@@ -73,13 +64,34 @@ class SpanAggStats {
       HTTPMethod: method,
       HTTPEndpoint: endpoint,
       srv_src: srvSrc,
-      Hits: this.hits,
-      TopLevelHits: this.topLevelHits,
-      Errors: this.errors,
-      Duration: this.duration,
-      OkSummary: this.okDistribution.toProto(), // TODO: custom proto encoding
-      ErrorSummary: this.errorDistribution.toProto(), // TODO: custom proto encoding
+      SpanKind: spanKind,
+      GRPCStatusCode: rpcStatusCode,
+    }
+    const rows = []
+    if (this.topLevelHits > 0) {
+      rows.push({
+        ...base,
+        Hits: this.topLevelHits,
+        TopLevelHits: this.topLevelHits,
+        Errors: this.topLevelErrorDistribution.count,
+        Duration: this.topLevelOkDistribution.sum + this.topLevelErrorDistribution.sum,
+        OkSummary: this.topLevelOkDistribution.toProto(),
+        ErrorSummary: this.topLevelErrorDistribution.toProto(),
+      })
+    }
+    const nonTopLevelHits = this.hits - this.topLevelHits
+    if (nonTopLevelHits > 0) {
+      rows.push({
+        ...base,
+        Hits: nonTopLevelHits,
+        TopLevelHits: 0,
+        Errors: this.nonTopLevelErrorDistribution.count,
+        Duration: this.nonTopLevelOkDistribution.sum + this.nonTopLevelErrorDistribution.sum,
+        OkSummary: this.nonTopLevelOkDistribution.toProto(), // TODO: custom proto encoding
+        ErrorSummary: this.nonTopLevelErrorDistribution.toProto(), // TODO: custom proto encoding
+      })
     }
+    return rows
   }
 }
 
@@ -94,6 +106,12 @@ class SpanAggKey {
     this.endpoint = span.meta[HTTP_ROUTE] || span.meta[HTTP_ENDPOINT] || ''
     this.method = span.meta[HTTP_METHOD] || ''
     this.srvSrc = span.meta[SVC_SRC_KEY] || ''
+    this.spanKind = span.meta[SPAN_KIND] || ''
+    // dd gRPC plugin sets a numeric code via setTag; OTel/manual sets a string name via meta.
+    const grpcCode = span.meta[GRPC_STATUS_CODE] ?? span.metrics?.[GRPC_STATUS_CODE]
+    this.rpcStatusCode = typeof grpcCode === 'number'
+      ? (GRPC_STATUS_NAMES[grpcCode] ?? String(grpcCode))
+      : (grpcCode ?? '')
   }
 
   toString () {
@@ -107,6 +125,8 @@ class SpanAggKey {
       this.method,
       this.endpoint,
       this.srvSrc,
+      this.spanKind,
+      this.rpcStatusCode,
     ].join(',')
   }
 }
@@ -137,57 +157,60 @@ class TimeBuckets extends Map {
 class SpanStatsProcessor {
   constructor ({
     stats: {
-      enabled = false,
+      DD_TRACE_STATS_COMPUTATION_ENABLED: enabled = false,
       interval = 10,
-    },
+    } = {},
     hostname,
     port,
     url,
     env,
     tags,
-    version,
-  } = {}) {
-    this.exporter = new SpanStatsExporter({
-      hostname,
-      port,
-      tags,
-      url,
-    })
-    this.interval = interval
-    this.bucketSizeNs = interval * 1e9
+    version: appVersion,
+    _DD_TRACE_METRICS_OTEL_FLUSH_INTERVAL: flushIntervalMs,
+  } = {}, otlpExporter) {
+    if (!otlpExporter) {
+      this.exporter = new SpanStatsExporter({ hostname, port, tags, url })
+    }
+    const intervalMs = otlpExporter ? (flushIntervalMs ?? 10_000) : interval * 1e3
+    this.interval = intervalMs / 1e3
+    this.bucketSizeNs = intervalMs * 1e6
     this.buckets = new TimeBuckets()
     this.hostname = os.hostname()
     this.enabled = enabled
+    this.otlpExporter = otlpExporter || null
     this.env = env
     this.tags = tags || {}
     this.sequence = 0
-    this.version = version
+    this.version = appVersion
 
-    if (this.enabled) {
-      this.timer = setInterval(this.onInterval.bind(this), interval * 1e3)
+    if (this.enabled || this.otlpExporter) {
+      this.timer = setInterval(this.onInterval.bind(this), intervalMs)
       this.timer.unref?.()
     }
   }
 
   onInterval () {
-    const serialized = this._serializeBuckets()
-    if (!serialized) return
-
-    this.exporter.export({
-      Hostname: this.hostname,
-      Env: this.env,
-      Version: this.version || version,
-      Stats: serialized,
-      Lang: 'javascript',
-      TracerVersion: pkg.version,
-      RuntimeID: this.tags['runtime-id'],
-      Sequence: ++this.sequence,
-      ProcessTags: processTags.serialized,
-    })
+    const drained = this.#drainBuckets()
+
+    if (this.enabled && !this.otlpExporter) {
+      this.exporter.export({
+        Hostname: this.hostname,
+        Env: this.env,
+        Version: this.version || version,
+        Stats: this.#toV06Payload(drained),
+        Lang: 'javascript',
+        TracerVersion: pkg.version,
+        RuntimeID: this.tags['runtime-id'],
+        Sequence: ++this.sequence,
+        ProcessTags: processTags.serialized,
+      })
+    } else if (this.otlpExporter && drained.length > 0) {
+      this.otlpExporter.export(drained, this.bucketSizeNs)
+    }
   }
 
   onSpanFinished (span) {
-    if (!this.enabled) return
+    if (!this.enabled && !this.otlpExporter) return
     if (!span.metrics[TOP_LEVEL_KEY] && !span.metrics[MEASURED]) return
 
     const spanEndNs = span.start + span.duration
@@ -198,27 +221,22 @@ class SpanStatsProcessor {
       .record(span)
   }
 
-  _serializeBuckets () {
-    const { bucketSizeNs } = this
-    const serializedBuckets = []
-
+  #drainBuckets () {
+    const drained = []
     for (const [timeNs, bucket] of this.buckets.entries()) {
-      const bucketAggStats = []
-
-      for (const stats of bucket.values()) {
-        bucketAggStats.push(stats.toJSON())
-      }
-
-      serializedBuckets.push({
-        Start: timeNs,
-        Duration: bucketSizeNs,
-        Stats: bucketAggStats,
-      })
+      drained.push({ timeNs, bucket })
     }
-
     this.buckets.clear()
+    return drained
+  }
 
-    return serializedBuckets
+  #toV06Payload (drained) {
+    const { bucketSizeNs } = this
+    return drained.map(({ timeNs, bucket }) => ({
+      Start: timeNs,
+      Duration: bucketSizeNs,
+      Stats: [...bucket.values()].flatMap(stats => stats.toJSON()),
+    }))
   }
 }
 

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

@@ -76,6 +76,7 @@ function logGenericError (message) {
  */
 function configInfo () {
   const url = config.url
+  const profilingEnabled = config.profiling.DD_PROFILING_ENABLED
 
   return {
     [inspect.custom] () {
@@ -104,7 +105,7 @@ function configInfo () {
     ...(config.tags && config.tags.version && { dd_version: config.tags.version }),
     log_injection_enabled: !!config.logInjection,
     runtime_metrics_enabled: !!config.runtimeMetrics,
-    profiling_enabled: config.profiling?.enabled === 'true' || config.profiling?.enabled === 'auto',
+    profiling_enabled: profilingEnabled === 'true' || profilingEnabled === 'auto',
     appsec_enabled: config.appsec.enabled,
     data_streams_enabled: !!config.dsmEnabled,
   }

package/packages/dd-trace/src/telemetry/dependencies.js

@@ -32,7 +32,7 @@ function waitAndSend (config, application, host) {
       const [name, version, initialLoadModule] = dependency.split(' ')
       // If a dependency is from the initial load, *always* send the event
       // Otherwise, only send if dependencyCollection is enabled
-      const sendModule = isTrue(initialLoadModule) || config.telemetry?.dependencyCollection
+      const sendModule = isTrue(initialLoadModule) || config.telemetry.DD_TELEMETRY_DEPENDENCY_COLLECTION_ENABLED
 
       savedDependenciesToSend.delete(dependency)
 

package/packages/dd-trace/src/telemetry/endpoints.js

@@ -11,7 +11,10 @@ const { sendData } = require('./send-data')
  */
 /**
  * @typedef {import('./send-data').TelemetryConfig & {
- *   appsec?: { apiSecurity?: { endpointCollectionEnabled?: boolean, endpointCollectionMessageLimit?: number } }
+ *   appsec: {
+ *     DD_API_SECURITY_ENDPOINT_COLLECTION_ENABLED: boolean,
+ *     DD_API_SECURITY_ENDPOINT_COLLECTION_MESSAGE_LIMIT: number
+ *   }
  * }} TelemetryConfig
  */
 
@@ -142,8 +145,7 @@ function flushAndSend () {
   for (const [key, endpoint] of pendingEndpoints) {
     batchEndpoints.push(endpoint)
     pendingEndpoints.delete(key)
-    // Config is set when endpoint collection is enabled; message limit is optional
-    if (batchEndpoints.length >= (config.appsec?.apiSecurity?.endpointCollectionMessageLimit ?? 0)) break
+    if (batchEndpoints.length >= config.appsec.DD_API_SECURITY_ENDPOINT_COLLECTION_MESSAGE_LIMIT) break
   }
 
   const payloadObj = {
@@ -184,7 +186,7 @@ function flushAndSend () {
  * @param {import('./send-data').SendDataCallback} updateRetryDataFunction
  */
 function start (_config, _application, _host, getRetryDataFunction, updateRetryDataFunction) {
-  if (!_config.appsec?.apiSecurity?.endpointCollectionEnabled) return
+  if (!_config.appsec.DD_API_SECURITY_ENDPOINT_COLLECTION_ENABLED) return
 
   config = _config
   application = _application

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

@@ -5,14 +5,14 @@ let telemetry
 // Lazy load the telemetry module to avoid the performance impact of loading it unconditionally
 module.exports = {
   start (config, ...args) {
-    if (!config.telemetry.enabled) return
+    if (!config.telemetry.DD_INSTRUMENTATION_TELEMETRY_ENABLED) return
     telemetry ??= require('./telemetry')
     telemetry.start(config, ...args)
   },
   // This might be called before `start` so we have to trigger loading the
   // underlying module here as well.
   updateConfig (changes, config, ...args) {
-    if (!config.telemetry.enabled) return
+    if (!config.telemetry.DD_INSTRUMENTATION_TELEMETRY_ENABLED) return
     telemetry ??= require('./telemetry')
     telemetry.updateConfig(changes, config, ...args)
   },

package/packages/dd-trace/src/telemetry/logs/index.js

@@ -55,7 +55,7 @@ function onErrorLog (msg) {
 }
 
 function start (config) {
-  if (!config.telemetry.logCollection || enabled) return
+  if (!config.telemetry.DD_TELEMETRY_LOG_COLLECTION_ENABLED || enabled) return
 
   enabled = true
 

package/packages/dd-trace/src/telemetry/send-data.js

@@ -87,12 +87,12 @@ function getHeaders (config, application, reqType) {
   if (config.DD_ROOT_JS_SESSION_ID) {
     headers['dd-root-session-id'] = config.DD_ROOT_JS_SESSION_ID
   }
-  const debug = config.telemetry && config.telemetry.debug
+  const debug = config.telemetry && config.telemetry.DD_TELEMETRY_DEBUG
   if (debug) {
     headers['dd-telemetry-debug-enabled'] = 'true'
   }
-  if (config.apiKey) {
-    headers['dd-api-key'] = config.apiKey
+  if (config.DD_API_KEY) {
+    headers['dd-api-key'] = config.DD_API_KEY
   }
   return headers
 }
@@ -137,16 +137,16 @@ function sendData (config, application, host, reqType, payload = {}, cb = () =>
     hostname,
     port,
     isCiVisibility,
-    DD_CIVISIBILITY_AGENTLESS_ENABLED,
+    testOptimization,
   } = config
 
   let url = config.url
 
-  const isCiVisibilityAgentlessMode = isCiVisibility && DD_CIVISIBILITY_AGENTLESS_ENABLED
+  const isCiVisibilityAgentlessMode = isCiVisibility && testOptimization.DD_CIVISIBILITY_AGENTLESS_ENABLED
 
   if (isCiVisibilityAgentlessMode) {
     try {
-      url = config.DD_CIVISIBILITY_AGENTLESS_URL ?? new URL(getAgentlessTelemetryEndpoint(config.site))
+      url = testOptimization.DD_CIVISIBILITY_AGENTLESS_URL ?? new URL(getAgentlessTelemetryEndpoint(config.site))
     } catch (err) {
       log.error('Telemetry endpoint url is invalid', err)
       // No point to do the request if the URL is invalid
@@ -176,7 +176,7 @@ function sendData (config, application, host, reqType, payload = {}, cb = () =>
   })
 
   request(data, options, (error) => {
-    if (error && config.apiKey && config.site) {
+    if (error && config.DD_API_KEY && config.site) {
       if (agentTelemetry) {
         log.warn('Agent telemetry failed, started agentless telemetry')
         agentTelemetry = false
@@ -189,7 +189,7 @@ function sendData (config, application, host, reqType, payload = {}, cb = () =>
         log.error('Invalid Telemetry URL')
         return
       }
-      const backendHeader = { ...options.headers, 'DD-API-KEY': config.apiKey }
+      const backendHeader = { ...options.headers, 'DD-API-KEY': config.DD_API_KEY }
       const backendOptions = {
         ...options,
         url: backendUrl,

package/packages/dd-trace/src/telemetry/session-propagation.js

@@ -40,7 +40,7 @@ function onChildProcessStart (context) {
 }
 
 function start (config) {
-  if (!config.telemetry?.enabled || subscribed) return
+  if (!config.telemetry.DD_INSTRUMENTATION_TELEMETRY_ENABLED || subscribed) return
   subscribed = true
 
   runtimeId = config.DD_ROOT_JS_SESSION_ID || config.tags['runtime-id']