ddtrace 0.53.0 → 0.54.1

data/lib/ddtrace/ext/priority.rb

@@ -4,13 +4,15 @@ module Datadog
     # Priority is a hint given to the backend so that it knows which traces to reject or kept.
     # In a distributed context, it should be set before any context propagation (fork, RPC calls) to be effective.
     module Priority
-      # Use this to explicitely inform the backend that a trace should be rejected and not stored.
+      # Use this to explicitly inform the backend that a trace MUST be rejected and not stored.
+      # This includes rules and rate limits configured by the user through the {RuleSampler}.
       USER_REJECT = -1
-      # Used by the builtin sampler to inform the backend that a trace should be rejected and not stored.
+      # Used by the {PrioritySampler} to inform the backend that a trace should be rejected and not stored.
       AUTO_REJECT = 0
-      # Used by the builtin sampler to inform the backend that a trace should be kept and stored.
+      # Used by the {PrioritySampler} to inform the backend that a trace should be kept and stored.
       AUTO_KEEP = 1
-      # Use this to explicitely inform the backend that a trace should be kept and stored.
+      # Use this to explicitly inform the backend that a trace MUST be kept and stored.
+      # This includes rules and rate limits configured by the user through the {RuleSampler}.
       USER_KEEP = 2
     end
   end

data/lib/ddtrace/ext/profiling.rb

@@ -9,9 +9,9 @@ module Datadog
       ENV_ENDPOINT_COLLECTION_ENABLED = 'DD_PROFILING_ENDPOINT_COLLECTION_ENABLED'.freeze
 
       module Pprof
+        LABEL_KEY_LOCAL_ROOT_SPAN_ID = 'local root span id'.freeze
         LABEL_KEY_SPAN_ID = 'span id'.freeze
         LABEL_KEY_THREAD_ID = 'thread id'.freeze
-        LABEL_KEY_TRACE_ID = 'trace id'.freeze
         LABEL_KEY_TRACE_ENDPOINT = 'trace endpoint'.freeze
         SAMPLE_VALUE_NO_VALUE = 0
         VALUE_TYPE_CPU = 'cpu-time'.freeze

data/lib/ddtrace/metrics.rb

@@ -31,7 +31,7 @@ module Datadog
       !version.nil? && version >= Gem::Version.new('3.3.0') &&
         # dogstatsd-ruby >= 5.0 & < 5.2.0 has known issues with process forks
         # and do not support the single thread mode we use to avoid this problem.
-        !(version >= Gem::Version.new('5.0') && version < Gem::Version.new('5.2'))
+        !(version >= Gem::Version.new('5.0') && version < Gem::Version.new('5.3'))
     end
 
     def enabled?
@@ -274,7 +274,7 @@ module Datadog
       IGNORED_STATSD_ONLY_ONCE.run do
         Datadog.logger.warn(
           'Ignoring user-supplied statsd instance as currently-installed version of dogstastd-ruby is incompatible. ' \
-          "To fix this, ensure that you have `gem 'dogstatsd-ruby', '~> 5.2'` on your Gemfile or gems.rb file."
+          "To fix this, ensure that you have `gem 'dogstatsd-ruby', '~> 5.3'` on your Gemfile or gems.rb file."
         )
       end
     end

data/lib/ddtrace/profiling/collectors/stack.rb

@@ -1,4 +1,6 @@
 # typed: true
+
+require 'ddtrace/profiling/native_extension'
 require 'ddtrace/profiling/backtrace_location'
 require 'ddtrace/profiling/events/stack'
 require 'ddtrace/utils/only_once'
@@ -19,6 +21,7 @@ module Datadog
         MIN_INTERVAL = 0.01
         THREAD_LAST_CPU_TIME_KEY = :datadog_profiler_last_cpu_time
         THREAD_LAST_WALL_CLOCK_KEY = :datadog_profiler_last_wall_clock
+        SYNTHETIC_STACK_IN_NATIVE_CODE = [BacktraceLocation.new('', 0, 'In native code').freeze].freeze
 
         # This default was picked based on the current sampling performance and on expected concurrency on an average
         # Ruby MRI application. Lowering this optimizes for latency (less impact each time we sample), and raising
@@ -31,7 +34,8 @@ module Datadog
           :trace_identifiers_helper,
           :ignore_thread,
           :max_time_usage_pct,
-          :thread_api
+          :thread_api,
+          :cpu_time_provider
 
         def initialize(
           recorder,
@@ -41,6 +45,7 @@ module Datadog
           max_time_usage_pct: DEFAULT_MAX_TIME_USAGE_PCT,
           max_threads_sampled: DEFAULT_MAX_THREADS_SAMPLED,
           thread_api: Thread,
+          cpu_time_provider: Datadog::Profiling::NativeExtension,
           fork_policy: Workers::Async::Thread::FORK_POLICY_RESTART, # Restart in forks by default
           interval: MIN_INTERVAL,
           enabled: true
@@ -52,6 +57,8 @@ module Datadog
           @max_time_usage_pct = max_time_usage_pct
           @max_threads_sampled = max_threads_sampled
           @thread_api = thread_api
+          # Only set the provider if it's able to work in the current Ruby/OS combo
+          @cpu_time_provider = cpu_time_provider unless cpu_time_provider.cpu_time_ns_for(thread_api.current).nil?
 
           # Workers::Async::Thread settings
           self.fork_policy = fork_policy
@@ -62,8 +69,6 @@ module Datadog
           # Workers::Polling settings
           self.enabled = enabled
 
-          @warn_about_missing_cpu_time_instrumentation_only_once = Datadog::Utils::OnlyOnce.new
-
           # Cache this proc, since it's pretty expensive to keep recreating it
           @build_backtrace_location = method(:build_backtrace_location).to_proc
           # Cache this buffer, since it's pretty expensive to keep accessing it
@@ -119,6 +124,26 @@ module Datadog
           locations = thread.backtrace_locations
           return if locations.nil?
 
+          # Having empty locations means that the thread is alive, but we don't know what it's doing:
+          #
+          # 1. It can be starting up
+          #    ```
+          #    > Thread.new { sleep }.backtrace
+          #    => [] # <-- note the thread hasn't actually started running sleep yet, we got there first
+          #    ```
+          # 2. It can be running native code
+          #    ```
+          #    > t = Process.detach(fork { sleep })
+          #    => #<Process::Waiter:0x00007ffe7285f7a0 run>
+          #    > t.backtrace
+          #    => [] # <-- this can happen even minutes later, e.g. it's not a race as in 1.
+          #    ```
+          #    This effect has been observed in threads created by the Iodine web server and the ffi gem
+          #
+          # To give customers visibility into these threads, we replace the empty stack with one containing a
+          # synthetic placeholder frame, so that these threads are properly represented in the UX.
+          locations = SYNTHETIC_STACK_IN_NATIVE_CODE if locations.empty?
+
           # Get actual stack size then trim the stack
           stack_size = locations.length
           locations = locations[0..(max_frames - 1)]
@@ -126,8 +151,8 @@ module Datadog
           # Convert backtrace locations into structs
           locations = convert_backtrace_locations(locations)
 
-          thread_id = thread.respond_to?(:pthread_thread_id) ? thread.pthread_thread_id : thread.object_id
-          trace_id, span_id, trace_resource = trace_identifiers_helper.trace_identifiers_for(thread)
+          thread_id = thread.object_id
+          root_span_id, span_id, trace_resource = trace_identifiers_helper.trace_identifiers_for(thread)
           cpu_time = get_cpu_time_interval!(thread)
           wall_time_interval_ns =
             get_elapsed_since_last_sample_and_set_value(thread, THREAD_LAST_WALL_CLOCK_KEY, current_wall_time_ns)
@@ -137,7 +162,7 @@ module Datadog
             locations,
             stack_size,
             thread_id,
-            trace_id,
+            root_span_id,
             span_id,
             trace_resource,
             cpu_time,
@@ -146,17 +171,10 @@ module Datadog
         end
 
         def get_cpu_time_interval!(thread)
-          # Return if we can't get the current CPU time
-          unless thread.respond_to?(:cpu_time_instrumentation_installed?) && thread.cpu_time_instrumentation_installed?
-            warn_about_missing_cpu_time_instrumentation(thread)
-            return
-          end
+          return unless cpu_time_provider
 
-          current_cpu_time_ns = thread.cpu_time(:nanosecond)
+          current_cpu_time_ns = cpu_time_provider.cpu_time_ns_for(thread)
 
-          # NOTE: This can still be nil even when all of the checks above passed because of a race: there's a bit of
-          # initialization that needs to be done by the thread itself, and it's possible for us to try to sample
-          # *before* the thread had time to finish the initialization
           return unless current_cpu_time_ns
 
           get_elapsed_since_last_sample_and_set_value(thread, THREAD_LAST_CPU_TIME_KEY, current_cpu_time_ns)
@@ -205,33 +223,6 @@ module Datadog
 
         private
 
-        def warn_about_missing_cpu_time_instrumentation(thread)
-          @warn_about_missing_cpu_time_instrumentation_only_once.run do
-            # Is the profiler thread instrumented? If it is, then we know instrumentation is available, but seems to be
-            # missing on this thread we just found.
-            #
-            # As far as we know, it can be missing due to one the following:
-            #
-            # a) The thread was started before we installed our instrumentation.
-            #    In this case, the fix is to make sure ddtrace gets loaded before any other parts of the application.
-            #
-            # b) The thread was started using the Ruby native APIs (e.g. from a C extension such as ffi).
-            #    Known cases right now that trigger this are the ethon/typhoeus gems.
-            #    We currently have no solution for this case; these threads will always be missing our CPU instrumentation.
-            #
-            # c) The thread was started with `Thread.start`/`Thread.fork` and hasn't yet enabled the instrumentation.
-            #    When threads are started using these APIs, there's a small time window during which the thread has started
-            #    but our code to apply the instrumentation hasn't run yet; in these cases it's just a matter of allowing
-            #    it to run and our instrumentation to be applied.
-            #
-            if thread_api.current.respond_to?(:cpu_time) && thread_api.current.cpu_time
-              Datadog.logger.debug(
-                "Thread ('#{thread}') is missing profiling instrumentation; other threads should be unaffected"
-              )
-            end
-          end
-        end
-
         # If the profiler is started for a while, stopped and then restarted OR whenever the process forks, we need to
         # clean up any leftover per-thread counters, so that the first sample after starting doesn't end up with:
         #
@@ -253,9 +244,18 @@ module Datadog
         end
 
         def get_elapsed_since_last_sample_and_set_value(thread, key, current_value)
-          # See cthread.rb for more details, but this is a workaround for https://bugs.ruby-lang.org/issues/17807 ;
-          # using all thread_variable related methods on these instances also triggers a crash and for now we just
-          # skip it for the affected Rubies
+          # Process::Waiter crash workaround:
+          #
+          # This is a workaround for a Ruby VM segfault (usually something like
+          # "[BUG] Segmentation fault at 0x0000000000000008") in the affected Ruby versions.
+          # See https://bugs.ruby-lang.org/issues/17807 for details.
+          #
+          # In those Ruby versions, there's a very special subclass of `Thread` called `Process::Waiter` that causes VM
+          # crashes whenever something tries to read its instance or thread variables. This subclass of thread only
+          # shows up when the `Process.detach` API gets used.
+          # In the specs you'll find crash regression tests that include a way of reproducing it.
+          #
+          # As workaround for now we just skip it for the affected Rubies
           return 0 if @needs_process_waiter_workaround && thread.is_a?(::Process::Waiter)
 
           last_value = thread.thread_variable_get(key) || current_value

data/lib/ddtrace/profiling/encoding/profile.rb

@@ -37,7 +37,7 @@ module Datadog
             end
 
             # Build the profile and encode it
-            template.to_pprof
+            template.to_pprof(start: flush.start, finish: flush.finish)
           end
         end
       end

data/lib/ddtrace/profiling/events/stack.rb

@@ -11,7 +11,7 @@ module Datadog
           :frames,
           :total_frame_count,
           :thread_id,
-          :trace_id,
+          :root_span_id,
           :span_id,
           :trace_resource
 
@@ -20,7 +20,7 @@ module Datadog
           frames,
           total_frame_count,
           thread_id,
-          trace_id,
+          root_span_id,
           span_id,
           trace_resource
         )
@@ -29,16 +29,16 @@ module Datadog
           @frames = frames
           @total_frame_count = total_frame_count
           @thread_id = thread_id
-          @trace_id = trace_id
+          @root_span_id = root_span_id
           @span_id = span_id
           @trace_resource = trace_resource
 
           @hash = [
             thread_id,
-            trace_id,
+            root_span_id,
             span_id,
-            # trace_resource is deliberately not included -- events that share the same (trace_id, span_id)
-            # trace_resource might not match between pairs, but they refer to the same trace.
+            # trace_resource is deliberately not included -- events that share the same (root_span_id, span_id) refer
+            # to the same trace
             frames.collect(&:hash),
             total_frame_count
           ].hash
@@ -56,7 +56,7 @@ module Datadog
           frames,
           total_frame_count,
           thread_id,
-          trace_id,
+          root_span_id,
           span_id,
           trace_resource,
           cpu_time_interval_ns,
@@ -67,7 +67,7 @@ module Datadog
             frames,
             total_frame_count,
             thread_id,
-            trace_id,
+            root_span_id,
             span_id,
             trace_resource
           )

data/lib/ddtrace/profiling/native_extension.rb

@@ -2,7 +2,8 @@
 module Datadog
   module Profiling
     # This module contains classes and methods which are implemented using native code in the
-    # ext/ddtrace_profiling_native_extension folder
+    # ext/ddtrace_profiling_native_extension folder, as well as some Ruby-level utilities that don't make sense to
+    # write using C
     module NativeExtension
       private_class_method def self.working?
         native_working?
@@ -13,6 +14,27 @@ 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/ddtrace/profiling/pprof/builder.rb

@@ -4,6 +4,7 @@
 require 'ddtrace/profiling/flush'
 require 'ddtrace/profiling/pprof/message_set'
 require 'ddtrace/profiling/pprof/string_table'
+require 'ddtrace/utils/time'
 
 module Datadog
   module Profiling
@@ -47,14 +48,19 @@ module Datadog
           Perftools::Profiles::Profile.encode(profile).force_encoding(DEFAULT_ENCODING)
         end
 
-        def build_profile
+        def build_profile(start:, finish:)
+          start_ns = Datadog::Utils::Time.as_utc_epoch_ns(start)
+          finish_ns = Datadog::Utils::Time.as_utc_epoch_ns(finish)
+
           Perftools::Profiles::Profile.new(
             sample_type: @sample_types.messages,
             sample: @samples,
             mapping: @mappings.messages,
             location: @locations.values,
             function: @functions.messages,
-            string_table: @string_table.strings
+            string_table: @string_table.strings,
+            time_nanos: start_ns,
+            duration_nanos: finish_ns - start_ns,
           )
         end
 

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

@@ -32,7 +32,7 @@ module Datadog
 
           @most_recent_trace_samples = {}
           @processed_unique_stacks = 0
-          @processed_with_trace_ids = 0
+          @processed_with_trace = 0
         end
 
         def add_events!(stack_samples)
@@ -48,18 +48,18 @@ module Datadog
           stack_sample.hash
         end
 
-        # Track the most recent sample for each trace
+        # 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.trace_id && stack_sample.trace_resource
+          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.trace_id])
+          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.trace_id] = stack_sample
+              @most_recent_trace_samples[stack_sample.root_span_id] = stack_sample
             end
           else
             # Add trace resource
-            @most_recent_trace_samples[stack_sample.trace_id] = stack_sample
+            @most_recent_trace_samples[stack_sample.root_span_id] = stack_sample
           end
         end
 
@@ -100,15 +100,15 @@ module Datadog
             )
           ]
 
-          trace_id = stack_sample.trace_id || 0
+          root_span_id = stack_sample.root_span_id || 0
           span_id = stack_sample.span_id || 0
 
-          if trace_id != 0 && span_id != 0
-            @processed_with_trace_ids += 1
+          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(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)
             )
 
             labels << Perftools::Profiles::Label.new(
@@ -118,10 +118,7 @@ module Datadog
 
             # Use most up-to-date trace resource, if available.
             # Otherwise, use the trace resource provided.
-            trace_resource = (
-              @most_recent_trace_samples[stack_sample.trace_id] \
-              || stack_sample
-            ).trace_resource
+            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(
@@ -135,7 +132,7 @@ module Datadog
         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/template.rb

@@ -80,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/tasks/setup.rb

@@ -1,21 +1,20 @@
 # 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 do
@@ -39,19 +38,15 @@ module Datadog
           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: #{Array(e.backtrace).first}"
-          end
         end
 
         def setup_at_fork_hooks
@@ -75,6 +70,20 @@ module Datadog
             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

@@ -6,10 +6,10 @@ require 'ddtrace/ext/http'
 module Datadog
   module Profiling
     module TraceIdentifiers
-      # Used by Datadog::Profiling::TraceIdentifiers::Helper to get the trace identifiers (trace id and span id) for a
-      # given thread, if there is an active trace for that thread in Datadog.tracer.
+      # 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: nil)
+        def initialize(tracer:)
           @tracer = (tracer if tracer.respond_to?(:call_context))
         end
 
@@ -19,10 +19,13 @@ module Datadog
           context = @tracer.call_context(thread)
           return unless context
 
-          trace_id = context.trace_id || 0
-          span_id = context.span_id || 0
+          span, root_span = context.current_span_and_root_span
+          return unless span && root_span
 
-          [trace_id, span_id, maybe_extract_resource(context.current_root_span)] if trace_id != 0 && span_id != 0
+          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
@@ -31,8 +34,6 @@ module Datadog
         # 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)
-          return unless root_span
-
           root_span.resource if root_span.span_type == Datadog::Ext::HTTP::TYPE_INBOUND
         end
       end

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

@@ -6,7 +6,7 @@ require 'ddtrace/profiling/trace_identifiers/ddtrace'
 module Datadog
   module Profiling
     module TraceIdentifiers
-      # Helper used to retrieve the trace identifiers (trace id and span id) for a given thread,
+      # 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
@@ -28,7 +28,7 @@ module Datadog
         end
 
         # Expected output of the #trace_identifiers_for
-        # duck type is [trace_id, span_id, (optional trace_resource_container)]
+        # 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)

data/lib/ddtrace/profiling.rb

@@ -128,9 +128,7 @@ module Datadog
     private_class_method def self.load_profiling
       return false unless supported?
 
-      require 'ddtrace/profiling/ext/cpu'
       require 'ddtrace/profiling/ext/forking'
-
       require 'ddtrace/profiling/collectors/stack'
       require 'ddtrace/profiling/exporter'
       require 'ddtrace/profiling/recorder'

data/lib/ddtrace/sampler.rb

@@ -194,6 +194,12 @@ module Datadog
   class PrioritySampler
     extend Forwardable
 
+    # NOTE: We do not advise using a pre-sampler. It can save resources,
+    # but pre-sampling at rates < 100% may result in partial traces, unless
+    # the pre-sampler knows exactly how to drop a span without dropping its ancestors.
+    #
+    # Additionally, as service metrics are calculated in the Datadog Agent,
+    # the service's throughput will be underestimated.
     attr_reader :pre_sampler, :priority_sampler
 
     SAMPLE_RATE_METRIC_KEY = '_sample_rate'.freeze
@@ -209,17 +215,21 @@ module Datadog
 
     def sample!(span)
       # If pre-sampling is configured, do it first. (By default, this will sample at 100%.)
-      # NOTE: Pre-sampling at rates < 100% may result in partial traces; not recommended.
       span.sampled = pre_sample?(span) ? @pre_sampler.sample!(span) : true
 
       if span.sampled
-        # If priority sampling has already been applied upstream, use that, otherwise...
-        unless priority_assigned_upstream?(span)
-          # Roll the dice and determine whether how we set the priority.
-          priority = priority_sample!(span) ? Datadog::Ext::Priority::AUTO_KEEP : Datadog::Ext::Priority::AUTO_REJECT
+        # If priority sampling has already been applied upstream, use that value.
+        return true if priority_assigned?(span)
 
-          assign_priority!(span, priority)
-        end
+        # Check with post sampler how we set the priority.
+        sample = priority_sample!(span)
+
+        # Check if post sampler has already assigned a priority.
+        return true if priority_assigned?(span)
+
+        # If not, use agent priority values.
+        priority = sample ? Datadog::Ext::Priority::AUTO_KEEP : Datadog::Ext::Priority::AUTO_REJECT
+        assign_priority!(span, priority)
       else
         # If discarded by pre-sampling, set "reject" priority, so other
         # services for the same trace don't sample needlessly.
@@ -244,7 +254,7 @@ module Datadog
       end
     end
 
-    def priority_assigned_upstream?(span)
+    def priority_assigned?(span)
       span.context && !span.context.sampling_priority.nil?
     end
 

data/lib/ddtrace/sampling/rule_sampler.rb

@@ -97,11 +97,13 @@ module Datadog
         sampled = rule.sample?(span)
         sample_rate = rule.sample_rate(span)
 
+        set_priority(span, sampled)
         set_rule_metrics(span, sample_rate)
 
         return false unless sampled
 
-        rate_limiter.allow?(1).tap do
+        rate_limiter.allow?(1).tap do |allowed|
+          set_priority(span, allowed)
           set_limiter_metrics(span, rate_limiter.effective_rate)
         end
       rescue StandardError => e
@@ -109,6 +111,16 @@ module Datadog
         yield(span)
       end
 
+      # Span priority should only be set when the {RuleSampler}
+      # was responsible for the sampling decision.
+      def set_priority(span, sampled)
+        if sampled
+          ForcedTracing.keep(span)
+        else
+          ForcedTracing.drop(span)
+        end
+      end
+
       def set_rule_metrics(span, sample_rate)
         span.set_metric(Ext::Sampling::RULE_SAMPLE_RATE, sample_rate)
       end