datadog 2.21.0 → 2.38.0

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative '../../core/utils'
+require_relative 'helpers'
+
 module Datadog
   module Tracing
     module Distributed
@@ -75,34 +78,6 @@ module Datadog
 
         private
 
-        # Refinements to ensure newer rubies do not suffer performance impact
-        # by needing to use older APIs.
-        module Refine
-          # Backport `Regexp::match?` because it is measurably the most performant
-          # way to check if a string matches a regular expression.
-          unless Regexp.method_defined?(:match?)
-            refine ::Regexp do
-              def match?(*args)
-                !match(*args).nil?
-              end
-            end
-          end
-
-          unless String.method_defined?(:delete_prefix)
-            refine ::String do
-              def delete_prefix(prefix)
-                prefix = prefix.to_s
-                if rindex(prefix, 0)
-                  self[prefix.length..-1]
-                else
-                  dup
-                end
-              end
-            end
-          end
-        end
-        using Refine
-
         # @see https://www.w3.org/TR/trace-context/#traceparent-header
         def build_traceparent(digest)
           build_traceparent_string(
@@ -149,9 +124,9 @@ module Datadog
         # @see https://www.w3.org/TR/trace-context/#tracestate-header
         def build_tracestate(digest)
           tracestate = +'dd='
-          tracestate << last_dd_parent_id(digest)
-          tracestate << "s:#{digest.trace_sampling_priority};" if digest.trace_sampling_priority
-          tracestate << "o:#{serialize_origin(digest.trace_origin)};" if digest.trace_origin
+          append_dd(tracestate, last_dd_parent_id(digest))
+          append_dd(tracestate, "s:#{digest.trace_sampling_priority};") if digest.trace_sampling_priority
+          append_dd(tracestate, "o:#{serialize_origin(digest.trace_origin)};") if digest.trace_origin
 
           # Replacing this by safe navigation seems to have a different behaviour on Rubies <= 3.0.
           # It cause a LocalJumpError in the CI.
@@ -159,45 +134,50 @@ module Datadog
             digest.trace_distributed_tags.each do |name, value|
               tag = "t.#{serialize_tag_key(name)}:#{serialize_tag_value(value)};"
 
-              # If tracestate size limit is exceed, drop the remaining data.
-              # String#bytesize is used because only ASCII characters are allowed.
-              #
-              # We add 1 to the limit because of the trailing comma, which will be removed before returning.
-              break if tracestate.bytesize + tag.bytesize > (TRACESTATE_VALUE_SIZE_LIMIT + 1)
-
-              tracestate << tag
+              # If tracestate size limit is exceeded, drop the remaining data.
+              break unless append_dd(tracestate, tag)
             end
           end
 
-          tracestate << digest.trace_state_unknown_fields if digest.trace_state_unknown_fields
+          append_dd(tracestate, digest.trace_state_unknown_fields) if digest.trace_state_unknown_fields
+          vendors = split_tracestate(digest.trace_state)
 
           # Is there any Datadog-specific information to propagate.
           # Check for > 3 size because the empty prefix `dd=` has 3 characters.
-          if tracestate.size > 3
+          if tracestate.bytesize > 3
             # Propagate upstream tracestate with `dd=...` appended to the list
             tracestate.chop! # Removes trailing `;` from Datadog trace state string.
 
-            if digest.trace_state
-              trace_state = digest.trace_state.strip
-
+            if vendors && !vendors.empty?
               # Delete existing `dd=` tracestate fields, if present.
-              vendors = split_tracestate(trace_state)
               vendors.reject! { |v| v.start_with?('dd=') }
-            end
 
-            if vendors && !vendors.empty?
               # Ensure the list has at most 31 elements, as we need to prepend Datadog's
               # entry and the limit is 32 elements total.
-              vendors = vendors[0..30]
-              "#{tracestate},#{vendors.join(",")}"
-            else
-              tracestate.to_s
+              vendors.first(TRACESTATE_MAX_LIST_MEMBERS - 1).each do |vendor|
+                break if tracestate.bytesize + vendor.bytesize + 1 > TRACESTATE_MAX_SIZE_LIMIT
+
+                tracestate << ',' << vendor
+              end
             end
-          else
-            digest.trace_state # Propagate upstream tracestate with no Datadog changes
+
+            tracestate.to_s
+          elsif vendors && !vendors.empty?
+            vendors.join(',')
           end
         end
 
+        # Appends a Datadog tracestate field when it fits.
+        def append_dd(tracestate, field)
+          return true if field.empty?
+
+          # We add 1 to the limit because of the trailing semicolon, which will be removed before returning.
+          return false if tracestate.bytesize + field.bytesize > (TRACESTATE_VALUE_SIZE_LIMIT + 1)
+
+          tracestate << field
+          true
+        end
+
         def last_dd_parent_id(digest)
           if !digest.span_remote
             span_id = digest.span_id || 0 # Fall back to zero (invalid) if not present
@@ -281,19 +261,21 @@ module Datadog
 
         def parse_traceparent_string(traceparent)
           return unless traceparent
+          return if traceparent.bytesize > TRACEPARENT_MAX_SIZE_LIMIT
+
+          traceparent = traceparent.strip
 
-          version, trace_id, parent_id, trace_flags, extra = traceparent.strip.split('-')
+          version, trace_id, parent_id, trace_flags, extra = traceparent.split('-', 5)
 
-          return if version.size != 2 || version[0] < '0' || version[0] > 'f' || version[1] < '0' || version[1] > 'f'
+          return unless version && trace_id && parent_id && trace_flags
+          return if version.size != 2 || trace_id.size != 32 || parent_id.size != 16 || trace_flags.size != 2
+          return if version[0] < '0' || version[0] > 'f' || version[1] < '0' || version[1] > 'f'
 
           return if version == INVALID_VERSION
 
           # Extra fields are not allowed in version 00, but we have to be lenient for future versions.
           return if version == SPEC_VERSION && extra
 
-          # Invalid field sizes
-          return if trace_id.size != 32 || parent_id.size != 16 || trace_flags.size != 2
-
           [Integer(trace_id, 16), Integer(parent_id, 16), Integer(trace_flags, 16)]
         rescue ArgumentError # Conversion to integer failed
           nil
@@ -303,12 +285,16 @@ module Datadog
           trace_flags & TRACE_FLAGS_SAMPLED
         end
 
-        # @return [Array<String,Integer,String,String,Hash>] returns 4 values:
-        # tracestate, sampling_priority, ts_parent_id, origin, tags.
+        # @return [nil] when the tracestate is absent or has no vendor entries.
+        # @return [String] when no `dd=` entry is present, the joined vendor list.
+        # @return [Array(String, Integer, String, String, Hash, String)] when a `dd=`
+        #   entry is present: [tracestate without `dd=`, sampling_priority, origin,
+        #   ts_parent_id, tags, unknown_fields]. All elements past the first may be nil.
         def extract_tracestate(tracestate)
-          return unless tracestate
-
           vendors = split_tracestate(tracestate)
+          return unless vendors && !vendors.empty?
+
+          tracestate = vendors.join(',')
 
           # Find Datadog's `dd=` tracestate field.
           idx = vendors.index { |v| v.start_with?('dd=') }
@@ -396,10 +382,47 @@ module Datadog
           end
         end
 
+        # We MUST NOT propagate partial members, but we SHOULD try
+        # to parse as much of the tracestate as possible.
         def split_tracestate(tracestate)
-          tracestate.split(/[ \t]*+,[ \t]*+/)[0..31]
+          return unless tracestate
+
+          remove_last_member = false
+          if tracestate.bytesize > TRACESTATE_MAX_SIZE_LIMIT
+            # We parse 1 byte over the limit to detect if the last member
+            # is a partial member (toss) or ends exactly at the limit (keep).
+            remove_last_member = tracestate.byteslice(TRACESTATE_MAX_SIZE_LIMIT, 1) != ','
+
+            # To ensure we don't have a trailing partial UTF-8 codepoint, we keep one extra byte
+            # and safely remove it with `#chop`.
+            # `#chop` walks back the string until it finds a valid character boundary and deletes
+            # from there.
+            tracestate = tracestate.byteslice(0, TRACESTATE_MAX_SIZE_LIMIT + 1) #: String
+            tracestate = tracestate.chop
+          end
+
+          tracestate = ::Datadog::Core::Utils.utf8_encode(tracestate, placeholder: nil)
+          return unless tracestate
+
+          vendors = tracestate.split(',', TRACESTATE_MAX_LIST_MEMBERS + 1)
+          if vendors.length > TRACESTATE_MAX_LIST_MEMBERS || remove_last_member
+            vendors.pop
+          end
+
+          vendors.each(&:strip!)
+          vendors.pop while vendors.last == ''
+          vendors
         end
 
+        TRACEPARENT_MAX_SIZE_LIMIT = 512
+        private_constant :TRACEPARENT_MAX_SIZE_LIMIT
+
+        TRACESTATE_MAX_SIZE_LIMIT = 512
+        private_constant :TRACESTATE_MAX_SIZE_LIMIT
+
+        TRACESTATE_MAX_LIST_MEMBERS = 32
+        private_constant :TRACESTATE_MAX_LIST_MEMBERS
+
         # Version 0xFF is invalid as per spec
         # @see https://www.w3.org/TR/trace-context/#version
         INVALID_VERSION = 'ff'

data/lib/datadog/tracing/event.rb

@@ -62,7 +62,7 @@ module Datadog
           block.call(*args)
         rescue => e
           Datadog.logger.debug do
-            "Error while handling '#{name}' event with '#{block}': #{e.class.name} #{e.message} " \
+            "Error while handling '#{name}' event with '#{block}': #{e.class}: #{e.message} " \
             "at #{Array(e.backtrace).first}"
           end
         end

data/lib/datadog/tracing/ext.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Ext
+      TELEMETRY_METRICS_NAMESPACE = 'tracers'
+    end
+  end
+end

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

@@ -33,6 +33,16 @@ module Datadog
 
         TAG_APM_ENABLED = '_dd.apm.enabled'
 
+        # Set to the global service name when a span's service is overridden
+        TAG_BASE_SERVICE = '_dd.base_service'
+
+        # Set to the source of a span's service override: the component name for Datadog-instrumented spans
+        # (e.g. 'redis', 'pg'), or {SVC_SRC_MANUAL} for manually-instrumented spans
+        TAG_SVC_SRC = '_dd.svc_src'
+
+        # Value for {TAG_SVC_SRC} indicating that a span was manually instrumented via the Tracing API
+        SVC_SRC_MANUAL = 'm'
+
         # Defines constants for trace analytics
         # @public_api
         module Analytics
@@ -66,6 +76,10 @@ module Datadog
           TAG_DD_PARENT_ID = '_dd.parent_id'
           DD_PARENT_ID_DEFAULT = '0000000000000000'
 
+          # Knuth Sampling Rate: the sampling rate applied by agent-based or rule-based sampling.
+          # This is a propagated tag (prefixed with `_dd.p.`) that is included in `x-datadog-tags`.
+          TAG_KNUTH_SAMPLING_RATE = '_dd.p.ksr'
+
           # Trace tags with this prefix will propagate from a trace through distributed tracing.
           # Distributed headers tags with this prefix will be injected into the active trace.
           TAGS_PREFIX = '_dd.p.'
@@ -82,12 +96,20 @@ module Datadog
           TAG_MSG = 'error.message'
           TAG_STACK = 'error.stack'
           TAG_TYPE = 'error.type'
+
+          # From https://opentelemetry.io/docs/specs/semconv/registry/attributes/exception/#exception-stacktrace
+          ATTRIBUTE_MESSAGE = 'exception.message'
+          ATTRIBUTE_STACKTRACE = 'exception.stacktrace'
+          ATTRIBUTE_TYPE = 'exception.type'
+
+          # From https://opentelemetry.io/docs/specs/semconv/exceptions/exceptions-spans/#exception-event
+          EVENT_NAME = 'exception'
         end
 
         # @public_api
         module HTTP
-          ERROR_RANGE = (500...600).freeze
           TAG_BASE_URL = 'http.base_url'
+          TAG_ENDPOINT = 'http.endpoint'
           TAG_METHOD = 'http.method'
           TAG_STATUS_CODE = 'http.status_code'
           TAG_USER_AGENT = 'http.useragent'

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

@@ -52,7 +52,7 @@ module Datadog
             meta[Core::Utils.utf8_encode(key)] = Core::Utils.utf8_encode(value)
           end
         rescue => e
-          Datadog.logger.debug("Unable to set the tag #{key}, ignoring it. Caused by: #{e}")
+          Datadog.logger.debug("Unable to set the tag #{key}, ignoring it. Caused by: #{e.class}: #{e.message}")
         end
 
         # Sets tags from given hash, for each key in hash it sets the tag with that key
@@ -102,7 +102,7 @@ module Datadog
           # Encode strings in UTF-8 to facilitate downstream serialization
           metrics[Core::Utils.utf8_encode(key)] = value
         rescue => e
-          Datadog.logger.debug("Unable to set the metric #{key}, ignoring it. Caused by: #{e}")
+          Datadog.logger.debug("Unable to set the metric #{key}, ignoring it. Caused by: #{e.class}: #{e.message}")
         end
 
         # This method removes a metric for the given key. It acts like {#clear_tag}.

data/lib/datadog/tracing/pipeline.rb

@@ -51,7 +51,7 @@ module Datadog
         end
       rescue => e
         Datadog.logger.debug(
-          "trace dropped entirely due to `Pipeline.before_flush` error: #{e}"
+          "trace dropped entirely due to `Pipeline.before_flush` error: #{e.class}: #{e.message}"
         )
 
         nil

data/lib/datadog/tracing/remote.rb

@@ -7,8 +7,6 @@ module Datadog
   module Tracing
     # Remote configuration declaration
     module Remote
-      class ReadError < StandardError; end
-
       class << self
         PRODUCT = 'APM_TRACING'
 
@@ -17,6 +15,9 @@ module Datadog
           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
+          # APM_TRACING_ENABLE_DYNAMIC_INSTRUMENTATION (bit 38) is declared in
+          # DI::Remote.capabilities, not here, so it is registered only when DI
+          # is not explicitly disabled and the runtime supports DI.
         ].freeze
 
         def products
@@ -27,7 +28,7 @@ module Datadog
           CAPABILITIES
         end
 
-        def process_config(config, content)
+        def process_config(config, content, repository = nil)
           lib_config = config['lib_config']
 
           env_vars = Datadog::Tracing::Configuration::Dynamic::OPTIONS.map do |name, env_var, option|
@@ -41,11 +42,39 @@ module Datadog
             [env_var, value]
           end
 
+          if (di_enabled = lib_config['dynamic_instrumentation_enabled']) != nil # rubocop:disable Style/NonNilCheck
+            # repository is forwarded so that an enable signal can reconcile DI
+            # against probes delivered in an earlier poll while DI was stopped
+            # (see Datadog::DI::Remote.handle_rc_enablement).
+            Datadog::DI::Remote.handle_rc_enablement(di_enabled, repository)
+
+            if di_enabled
+              # DI was just (implicitly) enabled. A Symbol Database upload signal
+              # received in an earlier poll while DI was inactive was deferred by
+              # the component's DI-active gate; re-attempt it now. Mirrors the DI
+              # probe replay in handle_rc_enablement above. allow_initialization:
+              # false because this runs on the remote-config worker thread.
+              Datadog.send(:components, allow_initialization: false)&.symbol_database&.resume_pending_upload
+            else
+              # DI was disabled via remote configuration. In the nil-default
+              # (follows-DI) case, stop Symbol Database too so its TracePoint and
+              # scheduler don't keep uploading while DI is off. An explicit
+              # symbol_database.enabled = true is independent and keeps running.
+              Datadog.send(:components, allow_initialization: false)&.symbol_database&.stop_for_di_disable
+            end
+          end
+
           content.applied
 
-          Datadog.send(:components).telemetry.client_configuration_change!(env_vars)
+          # allow_initialization: false because process_config runs on the
+          # remote-config worker thread. If components haven't been built yet
+          # (e.g. during a teardown/reset window), the default `true` would
+          # synchronously build the entire component tree from this thread.
+          # The &. chain matches the pattern used by DI::Remote.handle_rc_enablement
+          # in the same dispatch path.
+          Datadog.send(:components, allow_initialization: false)&.telemetry&.client_configuration_change!(env_vars)
         rescue => e
-          content.errored("#{e.class.name} #{e.message}: #{Array(e.backtrace).join("\n")}")
+          content.errored("#{e.class}: #{e.message}: #{Array(e.backtrace).join("\n")}")
         end
 
         def receivers(_telemetry)
@@ -57,7 +86,7 @@ module Datadog
               case content.path.product
               when PRODUCT
                 config = parse_content(content)
-                process_config(config, content)
+                process_config(config, content, repository)
               end
             end
           end
@@ -71,13 +100,7 @@ module Datadog
         private
 
         def parse_content(content)
-          data = content.data.read
-
-          content.data.rewind
-
-          raise ReadError, 'EOF reached' if data.nil?
-
-          JSON.parse(data)
+          JSON.parse(content.data)
         end
       end
     end

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

@@ -47,6 +47,8 @@ module Datadog
           MANUAL = '-4'
           # Formerly AppSec.
           ASM = '-5'
+          # AI Guard.
+          AI_GUARD = '-13'
           # Dynamically configured rule, explicitly created by the user.
           REMOTE_USER_RULE = '-11'
           # Dynamically configured  rule, automatically generated by Datadog.

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

@@ -60,7 +60,9 @@ module Datadog
         ensure
           if trace.sampling_priority && trace.sampling_priority > 0
             # Don't modify decision if priority was set upstream.
-            if !distributed_sampling_priority && !trace.has_tag?(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
+            # Steep: https://github.com/soutaro/steep/issues/1971
+            if !distributed_sampling_priority && # steep:ignore FallbackAny
+                !trace.has_tag?(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
               # If no sampling priority being assigned at this point, a custom
               # sampler implementation is configured: this means the user has
               # full control over the sampling decision.
@@ -75,6 +77,19 @@ module Datadog
           end
         end
 
+        def reconsider_sample_resource!(trace)
+          return unless @priority_sampler.respond_to?(:reconsider_sample_resource!)
+
+          preserving_sampling(trace) do
+            @priority_sampler.reconsider_sample_resource!(trace)
+          end
+        end
+
+        def resource_sampling?
+          @priority_sampler.respond_to?(:resource_sampling?) &&
+            @priority_sampler.resource_sampling?
+        end
+
         # (see Datadog::Tracing::Sampling::RateByServiceSampler#update)
         def update(rate_by_service, decision: nil)
           @priority_sampler.update(rate_by_service, decision: decision)

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'sampler'
-require_relative '../utils'
+require_relative '../../core/knuth_sampler'
 
 module Datadog
   module Tracing
@@ -9,46 +9,35 @@ module Datadog
       # {Datadog::Tracing::Sampling::RateSampler} is based on a sample rate.
       class RateSampler < Sampler
         KNUTH_FACTOR = 1111111111111111111
-        UINT64_MODULO = (1 << 64)
 
         # Initialize a {Datadog::Tracing::Sampling::RateSampler}.
         # This sampler keeps a random subset of the traces. Its main purpose is to
         # reduce the instrumentation footprint.
         #
         # @param sample_rate [Numeric] the sample rate between 0.0 and 1.0, inclusive.
-        #   0.0 means that no trace will be sampled; 1.0 means that all traces will be  sampled.
+        #   0.0 means that no trace will be sampled; 1.0 means that all traces will be sampled.
         def initialize(sample_rate = 1.0, decision: nil)
           super()
-
-          unless sample_rate >= 0.0 && sample_rate <= 1.0
-            Datadog.logger.warn('sample rate is not between 0 and 1, falling back to 1')
-            sample_rate = 1.0
-          end
-
-          self.sample_rate = sample_rate
-
+          @sampler = Core::KnuthSampler.new(sample_rate, knuth_factor: KNUTH_FACTOR)
           @decision = decision
         end
 
         def sample_rate(*_)
-          @sample_rate
+          @sampler.rate
         end
 
         def sample_rate=(sample_rate)
-          @sample_rate = sample_rate
-          @sampling_id_threshold = sample_rate * Tracing::Utils::EXTERNAL_MAX_ID
+          @sampler = Core::KnuthSampler.new(sample_rate, knuth_factor: KNUTH_FACTOR)
         end
 
         def sample?(trace)
-          ((trace.id * KNUTH_FACTOR) % UINT64_MODULO) <= @sampling_id_threshold
+          @sampler.sample?(trace.id)
         end
 
         def sample!(trace)
-          sampled = sample?(trace)
-
-          return false unless sampled
+          return false unless sample?(trace)
 
-          trace.sample_rate = @sample_rate
+          trace.sample_rate = sample_rate
           trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, @decision) if @decision
 
           true

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

@@ -34,7 +34,7 @@ module Datadog
           @matcher.match?(trace)
         rescue => e
           Datadog.logger.error(
-            "Matcher failed. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+            "Matcher failed. Cause: #{e.class}: #{e.message} Source: #{Array(e.backtrace).first}"
           )
           Datadog::Core::Telemetry::Logger.report(e, description: 'Matcher failed')
           nil

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

@@ -50,6 +50,7 @@ module Datadog
             # TODO: Simplify .tags access, as `Tracer#tags` can't be arbitrarily changed anymore
             RateByServiceSampler.new(1.0, env: -> { Tracing.send(:tracer).tags['env'] })
           end
+          @reconsider_sample_resource_enabled = @rules.any? { |rule| resource_rule?(rule) }
         end
 
         def self.parse(rules, rate_limit, default_sample_rate)
@@ -84,7 +85,7 @@ module Datadog
           new(parsed_rules, rate_limit: rate_limit, default_sample_rate: default_sample_rate)
         rescue => e
           Datadog.logger.warn do
-            "Could not parse trace sampling rules '#{rules}': #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+            "Could not parse trace sampling rules '#{rules}': #{e.class}: #{e.message} at #{Array(e.backtrace).first}"
           end
 
           nil
@@ -103,6 +104,18 @@ module Datadog
           trace.sampled = sampled
         end
 
+        def reconsider_sample_resource!(trace)
+          rule = @rules.find { |r| resource_rule?(r) && r.match?(trace) }
+          return if rule.nil?
+
+          reconsider_matching_rule!(trace, rule)
+        end
+
+        # Do any rules match on the resource name?
+        def resource_sampling?
+          @reconsider_sample_resource_enabled
+        end
+
         # @!visibility private
         def update(*args, **kwargs)
           return false unless @default_sampler.respond_to?(:update)
@@ -117,32 +130,10 @@ module Datadog
 
           return yield(trace) if rule.nil?
 
-          sampled = rule.sample!(trace)
-          sample_rate = rule.sample_rate(trace)
-
-          set_priority(trace, sampled)
-          set_rule_metrics(trace, sample_rate)
-
-          return false unless sampled
-
-          rate_limiter.allow?.tap do |allowed|
-            set_priority(trace, allowed)
-            set_limiter_metrics(trace, rate_limiter.effective_rate)
-
-            provenance = case rule.provenance
-            when Rule::PROVENANCE_REMOTE_USER
-              Ext::Decision::REMOTE_USER_RULE
-            when Rule::PROVENANCE_REMOTE_DYNAMIC
-              Ext::Decision::REMOTE_DYNAMIC_RULE
-            else
-              Ext::Decision::TRACE_SAMPLING_RULE
-            end
-
-            trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, provenance)
-          end
+          apply_rule!(trace, rule)
         rescue => e
           Datadog.logger.error(
-            "Rule sampling failed. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+            "Rule sampling failed. Cause: #{e.class}: #{e.message} Source: #{Array(e.backtrace).first}"
           )
           Datadog::Core::Telemetry::Logger.report(e, description: 'Rule sampling failed')
 
@@ -166,6 +157,44 @@ module Datadog
         def set_limiter_metrics(trace, limiter_rate)
           trace.rate_limiter_rate = limiter_rate
         end
+
+        def apply_rule!(trace, rule)
+          sampled = rule.sample!(trace)
+          sample_rate = rule.sample_rate(trace)
+
+          set_priority(trace, sampled)
+          set_rule_metrics(trace, sample_rate)
+
+          return false unless sampled
+
+          rate_limiter.allow?.tap do |allowed|
+            set_priority(trace, allowed)
+            set_limiter_metrics(trace, rate_limiter.effective_rate)
+            trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, provenance_for(rule))
+          end
+        end
+
+        def provenance_for(rule)
+          case rule.provenance
+          when Rule::PROVENANCE_REMOTE_USER
+            Ext::Decision::REMOTE_USER_RULE
+          when Rule::PROVENANCE_REMOTE_DYNAMIC
+            Ext::Decision::REMOTE_DYNAMIC_RULE
+          else
+            Ext::Decision::TRACE_SAMPLING_RULE
+          end
+        end
+
+        def resource_rule?(rule)
+          matcher = rule.matcher
+          matcher.respond_to?(:resource) && matcher.resource != Matcher::MATCH_ALL
+        end
+
+        def reconsider_matching_rule!(trace, rule)
+          trace.agent_sample_rate = nil
+          trace.clear_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
+          apply_rule!(trace, rule)
+        end
       end
     end
   end

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

@@ -29,7 +29,7 @@ module Datadog
               rescue => e
                 Datadog.logger.warn(
                   "Error parsing Span Sampling Rules `#{rules.inspect}`: " \
-                  "#{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+                  "#{e.class}: #{e.message} at #{Array(e.backtrace).first}"
                 )
                 return nil
               end
@@ -61,7 +61,7 @@ module Datadog
                 rescue => e
                   Datadog.logger.warn(
                     "Cannot parse Span Sampling Rule #{hash.inspect}: " \
-                    "#{e.class.name} #{e} at #{Array(e.backtrace).first}"
+                    "#{e.class}: #{e.message} at #{Array(e.backtrace).first}"
                   )
                   return nil
                 end

data/lib/datadog/tracing/span.rb

@@ -80,7 +80,7 @@ module Datadog
 
         @meta = meta || {}
         @metrics = metrics || {}
-        @metastruct = metastruct || {}
+        @metastruct = metastruct || Metastruct.new
         @status = status || 0
 
         # start_time and end_time track wall clock. In Ruby, wall clock