harmoniser 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd51302d5c886af771b66e4528054042a8922071669719ba625aac5d5c0dc503
-  data.tar.gz: 2dd00c5d6699436fca25d6c721cba80518aa8baa967e3bca247af408b829582b
+  metadata.gz: a1a7c351ba8ed80091b6e32dbd3cb0486f6b4123b30de12f1406862f3bdedcbb
+  data.tar.gz: f3d68be4e8cc7cb83e5df89bbc20ce4bc905b44711d59a23de50e7ac761bc5ae
 SHA512:
-  metadata.gz: 6f2f43e8bc13d89db74bc38da9e08b86773aea3582cf5df277c985df22a016aa22bc5f965243b3df451c9f22ff40bc16299aeece5b7d5d15d57b6a43fb8b2233
-  data.tar.gz: e3768b89e31de5b74b27333a990247b416067acc6055e4a1ea15d3ad63560a91780d9f379ced069f0cc9c950907186d2e67cd5daaacfaaf4b4f64b8715804415
+  metadata.gz: 5c6da5317a0ea480766ce716b7710598d6a1720afd8bb24cf82f2aecd3b96e9d41b31b3246d306c525e5ddbb5532f8adb87c7b3188a402ecada8c87a192176fb
+  data.tar.gz: 9a31ed8616f30072245dbc783692cadf871c46f2082f627420fd71a38f6e29b3d9162b6152fdf741173a67e4a16fb5d1c8fbe812eaffb081356f4b83796ad510

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## [0.11.0] - 2024-10-09
+
+### Added
+- Attach callbacks for block/unblock at Connection
+- Introduce Connectable to accommodate Session/Channel management
+- Attach at_exit hook for maybe closing Publisher connection. Only applicable for cases in which harmoniser is not the process running.
+
+### Changed
+- Separate connection for Publisher, Subscriber and Topology as per recommendations from [RabbitMQ official docs](https://www.rabbitmq.com/docs/alarms#effects-on-clusters)
+
+## [0.10.0] - 2024-09-16
+
+### Added
+- Add a concurrency option to the CLI. By default, concurrency is unbounded, i.e., each subscriber
+  has its own thread dedicated to processing messages
+- Introduce Harmoniser::Subscriber::Registry for holding references to classes that include
+  Harmoniser::Subscriber
+- Kill the process when an ACK timeout is received through any channel. The process terminates with
+  exit code 138
+- Add a 25-second timeout to shut down the process. This is only applicable to processes using the
+  concurrency option
+
+### Changed
+- Update Bunny to the latest version, i.e., 2.23
+- Cancel subscribers and connection is done within the Launcher context instead of relying on
+  at_exit hook
+- Prevent the connection from being closed after Topology#declare finishes; only the channel used
+  is closed
+
 ## [0.9.0] - 2024-08-09
 
 ### Added

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2021 TODO: Write your name
+Copyright (c) 2021 Jose Lloret Perez
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -111,12 +111,6 @@ To contribute to this codebase, you will need to setup your local development us
 
 You can also access the running container by executing `$ make shell` and then execute any commands related to Harmoniser within its isolated environment.
 
-## Future Improvements
-
-- [ ] Feature: Introduce capability of configuring concurrency for Harmoniser process.
-- [ ] Issue: Reopen Channels anytime an exception occurs that closes them automatically. More info can be found [here](https://www.rabbitmq.com/channels.html#error-handling).
-- [ ] Chore: Introduce simplecov gem for code coverage.
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/harmoniser.gemspec

@@ -24,5 +24,5 @@ Gem::Specification.new do |spec|
   spec.executables = ["harmoniser"]
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "bunny", "~> 2.22"
+  spec.add_runtime_dependency "bunny", "~> 2.23"
 end

data/lib/harmoniser/cli.rb

@@ -5,11 +5,13 @@ require "harmoniser/launcher"
 
 module Harmoniser
   class CLI
+    class SigUsr1 < StandardError; end
     include Singleton
 
     SIGNAL_HANDLERS = {
       "INT" => lambda { |cli, signal| raise Interrupt },
-      "TERM" => lambda { |cli, signal| raise Interrupt }
+      "TERM" => lambda { |cli, signal| raise Interrupt },
+      "USR1" => lambda { |cli, signal| raise SigUsr1 }
     }
     SIGNAL_HANDLERS.default = lambda { |cli, signal| cli.logger.info("Default signal handler executed since there is no handler defined: signal = `#{signal}`") }
 
@@ -22,6 +24,7 @@ module Harmoniser
 
     def call
       parse_options
+      @launcher = Launcher.call(configuration: @configuration, logger: @logger)
       run
     end
 
@@ -37,7 +40,7 @@ module Harmoniser
     def define_signals
       @read_io, @write_io = IO.pipe
 
-      ["INT", "TERM"].each do |sig|
+      ["INT", "TERM", "USR1"].each do |sig|
         Signal.trap(sig) do
           @write_io.puts(sig)
         end
@@ -45,9 +48,7 @@ module Harmoniser
     end
 
     def run
-      Launcher
-        .new(configuration: configuration, logger: logger)
-        .start
+      @launcher.start
 
       define_signals
 
@@ -58,7 +59,13 @@ module Harmoniser
     rescue Interrupt
       @write_io.close
       @read_io.close
+      @launcher.stop
       exit(0)
+    rescue SigUsr1
+      @write_io.close
+      @read_io.close
+      @launcher.stop
+      exit(128 + 10)
     end
 
     def handle_signal(signal)

data/lib/harmoniser/configurable.rb

@@ -1,10 +1,7 @@
-require "forwardable"
 require "harmoniser/configuration"
 
 module Harmoniser
   module Configurable
-    extend Forwardable
-
     def configure
       @configuration ||= Configuration.new
       yield(@configuration)
@@ -19,7 +16,5 @@ module Harmoniser
     def default_configuration
       @configuration ||= Configuration.new
     end
-
-    def_delegators :configuration, :connection, :connection?
   end
 end

data/lib/harmoniser/configuration.rb

@@ -1,15 +1,14 @@
 require "forwardable"
-require "harmoniser/connectable"
+require "harmoniser/connection"
 require "harmoniser/topology"
 require "harmoniser/options"
 
 module Harmoniser
   class Configuration
     extend Forwardable
-    include Connectable
 
     attr_reader :logger, :options
-    def_delegators :options, :environment, :require, :verbose
+    def_delegators :options, :concurrency, :environment, :require, :verbose, :timeout
 
     def initialize
       @logger = Harmoniser.logger
@@ -18,6 +17,16 @@ module Harmoniser
       @topology = Topology.new
     end
 
+    def connection_opts
+      @connection_opts ||= Connection::DEFAULT_CONNECTION_OPTS
+    end
+
+    def connection_opts=(opts)
+      raise TypeError, "opts must be a Hash object" unless opts.is_a?(Hash)
+
+      @connection_opts = connection_opts.merge(opts)
+    end
+
     def define_topology
       raise LocalJumpError, "A block is required for this method" unless block_given?
 
@@ -33,8 +42,10 @@ module Harmoniser
 
     def default_options
       {
+        concurrency: Float::INFINITY,
         environment: ENV.fetch("RAILS_ENV", ENV.fetch("RACK_ENV", "production")),
         require: ".",
+        timeout: 25,
         verbose: false
       }
     end

data/lib/harmoniser/connectable.rb

@@ -4,45 +4,70 @@ module Harmoniser
   module Connectable
     MUTEX = Mutex.new
 
-    def connection_opts
-      @connection_opts ||= Connection::DEFAULT_CONNECTION_OPTS.merge({logger: Harmoniser.logger})
-    end
+    module ClassMethods
+      def connection(configuration = Harmoniser.configuration)
+        MUTEX.synchronize do
+          @connection ||= Connection.new(configuration.connection_opts)
+          @connection.start unless @connection.open? || @connection.recovering_from_network_failure?
+          @connection
+        end
+      end
 
-    def connection_opts=(opts)
-      raise TypeError, "opts must be a Hash object" unless opts.is_a?(Hash)
+      def connection?
+        !!defined?(@connection)
+      end
 
-      @connection_opts = connection_opts.merge(opts)
-    end
+      def create_channel(consumer_pool_size: 1, consumer_pool_shutdown_timeout: 60)
+        connection
+          .create_channel(nil, consumer_pool_size, false, consumer_pool_shutdown_timeout)
+          .tap do |channel|
+            attach_callbacks(channel)
+          end
+      end
 
-    def connection
-      MUTEX.synchronize do
-        @connection ||= create_connection
-        @connection.start unless @connection.open? || @connection.recovering_from_network_failure?
-        @connection
+      private
+
+      def attach_callbacks(channel)
+        channel.on_error(&method(:on_error).to_proc)
+        channel.on_uncaught_exception(&method(:on_uncaught_exception).to_proc)
       end
-    end
 
-    def connection?
-      !!defined?(@connection)
-    end
+      def on_error(channel, amq_method)
+        attributes = {
+          amq_method: amq_method,
+          exchanges: channel.exchanges.keys,
+          queues: channel.consumers.values.map(&:queue)
+        }
 
-    private
+        if amq_method.is_a?(AMQ::Protocol::Channel::Close)
+          attributes[:reply_code] = amq_method.reply_code
+          attributes[:reply_text] = amq_method.reply_text
+        end
 
-    def create_connection
-      at_exit(&method(:at_exit_handler).to_proc)
-      Connection.new(connection_opts)
-    end
+        stringified_attributes = attributes.map { |k, v| "#{k} = `#{v}`" }.join(", ")
+        Harmoniser.logger.error("Default on_error handler executed for channel: #{stringified_attributes}")
+        maybe_kill_process(amq_method)
+      end
+
+      def on_uncaught_exception(error, consumer)
+        Harmoniser.logger.error("Default on_uncaught_exception handler executed for channel: error_class = `#{error.class}`, error_message = `#{error.message}`, error_backtrace = `#{error.backtrace&.first(5)}, queue = `#{consumer.queue}`")
+      end
+
+      def maybe_kill_process(amq_method)
+        Process.kill("USR1", Process.pid) if ack_timed_out?(amq_method) && Harmoniser.server?
+      end
+
+      def ack_timed_out?(amq_method)
+        return false unless amq_method.is_a?(AMQ::Protocol::Channel::Close)
 
-    def at_exit_handler
-      logger = Harmoniser.logger
+        amq_method.reply_text =~ /delivery acknowledgement on channel \d+ timed out/
+      end
+    end
 
-      logger.info("Shutting down!")
-      if connection? && @connection.open?
-        logger.info("Connection will be closed: connection = `#{@connection}`")
-        @connection.close
-        logger.info("Connection closed: connection = `#{@connection}`")
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
       end
-      logger.info("Bye!")
     end
   end
 end

data/lib/harmoniser/connection.rb

@@ -7,19 +7,11 @@ module Harmoniser
 
     DEFAULT_CONNECTION_OPTS = {
       connection_name: "harmoniser@#{VERSION}",
-      connection_timout: 5,
+      connection_timeout: 5,
       host: "127.0.0.1",
       password: "guest",
       port: 5672,
       read_timeout: 5,
-      recovery_attempt_started: proc {
-        stringified_connection = Harmoniser.connection.to_s
-        Harmoniser.logger.info("Recovery attempt started: connection = `#{stringified_connection}`")
-      },
-      recovery_completed: proc {
-        stringified_connection = Harmoniser.connection.to_s
-        Harmoniser.logger.info("Recovery completed: connection = `#{stringified_connection}`")
-      },
       tls_silence_warnings: true,
       username: "guest",
       verify_peer: false,
@@ -29,20 +21,24 @@ module Harmoniser
 
     def_delegators :@bunny, :create_channel, :open?, :recovering_from_network_failure?
 
-    def initialize(opts)
-      @bunny = Bunny.new(opts)
+    def initialize(opts, logger: Harmoniser.logger)
+      @logger = logger
+      @bunny = Bunny.new(maybe_dynamic_opts(opts)).tap do |bunny|
+        attach_callbacks(bunny)
+      end
     end
 
     def to_s
-      "<#{self.class.name}>: #{user}@#{host}:#{port}, connection_name = `#{connection_name}`, vhost = `#{vhost}`"
+      "<#{self.class.name}>:#{object_id} #{user}@#{host}:#{port}, connection_name = `#{connection_name}`, vhost = `#{vhost}`"
     end
 
+    # TODO Only perform retries when Harmoniser.server?
     def start
       retries = 0
       begin
         with_signal_handler { @bunny.start }
       rescue => e
-        Harmoniser.logger.error("Connection attempt failed: retries = `#{retries}`, error_class = `#{e.class}`, error_message = `#{e.message}`")
+        @logger.error("Connection attempt failed: retries = `#{retries}`, error_class = `#{e.class}`, error_message = `#{e.message}`")
         with_signal_handler { sleep(1) }
         retries += 1
         retry
@@ -50,15 +46,26 @@ module Harmoniser
     end
 
     def close
-      @bunny.close
-      true
+      @logger.info("Connection will be closed: connection = `#{self}`")
+      @bunny.close.tap do
+        @logger.info("Connection closed: connection = `#{self}`")
+      end
     rescue => e
-      Harmoniser.logger.error("Connection#close failed: error_class = `#{e.class}`, error_message = `#{e.message}`")
+      @logger.error("Connection#close failed: error_class = `#{e.class}`, error_message = `#{e.message}`")
       false
     end
 
     private
 
+    def attach_callbacks(bunny)
+      bunny.on_blocked do |blocked|
+        @logger.warn("Connection blocked: connection = `#{self}`, reason = `#{blocked.reason}`")
+      end
+      bunny.on_unblocked do |unblocked|
+        @logger.info("Connection unblocked: connection = `#{self}`")
+      end
+    end
+
     def connection_name
       @bunny.connection_name
     end
@@ -67,6 +74,18 @@ module Harmoniser
       @bunny.transport.host
     end
 
+    def maybe_dynamic_opts(opts)
+      opts.merge({
+        logger: opts.fetch(:logger) { @logger },
+        recovery_attempt_started: opts.fetch(:recovery_attempt_started) do
+          proc { @logger.info("Recovery attempt started: connection = `#{self}`") }
+        end,
+        recovery_completed: opts.fetch(:recovery_completed) do
+          proc { @logger.info("Recovery completed: connection = `#{self}`") }
+        end
+      })
+    end
+
     def port
       @bunny.transport.port
     end
@@ -79,10 +98,11 @@ module Harmoniser
       @bunny.vhost
     end
 
+    # TODO Use Signal handler defined at Harmoniser::CLI instead of rescuing SignalException?
     def with_signal_handler
       yield if block_given?
     rescue SignalException => e
-      Harmoniser.logger.info("Signal received: signal = `#{Signal.signame(e.signo)}`")
+      @logger.info("Signal received: signal = `#{Signal.signame(e.signo)}`")
       Harmoniser.server? ? exit(0) : raise
     end
   end

data/lib/harmoniser/launcher/base.rb

@@ -0,0 +1,80 @@
+require "harmoniser/subscriber"
+require "harmoniser/subscriber/registry"
+require "harmoniser/work_pool_reporter"
+
+module Harmoniser
+  module Launcher
+    class Base
+      attr_reader :subscribers
+
+      def initialize(configuration:, logger:)
+        @configuration = configuration
+        @logger = logger
+        @subscribers = Subscriber.registry
+      end
+
+      def start
+        boot_app
+        start_subscribers
+        @logger.info("Subscribers registered to consume messages from queues: klasses = `#{@subscribers}`")
+      end
+
+      def stop
+        @logger.info("Shutting down!")
+        maybe_close
+        @logger.info("Bye!")
+      end
+
+      private
+
+      def boot_app
+        if File.directory?(@configuration.require)
+          load_rails
+        else
+          load_file
+        end
+      end
+
+      def load_rails
+        filepath = File.expand_path("#{@configuration.require}/config/environment.rb")
+        require filepath
+      rescue LoadError => e
+        @logger.warn("Error while requiring file within directory. No subscribers will run for this process: require = `#{@configuration.require}`, filepath = `#{filepath}`, error_class = `#{e.class}`, error_message = `#{e.message}`, error_backtrace = `#{e.backtrace&.first(5)}`")
+      end
+
+      def load_file
+        require @configuration.require
+      rescue LoadError => e
+        @logger.warn("Error while requiring file. No subscribers will run for this process: require = `#{@configuration.require}`, error_class = `#{e.class}`, error_message = `#{e.message}`, error_backtrace = `#{e.backtrace&.first(5)}`")
+      end
+
+      def maybe_close
+        maybe_close_subscriber
+        maybe_close_publisher
+      end
+
+      def maybe_close_publisher
+        return unless Publisher.connection?
+        Publisher.connection.close
+      end
+
+      def maybe_close_subscriber
+        return unless Subscriber.connection?
+
+        maybe_cancel_subscribers
+        report_work_pool
+        Subscriber.connection.close
+      end
+
+      def maybe_cancel_subscribers
+        @logger.info("Subscribers will be cancelled from queues: klasses = `#{@subscribers}`")
+        @subscribers.each(&:harmoniser_subscriber_stop)
+        @logger.info("Subscribers cancelled: klasses = `#{@subscribers}`")
+      end
+
+      def report_work_pool
+        @logger.info("Stats about the work pool: work_pool_reporter = `#{WorkPoolReporter.new(consumers: @consumers)}`. Note: A backlog greater than zero means messages could be lost for subscribers configured with no_ack, i.e. automatic ack")
+      end
+    end
+  end
+end

data/lib/harmoniser/launcher/bounded.rb

@@ -0,0 +1,19 @@
+require_relative "base"
+
+module Harmoniser
+  module Launcher
+    class Bounded < Base
+      private
+
+      def start_subscribers
+        @consumers = subscribers.map do |klass|
+          klass.harmoniser_subscriber_start(channel: channel)
+        end
+      end
+
+      def channel
+        @channel ||= Subscriber.create_channel(consumer_pool_size: @configuration.concurrency, consumer_pool_shutdown_timeout: @configuration.timeout)
+      end
+    end
+  end
+end

data/lib/harmoniser/launcher/unbounded.rb

@@ -0,0 +1,11 @@
+require_relative "base"
+
+module Harmoniser
+  module Launcher
+    class UnBounded < Base
+      def start_subscribers
+        @consumers = subscribers.map(&:harmoniser_subscriber_start)
+      end
+    end
+  end
+end

data/lib/harmoniser/launcher.rb

@@ -1,47 +1,14 @@
-module Harmoniser
-  class Launcher
-    def initialize(configuration:, logger:)
-      @configuration = configuration
-      @logger = logger
-    end
-
-    def start
-      boot_app
-      start_subscribers
-    end
+require_relative "launcher/bounded"
+require_relative "launcher/unbounded"
 
-    private
-
-    def boot_app
-      if File.directory?(@configuration.require)
-        load_rails
-      else
-        load_file
-      end
-    end
+module Harmoniser
+  module Launcher
+    class << self
+      def call(configuration:, logger:)
+        return Bounded.new(configuration:, logger:) unless configuration.options.unbounded_concurrency?
 
-    # TODO - Frameworks like Rails which have autoload for development/test will not start any subscriber unless the files where subscribers are located are required explicitly. Since we premier production and the eager load ensures that every file is loaded, this approach works
-    def start_subscribers
-      klasses = Subscriber.harmoniser_included
-      klasses.each do |klass|
-        klass.harmoniser_subscriber_start
+        UnBounded.new(configuration:, logger:)
       end
-      @logger.info("Subscribers registered to consume messages from queues: klasses = `#{klasses}`")
-    end
-
-    private
-
-    def load_rails
-      filepath = File.expand_path("#{@configuration.require}/config/environment.rb")
-      require filepath
-    rescue LoadError => e
-      @logger.warn("Error while requiring file within directory. No subscribers will run for this process: require = `#{@configuration.require}`, filepath = `#{filepath}`, error_class = `#{e.class}`, error_message = `#{e.message}`, error_backtrace = `#{e.backtrace&.first(5)}`")
-    end
-
-    def load_file
-      require @configuration.require
-    rescue LoadError => e
-      @logger.warn("Error while requiring file. No subscribers will run for this process: require = `#{@configuration.require}`, error_class = `#{e.class}`, error_message = `#{e.message}`, error_backtrace = `#{e.backtrace&.first(5)}`")
     end
   end
 end

data/lib/harmoniser/options.rb

@@ -1,9 +1,13 @@
 module Harmoniser
-  Options = Data.define(:environment, :require, :verbose) do
+  Options = Data.define(:concurrency, :environment, :require, :verbose, :timeout) do
     def production?
       environment == "production"
     end
 
+    def unbounded_concurrency?
+      concurrency == Float::INFINITY
+    end
+
     def verbose?
       !!verbose
     end

data/lib/harmoniser/parser.rb

@@ -8,6 +8,9 @@ module Harmoniser
       @options = {}
       @option_parser = OptionParser.new do |opts|
         opts.banner = "harmoniser [options]"
+        opts.on "-c", "--concurrency INT", "Set the number of threads to use" do |arg|
+          @options[:concurrency] = Integer(arg)
+        end
         opts.on "-e", "--environment ENV", "Set the application environment (defaults to inferred environment or 'production')" do |arg|
           @options[:environment] = arg
         end

data/lib/harmoniser/publisher.rb

@@ -1,10 +1,10 @@
-require "harmoniser/channelable"
+require "harmoniser/connectable"
 require "harmoniser/definition"
 
 module Harmoniser
   module Publisher
     class MissingExchangeDefinition < StandardError; end
-    include Channelable
+    include Connectable
 
     module ClassMethods
       def harmoniser_publisher(exchange_name:)
@@ -44,7 +44,7 @@ module Harmoniser
       end
 
       def raise_missing_exchange_definition
-        raise MissingExchangeDefinition, "Please call the harmoniser_publisher class method at `#{const_get(:HARMONISER_PUBLISHER_CLASS)}` with the exchange_name that will be used for publishing"
+        raise MissingExchangeDefinition, "Please call the harmoniser_publisher class method at `#{name}` with the exchange_name that will be used for publishing"
       end
 
       def handle_return(exchange)
@@ -57,9 +57,15 @@ module Harmoniser
     class << self
       def included(base)
         base.const_set(:HARMONISER_PUBLISHER_MUTEX, Mutex.new)
-        base.const_set(:HARMONISER_PUBLISHER_CLASS, base)
+        base.private_constant(:HARMONISER_PUBLISHER_MUTEX)
         base.extend(ClassMethods)
       end
     end
+
+    at_exit do
+      next if Harmoniser.server?
+      next unless Publisher.connection?
+      Publisher.connection.close
+    end
   end
 end

data/lib/harmoniser/subscriber/registry.rb

@@ -0,0 +1,19 @@
+require "forwardable"
+
+module Harmoniser
+  module Subscriber
+    class Registry
+      extend Forwardable
+
+      def_delegators :@klasses, :<<, :to_a, :each, :map
+
+      def initialize
+        @klasses = Set.new
+      end
+
+      def to_s
+        to_a.map(&:harmoniser_subscriber_to_s).to_s
+      end
+    end
+  end
+end

data/lib/harmoniser/subscriber.rb

@@ -1,12 +1,11 @@
-require "harmoniser/channelable"
+require "harmoniser/connectable"
 require "harmoniser/definition"
-require "harmoniser/includable"
+require "harmoniser/subscriber/registry"
 
 module Harmoniser
   module Subscriber
     class MissingConsumerDefinition < StandardError; end
-    include Channelable
-    include Includable
+    include Connectable
 
     module ClassMethods
       def harmoniser_subscriber(queue_name:, consumer_tag: nil, no_ack: true, exclusive: false, arguments: {})
@@ -19,22 +18,34 @@ module Harmoniser
         )
       end
 
-      def harmoniser_subscriber_start
+      def harmoniser_subscriber_start(channel: nil)
         const_get(:HARMONISER_SUBSCRIBER_MUTEX).synchronize do
-          @harmoniser_consumer ||= create_consumer
+          @harmoniser_consumer ||= create_consumer(channel)
         end
       end
 
+      def harmoniser_subscriber_stop
+        return unless @harmoniser_consumer
+        return unless @harmoniser_consumer.channel.open?
+
+        @harmoniser_consumer.cancel
+      end
+
+      def harmoniser_subscriber_to_s
+        definition = @harmoniser_consumer_definition
+        "<#{name}>: queue_name = `#{definition.queue_name}`, no_ack = `#{definition.no_ack}`"
+      end
+
       private
 
-      def create_consumer
+      def create_consumer(channel)
         raise_missing_consumer_definition unless @harmoniser_consumer_definition
 
-        channel = Subscriber.create_channel
+        ch = channel || Subscriber.create_channel
         consumer = Bunny::Consumer.new(
-          channel,
+          ch,
           @harmoniser_consumer_definition.queue_name,
-          @harmoniser_consumer_definition.consumer_tag || channel.generate_consumer_tag,
+          @harmoniser_consumer_definition.consumer_tag || ch.generate_consumer_tag,
           @harmoniser_consumer_definition.no_ack,
           @harmoniser_consumer_definition.exclusive,
           @harmoniser_consumer_definition.arguments
@@ -71,16 +82,20 @@ module Harmoniser
       end
 
       def raise_missing_consumer_definition
-        raise MissingConsumerDefinition, "Please call the harmoniser_subscriber class method at `#{const_get(:HARMONISER_SUBSCRIBER_CLASS)}` with the queue_name that will be used for subscribing"
+        raise MissingConsumerDefinition, "Please call the harmoniser_subscriber class method at `#{name}` with the queue_name that will be used for subscribing"
       end
     end
 
     class << self
       def included(base)
         base.const_set(:HARMONISER_SUBSCRIBER_MUTEX, Mutex.new)
-        base.const_set(:HARMONISER_SUBSCRIBER_CLASS, base)
+        base.private_constant(:HARMONISER_SUBSCRIBER_MUTEX)
+        registry << base
         base.extend(ClassMethods)
-        harmoniser_register_included(base)
+      end
+
+      def registry
+        @registry ||= Registry.new
       end
     end
   end

data/lib/harmoniser/topology.rb

@@ -1,9 +1,9 @@
-require "harmoniser/channelable"
+require "harmoniser/connectable"
 require "harmoniser/definition"
 
 module Harmoniser
   class Topology
-    include Channelable
+    include Connectable
 
     attr_reader :bindings, :exchanges, :queues
 
@@ -41,11 +41,12 @@ module Harmoniser
     end
 
     def declare
-      channel = self.class.create_channel
-      declare_exchanges(channel)
-      declare_queues(channel)
-      declare_bindings(channel)
-      Harmoniser.connection.close
+      self.class.create_channel.tap do |ch|
+        declare_exchanges(ch)
+        declare_queues(ch)
+        declare_bindings(ch)
+        ch.connection.close
+      end
     end
 
     private

data/lib/harmoniser/version.rb

@@ -1,3 +1,3 @@
 module Harmoniser
-  VERSION = "0.9.0"
+  VERSION = "0.11.0"
 end

data/lib/harmoniser/work_pool_reporter.rb

@@ -0,0 +1,48 @@
+require "delegate"
+
+module Harmoniser
+  class WorkPoolReporter
+    def initialize(consumers:, logger: Harmoniser.logger)
+      @channels = build_channels(consumers)
+      @logger = logger
+    end
+
+    def to_s
+      "<#{self.class.name}>: #{channels_to_s}"
+    end
+
+    private
+
+    def channels_to_s
+      @channels.map do |(channel, queues)|
+        channel_info(channel, queues.to_a)
+      end
+    end
+
+    def channel_info(channel, queues)
+      work_pool = channel.work_pool
+      "<#{channel.id}>: backlog = `#{work_pool.backlog}`, running? = `#{work_pool.running?}`, queues = `#{queues}`"
+    end
+
+    def build_channels(consumers)
+      initial = Hash.new { |hash, key| hash[key] = Set.new }
+      consumers.each_with_object(initial) do |consumer, acc|
+        acc[DecoratedChannel.new(consumer.channel)] << consumer.queue
+      end
+    end
+
+    class DecoratedChannel < SimpleDelegator
+      def id
+        __getobj__.id
+      end
+
+      def hash
+        id.hash
+      end
+
+      def eql?(other)
+        other.is_a?(DecoratedChannel) && id == other.id
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: harmoniser
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Jose Lloret
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-08-09 00:00:00.000000000 Z
+date: 2024-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.22'
+        version: '2.23'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.22'
+        version: '2.23'
 description: A declarative approach to communication with RabbitMQ that simplifies
   the integration of publishing and consuming messages.
 email:
@@ -42,22 +42,25 @@ files:
 - bin/setup
 - harmoniser.gemspec
 - lib/harmoniser.rb
-- lib/harmoniser/channelable.rb
 - lib/harmoniser/cli.rb
 - lib/harmoniser/configurable.rb
 - lib/harmoniser/configuration.rb
 - lib/harmoniser/connectable.rb
 - lib/harmoniser/connection.rb
 - lib/harmoniser/definition.rb
-- lib/harmoniser/includable.rb
 - lib/harmoniser/launcher.rb
+- lib/harmoniser/launcher/base.rb
+- lib/harmoniser/launcher/bounded.rb
+- lib/harmoniser/launcher/unbounded.rb
 - lib/harmoniser/loggable.rb
 - lib/harmoniser/options.rb
 - lib/harmoniser/parser.rb
 - lib/harmoniser/publisher.rb
 - lib/harmoniser/subscriber.rb
+- lib/harmoniser/subscriber/registry.rb
 - lib/harmoniser/topology.rb
 - lib/harmoniser/version.rb
+- lib/harmoniser/work_pool_reporter.rb
 homepage: https://github.com/jollopre/harmoniser
 licenses:
 - MIT

data/lib/harmoniser/channelable.rb

@@ -1,37 +0,0 @@
-module Harmoniser
-  module Channelable
-    MUTEX = Mutex.new
-    private_constant :MUTEX
-
-    module ClassMethods
-      def harmoniser_channel
-        MUTEX.synchronize do
-          @harmoniser_channel ||= create_channel
-        end
-      end
-
-      def create_channel
-        channel = Harmoniser.connection.create_channel
-        channel.on_error(&method(:on_error).to_proc)
-        channel.on_uncaught_exception(&method(:on_uncaught_exception).to_proc)
-        channel
-      end
-
-      private
-
-      def on_error(channel, amq_method)
-        Harmoniser.logger.error("Default on_error handler executed for channel: method = `#{amq_method}`, exchanges = `#{channel.exchanges.keys}`, queues = `#{channel.queues.keys}`")
-      end
-
-      def on_uncaught_exception(error, consumer)
-        Harmoniser.logger.error("Default on_uncaught_exception handler executed for channel: error_class = `#{error.class}`, error_message = `#{error.message}`, error_backtrace = `#{error.backtrace&.first(5)}, queue = `#{consumer.queue}`")
-      end
-    end
-
-    class << self
-      def included(base)
-        base.extend(ClassMethods)
-      end
-    end
-  end
-end

data/lib/harmoniser/includable.rb

@@ -1,25 +0,0 @@
-module Harmoniser
-  module Includable
-    MUTEX = Mutex.new
-    private_constant :MUTEX
-
-    module ClassMethods
-      def harmoniser_register_included(klass)
-        MUTEX.synchronize do
-          @harmoniser_included ||= Set.new
-          @harmoniser_included << klass
-        end
-      end
-
-      def harmoniser_included
-        @harmoniser_included.to_a
-      end
-    end
-
-    class << self
-      def included(base)
-        base.extend(ClassMethods)
-      end
-    end
-  end
-end