tonic-rails 0.4.0 → 0.6.0

data/lib/tonic/rails/instrumentation.rb

@@ -24,17 +24,32 @@ module Tonic
     module Instrumentation
       EVENT = "process_rpc.tonic_rails"
 
+      # Outgoing calls made with Tonic::Rails::Client publish
+      # "request_rpc.tonic_rails", with the same payload plus :address,
+      # the server called.
+      REQUEST_EVENT = "request_rpc.tonic_rails"
+
       module_function
 
       # @api private
-      def instrument(path, metadata)
+      def instrument(path, metadata, &)
+        publish(EVENT, path, metadata, &)
+      end
+
+      # @api private
+      def instrument_request(path, address, metadata, &)
+        publish(REQUEST_EVENT, path, metadata, address: address, &)
+      end
+
+      # @api private
+      def publish(event, path, metadata, **extra)
         # Without subscribers, skip building the payload: this runs on
         # every RPC.
-        return yield unless ActiveSupport::Notifications.notifier.listening?(EVENT)
+        return yield unless ActiveSupport::Notifications.notifier.listening?(event)
 
         service, rpc = path.delete_prefix("/").split("/", 2)
-        payload = { path: path, service: service, rpc: rpc, metadata: metadata, code: nil, status: nil }
-        ActiveSupport::Notifications.instrument(EVENT, payload) do
+        payload = { path: path, service: service, rpc: rpc, metadata: metadata, code: nil, status: nil, **extra }
+        ActiveSupport::Notifications.instrument(event, payload) do
           result = yield
           payload[:code] = 0
           payload[:status] = :ok

data/lib/tonic/rails/railtie.rb

@@ -31,6 +31,11 @@ module Tonic
         # tasks, or test runs.  With Puma, prefer `plugin :tonic_rails`
         # (lib/puma/plugin/tonic_rails.rb), which also covers cluster mode.
         if configuration.auto_start && defined?(::Rails::Server)
+          if configuration.multi_process?
+            raise Error, "auto_start can't run multiple processes (processes = #{configuration.processes}); " \
+                         "use `plugin :tonic_rails` in config/puma.rb or `bin/rails tonic_rails:serve`"
+          end
+
           server = Tonic::Rails.server
           thread = Thread.new do
             Thread.current.name = "tonic-rails"

data/lib/tonic/rails/rpc_error.rb

@@ -19,6 +19,8 @@ module Tonic
     # The message, metadata and details go to the client, so keep internal
     # details out of them.  Any other exception becomes INTERNAL with a
     # generic message and is logged server-side.
+    #
+    # Tonic::Rails::Client raises it too, for calls that fail.
     class RpcError < Error
       CODES = {
         ok: 0,
@@ -114,6 +116,65 @@ module Tonic
         CODE_NAMES.fetch(@code)
       end
 
+      # Unpacks the details of an encoded google.rpc.Status (from the
+      # grpc-status-details-bin trailer).  Details whose message type is
+      # loaded come back as that message; others stay Google::Protobuf::Any.
+      # @api private
+      # @return [Array<Google::Protobuf::AbstractMessage>]
+      def self.decode_details(bytes)
+        return [] if bytes.nil? || bytes.empty?
+
+        require "google/protobuf/well_known_types"
+        details = []
+        each_length_delimited_field(bytes.b) do |field, value|
+          details << unpack_detail(Google::Protobuf::Any.decode(value)) if field == 3
+        end
+        details
+      rescue Google::Protobuf::ParseError, ArgumentError
+        []
+      end
+
+      # Yields (field number, bytes) for each length-delimited field,
+      # skipping varints; raises ArgumentError on anything malformed.
+      def self.each_length_delimited_field(buf)
+        pos = 0
+        while pos < buf.bytesize
+          key, pos = read_varint(buf, pos)
+          case key & 7
+          when 0 then _, pos = read_varint(buf, pos)
+          when 2
+            length, pos = read_varint(buf, pos)
+            raise ArgumentError, "truncated google.rpc.Status" if pos + length > buf.bytesize
+
+            yield key >> 3, buf.byteslice(pos, length)
+            pos += length
+          else raise ArgumentError, "unexpected wire type in google.rpc.Status"
+          end
+        end
+      end
+      private_class_method :each_length_delimited_field
+
+      def self.read_varint(buf, pos)
+        value = 0
+        shift = 0
+        loop do
+          byte = buf.getbyte(pos) or raise ArgumentError, "truncated varint"
+          pos += 1
+          value |= (byte & 0x7f) << shift
+          return [value, pos] if byte < 0x80
+
+          shift += 7
+          raise ArgumentError, "varint too long" if shift > 63
+        end
+      end
+      private_class_method :read_varint
+
+      def self.unpack_detail(any)
+        type = Google::Protobuf::DescriptorPool.generated_pool.lookup(any.type_name)
+        type.is_a?(Google::Protobuf::Descriptor) ? any.unpack(type.msgclass) : any
+      end
+      private_class_method :unpack_detail
+
       # @api private
       def self.normalize_code(code)
         case code

data/lib/tonic/rails/server.rb

@@ -36,8 +36,9 @@ module Tonic
       # Start serving and block until stopped.
       # @param install_signal_handlers [Boolean] trap TERM and INT to stop.
       #   Pass false when embedding in a process that owns its signals.
-      # @yield once the server is accepting connections
-      def start(install_signal_handlers: true)
+      # @yield once the server is accepting connections (with
+      #   `processes > 1`, once every worker is)
+      def start(install_signal_handlers: true, &)
         @lock.synchronize do
           raise Error, "server is already running" unless @state == :stopped
 
@@ -50,40 +51,31 @@ module Tonic
 
           @configuration.validate!
           Tonic::Rails.native_extension!
-          Tonic::Rails._set_shutting_down(false)
           # A Queue rather than a self-pipe: pushing to it is safe from trap
           # handlers, and unlike pipes it can be waited on with a timeout
           # on every platform (Windows select() only handles sockets).
           @stop_signal = Thread::Queue.new
           stop if @stop_requested # requested while we were starting up
-          @native = build_native_server
-          @native.start_server
-          log_pump = spawn_log_pump
-          @health.attach(@native)
-          @state = :running
-
-          request_log = subscribe_request_logger
-          previous_handlers = install_signal_handlers ? trap_signals : {}
-          workers = Array.new(@configuration.dispatch_threads) { |i| spawn_worker(i) }
-          log_startup
-          yield self if block_given?
-
-          wait_for_stop(workers)
-          @health.detach
-          shutdown(workers)
+          if @configuration.multi_process?
+            run_cluster(install_signal_handlers, &)
+          else
+            serve(install_signal_handlers: install_signal_handlers, &)
+          end
         ensure
-          ActiveSupport::Notifications.unsubscribe(request_log) if request_log
-          previous_handlers&.each { |signal, handler| Signal.trap(signal, handler || "DEFAULT") }
-          @health.detach
-          @native&.stop_server
-          stop_log_pump(log_pump)
-          @native = nil
           @stop_signal = nil
-          Tonic::Rails._set_shutting_down(false)
           @state = :stopped
         end
       end
 
+      # @api private
+      # The body of a worker process in multi-process mode (see Cluster):
+      # serve on the listening socket the parent bound.
+      def run_worker(listener, index, &)
+        @worker_index = index
+        @configuration.on_worker_boot&.call(index)
+        serve(install_signal_handlers: true, listener: listener, &)
+      end
+
       # Request a graceful stop.  Safe to call from signal handlers and
       # other threads; returns immediately.
       def stop
@@ -125,6 +117,55 @@ module Tonic
 
       private
 
+      def run_cluster(install_signal_handlers)
+        @state = :running
+        Cluster.new(self, @configuration, @stop_signal).run(install_signal_handlers: install_signal_handlers) do
+          log_startup
+          yield self if block_given?
+        end
+      end
+
+      def serve(install_signal_handlers:, listener: nil)
+        Tonic::Rails._set_shutting_down(false)
+        @native = build_native_server
+        @native.set_listener_fd(listener.fileno) if listener
+        @native.start_server
+        # The transport holds its own copy now; let go of ours, so the
+        # socket closes once every worker has stopped accepting.
+        listener&.close
+        log_pump = spawn_log_pump
+        @health.attach(@native)
+        @state = :running
+
+        request_log = subscribe_request_logger
+        previous_handlers = install_signal_handlers ? trap_signals : {}
+        workers = Array.new(@configuration.dispatch_threads) { |i| spawn_worker(i) }
+        log_startup unless worker?
+        yield self if block_given?
+
+        wait_for_stop(workers)
+        @health.detach
+        shutdown(workers)
+      ensure
+        ActiveSupport::Notifications.unsubscribe(request_log) if request_log
+        previous_handlers&.each { |signal, handler| Signal.trap(signal, handler || "DEFAULT") }
+        @health.detach
+        @native&.stop_server
+        stop_log_pump(log_pump)
+        @native = nil
+        Tonic::Rails._set_shutting_down(false)
+      end
+
+      # True in a worker process of a multi-process server, whose parent
+      # logs startup and shutdown for all of them.
+      def worker?
+        !@worker_index.nil?
+      end
+
+      def worker_label
+        worker? ? "worker #{@worker_index}: " : ""
+      end
+
       def build_native_server
         config = @configuration
         native = TonicRails::Native::Server.new(config.bind_address, config.max_message_size)
@@ -267,13 +308,15 @@ module Tonic
 
       def shutdown(workers)
         logger = @configuration.logger
+        # In a worker, the parent logs shutdown once for all of them.
+        lifecycle = worker? ? nil : logger
         @state = :stopping
         Tonic::Rails._set_shutting_down(true)
-        logger&.info("tonic-rails: shutting down, draining for up to #{@configuration.drain_timeout}s")
+        lifecycle&.info("tonic-rails: shutting down, draining for up to #{@configuration.drain_timeout}s")
 
         @native.begin_shutdown
         unless @native.wait_for_drain(@configuration.drain_timeout.to_f)
-          logger&.warn("tonic-rails: drain timeout expired; closing remaining connections")
+          logger&.warn("tonic-rails: #{worker_label}drain timeout expired; closing remaining connections")
         end
         @native.stop_workers
         workers.each do |worker|
@@ -281,7 +324,7 @@ module Tonic
         rescue Exception # rubocop:disable Lint/RescueException
           # Already logged by the worker.
         end
-        logger&.info("tonic-rails: stopped")
+        lifecycle&.info("tonic-rails: stopped")
       end
 
       def log_grpc_web(logger, config)
@@ -306,10 +349,9 @@ module Tonic
         end
         logger.info("tonic-rails: reflection enabled") if config.reflection
         log_grpc_web(logger, config)
-        logger.info(
-          "tonic-rails: serving #{@router.service_names.join(', ')} on #{config.bind_address} " \
-          "(#{config.dispatch_threads} dispatch threads)",
-        )
+        threads = "#{config.dispatch_threads} dispatch threads"
+        threads = "#{config.processes} processes × #{threads} each" if config.multi_process?
+        logger.info("tonic-rails: serving #{@router.service_names.join(', ')} on #{config.bind_address} (#{threads})")
       end
     end
   end

data/lib/tonic/rails/version.rb

@@ -2,6 +2,6 @@
 
 module Tonic
   module Rails
-    VERSION = "0.4.0"
+    VERSION = "0.6.0"
   end
 end

data/lib/tonic-rails.rb

@@ -19,7 +19,9 @@ require "tonic/rails/instrumentation"
 require "tonic/rails/base"
 require "tonic/rails/health"
 require "tonic/rails/reflection"
+require "tonic/rails/cluster"
 require "tonic/rails/server"
+require "tonic/rails/client"
 
 module Tonic
   module Rails

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tonic-rails
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Matt Tanous
@@ -73,6 +73,7 @@ files:
 - ext/tonic_rails_native/Cargo.toml
 - ext/tonic_rails_native/extconf.rb
 - ext/tonic_rails_native/src/body.rs
+- ext/tonic_rails_native/src/client.rs
 - ext/tonic_rails_native/src/dispatch.rs
 - ext/tonic_rails_native/src/framing.rs
 - ext/tonic_rails_native/src/gvl.rs
@@ -90,6 +91,8 @@ files:
 - lib/puma/plugin/tonic_rails.rb
 - lib/tonic-rails.rb
 - lib/tonic/rails/base.rb
+- lib/tonic/rails/client.rb
+- lib/tonic/rails/cluster.rb
 - lib/tonic/rails/configuration.rb
 - lib/tonic/rails/health.rb
 - lib/tonic/rails/instrumentation.rb