ddtrace 1.14.0 → 1.15.0

data/lib/datadog/opentelemetry.rb

@@ -16,6 +16,7 @@ require_relative 'opentelemetry/api/context'
 # DEV: This is different from our existing OpenTracer API, but there are many safety
 # DEV: features built into Contrib instrumentation today.
 require_relative 'opentelemetry/sdk/configurator' if defined?(OpenTelemetry::SDK)
+require_relative 'opentelemetry/sdk/trace/span' if defined?(OpenTelemetry::SDK)
 
 module Datadog
   # Datadog OpenTelemetry integration.

data/lib/datadog/opentracer.rb

@@ -22,3 +22,12 @@ require_relative 'opentracer/global_tracer'
 
 # Modify the OpenTracing module functions
 ::OpenTracing.singleton_class.prepend(Datadog::OpenTracer::GlobalTracer)
+
+module Datadog
+  # Datadog OpenTracing integration.
+  # DEV: This module should be named `Datadog::OpenTracing` to match the gem (`opentracing`).
+  module OpenTracer
+    # Used by Telemetry to decide if OpenTracing instrumentation is enabled
+    LOADED = true
+  end
+end

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

@@ -14,25 +14,15 @@ module Datadog
         public
 
         def initialize(
-          recorder:,
-          max_frames:,
-          tracer:,
-          endpoint_collection_enabled:,
           gc_profiling_enabled:,
           allocation_counting_enabled:,
           no_signals_workaround_enabled:,
-          timeline_enabled:,
-          thread_context_collector: ThreadContext.new(
-            recorder: recorder,
-            max_frames: max_frames,
-            tracer: tracer,
-            endpoint_collection_enabled: endpoint_collection_enabled,
-            timeline_enabled: timeline_enabled,
-          ),
+          thread_context_collector:,
           idle_sampling_helper: IdleSamplingHelper.new,
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
           # profiler overhead!
-          dynamic_sampling_rate_enabled: true
+          dynamic_sampling_rate_enabled: true,
+          allocation_sample_every: 0 # Currently only for testing; Setting this to > 0 can add a lot of overhead!
         )
           unless dynamic_sampling_rate_enabled
             Datadog.logger.warn(
@@ -40,6 +30,13 @@ module Datadog
             )
           end
 
+          if allocation_counting_enabled && allocation_sample_every > 0
+            Datadog.logger.warn(
+              "Enabled experimental allocation profiling: allocation_sample_every=#{allocation_sample_every}. This is " \
+              'experimental, not recommended, and will increase overhead!'
+            )
+          end
+
           self.class._native_initialize(
             self,
             thread_context_collector,
@@ -48,6 +45,7 @@ module Datadog
             allocation_counting_enabled,
             no_signals_workaround_enabled,
             dynamic_sampling_rate_enabled,
+            allocation_sample_every,
           )
           @worker_thread = nil
           @failure_exception = nil
@@ -84,11 +82,7 @@ module Datadog
           true
         end
 
-        # TODO: Provided only for compatibility with the API for Collectors::OldStack used in the Profiler class.
-        # Can be removed once we remove OldStack.
-        def enabled=(_); end
-
-        def stop(*_)
+        def stop
           @start_stop_mutex.synchronize do
             Datadog.logger.debug('Requesting CpuAndWallTimeWorker thread shut down')
 

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

@@ -48,7 +48,7 @@ module Datadog
           true
         end
 
-        def stop(*_unused)
+        def stop
           @start_stop_mutex.synchronize do
             Datadog.logger.debug('Requesting IdleSamplingHelper thread shut down')
 

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

@@ -14,7 +14,14 @@ module Datadog
       #
       # Methods prefixed with _native_ are implemented in `collectors_thread_context.c`
       class ThreadContext
-        def initialize(recorder:, max_frames:, tracer:, endpoint_collection_enabled:, timeline_enabled:)
+        def initialize(
+          recorder:,
+          max_frames:,
+          tracer:,
+          endpoint_collection_enabled:,
+          timeline_enabled:,
+          allocation_type_enabled: true
+        )
           tracer_context_key = safely_extract_context_key_from(tracer)
           self.class._native_initialize(
             self,
@@ -23,6 +30,7 @@ module Datadog
             tracer_context_key,
             endpoint_collection_enabled,
             timeline_enabled,
+            allocation_type_enabled,
           )
         end
 

data/lib/datadog/profiling/component.rb

@@ -7,8 +7,9 @@ module Datadog
       # Passing in a `nil` tracer is supported and will disable the following profiling features:
       # * Code Hotspots panel 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:) # rubocop:disable Metrics/MethodLength
+      def self.build_profiler_component(settings:, agent_settings:, optional_tracer:)
         require_relative '../profiling/diagnostics/environment_logger'
+
         Profiling::Diagnostics::EnvironmentLogger.collect_and_log!
 
         return unless settings.profiling.enabled
@@ -33,67 +34,32 @@ module Datadog
         require_relative '../profiling'
         return unless Profiling.supported?
 
-        unless defined?(Profiling::Tasks::Setup)
-          # In #1545 a user reported a NameError due to this constant being uninitialized
-          # I've documented my suspicion on why that happened in
-          # https://github.com/DataDog/dd-trace-rb/issues/1545#issuecomment-856049025
-          #
-          # > Thanks for the info! It seems to feed into my theory: there's two moments in the code where we check if
-          # > profiler is "supported": 1) when loading ddtrace (inside preload) and 2) when starting the profile
-          # > after Datadog.configure gets run.
-          # > The problem is that the code assumes that both checks 1) and 2) will always reach the same conclusion:
-          # > either profiler is supported, or profiler is not supported.
-          # > In the problematic case, it looks like in your case check 1 decides that profiler is not
-          # > supported => doesn't load it, and then check 2 decides that it is => assumes it is loaded and tries to
-          # > start it.
-          #
-          # I was never able to validate if this was the issue or why exactly .supported? would change its mind BUT
-          # just in case it happens again, I've left this check which avoids breaking the user's application AND
-          # would instead direct them to report it to us instead, so that we can investigate what's wrong.
-          #
-          # TODO: As of June 2021, most checks in .supported? are related to the google-protobuf gem; so it's
-          # very likely that it was the origin of the issue we saw. Thus, if, as planned we end up moving away from
-          # protobuf OR enough time has passed and no users saw the issue again, we can remove this check altogether.
-          Datadog.logger.error(
-            'Profiling was marked as supported and enabled, but setup task was not loaded properly. ' \
-            'Please report this at https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug'
-          )
-
-          return
-        end
-
-        # Load extensions needed to support some of the Profiling features
+        # Activate forking extensions
         Profiling::Tasks::Setup.new.run
 
         # NOTE: Please update the Initialization section of ProfilingDevelopment.md with any changes to this method
 
-        no_signals_workaround_enabled = false
-        timeline_enabled = false
-
-        if enable_new_profiler?(settings)
-          no_signals_workaround_enabled = no_signals_workaround_enabled?(settings)
-          timeline_enabled = settings.profiling.advanced.experimental_timeline_enabled
+        no_signals_workaround_enabled = no_signals_workaround_enabled?(settings)
+        timeline_enabled = settings.profiling.advanced.experimental_timeline_enabled
 
-          recorder = Datadog::Profiling::StackRecorder.new(
-            cpu_time_enabled: RUBY_PLATFORM.include?('linux'), # Only supported on Linux currently
-            alloc_samples_enabled: false, # Always disabled for now -- work in progress
-          )
-          collector = Datadog::Profiling::Collectors::CpuAndWallTimeWorker.new(
-            recorder: recorder,
-            max_frames: settings.profiling.advanced.max_frames,
-            tracer: optional_tracer,
-            endpoint_collection_enabled: settings.profiling.advanced.endpoint.collection.enabled,
-            gc_profiling_enabled: enable_gc_profiling?(settings),
-            allocation_counting_enabled: settings.profiling.advanced.allocation_counting_enabled,
-            no_signals_workaround_enabled: no_signals_workaround_enabled,
-            timeline_enabled: timeline_enabled,
-          )
-        else
-          load_pprof_support
-
-          recorder = build_profiler_old_recorder(settings)
-          collector = build_profiler_oldstack_collector(settings, recorder, optional_tracer)
-        end
+        recorder = Datadog::Profiling::StackRecorder.new(
+          cpu_time_enabled: RUBY_PLATFORM.include?('linux'), # Only supported on Linux currently
+          alloc_samples_enabled: false, # Always disabled for now -- work in progress
+        )
+        thread_context_collector = 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,
+        )
+        worker = Datadog::Profiling::Collectors::CpuAndWallTimeWorker.new(
+          gc_profiling_enabled: enable_gc_profiling?(settings),
+          allocation_counting_enabled: settings.profiling.advanced.allocation_counting_enabled,
+          no_signals_workaround_enabled: no_signals_workaround_enabled,
+          thread_context_collector: thread_context_collector,
+          allocation_sample_every: 0,
+        )
 
         internal_metadata = {
           no_signals_workaround_enabled: no_signals_workaround_enabled,
@@ -104,11 +70,7 @@ module Datadog
         transport = build_profiler_transport(settings, agent_settings)
         scheduler = Profiling::Scheduler.new(exporter: exporter, transport: transport)
 
-        Profiling::Profiler.new([collector], scheduler)
-      end
-
-      private_class_method def self.build_profiler_old_recorder(settings)
-        Profiling::OldRecorder.new([Profiling::Events::StackSample], settings.profiling.advanced.max_events)
+        Profiling::Profiler.new(worker: worker, scheduler: scheduler)
       end
 
       private_class_method def self.build_profiler_exporter(settings, recorder, internal_metadata:)
@@ -122,19 +84,6 @@ module Datadog
         )
       end
 
-      private_class_method def self.build_profiler_oldstack_collector(settings, old_recorder, tracer)
-        trace_identifiers_helper = Profiling::TraceIdentifiers::Helper.new(
-          tracer: tracer,
-          endpoint_collection_enabled: settings.profiling.advanced.endpoint.collection.enabled
-        )
-
-        Profiling::Collectors::OldStack.new(
-          old_recorder,
-          trace_identifiers_helper: trace_identifiers_helper,
-          max_frames: settings.profiling.advanced.max_frames
-        )
-      end
-
       private_class_method def self.build_profiler_transport(settings, agent_settings)
         settings.profiling.exporter.transport ||
           Profiling::HttpTransport.new(
@@ -161,17 +110,6 @@ module Datadog
         end
       end
 
-      private_class_method def self.enable_new_profiler?(settings)
-        if settings.profiling.advanced.force_enable_legacy_profiler
-          Datadog.logger.warn(
-            'Legacy profiler has been force-enabled via configuration. Do not use unless instructed to by support.'
-          )
-          return false
-        end
-
-        true
-      end
-
       private_class_method def self.no_signals_workaround_enabled?(settings) # rubocop:disable Metrics/MethodLength
         setting_value = settings.profiling.advanced.no_signals_workaround_enabled
         legacy_ruby_that_should_use_workaround = RUBY_VERSION.start_with?('2.3.', '2.4.', '2.5.')
@@ -299,19 +237,6 @@ module Datadog
           true
         end
       end
-
-      # The old profiler's pprof support conflicts with the ruby-cloud-profiler gem.
-      #
-      # This is not a problem for almost all customers, since we now default everyone to use the new CPU Profiling 2.0
-      # profiler. But the issue was still triggered, because currently we still _load_ both the old and new profiling
-      # code paths.
-      #
-      # To work around this issue, and because we plan on deleting the old profiler soon, rather than poking at the
-      # pprof support code, we only load the conflicting file when the old profiler is in use. This way customers using
-      # the new profiler will not be affected by the issue any longer.
-      private_class_method def self.load_pprof_support
-        require_relative 'pprof/pprof_pb'
-      end
     end
   end
 end

data/lib/datadog/profiling/ext.rb

@@ -9,18 +9,6 @@ module Datadog
       ENV_AGENTLESS = 'DD_PROFILING_AGENTLESS'
       ENV_ENDPOINT_COLLECTION_ENABLED = 'DD_PROFILING_ENDPOINT_COLLECTION_ENABLED'
 
-      # TODO: Consider removing this once the Ruby-based pprof encoding is removed and replaced by libdatadog
-      module Pprof
-        LABEL_KEY_LOCAL_ROOT_SPAN_ID = 'local root span id'
-        LABEL_KEY_SPAN_ID = 'span id'
-        LABEL_KEY_THREAD_ID = 'thread id'
-        LABEL_KEY_TRACE_ENDPOINT = 'trace endpoint'
-        SAMPLE_VALUE_NO_VALUE = 0
-        VALUE_TYPE_CPU = 'cpu-time'
-        VALUE_TYPE_WALL = 'wall-time'
-        VALUE_UNIT_NANOSECONDS = 'nanoseconds'
-      end
-
       module Transport
         module HTTP
           FORM_FIELD_TAG_ENV = 'env'

data/lib/datadog/profiling/flush.rb

@@ -4,9 +4,6 @@ require 'json'
 
 module Datadog
   module Profiling
-    # Represents a collection of events of a specific type being flushed.
-    EventGroup = Struct.new(:event_class, :events)
-
     # Entity class used to represent metadata for a given profile
     class Flush
       attr_reader \

data/lib/datadog/profiling/http_transport.rb

@@ -1,3 +1,5 @@
+require_relative '../core/transport/ext'
+
 module Datadog
   module Profiling
     # Used to report profiling data to Datadog.
@@ -70,9 +72,9 @@ module Datadog
 
       def base_url_from(agent_settings)
         case agent_settings.adapter
-        when Datadog::Transport::Ext::HTTP::ADAPTER
+        when Datadog::Core::Transport::Ext::HTTP::ADAPTER
           "#{agent_settings.ssl ? 'https' : 'http'}://#{agent_settings.hostname}:#{agent_settings.port}/"
-        when Datadog::Transport::Ext::UnixSocket::ADAPTER
+        when Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
           "unix://#{agent_settings.uds_path}"
         else
           raise ArgumentError, "Unexpected adapter: #{agent_settings.adapter}"
@@ -80,7 +82,8 @@ module Datadog
       end
 
       def validate_agent_settings(agent_settings)
-        supported_adapters = [Datadog::Transport::Ext::HTTP::ADAPTER, Datadog::Transport::Ext::UnixSocket::ADAPTER]
+        supported_adapters = [Datadog::Core::Transport::Ext::HTTP::ADAPTER,
+                              Datadog::Core::Transport::Ext::UnixSocket::ADAPTER]
         unless supported_adapters.include?(agent_settings.adapter)
           raise ArgumentError,
             "Unsupported transport configuration for profiling: Adapter #{agent_settings.adapter} " \

data/lib/datadog/profiling/native_extension.rb

@@ -15,27 +15,6 @@ module Datadog
           false
         end
       end
-
-      unless singleton_class.method_defined?(:clock_id_for)
-        def self.clock_id_for(_)
-          nil
-        end
-      end
-
-      def self.cpu_time_ns_for(thread)
-        clock_id =
-          begin
-            clock_id_for(thread)
-          rescue Errno::ESRCH
-            nil
-          end
-
-        begin
-          ::Process.clock_gettime(clock_id, :nanosecond) if clock_id
-        rescue Errno::EINVAL
-          nil
-        end
-      end
     end
   end
 end

data/lib/datadog/profiling/profiler.rb

@@ -1,35 +1,34 @@
 module Datadog
   module Profiling
-    # Profiling entry point, which coordinates collectors and a scheduler
+    # Profiling entry point, which coordinates the worker and scheduler threads
     class Profiler
       include Datadog::Core::Utils::Forking
 
-      attr_reader \
-        :collectors,
-        :scheduler
+      private
 
-      def initialize(collectors, scheduler)
-        @collectors = collectors
+      attr_reader :worker, :scheduler
+
+      public
+
+      def initialize(worker:, scheduler:)
+        @worker = worker
         @scheduler = scheduler
       end
 
       def start
         after_fork! do
-          collectors.each(&:reset_after_fork)
+          worker.reset_after_fork
           scheduler.reset_after_fork
         end
 
-        collectors.each(&:start)
+        worker.start
         scheduler.start
       end
 
       def shutdown!
         Datadog.logger.debug('Shutting down profiler')
 
-        collectors.each do |collector|
-          collector.enabled = false
-          collector.stop(true)
-        end
+        worker.stop
 
         scheduler.enabled = false
         scheduler.stop(true)

data/lib/datadog/profiling.rb

@@ -5,22 +5,15 @@ require_relative 'core/utils/only_once'
 module Datadog
   # Datadog Continuous Profiler implementation: https://docs.datadoghq.com/profiler/
   module Profiling
-    GOOGLE_PROTOBUF_MINIMUM_VERSION = Gem::Version.new('3.0')
-    private_constant :GOOGLE_PROTOBUF_MINIMUM_VERSION
-
     def self.supported?
       unsupported_reason.nil?
     end
 
     def self.unsupported_reason
       # NOTE: Only the first matching reason is returned, so try to keep a nice order on reasons -- e.g. tell users
-      # first that they can't use this on JRuby before telling them that they are missing protobuf
+      # first that they can't use this on JRuby before telling them that something else failed
 
-      native_library_compilation_skipped? ||
-        native_library_failed_to_load? ||
-        protobuf_gem_unavailable? ||
-        protobuf_version_unsupported? ||
-        protobuf_failed_to_load?
+      native_library_compilation_skipped? || native_library_failed_to_load?
     end
 
     # Starts the profiler, if the profiler is supported by in
@@ -53,9 +46,7 @@ module Datadog
     #
     # Note 2: All fibers in the same thread will share the same counter values.
     #
-    # Only available when the profiler is running, the new CPU Profiling 2.0 profiler is in use, and allocation-related
-    # features are not disabled via configuration.
-    # For instructions on enabling CPU Profiling 2.0 see the ddtrace release notes.
+    # Only available when the profiler is running, and allocation-related features are not disabled via configuration.
     #
     # @return [Integer] number of allocations observed in the current thread.
     # @return [nil] when not available.
@@ -68,11 +59,12 @@ module Datadog
 
     def self.enabled?
       profiler = Datadog.send(:components).profiler
-      !!(profiler.scheduler.running? if profiler)
+      # Use .send(...) to avoid exposing the attr_reader as an API to the outside
+      !!(profiler.send(:scheduler).running? if profiler)
     end
 
     private_class_method def self.replace_noop_allocation_count
-      def self.allocation_count # rubocop:disable Lint/DuplicateMethods, Lint/NestedMethodDefinition (On purpose!)
+      def self.allocation_count # rubocop:disable Lint/NestedMethodDefinition (On purpose!)
         Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count
       end
     end
@@ -97,66 +89,6 @@ module Datadog
       end
     end
 
-    private_class_method def self.protobuf_gem_unavailable?
-      # NOTE: On environments where protobuf is already loaded, we skip the check. This allows us to support environments
-      # where no Gem.loaded_version is NOT available but customers are able to load protobuf; see for instance
-      # https://github.com/teamcapybara/capybara/commit/caf3bcd7664f4f2691d0ca9ef3be9a2a954fecfb
-      if !protobuf_already_loaded? && Gem.loaded_specs['google-protobuf'].nil?
-        "Missing google-protobuf dependency; please add `gem 'google-protobuf', '~> 3.0'` to your Gemfile or gems.rb file"
-      end
-    end
-
-    private_class_method def self.protobuf_version_unsupported?
-      # See above for why we skip the check when protobuf is already loaded; note that when protobuf was already loaded
-      # we skip the version check to avoid the call to Gem.loaded_specs. Unfortunately, protobuf does not seem to
-      # expose the gem version constant elsewhere, so in that setup we are not able to check the version.
-      if !protobuf_already_loaded? && Gem.loaded_specs['google-protobuf'].version < GOOGLE_PROTOBUF_MINIMUM_VERSION
-        'Your google-protobuf is too old; ensure that you have google-protobuf >= 3.0 by ' \
-        "adding `gem 'google-protobuf', '~> 3.0'` to your Gemfile or gems.rb file"
-      end
-    end
-
-    private_class_method def self.protobuf_already_loaded?
-      defined?(::Google::Protobuf) && !defined?(::Protobuf)
-      !!(defined?(::Google::Protobuf) && !defined?(::Protobuf))
-    end
-
-    private_class_method def self.protobuf_failed_to_load?
-      unless protobuf_loaded_successfully?
-        'There was an error loading the google-protobuf library; see previous warning message for details'
-      end
-    end
-
-    # The `google-protobuf` gem depends on a native component, and its creators helpfully tried to provide precompiled
-    # versions of this extension on rubygems.org.
-    #
-    # Unfortunately, for a long time, the supported Ruby versions metadata on these precompiled versions of the extension
-    # was not correctly set. (This is fixed in newer versions -- but not all Ruby versions we want to support can use
-    # these.)
-    #
-    # Thus, the gem can still be installed, but can be in a broken state. To avoid breaking customer applications, we
-    # use this helper to load it and gracefully handle failures.
-    private_class_method def self.protobuf_loaded_successfully?
-      return @protobuf_loaded if defined?(@protobuf_loaded)
-
-      begin
-        require 'google/protobuf'
-        @protobuf_loaded = true
-      rescue LoadError => e
-        # NOTE: We use Kernel#warn here because this code gets run BEFORE Datadog.logger is actually set up.
-        # In the future it'd be nice to shuffle the logger startup to happen first to avoid this special case.
-        Kernel.warn(
-          '[ddtrace] Error while loading google-protobuf gem. ' \
-          "Cause: '#{e.class.name} #{e.message}' Location: '#{Array(e.backtrace).first}'. " \
-          'This can happen when google-protobuf is missing its native components. ' \
-          'To fix this, try removing and reinstalling the gem, forcing it to recompile the components: ' \
-          '`gem uninstall google-protobuf -a; BUNDLE_FORCE_RUBY_PLATFORM=true bundle install`. ' \
-          'If the error persists, please contact Datadog support at <https://docs.datadoghq.com/help/>.'
-        )
-        @protobuf_loaded = false
-      end
-    end
-
     private_class_method def self.native_library_failed_to_load?
       success, exception = try_loading_native_library
 
@@ -184,7 +116,7 @@ module Datadog
     end
 
     # All requires for the profiler should be directly added here; and everything should be loaded eagerly.
-    # (Currently there's a few exceptions for the old profiler, but we should avoid other exceptions.)
+    # (Currently there's a leftovers that need to be cleaned up, but we should avoid other exceptions.)
     #
     # All of the profiler should be loaded and ready to go when this method returns `true`.
     private_class_method def self.load_profiling
@@ -195,21 +127,16 @@ module Datadog
       require_relative 'profiling/collectors/cpu_and_wall_time_worker'
       require_relative 'profiling/collectors/dynamic_sampling_rate'
       require_relative 'profiling/collectors/idle_sampling_helper'
-      require_relative 'profiling/collectors/old_stack'
       require_relative 'profiling/collectors/stack'
       require_relative 'profiling/collectors/thread_context'
       require_relative 'profiling/diagnostics/environment_logger'
       require_relative 'profiling/stack_recorder'
-      require_relative 'profiling/old_recorder'
       require_relative 'profiling/exporter'
+      require_relative 'profiling/flush'
       require_relative 'profiling/scheduler'
       require_relative 'profiling/tasks/setup'
       require_relative 'profiling/profiler'
       require_relative 'profiling/native_extension'
-      require_relative 'profiling/trace_identifiers/helper'
-      # This file is no longer eagerly loaded as a workaround for an issue. It only gets loaded dynamically if the old
-      # profiler is in use. See Profiling::Component#load_pprof_support for more details.
-      # require_relative 'profiling/pprof/pprof_pb'
       require_relative 'profiling/tag_builder'
       require_relative 'profiling/http_transport'
 

data/lib/datadog/tracing/component.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'tracer'
+require_relative 'configuration/agent_settings_resolver'
 require_relative 'flush'
 require_relative 'sync_writer'
 require_relative 'sampling/span/rule_parser'
@@ -22,12 +23,14 @@ module Datadog
         end
       end
 
-      def build_tracer(settings, agent_settings)
+      def build_tracer(settings, logger:)
         # If a custom tracer has been provided, use it instead.
         # Ignore all other options (they should already be configured.)
         tracer = settings.tracing.instance
         return tracer unless tracer.nil?
 
+        agent_settings = Configuration::AgentSettingsResolver.call(settings, logger: logger)
+
         # Apply test mode settings if test mode is activated
         if settings.tracing.test_mode.enabled
           trace_flush = build_test_mode_trace_flush(settings)
@@ -131,12 +134,12 @@ module Datadog
       # process, but can take a variety of options (including
       # a fully custom instance) that makes the Tracer
       # initialization process complex.
-      def build_writer(settings, agent_settings)
+      def build_writer(settings, agent_settings, options = settings.tracing.writer_options)
         if (writer = settings.tracing.writer)
           return writer
         end
 
-        Tracing::Writer.new(agent_settings: agent_settings, **settings.tracing.writer_options)
+        Tracing::Writer.new(agent_settings: agent_settings, **options)
       end
 
       def subscribe_to_writer_events!(writer, sampler_delegator, test_mode)
@@ -220,8 +223,11 @@ module Datadog
       end
 
       def build_test_mode_writer(settings, agent_settings)
-        # Flush traces synchronously, to guarantee they are written.
         writer_options = settings.tracing.test_mode.writer_options || {}
+
+        return build_writer(settings, agent_settings, writer_options) if settings.tracing.test_mode.async
+
+        # Flush traces synchronously, to guarantee they are written.
         Tracing::SyncWriter.new(agent_settings: agent_settings, **writer_options)
       end
     end

data/lib/datadog/tracing/configuration/agent_settings_resolver.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../../core/configuration/agent_settings_resolver'
+
+module Datadog
+  module Tracing
+    module Configuration
+      # This class encapsulates any tracing specific agent settings
+      class AgentSettingsResolver < Datadog::Core::Configuration::AgentSettingsResolver
+      end
+    end
+  end
+end

data/lib/datadog/tracing/configuration/ext.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../../core/configuration/ext'
+
 module Datadog
   module Tracing
     module Configuration
@@ -88,8 +90,8 @@ module Datadog
 
         # @public_api
         module Transport
-          ENV_DEFAULT_PORT = 'DD_TRACE_AGENT_PORT'
-          ENV_DEFAULT_URL = 'DD_TRACE_AGENT_URL'
+          ENV_DEFAULT_PORT = Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_PORT
+          ENV_DEFAULT_URL = Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_URL
         end
 
         # @public_api