dd-trace 5.19.0 → 5.21.0

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

@@ -29,14 +29,14 @@ const telemetryCounters = {
 function getCounter (event, ddVar, otelVar) {
   const counters = telemetryCounters[event]
   const tags = []
-  const ddVarPrefix = 'config.datadog:'
-  const otelVarPrefix = 'config.opentelemetry:'
+  const ddVarPrefix = 'config_datadog:'
+  const otelVarPrefix = 'config_opentelemetry:'
   if (ddVar) {
-    ddVar = ddVarPrefix + ddVar
+    ddVar = ddVarPrefix + ddVar.toLowerCase()
     tags.push(ddVar)
   }
   if (otelVar) {
-    otelVar = otelVarPrefix + otelVar
+    otelVar = otelVarPrefix + otelVar.toLowerCase()
     tags.push(otelVar)
   }
 
@@ -183,7 +183,7 @@ function remapify (input, mappings) {
   return output
 }
 
-function propagationStyle (key, option, defaultValue) {
+function propagationStyle (key, option) {
   // Extract by key if in object-form value
   if (option !== null && typeof option === 'object' && !Array.isArray(option)) {
     option = option[key]
@@ -206,69 +206,42 @@ function propagationStyle (key, option, defaultValue) {
       .filter(v => v !== '')
       .map(v => v.trim().toLowerCase())
   }
+}
 
-  return defaultValue
+function reformatSpanSamplingRules (rules) {
+  if (!rules) return rules
+  return rules.map(rule => {
+    return remapify(rule, {
+      sample_rate: 'sampleRate',
+      max_per_second: 'maxPerSecond'
+    })
+  })
 }
 
 class Config {
-  constructor (options) {
-    options = options || {}
-    options = this.options = {
+  constructor (options = {}) {
+    options = {
       ...options,
       appsec: options.appsec != null ? options.appsec : options.experimental?.appsec,
       iast: options.iast != null ? options.iast : options.experimental?.iast
     }
 
-    checkIfBothOtelAndDdEnvVarSet()
-
     // Configure the logger first so it can be used to warn about other configs
-    this.debug = isTrue(coalesce(
-      process.env.DD_TRACE_DEBUG,
-      process.env.OTEL_LOG_LEVEL && process.env.OTEL_LOG_LEVEL === 'debug',
-      false
-    ))
-    this.logger = options.logger
-
-    this.logLevel = coalesce(
-      options.logLevel,
-      process.env.DD_TRACE_LOG_LEVEL,
-      process.env.OTEL_LOG_LEVEL,
-      'debug'
-    )
+    const logConfig = log.getConfig()
+    this.debug = logConfig.enabled
+    this.logger = coalesce(options.logger, logConfig.logger)
+    this.logLevel = coalesce(options.logLevel, logConfig.logLevel)
 
     log.use(this.logger)
-    log.toggle(this.debug, this.logLevel, this)
-
-    const DD_TRACE_MEMCACHED_COMMAND_ENABLED = coalesce(
-      process.env.DD_TRACE_MEMCACHED_COMMAND_ENABLED,
-      false
-    )
+    log.toggle(this.debug, this.logLevel)
 
-    const DD_SERVICE_MAPPING = coalesce(
-      options.serviceMapping,
-      process.env.DD_SERVICE_MAPPING
-        ? fromEntries(
-          process.env.DD_SERVICE_MAPPING.split(',').map(x => x.trim().split(':'))
-        )
-        : {}
-    )
+    checkIfBothOtelAndDdEnvVarSet()
 
     const DD_API_KEY = coalesce(
       process.env.DATADOG_API_KEY,
       process.env.DD_API_KEY
     )
 
-    // 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 defaultPropagationStyle = ['datadog', 'tracecontext']
-    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
@@ -282,21 +255,11 @@ class Config {
     const PROPAGATION_STYLE_INJECT = propagationStyle(
       'inject',
       options.tracePropagationStyle,
-      defaultPropagationStyle
-    )
-    const PROPAGATION_STYLE_EXTRACT = propagationStyle(
-      'extract',
-      options.tracePropagationStyle,
-      defaultPropagationStyle
+      this._getDefaultPropagationStyle(options)
     )
 
     validateOtelPropagators(PROPAGATION_STYLE_INJECT)
 
-    const DD_TRACE_PROPAGATION_EXTRACT_FIRST = coalesce(
-      process.env.DD_TRACE_PROPAGATION_EXTRACT_FIRST,
-      false
-    )
-
     if (typeof options.appsec === 'boolean') {
       options.appsec = {
         enabled: options.appsec
@@ -305,33 +268,6 @@ class Config {
       options.appsec = {}
     }
 
-    const DD_APPSEC_GRAPHQL_BLOCKED_TEMPLATE_JSON = coalesce(
-      maybeFile(options.appsec.blockedTemplateGraphql),
-      maybeFile(process.env.DD_APPSEC_GRAPHQL_BLOCKED_TEMPLATE_JSON)
-    )
-    const DD_APPSEC_AUTOMATED_USER_EVENTS_TRACKING = coalesce(
-      options.appsec.eventTracking && options.appsec.eventTracking.mode,
-      process.env.DD_APPSEC_AUTOMATED_USER_EVENTS_TRACKING,
-      'safe'
-    ).toLowerCase()
-    const DD_API_SECURITY_ENABLED = coalesce(
-      options.appsec?.apiSecurity?.enabled,
-      process.env.DD_API_SECURITY_ENABLED && isTrue(process.env.DD_API_SECURITY_ENABLED),
-      process.env.DD_EXPERIMENTAL_API_SECURITY_ENABLED && isTrue(process.env.DD_EXPERIMENTAL_API_SECURITY_ENABLED),
-      true
-    )
-    const DD_API_SECURITY_REQUEST_SAMPLE_RATE = coalesce(
-      options.appsec?.apiSecurity?.requestSampling,
-      parseFloat(process.env.DD_API_SECURITY_REQUEST_SAMPLE_RATE),
-      0.1
-    )
-
-    // 0: disabled, 1: logging, 2: garbage collection + logging
-    const DD_TRACE_SPAN_LEAK_DEBUG = coalesce(
-      process.env.DD_TRACE_SPAN_LEAK_DEBUG,
-      0
-    )
-
     const DD_INSTRUMENTATION_INSTALL_ID = coalesce(
       process.env.DD_INSTRUMENTATION_INSTALL_ID,
       null
@@ -345,51 +281,10 @@ class Config {
       null
     )
 
-    const sampler = {
-      spanSamplingRules: coalesce(
-        options.spanSamplingRules,
-        safeJsonParse(maybeFile(process.env.DD_SPAN_SAMPLING_RULES_FILE)),
-        safeJsonParse(process.env.DD_SPAN_SAMPLING_RULES),
-        []
-      ).map(rule => {
-        return remapify(rule, {
-          sample_rate: 'sampleRate',
-          max_per_second: 'maxPerSecond'
-        })
-      })
-    }
-
     // TODO: refactor
     this.apiKey = DD_API_KEY
-    this.serviceMapping = DD_SERVICE_MAPPING
-    this.tracePropagationStyle = {
-      inject: PROPAGATION_STYLE_INJECT,
-      extract: PROPAGATION_STYLE_EXTRACT,
-      otelPropagators: process.env.DD_TRACE_PROPAGATION_STYLE ||
-        process.env.DD_TRACE_PROPAGATION_STYLE_INJECT ||
-        process.env.DD_TRACE_PROPAGATION_STYLE_EXTRACT
-        ? false
-        : !!process.env.OTEL_PROPAGATORS
-    }
-    this.tracePropagationExtractFirst = isTrue(DD_TRACE_PROPAGATION_EXTRACT_FIRST)
-    this.sampler = sampler
-    this.appsec = {
-      blockedTemplateGraphql: DD_APPSEC_GRAPHQL_BLOCKED_TEMPLATE_JSON,
-      eventTracking: {
-        enabled: ['extended', 'safe'].includes(DD_APPSEC_AUTOMATED_USER_EVENTS_TRACKING),
-        mode: DD_APPSEC_AUTOMATED_USER_EVENTS_TRACKING
-      },
-      apiSecurity: {
-        enabled: DD_API_SECURITY_ENABLED,
-        // Coerce value between 0 and 1
-        requestSampling: Math.min(1, Math.max(0, DD_API_SECURITY_REQUEST_SAMPLE_RATE))
-      }
-    }
 
-    // Requires an accompanying DD_APM_OBFUSCATION_MEMCACHED_KEEP_COMMAND=true in the agent
-    this.memcachedCommandEnabled = isTrue(DD_TRACE_MEMCACHED_COMMAND_ENABLED)
-    this.isAzureFunction = getIsAzureFunction()
-    this.spanLeakDebug = Number(DD_TRACE_SPAN_LEAK_DEBUG)
+    // sent in telemetry event app-started
     this.installSignature = {
       id: DD_INSTRUMENTATION_INSTALL_ID,
       time: DD_INSTRUMENTATION_INSTALL_TIME,
@@ -463,6 +358,21 @@ class Config {
     this._merge()
   }
 
+  _getDefaultPropagationStyle (options) {
+    // 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 defaultPropagationStyle = ['datadog', 'tracecontext']
+    if (isTrue(DD_TRACE_B3_ENABLED)) {
+      defaultPropagationStyle.push('b3')
+      defaultPropagationStyle.push('b3 single header')
+    }
+    return defaultPropagationStyle
+  }
+
   _isInServerlessEnvironment () {
     const inAWSLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined
     const isGCPFunction = getIsGCPFunction()
@@ -486,14 +396,19 @@ class Config {
       pkg.name ||
       'node'
 
-    const defaults = this._defaults = {}
+    const defaults = setHiddenProperty(this, '_defaults', {})
 
+    this._setValue(defaults, 'appsec.apiSecurity.enabled', true)
+    this._setValue(defaults, 'appsec.apiSecurity.requestSampling', 0.1)
+    this._setValue(defaults, 'appsec.blockedTemplateGraphql', undefined)
     this._setValue(defaults, 'appsec.blockedTemplateHtml', undefined)
     this._setValue(defaults, 'appsec.blockedTemplateJson', undefined)
     this._setValue(defaults, 'appsec.enabled', undefined)
+    this._setValue(defaults, 'appsec.eventTracking.enabled', true)
+    this._setValue(defaults, 'appsec.eventTracking.mode', 'safe')
     this._setValue(defaults, 'appsec.obfuscatorKeyRegex', defaultWafObfuscatorKeyRegex)
     this._setValue(defaults, 'appsec.obfuscatorValueRegex', defaultWafObfuscatorValueRegex)
-    this._setValue(defaults, 'appsec.rasp.enabled', false)
+    this._setValue(defaults, 'appsec.rasp.enabled', true)
     this._setValue(defaults, 'appsec.rateLimit', 100)
     this._setValue(defaults, 'appsec.rules', undefined)
     this._setValue(defaults, 'appsec.sca.enabled', null)
@@ -526,6 +441,7 @@ class Config {
     this._setValue(defaults, 'iast.redactionValuePattern', null)
     this._setValue(defaults, 'iast.requestSampling', 30)
     this._setValue(defaults, 'iast.telemetryVerbosity', 'INFORMATION')
+    this._setValue(defaults, 'isAzureFunction', false)
     this._setValue(defaults, 'isCiVisibility', false)
     this._setValue(defaults, 'isEarlyFlakeDetectionEnabled', false)
     this._setValue(defaults, 'isGCPFunction', false)
@@ -534,6 +450,7 @@ class Config {
     this._setValue(defaults, 'isManualApiEnabled', false)
     this._setValue(defaults, 'logInjection', false)
     this._setValue(defaults, 'lookup', undefined)
+    this._setValue(defaults, 'memcachedCommandEnabled', false)
     this._setValue(defaults, 'openAiLogsEnabled', false)
     this._setValue(defaults, 'openaiSpanCharLimit', 128)
     this._setValue(defaults, 'peerServiceMapping', {})
@@ -554,11 +471,14 @@ class Config {
     this._setValue(defaults, 'sampleRate', undefined)
     this._setValue(defaults, 'sampler.rateLimit', undefined)
     this._setValue(defaults, 'sampler.rules', [])
+    this._setValue(defaults, 'sampler.spanSamplingRules', [])
     this._setValue(defaults, 'scope', undefined)
     this._setValue(defaults, 'service', service)
+    this._setValue(defaults, 'serviceMapping', {})
     this._setValue(defaults, 'site', 'datadoghq.com')
     this._setValue(defaults, 'spanAttributeSchema', 'v0')
     this._setValue(defaults, 'spanComputePeerService', false)
+    this._setValue(defaults, 'spanLeakDebug', 0)
     this._setValue(defaults, 'spanRemoveIntegrationFromService', false)
     this._setValue(defaults, 'startupLogs', false)
     this._setValue(defaults, 'stats.enabled', false)
@@ -572,6 +492,10 @@ class Config {
     this._setValue(defaults, 'telemetry.metrics', true)
     this._setValue(defaults, 'traceId128BitGenerationEnabled', true)
     this._setValue(defaults, 'traceId128BitLoggingEnabled', false)
+    this._setValue(defaults, 'tracePropagationExtractFirst', false)
+    this._setValue(defaults, 'tracePropagationStyle.inject', ['datadog', 'tracecontext'])
+    this._setValue(defaults, 'tracePropagationStyle.extract', ['datadog', 'tracecontext'])
+    this._setValue(defaults, 'tracePropagationStyle.otelPropagators', false)
     this._setValue(defaults, 'tracing', true)
     this._setValue(defaults, 'url', undefined)
     this._setValue(defaults, 'version', pkg.version)
@@ -582,7 +506,11 @@ class Config {
     const {
       AWS_LAMBDA_FUNCTION_NAME,
       DD_AGENT_HOST,
+      DD_API_SECURITY_ENABLED,
+      DD_API_SECURITY_REQUEST_SAMPLE_RATE,
+      DD_APPSEC_AUTOMATED_USER_EVENTS_TRACKING,
       DD_APPSEC_ENABLED,
+      DD_APPSEC_GRAPHQL_BLOCKED_TEMPLATE_JSON,
       DD_APPSEC_HTTP_BLOCKED_TEMPLATE_HTML,
       DD_APPSEC_HTTP_BLOCKED_TEMPLATE_JSON,
       DD_APPSEC_MAX_STACK_TRACES,
@@ -600,6 +528,7 @@ class Config {
       DD_DOGSTATSD_HOSTNAME,
       DD_DOGSTATSD_PORT,
       DD_ENV,
+      DD_EXPERIMENTAL_API_SECURITY_ENABLED,
       DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED,
       DD_EXPERIMENTAL_PROFILING_ENABLED,
       JEST_WORKER_ID,
@@ -626,8 +555,11 @@ class Config {
       DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS,
       DD_RUNTIME_METRICS_ENABLED,
       DD_SERVICE,
+      DD_SERVICE_MAPPING,
       DD_SERVICE_NAME,
       DD_SITE,
+      DD_SPAN_SAMPLING_RULES,
+      DD_SPAN_SAMPLING_RULES_FILE,
       DD_TAGS,
       DD_TELEMETRY_DEBUG,
       DD_TELEMETRY_DEPENDENCY_COLLECTION_ENABLED,
@@ -647,9 +579,14 @@ class Config {
       DD_TRACE_GIT_METADATA_ENABLED,
       DD_TRACE_GLOBAL_TAGS,
       DD_TRACE_HEADER_TAGS,
+      DD_TRACE_MEMCACHED_COMMAND_ENABLED,
       DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP,
       DD_TRACE_PARTIAL_FLUSH_MIN_SPANS,
       DD_TRACE_PEER_SERVICE_MAPPING,
+      DD_TRACE_PROPAGATION_EXTRACT_FIRST,
+      DD_TRACE_PROPAGATION_STYLE,
+      DD_TRACE_PROPAGATION_STYLE_INJECT,
+      DD_TRACE_PROPAGATION_STYLE_EXTRACT,
       DD_TRACE_RATE_LIMIT,
       DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED,
       DD_TRACE_REPORT_HOSTNAME,
@@ -657,33 +594,46 @@ class Config {
       DD_TRACE_SAMPLING_RULES,
       DD_TRACE_SCOPE,
       DD_TRACE_SPAN_ATTRIBUTE_SCHEMA,
+      DD_TRACE_SPAN_LEAK_DEBUG,
       DD_TRACE_STARTUP_LOGS,
       DD_TRACE_TAGS,
       DD_TRACE_TELEMETRY_ENABLED,
       DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH,
       DD_TRACING_ENABLED,
       DD_VERSION,
-      OTEL_SERVICE_NAME,
+      OTEL_METRICS_EXPORTER,
+      OTEL_PROPAGATORS,
       OTEL_RESOURCE_ATTRIBUTES,
+      OTEL_SERVICE_NAME,
       OTEL_TRACES_SAMPLER,
-      OTEL_TRACES_SAMPLER_ARG,
-      OTEL_METRICS_EXPORTER
+      OTEL_TRACES_SAMPLER_ARG
     } = process.env
 
     const tags = {}
-    const env = this._env = {}
-    this._envUnprocessed = {}
+    const env = setHiddenProperty(this, '_env', {})
+    setHiddenProperty(this, '_envUnprocessed', {})
 
     tagger.add(tags, OTEL_RESOURCE_ATTRIBUTES, true)
     tagger.add(tags, DD_TAGS)
     tagger.add(tags, DD_TRACE_TAGS)
     tagger.add(tags, DD_TRACE_GLOBAL_TAGS)
 
+    this._setBoolean(env, 'appsec.apiSecurity.enabled', coalesce(
+      DD_API_SECURITY_ENABLED && isTrue(DD_API_SECURITY_ENABLED),
+      DD_EXPERIMENTAL_API_SECURITY_ENABLED && isTrue(DD_EXPERIMENTAL_API_SECURITY_ENABLED)
+    ))
+    this._setUnit(env, 'appsec.apiSecurity.requestSampling', DD_API_SECURITY_REQUEST_SAMPLE_RATE)
+    this._setValue(env, 'appsec.blockedTemplateGraphql', maybeFile(DD_APPSEC_GRAPHQL_BLOCKED_TEMPLATE_JSON))
     this._setValue(env, 'appsec.blockedTemplateHtml', maybeFile(DD_APPSEC_HTTP_BLOCKED_TEMPLATE_HTML))
     this._envUnprocessed['appsec.blockedTemplateHtml'] = DD_APPSEC_HTTP_BLOCKED_TEMPLATE_HTML
     this._setValue(env, 'appsec.blockedTemplateJson', maybeFile(DD_APPSEC_HTTP_BLOCKED_TEMPLATE_JSON))
     this._envUnprocessed['appsec.blockedTemplateJson'] = DD_APPSEC_HTTP_BLOCKED_TEMPLATE_JSON
     this._setBoolean(env, 'appsec.enabled', DD_APPSEC_ENABLED)
+    if (DD_APPSEC_AUTOMATED_USER_EVENTS_TRACKING) {
+      this._setValue(env, 'appsec.eventTracking.enabled',
+        ['extended', 'safe'].includes(DD_APPSEC_AUTOMATED_USER_EVENTS_TRACKING.toLowerCase()))
+      this._setValue(env, 'appsec.eventTracking.mode', DD_APPSEC_AUTOMATED_USER_EVENTS_TRACKING.toLowerCase())
+    }
     this._setString(env, 'appsec.obfuscatorKeyRegex', DD_APPSEC_OBFUSCATION_PARAMETER_KEY_REGEXP)
     this._setString(env, 'appsec.obfuscatorValueRegex', DD_APPSEC_OBFUSCATION_PARAMETER_VALUE_REGEXP)
     this._setBoolean(env, 'appsec.rasp.enabled', DD_APPSEC_RASP_ENABLED)
@@ -731,8 +681,11 @@ class Config {
     }
     this._envUnprocessed['iast.requestSampling'] = DD_IAST_REQUEST_SAMPLING
     this._setString(env, 'iast.telemetryVerbosity', DD_IAST_TELEMETRY_VERBOSITY)
+    this._setBoolean(env, 'isAzureFunction', getIsAzureFunction())
     this._setBoolean(env, 'isGCPFunction', getIsGCPFunction())
     this._setBoolean(env, 'logInjection', DD_LOGS_INJECTION)
+    // Requires an accompanying DD_APM_OBFUSCATION_MEMCACHED_KEEP_COMMAND=true in the agent
+    this._setBoolean(env, 'memcachedCommandEnabled', DD_TRACE_MEMCACHED_COMMAND_ENABLED)
     this._setBoolean(env, 'openAiLogsEnabled', DD_OPENAI_LOGS_ENABLED)
     this._setValue(env, 'openaiSpanCharLimit', maybeInt(DD_OPENAI_SPAN_CHAR_LIMIT))
     this._envUnprocessed.openaiSpanCharLimit = DD_OPENAI_SPAN_CHAR_LIMIT
@@ -772,6 +725,10 @@ class Config {
       : undefined
     this._setBoolean(env, 'runtimeMetrics', DD_RUNTIME_METRICS_ENABLED ||
     otelSetRuntimeMetrics)
+    this._setArray(env, 'sampler.spanSamplingRules', reformatSpanSamplingRules(coalesce(
+      safeJsonParse(maybeFile(DD_SPAN_SAMPLING_RULES_FILE)),
+      safeJsonParse(DD_SPAN_SAMPLING_RULES)
+    )))
     this._setUnit(env, 'sampleRate', DD_TRACE_SAMPLE_RATE ||
     getFromOtelSamplerMap(OTEL_TRACES_SAMPLER, OTEL_TRACES_SAMPLER_ARG))
     this._setValue(env, 'sampler.rateLimit', DD_TRACE_RATE_LIMIT)
@@ -779,11 +736,18 @@ class Config {
     this._envUnprocessed['sampler.rules'] = DD_TRACE_SAMPLING_RULES
     this._setString(env, 'scope', DD_TRACE_SCOPE)
     this._setString(env, 'service', DD_SERVICE || DD_SERVICE_NAME || tags.service || OTEL_SERVICE_NAME)
+    if (DD_SERVICE_MAPPING) {
+      this._setValue(env, 'serviceMapping', fromEntries(
+        process.env.DD_SERVICE_MAPPING.split(',').map(x => x.trim().split(':'))
+      ))
+    }
     this._setString(env, 'site', DD_SITE)
     if (DD_TRACE_SPAN_ATTRIBUTE_SCHEMA) {
       this._setString(env, 'spanAttributeSchema', validateNamingVersion(DD_TRACE_SPAN_ATTRIBUTE_SCHEMA))
       this._envUnprocessed.spanAttributeSchema = DD_TRACE_SPAN_ATTRIBUTE_SCHEMA
     }
+    // 0: disabled, 1: logging, 2: garbage collection + logging
+    this._setValue(env, 'spanLeakDebug', maybeInt(DD_TRACE_SPAN_LEAK_DEBUG))
     this._setBoolean(env, 'spanRemoveIntegrationFromService', DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED)
     this._setBoolean(env, 'startupLogs', DD_TRACE_STARTUP_LOGS)
     this._setTags(env, 'tags', tags)
@@ -807,24 +771,40 @@ class Config {
     this._setBoolean(env, 'telemetry.metrics', DD_TELEMETRY_METRICS_ENABLED)
     this._setBoolean(env, 'traceId128BitGenerationEnabled', DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED)
     this._setBoolean(env, 'traceId128BitLoggingEnabled', DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED)
+    this._setBoolean(env, 'tracePropagationExtractFirst', DD_TRACE_PROPAGATION_EXTRACT_FIRST)
+    this._setBoolean(env, 'tracePropagationStyle.otelPropagators',
+      DD_TRACE_PROPAGATION_STYLE ||
+      DD_TRACE_PROPAGATION_STYLE_INJECT ||
+      DD_TRACE_PROPAGATION_STYLE_EXTRACT
+        ? false
+        : !!OTEL_PROPAGATORS)
     this._setBoolean(env, 'tracing', DD_TRACING_ENABLED)
     this._setString(env, 'version', DD_VERSION || tags.version)
   }
 
   _applyOptions (options) {
-    const opts = this._options = this._options || {}
+    const opts = setHiddenProperty(this, '_options', this._options || {})
     const tags = {}
-    this._optsUnprocessed = {}
+    setHiddenProperty(this, '_optsUnprocessed', {})
 
-    options = this.options = Object.assign({ ingestion: {} }, options, opts)
+    options = setHiddenProperty(this, '_optionsArg', Object.assign({ ingestion: {} }, options, opts))
 
     tagger.add(tags, options.tags)
 
+    this._setBoolean(opts, 'appsec.apiSecurity.enabled', options.appsec.apiSecurity?.enabled)
+    this._setUnit(opts, 'appsec.apiSecurity.requestSampling', options.appsec.apiSecurity?.requestSampling)
+    this._setValue(opts, 'appsec.blockedTemplateGraphql', maybeFile(options.appsec.blockedTemplateGraphql))
     this._setValue(opts, 'appsec.blockedTemplateHtml', maybeFile(options.appsec.blockedTemplateHtml))
     this._optsUnprocessed['appsec.blockedTemplateHtml'] = options.appsec.blockedTemplateHtml
     this._setValue(opts, 'appsec.blockedTemplateJson', maybeFile(options.appsec.blockedTemplateJson))
     this._optsUnprocessed['appsec.blockedTemplateJson'] = options.appsec.blockedTemplateJson
     this._setBoolean(opts, 'appsec.enabled', options.appsec.enabled)
+    let eventTracking = options.appsec.eventTracking?.mode
+    if (eventTracking) {
+      eventTracking = eventTracking.toLowerCase()
+      this._setValue(opts, 'appsec.eventTracking.enabled', ['extended', 'safe'].includes(eventTracking))
+      this._setValue(opts, 'appsec.eventTracking.mode', eventTracking)
+    }
     this._setString(opts, 'appsec.obfuscatorKeyRegex', options.appsec.obfuscatorKeyRegex)
     this._setString(opts, 'appsec.obfuscatorValueRegex', options.appsec.obfuscatorValueRegex)
     this._setBoolean(opts, 'appsec.rasp.enabled', options.appsec.rasp?.enabled)
@@ -890,11 +870,13 @@ class Config {
     }
     this._setBoolean(opts, 'reportHostname', options.reportHostname)
     this._setBoolean(opts, 'runtimeMetrics', options.runtimeMetrics)
+    this._setArray(opts, 'sampler.spanSamplingRules', reformatSpanSamplingRules(options.spanSamplingRules))
     this._setUnit(opts, 'sampleRate', coalesce(options.sampleRate, options.ingestion.sampleRate))
     const ingestion = options.ingestion || {}
     this._setValue(opts, 'sampler.rateLimit', coalesce(options.rateLimit, ingestion.rateLimit))
     this._setSamplingRule(opts, 'sampler.rules', options.samplingRules)
     this._setString(opts, 'service', options.service || tags.service)
+    this._setValue(opts, 'serviceMapping', options.serviceMapping)
     this._setString(opts, 'site', options.site)
     if (options.spanAttributeSchema) {
       this._setString(opts, 'spanAttributeSchema', validateNamingVersion(options.spanAttributeSchema))
@@ -914,7 +896,7 @@ class Config {
 
   _isCiVisibility () {
     return coalesce(
-      this.options.isCiVisibility,
+      this._optionsArg.isCiVisibility,
       this._defaults.isCiVisibility
     )
   }
@@ -930,9 +912,9 @@ class Config {
     const DD_CIVISIBILITY_AGENTLESS_URL = process.env.DD_CIVISIBILITY_AGENTLESS_URL
     const url = DD_CIVISIBILITY_AGENTLESS_URL
       ? new URL(DD_CIVISIBILITY_AGENTLESS_URL)
-      : getAgentUrl(this._getTraceAgentUrl(), this.options)
+      : getAgentUrl(this._getTraceAgentUrl(), this._optionsArg)
     const DD_AGENT_HOST = coalesce(
-      this.options.hostname,
+      this._optionsArg.hostname,
       process.env.DD_AGENT_HOST,
       process.env.DD_TRACE_AGENT_HOSTNAME,
       '127.0.0.1'
@@ -943,17 +925,17 @@ class Config {
   _getSpanComputePeerService () {
     const DD_TRACE_SPAN_ATTRIBUTE_SCHEMA = validateNamingVersion(
       coalesce(
-        this.options.spanAttributeSchema,
+        this._optionsArg.spanAttributeSchema,
         process.env.DD_TRACE_SPAN_ATTRIBUTE_SCHEMA
       )
     )
 
     const peerServiceSet = (
-      this.options.hasOwnProperty('spanComputePeerService') ||
+      this._optionsArg.hasOwnProperty('spanComputePeerService') ||
       process.env.hasOwnProperty('DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED')
     )
     const peerServiceValue = coalesce(
-      this.options.spanComputePeerService,
+      this._optionsArg.spanComputePeerService,
       process.env.DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED
     )
 
@@ -984,7 +966,7 @@ class Config {
 
   _isTraceStatsComputationEnabled () {
     return coalesce(
-      this.options.stats,
+      this._optionsArg.stats,
       process.env.DD_TRACE_STATS_COMPUTATION_ENABLED,
       getIsGCPFunction() || getIsAzureFunction()
     )
@@ -992,7 +974,7 @@ class Config {
 
   _getTraceAgentUrl () {
     return coalesce(
-      this.options.url,
+      this._optionsArg.url,
       process.env.DD_TRACE_AGENT_URL,
       process.env.DD_TRACE_URL,
       null
@@ -1001,20 +983,21 @@ class Config {
 
   // handles values calculated from a mixture of options and env vars
   _applyCalculated () {
-    const calc = this._calculated = {}
+    const calc = setHiddenProperty(this, '_calculated', {})
 
     const {
-      DD_CIVISIBILITY_AGENTLESS_URL
+      DD_CIVISIBILITY_AGENTLESS_URL,
+      DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED
     } = process.env
 
     if (DD_CIVISIBILITY_AGENTLESS_URL) {
       this._setValue(calc, 'url', new URL(DD_CIVISIBILITY_AGENTLESS_URL))
     } else {
-      this._setValue(calc, 'url', getAgentUrl(this._getTraceAgentUrl(), this.options))
+      this._setValue(calc, 'url', getAgentUrl(this._getTraceAgentUrl(), this._optionsArg))
     }
     if (this._isCiVisibility()) {
       this._setBoolean(calc, 'isEarlyFlakeDetectionEnabled',
-        coalesce(process.env.DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED, true))
+        coalesce(DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED, true))
       this._setBoolean(calc, 'isIntelligentTestRunnerEnabled', isTrue(this._isCiVisibilityItrEnabled()))
       this._setBoolean(calc, 'isManualApiEnabled', this._isCiVisibilityManualApiEnabled())
     }
@@ -1023,11 +1006,24 @@ class Config {
       calc.isIntelligentTestRunnerEnabled && !isFalse(this._isCiVisibilityGitUploadEnabled()))
     this._setBoolean(calc, 'spanComputePeerService', this._getSpanComputePeerService())
     this._setBoolean(calc, 'stats.enabled', this._isTraceStatsComputationEnabled())
+    const defaultPropagationStyle = this._getDefaultPropagationStyle(this._optionsArg)
+    this._setValue(calc, 'tracePropagationStyle.inject', propagationStyle(
+      'inject',
+      this._optionsArg.tracePropagationStyle
+    ))
+    this._setValue(calc, 'tracePropagationStyle.extract', propagationStyle(
+      'extract',
+      this._optionsArg.tracePropagationStyle
+    ))
+    if (defaultPropagationStyle.length > 2) {
+      calc['tracePropagationStyle.inject'] = calc['tracePropagationStyle.inject'] || defaultPropagationStyle
+      calc['tracePropagationStyle.extract'] = calc['tracePropagationStyle.extract'] || defaultPropagationStyle
+    }
   }
 
   _applyRemote (options) {
-    const opts = this._remote = this._remote || {}
-    this._remoteUnprocessed = {}
+    const opts = setHiddenProperty(this, '_remote', this._remote || {})
+    setHiddenProperty(this, '_remoteUnprocessed', {})
     const tags = {}
     const headerTags = options.tracing_header_tags
       ? options.tracing_header_tags.map(tag => {
@@ -1196,4 +1192,13 @@ function getAgentUrl (url, options) {
   }
 }
 
+function setHiddenProperty (obj, name, value) {
+  Object.defineProperty(obj, name, {
+    value,
+    enumerable: false,
+    writable: true
+  })
+  return obj[name]
+}
+
 module.exports = Config

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

@@ -0,0 +1,44 @@
+const DataStreamsContext = require('./data_streams_context')
+
+class DataStreamsCheckpointer {
+  constructor (tracer) {
+    this.tracer = tracer
+    this.config = tracer._config
+    this.dsmProcessor = tracer._dataStreamsProcessor
+  }
+
+  setProduceCheckpoint (type, target, carrier) {
+    if (!this.config.dsmEnabled) return
+
+    const ctx = this.dsmProcessor.setCheckpoint(
+      ['type:' + type, 'topic:' + target, 'direction:out', 'manual_checkpoint:true'],
+      null,
+      DataStreamsContext.getDataStreamsContext(),
+      null
+    )
+    DataStreamsContext.setDataStreamsContext(ctx)
+
+    this.tracer.inject(ctx, 'text_map_dsm', carrier)
+  }
+
+  setConsumeCheckpoint (type, source, carrier) {
+    if (!this.config.dsmEnabled) return
+
+    const parentCtx = this.tracer.extract('text_map_dsm', carrier)
+    DataStreamsContext.setDataStreamsContext(parentCtx)
+
+    const ctx = this.dsmProcessor.setCheckpoint(
+      ['type:' + type, 'topic:' + source, 'direction:in', 'manual_checkpoint:true'],
+      null,
+      parentCtx,
+      null
+    )
+    DataStreamsContext.setDataStreamsContext(ctx)
+
+    return ctx
+  }
+}
+
+module.exports = {
+  DataStreamsCheckpointer
+}