ddtrace 0.51.1 → 0.54.2

data/lib/ddtrace/profiling/pprof/stack_sample.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/ext/profiling'
 require 'ddtrace/profiling/events/stack'
 require 'ddtrace/profiling/pprof/builder'
@@ -29,8 +30,9 @@ module Datadog
         def initialize(*_)
           super
 
+          @most_recent_trace_samples = {}
           @processed_unique_stacks = 0
-          @processed_with_trace_ids = 0
+          @processed_with_trace = 0
         end
 
         def add_events!(stack_samples)
@@ -39,9 +41,28 @@ module Datadog
         end
 
         def stack_sample_group_key(stack_sample)
+          # We want to make sure we have the most recent sample for any trace.
+          # (This is done here to save an iteration over all samples.)
+          update_most_recent_trace_sample(stack_sample)
+
           stack_sample.hash
         end
 
+        # Track the most recent sample for each trace (identified by root span id)
+        def update_most_recent_trace_sample(stack_sample)
+          return unless stack_sample.root_span_id && stack_sample.trace_resource
+
+          # Update trace resource with most recent value
+          if (most_recent_trace_sample = @most_recent_trace_samples[stack_sample.root_span_id])
+            if most_recent_trace_sample.timestamp < stack_sample.timestamp
+              @most_recent_trace_samples[stack_sample.root_span_id] = stack_sample
+            end
+          else
+            # Add trace resource
+            @most_recent_trace_samples[stack_sample.root_span_id] = stack_sample
+          end
+        end
+
         def build_samples(stack_samples)
           groups = group_events(stack_samples, &method(:stack_sample_group_key))
           groups.collect do |_group_key, group|
@@ -63,7 +84,7 @@ module Datadog
           )
         end
 
-        def build_sample_values(stack_sample)
+        def build_event_values(stack_sample)
           no_value = Datadog::Ext::Profiling::Pprof::SAMPLE_VALUE_NO_VALUE
           values = super(stack_sample)
           values[sample_value_index(:cpu_time_ns)] = stack_sample.cpu_time_interval_ns || no_value
@@ -79,26 +100,39 @@ module Datadog
             )
           ]
 
-          unless stack_sample.trace_id.nil? || stack_sample.trace_id.zero?
-            @processed_with_trace_ids += 1
+          root_span_id = stack_sample.root_span_id || 0
+          span_id = stack_sample.span_id || 0
+
+          if root_span_id != 0 && span_id != 0
+            @processed_with_trace += 1
+
             labels << Perftools::Profiles::Label.new(
-              key: builder.string_table.fetch(Datadog::Ext::Profiling::Pprof::LABEL_KEY_TRACE_ID),
-              str: builder.string_table.fetch(stack_sample.trace_id.to_s)
+              key: builder.string_table.fetch(Datadog::Ext::Profiling::Pprof::LABEL_KEY_LOCAL_ROOT_SPAN_ID),
+              str: builder.string_table.fetch(root_span_id.to_s)
             )
-          end
 
-          unless stack_sample.span_id.nil? || stack_sample.span_id.zero?
             labels << Perftools::Profiles::Label.new(
               key: builder.string_table.fetch(Datadog::Ext::Profiling::Pprof::LABEL_KEY_SPAN_ID),
-              str: builder.string_table.fetch(stack_sample.span_id.to_s)
+              str: builder.string_table.fetch(span_id.to_s)
             )
+
+            # Use most up-to-date trace resource, if available.
+            # Otherwise, use the trace resource provided.
+            trace_resource = @most_recent_trace_samples.fetch(stack_sample.root_span_id, stack_sample).trace_resource
+
+            if trace_resource && !trace_resource.empty?
+              labels << Perftools::Profiles::Label.new(
+                key: builder.string_table.fetch(Datadog::Ext::Profiling::Pprof::LABEL_KEY_TRACE_ENDPOINT),
+                str: builder.string_table.fetch(trace_resource)
+              )
+            end
           end
 
           labels
         end
 
         def debug_statistics
-          "unique stacks: #{@processed_unique_stacks}, of which had active traces: #{@processed_with_trace_ids}"
+          "unique stacks: #{@processed_unique_stacks}, of which had active traces: #{@processed_with_trace}"
         end
       end
     end

data/lib/ddtrace/profiling/pprof/string_table.rb

@@ -1,3 +1,4 @@
+# typed: strict
 require 'ddtrace/utils/string_table'
 
 module Datadog

data/lib/ddtrace/profiling/pprof/template.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'ddtrace/profiling/pprof/payload'
 require 'ddtrace/profiling/pprof/message_set'
 require 'ddtrace/profiling/pprof/builder'
@@ -79,8 +80,8 @@ module Datadog
           converters.values.map(&:debug_statistics).join(', ')
         end
 
-        def to_pprof
-          profile = builder.build_profile
+        def to_pprof(start:, finish:)
+          profile = builder.build_profile(start: start, finish: finish)
           data = builder.encode_profile(profile)
           types = sample_type_mappings.keys
 

data/lib/ddtrace/profiling/preload.rb

@@ -1,3 +1,4 @@
+# typed: strict
 require 'ddtrace'
 
 Datadog.profiler.start if Datadog.profiler

data/lib/ddtrace/profiling/profiler.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Datadog
   # Profiling entry point, which coordinates collectors and a scheduler
   class Profiler

data/lib/ddtrace/profiling/recorder.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/profiling/buffer'
 require 'ddtrace/profiling/flush'
 
@@ -7,9 +8,9 @@ module Datadog
     class Recorder
       attr_reader :max_size
 
-      def initialize(event_classes, max_size)
+      def initialize(event_classes, max_size, last_flush_time: Time.now.utc)
         @buffers = {}
-        @last_flush_time = Time.now.utc
+        @last_flush_time = last_flush_time
         @max_size = max_size
 
         # Add a buffer for each class

data/lib/ddtrace/profiling/scheduler.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/utils/time'
 
 require 'ddtrace/worker'
@@ -11,7 +12,16 @@ module Datadog
       include Workers::Polling
 
       DEFAULT_INTERVAL_SECONDS = 60
-      MIN_INTERVAL_SECONDS = 0
+      MINIMUM_INTERVAL_SECONDS = 0
+
+      # Profiles with duration less than this will not be reported
+      PROFILE_DURATION_THRESHOLD_SECONDS = 1
+
+      # We sleep for at most this duration seconds before reporting data to avoid multi-process applications all
+      # reporting profiles at the exact same time
+      DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS = 3
+
+      private_constant :DEFAULT_INTERVAL_SECONDS, :MINIMUM_INTERVAL_SECONDS, :PROFILE_DURATION_THRESHOLD_SECONDS
 
       attr_reader \
         :exporters,
@@ -56,10 +66,6 @@ module Datadog
         end
       end
 
-      def loop_back_off?
-        false
-      end
-
       def after_fork
         # Clear recorder's buffers by flushing events.
         # Objects from parent process will copy-on-write,
@@ -89,13 +95,37 @@ module Datadog
 
         # Update wait time to try to wake consistently on time.
         # Don't drop below the minimum interval.
-        self.loop_wait_time = [loop_base_interval - run_time, MIN_INTERVAL_SECONDS].max
+        self.loop_wait_time = [loop_base_interval - run_time, MINIMUM_INTERVAL_SECONDS].max
       end
 
       def flush_events
         # Get events from recorder
         flush = recorder.flush
 
+        if duration_below_threshold?(flush)
+          Datadog.logger.debug do
+            "Skipped exporting profiling events as profile duration is below minimum (#{flush.event_count} events skipped)"
+          end
+
+          return flush
+        end
+
+        # Sleep for a bit to cause misalignment between profilers in multi-process applications
+        #
+        # When not being run in a loop, it means the scheduler has not been started or was stopped, and thus
+        # a) it's being shutting down (and is trying to report the last profile)
+        # b) it's being run as a one-shot, usually in a test
+        # ...so in those cases we don't sleep
+        #
+        # During PR review (https://github.com/DataDog/dd-trace-rb/pull/1807) we discussed the possible alternative of
+        # just sleeping before starting the scheduler loop. We ended up not going with that option to avoid the first
+        # profile containing up to DEFAULT_INTERVAL_SECONDS + DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS instead of the
+        # usual DEFAULT_INTERVAL_SECONDS size.
+        if run_loop?
+          jitter_seconds = rand * DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS # floating point number between (0.0...maximum)
+          sleep(jitter_seconds)
+        end
+
         # Send events to each exporter
         if flush.event_count > 0
           exporters.each do |exporter|
@@ -103,7 +133,7 @@ module Datadog
               exporter.export(flush)
             rescue StandardError => e
               Datadog.logger.error(
-                "Unable to export #{flush.event_count} profiling events. Cause: #{e} Location: #{e.backtrace.first}"
+                "Unable to export #{flush.event_count} profiling events. Cause: #{e} Location: #{Array(e.backtrace).first}"
               )
             end
           end
@@ -111,6 +141,10 @@ module Datadog
 
         flush
       end
+
+      def duration_below_threshold?(flush)
+        (flush.finish - flush.start) < PROFILE_DURATION_THRESHOLD_SECONDS
+      end
     end
   end
 end

data/lib/ddtrace/profiling/tasks/setup.rb

@@ -1,24 +1,25 @@
-require 'ddtrace'
+# typed: false
 require 'ddtrace/utils/only_once'
 require 'ddtrace/profiling'
-require 'ddtrace/profiling/ext/cpu'
 require 'ddtrace/profiling/ext/forking'
 
 module Datadog
   module Profiling
     module Tasks
-      # Takes care of loading our extensions/monkey patches to handle fork() and CPU profiling.
+      # Takes care of loading our extensions/monkey patches to handle fork() and validating if CPU-time profiling is usable
       class Setup
         ACTIVATE_EXTENSIONS_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
 
         def run
           ACTIVATE_EXTENSIONS_ONLY_ONCE.run do
             begin
+              check_if_cpu_time_profiling_is_supported
               activate_forking_extensions
-              activate_cpu_extensions
               setup_at_fork_hooks
             rescue StandardError, ScriptError => e
-              Datadog.logger.warn { "Profiler extensions unavailable. Cause: #{e.message} Location: #{e.backtrace.first}" }
+              Datadog.logger.warn do
+                "Profiler extensions unavailable. Cause: #{e.message} Location: #{Array(e.backtrace).first}"
+              end
             end
           end
         end
@@ -33,23 +34,19 @@ module Datadog
           end
         rescue StandardError, ScriptError => e
           Datadog.logger.warn do
-            "Profiler forking extensions unavailable. Cause: #{e.message} Location: #{e.backtrace.first}"
+            "Profiler forking extensions unavailable. Cause: #{e.message} Location: #{Array(e.backtrace).first}"
           end
         end
 
-        def activate_cpu_extensions
-          if Ext::CPU.supported?
-            Ext::CPU.apply!
-          elsif Datadog.configuration.profiling.enabled
+        def check_if_cpu_time_profiling_is_supported
+          unsupported = cpu_time_profiling_unsupported_reason
+
+          if unsupported
             Datadog.logger.info do
               'CPU time profiling skipped because native CPU time is not supported: ' \
-              "#{Ext::CPU.unsupported_reason}. Profiles containing Wall time will still be reported."
+              "#{unsupported}. Profiles containing 'Wall time' data will still be reported."
             end
           end
-        rescue StandardError, ScriptError => e
-          Datadog.logger.warn do
-            "Profiler CPU profiling extensions unavailable. Cause: #{e.message} Location: #{e.backtrace.first}"
-          end
         end
 
         def setup_at_fork_hooks
@@ -66,11 +63,27 @@ module Datadog
                 # Restart profiler, if enabled
                 Datadog.profiler.start if Datadog.profiler
               rescue StandardError => e
-                Datadog.logger.warn { "Error during post-fork hooks. Cause: #{e.message} Location: #{e.backtrace.first}" }
+                Datadog.logger.warn do
+                  "Error during post-fork hooks. Cause: #{e.message} Location: #{Array(e.backtrace).first}"
+                end
               end
             end
           end
         end
+
+        def cpu_time_profiling_unsupported_reason
+          # NOTE: Only the first matching reason is returned, so try to keep a nice order on reasons
+
+          if RUBY_ENGINE == 'jruby'
+            'JRuby is not supported'
+          elsif RUBY_PLATFORM.include?('darwin')
+            'Feature requires Linux; macOS is not supported'
+          elsif RUBY_PLATFORM =~ /(mswin|mingw)/
+            'Feature requires Linux; Windows is not supported'
+          elsif !RUBY_PLATFORM.include?('linux')
+            "Feature requires Linux; #{RUBY_PLATFORM} is not supported"
+          end
+        end
       end
     end
   end

data/lib/ddtrace/profiling/trace_identifiers/ddtrace.rb

@@ -0,0 +1,42 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'ddtrace/ext/http'
+
+module Datadog
+  module Profiling
+    module TraceIdentifiers
+      # Used by Datadog::Profiling::TraceIdentifiers::Helper to get the trace identifiers (root span id and span id)
+      # for a given thread, if there is an active trace for that thread in the supplied tracer object.
+      class Ddtrace
+        def initialize(tracer:)
+          @tracer = (tracer if tracer.respond_to?(:call_context))
+        end
+
+        def trace_identifiers_for(thread)
+          return unless @tracer
+
+          context = @tracer.call_context(thread)
+          return unless context
+
+          span, root_span = context.current_span_and_root_span
+          return unless span && root_span
+
+          root_span_id = root_span.span_id || 0
+          span_id = span.span_id || 0
+
+          [root_span_id, span_id, maybe_extract_resource(root_span)] if root_span_id != 0 && span_id != 0
+        end
+
+        private
+
+        # NOTE: Currently we're only interested in HTTP service endpoints. Over time, this list may be expanded.
+        # Resources MUST NOT include personal identifiable information (PII); this should not be the case with
+        # ddtrace integrations, but worth mentioning just in case :)
+        def maybe_extract_resource(root_span)
+          root_span.resource if root_span.span_type == Datadog::Ext::HTTP::TYPE_INBOUND
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/trace_identifiers/helper.rb

@@ -0,0 +1,46 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'ddtrace/profiling/trace_identifiers/ddtrace'
+
+module Datadog
+  module Profiling
+    module TraceIdentifiers
+      # Helper used to retrieve the trace identifiers (root span id and span id) for a given thread,
+      # if there is an active trace for that thread for the supported tracing APIs.
+      #
+      # This data is used to connect profiles to the traces -- samples in a profile will be tagged with this data and
+      # the profile can be filtered down to look at only the samples for a given trace.
+      class Helper
+        DEFAULT_SUPPORTED_APIS = [
+          ::Datadog::Profiling::TraceIdentifiers::Ddtrace
+        ].freeze
+        private_constant :DEFAULT_SUPPORTED_APIS
+
+        def initialize(
+          tracer:,
+          # If this is disabled, the helper will strip the optional trace_resource_container even if provided by the api
+          endpoint_collection_enabled:,
+          supported_apis: DEFAULT_SUPPORTED_APIS.map { |api| api.new(tracer: tracer) }
+        )
+          @endpoint_collection_enabled = endpoint_collection_enabled
+          @supported_apis = supported_apis
+        end
+
+        # Expected output of the #trace_identifiers_for
+        # duck type is [root_span_id, span_id, (optional trace_resource_container)]
+        def trace_identifiers_for(thread)
+          @supported_apis.each do |api|
+            trace_identifiers = api.trace_identifiers_for(thread)
+
+            if trace_identifiers
+              return @endpoint_collection_enabled ? trace_identifiers : trace_identifiers[0..1]
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/transport/client.rb

@@ -1,8 +1,11 @@
+# typed: true
 module Datadog
   module Profiling
     module Transport
       # Generic interface for profiling transports
       module Client
+        include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
         def send_profiling_flush(flush)
           raise NotImplementedError
         end

data/lib/ddtrace/profiling/transport/http/api/endpoint.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/ext/profiling'
 require 'ddtrace/utils/compression'
 require 'ddtrace/vendor/multipart-post/multipart/post/composite_read_io'
@@ -40,11 +41,10 @@ module Datadog
 
             def build_form(env)
               flush = env.request.parcel.data
-              pprof_file, types = build_pprof(flush)
+              pprof_file = build_pprof(flush)
 
               form = {
-                # NOTE: Redundant w/ 'runtime-id' tag below; may want to remove this later.
-                FORM_FIELD_RUNTIME_ID => flush.runtime_id,
+                FORM_FIELD_INTAKE_VERSION => '3', # Aka 1.3 intake format
                 FORM_FIELD_RECORDING_START => flush.start.utc.iso8601,
                 FORM_FIELD_RECORDING_END => flush.finish.utc.iso8601,
                 FORM_FIELD_TAGS => [
@@ -63,14 +63,10 @@ module Datadog
                     .reject { |tag_key| TAGS_TO_IGNORE_IN_TAGS_HASH.include?(tag_key) }
                     .map { |tag_key, tag_value| "#{tag_key}:#{tag_value}" }
                 ],
-                FORM_FIELD_DATA => pprof_file,
-                FORM_FIELD_RUNTIME => flush.language,
-                FORM_FIELD_FORMAT => FORM_FIELD_FORMAT_PPROF
+                FORM_FIELD_PPROF_DATA => pprof_file,
+                FORM_FIELD_FAMILY => flush.language,
               }
 
-              # Add types
-              form[FORM_FIELD_TYPES] = types.join(',')
-
               # Optional fields
               form[FORM_FIELD_TAGS] << "#{FORM_FIELD_TAG_SERVICE}:#{flush.service}" unless flush.service.nil?
               form[FORM_FIELD_TAGS] << "#{FORM_FIELD_TAG_ENV}:#{flush.env}" unless flush.env.nil?
@@ -82,15 +78,13 @@ module Datadog
             def build_pprof(flush)
               pprof = encoder.encode(flush)
 
-              # Wrap pprof as a gzipped file
-              gzipped_data = Datadog::Utils::Compression.gzip(pprof.data)
-              pprof_file = Datadog::Vendor::Multipart::Post::UploadIO.new(
-                StringIO.new(gzipped_data),
+              gzipped_pprof_data = Datadog::Utils::Compression.gzip(pprof.data)
+
+              Datadog::Vendor::Multipart::Post::UploadIO.new(
+                StringIO.new(gzipped_pprof_data),
                 HEADER_CONTENT_TYPE_OCTET_STREAM,
                 PPROF_DEFAULT_FILENAME
               )
-
-              [pprof_file, [FORM_FIELD_TYPES_AUTO]]
             end
           end
         end

data/lib/ddtrace/profiling/transport/http/api/instance.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/transport/http/api/instance'
 require 'ddtrace/profiling/transport/http/api/spec'
 

data/lib/ddtrace/profiling/transport/http/api/spec.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/transport/http/api/spec'
 
 module Datadog

data/lib/ddtrace/profiling/transport/http/api.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/transport/http/api/map'
 require 'ddtrace/profiling/encoding/profile'
 require 'ddtrace/profiling/transport/http/api/spec'

data/lib/ddtrace/profiling/transport/http/builder.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/transport/http/builder'
 
 require 'ddtrace/profiling/transport/http/api'

data/lib/ddtrace/profiling/transport/http/client.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/transport/http/client'
 require 'ddtrace/profiling/transport/client'
 

data/lib/ddtrace/profiling/transport/http/response.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/transport/http/response'
 require 'ddtrace/profiling/transport/response'
 

data/lib/ddtrace/profiling/transport/http.rb

@@ -1,7 +1,9 @@
+# typed: true
 require 'datadog/core/environment/ext'
 require 'ddtrace/ext/transport'
 
 require 'datadog/core/environment/container'
+require 'datadog/core/environment/variable_helpers'
 
 require 'ddtrace/profiling/transport/http/builder'
 require 'ddtrace/profiling/transport/http/api'
@@ -15,21 +17,24 @@ module Datadog
     module Transport
       # Namespace for HTTP transport components
       module HTTP
-        module_function
-
         # Builds a new Transport::HTTP::Client
-        def new(&block)
+        def self.new(&block)
           Builder.new(&block).to_transport
         end
 
         # Builds a new Transport::HTTP::Client with default settings
-        # Pass a block to override any settings.
-        def default(profiling_upload_timeout_seconds:, agent_settings: nil, site: nil, api_key: nil)
+        def self.default(
+          profiling_upload_timeout_seconds:,
+          agent_settings:,
+          site: nil,
+          api_key: nil,
+          agentless_allowed: agentless_allowed?
+        )
           new do |transport|
             transport.headers default_headers
 
             # Configure adapter & API
-            if site && api_key
+            if site && api_key && agentless_allowed
               configure_for_agentless(
                 transport,
                 profiling_upload_timeout_seconds: profiling_upload_timeout_seconds,
@@ -37,13 +42,6 @@ module Datadog
                 api_key: api_key
               )
             else
-              unless agent_settings
-                raise(
-                  ArgumentError,
-                  "Missing configuration for #{self}.default: All of `agent_settings`, `site` and `api_key` are nil"
-                )
-              end
-
               configure_for_agent(
                 transport,
                 profiling_upload_timeout_seconds: profiling_upload_timeout_seconds,
@@ -53,7 +51,7 @@ module Datadog
           end
         end
 
-        def default_headers
+        def self.default_headers
           {
             Datadog::Ext::Transport::HTTP::HEADER_META_LANG => Core::Environment::Ext::LANG,
             Datadog::Ext::Transport::HTTP::HEADER_META_LANG_VERSION => Core::Environment::Ext::LANG_VERSION,
@@ -66,22 +64,10 @@ module Datadog
           end
         end
 
-        private_class_method def default_adapter
-          :net_http
-        end
-
-        private_class_method def configure_for_agent(transport, profiling_upload_timeout_seconds:, agent_settings:)
+        private_class_method def self.configure_for_agent(transport, profiling_upload_timeout_seconds:, agent_settings:)
           apis = API.agent_defaults
 
-          transport.adapter(
-            default_adapter,
-            agent_settings.hostname,
-            agent_settings.port,
-            # We explictly use profiling_upload_timeout_seconds instead of agent_settings.timeout because profile
-            # uploads are bigger and thus we employ a separate configuration.
-            timeout: profiling_upload_timeout_seconds,
-            ssl: agent_settings.ssl
-          )
+          transport.adapter(agent_settings.merge(timeout_seconds: profiling_upload_timeout_seconds))
           transport.api(API::V1, apis[API::V1], default: true)
 
           # NOTE: This proc, when it exists, usually overrides the transport specified above
@@ -90,7 +76,7 @@ module Datadog
           end
         end
 
-        private_class_method def configure_for_agentless(transport, profiling_upload_timeout_seconds:, site:, api_key:)
+        private_class_method def self.configure_for_agentless(transport, profiling_upload_timeout_seconds:, site:, api_key:)
           apis = API.api_defaults
 
           site_uri = URI(format(Datadog::Ext::Profiling::Transport::HTTP::URI_TEMPLATE_DD_API, site))
@@ -98,7 +84,7 @@ module Datadog
           port = site_uri.port
 
           transport.adapter(
-            default_adapter,
+            Datadog::Ext::Transport::HTTP::ADAPTER,
             hostname,
             port,
             timeout: profiling_upload_timeout_seconds,
@@ -108,10 +94,17 @@ module Datadog
           transport.headers(Datadog::Ext::Transport::HTTP::HEADER_DD_API_KEY => api_key)
         end
 
+        private_class_method def self.agentless_allowed?
+          Datadog::Core::Environment::VariableHelpers.env_to_bool(Datadog::Ext::Profiling::ENV_AGENTLESS, false)
+        end
+
         # Add adapters to registry
-        Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Net, :net_http)
-        Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Test, :test)
-        Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::UnixSocket, :unix)
+        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Net,
+                                                        Datadog::Ext::Transport::HTTP::ADAPTER)
+        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Test,
+                                                        Datadog::Ext::Transport::Test::ADAPTER)
+        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::UnixSocket,
+                                                        Datadog::Ext::Transport::UnixSocket::ADAPTER)
       end
     end
   end

data/lib/ddtrace/profiling/transport/io/client.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/transport/io/client'
 require 'ddtrace/profiling/transport/client'
 require 'ddtrace/profiling/transport/request'

data/lib/ddtrace/profiling/transport/io/response.rb

@@ -1,3 +1,4 @@
+# typed: strict
 require 'ddtrace/transport/io/response'
 require 'ddtrace/profiling/transport/response'