elastic-transport 8.1.2 → 8.2.0

data/lib/elastic/transport/transport/base.rb

@@ -24,12 +24,12 @@ module Elastic
         include Loggable
 
         DEFAULT_PORT             = 9200
-        DEFAULT_PROTOCOL         = 'http'
+        DEFAULT_PROTOCOL         = 'http'.freeze
         DEFAULT_RELOAD_AFTER     = 10_000 # Requests
         DEFAULT_RESURRECT_AFTER  = 60     # Seconds
         DEFAULT_MAX_RETRIES      = 3      # Requests
         DEFAULT_SERIALIZER_CLASS = Serializer::MultiJson
-        SANITIZED_PASSWORD       = '*' * (rand(14)+1)
+        SANITIZED_PASSWORD       = '*' * (rand(14) + 1)
 
         attr_reader   :hosts, :options, :connections, :counter, :last_request_at, :protocol
         attr_accessor :serializer, :sniffer, :logger, :tracer,
@@ -59,7 +59,7 @@ module Elastic
           @compression = !!@options[:compression]
           @connections = __build_connections
 
-          @serializer  = options[:serializer] || ( options[:serializer_class] ? options[:serializer_class].new(self) : DEFAULT_SERIALIZER_CLASS.new(self) )
+          @serializer  = options[:serializer] || ( options[:serializer_class] ? options[:serializer_class].new(self) : DEFAULT_SERIALIZER_CLASS.new(self))
           @protocol    = options[:protocol] || DEFAULT_PROTOCOL
 
           @logger      = options[:logger]
@@ -72,7 +72,7 @@ module Elastic
           @reload_connections = options[:reload_connections]
           @reload_after    = options[:reload_connections].is_a?(Integer) ? options[:reload_connections] : DEFAULT_RELOAD_AFTER
           @resurrect_after = options[:resurrect_after] || DEFAULT_RESURRECT_AFTER
-          @retry_on_status = Array(options[:retry_on_status]).map { |d| d.to_i }
+          @retry_on_status = Array(options[:retry_on_status]).map(&:to_i)
         end
 
         # Returns a connection from the connection pool by delegating to {Connections::Collection#get_connection}.
@@ -87,7 +87,7 @@ module Elastic
           resurrect_dead_connections! if Time.now > @last_request_at + @resurrect_after
 
           @counter_mtx.synchronize { @counter += 1 }
-          reload_connections!         if reload_connections && counter % reload_after == 0
+          reload_connections! if reload_connections && (counter % reload_after).zero?
           connections.get_connection(options)
         end
 
@@ -97,10 +97,10 @@ module Elastic
         #
         def reload_connections!
           hosts = sniffer.hosts
-          __rebuild_connections :hosts => hosts, :options => options
+          __rebuild_connections(hosts: hosts, options: options)
           self
         rescue SnifferTimeoutError
-          log_error "[SnifferTimeoutError] Timeout when reloading connections."
+          log_error('[SnifferTimeoutError] Timeout when reloading connections.')
           self
         end
 
@@ -109,7 +109,7 @@ module Elastic
         # @see Connections::Connection#resurrect!
         #
         def resurrect_dead_connections!
-          connections.dead.each { |c| c.resurrect! }
+          connections.dead.each(&:resurrect!)
         end
 
         # Rebuilds the connections collection in the transport.
@@ -128,7 +128,7 @@ module Elastic
             __close_connections
 
             new_connections = __build_connections
-            stale_connections = @connections.all.select  { |c| ! new_connections.include?(c) }
+            stale_connections = @connections.all.reject { |c| new_connections.include?(c) }
             new_connections = new_connections.reject { |c| @connections.all.include?(c) }
 
             @connections.remove(stale_connections)
@@ -177,8 +177,8 @@ module Elastic
         # @return [Connections::Connection]
         # @api    private
         #
-        def __build_connection(host, options={}, block=nil)
-          raise NoMethodError, "Implement this method in your class"
+        def __build_connection(host, options = {}, block = nil)
+          raise NoMethodError, 'Implement this method in your class'
         end
 
         # Closes the connections collection
@@ -209,14 +209,14 @@ module Elastic
         #
         def __trace(method, path, params, headers, body, url, response, json, took, duration)
           trace_url  = "http://localhost:9200/#{path}?pretty" +
-              ( params.empty? ? '' : "&#{::Faraday::Utils::ParamsHash[params].to_query}" )
+              (params.empty? ? '' : "&#{::Faraday::Utils::ParamsHash[params].to_query}")
           trace_body = body ? " -d '#{__convert_to_json(body, :pretty => true)}'" : ''
           trace_command = "curl -X #{method.to_s.upcase}"
-          trace_command += " -H '#{headers.collect { |k,v| "#{k}: #{v}" }.join(", ")}'" if headers && !headers.empty?
+          trace_command += " -H '#{headers.collect { |k, v| "#{k}: #{v}" }.join(", ")}'" if headers && !headers.empty?
           trace_command += " '#{trace_url}'#{trace_body}\n"
           tracer.info trace_command
           tracer.debug "# #{Time.now.iso8601} [#{response.status}] (#{format('%.3f', duration)}s)\n#"
-          tracer.debug json ? serializer.dump(json, :pretty => true).gsub(/^/, '# ').sub(/\}$/, "\n# }")+"\n" : "# #{response.body}\n"
+          tracer.debug json ? serializer.dump(json, pretty: true).gsub(/^/, '# ').sub(/\}$/, "\n# }")+"\n" : "# #{response.body}\n"
         end
 
         # Raise error specific for the HTTP response status or a generic server error
@@ -276,40 +276,37 @@ module Elastic
           reload_on_failure = opts.fetch(:reload_on_failure, @options[:reload_on_failure])
           delay_on_retry = opts.fetch(:delay_on_retry, @options[:delay_on_retry])
 
-          max_retries = if opts.key?(:retry_on_failure)
-            opts[:retry_on_failure] === true ? DEFAULT_MAX_RETRIES : opts[:retry_on_failure]
-          elsif options.key?(:retry_on_failure)
-            options[:retry_on_failure] === true ? DEFAULT_MAX_RETRIES : options[:retry_on_failure]
-          end
+          max_retries = max_retries(opts) || max_retries(options)
 
           params = params.clone
-          ignore = Array(params.delete(:ignore)).compact.map { |s| s.to_i }
+          # Transforms ignore status codes to Integer
+          ignore = Array(params.delete(:ignore)).compact.map(&:to_i)
 
           begin
             sleep(delay_on_retry / 1000.0) if tries > 0
-            tries     += 1
+            tries += 1
             connection = get_connection or raise Error.new('Cannot get new connection from pool.')
 
-            if connection.connection.respond_to?(:params) && connection.connection.params.respond_to?(:to_hash)
+            if connection.connection.respond_to?(:params) &&
+               connection.connection.params.respond_to?(:to_hash)
               params = connection.connection.params.merge(params.to_hash)
             end
 
-            url      = connection.full_url(path, params)
+            url = connection.full_url(path, params)
             response = block.call(connection, url)
-            connection.healthy! if connection.failures > 0
+            connection.healthy! if connection.failures.positive?
 
             # Raise an exception so we can catch it for `retry_on_status`
-            __raise_transport_error(response) if response.status.to_i >= 300 && @retry_on_status.include?(response.status.to_i)
+            __raise_transport_error(response) if response.status.to_i >= 300 &&
+                                                 @retry_on_status.include?(response.status.to_i)
           rescue Elastic::Transport::Transport::ServerError => e
-            if response && @retry_on_status.include?(response.status)
-              log_warn "[#{e.class}] Attempt #{tries} to get response from #{url}"
-              if tries <= (max_retries || DEFAULT_MAX_RETRIES)
-                retry
-              else
-                log_fatal "[#{e.class}] Cannot get response from #{url} after #{tries} tries"
-                raise e
-              end
+            raise e unless response && @retry_on_status.include?(response.status)
+
+            log_warn "[#{e.class}] Attempt #{tries} to get response from #{url}"
+            if tries <= (max_retries || DEFAULT_MAX_RETRIES)
+              retry
             else
+              log_fatal "[#{e.class}] Cannot get response from #{url} after #{tries} tries"
               raise e
             end
           rescue *host_unreachable_exceptions => e
@@ -317,22 +314,20 @@ module Elastic
 
             connection.dead!
 
-            if reload_on_failure and tries < connections.all.size
+            if reload_on_failure && tries < connections.all.size
               log_warn "[#{e.class}] Reloading connections (attempt #{tries} of #{connections.all.size})"
               reload_connections! and retry
             end
 
             exception = Elastic::Transport::Transport::Error.new(e.message)
 
-            if max_retries
-              log_warn "[#{e.class}] Attempt #{tries} connecting to #{connection.host.inspect}"
-              if tries <= max_retries
-                retry
-              else
-                log_fatal "[#{e.class}] Cannot connect to #{connection.host.inspect} after #{tries} tries"
-                raise exception
-              end
+            raise exception unless max_retries
+
+            log_warn "[#{e.class}] Attempt #{tries} connecting to #{connection.host.inspect}"
+            if tries <= max_retries
+              retry
             else
+              log_fatal "[#{e.class}] Cannot connect to #{connection.host.inspect} after #{tries} tries"
               raise exception
             end
           rescue Exception => e
@@ -351,8 +346,11 @@ module Elastic
             __raise_transport_error response unless ignore.include?(response.status.to_i)
           end
 
-          json     = serializer.load(response.body) if response.body && !response.body.empty? && response.headers && response.headers["content-type"] =~ /json/
-          took     = (json['took'] ? sprintf('%.3fs', json['took']/1000.0) : 'n/a') rescue 'n/a'
+          json = serializer.load(response.body) if response.body &&
+                                                       !response.body.empty? &&
+                                                       response.headers &&
+                                                       response.headers["content-type"] =~ /json/
+          took = (json['took'] ? sprintf('%.3fs', json['took'] / 1000.0) : 'n/a') rescue 'n/a'
           __log_response(method, path, params, body, url, response, json, took, duration) unless ignore.include?(response.status.to_i)
           __trace(method, path, params, connection_headers(connection), body, url, response, nil, 'N/A', duration) if tracer
           log_warn(response.headers['warning']) if response.headers&.[]('warning')
@@ -374,17 +372,21 @@ module Elastic
         private
 
         USER_AGENT_STR = 'User-Agent'.freeze
-        USER_AGENT_REGEX = /user\-?\_?agent/
+        USER_AGENT_REGEX = /user-?_?agent/
         ACCEPT_ENCODING = 'Accept-Encoding'.freeze
         CONTENT_ENCODING = 'Content-Encoding'.freeze
         CONTENT_TYPE_STR = 'Content-Type'.freeze
-        CONTENT_TYPE_REGEX = /content\-?\_?type/
+        CONTENT_TYPE_REGEX = /content-?_?type/
         DEFAULT_CONTENT_TYPE = 'application/json'.freeze
         GZIP = 'gzip'.freeze
         GZIP_FIRST_TWO_BYTES = '1f8b'.freeze
         HEX_STRING_DIRECTIVE = 'H*'.freeze
         RUBY_ENCODING = '1.9'.respond_to?(:force_encoding)
 
+        def max_retries(opts)
+          opts[:retry_on_failure] == true ? DEFAULT_MAX_RETRIES : opts[:retry_on_failure]
+        end
+
         def compress_request(body, headers)
           if body
             headers ||= {}
@@ -411,7 +413,7 @@ module Elastic
 
           io = StringIO.new(body)
           gzip_reader = if RUBY_ENCODING
-                          Zlib::GzipReader.new(io, :encoding => 'ASCII-8BIT')
+                          Zlib::GzipReader.new(io, encoding: 'ASCII-8BIT')
                         else
                           Zlib::GzipReader.new(io)
                         end
@@ -429,7 +431,7 @@ module Elastic
         end
 
         def apply_headers(client, options)
-          headers = options[:headers].clone || {}
+          headers = options[:headers] || {}
           headers[CONTENT_TYPE_STR] = find_value(headers, CONTENT_TYPE_REGEX) || DEFAULT_CONTENT_TYPE
           headers[USER_AGENT_STR] = find_value(headers, USER_AGENT_REGEX) || user_agent_header(client)
           client.headers[ACCEPT_ENCODING] = GZIP if use_compression?
@@ -444,7 +446,7 @@ module Elastic
           end
         end
 
-        def user_agent_header(client)
+        def user_agent_header(_client)
           @user_agent ||= begin
             meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
             if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
@@ -455,7 +457,8 @@ module Elastic
         end
 
         def connection_headers(connection)
-          if defined?(Elastic::Transport::Transport::HTTP::Manticore) && self.class == Elastic::Transport::Transport::HTTP::Manticore
+          if defined?(Elastic::Transport::Transport::HTTP::Manticore) &&
+             instance_of?(Elastic::Transport::Transport::HTTP::Manticore)
             @request_options[:headers]
           else
             connection.connection.headers

data/lib/elastic/transport/transport/errors.rb

@@ -18,7 +18,6 @@
 module Elastic
   module Transport
     module Transport
-
       # Generic client error
       #
       class Error < StandardError; end
@@ -78,14 +77,13 @@ module Elastic
         505 => 'HTTPVersionNotSupported',
         506 => 'VariantAlsoNegotiates',
         510 => 'NotExtended'
-      }
+      }.freeze
 
-      ERRORS = HTTP_STATUSES.inject({}) do |sum, error|
+      ERRORS = HTTP_STATUSES.each_with_object({}) do |error, sum|
         status, name = error
         sum[status] = Errors.const_set name, Class.new(ServerError)
         sum
       end
-
     end
   end
 end

data/lib/elastic/transport/transport/http/curb.rb

@@ -37,31 +37,34 @@ module Elastic
               body, headers = compress_request(body, headers)
 
               case method
-                when 'HEAD'
-                  connection.connection.set :nobody, true
-                when 'GET', 'POST', 'PUT', 'DELETE'
-                  connection.connection.set :nobody, false
-                  connection.connection.put_data = body if body
+              when 'HEAD'
+                connection.connection.set :nobody, true
+              when 'GET', 'POST', 'PUT', 'DELETE'
+                connection.connection.set :nobody, false
+                connection.connection.put_data = body if body
 
-                  if headers
-                    if connection.connection.headers
-                      connection.connection.headers.merge!(headers)
-                    else
-                      connection.connection.headers = headers
-                    end
+                if headers
+                  if connection.connection.headers
+                    connection.connection.headers.merge!(headers)
+                  else
+                    connection.connection.headers = headers
                   end
+                end
 
-                else raise ArgumentError, "Unsupported HTTP method: #{method}"
+              else raise ArgumentError, "Unsupported HTTP method: #{method}"
               end
 
               connection.connection.http(method.to_sym)
+              header_string = connection.connection.header_str.to_s
 
-              response_headers = {}
-              response_headers['content-type'] = 'application/json' if connection.connection.header_str =~ /\/json/
+              _response_status, *response_headers = header_string.split(/[\r\n]+/).map(&:strip)
+              response_headers = Hash[response_headers.flat_map { |s| s.scan(/^(\S+): (.+)/) }].transform_keys(&:downcase)
 
-              Response.new connection.connection.response_code,
-                           decompress_response(connection.connection.body_str),
-                           response_headers
+              Response.new(
+                connection.connection.response_code,
+                decompress_response(connection.connection.body_str),
+                response_headers
+              )
             end
           end
 
@@ -73,7 +76,7 @@ module Elastic
             client = ::Curl::Easy.new
 
             apply_headers(client, options)
-            client.url     = __full_url(host)
+            client.url = __full_url(host)
 
             if host[:user]
               client.http_auth_types = host[:auth_type] || :basic
@@ -105,13 +108,13 @@ module Elastic
 
           def user_agent_header(client)
             @user_agent ||= begin
-              meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
-              if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
-                meta << "#{RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase} #{RbConfig::CONFIG['target_cpu']}"
-              end
-              meta << "Curb #{Curl::CURB_VERSION}"
-              "elastic-transport-ruby/#{VERSION} (#{meta.join('; ')})"
-            end
+                              meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
+                              if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
+                                meta << "#{RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase} #{RbConfig::CONFIG['target_cpu']}"
+                              end
+                              meta << "Curb #{Curl::CURB_VERSION}"
+                              "elastic-transport-ruby/#{VERSION} (#{meta.join('; ')})"
+                            end
           end
         end
       end

data/lib/elastic/transport/transport/http/faraday.rb

@@ -34,26 +34,27 @@ module Elastic
           #
           def perform_request(method, path, params = {}, body = nil, headers = nil, opts = {})
             super do |connection, url|
-              headers = if connection.connection.headers
-                          if !headers.nil?
-                            connection.connection.headers.merge(headers)
-                          else
-                            connection.connection.headers
-                          end
-                        else
-                          headers
-                        end
+              headers = parse_headers(headers, connection)
               body = body ? __convert_to_json(body) : nil
               body, headers = compress_request(body, headers)
 
-              response = connection.connection.run_request(
-                method.downcase.to_sym,
-                url,
-                body,
-                headers
-              )
+              response = connection.connection.run_request(method.downcase.to_sym, url, body, headers)
 
-              Response.new response.status, decompress_response(response.body), response.headers
+              Response.new(response.status, decompress_response(response.body), response.headers)
+            end
+          end
+
+          # Merges headers already present in the connection and the ones passed in to perform_request
+          #
+          def parse_headers(headers, connection)
+            if connection.connection.headers
+              if !headers.nil?
+                connection.connection.headers.merge(headers)
+              else
+                connection.connection.headers
+              end
+            else
+              headers
             end
           end
 
@@ -73,10 +74,10 @@ module Elastic
           #
           def host_unreachable_exceptions
             [
-                ::Faraday::ConnectionFailed,
-                ::Faraday::TimeoutError,
-                ::Faraday.const_defined?(:ServerError) ? ::Faraday::ServerError : nil,
-                ::Faraday::SSLError
+              ::Faraday::ConnectionFailed,
+              ::Faraday::TimeoutError,
+              ::Faraday.const_defined?(:ServerError) ? ::Faraday::ServerError : nil,
+              ::Faraday::SSLError
             ].compact
           end
 
@@ -84,13 +85,14 @@ module Elastic
 
           def user_agent_header(client)
             @user_agent ||= begin
-              meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
-              if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
-                meta << "#{RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase} #{RbConfig::CONFIG['target_cpu']}"
-              end
-              meta << "#{client.headers[USER_AGENT_STR]}"
-              "elastic-transport-ruby/#{VERSION} (#{meta.join('; ')})"
-            end
+                              meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
+                              if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
+                                meta << "#{RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase} " \
+                                        "#{RbConfig::CONFIG['target_cpu']}"
+                              end
+                              meta << client.headers[USER_AGENT_STR]
+                              "elastic-transport-ruby/#{VERSION} (#{meta.join('; ')})"
+                            end
           end
         end
       end

data/lib/elastic/transport/transport/http/manticore.rb

@@ -162,7 +162,7 @@ module Elastic
           private
 
           def apply_headers(options)
-            headers = options[:headers].clone || options.dig(:transport_options, :headers).clone || {}
+            headers = options[:headers] || options.dig(:transport_options, :headers) || {}
             headers[CONTENT_TYPE_STR] = find_value(headers, CONTENT_TYPE_REGEX) || DEFAULT_CONTENT_TYPE
             headers[USER_AGENT_STR] = find_value(headers, USER_AGENT_REGEX) || find_value(@request_options[:headers], USER_AGENT_REGEX) || user_agent_header
             headers[ACCEPT_ENCODING] = GZIP if use_compression?

data/lib/elastic/transport/transport/response.rb

@@ -19,7 +19,8 @@ module Elastic
   module Transport
     module Transport
       # Wraps the response from Elasticsearch.
-      # It provides `body`, `status` and `headers` methods
+      # It provides `body`, `status` and `headers` methods, but you can treat is as a hash and
+      # access the keys directly.
       class Response
         attr_reader :status, :body, :headers
 
@@ -28,7 +29,7 @@ module Elastic
         # @param headers [Hash]    Response headers
         def initialize(status, body, headers = {})
           @status, @body, @headers = status, body, headers
-          @body = body.force_encoding('UTF-8') if body.respond_to?(:force_encoding) && !body.frozen?
+          @body = body.force_encoding('UTF-8') if body.respond_to?(:force_encoding)
         end
       end
     end

data/lib/elastic/transport/transport/sniffer.rb

@@ -76,9 +76,7 @@ module Elastic
         end
 
         def parse_publish_address(publish_address)
-          # When publish_address is in the format 'inet[hostname/ip:port]'
-          return parse_address_port(publish_address[6..-2]) if publish_address =~ /^inet\[.*\]$/
-
+          # publish_address is in the format hostname/ip:port
           if publish_address =~ /\//
             parts = publish_address.partition('/')
             [ parts[0], parse_address_port(parts[2])[1] ]

data/lib/elastic/transport/version.rb

@@ -17,6 +17,6 @@
 
 module Elastic
   module Transport
-    VERSION = '8.1.2'.freeze
+    VERSION = '8.2.0'.freeze
   end
 end

data/spec/elastic/transport/base_spec.rb

@@ -105,7 +105,8 @@ describe Elastic::Transport::Transport::Base do
     let(:arguments) do
       {
         hosts: ['http://unavailable:9200', 'http://unavailable:9201'],
-        retry_on_failure: 2
+        retry_on_failure: 2,
+        adapter: :net_http
       }
     end
 
@@ -129,7 +130,8 @@ describe Elastic::Transport::Transport::Base do
       let(:arguments) do
         {
           hosts: ELASTICSEARCH_HOSTS,
-          retry_on_status: ['404']
+          retry_on_status: ['404'],
+          adapter: :net_http
         }
       end
 

data/spec/elastic/transport/client_spec.rb

@@ -191,8 +191,8 @@ describe Elastic::Transport::Client do
         it 'uses Faraday NetHttp' do
           expect(adapter).to eq Faraday::Adapter::NetHttp
         end
-      end unless jruby?
-    end
+      end
+    end unless jruby?
 
     context 'when the adapter is patron' do
       let(:adapter) do
@@ -204,9 +204,10 @@ describe Elastic::Transport::Client do
       end
 
       it 'uses Faraday with the adapter' do
+        require 'faraday/patron'
         expect(adapter).to eq Faraday::Adapter::Patron
       end
-    end
+    end unless jruby?
 
     context 'when the adapter is typhoeus' do
       let(:adapter) do
@@ -214,6 +215,8 @@ describe Elastic::Transport::Client do
       end
 
       let(:client) do
+        require 'faraday/typhoeus' if is_faraday_v2?
+
         described_class.new(adapter: :typhoeus, enable_meta_header: false)
       end
 
@@ -234,7 +237,7 @@ describe Elastic::Transport::Client do
       it 'uses Faraday with the adapter' do
         expect(adapter).to eq Faraday::Adapter::Patron
       end
-    end
+    end unless jruby?
 
     context 'when the adapter can be detected', unless: jruby? do
       around do |example|
@@ -274,7 +277,7 @@ describe Elastic::Transport::Client do
       it 'sets the logger' do
         expect(handlers).to include(Faraday::Response::Logger)
       end
-    end
+    end unless jruby?
   end
 
   shared_examples_for 'a client that extracts hosts' do
@@ -1191,17 +1194,7 @@ describe Elastic::Transport::Client do
 
   context 'when the client connects to Elasticsearch' do
     let(:logger) do
-      Logger.new(STDERR).tap do |logger|
-        logger.formatter = proc do |severity, datetime, progname, msg|
-          color = case severity
-                  when /INFO/ then :green
-                  when /ERROR|WARN|FATAL/ then :red
-                  when /DEBUG/ then :cyan
-                  else :white
-                  end
-          ANSI.ansi(severity[0] + ' ', color, :faint) + ANSI.ansi(msg, :white, :faint) + "\n"
-        end
-      end unless ENV['QUIET']
+      Logger.new($stderr) unless ENV['QUIET']
     end
 
     let(:port) do
@@ -1263,6 +1256,8 @@ describe Elastic::Transport::Client do
         end
 
         context 'when the Faraday adapter is set in the block' do
+          require 'faraday/net_http_persistent' if is_faraday_v2?
+
           let(:client) do
             Elastic::Transport::Client.new(host: ELASTICSEARCH_HOSTS.first, logger: logger) do |client|
               client.adapter(:net_http_persistent)
@@ -1414,6 +1409,8 @@ describe Elastic::Transport::Client do
           end
 
           context 'when using the HTTPClient adapter' do
+            require 'faraday/httpclient'
+
             let(:client) do
               described_class.new(hosts: ELASTICSEARCH_HOSTS, compression: true, adapter: :httpclient, enable_meta_header: false)
             end

data/spec/elastic/transport/meta_header_spec.rb

@@ -155,7 +155,7 @@ describe Elastic::Transport::Client do
           expect(headers).to include('x-elastic-client-meta' => meta)
 
           Typhoeus = @klass if was_required
-        end unless jruby?
+        end
 
         it 'sets adapter in the meta header' do
           require 'typhoeus'
@@ -163,7 +163,7 @@ describe Elastic::Transport::Client do
           meta = "#{meta_header},ty=#{Typhoeus::VERSION}"
           expect(headers).to include('x-elastic-client-meta' => meta)
         end
-      end
+      end unless jruby?
 
       unless jruby?
         let(:adapter) { :patron }

data/spec/elastic/transport/sniffer_spec.rb

@@ -257,24 +257,6 @@ describe Elastic::Transport::Transport::Sniffer do
       end
     end
 
-    context 'when the address is IPv4' do
-      let(:publish_address) do
-        'inet[/127.0.0.1:9200]'
-      end
-
-      it 'parses the response' do
-        expect(hosts.size).to eq(1)
-      end
-
-      it 'correctly parses the host' do
-        expect(hosts[0][:host]).to eq('127.0.0.1')
-      end
-
-      it 'correctly parses the port' do
-        expect(hosts[0][:port]).to eq('9200')
-      end
-    end
-
     context 'when the transport has :randomize_hosts option' do
       let(:raw_response) do
         { 'nodes' => { 'n1' => { 'http' => { 'publish_address' => '127.0.0.1:9250' } },