elasticsearch-transport 7.9.0.pre → 7.11.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e172f03d64feff3991f8ef723219c1f3f26824d624cfaee35195168c2224361
-  data.tar.gz: d8039d3a4e5a5f406aae9ff94a56ef0c1068dd985b71c36a4d21d553b3404775
+  metadata.gz: 1e364f5d86474b878377249e59488749009a24682da9d35e3eaeb430a0c9d9d4
+  data.tar.gz: 9952aede93dd570e563acef81038e9423793f4e0682b9916d5155fa37edb0792
 SHA512:
-  metadata.gz: 1ae8684bffd3b1c1badd932702491266d93dafbe63cc7b02de814601bd120c0955914ff6e3f3220e7cfafe0654f87ecca3fea652c6df4783d106b9749b69eaca
-  data.tar.gz: 8607504cde6a896a5c11d2e7ab753829dddb9c1d7c2ae960e3cdb3a9bfff2f3d46e9bec0790222e7d34f8309ea86d5c096e9646fdadd51cfae6b0891defed73d
+  metadata.gz: be3c7ecd096850addb44e502f471ae2e88e43e3ee93dc342eb4b32b36eb994d66131e35f6458cec5026a02e7edd25e71d058efaa5a675fdacfe38c567a478a7f
+  data.tar.gz: 9ed532c04edc174e1eb903bb116add80f946f1610360a0294bed09d6d3f3b26444432745c67431e3611d3c478434e5afb18db9271450854c3255ef67e049e506

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
@@ -293,11 +299,16 @@ on a different host:
 
     Elasticsearch::Client.new hosts: ['localhost:9200', 'localhost:9201'], retry_on_failure: true
 
-You can specify how many times should the client retry the request before it raises an exception
-(the default is 3 times):
+By default, the client will retry the request 3 times. You can specify how many times to retry before it raises an exception by passing a number to `retry_on_failure`:
 
     Elasticsearch::Client.new hosts: ['localhost:9200', 'localhost:9201'], retry_on_failure: 5
 
+These two parameters can also be used together:
+
+```ruby
+Elasticsearch::Client.new hosts: ['localhost:9200', 'localhost:9201'], retry_on_status: [502, 503], retry_on_failure: 10
+```
+
 ### Reloading Hosts
 
 Elasticsearch by default dynamically discovers new nodes in the cluster. You can leverage this

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,24 +193,103 @@ 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', Elasticsearch::VERSION]
+        else
+          ['es', Elasticsearch::Transport::VERSION]
+        end
+      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
 
       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('$')
-        [ { scheme: 'https',
+
+        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
 
       # Normalizes and returns hosts configuration.
@@ -230,36 +322,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/connections/connection.rb

@@ -19,7 +19,6 @@ module Elasticsearch
   module Transport
     module Transport
       module Connections
-
         # Wraps the connection information and logic.
         #
         # The Connection instance wraps the host information (hostname, port, attributes, etc),
@@ -54,12 +53,14 @@ module Elasticsearch
           #
           # @return [String]
           #
-          def full_url(path, params={})
+          def full_url(path, params = {})
             url  = "#{host[:protocol]}://"
             url += "#{CGI.escape(host[:user])}:#{CGI.escape(host[:password])}@" if host[:user]
             url += "#{host[:host]}:#{host[:port]}"
             url += "#{host[:path]}" if host[:path]
-            url += "/#{full_path(path, params)}"
+            full_path = full_path(path, params)
+            url += '/' unless full_path.match?(/^\//)
+            url += full_path
           end
 
           # Returns the complete endpoint path with serialized parameters.

data/lib/elasticsearch/transport/version.rb

@@ -17,6 +17,6 @@
 
 module Elasticsearch
   module Transport
-    VERSION = "7.9.0.pre"
+    VERSION = '7.11.0.pre.1'.freeze
   end
 end

data/spec/elasticsearch/transport/base_spec.rb

@@ -46,10 +46,12 @@ describe Elasticsearch::Transport::Transport::Base do
 
     context 'when the user and password are provided as separate arguments' do
       let(:arguments) do
-        { hosts: 'fake',
+        {
+          hosts: 'fake',
           logger: logger,
           password: 'secret_password',
-          user: 'test' }
+          user: 'test'
+        }
       end
 
       it_behaves_like 'a redacted string'
@@ -57,8 +59,10 @@ describe Elasticsearch::Transport::Transport::Base do
 
     context 'when the user and password are provided in the string URI' do
       let(:arguments) do
-        { hosts: 'https://test:secret_password@fake_local_elasticsearch',
-          logger: logger }
+        {
+          hosts: 'https://test:secret_password@fake_local_elasticsearch',
+          logger: logger
+        }
       end
 
       it_behaves_like 'a redacted string'
@@ -66,8 +70,10 @@ describe Elasticsearch::Transport::Transport::Base do
 
     context 'when the user and password are provided in the URI object' do
       let(:arguments) do
-        { hosts: URI.parse('https://test:secret_password@fake_local_elasticsearch'),
-          logger: logger }
+        {
+          hosts: URI.parse('https://test:secret_password@fake_local_elasticsearch'),
+          logger: logger
+        }
       end
 
       it_behaves_like 'a redacted string'
@@ -75,36 +81,32 @@ describe Elasticsearch::Transport::Transport::Base do
   end
 
   context 'when reload_on_failure is true and and hosts are unreachable' do
-
     let(:client) do
       Elasticsearch::Transport::Client.new(arguments)
     end
 
     let(:arguments) do
       {
-          hosts: ['http://unavailable:9200', 'http://unavailable:9201'],
-          reload_on_failure: true,
-          sniffer_timeout: 5
+        hosts: ['http://unavailable:9200', 'http://unavailable:9201'],
+        reload_on_failure: true,
+        sniffer_timeout: 5
       }
     end
 
     it 'raises an exception' do
-      expect {
-        client.info
-      }.to raise_exception(Faraday::ConnectionFailed)
+      expect { client.info }.to raise_exception(Faraday::ConnectionFailed)
     end
   end
 
   context 'when the client has `retry_on_failure` set to an integer' do
-
     let(:client) do
       Elasticsearch::Transport::Client.new(arguments)
     end
 
     let(:arguments) do
       {
-          hosts: ['http://unavailable:9200', 'http://unavailable:9201'],
-          retry_on_failure: 2
+        hosts: ['http://unavailable:9200', 'http://unavailable:9201'],
+        retry_on_failure: 2
       }
     end
 
@@ -120,15 +122,34 @@ describe Elasticsearch::Transport::Transport::Base do
       end
     end
 
+    context 'when `perform_request` is called with a `retry_on_status` option value' do
+      before do
+        expect(client.transport).to receive(:__raise_transport_error).exactly(6).times.and_call_original
+      end
+
+      let(:arguments) do
+        {
+          hosts: ['http://localhost:9250'],
+          retry_on_status: ['404']
+        }
+      end
+
+      it 'retries on 404 status the specified number of max_retries' do
+        expect do
+          client.transport.perform_request('GET', 'myindex/mydoc/1?routing=FOOBARBAZ', {}, nil, nil, retry_on_failure: 5)
+        end.to raise_exception(Elasticsearch::Transport::Transport::Errors::NotFound)
+      end
+    end
+
     context 'when `perform_request` is called with a `retry_on_failure` option value' do
       before do
         expect(client.transport).to receive(:get_connection).exactly(6).times.and_call_original
       end
 
       it 'uses the option `retry_on_failure` value' do
-        expect {
+        expect do
           client.transport.perform_request('GET', '/info', {}, nil, nil, retry_on_failure: 5)
-        }.to raise_exception(Faraday::ConnectionFailed)
+        end.to raise_exception(Faraday::ConnectionFailed)
       end
     end
   end
@@ -209,40 +230,35 @@ describe Elasticsearch::Transport::Transport::Base do
   end
 
   context 'when the client has no `retry_on_failure` set' do
-
     let(:client) do
       Elasticsearch::Transport::Client.new(arguments)
     end
 
     let(:arguments) do
-      {
-          hosts: ['http://unavailable:9200', 'http://unavailable:9201'],
-      }
+      { hosts: ['http://unavailable:9200', 'http://unavailable:9201'] }
     end
 
     context 'when `perform_request` is called without a `retry_on_failure` option value' do
-
       before do
         expect(client.transport).to receive(:get_connection).exactly(1).times.and_call_original
       end
 
       it 'does not retry' do
-        expect {
+        expect do
           client.transport.perform_request('GET', '/info')
-        }.to raise_exception(Faraday::ConnectionFailed)
+        end.to raise_exception(Faraday::ConnectionFailed)
       end
     end
 
     context 'when `perform_request` is called with a `retry_on_failure` option value' do
-
       before do
         expect(client.transport).to receive(:get_connection).exactly(6).times.and_call_original
       end
 
       it 'uses the option `retry_on_failure` value' do
-        expect {
+        expect do
           client.transport.perform_request('GET', '/info', {}, nil, nil, retry_on_failure: 5)
-        }.to raise_exception(Faraday::ConnectionFailed)
+        end.to raise_exception(Faraday::ConnectionFailed)
       end
     end
   end