datadog 2.38.0 → 2.47.0

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

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
-require_relative 'aggregator'
-require_relative '../../core/encoding'
-require_relative '../../core/evp'
-require_relative '../../core/utils/time'
-require_relative '../../core/workers/async'
+require "digest"
+
+require_relative "aggregator"
+require_relative "../ext"
+require_relative "../../core/encoding"
+require_relative "../../core/evp"
+require_relative "../../core/utils/time"
+require_relative "../../core/workers/async"
 
 module Datadog
   module OpenFeature
@@ -29,15 +32,27 @@ module Datadog
         QUEUE_SIZE = 4_096
         MAX_DRAIN_EVENTS_PER_CYCLE = 1_024
         PAYLOAD_SIZE_LIMIT_BYTES = Core::EVP::PAYLOAD_SIZE_LIMIT_BYTES
-        TELEMETRY_NAMESPACE = 'tracers'
-        ROWS_DROPPED_METRIC = 'flagevaluation.rows.dropped'
-        ROWS_DEGRADED_METRIC = 'flagevaluation.rows.degraded'
-        PAYLOAD_SPLITS_METRIC = 'flagevaluation.payload.splits'
-
-        REASON_QUEUE_OVERFLOW = 'queue_overflow'
-        REASON_DEGRADED_CAP = 'degraded_cap'
-        REASON_CARDINALITY_CAP = 'cardinality_cap'
-        REASON_PAYLOAD_LIMIT = 'payload_limit'
+        TELEMETRY_NAMESPACE = "tracers"
+        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
 
@@ -98,7 +126,7 @@ module Datadog
 
           return true if join(SHUTDOWN_TIMEOUT_SECONDS)
 
-          @logger.debug { 'OpenFeature EVP: writer did not stop gracefully; terminating worker thread' }
+          @logger.debug { "OpenFeature EVP: writer did not stop gracefully; terminating worker thread" }
           terminate
         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 ' \
+            "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,50 +380,81 @@ 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},
-            'first_evaluation' => entry[:first_evaluation],
-            'last_evaluation' => entry[:last_evaluation],
-            'evaluation_count' => entry[:count],
+            "timestamp" => flush_time_ms,
+            "flag" => {"key" => flag_key},
+            "first_evaluation" => entry[:first_evaluation],
+            "last_evaluation" => entry[:last_evaluation],
+            "evaluation_count" => entry[:count],
           }
 
-          event['runtime_default_used'] = true if entry[:runtime_default]
-          event['error'] = {'message' => entry[:error_message]} if entry[:error_message] && !entry[:error_message].empty?
+          event["runtime_default_used"] = true if entry[:runtime_default]
+
+          # 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?
+          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?
-              event['context'] = {'evaluation' => entry[:context_attrs]}
+            if observe_full_evaluation_data && entry[:context_attrs] && !entry[:context_attrs].empty?
+              event["context"] = {"evaluation" => entry[:context_attrs]}
             end
           end
 
           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\":["
-          payload_suffix = ']}'
+          payload_suffix = "]}"
           base_payload_size = payload_prefix.bytesize + payload_suffix.bytesize
 
           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,15 +479,16 @@ 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)
           response = @transport.send_flag_evaluations(
             {
-              'context' => @service_context,
-              'flagEvaluations' => events,
+              "context" => @service_context,
+              "flagEvaluations" => events,
             }
           )
           if response.respond_to?(:ok?) && !response.ok?
@@ -402,20 +517,16 @@ module Datadog
         end
 
         def degrade_event_for_payload_limit(event)
-          return unless event.key?('targeting_key') || event.key?('context')
+          return unless event.key?("targeting_key") || event.key?("context")
 
           degraded = event.dup
-          degraded.delete('targeting_key')
-          degraded.delete('context')
+          degraded.delete("targeting_key")
+          degraded.delete("context")
           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 = event["evaluation_count"].to_i
           count.positive? ? count : 1
         end
 

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenFeature
+    module Hooks
+      class EvaluationTelemetryOptOutHook
+        PARAMETER = "dd_evaluation_telemetry_opt_out"
+
+        def self.opted_out?(evaluation_context)
+          evaluation_context&.fields&.[](PARAMETER).equal?(true)
+        end
+
+        def initialize(hook)
+          @hook = hook
+        end
+
+        def finally(hook_context:, evaluation_details:, **options)
+          return if self.class.opted_out?(hook_context.evaluation_context)
+
+          @hook.finally(hook_context: hook_context, evaluation_details: evaluation_details, **options)
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../ext"
+
 module Datadog
   module OpenFeature
     module Hooks
@@ -13,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)
@@ -37,18 +37,34 @@ module Datadog
           # Eval-time stamped by the provider at eval-entry time; fall back to hook-fire time.
           # Metadata key: 'dd.eval.timestamp_ms' (int, ms since epoch) — stamped at eval entry.
           metadata = evaluation_details.flag_metadata
-          eval_time_ms = metadata.is_a?(Hash) ? metadata['dd.eval.timestamp_ms'] : nil
+          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
 
@@ -70,30 +86,18 @@ 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
 
-        # Same key as OTel hook ('__dd_allocation_key') — do not diverge.
         def extract_allocation_key(evaluation_details)
           metadata = evaluation_details.flag_metadata
           return unless metadata.is_a?(Hash)
 
-          metadata['__dd_allocation_key']
+          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/hooks/flag_eval_metrics_hook.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../ext"
+
 module Datadog
   module OpenFeature
     module Hooks
@@ -41,7 +43,7 @@ module Datadog
           metadata = evaluation_details.flag_metadata
           return unless metadata.is_a?(Hash)
 
-          metadata['__dd_allocation_key']
+          metadata[Ext::METADATA_ALLOCATION_KEY]
         end
       end
     end