elasticsearch-transport 5.0.5 → 6.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9141220bdecbb5cd5fe9eef893010d24419a62a6
-  data.tar.gz: e2a2ad61469a9398e749b4004909ec2234360262
+SHA256:
+  metadata.gz: c036b32f60221fef3a8c617ddc30a55c50c916b4f3c235fe34f91917060c9ae4
+  data.tar.gz: 18d4582f2c6479fe2af5bf10a6f6cc97d6083172274be5de85d82a47f62b1a04
 SHA512:
-  metadata.gz: 47916a61140347aba5eb71728587d4c611f0219e8f03d3584405fde93d10fe991f38652b5125e073ad37f16cedd72fe452faea82197f892b539c95809db5cf74
-  data.tar.gz: 9130c01c4a9d7687f42fa57848c3dac0ae7382972e1c68776319c829b079307ccda469846f6231e2e64c783225c43a75386d35b6de8f3d5614516266d24e80c8
+  metadata.gz: a06a56942b78b094e562ef1fa4d6adfd9433a823aeb3e21e06296574c39bcb5c228b52a009fe3a375a8682a1d0e9c9d370ff74a5a84dce4d2800170ede4e3d5c
+  data.tar.gz: 8646819dd552fae0bbba12d03e0a2ed1c996f2d0493a0ad65c4f07bd5e2ae763d8067aefc66c8d52963def632d1a552c7271744233ba12a5b43945d281800d1c

data/Gemfile

@@ -14,3 +14,8 @@ end
 if File.exist? File.expand_path("../../elasticsearch/elasticsearch.gemspec", __FILE__)
   gem 'elasticsearch', :path => File.expand_path("../../elasticsearch", __FILE__), :require => false
 end
+
+group :development do
+  gem 'rspec'
+  gem 'pry-nav'
+end

data/README.md

@@ -16,24 +16,28 @@ data serialization and transport.
 It does not handle calling the Elasticsearch API;
 see the [`elasticsearch-api`](https://github.com/elasticsearch/elasticsearch-ruby/tree/master/elasticsearch-api) library.
 
-The library is compatible with Ruby 1.8.7 or higher and with all versions of Elasticsearch since 0.90.
+The library is compatible with Ruby 1.9 or higher and with all versions of Elasticsearch since 0.90.
 
 Features overview:
 
 * Pluggable logging and tracing
-* Plugabble connection selection strategies (round-robin, random, custom)
+* Pluggable connection selection strategies (round-robin, random, custom)
 * Pluggable transport implementation, customizable and extendable
 * Pluggable serializer implementation
 * Request retries and dead connections handling
 * Node reloading (based on cluster state) on errors or on demand
 
 For optimal performance, use a HTTP library which supports persistent ("keep-alive") connections,
-such as [Typhoeus](https://github.com/typhoeus/typhoeus).
-Just require the library (`require 'typhoeus'; require 'typhoeus/adapters/faraday'`) in your code,
-and it will be automatically used; currently these libraries will be automatically detected and used:
-[Patron](https://github.com/toland/patron),
-[HTTPClient](https://rubygems.org/gems/httpclient) and
-[Net::HTTP::Persistent](https://rubygems.org/gems/net-http-persistent).
+such as [patron](https://github.com/toland/patron).
+Just require the library (`require 'patron'`) in your code,
+and it will be automatically used.
+
+Currently these libraries will be automatically detected and used:
+- [Patron](https://github.com/toland/patron)
+- [HTTPClient](https://rubygems.org/gems/httpclient)
+- [Net::HTTP::Persistent](https://rubygems.org/gems/net-http-persistent)
+
+**Note on [Typhoeus](https://github.com/typhoeus/typhoeus)**: Typhoeus is compatible and will be automatically detected too. However, the latest release (v1.3.1 at the moment of writing this) is not compatible with Faraday 1.0. [It still uses the deprecated `Faraday::Error` namespace](https://github.com/typhoeus/typhoeus/blob/v1.3.1/lib/typhoeus/adapters/faraday.rb#L100). If you want to use it with this gem, we suggest getting `master` from GitHub, since this has been fixed for v1.4.0. We'll update this if/when v1.4.0 is released.a
 
 For detailed information, see example configurations [below](#transport-implementations).
 
@@ -69,6 +73,22 @@ Full documentation is available at <http://rubydoc.info/gems/elasticsearch-trans
 
 ## Configuration
 
+* [Setting Hosts](#setting-hosts)
+* [Default port](#default-port)
+* [Connect using an Elastic Cloud ID](#connect-using-an-elastic-cloud-id)
+* [Authentication](#authentication)
+* [Logging](#logging)
+* [Identifying running tasks with X-Opaque-Id](#identifying-running-tasks-with-x-opaque-id)
+* [Setting Timeouts](#setting-timeouts)
+* [Randomizing Hosts](#randomizing-hosts)
+* [Retrying on Failures](#retrying-on-failures)
+* [Reloading Hosts](#reloading-hosts)
+* [Connection Selector](#connection-selector)
+* [Transport Implementations](#transport-implementations)
+* [Serializer implementations](#serializer-implementations)
+* [Exception Handling](#exception-handling)
+* [Development and Community](#development-and-community)
+
 The client supports many configurations options for setting up and managing connections,
 configuring logging, customizing the transport library, etc.
 
@@ -128,6 +148,26 @@ use the `transport_options` option:
     Elasticsearch::Client.new url: 'https://username:password@example.com:9200',
                               transport_options: { ssl: { ca_file: '/path/to/cacert.pem' } }
 
+You can also use [**API Key authentication**](https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-create-api-key.html):
+
+``` ruby
+Elasticsearch::Client.new(
+  host: host,
+  transport_options: transport_options,
+  api_key: credentials
+)
+```
+
+Where credentials is either the base64 encoding of `id` and `api_key` joined by a colon or a hash with the `id` and `api_key`:
+
+``` ruby
+Elasticsearch::Client.new(
+  host: host,
+  transport_options: transport_options,
+  api_key: {id: 'my_id', api_key: 'my_api_key'}
+)
+```
+
 ### Logging
 
 To log requests and responses to standard output with the default logger (an instance of Ruby's {::Logger} class),
@@ -158,6 +198,29 @@ You can pass the client any conforming logger implementation:
 
     client = Elasticsearch::Client.new logger: log
 
+### Identifying running tasks with X-Opaque-Id
+
+The X-Opaque-Id header allows to track certain calls, or associate certain tasks with the client that started them ([more on the Elasticsearch docs](https://www.elastic.co/guide/en/elasticsearch/reference/master/tasks.html#_identifying_running_tasks)). To use this feature, you need to set an id for `opaque_id` on the client on each request. Example:
+
+```ruby
+client = Elasticsearch::Client.new
+client.search(index: 'myindex', q: 'title:test', opaque_id: '123456')
+```
+The search request will include the following HTTP Header:
+```
+X-Opaque-Id: 123456
+```
+
+You can also 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. Example:
+```ruby
+client = Elasticsearch::Client.new(opaque_id_prefix: 'eu-west1')
+client.search(index: 'myindex', q: 'title:test', opaque_id: '123456')
+```
+The request will include the following HTTP Header:
+```
+X-Opaque-Id: eu-west1_123456
+```
+
 ### Setting Timeouts
 
 For many operations in Elasticsearch, the default timeouts of HTTP libraries are too low.
@@ -292,44 +355,35 @@ constructor, use the `transport_options` key:
 
 To configure the _Faraday_ instance directly, use a block:
 
-    require 'typhoeus'
-    require 'typhoeus/adapters/faraday'
+    require 'patron'
 
     client = Elasticsearch::Client.new(host: 'localhost', port: '9200') do |f|
       f.response :logger
-      f.adapter  :typhoeus
+      f.adapter  :patron
     end
 
-You can use any standard Faraday middleware and plugins in the configuration block,
-for example sign the requests for the [AWS Elasticsearch service](https://aws.amazon.com/elasticsearch-service/):
-
-    require 'faraday_middleware/aws_signers_v4'
-
-    client = Elasticsearch::Client.new url: 'https://search-my-cluster-abc123....es.amazonaws.com' do |f|
-      f.request :aws_signers_v4,
-                credentials: Aws::Credentials.new(ENV['AWS_ACCESS_KEY'], ENV['AWS_SECRET_ACCESS_KEY']),
-                service_name: 'es',
-                region: 'us-east-1'
-    end
+You can use any standard Faraday middleware and plugins in the configuration block, for example sign the requests for the [AWS Elasticsearch service](https://aws.amazon.com/elasticsearch-service/). See [the AWS documentation](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-request-signing.html#es-request-signing-ruby) for an example.
 
 You can also initialize the transport class yourself, and pass it to the client constructor
 as the `transport` argument:
 
-    require 'typhoeus'
-    require 'typhoeus/adapters/faraday'
+```ruby
+require 'patron'
 
-    transport_configuration = lambda do |f|
-      f.response :logger
-      f.adapter  :typhoeus
-    end
+transport_configuration = lambda do |f|
+  f.response :logger
+  f.adapter  :patron
+end
 
-    transport = Elasticsearch::Transport::Transport::HTTP::Faraday.new \
-      hosts: [ { host: 'localhost', port: '9200' } ],
-      &transport_configuration
+transport = Elasticsearch::Transport::Transport::HTTP::Faraday.new \
+  hosts: [ { host: 'localhost', port: '9200' } ],
+  &transport_configuration
+
+# Pass the transport to the client
+#
+client = Elasticsearch::Client.new transport: transport
+```
 
-    # Pass the transport to the client
-    #
-    client = Elasticsearch::Client.new transport: transport
 
 Instead of passing the transport to the constructor, you can inject it at run time:
 

data/Rakefile

@@ -7,40 +7,37 @@ task :test    => 'test:unit'
 # ----- Test tasks ------------------------------------------------------------
 
 require 'rake/testtask'
+require 'rspec/core/rake_task'
+
 namespace :test do
-  task :ci_reporter do
-    ENV['CI_REPORTS'] ||= 'tmp/reports'
-    if defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
-      require 'ci/reporter/rake/test_unit'
-      Rake::Task['ci:setup:testunit'].invoke
-    else
-      require 'ci/reporter/rake/minitest'
-      Rake::Task['ci:setup:minitest'].invoke
-    end
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  desc "Wait for Elasticsearch to be in a green state"
+  task :wait_for_green do
+    sh '../scripts/wait-cluster.sh'
   end
 
   Rake::TestTask.new(:unit) do |test|
-    Rake::Task['test:ci_reporter'].invoke if ENV['CI']
     test.libs << 'lib' << 'test'
     test.test_files = FileList["test/unit/**/*_test.rb"]
-    # test.verbose = true
-    # test.warning = true
+    test.verbose = false
+    test.warning = false
   end
 
   Rake::TestTask.new(:integration) do |test|
-    Rake::Task['test:ci_reporter'].invoke if ENV['CI']
     test.libs << 'lib' << 'test'
     test.test_files = FileList["test/integration/**/*_test.rb"]
+    test.deps = [ :wait_for_green, :spec ]
+    test.verbose = false
+    test.warning = false
   end
 
   Rake::TestTask.new(:all) do |test|
-    Rake::Task['test:ci_reporter'].invoke if ENV['CI']
-    test.libs << 'lib' << 'test'
-    test.test_files = FileList["test/unit/**/*_test.rb", "test/integration/**/*_test.rb"]
+    test.deps = [ :unit, :integration ]
   end
 
   Rake::TestTask.new(:profile) do |test|
-    Rake::Task['test:ci_reporter'].invoke if ENV['CI']
     test.libs << 'lib' << 'test'
     test.test_files = FileList["test/profile/**/*_test.rb"]
   end

data/elasticsearch-transport.gemspec

@@ -4,74 +4,55 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'elasticsearch/transport/version'
 
 Gem::Specification.new do |s|
-  s.name          = "elasticsearch-transport"
+  s.name          = 'elasticsearch-transport'
   s.version       = Elasticsearch::Transport::VERSION
-  s.authors       = ["Karel Minarik"]
-  s.email         = ["karel.minarik@elasticsearch.org"]
-  s.summary       = "Ruby client for Elasticsearch."
-  s.homepage      = "https://github.com/elasticsearch/elasticsearch-ruby/tree/master/elasticsearch-transport"
-  s.license       = "Apache 2"
-
+  s.authors       = ['Karel Minarik']
+  s.email         = ['karel.minarik@elasticsearch.org']
+  s.summary       = 'Ruby client for Elasticsearch.'
+  s.homepage      = 'https://www.elastic.co/guide/en/elasticsearch/client/ruby-api/current/index.html'
+  s.license       = 'Apache-2.0'
+  s.metadata = {
+    'homepage_uri' => 'https://www.elastic.co/guide/en/elasticsearch/client/ruby-api/current/index.html',
+    'changelog_uri' => 'https://github.com/elastic/elasticsearch-ruby/blob/6.x/CHANGELOG.md',
+    'source_code_uri' => 'https://github.com/elastic/elasticsearch-ruby/tree/6.x/elasticsearch-transport',
+    'bug_tracker_uri' => 'https://github.com/elastic/elasticsearch-ruby/issues'
+  }
   s.files         = `git ls-files`.split($/)
   s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
-  s.require_paths = ["lib"]
-
-  s.extra_rdoc_files  = [ "README.md", "LICENSE.txt" ]
-  s.rdoc_options      = [ "--charset=UTF-8" ]
-
-  s.add_dependency "multi_json"
-  s.add_dependency "faraday"
-
-  if defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
-    s.add_dependency "system_timer"
-  end
-
-  s.add_development_dependency "bundler", "> 1"
-
-  if defined?(RUBY_VERSION) && RUBY_VERSION > '1.9'
-    s.add_development_dependency "rake", "~> 11.1"
-  else
-    s.add_development_dependency "rake", "< 11.0"
-  end
-
-  if defined?(RUBY_VERSION) && RUBY_VERSION > '1.9'
-    s.add_development_dependency "elasticsearch-extensions"
-  end
-
-  s.add_development_dependency "ansi"
-  s.add_development_dependency "shoulda-context"
-  s.add_development_dependency "mocha"
-  s.add_development_dependency "turn"
-  s.add_development_dependency "yard"
-  s.add_development_dependency "pry"
-  s.add_development_dependency "ci_reporter", "~> 1.9"
-
+  s.require_paths = ['lib']
+
+  s.extra_rdoc_files  = ['README.md', 'LICENSE.txt']
+  s.rdoc_options      = ['--charset=UTF-8']
+
+  s.required_ruby_version = '>= 2.4'
+
+  s.add_dependency 'multi_json'
+  s.add_dependency 'faraday', '~> 1'
+  s.add_development_dependency 'ansi'
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'elasticsearch-extensions'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'rake', '~> 13'
+  s.add_development_dependency 'shoulda-context'
+  s.add_development_dependency 'turn'
+  s.add_development_dependency 'yard'
   # Gems for testing integrations
-  s.add_development_dependency "curb"   unless defined? JRUBY_VERSION
-  s.add_development_dependency "patron" unless defined? JRUBY_VERSION
-  s.add_development_dependency "typhoeus", '~> 0.6'
-  s.add_development_dependency "net-http-persistent"
-  s.add_development_dependency "manticore", '~> 0.5.2' if defined? JRUBY_VERSION
-  s.add_development_dependency "hashie"
-
-  # Prevent unit test failures on Ruby 1.8
-  if defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
-    s.add_development_dependency "test-unit", '~> 2'
-    s.add_development_dependency "json", '~> 1.8'
-  end
-
-  if defined?(RUBY_VERSION) && RUBY_VERSION > '1.9'
-    s.add_development_dependency "minitest", "~> 4.0"
-    s.add_development_dependency "ruby-prof"    unless defined?(JRUBY_VERSION) || defined?(Rubinius)
-    s.add_development_dependency "require-prof" unless defined?(JRUBY_VERSION) || defined?(Rubinius)
-    s.add_development_dependency "simplecov"
-    s.add_development_dependency "simplecov-rcov"
-    s.add_development_dependency "cane"
-  end
-
-  if defined?(RUBY_VERSION) && RUBY_VERSION > '2.2'
-    s.add_development_dependency "test-unit", '~> 2'
+  s.add_development_dependency 'cane'
+  s.add_development_dependency 'hashie'
+  s.add_development_dependency 'manticore', '~> 0.5.2' if defined? JRUBY_VERSION
+  s.add_development_dependency 'minitest', '~> 4.0'
+  s.add_development_dependency 'net-http-persistent'
+  s.add_development_dependency 'simplecov', '~> 0.17', '< 0.18'
+  s.add_development_dependency 'simplecov-rcov'
+  s.add_development_dependency 'test-unit', '~> 2'
+  s.add_development_dependency 'typhoeus', '~> 0.6'
+  unless defined?(JRUBY_VERSION) || defined?(Rubinius)
+    s.add_development_dependency 'curb'
+    s.add_development_dependency 'patron'
+    s.add_development_dependency 'require-prof'
+    s.add_development_dependency 'ruby-prof'
   end
 
   s.description = <<-DESC.gsub(/^    /, '')

data/lib/elasticsearch/transport/client.rb

@@ -1,3 +1,7 @@
+# Licensed to Elasticsearch B.V under one or more agreements.
+# Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+# See the LICENSE file in the project root for more information
+
 module Elasticsearch
   module Transport
 
@@ -24,6 +28,11 @@ module Elasticsearch
         logger
       end
 
+      # The default host and port to use if not otherwise specified.
+      #
+      # @since 7.0.0
+      DEFAULT_HOST = 'localhost:9200'.freeze
+
       # Returns the transport object.
       #
       # @see Elasticsearch::Transport::Transport::Base
@@ -80,17 +89,16 @@ module Elasticsearch
       # @option arguments [String] :send_get_body_as Specify the HTTP method to use for GET requests with a body.
       #                                              (Default: GET)
       #
+      # @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
+      #
       # @yield [faraday] Access and configure the `Faraday::Connection` instance directly with a block
       #
       def initialize(arguments={}, &block)
+        @options = arguments
         @arguments = arguments
-
-        hosts = @arguments[:hosts] || \
-                @arguments[:host]  || \
-                @arguments[:url]   || \
-                @arguments[:urls]  || \
-                ENV.fetch('ELASTICSEARCH_URL', 'localhost:9200')
-
         @arguments[:logger] ||= @arguments[:log]   ? DEFAULT_LOGGER.call() : nil
         @arguments[:tracer] ||= @arguments[:trace] ? DEFAULT_TRACER.call() : nil
         @arguments[:reload_connections] ||= false
@@ -99,36 +107,69 @@ module Elasticsearch
         @arguments[:randomize_hosts]    ||= false
         @arguments[:transport_options]  ||= {}
         @arguments[:http]               ||= {}
+        @options[:http]                 ||= {}
 
-        @arguments[:transport_options].update(:request => { :timeout => @arguments[:request_timeout] } ) if @arguments[:request_timeout]
+        set_api_key if (@api_key = @arguments[:api_key])
 
-        @arguments[:transport_options][:headers] ||= {}
-        @arguments[:transport_options][:headers].update 'Content-Type' => 'application/json' unless @arguments[:transport_options][:headers].keys.any? {|k| k.to_s.downcase =~ /content\-?\_?type/}
+
+        @seeds ||= __extract_hosts(@arguments[:hosts] ||
+                                     @arguments[:host] ||
+                                     @arguments[:url] ||
+                                     @arguments[:urls] ||
+                                     ENV['ELASTICSEARCH_URL'] ||
+                                     DEFAULT_HOST)
 
         @send_get_body_as = @arguments[:send_get_body_as] || 'GET'
+        @opaque_id_prefix = @arguments[:opaque_id_prefix] || nil
 
-        transport_class  = @arguments[:transport_class] || DEFAULT_TRANSPORT_CLASS
+        if @arguments[:request_timeout]
+          @arguments[:transport_options][:request] = { timeout: @arguments[:request_timeout] }
+        end
+
+        @arguments[:transport_options][:headers] ||= {}
 
-        @transport       = @arguments[:transport] || begin
+        unless @arguments[:transport_options][:headers].keys.any? {|k| k.to_s.downcase =~ /content\-?\_?type/}
+          @arguments[:transport_options][:headers]['Content-Type'] = 'application/json'
+        end
+
+        if @arguments[:transport]
+          @transport = @arguments[:transport]
+        else
+          transport_class  = @arguments[:transport_class] || DEFAULT_TRANSPORT_CLASS
           if transport_class == Transport::HTTP::Faraday
-            transport_class.new(:hosts => __extract_hosts(hosts, @arguments), :options => @arguments) do |faraday|
-              block.call faraday if block
-              unless (h = faraday.builder.handlers.last) && h.name.start_with?("Faraday::Adapter")
-                faraday.adapter(@arguments[:adapter] || __auto_detect_adapter)
-              end
+            @transport = transport_class.new(hosts: @seeds, options: @arguments) do |faraday|
+              faraday.adapter(@arguments[:adapter] || __auto_detect_adapter)
+              block&.call faraday
             end
           else
-            transport_class.new(:hosts => __extract_hosts(hosts, @arguments), :options => @arguments)
+            @transport = transport_class.new(hosts: @seeds, options: @arguments)
           end
         end
       end
 
       # Performs a request through delegation to {#transport}.
       #
-      def perform_request(method, path, params={}, body=nil)
+      def perform_request(method, path, params = {}, body = nil, headers = nil)
         method = @send_get_body_as if 'GET' == method && body
+        if (opaque_id = params.delete(:opaque_id))
+          headers = {} if headers.nil?
+          opaque_id = @opaque_id_prefix ? "#{@opaque_id_prefix}#{opaque_id}" : opaque_id
+          headers.merge!('X-Opaque-Id' => opaque_id)
+        end
+        transport.perform_request(method, path, params, body, headers)
+      end
+
+      private
 
-        transport.perform_request method, path, params, body
+      def set_api_key
+        @api_key = __encode(@api_key) if @api_key.is_a? Hash
+        headers = @arguments[:transport_options]&.[](:headers) || {}
+        headers.merge!('Authorization' => "ApiKey #{@api_key}")
+        @arguments[:transport_options].merge!(
+          headers: headers
+        )
+        @arguments.delete(:user)
+        @arguments.delete(:password)
       end
 
       # Normalizes and returns hosts configuration.
@@ -143,52 +184,63 @@ module Elasticsearch
       #
       # @api private
       #
-      def __extract_hosts(hosts_config, options={})
-        if hosts_config.is_a?(Hash)
-          hosts = [ hosts_config ]
-        else
-          if hosts_config.is_a?(String) && hosts_config.include?(',')
-            hosts = hosts_config.split(/\s*,\s*/)
-          else
-            hosts = Array(hosts_config)
-          end
-        end
-
-        result = hosts.map do |host|
-          host_parts = case host
-            when String
-              if host =~ /^[a-z]+\:\/\//
-                uri = URI.parse(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
-
-          host_parts[:port] = host_parts[:port].to_i unless host_parts[:port].nil?
+      def __extract_hosts(hosts_config)
+        hosts = case hosts_config
+                when String
+                  hosts_config.split(',').map { |h| h.strip! || h }
+                when Array
+                  hosts_config
+                when Hash, URI
+                  [ hosts_config ]
+                else
+                  Array(hosts_config)
+                end
 
-          # Transfer the selected host parts such as authentication credentials to `options`,
-          # so we can re-use them when reloading connections
-          #
-          host_parts.select { |k,v| [:scheme, :port, :user, :password].include?(k) }.each do |k,v|
-            @arguments[:http][k] ||= v
-          end
+        host_list = hosts.map { |host| __parse_host(host) }
+        @options[:randomize_hosts] ? host_list.shuffle! : host_list
+      end
 
-          # Remove the trailing slash
-          host_parts[:path].chomp!('/') if host_parts[:path]
+      def __parse_host(host)
+        host_parts = case host
+                     when String
+                       if host =~ /^[a-z]+\:\/\//
+                         uri = URI.parse(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
 
-          host_parts
+        if @api_key
+          # Remove Basic Auth if using API KEY
+          host_parts.delete(:user)
+          host_parts.delete(:password)
+        else
+          @options[:http][:user] ||= host_parts[:user]
+          @options[:http][:password] ||= host_parts[:password]
         end
 
-        result.shuffle! if options[:randomize_hosts]
-        result
+        host_parts[:port] = host_parts[:port].to_i if host_parts[:port]
+        host_parts[:path].chomp!('/') if host_parts[:path]
+        host_parts
       end
 
       # Auto-detect the best adapter (HTTP "driver") available, based on libraries
@@ -213,6 +265,13 @@ module Elasticsearch
           ::Faraday.default_adapter
         end
       end
+
+      # Encode credentials for the Authorization Header
+      # Credentials is the base64 encoding of id and api_key joined by a colon
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-create-api-key.html
+      def __encode(api_key)
+        Base64.strict_encode64([api_key[:id], api_key[:api_key]].join(':'))
+      end
     end
   end
 end