datadog 2.30.0 → 2.45.0

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

@@ -19,10 +19,9 @@ module Datadog
           max_frames:,
           tracer:,
           endpoint_collection_enabled:,
-          timeline_enabled:,
-          waiting_for_gvl_threshold_ns:,
           otel_context_enabled:,
-          native_filenames_enabled:
+          native_filenames_enabled:,
+          show_classes:
         )
           tracer_context_key = safely_extract_context_key_from(tracer)
           self.class._native_initialize(
@@ -31,10 +30,10 @@ module Datadog
             max_frames: max_frames,
             tracer_context_key: tracer_context_key,
             endpoint_collection_enabled: endpoint_collection_enabled,
-            timeline_enabled: timeline_enabled,
-            waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
             otel_context_enabled: otel_context_enabled,
-            native_filenames_enabled: validate_native_filenames(native_filenames_enabled),
+            native_filenames_enabled: native_filenames_enabled,
+            show_classes: show_classes,
+            overhead_filename: __FILE__,
           )
         end
 
@@ -43,23 +42,29 @@ module Datadog
           max_frames: 400,
           tracer: nil,
           endpoint_collection_enabled: false,
-          timeline_enabled: false,
-          waiting_for_gvl_threshold_ns: 10_000_000,
           otel_context_enabled: false,
           native_filenames_enabled: true,
+          show_classes: false,
+          trigger_global_reset: true,
           **options
         )
-          new(
+          collector = new(
             recorder: recorder,
             max_frames: max_frames,
             tracer: tracer,
             endpoint_collection_enabled: endpoint_collection_enabled,
-            timeline_enabled: timeline_enabled,
-            waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
             otel_context_enabled: otel_context_enabled,
             native_filenames_enabled: native_filenames_enabled,
+            show_classes: show_classes,
             **options,
           )
+
+          # By default, mirror what the CpuAndWallTimeWorker does when profiling starts: reset the global per-thread
+          # context state, which (among other things) resizes the per-thread sampling buffers to this collector's
+          # max_frames. Tests that need to control this explicitly can pass `trigger_global_reset: false`.
+          Testing._native_global_reset_per_thread_context(collector) if trigger_global_reset
+
+          collector
         end
 
         def inspect
@@ -85,17 +90,6 @@ module Datadog
           context = provider.instance_variable_get(:@context)
           context&.instance_variable_get(:@key)
         end
-
-        def validate_native_filenames(native_filenames_enabled)
-          if native_filenames_enabled && !Datadog::Profiling::Collectors::Stack._native_filenames_available?
-            Datadog.logger.debug(
-              "Native filenames are enabled, but the required dladdr API was not available. Disabling native filenames."
-            )
-            false
-          else
-            native_filenames_enabled
-          end
-        end
       end
     end
   end

data/lib/datadog/profiling/component.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../core/telemetry/logger"
+
 module Datadog
   module Profiling
     # Responsible for wiring up the Profiler for execution
@@ -8,8 +10,6 @@ module Datadog
       # * Profiling in the trace viewer, as well as scoping a profile down to a span
       # * Endpoint aggregation in the profiler UX, including normalization (resource per endpoint call)
       def self.build_profiler_component(settings:, agent_settings:, optional_tracer:, logger:) # rubocop:disable Metrics/MethodLength
-        return [nil, {profiling_enabled: false}] unless settings.profiling.enabled
-
         # Workaround for weird dependency direction: the Core::Configuration::Components class currently has a
         # dependency on individual products, in this case the Profiler.
         # (Note "currently": in the future we want to change this so core classes don't depend on specific products)
@@ -29,7 +29,7 @@ module Datadog
         # no-op if profiling is already loaded).
         require_relative "../profiling"
 
-        return [nil, {profiling_enabled: false}] unless Profiling.supported?
+        return [nil, {profiling_enabled: false}] unless settings.profiling.enabled && Profiling.supported?
 
         # Activate forking extensions
         Profiling::Tasks::Setup.new.run
@@ -37,7 +37,6 @@ module Datadog
         # NOTE: Please update the Initialization section of ProfilingDevelopment.md with any changes to this method
 
         no_signals_workaround_enabled = no_signals_workaround_enabled?(settings, logger)
-        timeline_enabled = settings.profiling.advanced.timeline_enabled
         allocation_profiling_enabled = enable_allocation_profiling?(settings, logger)
         heap_sample_every = get_heap_sample_every(settings)
         heap_profiling_enabled = enable_heap_profiling?(settings, allocation_profiling_enabled, heap_sample_every, logger)
@@ -49,15 +48,13 @@ module Datadog
           valid_cpu_sampling_interval(settings.profiling.advanced.experimental_cpu_sampling_interval_ms, logger)
 
         recorder = Datadog::Profiling::StackRecorder.new(
-          cpu_time_enabled: RUBY_PLATFORM.include?("linux"), # Only supported on Linux currently
           alloc_samples_enabled: allocation_profiling_enabled,
           heap_samples_enabled: heap_profiling_enabled,
           heap_size_enabled: heap_size_profiling_enabled,
           heap_sample_every: heap_sample_every,
-          timeline_enabled: timeline_enabled,
           heap_clean_after_gc_enabled: settings.profiling.advanced.heap_clean_after_gc_enabled,
         )
-        thread_context_collector = build_thread_context_collector(settings, recorder, optional_tracer, timeline_enabled)
+        thread_context_collector = build_thread_context_collector(settings, recorder, optional_tracer)
         worker = Datadog::Profiling::Collectors::CpuAndWallTimeWorker.new(
           gc_profiling_enabled: enable_gc_profiling?(settings, logger),
           no_signals_workaround_enabled: no_signals_workaround_enabled,
@@ -68,15 +65,15 @@ module Datadog
           gvl_profiling_enabled: enable_gvl_profiling?(settings, logger),
           sighandler_sampling_enabled: settings.profiling.advanced.sighandler_sampling_enabled,
           cpu_sampling_interval_ms: cpu_sampling_interval_ms,
+          waiting_for_gvl_threshold_ns: settings.profiling.advanced.waiting_for_gvl_threshold_ns,
         )
 
         internal_metadata = {
           no_signals_workaround_enabled: no_signals_workaround_enabled,
-          timeline_enabled: timeline_enabled,
           heap_sample_every: heap_sample_every,
         }.freeze
 
-        exporter = build_profiler_exporter(settings, recorder, worker, internal_metadata: internal_metadata)
+        exporter = build_profiler_exporter(settings, worker, internal_metadata: internal_metadata)
         transport = build_profiler_transport(settings, agent_settings)
         scheduler = Profiling::Scheduler.new(exporter: exporter, transport: transport, interval: upload_period_seconds)
         profiler = Profiling::Profiler.new(worker: worker, scheduler: scheduler)
@@ -90,28 +87,34 @@ module Datadog
         end
 
         [profiler, {profiling_enabled: true}]
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        logger.warn do
+          "Failed to initialize profiling: #{e.class}: #{e.message} " \
+          "Location: #{Array(e.backtrace).first}"
+        end
+        Datadog::Core::Telemetry::Logger.report(e, description: "Failed to initialize profiling")
+
+        [nil, {profiling_enabled: false}]
       end
 
-      private_class_method def self.build_thread_context_collector(settings, recorder, optional_tracer, timeline_enabled)
+      private_class_method def self.build_thread_context_collector(settings, recorder, optional_tracer)
         Datadog::Profiling::Collectors::ThreadContext.new(
           recorder: recorder,
           max_frames: settings.profiling.advanced.max_frames,
           tracer: optional_tracer,
           endpoint_collection_enabled: settings.profiling.advanced.endpoint.collection.enabled,
-          timeline_enabled: timeline_enabled,
-          waiting_for_gvl_threshold_ns: settings.profiling.advanced.waiting_for_gvl_threshold_ns,
           otel_context_enabled: settings.profiling.advanced.preview_otel_context_enabled,
           native_filenames_enabled: settings.profiling.advanced.native_filenames_enabled,
+          show_classes: settings.profiling.advanced.experimental_show_classes_enabled,
         )
       end
 
-      private_class_method def self.build_profiler_exporter(settings, recorder, worker, internal_metadata:)
+      private_class_method def self.build_profiler_exporter(settings, worker, internal_metadata:)
         info_collector = Profiling::Collectors::Info.new(settings)
         code_provenance_collector =
           (Profiling::Collectors::CodeProvenance.new if settings.profiling.advanced.code_provenance_enabled)
 
         Profiling::Exporter.new(
-          pprof_recorder: recorder,
           worker: worker,
           info_collector: info_collector,
           code_provenance_collector: code_provenance_collector,
@@ -138,15 +141,14 @@ module Datadog
         # that causes a segmentation fault during garbage collection of Ractors
         # (https://bugs.ruby-lang.org/issues/18464). We don't allow enabling gc profiling on such Rubies.
         # This bug is fixed on Ruby versions 3.1.4, 3.2.3 and 3.3.0.
-        if RUBY_VERSION.start_with?("3.0.") ||
-            (RUBY_VERSION.start_with?("3.1.") && RUBY_VERSION < "3.1.4") ||
-            (RUBY_VERSION.start_with?("3.2.") && RUBY_VERSION < "3.2.3")
+        if RubyVersion.is?(">= 3", "< 3.1.4") ||
+            RubyVersion.is?(">= 3.2", "< 3.2.3")
           logger.warn(
             "Current Ruby version (#{RUBY_VERSION}) has a VM bug where enabling GC profiling would cause " \
             "crashes (https://bugs.ruby-lang.org/issues/18464). GC profiling has been disabled."
           )
           return false
-        elsif RUBY_VERSION.start_with?("3.")
+        elsif RubyVersion.is?(">= 3", "< 4")
           logger.debug(
             "Using Ractors may result in GC profiling unexpectedly " \
             "stopping (https://bugs.ruby-lang.org/issues/19112). Note that this stop has no impact in your " \
@@ -174,7 +176,7 @@ module Datadog
         # Ruby 3.2.0 to 3.2.2 have a bug in the newobj tracepoint (https://bugs.ruby-lang.org/issues/19482,
         # https://github.com/ruby/ruby/pull/7464) that makes this crash in any configuration. This bug is
         # fixed on Ruby versions 3.2.3 and 3.3.0.
-        if RUBY_VERSION.start_with?("3.2.") && RUBY_VERSION < "3.2.3"
+        if RubyVersion.is?(">= 3.2", "< 3.2.3")
           logger.warn(
             "Allocation profiling is not supported in Ruby versions 3.2.0, 3.2.1 and 3.2.2 and will be forcibly " \
             "disabled. This is due to a VM bug that can lead to crashes (https://bugs.ruby-lang.org/issues/19482). " \
@@ -188,9 +190,8 @@ module Datadog
         # that causes a segmentation fault during garbage collection of Ractors
         # (https://bugs.ruby-lang.org/issues/18464). We don't recommend using this feature on such Rubies.
         # This bug is fixed on Ruby versions 3.1.4, 3.2.3 and 3.3.0.
-        if RUBY_VERSION.start_with?("3.0.") ||
-            (RUBY_VERSION.start_with?("3.1.") && RUBY_VERSION < "3.1.4") ||
-            (RUBY_VERSION.start_with?("3.2.") && RUBY_VERSION < "3.2.3")
+        if RubyVersion.is?(">= 3", "< 3.1.4") ||
+            RubyVersion.is?(">= 3.2", "< 3.2.3")
           logger.warn(
             "Current Ruby version (#{RUBY_VERSION}) has a VM bug where enabling allocation profiling while using " \
             "Ractors may cause unexpected issues, including crashes (https://bugs.ruby-lang.org/issues/18464). " \
@@ -199,7 +200,7 @@ module Datadog
         # ANNOYANCE - Only with Ractors
         # On all known versions of Ruby 3.x, due to https://bugs.ruby-lang.org/issues/19112, when a ractor gets
         # garbage collected, Ruby will disable all active tracepoints, which this feature internally relies on.
-        elsif RUBY_VERSION.start_with?("3.")
+        elsif RubyVersion.is?(">= 3", "< 4")
           logger.debug(
             "Using Ractors may result in allocation profiling " \
             "stopping (https://bugs.ruby-lang.org/issues/19112). Note that this stop has no impact in your " \
@@ -217,7 +218,7 @@ module Datadog
 
         return false unless heap_profiling_enabled
 
-        if RUBY_VERSION < "3.1"
+        if RubyVersion.is?("< 3.1")
           logger.warn(
             "Current Ruby version (#{RUBY_VERSION}) cannot support heap profiling due to VM limitations. " \
             "Please upgrade to Ruby >= 3.1 in order to use this feature. Heap profiling has been disabled."
@@ -225,6 +226,17 @@ module Datadog
           return false
         end
 
+        # Heap profiling tracks live objects using an `ObjectSpace::WeakMap`, which could corrupt its internal
+        # state during compaction before these versions (https://bugs.ruby-lang.org/issues/19529).
+        if RubyVersion.is?("< 3.1.4") || RubyVersion.is?(">= 3.2", "< 3.2.3")
+          logger.warn(
+            "Current Ruby version (#{RUBY_VERSION}) cannot support heap profiling due to a VM bug. " \
+            "Please upgrade to Ruby >= 3.1.4 or >= 3.2.3 in order to use this feature. " \
+            "Heap profiling has been disabled."
+          )
+          return false
+        end
+
         unless allocation_profiling_enabled
           logger.warn(
             "Heap profiling was requested but allocation profiling is not enabled. " \
@@ -241,9 +253,7 @@ module Datadog
       private_class_method def self.enable_heap_size_profiling?(settings, heap_profiling_enabled, logger)
         heap_size_profiling_enabled = settings.profiling.advanced.experimental_heap_size_enabled
 
-        return false unless heap_profiling_enabled && heap_size_profiling_enabled
-
-        true
+        heap_profiling_enabled && heap_size_profiling_enabled
       end
 
       private_class_method def self.no_signals_workaround_enabled?(settings, logger) # rubocop:disable Metrics/MethodLength
@@ -259,7 +269,7 @@ module Datadog
         end
 
         if setting_value == false
-          if RUBY_VERSION.start_with?("2.5.")
+          if RubyVersion.is?("< 2.6")
             logger.warn(
               'The profiling "no signals" workaround has been disabled via configuration on Ruby 2.5. ' \
               "This is not recommended " \
@@ -285,7 +295,7 @@ module Datadog
         # Setting is in auto mode. Let's probe to see if we should enable it:
 
         # We don't warn users in this situation because "upgrade your Ruby" is not a great warning
-        return true if RUBY_VERSION.start_with?("2.5.")
+        return true if RubyVersion.is?("< 2.6")
 
         if Gem.loaded_specs["mysql2"] && incompatible_libmysqlclient_version?(settings, logger)
           logger.warn(
@@ -368,7 +378,7 @@ module Datadog
         rescue StandardError, LoadError => e
           logger.warn(
             "Failed to probe `mysql2` gem information. " \
-            "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+            "Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
           )
 
           true
@@ -447,13 +457,13 @@ module Datadog
       end
 
       private_class_method def self.dir_interruption_workaround_enabled?(settings, no_signals_workaround_enabled)
-        return false if no_signals_workaround_enabled || RUBY_VERSION >= "3.4"
+        return false if no_signals_workaround_enabled || RubyVersion.is?(">= 3.4")
 
         settings.profiling.advanced.dir_interruption_workaround_enabled
       end
 
       private_class_method def self.can_apply_exec_monkey_patch?(settings)
-        return false if RUBY_VERSION < "2.7"
+        return false if RubyVersion.is?("< 2.7")
 
         # This file is 2.7+ only so we only require it here once we've checked the Ruby version
         require "datadog/profiling/ext/exec_monkey_patch"
@@ -462,11 +472,7 @@ module Datadog
       end
 
       private_class_method def self.enable_gvl_profiling?(settings, logger)
-        return false if RUBY_VERSION < "3.2"
-
-        # GVL profiling only makes sense in the context of timeline. We could emit a warning here, but not sure how
-        # useful it is -- if a customer disables timeline, there's nowhere to look for GVL profiling anyway!
-        settings.profiling.advanced.timeline_enabled && settings.profiling.advanced.gvl_enabled
+        RubyVersion.is?(">= 3.2") && settings.profiling.advanced.gvl_enabled
       end
     end
   end

data/lib/datadog/profiling/exporter.rb

@@ -13,26 +13,34 @@ module Datadog
     # recorders, so I've decided to make it specific until we actually need to support more recorders.
     #
     class Exporter
+      # @rbs @worker: Datadog::Profiling::Collectors::CpuAndWallTimeWorker
+
       # Profiles with duration less than this will not be reported
       PROFILE_DURATION_THRESHOLD_SECONDS = 1
 
       private
 
-      attr_reader \
-        :pprof_recorder,
-        :code_provenance_collector, # The code provenance collector acts both as collector and as a recorder
-        :minimum_duration_seconds,
-        :time_provider,
-        :last_flush_finish_at,
-        :created_at,
-        :internal_metadata,
-        :info_json,
-        :sequence_tracker
+      # The code provenance collector acts both as collector and as a recorder
+      attr_reader :code_provenance_collector #: Datadog::Profiling::Collectors::CodeProvenance?
+      attr_reader :minimum_duration_seconds #: ::Integer
+      attr_reader :time_provider #: singleton(::Time)
+      attr_reader :last_flush_finish_at #: ::Time?
+      attr_reader :created_at #: ::Time
+      attr_reader :internal_metadata #: ::Hash[::Symbol, untyped]
+      attr_reader :info_json #: ::String
+      attr_reader :sequence_tracker #: singleton(Datadog::Profiling::SequenceTracker)
 
       public
 
+      # @rbs worker: Datadog::Profiling::Collectors::CpuAndWallTimeWorker
+      # @rbs info_collector: Datadog::Profiling::Collectors::Info
+      # @rbs code_provenance_collector: Datadog::Profiling::Collectors::CodeProvenance?
+      # @rbs internal_metadata: ::Hash[::Symbol, untyped]
+      # @rbs minimum_duration_seconds: ::Integer
+      # @rbs time_provider: singleton(::Time)
+      # @rbs sequence_tracker: singleton(Datadog::Profiling::SequenceTracker)
+      # @rbs return: void
       def initialize(
-        pprof_recorder:,
         worker:,
         info_collector:,
         code_provenance_collector:,
@@ -41,7 +49,6 @@ module Datadog
         time_provider: Time,
         sequence_tracker: Datadog::Profiling::SequenceTracker
       )
-        @pprof_recorder = pprof_recorder
         @worker = worker
         @code_provenance_collector = code_provenance_collector
         @minimum_duration_seconds = minimum_duration_seconds
@@ -55,7 +62,9 @@ module Datadog
         @sequence_tracker = sequence_tracker
       end
 
+      #: () -> Datadog::Profiling::Flush?
       def flush
+        pprof_recorder = @worker.prepare_serialize
         worker_stats = @worker.stats_and_reset_not_thread_safe
         serialization_result = pprof_recorder.serialize
         return if serialization_result.nil?
@@ -68,17 +77,27 @@ module Datadog
           return
         end
 
-        uncompressed_code_provenance = code_provenance_collector.refresh.generate_json if code_provenance_collector
+        uncompressed_code_provenance =
+          if (collector = code_provenance_collector)
+            collector.refresh.generate_json
+          end
+
+        metrics = [] #: Array[[::String, ::Numeric]]
+
+        # The key is always there, but the value might be nil if GVL profiling is disabled.
+        # We delete it to avoid reporting the same data point twice.
+        gvl_waiting_time_ns_total = worker_stats.delete(:gvl_waiting_time_ns_total)
+        metrics << ["ruby_global_lock_wait_time_total", gvl_waiting_time_ns_total] if gvl_waiting_time_ns_total
 
         process_tags = Datadog.configuration.experimental_propagate_process_tags_enabled ?
-          Core::Environment::Process.serialized : ''
+          Core::Environment::Process.serialized : ""
 
         Flush.new(
           start: start,
           finish: finish,
           encoded_profile: encoded_profile,
-          code_provenance_file_name: Datadog::Profiling::Ext::Transport::HTTP::CODE_PROVENANCE_FILENAME,
           code_provenance_data: uncompressed_code_provenance,
+          metrics: metrics,
           tags_as_array: Datadog::Profiling::TagBuilder.call(
             settings: Datadog.configuration,
             profile_seq: sequence_tracker.get_next,
@@ -89,17 +108,19 @@ module Datadog
               worker_stats: worker_stats,
               profile_stats: profile_stats,
               recorder_stats: pprof_recorder.stats,
-              gc: GC.stat,
+              gc: gc_stats,
             }
           ),
           info_json: info_json,
         )
       end
 
+      #: () -> bool
       def can_flush?
         !duration_below_threshold?(last_flush_finish_at || created_at, time_provider.now.utc)
       end
 
+      #: () -> void
       def reset_after_fork
         @last_flush_finish_at = time_provider.now.utc
         nil
@@ -107,6 +128,12 @@ module Datadog
 
       private
 
+      # @rbs return: Hash[Symbol, Integer | bool]
+      def gc_stats
+        GC.stat.merge(auto_compact: GC.respond_to?(:auto_compact) && GC.auto_compact)
+      end
+
+      #: (::Time, ::Time) -> bool
       def duration_below_threshold?(start, finish)
         (finish - start) < minimum_duration_seconds
       end

data/lib/datadog/profiling/ext/dir_monkey_patches.rb

@@ -4,9 +4,10 @@ module Datadog
   module Profiling
     # Monkey patches needed for profiler features and compatibility
     module Ext
-      # All Ruby versions as of this writing have bugs in the dir class implementation, causing issues such as
+      # Ruby versions before 3.4 have bugs in the `Dir` class implementation, causing issues such as
       # https://github.com/DataDog/dd-trace-rb/issues/3450 .
-      # See also https://bugs.ruby-lang.org/issues/20586 for more details.
+      # This was fixed upstream in https://bugs.ruby-lang.org/issues/20586 but we use this monkey patch to work around
+      # the issue on legacy versions (it gets applied by `Datadog::Profiling::Component`).
       #
       # This monkey patch for the Ruby `Dir` class works around these bugs for affected Ruby versions by temporarily
       # blocking the profiler from interrupting system calls.
@@ -27,7 +28,7 @@ module Datadog
         end
       end
 
-      if RUBY_VERSION.start_with?("2.")
+      if RubyVersion.is?("< 3")
         # Monkey patches for Dir.singleton_class (Ruby 2 version). See DirMonkeyPatches above for more details.
         module DirClassMonkeyPatches
           # Steep: Workaround that defines args and block only for Ruby 2.x.
@@ -269,7 +270,7 @@ module Datadog
         end
       end
 
-      if RUBY_VERSION.start_with?("2.")
+      if RubyVersion.is?("< 3")
         # Monkey patches for Dir (Ruby 2 version). See DirMonkeyPatches above for more details.
         module DirInstanceMonkeyPatches
           # Steep: Workaround that defines args and block only for Ruby 2.x.
@@ -299,7 +300,7 @@ module Datadog
             end
           end
 
-          unless RUBY_VERSION.start_with?("2.5.") # This is Ruby 2.6+
+          if RubyVersion.is?(">= 2.6.0") # This method is Ruby 2.6+
             # See note on methods that yield above.
             def each_child(*args, &block)
               if block

data/lib/datadog/profiling/ext.rb

@@ -13,8 +13,6 @@ module Datadog
       module Transport
         module HTTP
           FORM_FIELD_TAG_PROFILER_VERSION = "profiler_version"
-
-          CODE_PROVENANCE_FILENAME = "code-provenance.json"
         end
       end
     end

data/lib/datadog/profiling/flush.rb

@@ -6,23 +6,32 @@ module Datadog
   module Profiling
     # Entity class used to represent metadata for a given profile
     class Flush
-      attr_reader \
-        :start,
-        :finish,
-        :encoded_profile,
-        :code_provenance_file_name,
-        :code_provenance_data,
-        :tags_as_array,
-        :process_tags,
-        :internal_metadata_json,
-        :info_json
+      attr_reader :start #: ::Time
+      attr_reader :finish #: ::Time
+      attr_reader :encoded_profile #: Datadog::Profiling::EncodedProfile
+      attr_reader :code_provenance_data #: ::String?
+      attr_reader :metrics #: ::String
+      attr_reader :tags_as_array #: Array[[::String, ::String]]
+      attr_reader :process_tags #: ::String
+      attr_reader :internal_metadata_json #: ::String
+      attr_reader :info_json #: ::String
 
+      # @rbs start: ::Time
+      # @rbs finish: ::Time
+      # @rbs encoded_profile: Datadog::Profiling::EncodedProfile
+      # @rbs code_provenance_data: ::String?
+      # @rbs metrics: Array[[::String, ::Numeric]]
+      # @rbs tags_as_array: Array[[::String, ::String]]
+      # @rbs process_tags: ::String
+      # @rbs internal_metadata: ::Hash[::Symbol, ::String | bool | ::Numeric]
+      # @rbs info_json: ::String
+      # @rbs return: void
       def initialize(
         start:,
         finish:,
         encoded_profile:,
-        code_provenance_file_name:,
         code_provenance_data:,
+        metrics:,
         tags_as_array:,
         process_tags:,
         internal_metadata:,
@@ -31,8 +40,8 @@ module Datadog
         @start = start
         @finish = finish
         @encoded_profile = encoded_profile
-        @code_provenance_file_name = code_provenance_file_name
         @code_provenance_data = code_provenance_data
+        @metrics = JSON.generate(metrics)
         @tags_as_array = tags_as_array
         @process_tags = process_tags
         @internal_metadata_json = JSON.generate(internal_metadata)

data/lib/datadog/profiling/http_transport.rb

@@ -8,8 +8,16 @@ module Datadog
     # Used to report profiling data to Datadog.
     # Methods prefixed with _native_ are implemented in `http_transport.c`
     class HttpTransport
-      attr_reader :exporter_configuration
+      # @rbs @exporter_configuration: exporter_configuration_array
 
+      attr_reader :exporter_configuration #: exporter_configuration_array
+
+      # @rbs agent_settings: Datadog::Core::Configuration::AgentSettings
+      # @rbs site: ::String?
+      # @rbs api_key: ::String?
+      # @rbs upload_timeout_seconds: ::Integer
+      # @rbs use_system_dns: bool
+      # @rbs return: void
       def initialize(agent_settings:, site:, api_key:, upload_timeout_seconds:, use_system_dns:)
         timeout_milliseconds = (upload_timeout_seconds * 1_000).to_i
 
@@ -28,6 +36,7 @@ module Datadog
         raise(ArgumentError, "Failed to initialize transport: #{result}") if status == :error
       end
 
+      #: (Datadog::Profiling::Flush) -> bool
       def export(flush)
         status, result = self.class._native_do_export(
           exporter_configuration,
@@ -57,10 +66,12 @@ module Datadog
 
       private
 
+      #: (::String?, ::String?) -> bool?
       def agentless?(site, api_key)
-        site && api_key && %w[1 true].include?(ENV[Profiling::Ext::ENV_AGENTLESS] || '') # rubocop:disable CustomCops/EnvUsageCop
+        site && api_key && %w[1 true].include?(ENV[Profiling::Ext::ENV_AGENTLESS] || "") # rubocop:disable CustomCops/EnvUsageCop
       end
 
+      #: () -> ::String
       def config_without_api_key
         "#{exporter_configuration[0]}: #{exporter_configuration[3]}"
       end

data/lib/datadog/profiling/load_native_extension.rb

@@ -4,6 +4,6 @@ begin
   require "datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
 rescue LoadError => e
   raise LoadError,
-    "Failed to load the profiling loader extension. To fix this, please remove and then reinstall datadog " \
-    "(Details: #{e.message})"
+    "Failed to load the profiling native extension. To fix this, please remove and then reinstall datadog " \
+    "(Details: #{e.class}: #{e.message})"
 end

data/lib/datadog/profiling/profiler.rb

@@ -8,19 +8,20 @@ module Datadog
 
       private
 
-      attr_reader :worker, :scheduler
+      attr_reader :worker #: Datadog::Profiling::Collectors::CpuAndWallTimeWorker
+      attr_reader :scheduler #: Datadog::Profiling::Scheduler
 
       public
 
+      # @rbs worker: Datadog::Profiling::Collectors::CpuAndWallTimeWorker
+      # @rbs scheduler: Datadog::Profiling::Scheduler
+      # @rbs return: void
       def initialize(worker:, scheduler:)
         @worker = worker
         @scheduler = scheduler
       end
 
-      def enabled?
-        scheduler.running?
-      end
-
+      #: () -> void
       def start
         after_fork! do
           worker.reset_after_fork
@@ -36,6 +37,8 @@ module Datadog
         scheduler.start(on_failure_proc: proc { component_failed(:scheduler) })
       end
 
+      # @rbs report_last_profile: bool
+      # @rbs return: void
       def shutdown!(report_last_profile: true)
         Datadog.logger.debug("Shutting down profiler")
 
@@ -46,15 +49,20 @@ module Datadog
 
       private
 
+      #: () -> void
       def stop_worker
         worker.stop
       end
 
+      #: () -> void
       def stop_scheduler
         scheduler.enabled = false
         scheduler.stop(true)
       end
 
+      # @rbs failed_component: :worker | :scheduler | ::Symbol
+      # @rbs log_failure: bool
+      # @rbs return: void
       def component_failed(failed_component, log_failure: true)
         if log_failure
           Datadog.logger.warn(