ddtrace 0.52.0 → 1.8.0

data/lib/ddtrace/propagation/http_propagator.rb

@@ -1,91 +0,0 @@
-# typed: false
-require 'ddtrace/configuration'
-require 'ddtrace/context'
-require 'ddtrace/ext/distributed'
-require 'ddtrace/ext/priority'
-require 'ddtrace/distributed_tracing/headers/b3'
-require 'ddtrace/distributed_tracing/headers/b3_single'
-require 'ddtrace/distributed_tracing/headers/datadog'
-
-module Datadog
-  # HTTPPropagator helps extracting and injecting HTTP headers.
-  module HTTPPropagator
-    include Ext::DistributedTracing
-
-    PROPAGATION_STYLES = { PROPAGATION_STYLE_B3 => DistributedTracing::Headers::B3,
-                           PROPAGATION_STYLE_B3_SINGLE_HEADER => DistributedTracing::Headers::B3Single,
-                           PROPAGATION_STYLE_DATADOG => DistributedTracing::Headers::Datadog }.freeze
-
-    # inject! popolates the env with span ID, trace ID and sampling priority
-    def self.inject!(context, env)
-      # Prevent propagation from being attempted if context provided is nil.
-      if context.nil?
-        ::Datadog.logger.debug('Cannot inject context into env to propagate over HTTP: context is nil.'.freeze)
-        return
-      end
-
-      # Inject all configured propagation styles
-      ::Datadog.configuration.distributed_tracing.propagation_inject_style.each do |style|
-        propagator = PROPAGATION_STYLES[style]
-        begin
-          propagator.inject!(context, env) unless propagator.nil?
-        rescue => e
-          Datadog.logger.error(
-            'Error injecting propagated context into the environment. ' \
-            "Cause: #{e} Location: #{Array(e.backtrace).first}"
-          )
-        end
-      end
-    end
-
-    # extract returns a context containing the span ID, trace ID and
-    # sampling priority defined in env.
-    def self.extract(env)
-      context = nil
-      dd_context = nil
-
-      ::Datadog.configuration.distributed_tracing.propagation_extract_style.each do |style|
-        propagator = PROPAGATION_STYLES[style]
-        next if propagator.nil?
-
-        # Extract context
-        # DEV: `propagator.extract` will return `nil`, where `HTTPPropagator#extract` will not
-        begin
-          extracted_context = propagator.extract(env)
-        rescue => e
-          Datadog.logger.error(
-            'Error extracting propagated context from the environment. ' \
-            "Cause: #{e} Location: #{Array(e.backtrace).first}"
-          )
-        end
-
-        # Skip this style if no valid headers were found
-        next if extracted_context.nil?
-
-        # Keep track of the Datadog extract context, we want to return
-        #   this one if we have one
-        dd_context = extracted_context if extracted_context && style == PROPAGATION_STYLE_DATADOG
-
-        # No previously extracted context, use the one we just extracted
-        if context.nil?
-          context = extracted_context
-        else
-          unless context.trace_id == extracted_context.trace_id && context.span_id == extracted_context.span_id
-            # 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.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
-        end
-      end
-
-      # Return the extracted context if we found one or else a new empty context
-      # Always return the Datadog context if one exists since it has more
-      #   information than the B3 headers e.g. origin, expanded priority
-      #   sampling values, etc
-      dd_context || context || ::Datadog::Context.new
-    end
-  end
-end

data/lib/ddtrace/quantization/hash.rb

@@ -1,104 +0,0 @@
-# typed: true
-module Datadog
-  module Quantization
-    # Quantization for HTTP resources
-    module Hash
-      PLACEHOLDER = '?'.freeze
-      EXCLUDE_KEYS = [].freeze
-      SHOW_KEYS = [].freeze
-      DEFAULT_OPTIONS = {
-        exclude: EXCLUDE_KEYS,
-        show: SHOW_KEYS,
-        placeholder: PLACEHOLDER
-      }.freeze
-
-      module_function
-
-      def format(hash_obj, options = {})
-        options ||= {}
-        format!(hash_obj, options)
-      rescue StandardError
-        options[:placeholder] || PLACEHOLDER
-      end
-
-      def format!(hash_obj, options = {})
-        options ||= {}
-        options = merge_options(DEFAULT_OPTIONS, options)
-        format_hash(hash_obj, options)
-      end
-
-      def format_hash(hash_obj, options = {})
-        case hash_obj
-        when ::Hash
-          return {} if options[:exclude] == :all
-          return hash_obj if options[:show] == :all
-
-          hash_obj.each_with_object({}) do |(key, value), quantized|
-            if options[:show].any?(&indifferent_equals(key))
-              quantized[key] = value
-            elsif options[:exclude].none?(&indifferent_equals(key))
-              quantized[key] = format_value(value, options)
-            end
-          end
-        else
-          format_value(hash_obj, options)
-        end
-      end
-
-      def format_value(value, options = {})
-        return value if options[:show] == :all
-
-        case value
-        when ::Hash
-          format_hash(value, options)
-        when Array
-          # If any are objects, format them.
-          format_array(value, options)
-        else
-          options[:placeholder]
-        end
-      end
-
-      def format_array(value, options)
-        if value.any? { |v| v.class <= ::Hash || v.class <= Array }
-          first_entry = format_value(value.first, options)
-          value.size > 1 ? [first_entry, options[:placeholder]] : [first_entry]
-          # Otherwise short-circuit and return single placeholder
-        else
-          [options[:placeholder]]
-        end
-      end
-
-      def merge_options(original, additional)
-        {}.tap do |options|
-          # Show
-          # If either is :all, value becomes :all
-          options[:show] = if original[:show] == :all || additional[:show] == :all
-                             :all
-                           else
-                             (original[:show] || []).dup.concat(additional[:show] || []).uniq
-                           end
-
-          # Exclude
-          # If either is :all, value becomes :all
-          options[:exclude] = if original[:exclude] == :all || additional[:exclude] == :all
-                                :all
-                              else
-                                (original[:exclude] || []).dup.concat(additional[:exclude] || []).uniq
-                              end
-
-          options[:placeholder] = additional[:placeholder] || original[:placeholder]
-        end
-      end
-
-      def indifferent_equals(value)
-        value = convert_value(value)
-        ->(compared_value) { value == convert_value(compared_value) }
-      end
-
-      def convert_value(value)
-        value.is_a?(Symbol) ? value.to_s : value
-      end
-    end
-  end
-end

data/lib/ddtrace/quantization/http.rb

@@ -1,90 +0,0 @@
-# typed: true
-require 'uri'
-require 'set'
-
-module Datadog
-  module Quantization
-    # Quantization for HTTP resources
-    module HTTP
-      include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
-
-      PLACEHOLDER = '?'.freeze
-
-      module_function
-
-      def url(url, options = {})
-        url!(url, options)
-      rescue StandardError
-        options[:placeholder] || PLACEHOLDER
-      end
-
-      def url!(url, options = {})
-        options ||= {}
-
-        URI.parse(url).tap do |uri|
-          # Format the query string
-          if uri.query
-            query = query(uri.query, options[:query])
-            uri.query = (!query.nil? && query.empty? ? nil : query)
-          end
-
-          # Remove any URI framents
-          uri.fragment = nil unless options[:fragment] == :show
-        end.to_s
-      end
-
-      def query(query, options = {})
-        query!(query, options)
-      rescue StandardError
-        options[:placeholder] || PLACEHOLDER
-      end
-
-      def query!(query, options = {})
-        options ||= {}
-        options[:show] = options[:show] || []
-        options[:exclude] = options[:exclude] || []
-
-        # Short circuit if query string is meant to exclude everything
-        # or if the query string is meant to include everything
-        return '' if options[:exclude] == :all
-        return query if options[:show] == :all
-
-        collect_query(query, uniq: true) do |key, value|
-          if options[:exclude].include?(key)
-            [nil, nil]
-          else
-            value = options[:show].include?(key) ? value : nil
-            [key, value]
-          end
-        end
-      end
-
-      # Iterate over each key value pair, yielding to the block given.
-      # Accepts :uniq option, which keeps uniq copies of keys without values.
-      # e.g. Reduces "foo&bar=bar&bar=bar&foo" to "foo&bar=bar&bar=bar"
-      def collect_query(query, options = {})
-        return query unless block_given?
-
-        uniq = options[:uniq].nil? ? false : options[:uniq]
-        keys = Set.new
-
-        delims = query.scan(/(^|&|;)/).flatten
-        query.split(/[&;]/).collect.with_index do |pairs, i|
-          key, value = pairs.split('=', 2)
-          key, value = yield(key, value, delims[i])
-          if uniq && keys.include?(key)
-            ''
-          elsif key && value
-            "#{delims[i]}#{key}=#{value}"
-          elsif key
-            "#{delims[i]}#{key}".tap { keys << key }
-          else
-            ''
-          end
-        end.join.sub(/^[&;]/, '')
-      end
-
-      private_class_method :collect_query
-    end
-  end
-end

data/lib/ddtrace/runtime/metrics.rb

@@ -1,121 +0,0 @@
-# typed: true
-require 'ddtrace/ext/integration'
-require 'ddtrace/ext/runtime'
-
-require 'ddtrace/metrics'
-require 'datadog/core/environment/class_count'
-require 'datadog/core/environment/gc'
-require 'datadog/core/environment/identity'
-require 'datadog/core/environment/thread_count'
-
-module Datadog
-  module Runtime
-    # For generating runtime metrics
-    class Metrics < Datadog::Metrics
-      def initialize(**options)
-        super
-
-        # Initialize service list
-        @services = Set.new(options.fetch(:services, []))
-        @service_tags = nil
-        compile_service_tags!
-      end
-
-      def associate_with_span(span)
-        return if !enabled? || span.nil?
-
-        # Register service as associated with metrics
-        register_service(span.service) unless span.service.nil?
-
-        # Tag span with language and runtime ID for association with metrics.
-        # We only tag spans that performed internal application work.
-        unless span.get_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE)
-          span.set_tag(Ext::Runtime::TAG_LANG, Core::Environment::Identity.lang)
-        end
-      end
-
-      # Associate service with runtime metrics
-      def register_service(service)
-        return if !enabled? || service.nil?
-
-        service = service.to_s
-
-        unless @services.include?(service)
-          # Add service to list and update services tag
-          services << service
-
-          # Recompile the service tags
-          compile_service_tags!
-        end
-      end
-
-      # Flush all runtime metrics to Statsd client
-      def flush
-        return unless enabled?
-
-        try_flush do
-          if Core::Environment::ClassCount.available?
-            gauge(Ext::Runtime::Metrics::METRIC_CLASS_COUNT, Core::Environment::ClassCount.value)
-          end
-        end
-        try_flush do
-          if Core::Environment::ThreadCount.available?
-            gauge(Ext::Runtime::Metrics::METRIC_THREAD_COUNT, Core::Environment::ThreadCount.value)
-          end
-        end
-        try_flush { gc_metrics.each { |metric, value| gauge(metric, value) } if Core::Environment::GC.available? }
-      end
-
-      def gc_metrics
-        Core::Environment::GC.stat.flat_map do |k, v|
-          nested_gc_metric(Ext::Runtime::Metrics::METRIC_GC_PREFIX, k, v)
-        end.to_h
-      end
-
-      def try_flush
-        yield
-      rescue StandardError => e
-        Datadog.logger.error("Error while sending runtime metric. Cause: #{e.message}")
-      end
-
-      def default_metric_options
-        # Return dupes, so that the constant isn't modified,
-        # and defaults are unfrozen for mutation in Statsd.
-        super.tap do |options|
-          options[:tags] = options[:tags].dup
-
-          # Add services dynamically because they might change during runtime.
-          options[:tags].concat(service_tags) unless service_tags.nil?
-        end
-      end
-
-      private
-
-      attr_reader \
-        :service_tags,
-        :services
-
-      def compile_service_tags!
-        @service_tags = services.to_a.collect do |service|
-          "#{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,293 +0,0 @@
-# typed: true
-require 'forwardable'
-
-require 'ddtrace/ext/priority'
-require 'ddtrace/diagnostics/health'
-
-module Datadog
-  # \Sampler performs client-side trace sampling.
-  class Sampler
-    def sample?(_span)
-      raise NotImplementedError, 'Samplers must implement the #sample? method'
-    end
-
-    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.
-  class AllSampler < Sampler
-    def sample?(span)
-      true
-    end
-
-    def sample!(span)
-      span.sampled = true
-    end
-
-    def sample_rate(*_)
-      1.0
-    end
-  end
-
-  # \RateSampler is based on a sample rate.
-  class RateSampler < Sampler
-    KNUTH_FACTOR = 1111111111111111111
-    SAMPLE_RATE_METRIC_KEY = '_sample_rate'.freeze
-
-    # Initialize a \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)
-      unless sample_rate > 0.0 && sample_rate <= 1.0
-        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::EXTERNAL_MAX_ID
-    end
-
-    def sample?(span)
-      ((span.trace_id * KNUTH_FACTOR) % Datadog::Span::EXTERNAL_MAX_ID) <= @sampling_id_threshold
-    end
-
-    def sample!(span)
-      (span.sampled = sample?(span)).tap do |sampled|
-        span.set_metric(SAMPLE_RATE_METRIC_KEY, @sample_rate) if sampled
-      end
-    end
-  end
-
-  # 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
-
-      @default_key = default_key
-      @resolver = block
-      @mutex = Mutex.new
-      @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 = resolve(span)
-
-      @mutex.synchronize do
-        @samplers.fetch(key, default_sampler).sample?(span)
-      end
-    end
-
-    def sample!(span)
-      key = resolve(span)
-
-      @mutex.synchronize do
-        @samplers.fetch(key, default_sampler).sample!(span)
-      end
-    end
-
-    def sample_rate(span)
-      key = resolve(span)
-
-      @mutex.synchronize do
-        @samplers.fetch(key, default_sampler).sample_rate
-      end
-    end
-
-    def update(key, rate)
-      @mutex.synchronize do
-        set_rate(key, rate)
-      end
-    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)
-      # Resolve env dynamically, if Proc is given.
-      env = @env.is_a?(Proc) ? @env.call : @env
-
-      "service:#{span.service},env:#{env}"
-    end
-  end
-
-  # \PrioritySampler
-  class PrioritySampler
-    extend Forwardable
-
-    attr_reader :pre_sampler, :priority_sampler
-
-    SAMPLE_RATE_METRIC_KEY = '_sample_rate'.freeze
-
-    def initialize(opts = {})
-      @pre_sampler = opts[:base_sampler] || AllSampler.new
-      @priority_sampler = opts[:post_sampler] || RateByServiceSampler.new
-    end
-
-    def sample?(span)
-      @pre_sampler.sample?(span)
-    end
-
-    def sample!(span)
-      # If pre-sampling is configured, do it first. (By default, this will sample at 100%.)
-      # NOTE: Pre-sampling at rates < 100% may result in partial traces; not recommended.
-      span.sampled = pre_sample?(span) ? @pre_sampler.sample!(span) : true
-
-      if span.sampled
-        # If priority sampling has already been applied upstream, use that, otherwise...
-        unless priority_assigned_upstream?(span)
-          # Roll the dice and determine whether how we set the priority.
-          priority = priority_sample!(span) ? Datadog::Ext::Priority::AUTO_KEEP : Datadog::Ext::Priority::AUTO_REJECT
-
-          assign_priority!(span, priority)
-        end
-      else
-        # If discarded by pre-sampling, set "reject" priority, so other
-        # services for the same trace don't sample needlessly.
-        assign_priority!(span, Datadog::Ext::Priority::AUTO_REJECT)
-      end
-
-      span.sampled
-    end
-
-    def_delegators :@priority_sampler, :update
-
-    private
-
-    def pre_sample?(span)
-      case @pre_sampler
-      when RateSampler
-        @pre_sampler.sample_rate < 1.0
-      when RateByServiceSampler
-        @pre_sampler.sample_rate(span) < 1.0
-      else
-        true
-      end
-    end
-
-    def priority_assigned_upstream?(span)
-      span.context && !span.context.sampling_priority.nil?
-    end
-
-    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)
-      if span.context
-        span.context.sampling_priority = priority
-      else
-        # Set the priority directly on the span instead, since otherwise
-        # it won't receive the appropriate tag.
-        span.set_metric(
-          Ext::DistributedTracing::SAMPLING_PRIORITY_KEY,
-          priority
-        )
-      end
-    end
-  end
-end