fast-protowire 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0c2962e443067325c5f4a089b72e499b9e273f8f563464e9830ed9cdf6eccfa
-  data.tar.gz: cdc454d06627bf2d1f28ddc35127024e119e06e748120cfceac91fa7e4e40860
+  metadata.gz: e4332160b8041d794b7f19703e3c9ccfa0887bc1eb0d376b6e9d6e1947cf79c9
+  data.tar.gz: 990b87f8ffcf4b7684dd45bfef79f2ec93d66d6ad60b491109c5ab65cdfa7ec2
 SHA512:
-  metadata.gz: 5b6b5ea5c39ebc3fb9b25490fbea312dccdaaf450ab08b7a9be794056dbc3565e814f98890629664e405333e340e61d493760a57adc99b072b2cf59ff8399bc6
-  data.tar.gz: b788d96fe73458a33391b5339d35f7be57a37ec3bb203a2d645c590a5cb98d6ef4f9a5641788d8a12f20c7a51911c27287cba01cbac49e0d4b3c9e22f944be1d
+  metadata.gz: 69a56b231c6adb17d312ad7a90c2c223323d4283f564f5bc6b0853ee37136c5a3ffdc4ff81f86d70047f3fc10d5d1f510cc3152c5b3cd628f1bf965d5a50c8b9
+  data.tar.gz: 8f9478ae25d88e9ca0d8ce55d64ffa248c7e480d2323436eceb3b6757b8a0668faf18d4b32b89fef7df4379461d1b50e7d652f5428ab67026c8df1c82abc3ee2

data/AGENTS.md

@@ -8,7 +8,9 @@ Standing context for agents working in this repository.
 bundle install
 bundle exec sus
 bundle exec rubocop
-protoc --proto_path=fixtures/proto --ruby_out=fixtures/pb fixtures/proto/*.proto   # regenerate the reference schemas
+bundle exec ruby benchmark/messages.rb   # encode, build and decode against google-protobuf; BENCH_QUICK=1 for a short run
+protoc --proto_path=fixtures/proto --proto_path=/opt/homebrew/include --ruby_out=fixtures/pb fixtures/proto/*.proto
+# regenerates the reference schemas; the second path is where protoc keeps google/protobuf/timestamp.proto
 ```
 
 ## What this is

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 0.2.0
+
+- Encoding allocates nothing per nested message, packed field or map
+  entry: each is written into the parent buffer behind a length prefix
+  filled in afterwards. A family of 36,000 metrics x 12 labels encodes in
+  one object, its output, where it took 647,000, and 22% faster.
+  `Wire.append_length_delimited_from` now appends in place and returns the
+  width of the prefix it wrote, a hint to pass back for the next value;
+  `Wire.reserve_length` and `Wire.close_length` are its pieces, and
+  `Wire.varint_size` and `Wire.append_bytes` are public.
+- Fixed-width values pack with literal formats, so a double costs no Array
+  on Ruby 3.4+; text is appended with `String#append_as_bytes` there, tag
+  and one-byte size in the same call and no binary copy for UTF-8.
+  Zigzag no longer allocates for negative values.
+- Decoding reads nested messages, packed fields and map entries in place
+  (`Reader#read_nested`), unpacks fixed-width values at an offset
+  (`Reader#read_fixed`) and splits tags without an Array, so it allocates
+  only the messages, containers and Strings it returns: the same family
+  decodes in 1.4M objects where it took 7.1M, 1.7x faster.
+- `Message.new` no longer allocates an empty keyword Hash per message.
+- Removed: `Reader#read_packed` (use `read_nested`) and the interpretive
+  `Field#encode`, which the compiled encoder had superseded.
+- `test/fast/protowire/allocations.rb` holds the budgets; the Prometheus
+  client model (`fixtures/proto/metrics.proto`, upstream `client_model`)
+  joins the parity suite; `benchmark/messages.rb` measures encode, build
+  and decode against google-protobuf, published on the benchmarks page.
+
 ## 0.1.0
 
 - Initial release: `Wire`, `Reader`, `Enum` and the `Message` DSL covering

data/README.md

@@ -50,6 +50,23 @@ and the output is byte-identical to what `protoc`-generated code and `google-pro
 produce for the same values. The [tutorial](docs/tutorials/encode-a-message.md) walks
 through a full schema and proves that.
 
+## Performance
+
+Measured against `google-protobuf` on the Prometheus client model, a family of 36,000
+metrics with twelve labels each (Ruby 4.0.7; conditions and every table on the
+[benchmarks page](docs/explanation/benchmarks.md)):
+
+- Encoding allocates **one object, the output**, whatever the message's size or depth;
+  0.1.0 allocated 647,000 for this family. Decoding allocates only the messages,
+  containers and Strings it returns, 5x fewer than 0.1.0 and 1.7x faster.
+- Built a message at a time, the way an exposition builds series, `google-protobuf`
+  leaves **504,001 native arenas and 225 MiB** behind for an 11.76 MB body and spends
+  1.66 s of every ten builds in GC; fast-protowire leaves 16.5 MiB, no arenas, and 0.26 s.
+- `google-protobuf` is native, and 10 to 20x faster per operation on an existing tree
+  or one nested Hash. This gem trades that speed for memory that is roughly the size of
+  the output; fast-prometheus's scrape path goes further and writes series with `Wire`
+  directly, with no message per series at all.
+
 ## Documentation
 
 ### Tutorials
@@ -73,10 +90,12 @@ through a full schema and proves that.
 
 - [Design: the wire format and nothing else](docs/explanation/design.md) — what google-protobuf costs per message, what this gem does instead, and what it leaves out.
 - [How encoding works](docs/explanation/encoding.md) — compiled encoders, buffers, field order, presence, and decoding.
+- [Benchmarks](docs/explanation/benchmarks.md) — encode, build and decode against google-protobuf, what changed since 0.1.0, and how to reproduce them.
 
 ## Development
 
 ```bash
 bundle exec sus
 bundle exec rubocop
+BENCH_QUICK=1 bundle exec ruby benchmark/messages.rb   # encode, build and decode against google-protobuf
 ```

data/lib/fast/protowire/field.rb

@@ -141,14 +141,6 @@ module Fast
         end
       end
 
-      def encode(buffer, value)
-        case rule
-        when :repeated then encode_repeated(buffer, value)
-        when :map then encode_map(buffer, value)
-        else encode_one(buffer, value)
-        end
-      end
-
       # Reads one occurrence of this field into +current+ (the value already
       # held) and returns the value to store.
       def decode(reader, wire_type, current)
@@ -157,7 +149,7 @@ module Fast
         when :map then decode_map_entry(reader, wire_type, current)
         else
           if type == :message && current
-            current.merge_from(Reader.new(expect(reader, wire_type).read_length_delimited))
+            expect(reader, wire_type).read_nested { |nested| current.merge_from(nested) }
           else
             read_one(reader, wire_type)
           end
@@ -178,26 +170,38 @@ module Fast
         end
       end
 
-      def encode_one(buffer, value)
-        case type
-        when :message then Wire.append_length_delimited(buffer, @tag, value.encode)
-        when :string, :bytes then Wire.append_length_delimited(buffer, @tag, value)
-        else
-          buffer << @tag
-          append_scalar(buffer, value)
-        end
-      end
-
       def read_one(reader, wire_type)
         expect(reader, wire_type)
         case type
-        when :message then message_class.decode(reader.read_length_delimited)
+        when :message then reader.read_nested { |nested| message_class.new.merge_from(nested) }
         when :string then reader.read_length_delimited.force_encoding(Encoding::UTF_8)
         when :bytes then reader.read_length_delimited
         else read_scalar(reader)
         end
       end
 
+      # Appends the tag and one value. A nested message is encoded straight
+      # into the buffer behind a length prefix filled in after it, with no
+      # buffer of its own; +width+ carries the prefix width from one value
+      # to the next, a hint shared by every encode of the field. (A map's
+      # key and value fields build the entry writer together, which is why
+      # this is protected rather than private.)
+      def writer
+        tag = @tag
+        case type
+        when :message
+          width = 1
+          ->(buffer, value) { width = Wire.append_length_delimited_from(buffer, tag, width) { |b| value.encode(b) } }
+        when :string, :bytes then ->(buffer, value) { Wire.append_length_delimited(buffer, tag, value) }
+        else
+          scalar = scalar_writer
+          lambda do |buffer, value|
+            buffer << tag
+            scalar.call(buffer, value)
+          end
+        end
+      end
+
       private
 
       def resolve_type(type)
@@ -265,17 +269,19 @@ module Fast
         end
       end
 
+      # Packed: every value bare, behind one tag and length.
       def repeated_step(ivar)
         if packed?
           tag = @tag
           scalar = scalar_writer
+          width = 1
           lambda do |message, buffer|
             values = message.instance_variable_get(ivar)
             next if values.empty?
 
-            payload = String.new
-            values.each { |value| scalar.call(payload, value) }
-            Wire.append_length_delimited(buffer, tag, payload)
+            width = Wire.append_length_delimited_from(buffer, tag, width) do |b|
+              values.each { |value| scalar.call(b, value) }
+            end
           end
         else
           write = writer
@@ -283,36 +289,27 @@ module Fast
         end
       end
 
+      # Each entry is a message { key = 1; value = 2 }.
       def map_step(ivar)
         tag = @tag
         key = @key_field.writer
         value = @value_field.writer
+        width = 1
         lambda do |message, buffer|
           message.instance_variable_get(ivar).each do |k, v|
-            entry = String.new
-            key.call(entry, k)
-            value.call(entry, v)
-            Wire.append_length_delimited(buffer, tag, entry)
+            width = Wire.append_length_delimited_from(buffer, tag, width) do |b|
+              key.call(b, k)
+              value.call(b, v)
+            end
           end
         end
       end
 
-      # Appends the tag and one value.
-      def writer
-        tag = @tag
-        case type
-        when :message then ->(buffer, value) { Wire.append_length_delimited(buffer, tag, value.encode) }
-        when :string, :bytes then ->(buffer, value) { Wire.append_length_delimited(buffer, tag, value) }
-        else
-          scalar = scalar_writer
-          lambda do |buffer, value|
-            buffer << tag
-            scalar.call(buffer, value)
-          end
-        end
-      end
+      # -- writers -----------------------------------------------------------
 
       # Appends one scalar value without its tag, as packed fields need.
+      # Fixed-width types get a lambda each so the pack format is a literal:
+      # Ruby elides the Array in [value].pack(literal, buffer:), and only then.
       def scalar_writer
         case type
         when :int32, :int64, :uint32, :uint64 then ->(buffer, value) { Wire.append_varint(buffer, value) }
@@ -322,9 +319,12 @@ module Fast
         when :enum
           enum = @enum
           ->(buffer, value) { Wire.append_varint(buffer, value.is_a?(Symbol) ? enum.resolve(value) : value) }
-        else
-          format = FIXED_FORMATS.fetch(type)
-          ->(buffer, value) { [value].pack(format, buffer: buffer) }
+        when :double then ->(buffer, value) { [value].pack("E", buffer: buffer) }
+        when :float then ->(buffer, value) { [value].pack("e", buffer: buffer) }
+        when :fixed32 then ->(buffer, value) { [value].pack("L<", buffer: buffer) }
+        when :sfixed32 then ->(buffer, value) { [value].pack("l<", buffer: buffer) }
+        when :fixed64 then ->(buffer, value) { [value].pack("Q<", buffer: buffer) }
+        when :sfixed64 then ->(buffer, value) { [value].pack("q<", buffer: buffer) }
         end
       end
 
@@ -409,44 +409,11 @@ module Fast
         integer
       end
 
-      # -- encoding ----------------------------------------------------------
-
-      def encode_repeated(buffer, values)
-        return if values.empty?
-
-        if packed?
-          Wire.append_length_delimited_from(buffer, @tag) { |b| values.each { |v| append_scalar(b, v) } }
-        else
-          values.each { |v| encode_one(buffer, v) }
-        end
-      end
-
-      def encode_map(buffer, hash)
-        hash.each do |key, value|
-          Wire.append_length_delimited_from(buffer, @tag) do |entry|
-            @key_field.encode_one(entry, key)
-            @value_field.encode_one(entry, value)
-          end
-        end
-      end
-
-      def append_scalar(buffer, value)
-        case type
-        when :int32, :int64, :uint32, :uint64 then Wire.append_varint(buffer, value)
-        when :sint32 then Wire.append_varint(buffer, Wire.zigzag32(value))
-        when :sint64 then Wire.append_varint(buffer, Wire.zigzag64(value))
-        when :bool then buffer << (value ? 1 : 0)
-        when :enum then Wire.append_varint(buffer, enum_number(value))
-        else buffer << [value].pack(FIXED_FORMATS.fetch(type))
-        end
-      end
-
       # -- decoding ----------------------------------------------------------
 
       def decode_repeated(reader, wire_type, values)
         if packable? && wire_type == Wire::LENGTH_DELIMITED
-          packed = reader.read_packed
-          values << read_scalar(packed) until packed.eof?
+          reader.read_nested { |packed| values << read_scalar(packed) until packed.eof? }
         else
           values << read_one(reader, wire_type)
         end
@@ -454,18 +421,19 @@ module Fast
       end
 
       def decode_map_entry(reader, wire_type, hash)
-        entry = Reader.new(expect(reader, wire_type).read_length_delimited)
-        key = @key_field.default_value
-        value = @value_field.default_value
-        until entry.eof?
-          number, entry_wire_type = entry.read_tag
-          case number
-          when 1 then key = @key_field.read_one(entry, entry_wire_type)
-          when 2 then value = @value_field.decode(entry, entry_wire_type, value)
-          else entry.skip(entry_wire_type)
+        expect(reader, wire_type).read_nested do |entry|
+          key = @key_field.default_value
+          value = @value_field.default_value
+          until entry.eof?
+            tag = entry.read_varint
+            case tag >> 3
+            when 1 then key = @key_field.read_one(entry, tag & 0x7)
+            when 2 then value = @value_field.decode(entry, tag & 0x7, value)
+            else entry.skip(tag & 0x7)
+            end
           end
+          hash[key] = value
         end
-        hash[key] = value
         hash
       end
 
@@ -484,8 +452,8 @@ module Fast
         when :uint64 then reader.read_varint
         when :sint32, :sint64 then Wire.unzigzag(reader.read_varint)
         when :bool then reader.read_varint != 0
-        when :double, :fixed64, :sfixed64 then reader.read_bytes(8).unpack1(FIXED_FORMATS.fetch(type))
-        else reader.read_bytes(4).unpack1(FIXED_FORMATS.fetch(type))
+        when :double, :fixed64, :sfixed64 then reader.read_fixed(FIXED_FORMATS.fetch(type), 8)
+        else reader.read_fixed(FIXED_FORMATS.fetch(type), 4)
         end
       end
 
@@ -493,9 +461,6 @@ module Fast
         value &= (1 << bits) - 1
         value >= (1 << (bits - 1)) ? value - (1 << bits) : value
       end
-
-      # A map's key and value fields build the entry writer together.
-      protected :writer
     end
   end
 end

data/lib/fast/protowire/message.rb

@@ -143,11 +143,12 @@ module Fast
 
       # Scalar and message ivars stay unset until written (an unset ivar reads
       # as nil); repeated and map fields get their container up front so it
-      # can be mutated in place.
-      def initialize(attributes = nil, **keywords)
+      # can be mutated in place. +attributes+ is a Hash, or the keywords a
+      # caller writes instead of one.
+      def initialize(attributes = nil)
         self.class.container_fields.each { |field| instance_variable_set(field.ivar, field.default_value) }
         @unknown_fields = nil
-        (attributes || keywords).each do |name, value|
+        attributes&.each do |name, value|
           field = self.class.fields[name.to_sym]
           raise ArgumentError, "unknown field #{name.inspect} for #{self.class}" unless field
 
@@ -174,12 +175,14 @@ module Fast
       # merge) and returns self.
       def merge_from(reader)
         until reader.eof?
-          number, wire_type = reader.read_tag
-          field = self.class.fields_by_number[number]
+          key = reader.read_varint
+          wire_type = key & 0x7
+          field = self.class.fields_by_number[key >> 3]
           if field
             write_field(field, field.decode(reader, wire_type, instance_variable_get(field.ivar)))
           else
-            (@unknown_fields ||= String.new) << Wire.varint((number << 3) | wire_type) << reader.skip(wire_type)
+            Wire.append_varint(@unknown_fields ||= String.new, key)
+            @unknown_fields << reader.skip(wire_type)
           end
         end
         self

data/lib/fast/protowire/reader.rb

@@ -26,28 +26,40 @@ module Fast
         [key >> 3, key & 0x7]
       end
 
+      # Most varints (tags, small lengths) are one byte; the loop is only
+      # entered past it, and is a bare while because Kernel#loop costs an
+      # object per call.
       def read_varint
-        result = 0
-        shift = 0
-        loop do
-          raise DecodeError, "truncated varint" if @position >= @limit
+        byte = read_byte
+        return byte if byte < 0x80
 
-          byte = @buffer.getbyte(@position)
-          @position += 1
-          result |= (byte & 0x7f) << shift
-          return result if byte < 0x80
+        result = byte & 0x7f
+        shift = 7
+        while byte >= 0x80
+          raise DecodeError, "varint too long" if shift > 63
 
+          byte = read_byte
+          result |= (byte & 0x7f) << shift
           shift += 7
-          raise DecodeError, "varint too long" if shift > 63
         end
+        result
       end
 
       def read_fixed32
-        read_bytes(4).unpack1("L<")
+        read_fixed("L<", 4)
       end
 
       def read_fixed64
-        read_bytes(8).unpack1("Q<")
+        read_fixed("Q<", 8)
+      end
+
+      # Reads +width+ bytes as one value of the pack +format+, in place.
+      def read_fixed(format, width)
+        raise DecodeError, "truncated field" if @position + width > @limit
+
+        value = @buffer.unpack1(format, offset: @position)
+        @position += width
+        value
       end
 
       def read_bytes(length)
@@ -62,14 +74,19 @@ module Fast
         read_bytes(read_varint)
       end
 
-      # A reader bounded to the next length-delimited value, for packed fields.
-      def read_packed
+      # Bounds the reader to the next length-delimited value for the block
+      # and returns the block's result: nested messages, packed fields and
+      # map entries are read in place, with no copy of their bytes.
+      def read_nested
         length = read_varint
-        raise DecodeError, "truncated packed field" if @position + length > @limit
+        limit = @limit
+        raise DecodeError, "truncated field" if @position + length > limit
 
-        reader = Reader.new(@buffer, @position, @position + length)
-        @position += length
-        reader
+        @limit = @position + length
+        result = yield self
+        @position = @limit
+        @limit = limit
+        result
       end
 
       # Skips one value of +wire_type+ and returns its raw bytes, so unknown
@@ -89,6 +106,14 @@ module Fast
 
       private
 
+      def read_byte
+        raise DecodeError, "truncated varint" if @position >= @limit
+
+        byte = @buffer.getbyte(@position)
+        @position += 1
+        byte
+      end
+
       def skip_group
         loop do
           number, wire_type = read_tag

data/lib/fast/protowire/version.rb

@@ -2,6 +2,6 @@
 
 module Fast
   module Protowire
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/fast/protowire/wire.rb

@@ -3,8 +3,9 @@
 module Fast
   module Protowire
     # The wire format itself: tags, varints, zigzag, fixed-width values and
-    # length prefixes, appended to a binary String buffer. Everything above
-    # this module is bookkeeping about which field gets which of these.
+    # length prefixes, appended to a binary String buffer, and the size each
+    # takes so a length prefix can be written before its payload. Everything
+    # above this module is bookkeeping about which field gets which of these.
     module Wire
       VARINT = 0
       FIXED64 = 1
@@ -14,7 +15,9 @@ module Fast
       FIXED32 = 5
 
       UINT64_MASK = (1 << 64) - 1
-      private_constant :UINT64_MASK
+      # Zero bytes a length prefix is widened to, by varint width.
+      PLACEHOLDERS = Array.new(11) { |width| ("\0" * width).b.freeze }.freeze
+      private_constant :UINT64_MASK, :PLACEHOLDERS
 
       module_function
 
@@ -38,34 +41,100 @@ module Fast
         buffer << value
       end
 
+      # Bytes append_varint writes for +value+.
+      def varint_size(value)
+        return 10 if value.negative?
+
+        size = 1
+        while value > 0x7f
+          value >>= 7
+          size += 1
+        end
+        size
+      end
+
+      # (* 2 rather than << 1: a left shift of a negative Fixnum allocates.)
       def zigzag32(value)
-        (value << 1) ^ (value >> 31)
+        (value * 2) ^ (value >> 31)
       end
 
       def zigzag64(value)
-        (value << 1) ^ (value >> 63)
+        (value * 2) ^ (value >> 63)
       end
 
       def unzigzag(value)
         (value >> 1) ^ -(value & 1)
       end
 
-      # A length-delimited field: +tag+ then the varint size of +bytes+ then
-      # +bytes+. Non-ASCII text is appended as its bytes so the binary buffer
-      # never trips Ruby's encoding compatibility check.
-      def append_length_delimited(buffer, tag, bytes)
+      # A length-delimited field whose payload the block appends to +buffer+
+      # itself, behind a length prefix filled in once the payload is there,
+      # so a nested message, packed field or map entry costs no buffer of
+      # its own. Returns the width of the prefix it wrote: a caller writing
+      # many alike values passes it back as +width+ and the prefix is
+      # rarely resized.
+      def append_length_delimited_from(buffer, tag, width = 1)
         buffer << tag
-        append_varint(buffer, bytes.bytesize)
-        buffer << (bytes.ascii_only? ? bytes : bytes.b)
+        start = reserve_length(buffer, width)
+        yield buffer
+        close_length(buffer, start, width)
+      end
+
+      # Appends +width+ placeholder bytes for a length prefix and returns the
+      # position after them, for close_length.
+      def reserve_length(buffer, width = 1)
+        buffer << PLACEHOLDERS[width]
+        buffer.bytesize
+      end
+
+      # Writes the varint size of everything appended since +start+ into the
+      # +width+ placeholder bytes before it, first resizing the placeholder
+      # when the size needs a different width, which moves only the payload.
+      # Returns the width written. (Growing a String in place reallocates it
+      # to exactly the new size, so on a large buffer a resize costs far more
+      # than the bytes moved; hence the width hint.)
+      def close_length(buffer, start, width = 1)
+        length = buffer.bytesize - start
+        needed = length < 0x80 ? 1 : varint_size(length)
+        buffer.bytesplice(start - width, width, PLACEHOLDERS[needed]) unless needed == width
+        position = start - width
+        while length > 0x7f
+          buffer.setbyte(position, (length & 0x7f) | 0x80)
+          position += 1
+          length >>= 7
+        end
+        buffer.setbyte(position, length)
+        needed
       end
 
-      # A length-delimited field whose payload the block writes into a fresh
-      # buffer. (Writing into the parent and inserting the size afterwards
-      # looks cheaper but String#insert costs O(size) on the parent.)
-      def append_length_delimited_from(buffer, tag)
-        payload = String.new
-        yield payload
-        append_length_delimited(buffer, tag, payload)
+      # Text of any encoding goes into the binary buffer as bytes. Ruby 3.4's
+      # String#append_as_bytes does that with no copy, and takes the tag and
+      # a one-byte size in the same call; before it, non-ASCII text is
+      # appended as a binary copy so the buffer never trips Ruby's encoding
+      # compatibility check.
+      if String.method_defined?(:append_as_bytes)
+        # A length-delimited field: +tag+, the varint size of +bytes+, +bytes+.
+        def append_length_delimited(buffer, tag, bytes)
+          size = bytes.bytesize
+          return buffer.append_as_bytes(tag, size, bytes) if size < 0x80
+
+          buffer << tag
+          append_varint(buffer, size)
+          buffer.append_as_bytes(bytes)
+        end
+
+        def append_bytes(buffer, bytes)
+          buffer.append_as_bytes(bytes)
+        end
+      else
+        def append_length_delimited(buffer, tag, bytes)
+          buffer << tag
+          append_varint(buffer, bytes.bytesize)
+          append_bytes(buffer, bytes)
+        end
+
+        def append_bytes(buffer, bytes)
+          buffer << (bytes.encoding == Encoding::BINARY || bytes.ascii_only? ? bytes : bytes.b)
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fast-protowire
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Eric Jacobs
@@ -46,7 +46,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.20
 specification_version: 4
 summary: 'Protocol Buffers wire format for Ruby: declare messages, encode and decode
   bytes, no runtime.'