datadog 2.39.0 → 2.47.0

data/lib/datadog/open_feature/provider.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 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
   module OpenFeature
-    # OpenFeature feature flagging provider backed by Datadog Remote Configuration.
+    # OpenFeature feature flagging provider backed by Datadog configuration delivery.
     #
     # Requires openfeature-sdk >= 0.5.1 for flag evaluation metrics and EVP hook support.
     #
@@ -24,13 +26,14 @@ module Datadog
     #
     # Example:
     #
-    #   Make sure to enable Remote Configuration and OpenFeature in the Datadog configuration.
+    #   Feature Flags use agentless configuration delivery by default. To use
+    #   Remote Configuration delivery instead, configure the source explicitly.
     #
     #   ```ruby
     #   # FILE: initializers/datadog.rb
     #   Datadog.configure do |config|
     #     config.remote.enabled = true
-    #     config.open_feature.enabled = true
+    #     config.feature_flags.configuration_source = "remote_config"
     #   end
     #   ```
     #
@@ -58,28 +61,129 @@ module Datadog
     #   # => 'Welcome back!'
     #   ```
     class Provider
+      include ::OpenFeature::SDK::Provider::EventEmitter
+
       NAME = "Datadog Feature Flagging Provider"
+      INITIALIZATION_CANCELLED_MESSAGE = "Feature Flags provider initialization was cancelled by shutdown"
 
       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
+        @initialization_thread = nil
+        @awaiting_ready_after_fork = false
+        @initialization_failed = false
+        @provider_error_observed = false
+        @ready_pending = false
+        @ready_dispatch_claimed = false
+        @stale_emitted = false
+        @stale_pending = false
+        @error_handler = nil
+        @initialization_ready_handler = nil
+        @waiting_component = nil
+        @shutdown = false
       end
 
       def init
-        # no-op
+        @initialization_mutex.synchronize do
+          raise INITIALIZATION_CANCELLED_MESSAGE if @shutdown
+
+          @initializing = true
+          @initialization_thread = Thread.current
+          @awaiting_ready_after_fork = false
+          @initialization_failed = false
+          @provider_error_observed = false
+          @ready_pending = false
+          @ready_dispatch_claimed = false
+          @stale_emitted = false
+          @stale_pending = false
+        end
+        ready_handler_installed = install_initialization_ready_handler
+
+        component, failure = OpenFeature.activate_provider(self)
+        cancel_initialization_if_shutdown!
+        fail_initialization(component, failure || "Feature Flags component could not be activated") unless component
+
+        @initialization_mutex.synchronize do
+          raise INITIALIZATION_CANCELLED_MESSAGE if @shutdown
+
+          @waiting_component = component
+        end
+        # Shutdown publishes this flag through the component lock; taking our mutex here would invert lock order.
+        wait_result = component.wait_for_configuration { @shutdown }
+        cancel_initialization_if_shutdown!
+
+        case wait_result
+        when Component::CONFIGURATION_READY
+          @initialization_mutex.synchronize { @initializing = false } unless ready_handler_installed
+        when Component::CONFIGURATION_TIMEOUT
+          message = "Feature Flags provider initialization timed out while waiting for configuration"
+          Datadog.logger.error(message)
+          fail_initialization(component, message)
+        else
+          fail_initialization(component, "Feature Flags provider initialization stopped before configuration arrived")
+        end
+      rescue
+        prepare_initialization_failure(component) if @initialization_mutex.synchronize { @initializing }
+        raise
+      ensure
+        @initialization_mutex.synchronize do
+          @waiting_component = nil
+          # The SDK still owes READY after init returns; the initializing thread owns that dispatch.
+          @initialization_thread = nil unless @initializing
+        end
       end
 
       def shutdown
-        # no-op
+        configuration = @configuration
+        # @type var error_handler: Provider::provider_event_handler?
+        error_handler = nil
+        # @type var initialization_ready_handler: Provider::provider_event_handler?
+        initialization_ready_handler = nil
+        waiting_component = nil #: Component?
+        @initialization_mutex.synchronize do
+          return if @shutdown
+
+          @shutdown = true
+          @initializing = false
+          @initialization_thread = nil
+          error_handler = @error_handler
+          initialization_ready_handler = @initialization_ready_handler
+          waiting_component = @waiting_component
+          @error_handler = nil
+          @initialization_ready_handler = nil
+        end
+
+        waiting_component&.wake_configuration_waiters
+        configuration&.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_ERROR, error_handler) if error_handler
+        if initialization_ready_handler
+          configuration&.remove_handler(
+            ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY,
+            initialization_ready_handler,
+          )
+        end
+        OpenFeature.deactivate_provider(self)
       end
 
       def hooks
         component = Datadog.send(:components).open_feature
-        [
+        hooks = [
           component&.flag_eval_metrics_hook,
           component&.flag_eval_evp_hook,
         ].compact
+        return hooks unless @enable_evaluation_telemetry_opt_out_parameter
+
+        hooks.map { |hook| Hooks::EvaluationTelemetryOptOutHook.new(hook) }
       end
 
       def fetch_boolean_value(flag_key:, default_value:, evaluation_context: nil)
@@ -108,10 +212,196 @@ module Datadog
 
       private
 
+      def after_fork(component)
+        handler = @initialization_mutex.synchronize do
+          return if @shutdown || !@initializing || @initialization_thread&.alive?
+
+          @initializing = false
+          @initialization_thread = nil
+          @waiting_component = nil
+          @awaiting_ready_after_fork = true
+          @stale_pending = false
+          previous_handler = @initialization_ready_handler
+          @initialization_ready_handler = nil
+          previous_handler
+        end
+        if handler
+          @configuration&.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY, handler)
+        end
+        configuration_changed(Component::CONFIGURATION_READY) if component&.configuration_received?
+      end
+
+      def fail_initialization(component, message)
+        prepare_initialization_failure(component)
+        cancel_initialization_if_shutdown!
+        raise message.to_s
+      end
+
+      def prepare_initialization_failure(component)
+        cancelled, initialization_ready_handler = @initialization_mutex.synchronize do
+          handler = @initialization_ready_handler
+          @initialization_ready_handler = nil
+          @stale_pending = false
+          @initializing = false
+          @initialization_thread = nil
+          if @shutdown
+            [true, handler]
+          else
+            @initialization_failed = true
+            @ready_pending ||= !!component&.configuration_received?
+            [false, handler]
+          end
+        end
+        if initialization_ready_handler
+          @configuration&.remove_handler(
+            ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY,
+            initialization_ready_handler,
+          )
+        end
+        return if cancelled
+
+        install_error_handler
+      end
+
+      def cancel_initialization_if_shutdown!
+        cancelled = @initialization_mutex.synchronize do
+          @initializing = false if @shutdown
+          @shutdown
+        end
+        raise INITIALIZATION_CANCELLED_MESSAGE if cancelled
+      end
+
+      def shutdown?
+        @initialization_mutex.synchronize { @shutdown }
+      end
+
+      def install_initialization_ready_handler
+        configuration = @configuration
+        return false unless configuration
+
+        handler = @initialization_mutex.synchronize do
+          return false if @shutdown
+          return true if @initialization_ready_handler
+
+          @initialization_ready_handler = ->(details) { provider_ready(details) }
+        end
+        configuration.add_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY, handler)
+
+        cancelled = @initialization_mutex.synchronize { @shutdown }
+        configuration.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY, handler) if cancelled
+        return false if cancelled
+
+        true
+      end
+
+      def install_error_handler
+        configuration = @configuration
+        return unless configuration
+
+        handler = @initialization_mutex.synchronize do
+          return if @shutdown
+
+          @error_handler ||= ->(details) { provider_error(details) }
+        end
+        configuration.add_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_ERROR, handler)
+
+        cancelled = @initialization_mutex.synchronize { @shutdown }
+        configuration.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_ERROR, handler) if cancelled
+      end
+
+      def provider_error(_details)
+        configuration = @configuration
+        return unless configuration
+        return unless configuration.send(:provider_state, self) == ::OpenFeature::SDK::ProviderState::ERROR
+
+        emit_ready = @initialization_mutex.synchronize do
+          if @shutdown
+            false
+          else
+            @provider_error_observed = true
+            if @ready_pending && !@ready_dispatch_claimed
+              @ready_dispatch_claimed = true
+            else
+              false
+            end
+          end
+        end
+        emit_event(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY) if emit_ready
+      end
+
+      def provider_ready(_details)
+        configuration = @configuration
+        return unless configuration
+        return unless configuration.send(:provider_state, self) == ::OpenFeature::SDK::ProviderState::READY
+
+        handler, emit_stale = @initialization_mutex.synchronize do
+          handler = @initialization_ready_handler
+          @initialization_ready_handler = nil
+          @initializing = false
+          @initialization_thread = nil
+          if @stale_pending && !@shutdown
+            @stale_pending = false
+            @stale_emitted = true
+            [handler, true]
+          else
+            [handler, false]
+          end
+        end
+        configuration.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY, handler) if handler
+        emit_event(::OpenFeature::SDK::ProviderEvent::PROVIDER_STALE) if emit_stale
+      end
+
+      def configuration_changed(event)
+        event_type = @initialization_mutex.synchronize do
+          if @shutdown
+            nil
+          elsif event == Component::CONFIGURATION_READY
+            if @initializing
+              @ready_pending = true
+              @stale_pending = false
+              nil
+            elsif @awaiting_ready_after_fork
+              @awaiting_ready_after_fork = false
+              @stale_emitted = false
+              ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY
+            elsif @initialization_failed && !@provider_error_observed
+              @stale_emitted = false
+              @ready_pending = true
+              nil
+            elsif @stale_emitted
+              @stale_emitted = false
+              ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY
+            elsif @initialization_failed
+              if @provider_error_observed && !@ready_dispatch_claimed
+                @ready_dispatch_claimed = true
+                ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY
+              else
+                @ready_pending = true
+                nil
+              end
+            end
+          elsif event == Component::CONFIGURATION_CHANGED && !@initializing
+            ::OpenFeature::SDK::ProviderEvent::PROVIDER_CONFIGURATION_CHANGED
+          elsif event == Component::CONFIGURATION_LOST
+            @ready_pending = false
+            if @initializing
+              @stale_pending = true
+              nil
+            else
+              @stale_emitted = true
+              ::OpenFeature::SDK::ProviderEvent::PROVIDER_STALE
+            end
+          end
+        end
+
+        emit_event(event_type) if event_type
+      end
+
       def evaluate(flag_key, default_value:, expected_type:, evaluation_context:)
         # Stamp evaluation entry time once, here on the eval thread. The EVP path uses this for
         # accurate first/last_evaluation bounds instead of a later hook-fire clock read.
         eval_time_ms = (Core::Utils::Time.now.to_f * 1000).to_i
+        flag_meta = nil
 
         engine = OpenFeature.engine
         return component_not_configured_default(default_value, eval_time_ms) if engine.nil?
@@ -128,7 +418,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
@@ -138,7 +430,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 +468,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?
 
@@ -212,13 +509,21 @@ module Datadog
         Datadog.send(:components).open_feature&.span_enrichment_hook
       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,
           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/open_feature/remote.rb

@@ -19,11 +19,11 @@ module Datadog
           FFE_PRODUCTS
         end
 
-        def receivers(telemetry)
+        def receivers(telemetry, component_provider:)
           matcher = Core::Remote::Dispatcher::Matcher::Product.new(FFE_PRODUCTS)
           receiver = Core::Remote::Dispatcher::Receiver.new(matcher) do |repository, changes|
-            engine = OpenFeature.engine
-            next unless engine
+            component = component_provider.call
+            next unless component
 
             changes.each do |change|
               content = repository[change.path]
@@ -38,7 +38,7 @@ module Datadog
               when :insert, :update
                 begin
                   # @type var content: Core::Remote::Configuration::Content
-                  engine.reconfigure!(read_content(content))
+                  component.reconfigure!(read_content(content))
                   content.applied
                 rescue EvaluationEngine::ReconfigurationError => e
                   content.errored("Error applying OpenFeature configuration: #{e.class}: #{e.message}")
@@ -46,7 +46,7 @@ module Datadog
               when :delete
                 # NOTE: For now, we treat deletion as clearing the configuration
                 #       In a multi-config scenario, we might track configs per path
-                engine.reconfigure!(nil)
+                component.reconfigure!(nil)
               end
             end
           end

data/lib/datadog/open_feature/transport.rb

@@ -8,6 +8,7 @@ require_relative "../core/transport/http/api/endpoint"
 require_relative "../core/transport/http/api/instance"
 require_relative "../core/transport/parcel"
 require_relative "../core/transport/request"
+require_relative "../version"
 
 module Datadog
   module OpenFeature
@@ -27,6 +28,8 @@ module Datadog
               request_env.headers["Content-Type"] = env.request.parcel.content_type
               request_env.headers[Core::EVP::SUBDOMAIN_HEADER_NAME] =
                 Core::EVP::EVENT_PLATFORM_INTAKE_SUBDOMAIN
+              request_env.headers["DD-EVP-ORIGIN"] = "dd-trace-rb"
+              request_env.headers["DD-EVP-ORIGIN-VERSION"] = Datadog::VERSION::STRING
               request_env.body = env.request.parcel.data
 
               block.call(request_env)
@@ -49,6 +52,8 @@ module Datadog
               request_env.headers["Content-Type"] = env.request.parcel.content_type
               request_env.headers[Core::EVP::SUBDOMAIN_HEADER_NAME] =
                 Core::EVP::EVENT_PLATFORM_INTAKE_SUBDOMAIN
+              request_env.headers["DD-EVP-ORIGIN"] = "dd-trace-rb"
+              request_env.headers["DD-EVP-ORIGIN-VERSION"] = Datadog::VERSION::STRING
               request_env.body = env.request.parcel.data
 
               block.call(request_env)

data/lib/datadog/open_feature.rb

@@ -2,6 +2,7 @@
 
 require_relative "core/configuration"
 require_relative "open_feature/configuration"
+require_relative "open_feature/configuration/source"
 
 module Datadog
   # A namespace for the OpenFeature component.
@@ -9,11 +10,40 @@ module Datadog
     Core::Configuration::Settings.extend(Configuration::Settings)
 
     def self.enabled?
-      Datadog.configuration.open_feature.enabled
+      Configuration::Source.resolve(Datadog.configuration).enabled?
     end
 
     def self.engine
       Datadog.send(:components).open_feature&.engine
     end
+
+    def self.activate_provider(provider)
+      # Initialize the component tree before taking its reconfiguration lock.
+      Datadog.send(:components)
+      Datadog.send(:safely_synchronize) do
+        return [nil, nil] if provider.send(:shutdown?)
+
+        components = Datadog.send(:components, allow_initialization: false)
+        activation = components&.send(:open_feature_activation)
+        providers = @adopted_providers ||= {}.compare_by_identity
+        providers[provider] = true
+        [activation&.activate(provider), activation&.failure]
+      end
+    end
+
+    def self.deactivate_provider(provider)
+      Datadog.send(:safely_synchronize) do
+        @adopted_providers&.delete(provider)
+        components = Datadog.send(:components, allow_initialization: false)
+        components&.send(:open_feature_activation)&.deactivate(provider)
+      end
+    end
+
+    # Components startup already holds the non-reentrant reconfiguration lock.
+    def self.reattach(activation)
+      providers = @adopted_providers&.keys || []
+      providers.each { |provider| activation.activate(provider) }
+      nil
+    end
   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/signal_configuration.rb

@@ -12,23 +12,24 @@ module Datadog
       def create_resource
         resource_attributes = {}
 
-        @settings.tags&.each do |key, value| # steep:ignore
+        @settings.tags&.each do |key, value|
           otel_key = case key
           when "service" then "service.name"
-          when "env" then "deployment.environment"
+          when "env", "deployment.environment.name", "deployment.environment" then next
           when "version" then "service.version"
           else key
           end
           resource_attributes[otel_key] = value
         end
 
-        resource_attributes["service.name"] = @settings.service_without_fallback || resource_attributes["service.name"] || Datadog::Core::Environment::Ext::FALLBACK_SERVICE_NAME # steep:ignore
-        resource_attributes["deployment.environment"] = @settings.env if @settings.env # steep:ignore
-        resource_attributes["service.version"] = @settings.version if @settings.version # steep:ignore
+        resource_attributes["service.name"] = @settings.service_without_fallback || resource_attributes["service.name"] || Datadog::Core::Environment::Ext::FALLBACK_SERVICE_NAME
+        environment = @settings.env || @settings.tags["env"] || @settings.tags["deployment.environment.name"] || @settings.tags["deployment.environment"]
+        resource_attributes["deployment.environment.name"] = environment if environment
+        resource_attributes["service.version"] = @settings.version if @settings.version
 
-        hostname = Datadog::Core::Environment::Socket.resolved_hostname(@settings) # steep:ignore
+        hostname = Datadog::Core::Environment::Socket.resolved_hostname(@settings)
         if hostname
-          if hostname == @settings.hostname # steep:ignore
+          if hostname == @settings.hostname
             resource_attributes["host.name"] = hostname
           elsif !resource_attributes.key?("host.name")
             resource_attributes["host.name"] = hostname
@@ -41,9 +42,12 @@ module Datadog
       # Returns the signal-specific option value when explicitly set,
       # otherwise falls back to the general OTLP exporter config or computed_default.
       def config_or_exporter_fallback(signal:, option_name:, computed_default: nil)
-        signal_settings = @settings.opentelemetry.public_send(signal) # steep:ignore
+        signal_settings = case signal
+        when :logs then @settings.opentelemetry.logs
+        when :metrics then @settings.opentelemetry.metrics
+        end
         if signal_settings.using_default?(option_name)
-          @settings.opentelemetry.exporter.public_send(option_name) || computed_default # steep:ignore
+          @settings.opentelemetry.exporter.public_send(option_name) || computed_default
         else
           signal_settings.public_send(option_name)
         end

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,11 +46,12 @@ 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,
           skip_idle_samples_for_testing: false,
-          idle_sampling_helper: IdleSamplingHelper.new(thread_context_collector: thread_context_collector)
+          idle_sampling_helper: IdleSamplingHelper.new
         )
           unless dynamic_sampling_rate_enabled
             Datadog.logger.warn(
@@ -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
@@ -95,7 +98,7 @@ module Datadog
 
             Datadog.logger.debug { "Starting thread for: #{self}" }
 
-            @idle_sampling_helper.start
+            @idle_sampling_helper.start(self)
 
             @worker_thread = Thread.new do
               Thread.current.name = self.class.name
@@ -144,6 +147,11 @@ module Datadog
           end
         end
 
+        # @rbs return: Datadog::Profiling::StackRecorder
+        def prepare_serialize
+          self.class._native_prepare_serialize(self)
+        end
+
         #: () -> true
         def reset_after_fork
           self.class._native_reset_after_fork(self)

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

@@ -10,7 +10,6 @@ module Datadog
       class IdleSamplingHelper
         # @rbs @worker_thread: untyped
         # @rbs @start_stop_mutex: ::Thread::Mutex
-        # @rbs @thread_context_collector: Datadog::Profiling::Collectors::ThreadContext?
 
         private
 
@@ -18,15 +17,14 @@ module Datadog
 
         public
 
-        #: (thread_context_collector: Datadog::Profiling::Collectors::ThreadContext) -> void
-        def initialize(thread_context_collector:)
+        #: () -> void
+        def initialize
           @worker_thread = nil
           @start_stop_mutex = Mutex.new
-          @thread_context_collector = thread_context_collector
         end
 
-        #: () -> (nil | true)
-        def start
+        #: (CpuAndWallTimeWorker cpu_and_wall_time_worker) -> true?
+        def start(cpu_and_wall_time_worker)
           @start_stop_mutex.synchronize do
             return if @worker_thread&.alive?
 
@@ -39,7 +37,7 @@ module Datadog
             @worker_thread = Thread.new do
               Thread.current.name = self.class.name
 
-              self.class._native_idle_sampling_loop(self, @thread_context_collector)
+              self.class._native_idle_sampling_loop(self, cpu_and_wall_time_worker)
 
               Datadog.logger.debug("IdleSamplingHelper thread stopping cleanly")
             rescue Exception => e # rubocop:disable Lint/RescueException