active_publisher 1.2.6 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 736d696175390213664c2c01397673dff014a7aea213b64c99851a3d962aa3d2
-  data.tar.gz: 2f7efd868a202eec1513322d638023b00aa16c5e3f74c14a919484c06cb75289
+  metadata.gz: 6e205892cb22a44c4a5f8792b52ccd2d9d1f91cee827c86b26caf928b6790a2e
+  data.tar.gz: 3b868e1c64ce26f081911c6cf70ed3db5e3a9adc75beb844fea3db8adc2484f3
 SHA512:
-  metadata.gz: a2e4c032c91c55dcffd522da05251167007aca709ccfb62f3bd4bff9b20957426109c92bde1b526a40f10996ae93c07628a9d00b31b0ebaf220e3496a0404cf3
-  data.tar.gz: 52fcbde823b44976d7a8478ebb13d420fb9bd261675d9462372e8edc11cd01aa7b8705ccd39c44a278c9bdafc48fd9a546495a577ed9c5c9f85d61b6b51ae18e
+  metadata.gz: c0285683ccd9ca51a7c9b571cb0b47db2ef79404e344d7759cd3c69ea9eabb108cbbc5e5146b084fef5b28d90f6876f2c0fda8c7dba7f81cbfb99bb2e5b98b6d
+  data.tar.gz: bab6a2b9b9a2e785d9cfcf2523219ab2e4662350bcc41eefa807bc11312f1f0024ce01952fc62eb9bf60ca362bc71c4892551b6caa0b8bba4e6744776c42f991

data/README.md

@@ -55,7 +55,9 @@ Defaults for the configuration are:
   :network_recovery_interval => 1,
   :password => "guest",
   :port => 5672,
+  :publisher_threads => 1,
   :publisher_confirms => false,
+  :publisher_confirms_timeout => 5_000,
   :seconds_to_wait_for_graceful_shutdown => 30,
   :timeout => 1,
   :tls => false,

data/lib/active_publisher/async/in_memory_adapter/async_queue.rb

@@ -14,14 +14,15 @@ module ActivePublisher
           :max_queue_size,
           :supervisor_interval
 
-        attr_reader :consumer, :queue, :supervisor
+        attr_reader :consumers, :queue, :supervisor
 
         def initialize(back_pressure_strategy, max_queue_size, supervisor_interval)
           self.back_pressure_strategy = back_pressure_strategy
           @max_queue_size = max_queue_size
           @supervisor_interval = supervisor_interval
           @queue = ::MultiOpQueue::Queue.new
-          create_and_supervise_consumer!
+          @consumers = {}
+          create_and_supervise_consumers!
         end
 
         def back_pressure_strategy=(strategy)
@@ -52,36 +53,44 @@ module ActivePublisher
         def size
           # Requests might be in flight (out of the queue, but not yet published), so taking the max should be
           # good enough to make sure we're honest about the actual queue size.
-          return queue.size if consumer.nil?
-          [queue.size, consumer.sampled_queue_size].max
+          return queue.size if consumers.empty?
+          [queue.size, consumer_sampled_queue_size].max
         end
 
         private
 
-        def create_and_supervise_consumer!
-          @consumer = ::ActivePublisher::Async::InMemoryAdapter::ConsumerThread.new(queue)
+        def create_and_supervise_consumers!
+          ::ActivePublisher.configuration.publisher_threads.times do
+            consumer_id = ::SecureRandom.uuid
+            consumers[consumer_id] = ::ActivePublisher::Async::InMemoryAdapter::ConsumerThread.new(queue)
+            supervisor_task = ::Concurrent::TimerTask.new(:execution_interval => supervisor_interval) do
+              current_time = ::Time.now
+              consumer = consumers[consumer_id]
 
-          supervisor_task = ::Concurrent::TimerTask.new(:execution_interval => supervisor_interval) do
-            current_time = ::Time.now
+              # Consumer is lagging if it does not "tick" at least once every 10 seconds.
+              seconds_since_last_tick = current_time - consumer.last_tick_at
+              consumer_is_lagging = seconds_since_last_tick > ::ActivePublisher.configuration.max_async_publisher_lag_time
+              logger.error "ActivePublisher consumer is lagging. Last consumer tick was #{seconds_since_last_tick} seconds ago." if consumer_is_lagging
 
-            # Consumer is lagging if it does not "tick" at least once every 10 seconds.
-            seconds_since_last_tick = current_time - consumer.last_tick_at
-            consumer_is_lagging = seconds_since_last_tick > ::ActivePublisher.configuration.max_async_publisher_lag_time
-            logger.error "ActivePublisher consumer is lagging. Last consumer tick was #{seconds_since_last_tick} seconds ago." if consumer_is_lagging
+              # Check to see if we should restart the consumer.
+              if !consumer.alive? || consumer_is_lagging
+                consumer.kill rescue nil
+                consumers[consumer_id] = ::ActivePublisher::Async::InMemoryAdapter::ConsumerThread.new(queue)
+                ::ActiveSupport::Notifications.instrument "async_queue.thread_restart"
+              end
 
-            # Check to see if we should restart the consumer.
-            if !consumer.alive? || consumer_is_lagging
-              consumer.kill rescue nil
-              @consumer = ::ActivePublisher::Async::InMemoryAdapter::ConsumerThread.new(queue)
+              # Notify the current queue size.
+              ::ActiveSupport::Notifications.instrument "async_queue_size.active_publisher", queue.size
             end
-
-            # Notify the current queue size.
-            ::ActiveSupport::Notifications.instrument "async_queue_size.active_publisher", queue.size
+            supervisor_task.execute
           end
-          supervisor_task.execute
         end
-      end
 
+        def consumer_sampled_queue_size
+          consumers.values.map(&:sampled_queue_size).max
+        end
+
+      end
     end
   end
 end

data/lib/active_publisher/async/in_memory_adapter/consumer_thread.rb

@@ -151,7 +151,9 @@ module ActivePublisher
 
         def wait_for_confirms
           return true unless channel.using_publisher_confirms?
-          channel.wait_for_confirms(::ActivePublisher.configuration.publisher_confirms_timeout)
+          ::ActiveSupport::Notifications.instrument "publishes_confirmed.active_publisher" do
+            channel.wait_for_confirms(::ActivePublisher.configuration.publisher_confirms_timeout)
+          end
         end
       end
     end

data/lib/active_publisher/async/redis_adapter/consumer.rb

@@ -9,28 +9,33 @@ module ActivePublisher
           :timeout_interval => 5, # seconds
         }
 
-        attr_reader :consumer, :queue, :supervisor
+        attr_reader :consumers, :queue, :supervisor
 
         def initialize(redis_pool)
           @queue = ::ActivePublisher::Async::RedisAdapter::RedisMultiPopQueue.new(redis_pool, ::ActivePublisher::Async::RedisAdapter::REDIS_LIST_KEY)
-          create_and_supervise_consumer!
+          @consumers = {}
+          create_and_supervise_consumers!
         end
 
-        def create_and_supervise_consumer!
-          @consumer = ::ActivePublisher::Async::InMemoryAdapter::ConsumerThread.new(queue)
-
-          supervisor_task = ::Concurrent::TimerTask.new(SUPERVISOR_INTERVAL) do
-            # This may also be the place to start additional publishers when we are getting backed up ... ?
-            unless consumer.alive?
-              consumer.kill rescue nil
-              @consumer = ::ActivePublisher::Async::InMemoryAdapter::ConsumerThread.new(queue)
+        def create_and_supervise_consumers!
+          ::ActivePublisher.configuration.publisher_threads.times do
+            consumer_id = ::SecureRandom.uuid
+            consumers[consumer_id] = ::ActivePublisher::Async::InMemoryAdapter::ConsumerThread.new(queue)
+
+            supervisor_task = ::Concurrent::TimerTask.new(SUPERVISOR_INTERVAL) do
+              consumer = consumers[consumer_id]
+              unless consumer.alive?
+                consumer.kill rescue nil
+                consumers[consumer_id] = ::ActivePublisher::Async::InMemoryAdapter::ConsumerThread.new(queue)
+                ::ActiveSupport::Notifications.instrument "async_queue.thread_restart"
+              end
+
+              # Notify the current queue size.
+              ::ActiveSupport::Notifications.instrument "redis_async_queue_size.active_publisher", queue.size
             end
 
-            # Notify the current queue size.
-            ::ActiveSupport::Notifications.instrument "redis_async_queue_size.active_publisher", queue.size
+            supervisor_task.execute
           end
-
-          supervisor_task.execute
         end
 
         def size

data/lib/active_publisher/configuration.rb

@@ -12,6 +12,7 @@ module ActivePublisher
                   :network_recovery_interval,
                   :password,
                   :port,
+                  :publisher_threads,
                   :publisher_confirms,
                   :publisher_confirms_timeout,
                   :seconds_to_wait_for_graceful_shutdown,
@@ -41,6 +42,7 @@ module ActivePublisher
       :max_async_publisher_lag_time => 10,
       :network_recovery_interval => NETWORK_RECOVERY_INTERVAL,
       :port => 5672,
+      :publisher_threads => 1,
       :publisher_confirms => false,
       :publisher_confirms_timeout => 5_000, #specified as a number of milliseconds
       :seconds_to_wait_for_graceful_shutdown => 30,

data/lib/active_publisher/version.rb

@@ -1,3 +1,3 @@
 module ActivePublisher
-  VERSION = "1.2.6"
+  VERSION = "1.3.1"
 end

data/lib/active_publisher.rb

@@ -4,6 +4,7 @@ else
   require "bunny"
 end
 require "active_support"
+require "securerandom"
 require "thread"
 
 require "active_publisher/logging"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_publisher
 version: !ruby/object:Gem::Version
-  version: 1.2.6
+  version: 1.3.1
 platform: ruby
 authors:
 - Brian Stien
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-29 00:00:00.000000000 Z
+date: 2021-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -223,8 +223,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.7.6
+rubygems_version: 3.0.1
 signing_key:
 specification_version: 4
 summary: Aims to make publishing work across MRI and jRuby painless and add some nice