elasticsearch-transport 7.10.0.pre → 7.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64ed0d4e52c93d1bfaabaef470e71308ac9961da744584f770283f605131e3ac
-  data.tar.gz: 40b0baa58407ef49ac9fac314fbd9f84df3c8408d7312132ebe8f19cb1f5e35c
+  metadata.gz: a61db52575ad4a8669cbef5e60e6f90607f82155206c85e9e473835dfa35e0e5
+  data.tar.gz: e8d2f1899f4ebf17cfafdfee98174f86ba52633f04d8fadd30ec9b4d31457546
 SHA512:
-  metadata.gz: 24eefe245bb7fc61431b6798d0898bbadc4c0fafbefa6303b61336e4673df8e37f6ae71e0dc107ea0c446821a0d8138ebad16380a13b8dcb2ce5ee3c762acd8f
-  data.tar.gz: 8b790e93528ae4c3db68a7f63272f2cf0eefc3e9a8b66d2e2d1b8b8bd6dea67cdb180789e2df824cdc50eb90c8ef669fb7968f370c13d34d27dc2f3329ca5e53
+  metadata.gz: 0ca54a9d0f096d1f8675ea7ef4d84da517f34ffeea31c9ce72f3c4a9257cfab33d6548582490ff7f87708a0ff3bc25a29c907274870d2ea22df34d7585c6d59e
+  data.tar.gz: 854a17c7995ceede84fa87f73ccb7fafd8d57a8ff400429e8877258bd00e7cadbc69562400af8d682cb195b51599867bfce2fc84db151d3bff45c846844b188b

data/Gemfile

@@ -32,7 +32,7 @@ if File.exist? File.expand_path('../../elasticsearch/elasticsearch.gemspec', __F
   gem 'elasticsearch', path: File.expand_path('../../elasticsearch', __FILE__), require: false
 end
 
-group :development do
+group :development, :test do
   gem 'rspec'
   if defined?(JRUBY_VERSION)
     gem 'pry-nav'

data/README.md

@@ -136,7 +136,7 @@ Please see below for an exception to this when connecting using an Elastic Cloud
 
 If you are using [Elastic Cloud](https://www.elastic.co/cloud), you can provide your cloud id to the client.
 You must supply your username and password separately, and optionally a port. If no port is supplied,
-port 9243 will be used.
+port 443 will be used.
 
 Note: Do not enable sniffing when using Elastic Cloud. The nodes are behind a load balancer so
 Elastic Cloud will take care of everything for you.
@@ -187,18 +187,24 @@ Elasticsearch::Client.new(
 
 ### Logging
 
-To log requests and responses to standard output with the default logger (an instance of Ruby's {::Logger} class),
-set the `log` argument:
+To log requests and responses to standard output with the default logger (an instance of Ruby's {::Logger} class), set the `log` argument to true:
 
 ```ruby
-Elasticsearch::Client.new log: true
+Elasticsearch::Client.new(log: true)
+```
+
+You can also use [ecs-logging](https://github.com/elastic/ecs-logging-ruby). `ecs-logging` is a set of libraries that allows you to transform your application logs to structured logs that comply with the [Elastic Common Schema (ECS)](https://www.elastic.co/guide/en/ecs/current/ecs-reference.html):
+
+```ruby
+logger = EcsLogging::Logger.new($stdout)
+Elasticsearch::Client.new(logger: logger)
 ```
 
 
 To trace requests and responses in the _Curl_ format, set the `trace` argument:
 
 ```ruby
-Elasticsearch::Client.new trace: true
+Elasticsearch::Client.new(trace: true)
 ```
 
 You can customize the default logger or tracer:
@@ -211,7 +217,7 @@ You can customize the default logger or tracer:
 Or, you can use a custom `::Logger` instance:
 
 ```ruby
-Elasticsearch::Client.new logger: Logger.new(STDERR)
+Elasticsearch::Client.new(logger: Logger.new(STDERR))
 ```
 
 You can pass the client any conforming logger implementation:
@@ -223,7 +229,7 @@ log = Logging.logger['elasticsearch']
 log.add_appenders Logging.appenders.stdout
 log.level = :info
 
-client = Elasticsearch::Client.new logger: log
+client = Elasticsearch::Client.new(logger: log)
 ```
 
 ### Custom HTTP Headers

data/elasticsearch-transport.gemspec

@@ -39,7 +39,7 @@ Gem::Specification.new do |s|
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ['lib']
 
-  s.extra_rdoc_files  = [ 'README.md', 'LICENSE.txt' ]
+  s.extra_rdoc_files  = [ 'README.md', 'LICENSE' ]
   s.rdoc_options      = [ '--charset=UTF-8' ]
 
   s.required_ruby_version = '>= 2.4'

data/lib/elasticsearch/transport/client.rb

@@ -49,9 +49,15 @@ module Elasticsearch
       DEFAULT_HOST = 'localhost:9200'.freeze
 
       # The default port to use if connecting using a Cloud ID.
+      # Updated from 9243 to 443 in client version 7.10.1
       #
       # @since 7.2.0
-      DEFAULT_CLOUD_PORT = 9243
+      DEFAULT_CLOUD_PORT = 443
+
+      # The default port to use if not otherwise specified.
+      #
+      # @since 7.2.0
+      DEFAULT_PORT = 9200
 
       # Returns the transport object.
       #
@@ -114,8 +120,11 @@ module Elasticsearch
       #
       # @option api_key [String, Hash] :api_key Use API Key Authentication, either the base64 encoding of `id` and `api_key`
       #                                         joined by a colon as a String, or a hash with the `id` and `api_key` values.
-      # @option opaque_id_prefix [String] :opaque_id_prefix set a prefix for X-Opaque-Id when initializing the client. This
-      # will be prepended to the id you set before each request if you're using X-Opaque-Id
+      # @option opaque_id_prefix [String] :opaque_id_prefix set a prefix for X-Opaque-Id when initializing the client.
+      #                                                     This will be prepended to the id you set before each request
+      #                                                     if you're using X-Opaque-Id
+      # @option enable_meta_header [Boolean] :enable_meta_header Enable sending the meta data header to Cloud.
+      #                                                          (Default: true)
       #
       # @yield [faraday] Access and configure the `Faraday::Connection` instance directly with a block
       #
@@ -130,6 +139,7 @@ module Elasticsearch
         @arguments[:randomize_hosts]    ||= false
         @arguments[:transport_options]  ||= {}
         @arguments[:http]               ||= {}
+        @arguments[:enable_meta_header] = arguments.fetch(:enable_meta_header) { true }
         @options[:http]                 ||= {}
 
         set_api_key if (@api_key = @arguments[:api_key])
@@ -152,15 +162,18 @@ module Elasticsearch
         if @arguments[:transport]
           @transport = @arguments[:transport]
         else
-          transport_class  = @arguments[:transport_class] || DEFAULT_TRANSPORT_CLASS
-          if transport_class == Transport::HTTP::Faraday
-            @transport = transport_class.new(hosts: @seeds, options: @arguments) do |faraday|
-              faraday.adapter(@arguments[:adapter] || __auto_detect_adapter)
-              block&.call faraday
-            end
-          else
-            @transport = transport_class.new(hosts: @seeds, options: @arguments)
-          end
+          @transport_class = @arguments[:transport_class] || DEFAULT_TRANSPORT_CLASS
+          @transport = if @transport_class == Transport::HTTP::Faraday
+                         @arguments[:adapter] ||= __auto_detect_adapter
+                         set_meta_header
+                         @transport_class.new(hosts: @seeds, options: @arguments) do |faraday|
+                           faraday.adapter(@arguments[:adapter])
+                           block&.call faraday
+                         end
+                       else
+                         set_meta_header
+                         @transport_class.new(hosts: @seeds, options: @arguments)
+                       end
         end
       end
 
@@ -180,27 +193,111 @@ module Elasticsearch
 
       def set_api_key
         @api_key = __encode(@api_key) if @api_key.is_a? Hash
+        add_header('Authorization' => "ApiKey #{@api_key}")
+        @arguments.delete(:user)
+        @arguments.delete(:password)
+      end
+
+      def add_header(header)
         headers = @arguments[:transport_options]&.[](:headers) || {}
-        headers.merge!('Authorization' => "ApiKey #{@api_key}")
+        headers.merge!(header)
         @arguments[:transport_options].merge!(
           headers: headers
         )
-        @arguments.delete(:user)
-        @arguments.delete(:password)
+      end
+
+      def set_meta_header
+        return if @arguments[:enable_meta_header] == false
+
+        service, version = meta_header_service_version
+
+        meta_headers = {
+          service.to_sym => version,
+          rb: RUBY_VERSION,
+          t: Elasticsearch::Transport::VERSION
+        }
+        meta_headers.merge!(meta_header_engine) if meta_header_engine
+        meta_headers.merge!(meta_header_adapter) if meta_header_adapter
+
+        add_header({ 'x-elastic-client-meta' => meta_headers.map { |k, v| "#{k}=#{v}" }.join(',') })
+      end
+
+      def meta_header_service_version
+        if defined?(Elastic::META_HEADER_SERVICE_VERSION)
+          Elastic::META_HEADER_SERVICE_VERSION
+        elsif defined?(Elasticsearch::VERSION)
+          [:es, client_meta_version(Elasticsearch::VERSION)]
+        else
+          [:es, client_meta_version(Elasticsearch::Transport::VERSION)]
+        end
+      end
+
+      def client_meta_version(version)
+        regexp = /^([0-9]+\.[0-9]+\.[0-9]+)(\.?[a-z0-9.-]+)?$/
+        match = version.match(regexp)
+        return "#{match[1]}p" if (match[2])
+
+        version
+      end
+
+      def meta_header_engine
+        case RUBY_ENGINE
+        when 'ruby'
+          {}
+        when 'jruby'
+          { jv: ENV_JAVA['java.version'], jr: JRUBY_VERSION }
+        when 'rbx'
+          { rbx: RUBY_VERSION }
+        else
+          { RUBY_ENGINE.to_sym => RUBY_VERSION }
+        end
+      end
+
+      def meta_header_adapter
+        if @transport_class == Transport::HTTP::Faraday
+          {fd: Faraday::VERSION}.merge(
+            case @arguments[:adapter]
+            when :patron
+              {pt: Patron::VERSION}
+            when :net_http
+              {nh: defined?(Net::HTTP::VERSION) ? Net::HTTP::VERSION : Net::HTTP::HTTPVersion}
+            when :typhoeus
+              {ty: Typhoeus::VERSION}
+            when :httpclient
+              {hc: HTTPClient::VERSION}
+            when :net_http_persistent
+              {np: Net::HTTP::Persistent::VERSION}
+            else
+              {}
+            end
+          )
+        elsif defined?(Transport::HTTP::Curb) && @transport_class == Transport::HTTP::Curb
+          {cl: Curl::CURB_VERSION}
+        elsif defined?(Transport::HTTP::Manticore) && @transport_class == Transport::HTTP::Manticore
+          {mc: Manticore::VERSION}
+        end
       end
 
       def extract_cloud_creds(arguments)
-        return unless arguments[:cloud_id]
+        return unless arguments[:cloud_id] && !arguments[:cloud_id].empty?
 
         name = arguments[:cloud_id].split(':')[0]
         cloud_url, elasticsearch_instance = Base64.decode64(arguments[:cloud_id].gsub("#{name}:", '')).split('$')
+
+        if cloud_url.include?(':')
+          url, port = cloud_url.split(':')
+          host = "#{elasticsearch_instance}.#{url}"
+        else
+          host = "#{elasticsearch_instance}.#{cloud_url}"
+          port = arguments[:port] || DEFAULT_CLOUD_PORT
+        end
         [
           {
             scheme: 'https',
             user: arguments[:user],
             password: arguments[:password],
-            host: "#{elasticsearch_instance}.#{cloud_url}",
-            port: arguments[:port] || DEFAULT_CLOUD_PORT
+            host: host,
+            port: port.to_i
           }
         ]
       end
@@ -235,36 +332,38 @@ module Elasticsearch
 
       def __parse_host(host)
         host_parts = case host
-        when String
-          if host =~ /^[a-z]+\:\/\//
-            # Construct a new `URI::Generic` directly from the array returned by URI::split.
-            # This avoids `URI::HTTP` and `URI::HTTPS`, which supply default ports.
-            uri = URI::Generic.new(*URI.split(host))
-
-            { :scheme => uri.scheme,
-              :user => uri.user,
-              :password => uri.password,
-              :host => uri.host,
-              :path => uri.path,
-              :port => uri.port }
-          else
-            host, port = host.split(':')
-            { :host => host,
-              :port => port }
-          end
-        when URI
-          { :scheme => host.scheme,
-            :user => host.user,
-            :password => host.password,
-            :host => host.host,
-            :path => host.path,
-            :port => host.port }
-        when Hash
-          host
-        else
-          raise ArgumentError, "Please pass host as a String, URI or Hash -- #{host.class} given."
-        end
-
+                     when String
+                       if host =~ /^[a-z]+\:\/\//
+                         # Construct a new `URI::Generic` directly from the array returned by URI::split.
+                         # This avoids `URI::HTTP` and `URI::HTTPS`, which supply default ports.
+                         uri = URI::Generic.new(*URI.split(host))
+                         default_port = uri.scheme == 'https' ? 443 : DEFAULT_PORT
+                         {
+                           scheme: uri.scheme,
+                           user: uri.user,
+                           password: uri.password,
+                           host: uri.host,
+                           path: uri.path,
+                           port: uri.port || default_port
+                         }
+                       else
+                         host, port = host.split(':')
+                         { host: host, port: port }
+                       end
+                     when URI
+                       {
+                         scheme: host.scheme,
+                         user: host.user,
+                         password: host.password,
+                         host: host.host,
+                         path: host.path,
+                         port: host.port
+                       }
+                     when Hash
+                       host
+                     else
+                       raise ArgumentError, "Please pass host as a String, URI or Hash -- #{host.class} given."
+                     end
         if @api_key
           # Remove Basic Auth if using API KEY
           host_parts.delete(:user)

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

@@ -33,9 +33,17 @@ module Elasticsearch
           # @return [Response]
           # @see    Transport::Base#perform_request
           #
-          def perform_request(method, path, params={}, body=nil, headers=nil, opts={})
+          def perform_request(method, path, params = {}, body = nil, headers = nil, opts = {})
             super do |connection, url|
-              headers = headers || connection.connection.headers
+              headers = if connection.connection.headers
+                          if !headers.nil?
+                            connection.connection.headers.merge(headers)
+                          else
+                            connection.connection.headers
+                          end
+                        else
+                          headers
+                        end
 
               response = connection.connection.run_request(method.downcase.to_sym,
                                                            url,

data/lib/elasticsearch/transport/version.rb

@@ -17,6 +17,6 @@
 
 module Elasticsearch
   module Transport
-    VERSION = "7.10.0.pre"
+    VERSION = '7.11.1'.freeze
   end
 end

data/spec/elasticsearch/transport/client_spec.rb

@@ -246,7 +246,7 @@ describe Elasticsearch::Transport::Client do
       end
 
       let(:client) do
-        described_class.new(adapter: :patron)
+        described_class.new(adapter: :patron, enable_meta_header: false)
       end
 
       it 'uses Faraday with the adapter' do
@@ -260,7 +260,7 @@ describe Elasticsearch::Transport::Client do
       end
 
       let(:client) do
-        described_class.new(adapter: :typhoeus)
+        described_class.new(adapter: :typhoeus, enable_meta_header: false)
       end
 
       it 'uses Faraday with the adapter' do
@@ -274,7 +274,7 @@ describe Elasticsearch::Transport::Client do
       end
 
       let(:client) do
-        described_class.new('adapter' => :patron)
+        described_class.new(adapter: :patron, enable_meta_header: false)
       end
 
       it 'uses Faraday with the adapter' do
@@ -344,24 +344,19 @@ describe Elasticsearch::Transport::Client do
       expect(hosts[0][:protocol]).to eq('https')
       expect(hosts[0][:user]).to eq('elastic')
       expect(hosts[0][:password]).to eq('changeme')
-      expect(hosts[0][:port]).to eq(9243)
+      expect(hosts[0][:port]).to eq(443)
     end
 
     it 'creates the correct full url' do
       expect(
         client.transport.__full_url(client.transport.hosts[0])
-      ).to eq('https://elastic:changeme@abcd.localhost:9243')
+      ).to eq('https://elastic:changeme@abcd.localhost:443')
     end
 
     context 'when a port is specified' do
 
       let(:client) do
-        described_class.new(
-          cloud_id: 'name:bG9jYWxob3N0JGFiY2QkZWZnaA==',
-          user: 'elastic',
-          password: 'changeme',
-          port: 9200
-        )
+        described_class.new(cloud_id: 'name:bG9jYWxob3N0JGFiY2QkZWZnaA==', user: 'elastic', password: 'changeme', port: 9250)
       end
 
       it 'sets the specified port along with the cloud credentials' do
@@ -369,11 +364,11 @@ describe Elasticsearch::Transport::Client do
         expect(hosts[0][:protocol]).to eq('https')
         expect(hosts[0][:user]).to eq('elastic')
         expect(hosts[0][:password]).to eq('changeme')
-        expect(hosts[0][:port]).to eq(9200)
+        expect(hosts[0][:port]).to eq(9250)
       end
 
       it 'creates the correct full url' do
-        expect(client.transport.__full_url(client.transport.hosts[0])).to eq('https://elastic:changeme@abcd.localhost:9200')
+        expect(client.transport.__full_url(client.transport.hosts[0])).to eq('https://elastic:changeme@abcd.localhost:9250')
       end
     end
 
@@ -396,13 +391,13 @@ describe Elasticsearch::Transport::Client do
         expect(hosts[0][:protocol]).to eq('https')
         expect(hosts[0][:user]).to eq('elasticfantastic')
         expect(hosts[0][:password]).to eq('tobechanged')
-        expect(hosts[0][:port]).to eq(9243)
+        expect(hosts[0][:port]).to eq(443)
       end
 
       it 'creates the correct full url' do
         expect(
           client.transport.__full_url(client.transport.hosts[0])
-        ).to eq('https://elasticfantastic:tobechanged@abcd.localhost:9243')
+        ).to eq('https://elasticfantastic:tobechanged@abcd.localhost:443')
       end
     end
 
@@ -424,125 +419,306 @@ describe Elasticsearch::Transport::Client do
         expect(hosts[0][:protocol]).to eq('https')
         expect(hosts[0][:user]).to eq('elasticfantastic')
         expect(hosts[0][:password]).to eq('changeme')
-        expect(hosts[0][:port]).to eq(9243)
+        expect(hosts[0][:port]).to eq(443)
       end
 
       it 'creates the correct full url' do
         expect(
           client.transport.__full_url(client.transport.hosts[0])
-        ).to eq('https://elasticfantastic:changeme@abcd.localhost:9243')
+        ).to eq('https://elasticfantastic:changeme@abcd.localhost:443')
       end
     end
-  end
 
-  shared_examples_for 'a client that extracts hosts' do
+    context 'when the cloud host provides a port' do
+      let(:client) do
+        described_class.new(
+          cloud_id: 'name:ZWxhc3RpY19zZXJ2ZXI6OTI0MyRlbGFzdGljX2lk',
+          user: 'elastic',
+          password: 'changeme'
+        )
+      end
 
-    context 'when the hosts are a String' do
+      let(:hosts) do
+        client.transport.hosts
+      end
 
-      let(:host) do
-        'myhost'
+      it 'creates the correct full url' do
+        expect(hosts[0][:host]).to eq('elastic_id.elastic_server')
+        expect(hosts[0][:protocol]).to eq('https')
+        expect(hosts[0][:user]).to eq('elastic')
+        expect(hosts[0][:password]).to eq('changeme')
+        expect(hosts[0][:port]).to eq(9243)
       end
+    end
 
-      it 'extracts the host' do
-        expect(hosts[0][:host]).to eq('myhost')
-        expect(hosts[0][:protocol]).to eq('http')
-        expect(hosts[0][:port]).to be(9200)
+    context 'when the cloud host provides a port and the port is also specified' do
+      let(:client) do
+        described_class.new(
+          cloud_id: 'name:ZWxhc3RpY19zZXJ2ZXI6OTI0MyRlbGFzdGljX2lk',
+          user: 'elastic',
+          password: 'changeme',
+          port: 9200
+        )
       end
 
-      context 'when IPv6 format is used' do
+      let(:hosts) do
+        client.transport.hosts
+      end
 
-        around do |example|
-          original_setting = Faraday.ignore_env_proxy
-          Faraday.ignore_env_proxy = true
-          example.run
-          Faraday.ignore_env_proxy = original_setting
-        end
+      it 'creates the correct full url' do
+        expect(hosts[0][:host]).to eq('elastic_id.elastic_server')
+        expect(hosts[0][:protocol]).to eq('https')
+        expect(hosts[0][:user]).to eq('elastic')
+        expect(hosts[0][:password]).to eq('changeme')
+        expect(hosts[0][:port]).to eq(9243)
+      end
+    end
+  end
 
-        let(:host) do
-          'https://[2090:db8:85a3:9811::1f]:8080'
-        end
+  shared_examples_for 'a client that extracts hosts' do
 
-        it 'extracts the host' do
-          expect(hosts[0][:host]).to eq('[2090:db8:85a3:9811::1f]')
-          expect(hosts[0][:scheme]).to eq('https')
-          expect(hosts[0][:port]).to be(8080)
-        end
+    context 'when the host is a String' do
 
-        it 'creates the correct full url' do
-          expect(client.transport.__full_url(client.transport.hosts[0])).to eq('https://[2090:db8:85a3:9811::1f]:8080')
-        end
-      end
+      context 'when there is a protocol specified' do
 
-      context 'when a path is specified' do
+        context 'when credentials are specified \'http://USERNAME:PASSWORD@myhost:8080\'' do
 
-        let(:host) do
-          'https://myhost:8080/api'
-        end
+          let(:host) do
+            'http://USERNAME:PASSWORD@myhost:8080'
+          end
 
-        it 'extracts the host' do
-          expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:scheme]).to eq('https')
-          expect(hosts[0][:path]).to eq('/api')
-          expect(hosts[0][:port]).to be(8080)
-        end
-      end
+          it 'extracts the credentials' do
+            expect(hosts[0][:user]).to eq('USERNAME')
+            expect(hosts[0][:password]).to eq('PASSWORD')
+          end
 
-      context 'when a scheme is specified' do
+          it 'extracts the host' do
+            expect(hosts[0][:host]).to eq('myhost')
+          end
 
-        let(:host) do
-          'https://myhost:8080'
+          it 'extracts the port' do
+            expect(hosts[0][:port]).to be(8080)
+          end
         end
 
-        it 'extracts the host' do
-          expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:scheme]).to eq('https')
-          expect(hosts[0][:port]).to be(8080)
-        end
-      end
+        context 'when there is a trailing slash \'http://myhost/\'' do
 
-      context 'when credentials are specified' do
+          let(:host) do
+            'http://myhost/'
+          end
 
-        let(:host) do
-          'http://USERNAME:PASSWORD@myhost:8080'
+          it 'extracts the host' do
+            expect(hosts[0][:host]).to eq('myhost')
+            expect(hosts[0][:scheme]).to eq('http')
+            expect(hosts[0][:path]).to eq('')
+          end
+
+          it 'extracts the scheme' do
+            expect(hosts[0][:scheme]).to eq('http')
+          end
+
+          it 'extracts the path' do
+            expect(hosts[0][:path]).to eq('')
+          end
         end
 
-        it 'extracts the host' do
-          expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:scheme]).to eq('http')
-          expect(hosts[0][:user]).to eq('USERNAME')
-          expect(hosts[0][:password]).to eq('PASSWORD')
-          expect(hosts[0][:port]).to be(8080)
+        context 'when there is a trailing slash with a path \'http://myhost/foo/bar/\'' do
+
+          let(:host) do
+            'http://myhost/foo/bar/'
+          end
+
+          it 'extracts the host' do
+            expect(hosts[0][:host]).to eq('myhost')
+            expect(hosts[0][:scheme]).to eq('http')
+            expect(hosts[0][:path]).to eq('/foo/bar')
+          end
         end
-      end
 
-      context 'when there is a trailing slash' do
+        context 'when the protocol is http' do
 
-        let(:host) do
-          'http://myhost/'
+          context 'when there is no port specified \'http://myhost\'' do
+
+            let(:host) do
+              'http://myhost'
+            end
+
+            it 'extracts the host' do
+              expect(hosts[0][:host]).to eq('myhost')
+            end
+
+            it 'extracts the protocol' do
+              expect(hosts[0][:protocol]).to eq('http')
+            end
+
+            it 'defaults to port 9200' do
+              expect(hosts[0][:port]).to be(9200)
+            end
+          end
+
+          context 'when there is a port specified \'http://myhost:7101\'' do
+
+            let(:host) do
+              'http://myhost:7101'
+            end
+
+            it 'extracts the host' do
+              expect(hosts[0][:host]).to eq('myhost')
+            end
+
+            it 'extracts the protocol' do
+              expect(hosts[0][:protocol]).to eq('http')
+            end
+
+            it 'extracts the port' do
+              expect(hosts[0][:port]).to be(7101)
+            end
+
+            context 'when there is a path specified \'http://myhost:7101/api\'' do
+
+              let(:host) do
+                'http://myhost:7101/api'
+              end
+
+              it 'sets the path' do
+                expect(hosts[0][:host]).to eq('myhost')
+                expect(hosts[0][:protocol]).to eq('http')
+                expect(hosts[0][:path]).to eq('/api')
+                expect(hosts[0][:port]).to be(7101)
+              end
+
+              it 'extracts the host' do
+                expect(hosts[0][:host]).to eq('myhost')
+              end
+
+              it 'extracts the protocol' do
+                expect(hosts[0][:protocol]).to eq('http')
+              end
+
+              it 'extracts the port' do
+                expect(hosts[0][:port]).to be(7101)
+              end
+
+              it 'extracts the path' do
+                expect(hosts[0][:path]).to eq('/api')
+              end
+            end
+          end
         end
 
-        it 'extracts the host' do
-          expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:scheme]).to eq('http')
-          expect(hosts[0][:path]).to eq('')
+        context 'when the protocol is https' do
+
+          context 'when there is no port specified \'https://myhost\'' do
+
+            let(:host) do
+              'https://myhost'
+            end
+
+            it 'extracts the host' do
+              expect(hosts[0][:host]).to eq('myhost')
+            end
+
+            it 'extracts the protocol' do
+              expect(hosts[0][:protocol]).to eq('https')
+            end
+
+            it 'defaults to port 443' do
+              expect(hosts[0][:port]).to be(443)
+            end
+          end
+
+          context 'when there is a port specified \'https://myhost:7101\'' do
+
+            let(:host) do
+              'https://myhost:7101'
+            end
+
+            it 'extracts the host' do
+              expect(hosts[0][:host]).to eq('myhost')
+            end
+
+            it 'extracts the protocol' do
+              expect(hosts[0][:protocol]).to eq('https')
+            end
+
+            it 'extracts the port' do
+              expect(hosts[0][:port]).to be(7101)
+            end
+
+            context 'when there is a path specified \'https://myhost:7101/api\'' do
+
+              let(:host) do
+                'https://myhost:7101/api'
+              end
+
+              it 'extracts the host' do
+                expect(hosts[0][:host]).to eq('myhost')
+              end
+
+              it 'extracts the protocol' do
+                expect(hosts[0][:protocol]).to eq('https')
+              end
+
+              it 'extracts the port' do
+                expect(hosts[0][:port]).to be(7101)
+              end
+
+              it 'extracts the path' do
+                expect(hosts[0][:path]).to eq('/api')
+              end
+            end
+          end
+
+          context 'when IPv6 format is used' do
+
+            around do |example|
+              original_setting = Faraday.ignore_env_proxy
+              Faraday.ignore_env_proxy = true
+              example.run
+              Faraday.ignore_env_proxy = original_setting
+            end
+
+            let(:host) do
+              'https://[2090:db8:85a3:9811::1f]:8080'
+            end
+
+            it 'extracts the host' do
+              expect(hosts[0][:host]).to eq('[2090:db8:85a3:9811::1f]')
+            end
+
+            it 'extracts the protocol' do
+              expect(hosts[0][:protocol]).to eq('https')
+            end
+
+            it 'extracts the port' do
+              expect(hosts[0][:port]).to be(8080)
+            end
+
+            it 'creates the correct full url' do
+              expect(client.transport.__full_url(client.transport.hosts[0])).to eq('https://[2090:db8:85a3:9811::1f]:8080')
+            end
+          end
         end
       end
 
-      context 'when there is a trailing slash with a path' do
+      context 'when no protocol is specified \'myhost\'' do
 
         let(:host) do
-          'http://myhost/foo/bar/'
+          'myhost'
         end
 
-        it 'extracts the host' do
+        it 'defaults to http' do
           expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:scheme]).to eq('http')
-          expect(hosts[0][:path]).to eq('/foo/bar')
+          expect(hosts[0][:protocol]).to eq('http')
+        end
+
+        it 'uses port 9200' do
+          expect(hosts[0][:port]).to be(9200)
         end
       end
     end
 
-    context 'when the hosts are a Hash' do
+    context 'when the host is a Hash' do
 
       let(:host) do
         { :host => 'myhost', :scheme => 'https' }
@@ -550,7 +726,13 @@ describe Elasticsearch::Transport::Client do
 
       it 'extracts the host' do
         expect(hosts[0][:host]).to eq('myhost')
-        expect(hosts[0][:scheme]).to eq('https')
+      end
+
+      it 'extracts the protocol' do
+        expect(hosts[0][:protocol]).to eq('https')
+      end
+
+      it 'extracts the port' do
         expect(hosts[0][:port]).to be(9200)
       end
 
@@ -609,7 +791,13 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
+        end
+
+        it 'extracts the protocol' do
           expect(hosts[0][:scheme]).to eq('https')
+        end
+
+        it 'converts the port to an integer' do
           expect(hosts[0][:port]).to be(443)
         end
       end
@@ -622,7 +810,13 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
+        end
+
+        it 'extracts the protocol' do
           expect(hosts[0][:scheme]).to eq('https')
+        end
+
+        it 'extracts port as an integer' do
           expect(hosts[0][:port]).to be(443)
         end
       end
@@ -636,7 +830,13 @@ describe Elasticsearch::Transport::Client do
 
       it 'extracts the host' do
         expect(hosts[0][:host]).to eq('myhost')
+      end
+
+      it 'extracts the protocol' do
         expect(hosts[0][:scheme]).to eq('https')
+      end
+
+      it 'converts the port to an integer' do
         expect(hosts[0][:port]).to be(9200)
       end
 
@@ -648,7 +848,13 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
+        end
+
+        it 'extracts the protocol' do
           expect(hosts[0][:scheme]).to eq('https')
+        end
+
+        it 'converts the port to an integer' do
           expect(hosts[0][:port]).to be(443)
         end
       end
@@ -661,7 +867,13 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
+        end
+
+        it 'extracts the protocol' do
           expect(hosts[0][:scheme]).to eq('https')
+        end
+
+        it 'extracts port as an integer' do
           expect(hosts[0][:port]).to be(443)
         end
       end
@@ -677,7 +889,13 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
+        end
+
+        it 'extracts the protocol' do
           expect(hosts[0][:protocol]).to eq('http')
+        end
+
+        it 'defaults to port 9200' do
           expect(hosts[0][:port]).to be(9200)
         end
       end
@@ -690,20 +908,13 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:protocol]).to eq('http')
-          expect(hosts[0][:port]).to be(9200)
         end
-      end
 
-      context 'when there is one host with a protocol and no port' do
-
-        let(:host) do
-          ['http://myhost']
+        it 'extracts the protocol' do
+          expect(hosts[0][:scheme]).to eq('http')
         end
 
-        it 'extracts the host' do
-          expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:protocol]).to eq('http')
+        it 'defaults to port 9200' do
           expect(hosts[0][:port]).to be(9200)
         end
       end
@@ -728,7 +939,7 @@ describe Elasticsearch::Transport::Client do
         end
       end
 
-      context 'when there is one host with a scheme, protocol and no port' do
+      context 'when there is one host with a protocol and no port' do
 
         let(:host) do
           ['https://myhost']
@@ -736,12 +947,18 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:protocol]).to eq('https')
-          expect(hosts[0][:port]).to be(9200)
+        end
+
+        it 'extracts the protocol' do
+          expect(hosts[0][:scheme]).to eq('https')
+        end
+
+        it 'defaults to port 443' do
+          expect(hosts[0][:port]).to be(443)
         end
       end
 
-      context 'when there is one host with a scheme, protocol, path, and no port' do
+      context 'when there is one host with a protocol, path, and no port' do
 
         let(:host) do
           ['http://myhost/foo/bar']
@@ -749,9 +966,18 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:protocol]).to eq('http')
+        end
+
+        it 'extracts the protocol' do
+          expect(hosts[0][:scheme]).to eq('http')
+        end
+
+        it 'defaults to port 9200' do
           expect(hosts[0][:port]).to be(9200)
-          expect(hosts[0][:path]).to eq("/foo/bar")
+        end
+
+        it 'extracts the path' do
+          expect(hosts[0][:path]).to eq('/foo/bar')
         end
       end
 
@@ -761,7 +987,7 @@ describe Elasticsearch::Transport::Client do
           ['host1', 'host2']
         end
 
-        it 'extracts the host' do
+        it 'extracts the hosts' do
           expect(hosts[0][:host]).to eq('host1')
           expect(hosts[0][:protocol]).to eq('http')
           expect(hosts[0][:port]).to be(9200)
@@ -777,7 +1003,7 @@ describe Elasticsearch::Transport::Client do
           ['host1:1000', 'host2:2000']
         end
 
-        it 'extracts the host' do
+        it 'extracts the hosts' do
           expect(hosts[0][:host]).to eq('host1')
           expect(hosts[0][:protocol]).to eq('http')
           expect(hosts[0][:port]).to be(1000)
@@ -1197,7 +1423,7 @@ describe Elasticsearch::Transport::Client do
           allow(client).to receive(:perform_request) { OpenStruct.new(body: '') }
           expect { client.search(opaque_id: 'opaque_id') }.not_to raise_error
           expect(client).to have_received(:perform_request)
-            .with('GET', '_search', { opaque_id: 'opaque_id' }, nil, {})
+                              .with('GET', '_search', { opaque_id: 'opaque_id' }, nil, {})
         end
       end
     end
@@ -1236,7 +1462,28 @@ describe Elasticsearch::Transport::Client do
         allow(client).to receive(:perform_request) { OpenStruct.new(body: '') }
         expect { client.search(headers: headers) }.not_to raise_error
         expect(client).to have_received(:perform_request)
-          .with('GET', '_search', {}, nil, headers)
+                            .with('GET', '_search', {}, nil, headers)
+      end
+    end
+
+    context 'when a header is set on an endpoint request and on initialization' do
+      let!(:client) do
+        described_class.new(
+          host: hosts,
+          transport_options: { headers: instance_headers }
+        )
+      end
+      let(:instance_headers) { { set_in_instantiation: 'header value' } }
+      let(:param_headers) {{'user-agent' => 'My Ruby Tests', 'set-on-method-call' => 'header value'}}
+
+      it 'performs the request with the header' do
+        expected_headers = client.transport.connections.connections.first.connection.headers.merge(param_headers)
+
+        expect_any_instance_of(Faraday::Connection)
+          .to receive(:run_request)
+                .with(:get, "http://#{hosts[0]}/_search", nil, expected_headers) { OpenStruct.new(body: '')}
+
+        client.search(headers: param_headers)
       end
     end
   end
@@ -1458,7 +1705,7 @@ describe Elasticsearch::Transport::Client do
           context 'when using the HTTPClient adapter' do
 
             let(:client) do
-              described_class.new(hosts: ELASTICSEARCH_HOSTS, compression: true, adapter: :httpclient)
+              described_class.new(hosts: ELASTICSEARCH_HOSTS, compression: true, adapter: :httpclient, enable_meta_header: false)
             end
 
             it 'compresses the request and decompresses the response' do