datadog 2.30.0 → 2.45.0

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'supported_configurations'
-require_relative '../logger'
-require_relative '../utils/only_once'
+require_relative "supported_configurations"
+require_relative "../logger"
+require_relative "../utils/only_once"
 
 module Datadog
   module Core
@@ -12,11 +12,11 @@ module Datadog
 
         def self.log_deprecations_from_all_sources(logger, deprecations: DEPRECATIONS, alias_to_canonical: ALIAS_TO_CANONICAL)
           LOG_DEPRECATIONS_ONLY_ONCE.run do
-            log_deprecated_environment_variables(logger, ENV, 'environment', deprecations, alias_to_canonical)
+            log_deprecated_environment_variables(logger, ENV, "environment", deprecations, alias_to_canonical)
             customer_config = StableConfig.configuration.dig(:local, :config)
-            log_deprecated_environment_variables(logger, customer_config, 'local', deprecations, alias_to_canonical) if customer_config
+            log_deprecated_environment_variables(logger, customer_config, "local", deprecations, alias_to_canonical) if customer_config
             fleet_config = StableConfig.configuration.dig(:fleet, :config)
-            log_deprecated_environment_variables(logger, fleet_config, 'fleet', deprecations, alias_to_canonical) if fleet_config
+            log_deprecated_environment_variables(logger, fleet_config, "fleet", deprecations, alias_to_canonical) if fleet_config
           end
         end
 

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

@@ -8,29 +8,29 @@ module Datadog
       module Ext
         # @public_api
         module Diagnostics
-          ENV_DEBUG_ENABLED = 'DD_TRACE_DEBUG'
-          ENV_HEALTH_METRICS_ENABLED = 'DD_HEALTH_METRICS_ENABLED'
-          ENV_STARTUP_LOGS_ENABLED = 'DD_TRACE_STARTUP_LOGS'
+          ENV_DEBUG_ENABLED = "DD_TRACE_DEBUG"
+          ENV_HEALTH_METRICS_ENABLED = "DD_HEALTH_METRICS_ENABLED"
+          ENV_STARTUP_LOGS_ENABLED = "DD_TRACE_STARTUP_LOGS"
         end
 
         module Metrics
-          ENV_DEFAULT_PORT = 'DD_METRIC_AGENT_PORT'
+          ENV_DEFAULT_PORT = "DD_METRIC_AGENT_PORT"
         end
 
         module APM
-          ENV_TRACING_ENABLED = 'DD_APM_TRACING_ENABLED'
+          ENV_TRACING_ENABLED = "DD_APM_TRACING_ENABLED"
         end
 
         module Agent
-          ENV_DEFAULT_HOST = 'DD_AGENT_HOST'
+          ENV_DEFAULT_HOST = "DD_AGENT_HOST"
           # Some env vars have "trace" in them, but they apply to all products
-          ENV_DEFAULT_PORT = 'DD_TRACE_AGENT_PORT'
-          ENV_DEFAULT_TIMEOUT_SECONDS = 'DD_TRACE_AGENT_TIMEOUT_SECONDS'
-          ENV_DEFAULT_URL = 'DD_TRACE_AGENT_URL'
+          ENV_DEFAULT_PORT = "DD_TRACE_AGENT_PORT"
+          ENV_DEFAULT_TIMEOUT_SECONDS = "DD_TRACE_AGENT_TIMEOUT_SECONDS"
+          ENV_DEFAULT_URL = "DD_TRACE_AGENT_URL"
 
           module HTTP
             ADAPTER = :net_http
-            DEFAULT_HOST = '127.0.0.1'
+            DEFAULT_HOST = "127.0.0.1"
             DEFAULT_PORT = 8126
             DEFAULT_USE_SSL = false
             DEFAULT_TIMEOUT_SECONDS = 30
@@ -39,7 +39,7 @@ module Datadog
           # @public_api
           module UnixSocket
             ADAPTER = :unix
-            DEFAULT_PATH = '/var/run/datadog/apm.socket'
+            DEFAULT_PATH = "/var/run/datadog/apm.socket"
             DEFAULT_TIMEOUT_SECONDS = 30
           end
         end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'stable_config'
-require_relative '../utils/safe_dup'
+require_relative "stable_config"
+require_relative "../utils/safe_dup"
 
 module Datadog
   module Core
@@ -42,22 +42,22 @@ module Datadog
           end
 
           # Remote configuration provided through the Datadog app.
-          REMOTE_CONFIGURATION = Value.new(5, :remote_configuration, 'remote_config').freeze
+          REMOTE_CONFIGURATION = Value.new(5, :remote_configuration, "remote_config").freeze
 
           # Configuration provided in Ruby code, in this same process
-          PROGRAMMATIC = Value.new(4, :programmatic, 'code').freeze
+          PROGRAMMATIC = Value.new(4, :programmatic, "code").freeze
 
           # Configuration provided by fleet managed stable config
-          FLEET_STABLE = Value.new(3, :fleet_stable, 'fleet_stable_config').freeze
+          FLEET_STABLE = Value.new(3, :fleet_stable, "fleet_stable_config").freeze
 
           # Configuration provided via environment variable
-          ENVIRONMENT = Value.new(2, :environment, 'env_var').freeze
+          ENVIRONMENT = Value.new(2, :environment, "env_var").freeze
 
           # Configuration provided by local stable config file
-          LOCAL_STABLE = Value.new(1, :local_stable, 'local_stable_config').freeze
+          LOCAL_STABLE = Value.new(1, :local_stable, "local_stable_config").freeze
 
           # Configuration that comes from default values
-          DEFAULT = Value.new(0, :default, 'default').freeze
+          DEFAULT = Value.new(0, :default, "default").freeze
 
           # All precedences, sorted from highest to lowest
           LIST = [REMOTE_CONFIGURATION, PROGRAMMATIC, FLEET_STABLE, ENVIRONMENT, LOCAL_STABLE, DEFAULT].sort.reverse.freeze
@@ -77,6 +77,16 @@ module Datadog
           @precedence_set = Precedence::DEFAULT
         end
 
+        # Computes the name of the option with the settings path.
+        # E.g. "tracing.rails.middleware_names" for the "middleware_names" option in the "tracing.rails" settings.
+        # @return [String] the name of the option with the settings path
+        def name_with_settings_path
+          @name_with_settings_path ||= begin
+            settings_path = @context.class.settings_path
+            settings_path.nil? ? definition.name.to_s : "#{settings_path}.#{definition.name}"
+          end
+        end
+
         # Overrides the current value for this option if the `precedence` is equal or higher than
         # the previously set value.
         # The first call to `#set` will always store the value regardless of precedence.
@@ -89,7 +99,7 @@ module Datadog
             # This should be uncommon, as higher precedence values tend to
             # happen later in the application lifecycle.
             Datadog.logger.info do
-              "Option '#{definition.name}' not changed to '#{value}' (precedence: #{precedence.name}) because the higher " \
+              "Option '#{name_with_settings_path}' not changed to '#{value}' (precedence: #{precedence.name}) because the higher " \
                 "precedence value '#{@value}' (precedence: #{@precedence_set.name}) was already set."
             end
 
@@ -178,6 +188,21 @@ module Datadog
           precedence_set == Precedence::DEFAULT
         end
 
+        def settings?
+          @definition.is_settings
+        end
+
+        def values_per_precedence
+          # value_per_precedence is only filled after we call `get` once.
+          get unless @is_set
+
+          @value_per_precedence.each_with_object({}) do |(precedence, value), result|
+            next if value.equal?(UNSET)
+
+            result[precedence] = value
+          end
+        end
+
         private
 
         def coerce_env_variable(value)
@@ -186,13 +211,13 @@ module Datadog
 
           case @definition.type
           when :hash
-            values = value.split(',') # By default we only want to support comma separated strings
+            values = value.split(",") # By default we only want to support comma separated strings
 
             values.each_with_object({}) do |v, hash| # $ Hash[String, String]
-              v.gsub!(/\A[\s,]*+|[\s,]*+\Z/, '')
+              v.gsub!(/\A[\s,]*+|[\s,]*+\Z/, "")
               next if v.empty?
 
-              pair = v.split(':', 2)
+              pair = v.split(":", 2)
               hash[pair[0]] = pair[1]
             end
           when :int
@@ -200,10 +225,10 @@ module Datadog
           when :float
             Float(value)
           when :array
-            values = value.split(',')
+            values = value.split(",")
 
             values.each_with_object([]) do |v, arr| # $ Array[String]
-              v.gsub!(/\A[\s,]*+|[\s,]*+\Z/, '')
+              v.gsub!(/\A[\s,]*+|[\s,]*+\Z/, "")
               next if v.empty?
 
               arr << v
@@ -211,12 +236,12 @@ module Datadog
           when :bool
             string_value = value.strip
             string_value = string_value.downcase
-            string_value == 'true' || string_value == '1'
+            string_value == "true" || string_value == "1"
           when :string, NilClass
             value
           else
             raise InvalidDefinitionError,
-              "The option #{@definition.name} is using an unsupported type option for env coercion `#{@definition.type}`"
+              "The option #{name_with_settings_path} is using an unsupported type option for env coercion `#{@definition.type}`"
           end
         end
 
@@ -239,10 +264,10 @@ module Datadog
 
           if raise_error
             error_msg = if @definition.type_options[:nilable]
-              "The setting `#{@definition.name}` inside your app's `Datadog.configure` block expects a " \
+              "The setting `#{name_with_settings_path}` inside your app's `Datadog.configure` block expects a " \
               "#{@definition.type} or `nil`, but a `#{value.class}` was provided (#{value.inspect})." \
             else
-              "The setting `#{@definition.name}` inside your app's `Datadog.configure` block expects a " \
+              "The setting `#{name_with_settings_path}` inside your app's `Datadog.configure` block expects a " \
               "#{@definition.type}, but a `#{value.class}` was provided (#{value.inspect})." \
             end
 
@@ -276,7 +301,7 @@ module Datadog
             true # No validation is performed when option is typeless
           else
             raise InvalidDefinitionError,
-              "The option #{@definition.name} is using an unsupported type option `#{@definition.type}`"
+              "The option #{name_with_settings_path} is using an unsupported type option `#{@definition.type}`"
           end
         end
 
@@ -315,7 +340,7 @@ module Datadog
           customer_config = StableConfig.configuration.dig(:local, :config)
           return if customer_config.nil?
 
-          value = get_value_from(customer_config, 'local')
+          value = get_value_from(customer_config, "local")
           set(value, precedence: Precedence::LOCAL_STABLE) unless value.nil?
         end
 
@@ -323,7 +348,7 @@ module Datadog
           fleet_config = StableConfig.configuration.dig(:fleet, :config)
           return if fleet_config.nil?
 
-          value = get_value_from(fleet_config, 'fleet')
+          value = get_value_from(fleet_config, "fleet")
           set(value, precedence: Precedence::FLEET_STABLE) unless value.nil?
         end
 

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'option'
+require_relative "option"
 
 module Datadog
   module Core
@@ -10,28 +10,36 @@ module Datadog
         IDENTITY = ->(new_value, _old_value) { new_value }
 
         attr_reader \
+          :is_settings,
           :default,
           :default_proc,
           :env,
           :env_parser,
           :name,
           :after_set,
+          :skip_telemetry,
           :resetter,
           :setter,
           :type,
           :type_options
 
-        def initialize(name, meta, &block)
-          @default = meta[:default]
-          @default_proc = meta[:default_proc]
-          @env = meta[:env]
-          @env_parser = meta[:env_parser]
+        def initialize(name, attributes, &block)
+          # When a settings is defined using the config DSL, an option is also created.
+          # See Datadog::Core::Configuration::Base::ClassMethods#settings for more details.
+          # This flag is used to indicate that the option is a settings option.
+          @is_settings = attributes[:is_settings]
+
+          @default = attributes[:default]
+          @default_proc = attributes[:default_proc]
+          @env = attributes[:env]
+          @env_parser = attributes[:env_parser]
           @name = name.to_sym
-          @after_set = meta[:after_set]
-          @resetter = meta[:resetter]
-          @setter = meta[:setter] || block || IDENTITY
-          @type = meta[:type]
-          @type_options = meta[:type_options]
+          @after_set = attributes[:after_set]
+          @skip_telemetry = attributes[:skip_telemetry]
+          @resetter = attributes[:resetter]
+          @setter = attributes[:setter] || block || IDENTITY
+          @type = attributes[:type]
+          @type_options = attributes[:type_options]
         end
 
         # Creates a new Option, bound to the context provided.
@@ -49,6 +57,8 @@ module Datadog
             :helpers
 
           def initialize(name, options = {})
+            @is_settings = options.fetch(:is_settings, false)
+
             @env = nil
             @env_parser = nil
             @default = nil
@@ -56,6 +66,7 @@ module Datadog
             @helpers = {}
             @name = name.to_sym
             @after_set = nil
+            @skip_telemetry = false
             @resetter = nil
             @setter = OptionDefinition::IDENTITY
             @type = nil
@@ -95,6 +106,16 @@ module Datadog
             @after_set = block
           end
 
+          # This should only be set to true for options that are manually modified
+          # before being added to the telemetry payload in app_started.rb.
+          # E.g. telemetry is skipped for `tracing.writer_options`, but in app_started.rb,
+          # we send two separate entries for the buffer_size and flush_interval values.
+          # Standard: We want to keep this method as skip_telemetry(value),
+          # not skip_telemetry = value, so attr_writer is not used.
+          def skip_telemetry(value) # standard:disable Style/TrivialAccessors
+            @skip_telemetry = value
+          end
+
           def resetter(&block)
             @resetter = block
           end
@@ -119,6 +140,8 @@ module Datadog
             env(options[:env]) if options.key?(:env)
             env_parser(&options[:env_parser]) if options.key?(:env_parser)
             after_set(&options[:after_set]) if options.key?(:after_set)
+            # Steep: https://github.com/soutaro/steep/issues/1979
+            skip_telemetry(options[:skip_telemetry]) if options.key?(:skip_telemetry) # steep:ignore ArgumentTypeMismatch
             resetter(&options[:resetter]) if options.key?(:resetter)
             # Steep: https://github.com/soutaro/steep/issues/1979
             setter(&options[:setter]) if options.key?(:setter) # steep:ignore BlockTypeMismatch
@@ -126,20 +149,23 @@ module Datadog
           end
 
           def to_definition
-            OptionDefinition.new(@name, meta)
+            OptionDefinition.new(@name, attributes)
           end
 
-          def meta
+          def attributes
             {
+              is_settings: @is_settings,
+
               default: @default,
               default_proc: @default_proc,
               env: @env,
               env_parser: @env_parser,
               after_set: @after_set,
+              skip_telemetry: @skip_telemetry,
               resetter: @resetter,
               setter: @setter,
               type: @type,
-              type_options: @type_options
+              type_options: @type_options,
             }
           end
 
@@ -148,9 +174,9 @@ module Datadog
           def validate_options!
             if !@default.nil? && @default_proc
               raise InvalidOptionError,
-                'Using `default` and `default_proc` is not allowed. Please use one or the other.' \
-                                'If you want to store a block as the default value use `default_proc`' \
-                                ' otherwise use `default`'
+                "Using `default` and `default_proc` is not allowed. Please use one or the other." \
+                                "If you want to store a block as the default value use `default_proc`" \
+                                " otherwise use `default`"
             end
           end
         end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'option_definition'
+require_relative "option_definition"
 
 module Datadog
   module Core
@@ -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)
@@ -54,7 +84,7 @@ module Datadog
             end
             {
               option_name.to_sym => opt_getter,
-              :"#{option_name}=" => opt_setter
+              :"#{option_name}=" => opt_setter,
             }
           end
 
@@ -75,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)