datadog 2.41.0 → 2.42.0

data/lib/datadog/open_feature/flag_evaluation/writer.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+require "digest"
+
 require_relative "aggregator"
+require_relative "../ext"
 require_relative "../../core/encoding"
 require_relative "../../core/evp"
 require_relative "../../core/utils/time"
@@ -33,11 +36,23 @@ module Datadog
         ROWS_DROPPED_METRIC = "flagevaluation.rows.dropped"
         ROWS_DEGRADED_METRIC = "flagevaluation.rows.degraded"
         PAYLOAD_SPLITS_METRIC = "flagevaluation.payload.splits"
+        CONTEXT_TRUNCATED_METRIC = "flagevaluation.context.truncated"
 
         REASON_QUEUE_OVERFLOW = "queue_overflow"
         REASON_DEGRADED_CAP = "degraded_cap"
         REASON_CARDINALITY_CAP = "cardinality_cap"
         REASON_PAYLOAD_LIMIT = "payload_limit"
+        REASON_PRE_QUEUE_OVERFLOW = "pre_queue_overflow"
+        REASON_SERIALIZATION_ERROR = "serialization_error"
+        REASON_SNAPSHOT_ERROR = "snapshot_error"
+
+        # Must equal OpenFeature::SDK::EvaluationContext::TARGETING_KEY. Duplicated as a
+        # literal rather than referenced because the SDK is an optional dependency and
+        # this file loads without it. If the two drift, the targeting key stops being
+        # excluded from the context snapshot and lands in context.evaluation as raw PII,
+        # so a spec asserts the equality.
+        TARGETING_KEY_FIELD = "targeting_key"
+        TARGETING_KEY_HASH_PREFIX = "sha256_"
 
         # Service context fields for the batch wrapper.
         attr_reader :service_context
@@ -56,6 +71,9 @@ module Datadog
           @stop_cond = ConditionVariable.new
           @stopped = false
           @dropped_queue_overflow = 0
+          @dropped_pre_queue_overflow = 0
+          @context_truncated_counts = Hash.new(0)
+          @context_snapshot_error_logged = false
 
           self.fork_policy = Core::Workers::Async::Thread::FORK_POLICY_RESTART
 
@@ -64,27 +82,37 @@ module Datadog
         end
 
         # Non-blocking enqueue from the finally hook. Drops + counts on overflow.
-        # Context flattening/pruning runs in the background writer, not on the caller eval thread.
-        def enqueue(**event)
+        def enqueue(
+          flag_key:, eval_time_ms:, variant: nil, allocation_key: nil, error_message: nil,
+          runtime_default: nil, targeting_key: nil, attrs: nil, observe_full_evaluation_data: false,
+          **_event
+        )
           start_background_thread if forked?
 
-          attrs = event[:attrs]
-          attrs = attrs.is_a?(Hash) ? snapshot_context_value(attrs, {}, 0) || {} : {}
+          # Avoid snapshot work when the queue is already full.
+          if @queue.size >= QUEUE_SIZE
+            @stop_mutex.synchronize { @dropped_pre_queue_overflow += 1 }
+            return
+          end
+
+          observe_full_evaluation_data = observe_full_evaluation_data == true
+          attrs = observe_full_evaluation_data ? snapshot_context(attrs) : nil
           bounded_event = {
-            flag_key: event[:flag_key],
-            variant: event[:variant],
-            allocation_key: event[:allocation_key],
-            error_message: event[:error_message],
-            runtime_default: event[:runtime_default],
-            targeting_key: event[:targeting_key],
-            eval_time_ms: event[:eval_time_ms],
+            flag_key: snapshot_string(flag_key),
+            variant: snapshot_string(variant),
+            allocation_key: snapshot_string(allocation_key),
+            error_message: normalized_error_code(error_message),
+            runtime_default: runtime_default,
+            targeting_key: snapshot_targeting_key(targeting_key),
+            eval_time_ms: snapshot_integer(eval_time_ms),
             attrs: attrs,
+            observe_full_evaluation_data: observe_full_evaluation_data,
           }
           @queue.push(bounded_event, true)
+          @stop_mutex.synchronize { @stop_cond.signal }
           start_background_thread unless running?
         rescue ThreadError
-          # Queue full — drop and count (best-effort, same as Go: drop-and-count). The count is
-          # emitted on the next flush so backpressure is observable, not silently lost.
+          # Report queue backpressure on the next flush.
           @stop_mutex.synchronize { @dropped_queue_overflow += 1 }
         end
 
@@ -111,45 +139,81 @@ module Datadog
           @stop_cond = ConditionVariable.new
           @stopped = false
           @dropped_queue_overflow = 0
+          @dropped_pre_queue_overflow = 0
+          @context_truncated_counts = Hash.new(0)
+          @context_snapshot_error_logged = false
         end
 
         private
 
+        def snapshot_context(attrs)
+          return {} unless attrs.is_a?(Hash)
+
+          snapshot, reasons = Aggregator.bounded_context_snapshot(attrs, excluded_key: TARGETING_KEY_FIELD)
+          unless reasons.empty?
+            @stop_mutex.synchronize { reasons.each { |reason| @context_truncated_counts[reason] += 1 } }
+          end
+          snapshot
+        rescue => e
+          # Context handling runs in the finally hook and must not interrupt flag evaluation.
+          should_log = false
+          @stop_mutex.synchronize do
+            @context_truncated_counts[REASON_SNAPSHOT_ERROR] += 1
+            unless @context_snapshot_error_logged
+              @context_snapshot_error_logged = true
+              should_log = true
+            end
+          end
+          @logger.debug { "OpenFeature EVP: context snapshot error: #{e.class}" } if should_log
+          {}
+        end
+
         def build_service_context
           config = Datadog.configuration
-          ctx = {"service" => config.service.to_s}
-          ctx["env"] = config.env if config.env && !config.env.empty?
-          ctx["version"] = config.version if config.version && !config.version.empty?
+          ctx = {"service" => snapshot_string(config.service) || ""}
+          env = snapshot_string(config.env)
+          version = snapshot_string(config.version)
+          ctx["env"] = env if env && !env.empty?
+          ctx["version"] = version if version && !version.empty?
           ctx
         end
 
-        def snapshot_context_value(value, seen, depth)
-          return if depth > Aggregator::MAX_CONTEXT_DEPTH
+        def snapshot_string(value)
+          return unless value
 
-          case value
-          when Hash
-            object_id = value.object_id
-            return if seen[object_id]
+          string = value.is_a?(String) ? value : value.to_s
+          String.new(string).encode(Encoding::UTF_8, invalid: :replace, undef: :replace).freeze
+        rescue
+          # Unsupported caller values must not break flag evaluation.
+          nil
+        end
 
-            seen[object_id] = true
-            value.each_with_object({}) do |(key, child_value), snapshot|
-              snapshot[key.is_a?(String) ? key.dup : key] = snapshot_context_value(child_value, seen, depth + 1)
-            end.tap { seen.delete(object_id) }
-          when Array
-            object_id = value.object_id
-            return if seen[object_id]
+        def snapshot_targeting_key(value)
+          return unless value.is_a?(String)
 
-            seen[object_id] = true
-            value.map { |child_value| snapshot_context_value(child_value, seen, depth + 1) }.tap { seen.delete(object_id) }
-          when String
-            value.dup
-          else
-            begin
-              value.dup
-            rescue TypeError
-              value
-            end
-          end
+          string = String.new(value)
+          return unless string.valid_encoding?
+
+          string.encode!(Encoding::UTF_8)
+          string.freeze
+        rescue EncodingError
+          nil
+        end
+
+        def snapshot_integer(value)
+          integer = value.to_i
+          integer.is_a?(Integer) ? integer : 0
+        rescue
+          0
+        end
+
+        def normalized_error_code(value)
+          error_code = snapshot_string(value)
+          # Preserve absence so evaluations without errors omit the error field.
+          return error_code if !error_code || error_code.empty?
+          return error_code if Ext::STANDARD_ERROR_CODES.include?(error_code)
+
+          Ext::GENERAL
         end
 
         def start_background_thread
@@ -189,7 +253,7 @@ module Datadog
 
         def wait_for_next_cycle
           @stop_mutex.synchronize do
-            return if @stopped
+            return if @stopped || !@queue.empty?
 
             @stop_cond.wait(@stop_mutex, DRAIN_INTERVAL_SECONDS)
           end
@@ -215,9 +279,10 @@ module Datadog
                 allocation_key: event[:allocation_key],
                 targeting_key: event[:targeting_key],
                 eval_time_ms: event[:eval_time_ms].to_i,
-                attrs: event[:attrs].is_a?(Hash) ? event[:attrs] : {},
+                attrs: event[:attrs],
                 error_message: event[:error_message],
                 runtime_default: event[:runtime_default],
+                observe_full_evaluation_data: event[:observe_full_evaluation_data],
               )
               drained += 1
             rescue ThreadError
@@ -230,12 +295,17 @@ module Datadog
         def flush_once
           snapshot = @aggregator.flush_and_reset
           dropped_overflow = snapshot[:dropped_degraded_overflow].to_i
-          dropped_queue = take_dropped_queue_overflow
+          dropped_queue = read_and_reset_dropped_queue_overflow
+          dropped_pre_queue = read_and_reset_dropped_pre_queue_overflow
+          context_truncated_counts = read_and_reset_context_truncated_counts
 
-          emit_drop_counts(dropped_queue, dropped_overflow)
+          emit_drop_counts(dropped_queue, dropped_overflow, dropped_pre_queue)
+          context_truncated_counts.each do |reason, count|
+            record_telemetry_count(CONTEXT_TRUNCATED_METRIC, count, reason: reason)
+          end
 
           events = build_events(snapshot)
-          emit_degraded_counts(snapshot[:degraded].values.sum { |entry| entry[:count].to_i })
+          record_telemetry_count(ROWS_DEGRADED_METRIC, snapshot[:degraded].values.sum { |entry| entry[:count].to_i }, reason: REASON_CARDINALITY_CAP)
           return if events.empty?
 
           send_payload_batches(events)
@@ -243,8 +313,7 @@ module Datadog
           @logger.debug { "OpenFeature EVP: flush error: #{e.class}: #{e.message}" }
         end
 
-        # Read-and-reset the queue-overflow drop counter under the stop mutex.
-        def take_dropped_queue_overflow
+        def read_and_reset_dropped_queue_overflow
           @stop_mutex.synchronize do
             count = @dropped_queue_overflow
             @dropped_queue_overflow = 0
@@ -252,32 +321,45 @@ module Datadog
           end
         end
 
+        def read_and_reset_dropped_pre_queue_overflow
+          @stop_mutex.synchronize do
+            count = @dropped_pre_queue_overflow
+            @dropped_pre_queue_overflow = 0
+            count
+          end
+        end
+
+        def read_and_reset_context_truncated_counts
+          @stop_mutex.synchronize do
+            counts = @context_truncated_counts
+            @context_truncated_counts = Hash.new(0)
+            counts
+          end
+        end
+
         # Emit (log) the observable drop counts so backpressure is never silently lost.
         # Σ(emitted tier counts + these drops) == evaluations processed.
-        def emit_drop_counts(dropped_queue, dropped_overflow)
-          return if dropped_queue.zero? && dropped_overflow.zero?
+        def emit_drop_counts(dropped_queue, dropped_overflow, dropped_pre_queue)
+          return if dropped_queue.zero? && dropped_overflow.zero? && dropped_pre_queue.zero?
 
+          record_telemetry_count(ROWS_DROPPED_METRIC, dropped_pre_queue, reason: REASON_PRE_QUEUE_OVERFLOW)
           record_telemetry_count(ROWS_DROPPED_METRIC, dropped_queue, reason: REASON_QUEUE_OVERFLOW)
           record_telemetry_count(ROWS_DROPPED_METRIC, dropped_overflow, reason: REASON_DEGRADED_CAP)
 
           @logger.debug do
             "OpenFeature EVP: dropped events " \
+              "pre_queue_overflow=#{dropped_pre_queue} " \
               "queue_overflow=#{dropped_queue} degraded_overflow=#{dropped_overflow}"
           end
         end
 
-        def emit_degraded_counts(degraded_count)
-          record_telemetry_count(ROWS_DEGRADED_METRIC, degraded_count, reason: REASON_CARDINALITY_CAP)
-        end
-
         # Build flagEvaluationEvent list from aggregation snapshot.
-        # Full-tier entries include all optional fields; degraded entries omit targeting_key + context.
         def build_events(snapshot)
           flush_time_ms = (Core::Utils::Time.now.to_f * 1000).to_i
           events = []
 
           snapshot[:full].each do |key, entry|
-            flag_key, variant, allocation_key, _runtime_default, _error_message, targeting_key, _ctx_key = key
+            flag_key, variant, allocation_key, _runtime_default, _error_message, targeting_key, _ctx_key, _observe_full_evaluation_data = key
             event = build_event(
               flag_key: flag_key, variant: variant, allocation_key: allocation_key,
               targeting_key: targeting_key, entry: entry, flush_time_ms: flush_time_ms, tier: :full,
@@ -285,8 +367,9 @@ module Datadog
             events << event
           end
 
+          # Degraded rows omit targeting_key and context, so the policy is not a key dimension.
           snapshot[:degraded].each do |key, entry|
-            flag_key, variant, allocation_key, _runtime_default, _error_message = key
+            flag_key, variant, allocation_key, _runtime_default, _error_dimension = key
             event = build_event(
               flag_key: flag_key, variant: variant, allocation_key: allocation_key,
               targeting_key: nil, entry: entry, flush_time_ms: flush_time_ms, tier: :degraded,
@@ -297,8 +380,11 @@ module Datadog
           events
         end
 
-        def build_event(flag_key:, variant:, allocation_key:, targeting_key:, entry:, flush_time_ms:, tier:)
-          # @type var event: ::Hash[::String, untyped]
+        def build_event(
+          flag_key:, variant:, allocation_key:, targeting_key:, entry:, flush_time_ms:, tier:
+        )
+          observe_full_evaluation_data = entry[:observe_full_evaluation_data]
+          # @type var event: ::Hash[::String, any]
           event = {
             "timestamp" => flush_time_ms,
             "flag" => {"key" => flag_key},
@@ -308,18 +394,30 @@ module Datadog
           }
 
           event["runtime_default_used"] = true if entry[:runtime_default]
-          event["error"] = {"message" => entry[:error_message]} if entry[:error_message] && !entry[:error_message].empty?
+
+          # EVP uses the normalized code as error.message and an aggregation dimension.
+          error_message = entry[:error_message]
+          if error_message && !error_message.empty?
+            event["error"] = {"message" => error_message}
+          end
 
           # variant + allocation are present in both tiers (omitempty per schema).
           event["variant"] = {"key" => variant} if variant && !variant.empty?
           event["allocation"] = {"key" => allocation_key} if allocation_key && !allocation_key.empty?
 
-          # Full-tier additionally carries targeting_key + the pruned evaluation context;
+          # Full-tier additionally carries targeting_key and the truncated evaluation context;
           # the degraded tier omits both.
           if tier == :full
-            event["targeting_key"] = targeting_key if targeting_key && !targeting_key.empty?
+            unless targeting_key.nil?
+              event["targeting_key"] =
+                if targeting_key.empty? || observe_full_evaluation_data
+                  targeting_key
+                else
+                  prefixed_targeting_key_digest(targeting_key)
+                end
+            end
 
-            if entry[:context_attrs] && !entry[:context_attrs].empty?
+            if observe_full_evaluation_data && entry[:context_attrs] && !entry[:context_attrs].empty?
               event["context"] = {"evaluation" => entry[:context_attrs]}
             end
           end
@@ -327,6 +425,14 @@ module Datadog
           event
         end
 
+        # Encode to UTF-8 first so Ruby encodings do not change the digest.
+        # Distinct from SpanEnrichmentHook::Codec.hash_targeting_key, which emits a
+        # bare digest for a different wire format on the span track.
+        def prefixed_targeting_key_digest(targeting_key)
+          utf8 = targeting_key.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+          TARGETING_KEY_HASH_PREFIX + Digest::SHA256.hexdigest(utf8)
+        end
+
         def send_payload_batches(events)
           context_json = Core::Encoding::JSONEncoder.encode(@service_context)
           payload_prefix = "{\"context\":#{context_json},\"flagEvaluations\":["
@@ -336,11 +442,19 @@ module Datadog
           batch = []
           batch_size = base_payload_size
           dropped_oversized = 0
+          dropped_serialization = 0
           payload_limit_degraded = 0
           payload_splits = 0
 
           events.each do |event|
-            encoded_event = encoded_event_for_payload(event, base_payload_size)
+            begin
+              encoded_event = encoded_event_for_payload(event, base_payload_size)
+            rescue => e
+              # Keep one malformed event from discarding the complete flush snapshot.
+              dropped_serialization += event_count(event)
+              @logger.debug { "OpenFeature EVP: dropped event serialization_error=#{e.class}" }
+              next
+            end
             unless encoded_event
               dropped_oversized += event_count(event)
               next
@@ -365,8 +479,9 @@ module Datadog
           send_payload_batch(batch) unless batch.empty?
           record_telemetry_count(ROWS_DEGRADED_METRIC, payload_limit_degraded, reason: REASON_PAYLOAD_LIMIT)
           record_telemetry_count(ROWS_DROPPED_METRIC, dropped_oversized, reason: REASON_PAYLOAD_LIMIT)
+          record_telemetry_count(ROWS_DROPPED_METRIC, dropped_serialization, reason: REASON_SERIALIZATION_ERROR)
           record_telemetry_count(PAYLOAD_SPLITS_METRIC, payload_splits)
-          emit_payload_oversize_drops(dropped_oversized) if dropped_oversized.positive?
+          @logger.debug { "OpenFeature EVP: dropped events payload_oversize=#{dropped_oversized}" } if dropped_oversized.positive?
         end
 
         def send_payload_batch(events)
@@ -410,10 +525,6 @@ module Datadog
           degraded
         end
 
-        def emit_payload_oversize_drops(dropped_oversized)
-          @logger.debug { "OpenFeature EVP: dropped events payload_oversize=#{dropped_oversized}" }
-        end
-
         def event_count(event)
           count = event["evaluation_count"].to_i
           count.positive? ? count : 1

data/lib/datadog/open_feature/hooks/flag_eval_evp_hook.rb

@@ -15,8 +15,6 @@ module Datadog
       # stay on the OTel path. This hook is registered as a provider hook so it receives
       # the SDK-final EvaluationDetails after hook failures and type validation.
       class FlagEvalEVPHook
-        TYPE_MISMATCH_ERROR_CODE = "TYPE_MISMATCH"
-
         # Include the Hook module if available (SDK >= 0.5.0) for interface documentation
         # and default implementations of other hook methods (before, after, error)
         include ::OpenFeature::SDK::Hooks::Hook if defined?(::OpenFeature::SDK::Hooks::Hook)
@@ -42,15 +40,31 @@ module Datadog
           eval_time_ms = metadata.is_a?(Hash) ? metadata["dd.eval.timestamp_ms"] : nil
           eval_time_ms ||= (Core::Utils::Time.now.to_f * 1000).to_i
 
+          # observe_full_evaluation_data travels on the event metadata (stamped from
+          # the UFC the evaluation ran against), never read from live config.
+          observe_full_evaluation_data = metadata.is_a?(Hash) ? metadata[Ext::METADATA_OBSERVE_FULL_EVALUATION_DATA] : nil
+          observe_full_evaluation_data = false unless observe_full_evaluation_data == true
+
+          attrs = if observe_full_evaluation_data
+            extract_attributes(hook_context.evaluation_context)
+          end
+
+          # Raw messages may contain high-cardinality data, so only error codes enter EVP.
+          reason = evaluation_details.reason.to_s
+          runtime_default = runtime_default_reason?(reason)
+          error_code = evaluation_details.error_code
+          error_code = Ext::GENERAL if reason == Ext::ERROR && error_code.to_s.empty?
+
           writer.enqueue(
             flag_key: hook_context.flag_key,
-            variant: evaluation_details.variant,
-            allocation_key: extract_allocation_key(evaluation_details),
-            error_message: extract_error_message(evaluation_details),
-            runtime_default: runtime_default?(evaluation_details),
+            variant: runtime_default ? nil : evaluation_details.variant,
+            allocation_key: runtime_default ? nil : extract_allocation_key(evaluation_details),
+            error_message: error_code,
+            runtime_default: runtime_default,
             targeting_key: extract_targeting_key(hook_context.evaluation_context),
             eval_time_ms: eval_time_ms,
-            attrs: extract_attributes(hook_context.evaluation_context),
+            attrs: attrs,
+            observe_full_evaluation_data: observe_full_evaluation_data,
           )
         end
 
@@ -72,9 +86,7 @@ module Datadog
           return {} unless evaluation_context.respond_to?(:fields)
 
           fields = evaluation_context.fields
-          return {} unless fields.is_a?(Hash)
-
-          fields.reject { |k, _| k.to_s == ::OpenFeature::SDK::EvaluationContext::TARGETING_KEY }
+          fields.is_a?(Hash) ? fields : {}
         end
 
         def extract_allocation_key(evaluation_details)
@@ -84,17 +96,8 @@ module Datadog
           metadata[Ext::METADATA_ALLOCATION_KEY]
         end
 
-        def extract_error_message(evaluation_details)
-          return unless evaluation_details.respond_to?(:error_message)
-
-          evaluation_details.error_message
-        end
-
-        def runtime_default?(evaluation_details)
-          return true if evaluation_details.variant.nil?
-          return false unless evaluation_details.respond_to?(:error_code)
-
-          evaluation_details.error_code.to_s == TYPE_MISMATCH_ERROR_CODE
+        def runtime_default_reason?(reason)
+          reason == Ext::DEFAULT || reason == Ext::ERROR
         end
       end
     end

data/lib/datadog/open_feature/native_evaluator.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "json"
 require_relative "../core/feature_flags"
 require_relative "ext"
 require_relative "resolution_details"
@@ -15,8 +16,11 @@ module Datadog
       #       in the format expected by `libdatadog` without any modifications
       def initialize(configuration)
         @configuration = Core::FeatureFlags::Configuration.new(configuration)
+        @observe_full_evaluation_data = parse_observe_full_evaluation_data(configuration)
       end
 
+      attr_reader :observe_full_evaluation_data
+
       # Returns the assignment for a given flag key based on the feature flags
       # configuration
       #
@@ -27,21 +31,44 @@ module Datadog
       # @param context [Hash] The context of the evaluation, containing targeting key
       #                       and other attributes
       #
-      # @return [Core::FeatureFlags::ResolutionDetails] The assignment for the flag
+      # @return [ResolutionDetails] The assignment for the flag
       def get_assignment(flag_key, default_value:, expected_type:, context:)
         result = @configuration.get_assignment(flag_key, expected_type, context)
 
         return invalid_flag_configuration_error(default_value) if invalid_flag_configuration?(result)
 
-        # NOTE: This is a special case when we need to fallback to the default
-        #       value, even tho the evaluation itself doesn't produce an error
-        #       resolution details
-        result.value = default_value if result.variant.nil?
-        result
+        build_resolution_details(result, default_value)
       end
 
       private
 
+      # Parse observe_full_evaluation_data from the top level of the UFC JSON (a sibling
+      # of `environment`). Absent, null, or wrong-typed values return false.
+      def parse_observe_full_evaluation_data(configuration)
+        return false unless configuration.is_a?(String) && !configuration.empty?
+
+        parsed = JSON.parse(configuration)
+        parsed.is_a?(Hash) && parsed["observeFullEvaluationData"] == true
+      rescue
+        # This secondary policy parse must not reject configuration accepted by the native evaluator.
+        false
+      end
+
+      def build_resolution_details(result, default_value)
+        ResolutionDetails.new(
+          value: result.variant.nil? ? default_value : result.value,
+          reason: result.reason,
+          variant: result.variant,
+          error_code: result.error_code,
+          error_message: result.error_message,
+          flag_metadata: result.flag_metadata,
+          allocation_key: result.allocation_key,
+          serial_id: result.serial_id,
+          log?: result.log?,
+          error?: result.error?,
+        )
+      end
+
       def invalid_flag_configuration?(result)
         result.reason == Ext::DEFAULT &&
           result.error_code.nil? &&

data/lib/datadog/open_feature/noop_evaluator.rb

@@ -7,6 +7,11 @@ module Datadog
   module OpenFeature
     # This class is a noop interface of evaluation logic
     class NoopEvaluator
+      # Privacy-preserving default before configuration is present.
+      def observe_full_evaluation_data
+        false
+      end
+
       def initialize(_configuration)
         # no-op
       end

data/lib/datadog/open_feature/provider.rb

@@ -112,6 +112,7 @@ module Datadog
         # 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
+        flag_meta = nil
 
         engine = OpenFeature.engine
         return component_not_configured_default(default_value, eval_time_ms) if engine.nil?
@@ -138,7 +139,10 @@ module Datadog
           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)
+        error_flag_meta = flag_meta
+        error_flag_meta ||= build_flag_metadata(
+          error_result, eval_time_ms || (Core::Utils::Time.now.to_f * 1000).to_i
+        )
 
         sdk_error_details(default_value, Ext::GENERAL, error_message, Ext::ERROR, error_flag_meta)
       end
@@ -173,6 +177,8 @@ module Datadog
 
       def build_flag_metadata(result, eval_time_ms)
         metadata = result.flag_metadata&.dup || {}
+        metadata[Ext::METADATA_OBSERVE_FULL_EVALUATION_DATA] =
+          metadata[Ext::METADATA_OBSERVE_FULL_EVALUATION_DATA] == true
         allocation_key = result.allocation_key
         metadata[Ext::METADATA_ALLOCATION_KEY] = allocation_key if allocation_key && !allocation_key.empty?
 
@@ -218,7 +224,10 @@ module Datadog
           error_code: Ext::PROVIDER_FATAL,
           error_message: "Datadog's OpenFeature component must be configured",
           reason: Ext::ERROR,
-          flag_metadata: {"dd.eval.timestamp_ms" => eval_time_ms}
+          flag_metadata: {
+            "dd.eval.timestamp_ms" => eval_time_ms,
+            Ext::METADATA_OBSERVE_FULL_EVALUATION_DATA => false,
+          }
         )
       end
     end

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

@@ -60,7 +60,7 @@ module Datadog
 
           if digest.trace_state || digest.trace_flags
             trace_flags = ::OpenTelemetry::Trace::TraceFlags.from_byte(digest.trace_flags)
-            tracestate = Tracing::Distributed::TraceContext.new(fetcher: nil).send(:build_tracestate, digest)
+            tracestate = Tracing::Distributed::TraceState.serialize_digest(digest)
           else
             trace_flags = if Tracing::Sampling::PrioritySampler.sampled?(digest.trace_sampling_priority)
               ::OpenTelemetry::Trace::TraceFlags::SAMPLED

data/lib/datadog/opentelemetry/trace.rb

@@ -50,6 +50,9 @@ module Datadog
             trace_service: digest.trace_service,
             trace_state: digest.trace_state,
             trace_state_unknown_fields: digest.trace_state_unknown_fields,
+            trace_otel_random_value: digest.trace_otel_random_value,
+            trace_otel_threshold: digest.trace_otel_threshold,
+            trace_otel_unknown_fields: digest.trace_otel_unknown_fields,
             span_remote: digest.span_remote,
           ).freeze
         end

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

@@ -33,6 +33,7 @@ module Datadog
         # @rbs allocation_counting_enabled: bool
         # @rbs gvl_profiling_enabled: bool
         # @rbs sighandler_sampling_enabled: bool
+        # @rbs waiting_for_gvl_threshold_ns: ::Integer
         # @rbs skip_idle_samples_for_testing: false
         # @rbs return: void
         def initialize(
@@ -45,6 +46,7 @@ module Datadog
           gvl_profiling_enabled:,
           sighandler_sampling_enabled:,
           cpu_sampling_interval_ms:,
+          waiting_for_gvl_threshold_ns:,
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
           # profiler overhead!
           dynamic_sampling_rate_enabled: true,
@@ -78,6 +80,7 @@ module Datadog
             sighandler_sampling_enabled: sighandler_sampling_enabled,
             skip_idle_samples_for_testing: skip_idle_samples_for_testing,
             cpu_sampling_interval_ms: cpu_sampling_interval_ms,
+            waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
           )
           @worker_thread = nil
           @failure_exception = nil