sidekiq-ratomic-pool 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73e5869196bd322f91cea20c1332e39b2c2e3c9d81e99717ac74210fb766be36
-  data.tar.gz: 4b830bdc58727ba25cc653011bf52d1394d2344ad5de996a7f20965b9b404e57
+  metadata.gz: 3c1be6120972266a46da7e3b1646f695b015be76d366c231374d47d93aae1ac6
+  data.tar.gz: 85b6f68ea11bcc778afd3874551577b364bda3af6b5e8e9084c9e249ee18f85b
 SHA512:
-  metadata.gz: 6272ccc17b365724a851f3d6b39cb82d4ce109068cc854a640ab0b649f2c062bf4ee6afdeccf0c6e442789dfe03be411eb3bf8abd8dab2da36d8f9b5f8d09e00
-  data.tar.gz: 71f001b3aca75e43792bf760795d037a6f7a220eb15de33da7b1802eab89e976186ebce147f6eeb21f95e88c702ffd05c8309b06a410831609b58ff613133417
+  metadata.gz: 065052f3df563140c3928c37d4c4953ab4c1297760aa046ec6c91cd41e90b6debefa4aea28b13399975c4556b50a59e986127cd70bf4f060652a6579cdc13f5b
+  data.tar.gz: a045612004cdd32f615e4dfbb4eacab6240257d06ae68ecaa02d322a479933d24c1f1a202339effc8d61c07f9b9502ccf175adcc337d6e19918e3b1382a52605

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [Unreleased]
 
+## [0.2.0] - 2026-08-25
+
+- Added a real Redis-backed `smoke_test/` harness with standalone Sidekiq client
+  and server examples, Docker Compose Redis, and process/thread scheduling output.
+- Made the middleware compatible with Sidekiq's per-job middleware instantiation
+  by sharing each configured pool runtime across middleware instances.
+- Added support for Sidekiq-style positional middleware options and validation for
+  unknown options.
+- Added smoke coverage for multi-threaded job processing across visible CPUs.
+
+## [0.1.0] - 2026-08-24
+
 - Added Sidekiq middleware with Ratomic `LocalPool` resource injection,
   health validation, exponential retries, and circuit-breaker fast failure.
 - Added thread-boundary pool behavior tests and synchronized RBS signatures for the

data/README.md

@@ -35,13 +35,13 @@ and worker pool accessor pattern.
 
 ## Usage
 
-Factories must be Ractor-shareable because `Ratomic::LocalPool` creates resources lazily
-inside each Ractor. A small frozen factory object is suitable for production use:
+Factories are made Ractor-shareable because `Ratomic::LocalPool` creates resources
+lazily inside each Ractor. A small frozen factory object is suitable for production use:
 
 ```ruby
 RedisFactory = Data.define(:url) do
   def call
-    RedisClient.new(url:)
+    RedisClient.config(url:).new_client
   end
 end
 

data/lib/sidekiq/ratomic/pool/version.rb

@@ -6,7 +6,7 @@ module Sidekiq
   module Ratomic
     class Pool
       # Current gem version.
-      VERSION = '0.1.0'
+      VERSION = '0.2.0'
     end
   end
 end

data/lib/sidekiq/ratomic/pool.rb

@@ -13,14 +13,29 @@ module Sidekiq
     #
     # Resources are validated before checkout and transient failures are retried
     # with exponential backoff. Persistent failures open the circuit breaker.
+    # rubocop:disable Metrics/ClassLength
     class Pool
       attr_reader :pool_name, :size, :max_retries, :retry_delay, :validator, :cb_threshold, :cb_timeout,
                   :retryable_errors
 
-      def initialize(pool_name:, size: 10, max_retries: 3, retry_delay: 0.2,
+      # rubocop:disable Metrics/MethodLength
+      def initialize(options = nil, pool_name: nil, size: 10, max_retries: 3, retry_delay: 0.2,
                      cb_threshold: 5, cb_timeout: 30, validator: nil,
                      retryable_errors: [IOError, SystemCallError, Timeout::Error], factory: nil, &block)
+        normalize_options!(options) do |config|
+          pool_name = config.fetch(:pool_name, pool_name)
+          size = config.fetch(:size, size)
+          max_retries = config.fetch(:max_retries, max_retries)
+          retry_delay = config.fetch(:retry_delay, retry_delay)
+          cb_threshold = config.fetch(:cb_threshold, cb_threshold)
+          cb_timeout = config.fetch(:cb_timeout, cb_timeout)
+          validator = config.fetch(:validator, validator)
+          retryable_errors = config.fetch(:retryable_errors, retryable_errors)
+          factory = config.fetch(:factory, factory)
+        end
+
         factory ||= block
+        raise ArgumentError, 'A pool_name must be provided' unless pool_name
         raise ArgumentError, 'A resource factory must be provided' unless factory
 
         validate_options!(size, max_retries, retry_delay, cb_threshold, cb_timeout)
@@ -35,13 +50,37 @@ module Sidekiq
         @retryable_errors = retryable_errors.freeze
         @state_mutex = Mutex.new
         @failure_count = ::Ratomic::Counter.new
-        @state = :closed
-        @last_state_change = monotonic_time
+        @state_holder = { state: :closed, last_state_change: monotonic_time }
 
         shareable_factory = Ractor.make_shareable(factory)
         @local_pool = ::Ratomic::LocalPool.new(size: @size, factory: shareable_factory)
       end
 
+      # Share one pool runtime across Sidekiq's per-job middleware instances.
+      def config=(config)
+        mutex = config.instance_variable_get(:@sidekiq_ratomic_pool_mutex)
+        unless mutex
+          mutex = Mutex.new
+          config.instance_variable_set(:@sidekiq_ratomic_pool_mutex, mutex)
+        end
+
+        runtimes = config.instance_variable_get(:@sidekiq_ratomic_pool_runtimes)
+        unless runtimes
+          runtimes = {} # : Hash[Symbol, Pool]
+          config.instance_variable_set(:@sidekiq_ratomic_pool_runtimes, runtimes)
+        end
+
+        mutex.synchronize do
+          runtime = runtimes[@pool_name]
+          if runtime
+            adopt_runtime(runtime)
+          else
+            runtimes[@pool_name] = self
+          end
+        end
+        @config = config
+      end
+
       # Inject this pool into a worker's configured pool accessor.
       def call(job_instance, _job_payload, _queue)
         setter = "#{@pool_name}="
@@ -93,11 +132,11 @@ module Sidekiq
       # Return the current circuit-breaker state.
       def state
         @state_mutex.synchronize do
-          if @state == :open && monotonic_time - @last_state_change > @cb_timeout
-            @state = :half_open
-            @last_state_change = monotonic_time
+          if @state_holder[:state] == :open && monotonic_time - @state_holder[:last_state_change] > @cb_timeout
+            @state_holder[:state] = :half_open
+            @state_holder[:last_state_change] = monotonic_time
           end
-          @state
+          @state_holder[:state]
         end
       end
 
@@ -136,6 +175,25 @@ module Sidekiq
         end
       end
 
+      def normalize_options!(options)
+        return unless options
+        raise ArgumentError, 'middleware options must be a Hash' unless options.is_a?(Hash)
+
+        config = options.transform_keys(&:to_sym)
+        allowed = %i[pool_name size max_retries retry_delay cb_threshold cb_timeout validator retryable_errors factory]
+        unknown = config.keys - allowed
+        raise ArgumentError, "unknown middleware options: #{unknown.join(', ')}" unless unknown.empty?
+
+        yield config
+      end
+
+      def adopt_runtime(runtime)
+        @local_pool = runtime.instance_variable_get(:@local_pool)
+        @state_mutex = runtime.instance_variable_get(:@state_mutex)
+        @failure_count = runtime.instance_variable_get(:@failure_count)
+        @state_holder = runtime.instance_variable_get(:@state_holder)
+      end
+
       def default_validator(resource)
         return resource.ping if resource.respond_to?(:ping)
         return resource.active? if resource.respond_to?(:active?)
@@ -147,16 +205,16 @@ module Sidekiq
         @state_mutex.synchronize do
           failure_count = @failure_count.value
           @failure_count.decrement(failure_count) unless failure_count.zero?
-          @state = :closed if @state == :half_open
+          @state_holder[:state] = :closed if @state_holder[:state] == :half_open
         end
       end
 
       def record_failure
         @state_mutex.synchronize do
           @failure_count.increment(1)
-          if @failure_count.value >= @cb_threshold || @state == :half_open
-            @state = :open
-            @last_state_change = monotonic_time
+          if @failure_count.value >= @cb_threshold || @state_holder[:state] == :half_open
+            @state_holder[:state] = :open
+            @state_holder[:last_state_change] = monotonic_time
           end
         end
       end
@@ -165,5 +223,7 @@ module Sidekiq
         Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end
     end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/sig/sidekiq/ratomic/pool.rbs

@@ -22,7 +22,8 @@ module Sidekiq
       attr_reader retryable_errors: Array[Class]
 
       def initialize: (
-        pool_name: Symbol | String,
+        ?untyped options,
+        ?pool_name: (Symbol | String),
         ?size: Integer,
         ?max_retries: Integer,
         ?retry_delay: Numeric,
@@ -34,12 +35,15 @@ module Sidekiq
       ) { () -> untyped } -> void
 
       def call: (untyped, untyped, untyped) { () -> untyped } -> untyped
+      def config=: (untyped) -> untyped
       def close: () -> nil
       def shutdown: () -> nil
       def with: () { (untyped) -> untyped } -> untyped
       def state: () -> Symbol
       private
       def validate_options!: (untyped, untyped, untyped, untyped, untyped) -> void
+      def normalize_options!: (untyped) { (Hash[Symbol, untyped]) -> void } -> void
+      def adopt_runtime: (instance) -> void
       def check_circuit_state!: () -> void
       def verify_health: (untyped) -> bool
       def retryable_error?: (StandardError) -> bool

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-ratomic-pool
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ken C. Demanawa
@@ -66,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.18
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Ractor-safe connection pooling for Sidekiq utilizing Ratomic's LocalPool.
 test_files: []