tobox 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0481835fffcdbaf85fb53ebf116a6b117ad267cfb4a4efbcbae05b2f87058951'
-  data.tar.gz: 39589407d92d28fc538aebb59a039a606d833aeb0eb26f82b7cf96228e73d5b3
+  metadata.gz: 15d95687a102c98fcc33859b3a369dc9026f04fa58f7f785bcad1d9ccb40010f
+  data.tar.gz: 656b296f9d72d67877945317d4a6d5505de63044f74e08c506970b2c841599f4
 SHA512:
-  metadata.gz: 8a1137598cc58cb22573ccbec80f448aa55db3505a97b741cc146eaef6f16392ba3159b9db9f61498cea530dba33c431bba4f9c847325064a770a96553d9ec20
-  data.tar.gz: 274be354130a8ae5ab59188ad98c4de208adac78cd7c9720b569db98de75d2ec0514a2560db05c080b9118e6967b573b7ea1fd11b0297edf9c07f05478acbefe
+  metadata.gz: 172b54fd340f865dbc26a30266f815fe556424cd150c8205c872da02d3725def786648710097b0880de41cc16940a39bd34c8592049d22a907d527ff84b26a3a
+  data.tar.gz: 1dafbf50e8d18c4eb7f4dfd31539322230bd1d11d403f250e4612a0579e878c366fe6b2d44eb24ae17f32476bd25994457563d3fd5ef1a46d7499dc92a93ee1d

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [0.5.1] - 2024-09-26
+
+### Improvements
+
+* Refactoring of management of event id which replaces `SELECT id IN (?)` resulting queries with `SELECT id = ?`.
+* Process shutdown is now more predictable, also in the grace period.
+  * `grace_shutdown_timeout` is a new configuration, by default 5 (seconds).
+
 ## [0.5.0] - 2024-09-16
 
 ### Features

data/README.md

@@ -241,6 +241,10 @@ Time (in seconds) to wait before checking again for events in the outbox.
 
 Time (in seconds) to wait for events to finishing processing, before hard-killing the process.
 
+### `grace_shutdown_timeout`
+
+Grace period (in seconds) to wait after, hard-killing the work in progress, and before exiting the process.
+
 ### `on(event_type) { |before, after| }`
 
 callback executed when processing an event of the given type. By default, it'll yield the state of data before and after the event (unless `message_to_arguments` is set).
@@ -583,6 +587,7 @@ on_stats(5) do |stats_collector| # every 5 seconds
   # now you can send them to your statsd collector
   #
   StatsD.gauge('outbox_pending_backlog', stats[:pending_count])
+  StatsD.gauge('outbox_oldest_message_age', stats[:oldest_event_age_in_seconds])
 end
 ```
 

data/lib/tobox/cli.rb

@@ -108,12 +108,18 @@ module Tobox
           opts[:tag] = arg
         end
 
-        o.on "-t", "--shutdown-timeout NUM", Integer, "Shutdown timeout (in seconds)" do |arg|
+        o.on "-t", "--shutdown-timeout NUM", Float, "Shutdown timeout (in seconds)" do |arg|
           raise ArgumentError, "must be positive" unless arg.positive?
 
           opts[:shutdown_timeout] = arg
         end
 
+        o.on "-g", "--shutdown-grace-timeout NUM", Float, "Shutdown grace timeout (in seconds)" do |arg|
+          raise ArgumentError, "must be positive" unless arg.positive?
+
+          opts[:grace_shutdown_timeout] = arg
+        end
+
         o.on "--verbose", "Print more verbose output" do |arg|
           opts[:verbose] = arg
         end

data/lib/tobox/configuration.rb

@@ -24,6 +24,7 @@ module Tobox
       exponential_retry_factor: 2,
       wait_for_events_delay: 5,
       shutdown_timeout: 10,
+      grace_shutdown_timeout: 5,
       concurrency: 4, # TODO: CPU count
       worker: :thread
     }.freeze

data/lib/tobox/fetcher.rb

@@ -38,27 +38,20 @@ module Tobox
     def fetch_events(&blk)
       num_events = 0
       events_tr do
-        event_ids = EMPTY
+        event_id = nil
 
-        event_ids_tr do
-          event_ids = fetch_event_ids
-          mark_as_fetched(event_ids)
+        event_id_tr do
+          event_id = fetch_event_id
+          mark_as_fetched(event_id) if event_id
         end
 
-        evts = nil
+        if event_id
+          with_event(event_id) do |event|
+            num_events = 1
 
-        unless event_ids.empty?
-          with_events(event_ids) do |events|
-            evts = events
-            num_events = events.count
-
-            evts = events.filter_map do |ev|
-              prepare_event(ev, &blk)
-            end
+            prepare_event(event, &blk)
           end
         end
-
-        return 0 if evts.nil?
       end
 
       num_events
@@ -70,56 +63,52 @@ module Tobox
       event[:metadata] = try_json_parse(event[:metadata])
       handle_before_event(event)
       yield(to_message(event))
-      event
     end
 
-    def fetch_event_ids
+    def fetch_event_id
       @pick_next_sql.for_update
                     .skip_locked
-                    .limit(1).select_map(:id) # lock starts here
+                    .limit(1).select_map(:id).first # lock starts here
     end
 
-    def mark_as_fetched(event_ids)
-      @ds.where(id: event_ids).update(@mark_as_fetched_params) unless event_ids.empty?
+    def mark_as_fetched(event_id)
+      @ds.where(id: event_id).update(@mark_as_fetched_params)
     end
 
     def events_tr(&block)
       @db.transaction(savepoint: false, &block)
     end
 
-    def event_ids_tr
+    def event_id_tr
       yield
     end
 
-    def with_events(event_ids, &blk)
-      events, error = yield_events(event_ids, &blk)
+    def with_event(event_id, &blk)
+      event, error = yield_event(event_id, &blk)
 
-      events.each do |event|
-        if error
-          event.merge!(mark_as_error(event, error))
-          handle_error_event(event, error)
-        else
-          handle_after_event(event)
-        end
+      if error
+        event.merge!(mark_as_error(event, error))
+        handle_error_event(event, error)
+      else
+        handle_after_event(event)
       end
     end
 
-    def yield_events(event_ids)
-      events_ds = @ds.where(id: event_ids)
-      events = EMPTY
-      error = nil
+    def yield_event(event_id)
+      events_ds = @ds.where(id: event_id)
+      event = error = nil
 
       begin
-        events = events_ds.all
+        event = events_ds.first
 
-        yield events
+        yield event
 
         events_ds.delete
       rescue StandardError => e
         error = e
       end
 
-      [events, error]
+      [event, error]
     end
 
     def log_message(msg)

data/lib/tobox/plugins/event_grouping.rb

@@ -16,7 +16,7 @@ module Tobox
 
         private
 
-        def fetch_event_ids
+        def fetch_event_id
           group = @pick_next_sql.for_update
                                 .skip_locked
                                 .limit(1)
@@ -37,7 +37,7 @@ module Tobox
           end
 
           # lock all, process 1
-          event_ids[0, 1]
+          event_ids.first
         end
       end
     end

data/lib/tobox/plugins/progress.rb

@@ -23,7 +23,7 @@ module Tobox
           yield
         end
 
-        def event_ids_tr(&block)
+        def event_id_tr(&block)
           @db.transaction(savepoint: false, &block)
         end
       end

data/lib/tobox/pool/fiber_pool.rb

@@ -5,34 +5,74 @@ require "fiber_scheduler"
 
 module Tobox
   class FiberPool < Pool
-    def initialize(_configuration)
+    def initialize(_)
       Sequel.extension(:fiber_concurrency)
       super
+      @fibers = []
+
+      @fiber_mtx = Mutex.new
+      @fiber_cond = ConditionVariable.new
+      @fiber_thread = nil
     end
 
     def start
       @fiber_thread = Thread.start do
         Thread.current.name = "tobox-fibers-thread"
 
-        FiberScheduler do
-          @workers.each_with_index do |wk, _idx|
-            Fiber.schedule { do_work(wk) }
+        begin
+          FiberScheduler do
+            @fiber_mtx.synchronize do
+              @workers.each do |worker|
+                @fibers << start_fiber_worker(worker)
+              end
+              @fiber_cond.signal
+            end
           end
+        rescue KillError
+          @fibers.each { |f| f.raise(KillError) }
         end
       end
+      @fiber_mtx.synchronize do
+        @fiber_cond.wait(@fiber_mtx)
+      end
     end
 
     def stop
       shutdown_timeout = @configuration[:shutdown_timeout]
+      grace_shutdown_timeout = @configuration[:grace_shutdown_timeout]
 
       super
 
-      begin
-        Timeout.timeout(shutdown_timeout) { @fiber_thread.value }
-      rescue Timeout::Error
-        # hard exit
-        @fiber_thread.raise(KillError)
-        @fiber_thread.value
+      @fiber_thread.join(shutdown_timeout)
+
+      return unless @fiber_thread.alive?
+
+      @fiber_thread.raise(KillError)
+      @fiber_thread.join(grace_shutdown_timeout)
+      @fiber_thread.kill
+      @fiber_thread.join(1)
+    end
+
+    private
+
+    def start_fiber_worker(worker)
+      Fiber.schedule do
+        do_work(worker)
+
+        @fiber_mtx.synchronize do
+          @fibers.delete(Fiber.current)
+
+          if worker.finished? && @running
+            idx = @workers.index(worker)
+
+            raise Error, "worker not found" unless idx
+
+            subst_worker = Worker.new(worker.label, @configuration)
+            @workers[idx] = subst_worker
+            subst_fiber = start_fiber_worker(subst_worker)
+            @fiber_mtx.synchronize { @fibers << subst_fiber }
+          end
+        end
       end
     end
   end

data/lib/tobox/pool/threaded_pool.rb

@@ -22,24 +22,35 @@ module Tobox
 
     def stop
       shutdown_timeout = @configuration[:shutdown_timeout]
-
-      deadline = Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      grace_shutdown_timeout = @configuration[:grace_shutdown_timeout]
 
       super
       Thread.pass # let workers finish
 
       # soft exit
-      while Process.clock_gettime(::Process::CLOCK_MONOTONIC) - deadline < shutdown_timeout
-        return if @threads.empty?
+      join = lambda do |timeout|
+        start = Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+
+        loop do
+          terminating_th = @threads.synchronize { @threads.first }
+
+          return unless terminating_th
+
+          elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
 
-        sleep 0.5
+          break if elapsed > timeout
+
+          terminating_th.join(timeout - elapsed)
+        end
       end
 
+      join.call(shutdown_timeout)
+
       # hard exit
-      @threads.each { |th| th.raise(KillError) }
-      while (th = @threads.pop)
-        th.value # waits
-      end
+      @threads.synchronize { @threads.each { |th| th.raise(KillError) } }
+      join.call(grace_shutdown_timeout)
+      @threads.synchronize { @threads.each(&:kill) }
+      join.call(1)
     end
 
     private
@@ -63,8 +74,6 @@ module Tobox
             subst_thread = start_thread_worker(subst_worker)
             @threads << subst_thread
           end
-          # all workers went down abruply, we need to kill the process.
-          # @parent_thread.raise(Interrupt) if wk.finished? && @threads.empty? && @running
         end
       end
     end

data/lib/tobox/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tobox
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tobox
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - HoneyryderChuck
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-16 00:00:00.000000000 Z
+date: 2024-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel