ddtrace 1.4.2 → 1.23.3

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

@@ -1,22 +1,22 @@
-# typed: false
-
 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 '../../tracing/configuration/ext'
+
+require_relative '../../tracing/configuration/settings'
 
 module Datadog
   module Core
     module Configuration
-      # Global configuration settings for the trace library.
+      # Global configuration settings for the Datadog library.
       # @public_api
       # rubocop:disable Metrics/BlockLength
-      # rubocop:disable Metrics/ClassLength
-      # rubocop:disable Layout/LineLength
       class Settings
         include Base
 
@@ -80,8 +80,8 @@ module Datadog
         # @default `DD_API_KEY` environment variable, otherwise `nil`
         # @return [String,nil]
         option :api_key do |o|
-          o.default { ENV.fetch(Core::Environment::Ext::ENV_API_KEY, nil) }
-          o.lazy
+          o.type :string, nilable: true
+          o.env Core::Environment::Ext::ENV_API_KEY
         end
 
         # Datadog diagnostic settings.
@@ -100,18 +100,17 @@ module Datadog
           # @default `DD_TRACE_DEBUG` environment variable, otherwise `false`
           # @return [Boolean]
           option :debug do |o|
-            o.default { env_to_bool(Datadog::Core::Diagnostics::Ext::DD_TRACE_DEBUG, false) }
-            o.lazy
-            o.on_set do |enabled|
+            o.env Datadog::Core::Configuration::Ext::Diagnostics::ENV_DEBUG_ENABLED
+            o.default false
+            o.type :bool
+            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
             end
           end
-
           # Internal {Datadog::Statsd} metrics collection.
           #
-          # The list of metrics collected can be found in {Datadog::Core::Diagnostics::Ext::Health::Metrics}.
           # @public_api
           settings :health_metrics do
             # Enable health metrics collection.
@@ -119,8 +118,9 @@ module Datadog
             # @default `DD_HEALTH_METRICS_ENABLED` environment variable, otherwise `false`
             # @return [Boolean]
             option :enabled do |o|
-              o.default { env_to_bool(Datadog::Core::Diagnostics::Ext::Health::Metrics::ENV_ENABLED, false) }
-              o.lazy
+              o.env Datadog::Core::Configuration::Ext::Diagnostics::ENV_HEALTH_METRICS_ENABLED
+              o.default false
+              o.type :bool
             end
 
             # {Datadog::Statsd} instance to collect health metrics.
@@ -142,11 +142,11 @@ module Datadog
             # is *not* running in a development environment.
             #
             # @default `DD_TRACE_STARTUP_LOGS` environment variable, otherwise `nil`
-            # @return [Boolean,nil]
+            # @return [Boolean, nil]
             option :enabled do |o|
+              o.env Datadog::Core::Configuration::Ext::Diagnostics::ENV_STARTUP_LOGS_ENABLED
               # Defaults to nil as we want to know when the default value is being used
-              o.default { env_to_bool(Datadog::Core::Diagnostics::Ext::DD_TRACE_STARTUP_LOGS, nil) }
-              o.lazy
+              o.type :bool, nilable: true
             end
           end
         end
@@ -156,9 +156,11 @@ module Datadog
         # @default `DD_ENV` environment variable, otherwise `nil`
         # @return [String,nil]
         option :env do |o|
+          # DEV-2.0: Remove this conversion for symbol.
+          o.setter { |v| v.to_s if v }
+
           # NOTE: env also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
-          o.default { ENV.fetch(Core::Environment::Ext::ENV_ENVIRONMENT, nil) }
-          o.lazy
+          o.env Core::Environment::Ext::ENV_ENVIRONMENT
         end
 
         # Internal `Datadog.logger` configuration.
@@ -174,7 +176,7 @@ module Datadog
           #
           # @return Logger::Severity
           option :instance do |o|
-            o.on_set { |value| set_option(:level, value.level) unless value.nil? }
+            o.after_set { |value| set_option(:level, value.level) unless value.nil? }
           end
 
           # Log level for `Datadog.logger`.
@@ -193,8 +195,9 @@ module Datadog
           # @default `DD_PROFILING_ENABLED` environment variable, otherwise `false`
           # @return [Boolean]
           option :enabled do |o|
-            o.default { env_to_bool(Profiling::Ext::ENV_ENABLED, false) }
-            o.lazy
+            o.env Profiling::Ext::ENV_ENABLED
+            o.default false
+            o.type :bool
           end
 
           # @public_api
@@ -202,18 +205,47 @@ module Datadog
             option :transport
           end
 
+          # Can be used to enable/disable collection of allocation profiles.
+          #
+          # This feature is disabled by default
+          #
+          # @warn Due to bugs in Ruby we only recommend enabling this feature in
+          #       Ruby versions 2.x, 3.1.4+, 3.2.3+ and 3.3.0+
+          #       (more details in {Datadog::Profiling::Component.enable_allocation_profiling?})
+          #
+          # @default `DD_PROFILING_ALLOCATION_ENABLED` environment variable as a boolean, otherwise `false`
+          option :allocation_enabled do |o|
+            o.type :bool
+            o.deprecated_env 'DD_PROFILING_EXPERIMENTAL_ALLOCATION_ENABLED' # TODO: Remove this for dd-trace-rb 2.0
+            o.env 'DD_PROFILING_ALLOCATION_ENABLED'
+            o.default false
+          end
+
           # @public_api
           settings :advanced do
-            # This should never be reduced, as it can cause the resulting profiles to become biased.
-            # The current default should be enough for most services, allowing 16 threads to be sampled around 30 times
-            # per second for a 60 second period.
-            option :max_events, default: 32768
+            # @deprecated No longer does anything, and will be removed on dd-trace-rb 2.0.
+            #
+            # This was used prior to the GA of the new CPU Profiling 2.0 profiler. The CPU Profiling 2.0 profiler does not
+            # use or need this setting and thus it doesn't do anything.
+            option :max_events do |o|
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.max_events setting has been deprecated for removal and no ' \
+                    'longer does anything. Please remove it from your Datadog.configure block.'
+                  )
+                end
+              end
+            end
 
             # Controls the maximum number of frames for each thread sampled. Can be tuned to avoid omitted frames in the
             # produced profiles. Increasing this may increase the overhead of profiling.
+            #
+            # @default `DD_PROFILING_MAX_FRAMES` environment variable, otherwise 400
             option :max_frames do |o|
-              o.default { env_to_int(Profiling::Ext::ENV_MAX_FRAMES, 400) }
-              o.lazy
+              o.type :int
+              o.env Profiling::Ext::ENV_MAX_FRAMES
+              o.default 400
             end
 
             # @public_api
@@ -225,40 +257,291 @@ module Datadog
                 # @default `DD_PROFILING_ENDPOINT_COLLECTION_ENABLED` environment variable, otherwise `true`
                 # @return [Boolean]
                 option :enabled do |o|
-                  o.default { env_to_bool(Profiling::Ext::ENV_ENDPOINT_COLLECTION_ENABLED, true) }
-                  o.lazy
+                  o.env Profiling::Ext::ENV_ENDPOINT_COLLECTION_ENABLED
+                  o.default true
+                  o.type :bool
                 end
               end
             end
 
-            # Disable gathering of names and versions of gems in use by the service, used to power grouping and
-            # categorization of stack traces.
-            option :code_provenance_enabled, default: true
+            # Can be used to disable the gathering of names and versions of gems in use by the service, used to power
+            # grouping and categorization of stack traces.
+            option :code_provenance_enabled do |o|
+              o.type :bool
+              o.default true
+            end
 
-            # Use legacy transport code instead of HttpTransport. Temporarily added for migration to HttpTransport,
-            # and will be removed soon. Do not use unless instructed to by support.
+            # @deprecated No longer does anything, and will be removed on dd-trace-rb 2.0.
+            #
+            # This was added as a temporary support option in case of issues with the new `Profiling::HttpTransport` class
+            # but we're now confident it's working nicely so we've removed the old code path.
             option :legacy_transport_enabled do |o|
-              o.default { env_to_bool('DD_PROFILING_LEGACY_TRANSPORT_ENABLED', false) }
-              o.lazy
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.legacy_transport_enabled setting has been deprecated for removal and no ' \
+                    'longer does anything. Please remove it from your Datadog.configure block.'
+                  )
+                end
+              end
             end
 
-            # Forces enabling the new profiler. We do not yet recommend turning on this option.
+            # @deprecated No longer does anything, and will be removed on dd-trace-rb 2.0.
             #
-            # Note that setting this to "false" (or not setting it) will not prevent the new profiler from
-            # being automatically used in the future.
-            # This option will be deprecated for removal once the new profiler gets enabled by default for all customers.
+            # This was used prior to the GA of the new CPU Profiling 2.0 profiler. Using CPU Profiling 2.0 is now the
+            # default and this doesn't do anything.
             option :force_enable_new_profiler do |o|
-              o.default { env_to_bool('DD_PROFILING_FORCE_ENABLE_NEW', false) }
-              o.lazy
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.force_enable_new_profiler setting has been deprecated for removal and no ' \
+                    'longer does anything. Please remove it from your Datadog.configure block.'
+                  )
+                end
+              end
+            end
+
+            # @deprecated No longer does anything, and will be removed on dd-trace-rb 2.0.
+            #
+            # This was used prior to the GA of the new CPU Profiling 2.0 profiler. Using CPU Profiling 2.0 is now the
+            # default and this doesn't do anything.
+            option :force_enable_legacy_profiler do |o|
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.force_enable_legacy_profiler setting has been deprecated for removal and no ' \
+                    'longer does anything. Please remove it from your Datadog.configure block.'
+                  )
+                end
+              end
+            end
+
+            # @deprecated No longer does anything, and will be removed on dd-trace-rb 2.0.
+            #
+            # GC profiling is now on by default and controlled by {:gc_enabled}.
+            option :force_enable_gc_profiling do |o|
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.force_enable_gc_profiling setting has been deprecated for removal and no ' \
+                    'longer does anything (the feature is now on by default). ' \
+                    'Please remove this setting from your Datadog.configure block.'
+                  )
+                end
+              end
+            end
+
+            # Can be used to enable/disable garbage collection profiling.
+            #
+            # @warn To avoid https://bugs.ruby-lang.org/issues/18464 even when enabled, GC profiling is only started
+            #       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.default true
+            end
+
+            # Can be used to enable/disable the Datadog::Profiling.allocation_count feature.
+            #
+            # @deprecated Use {:allocation_enabled} (outside of advanced section) instead.
+            option :allocation_counting_enabled do |o|
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.allocation_counting_enabled setting has been deprecated for removal and no ' \
+                    'longer does anything. Please remove it from your Datadog.configure block. ' \
+                    'Allocation counting is now controlled by the profiling.allocation_enabled setting instead.'
+                  )
+                end
+              end
+            end
+
+            # @deprecated Use {:allocation_enabled} (outside of advanced section) instead.
+            option :experimental_allocation_enabled do |o|
+              o.type :bool
+              o.default false
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.experimental_allocation_enabled setting has been deprecated for removal and ' \
+                    'no longer does anything. Please remove it from your Datadog.configure block. ' \
+                    'Allocation profiling is now controlled by the profiling.allocation_enabled setting instead.'
+                  )
+                end
+              end
+            end
+
+            # Can be used to enable/disable the collection of heap profiles.
+            #
+            # This feature is alpha and disabled by default
+            #
+            # @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.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.
+            #
+            # @warn To enable heap size profiling you are required to also enable allocation and heap profiling.
+            #
+            # @default `DD_PROFILING_EXPERIMENTAL_HEAP_SIZE_ENABLED` environment variable as a boolean, otherwise
+            # whatever the value of DD_PROFILING_EXPERIMENTAL_HEAP_ENABLED is.
+            option :experimental_heap_size_enabled do |o|
+              o.type :bool
+              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 allocation sampling rate: a sample will be collected every x allocations.
+            #
+            # This feature is now controlled via {:overhead_target_percentage}
+            option :experimental_allocation_sample_rate do |o|
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.experimental_allocation_sample_rate setting has been deprecated for removal ' \
+                    'and no longer does anything. Please remove it from your Datadog.configure block. ' \
+                    'Allocation sample rate is now handled by a dynamic sampler which will adjust the sampling rate to ' \
+                    'keep to the configured `profiling.advanced.overhead_target_percentage`.'
+                  )
+                end
+              end
+            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 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`.
+            option :experimental_heap_sample_rate do |o|
+              o.type :int
+              o.env 'DD_PROFILING_EXPERIMENTAL_HEAP_SAMPLE_RATE'
+              o.default 10
+            end
+
+            # Can be used to disable checking which version of `libmysqlclient` is being used by the `mysql2` gem.
+            #
+            # This setting is only used when the `mysql2` gem is installed.
+            #
+            # @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.default false
+            end
+
+            # Enables data collection for the timeline feature. This is still experimental and not recommended yet.
+            #
+            # @default `DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED` environment variable as a boolean, otherwise `false`
+            option :experimental_timeline_enabled do |o|
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.experimental_timeline_enabled setting has been deprecated for removal ' \
+                    'and no longer does anything. Please remove it from your Datadog.configure block. ' \
+                    'The timeline feature counting is now controlled by the `timeline_enabled` setting instead.'
+                  )
+                end
+              end
+            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`
+            option :timeline_enabled do |o|
+              o.type :bool
+              o.env 'DD_PROFILING_TIMELINE_ENABLED'
+              o.default true
+            end
+
+            # The profiler gathers data by sending `SIGPROF` unix signals to Ruby application threads.
+            #
+            # Sending `SIGPROF` is a common profiling approach, and may cause system calls from native
+            # extensions/libraries to be interrupted with a system
+            # [EINTR error code.](https://man7.org/linux/man-pages/man7/signal.7.html#:~:text=Interruption%20of%20system%20calls%20and%20library%20functions%20by%20signal%20handlers)
+            # Rarely, native extensions or libraries called by them may have missing or incorrect error handling for the
+            # `EINTR` error code.
+            #
+            # The "no signals" workaround, when enabled, enables an alternative mode for the profiler where it does not
+            # send `SIGPROF` unix signals. The downside of this approach is that the profiler data will have lower
+            # quality.
+            #
+            # This workaround is automatically enabled when gems that are known to have issues handling
+            # `EINTR` error codes are detected. If you suspect you may be seeing an issue due to the profiler's use of
+            # signals, you can try manually enabling this mode as a fallback.
+            # Please also report these issues to us on <https://github.com/DataDog/dd-trace-rb/issues/new>, so we can
+            # work with the gem authors to fix them!
+            #
+            # @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.default :auto
+              o.env_parser do |value|
+                if value
+                  value = value.strip.downcase
+                  ['true', '1'].include?(value)
+                end
+              end
+            end
+
+            # Configures how much wall-time overhead the profiler targets. The profiler will dynamically adjust the
+            # interval between samples it takes so as to try and maintain the property that it spends no longer than
+            # this amount of wall-clock time profiling. For example, with the default value of 2%, the profiler will
+            # try and cause no more than 1.2 seconds per minute of overhead. Decreasing this value will reduce the
+            # accuracy of the data collected. Increasing will impact the application.
+            #
+            # We do not recommend tweaking this value.
+            #
+            # This value should be a percentage i.e. a number between 0 and 100, not 0 and 1.
+            #
+            # @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.default 2.0
+            end
+
+            # Controls how often the profiler reports data, in seconds. Cannot be lower than 60 seconds.
+            #
+            # We do not recommend tweaking this value.
+            #
+            # @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.default 60
             end
           end
 
           # @public_api
           settings :upload do
+            # Network timeout for reporting profiling data to Datadog.
+            #
+            # @default `DD_PROFILING_UPLOAD_TIMEOUT` environment variable, otherwise `30.0`
             option :timeout_seconds do |o|
-              o.setter { |value| value.nil? ? 30.0 : value.to_f }
-              o.default { env_to_float(Profiling::Ext::ENV_UPLOAD_TIMEOUT, 30.0) }
-              o.lazy
+              o.type :float
+              o.env Profiling::Ext::ENV_UPLOAD_TIMEOUT
+              o.default 30.0
             end
           end
         end
@@ -271,11 +554,12 @@ module Datadog
           # @default `DD_RUNTIME_METRICS_ENABLED` environment variable, otherwise `false`
           # @return [Boolean]
           option :enabled do |o|
-            o.default { env_to_bool(Core::Runtime::Ext::Metrics::ENV_ENABLED, false) }
-            o.lazy
+            o.env Core::Runtime::Ext::Metrics::ENV_ENABLED
+            o.default false
+            o.type :bool
           end
 
-          option :opts, default: ->(_i) { {} }, lazy: true
+          option :opts, default: {}, type: :hash
           option :statsd
         end
 
@@ -284,9 +568,12 @@ module Datadog
         # @default `DD_SERVICE` environment variable, otherwise the program name (e.g. `'ruby'`, `'rails'`, `'pry'`)
         # @return [String]
         option :service do |o|
+          # DEV-2.0: Remove this conversion for symbol.
+          o.setter { |v| v.to_s if v }
+
           # NOTE: service also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
-          o.default { ENV.fetch(Core::Environment::Ext::ENV_SERVICE, Core::Environment::Ext::FALLBACK_SERVICE_NAME) }
-          o.lazy
+          o.env Core::Environment::Ext::ENV_SERVICE
+          o.default Core::Environment::Ext::FALLBACK_SERVICE_NAME
 
           # 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
@@ -308,8 +595,8 @@ module Datadog
         # @default `DD_SITE` environment variable, otherwise `nil` which sends data to `app.datadoghq.com`
         # @return [String,nil]
         option :site do |o|
-          o.default { ENV.fetch(Core::Environment::Ext::ENV_SITE, nil) }
-          o.lazy
+          o.type :string, nilable: true
+          o.env Core::Environment::Ext::ENV_SITE
         end
 
         # Default tags
@@ -319,44 +606,57 @@ module Datadog
         # @default `DD_TAGS` environment variable (in the format `'tag1:value1,tag2:value2'`), otherwise `{}`
         # @return [Hash<String,String>]
         option :tags do |o|
-          o.default do
-            tags = {}
+          o.type :hash, nilable: true
+          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
 
-            # Parse tags from environment
-            env_to_list(Core::Environment::Ext::ENV_TAGS, comma_separated_only: false).each do |tag|
-              pair = tag.split(':')
-              tags[pair.first] = pair.last if pair.length == 2
+            values.compact!
+            values.each_with_object({}) do |tag, tags|
+              key, value = tag.split(':', 2)
+              tags[key] = value if value && !value.empty?
             end
+          end
+          o.setter do |new_value, old_value|
+            raw_tags = new_value || {}
 
-            # Override tags if defined
-            tags[Core::Environment::Ext::TAG_ENV] = env unless env.nil?
-            tags[Core::Environment::Ext::TAG_VERSION] = version unless version.nil?
+            env_value = env
+            version_value = version
+            service_name = service_without_fallback
 
-            tags
-          end
+            # Override tags if defined
+            raw_tags[Core::Environment::Ext::TAG_ENV] = env_value unless env_value.nil?
+            raw_tags[Core::Environment::Ext::TAG_VERSION] = version_value unless version_value.nil?
 
-          o.setter do |new_value, old_value|
             # Coerce keys to strings
-            string_tags = new_value.collect { |k, v| [k.to_s, v] }.to_h
+            string_tags = raw_tags.collect { |k, v| [k.to_s, v] }.to_h
 
             # Cross-populate tag values with other settings
-            if env.nil? && string_tags.key?(Core::Environment::Ext::TAG_ENV)
+            if env_value.nil? && string_tags.key?(Core::Environment::Ext::TAG_ENV)
               self.env = string_tags[Core::Environment::Ext::TAG_ENV]
             end
 
-            if version.nil? && string_tags.key?(Core::Environment::Ext::TAG_VERSION)
+            if version_value.nil? && string_tags.key?(Core::Environment::Ext::TAG_VERSION)
               self.version = string_tags[Core::Environment::Ext::TAG_VERSION]
             end
 
-            if service_without_fallback.nil? && string_tags.key?(Core::Environment::Ext::TAG_SERVICE)
+            if service_name.nil? && string_tags.key?(Core::Environment::Ext::TAG_SERVICE)
               self.service = string_tags[Core::Environment::Ext::TAG_SERVICE]
             end
 
             # Merge with previous tags
             (old_value || {}).merge(string_tags)
           end
-
-          o.lazy
         end
 
         # The time provider used by Datadog. It must respect the interface of [Time](https://ruby-doc.org/core-3.0.1/Time.html).
@@ -369,9 +669,10 @@ module Datadog
         # @default `->{ Time.now }`
         # @return [Proc<Time>]
         option :time_now_provider do |o|
-          o.default { ::Time.now }
+          o.default_proc { ::Time.now }
+          o.type :proc
 
-          o.on_set do |time_provider|
+          o.after_set do |time_provider|
             Core::Utils::Time.now_provider = time_provider
           end
 
@@ -384,269 +685,164 @@ module Datadog
           end
         end
 
-        # Tracer specific configurations.
+        # The `version` tag in Datadog. Use it to enable [Deployment Tracking](https://docs.datadoghq.com/tracing/deployment_tracking/).
+        # @see https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging
+        # @default `DD_VERSION` environment variable, otherwise `nils`
+        # @return [String,nil]
+        option :version do |o|
+          # NOTE: version also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
+          o.type :string, nilable: true
+          o.env Core::Environment::Ext::ENV_VERSION
+        end
+
+        # Client-side telemetry configuration
         # @public_api
-        settings :tracing do
-          # Legacy [App Analytics](https://docs.datadoghq.com/tracing/legacy_app_analytics/) configuration.
+        settings :telemetry do
+          # Whether the bundled Ruby gems as reported through telemetry.
           #
-          # @configure_with {Datadog::Tracing}
-          # @deprecated Use [Trace Retention and Ingestion](https://docs.datadoghq.com/tracing/trace_retention_and_ingestion/)
-          #   controls.
-          # @public_api
-          settings :analytics do
-            # @default `DD_TRACE_ANALYTICS_ENABLED` environment variable, otherwise `nil`
-            # @return [Boolean,nil]
-            option :enabled do |o|
-              o.default { env_to_bool(Tracing::Configuration::Ext::Analytics::ENV_TRACE_ANALYTICS_ENABLED, nil) }
-              o.lazy
-            end
+          # @default `DD_TELEMETRY_DEPENDENCY_COLLECTION_ENABLED` environment variable, otherwise `true`.
+          # @return [Boolean]
+          option :dependency_collection do |o|
+            o.type :bool
+            o.env Core::Telemetry::Ext::ENV_DEPENDENCY_COLLECTION
+            o.default true
           end
 
-          # [Distributed Tracing](https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#distributed-tracing) propagation
-          # style configuration.
-          #
-          # The supported formats are:
-          # * `Datadog`: Datadog propagation format, described by [Distributed Tracing](https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#distributed-tracing).
-          # * `B3`: B3 Propagation using multiple headers, described by [openzipkin/b3-propagation](https://github.com/openzipkin/b3-propagation#multiple-headers).
-          # * `B3 single header`: B3 Propagation using a single header, described by [openzipkin/b3-propagation](https://github.com/openzipkin/b3-propagation#single-header).
+          # Enable telemetry collection. This allows telemetry events to be emitted to the telemetry API.
           #
-          # @public_api
-          settings :distributed_tracing do
-            # An ordered list of what data propagation styles the tracer will use to extract distributed tracing propagation
-            # data from incoming requests and messages.
-            #
-            # The tracer will try to find distributed headers in the order they are present in the list provided to this option.
-            # The first format to have valid data present will be used.
-            #
-            # @default `DD_PROPAGATION_STYLE_EXTRACT` environment variable (comma-separated list),
-            #   otherwise `['Datadog','B3','B3 single header']`.
-            # @return [Array<String>]
-            option :propagation_extract_style do |o|
-              o.default do
-                # Look for all headers by default
-                env_to_list(
-                  Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE_EXTRACT,
-                  [
-                    Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG,
-                    Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3,
-                    Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER
-                  ],
-                  comma_separated_only: true
-                )
-              end
-
-              o.lazy
-            end
-
-            # The data propagation styles the tracer will use to inject distributed tracing propagation
-            # data into outgoing requests and messages.
-            #
-            # The tracer will inject data from all styles specified in this option.
-            #
-            # @default `DD_PROPAGATION_STYLE_INJECT` environment variable (comma-separated list), otherwise `['Datadog']`.
-            # @return [Array<String>]
-            option :propagation_inject_style do |o|
-              o.default do
-                env_to_list(
-                  Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE_INJECT,
-                  [Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG],
-                  comma_separated_only: true # Only inject Datadog headers by default
-                )
+          # @default `DD_INSTRUMENTATION_TELEMETRY_ENABLED` environment variable, otherwise `true`.
+          #   Can be disabled as documented [here](https://docs.datadoghq.com/tracing/configure_data_security/#telemetry-collection).
+          #   By default, telemetry is disabled in development environments.
+          # @return [Boolean]
+          option :enabled do |o|
+            o.env Core::Telemetry::Ext::ENV_ENABLED
+            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.'
+                end
+                false
+              else
+                true
               end
-
-              o.lazy
             end
+            o.type :bool
           end
 
-          # Enable trace collection and span generation.
+          # The interval in seconds when telemetry must be sent.
           #
-          # You can use this option to disable tracing without having to
-          # remove the library as a whole.
+          # This method is used internally, for testing purposes only.
           #
-          # @default `DD_TRACE_ENABLED` environment variable, otherwise `true`
-          # @return [Boolean]
-          option :enabled do |o|
-            o.default { env_to_bool(Datadog::Core::Diagnostics::Ext::DD_TRACE_ENABLED, true) }
-            o.lazy
+          # @default `DD_TELEMETRY_HEARTBEAT_INTERVAL` environment variable, otherwise `60`.
+          # @return [Float]
+          # @!visibility private
+          option :heartbeat_interval_seconds do |o|
+            o.type :float
+            o.env Core::Telemetry::Ext::ENV_HEARTBEAT_INTERVAL
+            o.default 60.0
           end
 
-          # A custom tracer instance.
-          #
-          # It must respect the contract of {Datadog::Tracing::Tracer}.
-          # It's recommended to delegate methods to {Datadog::Tracing::Tracer} to ease the implementation
-          # of a custom tracer.
+          # The install id of the application.
           #
-          # This option will not return the live tracer instance: it only holds a custom tracing instance, if any.
+          # This method is used internally, by library injection.
           #
-          # For internal use only.
-          #
-          # @default `nil`
-          # @return [Object,nil]
-          option :instance
-
-          # Automatic correlation between tracing and logging.
-          # @see https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#trace-correlation
-          # @return [Boolean]
-          option :log_injection do |o|
-            o.default { env_to_bool(Tracing::Configuration::Ext::Correlation::ENV_LOGS_INJECTION_ENABLED, true) }
-            o.lazy
+          # @default `DD_INSTRUMENTATION_INSTALL_ID` environment variable, otherwise `nil`.
+          # @return [String,nil]
+          # @!visibility private
+          option :install_id do |o|
+            o.type :string, nilable: true
+            o.env Core::Telemetry::Ext::ENV_INSTALL_ID
           end
 
-          # Configures an alternative trace transport behavior, where
-          # traces can be sent to the agent and backend before all spans
-          # have finished.
+          # The install type of the application.
           #
-          # This is useful for long-running jobs or very large traces.
+          # This method is used internally, by library injection.
           #
-          # The trace flame graph will display the partial trace as it is received and constantly
-          # update with new spans as they are flushed.
-          # @public_api
-          settings :partial_flush do
-            # Enable partial trace flushing.
-            #
-            # @default `false`
-            # @return [Boolean]
-            option :enabled, default: false
-
-            # Minimum number of finished spans required in a single unfinished trace before
-            # the tracer will consider that trace for partial flushing.
-            #
-            # This option helps preserve a minimum amount of batching in the
-            # flushing process, reducing network overhead.
-            #
-            # This threshold only applies to unfinished traces. Traces that have finished
-            # are always flushed immediately.
-            #
-            # @default 500
-            # @return [Integer]
-            option :min_spans_threshold, default: 500
+          # @default `DD_INSTRUMENTATION_INSTALL_TYPE` environment variable, otherwise `nil`.
+          # @return [String,nil]
+          # @!visibility private
+          option :install_type do |o|
+            o.type :string, nilable: true
+            o.env Core::Telemetry::Ext::ENV_INSTALL_TYPE
           end
 
-          # Enables {https://docs.datadoghq.com/tracing/trace_retention_and_ingestion/#datadog-intelligent-retention-filter
-          # Datadog intelligent retention filter}.
-          # @default `true`
-          # @return [Boolean,nil]
-          option :priority_sampling
-
-          option :report_hostname do |o|
-            o.default { env_to_bool(Tracing::Configuration::Ext::NET::ENV_REPORT_HOSTNAME, false) }
-            o.lazy
+          # The install time of the application.
+          #
+          # This method is used internally, by library injection.
+          #
+          # @default `DD_INSTRUMENTATION_INSTALL_TIME` environment variable, otherwise `nil`.
+          # @return [String,nil]
+          # @!visibility private
+          option :install_time do |o|
+            o.type :string, nilable: true
+            o.env Core::Telemetry::Ext::ENV_INSTALL_TIME
           end
+        end
 
-          # A custom sampler instance.
-          # The object must respect the {Datadog::Tracing::Sampling::Sampler} interface.
-          # @default `nil`
-          # @return [Object,nil]
-          option :sampler
-
-          # Client-side sampling configuration.
-          # @public_api
-          settings :sampling do
-            # Default sampling rate for the tracer.
-            #
-            # If `nil`, the trace uses an automatic sampling strategy that tries to ensure
-            # the collection of traces that are considered important (e.g. traces with an error, traces
-            # for resources not seen recently).
-            #
-            # @default `DD_TRACE_SAMPLE_RATE` environment variable, otherwise `nil`.
-            # @return [Float,nil]
-            option :default_rate do |o|
-              o.default { env_to_float(Tracing::Configuration::Ext::Sampling::ENV_SAMPLE_RATE, nil) }
-              o.lazy
-            end
-
-            # Rate limit for number of spans per second.
-            #
-            # Spans created above the limit will contribute to service metrics, but won't
-            # have their payload stored.
-            #
-            # @default `DD_TRACE_RATE_LIMIT` environment variable, otherwise 100.
-            # @return [Numeric,nil]
-            option :rate_limit do |o|
-              o.default { env_to_float(Tracing::Configuration::Ext::Sampling::ENV_RATE_LIMIT, 100) }
-              o.lazy
+        # Remote configuration
+        # @public_api
+        settings :remote do
+          # Enable remote configuration. This allows fetching of remote configuration for live updates.
+          #
+          # @default `DD_REMOTE_CONFIGURATION_ENABLED` environment variable, otherwise `true`.
+          #   By default, remote configuration is disabled in development environments.
+          # @return [Boolean]
+          option :enabled do |o|
+            o.env Core::Remote::Ext::ENV_ENABLED
+            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.'
+                end
+                false
+              else
+                true
+              end
             end
+            o.type :bool
           end
 
-          # [Continuous Integration Visibility](https://docs.datadoghq.com/continuous_integration/) configuration.
-          # @public_api
-          settings :test_mode do
-            # Enable test mode. This allows the tracer to collect spans from test runs.
-            #
-            # It also prevents the tracer from collecting spans in a production environment. Only use in a test environment.
-            #
-            # @default `DD_TRACE_TEST_MODE_ENABLED` environment variable, otherwise `false`
-            # @return [Boolean]
-            option :enabled do |o|
-              o.default { env_to_bool(Tracing::Configuration::Ext::Test::ENV_MODE_ENABLED, false) }
-              o.lazy
-            end
-
-            option :trace_flush do |o|
-              o.default { nil }
-              o.lazy
-            end
-
-            option :writer_options do |o|
-              o.default { {} }
-              o.lazy
-            end
+          # Tune remote configuration polling interval.
+          # This is a private setting. Do not use outside of Datadog. It might change at any point in time.
+          #
+          # @default `DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS` environment variable, otherwise `5.0` seconds.
+          # @return [Float]
+          # @!visibility private
+          option :poll_interval_seconds do |o|
+            o.env Core::Remote::Ext::ENV_POLL_INTERVAL_SECONDS
+            o.type :float
+            o.default 5.0
           end
 
-          # @see file:docs/GettingStarted.md#configuring-the-transport-layer Configuring the transport layer
-          #
-          # A {Proc} that configures a custom tracer transport.
-          # @yield Receives a {Datadog::Transport::HTTP} that can be modified with custom adapters and settings.
-          # @yieldparam [Datadog::Transport::HTTP] t transport to be configured.
-          # @default `nil`
-          # @return [Proc,nil]
-          option :transport_options, default: nil
-
-          # A custom writer instance.
-          # The object must respect the {Datadog::Tracing::Writer} interface.
+          # Tune remote configuration boot timeout.
+          # Early operations such as requests are blocked until RC is ready. In
+          # order to not block the application indefinitely a timeout is
+          # enforced allowing requests to proceed with the local configuration.
           #
-          # This option is recommended for internal use only.
-          #
-          # @default `nil`
-          # @return [Object,nil]
-          option :writer
+          # @default `DD_REMOTE_CONFIG_BOOT_TIMEOUT` environment variable, otherwise `1.0` seconds.
+          # @return [Float]
+          option :boot_timeout_seconds do |o|
+            o.env Core::Remote::Ext::ENV_BOOT_TIMEOUT_SECONDS
+            o.type :float
+            o.default 1.0
+          end
 
-          # A custom {Hash} with keyword options to be passed to {Datadog::Tracing::Writer#initialize}.
-          #
-          # This option is recommended for internal use only.
+          # Declare service name to bind to remote configuration. Use when
+          # DD_SERVICE does not match the correct integration for which remote
+          # configuration applies.
           #
-          # @default `{}`
-          # @return [Hash,nil]
-          option :writer_options, default: ->(_i) { {} }, lazy: true
-        end
-
-        # The `version` tag in Datadog. Use it to enable [Deployment Tracking](https://docs.datadoghq.com/tracing/deployment_tracking/).
-        # @see https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging
-        # @default `DD_VERSION` environment variable, otherwise `nils`
-        # @return [String,nil]
-        option :version do |o|
-          # NOTE: version also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
-          o.default { ENV.fetch(Core::Environment::Ext::ENV_VERSION, nil) }
-          o.lazy
+          # @default `nil`.
+          # @return [String,nil]
+          option :service
         end
 
-        # Client-side telemetry configuration
-        # @public_api
-        settings :telemetry do
-          # Enable telemetry collection. This allows telemetry events to be emitted to the telemetry API.
-          #
-          # @default `DD_INSTRUMENTATION_TELEMETRY_ENABLED` environment variable, otherwise `false`. In a future release,
-          #   this value will be changed to `true` by default as documented [here](https://docs.datadoghq.com/tracing/configure_data_security/#telemetry-collection).
-          # @return [Boolean]
-          option :enabled do |o|
-            o.default { env_to_bool(Core::Telemetry::Ext::ENV_ENABLED, false) }
-            o.lazy
-          end
-        end
+        # TODO: Tracing should manage its own settings.
+        #       Keep this extension here for now to keep things working.
+        extend Datadog::Tracing::Configuration::Settings
       end
       # rubocop:enable Metrics/BlockLength
-      # rubocop:enable Metrics/ClassLength
-      # rubocop:enable Layout/LineLength
     end
   end
 end