datadog 2.3.0 → 2.4.0

data/lib/datadog/tracing/contrib/graphql/tracing_patcher.rb

@@ -8,13 +8,13 @@ module Datadog
         module TracingPatcher
           module_function
 
-          def patch!(schemas, options)
+          def patch!(schemas)
             if schemas.empty?
-              ::GraphQL::Schema.tracer(::GraphQL::Tracing::DataDogTracing.new(**options))
+              ::GraphQL::Schema.tracer(::GraphQL::Tracing::DataDogTracing.new)
             else
               schemas.each do |schema|
                 if schema.respond_to? :use
-                  schema.use(::GraphQL::Tracing::DataDogTracing, **options)
+                  schema.use(::GraphQL::Tracing::DataDogTracing)
                 else
                   Datadog.logger.warn("Unable to patch #{schema}: Please migrate to class-based schema.")
                 end

data/lib/datadog/tracing/contrib/graphql/unified_trace.rb

@@ -11,14 +11,7 @@ module Datadog
         # which is required to use features such as API Catalog.
         # DEV-3.0: This tracer should be the default one in the next major version.
         module UnifiedTrace
-          # @param analytics_enabled [Boolean] Deprecated
-          # @param analytics_sample_rate [Float] Deprecated
-          # @param service [String|nil] The service name to be set on the spans
-          def initialize(*args, analytics_enabled: false, analytics_sample_rate: 1.0, service: nil, **kwargs)
-            @analytics_enabled = analytics_enabled
-            @analytics_sample_rate = analytics_sample_rate
-
-            @service_name = service
+          def initialize(*args, **kwargs)
             @has_prepare_span = respond_to?(:prepare_span)
             super
           end
@@ -139,7 +132,18 @@ module Datadog
           private
 
           def trace(callable, trace_key, resource, **kwargs)
-            Tracing.trace("graphql.#{trace_key}", resource: resource, service: @service_name, type: 'graphql') do |span|
+            config = Datadog.configuration.tracing[:graphql]
+
+            Tracing.trace(
+              "graphql.#{trace_key}",
+              type: 'graphql',
+              resource: resource,
+              service: config[:service_name]
+            ) do |span|
+              if Contrib::Analytics.enabled?(config[:analytics_enabled])
+                Contrib::Analytics.set_sample_rate(span, config[:analytics_sample_rate])
+              end
+
               yield(span) if block_given?
 
               prepare_span(trace_key, kwargs, span) if @has_prepare_span

data/lib/datadog/tracing/contrib/graphql/unified_trace_patcher.rb

@@ -12,12 +12,15 @@ module Datadog
         module UnifiedTracePatcher
           module_function
 
-          def patch!(schemas, options)
+          # TODO: `GraphQL::Schema.trace_with` and `YOUR_SCHEMA.trace_with` don't mix.
+          # TODO: They create duplicate spans when combined.
+          # TODO: We should measure how frequently users use `YOUR_SCHEMA.trace_with`, and hopefully we can remove it.
+          def patch!(schemas)
             if schemas.empty?
-              ::GraphQL::Schema.trace_with(UnifiedTrace, **options)
+              ::GraphQL::Schema.trace_with(UnifiedTrace)
             else
               schemas.each do |schema|
-                schema.trace_with(UnifiedTrace, **options)
+                schema.trace_with(UnifiedTrace)
               end
             end
           end

data/lib/datadog/tracing/contrib/http/instrumentation.rb

@@ -6,6 +6,7 @@ require_relative '../../metadata/ext'
 require_relative '../analytics'
 require_relative '../http_annotation_helper'
 require_relative '../utils/quantization/http'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -30,23 +31,19 @@ module Datadog
               return super(req, body, &block) if Contrib::HTTP.should_skip_tracing?(req)
 
               Tracing.trace(Ext::SPAN_REQUEST, on_error: method(:annotate_span_with_error!)) do |span, trace|
-                begin
-                  span.service = service_name(host, request_options, client_config)
-                  span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
-                  span.resource = req.method
-
-                  if Tracing.enabled? && !Contrib::HTTP.should_skip_distributed_tracing?(client_config)
-                    Contrib::HTTP.inject(trace, req)
-                  end
-
-                  # Add additional request specific tags to the span.
-                  annotate_span_with_request!(span, req, request_options)
-                rescue StandardError => e
-                  Datadog.logger.error("error preparing span for http request: #{e}")
-                ensure
-                  response = super(req, body, &block)
+                span.service = service_name(host, request_options, client_config)
+                span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
+                span.resource = req.method
+
+                if Tracing.enabled? && !Contrib::HTTP.should_skip_distributed_tracing?(client_config)
+                  Contrib::HTTP.inject(trace, req)
                 end
 
+                # Add additional request specific tags to the span.
+                annotate_span_with_request!(span, req, request_options)
+
+                response = super(req, body, &block)
+
                 # Add additional response specific tags to the span.
                 annotate_span_with_response!(span, response, request_options)
 
@@ -91,6 +88,9 @@ module Datadog
               )
 
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+            rescue StandardError => e
+              Datadog.logger.error("error preparing span from http request: #{e}")
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def annotate_span_with_response!(span, response, request_options)
@@ -103,6 +103,9 @@ module Datadog
               span.set_tags(
                 Datadog.configuration.tracing.header_tags.response_tags(response)
               )
+            rescue StandardError => e
+              Datadog.logger.error("error preparing span from http response: #{e}")
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def annotate_span_with_error!(span, error)

data/lib/datadog/tracing/contrib/httpclient/instrumentation.rb

@@ -4,6 +4,7 @@ require_relative '../../metadata/ext'
 require_relative '../http'
 require_relative '../analytics'
 require_relative '../http_annotation_helper'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -36,7 +37,8 @@ module Datadog
                   # Add additional request specific tags to the span.
                   annotate_span_with_request!(span, req, request_options)
                 rescue StandardError => e
-                  logger.error("error preparing span for httpclient request: #{e}, Source: #{e.backtrace}")
+                  Datadog.logger.error("error preparing span for httpclient request: #{e}, Source: #{e.backtrace}")
+                  Datadog::Core::Telemetry::Logger.report(e)
                 ensure
                   res = super
                 end
@@ -100,6 +102,9 @@ module Datadog
               span.set_tags(
                 Datadog.configuration.tracing.header_tags.response_tags(response.header)
               )
+            rescue StandardError => e
+              Datadog.logger.error("error preparing span from httpclient response: #{e}, Source: #{e.backtrace}")
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def annotate_span_with_error!(span, error)
@@ -114,10 +119,6 @@ module Datadog
               Contrib::Analytics.enabled?(request_options[:analytics_enabled])
             end
 
-            def logger
-              Datadog.logger
-            end
-
             def should_skip_distributed_tracing?(client_config)
               return !client_config[:distributed_tracing] if client_config && client_config.key?(:distributed_tracing)
 

data/lib/datadog/tracing/contrib/httpclient/patcher.rb

@@ -13,27 +13,14 @@ module Datadog
         module Patcher
           include Contrib::Patcher
 
-          PATCH_ONLY_ONCE = Core::Utils::OnlyOnce.new
-
           module_function
 
-          def patched?
-            PATCH_ONLY_ONCE.ran?
-          end
-
           def target_version
             Integration.version
           end
 
-          # patch applies our patch
           def patch
-            PATCH_ONLY_ONCE.run do
-              begin
-                ::HTTPClient.include(Instrumentation)
-              rescue StandardError => e
-                Datadog.logger.error("Unable to apply httpclient integration: #{e}")
-              end
-            end
+            ::HTTPClient.include(Instrumentation)
           end
         end
       end

data/lib/datadog/tracing/contrib/httprb/instrumentation.rb

@@ -4,6 +4,7 @@ require_relative '../../metadata/ext'
 require_relative '../http'
 require_relative '../analytics'
 require_relative '../http_annotation_helper'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -35,6 +36,7 @@ module Datadog
                   annotate_span_with_request!(span, req, request_options)
                 rescue StandardError => e
                   logger.error("error preparing span for http.rb request: #{e}, Source: #{e.backtrace}")
+                  Datadog::Core::Telemetry::Logger.report(e)
                 ensure
                   res = super(req, options)
                 end
@@ -108,6 +110,9 @@ module Datadog
               span.set_tags(
                 Datadog.configuration.tracing.header_tags.response_tags(response.headers)
               )
+            rescue StandardError => e
+              logger.error("error preparing span from http.rb response: #{e}, Source: #{e.backtrace}")
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def annotate_span_with_error!(span, error)

data/lib/datadog/tracing/contrib/httprb/patcher.rb

@@ -13,27 +13,14 @@ module Datadog
         module Patcher
           include Contrib::Patcher
 
-          PATCH_ONLY_ONCE = Core::Utils::OnlyOnce.new
-
           module_function
 
-          def patched?
-            PATCH_ONLY_ONCE.ran?
-          end
-
           def target_version
             Integration.version
           end
 
-          # patch applies our patch
           def patch
-            PATCH_ONLY_ONCE.run do
-              begin
-                ::HTTP::Client.include(Instrumentation)
-              rescue StandardError => e
-                Datadog.logger.error("Unable to apply httprb integration: #{e}")
-              end
-            end
+            ::HTTP::Client.include(Instrumentation)
           end
         end
       end

data/lib/datadog/tracing/contrib/lograge/patcher.rb

@@ -24,8 +24,7 @@ module Datadog
             if defined?(::ActiveSupport::TaggedLogging::Formatter) &&
                 ::Lograge::LogSubscribers::ActionController
                     .logger&.formatter.is_a?(::ActiveSupport::TaggedLogging::Formatter)
-
-              Datadog.logger.error(
+              Datadog.logger.warn(
                 'Lograge and ActiveSupport::TaggedLogging (the default Rails log formatter) are not compatible: ' \
                   'Lograge does not account for Rails log tags, creating polluted logs and breaking log formatting. ' \
                   'Traces and Logs correlation may not work. ' \

data/lib/datadog/tracing/contrib/mongodb/subscribers.rb

@@ -70,6 +70,8 @@ module Datadog
 
             # set the resource with the quantized query
             span.resource = serialized_query
+          rescue StandardError => e
+            Datadog.logger.debug("error when handling MongoDB 'started' event: #{e}")
           end
           # rubocop:enable Metrics/AbcSize
 

data/lib/datadog/tracing/contrib/opensearch/patcher.rb

@@ -6,6 +6,7 @@ require_relative 'ext'
 require_relative '../ext'
 require_relative '../integration'
 require_relative '../patcher'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -81,6 +82,8 @@ module Datadog
                   Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
                 rescue StandardError => e
                   Datadog.logger.error(e.message)
+                  Datadog::Core::Telemetry::Logger.report(e)
+                  # TODO: Refactor the code to streamline the execution without ensure
                 ensure
                   begin
                     response = super
@@ -90,12 +93,16 @@ module Datadog
                     raise
                   end
                   # Set post-response tags
-                  span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
-                  if response.headers['content-length']
-                    span.set_tag(
-                      OpenSearch::Ext::TAG_RESPONSE_CONTENT_LENGTH,
-                      response.headers['content-length'].to_i
-                    )
+                  if response
+                    if response.respond_to?(:status)
+                      span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
+                    end
+                    if response.respond_to?(:headers) && (response.headers || {})['content-length']
+                      span.set_tag(
+                        OpenSearch::Ext::TAG_RESPONSE_CONTENT_LENGTH,
+                        response.headers['content-length'].to_i
+                      )
+                    end
                   end
                 end
               end

data/lib/datadog/tracing/contrib/patcher.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../core/utils/only_once'
+require_relative '../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -49,8 +50,8 @@ module Datadog
           # Processes patching errors. This default implementation logs the error and reports relevant metrics.
           # @param e [Exception]
           def on_patch_error(e)
-            # Log the error
             Datadog.logger.error("Failed to apply #{patch_name} patch. Cause: #{e} Location: #{Array(e.backtrace).first}")
+            Datadog::Core::Telemetry::Logger.report(e, description: "Failed to apply #{patch_name} patch")
 
             @patch_error_result = {
               type: e.class.name,

data/lib/datadog/tracing/contrib/presto/patcher.rb

@@ -13,22 +13,10 @@ module Datadog
         module Patcher
           include Contrib::Patcher
 
-          PATCH_ONLY_ONCE = Core::Utils::OnlyOnce.new
-
           module_function
 
-          def patched?
-            PATCH_ONLY_ONCE.ran?
-          end
-
           def patch
-            PATCH_ONLY_ONCE.run do
-              begin
-                ::Presto::Client::Client.include(Instrumentation::Client)
-              rescue StandardError => e
-                Datadog.logger.error("Unable to apply Presto integration: #{e}")
-              end
-            end
+            ::Presto::Client::Client.include(Instrumentation::Client)
           end
         end
       end

data/lib/datadog/tracing/contrib/rack/middlewares.rb

@@ -138,6 +138,29 @@ module Datadog
             request_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
             request_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
 
+            if status != 404 && (last_route = trace.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE))
+              last_script_name = trace.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH) || ''
+
+              # If the last_script_name is empty but the env['SCRIPT_NAME'] is NOT empty
+              # then the current rack request was not routed and must be accounted for
+              # which only happens in pure nested rack requests i.e /rack/rack/hello/world
+              #
+              # To account for the unaccounted nested rack requests of /rack/hello/world,
+              # we use 'PATH_INFO knowing that rack cannot have named parameters
+              if last_script_name == '' && env['SCRIPT_NAME'] && env['SCRIPT_NAME'] != ''
+                last_script_name = last_route
+                last_route = env['PATH_INFO']
+              end
+
+              # Clear the route and route path tags from the request trace to avoid possibility of misplacement
+              trace.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE)
+              trace.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH)
+
+              # Ensure tags are placed in rack.request span as desired
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, last_script_name + last_route)
+              request_span.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH)
+            end
+
             # Set analytics sample rate
             if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
               Contrib::Analytics.set_sample_rate(request_span, configuration[:analytics_sample_rate])
@@ -195,6 +218,10 @@ module Datadog
               request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT, user_agent)
             end
 
+            if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE).nil? && status != 404
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, env['PATH_INFO'])
+            end
+
             HeaderTagging.tag_request_headers(request_span, request_header_collection, configuration)
             HeaderTagging.tag_response_headers(request_span, headers, configuration) if headers
 

data/lib/datadog/tracing/contrib/redis/tags.rb

@@ -4,6 +4,7 @@ require_relative '../../metadata/ext'
 require_relative '../analytics'
 require_relative 'ext'
 require_relative '../ext'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -45,6 +46,9 @@ module Datadog
               span.set_tag Ext::TAG_RAW_COMMAND, raw_command
 
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+            rescue StandardError => e
+              Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             private

data/lib/datadog/tracing/contrib/sinatra/tracer.rb

@@ -69,6 +69,10 @@ module Datadog
 
                 trace.resource = span.resource
 
+                _, path = env['sinatra.route'].split(' ', 2)
+                trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, path)
+                trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, env['SCRIPT_NAME'])
+
                 sinatra_request_span = Sinatra::Env.datadog_span(env)
 
                 sinatra_request_span.resource = span.resource

data/lib/datadog/tracing/contrib/stripe/request.rb

@@ -47,8 +47,9 @@ module Datadog
 
             # Measure service stats
             Contrib::Analytics.set_measured(span)
-
-            span.set_tag(Ext::TAG_REQUEST_ID, event.request_id)
+            # `5.38.0` Add request_id to RequestEndEvent
+            # https://github.com/stripe/stripe-ruby/blob/master/CHANGELOG.md#5380---2021-08-10
+            span.set_tag(Ext::TAG_REQUEST_ID, event.request_id) if event.respond_to?(:request_id)
             span.set_tag(Ext::TAG_REQUEST_HTTP_STATUS, event.http_status.to_s)
             span.set_tag(Ext::TAG_REQUEST_METHOD, event.method)
             span.set_tag(Ext::TAG_REQUEST_PATH, event.path)

data/lib/datadog/tracing/distributed/propagation.rb

@@ -3,6 +3,7 @@
 require_relative '../configuration/ext'
 require_relative '../trace_digest'
 require_relative '../trace_operation'
+require_relative '../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -43,6 +44,7 @@ module Datadog
         # DEV-2.0: if needed.
         # DEV-2.0: Ideally, we'd have a separate stream to report tracer errors and never
         # DEV-2.0: touch the active span.
+        # DEV-3.0: Sample trace here instead of when generating digest.
         #
         # @param digest [TraceDigest]
         # @param data [Hash]
@@ -72,6 +74,10 @@ module Datadog
             ::Datadog.logger.error(
               "Error injecting distributed trace data. Cause: #{e} Location: #{Array(e.backtrace).first}"
             )
+            ::Datadog::Core::Telemetry::Logger.report(
+              e,
+              description: "Error injecting distributed trace data with #{propagator.class.name}"
+            )
           end
 
           result
@@ -127,6 +133,7 @@ module Datadog
               )
             end
           rescue => e
+            # TODO: Not to report Telemetry logs for now
             ::Datadog.logger.error(
               "Error extracting distributed trace data. Cause: #{e} Location: #{Array(e.backtrace).first}"
             )

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

@@ -87,6 +87,8 @@ module Datadog
           TAG_STATUS_CODE = 'http.status_code'
           TAG_USER_AGENT = 'http.useragent'
           TAG_URL = 'http.url'
+          TAG_ROUTE = 'http.route'
+          TAG_ROUTE_PATH = 'http.route.path'
           TYPE_INBOUND = AppTypes::TYPE_WEB.freeze
           TYPE_OUTBOUND = 'http'
           TYPE_PROXY = 'proxy'

data/lib/datadog/tracing/remote.rb

@@ -13,7 +13,10 @@ module Datadog
         PRODUCT = 'APM_TRACING'
 
         CAPABILITIES = [
-          1 << 29 # APM_TRACING_SAMPLE_RULES: Dynamic trace sampling rules configuration
+          1 << 12, # APM_TRACING_SAMPLE_RATE: Dynamic trace sampling rate configuration
+          1 << 13, # APM_TRACING_LOGS_INJECTION: Dynamic trace logs injection configuration
+          1 << 14, # APM_TRACING_HTTP_HEADER_TAGS: Dynamic trace HTTP header tags configuration
+          1 << 29, # APM_TRACING_SAMPLE_RULES: Dynamic trace sampling rules configuration
         ].freeze
 
         def products
@@ -45,7 +48,7 @@ module Datadog
           content.errored("#{e.class.name} #{e.message}: #{Array(e.backtrace).join("\n")}")
         end
 
-        def receivers
+        def receivers(_telemetry)
           receiver do |repository, _changes|
             # DEV: Filter our by product. Given it will be very common
             # DEV: we can filter this out before we receive the data in this method.

data/lib/datadog/tracing/sampling/matcher.rb

@@ -28,7 +28,7 @@ module Datadog
         # @return [#match?(String)]
         def self.glob_to_regex(glob)
           # Optimization for match-all case
-          return MATCH_ALL if glob == MATCH_ALL_PATTERN
+          return MATCH_ALL if /\A\*+\z/.match?(glob)
 
           # Ensure no undesired characters are treated as regex.
           glob = Regexp.quote(glob)
@@ -100,6 +100,11 @@ module Datadog
           @tags.all? do |name, matcher|
             tag = trace.get_tag(name)
 
+            # Floats: Matching floating point values with a non-zero decimal part is not supported.
+            # For floating point values with a non-zero decimal part, any all * pattern always returns true.
+            # Other patterns always return false.
+            return false if tag.is_a?(Float) && tag.truncate != tag && matcher != MATCH_ALL
+
             # Format metrics as strings, to allow for partial number matching (/4.*/ matching '400', '404', etc.).
             # Because metrics are floats, we use the '%g' format specifier to avoid trailing zeros, which
             # can affect exact string matching (e.g. '400' matching '400.0').

data/lib/datadog/tracing/sampling/rate_sampler.rb

@@ -20,7 +20,7 @@ module Datadog
           super()
 
           unless sample_rate >= 0.0 && sample_rate <= 1.0
-            Datadog.logger.error('sample rate is not between 0 and 1, falling back to 1')
+            Datadog.logger.warn('sample rate is not between 0 and 1, falling back to 1')
             sample_rate = 1.0
           end
 

data/lib/datadog/tracing/sampling/rule.rb

@@ -2,6 +2,7 @@
 
 require_relative 'matcher'
 require_relative 'rate_sampler'
+require_relative '../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -35,6 +36,7 @@ module Datadog
           Datadog.logger.error(
             "Matcher failed. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
+          Datadog::Core::Telemetry::Logger.report(e, description: 'Matcher failed')
           nil
         end
 

data/lib/datadog/tracing/sampling/rule_sampler.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 require_relative 'ext'
-require_relative 'rate_limiter'
+require_relative '../../core/rate_limiter'
 require_relative 'rule'
+require_relative '../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -32,9 +33,9 @@ module Datadog
           @rate_limiter = if rate_limiter
                             rate_limiter
                           elsif rate_limit
-                            TokenBucket.new(rate_limit)
+                            Core::TokenBucket.new(rate_limit)
                           else
-                            UnlimitedLimiter.new
+                            Core::UnlimitedLimiter.new
                           end
 
           @default_sampler = if default_sampler
@@ -80,9 +81,10 @@ module Datadog
 
           new(parsed_rules, rate_limit: rate_limit, default_sample_rate: default_sample_rate)
         rescue => e
-          Datadog.logger.error do
+          Datadog.logger.warn do
             "Could not parse trace sampling rules '#{rules}': #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
           end
+
           nil
         end
 
@@ -121,7 +123,7 @@ module Datadog
 
           return false unless sampled
 
-          rate_limiter.allow?(1).tap do |allowed|
+          rate_limiter.allow?.tap do |allowed|
             set_priority(trace, allowed)
             set_limiter_metrics(trace, rate_limiter.effective_rate)
 
@@ -140,6 +142,8 @@ module Datadog
           Datadog.logger.error(
             "Rule sampling failed. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
+          Datadog::Core::Telemetry::Logger.report(e, description: 'Rule sampling failed')
+
           yield(trace)
         end
 

data/lib/datadog/tracing/sampling/span/ext.rb

@@ -9,7 +9,7 @@ module Datadog
           # Accept all spans (100% retention).
           DEFAULT_SAMPLE_RATE = 1.0
           # Unlimited.
-          # @see Datadog::Tracing::Sampling::TokenBucket
+          # @see Datadog::Core::TokenBucket
           DEFAULT_MAX_PER_SECOND = -1
 
           # Sampling decision method used to come to the sampling decision for this span

data/lib/datadog/tracing/sampling/span/rule.rb

@@ -30,7 +30,7 @@ module Datadog
             @rate_limit = rate_limit
 
             @sampler = Sampling::RateSampler.new(sample_rate)
-            @rate_limiter = Sampling::TokenBucket.new(rate_limit)
+            @rate_limiter = Core::TokenBucket.new(rate_limit)
           end
 
           # This method should only be invoked for spans that are part
@@ -54,7 +54,7 @@ module Datadog
           def sample!(trace_op, span_op)
             return :not_matched unless @matcher.match?(span_op)
 
-            if @rate_limiter.allow?(1) && @sampler.sample!(trace_op)
+            if @rate_limiter.allow? && @sampler.sample!(trace_op)
               span_op.set_metric(Span::Ext::TAG_MECHANISM, Sampling::Ext::Mechanism::SPAN_SAMPLING_RATE)
               span_op.set_metric(Span::Ext::TAG_RULE_RATE, @sample_rate)
               span_op.set_metric(Span::Ext::TAG_MAX_PER_SECOND, @rate_limit)