ls-trace 0.1.2 → 0.2.0

data/lib/ddtrace/pipeline.rb

@@ -34,7 +34,7 @@ module Datadog
 
       result || []
     rescue => e
-      Datadog::Tracer.log.debug(
+      Datadog.logger.debug(
         "trace dropped entirely due to `Pipeline.before_flush` error: #{e}"
       )
 

data/lib/ddtrace/pipeline/span_filter.rb

@@ -10,12 +10,22 @@ module Datadog
         @criteria = filter || block
       end
 
+      # 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
+      # parent spans, then the code below will need to be updated.
       def call(trace)
-        black_list = trace.select(&method(:drop_it?))
-
-        clean_trace(black_list, trace) while black_list.any?
-
-        trace
+        deleted = Set.new
+
+        trace.delete_if do |span|
+          if deleted.include?(span.parent)
+            deleted << span
+            true
+          else
+            drop = drop_it?(span)
+            deleted << span if drop
+            drop
+          end
+        end
       end
 
       private
@@ -23,16 +33,6 @@ module Datadog
       def drop_it?(span)
         @criteria.call(span) rescue false
       end
-
-      def clean_trace(black_list, trace)
-        current = black_list.shift
-
-        trace.delete(current)
-
-        trace.each do |span|
-          black_list << span if span.parent == current
-        end
-      end
     end
   end
 end

data/lib/ddtrace/propagation/http_propagator.rb

@@ -19,7 +19,7 @@ module Datadog
     def self.inject!(context, env)
       # Prevent propagation from being attempted if context provided is nil.
       if context.nil?
-        ::Datadog::Tracer.log.debug('Cannot inject context into env to propagate over HTTP: context is nil.'.freeze)
+        ::Datadog.logger.debug('Cannot inject context into env to propagate over HTTP: context is nil.'.freeze)
         return
       end
 
@@ -58,7 +58,7 @@ module Datadog
             # Return an empty/new context if we have a mismatch in values extracted
             msg = "#{context.trace_id} != #{extracted_context.trace_id} && " \
                   "#{context.span_id} != #{extracted_context.span_id}"
-            ::Datadog::Tracer.log.debug("Cannot extract context from HTTP: extracted contexts differ, #{msg}".freeze)
+            ::Datadog.logger.debug("Cannot extract context from HTTP: extracted contexts differ, #{msg}".freeze)
             # DEV: This will return from `self.extract` not this `each` block
             return ::Datadog::Context.new
           end

data/lib/ddtrace/runtime/cgroup.rb

@@ -27,7 +27,7 @@ module Datadog
               end
             end
           rescue StandardError => e
-            Datadog::Tracer.log.error("Error while parsing cgroup. Cause: #{e.message} Location: #{e.backtrace.first}")
+            Datadog.logger.error("Error while parsing cgroup. Cause: #{e.message} Location: #{e.backtrace.first}")
           end
         end
       end

data/lib/ddtrace/runtime/container.rb

@@ -61,7 +61,7 @@ module Datadog
                 break
               end
             rescue StandardError => e
-              Datadog::Tracer.log.error(
+              Datadog.logger.error(
                 "Error while parsing container info. Cause: #{e.message} Location: #{e.backtrace.first}"
               )
             end

data/lib/ddtrace/runtime/metrics.rb

@@ -14,12 +14,13 @@ module Datadog
         super
 
         # Initialize service list
-        @services = Set.new
+        @services = Set.new(options.fetch(:services, []))
         @service_tags = nil
+        compile_service_tags!
       end
 
       def associate_with_span(span)
-        return if span.nil?
+        return if !enabled? || span.nil?
 
         # Register service as associated with metrics
         register_service(span.service) unless span.service.nil?
@@ -30,7 +31,7 @@ module Datadog
 
       # Associate service with runtime metrics
       def register_service(service)
-        return if service.nil?
+        return if !enabled? || service.nil?
 
         service = service.to_s
 
@@ -54,8 +55,8 @@ module Datadog
 
       def gc_metrics
         Hash[
-          GC.stat.map do |k, v|
-            ["#{Ext::Runtime::Metrics::METRIC_GC_PREFIX}.#{k}", v]
+          GC.stat.flat_map do |k, v|
+            nested_gc_metric(Ext::Runtime::Metrics::METRIC_GC_PREFIX, k, v)
           end
         ]
       end
@@ -63,7 +64,7 @@ module Datadog
       def try_flush
         yield
       rescue StandardError => e
-        Datadog::Tracer.log.error("Error while sending runtime metric. Cause: #{e.message}")
+        Datadog.logger.error("Error while sending runtime metric. Cause: #{e.message}")
       end
 
       def default_metric_options
@@ -88,6 +89,22 @@ module Datadog
           "#{Ext::Runtime::Metrics::TAG_SERVICE}:#{service}".freeze
         end
       end
+
+      def nested_gc_metric(prefix, k, v)
+        path = "#{prefix}.#{k}"
+
+        if v.is_a?(Hash)
+          v.flat_map do |key, value|
+            nested_gc_metric(path, key, value)
+          end
+        else
+          [[to_metric_name(path), v]]
+        end
+      end
+
+      def to_metric_name(str)
+        str.downcase.gsub(/[-\s]/, '_')
+      end
     end
   end
 end

data/lib/ddtrace/sampler.rb

@@ -1,6 +1,7 @@
 require 'forwardable'
 
 require 'ddtrace/ext/priority'
+require 'ddtrace/diagnostics/health'
 
 module Datadog
   # \Sampler performs client-side trace sampling.
@@ -12,6 +13,10 @@ module Datadog
     def sample!(_span)
       raise NotImplementedError, 'Samplers must implement the #sample! method'
     end
+
+    def sample_rate(span)
+      raise NotImplementedError, 'Samplers must implement the #sample_rate method'
+    end
   end
 
   # \AllSampler samples all the traces.
@@ -23,6 +28,10 @@ module Datadog
     def sample!(span)
       span.sampled = true
     end
+
+    def sample_rate(*_)
+      1.0
+    end
   end
 
   # \RateSampler is based on a sample rate.
@@ -30,8 +39,6 @@ module Datadog
     KNUTH_FACTOR = 1111111111111111111
     SAMPLE_RATE_METRIC_KEY = '_sample_rate'.freeze
 
-    attr_reader :sample_rate
-
     # Initialize a \RateSampler.
     # This sampler keeps a random subset of the traces. Its main purpose is to
     # reduce the instrumentation footprint.
@@ -41,13 +48,17 @@ module Datadog
     #   sampled.
     def initialize(sample_rate = 1.0)
       unless sample_rate > 0.0 && sample_rate <= 1.0
-        Datadog::Tracer.log.error('sample rate is not between 0 and 1, disabling the sampler')
+        Datadog.logger.error('sample rate is not between 0 and 1, disabling the sampler')
         sample_rate = 1.0
       end
 
       self.sample_rate = sample_rate
     end
 
+    def sample_rate(*_)
+      @sample_rate
+    end
+
     def sample_rate=(sample_rate)
       @sample_rate = sample_rate
       @sampling_id_threshold = sample_rate * Span::MAX_ID
@@ -64,56 +75,117 @@ module Datadog
     end
   end
 
-  # \RateByServiceSampler samples different services at different rates
-  class RateByServiceSampler < Sampler
-    DEFAULT_KEY = 'service:,env:'.freeze
+  # Samples at different rates by key.
+  class RateByKeySampler < Sampler
+    attr_reader \
+      :default_key
+
+    def initialize(default_key, default_rate = 1.0, &block)
+      raise ArgumentError, 'No resolver given!' unless block_given?
 
-    def initialize(rate = 1.0, opts = {})
-      @env = opts.fetch(:env, Datadog.tracer.tags[:env])
+      @default_key = default_key
+      @resolver = block
       @mutex = Mutex.new
-      @fallback = RateSampler.new(rate)
-      @sampler = { DEFAULT_KEY => @fallback }
+      @samplers = {}
+
+      set_rate(default_key, default_rate)
+    end
+
+    def resolve(span)
+      @resolver.call(span)
+    end
+
+    def default_sampler
+      @samplers[default_key]
     end
 
     def sample?(span)
-      key = key_for(span)
+      key = resolve(span)
 
       @mutex.synchronize do
-        @sampler.fetch(key, @fallback).sample?(span)
+        @samplers.fetch(key, default_sampler).sample?(span)
       end
     end
 
     def sample!(span)
-      key = key_for(span)
+      key = resolve(span)
 
       @mutex.synchronize do
-        @sampler.fetch(key, @fallback).sample!(span)
+        @samplers.fetch(key, default_sampler).sample!(span)
       end
     end
 
     def sample_rate(span)
-      key = key_for(span)
+      key = resolve(span)
 
       @mutex.synchronize do
-        @sampler.fetch(key, @fallback).sample_rate
+        @samplers.fetch(key, default_sampler).sample_rate
       end
     end
 
-    def update(rate_by_service)
+    def update(key, rate)
       @mutex.synchronize do
-        @sampler.delete_if { |key, _| key != DEFAULT_KEY && !rate_by_service.key?(key) }
+        set_rate(key, rate)
+      end
+    end
 
-        rate_by_service.each do |key, rate|
-          @sampler[key] ||= RateSampler.new(rate)
-          @sampler[key].sample_rate = rate
-        end
+    def update_all(rate_by_key)
+      @mutex.synchronize do
+        rate_by_key.each { |key, rate| set_rate(key, rate) }
+      end
+    end
+
+    def delete(key)
+      @mutex.synchronize do
+        @samplers.delete(key)
+      end
+    end
+
+    def delete_if(&block)
+      @mutex.synchronize do
+        @samplers.delete_if(&block)
       end
     end
 
+    def length
+      @samplers.length
+    end
+
+    private
+
+    def set_rate(key, rate)
+      @samplers[key] ||= RateSampler.new(rate)
+      @samplers[key].sample_rate = rate
+    end
+  end
+
+  # \RateByServiceSampler samples different services at different rates
+  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]
+    end
+
+    def update(rate_by_service)
+      # Remove any old services
+      delete_if { |key, _| key != DEFAULT_KEY && !rate_by_service.key?(key) }
+
+      # Update each service rate
+      update_all(rate_by_service)
+
+      # Emit metric for service cache size
+      Datadog.health_metrics.sampling_service_cache_length(length)
+    end
+
     private
 
     def key_for(span)
-      "service:#{span.service},env:#{@env}"
+      # Resolve env dynamically, if Proc is given.
+      env = @env.is_a?(Proc) ? @env.call : @env
+
+      "service:#{span.service},env:#{env}"
     end
   end
 
@@ -121,6 +193,8 @@ module Datadog
   class PrioritySampler
     extend Forwardable
 
+    attr_reader :pre_sampler, :priority_sampler
+
     SAMPLE_RATE_METRIC_KEY = '_sample_rate'.freeze
 
     def initialize(opts = {})
@@ -141,10 +215,8 @@ module Datadog
         # 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.
-          # NOTE: We'll want to leave `span.sampled = true` here; all spans for priority sampling must
-          #       be sent to the agent. Otherwise metrics for traces will not be accurate, since the
-          #       agent will have an incomplete dataset.
-          priority = priority_sample(span) ? Datadog::Ext::Priority::AUTO_KEEP : Datadog::Ext::Priority::AUTO_REJECT
+          priority = priority_sample!(span) ? Datadog::Ext::Priority::AUTO_KEEP : Datadog::Ext::Priority::AUTO_REJECT
+
           assign_priority!(span, priority)
         end
       else
@@ -175,8 +247,33 @@ module Datadog
       span.context && !span.context.sampling_priority.nil?
     end
 
-    def priority_sample(span)
-      @priority_sampler.sample?(span)
+    def priority_sample!(span)
+      preserving_sampling(span) do
+        @priority_sampler.sample!(span)
+      end
+    end
+
+    # Ensures the span is always propagated to the writer and that
+    # the sample rate metric represents the true client-side sampling.
+    def preserving_sampling(span)
+      pre_sample_rate_metric = span.get_metric(SAMPLE_RATE_METRIC_KEY)
+
+      yield.tap do
+        # NOTE: We'll want to leave `span.sampled = true` here; all spans for priority sampling must
+        #       be sent to the agent. Otherwise metrics for traces will not be accurate, since the
+        #       agent will have an incomplete dataset.
+        #
+        #       We also ensure that the agent knows we that our `post_sampler` is not performing true sampling,
+        #       to avoid erroneous metric upscaling.
+        span.sampled = true
+        if pre_sample_rate_metric
+          # Restore true sampling metric, as only the @pre_sampler can reject traces
+          span.set_metric(SAMPLE_RATE_METRIC_KEY, pre_sample_rate_metric)
+        else
+          # If @pre_sampler is not enable, sending this metric would be misleading
+          span.clear_metric(SAMPLE_RATE_METRIC_KEY)
+        end
+      end
     end
 
     def assign_priority!(span, priority)

data/lib/ddtrace/sampling.rb

@@ -0,0 +1,2 @@
+require 'ddtrace/sampling/rule'
+require 'ddtrace/sampling/rule_sampler'

data/lib/ddtrace/sampling/matcher.rb

@@ -0,0 +1,57 @@
+module Datadog
+  module Sampling
+    # Checks if a span conforms to a matching criteria.
+    class Matcher
+      # Returns `true` if the span should conforms to this rule, `false` otherwise
+      #
+      # @abstract
+      # @param [Span] span
+      # @return [Boolean]
+      def match?(span)
+        raise NotImplementedError
+      end
+    end
+
+    # A \Matcher that supports matching a span by
+    # operation name and/or service name.
+    class SimpleMatcher < Matcher
+      # Returns `true` for case equality (===) with any object
+      MATCH_ALL = Class.new do
+        # DEV: A class that implements `#===` is ~20% faster than
+        # DEV: a `Proc` that always returns `true`.
+        def ===(other)
+          true
+        end
+      end.new
+
+      attr_reader :name, :service
+
+      # @param name [String,Regexp,Proc] Matcher for case equality (===) with the span name, defaults to always match
+      # @param service [String,Regexp,Proc] Matcher for case equality (===) with the service name, defaults to always match
+      def initialize(name: MATCH_ALL, service: MATCH_ALL)
+        @name = name
+        @service = service
+      end
+
+      def match?(span)
+        name === span.name && service === span.service
+      end
+    end
+
+    # A \Matcher that allows for arbitrary span matching
+    # based on the return value of a provided block.
+    class ProcMatcher < Matcher
+      attr_reader :block
+
+      # @yield [name, service] Provides span name and service to the block
+      # @yieldreturn [Boolean] Whether the span conforms to this matcher
+      def initialize(&block)
+        @block = block
+      end
+
+      def match?(span)
+        block.call(span.name, span.service)
+      end
+    end
+  end
+end