datadog 2.47.0 → 2.48.0

data/lib/datadog/open_feature/configuration.rb

@@ -44,7 +44,7 @@ module Datadog
 
                   Datadog.logger.warn(
                     "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED is deprecated; use " \
-                    "DD_FEATURE_FLAGS_ENABLED and DD_FEATURE_FLAGS_CONFIGURATION_SOURCE instead"
+                    "DD_FEATURE_FLAGS_ENABLED and DD_FEATURE_FLAGS_CONFIGURATION_SOURCE instead",
                   )
                 end
               end
@@ -118,7 +118,7 @@ module Datadog
                       value
                     else
                       Datadog.logger.warn(
-                        "Feature Flags agentless poll interval must be positive; using the default"
+                        "Feature Flags agentless poll interval must be positive; using the default",
                       )
                       Settings::DEFAULT_POLL_INTERVAL_SECONDS
                     end
@@ -138,7 +138,7 @@ module Datadog
                     else
                       Datadog.logger.warn(
                         "Feature Flags agentless request timeout must be within (0, " \
-                        "#{Settings::MAX_REQUEST_TIMEOUT_SECONDS}]; using the default"
+                        "#{Settings::MAX_REQUEST_TIMEOUT_SECONDS}]; using the default",
                       )
                       Settings::DEFAULT_REQUEST_TIMEOUT_SECONDS
                     end
@@ -159,7 +159,7 @@ module Datadog
                   else
                     Datadog.logger.warn(
                       "Feature Flags provider initialization timeout must be within (0, " \
-                      "#{Settings::MAX_INITIALIZATION_TIMEOUT_MS}]; using the default"
+                      "#{Settings::MAX_INITIALIZATION_TIMEOUT_MS}]; using the default",
                     )
                     Settings::DEFAULT_INITIALIZATION_TIMEOUT_MS
                   end

data/lib/datadog/open_feature/evaluation_engine.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
+require "json"
+
 require_relative "ext"
 require_relative "noop_evaluator"
 require_relative "native_evaluator"
 require_relative "resolution_details"
+require_relative "../core/utils/only_once"
 
 module Datadog
   module OpenFeature
@@ -14,10 +17,15 @@ module Datadog
 
       ALLOWED_TYPES = %i[boolean string number float integer object].freeze
 
+      RAW_DATA_WARNING = "Feature Flags: debug logging is enabled, so feature flag logs include raw evaluation data " \
+        "(targeting keys, evaluation context attributes, flag values, and default values) that may contain " \
+        "personal or sensitive information. Unset DD_TRACE_DEBUG when you no longer need it."
+
       def initialize(reporter, telemetry:, logger:)
         @reporter = reporter
         @telemetry = telemetry
         @logger = logger
+        @raw_data_warning = Core::Utils::OnlyOnce.new
 
         @evaluator = NoopEvaluator.new(nil)
       end
@@ -34,7 +42,7 @@ module Datadog
         unless ALLOWED_TYPES.include?(expected_type)
           message = "unknown type #{expected_type.inspect}, allowed types #{ALLOWED_TYPES.join(", ")}"
           result = ResolutionDetails.build_error(
-            value: default_value, error_code: Ext::UNKNOWN_TYPE, error_message: message
+            value: default_value, error_code: Ext::UNKNOWN_TYPE, error_message: message,
           )
 
           return with_observe_full_evaluation_data(result, observe_full_evaluation_data)
@@ -42,19 +50,21 @@ module Datadog
 
         context = evaluation_context&.fields.to_h
         result = evaluator.get_assignment(
-          flag_key, default_value: default_value, context: context, expected_type: expected_type
+          flag_key, default_value: default_value, context: context, expected_type: expected_type,
         )
 
         result = with_observe_full_evaluation_data(result, observe_full_evaluation_data)
+        log_resolution(flag_key, expected_type, result)
 
         @reporter.report(result, flag_key: flag_key, context: evaluation_context)
 
         result
       rescue => e
         @telemetry.report(e, description: "OpenFeature: Failed to fetch flag value")
+        log_resolution_failure(flag_key, e)
 
         result = ResolutionDetails.build_error(
-          value: default_value, error_code: Ext::GENERAL, error_message: "#{e.class}: #{e.message}"
+          value: default_value, error_code: Ext::GENERAL, error_message: "#{e.class}: #{e.message}",
         )
         # `== true` is load-bearing: Steep types this local as `(nil | bool)` in a rescue
         # body, and coercing at the use site is what narrows it to `bool`.
@@ -66,12 +76,13 @@ module Datadog
       #       in the format expected by `libdatadog` without any modifications
       def reconfigure!(configuration)
         if configuration.nil?
-          @logger.debug("OpenFeature: Removing configuration")
+          @logger.debug("Feature Flags: configuration removed")
 
           return @evaluator = NoopEvaluator.new(configuration)
         end
 
         @evaluator = NativeEvaluator.new(configuration)
+        @logger.debug { "Feature Flags: configuration applied; #{configuration_summary(configuration)}" }
       rescue => e
         message = "OpenFeature: Failed to reconfigure, reverting to the previous configuration"
 
@@ -81,8 +92,55 @@ module Datadog
         raise ReconfigurationError, "#{e.class}: #{e.message}"
       end
 
+      # Public so Component can warn before handing out DebugLoggingHook, which logs raw data.
+      def warn_raw_data_logging
+        return unless @logger.debug?
+
+        @raw_data_warning.run { @logger.warn(RAW_DATA_WARNING) }
+      end
+
       private
 
+      # The SDK can still replace this result, for example on a type mismatch; DebugLoggingHook logs the final one.
+      def log_resolution(flag_key, expected_type, result)
+        @logger.debug do
+          warn_raw_data_logging
+          "Feature Flags: provider resolved #{flag_key.inspect}: type=#{expected_type}, " \
+            "value=#{result.value.inspect}, variant=#{result.variant.inspect}, reason=#{result.reason.inspect}, " \
+            "allocation=#{result.allocation_key.inspect}, serial_id=#{result.serial_id.inspect}, " \
+            "error_code=#{result.error_code.inspect}, error_message=#{result.error_message.inspect}"
+        end
+      end
+
+      def log_resolution_failure(flag_key, error)
+        @logger.debug do
+          warn_raw_data_logging
+          "Feature Flags: provider failed to resolve #{flag_key.inspect}: #{error.class}: #{error.message}; " \
+            "returning the default value"
+        end
+      end
+
+      def configuration_summary(configuration)
+        payload = begin
+          JSON.parse(configuration)
+        rescue JSON::NestingError
+          # Native parsing accepts deeper JSON than Ruby's default nesting limit.
+          return "received payload metadata unavailable: JSON nesting exceeds the diagnostic parser limit"
+        end
+        return "received payload metadata unavailable: expected a JSON object" unless payload.is_a?(Hash)
+
+        flags = payload["flags"]
+        environment = payload["environment"]
+        environment_name = environment["name"] if environment.is_a?(Hash)
+        flag_count = flags.is_a?(Hash) ? "flag_count=#{flags.size}" : "flag_count is not specified"
+        environment_summary = environment_name ? "environment=#{environment_name.inspect}" : "environment is not specified"
+        created_at = payload["createdAt"]
+        creation_summary = created_at ? "created_at=#{created_at.inspect}" : "created_at is not specified"
+
+        "received payload: #{flag_count}, #{environment_summary}, #{creation_summary}; " \
+          "individual flags may still fail evaluation"
+      end
+
       # Stamps observe_full_evaluation_data onto the result metadata so the hook
       # reads it from the event, not live config.
       def with_observe_full_evaluation_data(result, observe_full_evaluation_data)

data/lib/datadog/open_feature/exposures/buffer.rb

@@ -21,6 +21,10 @@ module Datadog
           super
         end
 
+        def pending_dropped_count
+          @dropped
+        end
+
         protected
 
         def drain!

data/lib/datadog/open_feature/exposures/reporter.rb

@@ -19,21 +19,34 @@ module Datadog
         #       might be missing depending on the customer way of using flags evaluation API.
         #       In addition to that the evaluation result must be marked for reporting.
         def report(result, flag_key:, context:)
-          return false if context.nil?
-          return false unless result.log?
+          return skip(flag_key, "no evaluation context") if context.nil?
+          return skip(flag_key, "the evaluation result is not marked for exposure logging") unless result.log?
 
           key = Event.cache_key(result, flag_key: flag_key, context: context)
           value = Event.cache_value(result, flag_key: flag_key, context: context)
-          return false if @deduplicator.duplicate?(key, value)
+          return skip(flag_key, "duplicate of the last exposure for this subject") if @deduplicator.duplicate?(key, value)
 
           event = Event.build(result, flag_key: flag_key, context: context)
-          @worker.enqueue(event)
+          return false unless @worker.enqueue(event)
+
+          @logger.debug do
+            "Feature Flags: queued exposure for #{flag_key.inspect} (allocation=#{result.allocation_key.inspect}, " \
+              "variant=#{result.variant.inspect}, targeting_key=#{context.targeting_key.inspect})"
+          end
+          true
         rescue => e
           @logger.debug { "OpenFeature: Failed to report resolution details: #{e.class}: #{e.message}" }
           @telemetry.report(e, description: "OpenFeature: Failed to report resolution details")
 
           false
         end
+
+        private
+
+        def skip(flag_key, reason)
+          @logger.debug { "Feature Flags: exposure for #{flag_key.inspect} not recorded: #{reason}" }
+          false
+        end
       end
     end
   end

data/lib/datadog/open_feature/exposures/worker.rb

@@ -54,7 +54,11 @@ module Datadog
         end
 
         def enqueue(event)
-          buffer.push(event)
+          unless buffer.push(event)
+            @logger.debug { "Feature Flags: exposure not queued: buffer closed" }
+            return false
+          end
+
           start unless running?
 
           true
@@ -84,7 +88,10 @@ module Datadog
             break if Core::Utils::Time.get_time - started > wait_time
           end
 
-          stop(true)
+          log_shutdown_outcome(wait_time)
+          stopped = stop(true)
+          @logger.debug("Feature Flags: exposure worker stopped") unless running?
+          stopped
         end
 
         private
@@ -93,23 +100,47 @@ module Datadog
           return if events.empty?
 
           if dropped.positive?
-            @logger.debug { "OpenFeature: Resolution details worker dropped #{dropped} event(s) due to full buffer" }
+            @logger.debug do
+              "Feature Flags: dropped #{dropped} older queued exposure event(s) because the exposure buffer was full"
+            end
           end
 
           payload = @batch_builder.payload_for(events)
+          @logger.debug { "Feature Flags: flushing #{events.size} exposure event(s) to the Datadog Agent" }
           response = @transport.send_exposures(payload)
 
-          unless response&.ok?
-            @logger.debug { "OpenFeature: Resolution details upload response was not OK: #{response.inspect}" }
+          if response&.ok?
+            @logger.debug { "Feature Flags: sent #{events.size} exposure event(s) to the Datadog Agent" }
+          else
+            @logger.debug do
+              "Feature Flags: exposure upload response was not OK; dropping #{events.size} exposure event(s) " \
+                "without retry: #{response.inspect}"
+            end
           end
 
           response
         rescue => e
-          @logger.debug { "OpenFeature: Failed to flush resolution details events: #{e.class}: #{e.message}" }
+          @logger.debug do
+            "Feature Flags: failed to flush exposure events; dropping #{events.size} exposure event(s) " \
+              "without retry: #{e.class}: #{e.message}"
+          end
           @telemetry.report(e, description: "OpenFeature: Failed to flush resolution details events")
 
           nil
         end
+
+        def log_shutdown_outcome(wait_time)
+          @logger.debug do
+            queued = buffer.length
+            evicted = buffer.pending_dropped_count
+            uploading = !!in_iteration?
+            remaining = queued.positive? ? "; #{queued} queued exposure event(s) will not be sent" : "; no queued exposure events remain"
+            remaining += "; #{evicted} exposure event(s) evicted from the full buffer were not sent" if evicted.positive?
+            outcome = uploading ? "; the in-flight upload may still report sent or dropping during shutdown; if forcibly terminated, its outcome will not be reported" : ""
+            "Feature Flags: exposure shutdown wait finished; queued=#{queued}, " \
+              "upload_in_progress=#{uploading}, wait_budget=#{wait_time}s#{remaining}#{outcome}"
+          end
+        end
       end
     end
   end

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

@@ -124,7 +124,7 @@ module Datadog
             if per_flag_count >= @per_flag_cap
               add_to_degraded(
                 flag_key, variant, allocation_key, runtime_default, error_message, evaluation_time_ms,
-                observe_full_evaluation_data
+                observe_full_evaluation_data,
               )
               return
             end
@@ -140,7 +140,7 @@ module Datadog
                 error_message: error_message,
                 targeting_key: targeting_key,
                 context_attrs: observe_full_evaluation_data ? attrs : nil,
-                observe_full_evaluation_data: observe_full_evaluation_data
+                observe_full_evaluation_data: observe_full_evaluation_data,
               )
               @full[full_key] = entry
               @global_count += 1
@@ -148,7 +148,7 @@ module Datadog
               # Route to degraded tier
               add_to_degraded(
                 flag_key, variant, allocation_key, runtime_default, error_message, evaluation_time_ms,
-                observe_full_evaluation_data
+                observe_full_evaluation_data,
               )
             end
           end
@@ -328,7 +328,7 @@ module Datadog
                 end
 
                 output[prefix] = string_value.encode(
-                  Encoding::UTF_8, invalid: :replace, undef: :replace
+                  Encoding::UTF_8, invalid: :replace, undef: :replace,
                 ).freeze
               rescue
                 # Unsupported caller values must not break flag evaluation.
@@ -433,7 +433,7 @@ module Datadog
             evaluation_time_ms,
             runtime_default: runtime_default,
             error_message: error_message,
-            observe_full_evaluation_data: observe_full_evaluation_data
+            observe_full_evaluation_data: observe_full_evaluation_data,
           )
         end
       end

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

@@ -489,7 +489,7 @@ module Datadog
             {
               "context" => @service_context,
               "flagEvaluations" => events,
-            }
+            },
           )
           if response.respond_to?(:ok?) && !response.ok?
             @logger.debug { "OpenFeature EVP: transport response was not OK: #{response.inspect}" }

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../ext"
+
+module Datadog
+  module OpenFeature
+    module Hooks
+      # Logs each SDK-final evaluation outcome for onboarding diagnostics.
+      #
+      # Logs raw flag values, default values, targeting keys, context attributes, and
+      # error messages, so it is only registered while debug logging is enabled.
+      class DebugLoggingHook
+        include ::OpenFeature::SDK::Hooks::Hook if defined?(::OpenFeature::SDK::Hooks::Hook)
+
+        def self.available?
+          !!defined?(::OpenFeature::SDK::Hooks::Hook)
+        end
+
+        def initialize(logger)
+          @logger = logger
+        end
+
+        def finally(hook_context:, evaluation_details:, **_opts)
+          @logger.debug do
+            evaluation_context = hook_context.evaluation_context
+            "Feature Flags: evaluated #{hook_context.flag_key.inspect} (" \
+              "type=#{hook_context.flag_value_type}, " \
+              "default=#{hook_context.default_value.inspect}, " \
+              "value=#{evaluation_details.value.inspect}, " \
+              "variant=#{evaluation_details.variant.inspect}, " \
+              "reason=#{evaluation_details.reason.inspect}, " \
+              "allocation=#{extract_allocation_key(evaluation_details).inspect}, " \
+              "error_code=#{evaluation_details.error_code.inspect}, " \
+              "error_message=#{evaluation_details.error_message.inspect}, " \
+              "targeting_key=#{evaluation_context&.targeting_key.inspect}, " \
+              "attributes=#{attributes(evaluation_context).inspect}, " \
+              "flag_metadata=#{evaluation_details.flag_metadata.inspect})"
+          end
+        end
+
+        private
+
+        def extract_allocation_key(evaluation_details)
+          metadata = evaluation_details.flag_metadata
+          metadata&.[](Ext::METADATA_ALLOCATION_KEY)
+        end
+
+        def attributes(evaluation_context)
+          return {} unless evaluation_context
+
+          evaluation_context.fields.reject { |key, _value| key == ::OpenFeature::SDK::EvaluationContext::TARGETING_KEY }
+        end
+      end
+    end
+  end
+end

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

@@ -94,7 +94,7 @@ module Datadog
             end
           end
         rescue => e
-          @logger.debug { "Error capturing span enrichment: #{e.class}: #{e.message}" }
+          @logger.debug { "OpenFeature: Error capturing span enrichment: #{e.class}: #{e.message}" }
         end
 
         # Provider-close cleanup: mark the hook inactive and drop all accumulated
@@ -153,7 +153,7 @@ module Datadog
 
             write_tags_on_root(span_op, finishing_trace_op, state)
           rescue => e
-            @logger.debug { "Error writing span enrichment tags: #{e.class}: #{e.message}" }
+            @logger.debug { "OpenFeature: Error writing span enrichment tags: #{e.class}: #{e.message}" }
           end
         end
 

data/lib/datadog/open_feature/metrics/flag_eval_metrics.rb

@@ -78,7 +78,7 @@ module Datadog
             @counter = meter.create_counter(
               METRIC_NAME,
               unit: METRIC_UNIT,
-              description: METRIC_DESCRIPTION
+              description: METRIC_DESCRIPTION,
             )
           end
         rescue => e

data/lib/datadog/open_feature/native_evaluator.rb

@@ -66,7 +66,7 @@ module Datadog
         ResolutionDetails.build_error(
           value: default_value,
           error_code: Ext::PARSE_ERROR,
-          error_message: INVALID_FLAG_CONFIGURATION_ERROR_MESSAGE
+          error_message: INVALID_FLAG_CONFIGURATION_ERROR_MESSAGE,
         )
       end
     end

data/lib/datadog/open_feature/noop_evaluator.rb

@@ -23,7 +23,7 @@ module Datadog
           error?: true,
           error_code: Ext::PROVIDER_NOT_READY,
           error_message: "Waiting for flags configuration",
-          reason: Ext::ERROR
+          reason: Ext::ERROR,
         )
       end
     end

data/lib/datadog/open_feature/provider.rb

@@ -108,6 +108,7 @@ module Datadog
           @stale_emitted = false
           @stale_pending = false
         end
+        Datadog.logger.debug { "Feature Flags: provider initialization started" }
         ready_handler_installed = install_initialization_ready_handler
 
         component, failure = OpenFeature.activate_provider(self)
@@ -126,6 +127,7 @@ module Datadog
         case wait_result
         when Component::CONFIGURATION_READY
           @initialization_mutex.synchronize { @initializing = false } unless ready_handler_installed
+          Datadog.logger.debug { "Feature Flags: provider initialized successfully" }
         when Component::CONFIGURATION_TIMEOUT
           message = "Feature Flags provider initialization timed out while waiting for configuration"
           Datadog.logger.error(message)
@@ -173,17 +175,20 @@ module Datadog
           )
         end
         OpenFeature.deactivate_provider(self)
+        Datadog.logger.debug { "Feature Flags: provider shut down" }
       end
 
       def hooks
         component = Datadog.send(:components).open_feature
-        hooks = [
+        telemetry_hooks = [
           component&.flag_eval_metrics_hook,
           component&.flag_eval_evp_hook,
         ].compact
-        return hooks unless @enable_evaluation_telemetry_opt_out_parameter
+        if @enable_evaluation_telemetry_opt_out_parameter
+          telemetry_hooks = telemetry_hooks.map { |hook| Hooks::EvaluationTelemetryOptOutHook.new(hook) }
+        end
 
-        hooks.map { |hook| Hooks::EvaluationTelemetryOptOutHook.new(hook) }
+        [*telemetry_hooks, component&.debug_logging_hook].compact
       end
 
       def fetch_boolean_value(flag_key:, default_value:, evaluation_context: nil)
@@ -234,6 +239,8 @@ module Datadog
       def fail_initialization(component, message)
         prepare_initialization_failure(component)
         cancel_initialization_if_shutdown!
+        # Non-blocking set_provider surfaces this only as a PROVIDER_ERROR event.
+        Datadog.logger.debug { "Feature Flags: provider failed to initialize: #{message}" }
         raise message.to_s
       end
 
@@ -326,7 +333,7 @@ module Datadog
             end
           end
         end
-        emit_event(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY) if emit_ready
+        emit_state_event(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY) if emit_ready
       end
 
       def provider_ready(_details)
@@ -348,7 +355,7 @@ module Datadog
           end
         end
         configuration.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY, handler) if handler
-        emit_event(::OpenFeature::SDK::ProviderEvent::PROVIDER_STALE) if emit_stale
+        emit_state_event(::OpenFeature::SDK::ProviderEvent::PROVIDER_STALE) if emit_stale
       end
 
       def configuration_changed(event)
@@ -394,7 +401,25 @@ module Datadog
           end
         end
 
-        emit_event(event_type) if event_type
+        emit_state_event(event_type) if event_type
+      end
+
+      def emit_state_event(event_type)
+        log_state_event(event_type)
+        emit_event(event_type)
+      end
+
+      def log_state_event(event_type)
+        logger = Datadog.logger
+        logger.debug do
+          availability = case event_type
+          when ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY
+            "; configuration is available"
+          when ::OpenFeature::SDK::ProviderEvent::PROVIDER_STALE
+            "; configuration is no longer available"
+          end
+          "Feature Flags: provider emitted #{event_type}#{availability}"
+        end
       end
 
       def evaluate(flag_key, default_value:, expected_type:, evaluation_context:)
@@ -404,7 +429,10 @@ module Datadog
         flag_meta = nil
 
         engine = OpenFeature.engine
-        return component_not_configured_default(default_value, eval_time_ms) if engine.nil?
+        if engine.nil?
+          log_component_not_configured(flag_key, expected_type)
+          return component_not_configured_default(default_value, eval_time_ms)
+        end
 
         result = fetch_engine_value(engine, flag_key, default_value, expected_type, evaluation_context)
 
@@ -428,11 +456,11 @@ module Datadog
         error_result = Datadog::OpenFeature::ResolutionDetails.build_error(
           value: default_value,
           error_code: Ext::GENERAL,
-          error_message: error_message
+          error_message: error_message,
         )
         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
+          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)
@@ -443,7 +471,7 @@ module Datadog
           flag_key,
           default_value: default_value,
           expected_type: expected_type,
-          evaluation_context: evaluation_context
+          evaluation_context: evaluation_context,
         )
       end
 
@@ -462,7 +490,7 @@ module Datadog
           error_code: error_code,
           error_message: error_message,
           reason: reason,
-          flag_metadata: flag_meta
+          flag_metadata: flag_meta,
         )
       end
 
@@ -509,6 +537,16 @@ module Datadog
         Datadog.send(:components).open_feature&.span_enrichment_hook
       end
 
+      # No component means no DebugLoggingHook and no raw-data warning, so only non-raw fields are logged.
+      def log_component_not_configured(flag_key, expected_type)
+        logger = Datadog.logger
+        logger.debug do
+          "Feature Flags: provider returned the default value for #{flag_key.inspect} (type=#{expected_type}): " \
+            "the Feature Flags component is not active; see the provider initialization logs " \
+            "(error_code=#{Ext::PROVIDER_FATAL})"
+        end
+      end
+
       def evaluation_telemetry_opted_out?(evaluation_context)
         @enable_evaluation_telemetry_opt_out_parameter &&
           Hooks::EvaluationTelemetryOptOutHook.opted_out?(evaluation_context)
@@ -523,7 +561,7 @@ module Datadog
           flag_metadata: {
             "dd.eval.timestamp_ms" => eval_time_ms,
             Ext::METADATA_OBSERVE_FULL_EVALUATION_DATA => false,
-          }
+          },
         )
       end
     end

data/lib/datadog/open_feature/remote.rb

@@ -19,7 +19,7 @@ module Datadog
           FFE_PRODUCTS
         end
 
-        def receivers(telemetry, component_provider:)
+        def receivers(telemetry, component_provider:, logger: Datadog.logger)
           matcher = Core::Remote::Dispatcher::Matcher::Product.new(FFE_PRODUCTS)
           receiver = Core::Remote::Dispatcher::Receiver.new(matcher) do |repository, changes|
             component = component_provider.call
@@ -27,8 +27,15 @@ module Datadog
 
             changes.each do |change|
               content = repository[change.path]
+              logger.debug do
+                version = content ? " (version #{content.version})" : ""
+                "Feature Flags: received Remote Configuration #{change.type} for #{change.path}#{version}"
+              end
 
               unless content || change.type == :delete
+                logger.debug do
+                  "Feature Flags: ignored Remote Configuration #{change.type} for #{change.path}: content is missing"
+                end
                 next telemetry.error("OpenFeature: Remote Configuration change is not present on #{change.type}")
               end
 

data/lib/datadog/open_feature/resolution_details.rb

@@ -19,7 +19,7 @@ module Datadog
       :extra_logging,
       :log?,
       :error?,
-      keyword_init: true
+      keyword_init: true,
     )
       def self.build_error(value:, error_code:, error_message:, reason: Ext::ERROR)
         new(
@@ -29,7 +29,7 @@ module Datadog
           reason: reason,
           error?: true,
           log?: false,
-          serial_id: nil
+          serial_id: nil,
         ).freeze
       end
     end