amq-protocol 2.3.4 → 2.5.0

data/benchmarks/table_encoding.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# frozen_string_literal: true
+
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "amq/protocol/client"
+require "benchmark/ips"
+
+puts
+puts "-" * 80
+puts "Table Encoding/Decoding Benchmarks on #{RUBY_DESCRIPTION}"
+puts "-" * 80
+
+# Test data - various table sizes and types
+EMPTY_TABLE = {}
+
+SIMPLE_TABLE = {
+  "key1" => "value1",
+  "key2" => 42,
+  "key3" => true
+}.freeze
+
+TYPICAL_HEADERS = {
+  "content_type" => "application/json",
+  "content_encoding" => "utf-8",
+  "x-custom-header" => "some-value",
+  "x-retry-count" => 3,
+  "x-timestamp" => Time.now.to_i
+}.freeze
+
+COMPLEX_TABLE = {
+  "string" => "hello world",
+  "integer" => 123456789,
+  "float" => 3.14159,
+  "boolean_true" => true,
+  "boolean_false" => false,
+  "nested" => {
+    "inner_key" => "inner_value",
+    "inner_number" => 999
+  },
+  "array" => [1, 2, 3, "four", true]
+}.freeze
+
+LARGE_TABLE = (1..50).to_h { |i| ["key_#{i}", "value_#{i}"] }.freeze
+
+# Pre-encode tables for decode benchmarks
+ENCODED_EMPTY = AMQ::Protocol::Table.encode(EMPTY_TABLE)
+ENCODED_SIMPLE = AMQ::Protocol::Table.encode(SIMPLE_TABLE)
+ENCODED_TYPICAL = AMQ::Protocol::Table.encode(TYPICAL_HEADERS)
+ENCODED_COMPLEX = AMQ::Protocol::Table.encode(COMPLEX_TABLE)
+ENCODED_LARGE = AMQ::Protocol::Table.encode(LARGE_TABLE)
+
+puts "Table sizes (bytes): empty=#{ENCODED_EMPTY.bytesize}, simple=#{ENCODED_SIMPLE.bytesize}, typical=#{ENCODED_TYPICAL.bytesize}, complex=#{ENCODED_COMPLEX.bytesize}, large=#{ENCODED_LARGE.bytesize}"
+puts
+
+puts "=== Table Encoding ==="
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("encode empty") do
+    AMQ::Protocol::Table.encode(EMPTY_TABLE)
+  end
+
+  x.report("encode simple (3 keys)") do
+    AMQ::Protocol::Table.encode(SIMPLE_TABLE)
+  end
+
+  x.report("encode typical headers (5 keys)") do
+    AMQ::Protocol::Table.encode(TYPICAL_HEADERS)
+  end
+
+  x.report("encode complex (nested/array)") do
+    AMQ::Protocol::Table.encode(COMPLEX_TABLE)
+  end
+
+  x.report("encode large (50 keys)") do
+    AMQ::Protocol::Table.encode(LARGE_TABLE)
+  end
+
+  x.compare!
+end
+
+puts
+puts "=== Table Decoding ==="
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("decode empty") do
+    AMQ::Protocol::Table.decode(ENCODED_EMPTY)
+  end
+
+  x.report("decode simple (3 keys)") do
+    AMQ::Protocol::Table.decode(ENCODED_SIMPLE)
+  end
+
+  x.report("decode typical headers (5 keys)") do
+    AMQ::Protocol::Table.decode(ENCODED_TYPICAL)
+  end
+
+  x.report("decode complex (nested/array)") do
+    AMQ::Protocol::Table.decode(ENCODED_COMPLEX)
+  end
+
+  x.report("decode large (50 keys)") do
+    AMQ::Protocol::Table.decode(ENCODED_LARGE)
+  end
+
+  x.compare!
+end

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,

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"
 

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

@@ -1569,30 +1569,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 +1689,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 +1865,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 +2007,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 +2136,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.
@@ -56,9 +60,11 @@ This functionality is part of the https://github.com/ruby-amqp/amq-client librar
         EOF
       end
 
+      # Optimized header decode using unpack1 for single values where appropriate
       def self.decode_header(header)
         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
@@ -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

data/lib/amq/protocol/table.rb

@@ -1,4 +1,5 @@
 # encoding: binary
+# frozen_string_literal: true
 
 require "amq/protocol/type_constants"
 require "amq/protocol/table_value_encoder"
@@ -14,6 +15,8 @@ module AMQ
 
       include TypeConstants
 
+      # Pack format string
+      PACK_UINT32_BE = 'N'.freeze
 
       #
       # API
@@ -27,16 +30,16 @@ module AMQ
 
 
       def self.encode(table)
-        buffer = String.new
+        buffer = +''
 
         table ||= {}
 
         table.each do |key, value|
           key = key.to_s # it can be a symbol as well
-          buffer << key.bytesize.chr + key
+          buffer << key.bytesize.chr << key
 
           case value
-          when Hash then
+          when Hash
             buffer << TYPE_HASH
             buffer << self.encode(value)
           else
@@ -44,15 +47,15 @@ module AMQ
           end
         end
 
-        [buffer.bytesize].pack(PACK_UINT32).force_encoding(buffer.encoding) + buffer
+        [buffer.bytesize].pack(PACK_UINT32_BE) << buffer
       end
 
 
 
 
       def self.decode(data)
-        table        = Hash.new
-        table_length = data.unpack(PACK_UINT32).first
+        table        = {}
+        table_length = data.unpack1(PACK_UINT32_BE)
 
         return table if table_length.zero?
 
@@ -86,19 +89,19 @@ module AMQ
                        when TYPE_BOOLEAN
                          v, offset = TableValueDecoder.decode_boolean(data, offset)
                          v
-                      when TYPE_BYTE  then
+                       when TYPE_BYTE
                          v, offset = TableValueDecoder.decode_byte(data, offset)
                          v
-                       when TYPE_SIGNED_16BIT then
+                       when TYPE_SIGNED_16BIT
                          v, offset = TableValueDecoder.decode_short(data, offset)
                          v
-                       when TYPE_SIGNED_64BIT then
+                       when TYPE_SIGNED_64BIT
                          v, offset = TableValueDecoder.decode_long(data, offset)
                          v
-                       when TYPE_32BIT_FLOAT then
+                       when TYPE_32BIT_FLOAT
                          v, offset = TableValueDecoder.decode_32bit_float(data, offset)
                          v
-                       when TYPE_64BIT_FLOAT then
+                       when TYPE_64BIT_FLOAT
                          v, offset = TableValueDecoder.decode_64bit_float(data, offset)
                          v
                        when TYPE_VOID
@@ -112,11 +115,11 @@ module AMQ
         end
 
         table
-      end # self.decode
+      end
 
 
       def self.length(data)
-        data.unpack(PACK_UINT32).first
+        data.unpack1(PACK_UINT32_BE)
       end
 
 
@@ -128,17 +131,17 @@ module AMQ
         end
 
         acc
-      end # self.hash_size(value)
+      end
 
 
       def self.decode_table_key(data, offset)
-        key_length = data.slice(offset, 1).unpack(PACK_CHAR).first
+        key_length = data.getbyte(offset)
         offset += 1
-        key = data.slice(offset, key_length)
+        key = data.byteslice(offset, key_length)
         offset += key_length
 
         [key, offset]
-      end # self.decode_table_key(data, offset)
+      end