chewy 6.0.0 → 7.6.0

data/lib/chewy/{type → index}/syncer.rb

@@ -1,5 +1,5 @@
 module Chewy
-  class Type
+  class Index
     # This class is able to find missing and outdated documents in the ES
     # comparing ids from the data source and the ES index. Also, if `outdated_sync_field`
     # exists in the index definition, it performs comparison of this field
@@ -9,10 +9,10 @@ module Chewy
     # should be reindexed.
     #
     # To fetch necessary data from the source it uses adapter method
-    # {Chewy::Type::Adapter::Base#import_fields}, in case when the Object
+    # {Chewy::Index::Adapter::Base#import_fields}, in case when the Object
     # adapter is used it makes sense to read corresponding documentation.
     #
-    # If `parallel` option is passed to the initializer - it will fetch surce and
+    # If `parallel` option is passed to the initializer - it will fetch source and
     # index data in parallel and then perform outdated objects calculation in
     # parallel processes. Also, further import (if required) will be performed
     # in parallel as well.
@@ -24,17 +24,17 @@ module Chewy
     #   ATTENTION: synchronization may be slow in case when synchronized tables
     #   are missing compound index on primary key and `outdated_sync_field`.
     #
-    # @see Chewy::Type::Actions::ClassMethods#sync
+    # @see Chewy::Index::Actions::ClassMethods#sync
     class Syncer
       DEFAULT_SYNC_BATCH_SIZE = 20_000
       ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
-      OUTDATED_IDS_WORKER = lambda do |outdated_sync_field_type, source_data_hash, type, total, index_data|
-        ::Process.setproctitle("chewy [#{type}]: sync outdated calculation (#{::Parallel.worker_number + 1}/#{total})") if type
+      OUTDATED_IDS_WORKER = lambda do |outdated_sync_field_type, source_data_hash, index, total, index_data|
+        ::Process.setproctitle("chewy [#{index}]: sync outdated calculation (#{::Parallel.worker_number + 1}/#{total})") if index
         index_data.each_with_object([]) do |(id, index_sync_value), result|
           next unless source_data_hash[id]
 
           outdated = if outdated_sync_field_type == 'date'
-            !Chewy::Type::Syncer.dates_equal(typecast_date(source_data_hash[id]), Time.iso8601(index_sync_value))
+            !Chewy::Index::Syncer.dates_equal(typecast_date(source_data_hash[id]), Time.iso8601(index_sync_value))
           else
             source_data_hash[id] != index_sync_value
           end
@@ -42,8 +42,8 @@ module Chewy
           result.push(id) if outdated
         end
       end
-      SOURCE_OR_INDEX_DATA_WORKER = lambda do |syncer, type, kind|
-        ::Process.setproctitle("chewy [#{type}]: sync fetching data (#{kind})")
+      SOURCE_OR_INDEX_DATA_WORKER = lambda do |syncer, index, kind|
+        ::Process.setproctitle("chewy [#{index}]: sync fetching data (#{kind})")
         result = case kind
         when :source
           syncer.send(:fetch_source_data)
@@ -56,7 +56,10 @@ module Chewy
       def self.typecast_date(string)
         if string.is_a?(String) && (match = ISO_DATETIME.match(string))
           microsec = (match[7].to_r * 1_000_000).to_i
-          date = "#{match[1]}-#{match[2]}-#{match[3]}T#{match[4]}:#{match[5]}:#{match[6]}.#{format('%06d', microsec)}+00:00"
+          day = "#{match[1]}-#{match[2]}-#{match[3]}"
+          time_with_seconds = "#{match[4]}:#{match[5]}:#{match[6]}"
+          microseconds = format('%06d', microsec)
+          date = "#{day}T#{time_with_seconds}.#{microseconds}+00:00"
           Time.iso8601(date)
         else
           string
@@ -68,18 +71,10 @@ module Chewy
         [one.to_i, one.usec / 1000] == [two.to_i, two.usec / 1000]
       end
 
-      # In ActiveSupport ~> 4.0 json dumpled times without any
-      # milliseconds, so ES stored time with the seconds precision.
-      if ActiveSupport::VERSION::STRING < '4.1.0'
-        def self.dates_equal(one, two)
-          one.to_i == two.to_i
-        end
-      end
-
-      # @param type [Chewy::Type] chewy type
+      # @param index [Chewy::Index] chewy index
       # @param parallel [true, Integer, Hash] options for parallel execution or the number of processes
-      def initialize(type, parallel: nil)
-        @type = type
+      def initialize(index, parallel: nil)
+        @index = index
         @parallel = if !parallel || parallel.is_a?(Hash)
           parallel
         elsif parallel.is_a?(Integer)
@@ -95,7 +90,8 @@ module Chewy
       def perform
         ids = missing_ids | outdated_ids
         return 0 if ids.blank?
-        @type.import(ids, parallel: @parallel) && ids.count
+
+        @index.import(ids, parallel: @parallel) && ids.count
       end
 
       # Finds ids of all the objects that are not indexed yet or deleted
@@ -113,21 +109,19 @@ module Chewy
         end
       end
 
-      # If type supports outdated sync, it compares for the values of the
-      # type `outdated_sync_field` for each object and document in the source
-      # and index and returns the ids of entities which which are having
-      # different values there.
+      # If index supports outdated sync, it compares the values of the
+      # `outdated_sync_field` for each object and document in the source
+      # and index and returns the ids of entities which differ.
       #
-      # @see Chewy::Type::Mapping::ClassMethods#supports_outdated_sync?
+      # @see Chewy::Index::Mapping::ClassMethods#supports_outdated_sync?
       # @return [Array<String>] an array of outdated ids
       def outdated_ids
-        return [] if source_data.blank? || index_data.blank? || !@type.supports_outdated_sync?
-        @outdated_ids ||= begin
-          if @parallel
-            parallel_outdated_ids
-          else
-            linear_outdated_ids
-          end
+        return [] if source_data.blank? || index_data.blank? || !@index.supports_outdated_sync?
+
+        @outdated_ids ||= if @parallel
+          parallel_outdated_ids
+        else
+          linear_outdated_ids
         end
       end
 
@@ -142,44 +136,48 @@ module Chewy
       end
 
       def source_and_index_data
-        @source_and_index_data ||= begin
-          if @parallel
-            ::ActiveRecord::Base.connection.close if defined?(::ActiveRecord::Base)
-            result = ::Parallel.map(%i[source index], @parallel, &SOURCE_OR_INDEX_DATA_WORKER.curry[self, @type])
-            ::ActiveRecord::Base.connection.reconnect! if defined?(::ActiveRecord::Base)
-            if result.first.keys.first == :source
-              [result.first.values.first, result.second.values.first]
-            else
-              [result.second.values.first, result.first.values.first]
-            end
+        @source_and_index_data ||= if @parallel
+          ::ActiveRecord::Base.connection.close if defined?(::ActiveRecord::Base)
+          result = ::Parallel.map(%i[source index], @parallel, &SOURCE_OR_INDEX_DATA_WORKER.curry[self, @index])
+          ::ActiveRecord::Base.connection.reconnect! if defined?(::ActiveRecord::Base)
+          if result.first.keys.first == :source
+            [result.first.values.first, result.second.values.first]
           else
-            [fetch_source_data, fetch_index_data]
+            [result.second.values.first, result.first.values.first]
           end
+        else
+          [fetch_source_data, fetch_index_data]
         end
       end
 
       def fetch_source_data
-        if @type.supports_outdated_sync?
-          @type.adapter.import_fields(fields: [@type.outdated_sync_field], batch_size: DEFAULT_SYNC_BATCH_SIZE, typecast: false).to_a.flatten(1).each do |data|
+        if @index.supports_outdated_sync?
+          import_fields_args = {
+            fields: [@index.outdated_sync_field],
+            batch_size: DEFAULT_SYNC_BATCH_SIZE,
+            typecast: false
+          }
+          @index.adapter.import_fields(import_fields_args).to_a.flatten(1).each do |data|
             data[0] = data[0].to_s
           end
         else
-          @type.adapter.import_fields(batch_size: DEFAULT_SYNC_BATCH_SIZE, typecast: false).to_a.flatten(1).map(&:to_s)
+          @index.adapter.import_fields(batch_size: DEFAULT_SYNC_BATCH_SIZE, typecast: false).to_a.flatten(1).map(&:to_s)
         end
       end
 
       def fetch_index_data
-        if @type.supports_outdated_sync?
-          @type.pluck(:_id, @type.outdated_sync_field).each do |data|
+        if @index.supports_outdated_sync?
+          @index.pluck(:_id, @index.outdated_sync_field).each do |data|
             data[0] = data[0].to_s
           end
         else
-          @type.pluck(:_id).map(&:to_s)
+          @index.pluck(:_id).map(&:to_s)
         end
       end
 
       def data_ids(data)
-        return data unless @type.supports_outdated_sync?
+        return data unless @index.supports_outdated_sync?
+
         data.map(&:first)
       end
 
@@ -192,7 +190,12 @@ module Chewy
         batches = index_data.each_slice(size)
 
         ::ActiveRecord::Base.connection.close if defined?(::ActiveRecord::Base)
-        result = ::Parallel.map(batches, @parallel, &OUTDATED_IDS_WORKER.curry[outdated_sync_field_type, source_data.to_h, @type, batches.size]).flatten(1)
+        curried_outdated_ids_worker = OUTDATED_IDS_WORKER.curry[outdated_sync_field_type, source_data.to_h, @index, batches.size]
+        result = ::Parallel.map(
+          batches,
+          @parallel,
+          &curried_outdated_ids_worker
+        ).flatten(1)
         ::ActiveRecord::Base.connection.reconnect! if defined?(::ActiveRecord::Base)
         result
       end
@@ -203,16 +206,13 @@ module Chewy
 
       def outdated_sync_field_type
         return @outdated_sync_field_type if instance_variable_defined?(:@outdated_sync_field_type)
-        return unless @type.outdated_sync_field
+        return unless @index.outdated_sync_field
 
-        args = {index: @type.index_name, type: @type.type_name}
-        args[:include_type_name] = true if Runtime.version >= '6.7.0'
-        mappings = @type.client.indices.get_mapping(**args).values.first.fetch('mappings', {})
+        mappings = @index.client.indices.get_mapping(index: @index.index_name).values.first.fetch('mappings', {})
 
         @outdated_sync_field_type = mappings
-          .fetch(@type.type_name, {})
           .fetch('properties', {})
-          .fetch(@type.outdated_sync_field.to_s, {})['type']
+          .fetch(@index.outdated_sync_field.to_s, {})['type']
       rescue Elasticsearch::Transport::Transport::Errors::NotFound
         nil
       end

data/lib/chewy/{type → index}/witchcraft.rb

@@ -7,7 +7,7 @@ rescue LoadError
 end
 
 module Chewy
-  class Type
+  class Index
     module Witchcraft
       extend ActiveSupport::Concern
 
@@ -43,10 +43,10 @@ module Chewy
       class Cauldron
         attr_reader :locals
 
-        # @param type [Chewy::Type] type for composition
+        # @param index [Chewy::Index] index for composition
         # @param fields [Array<Symbol>] restricts the fields for composition
-        def initialize(type, fields: [])
-          @type = type
+        def initialize(index, fields: [])
+          @index = index
           @locals = []
           @fields = fields
         end
@@ -60,7 +60,7 @@ module Chewy
         def alicorn
           @alicorn ||= singleton_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
             -> (locals, object0, crutches) do
-              #{composed_values(@type.root, 0)}
+              #{composed_values(@index.root, 0)}
             end
           RUBY
         end
@@ -141,6 +141,7 @@ module Chewy
 
         def non_proc_fields_for(parent, nesting)
           return [] unless parent
+
           fields = (parent.children || []).reject { |field| field.value.is_a?(Proc) }
 
           if nesting.zero? && @fields.present?
@@ -152,6 +153,7 @@ module Chewy
 
         def proc_fields_for(parent, nesting)
           return [] unless parent
+
           fields = (parent.children || []).select { |field| field.value.is_a?(Proc) }
 
           if nesting.zero? && @fields.present?
@@ -173,7 +175,7 @@ module Chewy
           if proc.arity.zero?
             source = replace_self(source, :"object#{nesting}")
             source = replace_send(source, :"object#{nesting}")
-          elsif proc.arity < 0
+          elsif proc.arity.negative?
             raise "Splat arguments are unsupported by witchcraft:\n`#{proc.source}"
           else
             (nesting + 1).times do |n|
@@ -192,6 +194,7 @@ module Chewy
 
         def exctract_lambdas(node)
           return unless node.is_a?(Parser::AST::Node)
+
           if node.type == :block && node.children[0].type == :send && node.children[0].to_a == [nil, :lambda]
             [node.children[2]]
           else
@@ -214,7 +217,7 @@ module Chewy
         def replace_send(node, variable)
           if node.is_a?(Parser::AST::Node)
             if node.type == :send && node.children[0].nil?
-              node.updated(nil, [Parser::AST::Node.new(:lvar, [variable]), *node.children[1..-1]])
+              node.updated(nil, [Parser::AST::Node.new(:lvar, [variable]), *node.children[1..]])
             else
               node.updated(nil, node.children.map { |child| replace_send(child, variable) })
             end
@@ -253,6 +256,7 @@ module Chewy
 
         def binding_variable_list(node)
           return unless node.is_a?(Parser::AST::Node)
+
           if node.type == :send && node.children[0].nil?
             node.children[1]
           else

data/lib/chewy/{type → index}/wrapper.rb

@@ -1,5 +1,5 @@
 module Chewy
-  class Type
+  class Index
     module Wrapper
       extend ActiveSupport::Concern
 
@@ -28,7 +28,7 @@ module Chewy
       def ==(other)
         return true if super
 
-        if other.is_a?(Chewy::Type)
+        if other.is_a?(Chewy::Index)
           self.class == other.class && (respond_to?(:id) ? id == other.id : attributes == other.attributes)
         elsif other.respond_to?(:id)
           self.class.adapter.target.is_a?(Class) &&

data/lib/chewy/index.rb

@@ -1,23 +1,52 @@
 require 'chewy/search'
 require 'chewy/index/actions'
+require 'chewy/index/adapter/active_record'
+require 'chewy/index/adapter/object'
 require 'chewy/index/aliases'
+require 'chewy/index/crutch'
+require 'chewy/index/import'
+require 'chewy/index/mapping'
+require 'chewy/index/observe'
 require 'chewy/index/settings'
 require 'chewy/index/specification'
+require 'chewy/index/syncer'
+require 'chewy/index/witchcraft'
+require 'chewy/index/wrapper'
 
 module Chewy
   class Index
+    IMPORT_OPTIONS_KEYS = %i[
+      batch_size bulk_size consistency direct_import journal
+      pipeline raw_import refresh replication
+    ].freeze
+
+    STRATEGY_OPTIONS = {
+      delayed_sidekiq: %i[latency margin ttl reindex_wrapper]
+    }.freeze
+
     include Search
     include Actions
     include Aliases
+    include Import
+    include Mapping
+    include Observe
+    include Crutch
+    include Witchcraft
+    include Wrapper
 
     singleton_class.delegate :client, to: 'Chewy'
 
-    class_attribute :type_hash
-    self.type_hash = {}
+    class_attribute :adapter
+    self.adapter = Chewy::Index::Adapter::Object.new(:default)
+
+    class_attribute :index_scope_defined
 
     class_attribute :_settings
     self._settings = Chewy::Index::Settings.new
 
+    class_attribute :_default_import_options
+    self._default_import_options = {}
+
     class << self
       # @overload index_name(suggest)
       #   If suggested name is passed, it is set up as the new base name for
@@ -47,7 +76,8 @@ module Chewy
       #     UsersIndex.index_name(prefix: '', suffix: '2017') # => 'users_2017'
       #
       #   @param prefix [String] index name prefix, uses {.prefix} method by default
-      #   @param suffix [String] index name suffix, used for creating several indexes for the same alias during the zero-downtime reset
+      #   @param suffix [String] index name suffix, used for creating several indexes for the same
+      #     alias during the zero-downtime reset
       #   @raise [UndefinedIndex] if the base name is blank
       #   @return [String] result index name
       def index_name(suggest = nil, prefix: nil, suffix: nil)
@@ -55,7 +85,7 @@ module Chewy
           @base_name = suggest.to_s.presence
         else
           [
-            prefix || prefix_with_deprecation,
+            prefix || self.prefix,
             base_name,
             suffix
           ].reject(&:blank?).join('_')
@@ -77,6 +107,7 @@ module Chewy
       def base_name
         @base_name ||= name.sub(/Index\z/, '').demodulize.underscore if name
         raise UndefinedIndex if @base_name.blank?
+
         @base_name
       end
 
@@ -111,80 +142,30 @@ module Chewy
         Chewy.configuration[:prefix]
       end
 
-      # Defines type for the index. Arguments depends on adapter used. For
+      # Defines scope and options for the index. Arguments depends on adapter used. For
       # ActiveRecord you can pass model or scope and options
       #
       #   class CarsIndex < Chewy::Index
-      #     define_type Car do
-      #       ...
-      #     end # defines VehiclesIndex::Car type
-      #   end
-      #
-      # Type name might be passed in complicated cases:
-      #
-      #   class VehiclesIndex < Chewy::Index
-      #     define_type Vehicle.cars.includes(:manufacturer), name: 'cars' do
-      #        ...
-      #     end # defines VehiclesIndex::Cars type
-      #
-      #     define_type Vehicle.motocycles.includes(:manufacturer), name: 'motocycles' do
-      #        ...
-      #     end # defines VehiclesIndex::Motocycles type
+      #     index_scope Car
+      #     ...
       #   end
       #
-      # For plain objects:
+      # For plain objects you can completely omit this directive, unless you need to specify some options:
       #
       #   class PlanesIndex < Chewy::Index
-      #     define_type :plane do
-      #       ...
-      #     end # defines PlanesIndex::Plane type
+      #     ...
       #   end
       #
       # The main difference between using plain objects or ActiveRecord models for indexing
-      # is import. If you will call `CarsIndex::Car.import` - it will import all the cars
-      # automatically, while `PlanesIndex::Plane.import(my_planes)` requires import data to be
+      # is import. If you will call `CarsIndex.import` - it will import all the cars
+      # automatically, while `PlanesIndex.import(my_planes)` requires import data to be
       # passed.
       #
-      def define_type(target, options = {}, &block)
-        raise 'Multiple types are deprecated' if type_hash.present?
-
-        type_class = Chewy.create_type(self, target, options, &block)
-        self.type_hash = type_hash.merge(type_class.type_name => type_class)
-      end
-
-      # Types method has double usage.
-      # If no arguments are passed - it returns array of defined types:
-      #
-      #   UsersIndex.types # => [UsersIndex::Admin, UsersIndex::Manager, UsersIndex::User]
-      #
-      # If arguments are passed it treats like a part of chainable query DSL and
-      # adds types array for index to select.
-      #
-      #   UsersIndex.filters { name =~ 'ro' }.types(:admin, :manager)
-      #   UsersIndex.types(:admin, :manager).filters { name =~ 'ro' } # the same as the first example
-      #
-      def types(*args)
-        if args.present?
-          all.types(*args)
-        else
-          type_hash.values
-        end
-      end
-
-      # Returns defined types names:
-      #
-      #   UsersIndex.type_names # => ['admin', 'manager', 'user']
-      #
-      def type_names
-        type_hash.keys
-      end
+      def index_scope(target, options = {})
+        raise 'Index scope is already defined' if index_scope_defined?
 
-      # Returns named type:
-      #
-      #    UserIndex.type('admin') # => UsersIndex::Admin
-      #
-      def type(type_name)
-        type_hash.fetch(type_name) { raise UndefinedType, "Unknown type in #{name}: #{type_name}" }
+        self.adapter = Chewy.adapters.find { |klass| klass.accepts?(target) }.new(target, **options)
+        self.index_scope_defined = true
       end
 
       # Used as a part of index definition DSL. Defines settings:
@@ -221,7 +202,7 @@ module Chewy
       end
 
       def mappings_hash
-        mappings = types.map(&:mappings_hash).inject(:merge)
+        mappings = root.mappings_hash
         mappings.present? ? {mappings: mappings} : {}
       end
 
@@ -234,44 +215,36 @@ module Chewy
         [settings_hash, mappings_hash].inject(:merge)
       end
 
-      def index_params
-        ActiveSupport::Deprecation.warn '`Chewy::Index.index_params` is deprecated and will be removed soon, use `Chewy::Index.specification_hash`'
-        specification_hash
-      end
-
       # @see Chewy::Index::Specification
       # @return [Chewy::Index::Specification] a specification object instance for this particular index
       def specification
         @specification ||= Specification.new(self)
       end
 
-      def derivable_index_name
-        ActiveSupport::Deprecation.warn '`Chewy::Index.derivable_index_name` is deprecated and will be removed soon, use `Chewy::Index.derivable_name` instead'
-        derivable_name
+      def default_import_options(params)
+        params.assert_valid_keys(IMPORT_OPTIONS_KEYS)
+        self._default_import_options = _default_import_options.merge(params)
       end
 
-      # Handling old default_prefix if it is not defined.
-      def method_missing(name, *args, &block) # rubocop:disable Style/MethodMissing
-        if name == :default_prefix
-          ActiveSupport::Deprecation.warn '`Chewy::Index.default_prefix` is deprecated and will be removed soon, use `Chewy::Index.prefix` instead'
-          prefix
-        else
-          super
-        end
-      end
+      def strategy_config(params = {})
+        @strategy_config ||= begin
+          config_struct = Struct.new(*STRATEGY_OPTIONS.keys).new
 
-      def prefix_with_deprecation
-        if respond_to?(:default_prefix)
-          ActiveSupport::Deprecation.warn '`Chewy::Index.default_prefix` is deprecated and will be removed soon, define `Chewy::Index.prefix` method instead'
-          default_prefix
-        else
-          prefix
-        end
-      end
+          STRATEGY_OPTIONS.each_with_object(config_struct) do |(strategy, options), res|
+            res[strategy] = case strategy
+            when :delayed_sidekiq
+              Struct.new(*STRATEGY_OPTIONS[strategy]).new.tap do |config|
+                options.each do |option|
+                  config[option] = params.dig(strategy, option) || Chewy.configuration.dig(:strategy_config, strategy, option)
+                end
 
-      def build_index_name(*args)
-        ActiveSupport::Deprecation.warn '`Chewy::Index.build_index_name` is deprecated and will be removed soon, use `Chewy::Index.index_name` instead'
-        index_name(args.extract_options!)
+                config[:reindex_wrapper] ||= ->(&reindex) { reindex.call } # default wrapper
+              end
+            else
+              raise NotImplementedError, "Unsupported strategy: '#{strategy}'"
+            end
+          end
+        end
       end
     end
   end

data/lib/chewy/journal.rb

@@ -2,33 +2,36 @@ module Chewy
   # A class to perform journal-related actions for the specified indexes/types.
   #
   # @example
-  #   journal = Chewy::Journal.new('places#city', UsersIndex)
+  #   journal = Chewy::Journal.new('places', UsersIndex)
   #   journal.apply(20.minutes.ago)
   #   journal.clean
   #
   class Journal
-    # @param only [Array<String, Chewy::Index, Chewy::Type>] indexes/types or even string references to perform actions on
+    # @param only [Array<String, Chewy::Index>] indexes or string references to perform actions on
     def initialize(*only)
       @only = only
     end
 
     # Applies all changes that were done since the specified time to the
-    # specified indexes/types.
+    # specified indexes.
     #
     # @param since_time [Time, DateTime] timestamp from which changes will be applied
-    # @param retries [Integer] maximum number of attempts to make journal empty, 10 by default
+    # @param fetch_limit [Int] amount of entries to be fetched on each cycle
     # @return [Integer] the amount of journal entries found
-    def apply(since_time, retries: 10, **import_options)
+    def apply(since_time, fetch_limit: 10, **import_options)
       stage = 1
       since_time -= 1
       count = 0
-      while stage <= retries
-        entries = Chewy::Stash::Journal.entries(since_time, only: @only).to_a.presence or break
+
+      total_count = entries(since_time, fetch_limit).total_count
+
+      while count < total_count
+        entries = entries(since_time, fetch_limit).to_a.presence or break
         count += entries.size
         groups = reference_groups(entries)
         ActiveSupport::Notifications.instrument 'apply_journal.chewy', stage: stage, groups: groups
-        groups.each do |type, references|
-          type.import(references, import_options.merge(journal: false))
+        groups.each do |index, references|
+          index.import(references, import_options.merge(journal: false))
         end
         stage += 1
         since_time = entries.map(&:created_at).max
@@ -40,16 +43,24 @@ module Chewy
     #
     # @param until_time [Time, DateTime] time to clean up until it
     # @return [Hash] delete_by_query ES API call result
-    def clean(until_time = nil)
-      Chewy::Stash::Journal.clean(until_time, only: @only)
+    def clean(until_time = nil, delete_by_query_options: {})
+      Chewy::Stash::Journal.clean(
+        until_time,
+        only: @only,
+        delete_by_query_options: delete_by_query_options.merge(refresh: false)
+      )
     end
 
   private
 
+    def entries(since_time, fetch_limit)
+      Chewy::Stash::Journal.entries(since_time, only: @only).order(:created_at).limit(fetch_limit)
+    end
+
     def reference_groups(entries)
-      entries.group_by(&:type).map do |type, grouped_entries|
-        [type, grouped_entries.map(&:references).inject(:|)]
-      end.to_h
+      entries.group_by(&:index_name)
+        .transform_keys { |index_name| Chewy.derive_name(index_name) }
+        .transform_values { |grouped_entries| grouped_entries.map(&:references).inject(:|) }
     end
   end
 end

data/lib/chewy/log_subscriber.rb

@@ -24,7 +24,11 @@ module Chewy
 
       subject = payload[:type].presence || payload[:index]
       action = "#{subject} #{action} (#{event.duration.round(1)}ms)"
-      action = color(action, GREEN, true)
+      action = if ActiveSupport.version >= Gem::Version.new('7.1')
+        color(action, GREEN, bold: true)
+      else
+        color(action, GREEN, true)
+      end
 
       debug("  #{action} #{description}")
     end