datadog 2.12.0 → 2.22.0

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'supported_configurations'
+require_relative '../logger'
+require_relative '../utils/only_once'
+
+module Datadog
+  module Core
+    module Configuration
+      module Deprecations
+        LOG_DEPRECATIONS_ONLY_ONCE = Datadog::Core::Utils::OnlyOnce.new
+
+        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)
+            customer_config = StableConfig.configuration.dig(:local, :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
+          end
+        end
+
+        private_class_method def self.log_deprecated_environment_variables(logger, source_env, source_name, deprecations, alias_to_canonical)
+          deprecations.each do |deprecated_env_var, message|
+            next unless source_env.key?(deprecated_env_var)
+
+            Datadog::Core.log_deprecation(disallowed_next_major: false, logger: logger) do
+              "#{deprecated_env_var} #{source_name} variable is deprecated" +
+                (alias_to_canonical[deprecated_env_var] ? ", use #{alias_to_canonical[deprecated_env_var]} instead." : ". #{message}.")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,7 +9,6 @@ module Datadog
         # @public_api
         module Diagnostics
           ENV_DEBUG_ENABLED = 'DD_TRACE_DEBUG'
-          ENV_OTEL_LOG_LEVEL = 'OTEL_LOG_LEVEL'
           ENV_HEALTH_METRICS_ENABLED = 'DD_HEALTH_METRICS_ENABLED'
           ENV_STARTUP_LOGS_ENABLED = 'DD_TRACE_STARTUP_LOGS'
         end
@@ -18,6 +17,10 @@ module Datadog
           ENV_DEFAULT_PORT = 'DD_METRIC_AGENT_PORT'
         end
 
+        module APM
+          ENV_TRACING_ENABLED = 'DD_APM_TRACING_ENABLED'
+        end
+
         module Agent
           ENV_DEFAULT_HOST = 'DD_AGENT_HOST'
           # Some env vars have "trace" in them, but they apply to all products

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'stable_config'
 require_relative '../utils/safe_dup'
 
 module Datadog
@@ -14,16 +15,25 @@ module Datadog
         # @!attribute [r] precedence_set
         #   When this option was last set, what was the value precedence used?
         #   @return [Precedence::Value]
-        attr_reader :definition, :precedence_set, :resolved_env
+        attr_reader :definition, :precedence_set
 
         # Option setting precedence.
         module Precedence
           # Represents an Option precedence level.
           # Each precedence has a `numeric` value; higher values means higher precedence.
           # `name` is for inspection purposes only.
-          Value = Struct.new(:numeric, :name) do
+
+          class Value
             include Comparable
 
+            attr_accessor :numeric, :name, :origin
+
+            def initialize(numeric, name, origin)
+              @numeric = numeric
+              @name = name
+              @origin = origin
+            end
+
             def <=>(other)
               return nil unless other.is_a?(Value)
 
@@ -32,17 +42,25 @@ module Datadog
           end
 
           # Remote configuration provided through the Datadog app.
-          REMOTE_CONFIGURATION = Value.new(2, :remote_configuration).freeze
+          REMOTE_CONFIGURATION = Value.new(5, :remote_configuration, 'remote_config').freeze
 
           # Configuration provided in Ruby code, in this same process
-          # or via Environment variable
-          PROGRAMMATIC = Value.new(1, :programmatic).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
+
+          # Configuration provided via environment variable
+          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
 
           # Configuration that comes from default values
-          DEFAULT = Value.new(0, :default).freeze
+          DEFAULT = Value.new(0, :default, 'default').freeze
 
           # All precedences, sorted from highest to lowest
-          LIST = [REMOTE_CONFIGURATION, PROGRAMMATIC, DEFAULT].sort.reverse.freeze
+          LIST = [REMOTE_CONFIGURATION, PROGRAMMATIC, FLEET_STABLE, ENVIRONMENT, LOCAL_STABLE, DEFAULT].sort.reverse.freeze
         end
 
         def initialize(definition, context)
@@ -50,7 +68,6 @@ module Datadog
           @context = context
           @value = nil
           @is_set = false
-          @resolved_env = nil
 
           # One value is stored per precedence, to allow unsetting a higher
           # precedence value and falling back to a lower precedence one.
@@ -66,7 +83,7 @@ module Datadog
         #
         # @param value [Object] the new value to be associated with this option
         # @param precedence [Precedence] from what precedence order this new value comes from
-        def set(value, precedence: Precedence::PROGRAMMATIC, resolved_env: nil)
+        def set(value, precedence: Precedence::PROGRAMMATIC)
           # Is there a higher precedence value set?
           if @precedence_set > precedence
             # This should be uncommon, as higher precedence values tend to
@@ -85,7 +102,7 @@ module Datadog
             return @value
           end
 
-          internal_set(value, precedence, resolved_env)
+          internal_set(value, precedence)
         end
 
         def unset(precedence)
@@ -103,7 +120,7 @@ module Datadog
               # Look for value that is set.
               # The hash `@value_per_precedence` has a custom default value of `UNSET`.
               if (value = @value_per_precedence[p]) != UNSET
-                internal_set(value, p, nil)
+                internal_set(value, p)
                 return nil
               end
             end
@@ -118,23 +135,29 @@ module Datadog
         end
 
         def get
-          if @is_set
-            @value
-          else
-            set_value_from_env_or_default
+          unless @is_set
+            # Ensures that both the default value and the environment value are set.
+            # This approach handles scenarios where an environment value is unset
+            # by falling back to the default value consistently.
+            set_default_value
+            set_customer_stable_config_value
+            set_env_value
+            set_fleet_stable_config_value
           end
+
+          @value
         end
 
         def reset
           @value = if definition.resetter
-                     # Don't change @is_set to false; custom resetters are
-                     # responsible for changing @value back to a good state.
-                     # Setting @is_set = false would cause a default to be applied.
-                     context_exec(@value, &definition.resetter)
-                   else
-                     @is_set = false
-                     nil
-                   end
+            # Don't change @is_set to false; custom resetters are
+            # responsible for changing @value back to a good state.
+            # Setting @is_set = false would cause a default to be applied.
+            context_exec(@value, &definition.resetter)
+          else
+            @is_set = false
+            nil
+          end
 
           # Reset back to the lowest precedence, to allow all `set`s to succeed right after a reset.
           @precedence_set = Precedence::DEFAULT
@@ -157,20 +180,17 @@ module Datadog
         private
 
         def coerce_env_variable(value)
-          return context_exec(value, &@definition.env_parser) if @definition.env_parser
+          env_parser = @definition.env_parser
+          return context_exec(value, &env_parser) if env_parser
 
           case @definition.type
           when :hash
             values = value.split(',') # By default we only want to support comma separated strings
 
-            values.map! do |v|
-              v.gsub!(/\A[\s,]*|[\s,]*\Z/, '')
-
-              v.empty? ? nil : v
-            end
+            values.each_with_object({}) do |v, hash| # $ Hash[String, String]
+              v.gsub!(/\A[\s,]*+|[\s,]*+\Z/, '')
+              next if v.empty?
 
-            values.compact!
-            values.each.with_object({}) do |v, hash|
               pair = v.split(':', 2)
               hash[pair[0]] = pair[1]
             end
@@ -181,18 +201,16 @@ module Datadog
           when :array
             values = value.split(',')
 
-            values.map! do |v|
-              v.gsub!(/\A[\s,]*|[\s,]*\Z/, '')
+            values.each_with_object([]) do |v, arr| # $ Array[String]
+              v.gsub!(/\A[\s,]*+|[\s,]*+\Z/, '')
+              next if v.empty?
 
-              v.empty? ? nil : v
+              arr << v
             end
-
-            values.compact!
-            values
           when :bool
             string_value = value.strip
             string_value = string_value.downcase
-            string_value == 'true' || string_value == '1' # rubocop:disable Style/MultipleComparison
+            string_value == 'true' || string_value == '1'
           when :string, NilClass
             value
           else
@@ -212,20 +230,20 @@ module Datadog
 
           unless valid_type
             raise_error = if @definition.type_options[:nilable]
-                            !value.is_a?(NilClass)
-                          else
-                            true
-                          end
+              !value.is_a?(NilClass)
+            else
+              true
+            end
           end
 
           if raise_error
             error_msg = if @definition.type_options[:nilable]
-                          "The setting `#{@definition.name}` 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 "\
-                          "#{@definition.type}, but a `#{value.class}` was provided (#{value.inspect})."\
-                        end
+              "The setting `#{@definition.name}` 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 " \
+              "#{@definition.type}, but a `#{value.class}` was provided (#{value.inspect})." \
+            end
 
             error_msg = "#{error_msg} Please update your `configure` block. "
 
@@ -256,20 +274,20 @@ module Datadog
           when NilClass
             true # No validation is performed when option is typeless
           else
-            raise ArgumentError, "The option #{@definition.name} is using an unsupported type option `#{@definition.type}`"
+            raise InvalidDefinitionError,
+              "The option #{@definition.name} is using an unsupported type option `#{@definition.type}`"
           end
         end
 
         # Directly manipulates the current value and currently set precedence.
-        def internal_set(value, precedence, resolved_env)
+        def internal_set(value, precedence)
           old_value = @value
           (@value = context_exec(validate_type(value), old_value, &definition.setter)).tap do |v|
             @is_set = true
             @precedence_set = precedence
-            @resolved_env = resolved_env
             # Store original value to ensure we can always safely call `#internal_set`
             # when restoring a value from `@value_per_precedence`, and we are only running `definition.setter`
-            # on the original value, not on a valud that has already been processed by `definition.setter`.
+            # on the original value, not on a value that has already been processed by `definition.setter`.
             @value_per_precedence[precedence] = value
             context_exec(v, old_value, precedence, &definition.after_set) if definition.after_set
           end
@@ -283,39 +301,61 @@ module Datadog
           @context.instance_eval(&block)
         end
 
-        def set_value_from_env_or_default
-          value = nil
-          precedence = nil
-          resolved_env = nil
+        def set_default_value
+          set(default_value, precedence: Precedence::DEFAULT)
+        end
 
-          if definition.env
-            Array(definition.env).each do |env|
-              next if ENV[env].nil?
+        def set_env_value
+          value = get_value_from_env
+          set(value, precedence: Precedence::ENVIRONMENT) unless value.nil?
+        end
 
-              resolved_env = env
-              value = coerce_env_variable(ENV[env])
-              precedence = Precedence::PROGRAMMATIC
-              break
-            end
-          end
+        def set_customer_stable_config_value
+          customer_config = StableConfig.configuration.dig(:local, :config)
+          return if customer_config.nil?
 
-          if value.nil? && definition.deprecated_env && ENV[definition.deprecated_env]
-            resolved_env = definition.deprecated_env
-            value = coerce_env_variable(ENV[definition.deprecated_env])
-            precedence = Precedence::PROGRAMMATIC
+          value = get_value_from(customer_config, 'local')
+          set(value, precedence: Precedence::LOCAL_STABLE) unless value.nil?
+        end
 
-            Datadog::Core.log_deprecation do
-              "#{definition.deprecated_env} environment variable is deprecated, use #{definition.env} instead."
-            end
-          end
+        def set_fleet_stable_config_value
+          fleet_config = StableConfig.configuration.dig(:fleet, :config)
+          return if fleet_config.nil?
+
+          value = get_value_from(fleet_config, 'fleet')
+          set(value, precedence: Precedence::FLEET_STABLE) unless value.nil?
+        end
+
+        def get_value_from_env
+          env = definition.env
+          return unless env
+
+          value = DATADOG_ENV[env]
+          coerce_env_variable(value) unless value.nil?
+        rescue ArgumentError
+          # This will be raised when the type is set to :int or :float but an invalid env var value is provided.
+          raise ArgumentError,
+            # ArgumentError will be thrown from coerce_env_variable, so we've already checked that env is not nil.
+            # @type var env: String
+            "Expected environment variable #{DATADOG_ENV.resolve_env(env)} " \
+            "to be a #{definition.type}, but '#{value}' was provided."
+        end
 
-          option_value = value.nil? ? default_value : value
+        def get_value_from(source_env, source_name)
+          env = definition.env
+          return unless env
 
-          set(option_value, precedence: precedence || Precedence::DEFAULT, resolved_env: resolved_env)
+          # An instance of ConfigHelper could be used with any Hash but this is the only place where
+          # it's used with something else than ENV, let's keep it simple for now by overriding the source_env parameter.
+          value = DATADOG_ENV.get_environment_variable(env, source_env: source_env)
+          coerce_env_variable(value) unless value.nil?
         rescue ArgumentError
+          # This will be raised when the type is set to :int or :float but an invalid env var value is provided.
           raise ArgumentError,
-            "Expected environment variable #{resolved_env} to be a #{@definition.type}, " \
-                              "but '#{ENV[resolved_env]}' was provided"
+            # ArgumentError will be thrown from coerce_env_variable, so we've already checked that env is not nil.
+            # @type var env: String
+            "Expected #{source_name} configuration file variable #{DATADOG_ENV.resolve_env(env, source_env: source_env)} " \
+            "to be a #{definition.type}, but '#{value}' was provided."
         end
 
         # Anchor object that represents a value that is not set.

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

@@ -13,7 +13,6 @@ module Datadog
           :default,
           :default_proc,
           :env,
-          :deprecated_env,
           :env_parser,
           :name,
           :after_set,
@@ -22,11 +21,10 @@ module Datadog
           :type,
           :type_options
 
-        def initialize(name, meta = {}, &block)
+        def initialize(name, meta, &block)
           @default = meta[:default]
           @default_proc = meta[:default_proc]
           @env = meta[:env]
-          @deprecated_env = meta[:deprecated_env]
           @env_parser = meta[:env_parser]
           @name = name.to_sym
           @after_set = meta[:after_set]
@@ -44,14 +42,13 @@ module Datadog
         # Acts as DSL for building OptionDefinitions
         # @public_api
         class Builder
-          class InvalidOptionError < StandardError; end
+          InvalidOptionError = Class.new(StandardError)
 
           attr_reader \
             :helpers
 
           def initialize(name, options = {})
             @env = nil
-            @deprecated_env = nil
             @env_parser = nil
             @default = nil
             @default_proc = nil
@@ -71,14 +68,10 @@ module Datadog
             validate_options!
           end
 
-          def env(value)
+          def env(value) # standard:disable Style/TrivialAccessors
             @env = value
           end
 
-          def deprecated_env(value)
-            @deprecated_env = value
-          end
-
           # Invoked when the option is first read, and {#env} is defined.
           # The block provided is only invoked if the environment variable is present (not-nil).
           def env_parser(&block)
@@ -111,7 +104,7 @@ module Datadog
 
           def type(value, nilable: false)
             @type = value
-            @type_options = { nilable: nilable }
+            @type_options = {nilable: nilable}
 
             value
           end
@@ -123,7 +116,6 @@ module Datadog
             default(options[:default]) if options.key?(:default)
             default_proc(&options[:default_proc]) if options.key?(:default_proc)
             env(options[:env]) if options.key?(:env)
-            deprecated_env(options[:deprecated_env]) if options.key?(:deprecated_env)
             env_parser(&options[:env_parser]) if options.key?(:env_parser)
             after_set(&options[:after_set]) if options.key?(:after_set)
             resetter(&options[:resetter]) if options.key?(:resetter)
@@ -140,7 +132,6 @@ module Datadog
               default: @default,
               default_proc: @default_proc,
               env: @env,
-              deprecated_env: @deprecated_env,
               env_parser: @env_parser,
               after_set: @after_set,
               resetter: @resetter,
@@ -156,7 +147,7 @@ module Datadog
             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`'\
+                                'If you want to store a block as the default value use `default_proc`' \
                                 ' otherwise use `default`'
             end
           end

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

@@ -18,7 +18,7 @@ module Datadog
         module ClassMethods
           def options
             # Allows for class inheritance of option definitions
-            @options ||= superclass <= Options ? superclass.options.dup : {}
+            @options ||= (superclass <= Options) ? superclass.options.dup : {}
           end
 
           protected
@@ -40,14 +40,19 @@ module Datadog
 
           def default_helpers(name)
             option_name = name.to_sym
-
+            # @type var opt_getter: Configuration::OptionDefinition::helper_proc
+            opt_getter = proc do
+              # 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|
+              set_option(option_name, value) # steep:ignore NoMethod
+            end
             {
-              option_name.to_sym => proc do
-                get_option(option_name)
-              end,
-              "#{option_name}=".to_sym => proc do |value|
-                set_option(option_name, value)
-              end
+              option_name.to_sym => opt_getter,
+              :"#{option_name}=" => opt_setter
             }
           end
 
@@ -68,7 +73,7 @@ module Datadog
           end
 
           def set_option(name, value, precedence: Configuration::Option::Precedence::PROGRAMMATIC)
-            resolve_option(name).set(value, precedence: precedence, resolved_env: resolved_env(name))
+            resolve_option(name).set(value, precedence: precedence)
           end
 
           def unset_option(name, precedence: Configuration::Option::Precedence::PROGRAMMATIC)
@@ -113,13 +118,10 @@ module Datadog
 
             assert_valid_option!(name)
             definition = self.class.options[name]
+            # @type self: Configuration::Options::GenericSettingsClass
             options[name] = definition.build(self)
           end
 
-          def resolved_env(name)
-            return options[name].resolved_env if options.key?(name)
-          end
-
           def assert_valid_option!(name)
             raise(InvalidOptionError, "#{self.class.name} doesn't define the option: #{name}") unless option_defined?(name)
           end