ddtrace 0.38.0

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,33 @@
+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

@@ -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,163 @@
+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_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.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

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

@@ -0,0 +1,50 @@
+require 'ddtrace/transport/http/statistics'
+require 'ddtrace/transport/http/env'
+
+module Datadog
+  module Transport
+    module HTTP
+      # Routes, encodes, and sends tracer data to the trace agent via HTTP.
+      class Client
+        include Transport::HTTP::Statistics
+
+        attr_reader :api
+
+        def initialize(api)
+          @api = api
+        end
+
+        def send_request(request, &block)
+          # Build request into env
+          env = build_env(request)
+
+          # Get responses from API
+          response = yield(api, env)
+
+          # Update statistics
+          update_stats_from_response!(response)
+
+          response
+        rescue StandardError => e
+          message = "Internal error during HTTP transport request. Cause: #{e.message} Location: #{e.backtrace.first}"
+
+          # Log error
+          if stats.consecutive_errors > 0
+            Datadog.logger.debug(message)
+          else
+            Datadog.logger.error(message)
+          end
+
+          # Update statistics
+          update_stats_from_exception!(e)
+
+          InternalErrorResponse.new(e)
+        end
+
+        def build_env(request)
+          Env.new(request)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Datadog
+  module Transport
+    module HTTP
+      # Data structure for an HTTP request
+      class Env < Hash
+        attr_reader \
+          :request
+
+        def initialize(request, options = nil)
+          @request = request
+          merge!(options) unless options.nil?
+        end
+
+        def verb
+          self[:verb]
+        end
+
+        def verb=(value)
+          self[:verb] = value
+        end
+
+        def path
+          self[:path]
+        end
+
+        def path=(value)
+          self[:path] = value
+        end
+
+        def body
+          self[:body]
+        end
+
+        def body=(value)
+          self[:body] = value
+        end
+
+        def headers
+          self[:headers] ||= {}
+        end
+
+        def headers=(value)
+          self[:headers] = value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'forwardable'
+require 'ddtrace/transport/response'
+
+module Datadog
+  module Transport
+    module HTTP
+      # Wraps an HTTP response from an adapter.
+      #
+      # Used by endpoints to wrap responses from adapters with
+      # fields or behavior that's specific to that endpoint.
+      module Response
+        extend ::Forwardable
+
+        def initialize(http_response)
+          @http_response = http_response
+        end
+
+        def_delegators :@http_response, *Datadog::Transport::Response.instance_methods
+
+        def code
+          @http_response.respond_to?(:code) ? @http_response.code : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'ddtrace/transport/statistics'
+
+module Datadog
+  module Transport
+    module HTTP
+      # Tracks statistics for HTTP transports
+      module Statistics
+        def self.included(base)
+          base.send(:include, Datadog::Transport::Statistics)
+          base.send(:include, InstanceMethods)
+        end
+
+        # Instance methods for HTTP statistics
+        module InstanceMethods
+          # Decorate metrics for HTTP responses
+          def metrics_for_response(response)
+            super.tap do |metrics|
+              # Add status code tag to api.responses metric
+              if metrics.key?(:api_responses)
+                (metrics[:api_responses].options[:tags] ||= []).tap do |tags|
+                  tags << "status_code:#{response.code}"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+require 'json'
+
+require 'ddtrace/transport/traces'
+require 'ddtrace/transport/http/response'
+require 'ddtrace/transport/http/api/endpoint'
+
+module Datadog
+  module Transport
+    module HTTP
+      # HTTP transport behavior for traces
+      module Traces
+        # Response from HTTP transport for traces
+        class Response
+          include HTTP::Response
+          include Datadog::Transport::Traces::Response
+
+          def initialize(http_response, options = {})
+            super(http_response)
+            @service_rates = options.fetch(:service_rates, nil)
+            @trace_count = options.fetch(:trace_count, 0)
+          end
+        end
+
+        # Extensions for HTTP client
+        module Client
+          def send_payload(request)
+            send_request(request) do |api, env|
+              api.send_traces(env)
+            end
+          end
+        end
+
+        module API
+          # Extensions for HTTP API Spec
+          module Spec
+            attr_reader :traces
+
+            def traces=(endpoint)
+              @traces = endpoint
+            end
+
+            def send_traces(env, &block)
+              raise NoTraceEndpointDefinedError, self if traces.nil?
+              traces.call(env, &block)
+            end
+
+            def encoder
+              traces.encoder
+            end
+
+            # Raised when traces sent but no traces endpoint is defined
+            class NoTraceEndpointDefinedError < StandardError
+              attr_reader :spec
+
+              def initialize(spec)
+                @spec = spec
+              end
+
+              def message
+                'No trace endpoint is defined for API specification!'
+              end
+            end
+          end
+
+          # Extensions for HTTP API Instance
+          module Instance
+            def send_traces(env)
+              raise TracesNotSupportedError, spec unless spec.is_a?(Traces::API::Spec)
+
+              spec.send_traces(env) do |request_env|
+                call(request_env)
+              end
+            end
+
+            # Raised when traces sent to API that does not support traces
+            class TracesNotSupportedError < StandardError
+              attr_reader :spec
+
+              def initialize(spec)
+                @spec = spec
+              end
+
+              def message
+                'Traces not supported for this API!'
+              end
+            end
+          end
+
+          # Endpoint for submitting trace data
+          class Endpoint < HTTP::API::Endpoint
+            HEADER_CONTENT_TYPE = 'Content-Type'.freeze
+            HEADER_TRACE_COUNT = 'X-Datadog-Trace-Count'.freeze
+            SERVICE_RATE_KEY = 'rate_by_service'.freeze
+
+            attr_reader \
+              :encoder
+
+            def initialize(path, encoder, options = {})
+              super(:post, path)
+              @encoder = encoder
+              @service_rates = options.fetch(:service_rates, false)
+            end
+
+            def service_rates?
+              @service_rates == true
+            end
+
+            def call(env, &block)
+              # Add trace count header
+              env.headers[HEADER_TRACE_COUNT] = env.request.parcel.trace_count.to_s
+
+              # Encode body & type
+              env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
+              env.body = env.request.parcel.data
+
+              # Query for response
+              http_response = super(env, &block)
+
+              # Process the response
+              response_options = { trace_count: env.request.parcel.trace_count }.tap do |options|
+                # Parse service rates, if configured to do so.
+                if service_rates? && !http_response.payload.to_s.empty?
+                  body = JSON.parse(http_response.payload)
+                  if body.is_a?(Hash) && body.key?(SERVICE_RATE_KEY)
+                    options[:service_rates] = body[SERVICE_RATE_KEY]
+                  end
+                end
+              end
+
+              # Build and return a trace response
+              Traces::Response.new(http_response, response_options)
+            end
+          end
+        end
+
+        # Add traces behavior to transport components
+        HTTP::Client.send(:include, Traces::Client)
+        HTTP::API::Spec.send(:include, Traces::API::Spec)
+        HTTP::API::Instance.send(:include, Traces::API::Instance)
+      end
+    end
+  end
+end