ddtrace 1.12.1 → 1.23.2

data/lib/datadog/core/transport/http/negotiation.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-require_relative '../negotiation'
-require_relative 'client'
-require_relative '../../../../ddtrace/transport/http/response'
-require_relative '../../../../ddtrace/transport/http/api/endpoint'
-
-# TODO: Decouple standard transport/http/api/instance
-#
-# Separate classes are needed because transport/http/trace includes
-# Trace::API::Instance which closes over and uses a single spec, which is
-# negotiated as either /v3 or /v4 for the whole API at the spec level, but we
-# need an independent toplevel path at the endpoint level.
-#
-# Separate classes are needed because of `include Trace::API::Instance`.
-#
-# Below should be:
-# require_relative '../../../../ddtrace/transport/http/api/instance'
-require_relative 'api/instance'
-# Below should be:
-# require_relative '../../../../ddtrace/transport/http/api/spec'
-require_relative 'api/spec'
-
-module Datadog
-  module Core
-    module Transport
-      module HTTP
-        # HTTP transport behavior for agent feature negotiation
-        module Negotiation
-          # Response from HTTP transport for agent feature negotiation
-          class Response
-            include Datadog::Transport::HTTP::Response
-            include Core::Transport::Negotiation::Response
-
-            def initialize(http_response, options = {})
-              super(http_response)
-
-              # TODO: transform endpoint hash in a better object for negotiation
-              # TODO: transform config in a better object, notably config has max_request_bytes
-              @version = options[:version]
-              @endpoints = options[:endpoints]
-              @config = options[:config]
-            end
-          end
-
-          # Extensions for HTTP client
-          module Client
-            def send_info_payload(request)
-              send_request(request) do |api, env|
-                api.send_info(env)
-              end
-            end
-          end
-
-          module API
-            # Extensions for HTTP API Spec
-            module Spec
-              attr_reader :info
-
-              def info=(endpoint)
-                @info = endpoint
-              end
-
-              def send_info(env, &block)
-                raise NoNegotiationEndpointDefinedError, self if info.nil?
-
-                info.call(env, &block)
-              end
-
-              # Raised when traces sent but no traces endpoint is defined
-              class NoNegotiationEndpointDefinedError < StandardError
-                attr_reader :spec
-
-                def initialize(spec)
-                  super()
-
-                  @spec = spec
-                end
-
-                def message
-                  'No info endpoint is defined for API specification!'
-                end
-              end
-            end
-
-            # Extensions for HTTP API Instance
-            module Instance
-              def send_info(env)
-                raise NegotiationNotSupportedError, spec unless spec.is_a?(Negotiation::API::Spec)
-
-                spec.send_info(env) do |request_env|
-                  call(request_env)
-                end
-              end
-
-              # Raised when traces sent to API that does not support traces
-              class NegotiationNotSupportedError < StandardError
-                attr_reader :spec
-
-                def initialize(spec)
-                  super()
-
-                  @spec = spec
-                end
-
-                def message
-                  'Info not supported for this API!'
-                end
-              end
-            end
-
-            # Endpoint for negotiation
-            class Endpoint < Datadog::Transport::HTTP::API::Endpoint
-              def initialize(path)
-                super(:get, path)
-              end
-
-              def call(env, &block)
-                # Query for response
-                http_response = super(env, &block)
-
-                # Process the response
-                body = JSON.parse(http_response.payload, symbolize_names: true) if http_response.ok?
-
-                # TODO: there should be more processing here to ensure a proper response_options
-                response_options = body.is_a?(Hash) ? body : {}
-
-                # Build and return a trace response
-                Negotiation::Response.new(http_response, response_options)
-              end
-            end
-          end
-
-          # Add negotiation behavior to transport components
-          HTTP::Client.include(Negotiation::Client)
-          HTTP::API::Spec.include(Negotiation::API::Spec)
-          HTTP::API::Instance.include(Negotiation::API::Instance)
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/transport/http.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-require 'uri'
-
-require_relative '../environment/container'
-require_relative '../environment/ext'
-require_relative '../../../ddtrace/transport/ext'
-require_relative '../../../ddtrace/transport/http/adapters/net'
-require_relative '../../../ddtrace/transport/http/adapters/test'
-require_relative '../../../ddtrace/transport/http/adapters/unix_socket'
-
-# TODO: Improve negotiation to allow per endpoint selection
-#
-# Since endpoint negotiation happens at the `API::Spec` level there can not be
-# a mix of enpoints at various versions or versionless without describing all
-# the possible combinations as specs. See http/api.
-#
-# Below should be:
-# require_relative '../../../ddtrace/transport/http/api'
-require_relative 'http/api'
-
-# TODO: Decouple transport/http/builder
-#
-# See http/builder
-#
-# Below should be:
-# require_relative '../../../ddtrace/transport/http/builder'
-require_relative 'http/builder'
-
-# TODO: Decouple transport/http
-#
-# Because a new transport is required for every (API, Client, Transport)
-# triplet and endpoints cannot be negotiated independently, there can not be a
-# single `default` transport, but only endpoint-specific ones.
-
-module Datadog
-  module Core
-    module Transport
-      # Namespace for HTTP transport components
-      module HTTP
-        # NOTE: Due to... legacy reasons... This class likes having a default `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.
-        #
-        # DO NOT USE THIS IN NEW CODE, as it ignores any settings specified by users via `Datadog.configure`.
-        DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS = Datadog::Core::Configuration::AgentSettingsResolver.call(
-          Datadog::Core::Configuration::Settings.new,
-          logger: nil,
-        )
-
-        module_function
-
-        # Builds a new Transport::HTTP::Client
-        def new(klass, &block)
-          Builder.new(&block).to_transport(klass)
-        end
-
-        # Builds a new Transport::HTTP::Client with default settings
-        # Pass a block to override any settings.
-        def root(
-          agent_settings: DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS,
-          **options
-        )
-          new(Transport::Negotiation::Transport) do |transport|
-            transport.adapter(agent_settings)
-            transport.headers(default_headers)
-
-            apis = API.defaults
-
-            transport.api API::ROOT, apis[API::ROOT]
-
-            # Apply any settings given by options
-            unless options.empty?
-              transport.default_api = options[:api_version] if options.key?(:api_version)
-              transport.headers options[:headers] if options.key?(:headers)
-            end
-
-            if agent_settings.deprecated_for_removal_transport_configuration_proc
-              agent_settings.deprecated_for_removal_transport_configuration_proc.call(transport)
-            end
-
-            # Call block to apply any customization, if provided
-            yield(transport) if block_given?
-          end
-        end
-
-        # Builds a new Transport::HTTP::Client with default settings
-        # Pass a block to override any settings.
-        def v7(
-          agent_settings: DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS,
-          **options
-        )
-          new(Transport::Config::Transport) do |transport|
-            transport.adapter(agent_settings)
-            transport.headers default_headers
-
-            apis = API.defaults
-
-            transport.api API::V7, apis[API::V7]
-
-            # Apply any settings given by options
-            unless options.empty?
-              transport.default_api = options[:api_version] if options.key?(:api_version)
-              transport.headers options[:headers] if options.key?(:headers)
-            end
-
-            if agent_settings.deprecated_for_removal_transport_configuration_proc
-              agent_settings.deprecated_for_removal_transport_configuration_proc.call(transport)
-            end
-
-            # Call block to apply any customization, if provided
-            yield(transport) if block_given?
-          end
-        end
-
-        def default_headers
-          {
-            Datadog::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_TOP_LEVEL => '1',
-            Datadog::Transport::Ext::HTTP::HEADER_META_LANG => Datadog::Core::Environment::Ext::LANG,
-            Datadog::Transport::Ext::HTTP::HEADER_META_LANG_VERSION => Datadog::Core::Environment::Ext::LANG_VERSION,
-            Datadog::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER =>
-              Datadog::Core::Environment::Ext::LANG_INTERPRETER,
-            Datadog::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION => Datadog::Core::Environment::Ext::TRACER_VERSION
-          }.tap do |headers|
-            # Add container ID, if present.
-            container_id = Datadog::Core::Environment::Container.container_id
-            headers[Datadog::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
-          end
-        end
-
-        def default_adapter
-          Datadog::Transport::Ext::HTTP::ADAPTER
-        end
-
-        def default_hostname(logger: Datadog.logger)
-          logger.warn(
-            'Deprecated for removal: Using #default_hostname for configuration is deprecated and will ' \
-            'be removed on a future ddtrace release.'
-          )
-
-          DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS.hostname
-        end
-
-        def default_port(logger: Datadog.logger)
-          logger.warn(
-            'Deprecated for removal: Using #default_hostname for configuration is deprecated and will ' \
-            'be removed on a future ddtrace release.'
-          )
-
-          DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS.port
-        end
-
-        def default_url(logger: Datadog.logger)
-          logger.warn(
-            'Deprecated for removal: Using #default_url for configuration is deprecated and will ' \
-            'be removed on a future ddtrace release.'
-          )
-
-          nil
-        end
-
-        # Add adapters to registry
-        Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Net, Datadog::Transport::Ext::HTTP::ADAPTER)
-        Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Test, Datadog::Transport::Ext::Test::ADAPTER)
-        Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::UnixSocket, Datadog::Transport::Ext::UnixSocket::ADAPTER)
-      end
-    end
-  end
-end

data/lib/datadog/core/utils/object_set.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'sequence'
-
-module Datadog
-  module Core
-    module Utils
-      # Acts as a unique dictionary of objects
-      class ObjectSet
-        # You can provide a block that defines how the key
-        # for this message type is resolved.
-        def initialize(seed = 0, &block)
-          @sequence = Sequence.new(seed)
-          @items = {}
-          @key_block = block
-        end
-
-        # Submit an array of arguments that define the message.
-        # If they match an existing message, it will return the
-        # matching object. If it doesn't match, it will yield to
-        # the block with the next ID & args given.
-        def fetch(*args)
-          # TODO: Array hashing is **really** expensive, we probably want to get rid of it in the future
-          key = @key_block ? @key_block.call(*args) : args.hash
-          @items[key] ||= yield(@sequence.next, *args)
-        end
-
-        def length
-          @items.length
-        end
-
-        def objects
-          @items.values
-        end
-
-        def freeze
-          super
-          @items.freeze
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/utils/string_table.rb

@@ -1,47 +0,0 @@
-require_relative 'sequence'
-
-module Datadog
-  module Core
-    module Utils
-      # Tracks strings and returns IDs
-      class StringTable
-        def initialize
-          @sequence = Sequence.new
-          @ids = { ''.freeze => @sequence.next }
-        end
-
-        # Returns an ID for the string
-        def fetch(string)
-          @ids[string.to_s] ||= @sequence.next
-        end
-
-        # Returns the canonical copy of this string
-        # Typically used for psuedo interning; reduce
-        # identical copies of a string to one object.
-        def fetch_string(string)
-          return nil if string.nil?
-
-          # Co-erce to string
-          string = string.to_s
-
-          # Add to string table if no match
-          @ids[string] = @sequence.next unless @ids.key?(string)
-
-          # Get and return matching string in table
-          # NOTE: Have to resolve the key and retrieve from table again
-          #       because "string" argument is not same object as string key.
-          id = @ids[string]
-          @ids.key(id)
-        end
-
-        def [](id)
-          @ids.key(id)
-        end
-
-        def strings
-          @ids.keys
-        end
-      end
-    end
-  end
-end

data/lib/datadog/profiling/backtrace_location.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Profiling
-    # Entity class used to represent an entry in a stack trace.
-    # Its fields are a simplified struct version of `Thread::Backtrace::Location`.
-    class BacktraceLocation
-      attr_reader \
-        :base_label,
-        :lineno,
-        :path,
-        :hash
-
-      def initialize(
-        base_label,
-        lineno,
-        path
-      )
-        @base_label = base_label
-        @lineno = lineno
-        @path = path
-        @hash = [base_label, lineno, path].hash
-      end
-
-      def ==(other)
-        hash == other.hash
-      end
-
-      def eql?(other)
-        hash == other.hash
-      end
-    end
-  end
-end

data/lib/datadog/profiling/buffer.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../core/buffer/thread_safe'
-require_relative '../core/utils/object_set'
-require_relative '../core/utils/string_table'
-
-module Datadog
-  module Profiling
-    # Profiling buffer that stores profiling events. The buffer has a maximum size and when
-    # the buffer is full, a random event is discarded. This class is thread-safe.
-    class Buffer < Core::Buffer::ThreadSafe
-      def initialize(*args)
-        super
-        @caches = {}
-        @string_table = Core::Utils::StringTable.new
-      end
-
-      def cache(cache_name)
-        synchronize do
-          @caches[cache_name] ||= Core::Utils::ObjectSet.new
-        end
-      end
-
-      def string_table
-        synchronize do
-          @string_table
-        end
-      end
-
-      protected
-
-      def drain!
-        items = super
-
-        # Clear caches
-        @caches = {}
-        @string_table = Core::Utils::StringTable.new
-
-        items
-      end
-    end
-  end
-end