elastic-transport 8.1.1 → 8.2.0

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/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.1'.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' } },

data/spec/spec_helper.rb

@@ -21,7 +21,6 @@ end
 
 require 'elastic-transport'
 require 'logger'
-require 'ansi/code'
 require 'hashie/mash'
 if defined?(JRUBY_VERSION)
   require 'elastic/transport/transport/http/manticore'
@@ -74,6 +73,10 @@ def default_client
   $client ||= Elastic::Transport::Client.new(hosts: ELASTICSEARCH_HOSTS)
 end
 
+def is_faraday_v2?
+  Gem::Version.new(Faraday::VERSION) >= Gem::Version.new(2)
+end
+
 module Config
   def self.included(context)
     # Get the hosts to use to connect an elasticsearch client.

data/test/integration/jruby_test.rb

@@ -21,7 +21,7 @@ if JRUBY
   require 'elastic/transport/transport/http/manticore'
 
   class Elastic::Transport::ClientManticoreIntegrationTest < Minitest::Test
-    context "Transport" do
+    context 'Transport' do
       setup do
         uri = URI(HOST)
         @host = {

data/test/integration/transport_test.rb

@@ -18,9 +18,8 @@
 require 'test_helper'
 
 class Elastic::Transport::ClientIntegrationTest < Minitest::Test
-  context "Transport" do
+  context 'Transport' do
     setup do
-      begin; Object.send(:remove_const, :Patron);   rescue NameError; end
       uri = URI(HOST)
       @host = {
         host: uri.host,
@@ -30,69 +29,116 @@ class Elastic::Transport::ClientIntegrationTest < Minitest::Test
       }
     end
 
-    should "allow to customize the Faraday adapter to Typhoeus" do
-      require 'typhoeus'
-      require 'typhoeus/adapters/faraday'
-
+    should 'use the default Faraday adapter' do
       transport = Elastic::Transport::Transport::HTTP::Faraday.new(hosts: [@host]) do |f|
         f.response :logger
-        f.adapter  :typhoeus
       end
 
       client = Elastic::Transport::Client.new(transport: transport)
+      assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::NetHttp)
       client.perform_request 'GET', ''
-    end unless jruby?
+    end
 
-    should "allow to customize the Faraday adapter to NetHttpPersistent" do
-      require 'net/http/persistent'
+    unless jruby?
+      should 'allow to customize the Faraday adapter to Typhoeus' do
+        if is_faraday_v2?
+          require 'faraday/typhoeus'
+        else
+          require 'typhoeus'
+        end
+
+        transport = Elastic::Transport::Transport::HTTP::Faraday.new(hosts: [@host]) do |f|
+          f.response :logger
+          f.adapter  :typhoeus
+        end
+
+        client = Elastic::Transport::Client.new(transport: transport)
+        assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::Typhoeus)
+        client.perform_request 'GET', ''
+      end
 
-      transport = Elastic::Transport::Transport::HTTP::Faraday.new(hosts: [@host]) do |f|
-        f.response :logger
-        f.adapter  :net_http_persistent
+      should 'use the Curb client' do
+        require 'curb'
+        require 'elastic/transport/transport/http/curb'
+
+        transport = Elastic::Transport::Transport::HTTP::Curb.new(hosts: [@host]) do |curl|
+          curl.verbose = true
+        end
+
+        client = Elastic::Transport::Client.new(transport: transport)
+        assert_equal(client.transport.class, Elastic::Transport::Transport::HTTP::Curb)
+        client.perform_request 'GET', ''
       end
 
-      client = Elastic::Transport::Client.new(transport: transport)
-      client.perform_request 'GET', ''
-    end
+      should 'deserialize JSON responses in the Curb client' do
+        require 'curb'
+        require 'elastic/transport/transport/http/curb'
 
-    should "allow to define connection parameters and pass them" do
-      transport = Elastic::Transport::Transport::HTTP::Faraday.new(
-        hosts: [@host],
-        options: { transport_options: { params: { format: 'yaml' } } }
-      )
+        transport = Elastic::Transport::Transport::HTTP::Curb.new(hosts: [@host]) do |curl|
+          curl.verbose = true
+        end
 
-      client = Elastic::Transport::Client.new transport: transport
-      response = client.perform_request 'GET', ''
+        client = Elastic::Transport::Client.new(transport: transport)
+        response = client.perform_request 'GET', ''
 
-      assert response.body.start_with?("---\n"), "Response body should be YAML: #{response.body.inspect}"
+        assert_respond_to(response.body, :to_hash)
+        assert_not_nil response.body['name']
+        assert_equal 'application/json', response.headers['content-type']
+        assert_equal 'Elasticsearch', response.headers['x-elastic-product']
+      end
+
+      should 'allow to customize the Faraday adapter to Patron' do
+        if is_faraday_v2?
+          require 'faraday/patron'
+        else
+          require 'patron'
+        end
+        transport = Elastic::Transport::Transport::HTTP::Faraday.new(hosts: [@host]) do |f|
+          f.response :logger
+          f.adapter  :patron
+        end
+
+        client = Elastic::Transport::Client.new(transport: transport)
+        assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::Patron)
+        client.perform_request 'GET', ''
+      end
     end
 
-    should "use the Curb client" do
-      require 'curb'
-      require 'elastic/transport/transport/http/curb'
+    should 'allow to customize the Faraday adapter to NetHttpPersistent' do
+      require 'faraday/net_http_persistent'
 
-      transport = Elastic::Transport::Transport::HTTP::Curb.new(hosts: [@host]) do |curl|
-        curl.verbose = true
+      transport = Elastic::Transport::Transport::HTTP::Faraday.new(hosts: [@host]) do |f|
+        f.response :logger
+        f.adapter  :net_http_persistent
       end
 
       client = Elastic::Transport::Client.new(transport: transport)
+      assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::NetHttpPersistent)
       client.perform_request 'GET', ''
-    end unless JRUBY
+    end
 
-    should "deserialize JSON responses in the Curb client" do
-      require 'curb'
-      require 'elastic/transport/transport/http/curb'
+    should 'allow to customize the Faraday adapter to HTTPClient' do
+      require 'faraday/httpclient'
 
-      transport = Elastic::Transport::Transport::HTTP::Curb.new(hosts: [@host]) do |curl|
-        curl.verbose = true
+      transport = Elastic::Transport::Transport::HTTP::Faraday.new(hosts: [@host]) do |f|
+        f.response :logger
+        f.adapter  :httpclient
       end
 
       client = Elastic::Transport::Client.new(transport: transport)
-      response = client.perform_request 'GET', ''
+      assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::HTTPClient)
+      client.perform_request 'GET', ''
+    end
 
-      assert_respond_to(response.body, :to_hash)
-      assert_not_nil response.body['name']
-      assert_equal 'application/json', response.headers['content-type']
-    end unless jruby?
+    should 'allow to define connection parameters and pass them' do
+      transport = Elastic::Transport::Transport::HTTP::Faraday.new(
+        hosts: [@host],
+        options: { transport_options: { params: { format: 'yaml' } } }
+      )
+
+      client = Elastic::Transport::Client.new transport: transport
+      response = client.perform_request 'GET', ''
+      assert response.body.start_with?("---\n"), "Response body should be YAML: #{response.body.inspect}"
+    end
   end
 end

data/test/test_helper.rb

@@ -14,6 +14,7 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
+require 'uri'
 
 password = ENV['ELASTIC_PASSWORD'] || 'changeme'
 host = ENV['TEST_ES_SERVER'] || 'http://localhost:9200'
@@ -31,15 +32,13 @@ end
 
 require 'minitest/autorun'
 require 'minitest/reporters'
-require 'shoulda/context'
 require 'mocha/minitest'
-require 'ansi/code'
+require 'shoulda/context'
 
-require 'require-prof' if ENV["REQUIRE_PROF"]
 require 'elastic-transport'
-require 'logger'
-
 require 'hashie'
+require 'logger'
+require 'require-prof' if ENV["REQUIRE_PROF"]
 
 RequireProf.print_timing_infos if ENV["REQUIRE_PROF"]
 
@@ -80,4 +79,8 @@ module Minitest
   end
 end
 
+def is_faraday_v2?
+  Gem::Version.new(Faraday::VERSION) >= Gem::Version.new(2)
+end
+
 Minitest::Reporters.use! FixedMinitestSpecReporter.new