datadog 2.21.0 → 2.38.0

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

@@ -16,17 +16,47 @@ module Datadog
         # Class behavior for a configuration object with options
         # @public_api
         module ClassMethods
+          def settings_path
+            defined?(@settings_path) ? @settings_path : nil
+          end
+
+          # Registry of nested settings classes keyed by the option name declared
+          # via `Base.settings`. This lets us propagate a new settings path down the
+          # tree without storing parent references on the nested class or on the
+          # option definition itself.
+          def settings_children
+            @settings_children ||= if superclass <= Options
+              superclass.settings_children.dup
+            else
+              {}
+            end
+          end
+
+          def settings_path=(path)
+            @settings_path = path
+
+            # Keep nested settings paths in sync when a parent settings path is
+            # assigned later, which is how contrib integrations inject
+            # "tracing.<integration>" into their configuration classes.
+            settings_children.each do |name, settings_class|
+              nested_settings_path = path ? "#{path}.#{name}" : name.to_s
+              settings_class.settings_path = nested_settings_path
+            end
+          end
+
           def options
             # Allows for class inheritance of option definitions
-            @options ||= (superclass <= Options) ? superclass.options.dup : {}
+            @options ||= if superclass <= Options
+              superclass.options.dup
+            else
+              {}
+            end
           end
 
           protected
 
-          def option(name, meta = {}, &block)
-            settings_name = defined?(@settings_name) && @settings_name
-            option_name = settings_name ? "#{settings_name}.#{name}" : name
-            builder = OptionDefinition::Builder.new(option_name, meta, &block)
+          def option(name, attributes = {}, &block)
+            builder = OptionDefinition::Builder.new(name, attributes, &block)
             options[name] = builder.to_definition.tap do
               # Resolve and define helper functions
               helpers = default_helpers(name)
@@ -40,14 +70,16 @@ module Datadog
 
           def default_helpers(name)
             option_name = name.to_sym
-            # @type var opt_getter: Configuration::OptionDefinition::helper_proc
-            opt_getter = proc do
+            # Steep: https://github.com/soutaro/steep/issues/335
+            # @type var opt_getter: Configuration::OptionDefinition::generic_proc
+            opt_getter = proc do # steep:ignore IncompatibleAssignment
               # These Procs uses `get/set_option`, but we only add them to the OptionDefinition helpers here.
               # Steep is right that these methods are not defined, but we only run these Procs in instance context.
               get_option(option_name) # steep:ignore NoMethod
             end
-            # @type var opt_setter: Configuration::OptionDefinition::helper_proc
-            opt_setter = proc do |value|
+            # Steep: https://github.com/soutaro/steep/issues/335
+            # @type var opt_setter: Configuration::OptionDefinition::generic_proc
+            opt_setter = proc do |value| # steep:ignore IncompatibleAssignment
               set_option(option_name, value) # steep:ignore NoMethod
             end
             {
@@ -73,7 +105,11 @@ module Datadog
           end
 
           def set_option(name, value, precedence: Configuration::Option::Precedence::PROGRAMMATIC)
-            resolve_option(name).set(value, precedence: precedence)
+            option = resolve_option(name)
+            # Populate lower-precedence values so telemetry and `unset` can
+            # still observe the fallback chain after a first programmatic set.
+            option.get
+            option.set(value, precedence: precedence)
           end
 
           def unset_option(name, precedence: Configuration::Option::Precedence::PROGRAMMATIC)
@@ -118,7 +154,7 @@ module Datadog
 
             assert_valid_option!(name)
             definition = self.class.options[name]
-            # @type self: Configuration::Options::GenericSettingsClass
+            # @type self: Configuration::Options::_Settings
             options[name] = definition.build(self)
           end
 
@@ -127,7 +163,8 @@ module Datadog
           end
         end
 
-        InvalidOptionError = Class.new(StandardError)
+        # Steep: https://github.com/soutaro/steep/issues/1880
+        InvalidOptionError = Class.new(StandardError) # steep:ignore IncompatibleAssignment
       end
     end
   end

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

@@ -6,12 +6,14 @@ 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 '../../opentelemetry/configuration/settings'
 
 module Datadog
   module Core
@@ -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.
@@ -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,6 +233,8 @@ 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
 
@@ -292,9 +321,6 @@ 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
@@ -368,16 +394,19 @@ module Datadog
               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.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.
@@ -424,6 +453,23 @@ module Datadog
               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
+
             # 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
@@ -571,10 +617,33 @@ module Datadog
               o.type :bool
               o.env 'DD_PROFILING_SIGHANDLER_SAMPLING_ENABLED'
               o.default do
-                Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.2.5') &&
-                  !(RUBY_VERSION.start_with?('3.3.') && Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.3.4'))
+                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
 
           # @public_api
@@ -626,12 +695,16 @@ module Datadog
           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
 
@@ -751,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|
@@ -766,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
@@ -828,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|
@@ -858,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`.
           #
@@ -1003,6 +1090,16 @@ module Datadog
           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
@@ -1030,6 +1127,8 @@ module Datadog
         # 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
       # standard:enable Metrics/BlockLength
     end

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

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
+require_relative '../utils/only_once'
+
 module Datadog
   module Core
     module Configuration
       # Import config from config files (fleet automation)
       module StableConfig
+        LOG_ONLY_ONCE = Utils::OnlyOnce.new
+
         def self.extract_configuration
           if (libdatadog_api_failure = Datadog::Core::LIBDATADOG_API_FAILURE)
             Datadog.config_init_logger.debug("Cannot enable stable config: #{libdatadog_api_failure}")
@@ -16,6 +20,12 @@ module Datadog
         def self.configuration
           @configuration ||= StableConfig.extract_configuration
         end
+
+        def self.log_result(logger)
+          LOG_ONLY_ONCE.run do
+            logger.debug(configuration[:logs]) if configuration[:logs]
+          end
+        end
       end
     end
   end