ddtrace 1.12.1 → 1.23.2

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '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,17 +0,0 @@
-# frozen_string_literal: 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,39 +0,0 @@
-require_relative '../../../datadog/core/encoding'
-
-require_relative 'api/map'
-require_relative 'api/spec'
-
-require_relative 'traces'
-
-module Datadog
-  module Transport
-    module HTTP
-      # Namespace for API components
-      module API
-        # Default API versions
-        V4 = 'v0.4'.freeze
-        V3 = 'v0.3'.freeze
-
-        module_function
-
-        def defaults
-          Map[
-            V4 => Spec.new do |s|
-              s.traces = Traces::API::Endpoint.new(
-                '/v0.4/traces'.freeze,
-                Core::Encoding::MsgpackEncoder,
-                service_rates: true
-              )
-            end,
-            V3 => Spec.new do |s|
-              s.traces = Traces::API::Endpoint.new(
-                '/v0.3/traces'.freeze,
-                Core::Encoding::MsgpackEncoder
-              )
-            end,
-          ].with_fallbacks(V4 => V3)
-        end
-      end
-    end
-  end
-end

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

@@ -1,176 +0,0 @@
-require_relative '../../../datadog/core/configuration/agent_settings_resolver'
-require_relative 'adapters/registry'
-require_relative 'api/map'
-require_relative 'api/instance'
-require_relative '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 Core::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

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

@@ -1,52 +0,0 @@
-require_relative 'statistics'
-require_relative '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 #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
-            "Location: #{Array(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

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-        def form
-          self[:form] ||= {}
-        end
-
-        def form=(value)
-          self[:form] = value
-        end
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../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
-        def initialize(http_response)
-          @http_response = http_response
-        end
-
-        # (see Datadog::Transport::Response#payload)
-        def payload
-          @http_response.payload
-        end
-
-        # (see Datadog::Transport::Response#internal_error?)
-        def internal_error?
-          @http_response.internal_error?
-        end
-
-        # (see Datadog::Transport::Response#unsupported?)
-        def unsupported?
-          @http_response.unsupported?
-        end
-
-        # (see Datadog::Transport::Response#ok?)
-        def ok?
-          @http_response.ok?
-        end
-
-        # (see Datadog::Transport::Response#not_found?)
-        def not_found?
-          @http_response.not_found?
-        end
-
-        # (see Datadog::Transport::Response#client_error?)
-        def client_error?
-          @http_response.client_error?
-        end
-
-        # (see Datadog::Transport::Response#server_error?)
-        def server_error?
-          @http_response.server_error?
-        end
-
-        def code
-          @http_response.respond_to?(:code) ? @http_response.code : nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-require_relative '../statistics'
-
-module Datadog
-  module Transport
-    module HTTP
-      # Tracks statistics for HTTP transports
-      module Statistics
-        def self.included(base)
-          base.include(Datadog::Transport::Statistics)
-          base.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 << metrics_tag_value(response.code)
-                end
-              end
-            end
-          end
-
-          private
-
-          # The most common status code on a healthy tracer
-          STATUS_CODE_200 = 'status_code:200'.freeze
-
-          def metrics_tag_value(status_code)
-            if status_code == 200
-              STATUS_CODE_200 # DEV Saves string concatenation/creation for common case
-            else
-              "status_code:#{status_code}"
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,144 +0,0 @@
-require 'json'
-
-require_relative '../traces'
-require_relative 'client'
-require_relative 'response'
-require_relative 'api/endpoint'
-require_relative 'api/instance'
-
-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_traces_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)
-                  options[:service_rates] = body[SERVICE_RATE_KEY] if body.is_a?(Hash) && body.key?(SERVICE_RATE_KEY)
-                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.include(Traces::Client)
-        HTTP::API::Spec.include(Traces::API::Spec)
-        HTTP::API::Instance.include(Traces::API::Instance)
-      end
-    end
-  end
-end