ddtrace 0.34.1 → 1.23.1

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

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

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

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

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

@@ -1,107 +0,0 @@
-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 \
-          :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::Logger.log.debug(message)
-          else
-            Datadog::Logger.log.error(message)
-          end
-
-          # Update statistics
-          update_stats_from_exception!(e)
-
-          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

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

@@ -1,26 +0,0 @@
-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
-
-        def code
-          @http_response.respond_to?(:code) ? @http_response.code : nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-require 'ddtrace/transport/statistics'
-
-module Datadog
-  module Transport
-    module HTTP
-      # Tracks statistics for HTTP transports
-      module Statistics
-        def self.included(base)
-          base.send(:include, 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