sbmt-outbox 7.0.1 → 7.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f929127e2a4e45dd88bde6fe1115b13651532fe5f9fa1a0c0112dbeba2111036
-  data.tar.gz: f9368bb61d59199f5d73ccd0634dbad6c2a7b06817d94bbdfe0ea50fd5357db7
+  metadata.gz: 751fcef19c53ff5a38d589d0dac8d5a1007335faec5fd710b1fb1e69f2ea25ef
+  data.tar.gz: a12ec44b3c6774b0ff72503f60a645ba3b2a8d52ed28a70d85e51041ef17e2d8
 SHA512:
-  metadata.gz: b4e3b29dc6495d129aa8beac3e99d5f5bff4fd07891775192c761556ea25f24fbf2471f88ab173ec2efc3106210a8b036545ce26c6c552ecc8699a0464a1d6f1
-  data.tar.gz: ada7866bbef15b69b85b5fc7572a305f0ab0d9b603a3d8cf97ca91f4e6802e54d69c841f6ae414d1080eca7f7c890979fc6c0e8f2009874e2608322706af5af8
+  metadata.gz: ecfeecc1840db0694c89a950e35f30fe917b7ce7dbf7ad522f65c27ac1f0d3dceda550ff879b246683d795d5c6add96e9ea785cab89e0ee2dbbdec32f59c8746
+  data.tar.gz: 66c2b31e030041587f6e88ee2e35ae960f4e0a274128d10f770856b44302bdb805c5f89c0bc159d75b5349e9ecb75c0f54a71e676ee082fc5d09223dc060a78c

data/app/jobs/sbmt/outbox/base_delete_stale_items_job.rb

@@ -234,7 +234,7 @@ module Sbmt
           .outbox
           .delete_latency
           .measure({box_type: box_type, box_name: box_name}) do
-          yield
+            yield
         end
       end
     end

data/app/models/sbmt/outbox/base_item.rb

@@ -34,8 +34,8 @@ module Sbmt
         def calc_bucket_partitions(count)
           (0...count).to_a
             .index_with do |x|
-            (0...config.bucket_size).to_a
-              .select { |p| p % count == x }
+              (0...config.bucket_size).to_a
+                .select { |p| p % count == x }
           end
         end
 

data/lib/sbmt/outbox/error_tracker.rb

@@ -5,10 +5,8 @@ module Sbmt
     class ErrorTracker
       class << self
         def error(message, params = {})
-          unless defined?(Sentry)
-            Outbox.logger.log_error(message, **params)
-            return
-          end
+          Outbox.logger.log_error(message, **params)
+          return unless defined?(Sentry)
 
           Sentry.with_scope do |scope|
             scope.set_contexts(contexts: params)

data/lib/sbmt/outbox/v2/box_processor.rb

@@ -21,7 +21,11 @@ module Sbmt
             concurrency: threads_count,
             name: "#{name}_thread_pool"
           ) do
-            queue.pop
+            logger.log_debug("#{name}_thread_pool: requesting next task from queue")
+            task = queue.pop
+            logger.log_debug("#{name}_thread_pool: received task #{task&.item_class&.box_name}")
+
+            task
           end
 
           @started = false
@@ -30,10 +34,15 @@ module Sbmt
         end
 
         def start
+          logger.log_info("#{worker_name}: starting with #{@threads_count} threads")
+
           raise "#{worker_name} is already started" if started
           @started = true
 
+          logger.log_info("#{worker_name}: starting thread pool")
           thread_pool.start do |worker_number, scheduled_task|
+            logger.log_debug("#{worker_name}: worker #{worker_number} processing scheduled task for box #{scheduled_task&.item_class&.box_name}")
+
             result = ThreadPool::PROCESSED
             last_result = Thread.current[:last_polling_result]
 
@@ -47,7 +56,9 @@ module Sbmt
                 box_worker.job_execution_runtime.measure(labels) do
                   ::Rails.application.executor.wrap do
                     logger.with_tags(**locked_task.log_tags) do
+                      logger.log_debug("#{worker_name}: worker #{worker_number} processing locked task")
                       result = safe_process_task(worker_number, locked_task)
+                      logger.log_debug("#{worker_name}: worker #{worker_number} completed locked task")
                     end
                   end
                 end
@@ -58,31 +69,62 @@ module Sbmt
               box_worker.job_counter.increment(base_labels.merge(state: locked_task ? "processed" : "skipped"), by: 1)
             end
 
+            logger.log_debug("#{worker_name}: worker #{worker_number} finished processing")
             Thread.current[:last_polling_result] = result || ThreadPool::PROCESSED
           ensure
+            logger.log_debug("#{worker_name}: returning task to queue")
             queue << scheduled_task
           end
         rescue => e
+          logger.log_error("#{worker_name}: thread pool encountered error during start: #{e.inspect}")
           Outbox.error_tracker.error(e)
           raise
         end
 
         def stop
+          logger.log_info("#{worker_name}: stopping worker")
           @started = false
           @thread_pool.stop
+          logger.log_info("#{worker_name}: worker stopped")
         end
 
         def ready?
-          started && @thread_pool.running?
+          logger.log_debug("#{worker_name}: checking if ready")
+          unless started
+            logger.log_debug("#{worker_name}: checking if ready: not started")
+            return false
+          end
+
+          result = @thread_pool.running?
+          unless result
+            logger.log_debug("#{worker_name}: checking if ready: thread_pool is not running")
+            return false
+          end
+
+          logger.log_debug("#{worker_name}: ready? #{result}")
+          result
         end
 
         def alive?(timeout)
-          return false unless ready?
+          logger.log_debug("#{worker_name}: checking if alive with timeout #{timeout}")
 
-          @thread_pool.alive?(timeout)
+          unless ready?
+            logger.log_debug("#{worker_name}: checking if alive: not ready")
+            return false
+          end
+
+          result = @thread_pool.alive?(timeout)
+          unless result
+            logger.log_info("#{worker_name}: checking if alive: thread_pool is not alive")
+            return false
+          end
+
+          logger.log_debug("#{worker_name}: alive? #{result}")
+          result
         end
 
         def safe_process_task(worker_number, task)
+          logger.log_debug("#{worker_name}: safely processing task for worker #{worker_number}")
           process_task(worker_number, task)
         rescue => e
           log_fatal(e, task)
@@ -103,6 +145,8 @@ module Sbmt
         attr_accessor :queue, :thread_pool, :redis, :lock_manager
 
         def init_redis(redis)
+          logger.log_info("#{worker_name}: initializing Redis connection")
+
           self.redis = redis || ConnectionPool::Wrapper.new(size: threads_count) { RedisClientFactory.build(config.redis) }
 
           client = if Gem::Version.new(Redlock::VERSION) >= Gem::Version.new("2.0.0")
@@ -112,6 +156,7 @@ module Sbmt
           end
 
           self.lock_manager = Redlock::Client.new([client], retry_count: 0)
+          logger.log_info("#{worker_name}: Redis initialized")
         end
 
         def lock_task(scheduled_task)
@@ -124,8 +169,8 @@ module Sbmt
             Tasks::Default.new(item_class: item_class, worker_name: worker_name)
           end
 
+          logger.log_debug("#{worker_name}: building task queue with #{scheduled_tasks.length} tasks")
           scheduled_tasks.shuffle!
-
           Queue.new.tap { |queue| scheduled_tasks.each { |task| queue << task } }
         end
 

data/lib/sbmt/outbox/v2/processor.rb

@@ -105,6 +105,7 @@ module Sbmt
           RedisJob.deserialize!(result)
         rescue => ex
           logger.log_error("error while fetching redis job: #{ex.message}")
+          nil
         end
 
         def redis_block_timeout

data/lib/sbmt/outbox/v2/thread_pool.rb

@@ -28,6 +28,7 @@ module Sbmt
 
             if task == BREAK
               self.stopped = true
+              logger.log_debug("#{name}: received BREAK signal, stopping thread pool")
               return
             end
 
@@ -47,35 +48,54 @@ module Sbmt
             end
           end
 
-          logger.log_info("#{name}: threads started")
+          logger.log_info("#{name}: thread pool started with #{concurrency} threads")
 
           raise result if result.is_a?(Exception)
         end
 
         def stop
+          logger.log_info("#{name}: stopping thread pool")
           self.stopped = true
 
           threads.map(&:join) if start_async
         ensure
           stop_threads
+          logger.log_info("#{name}: thread pool stopped")
         end
 
         def running?
-          return false if stopped
+          if stopped
+            logger.log_info("#{name}: checking if running: stopped")
+            return false
+          end
 
           true
         end
 
         def alive?(timeout)
-          return false if stopped
+          if stopped
+            logger.log_info("#{name}: checking if alive: stopped")
+            return false
+          end
 
           deadline = Time.current - timeout
-          threads.all? do |thread|
+          alive_threads = threads.select do |thread|
+            next false unless thread.alive?
+
             last_active_at = last_active_at(thread)
-            return false unless last_active_at
+            if last_active_at
+              deadline < last_active_at
+            else
+              false
+            end
+          end
 
-            deadline < last_active_at
+          unless alive_threads.length == concurrency
+            logger.log_info("#{name}: checking if alive: false, only #{alive_threads.length}/#{concurrency} threads alive")
+            return false
           end
+
+          true
         end
 
         private
@@ -98,6 +118,7 @@ module Sbmt
           exception = nil
 
           in_threads do |worker_num|
+            logger.log_debug("#{name}: worker #{worker_num} starting")
             self.worker_number = worker_num
             # We don't want to start all threads at the same time
             sleep(rand * (worker_num + 1)) if random_startup_delay
@@ -113,30 +134,39 @@ module Sbmt
               begin
                 yield task
               rescue Exception => e # rubocop:disable Lint/RescueException
+                logger.log_error("#{name}: worker #{worker_num} caught exception in task: #{e.class} - #{e.message}")
                 exception = e
               end
             end
           end
 
+          logger.log_info("#{name}: run_threads completed, exception: #{exception&.inspect}")
           exception
         end
 
         def in_threads
           Thread.handle_interrupt(Exception => :never) do
             Thread.handle_interrupt(Exception => :immediate) do
+              logger.log_info("#{name}: creating #{concurrency} threads")
               concurrency.times do |i|
                 threads << Thread.new { yield(i) }
               end
               threads.map(&:value) unless start_async
             end
           ensure
+            logger.log_debug("#{name}: in_threads ensuring stop_threads")
             stop_threads unless start_async
           end
         end
 
         def stop_threads
-          threads.each(&:kill)
+          logger.log_debug("#{name}: stop_threads called, clearing #{threads.length} threads")
+          threads.each do |thread|
+            logger.log_debug("#{name}: killing thread #{thread.object_id}")
+            thread.kill
+          end
           threads.clear
+          logger.log_debug("#{name}: stop_threads completed")
         end
 
         def worker_number=(num)

data/lib/sbmt/outbox/version.rb

@@ -2,6 +2,6 @@
 
 module Sbmt
   module Outbox
-    VERSION = "7.0.1"
+    VERSION = "7.0.2"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sbmt-outbox
 version: !ruby/object:Gem::Version
-  version: 7.0.1
+  version: 7.0.2
 platform: ruby
 authors:
 - Sbermarket Ruby-Platform Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-27 00:00:00.000000000 Z
+date: 2026-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -627,7 +627,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Outbox service