protobuf 3.10.9 → 3.10.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ed2f7beb2186899fa855dcdc852e2ab8d8433f0365d6bfd01bd5ad5d010b189
-  data.tar.gz: fe237afa9ce1f42475919b85246f97890343a652b752f82b57863309b314a759
+  metadata.gz: 8096ad0d169fe7be73b2cce91ed6b45fc29ce8377f6599468ea4b165f3cba5fc
+  data.tar.gz: f562a6ffed606efb06c22f429859d3c6f34a95024e12775b5fe500242f4af760
 SHA512:
-  metadata.gz: 223ba3d3993ca39c973228c6572d0b15ff21c86967114749fad157d19386ae7e285a6a40ab2a05187108f63f28f1d1242ed6861ac2f4dc456d8e1327cc46974e
-  data.tar.gz: 374f7d7484f34098d8d07ede5b08be53842550ec0cc7291410b1d25b85289ffe921d0aa6d4dd55a39cf12005b2374ab4a9dd546f061e3f6e95b55e489f1b7845
+  metadata.gz: 759ac6f9f38a1eb1a462cbaa8b7f8c172563fe85963fa51e8557d37464def8dd486b66a4e272593b6a9cb10f6094df3848678b139dd8fe15fd057f3a1d50d512
+  data.tar.gz: eacef1704e921e60280621d4cea12396c43a20e597e0485dfb402c18cf2d918d110f33cfb88fec57d729eb1bdf797c15abef77216604c99b3dca845d55ac1e21

data/.circleci/config.yml

@@ -1,46 +1,130 @@
 version: 2.1
 
 jobs:
-  # skipping build step because Gemfile.lock is not included in the source
-  # this makes the bundler caching step a noop
+  rubocop:
+    docker:
+      # RuboCop 0.81 does not load on Ruby 4.0 (it needs the benchmark gem).
+      - image: cimg/ruby:3.4
+    steps:
+      - checkout
+      - run:
+          name: Install gems
+          command: bundle install --jobs 4 --retry 3
+      - run:
+          name: RuboCop
+          command: bundle exec rubocop
+
   test:
     parameters:
-      ruby-image:
+      ruby:
+        type: string
+      rails:
         type: string
     docker:
-      - image: << parameters.ruby-image >>
+      - image: cimg/ruby:<< parameters.ruby >>
+    environment:
+      # Newer protoc versions reject the explicit `map_entry` option in the spec protos.
+      PROTOC_VERSION: "3.16.0"
+      RAILS_VERSION: "~> << parameters.rails >>.0"
     steps:
+      - checkout
+      - run:
+          name: Install ZeroMQ
+          command: sudo apt-get update && sudo apt-get install -y libzmq3-dev
       - run:
-          name: Install protobuf compiler
+          name: Install protoc
           command: |
-            archive=protoc-3.16.0-linux-x86_64
-            curl -O -L https://github.com/protocolbuffers/protobuf/releases/download/v3.16.0/$archive.zip
-            sudo unzip -d '/usr/local' $archive.zip 'bin/*' 'include/*'
-            sudo chown -R $(whoami) /usr/local/bin/protoc /usr/local/include/google
-            rm -rf $archive.zip
+            archive="protoc-${PROTOC_VERSION}-linux-x86_64"
+            curl -sSL -o "/tmp/${archive}.zip" \
+              "https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOC_VERSION}/${archive}.zip"
+            sudo unzip -q -o -d /usr/local "/tmp/${archive}.zip" 'bin/*' 'include/*'
+            sudo chmod -R a+rX /usr/local/bin/protoc /usr/local/include/google
+            protoc --version
+      # Gemfile.lock is not committed, so each job resolves gems for its own
+      # Ruby and RAILS_VERSION.
+      - run:
+          name: Install gems
+          command: bundle install --jobs 4 --retry 3
+      - run:
+          name: Compile protos
+          command: bundle exec rake compile:spec compile:rpc
       - run:
-          command: protoc --version
+          name: Check compiled protos are committed
+          command: git diff --exit-code
       - run:
-          command: sudo apt-get update
+          name: Run specs
+          command: bundle exec rspec
+
+  test-jruby:
+    parameters:
+      jruby:
+        type: string
+      rails:
+        type: string
+    docker:
+      - image: jruby:<< parameters.jruby >>
+    environment:
+      PROTOC_VERSION: "3.16.0"
+      RAILS_VERSION: "~> << parameters.rails >>.0"
+      JRUBY_OPTS: "--dev"
+    steps:
+      # The jruby image has no git, so install it before checkout.
       - run:
-          message: Install ZeroMQ
-          command: sudo apt-get -y install libzmq3-dev
+          name: Install system packages
+          command: apt-get update && apt-get install -y git unzip build-essential libzmq3-dev
       - checkout
       - run:
-          command: gem install bundler
+          name: Install protoc
+          command: |
+            archive="protoc-${PROTOC_VERSION}-linux-x86_64"
+            curl -sSL -o "/tmp/${archive}.zip" \
+              "https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOC_VERSION}/${archive}.zip"
+            unzip -q -o -d /usr/local "/tmp/${archive}.zip" 'bin/*' 'include/*'
+            protoc --version
+      - run:
+          name: Install gems
+          command: bundle install --jobs 4 --retry 3
+      - run:
+          name: Compile protos
+          command: bundle exec rake compile:spec compile:rpc
       - run:
-          command: bundle install
+          name: Check compiled protos are committed
+          command: git diff --exit-code
       - run:
-          command: bundle exec rake
+          name: Run specs
+          command: bundle exec rspec
 
 workflows:
   build_and_test:
     jobs:
+      - rubocop
       - test:
+          name: test-ruby-<< matrix.ruby >>-rails-<< matrix.rails >>
+          matrix:
+            parameters:
+              ruby: ["3.1", "3.2", "3.3", "3.4", "4.0"]
+              rails: ["6.0", "6.1", "7.0", "7.1", "7.2", "8.0", "8.1"]
+            exclude:
+              # Rails 8.0+ requires Ruby 3.2+.
+              - { ruby: "3.1", rails: "8.0" }
+              - { ruby: "3.1", rails: "8.1" }
+              # Rails 6.x does not load on Ruby 3.4+: it needs bigdecimal and
+              # logger, which are no longer default gems, and does not declare them.
+              - { ruby: "3.4", rails: "6.0" }
+              - { ruby: "3.4", rails: "6.1" }
+              - { ruby: "4.0", rails: "6.0" }
+              - { ruby: "4.0", rails: "6.1" }
+      - test-jruby:
+          name: test-jruby-<< matrix.jruby >>-rails-<< matrix.rails >>
           matrix:
             parameters:
-              ruby-image:
-                - circleci/jruby:9.2.6.0-jdk
-                - circleci/jruby:9.1.17.0-jdk
-                - circleci/ruby:2.5
-                - circleci/ruby:2.7
+              # JRuby 9.4 is Ruby 3.1; JRuby 10.0 is Ruby 3.4.
+              jruby: ["9.4", "10.0"]
+              rails: ["6.1", "7.1", "7.2", "8.0", "8.1"]
+            exclude:
+              # Rails 8.0+ requires Ruby 3.2+.
+              - { jruby: "9.4", rails: "8.0" }
+              - { jruby: "9.4", rails: "8.1" }
+              # Rails 6.x does not load on Ruby 3.4 (base64 and bigdecimal are
+              # no longer default gems).
+              - { jruby: "10.0", rails: "6.1" }

data/.rubocop.yml

@@ -2,6 +2,9 @@ inherit_from: .rubocop_todo.yml
 
 AllCops:
   DisplayCopNames: true
+  # The newest version RuboCop 0.81 knows. Without it, RuboCop reads the Ruby
+  # version from .ruby-version or Gemfile.lock and fails on Ruby 3.x.
+  TargetRubyVersion: 2.7
   Exclude:
     - 'spec/support/protos/*.pb.rb'
     - 'varint_prof.rb'
@@ -79,3 +82,8 @@ Style/TrivialAccessors:
 Style/Encoding:
   Exclude:
     - '**/*.pb.rb'
+
+# TargetRubyVersion (2.7) cannot match required_ruby_version (>= 3.1), because
+# RuboCop 0.81 does not know Ruby 3.x.
+Gemspec/RequiredRubyVersion:
+  Enabled: false

data/.rubocop_todo.yml

@@ -6,6 +6,12 @@
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
+# RuboCop 0.81 validates this file alone, before it merges it into
+# .rubocop.yml, so it needs its own TargetRubyVersion. Keep it equal to the
+# value in .rubocop.yml.
+AllCops:
+  TargetRubyVersion: 2.7
+
 # Offense count: 1
 # Cop supports --auto-correct.
 # Configuration parameters: TreatCommentsAsGroupSeparators, Include.

data/CHANGES.md

@@ -1,5 +1,36 @@
 # Stable (3.8.x)
 
+3.10.10
+-------
+- Decode repeated scalar fields by the wire type of each record, not by the
+  `packed` declaration. Packed input (the proto3 default in Go, Java, C++ and
+  google-protobuf) for a field without `packed` no longer decodes bools as
+  `false`, raises on integers and enums, or drops all but the first
+  fixed32/float/double value. (#438, #330, #414)
+- Skip a record whose wire type does not match its known field, as the
+  reference parsers do. Before, such a record could decode to a wrong value
+  or raise `NoMethodError`/`TypeError` for string, bytes, message, and map
+  fields.
+- Decode any non-zero bool varint as `true`.
+- An `int32`, `uint32`, or `sint32` field keeps the low 32 bits of a wider
+  varint, as the reference parsers do. Before, a peer that sent an int64 value
+  for the field (a compatible schema change) made the whole decode raise
+  `TypeError`.
+- Skip a group (wire types 3 and 4, from proto2 groups or editions `DELIMITED`
+  encoding) as an unknown field. Before, the decode raised
+  `Protobuf::InvalidWireType`.
+- Support Ruby 4.0. CircleCI also tests Ruby 4.0, JRuby 9.4, and JRuby 10.0.
+- Require Ruby >= 3.1 and ActiveSupport >= 6.0.
+- Add `Protobuf::Rpc::ApplicationService`, a base class for application services.
+- `Service.implemented_services` walks all descendants, not only direct subclasses.
+- Add `Protobuf::Railtie`. Set `config.protobuf.services_path` to load that
+  directory when the RPC server binds, so dynamic discovery sees lazily loaded
+  services.
+- Service filters and `rescue_from` handlers now pass from a parent class to
+  its subclasses.
+- Add `PB_SERVICE_PARENT` to set the parent class of generated services.
+- CircleCI tests Ruby 3.1 to 3.4 with Rails 6.0 to 8.1, and runs RuboCop.
+
 
 3.10.0
 ------

data/Gemfile

@@ -2,19 +2,18 @@ source 'https://rubygems.org'
 
 gemspec
 
+# CI sets RAILS_VERSION (for example "~> 6.1.0") to test each supported Rails.
+# railties is also a gemspec development dependency, so only activesupport is
+# pinned here and railties follows it.
+if (rails_version = ENV['RAILS_VERSION'])
+  gem 'activesupport', rails_version
+end
+
 group :development do
   # debuggers only work in MRI
   if RUBY_ENGINE.to_sym == :ruby
-    if RUBY_VERSION < '2.0.0'
-      gem 'pry-debugger'
-    elsif RUBY_VERSION < '2.4.0'
-      gem 'pry', '~> 0.12.0'
-      gem 'pry-byebug'
-    else
-      gem 'pry', '~> 0.13.0'
-      gem 'pry-byebug', '~> 3.9.0'
-    end
-
+    gem 'pry'
+    gem 'pry-byebug'
     gem 'pry-stack_explorer'
 
     gem 'ruby-prof'

data/lib/protobuf/code_generator.rb

@@ -63,7 +63,14 @@ module Protobuf
       def define_set_method!
       end
 
-      def set_without_options(message_instance, bytes)
+      # Same rules as the set methods in BaseFieldObjectDefinitions: a packable
+      # repeated field decodes by the record's wire type, not its declaration.
+      def set_without_options(message_instance, bytes, record_wire_type = nil)
+        if repeated? && packable?
+          return set_packable_without_options(message_instance[name], bytes, record_wire_type)
+        end
+
+        return if record_wire_type && record_wire_type != wire_type
         return message_instance[name] = decode(bytes) unless repeated?
 
         if map?
@@ -75,9 +82,14 @@ module Protobuf
           return hash[entry.key]
         end
 
-        return message_instance[name] << decode(bytes) unless packed?
+        message_instance[name] << decode(bytes)
+      end
+
+      def set_packable_without_options(array, bytes, record_wire_type)
+        record_wire_type ||= packed? ? ::Protobuf::WireType::LENGTH_DELIMITED : wire_type
+        return array << decode(bytes) if record_wire_type == wire_type
+        return unless record_wire_type == ::Protobuf::WireType::LENGTH_DELIMITED
 
-        array = message_instance[name]
         stream = StringIO.new(bytes)
 
         if wire_type == ::Protobuf::WireType::VARINT
@@ -92,7 +104,7 @@ module Protobuf
       # Sets a MessageField that is known to be an option.
       # We must allow fields to be set one at a time, as option syntax allows us to
       # set each field within the option using a separate "option" line.
-      def set_with_options(message_instance, bytes)
+      def set_with_options(message_instance, bytes, record_wire_type = nil)
         if message_instance[name].is_a?(::Protobuf::Message)
           gp = Google::Protobuf
           if message_instance.is_a?(gp::EnumOptions) || message_instance.is_a?(gp::EnumValueOptions) ||
@@ -109,7 +121,7 @@ module Protobuf
           end
         end
 
-        set_without_options(message_instance, bytes)
+        set_without_options(message_instance, bytes, record_wire_type)
       end
       alias_method :set, :set_with_options
 

data/lib/protobuf/decoder.rb

@@ -1,7 +1,8 @@
 module Protobuf
   class Decoder
 
-    # Read bytes from +stream+ and pass to +message+ object.
+    # Read bytes from +stream+ and yield (tag, bytes, wire_type) for each field.
+    # A block that takes only (tag, bytes) still works: blocks drop extra arguments.
     def self.decode_each_field(stream)
       until stream.eof?
         bits = Varint.decode(stream)
@@ -17,12 +18,42 @@ module Protobuf
                   stream.read(8)
                 elsif wire_type == ::Protobuf::WireType::FIXED32
                   stream.read(4)
+                elsif wire_type == ::Protobuf::WireType::START_GROUP
+                  skip_group(stream, tag)
+                  next
                 else
                   fail InvalidWireType, wire_type
                 end
 
-        yield(tag, bytes)
+        yield(tag, bytes, wire_type)
       end
     end
+
+    # Skip a group (wire types 3 and 4), with any groups inside it. This gem
+    # has no group fields, so the rule for an unknown field applies, as in the
+    # reference parsers: skip it. A group without its end raises InvalidWireType.
+    def self.skip_group(stream, group_tag)
+      open_tags = [group_tag]
+      until open_tags.empty?
+        fail InvalidWireType, ::Protobuf::WireType::START_GROUP if stream.eof?
+
+        bits = Varint.decode(stream)
+        wire_type = bits & 0x07
+        tag = bits >> 3
+
+        case wire_type
+        when ::Protobuf::WireType::VARINT then Varint.decode(stream)
+        when ::Protobuf::WireType::LENGTH_DELIMITED then stream.read(Varint.decode(stream))
+        when ::Protobuf::WireType::FIXED64 then stream.read(8)
+        when ::Protobuf::WireType::FIXED32 then stream.read(4)
+        when ::Protobuf::WireType::START_GROUP then open_tags.push(tag)
+        when ::Protobuf::WireType::END_GROUP
+          fail InvalidWireType, wire_type unless open_tags.pop == tag
+        else
+          fail InvalidWireType, wire_type
+        end
+      end
+    end
+    private_class_method :skip_group
   end
 end

data/lib/protobuf/field/base_field.rb

@@ -287,8 +287,8 @@ module Protobuf
       def define_set_method!
         @set_method = if map?
                         OBJECT_MODULE::MapSetMethod.new(self)
-                      elsif repeated? && packed?
-                        OBJECT_MODULE::RepeatedPackedSetMethod.new(self)
+                      elsif repeated? && packable?
+                        OBJECT_MODULE::RepeatedPackableSetMethod.new(self)
                       elsif repeated?
                         OBJECT_MODULE::RepeatedNotPackedSetMethod.new(self)
                       else
@@ -296,8 +296,16 @@ module Protobuf
                       end
       end
 
-      def set(message_instance, bytes)
-        @set_method.call(message_instance, bytes)
+      # Whether the field's type can use the packed encoding (scalar numeric
+      # types). This is about the type, not about the `packed` option.
+      def packable?
+        ::Protobuf::Field::BaseField::PACKED_TYPES.include?(wire_type)
+      end
+
+      # +wire_type+ is the wire type of the record that +bytes+ came from. It is
+      # nil for callers that do not know it; then the field declaration decides.
+      def set(message_instance, bytes, wire_type = nil)
+        @set_method.call(message_instance, bytes, wire_type)
       end
 
       def tag_encoded
@@ -372,7 +380,7 @@ module Protobuf
       end
 
       def validate_packed_field
-        if packed? && ! ::Protobuf::Field::BaseField::PACKED_TYPES.include?(wire_type)
+        if packed? && !packable?
           fail "Can't use packed encoding for '#{type_class}' type"
         end
       end

data/lib/protobuf/field/base_field_object_definitions.rb

@@ -116,9 +116,13 @@ module Protobuf
         def initialize(selph)
           @selph = selph
           @name = selph.name
+          @wire_type = selph.wire_type
         end
 
-        def call(message_instance, bytes)
+        # A record whose wire type differs from the field's is skipped, as the
+        # protobuf spec and the reference parsers do.
+        def call(message_instance, bytes, wire_type = nil)
+          return if wire_type && wire_type != @wire_type
           message_instance.set_field(@name, @selph.decode(bytes), true, @selph)
         end
       end
@@ -127,9 +131,11 @@ module Protobuf
         def initialize(selph)
           @selph = selph
           @name = selph.name
+          @wire_type = selph.wire_type
         end
 
-        def call(message_instance, bytes)
+        def call(message_instance, bytes, wire_type = nil)
+          return if wire_type && wire_type != @wire_type
           hash = message_instance[@name]
           entry = @selph.decode(bytes)
           # decoded value could be nil for an
@@ -139,26 +145,54 @@ module Protobuf
         end
       end
 
+      # Repeated string, bytes, and message fields. These are never packed.
       class RepeatedNotPackedSetMethod
         def initialize(selph)
           @selph = selph
           @name = selph.name
+          @wire_type = selph.wire_type
         end
 
-        def call(message_instance, bytes)
+        def call(message_instance, bytes, wire_type = nil)
+          return if wire_type && wire_type != @wire_type
           message_instance[@name] << @selph.decode(bytes)
         end
       end
 
-      class RepeatedPackedSetMethod
+      # Repeated scalar numeric fields (varint, fixed32, fixed64). The protobuf
+      # spec requires a parser to accept both the packed and the unpacked
+      # encoding, whatever the field declares. The wire type of each record
+      # selects the decoding: LENGTH_DELIMITED is a packed run, and the field's
+      # own wire type is one value. A record without a wire type (an old
+      # caller of BaseField#set) falls back to the declaration.
+      class RepeatedPackableSetMethod
+        LENGTH_DELIMITED = ::Protobuf::WireType::LENGTH_DELIMITED
+
         def initialize(selph)
           @selph = selph
           @name = selph.name
           @wire_type = selph.wire_type
+          @packed = selph.packed?
+        end
+
+        def call(message_instance, bytes, wire_type = nil)
+          # Most common first: one unpacked value, as this gem encodes by default.
+          if wire_type == @wire_type
+            message_instance[@name] << @selph.decode(bytes)
+          elsif wire_type == LENGTH_DELIMITED
+            decode_packed(message_instance[@name], bytes)
+          elsif wire_type.nil?
+            if @packed
+              decode_packed(message_instance[@name], bytes)
+            else
+              message_instance[@name] << @selph.decode(bytes)
+            end
+          end
         end
 
-        def call(message_instance, bytes)
-          array = message_instance[@name]
+        private
+
+        def decode_packed(array, bytes)
           stream = ::StringIO.new(bytes)
 
           if @wire_type == ::Protobuf::WireType::VARINT

data/lib/protobuf/field/bool_field.rb

@@ -38,8 +38,9 @@ module Protobuf
         end
       end
 
+      # Any non-zero varint is true, as in the reference parsers.
       def decode(value)
-        value == ONE
+        value != 0
       end
 
       def encode(value)

data/lib/protobuf/field/int32_field.rb

@@ -16,6 +16,18 @@ module Protobuf
         INT32_MIN
       end
 
+      ##
+      # Public Instance Methods
+      #
+
+      # Keep the low 32 bits, as the reference parsers do. A peer that sends
+      # an int64 or uint64 value for this field (a compatible schema change)
+      # then decodes instead of raising.
+      def decode(value)
+        value &= 0xffff_ffff
+        value >= 0x8000_0000 ? value - 0x1_0000_0000 : value
+      end
+
     end
   end
 end

data/lib/protobuf/field/sint32_field.rb

@@ -16,6 +16,16 @@ module Protobuf
         INT32_MIN
       end
 
+      ##
+      # Public Instance Methods
+      #
+
+      # Keep the low 32 bits before the zigzag decode, as the reference
+      # parsers do. A peer that sends a sint64 value then decodes.
+      def decode(value)
+        super(value & 0xffff_ffff)
+      end
+
     end
   end
 end

data/lib/protobuf/field/uint32_field.rb

@@ -16,6 +16,15 @@ module Protobuf
         0
       end
 
+      ##
+      # Public Instance Methods
+      #
+
+      # Keep the low 32 bits, as the reference parsers do.
+      def decode(value)
+        value & 0xffff_ffff
+      end
+
     end
   end
 end

data/lib/protobuf/generators/printable.rb

@@ -82,12 +82,21 @@ module Protobuf
         when :enum then
           PARENT_CLASS_ENUM
         when :service then
-          PARENT_CLASS_SERVICE
+          service_parent_class
         else
           fail "Unknown parent class type #{type}: #{caller[0..5].join("\n")}"
         end
       end
 
+      # PB_SERVICE_PARENT sets the parent class of generated services, for
+      # example `ApplicationService` or `::Protobuf::Rpc::ApplicationService`.
+      # The parent class must be loaded before the generated file.
+      #
+      def service_parent_class
+        parent = ENV['PB_SERVICE_PARENT'].to_s.strip
+        parent.empty? ? PARENT_CLASS_SERVICE : parent
+      end
+
       # Print a class or module block, indicated by type.
       # If a class, can be given a parent class to inherit from.
       # If a block is given, call the block from within an indent block.

data/lib/protobuf/message/serialization.rb

@@ -38,8 +38,8 @@ module Protobuf
       # Decode the given stream into this message.
       #
       def decode_from(stream)
-        ::Protobuf::Decoder.decode_each_field(stream) do |tag, bytes|
-          set_field_bytes(tag, bytes)
+        ::Protobuf::Decoder.decode_each_field(stream) do |tag, bytes, wire_type|
+          set_field_bytes(tag, bytes, wire_type)
         end
 
         self
@@ -75,9 +75,9 @@ module Protobuf
 
       private
 
-      def set_field_bytes(tag, bytes)
+      def set_field_bytes(tag, bytes, wire_type = nil)
         field = _protobuf_message_field[tag]
-        field.set(self, bytes) if field
+        field.set(self, bytes, wire_type) if field
       end
 
     end

data/lib/protobuf/railtie.rb

@@ -0,0 +1,48 @@
+require 'rails/railtie'
+require 'protobuf/service_loader'
+
+module Protobuf
+  # RPC discovery (`Service.implemented_services`) walks `descendants`, which
+  # only sees loaded classes, and Zeitwerk loads lazily. This railtie loads the
+  # configured services directory one time, when the RPC server is about to
+  # bind. Web, console, and test processes never pay that cost.
+  #
+  # Opt in from config/application.rb:
+  #
+  #   config.protobuf.services_path = 'app/services/rpc'
+  #
+  # A relative path resolves against Rails.root.
+  class Railtie < ::Rails::Railtie
+    config.protobuf = ::ActiveSupport::OrderedOptions.new
+    config.protobuf.services_path = nil
+
+    initializer 'protobuf.load_services' do |app|
+      ::ActiveSupport::Notifications.subscribe('before_server_bind') do
+        ::Protobuf::Railtie.load_services(app)
+      end
+    end
+
+    def self.services_path(app)
+      configured = app.config.protobuf.services_path.to_s
+      return if configured.empty?
+
+      ::File.expand_path(configured, app.root.to_s)
+    end
+
+    def self.load_services(app)
+      path = services_path(app)
+      return unless path && ::File.directory?(path)
+
+      loader = ::Rails.autoloaders.main # nil with the classic autoloader
+      if loader.respond_to?(:eager_load_dir) # Zeitwerk 2.6.2+
+        begin
+          return loader.eager_load_dir(path)
+        rescue ::Zeitwerk::Error
+          # The main autoloader does not manage this path. Fall through.
+        end
+      end
+
+      ::Protobuf::ServiceLoader.load_services(path)
+    end
+  end
+end

data/lib/protobuf/rpc/application_service.rb

@@ -0,0 +1,12 @@
+require 'protobuf/rpc/service'
+
+module Protobuf
+  module Rpc
+    # Base class for application services, like `ApplicationController`.
+    # Filters and `rescue_from` handlers defined here pass to every subclass.
+    # Generate services with `PB_SERVICE_PARENT=::Protobuf::Rpc::ApplicationService`
+    # to inherit from it.
+    class ApplicationService < Service
+    end
+  end
+end