dd-trace 5.98.0 → 5.99.1

package/packages/dd-trace/src/opentelemetry/tracer.js

@@ -81,10 +81,10 @@ class Tracer {
   }
 
   _convertOtelContextToDatadog (traceId, spanId, traceFlag, ts, meta = {}) {
-    const origin = null
+    let origin = null
     let samplingPriority = traceFlag
 
-    ts = ts?.traceparent || null
+    ts = ts?.traceparent
 
     if (ts) {
       // Use TraceState.fromString to parse the tracestate header
@@ -101,19 +101,17 @@ class Tracer {
         // Assuming ddTraceStateData is now a Map or similar structure containing Datadog trace state data
         // Extract values as needed, similar to the original logic
         const samplingPriorityTs = ddTraceStateData.get('s')
-        const origin = ddTraceStateData.get('o')
+        origin = ddTraceStateData.get('o') ?? null
         // Convert Map to object for meta
         const otherPropagatedTags = Object.fromEntries(ddTraceStateData.entries())
 
         // Update meta and samplingPriority based on extracted values
         Object.assign(meta, otherPropagatedTags)
-        samplingPriority = TextMapPropagator._getSamplingPriority(
-          traceFlag,
-          Number.parseInt(samplingPriorityTs, 10),
-          origin
-        )
+        // Guard against an undefined/empty `s:` field that would result in NaN.
+        const tracestateSamplingPriority = samplingPriorityTs ? Math.trunc(samplingPriorityTs) : undefined
+        samplingPriority = TextMapPropagator._getSamplingPriority(traceFlag, tracestateSamplingPriority, origin)
       } else {
-        log.debug('no dd list member in tracestate from incoming request:', ts)
+        log.debug('No dd list member in tracestate from incoming request:', ts)
       }
     }
 
@@ -121,8 +119,8 @@ class Tracer {
       traceId: id(traceId, 16), spanId: id(), tags: meta, parentId: id(spanId, 16),
     })
 
-    spanContext._sampling = { priority: samplingPriority }
-    spanContext._trace = { origin }
+    spanContext._ddContext._sampling = { priority: samplingPriority }
+    spanContext._ddContext._trace = { ...spanContext._ddContext._trace, origin }
     return spanContext
   }
 

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -64,6 +64,7 @@ const tracestateTagValueFilter = /[^\x20-\x2B\x2D-\x3A\x3C-\x7D]/g
 const invalidSegment = /^0+$/
 const zeroTraceId = '0000000000000000'
 const hex16 = /^[0-9A-Fa-f]{16}$/
+const percentByte = /%([0-9A-Fa-f]{2})/g
 
 class TextMapPropagator {
   #extractB3Context
@@ -173,15 +174,15 @@ class TextMapPropagator {
       const baggageItems = getAllBaggageItems()
       if (!baggageItems) return
       for (const [key, value] of Object.entries(baggageItems)) {
-        const baggageKey = String(key).trim()
-        if (!baggageKey || !baggageTokenExpr.test(baggageKey)) continue
+        const baggageKey = key.trim()
+        if (!baggageTokenExpr.test(baggageKey)) continue
 
         // Do not trim values. If callers include leading/trailing whitespace, it must be percent-encoded.
         // W3C list-member allows optional properties after ';'.
         // https://www.w3.org/TR/baggage/#header-content
-        const item = `${baggageKey}=${encodeURIComponent(String(value))},`
+        const item = `${baggageKey}=${encodeURIComponent(value)},`
         itemCounter += 1
-        byteCounter += Buffer.byteLength(item)
+        byteCounter += item.length
 
         // Check for item count limit exceeded
         if (itemCounter > this._config.baggageMaxItems) {
@@ -209,7 +210,7 @@ class TextMapPropagator {
   _injectTags (spanContext, carrier) {
     const trace = spanContext._trace
 
-    if (this._config.tagsHeaderMaxLength === 0) {
+    if (this._config.DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH === 0) {
       log.debug('Trace tag propagation is disabled, skipping injection.')
       return
     }
@@ -228,7 +229,7 @@ class TextMapPropagator {
 
     const header = tags.join(',')
 
-    if (header.length > this._config.tagsHeaderMaxLength) {
+    if (header.length > this._config.DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH) {
       log.error('Trace tags from span are too large, skipping injection.')
     } else if (header) {
       carrier[tagsKey] = header
@@ -387,7 +388,7 @@ class TextMapPropagator {
       if (context === null) {
         context = extractedContext
         style = extractor
-        if (this._config.tracePropagationExtractFirst) {
+        if (this._config.DD_TRACE_PROPAGATION_EXTRACT_FIRST) {
           break
         }
       } else {
@@ -436,7 +437,7 @@ class TextMapPropagator {
     this._extractSamplingPriority(carrier, spanContext)
     this._extractTags(carrier, spanContext)
 
-    if (this._config.tracePropagationExtractFirst) return spanContext
+    if (this._config.DD_TRACE_PROPAGATION_EXTRACT_FIRST) return spanContext
 
     const tc = this._extractTraceparentContext(carrier)
 
@@ -706,9 +707,8 @@ class TextMapPropagator {
       try {
         value = decodeURIComponent(value)
       } catch {
-        tracerMetrics.count('context_header_style.malformed', ['header_style:baggage']).inc()
-        removeAllBaggageItems()
-        return
+        const bytes = value.replaceAll(percentByte, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
+        value = Buffer.from(bytes, 'binary').toString('utf8')
       }
 
       if (spanContext && (tagAllKeys || baggageTagKeys.has(key))) {
@@ -734,9 +734,9 @@ class TextMapPropagator {
 
     const trace = spanContext._trace
 
-    if (this._config.tagsHeaderMaxLength === 0) {
+    if (this._config.DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH === 0) {
       log.debug('Trace tag propagation is disabled, skipping extraction.')
-    } else if (carrier[tagsKey].length > this._config.tagsHeaderMaxLength) {
+    } else if (carrier[tagsKey].length > this._config.DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH) {
       log.error('Trace tags from carrier are too large, skipping extraction.')
     } else {
       const pairs = carrier[tagsKey].split(',')
@@ -802,18 +802,25 @@ class TextMapPropagator {
     return spanContext._traceId.toString(16)
   }
 
-  static _getSamplingPriority (traceparentSampled, tracestateSamplingPriority, origin = null) {
+  /**
+   * @param {number} traceparentSampled
+   * @param {number|undefined} tracestateSamplingPriority
+   * @param {string|null} origin
+   * @returns {import('../../priority_sampler').SamplingPriority}
+   */
+  static _getSamplingPriority (traceparentSampled, tracestateSamplingPriority, origin) {
     const fromRumWithoutPriority = !tracestateSamplingPriority && origin === 'rum'
 
-    let samplingPriority
-    if (!fromRumWithoutPriority && traceparentSampled === 0 &&
-    (!tracestateSamplingPriority || tracestateSamplingPriority >= 0)) {
-      samplingPriority = 0
-    } else if (!fromRumWithoutPriority && traceparentSampled === 1 &&
-    (!tracestateSamplingPriority || tracestateSamplingPriority < 0)) {
-      samplingPriority = 1
-    } else {
-      samplingPriority = tracestateSamplingPriority
+    let samplingPriority =
+      /** @type {import('../../priority_sampler').SamplingPriority} */ (tracestateSamplingPriority ?? AUTO_KEEP)
+    if (!fromRumWithoutPriority) {
+      if (traceparentSampled === 0 &&
+          (!tracestateSamplingPriority || tracestateSamplingPriority >= 0)) {
+        samplingPriority = AUTO_REJECT
+      } else if (traceparentSampled === 1 &&
+                 (!tracestateSamplingPriority || tracestateSamplingPriority < 0)) {
+        samplingPriority = AUTO_KEEP
+      }
     }
 
     return samplingPriority

package/packages/dd-trace/src/opentracing/span.js

@@ -112,7 +112,7 @@ class DatadogSpan {
     // even `Span` itself in this case.
     //
     // TODO: Refactor Tracer/Span + tests to avoid having to do nullish checks.
-    if (tracer?._config?.spanLeakDebug > 0) {
+    if (tracer?._config?.DD_TRACE_SPAN_LEAK_DEBUG > 0) {
       require('../spanleak').addSpan(this, operationName)
     }
 
@@ -149,7 +149,7 @@ class DatadogSpan {
   }
 
   /**
-   * @returns {import('../priority_sampler').DatadogSpanContext}
+   * @returns {import('./span_context')}
    */
   context () {
     return this._spanContext

package/packages/dd-trace/src/opentracing/tracer.js

@@ -20,7 +20,7 @@ const REFERENCE_CHILD_OF = 'child_of'
 const REFERENCE_FOLLOWS_FROM = 'follows_from'
 
 class DatadogTracer {
-  constructor (config, prioritySampler, exporter) {
+  constructor (config, prioritySampler) {
     this._config = config
     this._service = config.service
     this._version = config.version
@@ -29,8 +29,15 @@ class DatadogTracer {
     this._debug = config.debug
     this._prioritySampler = prioritySampler ?? new PrioritySampler(config.env, config.sampler)
 
-    if (exporter) {
-      this._exporter = exporter
+    // OTEL_TRACES_EXPORTER=otlp should not replace the Test Optimization
+    // exporter when the tracer is running in Test Optimization mode. Test spans
+    // (test_session/test_module/ test_suite/test) belong on the citestcycle
+    // endpoint, not on an OTLP traces endpoint — otherwise users with OTEL_*
+    // vars set in their environment (e.g. for a separate telemetry integration)
+    // silently lose all test spans.
+    if (config.OTEL_TRACES_EXPORTER === 'otlp' && !config.isCiVisibility) {
+      const { createOtlpTraceExporter } = require('../opentelemetry/trace')
+      this._exporter = createOtlpTraceExporter(config)
     } else {
       const Exporter = getExporter(config.experimental.exporter)
       this._exporter = new Exporter(config, this._prioritySampler)
@@ -43,7 +50,7 @@ class DatadogTracer {
     this._propagators = {
       [formats.TEXT_MAP]: new TextMapPropagator(config),
       [formats.HTTP_HEADERS]: new HttpPropagator(config),
-      [formats.BINARY]: new BinaryPropagator(config),
+      [formats.BINARY]: new BinaryPropagator(),
       [formats.LOG]: new LogPropagator(config),
       [formats.TEXT_MAP_DSM]: new DSMTextMapPropagator(config),
     }
@@ -116,7 +123,7 @@ class DatadogTracer {
  * Get the span context from a span or a span context.
  *
  * @param {Span|SpanContext} spanContext
- * @returns {SpanContext}
+ * @returns {SpanContext|null}
  */
 function getContext (spanContext) {
   if (spanContext instanceof Span) {

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

@@ -163,9 +163,9 @@ module.exports = class PluginManager {
       dsmEnabled,
       clientIpEnabled,
       clientIpHeader,
-      memcachedCommandEnabled,
-      ciVisibilityTestSessionName,
-      ciVisAgentlessLogSubmissionEnabled,
+      DD_TRACE_MEMCACHED_COMMAND_ENABLED,
+      DD_TEST_SESSION_NAME,
+      DD_AGENTLESS_LOG_SUBMISSION_ENABLED,
       isTestDynamicInstrumentationEnabled,
       isServiceUserProvided,
       middlewareTracingEnabled,
@@ -180,13 +180,13 @@ module.exports = class PluginManager {
       codeOriginForSpans,
       dbmPropagationMode,
       dsmEnabled,
-      memcachedCommandEnabled,
+      DD_TRACE_MEMCACHED_COMMAND_ENABLED,
       site,
       url,
       headers: headerTags || [],
       clientIpHeader,
-      ciVisibilityTestSessionName,
-      ciVisAgentlessLogSubmissionEnabled,
+      DD_TEST_SESSION_NAME,
+      DD_AGENTLESS_LOG_SUBMISSION_ENABLED,
       isTestDynamicInstrumentationEnabled,
       isServiceUserProvided,
       traceWebsocketMessagesEnabled,

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

@@ -6,6 +6,7 @@ const plugins = {
   get '@aws-sdk/smithy-client' () { return require('../../../datadog-plugin-aws-sdk/src') },
   get '@azure/event-hubs' () { return require('../../../datadog-plugin-azure-event-hubs/src') },
   get '@azure/functions' () { return require('../../../datadog-plugin-azure-functions/src') },
+  get '@modelcontextprotocol/sdk' () { return require('../../../datadog-plugin-modelcontextprotocol-sdk/src') },
   get 'durable-functions' () { return require('../../../datadog-plugin-azure-durable-functions/src') },
   get '@azure/service-bus' () { return require('../../../datadog-plugin-azure-service-bus/src') },
   get '@cucumber/cucumber' () { return require('../../../datadog-plugin-cucumber/src') },

package/packages/dd-trace/src/plugins/log_plugin.js

@@ -51,7 +51,7 @@ module.exports = class LogPlugin extends Plugin {
   configure (config) {
     return super.configure({
       ...config,
-      enabled: config.enabled && (config.logInjection || config.ciVisAgentlessLogSubmissionEnabled),
+      enabled: config.enabled && (config.logInjection || config.DD_AGENTLESS_LOG_SUBMISSION_ENABLED),
     })
   }
 }

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

@@ -9,7 +9,6 @@ const { getEnvironmentVariable } = require('../../config/helper')
 const satisfies = require('../../../../../vendor/dist/semifies')
 
 const istanbul = require('../../../../../vendor/dist/istanbul-lib-coverage')
-const ignore = require('../../../../../vendor/dist/ignore')
 
 const id = require('../../id')
 const {
@@ -671,24 +670,146 @@ function getCodeOwnersFileEntries (rootDir) {
     const trimmed = content.trim()
     if (trimmed === '') continue
     const [pattern, ...owners] = trimmed.split(/\s+/)
-    entries.push({ pattern, owners })
+    entries.push(setCodeOwnersPatternRegex({ pattern, owners }))
   }
   // Reverse because rules defined last take precedence
   return entries.reverse()
 }
 
-const codeOwnersPerFileName = new Map()
+const codeOwnersPerEntries = new WeakMap()
+
+/**
+ * @param {string} character
+ * @returns {string}
+ */
+function escapeRegexCharacter (character) {
+  return character.replaceAll(/[|\\{}()[\]^$+*?.]/g, String.raw`\$&`)
+}
+
+/**
+ * @param {string} pattern
+ * @returns {boolean}
+ */
+function hasUnescapedWildcard (pattern) {
+  for (let i = 0; i < pattern.length; i++) {
+    const character = pattern[i]
+    if (character === '\\') {
+      i++
+    } else if (character === '*' || character === '?') {
+      return true
+    }
+  }
+  return false
+}
+
+/**
+ * @param {string} pattern
+ * @returns {string}
+ */
+function codeOwnersPatternToRegexSource (pattern) {
+  let source = ''
+  for (let i = 0; i < pattern.length; i++) {
+    const character = pattern[i]
+
+    if (character === '\\') {
+      const escapedCharacter = pattern[i + 1]
+      source += escapedCharacter === undefined
+        ? escapeRegexCharacter(character)
+        : escapeRegexCharacter(escapedCharacter)
+      i++
+    } else if (character === '*') {
+      if (pattern[i + 1] === '*') {
+        if (pattern[i + 2] === '/') {
+          source += '(?:.*/)?'
+          i += 2
+        } else {
+          source += '.*'
+          i++
+        }
+      } else {
+        source += '[^/]*'
+      }
+    } else if (character === '?') {
+      source += '[^/]'
+    } else {
+      source += escapeRegexCharacter(character)
+    }
+  }
+  return source
+}
+
+/**
+ * @param {string} pattern
+ * @returns {RegExp|null}
+ */
+function getCodeOwnersPatternRegex (pattern) {
+  if (!pattern || pattern[0] === '!') {
+    return null
+  }
+
+  const directoryOnly = pattern.endsWith('/')
+  const normalizedPattern = pattern.replace(/^\/+/, '').replace(/\/+$/, '')
+  const anchored = pattern.startsWith('/') || normalizedPattern.includes('/')
+
+  if (!normalizedPattern) {
+    return null
+  }
+
+  const lastSlashIndex = normalizedPattern.lastIndexOf('/')
+  const lastSegment = lastSlashIndex === -1 ? normalizedPattern : normalizedPattern.slice(lastSlashIndex + 1)
+  const descendantSuffix = directoryOnly || !hasUnescapedWildcard(lastSegment) ? '(?:/.*)?' : ''
+  const patternSource = codeOwnersPatternToRegexSource(normalizedPattern)
+  const regexSource = anchored
+    ? `^${patternSource}${descendantSuffix}$`
+    : `(?:^|/)${patternSource}${descendantSuffix}$`
+
+  return new RegExp(regexSource)
+}
+
+function setCodeOwnersPatternRegex (entry) {
+  Object.defineProperty(entry, 'regex', {
+    configurable: true,
+    value: getCodeOwnersPatternRegex(entry.pattern),
+    writable: true,
+  })
+  return entry
+}
+
+/**
+ * Match a repository-relative filename against a CODEOWNERS pattern.
+ * See GitHub's CODEOWNERS pattern rules:
+ * https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners
+ *
+ * @param {RegExp|null} regex
+ * @param {string} filename
+ * @returns {boolean}
+ */
+function isCodeOwnersPatternMatch (regex, filename) {
+  if (!regex || !filename) {
+    return false
+  }
+
+  const normalizedFilename = filename.replaceAll('\\', '/').replace(/^\/+/, '')
+  return regex.test(normalizedFilename)
+}
 
 function getCodeOwnersForFilename (filename, entries) {
   if (!entries) {
     return null
   }
-  if (codeOwnersPerFileName.has(filename)) {
+  let codeOwnersPerFileName = codeOwnersPerEntries.get(entries)
+
+  if (!codeOwnersPerFileName) {
+    codeOwnersPerFileName = new Map()
+    codeOwnersPerEntries.set(entries, codeOwnersPerFileName)
+  } else if (codeOwnersPerFileName.has(filename)) {
     return codeOwnersPerFileName.get(filename)
   }
+
   for (const entry of entries) {
     try {
-      const isResponsible = ignore().add(entry.pattern).ignores(filename)
+      const regex = entry.regex === undefined ? setCodeOwnersPatternRegex(entry).regex : entry.regex
+      const isResponsible = isCodeOwnersPatternMatch(regex, filename)
       if (isResponsible) {
         const codeOwners = JSON.stringify(entry.owners)
         codeOwnersPerFileName.set(filename, codeOwners)
@@ -934,8 +1055,8 @@ function getIsFaultyEarlyFlakeDetection (projectSuites, testsBySuiteName, faulty
 }
 
 function getTestSessionName (config, trimmedCommand, envTags) {
-  if (config.ciVisibilityTestSessionName) {
-    return config.ciVisibilityTestSessionName
+  if (config.DD_TEST_SESSION_NAME) {
+    return config.DD_TEST_SESSION_NAME
   }
   const lageTestSessionName = getLageTestSessionName()
   if (lageTestSessionName) {

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

@@ -31,7 +31,8 @@ function extractURL (req) {
 }
 
 function getProtocol (req) {
-  return (req.socket?.encrypted || req.connection?.encrypted) ? 'https' : 'http'
+  // Do not check deprecated `req.connection` property.
+  return req.socket?.encrypted ? 'https' : 'http'
 }
 
 /**

package/packages/dd-trace/src/profiling/profilers/event_plugins/crypto.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const EventPlugin = require('./event')
+
+// Params captured on the instrumentation context that are safe to forward as pprof labels. Must be
+// a subset of the names declared in asyncParamsByMethod in datadog-instrumentations/src/crypto.js.
+const allowedParams = new Set([
+  'algorithm', 'digest', 'iterations', 'keylen', 'offset', 'operation', 'size', 'type',
+])
+
+class CryptoPlugin extends EventPlugin {
+  static id = 'crypto'
+
+  static operation = 'operation'
+
+  static entryType = 'crypto'
+
+  extendEvent (event, ctx) {
+    const detail = {}
+    for (const name of allowedParams) {
+      const value = ctx[name]
+      if (typeof value === 'string' || typeof value === 'number') {
+        detail[name] = value
+      }
+    }
+    event.detail = detail
+
+    return event
+  }
+}
+
+module.exports = CryptoPlugin

package/packages/dd-trace/src/profiling/profilers/event_plugins/zlib.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const EventPlugin = require('./event')
+
+class ZlibPlugin extends EventPlugin {
+  static id = 'zlib'
+
+  static operation = 'operation'
+
+  static entryType = 'zlib'
+
+  extendEvent (event, ctx) {
+    event.detail = { operation: ctx.operation }
+
+    return event
+  }
+}
+
+module.exports = ZlibPlugin

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

@@ -194,13 +194,46 @@ class FilesystemDecorator {
   }
 }
 
+class ZlibDecorator {
+  constructor (stringTable) {
+    this.stringTable = stringTable
+    this.operationNameLabelKey = stringTable.dedup('operation')
+  }
+
+  decorateSample (sampleInput, item) {
+    sampleInput.label.push(labelFromStr(this.stringTable, this.operationNameLabelKey, item.detail.operation))
+  }
+}
+
+class CryptoDecorator {
+  constructor (stringTable) {
+    this.stringTable = stringTable
+  }
+
+  decorateSample (sampleInput, item) {
+    const labels = sampleInput.label
+    const stringTable = this.stringTable
+    for (const [key, value] of Object.entries(item.detail)) {
+      switch (typeof value) {
+        case 'string':
+          labels.push(labelFromStrStr(stringTable, key, value))
+          break
+        case 'number':
+          labels.push(new Label({ key: stringTable.dedup(key), num: value }))
+      }
+    }
+  }
+}
+
 // Keys correspond to PerformanceEntry.entryType, values are constructor
 // functions for type-specific decorators.
 const decoratorTypes = {
+  crypto: CryptoDecorator,
   fs: FilesystemDecorator,
   dns: DNSDecorator,
   gc: GCDecorator,
   net: NetDecorator,
+  zlib: ZlibDecorator,
 }
 
 // Translates performance entries into pprof samples.
@@ -348,12 +381,14 @@ class DatadogInstrumentationEventSource {
   constructor (eventHandler, eventFilter) {
     // List all entries explicitly for bundlers to pick up the require calls correctly.
     const plugins = [
+      require('./event_plugins/crypto'),
       require('./event_plugins/dns_lookup'),
       require('./event_plugins/dns_lookupservice'),
       require('./event_plugins/dns_resolve'),
       require('./event_plugins/dns_reverse'),
       require('./event_plugins/fs'),
       require('./event_plugins/net'),
+      require('./event_plugins/zlib'),
     ]
     this.plugins = plugins.map((Plugin) => {
       return new Plugin(eventHandler, eventFilter)

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

@@ -1,6 +1,5 @@
 'use strict'
 
-const { getValueFromEnvSources } = require('./config/helper')
 const NoopProxy = require('./noop/proxy')
 const DatadogTracer = require('./tracer')
 const getConfig = require('./config')
@@ -129,11 +128,11 @@ class Tracer extends NoopProxy {
         lazyProxy(this, 'dogstatsd', () => require('./dogstatsd').CustomMetrics, config)
       }
 
-      if (config.spanLeakDebug > 0) {
+      if (config.DD_TRACE_SPAN_LEAK_DEBUG > 0) {
         const spanleak = require('./spanleak')
-        if (config.spanLeakDebug === spanleak.MODES.LOG) {
+        if (config.DD_TRACE_SPAN_LEAK_DEBUG === spanleak.MODES.LOG) {
           spanleak.enableLogging()
-        } else if (config.spanLeakDebug === spanleak.MODES.GC_AND_LOG) {
+        } else if (config.DD_TRACE_SPAN_LEAK_DEBUG === spanleak.MODES.GC_AND_LOG) {
           spanleak.enableGarbageCollection()
         }
         spanleak.startScrubber()
@@ -204,7 +203,7 @@ class Tracer extends NoopProxy {
 
       this._modules.rewriter.enable(config)
 
-      if (config.tracing && config.isManualApiEnabled) {
+      if (config.tracing && config.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
@@ -212,8 +211,8 @@ class Tracer extends NoopProxy {
         // are lazily configured when the library is imported.
         this._testApiManualPlugin.configure({ ...config, enabled: true }, false)
       }
-      if (config.ciVisAgentlessLogSubmissionEnabled) {
-        if (getValueFromEnvSources('DD_API_KEY')) {
+      if (config.DD_AGENTLESS_LOG_SUBMISSION_ENABLED) {
+        if (config.apiKey) {
           const LogSubmissionPlugin = require('./ci-visibility/log-submission/log-submission-plugin')
           const automaticLogPlugin = new LogSubmissionPlugin(this)
           automaticLogPlugin.configure({ ...config, enabled: true })
@@ -225,7 +224,7 @@ class Tracer extends NoopProxy {
         }
       }
 
-      if (config.otelLogsEnabled) {
+      if (config.DD_LOGS_OTEL_ENABLED) {
         const { initializeOpenTelemetryLogs } = require('./opentelemetry/logs')
         initializeOpenTelemetryLogs(config)
       }
@@ -279,12 +278,7 @@ class Tracer extends NoopProxy {
         const prioritySampler = config.apmTracingEnabled === false
           ? require('./standalone').configure(config)
           : undefined
-        let otlpExporter
-        if (config.otelTracesEnabled) {
-          const { buildResourceAttributes, createOtlpTraceExporter } = require('./opentelemetry/trace')
-          otlpExporter = createOtlpTraceExporter(config, buildResourceAttributes(config))
-        }
-        this._tracer = new DatadogTracer(config, prioritySampler, otlpExporter)
+        this._tracer = new DatadogTracer(config, prioritySampler)
         this.dataStreamsCheckpointer = this._tracer.dataStreamsCheckpointer
         lazyProxy(this, 'appsec', () => require('./appsec/sdk'), this._tracer, config)
         lazyProxy(this, 'llmobs', () => require('./llmobs/sdk'), this._tracer, this._modules.llmobs, config)

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

@@ -51,6 +51,8 @@ module.exports = {
     const trackEventLoop = config.runtimeMetrics.eventLoop !== false
     const trackGc = config.runtimeMetrics.gc !== false
 
+    client = new MetricsAggregationClient(new DogStatsDClient(clientConfig))
+
     if (trackGc) {
       startGCObserver()
     }
@@ -72,8 +74,6 @@ module.exports = {
       }
     }
 
-    client = new MetricsAggregationClient(new DogStatsDClient(clientConfig))
-
     lastTime = performance.now()
 
     if (nativeMetrics) {