ddtrace 0.24.0 → 0.25.0

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

@@ -0,0 +1,108 @@
+require 'ddtrace/transport/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::Statistics
+
+        attr_reader \
+          :apis,
+          :current_api_id
+
+        def initialize(apis, current_api_id)
+          @apis = apis
+
+          # Activate initial API
+          change_api!(current_api_id)
+        end
+
+        def send_request(request, &block)
+          # Build request into env
+          env = build_env(request)
+
+          # Get response from API
+          response = yield(current_api, env)
+
+          # Update statistics
+          update_stats_from_response!(response)
+
+          # If API should be downgraded, downgrade and try again.
+          if downgrade?(response)
+            downgrade!
+            response = send_request(request, &block)
+          end
+
+          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::Tracer.log.debug(message)
+          else
+            Datadog::Tracer.log.error(message)
+          end
+
+          # Update statistics
+          stats.internal_error += 1
+          stats.consecutive_errors += 1
+
+          InternalErrorResponse.new(e)
+        end
+
+        def build_env(request)
+          Env.new(request)
+        end
+
+        def downgrade?(response)
+          return false unless apis.fallbacks.key?(current_api_id)
+          response.not_found? || response.unsupported?
+        end
+
+        def current_api
+          apis[current_api_id]
+        end
+
+        def change_api!(api_id)
+          raise UnknownApiVersionError, api_id unless apis.key?(api_id)
+          @current_api_id = api_id
+        end
+
+        def downgrade!
+          downgrade_api_id = apis.fallbacks[current_api_id]
+          raise NoDowngradeAvailableError, current_api_id if downgrade_api_id.nil?
+          change_api!(downgrade_api_id)
+        end
+
+        # Raised when configured with an unknown API version
+        class UnknownApiVersionError < StandardError
+          attr_reader :version
+
+          def initialize(version)
+            @version = version
+          end
+
+          def message
+            "No matching transport API for version #{version}!"
+          end
+        end
+
+        # Raised when configured with an unknown API version
+        class NoDowngradeAvailableError < StandardError
+          attr_reader :version
+
+          def initialize(version)
+            @version = version
+          end
+
+          def message
+            "No downgrade from transport API version #{version} is available!"
+          end
+        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,22 @@
+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, *Transport::Response.instance_methods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+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 Transport::Traces::Response
+
+          def initialize(http_response, options = {})
+            super(http_response)
+            @service_rates = options.fetch(:service_rates, nil)
+          end
+        end
+
+        # Extensions for HTTP client
+        module Client
+          def send_traces(traces)
+            request = Transport::Traces::Request.new(traces)
+
+            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
+
+            # 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.count.to_s
+
+              # Encode body & type
+              env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
+              env.body = env.request.parcel.encode_with(encoder)
+
+              # Query for response
+              http_response = super(env, &block)
+
+              # Process the response
+              response_options = {}.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

data/lib/ddtrace/transport/parcel.rb

@@ -0,0 +1,13 @@
+module Datadog
+  module Transport
+    # Data transfer object for generic data
+    module Parcel
+      attr_reader \
+        :data
+
+      def initialize(data)
+        @data = data
+      end
+    end
+  end
+end

data/lib/ddtrace/transport/request.rb

@@ -0,0 +1,13 @@
+module Datadog
+  module Transport
+    # Defines request for transport operations
+    class Request
+      attr_reader \
+        :parcel
+
+      def initialize(parcel)
+        @parcel = parcel
+      end
+    end
+  end
+end

data/lib/ddtrace/transport/response.rb

@@ -0,0 +1,49 @@
+module Datadog
+  module Transport
+    # Defines abstract response for transport operations
+    module Response
+      def payload
+        nil
+      end
+
+      def ok?
+        nil
+      end
+
+      def unsupported?
+        nil
+      end
+
+      def not_found?
+        nil
+      end
+
+      def client_error?
+        nil
+      end
+
+      def server_error?
+        nil
+      end
+
+      def internal_error?
+        nil
+      end
+    end
+
+    # A generic error response for internal errors
+    class InternalErrorResponse
+      include Response
+
+      attr_reader :error
+
+      def initialize(error)
+        @error = error
+      end
+
+      def internal_error?
+        true
+      end
+    end
+  end
+end

data/lib/ddtrace/transport/statistics.rb

@@ -0,0 +1,44 @@
+module Datadog
+  module Transport
+    # Tracks statistics for transports
+    module Statistics
+      def stats
+        @stats ||= Counts.new
+      end
+
+      def update_stats_from_response!(response)
+        if response.ok?
+          stats.success += 1
+          stats.consecutive_errors = 0
+        else
+          stats.client_error += 1 if response.client_error?
+          stats.server_error += 1 if response.server_error?
+          stats.internal_error += 1 if response.internal_error?
+          stats.consecutive_errors += 1
+        end
+      end
+
+      # Stat counts
+      class Counts
+        attr_accessor \
+          :success,
+          :client_error,
+          :server_error,
+          :internal_error,
+          :consecutive_errors
+
+        def initialize
+          reset!
+        end
+
+        def reset!
+          @success = 0
+          @client_error = 0
+          @server_error = 0
+          @internal_error = 0
+          @consecutive_errors = 0
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/transport/traces.rb

@@ -0,0 +1,33 @@
+require 'ddtrace/transport/parcel'
+require 'ddtrace/transport/request'
+
+module Datadog
+  module Transport
+    module Traces
+      # Data transfer object for trace data
+      class Parcel
+        include Transport::Parcel
+
+        def count
+          data.length
+        end
+
+        def encode_with(encoder)
+          encoder.encode_traces(data)
+        end
+      end
+
+      # Traces request
+      class Request < Transport::Request
+        def initialize(traces)
+          super(Parcel.new(traces))
+        end
+      end
+
+      # Traces response
+      module Response
+        attr_reader :service_rates
+      end
+    end
+  end
+end