ddtrace 0.49.0 → 1.12.1

data/lib/ddtrace/buffer.rb

@@ -1,326 +0,0 @@
-require 'ddtrace/diagnostics/health'
-require 'ddtrace/runtime/object_space'
-
-# Trace buffer that accumulates traces for a consumer.
-# Consumption can happen from a different thread.
-module Datadog
-  # Buffer that stores objects. The buffer has a maximum size and when
-  # the buffer is full, a random object is discarded.
-  class Buffer
-    def initialize(max_size)
-      @max_size = max_size
-      @items = []
-      @closed = false
-    end
-
-    # Add a new ``item`` in the local queue. This method doesn't block the execution
-    # even if the buffer is full. In that case, a random item is discarded.
-    def push(item)
-      return if closed?
-
-      full? ? replace!(item) : add!(item)
-      item
-    end
-
-    # A bulk push alternative to +#push+. Use this method if
-    # pushing more than one item for efficiency.
-    def concat(items)
-      return if closed?
-
-      # Segment items into underflow and overflow
-      underflow, overflow = overflow_segments(items)
-
-      # Concatenate items do not exceed capacity.
-      add_all!(underflow) unless underflow.nil?
-
-      # Iteratively replace items, to ensure pseudo-random replacement.
-      overflow.each { |item| replace!(item) } unless overflow.nil?
-    end
-
-    # Stored items are returned and the local buffer is reset.
-    def pop
-      drain!
-    end
-
-    # Return the current number of stored traces.
-    def length
-      @items.length
-    end
-
-    # Return if the buffer is empty.
-    def empty?
-      @items.empty?
-    end
-
-    # Closes this buffer, preventing further pushing.
-    # Draining is still allowed.
-    def close
-      @closed = true
-    end
-
-    def closed?
-      @closed
-    end
-
-    protected
-
-    # Segment items into two distinct segments: underflow and overflow.
-    # Underflow are items that will fit into buffer.
-    # Overflow are items that will exceed capacity, after underflow is added.
-    # Returns each array, and nil if there is no underflow/overflow.
-    def overflow_segments(items)
-      underflow = nil
-      overflow = nil
-
-      overflow_size = @max_size > 0 ? (@items.length + items.length) - @max_size : 0
-
-      if overflow_size > 0
-        # Items will overflow
-        if overflow_size < items.length
-          # Partial overflow
-          underflow_end_index = items.length - overflow_size - 1
-          underflow = items[0..underflow_end_index]
-          overflow = items[(underflow_end_index + 1)..-1]
-        else
-          # Total overflow
-          overflow = items
-        end
-      else
-        # Items do not exceed capacity.
-        underflow = items
-      end
-
-      [underflow, overflow]
-    end
-
-    def full?
-      @max_size > 0 && @items.length >= @max_size
-    end
-
-    def add_all!(items)
-      @items.concat(items)
-    end
-
-    def add!(item)
-      @items << item
-    end
-
-    def replace!(item)
-      # Choose random item to be replaced
-      replace_index = rand(@items.length)
-
-      # Replace random item
-      discarded_item = @items[replace_index]
-      @items[replace_index] = item
-
-      # Return discarded item
-      discarded_item
-    end
-
-    def drain!
-      items = @items
-      @items = []
-      items
-    end
-  end
-
-  # Buffer that stores objects, has a maximum size, and
-  # can be safely used concurrently on any environment.
-  #
-  # This implementation uses a {Mutex} around public methods, incurring
-  # overhead in order to ensure thread-safety.
-  #
-  # This is implementation is recommended for non-CRuby environments.
-  # If using CRuby, {Datadog::CRubyBuffer} is a faster implementation with minimal compromise.
-  class ThreadSafeBuffer < Buffer
-    def initialize(max_size)
-      super
-
-      @mutex = Mutex.new
-    end
-
-    # Add a new ``item`` in the local queue. This method doesn't block the execution
-    # even if the buffer is full. In that case, a random item is discarded.
-    def push(item)
-      synchronize { super }
-    end
-
-    def concat(items)
-      synchronize { super }
-    end
-
-    # Return the current number of stored traces.
-    def length
-      synchronize { super }
-    end
-
-    # Return if the buffer is empty.
-    def empty?
-      synchronize { super }
-    end
-
-    # Stored traces are returned and the local buffer is reset.
-    def pop
-      synchronize { super }
-    end
-
-    def close
-      synchronize { super }
-    end
-
-    def synchronize(&block)
-      @mutex.synchronize(&block)
-    end
-  end
-
-  # Buffer that stores objects, has a maximum size, and
-  # can be safely used concurrently with CRuby.
-  #
-  # Under extreme concurrency scenarios, this class can exceed
-  # its +max_size+ by up to 4%.
-  #
-  # Because singular +Array+ operations are thread-safe in CRuby,
-  # we can implement the trace buffer without an explicit lock,
-  # while making the compromise of allowing the buffer to go
-  # over its maximum limit under extreme circumstances.
-  #
-  # On the following scenario:
-  # * 4.5 million spans/second.
-  # * Pushed into a single CRubyTraceBuffer from 1000 threads.
-  # The buffer can exceed its maximum size by no more than 4%.
-  #
-  # This implementation allocates less memory and is faster
-  # than {Datadog::ThreadSafeBuffer}.
-  #
-  # @see spec/ddtrace/benchmark/buffer_benchmark_spec.rb Buffer benchmarks
-  # @see https://github.com/ruby-concurrency/concurrent-ruby/blob/c1114a0c6891d9634f019f1f9fe58dcae8658964/lib/concurrent-ruby/concurrent/array.rb#L23-L27
-  class CRubyBuffer < Buffer
-    # Add a new ``trace`` in the local queue. This method doesn't block the execution
-    # even if the buffer is full. In that case, a random trace is discarded.
-    def replace!(item)
-      # we should replace a random trace with the new one
-      replace_index = rand(@items.size)
-      replaced_trace = @items.delete_at(replace_index)
-      @items << item
-
-      # We might have deleted an element right when the buffer
-      # was drained, thus +replaced_trace+ will be +nil+.
-      # In that case, nothing was replaced, and this method
-      # performed a simple insertion into the buffer.
-      replaced_trace
-    end
-  end
-
-  # Health metrics for trace buffers.
-  module MeasuredBuffer
-    def initialize(*_)
-      super
-
-      @buffer_accepted = 0
-      @buffer_accepted_lengths = 0
-      @buffer_dropped = 0
-      @buffer_spans = 0
-    end
-
-    def add!(trace)
-      super
-
-      # Emit health metrics
-      measure_accept(trace)
-    end
-
-    def add_all!(traces)
-      super
-
-      # Emit health metrics
-      traces.each { |trace| measure_accept(trace) }
-    end
-
-    def replace!(trace)
-      discarded_trace = super
-
-      # Emit health metrics
-      measure_accept(trace)
-      measure_drop(discarded_trace) if discarded_trace
-
-      discarded_trace
-    end
-
-    # Stored traces are returned and the local buffer is reset.
-    def drain!
-      traces = super
-      measure_pop(traces)
-      traces
-    end
-
-    def measure_accept(trace)
-      @buffer_accepted += 1
-      @buffer_accepted_lengths += trace.length
-
-      @buffer_spans += trace.length
-    rescue StandardError => e
-      Datadog.logger.debug("Failed to measure queue accept. Cause: #{e.message} Source: #{e.backtrace.first}")
-    end
-
-    def measure_drop(trace)
-      @buffer_dropped += 1
-
-      @buffer_spans -= trace.length
-    rescue StandardError => e
-      Datadog.logger.debug("Failed to measure queue drop. Cause: #{e.message} Source: #{e.backtrace.first}")
-    end
-
-    def measure_pop(traces)
-      # Accepted, cumulative totals
-      Datadog.health_metrics.queue_accepted(@buffer_accepted)
-      Datadog.health_metrics.queue_accepted_lengths(@buffer_accepted_lengths)
-
-      # Dropped, cumulative totals
-      Datadog.health_metrics.queue_dropped(@buffer_dropped)
-      # TODO: are we missing a +queue_dropped_lengths+ metric?
-
-      # Queue gauges, current values
-      Datadog.health_metrics.queue_max_length(@max_size)
-      Datadog.health_metrics.queue_spans(@buffer_spans)
-      Datadog.health_metrics.queue_length(traces.length)
-
-      # Reset aggregated metrics
-      @buffer_accepted = 0
-      @buffer_accepted_lengths = 0
-      @buffer_dropped = 0
-      @buffer_spans = 0
-    rescue StandardError => e
-      Datadog.logger.debug("Failed to measure queue. Cause: #{e.message} Source: #{e.backtrace.first}")
-    end
-  end
-
-  # Trace buffer that stores application traces, has a maximum size, and
-  # can be safely used concurrently on any environment.
-  #
-  # @see {Datadog::ThreadSafeBuffer}
-  class ThreadSafeTraceBuffer < ThreadSafeBuffer
-    prepend MeasuredBuffer
-  end
-
-  # Trace buffer that stores application traces, has a maximum size, and
-  # can be safely used concurrently with CRuby.
-  #
-  # @see {Datadog::CRubyBuffer}
-  class CRubyTraceBuffer < CRubyBuffer
-    prepend MeasuredBuffer
-  end
-
-  # Trace buffer that stores application traces. The buffer has a maximum size and when
-  # the buffer is full, a random trace is discarded. This class is thread-safe and is used
-  # automatically by the ``Tracer`` instance when a ``Span`` is finished.
-  #
-  # We choose the default TraceBuffer implementation for current platform dynamically here.
-  #
-  # TODO We should restructure this module, so that classes are not declared at top-level ::Datadog.
-  # TODO Making such a change is potentially breaking for users manually configuring the tracer.
-  TraceBuffer = if Datadog::Ext::Runtime::RUBY_ENGINE == 'ruby'
-                  CRubyTraceBuffer
-                else
-                  ThreadSafeTraceBuffer
-                end
-end

data/lib/ddtrace/chunker.rb

@@ -1,34 +0,0 @@
-require 'json'
-require 'msgpack'
-
-module Datadog
-  # Chunks list of elements into batches
-  module Chunker
-    module_function
-
-    # Chunks a list into batches of at most +max_chunk_size+ elements each.
-    #
-    # An exception can occur if a single element is too large. That single
-    # element will be returned in its own chunk. You have to verify by yourself
-    # when such elements are returned.
-    #
-    # @param list [Enumerable] list of elements
-    # @param max_chunk_size [Numeric] maximum acceptable chunk size
-    # @return [Enumerable] lazy list of chunks
-    def chunk_by_size(list, max_chunk_size)
-      chunk_agg = 0
-      list.slice_before do |elem|
-        size = elem.size
-        chunk_agg += size
-        if chunk_agg > max_chunk_size
-          # Can't fit element in current chunk, start a new one.
-          chunk_agg = size
-          true
-        else
-          # Add to current chunk
-          false
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/configuration/agent_settings_resolver.rb

@@ -1,241 +0,0 @@
-require 'uri'
-
-require 'ddtrace/ext/transport'
-require 'ddtrace/configuration/settings'
-
-module Datadog
-  module Configuration
-    # This class unifies all the different ways that users can configure how we talk to the agent.
-    #
-    # It has quite a lot of complexity, but this complexity just reflects the actual complexity we have around our
-    # configuration today. E.g., this is just all of the complexity regarding agent settings gathered together in a
-    # single place. As we deprecate more and more of the different ways that these things can be configured,
-    # this class will reflect that simplification as well.
-    #
-    # Whenever there is a conflict (different configurations are provided in different orders), it MUST warn the users
-    # about it and pick a value based on the following priority: code > environment variable > defaults.
-    #
-    # rubocop:disable Metrics/ClassLength
-    class AgentSettingsResolver
-      AgentSettings = \
-        Struct.new(
-          :ssl,
-          :hostname,
-          :port,
-          :timeout_seconds,
-          :deprecated_for_removal_transport_configuration_proc,
-          :deprecated_for_removal_transport_configuration_options
-        ) do
-          def initialize(
-            # Hacky required kw args, we can get rid of this when we drop Ruby 2.0
-            ssl: raise(ArgumentError, 'missing keyword :ssl'),
-            hostname: raise(ArgumentError, 'missing keyword :hostname'),
-            port: raise(ArgumentError, 'missing keyword :port'),
-            timeout_seconds: raise(ArgumentError, 'missing keyword :timeout_seconds'),
-            deprecated_for_removal_transport_configuration_proc: \
-              raise(ArgumentError, 'missing keyword :deprecated_for_removal_transport_configuration_proc'),
-            deprecated_for_removal_transport_configuration_options: \
-              raise(ArgumentError, 'missing keyword :deprecated_for_removal_transport_configuration_options')
-          )
-            super(ssl, hostname, port, timeout_seconds, deprecated_for_removal_transport_configuration_proc, \
-              deprecated_for_removal_transport_configuration_options)
-            freeze
-          end
-        end
-
-      def self.call(settings, logger: Datadog.logger)
-        new(settings, logger: logger).send(:call)
-      end
-
-      private
-
-      attr_reader \
-        :logger,
-        :settings
-
-      def initialize(settings, logger: Datadog.logger)
-        @settings = settings
-        @logger = logger
-      end
-
-      def call
-        AgentSettings.new(
-          ssl: ssl?,
-          hostname: hostname,
-          port: port,
-          timeout_seconds: timeout_seconds,
-          # NOTE: When provided, the deprecated_for_removal_transport_configuration_proc can override all
-          # values above (ssl, hostname, port, timeout), or even make them irrelevant (by using an unix socket or
-          # enabling test mode instead).
-          # That is the main reason why it is deprecated -- it's an opaque function that may set a bunch of settings
-          # that we know nothing of until we actually call it.
-          deprecated_for_removal_transport_configuration_proc: deprecated_for_removal_transport_configuration_proc,
-          deprecated_for_removal_transport_configuration_options: deprecated_for_removal_transport_configuration_options
-        )
-      end
-
-      def hostname
-        pick_from(
-          configurations_in_priority_order: [
-            DetectedConfiguration.new(
-              friendly_name: "'c.tracer.hostname'",
-              value: settings.tracer.hostname
-            ),
-            DetectedConfiguration.new(
-              friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL} environment variable",
-              value: parsed_url && parsed_url.hostname
-            ),
-            DetectedConfiguration.new(
-              friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_HOST} environment variable",
-              value: ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_HOST]
-            )
-          ],
-          or_use_default: Datadog::Ext::Transport::HTTP::DEFAULT_HOST
-        )
-      end
-
-      def port
-        port_from_env = ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT]
-        parsed_port_from_env =
-          if port_from_env
-            begin
-              Integer(port_from_env)
-            rescue ArgumentError
-              log_warning(
-                "Invalid value for #{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT} environment variable " \
-                "('#{port_from_env}'). Ignoring this configuration."
-              )
-            end
-          end
-
-        pick_from(
-          configurations_in_priority_order: [
-            DetectedConfiguration.new(
-              friendly_name: '"c.tracer.port"',
-              value: settings.tracer.port
-            ),
-            DetectedConfiguration.new(
-              friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL} environment variable",
-              value: parsed_url && parsed_url.port
-            ),
-            DetectedConfiguration.new(
-              friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT} environment variable",
-              value: parsed_port_from_env
-            )
-          ],
-          or_use_default: Datadog::Ext::Transport::HTTP::DEFAULT_PORT
-        )
-      end
-
-      def ssl?
-        !parsed_url.nil? && parsed_url.scheme == 'https'
-      end
-
-      def timeout_seconds
-        Datadog::Ext::Transport::HTTP::DEFAULT_TIMEOUT_SECONDS
-      end
-
-      def deprecated_for_removal_transport_configuration_proc
-        settings.tracer.transport_options if settings.tracer.transport_options.is_a?(Proc)
-      end
-
-      def deprecated_for_removal_transport_configuration_options
-        options = settings.tracer.transport_options
-
-        if options.is_a?(Hash) && !options.empty?
-          log_warning(
-            'Configuring the tracer via a c.tracer.transport_options hash is deprecated for removal in a future ' \
-            "ddtrace version (c.tracer.transport_options contained '#{options.inspect}')."
-          )
-
-          options
-        end
-      end
-
-      def parsed_url
-        return @parsed_url if defined?(@parsed_url)
-
-        @parsed_url =
-          if unparsed_url_from_env
-            parsed = URI.parse(unparsed_url_from_env)
-
-            if %w[http https].include?(parsed.scheme)
-              parsed
-            else
-              log_warning(
-                "Invalid URI scheme '#{parsed.scheme}' for #{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL} " \
-                "environment variable ('#{unparsed_url_from_env}'). " \
-                "Ignoring the contents of #{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL}."
-              )
-
-              nil
-            end
-          end
-      end
-
-      # NOTE: This should only be used AFTER parsing, via `#parsed_url`. The only other use-case where this can be used
-      # directly without parsing, is when displaying in warning messages, to show users what it actually contains.
-      def unparsed_url_from_env
-        @unparsed_url_from_env ||= ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL]
-      end
-
-      def pick_from(
-        # Hacky required kw args, we can get rid of this when we drop Ruby 2.0
-        configurations_in_priority_order: raise(ArgumentError, 'missing keyword :configurations'),
-        or_use_default: raise(ArgumentError, 'missing keyword :or_use_default')
-      )
-        detected_configurations_in_priority_order = configurations_in_priority_order.select(&:value?)
-
-        if detected_configurations_in_priority_order.any?
-          warn_if_configuration_mismatch(detected_configurations_in_priority_order)
-
-          # The configurations are listed in priority, so we only need to look at the first; if there's more than
-          # one, we emit a warning above
-          detected_configurations_in_priority_order.first.value
-        else
-          or_use_default
-        end
-      end
-
-      def warn_if_configuration_mismatch(detected_configurations_in_priority_order)
-        return unless detected_configurations_in_priority_order.map(&:value).uniq.size > 1
-
-        log_warning(
-          'Configuration mismatch: values differ between ' \
-          "#{detected_configurations_in_priority_order
-            .map { |config| "#{config.friendly_name} ('#{config.value}')" }.join(' and ')}" \
-          ". Using '#{detected_configurations_in_priority_order.first.value}'."
-        )
-      end
-
-      def log_warning(message)
-        logger.warn(message) if logger
-      end
-
-      DetectedConfiguration = Struct.new(:friendly_name, :value) do
-        def initialize(
-          # Hacky required kw args, we can get rid of this when we drop Ruby 2.0
-          friendly_name: raise(ArgumentError, 'missing keyword :friendly_name'),
-          value: raise(ArgumentError, 'missing keyword :value')
-        )
-          super(friendly_name, value)
-          freeze
-        end
-
-        def value?
-          !value.nil?
-        end
-      end
-      private_constant :DetectedConfiguration
-
-      # NOTE: Due to... legacy reasons... Some classes like having an `AgentSettings` instance to fall back to.
-      # Because we generate this instance with an empty instance of `Settings`, the resulting `AgentSettings` below
-      # represents only settings specified via environment variables + the usual defaults.
-      #
-      # YOU DO NOT WANT TO USE THE BELOW INSTANCE ON ANY NEWLY WRITTEN CODE, as it ignores any settings specified
-      # by users via `Datadog.configure`.
-      ENVIRONMENT_AGENT_SETTINGS = call(Settings.new, logger: nil)
-    end
-    # rubocop:enable Metrics/ClassLength
-  end
-end

data/lib/ddtrace/configuration/base.rb

@@ -1,84 +0,0 @@
-require 'ddtrace/environment'
-require 'ddtrace/configuration/options'
-
-module Datadog
-  module Configuration
-    # Basic configuration behavior
-    module Base
-      def self.included(base)
-        base.send(:extend, Datadog::Environment::Helpers)
-        base.send(:include, Datadog::Environment::Helpers)
-        base.send(:include, Options)
-
-        base.send(:extend, ClassMethods)
-        base.send(:include, InstanceMethods)
-      end
-
-      # Class methods for configuration
-      module ClassMethods
-        protected
-
-        # Allows subgroupings of settings to be defined.
-        # e.g. `settings :foo { option :bar }` --> `config.foo.bar`
-        def settings(name, &block)
-          settings_class = new_settings_class(&block)
-
-          option(name) do |o|
-            o.default { settings_class.new }
-            o.lazy
-            o.resetter do |value|
-              value.reset! if value.respond_to?(:reset!)
-              value
-            end
-          end
-        end
-
-        private
-
-        def new_settings_class(&block)
-          Class.new { include Datadog::Configuration::Base }.tap do |klass|
-            klass.instance_eval(&block) if block
-          end
-        end
-      end
-
-      # Instance methods for configuration
-      module InstanceMethods
-        def initialize(options = {})
-          configure(options) unless options.empty?
-        end
-
-        def configure(opts = {})
-          # Sort the options in preference of dependency order first
-          ordering = self.class.options.dependency_order
-          sorted_opts = opts.sort_by do |name, _value|
-            ordering.index(name) || (ordering.length + 1)
-          end
-
-          # Ruby 2.0 doesn't support Array#to_h
-          sorted_opts = Hash[*sorted_opts.flatten]
-
-          # Apply options in sort order
-          sorted_opts.each do |name, value|
-            if respond_to?("#{name}=")
-              send("#{name}=", value)
-            elsif option_defined?(name)
-              set_option(name, value)
-            end
-          end
-
-          # Apply any additional settings from block
-          yield(self) if block_given?
-        end
-
-        def to_h
-          options_hash
-        end
-
-        def reset!
-          reset_options!
-        end
-      end
-    end
-  end
-end