datadog 2.31.0 → 2.33.0

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

@@ -1,23 +1,29 @@
 # frozen_string_literal: true
 
+require_relative '../../tracing/utils'
+
 module Datadog
   module OpenTelemetry
     module SDK
-      # Generates Datadog-compatible IDs for OpenTelemetry traces.
-      # OpenTelemetry traces already produce Datadog-compatible IDs.
+      # Generates Datadog-compatible trace IDs for OpenTelemetry spans.
+      #
+      # Reuses the same 128-bit ID format as non-OTel Datadog tracing:
+      #   [32-bit seconds since Epoch | 32 zero bits | 64 random bits]
+      #
+      # When DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED is false the high 64
+      # bits are zero, preserving the OTel 16-byte wire format while keeping
+      # backward compatibility with 64-bit Datadog trace IDs.
       class IdGenerator
         class << self
           include ::OpenTelemetry::Trace
 
-          # Generates a valid trace identifier, a 16-byte string with at least one
-          # non-zero byte.
-          #
-          # @return [String] a valid trace ID.
+          # @return [String] a valid 16-byte trace ID.
           def generate_trace_id
-            loop do
-              id = Random.bytes(8) # DEV: Change to 16 (16*8-byte) when 128-bit trace_id is supported.
-              return id unless id == ::OpenTelemetry::Trace::INVALID_SPAN_ID
-            end
+            trace_id = Tracing::Utils::TraceId.next_id
+            [
+              Tracing::Utils::TraceId.to_high_order(trace_id),
+              Tracing::Utils::TraceId.to_low_order(trace_id),
+            ].pack('Q>Q>')
           end
         end
       end

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

@@ -19,7 +19,7 @@ module Datadog
           telemetry&.inc(TELEMETRY_NAMESPACE, metric_name, 1, tags: TELEMETRY_TAGS)
           result
         rescue => e
-          Datadog.logger.error("Failed to export OpenTelemetry Metrics:  #{e.class}: #{e}")
+          Datadog.logger.error("Failed to export OpenTelemetry Metrics:  #{e.class}: #{e.message}")
           telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_FAILURES, 1, tags: TELEMETRY_TAGS)
           raise
         end

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

@@ -14,6 +14,9 @@ module Datadog
       #
       # This class acts both as a collector (collecting data) as well as a recorder (records/serializes it)
       class CodeProvenance
+        # @rbs standard_library_path: ::String
+        # @rbs ruby_native_filename: ::String?
+        # @rbs return: void
         def initialize(
           standard_library_path: RbConfig::CONFIG.fetch("rubylibdir"),
           ruby_native_filename: Datadog::Profiling::Collectors::Stack._native_ruby_native_filename
@@ -35,6 +38,9 @@ module Datadog
           )
         end
 
+        # @rbs loaded_files: ::Array[::String]
+        # @rbs loaded_specs: ::Array[::Gem::BasicSpecification]
+        # @rbs return: self
         def refresh(loaded_files: $LOADED_FEATURES, loaded_specs: Gem.loaded_specs.values)
           record_loaded_specs(loaded_specs)
           record_loaded_files(loaded_files)
@@ -42,19 +48,20 @@ module Datadog
           self
         end
 
+        #: () -> ::String
         def generate_json
           JSON.generate(v1: seen_libraries.to_a)
         end
 
         private
 
-        attr_reader \
-          :libraries_by_name,
-          :libraries_by_path,
-          :seen_files,
-          :seen_libraries,
-          :executable_paths
+        attr_reader :libraries_by_name #: ::Hash[::String, Library]
+        attr_reader :libraries_by_path #: ::Hash[::String, Library]
+        attr_reader :seen_files #: ::Set[::String]
+        attr_reader :seen_libraries #: ::Set[Library]
+        attr_reader :executable_paths #: ::Array[::String]
 
+        #: (Library) -> void
         def record_library(library)
           libraries_by_name[library.name] = library
           libraries_by_path[library.path] = library
@@ -71,10 +78,12 @@ module Datadog
         #
         # Alternatively/in the future we could instead use a trie to match paths, but I doubt for the data sizes we're
         # looking at that a trie is that much faster than using Ruby's built-in native collections.
+        #: () -> void
         def sort_libraries_by_longest_path_first
           @libraries_by_path = @libraries_by_path.sort.reverse!.to_h
         end
 
+        #: (::Array[::Gem::BasicSpecification]) -> void
         def record_loaded_specs(loaded_specs)
           recorded_library = false
 
@@ -103,6 +112,7 @@ module Datadog
           sort_libraries_by_longest_path_first if recorded_library
         end
 
+        #: (::Array[::String]) -> void
         def record_loaded_files(loaded_files)
           loaded_files.each do |file_path|
             next if seen_files.include?(file_path)
@@ -125,6 +135,7 @@ module Datadog
         # bundler complaints here impacting the application. (Bundler tends to go "something is wrong, raise!" which
         # I think makes a lot of sense given how bundler is intended to be used, but for this our kind of "ask a few
         # questions usage" it's not what we want.)
+        #: () -> ::String?
         def bundler_bin_path
           return unless defined?(Bundler)
 
@@ -135,7 +146,7 @@ module Datadog
         rescue Exception => e # rubocop:disable Lint/RescueException
           Datadog.logger.debug(
             "CodeProvenance#bundler_bin_path failed. " \
-            "Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
+            "Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
           )
           nil
         end
@@ -149,8 +160,21 @@ module Datadog
         # Thus, this class was setup to match the JSON output. Take this into consideration if you are adding new
         # fields. (Also, we have a spec for this)
         class Library
-          attr_reader :kind, :name, :version
-
+          # @rbs @kind: ::String
+          # @rbs @name: ::String
+          # @rbs @version: ::String
+          # @rbs @paths: ::Array[::String]
+
+          attr_reader :kind #: ::String
+          attr_reader :name #: ::String
+          attr_reader :version #: ::String
+
+          # @rbs kind: ::String
+          # @rbs name: ::String
+          # @rbs version: ::String | ::Gem::Version
+          # @rbs path: ::String
+          # @rbs extra_paths: ::Array[::String?]
+          # @rbs return: void
           def initialize(kind:, name:, version:, path:, extra_paths:)
             extra_paths = Array(extra_paths).compact.reject(&:empty?).map { |p| p.dup.freeze }
             @kind = kind.freeze
@@ -160,10 +184,12 @@ module Datadog
             freeze
           end
 
+          #: (?::JSON::State?) -> ::String
           def to_json(arg = nil)
             {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg)
           end
 
+          #: () -> ::String
           def path
             @paths.first
           end

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

@@ -9,12 +9,32 @@ module Datadog
       #
       # Methods prefixed with _native_ are implemented in `collectors_cpu_and_wall_time_worker.c`
       class CpuAndWallTimeWorker
+        # @rbs @worker_thread: untyped
+        # @rbs @start_stop_mutex: ::Thread::Mutex
+        # @rbs @failure_exception: ::Exception?
+        # @rbs @idle_sampling_helper: IdleSamplingHelper
+        # @rbs @wait_until_running_mutex: ::Thread::Mutex
+        # @rbs @wait_until_running_condition: ::Thread::ConditionVariable
+
         private
 
-        attr_accessor :failure_exception
+        attr_accessor :failure_exception #: ::Exception?
 
         public
 
+        # @rbs gc_profiling_enabled: bool
+        # @rbs no_signals_workaround_enabled: bool
+        # @rbs thread_context_collector: Datadog::Profiling::Collectors::ThreadContext
+        # @rbs dynamic_sampling_rate_overhead_target_percentage: Float
+        # @rbs cpu_sampling_interval_ms: ::Integer
+        # @rbs idle_sampling_helper: Datadog::Profiling::Collectors::IdleSamplingHelper
+        # @rbs dynamic_sampling_rate_enabled: bool
+        # @rbs allocation_profiling_enabled: bool
+        # @rbs allocation_counting_enabled: bool
+        # @rbs gvl_profiling_enabled: bool
+        # @rbs sighandler_sampling_enabled: bool
+        # @rbs skip_idle_samples_for_testing: false
+        # @rbs return: void
         def initialize(
           gc_profiling_enabled:,
           no_signals_workaround_enabled:,
@@ -67,6 +87,8 @@ module Datadog
           @wait_until_running_condition = ConditionVariable.new
         end
 
+        # @rbs on_failure_proc: (^(?log_failure: bool) -> void)?
+        # @rbs return: bool?
         def start(on_failure_proc: nil)
           @start_stop_mutex.synchronize do
             return if @worker_thread&.alive?
@@ -93,7 +115,7 @@ module Datadog
               operation_name = self.class._native_failure_exception_during_operation(self).inspect
               Datadog.logger.warn(
                 "CpuAndWallTimeWorker thread error. " \
-                "Operation: #{operation_name} Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
+                "Operation: #{operation_name} Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
               )
               on_failure_proc&.call
               Datadog::Core::Telemetry::Logger.report(e, description: "CpuAndWallTimeWorker thread error: #{operation_name}")
@@ -105,6 +127,7 @@ module Datadog
           true
         end
 
+        #: () -> void
         def stop
           @start_stop_mutex.synchronize do
             Datadog.logger.debug("Requesting CpuAndWallTimeWorker thread shut down")
@@ -121,14 +144,17 @@ module Datadog
           end
         end
 
+        #: () -> true
         def reset_after_fork
           self.class._native_reset_after_fork(self)
         end
 
+        #: () -> ::Hash[::Symbol, untyped]
         def stats
           self.class._native_stats(self)
         end
 
+        #: () -> ::Hash[::Symbol, untyped]
         def stats_and_reset_not_thread_safe
           stats = self.stats
           self.class._native_stats_reset_not_thread_safe(self)
@@ -136,6 +162,8 @@ module Datadog
         end
 
         # Useful for testing, to e.g. make sure the profiler is running before we start running some code we want to observe
+        # @rbs timeout_seconds: ::Integer?
+        # @rbs return: true
         def wait_until_running(timeout_seconds: 5)
           @wait_until_running_mutex.synchronize do
             return true if self.class._native_is_running?(self)
@@ -152,6 +180,7 @@ module Datadog
 
         private
 
+        #: () -> void
         def signal_running
           @wait_until_running_mutex.synchronize { @wait_until_running_condition.broadcast }
         end

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

@@ -8,17 +8,22 @@ module Datadog
       #
       # Methods prefixed with _native_ are implemented in `collectors_idle_sampling_helper.c`
       class IdleSamplingHelper
+        # @rbs @worker_thread: untyped
+        # @rbs @start_stop_mutex: ::Thread::Mutex
+
         private
 
-        attr_accessor :failure_exception
+        attr_accessor :failure_exception #: ::Exception?
 
         public
 
+        #: () -> void
         def initialize
           @worker_thread = nil
           @start_stop_mutex = Mutex.new
         end
 
+        #: () -> (nil | true)
         def start
           @start_stop_mutex.synchronize do
             return if @worker_thread&.alive?
@@ -39,7 +44,7 @@ module Datadog
               @failure_exception = e
               Datadog.logger.warn(
                 "IdleSamplingHelper thread error. " \
-                "Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
+                "Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
               )
               Datadog::Core::Telemetry::Logger.report(e, description: "IdleSamplingHelper thread error")
             end
@@ -50,6 +55,7 @@ module Datadog
           true
         end
 
+        #: () -> void
         def stop
           @start_stop_mutex.synchronize do
             Datadog.logger.debug("Requesting IdleSamplingHelper thread shut down")

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

@@ -14,11 +14,18 @@ module Datadog
       # could be seen as overkill for this case but it allows us to centralize information
       # gathering and easily support more flexible/dynamic info collection in the future.
       class Info
+        # @rbs @info: ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
+        # @rbs @platform_info: ::Hash[::Symbol, untyped]
+        # @rbs @runtime_info: ::Hash[::Symbol, untyped]
+        # @rbs @application_info: ::Hash[::Symbol, untyped]
+        # @rbs @profiler_info: ::Hash[::Symbol, untyped]?
+        # @rbs @gc_tuning_info: ::Hash[::Symbol, ::String]
+
+        #: (untyped) -> void
         def initialize(settings)
           @profiler_info = nil
 
-          # Steep: https://github.com/soutaro/steep/issues/363
-          @info = { # steep:ignore IncompatibleAssignment
+          @info = {
             platform: collect_platform_info,
             runtime: collect_runtime_info,
             application: collect_application_info(settings),
@@ -26,7 +33,7 @@ module Datadog
           }.freeze
         end
 
-        attr_reader :info
+        attr_reader :info #: ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
 
         private
 
@@ -69,6 +76,7 @@ module Datadog
         # gets initialized before a user has a chance to configure the library.
         START_TIME = Time.now.utc.freeze
 
+        #: () -> ::Hash[::Symbol, untyped]
         def collect_platform_info
           @platform_info ||= {
             container_id: Datadog::Core::Environment::Container.container_id,
@@ -79,6 +87,7 @@ module Datadog
           }.freeze
         end
 
+        #: () -> ::Hash[::Symbol, untyped]
         def collect_runtime_info
           @runtime_info ||= {
             engine: Datadog::Core::Environment::Identity.lang_engine,
@@ -88,6 +97,7 @@ module Datadog
           }.freeze
         end
 
+        #: (untyped) -> ::Hash[::Symbol, untyped]
         def collect_application_info(settings)
           @application_info ||= {
             start_time: START_TIME.iso8601,
@@ -97,6 +107,7 @@ module Datadog
           }.freeze
         end
 
+        #: (untyped) -> ::Hash[::Symbol, untyped]
         def collect_profiler_info(settings)
           @profiler_info ||= begin
             lib_datadog_gem = ::Gem.loaded_specs["libdatadog"]
@@ -123,6 +134,7 @@ module Datadog
         # instances without proper serialization.
         # This method navigates a settings object recursively, converting
         # it into more basic types that are trivially convertible to JSON.
+        #: (untyped) -> untyped
         def collect_settings_recursively(v)
           v = v.options_hash if v.respond_to?(:options_hash)
 
@@ -143,6 +155,7 @@ module Datadog
           end
         end
 
+        #: () -> ::Hash[::Symbol, ::String]
         def collect_gc_tuning_info
           return @gc_tuning_info if defined?(@gc_tuning_info)
 

data/lib/datadog/profiling/component.rb

@@ -10,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)
@@ -31,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
@@ -51,7 +49,6 @@ 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,
@@ -94,7 +91,7 @@ module Datadog
         [profiler, {profiling_enabled: true}]
       rescue Exception => e # rubocop:disable Lint/RescueException
         logger.warn do
-          "Failed to initialize profiling: #{e.class}: #{e} " \
+          "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")
@@ -378,7 +375,7 @@ module Datadog
         rescue StandardError, LoadError => e
           logger.warn(
             "Failed to probe `mysql2` gem information. " \
-            "Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
+            "Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
           )
 
           true

data/lib/datadog/profiling/exporter.rb

@@ -13,24 +13,35 @@ 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
+      attr_reader :pprof_recorder #: Datadog::Profiling::StackRecorder
+      # 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 pprof_recorder: Datadog::Profiling::StackRecorder
+      # @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:,
@@ -55,6 +66,7 @@ module Datadog
         @sequence_tracker = sequence_tracker
       end
 
+      #: () -> Datadog::Profiling::Flush?
       def flush
         worker_stats = @worker.stats_and_reset_not_thread_safe
         serialization_result = pprof_recorder.serialize
@@ -68,7 +80,17 @@ 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 : ''
@@ -77,8 +99,8 @@ module Datadog
           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,
@@ -96,10 +118,12 @@ module Datadog
         )
       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 +131,7 @@ module Datadog
 
       private
 
+      #: (::Time, ::Time) -> bool
       def duration_below_threshold?(start, finish)
         (finish - start) < minimum_duration_seconds
       end

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
       end
 
+      #: () -> ::String
       def config_without_api_key
         "#{exporter_configuration[0]}: #{exporter_configuration[3]}"
       end

data/lib/datadog/profiling/load_native_extension.rb

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