datadog 2.20.0 → 2.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b5e6a8c0374f599db43eabbbee53ea6a9e0b4079b04880e81298b8f4aa55545
-  data.tar.gz: ca1d8964d2e12768e405a0c70062dae7420f8a53d73b32bdb163c8b5dd38d794
+  metadata.gz: e804b0ea5131eba47b865f95a6540c84a2c20e061a9d25a9bf1f2841895c46c6
+  data.tar.gz: 7c7b61bb061c943aad519ede1f4900351db8b79e7111368c3d85f23ac73fafb8
 SHA512:
-  metadata.gz: 77f707de1847f987a71dfd13401c07260fc1b33997b8033bb42c466cbe55af1177f30fb4f8aaf17d36f5aa7dec2c25b87961f7a38b013e0cbd27d62ab3e8c3fa
-  data.tar.gz: 4cf002b5b6fd6e2ca6dc2870409115624768f1f0b0d0556bea760117d8298d0657efff39bd8c2d1c8b23d03bbbf0e8ecb2c1735f6f1d55df2ca963359bf1631f
+  metadata.gz: 669cc7248fe15fbd07ab98e71d20e3ec97d644b27ef43be9b7fe7b047c60bd8794c903db3cfe1f4580f7877f7a1491f5028743a618e649930ff10d14756ae820
+  data.tar.gz: e5a2e28ebcc390f1e2277299b883946c4f0baec35754216bbea4da4df437fa06e8c2b6cc0aa5f7847256e0b500903076a19ec7456c7979e7759fc7a4fb8836d3

data/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [2.21.0] - 2025-09-17
+
+### Added
+
+* Tracing: Generate metrics for GraphQL operation execution ([#4862][])
+
+### Changed
+
+* Tracing: The `graphql.execute` span resource now includes the operation type ([#4862][])
+
+### Fixed
+
+* Tracing: Fix Service Discovery capabilities on forked processes ([#4877][])
+* Tracing: Fix an unclosed trace issue when the Rack application has proxy spans and raises an exception. This caused traces that encompassed multiple requests ([#4779][])
+* AppSec: Fix API Security route extraction for Rails ([#4887][])
+* AppSec: Fix a bug with non-string Hash keys conversion ([#4893][])
+* Dynamic Instrumentation: Fix incorrect template expression evaluation in some cases ([#4884][])
+
 ## [2.20.0] - 2025-09-04
 
 ### Added
@@ -3315,7 +3333,8 @@ Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.3.1
 Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 
 
-[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.20.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.21.0...master
+[2.21.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.20.0...v2.21.0
 [2.20.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.19.0...v2.20.0
 [2.19.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.18.0...v2.19.0
 [2.18.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.17.0...v2.18.0
@@ -4894,6 +4913,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#4771]: https://github.com/DataDog/dd-trace-rb/issues/4771
 [#4772]: https://github.com/DataDog/dd-trace-rb/issues/4772
 [#4776]: https://github.com/DataDog/dd-trace-rb/issues/4776
+[#4779]: https://github.com/DataDog/dd-trace-rb/issues/4779
 [#4783]: https://github.com/DataDog/dd-trace-rb/issues/4783
 [#4785]: https://github.com/DataDog/dd-trace-rb/issues/4785
 [#4786]: https://github.com/DataDog/dd-trace-rb/issues/4786
@@ -4909,7 +4929,12 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#4838]: https://github.com/DataDog/dd-trace-rb/issues/4838
 [#4848]: https://github.com/DataDog/dd-trace-rb/issues/4848
 [#4851]: https://github.com/DataDog/dd-trace-rb/issues/4851
+[#4862]: https://github.com/DataDog/dd-trace-rb/issues/4862
 [#4863]: https://github.com/DataDog/dd-trace-rb/issues/4863
+[#4877]: https://github.com/DataDog/dd-trace-rb/issues/4877
+[#4884]: https://github.com/DataDog/dd-trace-rb/issues/4884
+[#4887]: https://github.com/DataDog/dd-trace-rb/issues/4887
+[#4893]: https://github.com/DataDog/dd-trace-rb/issues/4893
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot

data/README.md

@@ -1,7 +1,6 @@
 # Datadog Trace Client
 
 [![Gem](https://img.shields.io/gem/v/datadog)](https://rubygems.org/gems/datadog/)
-[![codecov](https://codecov.io/gh/DataDog/dd-trace-rb/branch/master/graph/badge.svg)](https://app.codecov.io/gh/DataDog/dd-trace-rb/branch/master)
 [![YARD documentation](https://img.shields.io/badge/YARD-documentation-blue)][api docs]
 
 ``datadog`` is Datadog's client library for Ruby. It includes a suite of tools which provide visibility into the performance and security of Ruby applications, to enable Ruby developers to identify bottlenecks and other issues.

data/ext/libdatadog_api/process_discovery.c

@@ -27,13 +27,13 @@ static const rb_data_type_t tracer_memfd_type = {
 };
 
 void process_discovery_init(VALUE core_module) {
-  VALUE process_discovery_class = rb_define_class_under(core_module, "ProcessDiscovery", rb_cObject);
-  VALUE tracer_memfd_class = rb_define_class_under(process_discovery_class, "TracerMemfd", rb_cObject);
+  VALUE process_discovery_module = rb_define_module_under(core_module, "ProcessDiscovery");
+  VALUE tracer_memfd_class = rb_define_class_under(process_discovery_module, "TracerMemfd", rb_cObject);
   rb_undef_alloc_func(tracer_memfd_class); // Class cannot be instantiated from Ruby
 
-  rb_define_singleton_method(process_discovery_class, "_native_store_tracer_metadata", _native_store_tracer_metadata, -1);
-  rb_define_singleton_method(process_discovery_class, "_native_to_rb_int", _native_to_rb_int, 1);
-  rb_define_singleton_method(process_discovery_class, "_native_close_tracer_memfd", _native_close_tracer_memfd, 2);
+  rb_define_module_function(process_discovery_module, "_native_store_tracer_metadata", _native_store_tracer_metadata, -1);
+  rb_define_module_function(process_discovery_module, "_native_to_rb_int", _native_to_rb_int, 1);
+  rb_define_module_function(process_discovery_module, "_native_close_tracer_memfd", _native_close_tracer_memfd, 2);
 }
 
 static VALUE _native_store_tracer_metadata(int argc, VALUE *argv, VALUE self) {

data/lib/datadog/appsec/api_security/route_extractor.rb

@@ -39,9 +39,9 @@ module Datadog
         # WARNING: This method works only *after* the request has been routed.
         #
         # WARNING: In Rails > 7.1 when a route was not found,
-        #          action_dispatch.route_uri_pattern will not be set.
+        #          `action_dispatch.route_uri_pattern` will not be set.
         #          In Rails < 7.1 it also will not be set even if a route was found,
-        #          but in this case  action_dispatch.request.path_parameters won't be empty.
+        #          but in this case `action_dispatch.request.path_parameters` won't be empty.
         def self.route_pattern(request)
           if request.env.key?(GRAPE_ROUTE_KEY)
             pattern = request.env[GRAPE_ROUTE_KEY][:route_info]&.pattern&.origin
@@ -52,6 +52,10 @@ module Datadog
           elsif request.env.key?(RAILS_ROUTE_KEY)
             request.env[RAILS_ROUTE_KEY].delete_suffix(RAILS_FORMAT_SUFFIX)
           elsif request.env.key?(RAILS_ROUTES_KEY) && !request.env.fetch(RAILS_PATH_PARAMS_KEY, {}).empty?
+            # NOTE: Rails mutate HEAD request in order to understand that route is supported.
+            #       It will assing GET request method and run the route recognition.
+            request = request.env[RAILS_ROUTES_KEY].request_class.new(request.env) if request.head?
+
             pattern = request.env[RAILS_ROUTES_KEY].router
               .recognize(request) { |route, _| break route.path.spec.to_s }
 

data/lib/datadog/appsec/autoload.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-if %w[1 true].include?((ENV['DD_APPSEC_ENABLED'] || '').downcase)
+if %w[1 true].include?((Datadog::DATADOG_ENV['DD_APPSEC_ENABLED'] || '').downcase)
   begin
     require_relative 'contrib/auto_instrument'
     Datadog::AppSec::Contrib::AutoInstrument.patch_all

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

@@ -68,7 +68,7 @@ module Datadog
             ),
             DetectedConfiguration.new(
               friendly_name: "#{Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_HOST} environment variable",
-              value: ENV[Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_HOST]
+              value: DATADOG_ENV[Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_HOST]
             )
           )
         end
@@ -87,7 +87,7 @@ module Datadog
             ),
             try_parsing_as_integer(
               friendly_name: "#{Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_PORT} environment variable",
-              value: ENV[Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_PORT],
+              value: DATADOG_ENV[Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_PORT],
             )
           )
         end
@@ -118,7 +118,7 @@ module Datadog
             try_parsing_as_integer(
               friendly_name: "#{Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_TIMEOUT_SECONDS} " \
                 'environment variable',
-              value: ENV[Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_TIMEOUT_SECONDS],
+              value: DATADOG_ENV[Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_TIMEOUT_SECONDS],
             )
           )
         end
@@ -256,7 +256,7 @@ module Datadog
         def parsed_url
           return @parsed_url if defined?(@parsed_url)
 
-          unparsed_url_from_env = ENV[Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_URL]
+          unparsed_url_from_env = DATADOG_ENV[Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_URL]
 
           @parsed_url =
             if unparsed_url_from_env

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

@@ -3,6 +3,7 @@
 require_relative 'agent_settings_resolver'
 require_relative 'components_state'
 require_relative 'ext'
+require_relative 'deprecations'
 require_relative '../diagnostics/environment_logger'
 require_relative '../diagnostics/health'
 require_relative '../logger'
@@ -97,6 +98,7 @@ module Datadog
         def initialize(settings)
           @logger = self.class.build_logger(settings)
           @environment_logger_extra = {}
+          Deprecations.log_deprecations_from_all_sources(@logger)
 
           # This agent_settings is intended for use within Core. If you require
           # agent_settings within a product outside of core you should extend
@@ -126,7 +128,6 @@ module Datadog
           @dynamic_instrumentation = Datadog::DI::Component.build(settings, agent_settings, @logger, telemetry: telemetry)
           @error_tracking = Datadog::ErrorTracking::Component.build(settings, @tracer, @logger)
           @environment_logger_extra[:dynamic_instrumentation_enabled] = !!@dynamic_instrumentation
-          @process_discovery_fd = Core::ProcessDiscovery.get_and_store_metadata(settings, @logger)
 
           self.class.configure_tracing(settings)
         end
@@ -155,6 +156,11 @@ module Datadog
             remote&.start
           end
 
+          # This should stay here, not in initialize. During reconfiguration, the order of the calls is:
+          # initialize new components, shutdown old components, startup new components.
+          # Because this is a singleton, if we call it in initialize, it will be shutdown right away.
+          Core::ProcessDiscovery.publish(settings)
+
           Core::Diagnostics::EnvironmentLogger.collect_and_log!(@environment_logger_extra)
         end
 
@@ -210,7 +216,7 @@ module Datadog
           telemetry.emit_closing! unless replacement&.telemetry&.enabled
           telemetry.shutdown!
 
-          @process_discovery_fd&.shutdown!
+          Core::ProcessDiscovery.shutdown!
         end
 
         # Returns the current state of various components.

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative 'supported_configurations'
+require_relative '../logger'
+
+module Datadog
+  module Core
+    module Configuration
+      class ConfigHelper
+        def initialize(
+          source_env: ENV,
+          supported_configurations: SUPPORTED_CONFIGURATIONS,
+          aliases: ALIASES,
+          alias_to_canonical: ALIAS_TO_CANONICAL,
+          raise_on_unknown_env_var: false
+        )
+          @source_env = source_env
+          @supported_configurations = supported_configurations
+          @aliases = aliases
+          @alias_to_canonical = alias_to_canonical
+          @raise_on_unknown_env_var = raise_on_unknown_env_var
+        end
+
+        def [](name)
+          get_environment_variable(name)
+        end
+
+        def fetch(name, default_value = UNSET)
+          if (item = get_environment_variable(name))
+            return item
+          end
+
+          return yield(name) if block_given?
+          return default_value unless default_value == UNSET
+
+          raise KeyError, "key not found: #{name}"
+        end
+
+        def key?(name)
+          !get_environment_variable(name).nil?
+        end
+
+        alias_method :has_key?, :key?
+        alias_method :include?, :key?
+        alias_method :member?, :key?
+
+        # Returns the environment variable value if the environment variable is a supported Datadog configuration (starts with DD_ or OTEL_)
+        # or if it is not a Datadog configuration. Otherwise, it returns nil.
+        #
+        # @param name [String] Environment variable name
+        # @param default_value [String, nil] Default value to return if the environment variable is not set
+        # @param source_env [Hash[String, String]] Environment variables to use
+        # @return [String, nil] The environment variable value
+        # @raise [RuntimeError] if the configuration is not supported
+        def get_environment_variable(name, default_value = nil, source_env: @source_env)
+          # datadog-ci-rb is using dd-trace-rb config DSL, which uses this method.
+          # Until we've correctly implemented support for datadog-ci-rb, we disable config inversion if ci is enabled.
+          if !defined?(::Datadog::CI) &&
+              (name.start_with?('DD_', 'OTEL_') || @alias_to_canonical[name]) &&
+              !@supported_configurations[name]
+            if defined?(@raise_on_unknown_env_var) && @raise_on_unknown_env_var # Only enabled for tests!
+              if @alias_to_canonical[name]
+                raise "Please use #{@alias_to_canonical[name]} instead of #{name}. See docs/AccessEnvironmentVariables.md for details."
+              else
+                raise "Missing #{name} env/configuration in \"supported-configurations.json\" file. See docs/AccessEnvironmentVariables.md for details."
+              end
+            end
+            # TODO: Send telemetry to know if we ever miss an env var
+            return nil
+          end
+
+          env_value = source_env[name]
+          if env_value.nil? && @aliases[name]
+            @aliases[name].each do |alias_name|
+              return source_env[alias_name] if source_env[alias_name]
+            end
+          end
+
+          env_value || default_value
+        end
+
+        # Only used in error message creation. Match get_environment_variable logic to return the resolved environment variable name.
+        def resolve_env(name, source_env: @source_env)
+          if source_env[name].nil? && @aliases[name]
+            @aliases[name].each do |alias_name|
+              return alias_name if source_env[alias_name]
+            end
+          end
+
+          name
+        end
+
+        # Anchor object that represents an undefined default value.
+        # This is necessary because `nil` is a valid default value.
+        UNSET = Object.new
+        private_constant :UNSET
+      end
+    end
+  end
+end

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

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

@@ -15,7 +15,7 @@ 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
@@ -68,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.
@@ -84,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
@@ -103,7 +102,7 @@ module Datadog
             return @value
           end
 
-          internal_set(value, precedence, resolved_env)
+          internal_set(value, precedence)
         end
 
         def unset(precedence)
@@ -121,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
@@ -189,7 +188,7 @@ module Datadog
             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)
@@ -203,7 +202,7 @@ module Datadog
             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
@@ -281,12 +280,11 @@ module Datadog
         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 value that has already been processed by `definition.setter`.
@@ -308,59 +306,56 @@ module Datadog
         end
 
         def set_env_value
-          value, resolved_env = get_value_and_resolved_env_from(ENV)
-          set(value, precedence: Precedence::ENVIRONMENT, resolved_env: resolved_env) unless value.nil?
+          value = get_value_from_env
+          set(value, precedence: Precedence::ENVIRONMENT) unless value.nil?
         end
 
         def set_customer_stable_config_value
           customer_config = StableConfig.configuration.dig(:local, :config)
           return if customer_config.nil?
 
-          value, resolved_env = get_value_and_resolved_env_from(customer_config, source: 'local stable config')
-          set(value, precedence: Precedence::LOCAL_STABLE, resolved_env: resolved_env) unless value.nil?
+          value = get_value_from(customer_config, 'local')
+          set(value, precedence: Precedence::LOCAL_STABLE) unless value.nil?
         end
 
         def set_fleet_stable_config_value
           fleet_config = StableConfig.configuration.dig(:fleet, :config)
           return if fleet_config.nil?
 
-          value, resolved_env = get_value_and_resolved_env_from(fleet_config, source: 'fleet stable config')
-          set(value, precedence: Precedence::FLEET_STABLE, resolved_env: resolved_env) unless value.nil?
+          value = get_value_from(fleet_config, 'fleet')
+          set(value, precedence: Precedence::FLEET_STABLE) unless value.nil?
         end
 
-        def get_value_and_resolved_env_from(env_vars, source: 'environment variable')
-          value = nil
-          resolved_env = nil
+        def get_value_from_env
+          env = definition.env
+          return unless env
 
-          if definition.env
-            # @type var env_and_aliases: Array[String]
-            env_and_aliases = Array(definition.env)
-            env_and_aliases.each do |env|
-              env_value = env_vars[env]
-              next if env_value.nil?
-
-              resolved_env = env
-              value = coerce_env_variable(env_value)
-              break
-            end
-          end
-
-          deprecated_env = definition.deprecated_env ? env_vars[definition.deprecated_env] : nil
-          if value.nil? && deprecated_env
-            resolved_env = definition.deprecated_env
-            value = coerce_env_variable(deprecated_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
 
-            Datadog::Core.log_deprecation do
-              "#{definition.deprecated_env} #{source} is deprecated, use #{definition.env} instead."
-            end
-          end
+        def get_value_from(source_env, source_name)
+          env = definition.env
+          return unless env
 
-          [value, 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
-          env_value = resolved_env ? env_vars[resolved_env] : nil
+          # This will be raised when the type is set to :int or :float but an invalid env var value is provided.
           raise ArgumentError,
-            "Expected #{source} #{resolved_env} to be a #{definition.type}, " \
-            "but '#{env_value}' 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,
@@ -26,7 +25,6 @@ module Datadog
           @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]
@@ -51,7 +49,6 @@ module Datadog
 
           def initialize(name, options = {})
             @env = nil
-            @deprecated_env = nil
             @env_parser = nil
             @default = nil
             @default_proc = nil
@@ -75,10 +72,6 @@ module Datadog
             @env = value
           end
 
-          def deprecated_env(value) # standard:disable Style/TrivialAccessors
-            @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)
@@ -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,

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

@@ -73,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)
@@ -122,10 +122,6 @@ module Datadog
             options[name] = definition.build(self)
           end
 
-          def resolved_env(name)
-            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

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

@@ -122,8 +122,8 @@ module Datadog
           # @default `DD_TRACE_DEBUG` environment variable, otherwise `false`
           # @return [Boolean]
           option :debug do |o|
-            o.env [Datadog::Core::Configuration::Ext::Diagnostics::ENV_DEBUG_ENABLED,
-              Datadog::Core::Configuration::Ext::Diagnostics::ENV_OTEL_LOG_LEVEL]
+            # Note: Alias (OTEL_LOG_LEVEL) defined in supported-configurations.json
+            o.env Datadog::Core::Configuration::Ext::Diagnostics::ENV_DEBUG_ENABLED
             o.default false
             o.type :bool
             o.env_parser do |value|
@@ -212,6 +212,7 @@ module Datadog
           # Log level for `Datadog.logger`.
           # @see Logger::Severity
           # @return Logger::Severity
+          # TODO: Add environment variable for this `DD_TRACE_LOG_LEVEL`
           option :level, default: ::Logger::INFO
         end
 
@@ -485,7 +486,7 @@ module Datadog
             # @default `DD_PROFILING_GVL_ENABLED` environment variable as a boolean, otherwise `true`
             option :gvl_enabled do |o|
               o.type :bool
-              o.deprecated_env 'DD_PROFILING_PREVIEW_GVL_ENABLED'
+              # Note: Deprecated alias (DD_PROFILING_PREVIEW_GVL_ENABLED) defined in supported-configurations.json
               o.env 'DD_PROFILING_GVL_ENABLED'
               o.default true
             end
@@ -604,7 +605,8 @@ module Datadog
 
           option :experimental_runtime_id_enabled do |o|
             o.type :bool
-            o.env ['DD_TRACE_EXPERIMENTAL_RUNTIME_ID_ENABLED', 'DD_RUNTIME_METRICS_RUNTIME_ID_ENABLED']
+            # Note: Alias (DD_TRACE_EXPERIMENTAL_RUNTIME_ID_ENABLED) defined in supported-configurations.json
+            o.env 'DD_RUNTIME_METRICS_RUNTIME_ID_ENABLED'
             o.default false
           end
 
@@ -620,7 +622,8 @@ module Datadog
           o.type :string, nilable: true
 
           # NOTE: service also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
-          o.env [Core::Environment::Ext::ENV_SERVICE, Core::Environment::Ext::ENV_OTEL_SERVICE]
+          # Note: Alias (OTEL_SERVICE_NAME) defined in supported-configurations.json
+          o.env Core::Environment::Ext::ENV_SERVICE
           o.default Core::Environment::Ext::FALLBACK_SERVICE_NAME
 
           # There's a few cases where we don't want to use the fallback service name, so this helper allows us to get a
@@ -655,7 +658,8 @@ module Datadog
         # @return [Hash<String,String>]
         option :tags do |o|
           o.type :hash, nilable: true
-          o.env [Core::Environment::Ext::ENV_TAGS, Core::Environment::Ext::ENV_OTEL_RESOURCE_ATTRIBUTES]
+          # Note: Alias (OTEL_RESOURCE_ATTRIBUTES) defined in supported-configurations.json
+          o.env Core::Environment::Ext::ENV_TAGS
           o.env_parser do |env_value|
             # Parses a string containing key-value pairs and returns a hash.
             # Key-value pairs are delimited by ':' OR `=`, and pairs are separated by whitespace, comma, OR BOTH.