datadog 2.8.0 → 2.39.0

data/lib/datadog/core/configuration/settings.rb

@@ -1,24 +1,26 @@
 # frozen_string_literal: true
 
-require 'logger'
+require "logger"
 
-require_relative 'base'
-require_relative 'ext'
-require_relative '../environment/execution'
-require_relative '../environment/ext'
-require_relative '../runtime/ext'
-require_relative '../telemetry/ext'
-require_relative '../remote/ext'
-require_relative '../../profiling/ext'
+require_relative "base"
+require_relative "ext"
+require_relative "../environment/execution"
+require_relative "../environment/ext"
+require_relative "../environment/process"
+require_relative "../runtime/ext"
+require_relative "../telemetry/ext"
+require_relative "../remote/ext"
+require_relative "../../profiling/ext"
 
-require_relative '../../tracing/configuration/settings'
+require_relative "../../tracing/configuration/settings"
+require_relative "../../opentelemetry/configuration/settings"
 
 module Datadog
   module Core
     module Configuration
       # Global configuration settings for the Datadog library.
       # @public_api
-      # rubocop:disable Metrics/BlockLength
+      # standard:disable Metrics/BlockLength
       class Settings
         include Base
 
@@ -104,6 +106,7 @@ module Datadog
         option :api_key do |o|
           o.type :string, nilable: true
           o.env Core::Environment::Ext::ENV_API_KEY
+          o.skip_telemetry true
         end
 
         # Datadog diagnostic settings.
@@ -122,8 +125,8 @@ module Datadog
           # @default `DD_TRACE_DEBUG` environment variable, otherwise `false`
           # @return [Boolean]
           option :debug do |o|
-            o.env [Datadog::Core::Configuration::Ext::Diagnostics::ENV_DEBUG_ENABLED,
-                   Datadog::Core::Configuration::Ext::Diagnostics::ENV_OTEL_LOG_LEVEL]
+            # Note: Alias (OTEL_LOG_LEVEL) defined in supported-configurations.json
+            o.env Datadog::Core::Configuration::Ext::Diagnostics::ENV_DEBUG_ENABLED
             o.default false
             o.type :bool
             o.env_parser do |value|
@@ -131,13 +134,13 @@ module Datadog
                 value = value.strip.downcase
                 # Debug is enabled when DD_TRACE_DEBUG is true or 1 OR
                 # when OTEL_LOG_LEVEL is set to debug
-                ['true', '1', 'debug'].include?(value)
+                ["true", "1", "debug"].include?(value)
               end
             end
             o.after_set do |enabled|
               # Enable rich debug print statements.
               # We do not need to unnecessarily load 'pp' unless in debugging mode.
-              require 'pp' if enabled
+              require "pp" if enabled # standard:disable Lint/RedundantRequireStatement
             end
           end
 
@@ -169,6 +172,30 @@ module Datadog
           o.env Core::Environment::Ext::ENV_ENVIRONMENT
         end
 
+        # Override the hostname reported by this process.
+        # When `report_hostname` is enabled, sets the hostname on traces and
+        # the `host.name` resource attribute in OpenTelemetry.
+        # @default `DD_HOSTNAME` environment variable, otherwise `nil`
+        # @return [String,nil]
+        option :hostname do |o|
+          o.type :string, nilable: true
+          o.env Core::Environment::Ext::ENV_HOSTNAME
+        end
+
+        # Configuration for container environments. For internal use only.
+        # @!visibility private
+        settings :container do
+          # Data supplied by the container runner to assist in uniquely identifying this process.
+          # Used in [Origin Detection](https://docs.datadoghq.com/developers/dogstatsd/unix_socket/?tab=host#origin-detection)
+          #
+          # @default `DD_EXTERNAL_ENV` environment variable, otherwise `nil`
+          # @return [String,nil]
+          option :external_env do |o|
+            o.type :string, nilable: true
+            o.env Core::Environment::Ext::ENV_EXTERNAL_ENV
+          end
+        end
+
         # Internal {Datadog::Statsd} metrics collection.
         #
         # @public_api
@@ -206,12 +233,15 @@ module Datadog
           #
           # @return Logger::Severity
           option :instance do |o|
+            # Telemetry for this option is manually modified and added in the AppStarted event.
+            o.skip_telemetry true
             o.after_set { |value| set_option(:level, value.level) unless value.nil? }
           end
 
           # Log level for `Datadog.logger`.
           # @see Logger::Severity
           # @return Logger::Severity
+          # TODO: Add environment variable for this `DD_TRACE_LOG_LEVEL`
           option :level, default: ::Logger::INFO
         end
 
@@ -246,7 +276,7 @@ module Datadog
           # @default `DD_PROFILING_ALLOCATION_ENABLED` environment variable as a boolean, otherwise `false`
           option :allocation_enabled do |o|
             o.type :bool
-            o.env 'DD_PROFILING_ALLOCATION_ENABLED'
+            o.env "DD_PROFILING_ALLOCATION_ENABLED"
             o.default false
           end
 
@@ -291,13 +321,10 @@ module Datadog
             #       for Ruby versions 2.x, 3.1.4+, 3.2.3+ and 3.3.0+
             #       (more details in {Datadog::Profiling::Component.enable_gc_profiling?})
             #
-            # @warn Due to a VM bug in the Ractor implementation (https://bugs.ruby-lang.org/issues/19112) this feature
-            #       stops working when Ractors get garbage collected.
-            #
             # @default `DD_PROFILING_GC_ENABLED` environment variable, otherwise `true`
             option :gc_enabled do |o|
               o.type :bool
-              o.env 'DD_PROFILING_GC_ENABLED'
+              o.env "DD_PROFILING_GC_ENABLED"
               o.default true
             end
 
@@ -313,45 +340,47 @@ module Datadog
 
             # Can be used to enable/disable the collection of heap profiles.
             #
-            # This feature is alpha and disabled by default
+            # This feature is in preview and disabled by default. Requires Ruby 3.1+.
             #
             # @warn To enable heap profiling you are required to also enable allocation profiling.
             #
             # @default `DD_PROFILING_EXPERIMENTAL_HEAP_ENABLED` environment variable as a boolean, otherwise `false`
             option :experimental_heap_enabled do |o|
               o.type :bool
-              o.env 'DD_PROFILING_EXPERIMENTAL_HEAP_ENABLED'
+              o.env "DD_PROFILING_EXPERIMENTAL_HEAP_ENABLED"
               o.default false
             end
 
             # Can be used to enable/disable the collection of heap size profiles.
             #
-            # This feature is alpha and enabled by default when heap profiling is enabled.
+            # This feature is in preview and by default is enabled whenever heap profiling is enabled.
             #
-            # @warn To enable heap size profiling you are required to also enable allocation and heap profiling.
+            # @warn Heap size profiling depends on allocation and heap profiling, so they must be enabled as well.
             #
-            # @default `DD_PROFILING_EXPERIMENTAL_HEAP_SIZE_ENABLED` environment variable as a boolean, otherwise
-            # whatever the value of DD_PROFILING_EXPERIMENTAL_HEAP_ENABLED is.
+            # @default `DD_PROFILING_EXPERIMENTAL_HEAP_SIZE_ENABLED` environment variable as a boolean, otherwise it
+            # follows the value of `experimental_heap_enabled`.
             option :experimental_heap_size_enabled do |o|
               o.type :bool
-              o.env 'DD_PROFILING_EXPERIMENTAL_HEAP_SIZE_ENABLED'
+              o.env "DD_PROFILING_EXPERIMENTAL_HEAP_SIZE_ENABLED"
               o.default true # This gets ANDed with experimental_heap_enabled in the profiler component.
             end
 
             # Can be used to configure the heap sampling rate: a heap sample will be collected for every x allocation
             # samples.
             #
-            # The lower the value, the more accuracy in heap tracking but the bigger the overhead. In particular, a
-            # value of 1 will track ALL allocations samples for heap profiles.
+            # The higher the value, the less accuracy in heap tracking but the smaller the overhead.
+            #
+            # If you needed to tweak this, please tell us why on <https://github.com/DataDog/dd-trace-rb/issues/new>,
+            # so we can fix it!
             #
             # The effective heap sampling rate in terms of allocations (not allocation samples) can be calculated via
             # effective_heap_sample_rate = allocation_sample_rate * heap_sample_rate.
             #
-            # @default `DD_PROFILING_EXPERIMENTAL_HEAP_SAMPLE_RATE` environment variable, otherwise `10`.
+            # @default `DD_PROFILING_EXPERIMENTAL_HEAP_SAMPLE_RATE` environment variable, otherwise `1`.
             option :experimental_heap_sample_rate do |o|
               o.type :int
-              o.env 'DD_PROFILING_EXPERIMENTAL_HEAP_SAMPLE_RATE'
-              o.default 10
+              o.env "DD_PROFILING_EXPERIMENTAL_HEAP_SAMPLE_RATE"
+              o.default 1
             end
 
             # Can be used to disable checking which version of `libmysqlclient` is being used by the `mysql2` gem.
@@ -361,20 +390,23 @@ module Datadog
             # @default `DD_PROFILING_SKIP_MYSQL2_CHECK` environment variable, otherwise `false`
             option :skip_mysql2_check do |o|
               o.type :bool
-              o.env 'DD_PROFILING_SKIP_MYSQL2_CHECK'
+              o.env "DD_PROFILING_SKIP_MYSQL2_CHECK"
               o.default false
             end
 
-            # Controls data collection for the timeline feature.
-            #
-            # If you needed to disable this, please tell us why on <https://github.com/DataDog/dd-trace-rb/issues/new>,
-            # so we can fix it!
-            #
-            # @default `DD_PROFILING_TIMELINE_ENABLED` environment variable as a boolean, otherwise `true`
+            # DEV-3.0: Remove `timeline_enabled` option
             option :timeline_enabled do |o|
               o.type :bool
-              o.env 'DD_PROFILING_TIMELINE_ENABLED'
+              o.env "DD_PROFILING_TIMELINE_ENABLED"
               o.default true
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Core.log_deprecation(key: :timeline_enabled) do
+                    "The profiling.advanced.timeline_enabled setting has been deprecated for removal and no longer does anything. " \
+                      "Please remove it from your Datadog.configure block and do not set DD_PROFILING_TIMELINE_ENABLED."
+                  end
+                end
+              end
             end
 
             # The profiler gathers data by sending `SIGPROF` unix signals to Ruby application threads.
@@ -397,12 +429,12 @@ module Datadog
             #
             # @default `DD_PROFILING_NO_SIGNALS_WORKAROUND_ENABLED` environment variable as a boolean, otherwise `:auto`
             option :no_signals_workaround_enabled do |o|
-              o.env 'DD_PROFILING_NO_SIGNALS_WORKAROUND_ENABLED'
+              o.env "DD_PROFILING_NO_SIGNALS_WORKAROUND_ENABLED"
               o.default :auto
               o.env_parser do |value|
                 if value
                   value = value.strip.downcase
-                  ['true', '1'].include?(value)
+                  ["true", "1"].include?(value)
                 end
               end
             end
@@ -416,7 +448,24 @@ module Datadog
             # @default `DD_PROFILING_DIR_INTERRUPTION_WORKAROUND_ENABLED` environment variable as a boolean,
             # otherwise `true`
             option :dir_interruption_workaround_enabled do |o|
-              o.env 'DD_PROFILING_DIR_INTERRUPTION_WORKAROUND_ENABLED'
+              o.env "DD_PROFILING_DIR_INTERRUPTION_WORKAROUND_ENABLED"
+              o.type :bool
+              o.default true
+            end
+
+            # The profiler gathers data by sending `SIGPROF` unix signals to Ruby application threads.
+            #
+            # When using `Kernel#exec` on Linux, it can happen that a signal sent before calling `exec` arrives after
+            # the new process is running, causing it to fail with the `Profiling timer expired` error message.
+            # To avoid this, the profiler installs a monkey patch on `Kernel#exec` to stop profiling before actually
+            # calling `exec`.
+            # This monkey patch is available for Ruby 2.7+; let us know if you need it on earlier Rubies.
+            # For more details see https://github.com/DataDog/dd-trace-rb/issues/5101 .
+            #
+            # @default `DD_PROFILING_SHUTDOWN_ON_EXEC_ENABLED` environment variable as a boolean,
+            # otherwise `true`
+            option :shutdown_on_exec_enabled do |o|
+              o.env "DD_PROFILING_SHUTDOWN_ON_EXEC_ENABLED"
               o.type :bool
               o.default true
             end
@@ -434,7 +483,7 @@ module Datadog
             # @default `DD_PROFILING_OVERHEAD_TARGET_PERCENTAGE` as a float, otherwise 2.0
             option :overhead_target_percentage do |o|
               o.type :float
-              o.env 'DD_PROFILING_OVERHEAD_TARGET_PERCENTAGE'
+              o.env "DD_PROFILING_OVERHEAD_TARGET_PERCENTAGE"
               o.default 2.0
             end
 
@@ -445,7 +494,7 @@ module Datadog
             # @default `DD_PROFILING_UPLOAD_PERIOD` environment variable, otherwise 60
             option :upload_period_seconds do |o|
               o.type :int
-              o.env 'DD_PROFILING_UPLOAD_PERIOD'
+              o.env "DD_PROFILING_UPLOAD_PERIOD"
               o.default 60
             end
 
@@ -454,22 +503,38 @@ module Datadog
               o.after_set do |_, _, precedence|
                 unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
                   Core.log_deprecation(key: :experimental_crash_tracking_enabled) do
-                    'The profiling.advanced.experimental_crash_tracking_enabled setting has been deprecated for removal '\
-                    'and no longer does anything. Please remove it from your Datadog.configure block.'
+                    "The profiling.advanced.experimental_crash_tracking_enabled setting has been deprecated for removal " \
+                    "and no longer does anything. Please remove it from your Datadog.configure block."
                   end
                 end
               end
             end
 
-            # Enables GVL profiling. This will show when threads are waiting for GVL in the timeline view.
-            #
-            # This is a preview feature and disabled by default. It requires Ruby 3.2+.
-            #
-            # @default `DD_PROFILING_PREVIEW_GVL_ENABLED` environment variable as a boolean, otherwise `false`
+            # @deprecated Use {:gvl_enabled} instead.
             option :preview_gvl_enabled do |o|
               o.type :bool
-              o.env 'DD_PROFILING_PREVIEW_GVL_ENABLED'
               o.default false
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    "The profiling.advanced.preview_gvl_enabled setting has been deprecated for removal and " \
+                    "no longer does anything. Please remove it from your Datadog.configure block. " \
+                    "GVL profiling is now controlled by the profiling.advanced.gvl_enabled setting instead."
+                  )
+                end
+              end
+            end
+
+            # Controls GVL profiling. This will show when threads are waiting for GVL in the timeline view.
+            #
+            # This feature requires Ruby 3.2+.
+            #
+            # @default `DD_PROFILING_GVL_ENABLED` environment variable as a boolean, otherwise `true`
+            option :gvl_enabled do |o|
+              o.type :bool
+              # Note: Deprecated alias (DD_PROFILING_PREVIEW_GVL_ENABLED) defined in supported-configurations.json
+              o.env "DD_PROFILING_GVL_ENABLED"
+              o.default true
             end
 
             # Controls the smallest time period the profiler will report a thread waiting for the GVL.
@@ -490,24 +555,24 @@ module Datadog
             #
             # @default false
             option :preview_otel_context_enabled do |o|
-              o.env 'DD_PROFILING_PREVIEW_OTEL_CONTEXT_ENABLED'
+              o.env "DD_PROFILING_PREVIEW_OTEL_CONTEXT_ENABLED"
               o.default false
               o.env_parser do |value|
                 if value
                   value = value.strip.downcase
-                  if ['only', 'both'].include?(value)
+                  if ["only", "both"].include?(value)
                     value
-                  elsif ['true', '1'].include?(value)
-                    'both'
+                  elsif ["true", "1"].include?(value)
+                    "both"
                   else
-                    'false'
+                    "false"
                   end
                 end
               end
               o.setter do |value|
                 if value == true
                   :both
-                elsif ['only', 'both', :only, :both].include?(value)
+                elsif ["only", "both", :only, :both].include?(value)
                   value.to_sym
                 else
                   false
@@ -523,7 +588,60 @@ module Datadog
             # @default true
             option :heap_clean_after_gc_enabled do |o|
               o.type :bool
-              o.env 'DD_PROFILING_HEAP_CLEAN_AFTER_GC_ENABLED'
+              o.env "DD_PROFILING_HEAP_CLEAN_AFTER_GC_ENABLED"
+              o.default true
+            end
+
+            # Controls if the profiler should use native filenames for frames in stack traces for functions implemented using
+            # native code. Setting to `false` will make the profiler fall back to default Ruby stack trace behavior (only show .rb files).
+            #
+            # @default true
+            option :native_filenames_enabled do |o|
+              o.type :bool
+              o.env "DD_PROFILING_NATIVE_FILENAMES_ENABLED"
+              o.default true
+            end
+
+            # Controls if the profiler should sample directly from the signal handler.
+            # Sampling directly from the signal handler improves accuracy of the data collected.
+            #
+            # We recommend using this setting with Ruby 3.2.5+ / Ruby 3.3.4+ and above
+            # as they include additional safety measures added in https://github.com/ruby/ruby/pull/11036.
+            # We have not validated it thoroughly with earlier versions, but in practice it should work on Ruby 3.0+
+            # (the key change was https://github.com/ruby/ruby/pull/3296).
+            #
+            # Enabling this on Ruby 2 is not recommended as it may cause VM crashes and/or incorrect data.
+            #
+            # @default true on Ruby 3.2.5+ / Ruby 3.3.4+, false on older Rubies
+            option :sighandler_sampling_enabled do |o|
+              o.type :bool
+              o.env "DD_PROFILING_SIGHANDLER_SAMPLING_ENABLED"
+              o.default do
+                RubyVersion.is?(">= 3.2.5") && !RubyVersion.is?(">= 3.3", "< 3.3.4")
+              end
+            end
+
+            # Experimental: Controls the CPU sampling interval in milliseconds. This sets how often the profiler
+            # attempts to take a CPU sample. Valid values are 1 to 10.
+            #
+            # Lower values increase accuracy but also increase overhead. If you need to reduce profiler overhead,
+            # use the `overhead_target_percentage` setting instead.
+            #
+            # @warn This setting is experimental and may be removed or changed in future versions.
+            #
+            # # No config via environment variable yet
+            # @default 10
+            option :experimental_cpu_sampling_interval_ms do |o|
+              o.type :int
+              o.default 10
+            end
+
+            # Fallback to system dns instead of using libdatadog built-in resolver.
+            #
+            # @default `DD_PROFILING_EXPERIMENTAL_USE_SYSTEM_DNS` environment variable as a boolean, otherwise `true`
+            option :experimental_use_system_dns do |o|
+              o.type :bool
+              o.env "DD_PROFILING_EXPERIMENTAL_USE_SYSTEM_DNS"
               o.default true
             end
           end
@@ -554,6 +672,13 @@ module Datadog
             o.type :bool
           end
 
+          option :experimental_runtime_id_enabled do |o|
+            o.type :bool
+            # Note: Alias (DD_TRACE_EXPERIMENTAL_RUNTIME_ID_ENABLED) defined in supported-configurations.json
+            o.env "DD_RUNTIME_METRICS_RUNTIME_ID_ENABLED"
+            o.default false
+          end
+
           option :opts, default: {}, type: :hash
           option :statsd
         end
@@ -566,15 +691,20 @@ module Datadog
           o.type :string, nilable: true
 
           # NOTE: service also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
-          o.env [Core::Environment::Ext::ENV_SERVICE, Core::Environment::Ext::ENV_OTEL_SERVICE]
+          # Note: Alias (OTEL_SERVICE_NAME) defined in supported-configurations.json
+          o.env Core::Environment::Ext::ENV_SERVICE
           o.default Core::Environment::Ext::FALLBACK_SERVICE_NAME
 
+          o.after_set do |service_name|
+            Core::Environment::Process.set_service(service_name, user_configured: !using_default?(:service))
+          end
+
           # There's a few cases where we don't want to use the fallback service name, so this helper allows us to get a
           # nil instead so that one can do
           # nice_service_name = Datadog.configuration.service_without_fallback || nice_service_name_default
           o.helper(:service_without_fallback) do
             service_name = service
-            service_name unless service_name.equal?(Core::Environment::Ext::FALLBACK_SERVICE_NAME)
+            service_name unless using_default?(:service)
           end
         end
 
@@ -601,40 +731,34 @@ module Datadog
         # @return [Hash<String,String>]
         option :tags do |o|
           o.type :hash, nilable: true
-          o.env [Core::Environment::Ext::ENV_TAGS, Core::Environment::Ext::ENV_OTEL_RESOURCE_ATTRIBUTES]
+          # Note: Alias (OTEL_RESOURCE_ATTRIBUTES) defined in supported-configurations.json
+          o.env Core::Environment::Ext::ENV_TAGS
           o.env_parser do |env_value|
-            values = if env_value.include?(',')
-                       env_value.split(',')
-                     else
-                       env_value.split(' ') # rubocop:disable Style/RedundantArgument
-                     end
-            values.map! do |v|
-              v.gsub!(/\A[\s,]*|[\s,]*\Z/, '')
-
-              v.empty? ? nil : v
-            end
-
-            values.compact!
-            values.each_with_object({}) do |tag, tags|
-              key, value = tag.split(':', 2)
-              if value.nil?
-                # support tags/attributes delimited by the OpenTelemetry separator (`=`)
-                key, value = tag.split('=', 2)
-              end
-              next if value.nil? || value.empty?
-
-              # maps OpenTelemetry semantic attributes to Datadog tags
-              case key.downcase
-              when 'deployment.environment'
-                tags['env'] = value
-              when 'service.version'
-                tags['version'] = value
-              when 'service.name'
-                tags['service'] = value
-              else
-                tags[key] = value
+            # Parses a string containing key-value pairs and returns a hash.
+            # Key-value pairs are delimited by ':' OR `=`, and pairs are separated by whitespace, comma, OR BOTH.
+            result = {}
+            unless env_value.nil? || env_value.empty?
+              # falling back to comma as separator
+              sep = env_value.include?(",") ? "," : " "
+              # split by separator
+              env_value.split(sep).each do |tag|
+                tag.strip!
+                next if tag.empty?
+
+                # tag by : or = (for OpenTelemetry)
+                key, val = tag.split(/[:=]/, 2).map(&:strip)
+                val ||= ""
+                # maps OpenTelemetry semantic attributes to Datadog tags
+                key = case key.downcase
+                when "deployment.environment" then "env"
+                when "service.version" then "version"
+                when "service.name" then "service"
+                else key
+                end
+                result[key] = val unless key.empty?
               end
             end
+            result
           end
           o.setter do |new_value, old_value|
             raw_tags = new_value || {}
@@ -700,14 +824,14 @@ module Datadog
         # It must respect the interface of [Datadog::Core::Utils::Time#get_time] method.
         #
         # For [Timecop](https://rubygems.org/gems/timecop), for example,
-        # `->(unit = :float_second) { ::Process.clock_gettime_without_mock(::Process::CLOCK_MONOTONIC, unit) }`
+        # `->(unit = :float_second) { ::Process.clock_gettime_without_mock(Datadog::Core::Utils::Time::MONOTONIC_CLOCK_ID, unit) }`
         # allows Datadog features to use the real monotonic time when time is frozen with
         # `Timecop.mock_process_clock = true`.
         #
-        # @default `->(unit = :float_second) { ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, unit)}`
+        # @default `->(unit = :float_second) { ::Process.clock_gettime(Core::Utils::Time::MONOTONIC_CLOCK_ID, unit) }`
         # @return [Proc<Numeric>]
         option :get_time_provider do |o|
-          o.default_proc { |unit = :float_second| ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, unit) }
+          o.default_proc { |unit = :float_second| ::Process.clock_gettime(Core::Utils::Time::MONOTONIC_CLOCK_ID, unit) }
           o.type :proc
 
           o.after_set do |get_time_provider|
@@ -715,7 +839,7 @@ module Datadog
           end
 
           o.resetter do |_value|
-            ->(unit = :float_second) { ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, unit) }.tap do |default|
+            ->(unit = :float_second) { ::Process.clock_gettime(Core::Utils::Time::MONOTONIC_CLOCK_ID, unit) }.tap do |default|
               Core::Utils::Time.get_time_provider = default
             end
           end
@@ -755,8 +879,8 @@ module Datadog
             o.default do
               if Datadog::Core::Environment::Execution.development?
                 Datadog.logger.debug do
-                  'Development environment detected, disabling Telemetry. ' \
-                    'You can enable it with DD_INSTRUMENTATION_TELEMETRY_ENABLED=true.'
+                  "Development environment detected, disabling Telemetry. " \
+                    "You can enable it with DD_INSTRUMENTATION_TELEMETRY_ENABLED=true."
                 end
                 false
               else
@@ -777,6 +901,7 @@ module Datadog
 
           # Overrides agentless telemetry URL. To be used internally for testing purposes only.
           #
+          # @default `DD_TELEMETRY_AGENTLESS_URL` environment variable, otherwise `nil`.
           # @return [String]
           # @!visibility private
           option :agentless_url_override do |o|
@@ -807,6 +932,19 @@ module Datadog
             o.default 60.0
           end
 
+          # The interval in seconds when extended heartbeat must be sent.
+          #
+          # This method is used internally, for testing purposes only.
+          #
+          # @default `DD_TELEMETRY_EXTENDED_HEARTBEAT_INTERVAL` environment variable, otherwise `86400`.
+          # @return [Integer]
+          # @!visibility private
+          option :extended_heartbeat_interval_seconds do |o|
+            o.type :int
+            o.env Core::Telemetry::Ext::ENV_EXTENDED_HEARTBEAT_INTERVAL
+            o.default 86400
+          end
+
           # The interval in seconds when telemetry metrics are aggregated.
           # Should be a denominator of `heartbeat_interval_seconds`.
           #
@@ -873,6 +1011,16 @@ module Datadog
             o.env Core::Telemetry::Ext::ENV_LOG_COLLECTION
             o.default true
           end
+
+          # For internal use only.
+          # Enables telemetry debugging through the Datadog platform.
+          #
+          # @default `false`.
+          # @return [Boolean]
+          option :debug do |o|
+            o.type :bool
+            o.default false
+          end
         end
 
         # Remote configuration
@@ -888,8 +1036,8 @@ module Datadog
             o.default do
               if Datadog::Core::Environment::Execution.development?
                 Datadog.logger.debug do
-                  'Development environment detected, disabling Remote Configuration. ' \
-                    'You can enable it with DD_REMOTE_CONFIGURATION_ENABLED=true.'
+                  "Development environment detected, disabling Remote Configuration. " \
+                    "You can enable it with DD_REMOTE_CONFIGURATION_ENABLED=true."
                 end
                 false
               else
@@ -938,15 +1086,51 @@ module Datadog
           option :enabled do |o|
             o.type :bool
             o.default true
-            o.env 'DD_CRASHTRACKING_ENABLED'
+            o.env "DD_CRASHTRACKING_ENABLED"
+          end
+        end
+
+        # Enable process tags propagation such that payloads like spans contain the process tag.
+        #
+        # @default `DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED` environment variable, otherwise `true`
+        # @return [Boolean]
+        option :experimental_propagate_process_tags_enabled do |o|
+          o.env "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED"
+          o.default true
+          o.type :bool
+        end
+
+        # Tracer specific configuration starting with APM (e.g. DD_APM_TRACING_ENABLED).
+        # @public_api
+        settings :apm do
+          # Tracing as a transport
+          # @public_api
+          settings :tracing do
+            # Enables tracing as transport.
+            # Disabling it will set sampling priority to -1 (FORCE_DROP) on most traces,
+            # (which tells to the agent to drop these traces)
+            # except heartbeat ones (1 per minute) and manually kept ones (sampling priority to 2) (e.g. appsec events)
+            #
+            # This is different than `DD_TRACE_ENABLED`, which completely disables tracing (sends no trace at all),
+            # while this will send heartbeat traces (1 per minute) so that the service is considered alive in the backend.
+            #
+            # @default `DD_APM_TRACING_ENABLED` environment variable, otherwise `true`
+            # @return [Boolean]
+            option :enabled do |o|
+              o.env Configuration::Ext::APM::ENV_TRACING_ENABLED
+              o.default true
+              o.type :bool
+            end
           end
         end
 
         # TODO: Tracing should manage its own settings.
         #       Keep this extension here for now to keep things working.
         extend Datadog::Tracing::Configuration::Settings
+
+        extend Datadog::OpenTelemetry::Configuration::Settings
       end
-      # rubocop:enable Metrics/BlockLength
+      # standard:enable Metrics/BlockLength
     end
   end
 end