search-engine-for-typesense 30.1.6.3 → 30.1.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 228f70410334d2a324508d0d44dfd31aadbcb4a957f28425909108490a3129a2
-  data.tar.gz: 89fd3243af9aec91757d9819136ce9b0fd783845ff1ff6e6fe72467106d20ecb
+  metadata.gz: 46b318e4be1f0f8d12e5f3ead35ad4945c472773f8f7117427d1ffd2a0f44732
+  data.tar.gz: 4db7bc9cf0e081ff21b87c8b089627fe02e651020ad8a9df7fc0a3edb0cc7dea
 SHA512:
-  metadata.gz: 42e556e2b25d40fd5ba85cb1ae1961223420d6affb6f532936642a48159dc013a8297398cba3724ef798f2cab05a0819140c9038d415b0035c7f9a95b2408e07
-  data.tar.gz: ea3aba9866079ade74da2712d73f6e2a7169cc0a013dff5814ccbc7034789e9f2d6ae38979e49761210e46e4a61f329fde3ae9bb356f02b643b14899a0d24d9d
+  metadata.gz: cccc05756309485db9c5c49a880e45aa09a3f8f7e6afade62fd2d064eb3ccca286c96791aed830da01090ee10c60b6cf5c602269b55859b3466f76d3d22bd704
+  data.tar.gz: 112cbcd585dfeec20a848c9b153024fcb48526b4f56127a75ef45300693baf6ca666899f607f436e32889d50d2e7f1ad1b29d1daf6af6c5f59b1611db8d9b683

data/lib/search_engine/base/index_maintenance/cleanup.rb

@@ -45,13 +45,13 @@ module SearchEngine
           def cleanup(into: nil, partition: nil, clear_cache: false)
             logical = respond_to?(:collection) ? collection.to_s : name.to_s
             puts
-            puts(%(>>>>>> Cleanup Collection "#{logical}"))
+            puts(SearchEngine::Logging::Color.header(%(>>>>>> Cleanup Collection "#{logical}")))
 
             filters = SearchEngine::StaleRules.compile_filters(self, partition: partition)
             filters.compact!
             filters.reject! { |f| f.to_s.strip.empty? }
             if filters.empty?
-              puts('Cleanup — skip (no stale configuration)')
+              puts(SearchEngine::Logging::Color.dim('Cleanup — skip (no stale configuration)'))
               return 0
             end
 
@@ -65,25 +65,23 @@ module SearchEngine
               partition: partition
             )
 
-            puts("Cleanup — deleted=#{deleted}")
+            puts("Cleanup — #{SearchEngine::Logging::Color.apply("deleted=#{deleted}", :green)}")
             deleted
           rescue StandardError => error
-            warn(
-              "Cleanup — error=#{error.class}: #{error.message.to_s[0, 200]}"
-            )
+            err_msg = "Cleanup — error=#{error.class}: #{error.message.to_s[0, 200]}"
+            warn(SearchEngine::Logging::Color.apply(err_msg, :red))
             0
           ensure
             if clear_cache
               begin
-                puts('Cleanup — cache clear')
+                puts("Cleanup — #{SearchEngine::Logging::Color.bold('cache clear')}")
                 SearchEngine::Cache.clear
               rescue StandardError => error
-                warn(
-                  "Cleanup — cache clear error=#{error.class}: #{error.message.to_s[0, 200]}"
-                )
+                err_msg = "Cleanup — cache clear error=#{error.class}: #{error.message.to_s[0, 200]}"
+                warn(SearchEngine::Logging::Color.apply(err_msg, :red))
               end
             end
-            puts(%(>>>>>> Cleanup Done))
+            puts(SearchEngine::Logging::Color.header(%(>>>>>> Cleanup Done)))
           end
 
           private

data/lib/search_engine/base/index_maintenance/lifecycle.rb

@@ -17,7 +17,7 @@ module SearchEngine
           def index_collection(partition: nil, client: nil, pre: nil, force_rebuild: false)
             logical = respond_to?(:collection) ? collection.to_s : name.to_s
             puts
-            puts(%(>>>>>> Indexing Collection "#{logical}"))
+            puts(SearchEngine::Logging::Color.header(%(>>>>>> Indexing Collection "#{logical}")))
             client_obj = client || SearchEngine.client
 
             result = if partition.nil?
@@ -56,7 +56,12 @@ module SearchEngine
 
             diff = SearchEngine::Schema.diff(self, client: client)[:diff] || {}
             missing = __se_schema_missing?(diff)
-            puts("Step 1: Presence — processing → #{missing ? 'missing' : 'present'}")
+            presence = if missing
+                         SearchEngine::Logging::Color.apply('missing', :yellow)
+                       else
+                         SearchEngine::Logging::Color.apply('present', :green)
+                       end
+            puts("Step 1: Presence — #{SearchEngine::Logging::Color.bold('processing')} → #{presence}")
 
             applied, indexed_inside_apply = __se_full_apply_if_missing(client, missing)
             drift = __se_full_check_drift(diff, missing, force_rebuild)
@@ -76,43 +81,48 @@ module SearchEngine
             applied = false
             indexed_inside_apply = false
             if missing
-              puts('Step 2: Create+Apply Schema — processing')
+              puts("Step 2: Create+Apply Schema — #{SearchEngine::Logging::Color.bold('processing')}")
               SearchEngine::Schema.apply!(self, client: client) do |new_physical|
                 indexed_inside_apply = __se_index_partitions!(into: new_physical)
               end
               applied = true
-              puts('Step 2: Create+Apply Schema — done')
+              puts("Step 2: Create+Apply Schema — #{SearchEngine::Logging::Color.apply('done', :green)}")
             else
-              puts('Step 2: Create+Apply Schema — skip (collection present)')
+              puts(SearchEngine::Logging::Color.dim('Step 2: Create+Apply Schema — skip (collection present)'))
             end
             [applied, indexed_inside_apply]
           end
 
           def __se_full_check_drift(diff, missing, force_rebuild)
             unless missing
-              puts('Step 3: Check Schema Status — processing')
+              puts("Step 3: Check Schema Status — #{SearchEngine::Logging::Color.bold('processing')}")
               drift = __se_schema_drift?(diff)
               if force_rebuild && !drift
-                puts('Step 3: Check Schema Status — force_rebuild')
+                puts("Step 3: Check Schema Status — #{SearchEngine::Logging::Color.apply('force_rebuild', :yellow)}")
                 return true
               end
-              puts("Step 3: Check Schema Status — #{drift ? 'drift' : 'in_sync'}")
+              schema_status = if drift
+                                SearchEngine::Logging::Color.apply('drift', :yellow)
+                              else
+                                SearchEngine::Logging::Color.apply('in_sync', :green)
+                              end
+              puts("Step 3: Check Schema Status — #{schema_status}")
               return drift
             end
-            puts('Step 3: Check Schema Status — skip (just created)')
+            puts(SearchEngine::Logging::Color.dim('Step 3: Check Schema Status — skip (just created)'))
             false
           end
 
           def __se_full_apply_if_drift(client, drift, applied, indexed_inside_apply, force_rebuild)
             if drift
-              puts('Step 4: Apply New Schema — processing')
+              puts("Step 4: Apply New Schema — #{SearchEngine::Logging::Color.bold('processing')}")
               SearchEngine::Schema.apply!(self, client: client, force_rebuild: force_rebuild) do |new_physical|
                 indexed_inside_apply = __se_index_partitions!(into: new_physical)
               end
               applied = true
-              puts('Step 4: Apply New Schema — done')
+              puts("Step 4: Apply New Schema — #{SearchEngine::Logging::Color.apply('done', :green)}")
             else
-              puts('Step 4: Apply New Schema — skip')
+              puts(SearchEngine::Logging::Color.dim('Step 4: Apply New Schema — skip'))
             end
             [applied, indexed_inside_apply]
           end
@@ -120,12 +130,12 @@ module SearchEngine
           def __se_full_indexation(applied, indexed_inside_apply)
             result = nil
             if applied && indexed_inside_apply
-              puts('Step 5: Indexing — skip (performed during schema apply)')
+              puts(SearchEngine::Logging::Color.dim('Step 5: Indexing — skip (performed during schema apply)'))
               result = indexed_inside_apply if indexed_inside_apply.is_a?(Hash)
             else
-              puts('Step 5: Indexing — processing')
+              puts("Step 5: Indexing — #{SearchEngine::Logging::Color.bold('processing')}")
               result = __se_index_partitions!(into: nil)
-              puts('Step 5: Indexing — done')
+              puts("Step 5: Indexing — #{SearchEngine::Logging::Color.apply('done', :green)}")
             end
 
             cascade_ok = result.is_a?(Hash) ? result[:status] == :ok : false
@@ -135,11 +145,12 @@ module SearchEngine
 
           def __se_full_retention(applied, logical, client)
             if applied
-              puts('Step 6: Retention Cleanup — skip (handled by schema apply)')
+              puts(SearchEngine::Logging::Color.dim('Step 6: Retention Cleanup — skip (handled by schema apply)'))
             else
-              puts('Step 6: Retention Cleanup — processing')
+              puts("Step 6: Retention Cleanup — #{SearchEngine::Logging::Color.bold('processing')}")
               dropped = __se_retention_cleanup!(logical: logical, client: client)
-              puts("Step 6: Retention Cleanup — dropped=#{dropped.inspect}")
+              dropped_str = SearchEngine::Logging::Color.apply("dropped=#{dropped.inspect}", :green)
+              puts("Step 6: Retention Cleanup — #{dropped_str}")
             end
           end
 
@@ -149,32 +160,43 @@ module SearchEngine
             diff = diff_res[:diff] || {}
 
             missing = __se_schema_missing?(diff)
-            puts("Step 1: Presence — processing → #{missing ? 'missing' : 'present'}")
+            presence = if missing
+                         SearchEngine::Logging::Color.apply('missing', :yellow)
+                       else
+                         SearchEngine::Logging::Color.apply('present', :green)
+                       end
+            puts("Step 1: Presence — #{SearchEngine::Logging::Color.bold('processing')} → #{presence}")
             if missing
-              puts('Partial: collection is not present. Quit early.')
+              msg = SearchEngine::Logging::Color.apply(
+                'Step 1: Partial — collection is not present. Quit early.', :yellow
+              )
+              puts(msg)
               return { status: :failed, docs_total: 0, success_total: 0, failed_total: 0,
                        sample_error: 'Collection not present' }
             end
 
-            puts('Step 2: Check Schema Status — processing')
+            puts("Step 2: Check Schema Status — #{SearchEngine::Logging::Color.bold('processing')}")
             drift = __se_schema_drift?(diff)
             if drift
-              puts('Partial: schema is not up-to-date. Exit early (run full indexing).')
+              msg = SearchEngine::Logging::Color.apply(
+                'Step 2: Partial — schema is not up-to-date. Exit early (run full indexing).', :yellow
+              )
+              puts(msg)
               return { status: :failed, docs_total: 0, success_total: 0, failed_total: 0,
                        sample_error: 'Schema drift detected' }
             end
-            puts('Step 2: Check Schema Status — in_sync')
+            puts("Step 2: Check Schema Status — #{SearchEngine::Logging::Color.apply('in_sync', :green)}")
 
             __se_preflight_dependencies!(mode: pre, client: client) if pre
 
-            puts('Step 3: Partial Indexing — processing')
+            puts("Step 3: Partial Indexing — #{SearchEngine::Logging::Color.bold('processing')}")
             summaries = []
             partitions.each do |p|
               summary = SearchEngine::Indexer.rebuild_partition!(self, partition: p, into: nil)
               summaries << summary
               puts(SearchEngine::Logging::PartitionProgress.line(p, summary))
             end
-            puts('Step 3: Partial Indexing — done')
+            puts("Step 3: Partial Indexing — #{SearchEngine::Logging::Color.apply('done', :green)}")
 
             result = __se_build_index_result(summaries)
             __se_cascade_after_indexation!(context: :full) if result[:status] == :ok
@@ -185,34 +207,34 @@ module SearchEngine
           def __se_cascade_after_indexation!(context: :full)
             if SearchEngine::Instrumentation.context&.[](:bulk_suppress_cascade)
               puts
-              puts('>>>>>> Cascade Referencers — suppressed (bulk)')
+              puts(SearchEngine::Logging::Color.dim('>>>>>> Cascade Referencers — suppressed (bulk)'))
               return
             end
             puts
-            puts(%(>>>>>> Cascade Referencers))
+            puts(SearchEngine::Logging::Color.header(%(>>>>>> Cascade Referencers)))
             results = SearchEngine::Cascade.cascade_reindex!(source: self, ids: nil, context: context)
             outcomes = Array(results[:outcomes])
             if outcomes.empty?
-              puts('  none')
+              puts(SearchEngine::Logging::Color.dim('  none'))
             else
               outcomes.each do |o|
                 coll = o[:collection] || o['collection']
                 mode = (o[:mode] || o['mode']).to_s
                 case mode
                 when 'partial'
-                  puts(%(  Referencer "#{coll}" → partial reindex))
+                  puts(%(  Referencer "#{coll}" → #{SearchEngine::Logging::Color.apply('partial reindex', :green)}))
                 when 'full'
-                  puts(%(  Referencer "#{coll}" → full reindex))
+                  puts(%(  Referencer "#{coll}" → #{SearchEngine::Logging::Color.apply('full reindex', :green)}))
                 when 'skipped_unregistered'
-                  puts(%(  Referencer "#{coll}" → skipped (unregistered)))
+                  puts(SearchEngine::Logging::Color.dim(%(  Referencer "#{coll}" → skipped (unregistered))))
                 when 'skipped_cycle'
-                  puts(%(  Referencer "#{coll}" → skipped (cycle)))
+                  puts(SearchEngine::Logging::Color.dim(%(  Referencer "#{coll}" → skipped (cycle))))
                 else
                   puts(%(  Referencer "#{coll}" → #{mode}))
                 end
               end
             end
-            puts('>>>>>> Cascade Done')
+            puts(SearchEngine::Logging::Color.header('>>>>>> Cascade Done'))
           rescue StandardError => error
             base = "Cascade — error=#{error.class}: #{error.message.to_s[0, 200]}"
             if error.respond_to?(:status) || error.respond_to?(:body)
@@ -233,9 +255,12 @@ module SearchEngine
               rescue StandardError
                 nil
               end
-              warn([base, ("status=#{status}" if status), ("body=#{body_preview}" if body_preview)].compact.join(' '))
+              err_parts = [base]
+              err_parts << "status=#{status}" if status
+              err_parts << "body=#{body_preview}" if body_preview
+              warn(SearchEngine::Logging::Color.apply(err_parts.compact.join(' '), :red))
             else
-              warn(base)
+              warn(SearchEngine::Logging::Color.apply(base, :red))
             end
           end
           # rubocop:enable Metrics/PerceivedComplexity, Metrics/AbcSize

data/lib/search_engine/base/index_maintenance/schema.rb

@@ -28,13 +28,18 @@ module SearchEngine
           def update_collection!
             client = SearchEngine.client
 
-            puts 'Update Collection — analyzing diff for in-place update...'
+            status_word = SearchEngine::Logging::Color.bold('analyzing diff for in-place update...')
+            puts "Update Collection — #{status_word}"
             updated = SearchEngine::Schema.update!(self, client: client)
 
             if updated
-              puts 'Update Collection — schema updated in-place (PATCH)'
+              status_word = SearchEngine::Logging::Color.apply('schema updated in-place (PATCH)', :green)
+              puts "Update Collection — #{status_word}"
             else
-              puts 'Update Collection — in-place update not possible (no changes or incompatible)'
+              msg = SearchEngine::Logging::Color.dim(
+                'Update Collection — in-place update not possible (no changes or incompatible)'
+              )
+              puts(msg)
             end
             updated
           end
@@ -53,17 +58,19 @@ module SearchEngine
                        end
 
             if physical.nil?
-              puts('Drop Collection — skip (not present)')
+              puts(SearchEngine::Logging::Color.dim('Drop Collection — skip (not present)'))
               return
             end
 
             puts
-            puts(%(>>>>>> Dropping Collection "#{logical}"))
-            puts("Drop Collection — processing (logical=#{logical} physical=#{physical})")
+            header = SearchEngine::Logging::Color.header(%(>>>>>> Dropping Collection "#{logical}"))
+            puts(header)
+            status_word = SearchEngine::Logging::Color.bold('processing')
+            puts("Drop Collection — #{status_word} (logical=#{logical} physical=#{physical})")
             # Use an extended timeout to accommodate large collection drops
             client.delete_collection(physical, timeout_ms: 60_000)
-            puts('Drop Collection — done')
-            puts(%(>>>>>> Dropped Collection "#{logical}"))
+            puts("Drop Collection — #{SearchEngine::Logging::Color.apply('done', :green)}")
+            puts(SearchEngine::Logging::Color.header(%(>>>>>> Dropped Collection "#{logical}")))
             nil
           end
 
@@ -80,16 +87,19 @@ module SearchEngine
                        end
 
             if physical
-              puts("Recreate Collection — dropping existing (logical=#{logical} physical=#{physical})")
+              status_word = SearchEngine::Logging::Color.apply('dropping existing', :yellow)
+              puts("Recreate Collection — #{status_word} (logical=#{logical} physical=#{physical})")
               client.delete_collection(physical)
             else
-              puts('Recreate Collection — no existing collection (skip drop)')
+              msg = SearchEngine::Logging::Color.dim('Recreate Collection — no existing collection (skip drop)')
+              puts(msg)
             end
 
             schema = SearchEngine::Schema.compile(self)
-            puts("Recreate Collection — creating collection with schema (logical=#{logical})")
+            status_word = SearchEngine::Logging::Color.bold('creating collection with schema')
+            puts("Recreate Collection — #{status_word} (logical=#{logical})")
             client.create_collection(schema)
-            puts('Recreate Collection — done')
+            puts("Recreate Collection — #{SearchEngine::Logging::Color.apply('done', :green)}")
             nil
           end
 

data/lib/search_engine/base/index_maintenance.rb

@@ -5,6 +5,7 @@ require 'search_engine/base/index_maintenance/cleanup'
 require 'search_engine/base/index_maintenance/lifecycle'
 require 'search_engine/base/index_maintenance/schema'
 require 'search_engine/logging/color'
+require 'search_engine/logging/batch_line'
 
 module SearchEngine
   class Base
@@ -41,7 +42,10 @@ module SearchEngine
 
           indent = '  ' * depth
           puts if depth.zero?
-          puts(%(#{indent}>>>>>> Preflight Dependencies (mode: #{mode}, collection: "#{current}")))
+          header = SearchEngine::Logging::Color.header(
+            %(#{indent}>>>>>> Preflight Dependencies (mode: #{mode}, collection: "#{current}"))
+          )
+          puts(header)
 
           deps.each do |cfg|
             dep_coll = (cfg[:collection] || cfg['collection']).to_s
@@ -50,7 +54,7 @@ module SearchEngine
             dep_klass = __se_resolve_dep_class(dep_coll)
 
             if dep_klass.nil?
-              puts(%(#{indent}  "#{dep_coll}" → skipped (unregistered)))
+              puts(SearchEngine::Logging::Color.dim(%(#{indent}  "#{dep_coll}" → skipped (unregistered))))
               visited.add(dep_coll)
               next
             end
@@ -72,7 +76,7 @@ module SearchEngine
             visited.add(dep_coll)
           end
 
-          puts(%(#{indent}>>>>>> Preflight Done (collection: "#{current}")))
+          puts(SearchEngine::Logging::Color.header(%(#{indent}>>>>>> Preflight Done (collection: "#{current}"))))
         end
 
         # @return [String] current collection logical name; empty string when unavailable
@@ -165,27 +169,29 @@ module SearchEngine
           case mode.to_s
           when 'ensure'
             if missing
-              puts(%(#{indent}"#{dep_coll}" → ensure (missing) → index_collection))
+              status_word = SearchEngine::Logging::Color.apply('ensure (missing)', :yellow)
+              puts(%(#{indent}"#{dep_coll}" → #{status_word} → index_collection))
               # Avoid nested preflight to prevent redundant recursion cycles
               SearchEngine::Instrumentation.with_context(bulk_suppress_cascade: true) do
                 dep_klass.index_collection(client: client)
               end
             else
-              puts(%(#{indent}"#{dep_coll}" → present (skip)))
+              puts(SearchEngine::Logging::Color.dim(%(#{indent}"#{dep_coll}" → present (skip))))
             end
           when 'index'
             if missing || drift
               reason = missing ? 'missing' : 'drift'
-              puts(%(#{indent}"#{dep_coll}" → index (#{reason}) → index_collection))
+              status_word = SearchEngine::Logging::Color.apply("index (#{reason})", :yellow)
+              puts(%(#{indent}"#{dep_coll}" → #{status_word} → index_collection))
               # Avoid nested preflight to prevent redundant recursion cycles
               SearchEngine::Instrumentation.with_context(bulk_suppress_cascade: true) do
                 dep_klass.index_collection(client: client)
               end
             else
-              puts(%(#{indent}"#{dep_coll}" → in_sync (skip)))
+              puts(SearchEngine::Logging::Color.dim(%(#{indent}"#{dep_coll}" → in_sync (skip))))
             end
           else
-            puts(%(#{indent}"#{dep_coll}" → skipped (unknown mode: #{mode})))
+            puts(SearchEngine::Logging::Color.dim(%(#{indent}"#{dep_coll}" → skipped (unknown mode: #{mode}))))
           end
         end
 
@@ -193,61 +199,10 @@ module SearchEngine
           return unless batches.is_a?(Array)
 
           batches.each_with_index do |batch_stats, idx|
-            batch_number = idx + 1
-            batch_status = __se_batch_status_from_stats(batch_stats)
-            status_color = SearchEngine::Logging::Color.for_status(batch_status)
-
-            prefix = batch_number == 1 ? '  single → ' : '          '
-            line = +prefix
-            line << SearchEngine::Logging::Color.apply("status=#{batch_status}", status_color) << ' '
-            docs_count = batch_stats[:docs_count] || batch_stats['docs_count'] || 0
-            line << "docs=#{docs_count}" << ' '
-            success_count = (batch_stats[:success_count] || batch_stats['success_count'] || 0).to_i
-            success_str = "success=#{success_count}"
-            line << (
-              success_count.positive? ? SearchEngine::Logging::Color.bold(success_str) : success_str
-            ) << ' '
-            failed_count = (batch_stats[:failure_count] || batch_stats['failure_count'] || 0).to_i
-            failed_str = "failed=#{failed_count}"
-            line << (
-              failed_count.positive? ? SearchEngine::Logging::Color.apply(failed_str, :red) : failed_str
-            ) << ' '
-            line << "batch=#{batch_number} "
-            duration_ms = batch_stats[:duration_ms] || batch_stats['duration_ms'] || 0.0
-            line << "duration_ms=#{duration_ms}"
-
-            # Extract sample error from batch stats
-            sample_err = __se_extract_batch_sample_error(batch_stats)
-            line << " sample_error=#{sample_err.inspect}" if sample_err
-
-            puts(line)
+            puts(SearchEngine::Logging::BatchLine.format(batch_stats, idx + 1, indifferent: true))
           end
         end
 
-        def __se_batch_status_from_stats(stats)
-          success_count = (stats[:success_count] || stats['success_count'] || 0).to_i
-          failure_count = (stats[:failure_count] || stats['failure_count'] || 0).to_i
-
-          if failure_count.positive? && success_count.positive?
-            :partial
-          elsif failure_count.positive?
-            :failed
-          else
-            :ok
-          end
-        end
-
-        def __se_extract_batch_sample_error(stats)
-          samples = stats[:errors_sample] || stats['errors_sample']
-          return nil unless samples.is_a?(Array) && samples.any?
-
-          samples.each do |msg|
-            s = msg.to_s
-            return s unless s.strip.empty?
-          end
-          nil
-        end
-
         private :__se_current_collection_name,
                 :__se_fetch_joins_config,
                 :__se_belongs_to_dependencies,
@@ -257,9 +212,7 @@ module SearchEngine
                 :__se_diff_for,
                 :__se_dependency_status,
                 :__se_handle_preflight_action,
-                :__se_log_batches_from_summary,
-                :__se_batch_status_from_stats,
-                :__se_extract_batch_sample_error
+                :__se_log_batches_from_summary
       end
 
       class_methods do
@@ -390,7 +343,8 @@ module SearchEngine
                 end
               rescue StandardError => error
                 mtx.synchronize do
-                  warn("  partition=#{part.inspect} → error=#{error.class}: #{error.message.to_s[0, 200]}")
+                  err_msg = "  partition=#{part.inspect} → error=#{error.class}: #{error.message.to_s[0, 200]}"
+                  warn(SearchEngine::Logging::Color.apply(err_msg, :red))
                   partition_errors << "#{error.class}: #{error.message.to_s[0, 200]}"
                 end
               end

data/lib/search_engine/cascade.rb

@@ -145,7 +145,7 @@ into: nil
       # when no partitions are configured.
       # @param ref_klass [Class]
       # @return [void]
-      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/PerceivedComplexity, Metrics/AbcSize
       def __se_full_reindex_for_referrer(ref_klass, client:, alias_cache:)
         logical = ref_klass.respond_to?(:collection) ? ref_klass.collection.to_s : ref_klass.name.to_s
         physical = resolve_physical_collection_name(logical, client: client, cache: alias_cache)
@@ -184,12 +184,13 @@ into: nil
 
           if parts.empty?
             coll_display = physical && physical != logical ? "#{logical} (physical: #{physical})" : logical
-            puts(%(  Referencer "#{coll_display}" — partitions=0 → skip))
+            puts(SearchEngine::Logging::Color.dim(%(  Referencer "#{coll_display}" — partitions=0 → skip)))
             return false
           end
 
           coll_display = physical && physical != logical ? "#{logical} (physical: #{physical})" : logical
-          puts(%(  Referencer "#{coll_display}" — partitions=#{parts.size} parallel=#{compiled.max_parallel}))
+          parts_str = SearchEngine::Logging::Color.bold("partitions=#{parts.size}")
+          puts(%(  Referencer "#{coll_display}" — #{parts_str} parallel=#{compiled.max_parallel}))
           mp = compiled.max_parallel.to_i
           if mp > 1 && parts.size > 1
             require 'concurrent-ruby'
@@ -211,13 +212,13 @@ into: nil
 
         else
           coll_display = physical && physical != logical ? "#{logical} (physical: #{physical})" : logical
-          puts(%(  Referencer "#{coll_display}" — single))
+          puts(%(  Referencer "#{coll_display}" — #{SearchEngine::Logging::Color.bold('single')}))
           SearchEngine::Indexer.rebuild_partition!(ref_klass, partition: nil, into: nil)
           executed = true
         end
         executed
       end
-      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/PerceivedComplexity, Metrics/AbcSize
 
       # Resolve logical alias to physical name with optional per-run memoization.
       # @param logical [String]
@@ -333,27 +334,31 @@ into: nil
       def reindex_referencer_with_fresh_schema!(ref_klass, logical, physical, client:, force_rebuild: false)
         coll_display = physical && physical != logical ? "#{logical} (physical: #{physical})" : logical
         action = force_rebuild ? 'force_rebuild index_collection' : 'index_collection'
-        puts(%(  Referencer "#{coll_display}" — schema rebuild required, running #{action}))
+        status_word = SearchEngine::Logging::Color.apply("schema rebuild required, running #{action}", :yellow)
+        puts(%(  Referencer "#{coll_display}" — #{status_word}))
 
         SearchEngine::Instrumentation.with_context(bulk_suppress_cascade: true) do
           ref_klass.index_collection(client: client, pre: :ensure, force_rebuild: force_rebuild)
         end
         true
       rescue StandardError => error
-        puts(%(  Referencer "#{logical}" — schema rebuild failed: #{error.message}))
+        err_line = %(  Referencer "#{logical}" — schema rebuild failed: #{error.message})
+        puts(SearchEngine::Logging::Color.apply(err_line, :red))
         false
       end
 
       def reindex_referencer_with_drop!(ref_klass, logical, physical)
         coll_display = physical && physical != logical ? "#{logical} (physical: #{physical})" : logical
-        puts(%(  Referencer "#{coll_display}" — force reindex (drop+index)))
+        status_word = SearchEngine::Logging::Color.apply('force reindex (drop+index)', :yellow)
+        puts(%(  Referencer "#{coll_display}" — #{status_word}))
 
         SearchEngine::Instrumentation.with_context(bulk_suppress_cascade: true) do
           ref_klass.reindex_collection!
         end
         true
       rescue StandardError => error
-        puts(%(  Referencer "#{logical}" — force reindex failed: #{error.message}))
+        err_line = %(  Referencer "#{logical}" — force reindex failed: #{error.message})
+        puts(SearchEngine::Logging::Color.apply(err_line, :red))
         false
       end
 

data/lib/search_engine/cli/doctor.rb

@@ -553,10 +553,8 @@ module SearchEngine
           started = monotonic_ms
           callable.call
         rescue StandardError => error
-          puts "error: #{error.backtrace.join("\n")}"
-          puts '--------------------------------'
-          puts '--------------------------------'
-          puts '--------------------------------'
+          puts SearchEngine::Cli::Support.fmt_err("#{error.class}: #{error.message}")
+          puts SearchEngine::Cli::Support.fmt_err(error.backtrace.first(5).join("\n"))
           failure(callable.name, started, error, hint: 'Unexpected error', doc: nil)
         end
       end

data/lib/search_engine/indexer/bulk_import.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'search_engine/logging/color'
+require 'search_engine/logging/batch_line'
 
 module SearchEngine
   class Indexer
@@ -141,7 +142,7 @@ module SearchEngine
           shared_state = initialize_shared_state
           producer_error = nil
 
-          puts('  Starting parallel batch processing...') if log_batches
+          puts(SearchEngine::Logging::Color.dim('  Starting parallel batch processing...')) if log_batches
           started_at = monotonic_ms
 
           # Producer thread: fetch batches lazily and push to queue
@@ -154,15 +155,17 @@ module SearchEngine
               next unless log_batches && (batch_count % 10).zero?
 
               elapsed = (monotonic_ms - started_at).round(1)
-              if total_batches_estimate
-                puts("  Processed #{batch_count}/#{total_batches_estimate} batches... (#{elapsed}ms)")
-              else
-                puts("  Processed #{batch_count} batches... (#{elapsed}ms)")
-              end
+              progress = if total_batches_estimate
+                           "  Processed #{batch_count}/#{total_batches_estimate} batches... (#{elapsed}ms)"
+                         else
+                           "  Processed #{batch_count} batches... (#{elapsed}ms)"
+                         end
+              puts(SearchEngine::Logging::Color.dim(progress))
             end
           rescue StandardError => error
             producer_error = error
-            warn("  Producer failed at batch #{batch_count}: #{error.class}: #{error.message.to_s[0, 200]}")
+            err_msg = "  Producer failed at batch #{batch_count}: #{error.class}: #{error.message.to_s[0, 200]}"
+            warn(SearchEngine::Logging::Color.apply(err_msg, :red))
           ensure
             # Signal completion to all workers
             max_parallel.times { batch_queue.push(sentinel) }
@@ -299,7 +302,8 @@ module SearchEngine
             failure_stat = failure_stats(thread_idx, docs_count, 0, error)
 
             shared_state[:mtx].synchronize do
-              warn("  batch_index=#{thread_idx} → error=#{error.class}: #{error.message.to_s[0, 200]}")
+              err_msg = "  batch_index=#{thread_idx} → error=#{error.class}: #{error.message.to_s[0, 200]}"
+              warn(SearchEngine::Logging::Color.apply(err_msg, :red))
               aggregate_stats([failure_stat], shared_state, batch_size, log_batches)
             end
           end
@@ -572,53 +576,7 @@ module SearchEngine
         end
 
         def log_batch(stats, batch_number)
-          batch_status = batch_status_from_stats(stats)
-          status_color = SearchEngine::Logging::Color.for_status(batch_status)
-
-          prefix = batch_number == 1 ? '  single → ' : '          '
-          line = +prefix
-          line << SearchEngine::Logging::Color.apply("status=#{batch_status}", status_color) << ' '
-          line << "docs=#{stats[:docs_count]}" << ' '
-          success_count = stats[:success_count].to_i
-          success_str = "success=#{success_count}"
-          line << (
-            success_count.positive? ? SearchEngine::Logging::Color.bold(success_str) : success_str
-          ) << ' '
-          failed_count = stats[:failure_count].to_i
-          failed_str = "failed=#{failed_count}"
-          line << (failed_count.positive? ? SearchEngine::Logging::Color.apply(failed_str, :red) : failed_str) << ' '
-          line << "batch=#{batch_number} "
-          line << "duration_ms=#{stats[:duration_ms]}"
-
-          # Extract sample error from batch stats
-          sample_err = extract_batch_sample_error(stats)
-          line << " sample_error=#{sample_err.inspect}" if sample_err
-
-          puts(line)
-        end
-
-        def extract_batch_sample_error(stats)
-          samples = stats[:errors_sample] || stats['errors_sample']
-          return nil unless samples.is_a?(Array) && samples.any?
-
-          samples.each do |msg|
-            s = msg.to_s
-            return s unless s.strip.empty?
-          end
-          nil
-        end
-
-        def batch_status_from_stats(stats)
-          success_count = stats[:success_count].to_i
-          failure_count = stats[:failure_count].to_i
-
-          if failure_count.positive? && success_count.positive?
-            :partial
-          elsif failure_count.positive?
-            :failed
-          else
-            :ok
-          end
+          puts(SearchEngine::Logging::BatchLine.format(stats, batch_number))
         end
       end
     end

data/lib/search_engine/logging/batch_line.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module SearchEngine
+  module Logging
+    # Shared formatter for per-batch log lines during indexation.
+    #
+    # Produces the aligned `single →` / continuation lines used by both
+    # {SearchEngine::Base::IndexMaintenance} and {SearchEngine::Indexer::BulkImport}.
+    #
+    # @since M8
+    module BatchLine
+      FIRST_PREFIX = '  single → '
+      CONTINUATION_PREFIX = '           '
+
+      module_function
+
+      # Format a single batch log line.
+      #
+      # @param stats [Hash] batch statistics with :docs_count, :success_count, :failure_count, :duration_ms, :errors_sample
+      # @param batch_number [Integer] 1-based batch index
+      # @param indifferent [Boolean] when true, also check string keys (for summary hashes)
+      # @return [String]
+      def format(stats, batch_number, indifferent: false)
+        require 'search_engine/logging/color'
+
+        batch_status = status_from_counts(stats, indifferent: indifferent)
+        status_color = SearchEngine::Logging::Color.for_status(batch_status)
+
+        prefix = batch_number == 1 ? FIRST_PREFIX : CONTINUATION_PREFIX
+        line = +prefix
+        line << SearchEngine::Logging::Color.apply("status=#{batch_status}", status_color) << ' '
+        line << "docs=#{fetch_stat(stats, :docs_count, indifferent: indifferent, default: 0)}" << ' '
+
+        success_count = fetch_stat(stats, :success_count, indifferent: indifferent, default: 0).to_i
+        success_str = "success=#{success_count}"
+        line << (success_count.positive? ? SearchEngine::Logging::Color.bold(success_str) : success_str) << ' '
+
+        failed_count = fetch_stat(stats, :failure_count, indifferent: indifferent, default: 0).to_i
+        failed_str = "failed=#{failed_count}"
+        line << (failed_count.positive? ? SearchEngine::Logging::Color.apply(failed_str, :red) : failed_str) << ' '
+
+        line << "batch=#{batch_number} "
+        line << "duration_ms=#{fetch_stat(stats, :duration_ms, indifferent: indifferent, default: 0.0)}"
+
+        sample_err = extract_sample_error(stats, indifferent: indifferent)
+        line << " sample_error=#{sample_err.inspect}" if sample_err
+
+        line
+      end
+
+      # Derive batch status from success/failure counts.
+      # @return [Symbol] :ok, :partial, or :failed
+      def status_from_counts(stats, indifferent: false)
+        success = fetch_stat(stats, :success_count, indifferent: indifferent, default: 0).to_i
+        failure = fetch_stat(stats, :failure_count, indifferent: indifferent, default: 0).to_i
+
+        if failure.positive? && success.positive?
+          :partial
+        elsif failure.positive?
+          :failed
+        else
+          :ok
+        end
+      end
+
+      # Extract first non-blank sample error message.
+      # @return [String, nil]
+      def extract_sample_error(stats, indifferent: false)
+        samples = fetch_stat(stats, :errors_sample, indifferent: indifferent, default: nil)
+        return nil unless samples.is_a?(Array) && samples.any?
+
+        samples.each do |msg|
+          s = msg.to_s
+          return s unless s.strip.empty?
+        end
+        nil
+      end
+
+      # @api private
+      def fetch_stat(stats, key, indifferent: false, default: nil)
+        val = stats[key]
+        val = stats[key.to_s] if val.nil? && indifferent
+        val.nil? ? default : val
+      end
+
+      private_class_method :fetch_stat
+    end
+  end
+end

data/lib/search_engine/logging/color.rb

@@ -12,7 +12,7 @@ module SearchEngine
       module_function
 
       # @param str [String]
-      # @param color [Symbol] one of :green, :yellow, :red
+      # @param color [Symbol] one of :green, :yellow, :red, :cyan
       # @return [String]
       def apply(str, color)
         return str unless enabled?
@@ -21,6 +21,7 @@ module SearchEngine
                when :green then 32
                when :yellow then 33
                when :red then 31
+               when :cyan then 36
                else 0
                end
         return str if code.zero?
@@ -37,6 +38,22 @@ module SearchEngine
         "\e[1m#{str}\e[0m"
       end
 
+      # Apply dim styling to de-emphasize text (skip/no-op states).
+      # @param str [String]
+      # @return [String]
+      def dim(str)
+        return str unless enabled?
+
+        "\e[2m#{str}\e[0m"
+      end
+
+      # Bold text for section headers (>>>>>> lines).
+      # @param str [String]
+      # @return [String]
+      def header(str)
+        bold(str)
+      end
+
       # Map indexation status to a color.
       # @param status [#to_s]
       # @return [Symbol] color name

data/lib/search_engine/version.rb

@@ -3,5 +3,5 @@
 module SearchEngine
   # Current gem version.
   # @return [String]
-  VERSION = '30.1.6.3'
+  VERSION = '30.1.6.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: search-engine-for-typesense
 version: !ruby/object:Gem::Version
-  version: 30.1.6.3
+  version: 30.1.6.4
 platform: ruby
 authors:
 - Nikita Shkoda
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-23 00:00:00.000000000 Z
+date: 2026-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -153,6 +153,7 @@ files:
 - lib/search_engine/instrumentation.rb
 - lib/search_engine/joins/guard.rb
 - lib/search_engine/joins/resolver.rb
+- lib/search_engine/logging/batch_line.rb
 - lib/search_engine/logging/color.rb
 - lib/search_engine/logging/format_helpers.rb
 - lib/search_engine/logging/partition_progress.rb