elastic-transport 8.1.0 → 8.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 388aaaffda8babdfb8466e6aef816ed63bc520b56c7cb4f09964a23a1ab73854
-  data.tar.gz: 2bdc179dba8822d690bc1a1b41b9766996f5a39cf8d8b8d7fa1bc03662cdcc97
+  metadata.gz: aca3fc15486eeb7455f903dbaa5b6a594d4fd410f895cff6b3bf832c0dcad8b4
+  data.tar.gz: 4fd798b71008e3bba436434a5c98321fcd2b15934a6244908966c8b9cdd5c3e0
 SHA512:
-  metadata.gz: 45f117b13be213d5b85a17b1df2ecbafcc14fa566f7beda6bd39be8e26b4e5611f80b1d1bd5f3e0f9e35c726721f70e05c479ae112f9e2da97d2d21ff3af676a
-  data.tar.gz: 9b6d8a1fcc73da9676a309b11860640d6194bed392b1cdd91b4ef8b0ba407de11a8500f542efa588aa3f0a03c31dbef9e374f380c018fe297527ee486540a8b0
+  metadata.gz: a33a557b17fc75fbc2cd9b8fb713603b67c35097fce929ccdee0b81b76c58c05885286aeb1aeed8c72068d6c12a83b51e6dc1f9f07678d6e17f51ce962cb0af8
+  data.tar.gz: 5105d1a01106314206e250a105329abfb9553f6c12170bafaf8b7eb4741f5d7b9b414027919aac9df9867ee0859fbfce6b492fbc64a8335f17eebcc7fd109cf4

data/.github/workflows/tests.yml

@@ -15,8 +15,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '2.7', '3.0', '3.1', 'jruby-9.3' ]
-        es_version: ['8.2-SNAPSHOT', '8.3-SNAPSHOT', '8.4-SNAPSHOT']
+        ruby: [ '2.7', '3.0', '3.1', '3.2', 'jruby-9.3', 'jruby-9.4' ]
+        es_version: ['8.4-SNAPSHOT', '8.5-SNAPSHOT', '8.6-SNAPSHOT']
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
@@ -53,8 +53,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '2.7', '3.0', '3.1', 'jruby-9.3' ]
-        es_version: ['8.3.0-SNAPSHOT']
+        ruby: [ '2.7', '3.0', '3.1', '3.2', 'jruby-9.3' ]
+        es_version: ['8.6-SNAPSHOT']
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2

data/CHANGELOG.md

@@ -1,10 +1,19 @@
+## 8.2.0
+
+Tested versions of Ruby: (MRI) 2.7, 3.0, 3.1, 3.2, JRuby 9.3 and JRuby 9.4.
+
+- Fixes [issue #44](https://github.com/elastic/elastic-transport-ruby/issues/44), raising `Elasticsearch::Transport::Transport::Error` instead of `Faraday::ConnectionFailed` (or any other Faraday error class) when a host is unreachable.
+- Removes development dependency on `ansi`, it hasn't been updated for years.
+- Adds `rake console` task to run IRB with the Elastic transport client libraries loaded.
+- General refactors, cleanup and updates in code for `base.rb` (The base class used by HTTP implementations Faraday, Manticore, Curb), `errors.rb`, `faraday.rb`, and more.
+
 ## 8.1.0
 
 Adds support for Faraday version 2. From [Faraday's Upgrading guide](https://github.com/lostisland/faraday/blob/main/UPGRADING.md#faraday-20), the main change is the adapters have moved:
 
 > With this release, we've officially moved all adapters, except for the net_http one, out of Faraday. What that means, is that they won't be available out-of-the-box anymore, and you'll instead need to add them to your Gemfile.
 > If you just use the default net_http adapter, then you don't need to do anything!
-> Otherwise, add the corresponding adapter gem to your Gemfile (e.g. faraday-net_http_persistent). Then, simply require them after you require faraday. 
+> Otherwise, add the corresponding adapter gem to your Gemfile (e.g. faraday-net_http_persistent). Then, simply require them after you require faraday.
 
 We're now supporting Faraday v2 and Faraday v1. The adapters were removed as development dependency in the gemspec and added to the Gemfile. A new file `Gemfile-faraday1.gemfile` was added to run tests with version `1.x` of Faraday too.
 

data/README.md

@@ -3,63 +3,7 @@
 
 This gem provides a low-level Ruby client for connecting to an [Elastic](http://elastic.co) cluster. It powers both the [Elasticsearch client](https://github.com/elasticsearch/elasticsearch-ruby/) and the [Elastic Enterprise Search](https://github.com/elastic/enterprise-search-ruby/) client.
 
-## Compatibility
-
-This gem is compatible with maintained Ruby versions. See [Ruby Maintenance Branches](https://www.ruby-lang.org/en/downloads/branches/). We don't provide support to versions which have reached their end of life.
-
-## Installation
-
-Install the package from [Rubygems](https://rubygems.org):
-
-    gem install elastic-transport
-
-To use an unreleased version, either add it to your `Gemfile` for [Bundler](http://gembundler.com):
-
-    gem 'elastic-transport', git: 'git://github.com/elastic/elastic-transport-ruby.git'
-
-or install it from a source code checkout:
-
-```bash
-git clone https://github.com/elastic/elastic-transport-ruby.git
-cd elastic-transport-ruby
-bundle install
-rake install
-```
-
-## Description
-
-It handles connecting to multiple nodes in the cluster, rotating across connections, logging and tracing requests and responses, maintaining failed connections, discovering nodes in the cluster, and provides an abstraction for
-data serialization and transport.
-
-It does not handle calling the Elasticsearch API; see the [`elasticsearch`](https://github.com/elasticsearch/elasticsearch-ruby) library for that.
-
-Features overview:
-
-* Pluggable logging and tracing
-* 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
-
-This library uses [Faraday](https://github.com/lostisland/faraday) by default as the HTTP transport implementation. We test it it with Faraday versions 1.x and Faraday 2.x.
-
-For optimal performance, use a HTTP library which supports persistent ("keep-alive") connections, such as [patron](https://github.com/toland/patron) or [Typhoeus](https://github.com/typhoeus/typhoeus).
-Require the library (`require 'patron'`) in your code for Faraday 1.x or the adapter (`require 'faraday/patron'`) for Faraday 2.x, and it will be automatically used.
-
-Currently these libraries are supported:
-- [Patron](https://github.com/toland/patron)
-- [Typhoeus](https://github.com/typhoeus/typhoeus)
-- [HTTPClient](https://rubygems.org/gems/httpclient)
-- [Net::HTTP::Persistent](https://rubygems.org/gems/net-http-persistent)
-
-**Note on [Typhoeus](https://github.com/typhoeus/typhoeus)**: You need to use v1.4.0 or up since older versions are not compatible with Faraday 1.0.
-
-You can customize Faraday and implement your own HTTP transport. For detailed information, see the example configurations and more information [below](#transport-implementations).
-
-## Example Usage
-
-In the simplest form, connect to Elasticsearch running on <http://localhost:9200> without any configuration:
+In the simplest form, connect to Elasticsearch running on `http://localhost:9200` without any configuration:
 
 ```ruby
 require 'elastic/transport'
@@ -69,455 +13,13 @@ response = client.perform_request('GET', '_cluster/health')
 # => #<Elastic::Transport::Transport::Response:0x007fc5d506ce38 @status=200, @body={ ... } >
 ```
 
-Full documentation is available at <http://rubydoc.info/gems/elastic-transport>.
-
-## Configuration
-
-* [Setting Hosts](#setting-hosts)
-* [Default port](#default-port)
-* [Authentication](#authentication)
-* [Logging](#logging)
-* [Custom HTTP Headers](#custom-http-headers)
-* [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.
-
-### Setting Hosts
-
-This behaviour is going to be simplified, see [#5](https://github.com/elastic/elastic-transport-ruby/issues/5). To connect to a specific Elasticsearch host:
-
-```ruby
-Elastic::Transport::Client.new(host: 'search.myserver.com')
-```
-
-To connect to a host with specific port:
-
-```ruby
-Elastic::Transport::Client.new(host: 'myhost:8080')
-```
-
-To connect to multiple hosts:
-
-```ruby
-Elastic::Transport::Client.new(hosts: ['myhost1', 'myhost2'])
-```
-
-Instead of Strings, you can pass host information as an array of Hashes:
-
-```ruby
-Elastic::Transport::Client.new(hosts: [{ host: 'myhost1', port: 8080 }, { host: 'myhost2', port: 8080 }])
-```
-
-**NOTE:** When specifying multiple hosts, you probably want to enable the `retry_on_failure` or `retry_on_status` options to perform a failed request on another node (see the _Retrying on Failures_ chapter).
-
-Common URL parts -- scheme, HTTP authentication credentials, URL prefixes, etc -- are handled automatically:
-```ruby
-Elastic::Transport::Client.new(url: 'https://username:password@api.server.org:4430/search')
-```
-
-You can pass multiple URLs separated by a comma:
-```ruby
-Elastic::Transport::Client.new(urls: 'http://localhost:9200,http://localhost:9201')
-```
-
-Another way to configure the URL(s) is to export the `ELASTICSEARCH_URL` variable.
-
-The client will automatically round-robin across the hosts (unless you select or implement a different [connection selector](#connection-selector)).
-
-### Default port
-
-The default port is `9200`. Please specify a port for your host(s) if they differ from this default. Please see below for an exception to this when connecting using an Elastic Cloud ID.
-
-### Authentication
-
-You can pass the authentication credentials, scheme and port in the host configuration hash:
-
-```ruby
-Elastic::Transport::Client.new(
-  hosts: [
-    {
-      host: 'my-protected-host',
-      port: '443',
-      user: 'USERNAME',
-      password: 'PASSWORD',
-      scheme: 'https'
-    }
-  ]
-)
-```
-Or use the common URL format:
-
-```ruby
-Elastic::Transport::Client.new(url: 'https://username:password@example.com:9200')
-```
-
-To pass a custom certificate for SSL peer verification to Faraday-based clients, use the `transport_options` option:
-
-```ruby
-Elastic::Transport::Client.new(
-  url: 'https://username:password@example.com:9200',
-  transport_options: { ssl: { ca_file: '/path/to/cacert.pem' } }
-)
-```
-
-### 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 true:
-
-```ruby
-Elastic::Transport::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)
-Elastic::Transport::Client.new(logger: logger)
-```
-
-To trace requests and responses in the _Curl_ format, set the `trace` argument:
-
-```ruby
-Elastic::Transport::Client.new(trace: true)
-```
-
-You can customize the default logger or tracer:
-
-```ruby
-client.transport.logger.formatter = proc { |s, d, p, m| "#{s}: #{m}\n" }
-client.transport.logger.level = Logger::INFO
-```
-
-Or, you can use a custom `::Logger` instance:
-
-```ruby
-Elastic::Transport::Client.new(logger: Logger.new(STDERR))
-```
-
-You can pass the client any conforming logger implementation:
-
-```ruby
-require 'logging' # https://github.com/TwP/logging/
-
-log = Logging.logger['elasticsearch']
-log.add_appenders Logging.appenders.stdout
-log.level = :info
-
-client = Elastic::Transport::Client.new(logger: log)
-```
-
-### Custom HTTP Headers
-
-You can set a custom HTTP header on the client's initializer:
-
-```ruby
-client = Elastic::Transport::Client.new(
-  transport_options: {
-    headers:
-      {user_agent: "My App"}
-  }
-)
-```
-
-You can also pass in `headers` as a parameter to any of the API Endpoints to set custom headers for the request:
-
-```ruby
-client.search(index: 'myindex', q: 'title:test', headers: { user_agent: "My App" })
-```
-
-### Setting Timeouts
-
-For many operations in Elasticsearch, the default timeouts of HTTP libraries are too low.
-To increase the timeout, you can use the `request_timeout` parameter:
-
-```ruby
-Elastic::Transport::Client.new(request_timeout: 5 * 60)
-```
-
-You can also use the `transport_options` argument documented below.
-
-### Randomizing Hosts
-
-If you pass multiple hosts to the client, it rotates across them in a round-robin fashion, by default.
-When the same client would be running in multiple processes (eg. in a Ruby web server such as Thin),
-it might keep connecting to the same nodes "at once". To prevent this, you can randomize the hosts
-collection on initialization and reloading:
-
-```ruby
-Elastic::Transport::Client.new(hosts: ['localhost:9200', 'localhost:9201'], randomize_hosts: true)
-```
-
-### Retrying on Failures
-
-When the client is initialized with multiple hosts, it makes sense to retry a failed request
-on a different host:
-
-```ruby
-Elastic::Transport::Client.new(hosts: ['localhost:9200', 'localhost:9201'], retry_on_failure: true)
-```
+**Refer to [the official documentation on Elastic Transport](https://www.elastic.co/guide/en/elasticsearch/client/ruby-api/current/transport.html).**
 
-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`:
+**Refer to [Advanced Configuration](https://elasticsearch-ruby_1881.docs-preview.app.elstc.co/guide/en/elasticsearch/client/ruby-api/master/advanced-config.html) to read about more configuration options.**
 
-```ruby
-Elastic::Transport::Client.new(hosts: ['localhost:9200', 'localhost:9201'], retry_on_failure: 5)
-```
-
-You can also use `retry_on_status` to retry when specific status codes are returned:
-
-```ruby
-Elastic::Transport::Client.new(hosts: ['localhost:9200', 'localhost:9201'], retry_on_status: [502, 503])
-```
-
-These two parameters can also be used together:
-
-```ruby
-Elastic::Transport::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 in the client, and periodically check for new nodes to spread the load.
-
-To retrieve and use the information from the [_Nodes Info API_](http://www.elastic.co/guide/en/elasticsearch/reference/current/cluster-nodes-info.html) on every 10,000th request:
-
-```ruby
-Elastic::Transport::Client.new(hosts: ['localhost:9200', 'localhost:9201'], reload_connections: true)
-```
-
-You can pass a specific number of requests after which the reloading should be performed:
-
-```ruby
-Elastic::Transport::Client.new(hosts: ['localhost:9200', 'localhost:9201'], reload_connections: 1_000)
-```
-
-To reload connections on failures, use:
-
-```ruby
-Elastic::Transport::Client.new(hosts: ['localhost:9200', 'localhost:9201'], reload_on_failure: true)
-```
-
-The reloading will timeout if not finished under 1 second by default. To change the setting:
-
-```ruby
-Elastic::Transport::Client.new(hosts: ['localhost:9200', 'localhost:9201'], sniffer_timeout: 3)
-```
-
-**NOTE:** When using reloading hosts ("sniffing") together with authentication, just pass the scheme, user and password with the host info -- or, for more clarity, in the `http` options:
-
-```ruby
-Elastic::Transport::Client.new(
-  host: 'localhost:9200',
-  http: { scheme: 'https', user: 'U', password: 'P' },
-  reload_connections: true,
-  reload_on_failure: true
-)
-```
-
-### Connection Selector
-
-By default, the client will rotate the connections in a round-robin fashion, using the {Elastic::Transport::Transport::Connections::Selector::RoundRobin} strategy.
-
-You can implement your own strategy to customize the behaviour. For example, let's have a "rack aware" strategy, which will prefer the nodes with a specific [attribute](https://github.com/elasticsearch/elasticsearch/blob/1.0/config/elasticsearch.yml#L81-L85). Only when these would be unavailable, the strategy will use the other nodes:
-
-```ruby
-class RackIdSelector
-  include Elastic::Transport::Transport::Connections::Selector::Base
-
-  def select(options={})
-    connections.select do |c|
-      # Try selecting the nodes with a `rack_id:x1` attribute first
-      c.host[:attributes] && c.host[:attributes][:rack_id] == 'x1'
-    end.sample || connections.to_a.sample
-  end
-end
-
-Elastic::Transport::Client.new hosts: ['x1.search.org', 'x2.search.org'], selector_class: RackIdSelector
-```
-
-### Transport Implementations
-
-By default, the client will use the [_Faraday_](https://rubygems.org/gems/faraday) HTTP library as a transport implementation.
-
-It will auto-detect and use an _adapter_ for _Faraday_ based on gems loaded in your code, preferring HTTP clients with support for persistent connections. Faraday 2 changed the way adapters are used ([read more here](https://github.com/lostisland/faraday/blob/main/UPGRADING.md#adapters-have-moved)). If you're using Faraday 1.x, you can require the HTTP library. To use the [_Patron_](https://github.com/toland/patron) HTTP, for example, require it:
-
-```ruby
-require 'patron'
-```
-
-If you're using Faraday 2.x, you need to add the corresponding adapter gem to your Gemfile and require them after you require `faraday`:
-
-```ruby
-# Gemfile
-gem 'faraday-patron'
-
-# Code
-require 'faraday'
-require 'faraday/patron'
-```
-
-Then, create a new client, and the _Patron_  gem will be used as the "driver":
-
-```ruby
-client = Elastic::Transport::Client.new
-
-client.transport.connections.first.connection.builder.adapter
-# => Faraday::Adapter::Patron
-
-10.times do
-  client.nodes.stats(metric: 'http')['nodes'].values.each do |n|
-    puts "#{n['name']} : #{n['http']['total_opened']}"
-  end
-end
-
-# => Stiletoo : 24
-# => Stiletoo : 24
-# => Stiletoo : 24
-# => ...
-```
-
-To use a specific adapter for _Faraday_, pass it as the `adapter` argument:
-
-```ruby
-# Gemfile
-gem 'faraday-net_http_persistent'
-
-# Code
-client = Elastic::Transport::Client.new(adapter: :net_http_persistent)
-
-client.transport.connections.first.connection.builder.handlers
-# => [Faraday::Adapter::NetHttpPersistent]
-```
-
-To pass options to the
-[`Faraday::Connection`](https://github.com/lostisland/faraday/blob/master/lib/faraday/connection.rb)
-constructor, use the `transport_options` key:
-
-```ruby
-client = Elastic::Transport::Client.new(
-  transport_options: {
-    request: { open_timeout: 1 },
-    headers: { user_agent:   'MyApp' },
-    params:  { :format => 'yaml' },
-    ssl:     { verify: false }
-  }
-)
-```
-
-To configure the _Faraday_ instance directly, use a block:
-
-```ruby
-require 'patron'
-
-client = Elastic::Transport::Client.new(host: 'localhost', port: '9200') do |f|
-  f.response :logger
-  f.adapter  :patron
-end
-```
-
-You can use any standard Faraday middleware and plugins in the configuration block. You can also initialize the transport class yourself, and pass it to the client constructor as the `transport` argument:
-
-```ruby
-require 'patron'
-
-transport_configuration = lambda do |f|
-  f.response :logger
-  f.adapter  :patron
-end
-
-transport = Elastic::Transport::Transport::HTTP::Faraday.new(
-  hosts: [ { host: 'localhost', port: '9200' } ],
-  &transport_configuration
-)
-
-# Pass the transport to the client
-#
-client = Elastic::Transport::Client.new(transport: transport)
-```
-
-Instead of passing the transport to the constructor, you can inject it at run time:
-
-```ruby
-# Set up the transport
-#
-faraday_configuration = lambda do |f|
-  f.instance_variable_set :@ssl, { verify: false }
-  f.adapter :excon
-end
-
-faraday_client = Elastic::Transport::Transport::HTTP::Faraday.new(
-  hosts: [
-    {
-      host: 'my-protected-host',
-      port: '443',
-      user: 'USERNAME',
-      password: 'PASSWORD',
-      scheme: 'https'
-    }
-  ],
-  &faraday_configuration
-)
-
-# Create a default client
-#
-client = Elastic::Transport::Client.new
-
-# Inject the transport to the client
-#
-client.transport = faraday_client
-```
-
-You can also use a bundled [_Curb_](https://rubygems.org/gems/curb) based transport implementation:
-
-```ruby
-require 'curb'
-require 'elastic/transport/transport/http/curb'
-
-client = Elastic::Transport::Client.new(transport_class: Elastic::Transport::Transport::HTTP::Curb)
-
-client.transport.connections.first.connection
-# => #<Curl::Easy http://localhost:9200/>
-```
-
-It's possible to customize the _Curb_ instance by passing a block to the constructor as well (in this case, as an inline block):
-
-```ruby
-transport = Elastic::Transport::Transport::HTTP::Curb.new(
-  hosts: [ { host: 'localhost', port: '9200' } ],
-  & lambda { |c| c.verbose = true }
-)
-
-client = Elastic::Transport::Client.new(transport: transport)
-```
-
-You can write your own transport implementation by including the `Elastic::Transport::Transport::Base` module, implementing the required contract, and passing it to the client as the `transport_class` parameter -- or injecting it directly.
-
-### Serializer Implementations
-
-By default, the [MultiJSON](http://rubygems.org/gems/multi_json) library is used as the serializer implementation, and it will pick up the "right" adapter based on gems available.
-
-The serialization component is pluggable, though, so you can write your own by including the `Elastic::Transport::Transport::Serializer::Base` module, implementing the required contract, and passing it to the client as the `serializer_class` or `serializer` parameter.
-
-### Exception Handling
-
-The library defines a [number of exception classes](https://github.com/elastic/elastic-transport-ruby/blob/main/lib/elastic/transport/transport/errors.rb) for various client and server errors, as well as unsuccessful HTTP responses,
-making it possible to `rescue` specific exceptions with desired granularity.
-
-The highest-level exception is `Elastic::Transport::Transport::Error` and will be raised for any generic client *or* server errors.
-
-`Elastic::Transport::Transport::ServerError` will be raised for server errors only.
-
-As an example for response-specific errors, a `404` response status will raise an `Elastic::Transport::Transport::Errors::NotFound` exception.
+## Compatibility
 
-Finally, `Elastic::Transport::Transport::SnifferTimeoutError` will be raised when connection reloading ("sniffing") times out.
+This gem is compatible with maintained Ruby versions. See [Ruby Maintenance Branches](https://www.ruby-lang.org/en/downloads/branches/). We don't provide support to versions which have reached their end of life.
 
 ## Development and Community
 
@@ -525,21 +27,6 @@ For local development, clone the repository and run `bundle install`. See `rake
 
 Bug fixes and features must be covered by unit tests.
 
-Github's pull requests and issues are used to communicate, send bug reports and code contributions.
-
-## The Architecture
-
-* `Elastic::Transport::Client` is composed of `Elastic::Transport::Transport`.
-* `Elastic::Transport::Transport` is composed of `Elastic::Transport::Transport::Connections`, and an instance of logger, tracer, serializer and sniffer.
-* Logger and tracer can be any object conforming to the Ruby logging interface, ie. an instance of [`Logger`](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/logger/rdoc/Logger.html), [_log4r_](https://rubygems.org/gems/log4r), [_logging_](https://github.com/TwP/logging/), etc.
-* The `Elastic::Transport::Transport::Serializer::Base` implementations handles converting data for Elasticsearch (eg. to JSON). You can implement your own serializer.
-* `Elastic::Transport::Transport::Sniffer` allows discovering nodes in the cluster and use them as connections.
-* `Elastic::Transport::Transport::Connections::Collection` is composed of `Elastic::Transport::Transport::Connections::Connection` instances and a selector instance.
-* `Elastic::Transport::Transport::Connections::Connection` contains the connection attributes such as hostname and port, as well as the concrete persistent "session" connected to a specific node.
-* The `Elastic::Transport::Transport::Connections::Selector::Base` implementations allows you to choose connections from the pool, eg. in a round-robin or random fashion. You can implement your own selector strategy.
-
-## Development
-
 A rake task is included to launch an Elasticsearch cluster with Docker. You need to install docker on your system and then run:
 ```bash
 $ rake docker:start[VERSION]
@@ -561,6 +48,8 @@ time rake test:integration
 
 Use `COVERAGE=true` before running a test task to check coverage with Simplecov.
 
+Github's pull requests and issues are used to communicate, send bug reports and code contributions.
+
 ## License
 
 This software is licensed under the [Apache 2 license](./LICENSE).

data/Rakefile

@@ -110,6 +110,15 @@ namespace :docker do
   end
 end
 
+desc 'Run Ruby console with the Elastic transport client libraries loaded'
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'elastic-transport'
+  ARGV.clear
+  IRB.start
+end
+
 # ----- Documentation tasks ---------------------------------------------------
 require 'yard'
 YARD::Rake::YardocTask.new(:doc) do |t|

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

@@ -24,12 +24,12 @@ module Elastic
         include Loggable
 
         DEFAULT_PORT             = 9200
-        DEFAULT_PROTOCOL         = 'http'
+        DEFAULT_PROTOCOL         = 'http'.freeze
         DEFAULT_RELOAD_AFTER     = 10_000 # Requests
         DEFAULT_RESURRECT_AFTER  = 60     # Seconds
         DEFAULT_MAX_RETRIES      = 3      # Requests
         DEFAULT_SERIALIZER_CLASS = Serializer::MultiJson
-        SANITIZED_PASSWORD       = '*' * (rand(14)+1)
+        SANITIZED_PASSWORD       = '*' * (rand(14) + 1)
 
         attr_reader   :hosts, :options, :connections, :counter, :last_request_at, :protocol
         attr_accessor :serializer, :sniffer, :logger, :tracer,
@@ -59,7 +59,7 @@ module Elastic
           @compression = !!@options[:compression]
           @connections = __build_connections
 
-          @serializer  = options[:serializer] || ( options[:serializer_class] ? options[:serializer_class].new(self) : DEFAULT_SERIALIZER_CLASS.new(self) )
+          @serializer  = options[:serializer] || ( options[:serializer_class] ? options[:serializer_class].new(self) : DEFAULT_SERIALIZER_CLASS.new(self))
           @protocol    = options[:protocol] || DEFAULT_PROTOCOL
 
           @logger      = options[:logger]
@@ -72,7 +72,7 @@ module Elastic
           @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
-          @retry_on_status = Array(options[:retry_on_status]).map { |d| d.to_i }
+          @retry_on_status = Array(options[:retry_on_status]).map(&:to_i)
         end
 
         # Returns a connection from the connection pool by delegating to {Connections::Collection#get_connection}.
@@ -87,7 +87,7 @@ module Elastic
           resurrect_dead_connections! if Time.now > @last_request_at + @resurrect_after
 
           @counter_mtx.synchronize { @counter += 1 }
-          reload_connections!         if reload_connections && counter % reload_after == 0
+          reload_connections! if reload_connections && (counter % reload_after).zero?
           connections.get_connection(options)
         end
 
@@ -97,10 +97,10 @@ module Elastic
         #
         def reload_connections!
           hosts = sniffer.hosts
-          __rebuild_connections :hosts => hosts, :options => options
+          __rebuild_connections(hosts: hosts, options: options)
           self
         rescue SnifferTimeoutError
-          log_error "[SnifferTimeoutError] Timeout when reloading connections."
+          log_error('[SnifferTimeoutError] Timeout when reloading connections.')
           self
         end
 
@@ -109,7 +109,7 @@ module Elastic
         # @see Connections::Connection#resurrect!
         #
         def resurrect_dead_connections!
-          connections.dead.each { |c| c.resurrect! }
+          connections.dead.each(&:resurrect!)
         end
 
         # Rebuilds the connections collection in the transport.
@@ -128,7 +128,7 @@ module Elastic
             __close_connections
 
             new_connections = __build_connections
-            stale_connections = @connections.all.select  { |c| ! new_connections.include?(c) }
+            stale_connections = @connections.all.reject { |c| new_connections.include?(c) }
             new_connections = new_connections.reject { |c| @connections.all.include?(c) }
 
             @connections.remove(stale_connections)
@@ -177,8 +177,8 @@ module Elastic
         # @return [Connections::Connection]
         # @api    private
         #
-        def __build_connection(host, options={}, block=nil)
-          raise NoMethodError, "Implement this method in your class"
+        def __build_connection(host, options = {}, block = nil)
+          raise NoMethodError, 'Implement this method in your class'
         end
 
         # Closes the connections collection
@@ -209,14 +209,14 @@ module Elastic
         #
         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}" )
+              (params.empty? ? '' : "&#{::Faraday::Utils::ParamsHash[params].to_query}")
           trace_body = body ? " -d '#{__convert_to_json(body, :pretty => true)}'" : ''
           trace_command = "curl -X #{method.to_s.upcase}"
-          trace_command += " -H '#{headers.collect { |k,v| "#{k}: #{v}" }.join(", ")}'" if headers && !headers.empty?
+          trace_command += " -H '#{headers.collect { |k, v| "#{k}: #{v}" }.join(", ")}'" 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"
+          tracer.debug json ? serializer.dump(json, pretty: true).gsub(/^/, '# ').sub(/\}$/, "\n# }")+"\n" : "# #{response.body}\n"
         end
 
         # Raise error specific for the HTTP response status or a generic server error
@@ -276,40 +276,37 @@ module Elastic
           reload_on_failure = opts.fetch(:reload_on_failure, @options[:reload_on_failure])
           delay_on_retry = opts.fetch(:delay_on_retry, @options[:delay_on_retry])
 
-          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
+          max_retries = max_retries(opts) || max_retries(options)
 
           params = params.clone
-          ignore = Array(params.delete(:ignore)).compact.map { |s| s.to_i }
+          # Transforms ignore status codes to Integer
+          ignore = Array(params.delete(:ignore)).compact.map(&:to_i)
 
           begin
             sleep(delay_on_retry / 1000.0) if tries > 0
-            tries     += 1
+            tries += 1
             connection = get_connection or raise Error.new('Cannot get new connection from pool.')
 
-            if connection.connection.respond_to?(:params) && connection.connection.params.respond_to?(:to_hash)
+            if connection.connection.respond_to?(:params) &&
+               connection.connection.params.respond_to?(:to_hash)
               params = connection.connection.params.merge(params.to_hash)
             end
 
-            url      = connection.full_url(path, params)
+            url = connection.full_url(path, params)
             response = block.call(connection, url)
-            connection.healthy! if connection.failures > 0
+            connection.healthy! if connection.failures.positive?
 
             # Raise an exception so we can catch it for `retry_on_status`
-            __raise_transport_error(response) if response.status.to_i >= 300 && @retry_on_status.include?(response.status.to_i)
+            __raise_transport_error(response) if response.status.to_i >= 300 &&
+                                                 @retry_on_status.include?(response.status.to_i)
           rescue Elastic::Transport::Transport::ServerError => e
-            if response && @retry_on_status.include?(response.status)
-              log_warn "[#{e.class}] Attempt #{tries} to get response from #{url}"
-              if tries <= (max_retries || DEFAULT_MAX_RETRIES)
-                retry
-              else
-                log_fatal "[#{e.class}] Cannot get response from #{url} after #{tries} tries"
-                raise e
-              end
+            raise e unless response && @retry_on_status.include?(response.status)
+
+            log_warn "[#{e.class}] Attempt #{tries} to get response from #{url}"
+            if tries <= (max_retries || DEFAULT_MAX_RETRIES)
+              retry
             else
+              log_fatal "[#{e.class}] Cannot get response from #{url} after #{tries} tries"
               raise e
             end
           rescue *host_unreachable_exceptions => e
@@ -317,21 +314,21 @@ module Elastic
 
             connection.dead!
 
-            if reload_on_failure and tries < connections.all.size
+            if reload_on_failure && tries < connections.all.size
               log_warn "[#{e.class}] Reloading connections (attempt #{tries} of #{connections.all.size})"
               reload_connections! and retry
             end
 
-            if max_retries
-              log_warn "[#{e.class}] Attempt #{tries} connecting to #{connection.host.inspect}"
-              if tries <= max_retries
-                retry
-              else
-                log_fatal "[#{e.class}] Cannot connect to #{connection.host.inspect} after #{tries} tries"
-                raise e
-              end
+            exception = Elastic::Transport::Transport::Error.new(e.message)
+
+            raise exception unless max_retries
+
+            log_warn "[#{e.class}] Attempt #{tries} connecting to #{connection.host.inspect}"
+            if tries <= max_retries
+              retry
             else
-              raise e
+              log_fatal "[#{e.class}] Cannot connect to #{connection.host.inspect} after #{tries} tries"
+              raise exception
             end
           rescue Exception => e
             log_fatal "[#{e.class}] #{e.message} (#{connection.host.inspect if connection})"
@@ -349,8 +346,11 @@ module Elastic
             __raise_transport_error response unless ignore.include?(response.status.to_i)
           end
 
-          json     = serializer.load(response.body) if response.body && !response.body.empty? && response.headers && response.headers["content-type"] =~ /json/
-          took     = (json['took'] ? sprintf('%.3fs', json['took']/1000.0) : 'n/a') rescue 'n/a'
+          json = serializer.load(response.body) if response.body &&
+                                                       !response.body.empty? &&
+                                                       response.headers &&
+                                                       response.headers["content-type"] =~ /json/
+          took = (json['took'] ? sprintf('%.3fs', json['took'] / 1000.0) : 'n/a') rescue 'n/a'
           __log_response(method, path, params, body, url, response, json, took, duration) unless ignore.include?(response.status.to_i)
           __trace(method, path, params, connection_headers(connection), body, url, response, nil, 'N/A', duration) if tracer
           log_warn(response.headers['warning']) if response.headers&.[]('warning')
@@ -372,17 +372,21 @@ module Elastic
         private
 
         USER_AGENT_STR = 'User-Agent'.freeze
-        USER_AGENT_REGEX = /user\-?\_?agent/
+        USER_AGENT_REGEX = /user-?_?agent/
         ACCEPT_ENCODING = 'Accept-Encoding'.freeze
         CONTENT_ENCODING = 'Content-Encoding'.freeze
         CONTENT_TYPE_STR = 'Content-Type'.freeze
-        CONTENT_TYPE_REGEX = /content\-?\_?type/
+        CONTENT_TYPE_REGEX = /content-?_?type/
         DEFAULT_CONTENT_TYPE = 'application/json'.freeze
         GZIP = 'gzip'.freeze
         GZIP_FIRST_TWO_BYTES = '1f8b'.freeze
         HEX_STRING_DIRECTIVE = 'H*'.freeze
         RUBY_ENCODING = '1.9'.respond_to?(:force_encoding)
 
+        def max_retries(opts)
+          opts[:retry_on_failure] == true ? DEFAULT_MAX_RETRIES : opts[:retry_on_failure]
+        end
+
         def compress_request(body, headers)
           if body
             headers ||= {}
@@ -409,7 +413,7 @@ module Elastic
 
           io = StringIO.new(body)
           gzip_reader = if RUBY_ENCODING
-                          Zlib::GzipReader.new(io, :encoding => 'ASCII-8BIT')
+                          Zlib::GzipReader.new(io, encoding: 'ASCII-8BIT')
                         else
                           Zlib::GzipReader.new(io)
                         end
@@ -442,7 +446,7 @@ module Elastic
           end
         end
 
-        def user_agent_header(client)
+        def user_agent_header(_client)
           @user_agent ||= begin
             meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
             if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
@@ -453,7 +457,8 @@ module Elastic
         end
 
         def connection_headers(connection)
-          if defined?(Elastic::Transport::Transport::HTTP::Manticore) && self.class == Elastic::Transport::Transport::HTTP::Manticore
+          if defined?(Elastic::Transport::Transport::HTTP::Manticore) &&
+             instance_of?(Elastic::Transport::Transport::HTTP::Manticore)
             @request_options[:headers]
           else
             connection.connection.headers

data/lib/elastic/transport/transport/errors.rb

@@ -18,7 +18,6 @@
 module Elastic
   module Transport
     module Transport
-
       # Generic client error
       #
       class Error < StandardError; end
@@ -78,14 +77,13 @@ module Elastic
         505 => 'HTTPVersionNotSupported',
         506 => 'VariantAlsoNegotiates',
         510 => 'NotExtended'
-      }
+      }.freeze
 
-      ERRORS = HTTP_STATUSES.inject({}) do |sum, error|
+      ERRORS = HTTP_STATUSES.each_with_object({}) do |error, sum|
         status, name = error
         sum[status] = Errors.const_set name, Class.new(ServerError)
         sum
       end
-
     end
   end
 end

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

@@ -34,26 +34,27 @@ module Elastic
           #
           def perform_request(method, path, params = {}, body = nil, headers = nil, opts = {})
             super do |connection, url|
-              headers = if connection.connection.headers
-                          if !headers.nil?
-                            connection.connection.headers.merge(headers)
-                          else
-                            connection.connection.headers
-                          end
-                        else
-                          headers
-                        end
+              headers = parse_headers(headers, connection)
               body = body ? __convert_to_json(body) : nil
               body, headers = compress_request(body, headers)
 
-              response = connection.connection.run_request(
-                method.downcase.to_sym,
-                url,
-                body,
-                headers
-              )
+              response = connection.connection.run_request(method.downcase.to_sym, url, body, headers)
 
-              Response.new response.status, decompress_response(response.body), response.headers
+              Response.new(response.status, decompress_response(response.body), response.headers)
+            end
+          end
+
+          # Merges headers already present in the connection and the ones passed in to perform_request
+          #
+          def parse_headers(headers, connection)
+            if connection.connection.headers
+              if !headers.nil?
+                connection.connection.headers.merge(headers)
+              else
+                connection.connection.headers
+              end
+            else
+              headers
             end
           end
 
@@ -73,10 +74,10 @@ module Elastic
           #
           def host_unreachable_exceptions
             [
-                ::Faraday::ConnectionFailed,
-                ::Faraday::TimeoutError,
-                ::Faraday.const_defined?(:ServerError) ? ::Faraday::ServerError : nil,
-                ::Faraday::SSLError
+              ::Faraday::ConnectionFailed,
+              ::Faraday::TimeoutError,
+              ::Faraday.const_defined?(:ServerError) ? ::Faraday::ServerError : nil,
+              ::Faraday::SSLError
             ].compact
           end
 
@@ -84,13 +85,14 @@ module Elastic
 
           def user_agent_header(client)
             @user_agent ||= begin
-              meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
-              if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
-                meta << "#{RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase} #{RbConfig::CONFIG['target_cpu']}"
-              end
-              meta << "#{client.headers[USER_AGENT_STR]}"
-              "elastic-transport-ruby/#{VERSION} (#{meta.join('; ')})"
-            end
+                              meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
+                              if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
+                                meta << "#{RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase} " \
+                                        "#{RbConfig::CONFIG['target_cpu']}"
+                              end
+                              meta << client.headers[USER_AGENT_STR]
+                              "elastic-transport-ruby/#{VERSION} (#{meta.join('; ')})"
+                            end
           end
         end
       end

data/lib/elastic/transport/transport/response.rb

@@ -19,14 +19,15 @@ module Elastic
   module Transport
     module Transport
       # Wraps the response from Elasticsearch.
-      #
+      # It provides `body`, `status` and `headers` methods, but you can treat is as a hash and
+      # access the keys directly.
       class Response
         attr_reader :status, :body, :headers
 
         # @param status  [Integer] Response status code
         # @param body    [String]  Response body
         # @param headers [Hash]    Response headers
-        def initialize(status, body, headers={})
+        def initialize(status, body, headers = {})
           @status, @body, @headers = status, body, headers
           @body = body.force_encoding('UTF-8') if body.respond_to?(:force_encoding)
         end

data/lib/elastic/transport/version.rb

@@ -17,6 +17,6 @@
 
 module Elastic
   module Transport
-    VERSION = '8.1.0'.freeze
+    VERSION = '8.2.0'.freeze
   end
 end

data/spec/elastic/transport/base_spec.rb

@@ -30,16 +30,16 @@ describe Elastic::Transport::Transport::Base do
 
       it 'does not include the password in the logged string' do
         expect(logger).not_to receive(:error).with(/secret_password/)
-        expect {
+        expect do
           client.perform_request('GET', '/_cluster/stats')
-        }.to raise_exception(Faraday::ConnectionFailed)
+        end.to raise_exception(Elastic::Transport::Transport::Error)
       end
 
       it 'replaces the password with the string \'REDACTED\'' do
         expect(logger).to receive(:error).with(/REDACTED/)
-        expect {
+        expect do
           client.perform_request('GET', '/_cluster/stats')
-        }.to raise_exception(Faraday::ConnectionFailed)
+        end.to raise_exception(Elastic::Transport::Transport::Error)
       end
     end
 
@@ -93,7 +93,7 @@ describe Elastic::Transport::Transport::Base do
     end
 
     it 'raises an exception' do
-      expect { client.perform_request('GET', '/info') }.to raise_exception(Faraday::ConnectionFailed)
+      expect { client.perform_request('GET', '/info') }.to raise_exception(Elastic::Transport::Transport::Error)
     end
   end
 
@@ -116,9 +116,9 @@ describe Elastic::Transport::Transport::Base do
       end
 
       it 'uses the client `retry_on_failure` value' do
-        expect {
+        expect do
           client.transport.perform_request('GET', '/info')
-        }.to raise_exception(Faraday::ConnectionFailed)
+        end.to raise_exception(Elastic::Transport::Transport::Error)
       end
     end
 
@@ -150,7 +150,7 @@ describe Elastic::Transport::Transport::Base do
       it 'uses the option `retry_on_failure` value' do
         expect do
           client.transport.perform_request('GET', '/info', {}, nil, nil, retry_on_failure: 5)
-        end.to raise_exception(Faraday::ConnectionFailed)
+        end.to raise_exception(Elastic::Transport::Transport::Error)
       end
     end
   end
@@ -162,8 +162,8 @@ describe Elastic::Transport::Transport::Base do
 
     let(:arguments) do
       {
-          hosts: ['http://unavailable:9200', 'http://unavailable:9201'],
-          retry_on_failure: true
+        hosts: ['http://unavailable:9200', 'http://unavailable:9201'],
+        retry_on_failure: true
       }
     end
 
@@ -173,9 +173,9 @@ describe Elastic::Transport::Transport::Base do
       end
 
       it 'uses the default `MAX_RETRIES` value' do
-        expect {
+        expect do
           client.transport.perform_request('GET', '/info')
-        }.to raise_exception(Faraday::ConnectionFailed)
+        end.to raise_exception(Elastic::Transport::Transport::Error)
       end
     end
 
@@ -185,9 +185,9 @@ describe Elastic::Transport::Transport::Base do
       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(Elastic::Transport::Transport::Error)
       end
     end
   end
@@ -199,8 +199,8 @@ describe Elastic::Transport::Transport::Base do
 
     let(:arguments) do
       {
-          hosts: ['http://unavailable:9200', 'http://unavailable:9201'],
-          retry_on_failure: false
+        hosts: ['http://unavailable:9200', 'http://unavailable:9201'],
+        retry_on_failure: false
       }
     end
 
@@ -210,22 +210,21 @@ describe Elastic::Transport::Transport::Base do
       end
 
       it 'does not retry' do
-        expect {
+        expect do
           client.transport.perform_request('GET', '/info')
-        }.to raise_exception(Faraday::ConnectionFailed)
+        end.to raise_exception(Elastic::Transport::Transport::Error)
       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(Elastic::Transport::Transport::Error)
       end
     end
   end
@@ -247,7 +246,7 @@ describe Elastic::Transport::Transport::Base do
       it 'does not retry' do
         expect do
           client.transport.perform_request('GET', '/info')
-        end.to raise_exception(Faraday::ConnectionFailed)
+        end.to raise_exception(Elastic::Transport::Transport::Error)
       end
     end
 
@@ -259,7 +258,7 @@ describe Elastic::Transport::Transport::Base do
       it 'uses the option `retry_on_failure` value' do
         expect do
           client.transport.perform_request('GET', '/info', {}, nil, nil, retry_on_failure: 5)
-        end.to raise_exception(Faraday::ConnectionFailed)
+        end.to raise_exception(Elastic::Transport::Transport::Error)
       end
     end
   end

data/spec/elastic/transport/client_spec.rb

@@ -1194,17 +1194,7 @@ describe Elastic::Transport::Client do
 
   context 'when the client connects to Elasticsearch' do
     let(:logger) do
-      Logger.new(STDERR).tap do |logger|
-        logger.formatter = proc do |severity, datetime, progname, msg|
-          color = case severity
-                  when /INFO/ then :green
-                  when /ERROR|WARN|FATAL/ then :red
-                  when /DEBUG/ then :cyan
-                  else :white
-                  end
-          ANSI.ansi(severity[0] + ' ', color, :faint) + ANSI.ansi(msg, :white, :faint) + "\n"
-        end
-      end unless ENV['QUIET']
+      Logger.new($stderr) unless ENV['QUIET']
     end
 
     let(:port) do
@@ -1327,9 +1317,9 @@ describe Elastic::Transport::Client do
 
         it 'retries only the specified number of times' do
           expect(client.perform_request('GET', '_nodes/_local'))
-          expect {
+          expect do
             client.perform_request('GET', '_nodes/_local')
-          }.to raise_exception(Faraday::ConnectionFailed)
+          end.to raise_exception(Elastic::Transport::Transport::Error)
         end
       end
 

data/spec/spec_helper.rb

@@ -21,7 +21,6 @@ end
 
 require 'elastic-transport'
 require 'logger'
-require 'ansi/code'
 require 'hashie/mash'
 if defined?(JRUBY_VERSION)
   require 'elastic/transport/transport/http/manticore'

data/test/test_helper.rb

@@ -30,7 +30,6 @@ if ENV['COVERAGE']
   SimpleCov.start { add_filter %r{^/test/} }
 end
 
-require 'ansi/code'
 require 'minitest/autorun'
 require 'minitest/reporters'
 require 'mocha/minitest'

data/test/unit/transport_base_test.rb

@@ -255,10 +255,9 @@ class Elastic::Transport::Transport::BaseTest < Minitest::Test
     should "raise an error on connection failure" do
       @transport.expects(:get_connection).returns(stub_everything :failures => 1)
 
-      # `block.expects(:call).raises(::Errno::ECONNREFUSED)` fails on Ruby 1.8
-      block = lambda { |a,b| raise ::Errno::ECONNREFUSED }
+      block = lambda { |a,b| raise Elastic::Transport::Transport::Error }
 
-      assert_raise ::Errno::ECONNREFUSED do
+      assert_raise Elastic::Transport::Transport::Error do
         @transport.perform_request 'GET', '/', &block
       end
     end
@@ -291,11 +290,11 @@ class Elastic::Transport::Transport::BaseTest < Minitest::Test
       c = stub_everything :failures => 1
       @transport.expects(:get_connection).returns(c)
 
-      block = lambda { |a,b| raise ::Errno::ECONNREFUSED }
+      block = lambda { |a, b| raise Errno::ECONNREFUSED }
 
       c.expects(:dead!)
 
-      assert_raise( ::Errno::ECONNREFUSED ) { @transport.perform_request 'GET', '/', &block }
+      assert_raise( Elastic::Transport::Transport::Error ) { @transport.perform_request 'GET', '/', &block }
     end
   end
 
@@ -311,7 +310,7 @@ class Elastic::Transport::Transport::BaseTest < Minitest::Test
 
     should "reload connections when host is unreachable" do
       @block.expects(:call).times(2).
-            raises(Errno::ECONNREFUSED).
+        raises(Errno::ECONNREFUSED).
             then.returns(stub_everything :failures => 1)
 
       @transport.expects(:reload_connections!).returns([])
@@ -343,13 +342,13 @@ class Elastic::Transport::Transport::BaseTest < Minitest::Test
 
     should "raise an error after max tries" do
       @block.expects(:call).times(4).
-            raises(Errno::ECONNREFUSED).
+        raises(Errno::ECONNREFUSED).
             then.raises(Errno::ECONNREFUSED).
             then.raises(Errno::ECONNREFUSED).
             then.raises(Errno::ECONNREFUSED).
             then.returns(stub_everything :failures => 1)
 
-      assert_raise Errno::ECONNREFUSED do
+      assert_raise Elastic::Transport::Transport::Error do
         @transport.perform_request('GET', '/', &@block)
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elastic-transport
 version: !ruby/object:Gem::Version
-  version: 8.1.0
+  version: 8.2.0
 platform: ruby
 authors:
 - Karel Minarik
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-09-01 00:00:00.000000000 Z
+date: 2023-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday