ddtrace 0.42.0 → 0.54.2

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

@@ -0,0 +1,31 @@
+# typed: true
+require 'ddtrace/profiling/transport/io/client'
+require 'ddtrace/profiling/encoding/profile'
+
+module Datadog
+  module Profiling
+    module Transport
+      # Namespace for profiling IO transport components
+      module IO
+        module_function
+
+        # Builds a new Profiling::Transport::IO::Client
+        def new(out, encoder, options = {})
+          Client.new(out, encoder, options)
+        end
+
+        # Builds a new Profiling::Transport::IO::Client with default settings
+        # Pass options to override any settings.
+        def default(options = {})
+          options = options.dup
+
+          new(
+            options.delete(:out) || $stdout,
+            options.delete(:encoder) || Profiling::Encoding::Profile::Protobuf,
+            options
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# typed: true
+require 'ddtrace/transport/parcel'
+
+module Datadog
+  module Profiling
+    module Transport
+      # Data transfer object for profiling data
+      class Parcel
+        include Datadog::Transport::Parcel
+
+        def encode_with(encoder)
+          # TODO: Determine encoding behavior
+          encoder.encode(data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# typed: true
+require 'ddtrace/transport/request'
+require 'ddtrace/profiling/transport/parcel'
+
+module Datadog
+  module Profiling
+    module Transport
+      # Profiling request
+      class Request < Datadog::Transport::Request
+        def initialize(flush)
+          super(Parcel.new(flush))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# typed: strict
+module Datadog
+  module Profiling
+    module Transport
+      # Profiling response
+      module Response; end
+    end
+  end
+end

data/lib/ddtrace/profiling.rb

@@ -0,0 +1,149 @@
+# typed: true
+require 'datadog/core/environment/variable_helpers'
+require 'ddtrace/utils/only_once'
+
+module Datadog
+  # Contains profiler for generating stack profiles, etc.
+  module Profiling # rubocop:disable Metrics/ModuleLength
+    GOOGLE_PROTOBUF_MINIMUM_VERSION = Gem::Version.new('3.0')
+    private_constant :GOOGLE_PROTOBUF_MINIMUM_VERSION
+
+    SKIPPED_NATIVE_EXTENSION_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+    private_constant :SKIPPED_NATIVE_EXTENSION_ONLY_ONCE
+
+    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
+
+      ruby_engine_unsupported? ||
+        native_library_failed_to_load? ||
+        protobuf_gem_unavailable? ||
+        protobuf_version_unsupported? ||
+        protobuf_failed_to_load?
+    end
+
+    private_class_method def self.ruby_engine_unsupported?
+      'JRuby is not supported' if RUBY_ENGINE == 'jruby'
+    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 !defined?(::Google::Protobuf) && 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 !defined?(::Google::Protobuf) && 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_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.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 support via <https://docs.datadoghq.com/help/> or ' \
+          'file a bug at <https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug>.'
+        )
+        @protobuf_loaded = false
+      end
+    end
+
+    private_class_method def self.native_library_failed_to_load?
+      success, exception = try_loading_native_library
+
+      unless success
+        if exception
+          'There was an error loading the profiling native extension due to ' \
+          "'#{exception.message}' at '#{exception.backtrace.first}'"
+        else
+          'The profiling native extension did not load correctly. ' \
+          'If the error persists, please contact support via <https://docs.datadoghq.com/help/> or ' \
+          'file a bug at <https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug>.'
+        end
+      end
+    end
+
+    private_class_method def self.try_loading_native_library
+      if Datadog::Core::Environment::VariableHelpers.env_to_bool('DD_PROFILING_NO_EXTENSION', false)
+        SKIPPED_NATIVE_EXTENSION_ONLY_ONCE.run do
+          Kernel.warn(
+            '[DDTRACE] Skipped loading of profiling native extension due to DD_PROFILING_NO_EXTENSION environment ' \
+            'variable being set. ' \
+            'This option is experimental and will lead to the profiler not working in future releases. ' \
+            'If you needed to use this, please tell us why on <https://github.com/DataDog/dd-trace-rb/issues/new>.'
+          )
+        end
+
+        return [true, nil]
+      end
+
+      begin
+        require "ddtrace_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
+        success =
+          defined?(Datadog::Profiling::NativeExtension) && Datadog::Profiling::NativeExtension.send(:native_working?)
+        [success, nil]
+      rescue StandardError, LoadError => e
+        [false, e]
+      end
+    end
+
+    private_class_method def self.load_profiling
+      return false unless supported?
+
+      require 'ddtrace/profiling/ext/forking'
+      require 'ddtrace/profiling/collectors/stack'
+      require 'ddtrace/profiling/exporter'
+      require 'ddtrace/profiling/recorder'
+      require 'ddtrace/profiling/scheduler'
+      require 'ddtrace/profiling/tasks/setup'
+      require 'ddtrace/profiling/transport/io'
+      require 'ddtrace/profiling/transport/http'
+      require 'ddtrace/profiling/profiler'
+      require 'ddtrace/profiling/native_extension'
+      require 'ddtrace/profiling/trace_identifiers/helper'
+      require 'ddtrace/profiling/pprof/pprof_pb'
+
+      true
+    end
+
+    load_profiling if supported?
+  end
+end

data/lib/ddtrace/propagation/grpc_propagator.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/context'
 require 'ddtrace/ext/distributed'
 
@@ -19,6 +20,7 @@ module Datadog
     def self.extract(metadata)
       metadata = Carrier.new(metadata)
       return Datadog::Context.new unless metadata.valid?
+
       Datadog::Context.new(trace_id: metadata.trace_id,
                            span_id: metadata.parent_id,
                            sampling_priority: metadata.sampling_priority,

data/lib/ddtrace/propagation/http_propagator.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'ddtrace/configuration'
 require 'ddtrace/context'
 require 'ddtrace/ext/distributed'
@@ -26,7 +27,14 @@ module Datadog
       # Inject all configured propagation styles
       ::Datadog.configuration.distributed_tracing.propagation_inject_style.each do |style|
         propagator = PROPAGATION_STYLES[style]
-        propagator.inject!(context, env) unless propagator.nil?
+        begin
+          propagator.inject!(context, env) unless propagator.nil?
+        rescue => e
+          Datadog.logger.error(
+            'Error injecting propagated context into the environment. ' \
+            "Cause: #{e} Location: #{Array(e.backtrace).first}"
+          )
+        end
       end
     end
 
@@ -42,7 +50,15 @@ module Datadog
 
         # Extract context
         # DEV: `propagator.extract` will return `nil`, where `HTTPPropagator#extract` will not
-        extracted_context = propagator.extract(env)
+        begin
+          extracted_context = propagator.extract(env)
+        rescue => e
+          Datadog.logger.error(
+            'Error extracting propagated context from the environment. ' \
+            "Cause: #{e} Location: #{Array(e.backtrace).first}"
+          )
+        end
+
         # Skip this style if no valid headers were found
         next if extracted_context.nil?
 

data/lib/ddtrace/quantization/hash.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Datadog
   module Quantization
     # Quantization for HTTP resources

data/lib/ddtrace/quantization/http.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'uri'
 require 'set'
 
@@ -5,6 +6,8 @@ module Datadog
   module Quantization
     # Quantization for HTTP resources
     module HTTP
+      include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
       PLACEHOLDER = '?'.freeze
 
       module_function
@@ -61,6 +64,7 @@ module Datadog
       # e.g. Reduces "foo&bar=bar&bar=bar&foo" to "foo&bar=bar&bar=bar"
       def collect_query(query, options = {})
         return query unless block_given?
+
         uniq = options[:uniq].nil? ? false : options[:uniq]
         keys = Set.new
 

data/lib/ddtrace/runtime/metrics.rb

@@ -1,17 +1,19 @@
+# typed: true
 require 'ddtrace/ext/integration'
 require 'ddtrace/ext/runtime'
 
 require 'ddtrace/metrics'
-require 'ddtrace/runtime/class_count'
-require 'ddtrace/runtime/gc'
-require 'ddtrace/runtime/identity'
-require 'ddtrace/runtime/thread_count'
+require 'datadog/core/environment/class_count'
+require 'datadog/core/environment/gc'
+require 'datadog/core/environment/identity'
+require 'datadog/core/environment/thread_count'
+require 'datadog/core/environment/vm_cache'
 
 module Datadog
   module Runtime
     # For generating runtime metrics
     class Metrics < Datadog::Metrics
-      def initialize(options = {})
+      def initialize(**options)
         super
 
         # Initialize service list
@@ -29,7 +31,7 @@ module Datadog
         # Tag span with language and runtime ID for association with metrics.
         # We only tag spans that performed internal application work.
         unless span.get_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE)
-          span.set_tag(Ext::Runtime::TAG_LANG, Runtime::Identity.lang)
+          span.set_tag(Ext::Runtime::TAG_LANG, Core::Environment::Identity.lang)
         end
       end
 
@@ -52,17 +54,36 @@ module Datadog
       def flush
         return unless enabled?
 
-        try_flush { gauge(Ext::Runtime::Metrics::METRIC_CLASS_COUNT, ClassCount.value) if ClassCount.available? }
-        try_flush { gauge(Ext::Runtime::Metrics::METRIC_THREAD_COUNT, ThreadCount.value) if ThreadCount.available? }
-        try_flush { gc_metrics.each { |metric, value| gauge(metric, value) } if GC.available? }
+        try_flush do
+          if Core::Environment::ClassCount.available?
+            gauge(Ext::Runtime::Metrics::METRIC_CLASS_COUNT, Core::Environment::ClassCount.value)
+          end
+        end
+
+        try_flush do
+          if Core::Environment::ThreadCount.available?
+            gauge(Ext::Runtime::Metrics::METRIC_THREAD_COUNT, Core::Environment::ThreadCount.value)
+          end
+        end
+
+        try_flush { gc_metrics.each { |metric, value| gauge(metric, value) } if Core::Environment::GC.available? }
+
+        try_flush do
+          if Core::Environment::VMCache.available?
+            gauge(Ext::Runtime::Metrics::METRIC_GLOBAL_CONSTANT_STATE, Core::Environment::VMCache.global_constant_state)
+
+            # global_method_state is not available since Ruby >= 3.0,
+            # as method caching was moved to a per-class basis.
+            global_method_state = Core::Environment::VMCache.global_method_state
+            gauge(Ext::Runtime::Metrics::METRIC_GLOBAL_METHOD_STATE, global_method_state) if global_method_state
+          end
+        end
       end
 
       def gc_metrics
-        Hash[
-          GC.stat.flat_map do |k, v|
-            nested_gc_metric(Ext::Runtime::Metrics::METRIC_GC_PREFIX, k, v)
-          end
-        ]
+        Core::Environment::GC.stat.flat_map do |k, v|
+          nested_gc_metric(Ext::Runtime::Metrics::METRIC_GC_PREFIX, k, v)
+        end.to_h
       end
 
       def try_flush

data/lib/ddtrace/sampler.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'forwardable'
 
 require 'ddtrace/ext/priority'
@@ -81,7 +82,7 @@ module Datadog
       :default_key
 
     def initialize(default_key, default_rate = 1.0, &block)
-      raise ArgumentError, 'No resolver given!' unless block_given?
+      raise ArgumentError, 'No resolver given!' unless block
 
       @default_key = default_key
       @resolver = block
@@ -193,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
@@ -208,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.
@@ -243,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/matcher.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Datadog
   module Sampling
     # Checks if a span conforms to a matching criteria.

data/lib/ddtrace/sampling/rate_limiter.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/utils/time'
 
 module Datadog
@@ -38,6 +39,10 @@ module Datadog
         @tokens = max_tokens
         @total_messages = 0
         @conforming_messages = 0
+        @prev_conforming_messages = nil
+        @prev_total_messages = nil
+        @current_window = nil
+
         @last_refill = Utils::Time.get_time
       end
 
@@ -47,28 +52,17 @@ module Datadog
       # If it does, return +true+ and remove +size+
       # tokens from the bucket.
       # If it does not, return +false+ without affecting
-      # the tokens form the bucket.
+      # the tokens from the bucket.
       #
       # @return [Boolean] +true+ if message conforms with current bucket limit
       def allow?(size)
-        return false if @rate.zero?
-        return true if @rate < 0
-
-        refill_since_last_message
-
-        increment_total_count
-
-        return false if @tokens < size
-
-        increment_conforming_count
-
-        @tokens -= size
-
-        true
+        allowed = should_allow?(size)
+        update_rate_counts(allowed)
+        allowed
       end
 
       # Ratio of 'conformance' per 'total messages' checked
-      # on this bucket.
+      # averaged for the past 2 buckets
       #
       # Returns +1.0+ when no messages have been checked yet.
       #
@@ -77,6 +71,20 @@ module Datadog
         return 0.0 if @rate.zero?
         return 1.0 if @rate < 0 || @total_messages.zero?
 
+        return current_window_rate if @prev_conforming_messages.nil? || @prev_total_messages.nil?
+
+        (@conforming_messages.to_f + @prev_conforming_messages.to_f) / (@total_messages + @prev_total_messages)
+      end
+
+      # Ratio of 'conformance' per 'total messages' checked
+      # on this bucket
+      #
+      # Returns +1.0+ when no messages have been checked yet.
+      #
+      # @return [Float] Conformance ratio, between +[0,1]+
+      def current_window_rate
+        return 1.0 if @total_messages.zero?
+
         @conforming_messages.to_f / @total_messages
       end
 
@@ -91,6 +99,8 @@ module Datadog
         now = Utils::Time.get_time
         elapsed = now - @last_refill
 
+        # Update the number of available tokens, but ensure we do not exceed the max
+        # we return the min of tokens + rate*elapsed, or max tokens
         refill_tokens(@rate * elapsed)
 
         @last_refill = now
@@ -108,6 +118,46 @@ module Datadog
       def increment_conforming_count
         @conforming_messages += 1
       end
+
+      def should_allow?(size)
+        # rate limit of 0 blocks everything
+        return false if @rate.zero?
+
+        # negative rate limit disables rate limiting
+        return true if @rate < 0
+
+        refill_since_last_message
+
+        # if tokens < 1 we don't allow?
+        return false if @tokens < size
+
+        @tokens -= size
+
+        true
+      end
+
+      # Sets and Updates the past two 1 second windows for which
+      # the rate limiter must compute it's rate over and updates
+      # the total count, and conforming message count if +allowed+
+      def update_rate_counts(allowed)
+        now = Utils::Time.get_time
+
+        # No tokens have been seen yet, start a new window
+        if @current_window.nil?
+          @current_window = now
+        # If more than 1 second has past since last window, reset
+        elsif now - @current_window >= 1
+          @prev_conforming_messages = @conforming_messages
+          @prev_total_messages = @total_messages
+          @conforming_messages = 0
+          @total_messages = 0
+          @current_window = now
+        end
+
+        increment_conforming_count if allowed
+
+        increment_total_count
+      end
     end
 
     # \RateLimiter that accepts all resources,

data/lib/ddtrace/sampling/rule.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'forwardable'
 
 require 'ddtrace/sampling/matcher'
@@ -28,7 +29,7 @@ module Datadog
       def match?(span)
         @matcher.match?(span)
       rescue => e
-        Datadog.logger.error("Matcher failed. Cause: #{e.message} Source: #{e.backtrace.first}")
+        Datadog.logger.error("Matcher failed. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
         nil
       end
 

data/lib/ddtrace/sampling/rule_sampler.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'forwardable'
 
 require 'ddtrace/ext/priority'
@@ -5,6 +6,7 @@ require 'ddtrace/ext/priority'
 require 'ddtrace/ext/sampling'
 require 'ddtrace/sampler'
 require 'ddtrace/sampling/rate_limiter'
+require 'ddtrace/sampling/rule'
 
 module Datadog
   module Sampling
@@ -45,15 +47,8 @@ module Datadog
         @default_sampler = if default_sampler
                              default_sampler
                            elsif default_sample_rate
-                             # We want to allow 0.0 to drop all traces, but \RateSampler
-                             # considers 0.0 an invalid rate and falls back to 100% sampling.
-                             #
-                             # We address that here by not setting the rate in the constructor,
-                             # but using the setter method.
-                             #
-                             # We don't want to make this change directly to \RateSampler
-                             # because it breaks its current contract to existing users.
-                             Datadog::RateSampler.new.tap { |s| s.sample_rate = default_sample_rate }
+                             # Add to the end of the rule list a rule always matches any span
+                             @rules << SimpleRule.new(sample_rate: default_sample_rate)
                            else
                              RateByServiceSampler.new(1.0, env: -> { Datadog.tracer.tags[:env] })
                            end
@@ -88,6 +83,7 @@ module Datadog
 
       def update(*args)
         return false unless @default_sampler.respond_to?(:update)
+
         @default_sampler.update(*args)
       end
 
@@ -101,18 +97,30 @@ 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
-        Datadog.logger.error("Rule sampling failed. Cause: #{e.message} Source: #{e.backtrace.first}")
+        Datadog.logger.error("Rule sampling failed. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
         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

data/lib/ddtrace/sampling.rb

@@ -1,2 +1,3 @@
+# typed: strict
 require 'ddtrace/sampling/rule'
 require 'ddtrace/sampling/rule_sampler'