amqp-client 2.0.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d50a249ba8677243b1dbfd865f798b9e24439e725301e31e70c2add330a4380
-  data.tar.gz: 552df8c243b7cf62ae7e36f873bba3779950b4e2c541f7ef19932a10db3f014b
+  metadata.gz: b52ef0851be1716d1833d84448e2470b19938b03050a14d8b5a40a1289cb41ae
+  data.tar.gz: 6e33352b3e238b7ccf1c203a4779da7b5f01f659ab27c39bf7a78299398025aa
 SHA512:
-  metadata.gz: 0c8a84f3f5b821f8aefa3e60e22c2210a51a512551e7cc25c964abe3e5cdb373d3b40fd0ef64e2cd81e9f3a066747284cb8839b9d646cddc8e979e7d3921305f
-  data.tar.gz: 8afefadae34068634ba6d74f6828b8848237c4239a3f9bbcbaea8032f6a7a94261c245d6e40891b2a04ddb66be523614ec575a08c8ca4b8293cd43ba296b6d1d
+  metadata.gz: e78020ff0cf64c9a4a13fb64625f5f0382950c5981fb2df130f4e61066930ba0c9298bd2d7bd3982b1ddbb1ef492cab89183d7e4a1c815a9fa10204897b0ff27
+  data.tar.gz: 2ab30a767b5fc5aa3f5a43949f7cde1b601e74e4bdb0ebc5b0d91306deee773aac9007bcc340610ae52fcba732983b804306cb6fdcbcfdab9e064ec17292ff30

data/lib/amqp/client/channel.rb

@@ -78,6 +78,8 @@ module AMQP
         # @return [nil]
         # @api private
         def closed!(level, code, reason, classid, methodid)
+          return if @closed
+
           @closed = [level, code, reason, classid, methodid]
           @replies.close
           @basic_gets.close
@@ -348,8 +350,10 @@ module AMQP
             consume_loop(msg_q, consumer_tag, &blk)
             nil
           else
-            threads = Array.new(worker_threads) do
-              Thread.new { consume_loop(msg_q, consumer_tag, &blk) }
+            threads = Array.new(worker_threads) do |i|
+              t = Thread.new { consume_loop(msg_q, consumer_tag, &blk) }
+              t.name = @connection.thread_name(role: "consumer", detail: "ch=#{@id} tag=#{consumer_tag} ##{i + 1}")
+              t
             end
             @consumers[consumer_tag] =
               ConsumeOk.new(channel_id: @id, consumer_tag:, worker_threads: threads, msg_q:, on_cancel:)
@@ -467,8 +471,12 @@ module AMQP
         def wait_for_confirms
           @unconfirmed_lock.synchronize do
             until @unconfirmed.empty?
-              @unconfirmed_empty.wait(@unconfirmed_lock)
+              # Check before waiting: if the channel was closed (and the
+              # @unconfirmed_empty broadcast from #closed! fired) before we got
+              # here, the wakeup is already gone and #wait would block forever.
               raise Error::Closed.new(@id, *@closed) if @closed
+
+              @unconfirmed_empty.wait(@unconfirmed_lock)
             end
             result = !@nacked
             @nacked = false # Reset for next round of publishes
@@ -481,15 +489,22 @@ module AMQP
         def confirm(args)
           ack_or_nack, delivery_tag, multiple = *args
           @unconfirmed_lock.synchronize do
-            case multiple
-            when true
-              idx = @unconfirmed.index(delivery_tag) || raise("Delivery tag not found")
-              @unconfirmed.shift(idx + 1)
-            when false
-              @unconfirmed.delete(delivery_tag) || raise("Delivery tag not found")
+            # A tag we're not tracking (a duplicate, out-of-order, or broker
+            # quirk) is logged and ignored, not raised: #confirm runs on the
+            # read_loop thread, where an exception would tear down the connection.
+            confirmed =
+              if multiple
+                idx = @unconfirmed.index(delivery_tag)
+                @unconfirmed.shift(idx + 1) if idx
+              else
+                @unconfirmed.delete(delivery_tag)
+              end
+            if confirmed
+              @nacked = true if ack_or_nack == :nack
+              @unconfirmed_empty.broadcast if @unconfirmed.empty?
+            else
+              warn "AMQP-Client received #{ack_or_nack} for unknown delivery tag #{delivery_tag} on channel #{@id}"
             end
-            @nacked = true if ack_or_nack == :nack
-            @unconfirmed_empty.broadcast if @unconfirmed.empty?
           end
         end
 
@@ -589,7 +604,8 @@ module AMQP
           next_msg = @next_msg
           if next_msg.is_a? ReturnMessage
             if @on_return
-              Thread.new { @on_return.call(next_msg) }
+              t = Thread.new { @on_return.call(next_msg) }
+              t.name = @connection.thread_name(role: "on_return", detail: "ch=#{@id}")
             else
               warn "AMQP-Client message returned: #{next_msg.inspect}"
             end
@@ -622,6 +638,11 @@ module AMQP
           while (msg = queue.pop)
             begin
               yield msg
+            rescue Error::ConnectionClosed, Error::ChannelClosed
+              # The connection or channel closed while the message was being processed (e.g. an
+              # ack/reject/publish from the consumer raced a shutdown). The worker can't make
+              # progress and there's no bug to surface, so stop quietly instead of crashing it.
+              return
             rescue StandardError # cancel the consumer if an uncaught exception is raised
               begin
                 close("Unexpected exception in consumer #{tag} thread", 500)

data/lib/amqp/client/connection.rb

@@ -17,6 +17,9 @@ module AMQP
       #   otherwise the user have to run it explicitly, without {#read_loop} the connection won't function
       # @param codec_registry [MessageCodecRegistry] Registry for message codecs
       # @param strict_coding [Boolean] Whether to raise errors on unsupported codecs
+      # @param name [String, nil] Instance identifier embedded in thread names
+      #   (e.g. "amqp.read_loop[name] host:port") and lifecycle log prefixes.
+      #   Usually sourced from the URL's `?name=` query param by {Client}.
       # @option options [Boolean] connection_name (PROGRAM_NAME) Set a name for the connection to be able to identify
       #   the client from the broker
       # @option options [Boolean] verify_peer (true) Verify broker's TLS certificate, set to false for self-signed certs
@@ -28,7 +31,7 @@ module AMQP
       #   Maxium allowed is 65_536.  The smallest of the client's and the broker's value will be used.
       # @option options [String] keepalive (60:10:3) TCP keepalive setting, 60s idle, 10s interval between probes, 3 probes
       # @return [Connection]
-      def initialize(uri = "", read_loop_thread: true, codec_registry: nil, strict_coding: false, **options)
+      def initialize(uri = "", read_loop_thread: true, codec_registry: nil, strict_coding: false, name: nil, **options)
         uri = URI.parse(uri)
         tls = uri.scheme == "amqps"
         port = port_from_env || uri.port || (tls ? 5671 : 5672)
@@ -38,6 +41,10 @@ module AMQP
         vhost = URI.decode_www_form_component(uri.path[1..] || "/")
         options = URI.decode_www_form(uri.query || "").map! { |k, v| [k.to_sym, v] }.to_h.merge(options)
 
+        @host = host
+        @port = port
+        @name = name
+
         socket = open_socket(host, port, tls, options)
         channel_max, frame_max, heartbeat = establish(socket, user, password, vhost, options)
 
@@ -59,7 +66,20 @@ module AMQP
         # Only used with heartbeats
         @last_activity_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-        Thread.new { read_loop } if read_loop_thread
+        return unless read_loop_thread
+
+        t = Thread.new { read_loop }
+        t.name = thread_name(role: "read_loop")
+      end
+
+      # Build a thread name for a role attached to this connection.
+      # Format: "amqp.<role>[<name>] <host>:<port>[ <detail>]" — the `[<name>]`
+      # segment is only present when the connection has a `name:`.
+      # @api private
+      def thread_name(role:, detail: nil)
+        suffix = @name ? "[#{@name}]" : ""
+        base = "amqp.#{role}#{suffix} #{@host}:#{@port}"
+        detail ? "#{base} #{detail}" : base
       end
 
       # Indicates that the server is blocking publishes.
@@ -223,7 +243,7 @@ module AMQP
 
           # make sure that the frame end is correct
           frame_end = socket.readchar.ord
-          raise Error::UnexpectedFrameTypeEnd, frame_end if frame_end != 206
+          raise Error::UnexpectedFrameEnd, frame_end if frame_end != 206
 
           # parse the frame, will return false if a close frame was received
           parse_frame(type, channel_id, frame_buffer) || return
@@ -236,6 +256,10 @@ module AMQP
       ensure
         @closed ||= [400, "unknown"]
         @replies.close
+        # Wake channels still blocked in #expect / #wait_for_confirms: an abrupt
+        # socket close means no channel/connection close frame ever reached them.
+        code, reason = @closed.first(2)
+        @channels_lock.synchronize { @channels.values }.each { |ch| ch.closed!(:connection, code, reason, 0, 0) }
         begin
           if @write_lock.owned? # if connection is blocked
             @socket.close
@@ -451,7 +475,7 @@ module AMQP
 
       # Start the heartbeat background thread (called from connection#tune)
       def start_heartbeats(period)
-        Thread.new do
+        t = Thread.new do
           Thread.current.abort_on_exception = true # Raising an unhandled exception is a bug
           interval = period / 2.0
           loop do
@@ -471,6 +495,7 @@ module AMQP
             end
           end
         end
+        t.name = thread_name(role: "heartbeat")
       end
 
       def send_heartbeat
@@ -526,13 +551,16 @@ module AMQP
         loop do # rubocop:disable Metrics/BlockLength
           begin
             socket.readpartial(4096, buf)
+            # The 7-byte frame header may arrive split across reads (seen on JRuby); buffer it
+            # fully before unpacking, else frame_size is nil and frame_end below fails on nil.
+            buf << socket.readpartial(4096) while buf.bytesize < 7
           rescue *READ_EXCEPTIONS => e
             raise Error, "Could not establish AMQP connection: #{e.message}"
           end
 
           type, channel_id, frame_size = buf.unpack("C S> L>")
           frame_end = buf.getbyte(frame_size + 7)
-          raise Error::UnexpectedFrameTypeEnd, frame_end if frame_end != 206
+          raise Error::UnexpectedFrameEnd, frame_end if frame_end != 206
 
           case type
           when 1 # method frame

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/message_codecs.rb

@@ -38,6 +38,40 @@ module AMQP
 
         def decode(data, _properties) = Zlib.inflate(data)
       end.new
+
+      # Raw DEFLATE coder (RFC 1951 -- no zlib header, no Adler-32 checksum).
+      # Not registered by default. Use to interoperate with producers that emit
+      # raw DEFLATE under content_encoding "deflate", the same ambiguity HTTP
+      # has carried for decades and that Zlib::Deflate.new(level, -MAX_WBITS)
+      # exists for.
+      #
+      # @example Override the built-in deflate coder
+      #   AMQP::Client.configure do |config|
+      #     config.enable_builtin_codecs
+      #     config.register_coder(content_encoding: "deflate",
+      #                           coder: AMQP::Client::Coders::DeflateRaw)
+      #   end
+      DeflateRaw = Class.new do
+        def encode(data, _properties)
+          return data if data.encoding == Encoding::BINARY
+
+          deflater = Zlib::Deflate.new(Zlib::DEFAULT_COMPRESSION, -Zlib::MAX_WBITS)
+          begin
+            deflater.deflate(data, Zlib::FINISH)
+          ensure
+            deflater.close
+          end
+        end
+
+        def decode(data, _properties)
+          inflater = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+          begin
+            inflater.inflate(data)
+          ensure
+            inflater.close
+          end
+        end
+      end.new
     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.0.1"
+    VERSION = "2.2.0"
   end
 end

data/lib/amqp/client.rb

@@ -32,9 +32,28 @@ module AMQP
     #    the smallest of the client's and the broker's values will be used
     # @option options [Integer] channel_max (2048) Maximum number of channels the client will be allowed to have open.
     #   Maximum allowed is 65_536.  The smallest of the client's and the broker's value will be used.
-    def initialize(uri = "", **options)
+    # @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.
+    # @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 = {}
       @exchanges = {}
       @consumers = {}
@@ -57,7 +76,8 @@ module AMQP
     # @example
     #   connection = AMQP::Client.new("amqps://server.rmq.cloudamqp.com", connection_name: "My connection").connect
     def connect(read_loop_thread: true)
-      Connection.new(@uri, read_loop_thread:, codec_registry: @codec_registry, strict_coding: @strict_coding, **@options)
+      Connection.new(@uri, read_loop_thread:, name: @name,
+                           codec_registry: @codec_registry, strict_coding: @strict_coding, **@options)
     end
 
     # Opens an AMQP connection using the high level API, will try to reconnect if successfully connected at first
@@ -74,38 +94,36 @@ module AMQP
 
         @supervisor_started = true
         @stopped = false
-        Thread.new(connect(read_loop_thread: false)) do |conn|
+        initial_conn = connect(read_loop_thread: false)
+        log_lifecycle(:info, "connected")
+        supervisor = Thread.new(initial_conn) do |conn|
           Thread.current.abort_on_exception = true # Raising an unhandled exception is a bug
+          reconnect_attempts = 0
           loop do
             break if @stopped
 
-            conn ||= connect(read_loop_thread: false)
-
-            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? }
+            unless conn
+              conn = connect(read_loop_thread: false)
+              reconnect_attempts = 0
+              log_lifecycle(:info, "reconnected")
             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
-            warn "AMQP-Client reconnect error: #{e.inspect}"
+            reconnect_attempts += 1
+            break if give_up_reconnecting?(reconnect_attempts, e)
+
+            log_reconnect_error(e)
             sleep @options[:reconnect_interval] || 1
           ensure
             @connq.clear
             conn = nil
           end
         end
+        supervisor.name = thread_name("supervisor")
       end
       self
     end
@@ -133,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
@@ -147,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|
@@ -302,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|
@@ -316,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:)
@@ -539,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
@@ -557,12 +585,128 @@ module AMQP
     def cancel_consumer(consumer)
       @consumers.delete(consumer.id)
       with_connection do |conn|
-        conn.channel(consumer.channel_id).basic_cancel(consumer.tag)
+        ch = conn.channel(consumer.channel_id)
+        begin
+          ch.basic_cancel(consumer.tag)
+        ensure
+          ch.close
+        end
       end
     end
 
     private
 
+    def parse_name(uri)
+      return nil if uri.nil? || uri.empty?
+
+      query = URI.parse(uri).query
+      return nil unless query
+
+      URI.decode_www_form(query).each { |k, v| return v if k == "name" }
+      nil
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def log_lifecycle(level, event)
+      return unless @logger
+
+      @logger.public_send(level, "#{lifecycle_prefix}: #{event}")
+    end
+
+    def log_reconnect_error(err)
+      if @logger
+        @logger.warn("#{lifecycle_prefix}: reconnect error: #{err.inspect}")
+      else
+        warn "AMQP-Client reconnect error: #{err.inspect}"
+      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
+
+    def lifecycle_prefix
+      @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.0.1
+  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:
@@ -49,14 +53,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+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: []