amq-protocol 2.3.3 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49d61c5e0d929d97678b8c9f5b01c147c74f874a70481c7c24de865331ad8278
-  data.tar.gz: efaeca2672afb7b1cd8eceb809bd8be9fcbfbecceb2e1893187b6fc9dcd2d5ff
+  metadata.gz: 7cd695fb0f7f7cc8c9d80109f349fdba92c500b5b8eea4ff6ea2c5e6dfdddd8d
+  data.tar.gz: 929be34e6f1bd9c2f84fded2933e9f3775286e19babbabac45ce0ccab1b3c38d
 SHA512:
-  metadata.gz: 12444b7175daf2d75f021e91eccb8782ebd11ec60855229bf82fa3e29792ba1ca8c96283723b8b5ffeaaf16ef6586b0b74948f605fb3526bed4146cff4030b0a
-  data.tar.gz: 7d8c26b0e7a501515c1a130410c66d54ad7811c4e7cee15b02d894a8f46feacdc08f8456672e13b35df1f1ca738223c49721e545829c088079e28f96ebada1d8
+  metadata.gz: 990e85acbfc80b8dbfa1be036705afdef1f96fdae2b1c8270ff00c972483925361d9dbb7807309fca6a0db55c3d795f8da34d3255f153ff463cda2d12ceed918
+  data.tar.gz: 62f8b49269c978f162a21aced9eb22702ae676e28589da94f66b1560083c66878584a1999fa0611f4be1f205a402539b228f0d165107dc930d7a7112801cb8aa

data/ChangeLog.md

@@ -1,14 +1,97 @@
+## Changes between 2.8.0 and 2.9.0 (unreleased)
+
+No changes yet.
+
+## Changes between 2.7.0 and 2.8.0 (Apr 25, 2026)
+
+### Performance Improvements in Frame Decoding and Encoding
+
+Replacing `x == nil` with `x.nil?` in the frame layer hot path yields a
+consistent **+15–18% throughput improvement** in `Frame.decode_header`
+(called on every received frame) and **+12–14%** in `HeartbeatFrame.encode`,
+across Ruby 3.3, 3.4, and 4.0.
+
+See benchmarks/BENCHMARKS.md for instructions on how to reproduce these numbers on your machine.
+
+Contributed by @eglitobias.
+
+GitHub issue: [#86](https://github.com/ruby-amqp/amq-protocol/pull/86)
+
+
+## Changes between 2.6.0 and 2.7.0 (Mar 31, 2026)
+
+### Channel.Close Predicates Now Return True Boolean
+
+And not just truthy values (values that are not `nil` or `false`).
+
+
+## Changes between 2.5.1 and 2.6.0 (Mar 30, 2026)
+
+### Channel.Close Predicate Methods
+
+`Channel::Close` now provides predicate methods for identifying common
+channel closure reasons by reply code and text:
+
+ * `#delivery_ack_timeout?`: consumer [delivery acknowledgement timeout](https://www.rabbitmq.com/docs/consumers#acknowledgement-timeout)
+ * `#unknown_delivery_tag?`: unknown delivery tag (e.g. [double ack](https://www.rabbitmq.com/docs/channels#error-handling))
+ * `#message_too_large?`: message exceeded the configured max size
+
+
+## Changes between 2.5.0 and 2.5.1 (Jan 19, 2026)
+
+### Windows Installation Fixes
+
+`2.4.0` and `2.5.0` versions unintentionally included files that were
+symlinks, which caused installation on Windows to fail.
+
+
+## Changes between 2.4.0 and 2.5.0 (Dec 31, 2025)
+
+### Additional Consumer Hot Path Optimizations
+
+A few more decode method optimizations for consumer delivery code paths.
+
+
+## Changes between 2.3.4 and 2.4.0 (Dec 30, 2025)
+
+### Performance Improvements
+
+Optimized encoding and decoding hot paths:
+
+ * Built-in `Q>`/`q>` packing/unpacking directives are 6-7x faster than the original implementation (that originally targeted Ruby 1.8.x)
+ * Switched to `unpack1` instead of `unpack().first` throughout
+ * Use `byteslice` instead of `slice` for binary string operations
+ * Use `getbyte` for single byte access (4x faster than alternatives)
+ * Adopted the `frozen_string_literal` pragma
+
+The improvements on Ruby 3.4 are very meaningful:
+
+ * `AMQ::Pack.pack_uint64_big_endian`: about 6.6x faster
+ * `AMQ::Pack.unpack_uint64_big_endian`: about 7.2x faster
+ * `Basic.Deliver.decode`: about 1.7x faster
+ * `Basic.Ack/Nack/Reject.encode`: about 2.5x faster
+
+
+## Changes between 2.3.3 and 2.3.4 (May 12, 2025)
+
+### (Forward) Compatibility with Ruby 3.5
+
+Contributed by @Earlopain.
+
+GitHub issue: [#80](https://github.com/ruby-amqp/amq-protocol/pull/80)
+
+
 ## Changes between 2.3.2 and 2.3.3 (February 17, 2025)
 
 ### Improved Compatibility with Ruby 3.4
 
-Contribiuted by @BenTalagan.
+Contributed by @BenTalagan.
 
 GitHub issue: [#79](https://github.com/ruby-amqp/amq-protocol/pull/79)
 
 ### Support Binary-Encoded Frozen Strings for Payloads
 
-Contribiuted by @djrodgerspryor.
+Contributed by @djrodgerspryor.
 
 GitHub issue: [#78](https://github.com/ruby-amqp/amq-protocol/pull/78)
 

data/LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2010 – 2011 Jakub Šťastný aka Botanicus
-Copyright (c) 2011 – 2016 Michael S. Klishin <michael@defprotocol.org>
+Copyright (c) 2011 – 2026 Michael S. Klishin <michael@defprotocol.org>
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -9,6 +9,8 @@ needs for you, including RabbitMQ extensions to AMQP 0.9.1.
 
 ## Supported Ruby Versions
 
+ * amq-protocol `2.3.4` has fixes for Ruby 3.5 compatibility
+ * amq-protocol `2.3.3` has fixes for Ruby 3.4 compatibility
  * amq-protocol `2.3.0` only supports Ruby 2.2+.
  * amq-protocol `2.0.0` through `2.2.0` and later supports Ruby 2.0+.
  * amq-protocol `1.9.2` was the last version to support Ruby 1.8 and 1.9.
@@ -45,21 +47,14 @@ To run tests, use
 amq-protocol is maintained by [Michael Klishin](https://github.com/michaelklishin).
 
 
-## CI Status
-
-[![Build Status](https://secure.travis-ci.org/ruby-amqp/amq-protocol.svg)](https://travis-ci.org/ruby-amqp/amq-protocol)
-
-
 ## Issues
 
 Please report any issues you may find to our [Issue tracker](http://github.com/ruby-amqp/amq-protocol/issues) on GitHub.
 
-
 ## Mailing List
 
 Any questions you may have should be sent to the [Ruby AMQP mailing list](http://groups.google.com/group/ruby-amqp).
 
-
 ## License
 
 MIT (see LICENSE in the repository root).

data/lib/amq/bit_set.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module AMQ
   # Very minimalistic, pure Ruby implementation of bit set. Inspired by java.util.BitSet,
@@ -112,7 +113,7 @@ module AMQ
 
     def check_range(i)
       if i < 0 || i >= @nbits
-        raise IndexError.new("Cannot access bit #{i} from a BitSet with #{@nbits} bits")
+        raise IndexError, "Cannot access bit #{i} from a BitSet with #{@nbits} bits"
       end
     end # check_range
   end # BitSet

data/lib/amq/endianness.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AMQ
   module Endianness
     BIG_ENDIAN = ([1].pack("s") == "\x00\x01")

data/lib/amq/int_allocator.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 require "amq/bit_set"
 
@@ -25,13 +26,12 @@ module AMQ
     # @param [Integer] hi    Upper boundary of the integer range available for allocation
     # @raise [ArgumentError] if upper boundary is not greater than the lower one
     def initialize(lo, hi)
-      raise ArgumentError.new "upper boundary must be greater than the lower one (given: hi = #{hi}, lo = #{lo})" unless hi > lo
+      raise ArgumentError, "upper boundary must be greater than the lower one (given: hi = #{hi}, lo = #{lo})" unless hi > lo
 
       @hi = hi
       @lo = lo
 
       @number_of_bits = hi - lo
-      @range          = Range.new(1, @number_of_bits)
       @free_set       = BitSet.new(@number_of_bits)
     end # initialize(hi, lo)
 
@@ -46,7 +46,7 @@ module AMQ
 
       if n = @free_set.next_clear_bit
 
-        if n < @hi - 1 then
+        if n < @hi - 1
           @free_set.set(n)
           n + 1
         else

data/lib/amq/pack.rb

@@ -1,54 +1,45 @@
 # encoding: binary
-
-require 'amq/endianness'
+# frozen_string_literal: true
 
 module AMQ
-  # Implements pack to/unpack from 64bit string in network byte order
-  # compatible with Ruby 1.8+.
+  # Implements pack to/unpack from 64bit string in network byte order.
+  # Uses native Ruby pack directives with explicit endianness (Ruby 1.9.3+).
   module Pack
-    UINT64 = "Q".freeze
-    UINT16_BE  = "n".freeze
-    INT16 = "c".freeze
-
-    if Endianness.big_endian?
-      def self.pack_uint64_big_endian(long_long)
-        [long_long].pack(UINT64)
-      end
-
-      def self.unpack_uint64_big_endian(data)
-        data.unpack(UINT64)
-      end
-
-      def self.pack_int16_big_endian(short)
-        [long_long].pack(INT16)
-      end
-
-      def self.unpack_int16_big_endian(data)
-        data.unpack(INT16)
-      end
-    else
-      def self.pack_uint64_big_endian(long_long)
-        result = [long_long].pack(UINT64)
-        result.bytes.to_a.reverse.map(&:chr).join
-      end
+    # Pack format strings - frozen for performance
+    UINT64_BE = 'Q>'.freeze  # 64-bit unsigned, big-endian
+    INT64_BE  = 'q>'.freeze  # 64-bit signed, big-endian
+    INT16_BE  = 's>'.freeze  # 16-bit signed, big-endian
+    UINT16_BE = 'n'.freeze   # 16-bit unsigned, big-endian (network order)
+
+    # Packs a 64-bit unsigned integer to big-endian binary string.
+    # @param long_long [Integer] The value to pack
+    # @return [String] 8-byte binary string in big-endian order
+    def self.pack_uint64_big_endian(long_long)
+      [long_long].pack(UINT64_BE)
+    end
 
-      def self.unpack_uint64_big_endian(data)
-        data = data.bytes.to_a.reverse.map(&:chr).join
-        data.unpack(UINT64)
-      end
+    # Unpacks a big-endian binary string to a 64-bit unsigned integer.
+    # @param data [String] 8-byte binary string in big-endian order
+    # @return [Array<Integer>] Single-element array containing the unpacked value
+    def self.unpack_uint64_big_endian(data)
+      data.unpack(UINT64_BE)
+    end
 
-      def self.pack_int16_big_endian(short)
-        result = [long_long].pack(INT16)
-        result.bytes.to_a.reverse.map(&:chr).join
-      end
+    # Packs a 16-bit signed integer to big-endian binary string.
+    # @param short [Integer] The value to pack
+    # @return [String] 2-byte binary string in big-endian order
+    def self.pack_int16_big_endian(short)
+      [short].pack(INT16_BE)
+    end
 
-      def self.unpack_int16_big_endian(data)
-        value = data.bytes.to_a.map(&:chr).join.unpack(UINT16_BE)[0]
-        [(value & ~(1 << 15)) - (value & (1 << 15))]
-      end
+    # Unpacks a big-endian binary string to a 16-bit signed integer.
+    # @param data [String] 2-byte binary string in big-endian order
+    # @return [Array<Integer>] Single-element array containing the unpacked value
+    def self.unpack_int16_big_endian(data)
+      data.unpack(INT16_BE)
     end
   end
 
-  # Backwards compatibility
+  # Backwards compatibility alias
   Hacks = Pack
 end

data/lib/amq/protocol/channel_close.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module AMQ
+  module Protocol
+    class Channel
+      class Close
+        # @return [Boolean] true if the channel was closed due to a consumer delivery acknowledgement timeout
+        def delivery_ack_timeout?
+          reply_code == 406 && reply_text.match?(/delivery acknowledgement on channel \d+ timed out/)
+        end
+
+        # @return [Boolean] true if the channel was closed due to an unknown delivery tag (e.g. double ack)
+        def unknown_delivery_tag?
+          reply_code == 406 && reply_text.match?(/unknown delivery tag/)
+        end
+
+        # @return [Boolean] true if the channel was closed because a message exceeded the configured max size
+        def message_too_large?
+          reply_code == 406 && reply_text.match?(/larger than configured max size/)
+        end
+      end
+    end
+  end
+end

data/lib/amq/protocol/client.rb

@@ -173,9 +173,7 @@ module AMQ
         limit        = frame_size - 8
         return [BodyFrame.new(body, channel)] if body.bytesize < limit
 
-        # Otherwise String#slice on 1.9 will operate with code points,
-        # and we need bytes. MK.
-        body.force_encoding("ASCII-8BIT") if RUBY_VERSION.to_f >= 1.9 && body.encoding != Encoding::BINARY
+        body.force_encoding("ASCII-8BIT") if body.encoding != Encoding::BINARY
 
         array = Array.new
         while body && !body.empty?
@@ -1569,30 +1567,31 @@ module AMQ
         0x0004,
       ]
 
+      # Optimized decode_properties using getbyte and unpack1
       def self.decode_properties(data)
         offset, data_length, properties = 0, data.bytesize, {}
 
-        compressed_index = data[offset, 2].unpack(PACK_UINT16)[0]
+        compressed_index = data.byteslice(offset, 2).unpack1(PACK_UINT16)
         offset += 2
         while data_length > offset
           DECODE_PROPERTIES_KEYS.each do |key|
             next unless compressed_index >= key
             compressed_index -= key
-            name = DECODE_PROPERTIES[key] || raise(RuntimeError.new("No property found for index #{index.inspect}!"))
+            name = DECODE_PROPERTIES[key] || raise(RuntimeError.new("No property found for index #{key.inspect}!"))
             case DECODE_PROPERTIES_TYPE[key]
             when :shortstr
-              size = data[offset, 1].unpack(PACK_CHAR)[0]
+              size = data.getbyte(offset)
               offset += 1
-              result = data[offset, size]
+              result = data.byteslice(offset, size)
             when :octet
               size = 1
-              result = data[offset, size].unpack(PACK_CHAR).first
+              result = data.getbyte(offset)
             when :timestamp
               size = 8
-              result = Time.at(data[offset, size].unpack(PACK_UINT64_BE).last)
+              result = Time.at(data.byteslice(offset, 8).unpack1(PACK_UINT64_BE))
             when :table
-              size = 4 + data[offset, 4].unpack(PACK_UINT32)[0]
-              result = Table.decode(data[offset, size])
+              size = 4 + data.byteslice(offset, 4).unpack1(PACK_UINT32)
+              result = Table.decode(data.byteslice(offset, size))
             end
             properties[name] = result
             offset += size
@@ -1688,13 +1687,11 @@ module AMQ
         @index = 0x003C0015 # 60, 21, 3932181
         @packed_indexes = [60, 21].pack(PACK_UINT16_X2).freeze
 
+        # Optimized decode using getbyte
         # @return
         def self.decode(data)
-          offset = offset = 0 # self-assigning offset to eliminate "assigned but unused variable" warning even if offset is not used in this method
-          length = data[offset, 1].unpack(PACK_CHAR).first
-          offset += 1
-          consumer_tag = data[offset, length]
-          offset += length
+          length = data.getbyte(0)
+          consumer_tag = data.byteslice(1, length)
           self.new(consumer_tag)
         end
 
@@ -1866,26 +1863,25 @@ module AMQ
         @index = 0x003C003C # 60, 60, 3932220
         @packed_indexes = [60, 60].pack(PACK_UINT16_X2).freeze
 
+        # Optimized decode using getbyte and unpack1 for better performance
         # @return
         def self.decode(data)
-          offset = offset = 0 # self-assigning offset to eliminate "assigned but unused variable" warning even if offset is not used in this method
-          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset = 0
+          length = data.getbyte(offset)
           offset += 1
-          consumer_tag = data[offset, length]
+          consumer_tag = data.byteslice(offset, length)
           offset += length
-          delivery_tag = AMQ::Pack.unpack_uint64_big_endian(data[offset, 8]).first
+          delivery_tag = data.byteslice(offset, 8).unpack1(PACK_UINT64_BE)
           offset += 8
-          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
+          redelivered = (data.getbyte(offset) & 1) != 0
           offset += 1
-          redelivered = (bit_buffer & (1 << 0)) != 0
-          length = data[offset, 1].unpack(PACK_CHAR).first
+          length = data.getbyte(offset)
           offset += 1
-          exchange = data[offset, length]
+          exchange = data.byteslice(offset, length)
           offset += length
-          length = data[offset, 1].unpack(PACK_CHAR).first
+          length = data.getbyte(offset)
           offset += 1
-          routing_key = data[offset, length]
-          offset += length
+          routing_key = data.byteslice(offset, length)
           self.new(consumer_tag, delivery_tag, redelivered, exchange, routing_key)
         end
 
@@ -2009,14 +2005,11 @@ module AMQ
         @index = 0x003C0050 # 60, 80, 3932240
         @packed_indexes = [60, 80].pack(PACK_UINT16_X2).freeze
 
+        # Optimized decode using unpack1 and getbyte
         # @return
         def self.decode(data)
-          offset = offset = 0 # self-assigning offset to eliminate "assigned but unused variable" warning even if offset is not used in this method
-          delivery_tag = AMQ::Pack.unpack_uint64_big_endian(data[offset, 8]).first
-          offset += 8
-          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
-          offset += 1
-          multiple = (bit_buffer & (1 << 0)) != 0
+          delivery_tag = data.byteslice(0, 8).unpack1(PACK_UINT64_BE)
+          multiple = (data.getbyte(8) & 1) != 0
           self.new(delivery_tag, multiple)
         end
 
@@ -2141,15 +2134,13 @@ module AMQ
         @index = 0x003C0078 # 60, 120, 3932280
         @packed_indexes = [60, 120].pack(PACK_UINT16_X2).freeze
 
+        # Optimized decode using unpack1 and getbyte
         # @return
         def self.decode(data)
-          offset = offset = 0 # self-assigning offset to eliminate "assigned but unused variable" warning even if offset is not used in this method
-          delivery_tag = AMQ::Pack.unpack_uint64_big_endian(data[offset, 8]).first
-          offset += 8
-          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
-          offset += 1
-          multiple = (bit_buffer & (1 << 0)) != 0
-          requeue = (bit_buffer & (1 << 1)) != 0
+          delivery_tag = data.byteslice(0, 8).unpack1(PACK_UINT64_BE)
+          bit_buffer = data.getbyte(8)
+          multiple = (bit_buffer & 1) != 0
+          requeue = (bit_buffer & 2) != 0
           self.new(delivery_tag, multiple, requeue)
         end
 

data/lib/amq/protocol/constants.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AMQ
   module Protocol
     TLS_PORT         = 5671

data/lib/amq/protocol/exceptions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AMQ
   module Protocol
     class Error < StandardError
@@ -41,7 +43,7 @@ module AMQ
 
     class BadResponseError < Protocol::Error
       def initialize(argument, expected, actual)
-        super("Argument #{argument} has to be #{expected.inspect}, was #{data.inspect}")
+        super("Argument #{argument} has to be #{expected.inspect}, was #{actual.inspect}")
       end
     end
 

data/lib/amq/protocol/float_32bit.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AMQ
   module Protocol
     # Allows distinguishing between 32-bit and 64-bit floats in Ruby.

data/lib/amq/protocol/frame.rb

@@ -1,4 +1,5 @@
 # encoding: binary
+# frozen_string_literal: true
 
 module AMQ
   module Protocol
@@ -9,6 +10,9 @@ module AMQ
       CHANNEL_RANGE = (0..65535).freeze
       FINAL_OCTET   = "\xCE".freeze # 206
 
+      # Pack format for 64-bit unsigned big-endian
+      PACK_UINT64_BE = 'Q>'.freeze
+
       def self.encoded_payload(payload)
         if payload.respond_to?(:force_encoding) && payload.encoding.name != 'BINARY'
           # Only copy if we have to.
@@ -19,8 +23,8 @@ module AMQ
 
       # The channel number is 0 for all frames which are global to the connection and 1-65535 for frames that refer to specific channels.
       def self.encode_to_array(type, payload, channel)
-        raise RuntimeError.new("Channel has to be 0 or an integer in range 1..65535 but was #{channel.inspect}") unless CHANNEL_RANGE.include?(channel)
-        raise RuntimeError.new("Payload can't be nil") if payload.nil?
+        raise RuntimeError, "Channel has to be 0 or an integer in range 1..65535 but was #{channel.inspect}" unless CHANNEL_RANGE.include?(channel)
+        raise RuntimeError, "Payload can't be nil" if payload.nil?
         components = []
         components << [find_type(type), channel, payload.bytesize].pack(PACK_CHAR_UINT16_UINT32)
         components << encoded_payload(payload)
@@ -43,25 +47,27 @@ module AMQ
       end
 
       def self.find_type(type)
-        type_id = if Symbol === type then TYPES[type] else type end
-        raise FrameTypeError.new(TYPES_OPTIONS) if type == nil || !TYPES_REVERSE.has_key?(type_id)
+        type_id = type.is_a?(Symbol) ? TYPES[type] : type
+        raise FrameTypeError, TYPES_OPTIONS if type.nil? || !TYPES_REVERSE.key?(type_id)
         type_id
       end
 
       def self.decode(*)
-        raise NotImplementedError.new <<-EOF
+        raise NotImplementedError, <<-EOF
 You are supposed to redefine this method, because it's dependent on used IO adapter.
 
 This functionality is part of the https://github.com/ruby-amqp/amq-client library.
         EOF
       end
 
+      # Optimized header decode using unpack1 for single values where appropriate
       def self.decode_header(header)
-        raise EmptyResponseError if header == nil || header.empty?
+        raise EmptyResponseError if header.nil? || header.empty?
 
+        # Use unpack for multiple values - this is the optimal approach
         type_id, channel, size = header.unpack(PACK_CHAR_UINT16_UINT32)
         type = TYPES_REVERSE[type_id]
-        raise FrameTypeError.new(TYPES_OPTIONS) unless type
+        raise FrameTypeError, TYPES_OPTIONS unless type
         [type, channel, size]
       end
 
@@ -130,7 +136,7 @@ This functionality is part of the https://github.com/ruby-amqp/amq-client librar
       end # final?
 
       def decode_payload
-        self.method_class.decode(@payload[4..-1])
+        self.method_class.decode(@payload.byteslice(4..-1))
       end
     end
 
@@ -167,8 +173,8 @@ This functionality is part of the https://github.com/ruby-amqp/amq-client librar
                                # the total size of the content body, that is, the sum of the body sizes for the
                                # following content body frames. Zero indicates that there are no content body frames.
                                # So this is NOT related to this very header frame!
-                               @body_size         = AMQ::Hacks.unpack_uint64_big_endian(@payload[4..11]).first
-                               @data              = @payload[12..-1]
+                               @body_size         = @payload.byteslice(4, 8).unpack1(PACK_UINT64_BE)
+                               @data              = @payload.byteslice(12..-1)
                                @properties        = Basic.decode_properties(@data)
                              end
       end