amqp-client 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c07d38a543ff2c0e6e57dfc4ce4921ba74dbac1091cd55a7d06fc791a4ba501e
-  data.tar.gz: 1909a126c2c6c21d36990cff7b0c623ad4e843afe52ddd5cad69299487286f0c
+  metadata.gz: 768fa0e71de1ae6cc2ae41c902c4d61ee505f2dbf400552371fde1185a0afc60
+  data.tar.gz: 52b30e22ac20f6ab94d30b24457a930b9dd72d36c7196d26f255badaa6cc1220
 SHA512:
-  metadata.gz: 6628d1283167e699482baf15ae84bc336c59015b9a86921090ea2a15513267e1fe290788640cef65f92e88f779b039288b05fa6a50d25a449144268edeac7003
-  data.tar.gz: 1684f2e5ef0ffb7c8a67371fe80031904681ccac21e164d190a87605f52b5b73560b4dbd2862f4047f944238f1126aa6de139cdbd1fa1b9acdd39324f8d71c56
+  metadata.gz: f5e29bcd3dc25e4af06a2f5401a839a3b0d6796e8265783994facbf1a042504d351c9af5e34f96c2f52ace10e3dfb1f862030eeb1f13dc06164c1099b8bf89a5
+  data.tar.gz: e65b267fcd879a029752d724c28a17760ad3a4723ad25657b69baa0e1c53cbaa284f67a57872ef6afa3d8e2522dc64414d5b8a75cc0181d85a0f99feae2c7e1d

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

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

data/lib/amqp/client.rb

@@ -32,9 +32,14 @@ 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.
+    # @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)
       @uri = uri
       @options = options
+      @logger = options[:logger]
+      @name = parse_name(uri)
       @queues = {}
       @exchanges = {}
       @consumers = {}
@@ -57,7 +62,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,14 +80,19 @@ 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| # rubocop:disable Metrics/BlockLength
           Thread.current.abort_on_exception = true # Raising an unhandled exception is a bug
-          loop do
+          loop do # rubocop:disable Metrics/BlockLength
             break if @stopped
 
-            conn ||= connect(read_loop_thread: false)
+            unless conn
+              conn = connect(read_loop_thread: false)
+              log_lifecycle(:info, "reconnected")
+            end
 
-            Thread.new do
+            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|
@@ -97,15 +108,18 @@ module AMQP
               # Remove consumers whose internal queues were already closed (e.g. cancelled during reconnect window)
               @consumers.delete_if { |_, c| c.closed? }
             end
+            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}"
+            log_reconnect_error(e)
             sleep @options[:reconnect_interval] || 1
           ensure
             @connq.clear
             conn = nil
           end
         end
+        supervisor.name = thread_name("supervisor")
       end
       self
     end
@@ -331,8 +345,9 @@ module AMQP
     # @return [Message, nil] The message from the queue or nil if the queue is empty
     def get(queue, no_ack: false)
       with_connection do |conn|
-        ch = conn.channel
-        ch.basic_get(queue, no_ack:)
+        conn.with_channel do |ch|
+          ch.basic_get(queue, no_ack:)
+        end
       end
     end
 
@@ -556,12 +571,51 @@ 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 thread_name(role)
+      @name ? "amqp.#{role}[#{@name}]" : "amqp.#{role}"
+    end
+
+    def lifecycle_prefix
+      @name ? "AMQP::Client[#{@name}]" : "AMQP::Client"
+    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.0
+  version: 2.1.0
 platform: ruby
 authors:
 - CloudAMQP
@@ -49,14 +49,14 @@ 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.10
 specification_version: 4
 summary: AMQP 0-9-1 client
 test_files: []