datadog 2.36.0 → 2.38.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.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(
@@ -170,11 +170,16 @@ module Datadog
 
             @wait_until_running_condition.wait(@wait_until_running_mutex, timeout_seconds)
 
+            # Not using `_native_is_running?(self) || raise(...)` here: `_native_is_running?` is declared
+            # to return `bool`, so steep infers the `||` expression as `bool` too and rejects it against
+            # this method's declared `true` return type. The explicit `if`/`else` type-checks correctly.
+            # rubocop:disable Style/RedundantCondition
             if self.class._native_is_running?(self)
               true
             else
               raise "Timeout waiting for #{self.class.name} to start (waited for #{timeout_seconds} seconds)"
             end
+            # rubocop:enable Style/RedundantCondition
           end
         end
 

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

@@ -45,9 +45,10 @@ module Datadog
           waiting_for_gvl_threshold_ns: 10_000_000,
           otel_context_enabled: false,
           native_filenames_enabled: true,
+          trigger_global_reset: true,
           **options
         )
-          new(
+          collector = new(
             recorder: recorder,
             max_frames: max_frames,
             tracer: tracer,
@@ -57,6 +58,13 @@ module Datadog
             native_filenames_enabled: native_filenames_enabled,
             **options,
           )
+
+          # By default, mirror what the CpuAndWallTimeWorker does when profiling starts: reset the global per-thread
+          # context state, which (among other things) resizes the per-thread sampling buffers to this collector's
+          # max_frames. Tests that need to control this explicitly can pass `trigger_global_reset: false`.
+          Testing._native_global_reset_per_thread_context(collector) if trigger_global_reset
+
+          collector
         end
 
         def inspect

data/lib/datadog/profiling/component.rb

@@ -226,6 +226,15 @@ module Datadog
           return false
         end
 
+        # Heap profiling relies on `ObjectSpace._id2ref`, which was removed on Ruby 4.1
+        # (https://bugs.ruby-lang.org/issues/22135).
+        if RubyVersion.is?(">= 4.1")
+          logger.warn(
+            "Heap profiling is currently incompatible with Ruby 4.1+ and has been disabled."
+          )
+          return false
+        end
+
         unless allocation_profiling_enabled
           logger.warn(
             "Heap profiling was requested but allocation profiling is not enabled. " \
@@ -244,6 +253,14 @@ module Datadog
 
         return false unless heap_profiling_enabled && heap_size_profiling_enabled
 
+        if RubyVersion.is?(">= 4")
+          logger.info(
+            "Heap live size profiling is currently incompatible with Ruby 4 and has been disabled. " \
+            "Heap live objects is not affected and remains enabled."
+          )
+          return false
+        end
+
         true
       end