elastic-transport 8.3.2 → 8.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ece16e8da350495285378d8f76df8e40a3c366c75e90c37c6e7d5558780b175
-  data.tar.gz: 10655669e9c1b4254e607424ee4acd5d2cdaa3c56a3a8988f6a29e6b507fa982
+  metadata.gz: 88698d9c25a84a6242bfb875623c2bca0bd9a0e5c40244272e88fe291b06a9e0
+  data.tar.gz: 90aff86e0a0f301908c888877d97a72ac926e9b5f7f48b23ad447813a729824d
 SHA512:
-  metadata.gz: 4e541aaddfc31d02364d648e96dac3c7e42abda88650fc1c8e48dbdb3c84f26bc83fb9355c52e3972cd3c6d5ebf1b6e670c7beb0449988d8db69641013bae19f
-  data.tar.gz: 4cbde4527ca45280bf0cdd719ace9823e4c5462c03b0404263f5c4ac6dd0328249ca04cbb1d6a01bfad8ab489355ac8acb7513255069586a99e6575a1915bdce
+  metadata.gz: 3a235c8813516864b3b661790c56c9eeb6c8ee8b44a208d70a3309faca0075e9b45f25890be47d56ed29b845a70c5d3f6cd45c617592543993a0c6d788eb7211
+  data.tar.gz: 9cd571ba906d3e841f63f8bf3ea018820d0d9e2eddb9171f01785b6787df5ed19fecbeb0b05e494428af8853d2040c78c32f25a370c612d55a4a69ed77798682

data/.github/workflows/license.yml

@@ -4,10 +4,10 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 3
+        ruby-version: '3.4'
     - name: Check license headers
       run: |
         ruby ./.github/check_license_headers.rb

data/.github/workflows/otel.yml

@@ -16,11 +16,11 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['3.3', 'jruby-9.4']
-        es_version: ['8.12-SNAPSHOT']
+        ruby: ['3.4', 'jruby-9.4']
+        es_version: ['8.17.0-SNAPSHOT']
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: Increase system limits
         run: |
           sudo swapoff -a

data/.github/workflows/tests.yml

@@ -15,11 +15,11 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '3.0', '3.1', '3.2', '3.3', 'jruby-9.3', 'jruby-9.4' ]
-        es_version: ['8.10-SNAPSHOT', '8.11-SNAPSHOT', '8.12-SNAPSHOT']
+        ruby: ['3.1', '3.2', '3.3', '3.4', 'jruby-9.3', 'jruby-9.4']
+        es_version: ['8.16.0-SNAPSHOT', '8.17.0-SNAPSHOT', '8.18.0-SNAPSHOT']
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Increase system limits
       run: |
         sudo swapoff -a
@@ -53,11 +53,11 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '3.0', '3.1', '3.2', '3.3', 'jruby-9.3' ]
-        es_version: ['8.12-SNAPSHOT']
+        ruby: ['3.0', '3.1', '3.2', '3.3', 'jruby-9.3']
+        es_version: ['8.16.0-SNAPSHOT']
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Increase system limits
       run: |
         sudo swapoff -a
@@ -76,7 +76,6 @@ jobs:
         sudo apt-get update
         sudo apt-get install libcurl4-openssl-dev
         ruby -v
-        gem install bundler
         BUNDLE_GEMFILE=./Gemfile-faraday1.gemfile bundle install
     - name: faraday1 unit tests
       run: BUNDLE_GEMFILE=./Gemfile-faraday1.gemfile bundle exec rake test:faraday1:unit

data/CHANGELOG.md

@@ -1,3 +1,50 @@
+## 8.4.0
+
+- Adds support for **[Excon](https://github.com/excon/excon)** Faraday adapter. You can use the Excon adapter by setting it in when initializing an Elasticsearch client:
+
+```ruby
+require 'faraday/excon'
+
+Elasticsearch::Client.new(
+  host: host,
+  transport_options: transport_options,
+  adapter: :excon
+)
+```
+
+Excon may need some specific configuration for HTTPS/SSL. You may see certificate verification errors when trying to connect to Elastic. Excon has certificates bundled, but these can be customized:
+
+```ruby
+Excon.defaults[:ssl_ca_path] = path_to_certs
+ENV['SSL_CERT_DIR'] = path_to_certs
+Excon.defaults[:ssl_ca_file] = path_to_file
+ENV['SSL_CERT_FILE'] = path_to_file
+Excon.defaults[:ssl_verify_callback] = callback
+# (see OpenSSL::SSL::SSLContext#verify_callback)
+Excon.defaults[:ssl_verify_peer] = false` # (less secure).
+```
+
+- Adds support for **[Async::HTTP::Faraday](https://github.com/socketry/async-http-faraday)**. You can use the adapter by setting it when initializing an Elasticsearch client:
+```ruby
+require 'async-http-faraday'
+
+Elasticsearch::Client.new(
+  host: host,
+  adapter: :async_http
+)
+```
+- Minor refactors, styling fixes.
+
+## 8.3.5
+
+- Small updates in source code documentation.
+- Updates meta header for Elasticsearch Serverless.
+- Fixes issues with ES_SERVERLESS_SERVICE_VERSION for backwards compatibility
+
+## 8.3.3, 8.3.4 (yanked)
+
+- Yanked due to errors.
+
 ## 8.3.2
 
 - OpenTelemetry: In v8.3.0 and v8.3.1, the environment variable `OTEL_INSTRUMENTATION_ELASTICSEARCH_CAPTURE_SEARCH_QUERY` was available but is now deprecated in favor of `OTEL_RUBY_INSTRUMENTATION_ELASTICSEARCH_CAPTURE_SEARCH_QUERY`.

data/CONTRIBUTING.md

@@ -41,7 +41,13 @@ E.g.:
 $ rake docker:start[8.0.0-alpha1]
 ```
 
-You can find the available version in [Docker @ Elastic](https://www.docker.elastic.co/r/elasticsearch).
+You can find the available version in [Docker @ Elastic](https://www.docker.elastic.co/r/elasticsearch). You can also run Elasticsearch and Kibana locally with Docker with `start-local`:
+
+```bash
+curl -fsSL https://elastic.co/start-local | sh
+```
+
+This will run Elasticsearch in http://localhost:9200 and Kibana in http://localhost:5601. More information is available [here](https://www.elastic.co/guide/en/elasticsearch/reference/current/run-elasticsearch-locally.html).
 
 # Contributing
 

data/Gemfile

@@ -21,18 +21,19 @@ source 'https://rubygems.org'
 gemspec
 
 group :development, :test do
+  gem 'faraday-excon'
   gem 'faraday-httpclient'
   gem 'faraday-net_http_persistent'
-  gem 'faraday-patron' unless defined? JRUBY_VERSION
   gem 'faraday-typhoeus'
-  gem 'rspec'
-  gem 'oj' unless defined? JRUBY_VERSION
+  gem 'mutex_m' if RUBY_VERSION >= '3.4'
+  gem 'opentelemetry-sdk', require: false if RUBY_VERSION >= '3.0'
   if defined?(JRUBY_VERSION)
     gem 'pry-nav'
   else
+    gem 'async-http-faraday'
+    gem 'faraday-patron'
+    gem 'oj'
     gem 'pry-byebug'
   end
-  if RUBY_VERSION >= '3.0'
-    gem 'opentelemetry-sdk', require: false
-  end
+  gem 'rspec'
 end

data/Gemfile-faraday1.gemfile

@@ -23,18 +23,18 @@ source 'https://rubygems.org'
 # $ BUNDLE_GEMFILE=./Gemfile-faraday1.gemfile bundle exec rake test:faraday1:unit
 
 gem 'faraday', '~> 1'
-gemspec path: './'
+gemspec
 
 group :development, :test do
   gem 'httpclient'
   gem 'net-http-persistent'
-  gem 'patron' unless defined? JRUBY_VERSION
   gem 'rspec'
   gem 'typhoeus'
-  gem 'oj' unless defined? JRUBY_VERSION
   if defined?(JRUBY_VERSION)
     gem 'pry-nav'
   else
     gem 'pry-byebug'
+    gem 'oj'
+    gem 'patron'
   end
 end

data/lib/elastic/transport/client.rb

@@ -83,7 +83,7 @@ module Elastic
       #
       # @option arguments [Integer] :sniffer_timeout   Timeout for reloading connections in seconds (1 by default)
       #
-      # @option arguments [Boolean,Number] :retry_on_failure   Retry X times when request fails before raising and
+      # @option arguments [Boolean,Number] :retry_on_failure   Retry X times when request fails before raising an
       #                                                        exception (false by default)
       # @option arguments [Number] :delay_on_retry  Delay in milliseconds between each retry (0 by default)
       #
@@ -91,7 +91,8 @@ module Elastic
       #
       # @option arguments [Boolean] :reload_on_failure Reload connections after failure (false by default)
       #
-      # @option arguments [Integer] :request_timeout The request timeout to be passed to transport in options
+      # @option arguments [Integer] :request_timeout The request timeout to be passed to transport in options in seconds 
+      #                                              (the default value is taken from the transport)
       #
       # @option arguments [Symbol] :adapter A specific adapter for Faraday (e.g. `:patron`)
       #
@@ -110,7 +111,7 @@ module Elastic
       #
       # @option arguments [String] :send_get_body_as Specify the HTTP method to use for GET requests with a body.
       #                                              (Default: GET)
-      # @option arguments [true, false] :compression Whether to compress requests. Gzip compression will be used.
+      # @option arguments [Boolean] :compression Whether to compress requests. Gzip compression will be used.
       #   The default is false. Responses will automatically be inflated if they are compressed.
       #   If a custom transport object is used, it must handle the request compression and response inflation.
       #
@@ -122,8 +123,8 @@ module Elastic
       #
       def initialize(arguments = {}, &block)
         @arguments = arguments.transform_keys(&:to_sym)
-        @arguments[:logger] ||= @arguments[:log]   ? DEFAULT_LOGGER.call() : nil
-        @arguments[:tracer] ||= @arguments[:trace] ? DEFAULT_TRACER.call() : nil
+        @arguments[:logger] ||= @arguments[:log]   ? DEFAULT_LOGGER.call : nil
+        @arguments[:tracer] ||= @arguments[:trace] ? DEFAULT_TRACER.call : nil
         @arguments[:reload_connections] ||= false
         @arguments[:retry_on_failure]   ||= false
         @arguments[:delay_on_retry]     ||= 0
@@ -133,13 +134,7 @@ module Elastic
         @arguments[:http]               ||= {}
         @arguments[:enable_meta_header] = arguments.fetch(:enable_meta_header, true)
 
-        @hosts ||= __extract_hosts(@arguments[:hosts] ||
-                                   @arguments[:host] ||
-                                   @arguments[:url] ||
-                                   @arguments[:urls] ||
-                                   ENV['ELASTICSEARCH_URL'] ||
-                                   DEFAULT_HOST)
-
+        @hosts ||= extract_hosts
         @send_get_body_as = @arguments[:send_get_body_as] || 'GET'
         @ca_fingerprint = @arguments.delete(:ca_fingerprint)
 
@@ -152,7 +147,7 @@ module Elastic
         else
           @transport_class = @arguments[:transport_class] || DEFAULT_TRANSPORT_CLASS
           @transport = if @transport_class == Transport::HTTP::Faraday
-                         @arguments[:adapter] ||= __auto_detect_adapter
+                         @arguments[:adapter] ||= auto_detect_adapter
                          set_meta_header # from include MetaHeader
                          @transport_class.new(hosts: @hosts, options: @arguments) do |faraday|
                            faraday.adapter(@arguments[:adapter])
@@ -172,7 +167,7 @@ module Elastic
       # Performs a request through delegation to {#transport}.
       #
       def perform_request(method, path, params = {}, body = nil, headers = nil, opts = {})
-        method = @send_get_body_as if 'GET' == method && body
+        method = @send_get_body_as if method == 'GET' && body
         validate_ca_fingerprints if @ca_fingerprint
         if @otel
           # If no endpoint is specified in the opts, use the HTTP method name
@@ -245,7 +240,7 @@ module Elastic
       #
       # @api private
       #
-      def __extract_hosts(hosts_config)
+      def extract_hosts
         hosts = case hosts_config
                 when String
                   hosts_config.split(',').map { |h| h.strip! || h }
@@ -256,12 +251,20 @@ module Elastic
                 else
                   Array(hosts_config)
                 end
-
-        host_list = hosts.map { |host| __parse_host(host) }
+        host_list = hosts.map { |host| parse_host(host) }
         @arguments[:randomize_hosts] ? host_list.shuffle! : host_list
       end
 
-      def __parse_host(host)
+      def hosts_config
+        @arguments[:hosts] ||
+          @arguments[:host] ||
+          @arguments[:url] ||
+          @arguments[:urls] ||
+          ENV['ELASTICSEARCH_URL'] ||
+          DEFAULT_HOST
+      end
+
+      def parse_host(host)
         host_parts = case host
                      when String
                        if host =~ /^[a-z]+\:\/\//
@@ -312,12 +315,14 @@ module Elastic
       #
       # @api private
       #
-      def __auto_detect_adapter
+      def auto_detect_adapter
         if Gem::Version.new(Faraday::VERSION) >= Gem::Version.new(2)
           return :patron if defined?(Faraday::Adapter::Patron)
           return :typhoeus if defined?(Faraday::Adapter::Typhoeus)
           return :httpclient if defined?(Faraday::Adapter::HTTPClient)
           return :net_http_persistent if defined?(Faraday::Adapter::NetHttpPersistent)
+          return :excon if defined?(Faraday::Adapter::Excon)
+          return :async_http if defined?(Async::HTTP::Faraday)
         else
           return :patron if defined?(::Patron)
           return :typhoeus if defined?(::Typhoeus)

data/lib/elastic/transport/meta_header.rb

@@ -41,6 +41,12 @@ module Elastic
       def meta_header_service_version
         if enterprise_search?
           Elastic::ENTERPRISE_SERVICE_VERSION
+        elsif serverless?
+          if defined?(Elastic::ES_SERVERLESS_SERVICE_VERSION)
+            Elastic::ES_SERVERLESS_SERVICE_VERSION
+          else
+            Elastic::ELASTICSEARCH_SERVICE_VERSION
+          end
         elsif elasticsearch?
           Elastic::ELASTICSEARCH_SERVICE_VERSION
         elsif defined?(Elasticsearch::VERSION)
@@ -60,6 +66,11 @@ module Elastic
           called_from?('elasticsearch')
       end
 
+      def serverless?
+        defined?(ElasticsearchServerless::CLIENT_VERSION) &&
+          called_from?('elasticsearch-serverless')
+      end
+
       def called_from?(service)
         !caller.select { |c| c.match?(service) }.empty?
       end
@@ -70,7 +81,7 @@ module Elastic
       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])
+        return "#{match[1]}p" if match[2]
 
         version
       end

data/lib/elastic/transport/opentelemetry.rb

@@ -21,70 +21,77 @@ module Elastic
     #
     # @api private
     class OpenTelemetry
-      OTEL_TRACER_NAME = 'elasticsearch-api'
+      OTEL_TRACER_NAME = 'elasticsearch-api'.freeze
       # Valid values for the enabled config are 'true' and 'false'. Default is 'true'.
-      ENV_VARIABLE_ENABLED = 'OTEL_RUBY_INSTRUMENTATION_ELASTICSEARCH_ENABLED'
+      ENV_VARIABLE_ENABLED = 'OTEL_RUBY_INSTRUMENTATION_ELASTICSEARCH_ENABLED'.freeze
       # Describes how to handle search queries in the request body when assigned to
       # a span attribute.
       # Valid values are 'raw', 'omit', 'sanitize'. Default is 'omit'.
-      ENV_VARIABLE_BODY_STRATEGY = 'OTEL_RUBY_INSTRUMENTATION_ELASTICSEARCH_CAPTURE_SEARCH_QUERY'
-      ENV_VARIABLE_DEPRECATED_BODY_STRATEGY = 'OTEL_INSTRUMENTATION_ELASTICSEARCH_CAPTURE_SEARCH_QUERY'
-      DEFAULT_BODY_STRATEGY = 'omit'
+      ENV_VARIABLE_BODY_STRATEGY = 'OTEL_RUBY_INSTRUMENTATION_ELASTICSEARCH_CAPTURE_SEARCH_QUERY'.freeze
+      ENV_VARIABLE_DEPRECATED_BODY_STRATEGY = 'OTEL_INSTRUMENTATION_ELASTICSEARCH_CAPTURE_SEARCH_QUERY'.freeze
+      DEFAULT_BODY_STRATEGY = 'omit'.freeze
       # A string list of keys whose values are redacted. This is only relevant if the body strategy is
       # 'sanitize'. For example, a config 'sensitive-key,other-key' will redact the values at
       # 'sensitive-key' and 'other-key' in addition to the default keys.
-      ENV_VARIABLE_BODY_SANITIZE_KEYS = 'OTEL_RUBY_INSTRUMENTATION_ELASTICSEARCH_SEARCH_QUERY_SANITIZE_KEYS'
+      ENV_VARIABLE_BODY_SANITIZE_KEYS = 'OTEL_RUBY_INSTRUMENTATION_ELASTICSEARCH_SEARCH_QUERY_SANITIZE_KEYS'.freeze
 
       # A list of the Elasticsearch endpoints that qualify as "search" endpoints. The search query in
       # the request body may be captured for these endpoints, depending on the body capture strategy.
       SEARCH_ENDPOINTS = Set[
-        "search",
-        "async_search.submit",
-        "msearch",
-        "eql.search",
-        "terms_enum",
-        "search_template",
-        "msearch_template",
-        "render_search_template",
+        'search',
+        'async_search.submit',
+        'msearch',
+        'eql.search',
+        'terms_enum',
+        'search_template',
+        'msearch_template',
+        'render_search_template',
       ]
 
       # Initialize the Open Telemetry wrapper object. Takes the options originally passed to
       # Client#initialize.
       def initialize(opts)
-        @tracer = (opts[:opentelemetry_tracer_provider] || ::OpenTelemetry.tracer_provider).tracer(
-          OTEL_TRACER_NAME, Elastic::Transport::VERSION
-        )
-        @body_strategy = ENV[ENV_VARIABLE_DEPRECATED_BODY_STRATEGY] || ENV[ENV_VARIABLE_BODY_STRATEGY] ||
-                           DEFAULT_BODY_STRATEGY
+        @tracer = tracer_provider(opts).tracer(OTEL_TRACER_NAME, Elastic::Transport::VERSION)
+        @body_strategy = ENV[ENV_VARIABLE_DEPRECATED_BODY_STRATEGY] ||
+                         ENV[ENV_VARIABLE_BODY_STRATEGY] ||
+                         DEFAULT_BODY_STRATEGY
         @sanitize_keys = ENV[ENV_VARIABLE_BODY_SANITIZE_KEYS]&.split(',')&.collect! do |pattern|
           Regexp.new(pattern.gsub('*', '.*'))
         end
       end
       attr_accessor :tracer
 
+      def tracer_provider(opts)
+        opts[:opentelemetry_tracer_provider] || ::OpenTelemetry.tracer_provider
+      end
+
       # Process the request body. Applies the body strategy, which can be one of the following:
-      # 'omit': return nil
+      # 'omit' (DEFAULT_BODY_STRATEGY): return nil
       # 'sanitize': redact values at the default list of keys + any additional keys provided in
       # the OTEL_RUBY_INSTRUMENTATION_ELASTICSEARCH_SEARCH_QUERY_SANITIZE_KEYS env variable.
       # 'raw': return the original body, unchanged
       def process_body(body, endpoint)
-        unless @body_strategy == 'omit' || !SEARCH_ENDPOINTS.include?(endpoint)
-          if @body_strategy == 'sanitize'
-            Sanitizer.sanitize(body, @sanitize_keys).to_json
-          elsif @body_strategy == 'raw'
-            body&.is_a?(String) ? body : body.to_json
-          end
+        return if @body_strategy == DEFAULT_BODY_STRATEGY || !search_endpoint?(endpoint)
+
+        if @body_strategy == 'sanitize'
+          Sanitizer.sanitize(body, @sanitize_keys).to_json
+        elsif @body_strategy == 'raw'
+          body.is_a?(String) ? body : body.to_json
         end
       end
 
+      def search_endpoint?(endpoint)
+        SEARCH_ENDPOINTS.include?(endpoint)
+      end
+
       # Replaces values in a hash with 'REDACTED', given a set of keys to match on.
       class Sanitizer
         class << self
-          FILTERED = 'REDACTED'
+          FILTERED = 'REDACTED'.freeze
           DEFAULT_KEY_PATTERNS =
             %w[password passwd pwd secret *key *token* *session* *credit* *card* *auth* set-cookie].map! do |p|
-              Regexp.new(p.gsub('*', '.*'))
-            end
+            Regexp.new(p.gsub('*', '.*'))
+          end
 
           def sanitize(body, key_patterns = [])
             patterns = DEFAULT_KEY_PATTERNS

data/lib/elastic/transport/transport/base.rb

@@ -83,7 +83,7 @@ module Elastic
         # @return [Connections::Connection]
         # @see    Connections::Collection#get_connection
         #
-        def get_connection(options={})
+        def get_connection(options = {})
           resurrect_dead_connections! if Time.now > @last_request_at + @resurrect_after
 
           @counter_mtx.synchronize { @counter += 1 }
@@ -120,7 +120,7 @@ module Elastic
         # @return [Connections::Collection]
         # @api private
         #
-        def __rebuild_connections(arguments={})
+        def __rebuild_connections(arguments = {})
           @state_mutex.synchronize do
             @hosts       = arguments[:hosts]    || []
             @options     = arguments[:options]  || {}
@@ -232,7 +232,7 @@ module Elastic
         #
         # @api private
         #
-        def __convert_to_json(o=nil, options={})
+        def __convert_to_json(o = nil, options = {})
           o.is_a?(String) ? o : serializer.dump(o, options)
         end
 

data/lib/elastic/transport/transport/serializer/multi_json.rb

@@ -24,7 +24,7 @@ module Elastic
         module Base
           # @param transport [Object] The instance of transport which uses this serializer
           #
-          def initialize(transport=nil)
+          def initialize(transport = nil)
             @transport = transport
           end
         end
@@ -36,13 +36,13 @@ module Elastic
 
           # De-serialize a Hash from JSON string
           #
-          def load(string, options={})
+          def load(string, options = {})
             ::MultiJson.load(string, options)
           end
 
           # Serialize a Hash to JSON string
           #
-          def dump(object, options={})
+          def dump(object, options = {})
             ::MultiJson.dump(object, options)
           end
         end

data/lib/elastic/transport/version.rb

@@ -17,6 +17,6 @@
 
 module Elastic
   module Transport
-    VERSION = '8.3.2'.freeze
+    VERSION = '8.4.0'.freeze
   end
 end

data/spec/elastic/transport/client_spec.rb

@@ -225,6 +225,38 @@ describe Elastic::Transport::Client do
       end
     end unless jruby?
 
+    context 'when the adapter is excon' do
+      let(:adapter) do
+        client.transport.connections.all.first.connection.builder.adapter
+      end
+
+      let(:client) do
+        require 'faraday/excon'
+
+        described_class.new(adapter: :excon, enable_meta_header: false)
+      end
+
+      it 'uses Faraday with the adapter' do
+        expect(adapter).to eq Faraday::Adapter::Excon
+      end
+    end if is_faraday_v2?
+
+    context 'when the adapter is async-http' do
+      let(:adapter) do
+        client.transport.connections.all.first.connection.builder.adapter
+      end
+
+      let(:client) do
+        require 'async/http/faraday'
+
+        described_class.new(adapter: :async_http, enable_meta_header: false)
+      end
+
+      it 'uses Faraday with the adapter' do
+        expect(adapter).to eq Async::HTTP::Faraday::Adapter
+      end
+    end unless jruby? || !is_faraday_v2?
+
     context 'when the adapter is specified as a string key' do
       let(:adapter) do
         client.transport.connections.all.first.connection.builder.adapter
@@ -1453,6 +1485,7 @@ describe Elastic::Transport::Client do
 
           context 'when using the HTTPClient adapter' do
             require 'faraday/httpclient'
+            require 'mutex_m' if RUBY_VERSION >= '3.4'
 
             let(:client) do
               described_class.new(hosts: ELASTICSEARCH_HOSTS, compression: true, adapter: :httpclient, enable_meta_header: false)

data/test/unit/adapters_test.rb

@@ -72,6 +72,22 @@ class Elastic::Transport::ClientAdaptersUnitTest < Minitest::Test
       end
     end
 
+    should 'use Excon Faraday adapter' do
+      fork do
+        require 'faraday/excon'
+        client = Elastic::Transport::Client.new
+        assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::Excon)
+      end
+    end if is_faraday_v2?
+
+    should 'use Async HTTP Faraday adapter' do
+      fork do
+        require 'async/http/faraday'
+        client = Elastic::Transport::Client.new
+        assert_equal(client.transport.connections.first.connection.adapter, Async::HTTP::Faraday::Adapter)
+      end
+    end if is_faraday_v2?
+
     should 'use HTTPClient Faraday adapter' do
       fork do
         if is_faraday_v2?
@@ -81,7 +97,7 @@ class Elastic::Transport::ClientAdaptersUnitTest < Minitest::Test
         end
 
         client = Elastic::Transport::Client.new
-        assert_equal(Faraday::Adapter::HTTPClient, client.transport.connections.first.connection.adapter)
+        assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::HTTPClient)
       end
     end
   end unless jruby?

data/test/unit/connection_test.rb

@@ -20,66 +20,66 @@ require 'test_helper'
 class Elastic::Transport::Transport::Connections::ConnectionTest < Minitest::Test
   include Elastic::Transport::Transport::Connections
 
-  context "Connection" do
-    should "be initialized with :host, :connection, and :options" do
+  context 'Connection' do
+    should 'be initialized with :host, :connection, and :options' do
       c = Connection.new :host => 'x', :connection => 'y', :options => {}
       assert_equal 'x', c.host
       assert_equal 'y', c.connection
       assert_instance_of Hash, c.options
     end
 
-    should "return full path" do
+    should 'return full path' do
       c = Connection.new
       assert_equal '_search', c.full_path('_search')
       assert_equal '_search', c.full_path('_search', {})
-      assert_equal '_search?foo=bar', c.full_path('_search', {:foo => 'bar'})
-      assert_equal '_search?foo=bar+bam', c.full_path('_search', {:foo => 'bar bam'})
+      assert_equal '_search?foo=bar', c.full_path('_search', {foo: 'bar'})
+      assert_equal '_search?foo=bar+bam', c.full_path('_search', {foo: 'bar bam'})
     end
 
-    should "return full url" do
-      c = Connection.new :host => { :protocol => 'http', :host => 'localhost', :port => '9200' }
-      assert_equal 'http://localhost:9200/_search?foo=bar', c.full_url('_search', {:foo => 'bar'})
+    should 'return full url' do
+      c = Connection.new host: { protocol: 'http', host: 'localhost', port: '9200' }
+      assert_equal 'http://localhost:9200/_search?foo=bar', c.full_url('_search', { foo: 'bar' })
     end
 
-    should "return full url with credentials" do
-      c = Connection.new :host => { :protocol => 'http', :user => 'U', :password => 'P', :host => 'localhost', :port => '9200' }
-      assert_equal 'http://U:P@localhost:9200/_search?foo=bar', c.full_url('_search', {:foo => 'bar'})
+    should 'return full url with credentials' do
+      c = Connection.new host: { protocol: 'http', user: 'U', password: 'P', host: 'localhost', port: '9200' }
+      assert_equal 'http://U:P@localhost:9200/_search?foo=bar', c.full_url('_search', { foo: 'bar' })
     end
 
-    should "return full url with escaped credentials" do
-      c = Connection.new :host => { :protocol => 'http', :user => 'U$$$', :password => 'P^^^', :host => 'localhost', :port => '9200' }
-      assert_equal 'http://U%24%24%24:P%5E%5E%5E@localhost:9200/_search?foo=bar', c.full_url('_search', {:foo => 'bar'})
+    should 'return full url with escaped credentials' do
+      c = Connection.new host: { protocol: 'http', user: 'U$$$', password: 'P^^^', host: 'localhost', port: '9200' }
+      assert_equal 'http://U%24%24%24:P%5E%5E%5E@localhost:9200/_search?foo=bar', c.full_url('_search', { foo: 'bar' })
     end
 
-    should "return full url with path" do
-      c = Connection.new :host => { :protocol => 'http', :host => 'localhost', :port => '9200', :path => '/foo' }
-      assert_equal 'http://localhost:9200/foo/_search?foo=bar', c.full_url('_search', {:foo => 'bar'})
+    should 'return full url with path' do
+      c = Connection.new host: { protocol: 'http', host: 'localhost', port: '9200', path: '/foo' }
+      assert_equal 'http://localhost:9200/foo/_search?foo=bar', c.full_url('_search', { foo: 'bar' })
     end
 
-    should "return right full url with path when path starts with /" do
-      c = Connection.new :host => { :protocol => 'http', :host => 'localhost', :port => '9200', :path => '/foo' }
-      assert_equal 'http://localhost:9200/foo/_search?foo=bar', c.full_url('/_search', {:foo => 'bar'})
+    should 'return right full url with path when path starts with /' do
+      c = Connection.new host: { protocol: 'http', host: 'localhost', port: '9200', path: '/foo' }
+      assert_equal 'http://localhost:9200/foo/_search?foo=bar', c.full_url('/_search', { foo: 'bar' })
     end
 
-    should "have a string representation" do
-      c = Connection.new :host => 'x'
+    should 'have a string representation' do
+      c = Connection.new(host: 'x')
       assert_match(/host: x/, c.to_s)
       assert_match(/alive/,   c.to_s)
     end
 
-    should "not be dead by default" do
+    should 'not be dead by default' do
       c = Connection.new
       assert ! c.dead?
     end
 
-    should "be dead when marked" do
+    should 'be dead when marked' do
       c = Connection.new.dead!
       assert c.dead?
       assert_equal 1, c.failures
       assert_in_delta c.dead_since, Time.now, 1
     end
 
-    should "be alive when marked" do
+    should 'be alive when marked' do
       c = Connection.new.dead!
       assert c.dead?
       assert_equal 1, c.failures
@@ -90,7 +90,7 @@ class Elastic::Transport::Transport::Connections::ConnectionTest < Minitest::Tes
       assert_equal 1, c.failures
     end
 
-    should "be healthy when marked" do
+    should 'be healthy when marked' do
       c = Connection.new.dead!
       assert c.dead?
       assert_equal 1, c.failures
@@ -101,35 +101,33 @@ class Elastic::Transport::Transport::Connections::ConnectionTest < Minitest::Tes
       assert_equal 0, c.failures
     end
 
-    should "be resurrected if timeout passed" do
+    should 'be resurrected if timeout passed' do
       c = Connection.new.dead!
 
       now = Time.now + 60
       Time.stubs(:now).returns(now)
 
-      assert   c.resurrect!, c.inspect
-      assert ! c.dead?,      c.inspect
+      assert(c.resurrect!, c.inspect)
+      assert(!c.dead?, c.inspect)
     end
 
-    should "be resurrected if timeout passed for multiple failures" do
+    should 'be resurrected if timeout passed for multiple failures' do
       c = Connection.new.dead!.dead!
 
-      now = Time.now + 60*2
+      now = Time.now + 60 * 2
       Time.stubs(:now).returns(now)
 
       assert   c.resurrect!, c.inspect
       assert ! c.dead?,      c.inspect
     end
 
-    should "implement the equality operator" do
-      c1 = Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 123 })
-      c2 = Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 123 })
-      c3 = Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 456 })
+    should 'implement the equality operator' do
+      c1 = Connection.new(host: { protocol: 'http', host: 'foo', port: 123 })
+      c2 = Connection.new(host: { protocol: 'http', host: 'foo', port: 123 })
+      c3 = Connection.new(host: { protocol: 'http', host: 'foo', port: 456 })
 
       assert c1 == c2, "Connection #{c1} should be equal to #{c2}"
       assert c2 != c3, "Connection #{c2} should NOT be equal to #{c3}"
     end
-
   end
-
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: elastic-transport
 version: !ruby/object:Gem::Version
-  version: 8.3.2
+  version: 8.4.0
 platform: ruby
 authors:
 - Elastic Client Library Maintainers
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-14 00:00:00.000000000 Z
+date: 2025-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -324,7 +323,6 @@ metadata:
   changelog_uri: https://github.com/elastic/elastic-transport-ruby/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/elastic/elastic-transport-ruby
   bug_tracker_uri: https://github.com/elastic/elastic-transport-ruby/issues
-post_install_message: 
 rdoc_options:
 - "--charset=UTF-8"
 require_paths:
@@ -340,8 +338,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Low level Ruby client for Elastic services.
 test_files: