datadog 2.35.0 → 2.37.0

data/lib/datadog/open_feature/provider.rb

@@ -1,13 +1,18 @@
 # frozen_string_literal: true
 
 require_relative 'ext'
+require_relative '../core/utils/time'
 require 'open_feature/sdk'
 
 module Datadog
   module OpenFeature
     # OpenFeature feature flagging provider backed by Datadog Remote Configuration.
     #
-    # Requires openfeature-sdk >= 0.5.1 for flag evaluation metrics support.
+    # Requires openfeature-sdk >= 0.5.1 for flag evaluation metrics and EVP hook support.
+    #
+    # Hook lifecycle note: FlagEvalEVPHook is returned from #hooks so EVP uses the SDK-final
+    # EvaluationDetails. This matches FlagEvalMetricsHook and records defaults/errors produced
+    # by OpenFeature hook failures or post-provider type validation.
     #
     # Implementation follows the OpenFeature contract of Provider SDK.
     # For details see:
@@ -70,8 +75,10 @@ module Datadog
       end
 
       def hooks
-        hook = Datadog.send(:components).open_feature&.flag_eval_hook
-        [hook].compact
+        component = Datadog.send(:components).open_feature
+        otel_hook = component&.flag_eval_metrics_hook
+        evp_hook = component&.flag_eval_evp_hook
+        [otel_hook, evp_hook].compact
       end
 
       def fetch_boolean_value(flag_key:, default_value:, evaluation_context: nil)
@@ -101,57 +108,82 @@ module Datadog
       private
 
       def evaluate(flag_key, default_value:, expected_type:, evaluation_context:)
+        # Stamp evaluation entry time once, here on the eval thread. The EVP path uses this for
+        # accurate first/last_evaluation bounds instead of a later hook-fire clock read.
+        eval_time_ms = (Core::Utils::Time.now.to_f * 1000).to_i
+
         engine = OpenFeature.engine
-        return component_not_configured_default(default_value) if engine.nil?
+        return component_not_configured_default(default_value, eval_time_ms) if engine.nil?
+
+        result = fetch_engine_value(engine, flag_key, default_value, expected_type, evaluation_context)
+
+        # Build metadata before branching so provider-returned details carry eval-entry time.
+        flag_meta = build_flag_metadata(result, eval_time_ms)
+
+        if result.error?
+          return sdk_error_details(default_value, result.error_code, result.error_message, result.reason, flag_meta)
+        end
+
+        sdk_success_details(result, flag_meta)
+      rescue => e
+        error_message = "#{e.class}: #{e.message}"
+        error_result = Datadog::OpenFeature::ResolutionDetails.build_error(
+          value: default_value,
+          error_code: Ext::GENERAL,
+          error_message: error_message
+        )
+        error_flag_meta = build_flag_metadata(error_result, eval_time_ms || (Core::Utils::Time.now.to_f * 1000).to_i)
 
-        result = engine.fetch_value(
+        sdk_error_details(default_value, Ext::GENERAL, error_message, Ext::ERROR, error_flag_meta)
+      end
+
+      def fetch_engine_value(engine, flag_key, default_value, expected_type, evaluation_context)
+        engine.fetch_value(
           flag_key,
           default_value: default_value,
           expected_type: expected_type,
           evaluation_context: evaluation_context
         )
+      end
 
-        if result.error?
-          return ::OpenFeature::SDK::Provider::ResolutionDetails.new(
-            value: default_value,
-            error_code: result.error_code,
-            error_message: result.error_message,
-            reason: result.reason
-          )
-        end
-
+      def sdk_success_details(result, flag_meta)
         ::OpenFeature::SDK::Provider::ResolutionDetails.new(
           value: result.value,
           variant: result.variant,
           reason: result.reason,
-          flag_metadata: build_flag_metadata(result),
+          flag_metadata: flag_meta,
         )
-      rescue => e
+      end
+
+      def sdk_error_details(default_value, error_code, error_message, reason, flag_meta = {})
         ::OpenFeature::SDK::Provider::ResolutionDetails.new(
           value: default_value,
-          error_code: Ext::GENERAL,
-          error_message: "#{e.class}: #{e.message}",
-          reason: Ext::ERROR
+          error_code: error_code,
+          error_message: error_message,
+          reason: reason,
+          flag_metadata: flag_meta
         )
       end
 
-      def build_flag_metadata(result)
-        metadata = result.flag_metadata || {}
+      def build_flag_metadata(result, eval_time_ms)
+        metadata = result.flag_metadata&.dup || {}
         allocation_key = result.allocation_key
-        if allocation_key && !allocation_key.empty?
-          metadata = metadata.dup
-          metadata['__dd_allocation_key'] = allocation_key
-        end
+        metadata['__dd_allocation_key'] = allocation_key if allocation_key && !allocation_key.empty?
+
+        # Eval-time stamped at provider entry; the EVP hook reads 'dd.eval.timestamp_ms' for
+        # accurate first/last_evaluation bounds (it falls back to hook-fire time when absent).
+        metadata['dd.eval.timestamp_ms'] = eval_time_ms
 
         metadata
       end
 
-      def component_not_configured_default(value)
+      def component_not_configured_default(value, eval_time_ms)
         ::OpenFeature::SDK::Provider::ResolutionDetails.new(
           value: value,
           error_code: Ext::PROVIDER_FATAL,
           error_message: "Datadog's OpenFeature component must be configured",
-          reason: Ext::ERROR
+          reason: Ext::ERROR,
+          flag_metadata: {'dd.eval.timestamp_ms' => eval_time_ms}
         )
       end
     end

data/lib/datadog/open_feature/transport.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../core/encoding'
+require_relative '../core/evp'
 require_relative '../core/transport/http'
 require_relative '../core/transport/http/env'
 require_relative '../core/transport/http/api/endpoint'
@@ -12,6 +13,7 @@ module Datadog
   module OpenFeature
     module Transport
       class HTTP
+        # API spec for the EVP exposures endpoint.
         class Spec
           def initialize
             @endpoint = Core::Transport::HTTP::API::Endpoint.new(
@@ -23,7 +25,30 @@ module Datadog
           def call(env, &block)
             @endpoint.call(env) do |request_env|
               request_env.headers['Content-Type'] = env.request.parcel.content_type
-              request_env.headers['X-Datadog-EVP-Subdomain'] = 'event-platform-intake'
+              request_env.headers[Core::EVP::SUBDOMAIN_HEADER_NAME] =
+                Core::EVP::EVENT_PLATFORM_INTAKE_SUBDOMAIN
+              request_env.body = env.request.parcel.data
+
+              block.call(request_env)
+            end
+          end
+        end
+
+        # API spec for the EVP flagevaluation endpoint.
+        # Path: /evp_proxy/v2/api/v2/flagevaluation
+        # Header: X-Datadog-EVP-Subdomain: event-platform-intake (same as exposures)
+        class FlagevaluationsSpec
+          def initialize
+            @endpoint = Core::Transport::HTTP::API::Endpoint.new(
+              :post, '/evp_proxy/v2/api/v2/flagevaluation'
+            )
+          end
+
+          def call(env, &block)
+            @endpoint.call(env) do |request_env|
+              request_env.headers['Content-Type'] = env.request.parcel.content_type
+              request_env.headers[Core::EVP::SUBDOMAIN_HEADER_NAME] =
+                Core::EVP::EVENT_PLATFORM_INTAKE_SUBDOMAIN
               request_env.body = env.request.parcel.data
 
               block.call(request_env)
@@ -38,6 +63,14 @@ module Datadog
           ) { |t| t.api('exposures', HTTP::Spec.new) }.to_transport(self)
         end
 
+        # Build a transport instance for the flagevaluation EVP endpoint.
+        def self.build_flagevaluations(agent_settings:, logger:)
+          Core::Transport::HTTP.build(
+            agent_settings: agent_settings,
+            logger: logger
+          ) { |t| t.api('flagevaluations', HTTP::FlagevaluationsSpec.new) }.to_transport(self)
+        end
+
         def initialize(apis, default_api, logger:)
           @api = apis[default_api]
           @logger = logger
@@ -61,6 +94,27 @@ module Datadog
 
           Core::Transport::InternalErrorResponse.new(e)
         end
+
+        # POST a flag evaluations batch to /evp_proxy/v2/api/v2/flagevaluation.
+        # Mirrors send_exposures; uses the FlagevaluationsSpec endpoint.
+        def send_flag_evaluations(payload)
+          encoder = Core::Encoding::JSONEncoder
+          parcel = Core::Transport::Parcel.new(
+            encoder.encode(payload),
+            content_type: encoder.content_type
+          )
+          request = Core::Transport::Request.new(parcel)
+
+          @api.endpoint.call(Core::Transport::HTTP::Env.new(request)) do |env|
+            @api.call(env)
+          end
+        rescue => e
+          message = "Internal error during request. Cause: #{e.class}: #{e.message} " \
+                    "Location: #{Array(e.backtrace).first}"
+          @logger.debug(message)
+
+          Core::Transport::InternalErrorResponse.new(e)
+        end
       end
     end
   end

data/lib/datadog/opentelemetry/sdk/logs_exporter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'opentelemetry/exporter/otlp_logs'
+require_relative '../sdk'
 
 module Datadog
   module OpenTelemetry
@@ -10,27 +11,19 @@ module Datadog
         METRIC_EXPORT_SUCCESSES = 'otel.logs_export_successes'
         METRIC_EXPORT_FAILURES = 'otel.logs_export_failures'
         METRIC_LOG_RECORDS = 'otel.log_records'
-        TELEMETRY_NAMESPACE = 'tracers'
-        TELEMETRY_TAGS = {'protocol' => 'http', 'encoding' => 'protobuf'}.freeze
 
         def export(log_records, timeout: nil)
-          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_ATTEMPTS, 1, tags: TELEMETRY_TAGS)
-          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_LOG_RECORDS, log_records.size, tags: TELEMETRY_TAGS)
+          SDK.telemetry_inc(METRIC_EXPORT_ATTEMPTS, 1)
+          SDK.telemetry_inc(METRIC_LOG_RECORDS, log_records.size)
           result = super
           metric_name = (result == 0) ? METRIC_EXPORT_SUCCESSES : METRIC_EXPORT_FAILURES
-          telemetry&.inc(TELEMETRY_NAMESPACE, metric_name, 1, tags: TELEMETRY_TAGS)
+          SDK.telemetry_inc(metric_name, 1)
           result
         rescue => e
           Datadog.logger.warn("Failed to export OpenTelemetry Logs: #{e.class}: #{e.message}")
-          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_FAILURES, 1, tags: TELEMETRY_TAGS)
+          SDK.telemetry_inc(METRIC_EXPORT_FAILURES, 1)
           raise
         end
-
-        private
-
-        def telemetry
-          Datadog.send(:components).telemetry
-        end
       end
     end
   end

data/lib/datadog/opentelemetry/sdk/metrics_exporter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'opentelemetry/exporter/otlp_metrics'
+require_relative '../sdk'
 
 module Datadog
   module OpenTelemetry
@@ -9,26 +10,18 @@ module Datadog
         METRIC_EXPORT_ATTEMPTS = 'otel.metrics_export_attempts'
         METRIC_EXPORT_SUCCESSES = 'otel.metrics_export_successes'
         METRIC_EXPORT_FAILURES = 'otel.metrics_export_failures'
-        TELEMETRY_NAMESPACE = 'tracers'
-        TELEMETRY_TAGS = {'protocol' => "http", 'encoding' => 'protobuf'}
 
         def export(metrics, timeout: nil)
-          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_ATTEMPTS, 1, tags: TELEMETRY_TAGS)
+          SDK.telemetry_inc(METRIC_EXPORT_ATTEMPTS, 1)
           result = super
           metric_name = (result == 0) ? METRIC_EXPORT_SUCCESSES : METRIC_EXPORT_FAILURES
-          telemetry&.inc(TELEMETRY_NAMESPACE, metric_name, 1, tags: TELEMETRY_TAGS)
+          SDK.telemetry_inc(metric_name, 1)
           result
         rescue => e
           Datadog.logger.error("Failed to export OpenTelemetry Metrics:  #{e.class}: #{e.message}")
-          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_FAILURES, 1, tags: TELEMETRY_TAGS)
+          SDK.telemetry_inc(METRIC_EXPORT_FAILURES, 1)
           raise
         end
-
-        private
-
-        def telemetry
-          Datadog.send(:components).telemetry
-        end
       end
     end
   end

data/lib/datadog/opentelemetry/sdk/propagator.rb

@@ -43,6 +43,15 @@ module Datadog
           digest = @datadog_propagator.extract(carrier)
           return context unless digest
 
+          # Always call continue_trace! so span links are created in restart mode
+          # (when digest.trace_id is nil) before we attempt to build the OTel SpanContext.
+          trace = Tracing.continue_trace!(digest)
+
+          # In restart mode DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT=restart, the extracted
+          # digest carries no trace_id (fresh start). continue_trace! has already recorded
+          # the span link; return the current context so the caller's span starts a new root.
+          return context unless digest.trace_id
+
           # Converts the {Numeric} Datadog id object to OpenTelemetry's byte array format.
           # 128-bit unsigned, big-endian integer
           trace_id = [digest.trace_id >> 64, digest.trace_id & 0xFFFFFFFFFFFFFFFF].pack('Q>Q>')
@@ -70,9 +79,6 @@ module Datadog
           )
 
           span = ::OpenTelemetry::Trace.non_recording_span(span_context)
-
-          trace = Tracing.continue_trace!(digest)
-
           span.datadog_trace = trace
 
           ::OpenTelemetry::Trace.context_with_span(span, parent_context: context)

data/lib/datadog/opentelemetry/sdk/span_processor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'trace/span'
+require_relative '../../core/utils'
 require_relative '../../tracing/span_link'
 require_relative '../../tracing/span_event'
 require_relative '../../tracing/trace_digest'
@@ -101,12 +102,14 @@ module Datadog
 
           unless span.links.nil?
             datadog_span.links = span.links.map do |link|
+              tracestate = link.span_context.tracestate&.to_s
+
               Datadog::Tracing::SpanLink.new(
                 Datadog::Tracing::TraceDigest.new(
                   trace_id: link.span_context.hex_trace_id.to_i(16),
                   span_id: link.span_context.hex_span_id.to_i(16),
                   trace_sampling_priority: (link.span_context.trace_flags&.sampled? ? 1 : 0),
-                  trace_state: link.span_context.tracestate&.to_s,
+                  trace_state: tracestate && ::Datadog::Core::Utils.utf8_encode(tracestate, placeholder: nil),
                   span_remote: link.span_context.remote?,
                 ),
                 attributes: link.attributes

data/lib/datadog/opentelemetry/sdk.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../tracing/ext'
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      TELEMETRY_TAGS = {'protocol' => 'http', 'encoding' => 'protobuf'}.freeze
+
+      def self.telemetry_inc(metric_name, value)
+        telemetry&.inc(Datadog::Tracing::Ext::TELEMETRY_METRICS_NAMESPACE, metric_name, value, tags: TELEMETRY_TAGS)
+      end
+
+      def self.telemetry
+        Datadog.send(:components).telemetry
+      end
+    end
+  end
+end

data/lib/datadog/profiling/collectors/cpu_and_wall_time_worker.rb

@@ -49,7 +49,7 @@ module Datadog
           # profiler overhead!
           dynamic_sampling_rate_enabled: true,
           skip_idle_samples_for_testing: false,
-          idle_sampling_helper: IdleSamplingHelper.new
+          idle_sampling_helper: IdleSamplingHelper.new(thread_context_collector: thread_context_collector)
         )
           unless dynamic_sampling_rate_enabled
             Datadog.logger.warn(

data/lib/datadog/profiling/collectors/idle_sampling_helper.rb

@@ -10,6 +10,7 @@ module Datadog
       class IdleSamplingHelper
         # @rbs @worker_thread: untyped
         # @rbs @start_stop_mutex: ::Thread::Mutex
+        # @rbs @thread_context_collector: Datadog::Profiling::Collectors::ThreadContext?
 
         private
 
@@ -17,10 +18,11 @@ module Datadog
 
         public
 
-        #: () -> void
-        def initialize
+        #: (thread_context_collector: Datadog::Profiling::Collectors::ThreadContext) -> void
+        def initialize(thread_context_collector:)
           @worker_thread = nil
           @start_stop_mutex = Mutex.new
+          @thread_context_collector = thread_context_collector
         end
 
         #: () -> (nil | true)
@@ -37,7 +39,7 @@ module Datadog
             @worker_thread = Thread.new do
               Thread.current.name = self.class.name
 
-              self.class._native_idle_sampling_loop(self)
+              self.class._native_idle_sampling_loop(self, @thread_context_collector)
 
               Datadog.logger.debug("IdleSamplingHelper thread stopping cleanly")
             rescue Exception => e # rubocop:disable Lint/RescueException

data/lib/datadog/profiling/collectors/thread_context.rb

@@ -33,6 +33,7 @@ module Datadog
             waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
             otel_context_enabled: otel_context_enabled,
             native_filenames_enabled: validate_native_filenames(native_filenames_enabled),
+            overhead_filename: __FILE__,
           )
         end
 

data/lib/datadog/profiling/component.rb

@@ -141,15 +141,14 @@ module Datadog
         # that causes a segmentation fault during garbage collection of Ractors
         # (https://bugs.ruby-lang.org/issues/18464). We don't allow enabling gc profiling on such Rubies.
         # This bug is fixed on Ruby versions 3.1.4, 3.2.3 and 3.3.0.
-        if RUBY_VERSION.start_with?("3.0.") ||
-            (RUBY_VERSION.start_with?("3.1.") && RUBY_VERSION < "3.1.4") ||
-            (RUBY_VERSION.start_with?("3.2.") && RUBY_VERSION < "3.2.3")
+        if RubyVersion.is?(">= 3", "< 3.1.4") ||
+            RubyVersion.is?(">= 3.2", "< 3.2.3")
           logger.warn(
             "Current Ruby version (#{RUBY_VERSION}) has a VM bug where enabling GC profiling would cause " \
             "crashes (https://bugs.ruby-lang.org/issues/18464). GC profiling has been disabled."
           )
           return false
-        elsif RUBY_VERSION.start_with?("3.")
+        elsif RubyVersion.is?(">= 3", "< 4")
           logger.debug(
             "Using Ractors may result in GC profiling unexpectedly " \
             "stopping (https://bugs.ruby-lang.org/issues/19112). Note that this stop has no impact in your " \
@@ -177,7 +176,7 @@ module Datadog
         # Ruby 3.2.0 to 3.2.2 have a bug in the newobj tracepoint (https://bugs.ruby-lang.org/issues/19482,
         # https://github.com/ruby/ruby/pull/7464) that makes this crash in any configuration. This bug is
         # fixed on Ruby versions 3.2.3 and 3.3.0.
-        if RUBY_VERSION.start_with?("3.2.") && RUBY_VERSION < "3.2.3"
+        if RubyVersion.is?(">= 3.2", "< 3.2.3")
           logger.warn(
             "Allocation profiling is not supported in Ruby versions 3.2.0, 3.2.1 and 3.2.2 and will be forcibly " \
             "disabled. This is due to a VM bug that can lead to crashes (https://bugs.ruby-lang.org/issues/19482). " \
@@ -191,9 +190,8 @@ module Datadog
         # that causes a segmentation fault during garbage collection of Ractors
         # (https://bugs.ruby-lang.org/issues/18464). We don't recommend using this feature on such Rubies.
         # This bug is fixed on Ruby versions 3.1.4, 3.2.3 and 3.3.0.
-        if RUBY_VERSION.start_with?("3.0.") ||
-            (RUBY_VERSION.start_with?("3.1.") && RUBY_VERSION < "3.1.4") ||
-            (RUBY_VERSION.start_with?("3.2.") && RUBY_VERSION < "3.2.3")
+        if RubyVersion.is?(">= 3", "< 3.1.4") ||
+            RubyVersion.is?(">= 3.2", "< 3.2.3")
           logger.warn(
             "Current Ruby version (#{RUBY_VERSION}) has a VM bug where enabling allocation profiling while using " \
             "Ractors may cause unexpected issues, including crashes (https://bugs.ruby-lang.org/issues/18464). " \
@@ -202,7 +200,7 @@ module Datadog
         # ANNOYANCE - Only with Ractors
         # On all known versions of Ruby 3.x, due to https://bugs.ruby-lang.org/issues/19112, when a ractor gets
         # garbage collected, Ruby will disable all active tracepoints, which this feature internally relies on.
-        elsif RUBY_VERSION.start_with?("3.")
+        elsif RubyVersion.is?(">= 3", "< 4")
           logger.debug(
             "Using Ractors may result in allocation profiling " \
             "stopping (https://bugs.ruby-lang.org/issues/19112). Note that this stop has no impact in your " \
@@ -220,7 +218,7 @@ module Datadog
 
         return false unless heap_profiling_enabled
 
-        if RUBY_VERSION < "3.1"
+        if RubyVersion.is?("< 3.1")
           logger.warn(
             "Current Ruby version (#{RUBY_VERSION}) cannot support heap profiling due to VM limitations. " \
             "Please upgrade to Ruby >= 3.1 in order to use this feature. Heap profiling has been disabled."
@@ -262,7 +260,7 @@ module Datadog
         end
 
         if setting_value == false
-          if RUBY_VERSION.start_with?("2.5.")
+          if RubyVersion.is?("< 2.6")
             logger.warn(
               'The profiling "no signals" workaround has been disabled via configuration on Ruby 2.5. ' \
               "This is not recommended " \
@@ -288,7 +286,7 @@ module Datadog
         # Setting is in auto mode. Let's probe to see if we should enable it:
 
         # We don't warn users in this situation because "upgrade your Ruby" is not a great warning
-        return true if RUBY_VERSION.start_with?("2.5.")
+        return true if RubyVersion.is?("< 2.6")
 
         if Gem.loaded_specs["mysql2"] && incompatible_libmysqlclient_version?(settings, logger)
           logger.warn(
@@ -450,13 +448,13 @@ module Datadog
       end
 
       private_class_method def self.dir_interruption_workaround_enabled?(settings, no_signals_workaround_enabled)
-        return false if no_signals_workaround_enabled || RUBY_VERSION >= "3.4"
+        return false if no_signals_workaround_enabled || RubyVersion.is?(">= 3.4")
 
         settings.profiling.advanced.dir_interruption_workaround_enabled
       end
 
       private_class_method def self.can_apply_exec_monkey_patch?(settings)
-        return false if RUBY_VERSION < "2.7"
+        return false if RubyVersion.is?("< 2.7")
 
         # This file is 2.7+ only so we only require it here once we've checked the Ruby version
         require "datadog/profiling/ext/exec_monkey_patch"
@@ -465,7 +463,7 @@ module Datadog
       end
 
       private_class_method def self.enable_gvl_profiling?(settings, logger)
-        RUBY_VERSION >= "3.2" && settings.profiling.advanced.gvl_enabled
+        RubyVersion.is?(">= 3.2") && settings.profiling.advanced.gvl_enabled
       end
     end
   end

data/lib/datadog/profiling/ext/dir_monkey_patches.rb

@@ -28,7 +28,7 @@ module Datadog
         end
       end
 
-      if RUBY_VERSION.start_with?("2.")
+      if RubyVersion.is?("< 3")
         # Monkey patches for Dir.singleton_class (Ruby 2 version). See DirMonkeyPatches above for more details.
         module DirClassMonkeyPatches
           # Steep: Workaround that defines args and block only for Ruby 2.x.
@@ -270,7 +270,7 @@ module Datadog
         end
       end
 
-      if RUBY_VERSION.start_with?("2.")
+      if RubyVersion.is?("< 3")
         # Monkey patches for Dir (Ruby 2 version). See DirMonkeyPatches above for more details.
         module DirInstanceMonkeyPatches
           # Steep: Workaround that defines args and block only for Ruby 2.x.
@@ -300,7 +300,7 @@ module Datadog
             end
           end
 
-          unless RUBY_VERSION.start_with?("2.5.") # This is Ruby 2.6+
+          if RubyVersion.is?(">= 2.6.0") # This method is Ruby 2.6+
             # See note on methods that yield above.
             def each_child(*args, &block)
               if block

data/lib/datadog/ruby_version.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Datadog
+  # Compares the running Ruby against version requirements.
+  #
+  # Lexical comparisons against `RUBY_VERSION` are subtly wrong: `RUBY_VERSION < "3.2.3"` is also
+  # `true` on 3.2.10 and 3.2.11, since those sort *before* "3.2.3" as strings.
+  #
+  # @example
+  #   RubyVersion.is?(">= 3.2", "< 3.2.3") # => true on Ruby 3.2.0, 3.2.1, 3.2.2 (NOT 3.2.3+, NOT 3.2.10+)
+  module RubyVersion
+    extend RubyVersion # steep currently needs this (instead of extend self or def self.is?) for the inline rbs to work
+
+    CURRENT_RUBY_VERSION = Gem::Version.new(RUBY_VERSION) #: ::Gem::Version
+    private_constant :CURRENT_RUBY_VERSION
+
+    # Returns `true` when the running Ruby satisfies ALL of the given requirements. Each uses the
+    # same syntax as a gem dependency (e.g. `">= 3.1"`, `">= 3.2"`, `"< 3.2.3"`).
+    #
+    # @rbs (*String requirements, ?ruby_version: ::Gem::Version) -> bool
+    def is?(*requirements, ruby_version: CURRENT_RUBY_VERSION)
+      Gem::Requirement.new(*requirements).satisfied_by?(ruby_version)
+    end
+  end
+end