Merge pull request #15 from arikarim/multi-exchange-

fix: Enhance run_task method to handle existing RabbitMQ exchanges by…

.github/workflows/main.yml

@@ -14,7 +14,7 @@ jobs:
     strategy:
       matrix:
         ruby:
-          - '3.1.2'
+          - '4.0.1'
 
     steps:
     - uses: actions/checkout@v3

.github/workflows/release.yml

@@ -14,7 +14,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 3.1.2
+          ruby-version: 4.0.1
 
       - name: publish gem
         run: |

.rubocop.yml

@@ -1,11 +1,12 @@
-require: rubocop-rails
+plugins:
+  - rubocop-rails
 
 AllCops:
   NewCops: enable
   SuggestExtensions: false
 Layout/SpaceBeforeBrackets: # (new in 1.7)
   Enabled: true
-Layout/LineLength: 
+Layout/LineLength:
   Max: 350
 Lint/AmbiguousAssignment: # (new in 1.7)
   Enabled: true
@@ -110,4 +111,6 @@ Metrics/MethodLength:
 Metrics/CyclomaticComplexity:
   Max: 15
 Metrics/PerceivedComplexity:
-  Max: 15
+  Max: 15
+Metrics/ParameterLists:
+  Max: 6

Gemfile

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

Gemfile.lock

@@ -1,86 +1,112 @@
 PATH
   remote: .
   specs:
-    rabbit_carrots (0.1.19)
-      bunny (>= 2.19.0)
-      connection_pool (~> 2.3.0)
+    rabbit_carrots (1.1.1)
+      bunny (>= 2.22)
+      connection_pool (>= 2.4)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.0.4)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
+    activesupport (8.1.2)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
       i18n (>= 1.6, < 2)
+      json
+      logger (>= 1.4.2)
       minitest (>= 5.1)
-      tzinfo (~> 2.0)
-    amq-protocol (2.3.2)
-    ast (2.4.2)
-    bunny (2.22.0)
-      amq-protocol (~> 2.3, >= 2.3.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    amq-protocol (2.5.0)
+    ast (2.4.3)
+    base64 (0.3.0)
+    bigdecimal (4.0.1)
+    bunny (2.24.0)
+      amq-protocol (~> 2.3)
       sorted_set (~> 1, >= 1.0.2)
-    concurrent-ruby (1.1.10)
-    connection_pool (2.3.0)
-    diff-lcs (1.5.0)
-    i18n (1.12.0)
+    concurrent-ruby (1.3.6)
+    connection_pool (3.0.2)
+    diff-lcs (1.6.2)
+    drb (2.2.3)
+    i18n (1.14.8)
       concurrent-ruby (~> 1.0)
-    json (2.6.2)
-    minitest (5.16.3)
-    parallel (1.22.1)
-    parser (3.1.2.1)
+    json (2.18.0)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    minitest (6.0.1)
+      prism (~> 1.5)
+    parallel (1.27.0)
+    parser (3.3.10.1)
       ast (~> 2.4.1)
-    rack (3.0.4.2)
+      racc
+    prism (1.8.0)
+    racc (1.8.1)
+    rack (3.2.4)
     rainbow (3.1.1)
-    rake (13.0.6)
+    rake (13.3.1)
     rbtree (0.4.6)
-    regexp_parser (2.6.1)
-    rexml (3.2.5)
-    rspec (3.12.0)
-      rspec-core (~> 3.12.0)
-      rspec-expectations (~> 3.12.0)
-      rspec-mocks (~> 3.12.0)
-    rspec-core (3.12.0)
-      rspec-support (~> 3.12.0)
-    rspec-expectations (3.12.0)
+    regexp_parser (2.11.3)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.12.0)
-    rspec-mocks (3.12.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.7)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.12.0)
-    rspec-support (3.12.0)
-    rubocop (1.39.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.6)
+    rubocop (1.82.1)
       json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
       parallel (~> 1.10)
-      parser (>= 3.1.2.1)
+      parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 1.8, < 3.0)
-      rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.23.0, < 2.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.48.0, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.23.0)
-      parser (>= 3.1.1.0)
-    rubocop-rails (2.17.3)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.49.0)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    rubocop-rails (2.34.3)
       activesupport (>= 4.2.0)
+      lint_roller (~> 1.1)
       rack (>= 1.1)
-      rubocop (>= 1.33.0, < 2.0)
-    ruby-progressbar (1.11.0)
-    set (1.0.3)
+      rubocop (>= 1.75.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)
       rbtree
       set (~> 1.0)
-    tzinfo (2.0.5)
+    tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    unicode-display_width (2.3.0)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.2.0)
+    uri (1.1.1)
 
 PLATFORMS
+  arm64-darwin-25
   x86_64-linux
 
 DEPENDENCIES
   rabbit_carrots!
-  rake (~> 13.0)
-  rspec (~> 3.0)
-  rubocop (~> 1.21)
-  rubocop-rails (~> 2.17)
+  rake (~> 13.3.1)
+  rspec (~> 3.13.2)
+  rubocop (~> 1.82.1)
+  rubocop-rails (~> 2.34.3)
 
 BUNDLED WITH
    2.3.26

README.md

@@ -32,7 +32,11 @@ RabbitCarrots.configure do |c|
   c.rabbitmq_user = ENV.fetch('RABBITMQ__USER', nil)
   c.rabbitmq_password = ENV.fetch('RABBITMQ__PASSWORD', nil)
   c.rabbitmq_vhost = ENV.fetch('RABBITMQ__VHOST', nil)
-  c.event_bus_exchange_name = ENV.fetch('EVENTBUS__EXCHANGE_NAME', nil)
+  c.rabbitmq_exchange_name = ENV.fetch('RABBITMQ__EXCHANGE_NAME', nil)
+  c.automatically_recover = true
+  c.network_recovery_interval = 5
+  c.recovery_attempts = 5
+  c.orm = :activerecord || :mongoid
   c.routing_key_mappings =  [
     { routing_keys: ['RK1', 'RK2'], queue: 'QUEUE_NAME', handler: 'CLASS HANDLER IN STRING' },
     { routing_keys: ['RK1', 'RK2'], queue: 'QUEUE_NAME', handler: 'CLASS HANDLER IN STRING' }
@@ -41,8 +45,6 @@ end
 
 ```
 
-
-
 Note that handler is a class that must implement a method named ```handle!``` that takes 4 parameters as follow: 
 
 ```ruby
@@ -53,8 +55,6 @@ class DummyEventHandler
 end
 ```
 
-
-
 Inside the handle message, you can NACK the message without re-queuing by raising ```RabbitCarrots::EventHandlers::Errors::NackMessage``` exception.
 
 To NACK and re-queue, raise ```RabbitCarrots::EventHandlers::Errors::NackAndRequeueMessage``` exception. 
@@ -65,8 +65,16 @@ Note: Any other unrescued exception raised inside ```handle!``` the that is a su
 
 ### Running
 
-Then run ```bundle exec rake rabbit_carrots:eat```.
+For better scalability and improved performance, you can run rabbit_carrots in standalone mode by invoking the following command:
+```bundle exec rake rabbit_carrots:eat```.
 
+#### Puma
+
+For small and medium sized projects, you can delegate the management of the rabbit_carrots to the Puma web server. To achieve that, add the following line to your puma.rb
+
+```plugin :rabbit_carrots```
+
+This will make sure that Puma will manage rabbit carrots as a background service and will gracefully terminate if rabbit_carrots eventually loses connection after multiple automatic recovery. 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

lib/puma/plugin/rabbit_carrots.rb

@@ -0,0 +1,86 @@
+# rabbit_carrots.rb
+require 'English'
+require 'puma/plugin'
+require 'rabbit_carrots'
+
+Puma::Plugin.create do
+  attr_reader :puma_pid, :rabbit_carrots_pid, :log_writer, :core_service
+
+  def start(launcher)
+    @log_writer = launcher.log_writer
+    @puma_pid = $PROCESS_ID
+
+    @core_service = RabbitCarrots::Core.new(logger: log_writer)
+
+    in_background do
+      monitor_rabbit_carrots
+    end
+
+    launcher.events.on_booted do
+      @rabbit_carrots_pid = fork do
+        Thread.new { monitor_puma }
+        start_rabbit_carrots_consumer
+      end
+    end
+
+    launcher.events.on_stopped { stop_rabbit_carrots }
+    launcher.events.on_restart { stop_rabbit_carrots }
+  end
+
+  private
+
+  def start_rabbit_carrots_consumer
+    core_service.start(kill_to_restart_on_standard_error: true)
+  rescue StandardError => e
+    Rails.logger.error "Error starting Rabbit Carrots: #{e.message}"
+  end
+
+  def stop_rabbit_carrots
+    return unless rabbit_carrots_pid
+
+    log 'Stopping Rabbit Carrots...'
+    core_service.request_shutdown
+    Process.kill('TERM', rabbit_carrots_pid)
+    Process.wait(rabbit_carrots_pid)
+  rescue Errno::ECHILD, Errno::ESRCH
+    log 'Rabbit Carrots already stopped'
+  end
+
+  def monitor_puma
+    monitor(:puma_dead?, 'Detected Puma has gone away, stopping Rabbit Carrots...')
+  end
+
+  def monitor_rabbit_carrots
+    monitor(:rabbit_carrots_dead?, 'Rabbits Carrot is dead, stopping Puma...')
+  end
+
+  def monitor(process_dead, message)
+    loop do
+      if send(process_dead)
+        log message
+        Process.kill('TERM', $PROCESS_ID)
+        break
+      end
+      sleep 2
+    end
+  end
+
+  def rabbit_carrots_dead?
+    Process.waitpid(rabbit_carrots_pid, Process::WNOHANG) if rabbit_carrots_started?
+    false
+  rescue Errno::ECHILD, Errno::ESRCH
+    true
+  end
+
+  def rabbit_carrots_started?
+    rabbit_carrots_pid.present?
+  end
+
+  def puma_dead?
+    Process.ppid != puma_pid
+  end
+
+  def log(...)
+    log_writer.log(...)
+  end
+end

lib/rabbit_carrots.rb

@@ -1,25 +1,11 @@
 # frozen_string_literal: true
 
 require_relative 'rabbit_carrots/version'
+require 'rabbit_carrots/errors'
 require 'rabbit_carrots/connection'
 require 'rabbit_carrots/configuration'
 require 'rabbit_carrots/railtie' if defined?(Rails)
+require 'rabbit_carrots/core'
 
 module RabbitCarrots
-  class Error < StandardError; end
-
-  module EventHandlers
-    module Errors
-      class IrrelevantMessage < StandardError
-      end
-
-      class NackMessage < StandardError
-      end
-
-      class NackAndRequeueMessage < StandardError
-      end
-
-      class PlaceholderError < Error; end
-    end
-  end
 end

lib/rabbit_carrots/configuration.rb

@@ -9,6 +9,21 @@ module RabbitCarrots
   end
 
   class Configuration
-    attr_accessor :rabbitmq_host, :rabbitmq_port, :rabbitmq_user, :rabbitmq_password, :rabbitmq_vhost, :routing_key_mappings, :event_bus_exchange_name
+    attr_accessor :rabbitmq_host,
+                  :rabbitmq_port,
+                  :rabbitmq_user,
+                  :rabbitmq_password,
+                  :rabbitmq_vhost,
+                  :routing_key_mappings,
+                  :rabbitmq_exchange_name,
+                  :automatically_recover,
+                  :network_recovery_interval,
+                  :recovery_attempts
+
+    def orm
+      @orm ||= :activerecord
+    end
+
+    attr_writer :orm
   end
 end

lib/rabbit_carrots/connection.rb

@@ -3,6 +3,7 @@ require 'singleton'
 module RabbitCarrots
   class Connection
     include ::Singleton
+
     attr_reader :connection
 
     def initialize
@@ -11,7 +12,11 @@ module RabbitCarrots
         port: RabbitCarrots.configuration.rabbitmq_port,
         user: RabbitCarrots.configuration.rabbitmq_user,
         password: RabbitCarrots.configuration.rabbitmq_password,
-        vhost: RabbitCarrots.configuration.rabbitmq_vhost
+        vhost: RabbitCarrots.configuration.rabbitmq_vhost,
+        automatically_recover: RabbitCarrots.configuration.automatically_recover || true,
+        network_recovery_interval: RabbitCarrots.configuration.network_recovery_interval || 5,
+        recovery_attempts: RabbitCarrots.configuration.recovery_attempts || 5,
+        recovery_attempts_exhausted: -> { Process.kill('TERM', Process.pid) }
       )
 
       @connection.start

lib/rabbit_carrots/core.rb

@@ -0,0 +1,164 @@
+module RabbitCarrots
+  class Core # rubocop:disable Metrics/ClassLength
+    attr_reader :logger
+
+    @database_agnostic_not_null_violation = nil
+    @database_agnostic_connection_not_established = nil
+    @database_agnostic_record_invalid = nil
+
+    class << self
+      attr_accessor :database_agnostic_not_null_violation, :database_agnostic_connection_not_established, :database_agnostic_record_invalid
+    end
+
+    def initialize(logger: nil)
+      @logger = create_logger_adapter(logger || Logger.new(Rails.env.production? ? '/proc/self/fd/1' : $stdout))
+      @threads = []
+      @running = true
+      @shutdown_requested = false
+    end
+
+    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
+
+      channels = RabbitCarrots.configuration.routing_key_mappings.map do |mapping|
+        { **mapping, handler: mapping[:handler].constantize }
+      end
+
+      channels.each do |channel|
+        handler_class = channel[:handler]
+        raise "#{handler_class.name} must respond to `handle!`" unless handler_class.respond_to?(:handle!)
+
+        @threads << Thread.new do
+          run_task(
+            queue_name: channel[:queue],
+            handler_class:,
+            routing_keys: channel[:routing_keys],
+            queue_arguments: channel[:arguments],
+            exchange_name: channel[:exchange_name],
+            kill_to_restart_on_standard_error:
+          )
+        end
+      end
+
+      Signal.trap('INT') { request_shutdown }
+      Signal.trap('TERM') { request_shutdown }
+
+      while @running
+        if @shutdown_requested
+          request_shutdown
+          sleep 1
+          break
+        end
+        sleep 1
+      end
+
+      @threads.each(&:join)
+    rescue StandardError => e
+      logger.error "Error starting Rabbit Carrots: #{e.message}"
+    end
+
+    def request_shutdown
+      # Workaround to a known issue with Signal Traps and logs
+      Thread.start do
+        logger.error 'Shutting down Rabbit Carrots service...'
+      end
+      @shutdown_requested = true
+      @threads.each(&:kill)
+      stop
+    end
+
+    def stop
+      # Workaround to a known issue with Signal Traps and logs
+      Thread.start do
+        logger.error 'Stoppig the Rabbit Carrots service...'
+      end
+      @running = false
+    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_name ||= RabbitCarrots.configuration.rabbitmq_exchange_name
+
+        begin
+          # Try to passively read an existing exchange without declaring it
+          exchange = channel.topic(exchange_name, passive: true)
+        rescue Bunny::NotFound
+          # If the exchange does not exist, declare it
+          exchange = channel.topic(exchange_name, durable: true)
+        end
+
+        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) }
+
+        queue.subscribe(block: false, manual_ack: true, prefetch: 10) do |delivery_info, properties, payload|
+          break if @shutdown_requested
+
+          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)
+        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)
+        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)
+        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)
+        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)
+        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)
+          Process.kill('SIGTERM', Process.pid) if kill_to_restart_on_standard_error
+        end
+      end
+    rescue StandardError => e
+      logger.error "Bunny session error: #{e.message}"
+      request_shutdown
+    end
+
+    private
+
+    def create_logger_adapter(logger)
+      return logger if logger.respond_to?(:info) && logger.respond_to?(:error) && logger.respond_to?(:warn)
+
+      adapter = Object.new
+      def adapter.info(msg)
+        @logger.write("[INFO] #{msg}\n")
+      end
+
+      def adapter.error(msg)
+        @logger.write("[ERROR] #{msg}\n")
+      end
+
+      def adapter.warn(msg)
+        @logger.write("[WARN] #{msg}\n")
+      end
+
+      adapter.instance_variable_set(:@logger, logger)
+      adapter
+    end
+
+    def encode_payload(payload)
+      payload.encode(
+        'UTF-8',
+        invalid: :replace,
+        undef: :replace,
+        replace: ''
+      )
+    end
+  end
+end

lib/rabbit_carrots/errors.rb

@@ -0,0 +1,18 @@
+module RabbitCarrots
+  class Error < StandardError; end
+
+  module EventHandlers
+    module Errors
+      class IrrelevantMessage < StandardError
+      end
+
+      class NackMessage < StandardError
+      end
+
+      class NackAndRequeueMessage < StandardError
+      end
+
+      class PlaceholderError < Error; end
+    end
+  end
+end

lib/rabbit_carrots/tasks/rmq.rake

@@ -1,75 +1,13 @@
-require 'bunny'
-
 namespace :rabbit_carrots do
-  desc 'Listener for Queue'
+  desc 'Rake task for standalone RabbitCarrots mode'
   task eat: :environment do
     Rails.application.eager_load!
 
-    DatabaseAgonsticNotNullViolation = defined?(ActiveRecord) ? ActiveRecord::NotNullViolation : RabbitCarrots::EventHandlers::Errors::PlaceholderError
-    DatabaseAgonsticConnectionNotEstablished = defined?(ActiveRecord) ? ActiveRecord::ConnectionNotEstablished : Mongo::Error::SocketError
-    DatabaseAgnosticRecordInvalid = defined?(ActiveRecord) ? ActiveRecord::RecordInvalid : Mongoid::Errors::Validations
-    
-    channels = RabbitCarrots.configuration.routing_key_mappings.map do |mapping|
-      # This will be supplied in initializer. At that time, the Handler will not be available to be loaded and will throw Uninitialized Constant
-      { **mapping, handler: mapping[:handler].constantize }
-    end
+    logger = Logger.new(Rails.env.production? ? '/proc/self/fd/1' : $stdout)
+    logger.level = Logger::INFO
 
-    Rails.logger = Logger.new(Rails.env.production? ? '/proc/self/fd/1' : $stdout)
+    core_service = RabbitCarrots::Core.new(logger:)
 
-    # Run RMQ Subscriber for each channel
-    channels.each do |channel|
-      handler_class = channel[:handler]
-
-      raise "#{handler_class.name} must respond to `handle!`" unless handler_class.respond_to?(:handle!)
-
-      run_task(queue_name: channel[:queue], handler_class:, routing_keys: channel[:routing_keys], queue_arguments: channel[:arguments])
-    end
-
-    # Infinite loop to keep the process running
-    loop do
-      sleep 1
-    end
-  end
-end
-
-def run_task(queue_name:, queue_arguments: {}, handler_class:, routing_keys:)
-  RabbitCarrots::Connection.instance.channel.with do |channel|
-    exchange = channel.topic(RabbitCarrots.configuration.event_bus_exchange_name, durable: true)
-
-    Rails.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) }
-
-    queue.subscribe(block: false, manual_ack: true, prefetch: 10) do |delivery_info, properties, payload|
-      Rails.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)
-    rescue RabbitCarrots::EventHandlers::Errors::NackMessage, JSON::ParserError => _e
-      Rails.logger.info "Nacked message: #{payload}"
-      channel.nack(delivery_info.delivery_tag, false, false)
-    rescue RabbitCarrots::EventHandlers::Errors::NackAndRequeueMessage => _e
-      Rails.logger.info "Nacked and Requeued message: #{payload}"
-      channel.nack(delivery_info.delivery_tag, false, true)
-    rescue DatabaseAgonsticNotNullViolation, DatabaseAgnosticRecordInvalid => e
-      # on null constraint violation, we want to ack the message
-      Rails.logger.error "Null constraint or Invalid violation: #{payload}. Error: #{e.message}"
-      channel.ack(delivery_info.delivery_tag, false)
-    rescue DatabaseAgonsticConnectionNotEstablished => e
-      # on connection not established, we want to requeue the message and sleep for 3 seconds
-      Rails.logger.error "Error connection not established to the database: #{payload}. Error: #{e.message}"
-      # delay for 3 seconds before requeuing
-      sleep 3
-      channel.nack(delivery_info.delivery_tag, false, true)
-    rescue StandardError => e
-      Rails.logger.error "Error handling message: #{payload}. Error: #{e.message}"
-      # requeue the message then kill the container
-      sleep 3
-      channel.nack(delivery_info.delivery_tag, false, true)
-      # kill the container with sigterm
-      Process.kill('SIGTERM', Process.pid)
-    end
-
-    Rails.logger.info 'RUN TASK ENDED'
+    core_service.start(kill_to_restart_on_standard_error: true)
   end
 end

lib/rabbit_carrots/version.rb

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

rabbit_carrots.gemspec

@@ -32,8 +32,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   # Uncomment to register a new dependency of your gem
-  spec.add_dependency 'bunny', '>= 2.19.0'
-  spec.add_dependency 'connection_pool', '~> 2.3.0'
+  spec.add_dependency 'bunny', '>= 2.22'
+  spec.add_dependency 'connection_pool', '>= 2.4'
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html