active_publisher 1.2.3-java → 1.3.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15d88cf40d6d054ecdb12cf8d079fb8e09fedd02e19aab629e4034cbbb667979
-  data.tar.gz: 6c6e47f2d49b035c433a9fc400f83aa0b96ac5d1b0a8a926730476bbe5250b66
+  metadata.gz: 7447a8948c2a4e24769ef9733ab12e843266564385535c2cb7bfbb8d485ec50a
+  data.tar.gz: c8fef7d08eef182420cbdef0fa847b40cc5f9e14ef96b81ad076fcb885526717
 SHA512:
-  metadata.gz: a9d25a3231071ff71ebc32d0e98b362ae1c558b67e568df50806930567d334a57783a428007e95504d7c14e0a7deebf7b864457e008dabfb7a715b51b8fe8358
-  data.tar.gz: e90cd0c23105cd8ededa04d3bc0636e76d589b60f7060f8784720c2c7cd594e33d27063581b7787babd1cf87878deacea39a34269344257809ec46676143cfd6
+  metadata.gz: 6e5f3d51840ac76b600444eb36e4b358f4fed9ae5ae876eed27747f8e89f67273d7cf52fc608dc788f0631257b6f4c6d5e05b9f014a05b39175958f1956fefa1
+  data.tar.gz: e965f7bedbc7449c3cb6f6e86afa718be8d28853ba46acec02be6589eebf58389c276b4aa3c90b8a2a919825c17acfd22e93987d4212a4cec535219e9d34158f

data/.circleci/config.yml

@@ -0,0 +1,56 @@
+# Inspired by: http://mikebian.co/running-tests-against-multiple-ruby-versions-using-circleci/
+
+version: 2.1
+
+orbs:
+  ruby: circleci/ruby@1.1
+
+jobs:
+  test:
+    parallelism: 1
+    parameters:
+      ruby-image:
+        type: string
+    docker:
+      - image: << parameters.ruby-image >>
+      - image: rabbitmq
+
+    steps:
+      - checkout
+      - run:
+          name: install dockerize
+          command: wget https://github.com/jwilder/dockerize/releases/download/$DOCKERIZE_VERSION/dockerize-linux-amd64-$DOCKERIZE_VERSION.tar.gz && sudo tar -C /usr/local/bin -xzvf dockerize-linux-amd64-$DOCKERIZE_VERSION.tar.gz && rm dockerize-linux-amd64-$DOCKERIZE_VERSION.tar.gz
+          environment:
+            DOCKERIZE_VERSION: v0.3.0
+      - run:
+          name: Wait for rabbitmq
+          command: dockerize -wait tcp://localhost:5672 -timeout 1m
+      - run:
+          name: Install bundler
+          command: gem install bundler
+      - run:
+          name: Which bundler?
+          command: bundle -v
+      - run:
+          name: bundle install
+          command: bundle install
+      - run:
+          name: rspec
+          command: bundle exec rspec
+
+# strangely, there seems to be very little documentation about exactly how martix builds work.
+# By defining a param inside your job definition, Circle CI will automatically spawn a job for
+# unique param value passed via `matrix`. Neat!
+# https://circleci.com/blog/circleci-matrix-jobs/
+workflows:
+  build_and_test:
+    jobs:
+      - test:
+          matrix:
+            parameters:
+              ruby-image:
+                - circleci/ruby:2.5
+                - circleci/ruby:2.6
+                - circleci/ruby:2.7
+                - circleci/jruby:9.1
+                - circleci/jruby:9.2

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

@@ -2,7 +2,13 @@ module ActivePublisher
   module Async
     module InMemoryAdapter
       class ConsumerThread
-        attr_reader :thread, :queue, :sampled_queue_size, :last_tick_at
+        attr_reader :channel, :flush_max, :thread, :queue, :sampled_queue_size, :last_tick_at
+
+        if ::RUBY_PLATFORM == "java"
+          CHANNEL_CLOSED_ERRORS = [::MarchHare::ChannelAlreadyClosed]
+        else
+          CHANNEL_CLOSED_ERRORS = [::Bunny::ChannelAlreadyClosed]
+        end
 
         if ::RUBY_PLATFORM == "java"
           NETWORK_ERRORS = [::MarchHare::NetworkException, ::MarchHare::ConnectionRefused,
@@ -21,6 +27,7 @@ module ActivePublisher
         def initialize(listen_queue)
           @queue = listen_queue
           @sampled_queue_size = queue.size
+          @flush_max = ::ActivePublisher.configuration.messages_per_batch
 
           update_last_tick_at
           start_thread
@@ -45,6 +52,32 @@ module ActivePublisher
           end
         end
 
+        def cleanup_up_channel
+          return if channel.nil?
+          channel.close
+        rescue => error
+          ::ActivePublisher.configuration.error_handler.call(error, {:status => "Cleaning up the channel"})
+        end
+
+        def handle_current_messages_on_unknown_error(current_messages)
+          current_messages.each do |message|
+            # Degrade to single message publish ... or at least attempt to
+            begin
+              ::ActivePublisher.publish(message.route, message.payload, message.exchange_name, message.options)
+              current_messages.delete(message)
+            rescue *CHANNEL_CLOSED_ERRORS
+              # If the channel is bad, raise!
+              raise
+            rescue *PRECONDITION_ERRORS => error
+              # Delete messages if rabbitmq cannot declare the exchange (or somet other precondition failed).
+              ::ActivePublisher.configuration.error_handler.call(error, {:reason => "precondition failed", :message => message})
+              current_messages.delete(message)
+            rescue => other_error
+              ::ActivePublisher.configuration.error_handler.call(other_error, {:route => message.route, :payload => message.payload, :exchange_name => message.exchange_name, :options => message.options})
+            end
+          end
+        end
+
         def make_channel
           channel = ::ActivePublisher::Async::InMemoryAdapter::Channel.new
           channel.confirm_select if ::ActivePublisher.configuration.publisher_confirms
@@ -57,57 +90,54 @@ module ActivePublisher
 
         def start_thread
           return if alive?
-          @thread = ::Thread.new do
-            loop do
-              # Sample the queue size so we don't shutdown when messages are in flight.
-              @sampled_queue_size = queue.size
-              current_messages = queue.pop_up_to(50, :timeout => 0.1)
-              update_last_tick_at
-              # If the queue is empty, we should continue to update to "last_tick_at" time.
-              next if current_messages.nil?
-
-              # We only look at active publisher messages. Everything else is dropped.
-              current_messages.select! { |message| message.is_a?(::ActivePublisher::Message) }
-
-              begin
-                @channel ||= make_channel
-
-                # Only open a single connection for each group of messages to an exchange
-                current_messages.group_by(&:exchange_name).each do |exchange_name, messages|
-                  publish_all(@channel, exchange_name, messages)
-                  current_messages -= messages
-                end
-              rescue *NETWORK_ERRORS
-                # Sleep because connection is down
-                await_network_reconnect
-              rescue => unknown_error
-                ::ActivePublisher.configuration.error_handler.call(unknown_error, {:number_of_messages => current_messages.size})
-                current_messages.each do |message|
-                  # Degrade to single message publish ... or at least attempt to
-                  begin
-                    ::ActivePublisher.publish(message.route, message.payload, message.exchange_name, message.options)
-                    current_messages.delete(message)
-                  rescue *PRECONDITION_ERRORS => error
-                    # Delete messages if rabbitmq cannot declare the exchange (or somet other precondition failed).
-                    ::ActivePublisher.configuration.error_handler.call(error, {:reason => "precondition failed", :message => message})
-                    current_messages.delete(message)
-                  rescue => individual_error
-                    ::ActivePublisher.configuration.error_handler.call(individual_error, {:route => message.route, :payload => message.payload, :exchange_name => message.exchange_name, :options => message.options})
-                  end
-                end
-
-                # TODO: Find a way to bubble this out of the thread for logging purposes.
-                # Reraise the error out of the publisher loop. The Supervisor will restart the consumer.
-                raise unknown_error
-              ensure
-                # Always requeue anything that gets stuck.
-                queue.concat(current_messages) if current_messages && !current_messages.empty?
+          @thread = ::Thread.new { start_consuming_thread }
+        end
+
+        def start_consuming_thread
+          loop do
+            # Sample the queue size so we don't shutdown when messages are in flight.
+            @sampled_queue_size = queue.size
+            current_messages = queue.pop_up_to(flush_max, :timeout => 0.1)
+            update_last_tick_at
+            # If the queue is empty, we should continue to update to "last_tick_at" time.
+            next if current_messages.nil?
+
+            @channel ||= make_channel
+
+            # We only look at active publisher messages. Everything else is dropped.
+            current_messages.select! { |message| message.is_a?(::ActivePublisher::Message) }
+
+            begin
+              # Only open a single connection for each group of messages to an exchange
+              current_messages.group_by(&:exchange_name).each do |exchange_name, messages|
+                publish_all(exchange_name, messages)
+                current_messages -= messages
               end
+            rescue *CHANNEL_CLOSED_ERRORS
+              # If the channel is bad, raise without sending one-by-one!
+              raise
+            rescue *NETWORK_ERRORS
+              # Sleep because connection is down
+              await_network_reconnect
+            rescue => unknown_error
+              ::ActivePublisher.configuration.error_handler.call(unknown_error, {:number_of_messages => current_messages.size})
+
+              # Attempt to deliver a message one-by-one. Raise if a closed channel error appears.
+              handle_current_messages_on_unknown_error(current_messages)
+
+              # TODO: Find a way to bubble this out of the thread for logging purposes.
+              # Reraise the error out of the publisher loop. The Supervisor will restart the consumer.
+              raise unknown_error
+            ensure
+              # Always requeue anything that gets stuck.
+              queue.concat(current_messages) if current_messages && !current_messages.empty?
             end
           end
+        ensure
+          cleanup_up_channel
         end
 
-        def publish_all(channel, exchange_name, messages)
+        def publish_all(exchange_name, messages)
           exchange = channel.topic(exchange_name)
           messages.each do |message|
             fail ::ActivePublisher::ExchangeMismatchError, "bulk publish messages must match publish_all exchange_name" if message.exchange_name != exchange_name
@@ -116,10 +146,10 @@ module ActivePublisher
               exchange.publish(message.payload, options)
             end
           end
-          wait_for_confirms(channel)
+          wait_for_confirms
         end
 
-        def wait_for_confirms(channel)
+        def wait_for_confirms
           return true unless channel.using_publisher_confirms?
           channel.wait_for_confirms(::ActivePublisher.configuration.publisher_confirms_timeout)
         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/async/redis_adapter.rb

@@ -19,7 +19,7 @@ module ActivePublisher
         }
         include ::ActivePublisher::Logging
 
-        attr_reader :async_queue, :redis_pool, :queue
+        attr_reader :async_queue, :flush_max, :flush_min, :redis_pool, :queue
 
         def initialize(new_redis_pool)
           logger.info "Starting redis publisher adapter"
@@ -27,6 +27,8 @@ module ActivePublisher
           @redis_pool = new_redis_pool
           @async_queue = ::ActivePublisher::Async::RedisAdapter::Consumer.new(redis_pool)
           @queue = ::MultiOpQueue::Queue.new
+          @flush_max = ::ActivePublisher.configuration.messages_per_batch
+          @flush_min = @flush_max / 2
 
           supervisor_task = ::Concurrent::TimerTask.new(SUPERVISOR_INTERVAL) do
             queue_size = queue.size
@@ -41,7 +43,7 @@ module ActivePublisher
         def publish(route, payload, exchange_name, options = {})
           message = ::ActivePublisher::Message.new(route, payload, exchange_name, options)
           queue << ::Marshal.dump(message)
-          flush_queue! if queue.size >= 20 || options[:flush_queue]
+          flush_queue! if queue.size >= flush_min || options[:flush_queue]
 
           nil
         end
@@ -58,7 +60,7 @@ module ActivePublisher
 
         def flush_queue!
           return if queue.empty?
-          encoded_messages = queue.pop_up_to(25, :timeout => 0.001)
+          encoded_messages = queue.pop_up_to(flush_max, :timeout => 0.001)
 
           return if encoded_messages.nil?
           return unless encoded_messages.respond_to?(:each)

data/lib/active_publisher/configuration.rb

@@ -8,9 +8,11 @@ module ActivePublisher
                   :host,
                   :hosts,
                   :max_async_publisher_lag_time,
+                  :messages_per_batch,
                   :network_recovery_interval,
                   :password,
                   :port,
+                  :publisher_threads,
                   :publisher_confirms,
                   :publisher_confirms_timeout,
                   :seconds_to_wait_for_graceful_shutdown,
@@ -36,9 +38,11 @@ module ActivePublisher
       :host => "localhost",
       :hosts => [],
       :password => "guest",
+      :messages_per_batch => 25,
       :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.3"
+  VERSION = "1.3.0"
 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.3
+  version: 1.3.0
 platform: java
 authors:
 - Brian Stien
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-07-29 00:00:00.000000000 Z
+date: 2021-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -179,9 +179,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -223,8 +223,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.7.9
+rubygems_version: 3.2.28
 signing_key:
 specification_version: 4
 summary: Aims to make publishing work across MRI and jRuby painless and add some nice

data/.travis.yml

@@ -1,14 +0,0 @@
-language: ruby
-rvm:
- - 2.3.8
- - 2.5.7
- - jruby-9.1.12.0
- - jruby-9.2.7.0
-addons:
-  apt:
-    packages:
-      - rabbitmq-server
-services:
- - rabbitmq
-sudo: false
-cache: bundler