dd-trace 3.12.1 → 3.15.0

package/packages/dd-trace/src/appsec/remote_config/capabilities.js

@@ -3,5 +3,6 @@
 module.exports = {
   ASM_ACTIVATION: 1n << 1n,
   ASM_IP_BLOCKING: 1n << 2n,
-  ASM_DD_RULES: 1n << 3n
+  ASM_DD_RULES: 1n << 3n,
+  ASM_USER_BLOCKING: 1n << 7n
 }

package/packages/dd-trace/src/appsec/remote_config/index.js

@@ -35,12 +35,15 @@ function enable (config) {
 function enableAsmData (appsecConfig) {
   if (rc && appsecConfig && appsecConfig.rules === undefined) {
     rc.updateCapabilities(RemoteConfigCapabilities.ASM_IP_BLOCKING, true)
+    rc.updateCapabilities(RemoteConfigCapabilities.ASM_USER_BLOCKING, true)
     rc.on('ASM_DATA', _asmDataListener)
   }
 }
 
 function disableAsmData () {
   if (rc) {
+    rc.updateCapabilities(RemoteConfigCapabilities.ASM_IP_BLOCKING, false)
+    rc.updateCapabilities(RemoteConfigCapabilities.ASM_USER_BLOCKING, false)
     rc.off('ASM_DATA', _asmDataListener)
   }
 }

package/packages/dd-trace/src/appsec/reporter.js

@@ -86,28 +86,28 @@ function formatHeaderName (name) {
 
 function reportMetrics (metrics, store) {
   const req = store && store.get('req')
-  const topSpan = web.root(req)
-  if (!topSpan) return false
+  const rootSpan = web.root(req)
+  if (!rootSpan) return false
 
   if (metrics.duration) {
-    topSpan.setTag('_dd.appsec.waf.duration', metrics.duration)
+    rootSpan.setTag('_dd.appsec.waf.duration', metrics.duration)
   }
 
   if (metrics.durationExt) {
-    topSpan.setTag('_dd.appsec.waf.duration_ext', metrics.durationExt)
+    rootSpan.setTag('_dd.appsec.waf.duration_ext', metrics.durationExt)
   }
 
   if (metrics.rulesVersion) {
-    topSpan.setTag('_dd.appsec.event_rules.version', metrics.rulesVersion)
+    rootSpan.setTag('_dd.appsec.event_rules.version', metrics.rulesVersion)
   }
 }
 
 function reportAttack (attackData, store) {
   const req = store && store.get('req')
-  const topSpan = web.root(req)
-  if (!topSpan) return false
+  const rootSpan = web.root(req)
+  if (!rootSpan) return false
 
-  const currentTags = topSpan.context()._tags
+  const currentTags = rootSpan.context()._tags
 
   const newTags = {
     'appsec.event': 'true'
@@ -146,20 +146,20 @@ function reportAttack (attackData, store) {
     newTags['network.client.ip'] = resolvedRequest.remote_ip
   }
 
-  topSpan.addTags(newTags)
+  rootSpan.addTags(newTags)
 }
 
 function finishRequest (req, context) {
-  const topSpan = web.root(req)
-  if (!topSpan) return false
+  const rootSpan = web.root(req)
+  if (!rootSpan) return false
 
   if (metricsQueue.size) {
-    topSpan.addTags(Object.fromEntries(metricsQueue))
+    rootSpan.addTags(Object.fromEntries(metricsQueue))
 
     metricsQueue.clear()
   }
 
-  if (!context || !topSpan.context()._tags['appsec.event']) return false
+  if (!context || !rootSpan.context()._tags['appsec.event']) return false
 
   const resolvedResponse = resolveHTTPResponse(context)
 
@@ -169,7 +169,7 @@ function finishRequest (req, context) {
     newTags['http.endpoint'] = resolvedResponse.endpoint
   }
 
-  topSpan.addTags(newTags)
+  rootSpan.addTags(newTags)
 }
 
 function setRateLimit (rateLimit) {

package/packages/dd-trace/src/appsec/sdk/index.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const { trackUserLoginSuccessEvent, trackUserLoginFailureEvent, trackCustomEvent } = require('./track_event')
+const { checkUserAndSetUser, blockRequest } = require('./user_blocking')
+const { loadTemplates } = require('../blocking')
+const { setUser } = require('./set_user')
+
+class AppsecSdk {
+  constructor (tracer, config) {
+    this._tracer = tracer
+    if (config) {
+      loadTemplates(config)
+    }
+  }
+
+  trackUserLoginSuccessEvent (user, metadata) {
+    return trackUserLoginSuccessEvent(this._tracer, user, metadata)
+  }
+
+  trackUserLoginFailureEvent (userId, exists, metadata) {
+    return trackUserLoginFailureEvent(this._tracer, userId, exists, metadata)
+  }
+
+  trackCustomEvent (eventName, metadata) {
+    return trackCustomEvent(this._tracer, eventName, metadata)
+  }
+
+  isUserBlocked (user) {
+    return checkUserAndSetUser(this._tracer, user)
+  }
+
+  blockRequest (req, res) {
+    return blockRequest(this._tracer, req, res)
+  }
+
+  setUser (user) {
+    return setUser(this._tracer, user)
+  }
+}
+
+module.exports = AppsecSdk

package/packages/dd-trace/src/appsec/sdk/noop.js

@@ -0,0 +1,17 @@
+'use strict'
+
+class NoopAppsecSdk {
+  trackUserLoginSuccessEvent () {}
+
+  trackUserLoginFailureEvent () {}
+
+  trackCustomEvent () {}
+
+  isUserBlocked () {}
+
+  blockRequest () {}
+
+  setUser () {}
+}
+
+module.exports = NoopAppsecSdk

package/packages/dd-trace/src/appsec/sdk/set_user.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const { getRootSpan } = require('./utils')
+const log = require('../../log')
+
+function setUserTags (user, rootSpan) {
+  for (const k of Object.keys(user)) {
+    rootSpan.setTag(`usr.${k}`, '' + user[k])
+  }
+}
+
+function setUser (tracer, user) {
+  if (!user || !user.id) {
+    log.warn('Invalid user provided to setUser')
+    return
+  }
+
+  const rootSpan = getRootSpan(tracer)
+  if (!rootSpan) {
+    log.warn('Root span not available in setUser')
+    return
+  }
+
+  setUserTags(user, rootSpan)
+}
+
+module.exports = {
+  setUserTags,
+  setUser
+}

package/packages/dd-trace/src/appsec/sdk/track_event.js

@@ -0,0 +1,74 @@
+'use strict'
+
+const log = require('../../log')
+const { getRootSpan } = require('./utils')
+const { MANUAL_KEEP } = require('../../../../../ext/tags')
+const { setUserTags } = require('./set_user')
+
+function trackUserLoginSuccessEvent (tracer, user, metadata) {
+  // TODO: better user check here and in _setUser() ?
+  if (!user || !user.id) {
+    log.warn('Invalid user provided to trackUserLoginSuccessEvent')
+    return
+  }
+
+  const rootSpan = getRootSpan(tracer)
+  if (!rootSpan) {
+    log.warn('Root span not available in trackUserLoginSuccessEvent')
+    return
+  }
+
+  setUserTags(user, rootSpan)
+
+  trackEvent(tracer, 'users.login.success', metadata, 'trackUserLoginSuccessEvent', rootSpan)
+}
+
+function trackUserLoginFailureEvent (tracer, userId, exists, metadata) {
+  if (!userId || typeof userId !== 'string') {
+    log.warn('Invalid userId provided to trackUserLoginFailureEvent')
+    return
+  }
+
+  const fields = {
+    'usr.id': userId,
+    'usr.exists': exists ? 'true' : 'false',
+    ...metadata
+  }
+
+  trackEvent(tracer, 'users.login.failure', fields, 'trackUserLoginFailureEvent')
+}
+
+function trackCustomEvent (tracer, eventName, metadata) {
+  if (!eventName || typeof eventName !== 'string') {
+    log.warn('Invalid eventName provided to trackCustomEvent')
+    return
+  }
+
+  trackEvent(tracer, eventName, metadata, 'trackCustomEvent')
+}
+
+function trackEvent (tracer, eventName, fields, sdkMethodName, rootSpan = getRootSpan(tracer)) {
+  if (!rootSpan) {
+    log.warn(`Root span not available in ${sdkMethodName}`)
+    return
+  }
+
+  const tags = {
+    [`appsec.events.${eventName}.track`]: 'true',
+    [MANUAL_KEEP]: 'true'
+  }
+
+  if (fields) {
+    for (const metadataKey of Object.keys(fields)) {
+      tags[`appsec.events.${eventName}.${metadataKey}`] = '' + fields[metadataKey]
+    }
+  }
+
+  rootSpan.addTags(tags)
+}
+
+module.exports = {
+  trackUserLoginSuccessEvent,
+  trackUserLoginFailureEvent,
+  trackCustomEvent
+}

package/packages/dd-trace/src/appsec/sdk/user_blocking.js

@@ -0,0 +1,73 @@
+'use strict'
+
+const { USER_ID } = require('../addresses')
+const Gateway = require('../gateway/engine')
+const { getRootSpan } = require('./utils')
+const { block } = require('../blocking')
+const { storage } = require('../../../../datadog-core')
+const { setUserTags } = require('./set_user')
+const log = require('../../log')
+
+function isUserBlocked (user) {
+  const results = Gateway.propagate({ [USER_ID]: user.id })
+
+  if (!results) {
+    return false
+  }
+
+  for (const entry of results) {
+    if (entry && entry.includes('block')) {
+      return true
+    }
+  }
+
+  return false
+}
+
+function checkUserAndSetUser (tracer, user) {
+  if (!user || !user.id) {
+    log.warn('Invalid user provided to isUserBlocked')
+    return false
+  }
+
+  const rootSpan = getRootSpan(tracer)
+  if (rootSpan) {
+    if (!rootSpan.context()._tags['usr.id']) {
+      setUserTags(user, rootSpan)
+    }
+  } else {
+    log.warn('Root span not available in isUserBlocked')
+  }
+
+  return isUserBlocked(user)
+}
+
+function blockRequest (tracer, req, res) {
+  if (!req || !res) {
+    const store = storage.getStore()
+    if (store) {
+      req = req || store.req
+      res = res || store.res
+    }
+  }
+
+  if (!req || !res) {
+    log.warn('Requests or response object not available in blockRequest')
+    return false
+  }
+
+  const rootSpan = getRootSpan(tracer)
+  if (!rootSpan) {
+    log.warn('Root span not available in blockRequest')
+    return false
+  }
+
+  block(req, res, rootSpan)
+
+  return true
+}
+
+module.exports = {
+  checkUserAndSetUser,
+  blockRequest
+}

package/packages/dd-trace/src/appsec/sdk/utils.js

@@ -0,0 +1,10 @@
+'use strict'
+
+function getRootSpan (tracer) {
+  const span = tracer.scope().active()
+  return span && span.context()._trace.started[0]
+}
+
+module.exports = {
+  getRootSpan
+}

package/packages/dd-trace/src/ci-visibility/exporters/agent-proxy/index.js

@@ -20,8 +20,7 @@ class AgentProxyCiVisibilityExporter extends CiVisibilityExporter {
       prioritySampler,
       lookup,
       protocolVersion,
-      headers,
-      isGitUploadEnabled
+      headers
     } = config
 
     this.getAgentInfo((err, agentInfo) => {
@@ -38,9 +37,6 @@ class AgentProxyCiVisibilityExporter extends CiVisibilityExporter {
           url: this._url,
           evpProxyPrefix: AGENT_EVP_PROXY_PATH
         })
-        if (isGitUploadEnabled) {
-          this.sendGitMetadata({ url: this._url, isEvpProxy: true })
-        }
       } else {
         this._writer = new AgentWriter({
           url: this._url,

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

@@ -9,7 +9,7 @@ const log = require('../../../log')
 class AgentlessCiVisibilityExporter extends CiVisibilityExporter {
   constructor (config) {
     super(config)
-    const { tags, site, url, isGitUploadEnabled } = config
+    const { tags, site, url } = config
     // we don't need to request /info because we are using agentless by configuration
     this._isInitialized = true
     this._resolveCanUseCiVisProtocol(true)
@@ -21,10 +21,6 @@ class AgentlessCiVisibilityExporter extends CiVisibilityExporter {
     this._coverageWriter = new CoverageWriter({ url: this._coverageUrl })
 
     this._apiUrl = url || new URL(`https://api.${site}`)
-
-    if (isGitUploadEnabled) {
-      this.sendGitMetadata({ url: this._getApiUrl() })
-    }
   }
 
   setUrl (url, coverageUrl = url, apiUrl = url) {

package/packages/dd-trace/src/ci-visibility/exporters/ci-visibility-exporter.js

@@ -8,12 +8,28 @@ const { getSkippableSuites: getSkippableSuitesRequest } = require('../intelligen
 const log = require('../../log')
 const AgentInfoExporter = require('../../exporters/common/agent-info-exporter')
 
+function getTestConfigurationTags (tags) {
+  if (!tags) {
+    return {}
+  }
+  return Object.keys(tags).reduce((acc, key) => {
+    if (key.startsWith('test.configuration.')) {
+      const [, configKey] = key.split('test.configuration.')
+      acc[configKey] = tags[key]
+    }
+    return acc
+  }, {})
+}
+
 function getIsTestSessionTrace (trace) {
   return trace.some(span =>
-    span.type === 'test_session_end' || span.type === 'test_suite_end'
+    span.type === 'test_session_end' || span.type === 'test_suite_end' || span.type === 'test_module_end'
   )
 }
 
+const GIT_UPLOAD_TIMEOUT = 60000 // 60 seconds
+const CAN_USE_CI_VIS_PROTOCOL_TIMEOUT = GIT_UPLOAD_TIMEOUT
+
 class CiVisibilityExporter extends AgentInfoExporter {
   constructor (config) {
     super(config)
@@ -24,14 +40,24 @@ class CiVisibilityExporter extends AgentInfoExporter {
     // AKA CI Vis Protocol
     this._canUseCiVisProtocol = false
 
-    // TODO: add timeout to reject this promise
+    const gitUploadTimeoutId = setTimeout(() => {
+      this._resolveGit(new Error('Timeout while uploading git metadata'))
+    }, GIT_UPLOAD_TIMEOUT).unref()
+
+    const canUseCiVisProtocolTimeoutId = setTimeout(() => {
+      this._resolveCanUseCiVisProtocol(false)
+    }, CAN_USE_CI_VIS_PROTOCOL_TIMEOUT).unref()
+
     this._gitUploadPromise = new Promise(resolve => {
-      this._resolveGit = resolve
+      this._resolveGit = (err) => {
+        clearTimeout(gitUploadTimeoutId)
+        resolve(err)
+      }
     })
 
-    // TODO: add timeout to reject this promise
     this._canUseCiVisProtocolPromise = new Promise(resolve => {
       this._resolveCanUseCiVisProtocol = (canUseCiVisProtocol) => {
+        clearTimeout(canUseCiVisProtocolTimeoutId)
         this._canUseCiVisProtocol = canUseCiVisProtocol
         resolve(canUseCiVisProtocol)
       }
@@ -82,6 +108,7 @@ class CiVisibilityExporter extends AgentInfoExporter {
         env: this._config.env,
         service: this._config.service,
         isEvpProxy: !!this._isUsingEvpProxy,
+        custom: getTestConfigurationTags(this._config.tags),
         ...testConfiguration
       }
       getSkippableSuitesRequest(configuration, callback)
@@ -93,6 +120,7 @@ class CiVisibilityExporter extends AgentInfoExporter {
    * CI Visibility Protocol, hence the this._canUseCiVisProtocol promise.
    */
   getItrConfiguration (testConfiguration, callback) {
+    this.sendGitMetadata()
     if (!this.shouldRequestItrConfiguration()) {
       return callback(null, {})
     }
@@ -105,6 +133,7 @@ class CiVisibilityExporter extends AgentInfoExporter {
         env: this._config.env,
         service: this._config.service,
         isEvpProxy: !!this._isUsingEvpProxy,
+        custom: getTestConfigurationTags(this._config.tags),
         ...testConfiguration
       }
       getItrConfigurationRequest(configuration, (err, itrConfig) => {
@@ -118,14 +147,22 @@ class CiVisibilityExporter extends AgentInfoExporter {
     })
   }
 
-  sendGitMetadata ({ url, isEvpProxy }) {
-    sendGitMetadataRequest(url, isEvpProxy, (err) => {
-      if (err) {
-        log.error(`Error uploading git metadata: ${err.message}`)
-      } else {
-        log.debug('Successfully uploaded git metadata')
+  sendGitMetadata () {
+    if (!this._config.isGitUploadEnabled) {
+      return
+    }
+    this._canUseCiVisProtocolPromise.then((canUseCiVisProtocol) => {
+      if (!canUseCiVisProtocol) {
+        return
       }
-      this._resolveGit(err)
+      sendGitMetadataRequest(this._getApiUrl(), !!this._isUsingEvpProxy, (err) => {
+        if (err) {
+          log.error(`Error uploading git metadata: ${err.message}`)
+        } else {
+          log.debug('Successfully uploaded git metadata')
+        }
+        this._resolveGit(err)
+      })
     })
   }
 

package/packages/dd-trace/src/ci-visibility/exporters/git/git_metadata.js

@@ -10,7 +10,9 @@ const {
   getLatestCommits,
   getRepositoryUrl,
   generatePackFilesForCommits,
-  getCommitsToUpload
+  getCommitsToUpload,
+  isShallowRepository,
+  unshallowRepository
 } = require('../../../plugins/util/git')
 
 const isValidSha = (sha) => /[0-9a-f]{40}/.test(sha)
@@ -157,6 +159,10 @@ function sendGitMetadata (url, isEvpProxy, callback) {
     return callback(new Error('Repository URL is empty'))
   }
 
+  if (isShallowRepository()) {
+    unshallowRepository()
+  }
+
   getCommitsToExclude({ url, repositoryUrl, isEvpProxy }, (err, commitsToExclude, headCommit) => {
     if (err) {
       return callback(err)

package/packages/dd-trace/src/ci-visibility/intelligent-test-runner/get-itr-configuration.js

@@ -13,7 +13,8 @@ function getItrConfiguration ({
   osArchitecture,
   runtimeName,
   runtimeVersion,
-  branch
+  branch,
+  custom
 }, done) {
   const options = {
     path: '/api/v2/libraries/tests/services/setting',
@@ -53,7 +54,8 @@ function getItrConfiguration ({
           'os.version': osVersion,
           'os.architecture': osArchitecture,
           'runtime.name': runtimeName,
-          'runtime.version': runtimeVersion
+          'runtime.version': runtimeVersion,
+          custom
         },
         service,
         env,

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

@@ -11,7 +11,8 @@ function getSkippableSuites ({
   osPlatform,
   osArchitecture,
   runtimeName,
-  runtimeVersion
+  runtimeVersion,
+  custom
 }, done) {
   const options = {
     path: '/api/v2/ci/tests/skippable',
@@ -19,7 +20,7 @@ function getSkippableSuites ({
     headers: {
       'Content-Type': 'application/json'
     },
-    timeout: 15000,
+    timeout: 20000,
     url
   }
 
@@ -51,7 +52,8 @@ function getSkippableSuites ({
           'os.version': osVersion,
           'os.architecture': osArchitecture,
           'runtime.name': runtimeName,
-          'runtime.version': runtimeVersion
+          'runtime.version': runtimeVersion,
+          custom
         },
         service,
         env,

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

@@ -54,6 +54,32 @@ function remapify (input, mappings) {
   return output
 }
 
+function propagationStyle (key, option, defaultValue) {
+  // Extract by key if in object-form value
+  if (typeof option === 'object' && !Array.isArray(option)) {
+    option = option[key]
+  }
+
+  // Should be an array at this point
+  if (Array.isArray(option)) return option.map(v => v.toLowerCase())
+
+  // If it's not an array but not undefined there's something wrong with the input
+  if (typeof option !== 'undefined') {
+    log.warn('Unexpected input for config.tracePropagationStyle')
+  }
+
+  // Otherwise, fallback to env var parsing
+  const envKey = `DD_TRACE_PROPAGATION_STYLE_${key.toUpperCase()}`
+  const envVar = coalesce(process.env[envKey], process.env.DD_TRACE_PROPAGATION_STYLE)
+  if (typeof envVar !== 'undefined') {
+    return envVar.split(',')
+      .filter(v => v !== '')
+      .map(v => v.trim().toLowerCase())
+  }
+
+  return defaultValue
+}
+
 class Config {
   constructor (options) {
     options = options || {}
@@ -185,19 +211,46 @@ class Config {
       process.env.DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP,
       qsRegex
     )
+    const DD_TRACE_CLIENT_IP_ENABLED = coalesce(
+      options.clientIpEnabled,
+      process.env.DD_TRACE_CLIENT_IP_ENABLED && isTrue(process.env.DD_TRACE_CLIENT_IP_ENABLED),
+      false
+    )
     const DD_TRACE_CLIENT_IP_HEADER = coalesce(
+      options.clientIpHeader,
       process.env.DD_TRACE_CLIENT_IP_HEADER,
       null
     )
+    // TODO: Remove the experimental env vars as a major?
     const DD_TRACE_B3_ENABLED = coalesce(
       options.experimental && options.experimental.b3,
       process.env.DD_TRACE_EXPERIMENTAL_B3_ENABLED,
       false
     )
-    const DD_TRACE_TRACEPARENT_ENABLED = coalesce(
-      options.experimental && options.experimental.traceparent,
-      process.env.DD_TRACE_EXPERIMENTAL_TRACEPARENT_ENABLED,
-      false
+    const defaultPropagationStyle = ['tracecontext', 'datadog']
+    if (isTrue(DD_TRACE_B3_ENABLED)) {
+      defaultPropagationStyle.push('b3')
+      defaultPropagationStyle.push('b3 single header')
+    }
+    if (process.env.DD_TRACE_PROPAGATION_STYLE && (
+      process.env.DD_TRACE_PROPAGATION_STYLE_INJECT ||
+      process.env.DD_TRACE_PROPAGATION_STYLE_EXTRACT
+    )) {
+      log.warn(
+        'Use either the DD_TRACE_PROPAGATION_STYLE environment variable or separate ' +
+        'DD_TRACE_PROPAGATION_STYLE_INJECT and DD_TRACE_PROPAGATION_STYLE_EXTRACT ' +
+        'environment variables'
+      )
+    }
+    const DD_TRACE_PROPAGATION_STYLE_INJECT = propagationStyle(
+      'inject',
+      options.tracePropagationStyle,
+      defaultPropagationStyle
+    )
+    const DD_TRACE_PROPAGATION_STYLE_EXTRACT = propagationStyle(
+      'extract',
+      options.tracePropagationStyle,
+      defaultPropagationStyle
     )
     const DD_TRACE_RUNTIME_ID_ENABLED = coalesce(
       options.experimental && options.experimental.runtimeId,
@@ -323,7 +376,7 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
 
     const DD_CIVISIBILITY_GIT_UPLOAD_ENABLED = coalesce(
       process.env.DD_CIVISIBILITY_GIT_UPLOAD_ENABLED,
-      false
+      true
     )
 
     const ingestion = options.ingestion || {}
@@ -372,6 +425,7 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
     this.flushMinSpans = DD_TRACE_PARTIAL_FLUSH_MIN_SPANS
     this.sampleRate = coalesce(Math.min(Math.max(sampler.sampleRate, 0), 1), 1)
     this.queryStringObfuscation = DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP
+    this.clientIpEnabled = DD_TRACE_CLIENT_IP_ENABLED
     this.clientIpHeader = DD_TRACE_CLIENT_IP_HEADER
     this.plugins = !!coalesce(options.plugins, true)
     this.service = DD_SERVICE
@@ -382,9 +436,11 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
       port: String(coalesce(dogstatsd.port, process.env.DD_DOGSTATSD_PORT, 8125))
     }
     this.runtimeMetrics = isTrue(DD_RUNTIME_METRICS_ENABLED)
+    this.tracePropagationStyle = {
+      inject: DD_TRACE_PROPAGATION_STYLE_INJECT,
+      extract: DD_TRACE_PROPAGATION_STYLE_EXTRACT
+    }
     this.experimental = {
-      b3: isTrue(DD_TRACE_B3_ENABLED),
-      traceparent: isTrue(DD_TRACE_TRACEPARENT_ENABLED),
       runtimeId: isTrue(DD_TRACE_RUNTIME_ID_ENABLED),
       exporter: DD_TRACE_EXPORTER,
       enableGetRumData: isTrue(DD_TRACE_GET_RUM_DATA_ENABLED)