elasticsearch-transport 5.0.5 → 6.8.3

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,19 @@ 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
+      # @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
       #
-      def initialize(arguments={}, &block)
-        @arguments = arguments
-
-        hosts = @arguments[:hosts] || \
-                @arguments[:host]  || \
-                @arguments[:url]   || \
-                @arguments[:urls]  || \
-                ENV.fetch('ELASTICSEARCH_URL', 'localhost:9200')
-
+      def initialize(arguments = {}, &block)
+        @options = arguments.each_with_object({}){ |(k,v), args| args[k.to_sym] = v }
+        @arguments = @options
         @arguments[:logger] ||= @arguments[:log]   ? DEFAULT_LOGGER.call() : nil
         @arguments[:tracer] ||= @arguments[:trace] ? DEFAULT_TRACER.call() : nil
         @arguments[:reload_connections] ||= false
@@ -99,36 +110,147 @@ module Elasticsearch
         @arguments[:randomize_hosts]    ||= false
         @arguments[:transport_options]  ||= {}
         @arguments[:http]               ||= {}
+        @arguments[:enable_meta_header] = arguments.fetch(:enable_meta_header) { true }
+        @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
 
-        @transport       = @arguments[:transport] || begin
-          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
-            end
-          else
-            transport_class.new(:hosts => __extract_hosts(hosts, @arguments), :options => @arguments)
-          end
+        @arguments[:transport_options][:headers] ||= {}
+
+        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
+          @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
 
       # 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
+
+      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!(header)
+        @arguments[:transport_options].merge!(
+          headers: headers
+        )
+      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
 
-        transport.perform_request method, path, params, body
+        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}
+            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
 
       # Normalizes and returns hosts configuration.
@@ -143,52 +265,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 +346,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

data/lib/elasticsearch/transport/redacted.rb

@@ -0,0 +1,79 @@
+# 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
+
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#	http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Elasticsearch
+  module Transport
+
+    # Class for wrapping a hash that could have sensitive data.
+    # When printed, the sensitive values will be redacted.
+    #
+    # @since 6.2.0
+    class Redacted < ::Hash
+
+      def initialize(elements = nil)
+        super()
+        (elements || {}).each_pair{ |key, value| self[key] = value }
+      end
+
+      # The keys whose values will be redacted.
+      #
+      # @since 6.2.0
+      SENSITIVE_KEYS = [ :password,
+                         :pwd ].freeze
+
+      # The replacement string used in place of the value for sensitive keys.
+      #
+      # @since 6.2.0
+      STRING_REPLACEMENT = '<REDACTED>'.freeze
+
+      # Get a string representation of the hash.
+      #
+      # @return [ String ] The string representation of the hash.
+      #
+      # @since 6.2.0
+      def inspect
+        redacted_string(:inspect)
+      end
+
+      # Get a string representation of the hash.
+      #
+      # @return [ String ] The string representation of the hash.
+      #
+      # @since 6.2.0
+      def to_s
+        redacted_string(:to_s)
+      end
+
+      private
+
+      def redacted_string(method)
+        '{' + reduce([]) do |list, (k, v)|
+          list << "#{k.send(method)}=>#{redact(k, v, method)}"
+        end.join(', ') + '}'
+      end
+
+      def redact(k, v, method)
+        return STRING_REPLACEMENT if SENSITIVE_KEYS.include?(k.to_sym)
+        v.send(method)
+      end
+    end
+  end
+end

data/lib/elasticsearch/transport/transport/base.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
     module Transport
@@ -16,7 +20,7 @@ module Elasticsearch
         attr_reader   :hosts, :options, :connections, :counter, :last_request_at, :protocol
         attr_accessor :serializer, :sniffer, :logger, :tracer,
                       :reload_connections, :reload_after,
-                      :resurrect_after, :max_retries
+                      :resurrect_after
 
         # Creates a new transport object
         #
@@ -32,7 +36,7 @@ module Elasticsearch
           @state_mutex = Mutex.new
 
           @hosts       = arguments[:hosts]   || []
-          @options     = arguments[:options] || {}
+          @options     = arguments[:options] ? arguments[:options].dup : {}
           @options[:http] ||= {}
           @options[:retry_on_status] ||= []
 
@@ -52,7 +56,6 @@ module Elasticsearch
           @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
-          @max_retries     = options[:retry_on_failure].is_a?(Integer)   ? options[:retry_on_failure]   : DEFAULT_MAX_RETRIES
           @retry_on_status = Array(options[:retry_on_status]).map { |d| d.to_i }
         end
 
@@ -110,7 +113,7 @@ module Elasticsearch
 
             new_connections = __build_connections
             stale_connections = @connections.all.select  { |c| ! new_connections.include?(c) }
-            new_connections = new_connections.reject { |c| @connections.include?(c) }
+            new_connections = new_connections.reject { |c| @connections.all.include?(c) }
 
             @connections.remove(stale_connections)
             @connections.add(new_connections)
@@ -129,7 +132,7 @@ module Elasticsearch
           Connections::Collection.new \
             :connections => hosts.map { |host|
               host[:protocol] = host[:scheme] || options[:scheme] || options[:http][:scheme] || DEFAULT_PROTOCOL
-              host[:port] ||= options[:port] || options[:http][:scheme] || DEFAULT_PORT
+              host[:port] ||= options[:port] || options[:http][:port] || DEFAULT_PORT
               if (options[:user] || options[:http][:user]) && !host[:user]
                 host[:user] ||= options[:user] || options[:http][:user]
                 host[:password] ||= options[:password] || options[:http][:password]
@@ -184,11 +187,14 @@ module Elasticsearch
         #
         # @api private
         #
-        def __trace(method, path, params, body, url, response, json, took, duration)
+        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}" )
           trace_body = body ? " -d '#{__convert_to_json(body, :pretty => true)}'" : ''
-          tracer.info  "curl -X #{method.to_s.upcase} '#{trace_url}'#{trace_body}\n"
+          trace_command = "curl -X #{method.to_s.upcase}"
+          trace_command += " -H '#{headers.inject('') { |memo,item| memo << item[0] + ': ' + item[1] }}'" 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"
         end
@@ -233,6 +239,7 @@ module Elasticsearch
         # @param path   [String] The API endpoint
         # @param params [Hash]   Request parameters (will be serialized by {Connections::Connection#full_url})
         # @param body   [Hash]   Request body (will be serialized by the {#serializer})
+        # @param headers [Hash]   Request headers (will be serialized by the {#serializer})
         # @param block  [Proc]   Code block to evaluate, passed from the implementation
         #
         # @return [Response]
@@ -240,10 +247,17 @@ module Elasticsearch
         # @raise  [ServerError]   If request failed on server
         # @raise  [Error]         If no connection is available
         #
-        def perform_request(method, path, params={}, body=nil, &block)
+        def perform_request(method, path, params={}, body=nil, headers=nil, opts={}, &block)
           raise NoMethodError, "Implement this method in your transport class" unless block_given?
           start = Time.now if logger || tracer
           tries = 0
+          reload_on_failure = opts.fetch(:reload_on_failure, @options[:reload_on_failure])
+
+          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
 
           params = params.clone
 
@@ -267,9 +281,9 @@ module Elasticsearch
             __raise_transport_error(response) if response.status.to_i >= 300 && @retry_on_status.include?(response.status.to_i)
 
           rescue Elasticsearch::Transport::Transport::ServerError => e
-            if @retry_on_status.include?(response.status)
+            if response && @retry_on_status.include?(response.status)
               logger.warn "[#{e.class}] Attempt #{tries} to get response from #{url}" if logger
-              if tries <= max_retries
+              if tries <= (max_retries || DEFAULT_MAX_RETRIES)
                 retry
               else
                 logger.fatal "[#{e.class}] Cannot get response from #{url} after #{tries} tries" if logger
@@ -284,12 +298,12 @@ module Elasticsearch
 
             connection.dead!
 
-            if @options[:reload_on_failure] and tries < connections.all.size
+            if reload_on_failure and tries < connections.all.size
               logger.warn "[#{e.class}] Reloading connections (attempt #{tries} of #{connections.all.size})" if logger
               reload_connections! and retry
             end
 
-            if @options[:retry_on_failure]
+            if max_retries
               logger.warn "[#{e.class}] Attempt #{tries} connecting to #{connection.host.inspect}" if logger
               if tries <= max_retries
                 retry
@@ -311,7 +325,7 @@ module Elasticsearch
 
           if response.status.to_i >= 300
             __log    method, path, params, body, url, response, nil, 'N/A', duration if logger
-            __trace  method, path, params, body, url, response, nil, 'N/A', duration if tracer
+            __trace  method, path, params, headers, body, url, response, nil, 'N/A', duration if tracer
 
             # Log the failure only when `ignore` doesn't match the response status
             __log_failed response if logger && !ignore.include?(response.status.to_i)
@@ -323,7 +337,7 @@ module Elasticsearch
           took     = (json['took'] ? sprintf('%.3fs', json['took']/1000.0) : 'n/a') rescue 'n/a' if logger || tracer
 
           __log   method, path, params, body, url, response, json, took, duration if logger && !ignore.include?(response.status.to_i)
-          __trace method, path, params, body, url, response, json, took, duration if tracer
+          __trace method, path, params, headers, body, url, response, json, took, duration if tracer
 
           Response.new response.status, json || response.body, response.headers
         ensure

data/lib/elasticsearch/transport/transport/connections/collection.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
     module Transport

data/lib/elasticsearch/transport/transport/connections/connection.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
     module Transport
@@ -23,7 +27,7 @@ module Elasticsearch
           # @option arguments [Hash]   :options    Options (usually passed in from transport)
           #
           def initialize(arguments={})
-            @host       = arguments[:host]
+            @host       = arguments[:host].is_a?(Hash) ? Redacted.new(arguments[:host]) : arguments[:host]
             @connection = arguments[:connection]
             @options    = arguments[:options] || {}
             @state_mutex = Mutex.new

data/lib/elasticsearch/transport/transport/connections/selector.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
     module Transport

data/lib/elasticsearch/transport/transport/errors.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
     module Transport

data/lib/elasticsearch/transport/transport/http/curb.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
     module Transport
@@ -15,8 +19,8 @@ module Elasticsearch
           # @return [Response]
           # @see    Transport::Base#perform_request
           #
-          def perform_request(method, path, params={}, body=nil)
-            super do |connection,url|
+          def perform_request(method, path, params={}, body=nil, headers=nil, opts={})
+            super do |connection, url|
               connection.connection.url = url
 
               case method
@@ -26,6 +30,7 @@ module Elasticsearch
                   connection.connection.set :nobody, false
 
                   connection.connection.put_data = __convert_to_json(body) if body
+                  connection.connection.headers = headers if headers
                 else raise ArgumentError, "Unsupported HTTP method: #{method}"
               end
 

data/lib/elasticsearch/transport/transport/http/faraday.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
     module Transport
@@ -16,15 +20,14 @@ module Elasticsearch
           # @return [Response]
           # @see    Transport::Base#perform_request
           #
-          def perform_request(method, path, params={}, body=nil)
+          def perform_request(method, path, params={}, body=nil, headers=nil, opts={})
             super do |connection, url|
-              headers = connection.connection.headers
+              headers = headers || connection.connection.headers
 
-              response = connection.connection.run_request \
-                method.downcase.to_sym,
-                url,
-                ( body ? __convert_to_json(body) : nil ),
-                headers
+              response = connection.connection.run_request(method.downcase.to_sym,
+                                                           url,
+                                                           ( body ? __convert_to_json(body) : nil ),
+                                                           headers)
 
               Response.new response.status, response.body, response.headers
             end
@@ -44,7 +47,7 @@ module Elasticsearch
           # @return [Array]
           #
           def host_unreachable_exceptions
-            [::Faraday::Error::ConnectionFailed, ::Faraday::Error::TimeoutError]
+            [::Faraday::ConnectionFailed, ::Faraday::TimeoutError]
           end
         end
       end