gritz-core 0.4.0 → 0.6.0

data/lib/gritz/supervisor/launcher.rb

@@ -49,7 +49,7 @@ module Gritz
           end
           update_lifecycle
           @admin&.poll
-          @observer&.write(status)
+          @observer&.write { status }
           @observer&.flush
           break if @stopping && @generations.empty?
 
@@ -138,6 +138,10 @@ module Gritz
       def configure_generation(generation, metadata)
         return if generation.metadata || @stopping
 
+        if metadata[:listener_strategy] && !%w[reuseport inherited_fd].include?(metadata[:listener_strategy])
+          raise ConfigurationError, "Invalid master listener_strategy"
+        end
+
         %i[admin_bind bind pid_file].each do |field|
           raise ConfigurationError, "Missing master #{field}" unless metadata[field].is_a?(String)
         end
@@ -149,7 +153,7 @@ module Gritz
           raise ConfigurationError, "Invalid master #{field}" unless value.is_a?(Numeric) && value.finite? && value >= 0
         end
         if @metadata
-          %i[admin_bind bind pid_file].each do |field|
+          %i[admin_bind bind pid_file listener_strategy].each do |field|
             raise ConfigurationError, "USR2 cannot change #{field}" unless metadata[field] == @metadata[field]
           end
         else
@@ -160,6 +164,10 @@ module Gritz
         end
         generation.metadata = metadata
         generation.deadline = [generation.deadline, monotonic + metadata[:reexec_timeout]].min
+        if metadata[:listener_strategy] == "inherited_fd"
+          @listener ||= Listener.bind(metadata[:bind])
+          generation.channel.io.send_io(@listener)
+        end
       end
 
       def ready_workers(generation)
@@ -188,7 +196,7 @@ module Gritz
           return
         end
 
-        if @active.metadata[:bind].end_with?(":0")
+        if @active.metadata[:bind].end_with?(":0") && !@listener
           @reexec = { state: "failed", error: "USR2 requires a fixed RPC port" }
           @logger.warn(@reexec[:error])
           return
@@ -371,6 +379,7 @@ module Gritz
         @admin&.close
         @observer&.close
         @signals&.close
+        @listener&.close
         if @written_pid && File.file?(@pid_path) && File.read(@pid_path).strip == @written_pid.to_s
           File.unlink(@pid_path)
         end

data/lib/gritz/supervisor/listener.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Gritz
+  module Supervisor
+    # Creates a plain TCP listener without initializing a transport or scheduler.
+    # @api private
+    module Listener
+      def self.bind(address, reuseport: false)
+        host, _, port = address.rpartition(":")
+        info = Addrinfo.tcp(host.delete_prefix("[").delete_suffix("]"), Integer(port))
+        socket = Socket.new(info.afamily, Socket::SOCK_STREAM)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1) if reuseport
+        socket.bind(info)
+        socket.listen(Socket::SOMAXCONN)
+        socket
+      rescue StandardError
+        socket&.close
+        raise
+      end
+    end
+  end
+end

data/lib/gritz/supervisor/master.rb

@@ -10,12 +10,13 @@ module Gritz
       SIGNALS = %w[TERM INT QUIT TTIN TTOU HUP CHLD USR1 USR2].freeze
       attr_reader :workers
 
-      def initialize(config, logger: Logger.new($stdout), status_io: nil, owner_channel: nil)
+      def initialize(config, logger: Logger.new($stdout), status_io: nil, owner_channel: nil, listener: nil)
         @config = config
         @logger = logger
         @workers = {}
         @desired = config.workers
         @owner_channel = owner_channel
+        @listener = listener
         @reports = owner_channel || (StatusChannel.new(status_io) if status_io)
         @metrics = Metrics::Aggregator.new
         @forwarded = []
@@ -27,7 +28,8 @@ module Gritz
         @config.validate_runtime!
         raise ConfigurationError, "Supervisor requires workers > 0" unless @desired.positive?
 
-        require "gritz/native"
+        require "gritz/#{@config.transport}"
+        @listener ||= Listener.bind(@config.bind) if @config.listener_strategy == :inherited_fd
         @signals = SignalQueue.new(signals: SIGNALS)
         unless @owner_channel
           @admin = AdminServer.new(bind: @config.admin_bind, status: -> { status }, ready: -> { ready? },
@@ -36,7 +38,7 @@ module Gritz
         @guard = ForkGuard.activate(mode: @config.fork_mode == :clean ? @config.fork_guard : :off, logger: @logger)
         @config.preload! if @config.preload_app?
         Process.warmup if @config.preload_app? && Process.respond_to?(:warmup)
-        if @config.workers > 1 && !RUBY_PLATFORM.include?("linux")
+        if @config.transport == :native && @config.workers > 1 && !RUBY_PLATFORM.include?("linux")
           @logger.warn("Multiple native workers require Linux for SO_REUSEPORT load balancing; use workers 0 on macOS")
         end
         maintain_worker_count
@@ -50,7 +52,10 @@ module Gritz
           advance_replacement
           maintain_worker_count unless @shutdown_at
           flush_forwarded
-          @reports&.write(@owner_channel ? status.merge(type: "status") : status) if @forwarded.empty?
+          if @reports && @forwarded.empty? && (!@next_report_at || now >= @next_report_at || @shutdown_at) &&
+             @reports.write { @owner_channel ? status.merge(type: "status") : status }
+            @next_report_at = now + @config.status_interval
+          end
           @admin&.poll
           if @owner_channel&.closed?
             @exit_status = 1
@@ -115,7 +120,7 @@ module Gritz
             @admin&.close
             @workers.each_value(&:close)
             Transport::Native.postfork_child if experimental
-            exit_status = Worker::Runner.new(index: index, status_io: writer, config: @config, logger: @logger).run
+            exit_status = Worker::Runner.new(index: index, status_io: writer, config: @config, logger: @logger, listener: @listener).run
           rescue StandardError, LoadError, SyntaxError, SystemExit => e
             @logger.error("Worker #{index} failed: #{e.full_message}")
             exit_status = 1
@@ -132,6 +137,7 @@ module Gritz
         handle = WorkerHandle.new(pid: pid, index: index, status_io: reader)
         handle.recycle_factor = 1.0 + (rand * @config.worker_recycle.fetch(:jitter, 0.0))
         @workers[pid] = handle
+        @next_report_at = nil
         @logger.info("Worker #{index} spawned pid=#{pid}")
         handle
       rescue StandardError
@@ -159,7 +165,9 @@ module Gritz
             end
             next
           end
+          changed = handle.state != message[:state] || (message.key?(:healthy) && handle.stats[:healthy] != message[:healthy])
           handle.update(message, now: now)
+          @next_report_at = nil if changed
           if message[:state] == "failed" && !@ever_ready
             @exit_status = 1
             begin_shutdown
@@ -207,6 +215,7 @@ module Gritz
             break if handle.channel.closed?
           end
           @workers.delete(pid)
+          @next_report_at = nil
           @metrics.forget(handle)
           handle.close
           child_status = result.last
@@ -223,17 +232,19 @@ module Gritz
           break unless @forwarded.empty?
         rescue Errno::ECHILD
           @workers.delete(pid)&.close
+          @next_report_at = nil
         end
       end
 
       def handle_signal(signal)
+        @next_report_at = nil
         case signal
         when "TERM", "INT" then begin_shutdown
         when "QUIT" then begin_shutdown(immediate: true)
         when "TTIN"
           if @replacement || !@replacement_queue.empty?
             @logger.warn("Wait for phased restart before resizing workers")
-          elsif !@shutdown_at && @config.bind.end_with?(":0")
+          elsif !@shutdown_at && @config.bind.end_with?(":0") && !@listener
             @logger.warn("Cannot add a reuseport worker with port 0; configure a fixed bind port")
           elsif !@shutdown_at
             @desired += 1
@@ -284,7 +295,7 @@ module Gritz
       end
 
       def fixed_port?
-        return true unless @config.bind.end_with?(":0")
+        return true if @listener || !@config.bind.end_with?(":0")
 
         @logger.warn("Worker replacement requires a fixed bind port")
         false
@@ -301,6 +312,7 @@ module Gritz
             kill(fresh) if fresh
             @logger.warn("Replacement failed; keeping previous workers")
             @replacement = nil
+            @next_report_at = nil
             @replacement_queue.clear
             @recycle_retry_at = now + @config.worker_boot_timeout
             return true
@@ -314,6 +326,7 @@ module Gritz
           return if old || !@replacement[:retired]
 
           @replacement = nil
+          @next_report_at = nil
         end
         while (entry = @replacement_queue.shift)
           old_pid, reason = entry
@@ -329,7 +342,7 @@ module Gritz
       def check_recycle
         return if @shutdown_at || @replacement || !@replacement_queue.empty? || @config.worker_recycle.empty?
         return if @recycle_retry_at && now < @recycle_retry_at
-        return if @config.bind.end_with?(":0")
+        return if @config.bind.end_with?(":0") && !@listener
 
         @workers.each_value do |handle|
           next unless handle.state == "ready" && !handle.term_at
@@ -418,6 +431,7 @@ module Gritz
         @workers.clear
         @signals&.close
         @admin&.close
+        @listener&.close
         flush_forwarded
         @reports&.close
       end

data/lib/gritz/supervisor/signal_queue.rb

@@ -10,6 +10,7 @@ module Gritz
       def initialize(signals:)
         @io, @writer = IO.pipe
         @pending = []
+        @read_buffer = +""
         @previous = {}
         signals.each do |name|
           @previous[name] = Signal.trap(name) do
@@ -26,7 +27,7 @@ module Gritz
 
       def drain
         loop do
-          break unless @io.read_nonblock(4096, exception: false).is_a?(String)
+          break unless @io.read_nonblock(4096, @read_buffer, exception: false).is_a?(String)
         end
         # Swap instead of clearing: a signal arriving here belongs to the next drain.
         pending = @pending

data/lib/gritz/supervisor/status_channel.rb

@@ -16,14 +16,16 @@ module Gritz
       def initialize(io)
         @io = io
         @buffer = +""
+        @read_buffer = +""
         @pending = +""
         @discarding = false
         @closed = io.closed?
       end
 
-      def write(status)
+      def write(status = nil)
         return false if closed? || flush_pending.positive?
 
+        status = yield if block_given?
         line = "#{JSON.generate(status)}\n"
         return false if line.bytesize > MAX_LINE_BYTES
 
@@ -54,7 +56,7 @@ module Gritz
 
         remaining = max_bytes
         while remaining.positive?
-          chunk = @io.read_nonblock([4096, remaining].min, exception: false)
+          chunk = @io.read_nonblock([4096, remaining].min, @read_buffer, exception: false)
           break if chunk == :wait_readable
 
           if chunk.nil?

data/lib/gritz/testing/server.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Gritz
+  module Testing
+    # Starts a single-process server for integration tests.
+    # @api public
+    class Server
+      attr_reader :port, :address, :transport
+
+      def self.start(config = nil, controllers: nil, middleware: nil, logger: Logger.new(File::NULL))
+        config ||= Configuration.new.tap do |settings|
+          settings.workers = 0
+          settings.bind = "127.0.0.1:0"
+        end
+        config.controllers = controllers if controllers
+        config.middleware = middleware if middleware
+        server = new(config, logger:).start
+        return server unless block_given?
+
+        begin
+          yield server
+        ensure
+          server.stop
+        end
+      end
+
+      def initialize(config, logger:)
+        @config = config
+        @logger = logger
+        config.validate_single_process!
+      end
+
+      def start
+        raise ArgumentError, "Testing::Server is already started or stopped" if @started || @stopped
+
+        @started = true
+        begin
+          @config.preload! if @config.preload_app?
+          router = Router.new(controllers: @config.controllers, strict: @config.strict_routes, logger: @logger)
+          @lifecycle_started = true
+          @config.run_hooks(:on_worker_boot, 0)
+          @recorder = @config.metrics_recorder_factory&.call(worker: 0)
+          dispatcher = Dispatcher.new(router:, middleware: @config.middleware, logger: @logger, metrics: @recorder)
+          @transport = Transport.const_get(@config.transport.to_s.capitalize).new(config: @config, dispatcher:, logger: @logger)
+          @port = transport.bind
+          @address = @config.bind.sub(/:\d+\z/, ":#{port}")
+          transport.start
+          unless @config.health_checks.empty?
+            @health_stop = Queue.new
+            @health_thread = Thread.new do
+              transport.refresh_health until @health_stop.pop(timeout: @config.status_interval)
+            end
+          end
+          self
+        rescue StandardError
+          stop
+          raise
+        end
+      end
+
+      def stop
+        return if @stopped
+
+        @stopped = true
+        deadline = monotonic + @config.shutdown_timeout
+        begin
+          @health_stop&.push(true)
+          if @health_thread && !@health_thread.join([deadline - monotonic, 0].max)
+            @health_thread.kill.join
+          end
+          transport&.stop(deadline: Time.now + [deadline - monotonic, 0].max)
+        ensure
+          begin
+            @config.run_hooks(:on_worker_shutdown, 0) if @lifecycle_started
+          ensure
+            begin
+              @recorder&.observe_rejected(transport.stats.fetch(:rejected_total, 0)) if transport
+              @recorder&.observe_worker({ pid: Process.pid, index: 0, state: "stopped" })
+            ensure
+              @recorder&.close(timeout: [deadline - monotonic, 0].max)
+            end
+          end
+        end
+      end
+
+      private
+
+      def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/gritz/testing/transport_contract.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require "rspec/core"
+require "rspec/expectations"
+require "grpc"
+require "google/rpc/status_pb"
+require "google/rpc/error_details_pb"
+require "gritz/testing/server"
+
+module Gritz
+  module Testing
+    # Shared wire tests using the official gRPC client as an independent oracle.
+    # Include with adapter:, service:, stub:, request:, reply: for a four-method fixture.
+    # Explicitly requiring this helper needs RSpec and grpc as test dependencies.
+    # @api public
+    module TransportContract
+    end
+  end
+end
+
+RSpec.shared_examples Gritz::Testing::TransportContract do |adapter:, service:, stub:, request:, reply:|
+  let(:contract_request) { request }
+  let(:contract_reply) { reply }
+
+  define_method(:contract_controller) do |&block|
+    response = reply
+    Class.new(Gritz::Controller) do
+      bind service
+      define_method(:say_hello) { response.new(message: self.request.message.name) }
+      define_method(:list_greetings) { 3.times { |i| stream.write(response.new(message: "#{self.request.message.name}:#{i}")) } }
+      define_method(:record_names) { response.new(count: self.request.each_message.count) }
+      define_method(:chat) { self.request.each_message { |msg| stream.write(response.new(message: msg.name)) } }
+      class_eval(&block) if block
+    end
+  end
+
+  define_method(:with_contract_server) do |controller = contract_controller, **settings, &block|
+    config = Gritz::Configuration.new
+    config.transport = adapter
+    config.listener_strategy = adapter == :async ? :inherited_fd : :reuseport
+    config.bind = "127.0.0.1:0"
+    settings.each { |key, value| config.public_send("#{key}=", value) }
+    Gritz::Testing::Server.start(config, controllers: [controller]) do |server|
+      client = stub.new(server.address, :this_channel_is_insecure)
+      block.call(client, server)
+    end
+  end
+
+  it "preserves unary protobuf messages" do
+    with_contract_server { |client| expect(client.say_hello(contract_request.new(name: "Ruby")).message).to eq("Ruby") }
+  end
+
+  it "preserves ordered server streaming messages" do
+    with_contract_server do |client|
+      expect(client.list_greetings(contract_request.new(name: "x")).map(&:message)).to eq(%w[x:0 x:1 x:2])
+    end
+  end
+
+  it "reads client streams through half-close" do
+    with_contract_server do |client|
+      expect(client.record_names(%w[a b c].map { |name| contract_request.new(name:) }).count).to eq(3)
+    end
+  end
+
+  it "replies to bidi input before the client half-closes" do
+    gate = Queue.new
+    requests = Enumerator.new do |output|
+      output << contract_request.new(name: "first")
+      gate.pop
+      output << contract_request.new(name: "second")
+    end
+    with_contract_server do |client|
+      responses = client.chat(requests, deadline: Time.now + 5)
+      expect(responses.next.message).to eq("first")
+      gate << true
+      expect(responses.next.message).to eq("second")
+      expect { responses.next }.to raise_error(StopIteration)
+    end
+  ensure
+    gate << true
+  end
+
+  it "sends streaming output before the controller returns" do
+    gate = Queue.new
+    response = contract_reply
+    controller = contract_controller do
+      define_method(:list_greetings) do
+        stream.write(response.new(message: "first"))
+        gate.pop
+        stream.write(response.new(message: "second"))
+      end
+    end
+    with_contract_server(controller) do |client|
+      responses = client.list_greetings(contract_request.new, deadline: Time.now + 5)
+      expect(responses.next.message).to eq("first")
+      gate << true
+      expect(responses.next.message).to eq("second")
+      expect { responses.next }.to raise_error(StopIteration)
+    end
+  ensure
+    gate << true
+  end
+
+  it "passes binary metadata, deadline and peer, with separate headers and trailers" do
+    observations = Queue.new
+    response = contract_reply
+    controller = contract_controller do
+      define_method(:say_hello) do
+        observations << [context.metadata, context.deadline, context.peer, context.peer_identity]
+        context.call.send_initial_metadata("answer" => "initial", "reply-bin" => "\x00\xff".b, "repeat-bin" => ["a".b, "b".b])
+        context.call.trailing_metadata["answer"] = "trailing"
+        context.call.trailing_metadata["trailer-bin"] = "\x00\xfe".b
+        response.new(message: context.request_id)
+      end
+    end
+    with_contract_server(controller) do |client|
+      deadline = Time.now + 5
+      operation = client.say_hello(contract_request.new, return_op: true, deadline:,
+                                                         metadata: { "x-request-id" => "req-1", "request-bin" => "\x00\xfd".b, "repeat" => %w[a b] })
+      expect(operation.execute.message).to eq("req-1")
+      expect(operation.metadata).to include("answer" => "initial", "reply-bin" => "\x00\xff".b, "x-request-id" => "req-1")
+      expect(operation.trailing_metadata).to include("answer" => "trailing", "trailer-bin" => "\x00\xfe".b)
+      expect(operation.metadata["repeat-bin"]).to eq(%w[a b])
+      metadata, actual_deadline, peer, identity = observations.pop(timeout: 2)
+      expect(metadata).to include("request-bin" => "\x00\xfd".b)
+      expect(metadata["repeat"]).to eq(%w[a b])
+      expect(actual_deadline).to be_within(0.1).of(deadline)
+      expect(peer).to match(/ipv[46]:/)
+      expect(identity).to be_nil
+    end
+  end
+
+  it "encodes application status, metadata and rich protobuf details" do
+    controller = contract_controller do
+      def say_hello
+        fail!(:not_found, "missing", metadata: { "lookup" => "failed" },
+                                     details: [Google::Rpc::ResourceInfo.new(resource_type: "name", resource_name: "Ruby")])
+      end
+    end
+    with_contract_server(controller) do |client|
+      expect { client.say_hello(contract_request.new) }.to raise_error(GRPC::NotFound) do |error|
+        expect(error.details).to eq("missing")
+        expect(error.metadata).to include("lookup" => "failed")
+        status = Google::Rpc::Status.decode(error.metadata.fetch("grpc-status-details-bin"))
+        expect([status.code, status.message]).to eq([5, "missing"])
+        expect(status.details.first.unpack(Google::Rpc::ResourceInfo).resource_name).to eq("Ruby")
+      end
+    end
+  end
+
+  it "preserves a non-OK status after streamed messages" do
+    response = contract_reply
+    controller = contract_controller do
+      define_method(:list_greetings) do
+        stream.write(response.new(message: "first"))
+        fail!(:permission_denied, "revoked", metadata: { "reason" => "revoked" })
+      end
+    end
+    with_contract_server(controller) do |client|
+      responses = client.list_greetings(contract_request.new)
+      expect(responses.next.message).to eq("first")
+      expect { responses.next }.to raise_error(GRPC::PermissionDenied) do |error|
+        expect(error.metadata).to include("reason" => "revoked")
+      end
+    end
+  end
+
+  it "hides internal exception messages" do
+    controller = contract_controller { def say_hello = raise("database secret") }
+    with_contract_server(controller) do |client|
+      expect { client.say_hello(contract_request.new) }.to raise_error(GRPC::Internal) do |error|
+        expect(error.details).not_to include("database secret")
+        expect(error.metadata).to have_key("error-id")
+      end
+    end
+  end
+
+  it "rejects an unimplemented controller action" do
+    controller = Class.new(Gritz::Controller) { bind service }
+    with_contract_server(controller) do |client|
+      expect { client.say_hello(contract_request.new) }.to raise_error(GRPC::Unimplemented)
+    end
+  end
+
+  it "honors an active call deadline" do
+    controller = contract_controller { def say_hello = sleep(1) }
+    with_contract_server(controller) do |client|
+      expect { client.say_hello(contract_request.new, deadline: Time.now + 0.05) }.to raise_error(GRPC::DeadlineExceeded)
+    end
+  end
+
+  it "returns CANCELLED when the client cancels an active call" do
+    entered = Queue.new
+    gate = Queue.new
+    controller = contract_controller do
+      define_method(:say_hello) do
+        entered << true
+        gate.pop
+        fail!(:cancelled, "cancelled")
+      end
+    end
+    with_contract_server(controller) do |client|
+      operation = client.say_hello(contract_request.new, return_op: true, deadline: Time.now + 5)
+      caller = Thread.new do
+        operation.execute
+      rescue GRPC::BadStatus => e
+        e
+      end
+      expect(entered.pop(timeout: 2)).to be(true)
+      operation.cancel
+      expect(caller.join(2)).not_to be_nil
+      expect(caller.value).to be_a(GRPC::Cancelled)
+      gate << true
+    ensure
+      gate << true
+      operation&.cancel
+      caller&.join(5)
+    end
+  end
+
+  it "finishes an in-flight response during graceful shutdown" do
+    entered = Queue.new
+    gate = Queue.new
+    response = contract_reply
+    controller = contract_controller do
+      define_method(:say_hello) do
+        entered << true
+        gate.pop
+        response.new(message: "completed")
+      end
+    end
+    with_contract_server(controller) do |client, server|
+      caller = Thread.new { client.say_hello(contract_request.new, deadline: Time.now + 5) }
+      expect(entered.pop(timeout: 2)).to be(true)
+      stopper = Thread.new { server.transport.stop(deadline: Time.now + 3) }
+      sleep 0.02 # Let shutdown enter its drain phase while the application remains blocked.
+      gate << true
+      expect(caller.value.message).to eq("completed")
+      expect(stopper.join(4)).not_to be_nil
+      expect(server.transport.stats).to include(inflight: 0)
+    ensure
+      gate << true
+      caller&.join(5)
+      stopper&.join(5)
+    end
+  end
+
+  it "enforces the shutdown deadline on a blocked controller" do
+    entered = Queue.new
+    controller = contract_controller do
+      define_method(:say_hello) do
+        entered << true
+        Queue.new.pop
+      end
+    end
+    with_contract_server(controller) do |client, server|
+      caller = Thread.new do
+        client.say_hello(contract_request.new, deadline: Time.now + 5)
+      rescue GRPC::BadStatus => e
+        e
+      end
+      expect(entered.pop(timeout: 2)).to be(true)
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      server.transport.stop(deadline: Time.now + 0.05)
+      expect(Process.clock_gettime(Process::CLOCK_MONOTONIC) - started).to be < 1
+      expect(caller.join(2)).not_to be_nil
+      expect(caller.value).to be_a(GRPC::BadStatus)
+      expect(server.transport.running?).to be(false)
+    end
+  end
+end

data/lib/gritz/worker/runner.rb

@@ -7,11 +7,12 @@ module Gritz
     # Owns transport resources and heartbeats in one serving process.
     # @api private
     class Runner
-      def initialize(index:, config:, logger:, status_io: nil, owner_channel: nil)
+      def initialize(index:, config:, logger:, status_io: nil, owner_channel: nil, listener: nil)
         @index = index
         @config = config
         @logger = logger
         @owner_channel = owner_channel
+        @listener = listener
         @status = owner_channel || (Supervisor::StatusChannel.new(status_io) if status_io)
         @recorder = Metrics::Recorder.new
         @metrics = Metrics::Aggregator.new
@@ -24,7 +25,7 @@ module Gritz
         begin
           @signals = Supervisor::SignalQueue.new(signals: %w[TERM INT QUIT HUP USR1 USR2])
           report("booting")
-          require "gritz/native"
+          require "gritz/#{@config.transport}"
           @boot_started = true
           @config.preload! unless @config.preload_app?
           @config.run_hooks(:on_worker_boot, @index)
@@ -32,8 +33,8 @@ module Gritz
           router = Router.new(controllers: @config.controllers, strict: @config.strict_routes, logger: @logger)
           dispatcher = Dispatcher.new(router:, middleware: @config.middleware, logger: @logger, metrics: @recorder,
                                       worker: @index, log_format: @config.log_format, log_redact: @config.log_redact)
-          @adapter = Transport::Native.new(config: @config, dispatcher:, logger: @logger)
-          @port = @adapter.bind(@config.bind)
+          @adapter = Transport.const_get(@config.transport.to_s.capitalize).new(config: @config, dispatcher:, logger: @logger)
+          @port = @adapter.bind(@listener || @config.bind)
           @adapter.start
           unless @status
             @admin = Supervisor::AdminServer.new(bind: @config.admin_bind, status: -> { snapshot }, ready: -> { ready? },
@@ -95,7 +96,7 @@ module Gritz
           if @pending_reexec && @owner_channel.write(type: "reexec", pid: Process.pid)
             @pending_reexec = false
           end
-          publish_metrics
+          publish_metrics if @pending_delta || now >= next_status
           @admin&.poll
           if now >= next_status
             report(@draining ? "draining" : "ready")