ddtrace 0.13.0 → 0.47.0

data/lib/ddtrace/transport/http.rb

@@ -0,0 +1,113 @@
+require 'ddtrace/version'
+require 'ddtrace/ext/runtime'
+require 'ddtrace/ext/transport'
+
+require 'ddtrace/runtime/container'
+
+require 'ddtrace/transport/http/builder'
+require 'ddtrace/transport/http/api'
+
+require 'ddtrace/transport/http/adapters/net'
+require 'ddtrace/transport/http/adapters/test'
+require 'ddtrace/transport/http/adapters/unix_socket'
+require 'uri'
+
+module Datadog
+  module Transport
+    # Namespace for HTTP transport components
+    module HTTP
+      module_function
+
+      # Builds a new Transport::HTTP::Client
+      def new(&block)
+        Builder.new(&block).to_transport
+      end
+
+      # Builds a new Transport::HTTP::Client with default settings
+      # Pass a block to override any settings.
+      def default(options = {})
+        new do |transport|
+          transport.adapter default_adapter, default_hostname, default_port, timeout: 1
+          transport.headers default_headers
+
+          apis = API.defaults
+
+          transport.api API::V4, apis[API::V4], fallback: API::V3, default: true
+          transport.api API::V3, apis[API::V3], fallback: API::V2
+          transport.api API::V2, apis[API::V2]
+
+          # Apply any settings given by options
+          unless options.empty?
+            # Change hostname/port
+            if [:hostname, :port, :timeout, :ssl].any? { |key| options.key?(key) }
+              hostname = options[:hostname] || default_hostname
+              port = options[:port] || default_port
+
+              adapter_options = { timeout: 1 }
+              adapter_options[:timeout] = options[:timeout] if options.key?(:timeout)
+              adapter_options[:ssl] = options[:ssl] if options.key?(:ssl)
+
+              transport.adapter default_adapter, hostname, port, adapter_options
+            end
+
+            # Change default API
+            transport.default_api = options[:api_version] if options.key?(:api_version)
+
+            # Add headers
+            transport.headers options[:headers] if options.key?(:headers)
+
+            # Execute on_build callback
+            options[:on_build].call(transport) if options[:on_build].is_a?(Proc)
+          end
+
+          # Call block to apply any customization, if provided.
+          yield(transport) if block_given?
+        end
+      end
+
+      def default_headers
+        {
+          Datadog::Ext::Transport::HTTP::HEADER_META_LANG => Datadog::Ext::Runtime::LANG,
+          Datadog::Ext::Transport::HTTP::HEADER_META_LANG_VERSION => Datadog::Ext::Runtime::LANG_VERSION,
+          Datadog::Ext::Transport::HTTP::HEADER_META_LANG_INTERPRETER => Datadog::Ext::Runtime::LANG_INTERPRETER,
+          Datadog::Ext::Transport::HTTP::HEADER_META_TRACER_VERSION => Datadog::Ext::Runtime::TRACER_VERSION
+        }.tap do |headers|
+          # Add container ID, if present.
+          container_id = Datadog::Runtime::Container.container_id
+          headers[Datadog::Ext::Transport::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
+        end
+      end
+
+      def default_adapter
+        :net_http
+      end
+
+      def default_hostname
+        return default_url.hostname if default_url
+
+        ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_HOST, Datadog::Ext::Transport::HTTP::DEFAULT_HOST)
+      end
+
+      def default_port
+        return default_url.port if default_url
+
+        ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT, Datadog::Ext::Transport::HTTP::DEFAULT_PORT).to_i
+      end
+
+      def default_url
+        url_env = ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL, nil)
+
+        if url_env
+          uri_parsed = URI.parse(url_env)
+
+          uri_parsed if %w[http https].include?(uri_parsed.scheme)
+        end
+      end
+
+      # Add adapters to registry
+      Builder::REGISTRY.set(Adapters::Net, :net_http)
+      Builder::REGISTRY.set(Adapters::Test, :test)
+      Builder::REGISTRY.set(Adapters::UnixSocket, :unix)
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+require 'ddtrace/transport/response'
+require 'ddtrace/vendor/multipart-post/net/http/post/multipart'
+
+module Datadog
+  module Transport
+    module HTTP
+      module Adapters
+        # Adapter for Net::HTTP
+        class Net
+          attr_reader \
+            :hostname,
+            :port,
+            :timeout,
+            :ssl
+
+          DEFAULT_TIMEOUT = 30
+
+          def initialize(hostname, port, options = {})
+            @hostname = hostname
+            @port = port
+            @timeout = options[:timeout] || DEFAULT_TIMEOUT
+            @ssl = options.key?(:ssl) ? options[:ssl] == true : false
+          end
+
+          def open(&block)
+            # DEV Initializing +Net::HTTP+ directly help us avoid expensive
+            # options processing done in +Net::HTTP.start+:
+            # https://github.com/ruby/ruby/blob/b2d96abb42abbe2e01f010ffc9ac51f0f9a50002/lib/net/http.rb#L614-L618
+            req = ::Net::HTTP.new(hostname, port, nil)
+
+            req.use_ssl = ssl
+            req.open_timeout = req.read_timeout = timeout
+
+            req.start(&block)
+          end
+
+          def call(env)
+            if respond_to?(env.verb)
+              send(env.verb, env)
+            else
+              raise UnknownHTTPMethod, env
+            end
+          end
+
+          def post(env)
+            post = nil
+
+            if env.form.nil? || env.form.empty?
+              post = ::Net::HTTP::Post.new(env.path, env.headers)
+              post.body = env.body
+            else
+              post = ::Datadog::Vendor::Net::HTTP::Post::Multipart.new(
+                env.path,
+                env.form,
+                env.headers
+              )
+            end
+
+            # Connect and send the request
+            http_response = open do |http|
+              http.request(post)
+            end
+
+            # Build and return response
+            Response.new(http_response)
+          end
+
+          def url
+            "http://#{hostname}:#{port}?timeout=#{timeout}"
+          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
+
+            def inspect
+              "#{super}, http_response:#{http_response}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+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,83 @@
+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
+
+          def url; 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
+
+            def inspect
+              "#{super}, code:#{code}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+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(&block)
+            # Open connection
+            connection = HTTP.new(
+              filepath,
+              read_timeout: timeout,
+              continue_timeout: timeout
+            )
+
+            connection.start(&block)
+          end
+
+          def url
+            "http+unix://#{filepath}?timeout=#{timeout}"
+          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