httpx-patched 1.6.2.1

data/lib/httpx/adapters/datadog.rb

@@ -0,0 +1,359 @@
+# frozen_string_literal: true
+
+require "datadog/tracing/contrib/integration"
+require "datadog/tracing/contrib/configuration/settings"
+require "datadog/tracing/contrib/patcher"
+
+module Datadog::Tracing
+  module Contrib
+    module HTTPX
+      DATADOG_VERSION = defined?(::DDTrace) ? ::DDTrace::VERSION : ::Datadog::VERSION
+
+      METADATA_MODULE = Datadog::Tracing::Metadata
+
+      TYPE_OUTBOUND = Datadog::Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
+
+      TAG_BASE_SERVICE = if Gem::Version.new(DATADOG_VERSION::STRING) < Gem::Version.new("1.15.0")
+        "_dd.base_service"
+      else
+        Datadog::Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE
+      end
+      TAG_PEER_HOSTNAME = Datadog::Tracing::Metadata::Ext::TAG_PEER_HOSTNAME
+
+      TAG_KIND = Datadog::Tracing::Metadata::Ext::TAG_KIND
+      TAG_CLIENT = Datadog::Tracing::Metadata::Ext::SpanKind::TAG_CLIENT
+      TAG_COMPONENT = Datadog::Tracing::Metadata::Ext::TAG_COMPONENT
+      TAG_OPERATION = Datadog::Tracing::Metadata::Ext::TAG_OPERATION
+      TAG_URL = Datadog::Tracing::Metadata::Ext::HTTP::TAG_URL
+      TAG_METHOD = Datadog::Tracing::Metadata::Ext::HTTP::TAG_METHOD
+      TAG_TARGET_HOST = Datadog::Tracing::Metadata::Ext::NET::TAG_TARGET_HOST
+      TAG_TARGET_PORT = Datadog::Tracing::Metadata::Ext::NET::TAG_TARGET_PORT
+
+      TAG_STATUS_CODE = Datadog::Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE
+
+      # HTTPX Datadog Plugin
+      #
+      # Enables tracing for httpx requests.
+      #
+      # A span will be created for each request transaction; the span is created lazily only when
+      # buffering a request, and it is fed the start time stored inside the tracer object.
+      #
+      module Plugin
+        module RequestTracer
+          extend Contrib::HttpAnnotationHelper
+
+          module_function
+
+          SPAN_REQUEST = "httpx.request"
+
+          # initializes tracing on the +request+.
+          def call(request)
+            return unless configuration(request).enabled
+
+            span = nil
+
+            # request objects are reused, when already buffered requests get rerouted to a different
+            # connection due to connection issues, or when they already got a response, but need to
+            # be retried. In such situations, the original span needs to be extended for the former,
+            # while a new is required for the latter.
+            request.on(:idle) do
+              span = nil
+            end
+            # the span is initialized when the request is buffered in the parser, which is the closest
+            # one gets to actually sending the request.
+            request.on(:headers) do
+              next if span
+
+              span = initialize_span(request, now)
+            end
+
+            request.on(:response) do |response|
+              span = initialize_span(request, request.init_time) if !span && request.init_time
+
+              finish(response, span)
+            end
+          end
+
+          def finish(response, span)
+            if response.is_a?(::HTTPX::ErrorResponse)
+              span.set_error(response.error)
+            else
+              span.set_tag(TAG_STATUS_CODE, response.status.to_s)
+
+              span.set_error(::HTTPX::HTTPError.new(response)) if response.status >= 400 && response.status <= 599
+
+              span.set_tags(
+                Datadog.configuration.tracing.header_tags.response_tags(response.headers.to_h)
+              ) if Datadog.configuration.tracing.respond_to?(:header_tags)
+            end
+
+            span.finish
+          end
+
+          # return a span initialized with the +@request+ state.
+          def initialize_span(request, start_time)
+            verb = request.verb
+            uri = request.uri
+
+            config = configuration(request)
+
+            span = create_span(request, config, start_time)
+
+            span.resource = verb
+
+            # Tag original global service name if not used
+            span.set_tag(TAG_BASE_SERVICE, Datadog.configuration.service) if span.service != Datadog.configuration.service
+
+            span.set_tag(TAG_KIND, TAG_CLIENT)
+
+            span.set_tag(TAG_COMPONENT, "httpx")
+            span.set_tag(TAG_OPERATION, "request")
+
+            span.set_tag(TAG_URL, request.path)
+            span.set_tag(TAG_METHOD, verb)
+
+            span.set_tag(TAG_TARGET_HOST, uri.host)
+            span.set_tag(TAG_TARGET_PORT, uri.port)
+
+            span.set_tag(TAG_PEER_HOSTNAME, uri.host)
+
+            # Tag as an external peer service
+            # span.set_tag(TAG_PEER_SERVICE, span.service)
+
+            if config[:distributed_tracing]
+              propagate_trace_http(
+                Datadog::Tracing.active_trace,
+                request.headers
+              )
+            end
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(config[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, config[:analytics_sample_rate])
+            end
+
+            span.set_tags(
+              Datadog.configuration.tracing.header_tags.request_tags(request.headers.to_h)
+            ) if Datadog.configuration.tracing.respond_to?(:header_tags)
+
+            span
+          rescue StandardError => e
+            Datadog.logger.error("error preparing span for http request: #{e}")
+            Datadog.logger.error(e.backtrace)
+          end
+
+          def now
+            ::Datadog::Core::Utils::Time.now.utc
+          end
+
+          def configuration(request)
+            Datadog.configuration.tracing[:httpx, request.uri.host]
+          end
+
+          if Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("2.0.0")
+            def propagate_trace_http(trace, headers)
+              Datadog::Tracing::Contrib::HTTP.inject(trace, headers)
+            end
+
+            def create_span(request, configuration, start_time)
+              Datadog::Tracing.trace(
+                SPAN_REQUEST,
+                service: service_name(request.uri.host, configuration),
+                type: TYPE_OUTBOUND,
+                start_time: start_time
+              )
+            end
+          else
+            def propagate_trace_http(trace, headers)
+              Datadog::Tracing::Propagation::HTTP.inject!(trace.to_digest, headers)
+            end
+
+            def create_span(request, configuration, start_time)
+              Datadog::Tracing.trace(
+                SPAN_REQUEST,
+                service: service_name(request.uri.host, configuration),
+                span_type: TYPE_OUTBOUND,
+                start_time: start_time
+              )
+            end
+          end
+        end
+
+        module RequestMethods
+          attr_accessor :init_time
+
+          # intercepts request initialization to inject the tracing logic.
+          def initialize(*)
+            super
+
+            @init_time = nil
+
+            return unless Datadog::Tracing.enabled?
+
+            RequestTracer.call(self)
+          end
+
+          def response=(*)
+            # init_time should be set when it's send to a connection.
+            # However, there are situations where connection initialization fails.
+            # Example is the :ssrf_filter plugin, which raises an error on
+            # initialize if the host is an IP which matches against the known set.
+            # in such cases, we'll just set here right here.
+            @init_time ||= ::Datadog::Core::Utils::Time.now.utc
+
+            super
+          end
+        end
+
+        module ConnectionMethods
+          def initialize(*)
+            super
+
+            @init_time = ::Datadog::Core::Utils::Time.now.utc
+          end
+
+          def send(request)
+            request.init_time ||= @init_time
+
+            super
+          end
+        end
+      end
+
+      module Configuration
+        # Default settings for httpx
+        #
+        class Settings < Datadog::Tracing::Contrib::Configuration::Settings
+          DEFAULT_ERROR_HANDLER = lambda do |response|
+            Datadog::Ext::HTTP::ERROR_RANGE.cover?(response.status)
+          end
+
+          option :service_name, default: "httpx"
+          option :distributed_tracing, default: true
+          option :split_by_domain, default: false
+
+          if Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("1.13.0")
+            option :enabled do |o|
+              o.type :bool
+              o.env "DD_TRACE_HTTPX_ENABLED"
+              o.default true
+            end
+
+            option :analytics_enabled do |o|
+              o.type :bool
+              o.env "DD_TRACE_HTTPX_ANALYTICS_ENABLED"
+              o.default false
+            end
+
+            option :analytics_sample_rate do |o|
+              o.type :float
+              o.env "DD_TRACE_HTTPX_ANALYTICS_SAMPLE_RATE"
+              o.default 1.0
+            end
+          else
+            option :enabled do |o|
+              o.default { env_to_bool("DD_TRACE_HTTPX_ENABLED", true) }
+              o.lazy
+            end
+
+            option :analytics_enabled do |o|
+              o.default { env_to_bool(%w[DD_TRACE_HTTPX_ANALYTICS_ENABLED DD_HTTPX_ANALYTICS_ENABLED], false) }
+              o.lazy
+            end
+
+            option :analytics_sample_rate do |o|
+              o.default { env_to_float(%w[DD_TRACE_HTTPX_ANALYTICS_SAMPLE_RATE DD_HTTPX_ANALYTICS_SAMPLE_RATE], 1.0) }
+              o.lazy
+            end
+          end
+
+          if defined?(Datadog::Tracing::Contrib::SpanAttributeSchema)
+            option :service_name do |o|
+              o.default do
+                Datadog::Tracing::Contrib::SpanAttributeSchema.fetch_service_name(
+                  "DD_TRACE_HTTPX_SERVICE_NAME",
+                  "httpx"
+                )
+              end
+              o.lazy unless Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("1.13.0")
+            end
+          else
+            option :service_name do |o|
+              o.default do
+                ENV.fetch("DD_TRACE_HTTPX_SERVICE_NAME", "httpx")
+              end
+              o.lazy unless Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("1.13.0")
+            end
+          end
+
+          option :distributed_tracing, default: true
+
+          if Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("1.15.0")
+            option :error_handler do |o|
+              o.type :proc
+              o.default_proc(&DEFAULT_ERROR_HANDLER)
+            end
+          elsif Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("1.13.0")
+            option :error_handler do |o|
+              o.type :proc
+              o.experimental_default_proc(&DEFAULT_ERROR_HANDLER)
+            end
+          else
+            option :error_handler, default: DEFAULT_ERROR_HANDLER
+          end
+        end
+      end
+
+      # Patcher enables patching of 'httpx' with datadog components.
+      #
+      module Patcher
+        include Datadog::Tracing::Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        # loads a session instannce with the datadog plugin, and replaces the
+        # base HTTPX::Session with the patched session class.
+        def patch
+          datadog_session = ::HTTPX.plugin(Plugin)
+
+          ::HTTPX.send(:remove_const, :Session)
+          ::HTTPX.send(:const_set, :Session, datadog_session.class)
+        end
+      end
+
+      # Datadog Integration for HTTPX.
+      #
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new("0.10.2")
+
+        register_as :httpx
+
+        def self.version
+          Gem.loaded_specs["httpx"] && Gem.loaded_specs["httpx"].version
+        end
+
+        def self.loaded?
+          defined?(::HTTPX::Request)
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        def new_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

data/lib/httpx/adapters/faraday.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "httpx"
+require "faraday"
+
+module Faraday
+  class Adapter
+    class HTTPX < Faraday::Adapter
+      def initialize(app = nil, opts = {}, &block)
+        @connection = @bind = nil
+        super(app, opts, &block)
+      end
+
+      module RequestMixin
+        def build_connection(env)
+          return @connection if @connection
+
+          @connection = ::HTTPX.plugin(:persistent).plugin(ReasonPlugin)
+          @connection = @connection.with(@connection_options) unless @connection_options.empty?
+          connection_opts = options_from_env(env)
+
+          if (bind = env.request.bind)
+            @bind = TCPSocket.new(bind[:host], bind[:port])
+            connection_opts[:io] = @bind
+          end
+          @connection = @connection.with(connection_opts)
+
+          if (proxy = env.request.proxy)
+            proxy_options = { uri: proxy.uri }
+            proxy_options[:username] = proxy.user if proxy.user
+            proxy_options[:password] = proxy.password if proxy.password
+
+            @connection = @connection.plugin(:proxy).with(proxy: proxy_options)
+          end
+          @connection = @connection.plugin(OnDataPlugin) if env.request.stream_response?
+
+          @connection = @config_block.call(@connection) || @connection if @config_block
+          @connection
+        end
+
+        def close
+          @connection.close if @connection
+          @bind.close if @bind
+        end
+
+        private
+
+        def connect(env, &blk)
+          connection(env, &blk)
+        rescue ::HTTPX::TLSError => e
+          raise Faraday::SSLError, e
+        rescue Errno::ECONNABORTED,
+               Errno::ECONNREFUSED,
+               Errno::ECONNRESET,
+               Errno::EHOSTUNREACH,
+               Errno::EINVAL,
+               Errno::ENETUNREACH,
+               Errno::EPIPE,
+               ::HTTPX::ConnectionError => e
+          raise Faraday::ConnectionFailed, e
+        rescue ::HTTPX::TimeoutError => e
+          raise Faraday::TimeoutError, e
+        end
+
+        def build_request(env)
+          meth = env[:method]
+
+          request_options = {
+            headers: env.request_headers,
+            body: env.body,
+            **options_from_env(env),
+          }
+          [meth.to_s.upcase, env.url, request_options]
+        end
+
+        def options_from_env(env)
+          timeout_options = {}
+          req_opts = env.request
+          if (sec = request_timeout(:read, req_opts))
+            timeout_options[:read_timeout] = sec
+          end
+
+          if (sec = request_timeout(:write, req_opts))
+            timeout_options[:write_timeout] = sec
+          end
+
+          if (sec = request_timeout(:open, req_opts))
+            timeout_options[:connect_timeout] = sec
+          end
+
+          {
+            ssl: ssl_options_from_env(env),
+            timeout: timeout_options,
+          }
+        end
+
+        if defined?(::OpenSSL)
+          def ssl_options_from_env(env)
+            ssl_options = {}
+
+            unless env.ssl.verify.nil?
+              ssl_options[:verify_mode] = env.ssl.verify ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+            end
+
+            ssl_options[:ca_file] = env.ssl.ca_file if env.ssl.ca_file
+            ssl_options[:ca_path] = env.ssl.ca_path if env.ssl.ca_path
+            ssl_options[:cert_store] = env.ssl.cert_store if env.ssl.cert_store
+            ssl_options[:cert] = env.ssl.client_cert if env.ssl.client_cert
+            ssl_options[:key] = env.ssl.client_key if env.ssl.client_key
+            ssl_options[:ssl_version] = env.ssl.version if env.ssl.version
+            ssl_options[:verify_depth] = env.ssl.verify_depth if env.ssl.verify_depth
+            ssl_options[:min_version] = env.ssl.min_version if env.ssl.min_version
+            ssl_options[:max_version] = env.ssl.max_version if env.ssl.max_version
+            ssl_options
+          end
+        else
+          # :nocov:
+          def ssl_options_from_env(*)
+            {}
+          end
+          # :nocov:
+        end
+      end
+
+      include RequestMixin
+
+      module OnDataPlugin
+        module RequestMethods
+          attr_writer :response_on_data
+
+          def response=(response)
+            super
+
+            return unless @response
+
+            return if @response.is_a?(::HTTPX::ErrorResponse)
+
+            @response.body.on_data = @response_on_data
+          end
+        end
+
+        module ResponseBodyMethods
+          attr_writer :on_data
+
+          def write(chunk)
+            return super unless @on_data
+
+            @on_data.call(chunk, chunk.bytesize)
+          end
+        end
+      end
+
+      module ReasonPlugin
+        def self.load_dependencies(*)
+          require "net/http/status"
+        end
+
+        module ResponseMethods
+          def reason
+            Net::HTTP::STATUS_CODES.fetch(@status, "Non-Standard status code")
+          end
+        end
+      end
+
+      class ParallelManager
+        class ResponseHandler < SimpleDelegator
+          attr_reader :env
+
+          def initialize(env)
+            @env = env
+            super
+          end
+
+          def on_response(&blk)
+            if blk
+              @on_response = ->(response) do
+                blk.call(response)
+              end
+              self
+            else
+              @on_response
+            end
+          end
+
+          def on_complete(&blk)
+            if blk
+              @on_complete = blk
+              self
+            else
+              @on_complete
+            end
+          end
+        end
+
+        include RequestMixin
+
+        def initialize(options)
+          @handlers = []
+          @connection_options = options
+        end
+
+        def enqueue(request)
+          handler = ResponseHandler.new(request)
+          @handlers << handler
+          handler
+        end
+
+        def run
+          return unless @handlers.last
+
+          env = @handlers.last.env
+
+          connect(env) do |session|
+            requests = @handlers.map { |handler| session.build_request(*build_request(handler.env)) }
+
+            if env.request.stream_response?
+              requests.each do |request|
+                request.response_on_data = env.request.on_data
+              end
+            end
+
+            responses = session.request(*requests)
+            Array(responses).each_with_index do |response, index|
+              handler = @handlers[index]
+              handler.on_response.call(response)
+              handler.on_complete.call(handler.env) if handler.on_complete
+            end
+          end
+        end
+
+        private
+
+        # from Faraday::Adapter#connection
+        def connection(env)
+          conn = build_connection(env)
+          return conn unless block_given?
+
+          yield conn
+        end
+
+        # from Faraday::Adapter#request_timeout
+        def request_timeout(type, options)
+          key = Faraday::Adapter::TIMEOUT_KEYS[type]
+          options[key] || options[:timeout]
+        end
+      end
+
+      self.supports_parallel = true
+
+      class << self
+        def setup_parallel_manager(options = {})
+          ParallelManager.new(options)
+        end
+      end
+
+      def call(env)
+        super
+        if parallel?(env)
+          handler = env[:parallel_manager].enqueue(env)
+          handler.on_response do |response|
+            if response.is_a?(::HTTPX::Response)
+              save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
+                response_headers.merge!(response.headers)
+              end
+            else
+              env[:error] = response.error
+              save_response(env, 0, "", {}, nil)
+            end
+          end
+          return handler
+        end
+
+        response = connect_and_request(env)
+        save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
+          response_headers.merge!(response.headers)
+        end
+        @app.call(env)
+      end
+
+      private
+
+      def connect_and_request(env)
+        connect(env) do |session|
+          request = session.build_request(*build_request(env))
+
+          request.response_on_data = env.request.on_data if env.request.stream_response?
+
+          response = session.request(request)
+          # do not call #raise_for_status for HTTP 4xx or 5xx, as faraday has a middleware for that.
+          response.raise_for_status unless response.is_a?(::HTTPX::Response)
+          response
+        end
+      end
+
+      def parallel?(env)
+        env[:parallel_manager]
+      end
+    end
+
+    register_middleware httpx: HTTPX
+  end
+end