ddtrace 0.54.2 → 1.4.0

data/lib/datadog/core/buffer/cruby.rb

@@ -0,0 +1,55 @@
+# typed: true
+
+require_relative 'random'
+
+module Datadog
+  module Core
+    module Buffer
+      # Buffer that stores objects, has a maximum size, and
+      # can be safely used concurrently with CRuby.
+      #
+      # Because singular +Array+ operations are thread-safe in CRuby,
+      # we can implement the 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.
+      #
+      # This implementation allocates less memory and is faster
+      # than {Datadog::Core::Buffer::ThreadSafe}.
+      #
+      # @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 CRuby < Random
+        # A very large number to allow us to effectively
+        # drop all items when invoking `slice!(i, FIXNUM_MAX)`.
+        FIXNUM_MAX = (1 << 62) - 1
+
+        # 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 replace!(item)
+          # Ensure buffer stays within +max_size+ items.
+          # This can happen when there's concurrent modification
+          # between a call the check in `full?` and the `add!` call in
+          # `full? ? replace!(item) : add!(item)`.
+          #
+          # We can still have `@items.size > @max_size` for a short period of
+          # time, but we will always try to correct it here.
+          #
+          # `slice!` is performed before `delete_at` & `<<` to avoid always
+          # removing the item that was just inserted.
+          #
+          # DEV: `slice!` with two integer arguments is ~10% faster than
+          # `slice!` with a {Range} argument.
+          @items.slice!(@max_size, FIXNUM_MAX)
+
+          # We should replace a random item with the new one
+          replace_index = rand(@max_size)
+          @items[replace_index] = item
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/buffer/random.rb

@@ -0,0 +1,134 @@
+# typed: true
+
+module Datadog
+  module Core
+    module Buffer
+      # Buffer that accumulates items for a consumer.
+      # Consumption can happen from a different thread.
+
+      # Buffer that stores objects. The buffer has a maximum size and when
+      # the buffer is full, a random object is discarded.
+      class Random
+        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.
+        #
+        # When the buffer is full, we try to ensure that we are fairly choosing newly
+        # pushed items by randomly inserting them into the buffer slots. This discards
+        # old items randomly while trying to ensure that recent items are still captured.
+        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 items.
+        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 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
+    end
+  end
+end

data/lib/datadog/core/buffer/thread_safe.rb

@@ -0,0 +1,58 @@
+# typed: true
+
+require_relative 'random'
+
+module Datadog
+  module Core
+    module Buffer
+      # 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::Core::Buffer::CRuby} is a faster implementation with minimal compromise.
+      class ThreadSafe < Random
+        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 items.
+        def length
+          synchronize { super }
+        end
+
+        # Return if the buffer is empty.
+        def empty?
+          synchronize { super }
+        end
+
+        # Stored items 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
+    end
+  end
+end

data/lib/datadog/core/chunker.rb

@@ -0,0 +1,35 @@
+# typed: false
+
+module Datadog
+  module Core
+    # 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
+end

data/lib/datadog/core/configuration/agent_settings_resolver.rb

@@ -0,0 +1,365 @@
+# typed: true
+
+require 'uri'
+
+require_relative 'settings'
+require_relative '../../tracing/configuration/ext'
+require_relative '../../../ddtrace/transport/ext'
+
+module Datadog
+  module Core
+    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(
+            :adapter,
+            :ssl,
+            :hostname,
+            :port,
+            :uds_path,
+            :timeout_seconds,
+            :deprecated_for_removal_transport_configuration_proc,
+          ) do
+            def initialize(
+              adapter:,
+              ssl:,
+              hostname:,
+              port:,
+              uds_path:,
+              timeout_seconds:,
+              deprecated_for_removal_transport_configuration_proc:
+            )
+              super(
+                adapter,
+                ssl,
+                hostname,
+                port,
+                uds_path,
+                timeout_seconds,
+                deprecated_for_removal_transport_configuration_proc
+              )
+              freeze
+            end
+
+            # Returns a frozen copy of this struct
+            # with the provided +member_values+ modified.
+            #
+            # TODO: This is only used when configuring profiling, and can be removed once
+            # https://github.com/DataDog/dd-trace-rb/pull/1924 is merged
+            def merge(**member_values)
+              new_struct = dup
+
+              member_values.each do |member, value|
+                new_struct[member] = value
+              end
+
+              new_struct.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
+          # A transport_options proc configured for unix domain socket overrides most of the logic on this file
+          if transport_options.adapter == Transport::Ext::UnixSocket::ADAPTER
+            return AgentSettings.new(
+              adapter: Transport::Ext::UnixSocket::ADAPTER,
+              ssl: false,
+              hostname: nil,
+              port: nil,
+              uds_path: transport_options.uds_path,
+              timeout_seconds: timeout_seconds,
+              deprecated_for_removal_transport_configuration_proc: nil,
+            )
+          end
+
+          AgentSettings.new(
+            adapter: adapter,
+            ssl: ssl?,
+            hostname: hostname,
+            port: port,
+            uds_path: uds_path,
+            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,
+          )
+        end
+
+        def adapter
+          # If no agent settings have been provided, we try to connect using a local unix socket.
+          # We only do so if the socket is present when `ddtrace` runs.
+          if should_use_uds_fallback?
+            Transport::Ext::UnixSocket::ADAPTER
+          else
+            Transport::Ext::HTTP::ADAPTER
+          end
+        end
+
+        def configured_hostname
+          return @configured_hostname if defined?(@configured_hostname)
+
+          @configured_hostname = pick_from(
+            DetectedConfiguration.new(
+              friendly_name: "'c.tracing.transport_options'",
+              value: transport_options.hostname,
+            ),
+            DetectedConfiguration.new(
+              friendly_name: "'c.agent.host'",
+              value: settings.agent.host
+            ),
+            DetectedConfiguration.new(
+              friendly_name: "#{Datadog::Tracing::Configuration::Ext::Transport::ENV_DEFAULT_URL} environment variable",
+              value: parsed_url && parsed_url.hostname
+            ),
+            DetectedConfiguration.new(
+              friendly_name: "#{Datadog::Tracing::Configuration::Ext::Transport::ENV_DEFAULT_HOST} environment variable",
+              value: ENV[Datadog::Tracing::Configuration::Ext::Transport::ENV_DEFAULT_HOST]
+            )
+          )
+        end
+
+        def configured_port
+          return @configured_port if defined?(@configured_port)
+
+          @configured_port = pick_from(
+            try_parsing_as_integer(
+              friendly_name: "'c.tracing.transport_options'",
+              value: transport_options.port,
+            ),
+            try_parsing_as_integer(
+              friendly_name: '"c.agent.port"',
+              value: settings.agent.port,
+            ),
+            DetectedConfiguration.new(
+              friendly_name: "#{Datadog::Tracing::Configuration::Ext::Transport::ENV_DEFAULT_URL} environment variable",
+              value: parsed_url && parsed_url.port,
+            ),
+            try_parsing_as_integer(
+              friendly_name: "#{Datadog::Tracing::Configuration::Ext::Transport::ENV_DEFAULT_PORT} environment variable",
+              value: ENV[Datadog::Tracing::Configuration::Ext::Transport::ENV_DEFAULT_PORT],
+            )
+          )
+        end
+
+        def try_parsing_as_integer(value:, friendly_name:)
+          value =
+            begin
+              Integer(value) if value
+            rescue ArgumentError, TypeError
+              log_warning("Invalid value for #{friendly_name} (#{value.inspect}). Ignoring this configuration.")
+
+              nil
+            end
+
+          DetectedConfiguration.new(friendly_name: friendly_name, value: value)
+        end
+
+        def ssl?
+          transport_options.ssl ||
+            (!parsed_url.nil? && parsed_url.scheme == 'https')
+        end
+
+        def hostname
+          configured_hostname || (should_use_uds_fallback? ? nil : Datadog::Transport::Ext::HTTP::DEFAULT_HOST)
+        end
+
+        def port
+          configured_port || (should_use_uds_fallback? ? nil : Datadog::Transport::Ext::HTTP::DEFAULT_PORT)
+        end
+
+        # Unix socket path in the file system
+        def uds_path
+          uds_fallback
+        end
+
+        # Defaults to +nil+, letting the adapter choose what default
+        # works best in their case.
+        def timeout_seconds
+          transport_options.timeout_seconds
+        end
+
+        # In transport_options, we try to invoke the transport_options proc and get its configuration. In case that
+        # doesn't work, we include the proc directly in the agent settings result.
+        def deprecated_for_removal_transport_configuration_proc
+          if settings.tracing.transport_options.is_a?(Proc) && transport_options.adapter.nil?
+            settings.tracing.transport_options
+          end
+        end
+
+        # We only use the default unix socket if it is already present.
+        # This is by design, as we still want to use the default host:port if no unix socket is present.
+        def uds_fallback
+          return @uds_fallback if defined?(@uds_fallback)
+
+          @uds_fallback =
+            if configured_hostname.nil? &&
+                configured_port.nil? &&
+                deprecated_for_removal_transport_configuration_proc.nil? &&
+                File.exist?(Transport::Ext::UnixSocket::DEFAULT_PATH)
+
+              Transport::Ext::UnixSocket::DEFAULT_PATH
+            end
+        end
+
+        def should_use_uds_fallback?
+          uds_fallback != nil
+        end
+
+        def parsed_url
+          return @parsed_url if defined?(@parsed_url)
+
+          unparsed_url_from_env = ENV[Datadog::Tracing::Configuration::Ext::Transport::ENV_DEFAULT_URL]
+
+          @parsed_url =
+            if unparsed_url_from_env
+              parsed = URI.parse(unparsed_url_from_env)
+
+              if %w[http https].include?(parsed.scheme)
+                parsed
+              else
+                # rubocop:disable Layout/LineLength
+                log_warning(
+                  "Invalid URI scheme '#{parsed.scheme}' for #{Datadog::Tracing::Configuration::Ext::Transport::ENV_DEFAULT_URL} " \
+                  "environment variable ('#{unparsed_url_from_env}'). " \
+                  "Ignoring the contents of #{Datadog::Tracing::Configuration::Ext::Transport::ENV_DEFAULT_URL}."
+                )
+                # rubocop:enable Layout/LineLength
+
+                nil
+              end
+            end
+        end
+
+        def pick_from(*configurations_in_priority_order)
+          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
+          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.inspect})" }.join(' and ')}" \
+            ". Using #{detected_configurations_in_priority_order.first.value.inspect}."
+          )
+        end
+
+        def log_warning(message)
+          logger.warn(message) if logger
+        end
+
+        # The settings.tracing.transport_options allows users to have full control over the settings used to
+        # communicate with the agent. In the general case, we can't extract the configuration from this proc, but
+        # in the specific case of the http and unix socket adapters we can, and we use this method together with the
+        # `TransportOptionsResolver` to call the proc and extract its information.
+        def transport_options
+          return @transport_options if defined?(@transport_options)
+
+          transport_options_proc = settings.tracing.transport_options
+
+          @transport_options = TransportOptions.new
+
+          if transport_options_proc.is_a?(Proc)
+            begin
+              transport_options_proc.call(TransportOptionsResolver.new(@transport_options))
+            rescue NoMethodError => e
+              if logger
+                logger.debug do
+                  'Could not extract configuration from transport_options proc. ' \
+                  "Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+                end
+              end
+
+              # Reset the object; we shouldn't return the same one we passed into the proc as it may have
+              # some partial configuration and we want all-or-nothing.
+              @transport_options = TransportOptions.new
+            end
+          end
+
+          @transport_options.freeze
+        end
+
+        # Represents a given configuration value and where we got it from
+        class DetectedConfiguration
+          attr_reader :friendly_name, :value
+
+          def initialize(friendly_name:, value:)
+            @friendly_name = friendly_name
+            @value = value
+            freeze
+          end
+
+          def value?
+            !value.nil?
+          end
+        end
+        private_constant :DetectedConfiguration
+
+        # Used to contain information extracted from the transport_options proc (see #transport_options above)
+        TransportOptions = Struct.new(:adapter, :hostname, :port, :timeout_seconds, :ssl, :uds_path)
+        private_constant :TransportOptions
+
+        # Used to extract information from the transport_options proc (see #transport_options above)
+        class TransportOptionsResolver
+          def initialize(transport_options)
+            @transport_options = transport_options
+          end
+
+          def adapter(kind_or_custom_adapter, *args, **kwargs)
+            case kind_or_custom_adapter
+            when Datadog::Transport::Ext::HTTP::ADAPTER
+              @transport_options.adapter = Datadog::Transport::Ext::HTTP::ADAPTER
+              @transport_options.hostname = args[0] || kwargs[:hostname]
+              @transport_options.port = args[1] || kwargs[:port]
+              @transport_options.timeout_seconds = kwargs[:timeout]
+              @transport_options.ssl = kwargs[:ssl]
+            when Datadog::Transport::Ext::UnixSocket::ADAPTER
+              @transport_options.adapter = Datadog::Transport::Ext::UnixSocket::ADAPTER
+              @transport_options.uds_path = args[0] || kwargs[:uds_path]
+            end
+
+            nil
+          end
+        end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end