search-engine-for-typesense 30.1.6.3 → 30.1.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 228f70410334d2a324508d0d44dfd31aadbcb4a957f28425909108490a3129a2
-  data.tar.gz: 89fd3243af9aec91757d9819136ce9b0fd783845ff1ff6e6fe72467106d20ecb
+  metadata.gz: 933b8b58a98c81e8e6b72f3083cfcf2ee1de5ea9f709d4c10aea5d09dba59d99
+  data.tar.gz: 626111c57bc0ee533d21938d7a218c13b80cc23aa27827731994a968f97de672
 SHA512:
-  metadata.gz: 42e556e2b25d40fd5ba85cb1ae1961223420d6affb6f532936642a48159dc013a8297398cba3724ef798f2cab05a0819140c9038d415b0035c7f9a95b2408e07
-  data.tar.gz: ea3aba9866079ade74da2712d73f6e2a7169cc0a013dff5814ccbc7034789e9f2d6ae38979e49761210e46e4a61f329fde3ae9bb356f02b643b14899a0d24d9d
+  metadata.gz: 3e4456f56ddd18865793f0d61890967ba53e50eac9d2b573362800ed0f509aad397bc9233b4f4a0d308e5a9dadfc0a0aac9e9ca946516b638f5eee0a4728fa3b
+  data.tar.gz: 80133e73075e0047968ed9afb3d7756eb5cf47aadeb1c1bbb73d332ee2d44c61e0cc6e6fb5b8932f23ab280f8259319c36d16c288e7d3817a0fdc3844fcde24a

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

@@ -45,18 +45,19 @@ 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? }
+            step = SearchEngine::Logging::StepLine.new('Cleanup')
             if filters.empty?
-              puts('Cleanup — skip (no stale configuration)')
+              step.skip('no stale configuration')
               return 0
             end
 
             merged_filter = SearchEngine::StaleRules.merge_filters(filters)
-            puts("Cleanup — filter=#{merged_filter.inspect}")
+            step.update("filter=#{merged_filter.inspect}")
 
             deleted = SearchEngine::Deletion.delete_by(
               klass: self,
@@ -65,25 +66,24 @@ module SearchEngine
               partition: partition
             )
 
-            puts("Cleanup — deleted=#{deleted}")
+            step.finish("deleted=#{deleted}")
             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
+            step&.close
             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,8 @@ module SearchEngine
 
             diff = SearchEngine::Schema.diff(self, client: client)[:diff] || {}
             missing = __se_schema_missing?(diff)
-            puts("Step 1: Presence — processing → #{missing ? 'missing' : 'present'}")
+            step = SearchEngine::Logging::StepLine.new('Presence')
+            missing ? step.finish_warn('missing') : step.finish('present')
 
             applied, indexed_inside_apply = __se_full_apply_if_missing(client, missing)
             drift = __se_full_check_drift(diff, missing, force_rebuild)
@@ -75,72 +76,90 @@ module SearchEngine
           def __se_full_apply_if_missing(client, missing)
             applied = false
             indexed_inside_apply = false
+            step = SearchEngine::Logging::StepLine.new('Schema')
             if missing
-              puts('Step 2: Create+Apply Schema — processing')
+              step.update('creating')
               SearchEngine::Schema.apply!(self, client: client) do |new_physical|
+                step.yield_line!
                 indexed_inside_apply = __se_index_partitions!(into: new_physical)
               end
               applied = true
-              puts('Step 2: Create+Apply Schema — done')
+              step.finish('created')
             else
-              puts('Step 2: Create+Apply Schema — skip (collection present)')
+              step.skip('collection present')
             end
             [applied, indexed_inside_apply]
+          ensure
+            step&.close
           end
 
           def __se_full_check_drift(diff, missing, force_rebuild)
+            step = SearchEngine::Logging::StepLine.new('Schema Status')
             unless missing
-              puts('Step 3: Check Schema Status — processing')
+              step.update('checking')
               drift = __se_schema_drift?(diff)
               if force_rebuild && !drift
-                puts('Step 3: Check Schema Status — force_rebuild')
+                step.finish_warn('force_rebuild')
                 return true
               end
-              puts("Step 3: Check Schema Status — #{drift ? 'drift' : 'in_sync'}")
+              drift ? step.finish_warn('drift') : step.finish('in_sync')
               return drift
             end
-            puts('Step 3: Check Schema Status — skip (just created)')
+            step.skip('just created')
             false
+          ensure
+            step&.close
           end
 
           def __se_full_apply_if_drift(client, drift, applied, indexed_inside_apply, force_rebuild)
+            step = SearchEngine::Logging::StepLine.new('Schema Apply')
             if drift
-              puts('Step 4: Apply New Schema — processing')
+              step.update('applying')
               SearchEngine::Schema.apply!(self, client: client, force_rebuild: force_rebuild) do |new_physical|
+                step.yield_line!
                 indexed_inside_apply = __se_index_partitions!(into: new_physical)
               end
               applied = true
-              puts('Step 4: Apply New Schema — done')
+              step.finish('applied')
             else
-              puts('Step 4: Apply New Schema — skip')
+              step.skip
             end
             [applied, indexed_inside_apply]
+          ensure
+            step&.close
           end
 
           def __se_full_indexation(applied, indexed_inside_apply)
             result = nil
+            step = SearchEngine::Logging::StepLine.new('Indexing')
             if applied && indexed_inside_apply
-              puts('Step 5: Indexing — skip (performed during schema apply)')
+              step.skip('performed during schema apply')
               result = indexed_inside_apply if indexed_inside_apply.is_a?(Hash)
             else
-              puts('Step 5: Indexing — processing')
+              step.update('indexing')
+              step.yield_line!
               result = __se_index_partitions!(into: nil)
-              puts('Step 5: Indexing — done')
+              step.finish('done')
             end
 
             cascade_ok = result.is_a?(Hash) ? result[:status] == :ok : false
             __se_cascade_after_indexation!(context: :full) if cascade_ok
             result
+          ensure
+            step&.close
           end
 
           def __se_full_retention(applied, logical, client)
+            step = SearchEngine::Logging::StepLine.new('Retention')
             if applied
-              puts('Step 6: Retention Cleanup — skip (handled by schema apply)')
+              step.skip('handled by schema apply')
             else
-              puts('Step 6: Retention Cleanup — processing')
+              step.update('cleaning')
               dropped = __se_retention_cleanup!(logical: logical, client: client)
-              puts("Step 6: Retention Cleanup — dropped=#{dropped.inspect}")
+              step.finish("dropped=#{dropped.inspect}")
             end
+          ensure
+            step&.close
           end
 
           def __se_index_partial(partition:, client:, pre: nil)
@@ -149,70 +168,76 @@ module SearchEngine
             diff = diff_res[:diff] || {}
 
             missing = __se_schema_missing?(diff)
-            puts("Step 1: Presence — processing → #{missing ? 'missing' : 'present'}")
+            step = SearchEngine::Logging::StepLine.new('Presence')
             if missing
-              puts('Partial: collection is not present. Quit early.')
+              step.finish_warn('missing — collection not present, exit early')
               return { status: :failed, docs_total: 0, success_total: 0, failed_total: 0,
                        sample_error: 'Collection not present' }
             end
+            step.finish('present')
 
-            puts('Step 2: Check Schema Status — processing')
+            step = SearchEngine::Logging::StepLine.new('Schema Status')
+            step.update('checking')
             drift = __se_schema_drift?(diff)
             if drift
-              puts('Partial: schema is not up-to-date. Exit early (run full indexing).')
+              step.finish_warn('drift — exit early (run full indexing)')
               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')
+            step.finish('in_sync')
 
             __se_preflight_dependencies!(mode: pre, client: client) if pre
 
-            puts('Step 3: Partial Indexing — processing')
+            step = SearchEngine::Logging::StepLine.new('Partial Indexing')
+            step.update('indexing')
+            step.yield_line!
             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')
+            step.finish('done')
 
             result = __se_build_index_result(summaries)
             __se_cascade_after_indexation!(context: :full) if result[:status] == :ok
             result
+          ensure
+            step&.close
           end
 
           # rubocop:disable Metrics/PerceivedComplexity, Metrics/AbcSize
           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 +258,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

@@ -27,23 +27,24 @@ module SearchEngine
 
           def update_collection!
             client = SearchEngine.client
-
-            puts 'Update Collection — analyzing diff for in-place update...'
+            step = SearchEngine::Logging::StepLine.new('Update Collection')
+            step.update('analyzing diff')
             updated = SearchEngine::Schema.update!(self, client: client)
 
             if updated
-              puts 'Update Collection — schema updated in-place (PATCH)'
+              step.finish('updated in-place (PATCH)')
             else
-              puts 'Update Collection — in-place update not possible (no changes or incompatible)'
+              step.skip('no changes or incompatible')
             end
             updated
+          ensure
+            step&.close
           end
 
           def drop_collection!
             client = SearchEngine.client
             logical = respond_to?(:collection) ? collection.to_s : name.to_s
 
-            # Resolve alias with a safer timeout for control-plane operations
             alias_target = client.resolve_alias(logical, timeout_ms: 10_000)
             physical = if alias_target && !alias_target.to_s.strip.empty?
                          alias_target.to_s
@@ -52,19 +53,21 @@ module SearchEngine
                          live ? logical : nil
                        end
 
+            step = SearchEngine::Logging::StepLine.new('Drop Collection')
             if physical.nil?
-              puts('Drop Collection — skip (not present)')
+              step.skip('not present')
               return
             end
 
             puts
-            puts(%(>>>>>> Dropping Collection "#{logical}"))
-            puts("Drop Collection — processing (logical=#{logical} physical=#{physical})")
-            # Use an extended timeout to accommodate large collection drops
+            puts(SearchEngine::Logging::Color.header(%(>>>>>> Dropping Collection "#{logical}")))
+            step.update("dropping (logical=#{logical} physical=#{physical})")
             client.delete_collection(physical, timeout_ms: 60_000)
-            puts('Drop Collection — done')
-            puts(%(>>>>>> Dropped Collection "#{logical}"))
+            step.finish('done')
+            puts(SearchEngine::Logging::Color.header(%(>>>>>> Dropped Collection "#{logical}")))
             nil
+          ensure
+            step&.close
           end
 
           def recreate_collection!
@@ -79,18 +82,21 @@ module SearchEngine
                          live ? logical : nil
                        end
 
+            step = SearchEngine::Logging::StepLine.new('Recreate Collection')
             if physical
-              puts("Recreate Collection — dropping existing (logical=#{logical} physical=#{physical})")
+              step.update("dropping existing (logical=#{logical} physical=#{physical})")
               client.delete_collection(physical)
             else
-              puts('Recreate Collection — no existing collection (skip drop)')
+              step.update("creating (logical=#{logical})")
             end
 
             schema = SearchEngine::Schema.compile(self)
-            puts("Recreate Collection — creating collection with schema (logical=#{logical})")
+            step.update("creating with schema (logical=#{logical})")
             client.create_collection(schema)
-            puts('Recreate Collection — done')
+            step.finish('done')
             nil
+          ensure
+            step&.close
           end
 
           def __se_retention_cleanup!(_logical:, _client:)