datadog 2.46.0 → 2.48.0

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/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/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

@@ -3,6 +3,7 @@
 require_relative "ext"
 require_relative "../open_feature"
 require_relative "../core/utils/time"
+require_relative "hooks/evaluation_telemetry_opt_out_hook"
 require "open_feature/sdk"
 
 module Datadog
@@ -67,7 +68,15 @@ module Datadog
 
       attr_reader :metadata
 
-      def initialize
+      def initialize(enable_evaluation_telemetry_opt_out_parameter: nil)
+        @enable_evaluation_telemetry_opt_out_parameter = case enable_evaluation_telemetry_opt_out_parameter
+        when nil
+          Datadog.configuration.feature_flags.evaluation_telemetry_per_subject_opt_out_enabled
+        when true, false
+          enable_evaluation_telemetry_opt_out_parameter
+        else
+          raise ArgumentError, "enable_evaluation_telemetry_opt_out_parameter expects true, false, or nil"
+        end
         @metadata = ::OpenFeature::SDK::Provider::ProviderMetadata.new(name: NAME).freeze
         @initialization_mutex = Mutex.new
         @initializing = false
@@ -99,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)
@@ -117,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)
@@ -164,14 +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
-        [
+        telemetry_hooks = [
           component&.flag_eval_metrics_hook,
           component&.flag_eval_evp_hook,
         ].compact
+        if @enable_evaluation_telemetry_opt_out_parameter
+          telemetry_hooks = telemetry_hooks.map { |hook| Hooks::EvaluationTelemetryOptOutHook.new(hook) }
+        end
+
+        [*telemetry_hooks, component&.debug_logging_hook].compact
       end
 
       def fetch_boolean_value(flag_key:, default_value:, evaluation_context: nil)
@@ -222,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
 
@@ -314,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)
@@ -336,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)
@@ -382,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:)
@@ -392,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)
 
@@ -406,7 +446,9 @@ module Datadog
         # Drive APM span enrichment directly from the evaluation path. This is the only reliable
         # way to attach `ffe_*` tags across all supported OpenFeature SDK versions, since older
         # SDKs do not dispatch provider hooks. Guarded so enrichment can never break evaluation.
-        enrich_span(flag_key, result, evaluation_context)
+        unless evaluation_telemetry_opted_out?(evaluation_context)
+          enrich_span(flag_key, result, evaluation_context)
+        end
 
         sdk_success_details(result, flag_meta)
       rescue => e
@@ -414,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)
@@ -429,7 +471,7 @@ module Datadog
           flag_key,
           default_value: default_value,
           expected_type: expected_type,
-          evaluation_context: evaluation_context
+          evaluation_context: evaluation_context,
         )
       end
 
@@ -448,7 +490,7 @@ module Datadog
           error_code: error_code,
           error_message: error_message,
           reason: reason,
-          flag_metadata: flag_meta
+          flag_metadata: flag_meta,
         )
       end
 
@@ -495,6 +537,21 @@ 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)
+      end
+
       def component_not_configured_default(value, eval_time_ms)
         ::OpenFeature::SDK::Provider::ResolutionDetails.new(
           value: value,
@@ -504,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

data/lib/datadog/open_feature/transport.rb

@@ -18,7 +18,7 @@ module Datadog
         class Spec
           def initialize
             @endpoint = Core::Transport::HTTP::API::Endpoint.new(
-              :post, "/evp_proxy/v2/api/v2/exposures"
+              :post, "/evp_proxy/v2/api/v2/exposures",
             )
           end
 
@@ -43,7 +43,7 @@ module Datadog
         class FlagevaluationsSpec
           def initialize
             @endpoint = Core::Transport::HTTP::API::Endpoint.new(
-              :post, "/evp_proxy/v2/api/v2/flagevaluation"
+              :post, "/evp_proxy/v2/api/v2/flagevaluation",
             )
           end
 
@@ -64,7 +64,7 @@ module Datadog
         def self.build(agent_settings:, logger:)
           Core::Transport::HTTP.build(
             agent_settings: agent_settings,
-            logger: logger
+            logger: logger,
           ) { |t| t.api("exposures", HTTP::Spec.new) }.to_transport(self)
         end
 
@@ -72,7 +72,7 @@ module Datadog
         def self.build_flagevaluations(agent_settings:, logger:)
           Core::Transport::HTTP.build(
             agent_settings: agent_settings,
-            logger: logger
+            logger: logger,
           ) { |t| t.api("flagevaluations", HTTP::FlagevaluationsSpec.new) }.to_transport(self)
         end
 
@@ -85,7 +85,7 @@ module Datadog
           encoder = Core::Encoding::JSONEncoder
           parcel = Core::Transport::Parcel.new(
             encoder.encode(payload),
-            content_type: encoder.content_type
+            content_type: encoder.content_type,
           )
           request = Core::Transport::Request.new(parcel)
 
@@ -106,7 +106,7 @@ module Datadog
           encoder = Core::Encoding::JSONEncoder
           parcel = Core::Transport::Parcel.new(
             encoder.encode(payload),
-            content_type: encoder.content_type
+            content_type: encoder.content_type,
           )
           request = Core::Transport::Request.new(parcel)
 

data/lib/datadog/opentelemetry/api/context.rb

@@ -77,7 +77,7 @@ module Datadog
             # It effectively becomes an internal trace propagation.
             trace = Datadog::OpenTelemetry::Trace.start_trace_copy(
               current_span.datadog_trace,
-              parent_span: current_span.datadog_span
+              parent_span: current_span.datadog_span,
             )
           end
 
@@ -143,8 +143,8 @@ module Datadog
             unless calls_matched
               ::OpenTelemetry.handle_error(
                 exception: ::OpenTelemetry::Context::DetachError.new(
-                  "calls to detach should match corresponding calls to attach."
-                )
+                  "calls to detach should match corresponding calls to attach.",
+                ),
               )
             end
 

data/lib/datadog/opentelemetry/logs.rb

@@ -13,7 +13,7 @@ module Datadog
         true
       rescue => exc
         components.logger.warn(
-          "Failed to initialize OpenTelemetry logs: #{exc.class}: #{exc.message}\n#{(exc.backtrace || []).join("\n")}"
+          "Failed to initialize OpenTelemetry logs: #{exc.class}: #{exc.message}\n#{(exc.backtrace || []).join("\n")}",
         )
         false
       end
@@ -42,7 +42,7 @@ module Datadog
       def disable_log_injection
         @logger.warn("OTel logs enabled: disabling Datadog log injection to prevent duplicate trace correlation fields")
         Datadog.configure do |c|
-          c.tracing.log_injection = false # steep:ignore
+          c.tracing.log_injection = false
         end
       end
 
@@ -67,7 +67,7 @@ module Datadog
         endpoint = config_or_exporter_fallback(
           signal: :logs,
           option_name: :endpoint,
-          computed_default: default_logs_endpoint
+          computed_default: default_logs_endpoint,
         )
         timeout = config_or_exporter_fallback(signal: :logs, option_name: :timeout_millis)
         headers = config_or_exporter_fallback(signal: :logs, option_name: :headers)
@@ -77,7 +77,7 @@ module Datadog
         exporter = Datadog::OpenTelemetry::SDK::LogsExporter.new(
           endpoint: endpoint,
           timeout: timeout / 1000.0,
-          headers: headers
+          headers: headers,
         )
 
         processor = ::OpenTelemetry::SDK::Logs::Export::BatchLogRecordProcessor.new(
@@ -85,7 +85,7 @@ module Datadog
           max_queue_size: logs_config.max_queue_size,
           schedule_delay: logs_config.schedule_delay_millis,
           exporter_timeout: logs_config.export_timeout_millis,
-          max_export_batch_size: logs_config.max_export_batch_size
+          max_export_batch_size: logs_config.max_export_batch_size,
         )
         provider.add_log_record_processor(processor)
         true

data/lib/datadog/opentelemetry/metrics.rb

@@ -63,7 +63,7 @@ module Datadog
         endpoint = config_or_exporter_fallback(
           signal: :metrics,
           option_name: :endpoint,
-          computed_default: default_metrics_endpoint
+          computed_default: default_metrics_endpoint,
         )
         timeout = config_or_exporter_fallback(signal: :metrics, option_name: :timeout_millis)
         headers = config_or_exporter_fallback(signal: :metrics, option_name: :headers)
@@ -73,13 +73,13 @@ module Datadog
         exporter = Datadog::OpenTelemetry::SDK::MetricsExporter.new(
           endpoint: endpoint,
           timeout: timeout / 1000.0,
-          headers: headers
+          headers: headers,
         )
 
         reader = ::OpenTelemetry::SDK::Metrics::Export::PeriodicMetricReader.new(
           exporter: exporter,
           export_interval_millis: metrics_config.export_interval_millis,
-          export_timeout_millis: metrics_config.export_timeout_millis
+          export_timeout_millis: metrics_config.export_timeout_millis,
         )
         provider.add_metric_reader(reader)
       rescue LoadError => e

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

@@ -19,7 +19,7 @@ module Datadog
             Datadog.logger.error(
               "Custom setter is not supported. Please inform the `datadog` team at " \
             " https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default " \
-            "OpenTelemetry::Context::Propagation.text_map_setter as a fallback setter."
+            "OpenTelemetry::Context::Propagation.text_map_setter as a fallback setter.",
             )
           end
 
@@ -36,7 +36,7 @@ module Datadog
             Datadog.logger.error(
               "Custom getter #{getter} is not supported. Please inform the `datadog` team at " \
             " https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default " \
-            "OpenTelemetry::Context::Propagation.text_map_getter as a fallback getter."
+            "OpenTelemetry::Context::Propagation.text_map_getter as a fallback getter.",
             )
           end
 
@@ -75,7 +75,7 @@ module Datadog
             span_id: span_id,
             trace_flags: trace_flags,
             tracestate: tracestate,
-            remote: true
+            remote: true,
           )
 
           span = ::OpenTelemetry::Trace.non_recording_span(span_context)