chewy 7.2.1 → 7.6.0

data/README.md

@@ -5,7 +5,7 @@
 
 # Chewy
 
-Chewy is an ODM (Object Document Mapper), built on top of the [the official Elasticsearch client](https://github.com/elastic/elasticsearch-ruby).
+Chewy is an ODM (Object Document Mapper), built on top of [the official Elasticsearch client](https://github.com/elastic/elasticsearch-ruby).
 
 ## Why Chewy?
 
@@ -43,7 +43,7 @@ Or install it yourself as:
 
 ### Ruby
 
-Chewy is compatible with MRI 2.6-3.0¹.
+Chewy is compatible with MRI 3.0-3.2¹.
 
 > ¹ Ruby 3 is only supported with Rails 6.1
 
@@ -53,7 +53,7 @@ Chewy is compatible with MRI 2.6-3.0¹.
 | ------------- | ---------------------------------- |
 | 7.2.x         | 7.x                                |
 | 7.1.x         | 7.x                                |
-| 7.0.0         | 6.8, 7.x                           |
+| 7.0.x         | 6.8, 7.x                           |
 | 6.0.0         | 5.x, 6.x                           |
 | 5.x           | 5.x, limited support for 1.x & 2.x |
 
@@ -340,7 +340,7 @@ Chewy.settings = {
   [See index settings here](https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-update-settings.html).
   [See root object settings here](https://www.elastic.co/guide/en/elasticsearch/reference/current/dynamic-field-mapping.html).
 
-  See [mapping.rb](lib/chewy/type/mapping.rb) for more details.
+  See [mapping.rb](lib/chewy/index/mapping.rb) for more details.
 
 5. Add model-observing code
 
@@ -446,6 +446,23 @@ end
 
 See the section on *Script fields* for details on calculating distance in a search.
 
+### Join fields
+
+You can use a [join field](https://www.elastic.co/guide/en/elasticsearch/reference/current/parent-join.html)
+to implement parent-child relationships between documents.
+It [replaces the old `parent_id` based parent-child mapping](https://www.elastic.co/guide/en/elasticsearch/reference/current/removal-of-types.html#parent-child-mapping-types)
+
+To use it, you need to pass `relations` and `join` (with `type` and `id`) options:
+```ruby
+field :hierarchy_link, type: :join, relations: {question: %i[answer comment], answer: :vote, vote: :subvote}, join: {type: :comment_type, id: :commented_id}
+```
+assuming you have `comment_type` and `commented_id` fields in your model.
+
+Note that when you reindex a parent, its children and grandchildren will be reindexed as well.
+This may require additional queries to the primary database and to elastisearch.
+
+Also note that the join field doesn't support crutches (it should be a field directly defined on the model).
+
 ### Crutches™ technology
 
 Assume you are defining your index like this (product has_many categories through product_categories):
@@ -486,7 +503,7 @@ class ProductsIndex < Chewy::Index
 
   field :name
   # simply use crutch-fetched data as a value:
-  field :category_names, value: ->(product, crutches) { crutches.categories[product.id] }
+  field :category_names, value: ->(product, crutches) { crutches[:categories][product.id] }
 end
 ```
 
@@ -508,7 +525,7 @@ So Chewy Crutches™ technology is able to increase your indexing performance in
 
 ### Witchcraft™ technology
 
-One more experimental technology to increase import performance. As far as you know, chewy defines value proc for every imported field in mapping, so at the import time each of this procs is executed on imported object to extract result document to import. It would be great for performance to use one huge whole-document-returning proc instead. So basically the idea or Witchcraft™ technology is to compile a single document-returning proc from the index definition.
+One more experimental technology to increase import performance. As far as you know, chewy defines value proc for every imported field in mapping, so at the import time each of these procs is executed on imported object to extract result document to import. It would be great for performance to use one huge whole-document-returning proc instead. So basically the idea or Witchcraft™ technology is to compile a single document-returning proc from the index definition.
 
 ```ruby
 index_scope Product
@@ -552,7 +569,7 @@ Obviously not every type of definition might be compiled. There are some restric
   end
   ```
 
-However, it is quite possible that your index definition will be supported by Witchcraft™ technology out of the box in the most of the cases.
+However, it is quite possible that your index definition will be supported by Witchcraft™ technology out of the box in most of the cases.
 
 ### Raw Import
 
@@ -658,7 +675,9 @@ end
 
 You may be wondering why do you need it? The answer is simple: not to lose the data.
 
-Imagine that you reset your index in a zero-downtime manner (to separate index), and at the meantime somebody keeps updating the data frequently (to old index). So all these actions will be written to the journal index and you'll be able to apply them after index reset using the `Chewy::Journal` interface.
+Imagine that you reset your index in a zero-downtime manner (to separate index), and in the meantime somebody keeps updating the data frequently (to old index). So all these actions will be written to the journal index and you'll be able to apply them after index reset using the `Chewy::Journal` interface.
+
+When enabled, journal can grow to enormous size, consider setting up cron job that would clean it occasionally using [`chewy:journal:clean` rake task](#chewyjournal).
 
 ### Index manipulation
 
@@ -677,6 +696,7 @@ UsersIndex.import User.where('rating > 100') # or import specified users scope
 UsersIndex.import User.where('rating > 100').to_a # or import specified users array
 UsersIndex.import [1, 2, 42] # pass even ids for import, it will be handled in the most effective way
 UsersIndex.import User.where('rating > 100'), update_fields: [:email] # if update fields are specified - it will update their values only with the `update` bulk action
+UsersIndex.import! # raises an exception in case of any import errors
 
 UsersIndex.reset! # purges index and imports default data for all types
 ```
@@ -737,6 +757,106 @@ The default queue name is `chewy`, you can customize it in settings: `sidekiq.qu
 Chewy.settings[:sidekiq] = {queue: :low}
 ```
 
+#### `:lazy_sidekiq`
+
+This does the same thing as `:sidekiq`, but with lazy evaluation. Beware it does not allow you to use any non-persistent record state for indices and conditions because record will be re-fetched from database asynchronously using sidekiq. However for destroying records strategy will fallback to `:sidekiq` because it's not possible to re-fetch deleted records from database.
+
+The purpose of this strategy is to improve the response time of the code that should update indexes, as it does not only defer actual ES calls to a background job but `update_index` callbacks evaluation (for created and updated objects) too. Similar to `:sidekiq`, index update is asynchronous so this strategy cannot be used when data and index synchronization is required.
+
+```ruby
+Chewy.strategy(:lazy_sidekiq) do
+  City.popular.map(&:do_some_update_action!)
+end
+```
+
+The default queue name is `chewy`, you can customize it in settings: `sidekiq.queue_name`
+```
+Chewy.settings[:sidekiq] = {queue: :low}
+```
+
+#### `:delayed_sidekiq`
+
+It accumulates IDs of records to be reindexed during the latency window in Redis and then performs the reindexing of all accumulated records at once. 
+This strategy is very useful in the case of frequently mutated records. 
+It supports the `update_fields` option, so it will attempt to select just enough data from the database.
+
+Keep in mind, this strategy does not guarantee reindexing in the event of Sidekiq worker termination or an error during the reindexing phase. 
+This behavior is intentional to prevent continuous growth of Redis db.
+
+There are three options that can be defined in the index:
+```ruby
+class CitiesIndex...
+  strategy_config delayed_sidekiq: {
+    latency: 3,
+    margin: 2,
+    ttl: 60 * 60 * 24,
+    reindex_wrapper: ->(&reindex) {
+      ActiveRecord::Base.connected_to(role: :reading) { reindex.call }
+    }
+    # latency - will prevent scheduling identical jobs
+    # margin - main purpose is to cover db replication lag by the margin
+    # ttl - a chunk expiration time (in seconds)
+    # reindex_wrapper - lambda that accepts block to wrap that reindex process AR connection block.
+  }
+
+  ...
+end
+```
+
+Also you can define defaults in the `initializers/chewy.rb`
+```ruby
+Chewy.settings = {
+  strategy_config: {
+    delayed_sidekiq: {
+      latency: 3,
+      margin: 2,
+      ttl: 60 * 60 * 24,
+      reindex_wrapper: ->(&reindex) {
+        ActiveRecord::Base.connected_to(role: :reading) { reindex.call }
+      }
+    }
+  }
+}
+
+```
+or in `config/chewy.yml`
+```ruby
+  strategy_config:
+    delayed_sidekiq:
+      latency: 3
+      margin: 2
+      ttl: <%= 60 * 60 * 24 %>
+      # reindex_wrapper setting is not possible here!!! use the initializer instead
+```
+
+You can use the strategy identically to other strategies
+```ruby
+Chewy.strategy(:delayed_sidekiq) do
+  City.popular.map(&:do_some_update_action!)
+end
+```
+
+The default queue name is `chewy`, you can customize it in settings: `sidekiq.queue_name`
+```
+Chewy.settings[:sidekiq] = {queue: :low}
+```
+
+Explicit call of the reindex using `:delayed_sidekiq strategy`
+```ruby
+CitiesIndex.import([1, 2, 3], strategy: :delayed_sidekiq)
+```
+
+Explicit call of the reindex using `:delayed_sidekiq` strategy with `:update_fields` support
+```ruby
+CitiesIndex.import([1, 2, 3], update_fields: [:name], strategy: :delayed_sidekiq)
+```
+
+While running tests with delayed_sidekiq strategy and Sidekiq is using a real redis instance that is NOT cleaned up in between tests (via e.g. `Sidekiq.redis(&:flushdb)`), you'll want to cleanup some redis keys in between tests to avoid state leaking and flaky tests. Chewy provides a convenience method for that:
+```ruby
+# it might be a good idea to also add to your testing setup, e.g.: a rspec `before` hook
+Chewy::Strategy::DelayedSidekiq.clear_timechunks!
+```
+
 #### `:active_job`
 
 This does the same thing as `:atomic`, but using ActiveJob. This will inherit the ActiveJob configuration settings including the `active_job.queue_adapter` setting for the environment. Patch `Chewy::Strategy::ActiveJob::Worker` for index updates improving.
@@ -773,7 +893,9 @@ It is convenient for use in e.g. the Rails console with non-block notation:
 
 #### `:bypass`
 
-The bypass strategy simply silences index updates.
+When the bypass strategy is active the index will not be automatically updated on object save.
+
+For example, on `City.first.save!` the cities index would not be updated.
 
 #### Nesting
 
@@ -851,7 +973,7 @@ Chewy has notifying the following events:
     {index: 30, delete: 5}
     ```
 
-  * `payload[:errors]`: might not exists. Contains grouped errors with objects ids list:
+  * `payload[:errors]`: might not exist. Contains grouped errors with objects ids list:
 
     ```ruby
     {index: {
@@ -959,7 +1081,7 @@ Main methods of the request DSL are: `query`, `filter` and `post_filter`, it is
 ```ruby
 CitiesIndex
   .filter(term: {name: 'Bangkok'})
-  .query { match name: 'London' }
+  .query(match: {name: 'London'})
   .query.not(range: {population: {gt: 1_000_000}})
 ```
 
@@ -969,7 +1091,7 @@ You can query a set of indexes at once:
 CitiesIndex.indices(CountriesIndex).query(match: {name: 'Some'})
 ```
 
-See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html and https://github.com/elastic/elasticsearch-ruby/tree/master/elasticsearch-dsl for more details.
+See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html and https://github.com/elastic/elasticsearch-dsl-ruby for more details.
 
 An important part of requests manipulation is merging. There are 4 methods to perform it: `merge`, `and`, `or`, `not`. See [Chewy::Search::QueryProxy](lib/chewy/search/query_proxy.rb) for details. Also, `only` and `except` methods help to remove unneeded parts of the request.
 
@@ -983,7 +1105,7 @@ Request DSL also provides additional scope actions, like `delete_all`, `exists?`
 
 #### Pagination
 
-The request DSL supports pagination with `Kaminari`. An extension is enabled on initializtion if `Kaminari` is available. See [Chewy::Search](lib/chewy/search.rb) and [Chewy::Search::Pagination::Kaminari](lib/chewy/search/pagination/kaminari.rb) for details.
+The request DSL supports pagination with `Kaminari`. An extension is enabled on initialization if `Kaminari` is available. See [Chewy::Search](lib/chewy/search.rb) and [Chewy::Search::Pagination::Kaminari](lib/chewy/search/pagination/kaminari.rb) for details.
 
 #### Named scopes
 
@@ -1032,12 +1154,6 @@ rake chewy:reset[users,cities] # resets UsersIndex and CitiesIndex
 rake chewy:reset[-users,cities] # resets every index in the application except specified ones
 ```
 
-#### Progressbar for `chewy:reset` tasks
-
-You can optionally output the `progressbar` for `chewy:reset` and `chewy:parallel:reset` during import.
-
-Progressbar is hidden by default. Set `ENV['PROGRESS']` to `true` to display it.
-
 #### `chewy:upgrade`
 
 Performs reset exactly the same way as `chewy:reset` does, but only when the index specification (setting or mapping) was changed.
@@ -1090,6 +1206,10 @@ Right now the approach is that if some data had been updated, but index definiti
 
 Also, there is always full reset alternative with `rake chewy:reset`.
 
+#### `chewy:create_missing_indexes`
+
+This rake task creates newly defined indexes in ElasticSearch and skips existing ones. Useful for production-like environments.
+
 #### Parallelizing rake tasks
 
 Every task described above has its own parallel version. Every parallel rake task takes the number for processes for execution as the first argument and the rest of the arguments are exactly the same as for the non-parallel task version.
@@ -1115,9 +1235,29 @@ rake chewy:journal:apply["$(date -v-1H -u +%FT%TZ)"] # apply journaled changes f
 rake chewy:journal:apply["$(date -v-1H -u +%FT%TZ)",users] # apply journaled changes for the past hour on UsersIndex only
 ```
 
+When the size of the journal becomes very large, the classical way of deletion would be obstructive and resource consuming. Fortunately, Chewy internally uses [delete-by-query](https://www.elastic.co/guide/en/elasticsearch/reference/7.17/docs-delete-by-query.html#docs-delete-by-query-task-api) ES function which supports async execution with batching and [throttling](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-delete-by-query.html#docs-delete-by-query-throttle).
+
+The available options, which can be set by ENV variables, are listed below:
+* `WAIT_FOR_COMPLETION` - a boolean flag. It controls async execution. It waits by default. When set to `false` (`0`, `f`, `false` or `off` in any case spelling is accepted as `false`), Elasticsearch performs some preflight checks, launches the request, and returns a task reference you can use to cancel the task or get its status.
+* `REQUESTS_PER_SECOND` - float. The throttle for this request in sub-requests per second. No throttling is enforced by default.
+* `SCROLL_SIZE` - integer. The number of documents to be deleted in single sub-request. The default batch size is 1000.
+
+```bash
+rake chewy:journal:clean WAIT_FOR_COMPLETION=false REQUESTS_PER_SECOND=10 SCROLL_SIZE=5000
+```
+
 ### RSpec integration
 
-Just add `require 'chewy/rspec'` to your spec_helper.rb and you will get additional features: See [update_index.rb](lib/chewy/rspec/update_index.rb) for more details.
+Just add `require 'chewy/rspec'` to your spec_helper.rb and you will get additional features:
+
+[update_index](lib/chewy/rspec/update_index.rb) helper
+`mock_elasticsearch_response` helper to mock elasticsearch response
+`mock_elasticsearch_response_sources` helper to mock elasticsearch response sources
+`build_query` matcher to compare request and expected query (returns `true`/`false`)
+
+To use `mock_elasticsearch_response` and `mock_elasticsearch_response_sources` helpers add `include Chewy::Rspec::Helpers` to your tests.
+
+See [chewy/rspec/](lib/chewy/rspec/) for more details.
 
 ### Minitest integration
 
@@ -1127,6 +1267,14 @@ Since you can set `:bypass` strategy for test suites and manually handle import
 
 But if you require chewy to index/update model regularly in your test suite then you can specify `:urgent` strategy for documents indexing. Add `Chewy.strategy(:urgent)` to test_helper.rb.
 
+Also, you can use additional helpers:
+
+`mock_elasticsearch_response` to mock elasticsearch response
+`mock_elasticsearch_response_sources` to mock elasticsearch response sources
+`assert_elasticsearch_query` to compare request and expected query (returns `true`/`false`)
+
+See [chewy/minitest/](lib/chewy/minitest/) for more details.
+
 ### DatabaseCleaner
 
 If you use `DatabaseCleaner` in your tests with [the `transaction` strategy](https://github.com/DatabaseCleaner/database_cleaner#how-to-use), you may run into the problem that `ActiveRecord`'s models are not indexed automatically on save despite the fact that you set the callbacks to do this with the `update_index` method. The issue arises because `chewy` indices data on `after_commit` run as default, but all `after_commit` callbacks are not run with the `DatabaseCleaner`'s' `transaction` strategy. You can solve this issue by changing the `Chewy.use_after_commit_callbacks` option. Just add the following initializer in your Rails application:
@@ -1136,6 +1284,41 @@ If you use `DatabaseCleaner` in your tests with [the `transaction` strategy](htt
 Chewy.use_after_commit_callbacks = !Rails.env.test?
 ```
 
+### Pre-request Filter
+
+Should you need to inspect the query prior to it being dispatched to ElasticSearch during any queries, you can use the `before_es_request_filter`. `before_es_request_filter` is a callable object, as demonstrated below:
+
+```ruby
+Chewy.before_es_request_filter = -> (method_name, args, kw_args) { ... }
+```
+
+While using the `before_es_request_filter`, please consider the following:
+
+* `before_es_request_filter` acts as a simple proxy before any request made via the    `ElasticSearch::Client`. The arguments passed to this filter include:
+  * `method_name` -  The name of the method being called. Examples are search, count, bulk and etc.
+  * `args` and `kw_args` - These are the positional arguments provided in the method call.
+* The operation is synchronous, so avoid executing any heavy or time-consuming operations within the filter to prevent performance degradation.
+* The return value of the proc is disregarded. This filter is intended for inspection or modification of the query rather than generating a response.
+* Any exception raised inside the callback will propagate upward and halt the execution of the query. It is essential to handle potential errors adequately to ensure the stability of your search functionality.
+
+### Import scope clean-up behavior
+
+Whenever you set the `import_scope` for the index, in the case of ActiveRecord,
+options for order, offset and limit will be removed. You can set the behavior of
+chewy, before the clean-up itself.
+
+The default behavior is a warning sent to the Chewy logger (`:warn`). Another more
+restrictive option is raising an exception (`:raise`). Both options have a
+negative impact on performance since verifying whether the code uses any of
+these options requires building AREL query.
+
+To avoid the loading time impact, you can ignore the check (`:ignore`) before
+the clean-up.
+
+```
+Chewy.import_scope_cleanup_behavior = :ignore
+```
+
 ## Contributing
 
 1. Fork it (http://github.com/toptal/chewy/fork)

data/chewy.gemspec

@@ -2,7 +2,7 @@ lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'chewy/version'
 
-Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
+Gem::Specification.new do |spec|
   spec.name          = 'chewy'
   spec.version       = Chewy::VERSION
   spec.authors       = ['Toptal, LLC', 'pyromaniac']
@@ -14,24 +14,10 @@ Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
 
   spec.files         = `git ls-files`.split($RS)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'database_cleaner'
-  spec.add_development_dependency 'elasticsearch-extensions'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec', '>= 3.7.0'
-  spec.add_development_dependency 'rspec-collection_matchers'
-  spec.add_development_dependency 'rspec-its'
-  spec.add_development_dependency 'rubocop', '1.11'
-  spec.add_development_dependency 'sqlite3'
-  spec.add_development_dependency 'timecop'
-
-  spec.add_development_dependency 'method_source'
-  spec.add_development_dependency 'unparser'
-
-  spec.add_dependency 'activesupport', '>= 5.2'
-  spec.add_dependency 'elasticsearch', '>= 6.3.0'
+  spec.add_dependency 'activesupport', '>= 5.2' # Remove with major version bump, 8.x
+  spec.add_dependency 'elasticsearch', '>= 7.14.0', '< 8'
   spec.add_dependency 'elasticsearch-dsl'
-  spec.add_dependency 'ruby-progressbar'
+  spec.metadata['rubygems_mfa_required'] = 'true'
 end

data/gemfiles/base.gemfile

@@ -0,0 +1,12 @@
+gem 'database_cleaner'
+gem 'elasticsearch-extensions'
+gem 'method_source'
+gem 'rake'
+gem 'redis', require: false
+gem 'rspec', '>= 3.7.0'
+gem 'rspec-collection_matchers'
+gem 'rspec-its'
+gem 'rubocop', '1.63.4'
+gem 'sqlite3', '~> 1.4'
+gem 'timecop'
+gem 'unparser'

data/gemfiles/rails.6.1.activerecord.gemfile

@@ -8,6 +8,7 @@ gem 'parallel', require: false
 gem 'rspec_junit_formatter', '~> 0.4.1'
 gem 'sidekiq', require: false
 
-gem 'rexml' if RUBY_VERSION >= '3.0.0'
+gem 'rexml'
 
 gemspec path: '../'
+eval_gemfile 'base.gemfile'

data/gemfiles/{rails.5.2.activerecord.gemfile → rails.7.0.activerecord.gemfile}

@@ -1,11 +1,14 @@
 source 'https://rubygems.org'
 
-gem 'activejob', '~> 5.2.0'
-gem 'activerecord', '~> 5.2.0'
-gem 'activesupport', '~> 5.2.0'
+gem 'activejob', '~> 7.0.0'
+gem 'activerecord', '~> 7.0.0'
+gem 'activesupport', '~> 7.0.0'
 gem 'kaminari-core', '~> 1.1.0', require: false
 gem 'parallel', require: false
 gem 'rspec_junit_formatter', '~> 0.4.1'
 gem 'sidekiq', require: false
 
+gem 'rexml'
+
 gemspec path: '../'
+eval_gemfile 'base.gemfile'

data/gemfiles/{rails.6.0.activerecord.gemfile → rails.7.1.activerecord.gemfile}

@@ -1,11 +1,14 @@
 source 'https://rubygems.org'
 
-gem 'activejob', '~> 6.0.0'
-gem 'activerecord', '~> 6.0.0'
-gem 'activesupport', '~> 6.0.0'
+gem 'activejob', '~> 7.1.0'
+gem 'activerecord', '~> 7.1.0'
+gem 'activesupport', '~> 7.1.0'
 gem 'kaminari-core', '~> 1.1.0', require: false
 gem 'parallel', require: false
 gem 'rspec_junit_formatter', '~> 0.4.1'
 gem 'sidekiq', require: false
 
+gem 'rexml'
+
 gemspec path: '../'
+eval_gemfile 'base.gemfile'

data/lib/chewy/config.rb

@@ -32,13 +32,18 @@ module Chewy
                   # Set number_of_replicas to 0 before reset and put the original value after
                   # https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-update-settings.html
                   :reset_no_replicas,
-                  # Refresh or not when import async (sidekiq, activejob)
+                  # Refresh or not when import async (sidekiq, lazy_sidekiq, activejob)
                   :disable_refresh_async,
                   # Default options for root of Chewy type. Allows to set default options
                   # for type mappings like `_all`.
                   :default_root_options,
                   # Default field type for any field in any Chewy type. Defaults to 'text'.
-                  :default_field_type
+                  :default_field_type,
+                  # Callback called on each search request to be done into ES
+                  :before_es_request_filter,
+                  # Behavior when import scope for index includes order, offset or limit.
+                  # Can be :ignore, :warn, :raise. Defaults to :warn
+                  :import_scope_cleanup_behavior
 
     attr_reader :transport_logger, :transport_tracer,
                 # Chewy search request DSL base class, used by every index.
@@ -60,16 +65,17 @@ module Chewy
       @indices_path = 'app/chewy'
       @default_root_options = {}
       @default_field_type = 'text'.freeze
+      @import_scope_cleanup_behavior = :warn
       @search_class = build_search_class(Chewy::Search::Request)
     end
 
     def transport_logger=(logger)
-      Chewy.client.transport.logger = logger
+      Chewy.client.transport.transport.logger = logger
       @transport_logger = logger
     end
 
     def transport_tracer=(tracer)
-      Chewy.client.transport.tracer = tracer
+      Chewy.client.transport.transport.tracer = tracer
       @transport_tracer = tracer
     end
 
@@ -127,17 +133,19 @@ module Chewy
   private
 
     def yaml_settings
-      @yaml_settings ||= begin
-        if defined?(Rails::VERSION)
-          file = Rails.root.join('config', 'chewy.yml')
+      @yaml_settings ||= build_yaml_settings || {}
+    end
 
-          if File.exist?(file)
-            yaml = ERB.new(File.read(file)).result
-            hash = YAML.load(yaml) # rubocop:disable Security/YAMLLoad
-            hash[Rails.env].try(:deep_symbolize_keys) if hash
-          end
-        end || {}
-      end
+    def build_yaml_settings
+      return unless defined?(Rails::VERSION)
+
+      file = Rails.root.join('config', 'chewy.yml')
+
+      return unless File.exist?(file)
+
+      yaml = ERB.new(File.read(file)).result
+      hash = YAML.unsafe_load(yaml)
+      hash[Rails.env].try(:deep_symbolize_keys) if hash
     end
 
     def build_search_class(base)

data/lib/chewy/elastic_client.rb

@@ -0,0 +1,31 @@
+module Chewy
+  # Replacement for Chewy.client
+  class ElasticClient
+    def self.build_es_client(configuration = Chewy.configuration)
+      client_configuration = configuration.deep_dup
+      client_configuration.delete(:prefix) # used by Chewy, not relevant to Elasticsearch::Client
+      block = client_configuration[:transport_options].try(:delete, :proc)
+      ::Elasticsearch::Client.new(client_configuration, &block)
+    end
+
+    def initialize(elastic_client = self.class.build_es_client)
+      @elastic_client = elastic_client
+    end
+
+  private
+
+    def method_missing(name, *args, **kwargs, &block)
+      inspect_payload(name, args, kwargs)
+
+      @elastic_client.__send__(name, *args, **kwargs, &block)
+    end
+
+    def respond_to_missing?(name, _include_private = false)
+      @elastic_client.respond_to?(name) || super
+    end
+
+    def inspect_payload(name, args, kwargs)
+      Chewy.config.before_es_request_filter&.call(name, args, kwargs)
+    end
+  end
+end

data/lib/chewy/errors.rb

@@ -7,7 +7,7 @@ module Chewy
 
   class UndefinedUpdateStrategy < Error
     def initialize(_type)
-      super <<-MESSAGE
+      super(<<-MESSAGE)
   Index update strategy is undefined for current context.
   Please wrap your code with `Chewy.strategy(:strategy_name) block.`
       MESSAGE
@@ -27,7 +27,16 @@ module Chewy
           message << "        on #{documents.count} documents: #{documents}\n"
         end
       end
-      super message
+      super(message)
     end
   end
+
+  class InvalidJoinFieldType < Error
+    def initialize(join_field_type, join_field_name, relations)
+      super("`#{join_field_type}` set for the join field `#{join_field_name}` is not on the :relations list (#{relations})")
+    end
+  end
+
+  class ImportScopeCleanupError < Error
+  end
 end