amqp-client 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 768fa0e71de1ae6cc2ae41c902c4d61ee505f2dbf400552371fde1185a0afc60
-  data.tar.gz: 52b30e22ac20f6ab94d30b24457a930b9dd72d36c7196d26f255badaa6cc1220
+  metadata.gz: b52ef0851be1716d1833d84448e2470b19938b03050a14d8b5a40a1289cb41ae
+  data.tar.gz: 6e33352b3e238b7ccf1c203a4779da7b5f01f659ab27c39bf7a78299398025aa
 SHA512:
-  metadata.gz: f5e29bcd3dc25e4af06a2f5401a839a3b0d6796e8265783994facbf1a042504d351c9af5e34f96c2f52ace10e3dfb1f862030eeb1f13dc06164c1099b8bf89a5
-  data.tar.gz: e65b267fcd879a029752d724c28a17760ad3a4723ad25657b69baa0e1c53cbaa284f67a57872ef6afa3d8e2522dc64414d5b8a75cc0181d85a0f99feae2c7e1d
+  metadata.gz: e78020ff0cf64c9a4a13fb64625f5f0382950c5981fb2df130f4e61066930ba0c9298bd2d7bd3982b1ddbb1ef492cab89183d7e4a1c815a9fa10204897b0ff27
+  data.tar.gz: 2ab30a767b5fc5aa3f5a43949f7cde1b601e74e4bdb0ebc5b0d91306deee773aac9007bcc340610ae52fcba732983b804306cb6fdcbcfdab9e064ec17292ff30

data/lib/amqp/client/consumer.rb

@@ -39,8 +39,9 @@ module AMQP
 
       # Update the consumer with new metadata after reconnection
       # @api private
-      def update_consume_ok(consume_ok)
+      def update_consume_ok(consume_ok, channel_id)
         @consume_ok = consume_ok
+        @channel_id = channel_id
       end
     end
   end

data/lib/amqp/client/queue.rb

@@ -50,11 +50,13 @@ module AMQP
       # @param on_cancel [Proc] Optional proc that will be called if the consumer is cancelled by the broker
       #   The proc will be called with the consumer tag as the only argument
       # @param arguments [Hash] Custom arguments to the consumer
+      # @param consumer_tag [String, nil] Custom consumer tag. Pass nil or "" to let the broker generate one.
       # @yield [Message] Delivered message from the queue
       # @return [Consumer] The consumer object, which can be used to cancel the consumer
       def subscribe(no_ack: false, exclusive: false, prefetch: 1, worker_threads: 1, requeue_on_reject: true,
-                    on_cancel: nil, arguments: {})
-        @client.subscribe(@name, no_ack:, exclusive:, prefetch:, worker_threads:, on_cancel:, arguments:) do |message|
+                    on_cancel: nil, arguments: {}, consumer_tag: nil)
+        @client.subscribe(@name, no_ack:, exclusive:, prefetch:, worker_threads:,
+                                 on_cancel:, arguments:, consumer_tag:) do |message|
           yield message
           message.ack unless no_ack
         rescue StandardError => e

data/lib/amqp/client/version.rb

@@ -3,6 +3,6 @@
 module AMQP
   class Client
     # Version of the client library
-    VERSION = "2.1.0"
+    VERSION = "2.2.0"
   end
 end

data/lib/amqp/client.rb

@@ -35,9 +35,23 @@ module AMQP
     # @option options [#info, #warn, #error] logger (nil) Logger for {#start} lifecycle events
     #   (connected/reconnected/disconnected/reconnect errors). When nil, reconnect errors are
     #   written to stderr via Kernel#warn for backwards compatibility.
-    def initialize(uri = "", **options)
+    # @param on_connect [Proc, nil] Optional callback invoked with the client after each successful
+    #   (re)connection, after consumer recovery.
+    # @param on_failed [Proc, nil] Optional callback invoked with the triggering error once
+    #   reconnection has given up after max_retries consecutive failed attempts. The supervisor
+    #   stops after calling it, same as after {#stop}.
+    # @param max_retries [Integer, nil] Number of consecutive reconnect attempts to allow before
+    #   giving up and calling on_failed. Defaults to nil, retrying forever.
+    def initialize(uri = "", on_connect: nil, on_failed: nil, max_retries: nil, **options)
+      if max_retries && (!max_retries.is_a?(Integer) || max_retries.negative?)
+        raise ArgumentError, "max_retries must be a non-negative Integer or nil"
+      end
+
       @uri = uri
       @options = options
+      @on_connect = on_connect
+      @on_failed = on_failed
+      @max_retries = max_retries
       @logger = options[:logger]
       @name = parse_name(uri)
       @queues = {}
@@ -82,36 +96,26 @@ module AMQP
         @stopped = false
         initial_conn = connect(read_loop_thread: false)
         log_lifecycle(:info, "connected")
-        supervisor = Thread.new(initial_conn) do |conn| # rubocop:disable Metrics/BlockLength
+        supervisor = Thread.new(initial_conn) do |conn|
           Thread.current.abort_on_exception = true # Raising an unhandled exception is a bug
-          loop do # rubocop:disable Metrics/BlockLength
+          reconnect_attempts = 0
+          loop do
             break if @stopped
 
             unless conn
               conn = connect(read_loop_thread: false)
+              reconnect_attempts = 0
               log_lifecycle(:info, "reconnected")
             end
 
-            setup = Thread.new do
-              # restore connection in another thread, read_loop have to run
-              conn.channel(1) # reserve channel 1 for publishes
-              @consumers.each_value do |consumer|
-                ch = conn.channel
-                ch.basic_qos(consumer.prefetch)
-                consume_ok = ch.basic_consume(consumer.queue,
-                                              **consumer.basic_consume_args,
-                                              &consumer.block)
-                # Update the consumer with new channel and consume_ok metadata
-                consumer.update_consume_ok(consume_ok)
-              end
-              @connq << conn
-              # Remove consumers whose internal queues were already closed (e.g. cancelled during reconnect window)
-              @consumers.delete_if { |_, c| c.closed? }
-            end
+            setup = Thread.new { restore_connection(conn) }
             setup.name = thread_name("reconnect_setup")
             conn.read_loop # blocks until connection is closed, then reconnect
             log_lifecycle(:warn, "disconnected")
           rescue Error => e
+            reconnect_attempts += 1
+            break if give_up_reconnecting?(reconnect_attempts, e)
+
             log_reconnect_error(e)
             sleep @options[:reconnect_interval] || 1
           ensure
@@ -147,7 +151,7 @@ module AMQP
     # @!group High level objects
 
     # Declare a queue
-    # @param name [String] Name of the queue
+    # @param name [String, nil] Name of the queue. Pass nil or "" for a server-named queue.
     # @param durable [Boolean] If true the queue will survive broker restarts,
     #   messages in the queue will only survive if they are published as persistent
     # @param auto_delete [Boolean] If true the queue will be deleted when the last consumer stops consuming
@@ -161,7 +165,12 @@ module AMQP
     #   q = amqp.queue("foobar")
     #   q.publish("body")
     def queue(name, durable: true, auto_delete: false, exclusive: false, passive: false, arguments: {})
-      raise ArgumentError, "Currently only supports named, durable queues" if name.empty?
+      if server_named_queue?(name)
+        queue_ok = with_connection do |conn|
+          conn.channel(1).queue_declare("", durable:, auto_delete:, exclusive:, passive:, arguments:)
+        end
+        return Queue.new(self, queue_ok.queue_name)
+      end
 
       @queues.fetch(name) do
         with_connection do |conn|
@@ -316,10 +325,11 @@ module AMQP
     # @param on_cancel [Proc] Optional proc that will be called if the consumer is cancelled by the broker
     #   The proc will be called with the consumer tag as the only argument
     # @param arguments [Hash] Custom arguments to the consumer
+    # @param consumer_tag [String, nil] Custom consumer tag. Pass nil or "" to let the broker generate one.
     # @yield [Message] Delivered message from the queue
     # @return [Consumer] The consumer object, which can be used to cancel the consumer
     def subscribe(queue, exclusive: false, no_ack: false, prefetch: 1, worker_threads: 1,
-                  on_cancel: nil, arguments: {}, &blk)
+                  on_cancel: nil, arguments: {}, consumer_tag: nil, &blk)
       raise ArgumentError, "worker_threads have to be > 0" if worker_threads <= 0
 
       with_connection do |conn|
@@ -330,7 +340,9 @@ module AMQP
           @consumers.delete(consumer_id)
           on_cancel&.call(tag)
         end
-        basic_consume_args = { exclusive:, no_ack:, worker_threads:, on_cancel: on_cancel_proc, arguments: }
+        tag = consumer_tag.nil? ? "" : consumer_tag
+        basic_consume_args = { tag:, exclusive:, no_ack:, worker_threads:,
+                               on_cancel: on_cancel_proc, arguments: }
         consume_ok = ch.basic_consume(queue, **basic_consume_args, &blk)
         consumer = Consumer.new(client: self, channel_id: ch.id, id: consumer_id, block: blk,
                                 queue:, consume_ok:, prefetch:, basic_consume_args:)
@@ -553,6 +565,8 @@ module AMQP
     # @!endgroup
     #
     def with_connection
+      return yield Thread.current[reserved_conn_key] if Thread.current[reserved_conn_key]
+
       conn = nil
       loop do
         conn = @connq.pop
@@ -608,6 +622,15 @@ module AMQP
       end
     end
 
+    def log_give_up(reconnect_attempts, err)
+      message = "gave up reconnecting after #{reconnect_attempts} attempts: #{err.inspect}"
+      if @logger
+        @logger.error("#{lifecycle_prefix}: #{message}")
+      else
+        warn "AMQP-Client #{message}"
+      end
+    end
+
     def thread_name(role)
       @name ? "amqp.#{role}[#{@name}]" : "amqp.#{role}"
     end
@@ -616,6 +639,74 @@ module AMQP
       @name ? "AMQP::Client[#{@name}]" : "AMQP::Client"
     end
 
+    def restore_connection(conn)
+      conn.channel(1)
+      # Snapshot because @consumers can mutate while recovery is running.
+      @consumers.values.each do |consumer| # rubocop:disable Style/HashEachMethods
+        ch = conn.channel
+        ch.basic_qos(consumer.prefetch)
+        consume_ok = ch.basic_consume(consumer.queue,
+                                      **consumer.basic_consume_args,
+                                      &consumer.block)
+        consumer.update_consume_ok(consume_ok, ch.id)
+        @consumers.delete(consumer.id) if consumer.closed?
+      rescue Error::ChannelClosed => e
+        log_lifecycle(:warn, "failed to resubscribe consumer for #{consumer.queue}: #{e.message}")
+        @consumers.delete(consumer.id)
+      end
+      run_on_connect_hook(conn)
+      @connq << conn
+    end
+
+    def server_named_queue?(name)
+      name.nil? || name.empty?
+    end
+
+    # Thread-local (not an ivar) so the hook can call back into the client's API without
+    # deadlocking, and overlapping reconnects can't clobber each other's reservation.
+    def run_on_connect_hook(conn)
+      return unless @on_connect
+
+      Thread.current[reserved_conn_key] = conn
+      @on_connect.call(self)
+    rescue StandardError => e
+      if @logger
+        log_lifecycle(:warn, "on_connect raised: #{e.class}: #{e.message}")
+      else
+        warn "AMQP-Client on_connect error: #{e.inspect}"
+      end
+    ensure
+      Thread.current[reserved_conn_key] = nil
+    end
+
+    # Scoped per instance so a thread touching two Client objects can't cross-wire connections.
+    def reserved_conn_key
+      :"amqp_client_conn_#{object_id}"
+    end
+
+    # Reports whether the supervisor should give up after this reconnect failure, logging and
+    # calling on_failed as a side effect when it does.
+    def give_up_reconnecting?(reconnect_attempts, err)
+      return false unless @max_retries && reconnect_attempts >= @max_retries
+
+      @stopped = true
+      log_give_up(reconnect_attempts, err)
+      run_on_failed_hook(err)
+      true
+    end
+
+    def run_on_failed_hook(err)
+      return unless @on_failed
+
+      @on_failed.call(err)
+    rescue StandardError => e
+      if @logger
+        log_lifecycle(:warn, "on_failed raised: #{e.class}: #{e.message}")
+      else
+        warn "AMQP-Client on_failed error: #{e.inspect}"
+      end
+    end
+
     def default_content_properties
       {
         content_type: @default_content_type,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: amqp-client
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - CloudAMQP
@@ -9,7 +9,9 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: Modern AMQP 0-9-1 Ruby client
+description: A modern AMQP 0-9-1 Ruby client for RabbitMQ, LavinMQ and any other AMQP
+  0-9-1 broker. Very fast, fully thread-safe, with blocking operations, straight-forward
+  error handling and no dependencies.
 email:
 - team@cloudamqp.com
 executables: []
@@ -41,6 +43,8 @@ metadata:
   homepage_uri: https://github.com/cloudamqp/amqp-client.rb
   source_code_uri: https://github.com/cloudamqp/amqp-client.rb.git
   changelog_uri: https://github.com/cloudamqp/amqp-client.rb/blob/main/CHANGELOG.md
+  documentation_uri: https://cloudamqp.github.io/amqp-client.rb/
+  bug_tracker_uri: https://github.com/cloudamqp/amqp-client.rb/issues
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -56,7 +60,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
-summary: AMQP 0-9-1 client
+summary: Modern, fast and dependency-free AMQP 0-9-1 Ruby client for RabbitMQ and
+  LavinMQ
 test_files: []