chewy 8.0.1 → 8.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36ec23aabab2b6b62d9425ad6505f5589958400f21411c90d9808113336aac35
-  data.tar.gz: 0b082e6327fa4092477c7888714662f791a940b9a1045047ce7a183d41656f2c
+  metadata.gz: 4797e925ff275cb6b742ef6dd7be3a03d6033f73c93453305d08383c11252c00
+  data.tar.gz: 46b165cfeda3df1558221bc668a7749b1c98ec8a937e4956f710dfbe93934cb1
 SHA512:
-  metadata.gz: ad839b902eeb12a5f94547e21f0ed9b2d078be1869b0070be7698fd357edde8d6d759502301dd823eb53d8a3fa42bd6d5584cee53dd482df6c05d1b46e2d110a
-  data.tar.gz: 3fdef90ea2c73f41274556d5f001e7931bcbbb9b2bdd02df6204fbd75c5b8139ed2cbff00cd448922e8215d2f35f6f3695bd52505db2f30cd20968b54732c401
+  metadata.gz: 6451084c18ae23ee908f0ba6c00cffa2cc5abcec29ecc4c911f7e8340081f4b0b89c66d91f2c9dda988c412bcd5a995705ff219d00147c4d52209749f375ff84
+  data.tar.gz: b2dd7dda7bae223e450165ff35be42ea814b57d8f06cd0546970a0aed3bed113f290ccc233724248a0cdce3af7b9ef8ac60d2e0e155b1dc6f19376375ccb1990

data/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## master (unreleased)
+
+### New Features
+
+### Bug Fixes
+
+### Changes
+
+## 8.2.0 (2026-05-29)
+
+### New Features
+
+* Add `progressbar:` option to `import`/`import!` and a `PROGRESS=1` rake env toggle for `chewy:reset` / `chewy:update`. The bar is opt-in (default `false`), supports a `:unbounded` spinner mode that skips the `import_count` query, and is safe in parallel mode — workers stay process-based, the bar is incremented in the parent via `Parallel`'s `finish:` callback. Reintroduces the feature originally added in [#787](https://github.com/toptal/chewy/pull/787) and reverted in [#800](https://github.com/toptal/chewy/pull/800) without the GVL regression.
+
+### Bug Fixes
+
+* Fix race condition during `reset!` where the unsuffixed concrete index could be recreated by a concurrent process between the delete and the alias creation, causing the alias creation to fail with an index/alias name collision.
+  The delete + alias-add are now performed in a single atomic `_aliases` cluster state update via the `remove_index` action.
+  No public API or layout change.
+* [#992](https://github.com/toptal/chewy/issues/992): `import(update_fields: [])` is now a no-op (zero fields to update) instead of triggering a full document reindex. The default of `update_fields` is now `nil` (still performs a full reindex). Behavior change: any caller passing an explicit empty array previously got a silent full reimport; they will now skip the update.
+
+### Changes
+
+* [#1024](https://github.com/toptal/chewy/pull/1024): Replace deprecated `ZRANGEBYSCORE` with `ZRANGE ... BYSCORE` in the `delayed_sidekiq` worker Lua script. `ZRANGEBYSCORE` has been deprecated in Redis since 6.2.0.
+
+## 8.1.0 (2026-05-28)
+
+### New Features
+
+* [#887](https://github.com/toptal/chewy/pull/887): Add support [runtime_mappings](https://www.elastic.co/guide/en/elasticsearch/reference/current/runtime-search-request.html). ([@TakuyaKurimoto](https://github.com/TakuyaKurimoto))
+* [#996](https://github.com/toptal/chewy/pull/996): Add `context:` option to `import`/`import!` for passing custom data to crutch blocks and field value procs without redundant DB queries.
+
+### Bug Fixes
+
+* [#878](https://github.com/toptal/chewy/issues/878): Flatten `Chewy::Stash::Journal.for` to use a single `terms` filter instead of a chain of `bool.should` clauses. Fixes Elasticsearch `indices.query.bool.max_nested_depth` errors when applying or cleaning the journal across many indices.
+
+### Changes
+
+* [#916](https://github.com/toptal/chewy/pull/916): Raise error in #scroll_batches when search backend returns a failure. ([@tomdev][])
+* [#1008](https://github.com/toptal/chewy/pull/1008): Promote Elasticsearch to a native GitHub Actions service with a health-check gate, replacing the fragile `docker compose` + `sleep 15` approach. ([@mattmenefee][])
+* [#1010](https://github.com/toptal/chewy/pull/1010): Add Chewy 7/ES 7 to Chewy 8/ES 8 migration guide and fix stale `Elasticsearch::Transport` namespace references in docs. ([@mattmenefee][])
+* [#1011](https://github.com/toptal/chewy/pull/1011): Replace deprecated `Sidekiq::Testing` API with new `Sidekiq 8.1+` testing API and silence Sidekiq logger during spec runs. ([@mattmenefee][], [@mjankowski][])
+* [#1013](https://github.com/toptal/chewy/pull/1013): Fix `drop_indices` test helper to use `format: 'json'` for ES version portability. If you define a custom `drop_indices` helper in your test suite, update it to use `Chewy.client.cat.indices(format: 'json')` instead of parsing the text-format response. ([@mattmenefee][])
+* [#1014](https://github.com/toptal/chewy/pull/1014): Improve contributing documentation with development setup instructions, PR workflow, and grammar fixes. ([@mattmenefee][])
+
 ## 8.0.1 (2026-03-12)
 
 ### New Features
@@ -874,10 +919,12 @@
 [@marshall]: https://github.com/marshall
 [@matchbookmac]: https://github.com/matchbookmac
 [@matthee]: https://github.com/matthee
+[@mattmenefee]: https://github.com/mattmenefee
 [@mattzollinhofer]: https://github.com/mattzollinhofer
 [@menglewis]: https://github.com/menglewis
 [@mikeyhogarth]: https://github.com/mikeyhogarth
 [@milk1000cc]: https://github.com/milk1000cc
+[@mjankowski]: https://github.com/mjankowski
 [@mkcode]: https://github.com/mkcode
 [@mpeychich]: https://github.com/mpeychich
 [@mrbrdo]: https://github.com/mrbrdo
@@ -901,6 +948,7 @@
 [@socialchorus]: https://github.com/socialchorus
 [@taylor-au]: https://github.com/taylor-au
 [@TikiTDO]: https://github.com/TikiTDO
+[@tomdev]: https://github.com/tomdev
 [@undr]: https://github.com/undr
 [@Vitalina-Vakulchyk]: https://github.com/Vitalina-Vakulchyk
 [@webgago]: https://github.com/webgago

data/README.md

@@ -1,7 +1,5 @@
 [![Gem Version](https://badge.fury.io/rb/chewy.svg)](http://badge.fury.io/rb/chewy)
 [![GitHub Actions](https://github.com/toptal/chewy/actions/workflows/ruby.yml/badge.svg)](https://github.com/toptal/chewy/actions/workflows/ruby.yml)
-[![Code Climate](https://codeclimate.com/github/toptal/chewy.svg)](https://codeclimate.com/github/toptal/chewy)
-[![Inline docs](http://inch-ci.org/github/toptal/chewy.svg?branch=master)](http://inch-ci.org/github/toptal/chewy)
 
 # Chewy
 
@@ -47,7 +45,7 @@ Chewy aims to support all Ruby and Rails versions that are currently maintained
 
 ### Ruby
 
-Chewy is compatible with MRI 3.2-3.4.
+Chewy is compatible with MRI 3.2-4.0.
 
 ### Elasticsearch compatibility matrix
 
@@ -274,19 +272,7 @@ Use the standard client settings with your Cloud credentials (API key or user/pa
 
 ## Contributing
 
-1. Fork it (http://github.com/toptal/chewy/fork)
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Implement your changes, cover it with specs and make sure old specs are passing
-4. Commit your changes (`git commit -am 'Add some feature'`)
-5. Push to the branch (`git push origin my-new-feature`)
-6. Create new Pull Request
-
-Use the following Rake tasks to control the Elasticsearch cluster while developing, if you prefer native Elasticsearch installation over the dockerized one:
-
-```bash
-rake elasticsearch:start # start Elasticsearch cluster on 9250 port for tests
-rake elasticsearch:stop # stop Elasticsearch
-```
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup instructions, how to run tests, and the pull request workflow.
 
 ## Copyright
 

data/lib/chewy/errors.rb

@@ -37,6 +37,9 @@ module Chewy
     end
   end
 
+  class MissingHitsInScrollError < Error
+  end
+
   class ImportScopeCleanupError < Error
   end
 

data/lib/chewy/fields/root.rb

@@ -61,8 +61,8 @@ module Chewy
       # @param fields [Array<Symbol>] a list of fields to compose, every field will be composed if empty
       # @return [Hash] JSON-ready hash with stringified keys
       #
-      def compose(object, crutches = nil, fields: [])
-        result = evaluate([object, crutches])
+      def compose(object, crutches = nil, fields: [], context: {})
+        result = evaluate([object, crutches, context])
 
         if children.present?
           child_fields = if fields.present?
@@ -72,7 +72,7 @@ module Chewy
           end
 
           child_fields.each_with_object({}) do |field, memo|
-            memo.merge!(field.compose(result, crutches) || {})
+            memo.merge!(field.compose(result, crutches, context) || {})
           end.as_json
         elsif fields.present?
           result.as_json(only: fields, root: false)

data/lib/chewy/index/actions.rb

@@ -7,12 +7,13 @@ module Chewy
       extend ActiveSupport::Concern
 
       module ClassMethods
-        # Checks index existance. Returns true or false
+        # Checks index existance. Supports suffixes. Returns true or false
         #
         #   UsersIndex.exists? #=> true
+        #   UsersIndex.exists?('11-2024') #=> false
         #
-        def exists?
-          client.indices.exists(index: index_name)
+        def exists?(suffix = nil)
+          client.indices.exists(index: index_name(suffix: suffix))
         end
 
         # Creates index and applies mappings and settings.
@@ -163,16 +164,17 @@ module Chewy
             ))
             original_index_settings suffixed_name
 
-            delete if indexes.blank?
-            client.indices.update_aliases body: {actions: [
-              *indexes.map do |index|
-                {remove: {index: index, alias: general_name}}
-              end,
-              {add: {index: suffixed_name, alias: general_name}}
-            ]}
+            actions = indexes.map { |index| {remove: {index: index, alias: general_name}} }
+            actions << {add: {index: suffixed_name, alias: general_name}}
+            if indexes.blank? && exists?
+              index_names = client.indices.get_alias(index: general_name).keys
+              actions << {remove_index: {index: index_names.join(',')}}
+            end
+
+            client.indices.update_aliases body: {actions: actions}
             client.indices.delete index: indexes if indexes.present?
 
-            self.journal.apply(start_time, **import_options) if apply_journal
+            self.journal.apply(start_time, **import_options.except(:progressbar)) if apply_journal
             result
           else
             purge!

data/lib/chewy/index/adapter/object.rb

@@ -146,6 +146,23 @@ module Chewy
           collection.each_slice(options[:batch_size], &block)
         end
 
+        # Returns the count of objects that would be imported. Used by the
+        # progressbar feature to set the total. Mirrors {#import_args} input
+        # handling but does not enumerate batches.
+        #
+        # @return [Integer]
+        def import_count(*args)
+          args = args.dup
+          args.extract_options!
+          collection = if args.empty? && @target.respond_to?(import_all_method)
+            @target.send(import_all_method)
+          else
+            args.flatten(1).compact
+          end
+
+          collection.count
+        end
+
         # This method is used internally by the request DSL when the
         # collection of ORM/ODM objects is requested.
         #

data/lib/chewy/index/adapter/orm.rb

@@ -96,6 +96,26 @@ module Chewy
         end
         alias_method :import_references, :import_fields
 
+        # Returns the count of records that would be imported. Used by the
+        # progressbar feature to set the total. Accepts the same shapes as
+        # {#import}: nothing (uses default scope), a relation, or an array
+        # of ids/objects.
+        #
+        # @return [Integer]
+        def import_count(*args)
+          args = args.dup
+          args.extract_options!
+          collection = if args.empty?
+            default_scope
+          elsif args.first.is_a?(relation_class)
+            args.first
+          else
+            args.flatten.compact
+          end
+
+          collection.count
+        end
+
         def load(ids, **options)
           scope = all_scope_where_ids_in(ids)
           additional_scope = options[options[:_index].to_sym].try(:[], :scope) || options[:scope]

data/lib/chewy/index/crutch.rb

@@ -9,9 +9,12 @@ module Chewy
       end
 
       class Crutches
-        def initialize(index, collection)
+        attr_reader :context
+
+        def initialize(index, collection, context = {})
           @index = index
           @collection = collection
+          @context = context
           @crutches_instances = {}
         end
 
@@ -26,7 +29,14 @@ module Chewy
         end
 
         def [](name)
-          @crutches_instances[name] ||= @index._crutches[:"#{name}"].call(@collection)
+          @crutches_instances[name] ||= begin
+            block = @index._crutches[:"#{name}"]
+            if block.arity > 1 || block.arity < -1
+              block.call(@collection, @context)
+            else
+              block.call(@collection)
+            end
+          end
         end
       end
 

data/lib/chewy/index/import/bulk_builder.rb

@@ -13,11 +13,12 @@ module Chewy
         # @param to_index [Array<Object>] objects to index
         # @param delete [Array<Object>] objects or ids to delete
         # @param fields [Array<Symbol, String>] and array of fields for documents update
-        def initialize(index, to_index: [], delete: [], fields: [])
+        def initialize(index, to_index: [], delete: [], fields: nil, context: {})
           @index = index
           @to_index = to_index
           @delete = delete
-          @fields = fields.map!(&:to_sym)
+          @fields = fields&.map(&:to_sym)
+          @context = context
         end
 
         # Returns ES API-ready bulk requiest body.
@@ -42,10 +43,12 @@ module Chewy
       private
 
         def crutches_for_index
-          @crutches_for_index ||= Chewy::Index::Crutch::Crutches.new @index, @to_index
+          @crutches_for_index ||= Chewy::Index::Crutch::Crutches.new @index, @to_index, @context
         end
 
         def index_entry(object)
+          return [] if @fields&.empty?
+
           entry = {}
           entry[:_id] = index_object_ids[object] if index_object_ids[object]
           entry[:routing] = routing(object) if join_field?
@@ -257,13 +260,13 @@ module Chewy
         end
 
         def data_for(object, fields: [], crutches: crutches_for_index)
-          @index.compose(object, crutches, fields: fields)
+          @index.compose(object, crutches, fields: fields, context: @context)
         end
 
         def parent_changed?(data, old_parent)
           return false unless old_parent
           return false unless join_field?
-          return false unless @fields.include?(join_field.to_sym)
+          return false unless @fields&.include?(join_field.to_sym)
           return false unless data.key?(join_field)
 
           # The join field value can be a hash, e.g.:

data/lib/chewy/index/import/progressbar.rb

@@ -0,0 +1,79 @@
+module Chewy
+  class Index
+    module Import
+      # Thin wrapper around `ruby-progressbar` for import feedback.
+      #
+      # Unlike the original PR #787 implementation, this wrapper is only
+      # touched from the parent process: serial imports increment it directly,
+      # and parallel imports increment it via `Parallel`'s `finish:` callback
+      # (which runs in the parent under an internal mutex). The workers stay
+      # process-based, so there is no GVL contention as in PR #787 / #800.
+      #
+      # `Progressbar.build` returns a NULL object when the feature is disabled,
+      # so call sites do not need feature guards.
+      class Progressbar
+        NULL = Object.new
+        class << NULL
+          def increment(_); end
+          def total=(_); end
+          def finish; end
+        end
+
+        BOUNDED_FORMAT = '%t |%B| %p%% %c/%C %e'.freeze
+        UNBOUNDED_FORMAT = '%t %c (%a)'.freeze
+        TITLE = 'Importing'.freeze
+
+        # @param enabled [Boolean, :unbounded] feature flag. `:unbounded` shows
+        #   a spinner with no total (skip `import_count`).
+        # @param total [Integer, nil] expected total; ignored when `:unbounded`.
+        # @return [Progressbar, NULL]
+        def self.build(enabled, total)
+          return NULL unless enabled
+
+          unless '::ProgressBar'.safe_constantize
+            raise 'The `ruby-progressbar` gem is required for import progress, ' \
+                  "please add `gem 'ruby-progressbar'` to your Gemfile"
+          end
+
+          return new if enabled == :unbounded
+
+          new(normalize_total(total))
+        end
+
+        # Some ActiveRecord scopes (e.g., `.group(...)`) make `.count` return a
+        # Hash rather than an Integer. Coerce so we still get a usable total.
+        def self.normalize_total(total)
+          case total
+          when Hash then total.values.sum
+          when Integer then total
+          end
+        end
+
+        attr_reader :bar
+
+        def initialize(total = nil)
+          format = total ? BOUNDED_FORMAT : UNBOUNDED_FORMAT
+          @bar = ::ProgressBar.create(title: TITLE, total: total, format: format)
+        end
+
+        # Clamps to total when bounded — action_objects may include :delete
+        # entries (parent-child re-indexing, delete_if scope) that aren't
+        # counted by `adapter.import_count`, which would otherwise raise
+        # ProgressBar::InvalidProgressError.
+        def increment(by)
+          target = bar.progress + by
+          target = [bar.total, target].min if bar.total
+          bar.progress = target
+        end
+
+        def total=(value)
+          bar.total = value
+        end
+
+        def finish
+          bar.finish unless bar.finished?
+        end
+      end
+    end
+  end
+end

data/lib/chewy/index/import/routine.rb

@@ -31,7 +31,7 @@ module Chewy
 
         DEFAULT_OPTIONS = {
           refresh: true,
-          update_fields: [],
+          update_fields: nil,
           update_failover: true,
           batch_size: Chewy::Index::Adapter::Base::BATCH_SIZE
         }.freeze
@@ -56,6 +56,7 @@ module Chewy
               {}
             end
           end
+          @context = @options[:context] || {}
           @errors = []
           @stats = {}
           @leftovers = []
@@ -78,7 +79,7 @@ module Chewy
         # @param delete [Array<Object>] any acceptable objects for deleting
         # @return [true, false] the result of the request, true if no errors
         def process(index: [], delete: [])
-          bulk_builder = BulkBuilder.new(@index, to_index: index, delete: delete, fields: @options[:update_fields])
+          bulk_builder = BulkBuilder.new(@index, to_index: index, delete: delete, fields: @options[:update_fields], context: @context)
           bulk_body = bulk_builder.bulk_body
 
           if @options[:journal]

data/lib/chewy/index/import.rb

@@ -2,6 +2,7 @@ require 'chewy/index/import/journal_builder'
 require 'chewy/index/import/bulk_builder'
 require 'chewy/index/import/bulk_request'
 require 'chewy/index/import/routine'
+require 'chewy/index/import/progressbar'
 
 module Chewy
   class Index
@@ -11,20 +12,22 @@ module Chewy
       IMPORT_WORKER = lambda do |index, options, total, ids, iteration|
         ::Process.setproctitle("chewy [#{index}]: import data (#{iteration + 1}/#{total})")
         routine = Routine.new(index, **options)
+        processed = 0
         index.adapter.import(*ids, routine.options) do |action_objects|
           routine.process(**action_objects)
+          processed += action_objects.sum { |_, v| v.size }
         end
-        {errors: routine.errors, import: routine.stats, leftovers: routine.leftovers}
+        {errors: routine.errors, import: routine.stats, leftovers: routine.leftovers, processed: processed}
       end
 
       LEFTOVERS_WORKER = lambda do |index, options, total, body, iteration|
         ::Process.setproctitle("chewy [#{index}]: import leftovers (#{iteration + 1}/#{total})")
         routine = Routine.new(index, **options)
         routine.perform_bulk(body)
-        routine.errors
+        {errors: routine.errors}
       end
 
-      module ClassMethods
+      module ClassMethods # rubocop:disable Metrics/ModuleLength
         # @!method import(*collection, **options)
         # Basically, one of the main methods for an index. Performs any objects import
         # to the index. Does all the objects handling routines.
@@ -68,9 +71,15 @@ module Chewy
         # @option options [Integer] batch_size passed to the adapter import method, used to split imported objects in chunks, 1000 by default
         # @option options [Boolean] direct_import skips object reloading in ORM adapter, `false` by default
         # @option options [true, false] journal enables imported objects journaling, false by default
-        # @option options [Array<Symbol, String>] update_fields list of fields for the partial import, empty by default
+        # @option options [Array<Symbol, String>] update_fields list of fields for partial import. `nil` (default) triggers full document reindex;
+        #   an empty array (`[]`) is an explicit no-op (no fields updated).
         # @option options [true, false] update_failover enables full objects reimport in cases of partial update errors, `true` by default
         # @option options [true, Integer, Hash] parallel enables parallel import processing with the Parallel gem, accepts the number of workers or any Parallel gem acceptable options
+        # @option options [true, false, :unbounded] progressbar shows an import progressbar
+        #   on stderr. `true` precomputes the total via `adapter.import_count` (one extra
+        #   count query); `:unbounded` shows a spinner without computing the total. Default
+        #   `false`. Safe in parallel mode: the bar is incremented in the parent process via
+        #   `Parallel`'s `finish:` callback, workers stay process-based.
         # @return [true, false] false in case of errors
         def import(*args)
           intercept_import_using_strategy(*args).blank?
@@ -115,13 +124,13 @@ module Chewy
         # @param crutches [Object] optional crutches object; if omitted - a crutch for the single passed object is created as a fallback
         # @param fields [Array<Symbol>] and array of fields to restrict the generated document
         # @return [Hash] a JSON-ready hash
-        def compose(object, crutches = nil, fields: [])
-          crutches ||= Chewy::Index::Crutch::Crutches.new self, [object]
+        def compose(object, crutches = nil, fields: [], context: {})
+          crutches ||= Chewy::Index::Crutch::Crutches.new self, [object], context
 
           if witchcraft? && root.children.present?
-            cauldron(fields: fields).brew(object, crutches)
+            cauldron(fields: fields).brew(object, crutches, context)
           else
-            root.compose(object, crutches, fields: fields)
+            root.compose(object, crutches, fields: fields, context: context)
           end
         end
 
@@ -175,46 +184,91 @@ module Chewy
         end
 
         def import_linear(objects, routine)
+          bar = build_progressbar(routine, objects)
           ActiveSupport::Notifications.instrument 'import_objects.chewy', index: self do |payload|
             adapter.import(*objects, routine.options) do |action_objects|
               routine.process(**action_objects)
+              bar.increment(action_objects.sum { |_, v| v.size })
             end
             routine.perform_bulk(routine.leftovers)
             payload[:import] = routine.stats
             payload[:errors] = payload_errors(routine.errors) if routine.errors.present?
             payload[:errors]
           end
+        ensure
+          bar&.finish
         end
 
         def import_parallel(objects, routine)
           raise "The `parallel` gem is required for parallel import, please add `gem 'parallel'` to your Gemfile" unless '::Parallel'.safe_constantize
 
+          bar = build_progressbar(routine, objects)
           ActiveSupport::Notifications.instrument 'import_objects.chewy', index: self do |payload|
             batches = adapter.import_references(*objects, routine.options.slice(:batch_size)).to_a
 
             ::ActiveRecord::Base.connection.close if defined?(::ActiveRecord::Base)
             results = ::Parallel.map_with_index(
               batches,
-              routine.parallel_options,
+              parallel_options_with_progress(routine.parallel_options, bar),
               &IMPORT_WORKER.curry[self, routine.options, batches.size]
             )
             ::ActiveRecord::Base.connection.reconnect! if defined?(::ActiveRecord::Base)
             errors, import, leftovers = process_parallel_import_results(results)
-
-            if leftovers.present?
-              batches = leftovers.each_slice(routine.options[:batch_size])
-              results = ::Parallel.map_with_index(
-                batches,
-                routine.parallel_options,
-                &LEFTOVERS_WORKER.curry[self, routine.options, batches.size]
-              )
-              errors.concat(results.flatten(1))
-            end
+            errors.concat(process_parallel_leftovers(leftovers, routine)) if leftovers.present?
 
             payload[:import] = import
             payload[:errors] = payload_errors(errors) if errors.present?
             payload[:errors]
           end
+        ensure
+          bar&.finish
+        end
+
+        def process_parallel_leftovers(leftovers, routine)
+          batches = leftovers.each_slice(routine.options[:batch_size]).to_a
+          results = ::Parallel.map_with_index(
+            batches,
+            routine.parallel_options,
+            &LEFTOVERS_WORKER.curry[self, routine.options, batches.size]
+          )
+          results.flat_map { |r| r[:errors] }
+        end
+
+        # Builds Parallel options with a `finish:` callback that increments the
+        # progressbar after each worker batch returns. The callback runs in the
+        # parent (main) thread under Parallel's internal mutex (parallel-1.x),
+        # so workers stay process-based and there is no worker-side
+        # synchronization — the regression that triggered the PR #800 revert.
+        #
+        # If the caller already supplied a `finish:` callback in
+        # `parallel_options`, both run; user callback first, then the bar.
+        def parallel_options_with_progress(parallel_options, bar)
+          user_finish = parallel_options[:finish]
+          progress = lambda do |item, i, result|
+            user_finish&.call(item, i, result)
+            bar.increment(result[:processed]) if result.is_a?(Hash) && result[:processed]
+          end
+          parallel_options.merge(finish: progress)
+        end
+
+        def build_progressbar(routine, objects)
+          enabled = routine.options[:progressbar]
+          total = enabled == true ? safe_import_count(objects) : nil
+          Progressbar.build(enabled, total)
+        end
+
+        # Returns nil when the adapter cannot or should not be counted:
+        # missing `import_count` on a custom adapter, a grouped scope that
+        # raises, or any unexpected count failure. A nil total makes
+        # `Progressbar.new` render a spinner instead of a bounded bar —
+        # avoids aborting the import just because the progressbar can't
+        # size itself.
+        def safe_import_count(objects)
+          return nil unless adapter.respond_to?(:import_count)
+
+          adapter.import_count(*objects)
+        rescue StandardError
+          nil
         end
 
         def process_parallel_import_results(results)

data/lib/chewy/index/witchcraft.rb

@@ -59,15 +59,15 @@ module Chewy
           @fields = fields
         end
 
-        def brew(object, crutches = nil)
-          alicorn.call(locals, object, crutches).as_json
+        def brew(object, crutches = nil, context = {})
+          alicorn.call(locals, object, crutches, context).as_json
         end
 
       private
 
         def alicorn
           @alicorn ||= singleton_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            -> (locals, object0, crutches) do
+            -> (locals, object0, crutches, context) do
               #{composed_values(@index.root, 0)}
             end
           RUBY
@@ -171,7 +171,7 @@ module Chewy
           end
         end
 
-        def source_for(proc, nesting)
+        def source_for(proc, nesting) # rubocop:disable Metrics/AbcSize
           lambdas = exctract_lambdas(ast_from_proc(proc))
 
           raise "No lambdas found, try to reformat your code:\n`#{proc.source}`" unless lambdas
@@ -189,6 +189,7 @@ module Chewy
               source = replace_lvar(source, proc_params[n], :"object#{n}") if proc_params[n]
             end
             source = replace_lvar(source, proc_params[nesting + 1], :crutches) if proc_params[nesting + 1]
+            source = replace_lvar(source, proc_params[nesting + 2], :context) if proc_params[nesting + 2]
 
             binding_variable_list(source).each do |variable|
               locals.push(proc.binding.eval(variable.to_s))

data/lib/chewy/multi_search.rb

@@ -11,7 +11,7 @@ module Chewy
     # Instantiate a new MultiSearch instance.
     #
     # @param queries [Array<Chewy::Search::Request>]
-    # @option [Elasticsearch::Transport::Client] :client (Chewy.client)
+    # @option [Elasticsearch::Client] :client (Chewy.client)
     #   The Elasticsearch client that should be used for issuing requests.
     def initialize(queries, client: Chewy.client)
       @client = client

data/lib/chewy/rake_helper.rb

@@ -21,6 +21,8 @@ module Chewy
 
     DELETE_BY_QUERY_OPTIONS = %w[WAIT_FOR_COMPLETION REQUESTS_PER_SECOND SCROLL_SIZE].freeze
     FALSE_VALUES = %w[0 f false off].freeze
+    TRUE_VALUES = %w[1 t true on yes].freeze
+    UNBOUNDED_VALUES = %w[unbounded].freeze
 
     class << self
       # Performs zero-downtime reindexing of all documents for the specified indexes
@@ -105,7 +107,7 @@ module Chewy
           indexes_from(only: only, except: except).each_with_object([]) do |index, updated_indexes|
             if index.exists?
               output.puts "Updating #{index}"
-              index.import(parallel: parallel)
+              index.import(parallel: parallel, progressbar: progressbar_option)
               updated_indexes.push(index)
             else
               output.puts "Skipping #{index}, it does not exists (use rake chewy:reset[#{index.derivable_name}] to create and update it)"
@@ -336,7 +338,22 @@ module Chewy
 
       def reset_one(index, output, parallel: false)
         output.puts "Resetting #{index}"
-        index.reset!((Time.now.to_f * 1000).round, parallel: parallel, apply_journal: journal_exists?)
+        index.reset!((Time.now.to_f * 1000).round, parallel: parallel, apply_journal: journal_exists?, progressbar: progressbar_option)
+      end
+
+      def progressbar_option
+        value = ENV.fetch('PROGRESS', nil)
+        return false if value.nil? || value.empty?
+
+        case value.downcase
+        when *FALSE_VALUES then false
+        when *UNBOUNDED_VALUES then :unbounded
+        when *TRUE_VALUES then true
+        else
+          warn "PROGRESS=#{value.inspect} not recognized; treating as enabled. " \
+               "Use #{TRUE_VALUES.join('/')}, #{UNBOUNDED_VALUES.join('/')}, or #{FALSE_VALUES.join('/')}."
+          true
+        end
       end
 
       def warn_missing_index(output)

data/lib/chewy/search/parameters/runtime_mappings.rb

@@ -0,0 +1,14 @@
+module Chewy
+  module Search
+    class Parameters
+      # Just a standard hash storage. Nothing to see here.
+      #
+      # @see Chewy::Search::Parameters::HashStorage
+      # @see Chewy::Search::Request#runtime_mappings
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/runtime-search-request.html
+      class RuntimeMappings < Storage
+        include HashStorage
+      end
+    end
+  end
+end

data/lib/chewy/search/request.rb

@@ -25,7 +25,7 @@ module Chewy
         search_type preference limit offset terminate_after
         timeout min_score source stored_fields search_after
         load script_fields suggest aggs aggregations collapse none
-        indices_boost rescore highlight total total_count
+        indices_boost rescore highlight runtime_mappings total total_count
         total_entries indices types delete_all count exists?
         exist? find pluck scroll_batches scroll_hits
         scroll_results scroll_wrappers ignore_unavailable
@@ -656,7 +656,23 @@ module Chewy
       #   @see https://www.elastic.co/guide/en/elasticsearch/reference/current/highlighting.html
       #   @param value [Hash]
       #   @return [Chewy::Search::Request]
-      %i[script_fields indices_boost rescore highlight].each do |name|
+      #
+      # @!method runtime_mappings(value)
+      #   Add a `runtime_mappings` part to the request. Further
+      #   call values are merged to the storage hash.
+      #
+      #   @example
+      #     PlacesIndex
+      #       .runtime_mappings(field1: {type: "keyword", script: {lang: "painless", source: "emit('some script here')"}})
+      #       .runtime_mappings(field2: {type: "keyword", script: {lang: "painless", source: "emit('some script here')"}})
+      #     # => <PlacesIndex::Query {..., :body=>{:runtime_mappings=>{
+      #     #      "field1"=>{:type=>"keyword", :script=>{:lang=>"painless", :source=>"emit('some script here')"}},
+      #     #      "field2"=>{:type=>"keyword", :script=>{:lang=>"painless", :source=>"emit('some script here')"}}}}}>
+      #   @see Chewy::Search::Parameters::RuntimeMappings
+      #   @see https://www.elastic.co/guide/en/elasticsearch/reference/current/runtime-search-request.html
+      #   @param value [Hash]
+      #   @return [Chewy::Search::Request]
+      %i[script_fields indices_boost rescore highlight runtime_mappings].each do |name|
         define_method name do |value|
           modify(name) { update!(value) }
         end

data/lib/chewy/search/scrolling.rb

@@ -29,20 +29,28 @@ module Chewy
 
         result = perform(size: batch_size, scroll: scroll)
         total = [raw_limit_value, result.fetch('hits', {}).fetch('total', {}).fetch('value', 0)].compact.min
+
+        total_batches = total / batch_size
         last_batch_size = total % batch_size
-        fetched = 0
+
+        total_batches += 1 if last_batch_size != 0
+
         scroll_id = nil
 
-        loop do
+        total_batches.times do |batch_counter|
+          last_run = total_batches - 1 == batch_counter
+
           hits = result.fetch('hits', {}).fetch('hits', [])
-          fetched += hits.size
-          hits = hits.first(last_batch_size) if last_batch_size != 0 && fetched >= total
+          hits = hits.first(last_batch_size) if last_run && last_batch_size != 0
+
+          raise Chewy::MissingHitsInScrollError if hits.empty?
+
           yield(hits) if hits.present?
           scroll_id = result['_scroll_id']
 
-          break if result['terminated_early'] || fetched >= total
+          break if result['terminated_early']
 
-          result = perform_scroll(scroll: scroll, scroll_id: scroll_id)
+          result = perform_scroll(scroll: scroll, scroll_id: scroll_id) unless last_run
         end
       ensure
         Chewy.client.clear_scroll(body: {scroll_id: scroll_id}) if scroll_id

data/lib/chewy/stash.rb

@@ -38,17 +38,21 @@ module Chewy
 
       # Selects all the journal entries for the specified indices.
       #
+      # Uses a single `terms` filter rather than a chain of `bool.should`
+      # clauses so the query depth stays constant regardless of how many
+      # indices are passed. Avoids hitting the Elasticsearch
+      # `indices.query.bool.max_nested_depth` limit (default 30) when
+      # cleaning or applying journals across many indices.
+      #
       # @param indices [Chewy::Index, Array<Chewy::Index>]
       def self.for(*something)
         something = something.flatten.compact
+        return all if something.empty?
+
         indexes = something.flat_map { |s| Chewy.derive_name(s) }
-        return none if something.present? && indexes.blank?
+        return none if indexes.blank?
 
-        scope = all
-        indexes.each do |index|
-          scope = scope.or(filter(term: {index_name: index.derivable_name}))
-        end
-        scope
+        filter(terms: {index_name: indexes.map(&:derivable_name).uniq})
       end
 
       default_import_options journal: false

data/lib/chewy/strategy/delayed_sidekiq/worker.rb

@@ -13,7 +13,7 @@ module Chewy
           local timechunks_key = prefix .. ":" .. type .. ":timechunks"
 
           -- Get timechunk_keys with scores less than or equal to the specified score
-          local timechunk_keys = redis.call('zrangebyscore', timechunks_key, '-inf', score)
+          local timechunk_keys = redis.call('zrange', timechunks_key, '-inf', score, 'byscore')
 
           -- Get all members from the sets associated with the timechunk_keys
           local members = {}

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '8.0.1'.freeze
+  VERSION = '8.2.0'.freeze
 end

data/lib/chewy.rb

@@ -31,6 +31,7 @@ end
 try_require 'kaminari'
 try_require 'kaminari/core'
 try_require 'parallel'
+try_require 'ruby-progressbar'
 
 ActiveSupport.on_load(:active_record) do
   try_require 'kaminari/activerecord'

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chewy
 version: !ruby/object:Gem::Version
-  version: 8.0.1
+  version: 8.2.0
 platform: ruby
 authors:
 - Toptal, LLC
 - pyromaniac
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-12 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -89,6 +88,7 @@ files:
 - lib/chewy/index/import/bulk_builder.rb
 - lib/chewy/index/import/bulk_request.rb
 - lib/chewy/index/import/journal_builder.rb
+- lib/chewy/index/import/progressbar.rb
 - lib/chewy/index/import/routine.rb
 - lib/chewy/index/mapping.rb
 - lib/chewy/index/observe.rb
@@ -147,6 +147,7 @@ files:
 - lib/chewy/search/parameters/query.rb
 - lib/chewy/search/parameters/request_cache.rb
 - lib/chewy/search/parameters/rescore.rb
+- lib/chewy/search/parameters/runtime_mappings.rb
 - lib/chewy/search/parameters/script_fields.rb
 - lib/chewy/search/parameters/search_after.rb
 - lib/chewy/search/parameters/search_type.rb
@@ -186,7 +187,6 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -201,8 +201,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 4.0.12
 specification_version: 4
 summary: Elasticsearch ODM client wrapper
 test_files: []