gritz-core 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 023ead58f761660de79d7168434d85be2f92e583073fab043b18b18fd14035c5
-  data.tar.gz: f319a9c5f6a190fad09e78667072ee22a5994dfe1f5c2e4f12287f3213865e1a
+  metadata.gz: 600c0b33c1d7f7008866ee20d789504559715612886cd3f8dc33413e5192cb36
+  data.tar.gz: c3797690d572a4d29f5275946b16f84b5717fb19e4f31fd6a20217ece840eb92
 SHA512:
-  metadata.gz: d531f928a935dd66d9a3459919fff84263309e6821da90332a841170b1bc268e2ccc711394a5873590611883136d44987d0d059794520d1335d788ad37815660
-  data.tar.gz: '08b50b33dcbb22fdde34c4052f2c15e82cfb1562bc83f450966f98879e4f0d8bc64cf50f8bb3517fae12ebfe4ac4841928f5ab5f5032a96eabd006711f8e44dc'
+  metadata.gz: f2858b3d8e39c28d309a3acce2255fcc42ec4aba071b2b79735025a840973ffe0016183204eb7e87c67b1a14f11fef48ffa9e6560234cfd5da0866ccd195f68f
+  data.tar.gz: 149a97e113197dc7691152d5aa0f7e246adb55cc0bb90a699b122078ea3272cd32787461808b78d7379804c83a487866f503d8eea7f135a5c356c011e40a2209

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.4.0
+
+- Define lazy, fork-safe clients with process-local shared connections, per-call middleware, deadline propagation and selected request headers.
+- Treat unhandled downstream errors as safe `INTERNAL` responses by default; allow explicit status passthrough.
+- Support optional worker telemetry integrations with the remaining graceful shutdown budget.
+
+## 0.3.0
+
+- Replace workers one at a time with `USR1` and recycle them by request count, memory or lifetime.
+- Reload application code with `USR2`; retain the serving master if replacement startup fails, and update the PID file after readiness.
+- Keep admin probes and Prometheus totals available across worker and master replacement. Add application health checks and per-worker status.
+- Emit one structured completion log per RPC with JSON or logfmt output and credential redaction.
+
 ## 0.2.0
 
 - Supervise forked workers with boot and heartbeat timeouts, automatic replacement, graceful shutdown, lifecycle hooks, dynamic worker counts and log reopening.

data/README.md

@@ -10,6 +10,10 @@ Use [gritz](https://github.com/gritzrpc/gritz) for the default framework and exe
 
 Controller tests can load `gritz/testing/rspec` or `gritz/testing/minitest` and run without a network or the grpc gem. See the [controller examples](https://github.com/gritzrpc/gritz#controllers) and [configuration guide](docs/guides/configuration.md).
 
+Supervised servers support phased replacement, fresh-interpreter hot reexec, request/memory/lifetime recycling, Admin HTTP probes and process-wide Prometheus totals. The CLI keeps one lifecycle owner across master generations; application controllers and gRPC resources stay in serving processes.
+
+`Gritz::Client.define` creates lazy, fork-safe client constants with deadline propagation, selected request headers and middleware around complete streams. See the [client guide](docs/guides/clients.md). Optional [gritz-otel](https://github.com/gritzrpc/gritz-otel) adds server/client spans and worker OTLP metrics after fork.
+
 ## Development
 
 ```sh

data/lib/gritz/channel_registry.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Gritz
+  # Shares transport connections within a process, never across a fork.
+  # @api private
+  class ChannelRegistry
+    module ForkHook
+      def _fork(...)
+        result = super
+        Gritz::ChannelRegistry.reset! if result.zero?
+        result
+      end
+    end
+
+    class << self
+      def fetch(target:, credentials:, args: {}, pool: nil)
+        reset! unless @pid == Process.pid
+        key = [Process.pid, pool, snapshot(target), credentials, snapshot(args)].freeze
+        @lock.synchronize { @channels.fetch(key) { @channels[key] = yield } }
+      end
+
+      # In a child, discard references without calling native close methods.
+      def reset!
+        @lock = Mutex.new
+        @channels = {}
+        @pid = Process.pid
+      end
+
+      def snapshot(value)
+        case value
+        when String then value.dup.freeze
+        when Array then value.map { |entry| snapshot(entry) }.freeze
+        when Hash then value.to_h { |key, entry| [snapshot(key), snapshot(entry)] }.freeze
+        else value
+        end
+      end
+    end
+
+    reset!
+    Process.singleton_class.prepend(ForkHook) unless Process.singleton_class.ancestors.include?(ForkHook)
+  end
+end

data/lib/gritz/cli.rb

@@ -2,16 +2,31 @@
 
 require "optparse"
 require "logger"
+require "rbconfig"
+require "socket"
 
 module Gritz
   # Starts a server, lists routes, or checks configuration and fork safety.
   # @api public
   class CLI
-    def initialize(stdout: $stdout, stderr: $stderr, env: ENV, status_io: nil)
+    CHILD_BOOTSTRAP = <<~RUBY
+      require "socket"
+      fd = ENV.delete("GRITZ_INTERNAL_OWNER_FD")
+      exit Gritz::CLI.new(owner_io: UNIXSocket.for_fd(Integer(fd))).run(ARGV)
+    RUBY
+
+    def self.child_command(argv)
+      [RbConfig.ruby, "-I", $LOAD_PATH.join(File::PATH_SEPARATOR), "-rgritz/core", "-e", CHILD_BOOTSTRAP, "--", *argv]
+    end
+
+    def initialize(stdout: $stdout, stderr: $stderr, env: ENV, status_io: nil, owner_io: nil, launch: false, launch_command: nil)
       @stdout = stdout
       @stderr = stderr
       @env = env
       @status_io = status_io
+      @owner_channel = Supervisor::StatusChannel.new(owner_io) if owner_io
+      @launch = launch
+      @launch_command = launch_command
     end
 
     def run(argv)
@@ -39,12 +54,17 @@ module Gritz
       raise ConfigurationError, "Unknown command #{command}" unless %w[start routes check].include?(command)
       raise ConfigurationError, "Unexpected argument #{args.first}" unless args.empty?
 
+      logger = Logger.new(@stdout)
+      logger.formatter = ->(_severity, _time, _progname, message) { "#{message}\n" }
+      if command == "start" && @launch && !@owner_channel
+        return Supervisor::Launcher.new(command: @launch_command || self.class.child_command(argv), env: @env,
+                                        stdout: @stdout, stderr: @stderr, logger: logger, status_io: @status_io).run
+      end
+
       path ||= "config/gritz.rb" if File.file?("config/gritz.rb")
       guard = ForkGuard.activate(mode: :record) if command != "routes"
       require "gritz/native" if command != "routes"
       config = Configuration.load(path: path, env: @env, overrides: overrides)
-      logger = Logger.new(@stdout)
-      logger.formatter = ->(_severity, _time, _progname, message) { "#{message}\n" }
       if command == "check"
         config.preload! if config.preload_app?
         guard.violations.each { |violation| @stderr.puts(violation.message) }
@@ -61,11 +81,16 @@ module Gritz
           guard.violations.each { |violation| logger.warn(violation.message) } if config.fork_guard == :warn
         end
         @stdout.sync = true if @stdout.respond_to?(:sync=)
-        return Supervisor::Master.new(config, logger: logger, status_io: @status_io).run if config.workers.positive?
+        @owner_channel&.write(type: "configured", pid: Process.pid, workers: config.workers, bind: config.bind,
+                              admin_bind: config.admin_bind, min_ready_workers: config.min_ready_workers, pid_file: config.pid_file,
+                              reexec_timeout: config.reexec_timeout, drain_delay: config.drain_delay, shutdown_timeout: config.shutdown_timeout)
+        if config.workers.positive?
+          return Supervisor::Master.new(config, logger: logger, status_io: @status_io, owner_channel: @owner_channel).run
+        end
 
         ForkGuard.deactivate
         config.preload! if config.preload_app?
-        return Worker::Runner.new(index: 0, config: config, logger: logger).run
+        return Worker::Runner.new(index: 0, config: config, logger: logger, owner_channel: @owner_channel).run
       else
         config.preload! if config.preload_app?
         router = Router.new(controllers: config.controllers, strict: config.strict_routes, logger: logger)
@@ -81,6 +106,7 @@ module Gritz
       1
     ensure
       ForkGuard.deactivate if guard
+      @owner_channel&.close
     end
   end
 end

data/lib/gritz/client/call_context.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Gritz
+  class Client
+    # Middleware state for an outgoing RPC, independent of its transport.
+    # @api public
+    class CallContext
+      attr_reader :method, :kind, :options, :parent, :store, :logger
+      attr_accessor :request, :operation, :trace_context, :response_block
+
+      def initialize(method:, kind:, request:, options:, parent:, terminal:)
+        service, name = method.delete_prefix("/").split("/", 2)
+        @method = MethodDescriptor.new(service:, name:, input_type: nil, output_type: nil,
+                                       client_streaming: %i[client_streaming bidi].include?(kind),
+                                       server_streaming: %i[server_streaming bidi].include?(kind))
+        @kind = kind
+        @request = request
+        @options = options
+        @parent = parent
+        @terminal = terminal
+        @store = {}
+        @logger = parent&.logger || Logger.new($stderr)
+        @trace_context = parent&.trace_context
+      end
+
+      def metadata = options[:metadata]
+      def deadline = options[:deadline]
+      def remaining = deadline && [deadline - Time.now, 0.0].max
+      def request_id = metadata["x-request-id"]
+      def cancelled? = !!(store[:gritz_cancelled] || parent&.cancelled? || operation&.cancelled?)
+
+      def check_deadline!
+        raise Errors::DeadlineExceeded, "deadline exceeded" if deadline && remaining.zero?
+      end
+
+      def check_cancelled!
+        raise Errors::Cancelled, "request cancelled" if cancelled?
+      end
+
+      # Input streams stay lazy and retain the parent even on native writer threads.
+      # @api private
+      def each_request
+        Enumerator.new do |output|
+          Context.with(parent) do
+            request.each do |message|
+              check_deadline!
+              check_cancelled!
+              output << message
+            end
+          end
+        end
+      end
+
+      # @api private
+      def execute = @terminal.call(self, &response_block)
+    end
+  end
+end

data/lib/gritz/client/invocation.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Gritz
+  class Client
+    # Captures the deadline, parent context, and middleware for one outgoing RPC.
+    # @api private
+    class Invocation
+      attr_reader :options
+
+      def initialize(deadline: nil, safety_margin: 0.01, options: {}, parent: nil, middleware: nil)
+        validate_duration!(deadline, :deadline, positive: true) unless deadline.nil?
+        validate_duration!(safety_margin, :safety_margin, positive: false)
+        raise ArgumentError, "return_op is not supported by Gritz::Client" if options[:return_op]
+
+        @parent = parent
+        @options = options.dup
+        explicit = options[:deadline]
+        raise ArgumentError, "deadline must be an absolute Time" unless explicit.nil? || explicit.is_a?(Time)
+
+        now = Time.now
+        candidates = [explicit, deadline && (now + deadline), parent&.deadline && (parent.deadline - safety_margin)].compact
+        @options[:deadline] = candidates.min
+        @options[:metadata] = prepare_metadata(options.fetch(:metadata, {}))
+        check_parent!
+        raise Errors::DeadlineExceeded, "deadline exceeded" if @options[:deadline] && @options[:deadline] <= now
+
+        stack = Client.middleware.dup
+        stack.entries.concat(middleware.entries) if middleware
+        @app = stack.build(lambda(&:execute))
+      end
+
+      def call(terminal, method:, kind:, request:, options:, &block)
+        context = CallContext.new(method:, kind:, request:, options:, parent: @parent, terminal:)
+        if context.method.server_streaming? && !block
+          Enumerator.new { |output| run(context) { |reply| output << reply } }
+        else
+          run(context, &block)
+        end
+      end
+
+      private
+
+      def run(context, &block)
+        Context.with(@parent) do
+          context.check_deadline!
+          context.check_cancelled!
+          context.response_block = block
+          @app.call(context)
+        end
+      end
+
+      def check_parent!
+        raise Errors::Cancelled, "request cancelled" if @parent&.cancelled?
+      end
+
+      def prepare_metadata(metadata)
+        raise ArgumentError, "metadata must be a Hash" unless metadata.is_a?(Hash)
+
+        copied = metadata.to_h { |key, value| [key.to_s, copy_metadata_value(value)] }
+        copied["x-request-id"] ||= copy_metadata_value(@parent&.request_id) || SecureRandom.uuid
+        %w[traceparent tracestate].each do |key|
+          value = @parent&.metadata&.[](key)
+          copied[key] ||= copy_metadata_value(value) if value
+        end
+        copied
+      end
+
+      def copy_metadata_value(value)
+        case value
+        when Array then value.map { |item| item.is_a?(String) ? item.dup : item }
+        when String then value.dup
+        else value
+        end
+      end
+
+      def validate_duration!(value, name, positive:)
+        valid = value.is_a?(Numeric) && value.real? && value.finite? && (positive ? value.positive? : value >= 0)
+        raise ArgumentError, "#{name} must be a finite #{positive ? 'positive' : 'nonnegative'} number" unless valid
+      end
+    end
+  end
+end

data/lib/gritz/client.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Gritz
+  # Defines fork-safe singleton clients without constructing a native transport.
+  # @api public
+  class Client
+    class << self
+      attr_accessor :adapter
+
+      def middleware = @middleware ||= Middleware::Stack.new
+
+      def middleware=(stack)
+        raise ArgumentError, "middleware must be a Gritz::Middleware::Stack" unless stack.is_a?(Middleware::Stack)
+
+        @middleware = stack
+      end
+
+      def define(stub_class, target:, credentials: :insecure, channel_args: {}, deadline: nil,
+                 safety_margin: 0.01, service_config: nil, middleware: nil, adapter: nil)
+        unless stub_class.is_a?(Class) && !stub_class.public_instance_methods(false).empty?
+          raise ArgumentError, "stub_class must define RPC methods"
+        end
+        raise ArgumentError, "target must be a nonempty String" unless target.is_a?(String) && !target.strip.empty? && !target.include?("\0")
+        raise ArgumentError, "channel_args must be a Hash" unless channel_args.is_a?(Hash)
+
+        validate_time!(:deadline, deadline) unless deadline.nil?
+        validate_time!(:safety_margin, safety_margin)
+        if middleware && !middleware.is_a?(Middleware::Stack)
+          raise ArgumentError, "middleware must be a Gritz::Middleware::Stack"
+        end
+
+        args = channel_args.dup
+        unless service_config.nil?
+          raise ArgumentError, "service_config must be a JSON object" unless service_config.is_a?(Hash)
+
+          args["grpc.service_config"] = JSON.generate(service_config)
+          validate_json!(service_config)
+        end
+        definition = Definition.new(stub_class:, target: target.dup.freeze, credentials:,
+                                    args: ChannelRegistry.snapshot(args), deadline:, safety_margin:, middleware:, adapter:)
+        Module.new do
+          stub_class.public_instance_methods(false).each do |method|
+            define_singleton_method(method) do |request, options = {}, **keywords, &block|
+              raise ArgumentError, "RPC options must be a Hash" unless options.is_a?(Hash)
+
+              definition.call(method, request, options.merge(keywords), &block)
+            end
+          end
+        end
+      rescue JSON::GeneratorError, JSON::NestingError => e
+        raise ArgumentError, "invalid service_config: #{e.message}"
+      end
+
+      private
+
+      def validate_time!(name, value)
+        unless value.is_a?(Numeric) && value.real? && value.finite? && (name == :deadline ? value.positive? : value >= 0)
+          raise ArgumentError, "#{name} must be a finite #{name == :deadline ? 'positive' : 'nonnegative'} number"
+        end
+      end
+
+      def validate_json!(value)
+        case value
+        when Hash
+          value.each do |key, entry|
+            raise ArgumentError, "service_config object keys must be Strings or Symbols" unless key.is_a?(String) || key.is_a?(Symbol)
+
+            validate_json!(entry)
+          end
+        when Array then value.each { |entry| validate_json!(entry) }
+        when Float
+          raise ArgumentError, "service_config numbers must be finite" unless value.finite?
+        when String, Integer, Symbol, TrueClass, FalseClass, NilClass then nil
+        else raise ArgumentError, "service_config must contain only JSON values"
+        end
+      end
+    end
+
+    # @api private
+    class Definition
+      def initialize(stub_class:, target:, credentials:, args:, deadline:, safety_margin:, middleware:, adapter:)
+        @stub_class = stub_class
+        @target = target
+        @credentials = credentials
+        @args = args
+        @deadline = deadline
+        @safety_margin = safety_margin
+        @middleware = middleware
+        @adapter = adapter
+      end
+
+      def call(method, request, options, &)
+        ForkGuard.check!(@stub_class)
+        invocation = Invocation.new(deadline: @deadline, safety_margin: @safety_margin, options:,
+                                    parent: Context.current, middleware: @middleware)
+        adapter = @adapter || Client.adapter
+        raise ArgumentError, "require gritz/native or provide a client adapter" unless adapter
+
+        connection = ChannelRegistry.fetch(target: @target, credentials: @credentials, args: @args, pool: adapter) do
+          adapter.connect(target: @target, credentials: @credentials, args: @args)
+        end
+        adapter.invoke(stub_class: @stub_class, connection:, method:, request:, options: invocation.options,
+                       around: invocation.method(:call), &)
+      end
+    end
+  end
+end

data/lib/gritz/configuration.rb

@@ -18,7 +18,8 @@ module Gritz
       keepalive_permit_without_calls: true,
       max_receive_message_size: 4 * 1024 * 1024,
       max_send_message_size: 4 * 1024 * 1024, max_metadata_size: 8192,
-      metrics_backend: :pipe, log_format: :json, worker_recycle: {}, tls: {}
+      metrics_backend: :pipe, log_format: :json, log_redact: [], worker_recycle: {}, tls: {},
+      pid_file: "", reexec_timeout: 60.0
     }.freeze
     ENUMS = {
       transport: %i[native async], listener_strategy: %i[reuseport inherited_fd port_per_worker],
@@ -27,7 +28,7 @@ module Gritz
     }.freeze
     HOOKS = %i[before_fork on_worker_boot on_worker_shutdown].freeze
 
-    attr_accessor(*DEFAULTS.keys, :controllers, :middleware, :preload_app)
+    attr_accessor(*DEFAULTS.keys, :controllers, :middleware, :preload_app, :metrics_recorder_factory)
     attr_reader :health_checks
 
     def initialize
@@ -63,7 +64,7 @@ module Gritz
       when Integer then Integer(value, 10)
       when Float then Float(value)
       when Symbol then value.to_sym
-      when Hash then JSON.parse(value, symbolize_names: true)
+      when Hash, Array then JSON.parse(value, symbolize_names: true)
       when true, false
         return true if %w[true 1].include?(value)
         return false if %w[false 0].include?(value)
@@ -86,7 +87,7 @@ module Gritz
                 end
         raise ConfigurationError, "Invalid #{name}: #{value.inspect}" unless valid
       end
-      %i[shutdown_timeout worker_boot_timeout worker_timeout status_interval].each do |name|
+      %i[shutdown_timeout worker_boot_timeout worker_timeout status_interval reexec_timeout].each do |name|
         raise ConfigurationError, "#{name} must be positive" unless public_send(name).positive?
       end
       ENUMS.each do |name, allowed|
@@ -97,7 +98,16 @@ module Gritz
       validate_tls!
       raise ConfigurationError, "controllers must be an Array of classes" unless controllers.is_a?(Array) && controllers.all?(Class)
       raise ConfigurationError, "middleware must be a Stack" unless middleware.is_a?(Middleware::Stack)
+      if metrics_recorder_factory && !metrics_recorder_factory.respond_to?(:call)
+        raise ConfigurationError, "metrics recorder factory must be callable"
+      end
       raise ConfigurationError, "preload_app must be boolean" unless [true, false].include?(preload_app)
+      unless log_redact.all? { |name| name.is_a?(String) || name.is_a?(Symbol) }
+        raise ConfigurationError, "log_redact must contain metadata names"
+      end
+      unless health_checks.all? { |name, check| (name.is_a?(String) || name.is_a?(Symbol)) && check.respond_to?(:call) }
+        raise ConfigurationError, "health_checks must contain named callbacks"
+      end
 
       self
     end
@@ -109,11 +119,15 @@ module Gritz
       validate!
       raise ConfigurationError, "This release supports transport :native" unless transport == :native
       raise ConfigurationError, "This release supports listener_strategy :reuseport" unless listener_strategy == :reuseport
-      raise ConfigurationError, "TLS is planned for v0.3" unless tls.empty?
-      raise ConfigurationError, "worker_recycle is planned for v0.3" unless worker_recycle.empty?
-      raise ConfigurationError, "Health checks are planned for v0.3" unless health_checks.empty?
-      raise ConfigurationError, "This release supports log_format :json" unless log_format == :json
-      raise ConfigurationError, "This release reserves metrics_backend :pipe; metrics export is planned for v0.3" unless metrics_backend == :pipe
+      unless metrics_backend == :pipe || (metrics_backend == :otlp && metrics_recorder_factory)
+        raise ConfigurationError, "metrics_backend requires an installed recorder (:pipe is built in)"
+      end
+      raise ConfigurationError, "This release supports phased_restart_surge 1" unless phased_restart_surge == 1
+
+      unless worker_recycle.empty?
+        raise ConfigurationError, "worker_recycle requires workers > 0" unless workers.positive?
+        raise ConfigurationError, "worker_recycle requires a fixed bind port" if bind.end_with?(":0")
+      end
       raise ConfigurationError, "grpc_fork_support requires workers > 0" if workers.zero? && fork_mode != :clean
       raise ConfigurationError, "at least one controller must be registered" if controllers.empty?
 

data/lib/gritz/context.rb

@@ -4,13 +4,19 @@ module Gritz
   # Request state inherited by child fibers and threads using Ruby Fiber storage.
   # @api public
   class Context
-    attr_reader :call, :logger, :store
+    attr_reader :call, :logger, :store, :metrics, :worker, :log_format, :log_redact,
+                :requests_count, :responses_count, :bytes_in, :bytes_out
     attr_accessor :request_id, :trace_context
 
-    def initialize(call:, logger:)
+    def initialize(call:, logger:, metrics: nil, worker: nil, log_format: :json, log_redact: [])
       @call = call
       @logger = logger
       @store = {}
+      @metrics = metrics
+      @worker = worker
+      @log_format = log_format
+      @log_redact = log_redact.map(&:to_s)
+      @requests_count = @responses_count = @bytes_in = @bytes_out = 0
     end
 
     def self.current = Fiber[:gritz_context]
@@ -46,5 +52,28 @@ module Gritz
 
       message
     end
+
+    # @api private
+    def record_received(message)
+      return unless message
+
+      size = encoded_size(message)
+      @requests_count += 1
+      @bytes_in += size
+    end
+
+    # @api private
+    def record_sent(message)
+      size = encoded_size(message)
+      @responses_count += 1
+      @bytes_out += size
+    end
+
+    private
+
+    def encoded_size(message)
+      # ponytail: byte accounting encodes again; instrument native serialization if the Phase 6 overhead budget is exceeded.
+      message.class.respond_to?(:encode) ? message.class.encode(message).bytesize : message.to_s.bytesize
+    end
   end
 end

data/lib/gritz/controller.rb

@@ -96,6 +96,10 @@ module Gritz
       def initialize(call, context)
         @call = call
         @context = context
+        unless context.method.client_streaming?
+          @message = @call.read
+          @context.record_received(@message)
+        end
       end
 
       def message
@@ -104,14 +108,23 @@ module Gritz
         return @message if defined?(@message)
 
         @message = @call.read
+        @context.record_received(@message)
+        @message
       end
 
       def each_message
         return enum_for(__method__) unless block_given?
 
+        unless @context.method.client_streaming?
+          value = message
+          yield value if value
+          return
+        end
+
         @call.each_message do |message|
           @context.check_deadline!
           @context.check_cancelled!
+          @context.record_received(message)
           yield message
         end
       end
@@ -133,6 +146,7 @@ module Gritz
         @context.check_cancelled!
         @context.validate_response!(message)
         @call.write(message)
+        @context.record_sent(message)
       end
     end
   end

data/lib/gritz/core/version.rb

@@ -2,6 +2,6 @@
 
 module Gritz
   module Core
-    VERSION = "0.2.0"
+    VERSION = "0.4.0"
   end
 end

data/lib/gritz/dispatcher.rb

@@ -8,9 +8,11 @@ module Gritz
   class Dispatcher
     attr_reader :router
 
-    def initialize(router:, middleware: Middleware::Stack.default, logger: Logger.new($stdout))
+    def initialize(router:, middleware: Middleware::Stack.default, logger: Logger.new($stdout),
+                   metrics: nil, worker: nil, log_format: :json, log_redact: [])
       @router = router
       @logger = logger
+      @context_options = { metrics: metrics, worker: worker, log_format: log_format, log_redact: log_redact }
       endpoint = lambda do |context|
         context.check_deadline!
         context.check_cancelled!
@@ -18,13 +20,17 @@ module Gritz
         result = descriptor.controller.new(context:).process(descriptor.action)
         context.check_deadline!
         context.check_cancelled!
-        descriptor.server_streaming? ? result : context.validate_response!(result)
+        unless descriptor.server_streaming?
+          context.validate_response!(result)
+          context.record_sent(result)
+        end
+        result
       end
       @app = middleware ? middleware.build(endpoint) : endpoint
     end
 
     def call(call)
-      @app.call(Context.new(call:, logger: @logger))
+      @app.call(Context.new(call:, logger: @logger, **@context_options))
     end
   end
 end

data/lib/gritz/errors.rb

@@ -6,14 +6,16 @@ module Gritz
   class Error < StandardError
     attr_reader :details, :metadata
 
-    def initialize(message = nil, details: [], metadata: {})
+    def initialize(message = nil, details: [], metadata: {}, remote: false)
       super(message || code.to_s.tr("_", " "))
       @details = details
       @metadata = metadata
+      @remote = remote
     end
 
     def code = self.class::CODE
     def grpc_code = self.class::GRPC_CODE
+    def remote? = @remote
 
     CODE = :unknown
     GRPC_CODE = 2