ddtrace 0.24.0 → 0.25.0

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

@@ -0,0 +1,112 @@
+require 'ddtrace/transport/response'
+
+module Datadog
+  module Transport
+    module HTTP
+      module Adapters
+        # Adapter for Net::HTTP
+        class Net
+          attr_reader \
+            :hostname,
+            :port,
+            :timeout
+
+          DEFAULT_TIMEOUT = 1
+
+          def initialize(hostname, port, options = {})
+            @hostname = hostname
+            @port = port
+            @timeout = options[:timeout] || DEFAULT_TIMEOUT
+          end
+
+          def open
+            # Open connection
+            ::Net::HTTP.start(hostname, port, open_timeout: timeout, read_timeout: timeout) do |http|
+              yield(http)
+            end
+          end
+
+          def call(env)
+            if respond_to?(env.verb)
+              send(env.verb, env)
+            else
+              raise UnknownHTTPMethod, env
+            end
+          end
+
+          def post(env)
+            post = ::Net::HTTP::Post.new(env.path, env.headers)
+            post.body = env.body
+
+            # Connect and send the request
+            http_response = open do |http|
+              http.request(post)
+            end
+
+            # Build and return response
+            Response.new(http_response)
+          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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,77 @@
+require 'ddtrace/transport/response'
+
+module Datadog
+  module Transport
+    module HTTP
+      module Adapters
+        # Adapter for testing
+        class Test
+          attr_reader \
+            :buffer,
+            :status
+
+          def initialize(buffer = nil)
+            @buffer = 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
+
+          # 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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'net/http'
+require 'ddtrace/transport/http/adapters/net'
+
+module Datadog
+  module Transport
+    module HTTP
+      module Adapters
+        # Adapter for Unix sockets
+        class UnixSocket < Adapters::Net
+          DEFAULT_TIMEOUT = 1
+
+          attr_reader \
+            :filepath,
+            :timeout
+
+          def initialize(filepath, options = {})
+            @filepath = filepath
+            @timeout = options.fetch(:timeout, DEFAULT_TIMEOUT)
+          end
+
+          def open
+            # Open connection
+            connection = HTTP.new(
+              filepath,
+              read_timeout: timeout,
+              continue_timeout: timeout
+            )
+
+            connection.start do |http|
+              yield(http)
+            end
+          end
+
+          # Re-implements Net:HTTP with underlying Unix socket
+          class HTTP < ::Net::HTTP
+            DEFAULT_TIMEOUT = 1
+
+            attr_reader \
+              :filepath,
+              :unix_socket
+
+            def initialize(filepath, options = {})
+              super('localhost', 80)
+              @filepath = filepath
+              @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(filepath)
+              @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.rb

@@ -0,0 +1,46 @@
+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/api/endpoint.rb

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,29 @@
+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 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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,15 @@
+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/builder.rb

@@ -0,0 +1,165 @@
+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(type, *args)
+          @default_adapter = if type.is_a?(Symbol)
+                               registry_klass = REGISTRY.get(type)
+                               raise UnknownAdapterError, type if registry_klass.nil?
+                               registry_klass.new(*args)
+                             else
+                               type
+                             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_client
+          raise NoDefaultApiError if @default_api.nil?
+
+          @client ||= Client.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.new(
+                spec,
+                adapter,
+                api_options
+              )
+
+              # Configure fallback, if provided.
+              instances.with_fallbacks(key => fallback) unless fallback.nil?
+            end
+          end
+        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