ddtrace 1.1.0 → 1.12.1

data/lib/datadog/tracing/metadata.rb

@@ -1,8 +1,8 @@
-# typed: true
+# frozen_string_literal: true
 
-require 'datadog/tracing/metadata/analytics'
-require 'datadog/tracing/metadata/tagging'
-require 'datadog/tracing/metadata/errors'
+require_relative 'metadata/analytics'
+require_relative 'metadata/tagging'
+require_relative 'metadata/errors'
 
 module Datadog
   module Tracing

data/lib/datadog/tracing/pipeline/span_filter.rb

@@ -1,7 +1,7 @@
-# typed: true
+# frozen_string_literal: true
 
 require 'set'
-require 'datadog/tracing/pipeline/span_processor'
+require_relative 'span_processor'
 
 module Datadog
   module Tracing
@@ -15,17 +15,21 @@ module Datadog
       #
       # @public_api
       class SpanFilter < SpanProcessor
-        # NOTE: this SpanFilter implementation only handles traces in which child spans appear
-        # after parent spans in the trace array. If in the future child spans can be before
+        # NOTE: This SpanFilter implementation only handles traces in which child spans appear
+        # before parent spans in the trace array. If in the future child spans can be after
         # parent spans, then the code below will need to be updated.
         # @!visibility private
         def call(trace)
           deleted = Set.new
 
-          trace.spans.delete_if do |span|
+          span_count = trace.spans.length
+          trace.spans.reverse_each.with_index do |span, i|
             should_delete = deleted.include?(span.parent_id) || drop_it?(span)
-            deleted << span.id if should_delete
-            should_delete
+
+            if should_delete
+              deleted << span.id
+              trace.spans.delete_at(span_count - 1 - i)
+            end
           end
 
           trace

data/lib/datadog/tracing/pipeline/span_processor.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Tracing

data/lib/datadog/tracing/pipeline.rb

@@ -1,9 +1,5 @@
-# typed: true
-
-require 'datadog/core'
-
-require 'datadog/tracing/pipeline/span_filter'
-require 'datadog/tracing/pipeline/span_processor'
+require_relative 'pipeline/span_filter'
+require_relative 'pipeline/span_processor'
 
 module Datadog
   module Tracing

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

@@ -1,109 +1,14 @@
-# typed: false
+# frozen_string_literal: true
 
-require 'datadog/core'
-
-require 'datadog/tracing/configuration/ext'
-require 'datadog/tracing/sampling/ext'
-require 'datadog/tracing/distributed/headers/b3'
-require 'datadog/tracing/distributed/headers/b3_single'
-require 'datadog/tracing/distributed/headers/datadog'
-
-require 'datadog/tracing/trace_digest'
-require 'datadog/tracing/trace_operation'
+require_relative '../contrib/http/distributed/propagation'
 
 module Datadog
   module Tracing
     module Propagation
       # Propagation::HTTP helps extracting and injecting HTTP headers.
+      # DEV-2.0: This file has been moved to Contrib. Should be deleted in the next release.
       # @public_api
-      module HTTP
-        PROPAGATION_STYLES = {
-          Configuration::Ext::Distributed::PROPAGATION_STYLE_B3 => Distributed::Headers::B3,
-          Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER => Distributed::Headers::B3Single,
-          Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG => Distributed::Headers::Datadog
-        }.freeze
-
-        # inject! popolates the env with span ID, trace ID and sampling priority
-        def self.inject!(digest, env)
-          # Prevent propagation from being attempted if trace headers provided are nil.
-          if digest.nil?
-            Datadog.logger.debug(
-              'Cannot inject trace headers into env to propagate over HTTP: trace headers are nil.'.freeze
-            )
-            return
-          end
-
-          digest = digest.to_digest if digest.is_a?(TraceOperation)
-
-          # Inject all configured propagation styles
-          Datadog.configuration.tracing.distributed_tracing.propagation_inject_style.each do |style|
-            propagator = PROPAGATION_STYLES[style]
-            begin
-              propagator.inject!(digest, env) unless propagator.nil?
-            rescue => e
-              Datadog.logger.error(
-                'Error injecting propagated trace headers into the environment. ' \
-                "Cause: #{e} Location: #{Array(e.backtrace).first}"
-              )
-            end
-          end
-        end
-
-        # extract returns trace headers containing the span ID, trace ID and
-        # sampling priority defined in env.
-        def self.extract(env)
-          trace_digest = nil
-          dd_trace_digest = nil
-
-          Datadog.configuration.tracing.distributed_tracing.propagation_extract_style.each do |style|
-            propagator = PROPAGATION_STYLES[style]
-            next if propagator.nil?
-
-            # Extract trace headers
-            # DEV: `propagator.extract` will return `nil`, where `Propagation::HTTP#extract` will not
-            begin
-              extracted_trace_digest = propagator.extract(env)
-            rescue => e
-              Datadog.logger.error(
-                'Error extracting propagated trace headers from the environment. ' \
-                "Cause: #{e} Location: #{Array(e.backtrace).first}"
-              )
-            end
-
-            # Skip this style if no valid headers were found
-            next if extracted_trace_digest.nil?
-
-            # Keep track of the Datadog extract trace headers, we want to return
-            #   this one if we have one
-            if extracted_trace_digest && style == Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG
-              dd_trace_digest = extracted_trace_digest
-            end
-
-            # No previously extracted trace headers, use the one we just extracted
-            if trace_digest.nil?
-              trace_digest = extracted_trace_digest
-            else
-              unless trace_digest.trace_id == extracted_trace_digest.trace_id \
-                      && trace_digest.span_id == extracted_trace_digest.span_id
-                # Return an empty/new trace headers if we have a mismatch in values extracted
-                msg = "#{trace_digest.trace_id} != #{extracted_trace_digest.trace_id} && " \
-                      "#{trace_digest.span_id} != #{extracted_trace_digest.span_id}"
-                Datadog.logger.debug(
-                  "Cannot extract trace headers from HTTP: extracted trace headers differ, #{msg}"
-                )
-                # DEV: This will return from `self.extract` not this `each` block
-                return TraceDigest.new
-              end
-            end
-          end
-
-          # Return the extracted trace headers if we found one or else a new empty trace headers
-          # Always return the Datadog trace headers if one exists since it has more
-          #   information than the B3 headers e.g. origin, expanded priority
-          #   sampling values, etc
-          dd_trace_digest || trace_digest || nil
-        end
-      end
+      HTTP = Tracing::Contrib::HTTP::Distributed::Propagation.new
     end
   end
 end

data/lib/datadog/tracing/runtime/metrics.rb

@@ -1,6 +1,4 @@
-# typed: true
-
-require 'datadog/core'
+# frozen_string_literal: true
 
 module Datadog
   module Tracing

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

@@ -1,6 +1,6 @@
-# typed: true
+# frozen_string_literal: true
 
-require 'datadog/tracing/sampling/sampler'
+require_relative 'sampler'
 
 module Datadog
   module Tracing

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

@@ -1,4 +1,4 @@
-# typed: strict
+# frozen_string_literal: true
 
 module Datadog
   module Tracing
@@ -21,6 +21,35 @@ module Datadog
           # through the {Datadog::Tracing::Sampling::RuleSampler}.
           USER_KEEP = 2
         end
+
+        # List of what mechanism was used to make the trace-level sampling decision.
+        module Mechanism
+          # Single Span Sampled.
+          SPAN_SAMPLING_RATE = 8
+        end
+
+        # List of how the decision was made for the trace-level sampling.
+        #
+        # These values used to populate the {Datadog::Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER} tag.
+        #
+        # The decision has two parts, separated by a `-`:
+        # `part1-sampling_mechanism`. `part1` is currently not populated, thus
+        # this tag is currently formatted as `"-sampling_mechanism"`.
+        module Decision
+          # Used before the tracer receives any rates from agent and there are no rules configured.
+          DEFAULT = '-0'
+          # The sampling rate received in the agent's http response.
+          AGENT_RATE = '-1'
+          # Sampling rule or sampling rate based on tracer config.
+          TRACE_SAMPLING_RULE = '-3'
+          # User directly sets sampling priority via {Tracing.reject!} or {Tracing.keep!},
+          # or by a custom sampler implementation.
+          MANUAL = '-4'
+          # Formerly AppSec.
+          ASM = '-5'
+          # Single Span Sampled.
+          SPAN_SAMPLING_RATE = '-8'
+        end
       end
     end
   end

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

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Tracing

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

@@ -1,14 +1,14 @@
-# typed: true
+# frozen_string_literal: true
 
-require 'datadog/tracing/sampling/ext'
-require 'datadog/tracing/sampling/all_sampler'
-require 'datadog/tracing/sampling/rate_sampler'
-require 'datadog/tracing/sampling/rate_by_service_sampler'
+require_relative 'ext'
+require_relative 'all_sampler'
+require_relative 'rate_sampler'
+require_relative 'rate_by_service_sampler'
 
 module Datadog
   module Tracing
     module Sampling
-      # {Datadog:::Tracing::Sampling::PrioritySampler}
+      # {Datadog::Tracing::Sampling::PrioritySampler}
       # @public_api
       class PrioritySampler
         # NOTE: We do not advise using a pre-sampler. It can save resources,
@@ -21,17 +21,26 @@ module Datadog
 
         def initialize(opts = {})
           @pre_sampler = opts[:base_sampler] || AllSampler.new
-          @priority_sampler = opts[:post_sampler] || RateByServiceSampler.new
+          @priority_sampler = opts[:post_sampler] || RateByServiceSampler.new(decision: Sampling::Ext::Decision::AGENT_RATE)
         end
 
         def sample?(trace)
           @pre_sampler.sample?(trace)
         end
 
+        # DEV-2.0:We should get rid of this complicated interaction between @pre_sampler and @priority_sampler.
+        # DEV-2.0:If the user wants to configure a custom sampler, we should only allow them to provide a complete
+        # DEV-2.0:sampling suite, not having this convoluted support for mixing arbitrary provided samplers in
+        # DEV-2.0:the PrioritySampler. Ideally, the PrioritySampler is only used by Datadog.
+        # DEV-2.0:There are too many edge cases and combinations to work around currently in this class.
         def sample!(trace)
+          # The priority that was set before the sampler ran.
+          # This comes from distributed tracing priority propagation.
+          distributed_sampling_priority = priority_assigned?(trace)
+
           # 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.
-          trace.sampled = pre_sample?(trace) ? @pre_sampler.sample!(trace) : true
+          trace.sampled = pre_sample?(trace) ? preserving_priority_sampling(trace) { @pre_sampler.sample!(trace) } : true
 
           if trace.sampled?
             # If priority sampling has already been applied upstream, use that value.
@@ -53,11 +62,38 @@ module Datadog
           end
 
           trace.sampled?
+        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)
+              # 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.
+              trace.set_tag(
+                Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER,
+                Sampling::Ext::Decision::MANUAL
+              )
+            end
+          else
+            # The sampler decided to not keep this span, removing sampling decision.
+            trace.clear_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
+          end
         end
 
         # (see Datadog::Tracing::Sampling::RateByServiceSampler#update)
-        def update(rate_by_service)
-          @priority_sampler.update(rate_by_service)
+        def update(rate_by_service, decision: nil)
+          @priority_sampler.update(rate_by_service, decision: decision)
+        end
+
+        # Check if the Priority Sampling decision is to keep or drop the trace.
+        # Other factors can influence the sampling decision; this method is only
+        # responsible for interpreting the Sampling Priority decision.
+        #
+        # @param priority_sampling [Integer] priority sampling number
+        # @return [Boolean] true if trace is "kept" by priority sampling
+        # @return [Boolean] false if trace is "dropped" by priority sampling
+        def self.sampled?(priority_sampling)
+          priority_sampling >= Ext::Priority::AUTO_KEEP
         end
 
         private
@@ -83,6 +119,23 @@ module Datadog
           end
         end
 
+        # Ensures the trace's priority sampling decision is not changed by the @pre_sampler.
+        # The @pre_sampler should only change `trace.sampled`.
+        def preserving_priority_sampling(trace)
+          sampling_priority = trace.sampling_priority
+          sampling_decision = trace.get_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
+
+          yield.tap do
+            trace.sampling_priority = sampling_priority
+
+            if sampling_decision
+              trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, sampling_decision)
+            else
+              trace.clear_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
+            end
+          end
+        end
+
         # Ensures the trace is always propagated to the writer and that
         # the sample rate metric represents the true client-side sampling.
         def preserving_sampling(trace)

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

@@ -1,7 +1,5 @@
-# typed: true
-
-require 'datadog/tracing/sampling/sampler'
-require 'datadog/tracing/sampling/rate_sampler'
+require_relative 'sampler'
+require_relative 'rate_sampler'
 
 module Datadog
   module Tracing
@@ -12,7 +10,7 @@ module Datadog
         attr_reader \
           :default_key
 
-        def initialize(default_key, default_rate = 1.0, &block)
+        def initialize(default_key, default_rate = 1.0, decision: nil, &block)
           super()
 
           raise ArgumentError, 'No resolver given!' unless block
@@ -22,7 +20,7 @@ module Datadog
           @mutex = Mutex.new
           @samplers = {}
 
-          set_rate(default_key, default_rate)
+          set_rate(default_key, default_rate, decision)
         end
 
         def resolve(trace)
@@ -57,15 +55,15 @@ module Datadog
           end
         end
 
-        def update(key, rate)
+        def update(key, rate, decision: nil)
           @mutex.synchronize do
-            set_rate(key, rate)
+            set_rate(key, rate, decision)
           end
         end
 
-        def update_all(rate_by_key)
+        def update_all(rate_by_key, decision: nil)
           @mutex.synchronize do
-            rate_by_key.each { |key, rate| set_rate(key, rate) }
+            rate_by_key.each { |key, rate| set_rate(key, rate, decision) }
           end
         end
 
@@ -87,9 +85,8 @@ module Datadog
 
         private
 
-        def set_rate(key, rate)
-          @samplers[key] ||= RateSampler.new(rate)
-          @samplers[key].sample_rate = rate
+        def set_rate(key, rate, decision)
+          @samplers[key] = RateSampler.new(rate, decision: decision)
         end
       end
     end

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

@@ -1,27 +1,30 @@
-# typed: true
-
-require 'datadog/core'
-require 'datadog/tracing/sampling/rate_by_key_sampler'
+require_relative 'rate_by_key_sampler'
 
 module Datadog
   module Tracing
     module Sampling
-      # {Datadog:::Tracing::Sampling::RateByServiceSampler} samples different services at different rates
+      # {Datadog::Tracing::Sampling::RateByServiceSampler} samples different services at different rates
       # @public_api
       class RateByServiceSampler < RateByKeySampler
         DEFAULT_KEY = 'service:,env:'.freeze
 
-        def initialize(default_rate = 1.0, options = {})
-          super(DEFAULT_KEY, default_rate, &method(:key_for))
-          @env = options[:env]
+        def initialize(default_rate = 1.0, env: nil, decision: Datadog::Tracing::Sampling::Ext::Decision::DEFAULT)
+          super(
+            DEFAULT_KEY,
+            default_rate,
+            decision: decision,
+            &method(:key_for)
+          )
+
+          @env = env
         end
 
-        def update(rate_by_service)
+        def update(rate_by_service, decision: nil)
           # Remove any old services
           delete_if { |key, _| key != DEFAULT_KEY && !rate_by_service.key?(key) }
 
           # Update each service rate
-          update_all(rate_by_service)
+          update_all(rate_by_service, decision: decision)
 
           # Emit metric for service cache size
           Datadog.health_metrics.sampling_service_cache_length(length)
@@ -29,6 +32,24 @@ module Datadog
 
         private
 
+        # DEV: Creating a string on every trace to perform a single Hash lookup is expensive.
+        #
+        # Using 2 nested hashes: 1 for env and 1 for service is the fastest option.
+        # This approach requires large API changes to `RateByKeySampler`.
+        #
+        # Reducing the interpolated string size, by using a 1 character separator,
+        # is also measurably faster than the current method. This approach does not
+        # require changes to `RateByKeySampler`.
+        #
+        # Keep in mind that these changes also require changes to `#update`.
+        #
+        # Comparison:
+        #  2 nested hashes: `service_hash.fetch(service, {}).fetch(env, default_rate)`
+        #                   7730045 i/s
+        # 1 char separator: `hash.fetch("#{service}\0#{env}", default_rate)`
+        #                   4302801 i/s - 1.80x slower
+        #          current: `hash.fetch("service:#{service},env:#{env}", default_rate)`
+        #                   2720459 i/s - 2.84x slower
         def key_for(trace)
           # Resolve env dynamically, if Proc is given.
           env = @env.is_a?(Proc) ? @env.call : @env

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

@@ -1,6 +1,4 @@
-# typed: true
-
-require 'datadog/core/utils/time'
+require_relative '../../core/utils/time'
 
 module Datadog
   module Tracing
@@ -39,6 +37,9 @@ module Datadog
         def initialize(rate, max_tokens = rate)
           super()
 
+          raise ArgumentError, "rate must be a number: #{rate}" unless rate.is_a?(Numeric)
+          raise ArgumentError, "max_tokens must be a number: #{max_tokens}" unless max_tokens.is_a?(Numeric)
+
           @rate = rate
           @max_tokens = max_tokens
 

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

@@ -1,26 +1,32 @@
-# typed: true
-
-require 'datadog/core'
-
-require 'datadog/tracing/sampling/sampler'
-require 'datadog/tracing/span'
+require_relative 'sampler'
+require_relative '../utils'
 
 module Datadog
   module Tracing
     module Sampling
-      # {Datadog:::Tracing::Sampling::RateSampler} is based on a sample rate.
+      # {Datadog::Tracing::Sampling::RateSampler} is based on a sample rate.
       # @public_api
       class RateSampler < Sampler
         KNUTH_FACTOR = 1111111111111111111
 
-        # Initialize a {Datadog:::Tracing::Sampling::RateSampler}.
+        # Initialize a {Datadog::Tracing::Sampling::RateSampler}.
         # This sampler keeps a random subset of the traces. Its main purpose is to
         # reduce the instrumentation footprint.
         #
         # * +sample_rate+: the sample rate as a {Float} between 0.0 and 1.0. 0.0
         #   means that no trace will be sampled; 1.0 means that all traces will be
         #   sampled.
-        def initialize(sample_rate = 1.0)
+        #
+        # DEV-2.0: Allow for `sample_rate` zero (drop all) to be allowed. This eases
+        # DEV-2.0: usage for all internal users of the {RateSampler} class: both
+        # DEV-2.0: RuleSampler and Single Span Sampling leverage the RateSampler, but want
+        # DEV-2.0: `sample_rate` zero to mean "drop all". They work around this by hard-
+        # DEV-2.0: setting the `sample_rate` to zero like so:
+        # DEV-2.0: ```
+        # DEV-2.0: sampler = RateSampler.new
+        # DEV-2.0: sampler.sample_rate = sample_rate
+        # DEV-2.0: ```
+        def initialize(sample_rate = 1.0, decision: nil)
           super()
 
           unless sample_rate > 0.0 && sample_rate <= 1.0
@@ -29,6 +35,8 @@ module Datadog
           end
 
           self.sample_rate = sample_rate
+
+          @decision = decision
         end
 
         def sample_rate(*_)
@@ -37,17 +45,22 @@ module Datadog
 
         def sample_rate=(sample_rate)
           @sample_rate = sample_rate
-          @sampling_id_threshold = sample_rate * Span::EXTERNAL_MAX_ID
+          @sampling_id_threshold = sample_rate * Tracing::Utils::EXTERNAL_MAX_ID
         end
 
         def sample?(trace)
-          ((trace.id * KNUTH_FACTOR) % Span::EXTERNAL_MAX_ID) <= @sampling_id_threshold
+          ((trace.id * KNUTH_FACTOR) % Tracing::Utils::EXTERNAL_MAX_ID) <= @sampling_id_threshold
         end
 
         def sample!(trace)
           sampled = trace.sampled = sample?(trace)
-          trace.sample_rate = @sample_rate if sampled
-          sampled
+
+          return false unless sampled
+
+          trace.sample_rate = @sample_rate
+          trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, @decision) if @decision
+
+          true
         end
       end
     end

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

@@ -1,9 +1,5 @@
-# typed: true
-
-require 'datadog/core'
-
-require 'datadog/tracing/sampling/matcher'
-require 'datadog/tracing/sampling/rate_sampler'
+require_relative 'matcher'
+require_relative 'rate_sampler'
 
 module Datadog
   module Tracing

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

@@ -1,10 +1,6 @@
-# typed: true
-
-require 'datadog/core'
-
-require 'datadog/tracing/sampling/ext'
-require 'datadog/tracing/sampling/rate_limiter'
-require 'datadog/tracing/sampling/rule'
+require_relative 'ext'
+require_relative 'rate_limiter'
+require_relative 'rule'
 
 module Datadog
   module Tracing
@@ -48,7 +44,7 @@ module Datadog
                                nil
                              else
                                # TODO: Simplify .tags access, as `Tracer#tags` can't be arbitrarily changed anymore
-                               RateByServiceSampler.new(1.0, env: -> { Tracing.send(:tracer).tags[:env] })
+                               RateByServiceSampler.new(1.0, env: -> { Tracing.send(:tracer).tags['env'] })
                              end
         end
 
@@ -76,10 +72,10 @@ module Datadog
         end
 
         # @!visibility private
-        def update(*args)
+        def update(*args, **kwargs)
           return false unless @default_sampler.respond_to?(:update)
 
-          @default_sampler.update(*args)
+          @default_sampler.update(*args, **kwargs)
         end
 
         private
@@ -100,6 +96,7 @@ module Datadog
           rate_limiter.allow?(1).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, Ext::Decision::TRACE_SAMPLING_RULE)
           end
         rescue StandardError => e
           Datadog.logger.error(

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

@@ -1,5 +1,3 @@
-# typed: true
-
 module Datadog
   module Tracing
     module Sampling