ddtrace 0.54.2 → 1.18.0

data/lib/ddtrace/transport/http/adapters/net.rb

@@ -1,156 +0,0 @@
-# typed: true
-require 'ddtrace/transport/response'
-require 'ddtrace/vendor/multipart-post/net/http/post/multipart'
-
-module Datadog
-  module Transport
-    module HTTP
-      module Adapters
-        # Adapter for Net::HTTP
-        class Net
-          attr_reader \
-            :hostname,
-            :port,
-            :timeout,
-            :ssl
-
-          DEFAULT_TIMEOUT = 30
-
-          # @deprecated Positional parameters are deprecated. Use named parameters instead.
-          def initialize(hostname = nil, port = nil, **options)
-            @hostname = hostname || options.fetch(:hostname)
-            @port = port || options.fetch(:port)
-            @timeout = options[:timeout] || DEFAULT_TIMEOUT
-            @ssl = options.key?(:ssl) ? options[:ssl] == true : false
-          end
-
-          def self.build(agent_settings)
-            new(
-              hostname: agent_settings.hostname,
-              port: agent_settings.port,
-              timeout: agent_settings.timeout_seconds,
-              ssl: agent_settings.ssl
-            )
-          end
-
-          def open(&block)
-            # DEV Initializing +Net::HTTP+ directly help us avoid expensive
-            # options processing done in +Net::HTTP.start+:
-            # https://github.com/ruby/ruby/blob/b2d96abb42abbe2e01f010ffc9ac51f0f9a50002/lib/net/http.rb#L614-L618
-            req = ::Net::HTTP.new(hostname, port, nil)
-
-            req.use_ssl = ssl
-            req.open_timeout = req.read_timeout = timeout
-
-            req.start(&block)
-          end
-
-          def call(env)
-            if respond_to?(env.verb)
-              send(env.verb, env)
-            else
-              raise UnknownHTTPMethod, env
-            end
-          end
-
-          def post(env)
-            post = nil
-
-            if env.form.nil? || env.form.empty?
-              post = ::Net::HTTP::Post.new(env.path, env.headers)
-              post.body = env.body
-            else
-              post = ::Datadog::Vendor::Net::HTTP::Post::Multipart.new(
-                env.path,
-                env.form,
-                env.headers
-              )
-            end
-
-            # Connect and send the request
-            http_response = open do |http|
-              http.request(post)
-            end
-
-            # Build and return response
-            Response.new(http_response)
-          end
-
-          def url
-            "http://#{hostname}:#{port}?timeout=#{timeout}"
-          end
-
-          # Raised when called with an unknown HTTP method
-          class UnknownHTTPMethod < StandardError
-            attr_reader :verb
-
-            def initialize(verb)
-              @verb = verb
-            end
-
-            def message
-              "No matching Net::HTTP function for '#{verb}'!"
-            end
-          end
-
-          # A wrapped Net::HTTP response that implements the Transport::Response interface
-          class Response
-            include Datadog::Transport::Response
-
-            attr_reader :http_response
-
-            def initialize(http_response)
-              @http_response = http_response
-            end
-
-            def payload
-              return super if http_response.nil?
-
-              http_response.body
-            end
-
-            def code
-              return super if http_response.nil?
-
-              http_response.code.to_i
-            end
-
-            def ok?
-              return super if http_response.nil?
-
-              code.between?(200, 299)
-            end
-
-            def unsupported?
-              return super if http_response.nil?
-
-              code == 415
-            end
-
-            def not_found?
-              return super if http_response.nil?
-
-              code == 404
-            end
-
-            def client_error?
-              return super if http_response.nil?
-
-              code.between?(400, 499)
-            end
-
-            def server_error?
-              return super if http_response.nil?
-
-              code.between?(500, 599)
-            end
-
-            def inspect
-              "#{super}, http_response:#{http_response}"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/adapters/registry.rb

@@ -1,26 +0,0 @@
-# typed: true
-module Datadog
-  module Transport
-    module HTTP
-      module Adapters
-        # List of available adapters
-        class Registry
-          def initialize
-            @adapters = {}
-          end
-
-          def get(name)
-            @adapters[name]
-          end
-
-          def set(klass, name = nil)
-            name ||= klass.to_s
-            return if name.nil?
-
-            @adapters[name] = klass
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/adapters/test.rb

@@ -1,86 +0,0 @@
-# typed: true
-require 'ddtrace/transport/response'
-
-module Datadog
-  module Transport
-    module HTTP
-      module Adapters
-        # Adapter for testing
-        class Test
-          attr_reader \
-            :buffer,
-            :status
-
-          # @param buffer [Array] an optional array that will capture all spans sent to this adapter, defaults to +nil+
-          # @deprecated Positional parameters are deprecated. Use named parameters instead.
-          def initialize(buffer = nil, **options)
-            @buffer = buffer || options[:buffer]
-            @mutex = Mutex.new
-            @status = 200
-          end
-
-          def call(env)
-            add_request(env)
-            Response.new(status)
-          end
-
-          def buffer?
-            !@buffer.nil?
-          end
-
-          def add_request(env)
-            @mutex.synchronize { buffer << env } if buffer?
-          end
-
-          def set_status!(status)
-            @status = status
-          end
-
-          def url; end
-
-          # Response for test adapter
-          class Response
-            include Datadog::Transport::Response
-
-            attr_reader \
-              :body,
-              :code
-
-            def initialize(code, body = nil)
-              @code = code
-              @body = body
-            end
-
-            def payload
-              @body
-            end
-
-            def ok?
-              code.between?(200, 299)
-            end
-
-            def unsupported?
-              code == 415
-            end
-
-            def not_found?
-              code == 404
-            end
-
-            def client_error?
-              code.between?(400, 499)
-            end
-
-            def server_error?
-              code.between?(500, 599)
-            end
-
-            def inspect
-              "#{super}, code:#{code}"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/adapters/unix_socket.rb

@@ -1,78 +0,0 @@
-# typed: false
-require 'net/http'
-require 'ddtrace/ext/transport'
-require 'ddtrace/transport/http/adapters/net'
-
-module Datadog
-  module Transport
-    module HTTP
-      module Adapters
-        # Adapter for Unix sockets
-        class UnixSocket < Adapters::Net
-          attr_reader \
-            :filepath, # DEV(1.0): Rename to `uds_path`
-            :timeout
-
-          alias_method :uds_path, :filepath
-
-          # @deprecated Positional parameters are deprecated. Use named parameters instead.
-          def initialize(uds_path = nil, **options)
-            @filepath = uds_path || options.fetch(:uds_path)
-            @timeout = options[:timeout] || Ext::Transport::UnixSocket::DEFAULT_TIMEOUT_SECONDS
-          end
-
-          def self.build(agent_settings)
-            new(
-              uds_path: agent_settings.uds_path,
-              timeout: agent_settings.timeout_seconds,
-            )
-          end
-
-          def open(&block)
-            # Open connection
-            connection = HTTP.new(
-              uds_path,
-              read_timeout: timeout,
-              continue_timeout: timeout
-            )
-
-            connection.start(&block)
-          end
-
-          def url
-            "http+unix://#{uds_path}?timeout=#{timeout}"
-          end
-
-          # Re-implements Net:HTTP with underlying Unix socket
-          class HTTP < ::Net::HTTP
-            DEFAULT_TIMEOUT = 1
-
-            attr_reader \
-              :filepath, # DEV(1.0): Rename to `uds_path`
-              :unix_socket
-
-            alias_method :uds_path, :filepath
-
-            def initialize(uds_path, options = {})
-              super('localhost', 80)
-              @filepath = uds_path
-              @read_timeout = options.fetch(:read_timeout, DEFAULT_TIMEOUT)
-              @continue_timeout = options.fetch(:continue_timeout, DEFAULT_TIMEOUT)
-              @debug_output = options[:debug_output] if options.key?(:debug_output)
-            end
-
-            def connect
-              @unix_socket = UNIXSocket.open(uds_path)
-              @socket = ::Net::BufferedIO.new(@unix_socket).tap do |socket|
-                socket.read_timeout = @read_timeout
-                socket.continue_timeout = @continue_timeout
-                socket.debug_output = @debug_output
-              end
-              on_connect
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/api/endpoint.rb

@@ -1,28 +0,0 @@
-# typed: true
-require 'json'
-
-module Datadog
-  module Transport
-    module HTTP
-      module API
-        # Endpoint
-        class Endpoint
-          attr_reader \
-            :verb,
-            :path
-
-          def initialize(verb, path)
-            @verb = verb
-            @path = path
-          end
-
-          def call(env)
-            env.verb = verb
-            env.path = path
-            yield(env)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/api/fallbacks.rb

@@ -1,23 +0,0 @@
-# typed: false
-module Datadog
-  module Transport
-    module HTTP
-      module API
-        # Extension for Map with adds fallback versions.
-        module Fallbacks
-          def fallbacks
-            @fallbacks ||= {}
-          end
-
-          def with_fallbacks(fallbacks)
-            tap { add_fallbacks!(fallbacks) }
-          end
-
-          def add_fallbacks!(fallbacks)
-            self.fallbacks.merge!(fallbacks)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/api/instance.rb

@@ -1,34 +0,0 @@
-# typed: true
-module Datadog
-  module Transport
-    module HTTP
-      module API
-        # An API configured with adapter and routes
-        class Instance
-          attr_reader \
-            :adapter,
-            :headers,
-            :spec
-
-          def initialize(spec, adapter, options = {})
-            @spec = spec
-            @adapter = adapter
-            @headers = options.fetch(:headers, {})
-          end
-
-          def encoder
-            spec.encoder
-          end
-
-          def call(env)
-            # Add headers to request env, unless empty.
-            env.headers.merge!(headers) unless headers.empty?
-
-            # Send request env to the adapter.
-            adapter.call(env)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/api/map.rb

@@ -1,15 +0,0 @@
-# typed: true
-require 'ddtrace/transport/http/api/fallbacks'
-
-module Datadog
-  module Transport
-    module HTTP
-      module API
-        # A mapping of API version => API Routes/Instance
-        class Map < Hash
-          include Fallbacks
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/api/spec.rb

@@ -1,16 +0,0 @@
-# typed: true
-module Datadog
-  module Transport
-    module HTTP
-      module API
-        # Specification for an HTTP API
-        # Defines behaviors without specific configuration details.
-        class Spec
-          def initialize
-            yield(self) if block_given?
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/api.rb

@@ -1,47 +0,0 @@
-# typed: false
-require 'ddtrace/encoding'
-
-require 'ddtrace/transport/http/api/map'
-require 'ddtrace/transport/http/api/spec'
-
-require 'ddtrace/transport/http/traces'
-
-module Datadog
-  module Transport
-    module HTTP
-      # Namespace for API components
-      module API
-        # Default API versions
-        V4 = 'v0.4'.freeze
-        V3 = 'v0.3'.freeze
-        V2 = 'v0.2'.freeze
-
-        module_function
-
-        def defaults
-          Map[
-            V4 => Spec.new do |s|
-              s.traces = Traces::API::Endpoint.new(
-                '/v0.4/traces'.freeze,
-                Encoding::MsgpackEncoder,
-                service_rates: true
-              )
-            end,
-            V3 => Spec.new do |s|
-              s.traces = Traces::API::Endpoint.new(
-                '/v0.3/traces'.freeze,
-                Encoding::MsgpackEncoder
-              )
-            end,
-            V2 => Spec.new do |s|
-              s.traces = Traces::API::Endpoint.new(
-                '/v0.2/traces'.freeze,
-                Encoding::JSONEncoder
-              )
-            end
-          ].with_fallbacks(V4 => V3, V3 => V2)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/builder.rb

@@ -1,177 +0,0 @@
-# typed: true
-require 'ddtrace/configuration/agent_settings_resolver'
-require 'ddtrace/transport/http/adapters/registry'
-require 'ddtrace/transport/http/api/map'
-require 'ddtrace/transport/http/api/instance'
-require 'ddtrace/transport/http/client'
-
-module Datadog
-  module Transport
-    module HTTP
-      # Builds new instances of Transport::HTTP::Client
-      class Builder
-        REGISTRY = Adapters::Registry.new
-
-        attr_reader \
-          :apis,
-          :api_options,
-          :default_adapter,
-          :default_api,
-          :default_headers
-
-        def initialize
-          # Global settings
-          @default_adapter = nil
-          @default_headers = {}
-
-          # Client settings
-          @apis = API::Map.new
-          @default_api = nil
-
-          # API settings
-          @api_options = {}
-
-          yield(self) if block_given?
-        end
-
-        def adapter(config, *args, **kwargs)
-          @default_adapter = case config
-                             when Configuration::AgentSettingsResolver::AgentSettings
-                               registry_klass = REGISTRY.get(config.adapter)
-                               raise UnknownAdapterError, config.adapter if registry_klass.nil?
-
-                               registry_klass.build(config)
-                             when Symbol
-                               registry_klass = REGISTRY.get(config)
-                               raise UnknownAdapterError, config if registry_klass.nil?
-
-                               registry_klass.new(*args, **kwargs)
-                             else
-                               config
-                             end
-        end
-
-        def headers(values = {})
-          @default_headers.merge!(values)
-        end
-
-        # Adds a new API to the client
-        # Valid options:
-        #  - :adapter
-        #  - :default
-        #  - :fallback
-        #  - :headers
-        def api(key, spec, options = {})
-          options = options.dup
-
-          # Copy spec into API map
-          @apis[key] = spec
-
-          # Apply as default API, if specified to do so.
-          @default_api = key if options.delete(:default) || @default_api.nil?
-
-          # Save all other settings for initialization
-          (@api_options[key] ||= {}).merge!(options)
-        end
-
-        def default_api=(key)
-          raise UnknownApiError, key unless @apis.key?(key)
-
-          @default_api = key
-        end
-
-        def to_transport
-          raise NoDefaultApiError if @default_api.nil?
-
-          # DEV: Should not be specific to traces
-          Transport::Traces::Transport.new(to_api_instances, @default_api)
-        end
-
-        def to_api_instances
-          raise NoApisError if @apis.empty?
-
-          @apis.inject(API::Map.new) do |instances, (key, spec)|
-            instances.tap do
-              api_options = @api_options[key].dup
-
-              # Resolve the adapter to use for this API
-              adapter = api_options.delete(:adapter) || @default_adapter
-              raise NoAdapterForApiError, key if adapter.nil?
-
-              # Resolve fallback and merge headers
-              fallback = api_options.delete(:fallback)
-              api_options[:headers] = @default_headers.merge((api_options[:headers] || {}))
-
-              # Add API::Instance with all settings
-              instances[key] = api_instance_class.new(
-                spec,
-                adapter,
-                api_options
-              )
-
-              # Configure fallback, if provided.
-              instances.with_fallbacks(key => fallback) unless fallback.nil?
-            end
-          end
-        end
-
-        def api_instance_class
-          API::Instance
-        end
-
-        # Raised when the API key does not match known APIs.
-        class UnknownApiError < StandardError
-          attr_reader :key
-
-          def initialize(key)
-            @key = key
-          end
-
-          def message
-            "Unknown transport API '#{key}'!"
-          end
-        end
-
-        # Raised when the identifier cannot be matched to an adapter.
-        class UnknownAdapterError < StandardError
-          attr_reader :type
-
-          def initialize(type)
-            @type = type
-          end
-
-          def message
-            "Unknown transport adapter '#{type}'!"
-          end
-        end
-
-        # Raised when an adapter cannot be resolved for an API instance.
-        class NoAdapterForApiError < StandardError
-          attr_reader :key
-
-          def initialize(key)
-            @key = key
-          end
-
-          def message
-            "No adapter resolved for transport API '#{key}'!"
-          end
-        end
-
-        # Raised when built without defining APIs.
-        class NoApisError < StandardError
-          def message
-            'No APIs configured for transport!'
-          end
-        end
-
-        # Raised when client built without defining a default API.
-        class NoDefaultApiError < StandardError
-          def message
-            'No default API configured for transport!'
-          end
-        end
-      end
-    end
-  end
-end