rabbit_carrots 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8e5f321b0b92e7e1c3f1926e28b692398fd453e22c591ad0715fa7bc93b1b34
-  data.tar.gz: 5be7f4d4378c6a0fdc4f2edbec9fd438dca66a98ec1b9659d6a6a44d8d4d3cb4
+  metadata.gz: 0412aaeeded0b8ecd59e6f694e12b9cd692d60f280012bd55517a8871b43c579
+  data.tar.gz: e013959ec40f1222529265807bcc637582d27d7a07a5be1d29f0cf1dafb46057
 SHA512:
-  metadata.gz: 83bde341ce60aaaee1bcfd1c323484641fcfbc7e2d8b74fcd34ef0afe7eb91dc9d332254f34049dfe5b24120bfb717bf1d7cdc758130481059fcd9b1b5a7d848
-  data.tar.gz: 585ff0eb908008acdc9b323dd138dcb676955c2c87586f62d71d7926c534cfe988c1e071ae2b308455299a3a1672123ea054a5a70f2abea3194fad2456f38af4
+  metadata.gz: 13514329b505be358cd9ff2eddffa099c3a955150df51cfc045ac9ceb6d01779e848e707d391dcc4610ee75055cf251cf15174897758f29f4fea1f352f51639b
+  data.tar.gz: b4d242e1b5bc1050f4fc975f82cf287e7cb4410225b243a5ac05844cd3b6874456c4109c5e524ad353bca84b9ef89c36d1a1871e1dd7557eaa48845f859e19c8

data/CHANGELOG.md

@@ -1,5 +1,46 @@
 ## [Unreleased]
 
+## [1.2.0] - 2026-09-22
+
+### Fixed
+
+- **Consumers stopped consuming, permanently, after any connection recovery.**
+  The exchange was declared passively, which records `durable: false` for
+  topology recovery. On the first reconnect Bunny replayed that against a
+  durable exchange, the broker answered `PRECONDITION_FAILED - inequivalent arg
+  'durable'`, and the channel closed, taking every consumer with it. The process
+  stayed alive and exited 0, so nothing restarted it.
+- Acking or nacking a closed channel no longer raises into Bunny's work pool.
+  The rescue for a failed ack used to nack on the same closed channel, and that
+  second raise killed the consumer.
+- `start` no longer raises `NameError` when the configured ORM is not loaded.
+- `bunny` and `connection_pool` are required by the gem.
+- Each consumer gets its own channel. Channels came from a pool that was
+  handed back as soon as `subscribe` returned, so once there were more
+  mappings than the pool size, consumers silently shared channels — and
+  therefore shared a prefetch, a work pool, and the fate of that channel.
+
+### Added
+
+- A supervisor that checks the connection, consumers and channels every
+  `supervision_interval`. After `unhealthy_grace` without consuming it shuts
+  down and exits non-zero so the process is restarted. Transient reconnects are
+  tolerated.
+- `Core#start` returns false when the service died; `rabbit_carrots:eat` and the
+  Puma plugin exit non-zero on it. `Core#healthy?` added.
+- Config: `rabbitmq_exchange_durable` (default `true`), `prefetch` (default 10,
+  was hardcoded), `supervision_interval` (5s), `startup_grace` (60s),
+  `unhealthy_grace` (60s).
+- Specs that run against a real broker (`docker compose up -d`), including a
+  regression test that severs the connection and asserts messages are still
+  consumed.
+
+### Changed
+
+- `bunny` floor raised from `>= 2.22` to `>= 3.1`; 2.x and 3.x record topology
+  differently and only 3.x is tested.
+- The rake task and Puma plugin now exit non-zero when the consumer dies.
+
 ## [0.1.0] - 2022-12-01
 
 - Initial release

data/Gemfile

@@ -5,10 +5,10 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in rabbit_carrots.gemspec
 gemspec
 
-gem 'rake', '~> 13.3.1'
+gem 'rake', '~> 13.4.2'
 
 gem 'rspec', '~> 3.13.2'
 
-gem 'rubocop', '~> 1.82.1'
+gem 'rubocop', '~> 1.91.0'
 
-gem 'rubocop-rails', '~> 2.34.3'
+gem 'rubocop-rails', '~> 2.38.0'

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    rabbit_carrots (1.1.0)
-      bunny (>= 2.22)
+    rabbit_carrots (1.2.0)
+      bunny (>= 3.1)
       connection_pool (>= 2.4)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (8.1.2)
+    activesupport (8.1.3.1)
       base64
       bigdecimal
       concurrent-ruby (~> 1.0, >= 1.3.1)
@@ -21,36 +21,40 @@ GEM
       securerandom (>= 0.3)
       tzinfo (~> 2.0, >= 2.0.5)
       uri (>= 0.13.1)
-    amq-protocol (2.5.0)
+    amq-protocol (2.9.0)
     ast (2.4.3)
     base64 (0.3.0)
-    bigdecimal (4.0.1)
-    bunny (2.24.0)
-      amq-protocol (~> 2.3)
+    bigdecimal (4.1.3)
+    bunny (3.4.0)
+      amq-protocol (~> 2.9)
+      logger (~> 1, >= 1.7)
+      openssl (>= 3.3)
       sorted_set (~> 1, >= 1.0.2)
-    concurrent-ruby (1.3.6)
+    concurrent-ruby (1.3.8)
     connection_pool (3.0.2)
     diff-lcs (1.6.2)
     drb (2.2.3)
-    i18n (1.14.8)
+    i18n (1.15.2)
       concurrent-ruby (~> 1.0)
-    json (2.18.0)
-    language_server-protocol (3.17.0.5)
+    json (3.0.2)
+    language_server-protocol (3.17.0.6)
     lint_roller (1.1.0)
     logger (1.7.0)
-    minitest (6.0.1)
+    minitest (6.0.6)
+      drb (~> 2.0)
       prism (~> 1.5)
-    parallel (1.27.0)
-    parser (3.3.10.1)
+    openssl (4.0.2)
+    parallel (2.2.0)
+    parser (3.3.12.0)
       ast (~> 2.4.1)
       racc
-    prism (1.8.0)
+    prism (1.9.0)
     racc (1.8.1)
-    rack (3.2.4)
+    rack (3.2.7)
     rainbow (3.1.1)
-    rake (13.3.1)
-    rbtree (0.4.6)
-    regexp_parser (2.11.3)
+    rake (13.4.2)
+    rbtree (0.4.7)
+    regexp_parser (2.13.0)
     rspec (3.13.2)
       rspec-core (~> 3.13.0)
       rspec-expectations (~> 3.13.0)
@@ -60,53 +64,54 @@ GEM
     rspec-expectations (3.13.5)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-mocks (3.13.7)
+    rspec-mocks (3.13.8)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-support (3.13.6)
-    rubocop (1.82.1)
-      json (~> 2.3)
+    rspec-support (3.13.7)
+    rubocop (1.91.0)
+      json (>= 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)
-      parallel (~> 1.10)
+      parallel (>= 1.10)
       parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 2.9.3, < 3.0)
-      rubocop-ast (>= 1.48.0, < 2.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 4.0)
-    rubocop-ast (1.49.0)
+    rubocop-ast (1.50.0)
       parser (>= 3.3.7.2)
       prism (~> 1.7)
-    rubocop-rails (2.34.3)
+    rubocop-rails (2.38.0)
       activesupport (>= 4.2.0)
       lint_roller (~> 1.1)
       rack (>= 1.1)
-      rubocop (>= 1.75.0, < 2.0)
+      rubocop (>= 1.89.0, < 2.0)
       rubocop-ast (>= 1.44.0, < 2.0)
     ruby-progressbar (1.13.0)
     securerandom (0.4.1)
-    set (1.1.2)
-    sorted_set (1.0.3)
+    sorted_set (1.1.0)
       rbtree
-      set (~> 1.0)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    unicode-display_width (3.2.0)
-      unicode-emoji (~> 4.1)
-    unicode-emoji (4.2.0)
+    unicode-display_width (3.3.0)
+      unicode-emoji (~> 4.3)
+    unicode-emoji (4.3.0)
     uri (1.1.1)
 
 PLATFORMS
+  aarch64-linux-musl
   arm64-darwin-25
-  x86_64-linux
+  x86-linux-musl
+  x86_64-linux-gnu
+  x86_64-linux-musl
 
 DEPENDENCIES
   rabbit_carrots!
-  rake (~> 13.3.1)
+  rake (~> 13.4.2)
   rspec (~> 3.13.2)
-  rubocop (~> 1.82.1)
-  rubocop-rails (~> 2.34.3)
+  rubocop (~> 1.91.0)
+  rubocop-rails (~> 2.38.0)
 
 BUNDLED WITH
-   2.3.26
+  4.0.19

data/README.md

@@ -33,9 +33,14 @@ RabbitCarrots.configure do |c|
   c.rabbitmq_password = ENV.fetch('RABBITMQ__PASSWORD', nil)
   c.rabbitmq_vhost = ENV.fetch('RABBITMQ__VHOST', nil)
   c.rabbitmq_exchange_name = ENV.fetch('RABBITMQ__EXCHANGE_NAME', nil)
+  c.rabbitmq_exchange_durable = true # must match the exchange on the broker
   c.automatically_recover = true
   c.network_recovery_interval = 5
   c.recovery_attempts = 5
+  c.prefetch = 10
+  c.supervision_interval = 5
+  c.startup_grace = 60
+  c.unhealthy_grace = 60
   c.orm = :activerecord || :mongoid
   c.routing_key_mappings =  [
     { routing_keys: ['RK1', 'RK2'], queue: 'QUEUE_NAME', handler: 'CLASS HANDLER IN STRING' },
@@ -63,6 +68,38 @@ If no errors are thrown, the message will be acknowledged soon after the ```hand
 
 Note: Any other unrescued exception raised inside ```handle!``` the that is a subclass of ```StandardError``` will trigger a NACK and re-queue.
 
+### Exchange durability
+
+`rabbitmq_exchange_durable` has to match the exchange as it exists on the
+broker. It defaults to `true`, which is what a shared event bus exchange
+normally is.
+
+This is not cosmetic. Bunny records how an entity was declared and replays that
+declaration during automatic topology recovery, and topology recovery is not
+configurable. Declare a durable exchange as non-durable and every reconnect —
+a node put into maintenance, a failover, a brief network blip — is answered with
+`PRECONDITION_FAILED - inequivalent arg 'durable'`, which closes the channel and
+takes every consumer on it with it. The process stays up and stops consuming.
+
+If the durability is wrong, the service now says so and refuses to start rather
+than consuming from a channel that will not survive its first reconnect.
+
+### Health and restarts
+
+A consumer subscribes and then does its work on Bunny's own threads, so the
+process staying alive says nothing about whether it is still consuming. The
+supervisor checks every `supervision_interval` seconds that the connection is
+open, every consumer is still registered, and every channel is still alive.
+
+A reconnect in progress is indistinguishable from a dead consumer, so the
+service is only declared dead after `unhealthy_grace` seconds without
+consuming. It then shuts down and **exits non-zero**, so that Kubernetes, Puma
+or systemd restarts it. Make sure whatever supervises the process actually
+restarts it on failure.
+
+`Core#start` returns `true` when it shut down because it was asked to, and
+`false` when it died.
+
 ### Running
 
 For better scalability and improved performance, you can run rabbit_carrots in standalone mode by invoking the following command:

data/lib/puma/plugin/rabbit_carrots.rb

@@ -30,9 +30,14 @@ Puma::Plugin.create do
   private
 
   def start_rabbit_carrots_consumer
-    core_service.start(kill_to_restart_on_standard_error: true)
+    healthy = core_service.start(kill_to_restart_on_standard_error: true)
+
+    # Exits the forked child, not the Rails process, so that
+    # monitor_rabbit_carrots notices and brings Puma down with it.
+    exit(1) unless healthy # rubocop:disable Rails/Exit
   rescue StandardError => e
     Rails.logger.error "Error starting Rabbit Carrots: #{e.message}"
+    exit(1) # rubocop:disable Rails/Exit
   end
 
   def stop_rabbit_carrots

data/lib/rabbit_carrots/configuration.rb

@@ -16,9 +16,23 @@ module RabbitCarrots
                   :rabbitmq_vhost,
                   :routing_key_mappings,
                   :rabbitmq_exchange_name,
+                  # Must match the exchange on the broker, or topology recovery
+                  # is rejected and every consumer is lost. Defaults to true.
+                  :rabbitmq_exchange_durable,
                   :automatically_recover,
                   :network_recovery_interval,
-                  :recovery_attempts
+                  :recovery_attempts,
+                  # Unacked messages allowed per consumer. Defaults to 10.
+                  :prefetch,
+                  # Seconds between supervisor health checks. Defaults to 5.
+                  :supervision_interval,
+                  # Seconds to wait for every consumer to subscribe at boot.
+                  # Defaults to 60.
+                  :startup_grace,
+                  # Seconds the service may go without consuming before the
+                  # supervisor gives up. Must outlast Bunny's recovery.
+                  # Defaults to 60.
+                  :unhealthy_grace
 
     def orm
       @orm ||= :activerecord

data/lib/rabbit_carrots/connection.rb

@@ -27,5 +27,17 @@ module RabbitCarrots
         connection.create_channel
       end
     end
+
+    # Consumers get a channel of their own rather than one from the pool. A
+    # pooled channel is returned as soon as `subscribe` returns, so several
+    # consumers end up sharing one channel, which means they share a prefetch,
+    # a work pool, and the fate of that channel when it errors.
+    def create_channel(...)
+      connection.create_channel(...)
+    end
+
+    def open?
+      !connection.nil? && connection.open?
+    end
   end
 end

data/lib/rabbit_carrots/core.rb

@@ -13,19 +13,29 @@ module RabbitCarrots
     def initialize(logger: nil)
       @logger = create_logger_adapter(logger || Logger.new(Rails.env.production? ? '/proc/self/fd/1' : $stdout))
       @threads = []
+      @consumers = []
+      @consumers_mutex = Mutex.new
       @running = true
       @shutdown_requested = false
+      @healthy = true
     end
 
+    # Returns true when the service shut down because it was asked to, false
+    # when it shut down because it could no longer consume.
     def start(kill_to_restart_on_standard_error: false)
-      self.class.database_agnostic_not_null_violation = RabbitCarrots.configuration.orm == :activerecord ? ActiveRecord::NotNullViolation : RabbitCarrots::EventHandlers::Errors::PlaceholderError
-      self.class.database_agnostic_connection_not_established = RabbitCarrots.configuration.orm == :activerecord ? ActiveRecord::ConnectionNotEstablished : ::Mongo::Error::SocketError
-      self.class.database_agnostic_record_invalid = RabbitCarrots.configuration.orm == :activerecord ? ActiveRecord::RecordInvalid : ::Mongoid::Errors::Validations
+      activerecord = RabbitCarrots.configuration.orm == :activerecord
+
+      self.class.database_agnostic_not_null_violation = activerecord ? error_class('ActiveRecord::NotNullViolation') : RabbitCarrots::EventHandlers::Errors::PlaceholderError
+      self.class.database_agnostic_connection_not_established = error_class(activerecord ? 'ActiveRecord::ConnectionNotEstablished' : 'Mongo::Error::SocketError')
+      self.class.database_agnostic_record_invalid = error_class(activerecord ? 'ActiveRecord::RecordInvalid' : 'Mongoid::Errors::Validations')
 
       channels = RabbitCarrots.configuration.routing_key_mappings.map do |mapping|
         { **mapping, handler: mapping[:handler].constantize }
       end
 
+      @expected_consumers = channels.size
+      @startup_deadline = monotonic_now + startup_grace
+
       channels.each do |channel|
         handler_class = channel[:handler]
         raise "#{handler_class.name} must respond to `handle!`" unless handler_class.respond_to?(:handle!)
@@ -45,18 +55,14 @@ module RabbitCarrots
       Signal.trap('INT') { request_shutdown }
       Signal.trap('TERM') { request_shutdown }
 
-      while @running
-        if @shutdown_requested
-          request_shutdown
-          sleep 1
-          break
-        end
-        sleep 1
-      end
+      supervise
 
       @threads.each(&:join)
+
+      @healthy
     rescue StandardError => e
       logger.error "Error starting Rabbit Carrots: #{e.message}"
+      false
     end
 
     def request_shutdown
@@ -77,53 +83,213 @@ module RabbitCarrots
       @running = false
     end
 
+    def healthy?
+      @healthy
+    end
+
     def run_task(queue_name:, handler_class:, routing_keys:, queue_arguments: {}, exchange_name: nil, kill_to_restart_on_standard_error: false)
-      RabbitCarrots::Connection.instance.channel.with do |channel|
-        exchange = channel.topic(exchange_name || RabbitCarrots.configuration.rabbitmq_exchange_name, durable: true)
+      channel = RabbitCarrots::Connection.instance.create_channel
+      exchange_name ||= RabbitCarrots.configuration.rabbitmq_exchange_name
+      exchange = declare_exchange(channel, exchange_name)
 
-        logger.info "Listening on QUEUE: #{queue_name} for ROUTING KEYS: #{routing_keys}"
-        queue = channel.queue(queue_name, durable: true, arguments: queue_arguments)
+      logger.info "Listening on QUEUE: #{queue_name} for ROUTING KEYS: #{routing_keys}"
+      queue = channel.queue(queue_name, durable: true, arguments: queue_arguments)
 
-        routing_keys.map(&:strip).each { |k| queue.bind(exchange, routing_key: k) }
+      routing_keys.map(&:strip).each { |k| queue.bind(exchange, routing_key: k) }
 
-        queue.subscribe(block: false, manual_ack: true, prefetch: 10) do |delivery_info, properties, payload|
-          break if @shutdown_requested
+      consumer = queue.subscribe(block: false, manual_ack: true, prefetch:) do |delivery_info, properties, payload|
+        next if @shutdown_requested
 
+        begin
           logger.info "Received from queue: #{queue_name}, Routing Keys: #{routing_keys}"
           handler_class.handle!(channel, delivery_info, properties, payload)
-          channel.ack(delivery_info.delivery_tag, false)
+          acknowledge(channel, delivery_info)
         rescue RabbitCarrots::EventHandlers::Errors::NackMessage, JSON::ParserError => _e
           payload = encode_payload(payload)
           logger.warn "Nacked message: #{payload}"
-          channel.nack(delivery_info.delivery_tag, false, false)
+          reject(channel, delivery_info, requeue: false)
         rescue RabbitCarrots::EventHandlers::Errors::NackAndRequeueMessage => _e
           payload = encode_payload(payload)
           logger.warn "Nacked and Requeued message: #{payload}"
-          channel.nack(delivery_info.delivery_tag, false, true)
+          reject(channel, delivery_info, requeue: true)
         rescue self.class.database_agnostic_not_null_violation, self.class.database_agnostic_record_invalid => e
           payload = encode_payload(payload)
           logger.warn "Null constraint or Invalid violation: #{payload}. Error: #{e.message}"
-          channel.ack(delivery_info.delivery_tag, false)
+          acknowledge(channel, delivery_info)
         rescue self.class.database_agnostic_connection_not_established => e
           payload = encode_payload(payload)
           logger.warn "Error connection not established to the database: #{payload}. Error: #{e.message}"
           sleep 3
-          channel.nack(delivery_info.delivery_tag, false, true)
+          reject(channel, delivery_info, requeue: true)
         rescue StandardError => e
           payload = encode_payload(payload)
           logger.error "Error handling message: #{payload}. Error: #{e.message}"
           sleep 3
-          channel.nack(delivery_info.delivery_tag, false, true)
+          reject(channel, delivery_info, requeue: true)
           Process.kill('SIGTERM', Process.pid) if kill_to_restart_on_standard_error
         end
       end
+
+      register_consumer(queue_name:, channel:, consumer:)
     rescue StandardError => e
       logger.error "Bunny session error: #{e.message}"
+      @healthy = false
       request_shutdown
     end
 
     private
 
+    # Falls back to a class that is never raised when the ORM is not loaded.
+    def error_class(name)
+      Object.const_get(name)
+    rescue NameError
+      RabbitCarrots::EventHandlers::Errors::PlaceholderError
+    end
+
+    # Don't declare passively; Bunny topology recovery replays options, causing durable/exchange mismatch errors.
+    def declare_exchange(channel, exchange_name)
+      channel.topic(exchange_name, durable: exchange_durable?)
+    rescue Bunny::PreconditionFailed => e
+      logger.error(
+        "Exchange '#{exchange_name}' exists on the broker with a different durability than the one " \
+        "declared here (durable: #{exchange_durable?}). Set `config.rabbitmq_exchange_durable` to " \
+        "match the exchange. Error: #{e.message}"
+      )
+      raise
+    end
+
+    def exchange_durable?
+      durable = RabbitCarrots.configuration.rabbitmq_exchange_durable
+      durable.nil? ? true : durable # rubocop:disable Style/RedundantCondition
+    end
+
+    def prefetch
+      RabbitCarrots.configuration.prefetch || 10
+    end
+
+    def supervision_interval
+      RabbitCarrots.configuration.supervision_interval || 5
+    end
+
+    def startup_grace
+      RabbitCarrots.configuration.startup_grace || 60
+    end
+
+    def unhealthy_grace
+      RabbitCarrots.configuration.unhealthy_grace || 60
+    end
+
+    def register_consumer(queue_name:, channel:, consumer:)
+      @consumers_mutex.synchronize do
+        @consumers << { queue_name:, channel:, consumer: }
+      end
+    end
+
+    # `subscribe` is non-blocking, so the consumer threads finish at boot and
+    # every delivery happens on Bunny's threads, which this class does not own.
+    # Without this loop, a channel closed by a failed recovery leaves the
+    # process alive and idle forever.
+    def supervise
+      while @running
+        if @shutdown_requested
+          request_shutdown
+          sleep 1
+          break
+        end
+
+        if consumers_healthy?
+          logger.info 'Rabbit Carrots recovered and is consuming again' if @degraded_since
+          @degraded_since = nil
+        else
+          @degraded_since ||= monotonic_now
+          degraded_for = monotonic_now - @degraded_since
+
+          if degraded_for >= unhealthy_grace
+            @healthy = false
+            logger.error "Rabbit Carrots has not been consuming for #{degraded_for.round}s; shutting down so the process can be restarted"
+            request_shutdown
+            break
+          end
+
+          # A reconnect in progress is indistinguishable from a dead consumer.
+          logger.warn "Rabbit Carrots is not consuming (#{degraded_for.round}s); waiting for recovery"
+        end
+
+        sleep supervision_interval
+      end
+    end
+
+    def consumers_healthy?
+      return false unless connection_open?
+
+      registered = @consumers_mutex.synchronize { @consumers.dup }
+
+      if registered.size < @expected_consumers.to_i
+        return true if monotonic_now < @startup_deadline
+
+        logger.warn "Only #{registered.size} of #{@expected_consumers} consumers registered within #{startup_grace}s"
+        return false
+      end
+
+      registered.all? { |entry| consumer_alive?(entry) }
+    end
+
+    def consumer_alive?(entry)
+      channel = entry[:channel]
+      consumer = entry[:consumer]
+
+      unless channel.open?
+        logger.warn "Channel for queue #{entry[:queue_name]} is closed"
+        return false
+      end
+
+      # Bunny can regenerate the tag when it recovers a consumer.
+      return true if channel.consumers.key?(consumer.consumer_tag) || channel.consumers.value?(consumer)
+
+      logger.warn "Consumer for queue #{entry[:queue_name]} is no longer registered on its channel"
+      false
+    rescue StandardError => e
+      logger.warn "Could not determine consumer health for queue #{entry[:queue_name]}: #{e.message}"
+      false
+    end
+
+    def connection_open?
+      return true if RabbitCarrots::Connection.instance.open?
+
+      logger.warn 'RabbitMQ connection is closed'
+      false
+    rescue StandardError => e
+      logger.warn "Could not determine RabbitMQ connection health: #{e.message}"
+      false
+    end
+
+    # Acking a closed channel raises, and so does the nack in the rescue that
+    # follows; that second raise escapes into Bunny's work pool and takes the
+    # consumer with it. The broker redelivers whatever was left unacked.
+    def acknowledge(channel, delivery_info)
+      return false unless channel.open?
+
+      channel.ack(delivery_info.delivery_tag, false)
+      true
+    rescue StandardError => e
+      logger.error "Failed to ack message on a closed or closing channel: #{e.message}"
+      false
+    end
+
+    def reject(channel, delivery_info, requeue:)
+      return false unless channel.open?
+
+      channel.nack(delivery_info.delivery_tag, false, requeue)
+      true
+    rescue StandardError => e
+      logger.error "Failed to nack message on a closed or closing channel: #{e.message}"
+      false
+    end
+
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
     def create_logger_adapter(logger)
       return logger if logger.respond_to?(:info) && logger.respond_to?(:error) && logger.respond_to?(:warn)
 

data/lib/rabbit_carrots/tasks/rmq.rake

@@ -8,6 +8,9 @@ namespace :rabbit_carrots do
 
     core_service = RabbitCarrots::Core.new(logger:)
 
-    core_service.start(kill_to_restart_on_standard_error: true)
+    healthy = core_service.start(kill_to_restart_on_standard_error: true)
+
+    # Exit non-zero so that whatever supervises the process restarts it.
+    exit(1) unless healthy
   end
 end

data/lib/rabbit_carrots/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RabbitCarrots
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

data/lib/rabbit_carrots.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'bunny'
+require 'connection_pool'
+
 require_relative 'rabbit_carrots/version'
 require 'rabbit_carrots/errors'
 require 'rabbit_carrots/connection'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rabbit_carrots
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Brusk Awat
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-18 00:00:00.000000000 Z
+date: 2026-09-22 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: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.22'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: connection_pool
   requirement: !ruby/object:Gem::Requirement