async-grpc 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4796002440be1be16d777561582938e9ba8651636a7ebdc14e5f2ec5500e317
-  data.tar.gz: 47658a764095cc220dc087f9c12199cbfd78490c32f25949f4c93d94790525bc
+  metadata.gz: 33e1af099cdab3092bc722b175b4dc16cc4fdacbbe7c59c12d1f186cfec95b0b
+  data.tar.gz: 70c6f471fde84394a3a6aa5cb014d98a16be1746c132b0e932f516a6c175f8f3
 SHA512:
-  metadata.gz: e2ec6aff5358f4385d8d99db9ddcdfb2bf0987a50fbf2eefa12baebbbbebeeb6c206244fc57f7d73676be899e2d373975111f325cc147603b9b73ba3d0767a74
-  data.tar.gz: d1b3823eb2ce13f7c2ed01e8cccefb36bb7a17500f25b260ffa7227e0bb0d3c77c06cf05f5ae7b6e0e963ab408d9ba398200da3f6bec0d3e23fb3647dd4977d1
+  metadata.gz: a243cbd19d766995b1e63037f21357d97ff3878cd8020227df2652cd11be2bbbb367f753d8182ee319a0e47e7ecddc335ce38b4dca03209873ae869aee150acc
+  data.tar.gz: 9096b9bccc77a7860f164325dadc427c0e4ebc8ce4f9ff1411f87e3ccaa9c094c2502075b83ba21c5c9e458ac10e90034198e85d6f41d1d26f2b6e436010cc9b

data/context/getting-started.md

@@ -23,7 +23,7 @@ $ bundle add protocol-grpc async-http
   - {ruby Async::GRPC::Client} - An asynchronous gRPC client that wraps `Async::HTTP::Client`.
   - {ruby Async::GRPC::Stub} - A method-based stub for making RPC calls.
   - {ruby Async::GRPC::Service} - A concrete service implementation that uses a `Protocol::GRPC::Interface`.
-  - {ruby Async::GRPC::DispatcherMiddleware} - Middleware that routes requests to registered services.
+  - {ruby Async::GRPC::Dispatcher} - Middleware that routes requests to registered services.
 
 ## Client Usage
 
@@ -104,12 +104,12 @@ end
 ### Registering Services
 
 ``` ruby
-require "async/grpc/dispatcher_middleware"
+require "async/grpc/dispatcher"
 
-dispatcher = Async::GRPC::DispatcherMiddleware.new
+dispatcher = Async::GRPC::Dispatcher.new
 
 service = GreeterService.new(GreeterInterface, "hello.Greeter")
-dispatcher.register("hello.Greeter", service)
+dispatcher.register(service)
 ```
 
 ### Running a Server
@@ -151,8 +151,8 @@ end
 Async do
 		# Setup server
 	endpoint = Async::HTTP::Endpoint.parse("http://localhost:50051")
-	dispatcher = Async::GRPC::DispatcherMiddleware.new
-	dispatcher.register("hello.Greeter", GreeterService.new(GreeterInterface, "hello.Greeter"))
+	dispatcher = Async::GRPC::Dispatcher.new
+	dispatcher.register(GreeterService.new(GreeterInterface, "hello.Greeter"))
 	server = Async::HTTP::Server.for(endpoint, dispatcher)
 	
 		# Setup client
@@ -169,6 +169,3 @@ Async do
 	server.run
 end
 ```
-
-
-

data/design.md

@@ -318,13 +318,18 @@ module Async
 				end
 			end
 			
-			# Check gRPC status and raise error if not OK
+		# Check gRPC status and raise error if not OK
 			def check_status!(response)
 				status = Protocol::GRPC::Metadata.extract_status(response.headers)
-				if status != Protocol::GRPC::Status::OK
-					message = Protocol::GRPC::Metadata.extract_message(response.headers)
-					raise Protocol::GRPC::Error.new(status, message)
-				end
+				
+				return if status == Protocol::GRPC::Status::OK
+				
+				message = Protocol::GRPC::Metadata.extract_message(response.headers)
+				metadata = Protocol::GRPC::Methods.extract_metadata(response.headers)
+				
+				remote_error = RemoteError.for(message, metadata)
+				
+				raise Protocol::GRPC::Error.for(status, metadata: metadata), cause: remote_error
 			end
 		end
 	end
@@ -1001,7 +1006,7 @@ This enables async-grpc to be used as a drop-in replacement for the standard `gr
 ### Phase 1: Core Client (✅ Designed)
    - `Async::GRPC::Client` with all four RPC types
    - `Async::GRPC::ServerCall` context object (enhances Protocol::GRPC::Call)
-   - Basic error handling and status checking
+   - Error handling with backtrace support via `RemoteError` and exception chaining
    - Response body wrapping pattern
    - **Server**: Just use `Protocol::GRPC::Middleware` with `Async::HTTP::Server` (no wrapper needed!)
 

data/lib/async/grpc/client.rb

@@ -16,6 +16,7 @@ require "protocol/grpc/body/writable_body"
 require "protocol/grpc/metadata"
 require "protocol/grpc/error"
 require_relative "stub"
+require_relative "remote_error"
 
 module Async
 	module GRPC
@@ -100,7 +101,9 @@ module Async
 			def call(request)
 				request.headers = @headers.merge(request.headers)
 				
-				super
+				super.tap do |response|
+					response.headers.policy = Protocol::GRPC::HEADER_POLICY
+				end
 			end
 			
 			# Make a gRPC call.
@@ -166,19 +169,17 @@ module Async
 				begin
 					# Read body first - trailers are only available after body is consumed
 					response_encoding = response.headers["grpc-encoding"]
-					readable_body = Protocol::GRPC::Body::ReadableBody.new(
-						response.body,
-						message_class: response_class,
-						encoding: response_encoding
-					)
+					response_body = Protocol::GRPC::Body::ReadableBody.wrap(response, message_class: response_class, encoding: response_encoding)
 					
-					message = readable_body.read
-					readable_body.close
+					if response_body
+						response_value = response_body.read
+						response_body.close
+					end
 					
 					# Check status after reading body (trailers are now available)
 					check_status!(response)
 					
-					message
+					return response_value
 				ensure
 					response.close
 				end
@@ -203,32 +204,19 @@ module Async
 				response = call(http_request)
 				
 				begin
-					# Set gRPC policy BEFORE reading body so trailers are processed correctly:
-					unless response.headers.policy == Protocol::GRPC::HEADER_POLICY
-						response.headers.policy = Protocol::GRPC::HEADER_POLICY
-					end
-					
 					# Read body first - trailers are only available after body is consumed:
 					response_encoding = response.headers["grpc-encoding"]
-					readable_body = Protocol::GRPC::Body::ReadableBody.new(
-						response.body,
-						message_class: response_class,
-						encoding: response_encoding
-					)
-					
-					return readable_body unless block_given?
+					response_body = Protocol::GRPC::Body::ReadableBody.wrap(response, message_class: response_class, encoding: response_encoding)
 					
-					begin
-						readable_body.each(&block)
-					ensure
-						readable_body.close
+					if block_given? and response_body
+						response_body.each(&block)
 					end
 					
 					# Check status after reading all body chunks (trailers are now available):
 					check_status!(response)
 					
-					readable_body
-				rescue StandardError
+					return response_body
+				rescue
 					response.close
 					raise
 				end
@@ -327,24 +315,16 @@ module Async
 			# @parameter response [Protocol::HTTP::Response]
 			# @raises [Protocol::GRPC::Error] If status is not OK
 			def check_status!(response)
-				# Policy should already be set before calling this method:
-				# But ensure it's set just in case
-				unless response.headers.policy == Protocol::GRPC::HEADER_POLICY
-					response.headers.policy = Protocol::GRPC::HEADER_POLICY
-				end
-				
 				status = Protocol::GRPC::Metadata.extract_status(response.headers)
 				
-				# If status is UNKNOWN (not found), default to OK:
-				# This handles cases where trailers aren't available or status wasn't set
-				status = Protocol::GRPC::Status::OK if status == Protocol::GRPC::Status::UNKNOWN
-				
 				return if status == Protocol::GRPC::Status::OK
 				
 				message = Protocol::GRPC::Metadata.extract_message(response.headers)
 				metadata = Protocol::GRPC::Methods.extract_metadata(response.headers)
 				
-				raise Protocol::GRPC::Error.for(status, message, metadata: metadata)
+				remote_error = RemoteError.for(message, metadata)
+				
+				raise Protocol::GRPC::Error.for(status, metadata: metadata), cause: remote_error
 			end
 		end
 	end

data/lib/async/grpc/{dispatcher_middleware.rb → dispatcher.rb}

@@ -3,6 +3,9 @@
 # Released under the MIT License.
 # Copyright, 2025, by Samuel Williams.
 
+require "async"
+require "async/deadline"
+
 require "protocol/grpc/middleware"
 require "protocol/grpc/methods"
 require "protocol/grpc/call"
@@ -14,16 +17,16 @@ require "protocol/grpc/status"
 
 module Async
 	module GRPC
-		# Represents middleware that dispatches gRPC requests to registered services.
+		# Dispatches gRPC requests to registered services.
 		# Handles routing based on service name from the request path.
 		#
 		# @example Registering services:
-		#   dispatcher = DispatcherMiddleware.new
-		#   dispatcher.register("hello.Greeter", GreeterService.new(GreeterInterface, "hello.Greeter"))
-		#   dispatcher.register("world.Greeter", WorldService.new(WorldInterface, "world.Greeter"))
+		#   dispatcher = Dispatcher.new
+		#   dispatcher.register(GreeterService.new(GreeterInterface, "hello.Greeter"))
+		#   dispatcher.register(WorldService.new(WorldInterface, "world.Greeter"))
 		#
 		#   server = Async::HTTP::Server.for(endpoint, dispatcher)
-		class DispatcherMiddleware < Protocol::GRPC::Middleware
+		class Dispatcher < Protocol::GRPC::Middleware
 			# Initialize the dispatcher.
 			# @parameter app [#call | Nil] The next middleware in the chain
 			# @parameter services [Hash] Optional initial services hash (service_name => service_instance)
@@ -32,15 +35,47 @@ module Async
 				@services = services
 			end
 			
-			# Register a service.
-			# @parameter service_name [String] Service name (e.g., "hello.Greeter")
-			# @parameter service [Async::GRPC::Service] Service instance
-			def register(service_name, service)
-				@services[service_name] = service
-			end
+		# Register a service.
+		# @parameter service [Async::GRPC::Service] Service instance
+		# @parameter name [String] Service name (defaults to service.service_name)
+		def register(service, name: service.service_name)
+			@services[name] = service
+		end
 			
 			protected
 			
+			def invoke_service(service, handler_method, input, output, call)
+				begin
+					service.send(handler_method, input, output, call)
+				ensure
+					# Close input stream:
+					input.close
+					
+					# Close output stream:
+					output.close_write unless output.closed?
+				end
+				
+				# Mark trailers and add status (if not already set by handler):
+				if call.response&.headers
+					call.response.headers.trailer!
+					
+					# Only add OK status if grpc-status hasn't been set by the handler:
+					unless call.response.headers["grpc-status"]
+						Protocol::GRPC::Metadata.add_status!(call.response.headers, status: Protocol::GRPC::Status::OK)
+					end
+				end
+			end
+			
+			def dispatch_to_service(service, handler_method, input, output, call, deadline, parent: Async::Task.current)
+				if deadline
+					parent.with_timeout(deadline) do
+						invoke_service(service, handler_method, input, output, call)
+					end
+				else
+					invoke_service(service, handler_method, input, output, call)
+				end
+			end
+			
 			# Dispatch the request to the appropriate service.
 			# @parameter request [Protocol::HTTP::Request] The HTTP request
 			# @returns [Protocol::HTTP::Response] The HTTP response
@@ -66,9 +101,9 @@ module Async
 					raise Protocol::GRPC::Error.new(Protocol::GRPC::Status::UNIMPLEMENTED, "Method not found: #{method_name}")
 				end
 				
-				handler_method = rpc_descriptor[:method]
-				request_class = rpc_descriptor[:request_class]
-				response_class = rpc_descriptor[:response_class]
+				handler_method = rpc_descriptor.method
+				request_class = rpc_descriptor.request_class
+				response_class = rpc_descriptor.response_class
 				
 				# Verify handler method exists:
 				unless service.respond_to?(handler_method, true)
@@ -80,32 +115,33 @@ module Async
 				input = Protocol::GRPC::Body::ReadableBody.new(request.body, message_class: request_class, encoding: encoding)
 				output = Protocol::GRPC::Body::WritableBody.new(message_class: response_class, encoding: encoding)
 				
-				# Create call context:
+				# Create response headers:
 				response_headers = Protocol::HTTP::Headers.new([], nil, policy: Protocol::GRPC::HEADER_POLICY)
 				response_headers["content-type"] = "application/grpc+proto"
 				response_headers["grpc-encoding"] = encoding if encoding
 				
+				# Create response object:
+				response = Protocol::HTTP::Response[200, response_headers, output]
+				
 				# Parse deadline from timeout header:
-				timeout_value = request.headers["grpc-timeout"]
-				deadline = if timeout_value
-					timeout_seconds = Protocol::GRPC::Methods.parse_timeout(timeout_value)
-					require "async/deadline"
-					Async::Deadline.start(timeout_seconds) if timeout_seconds
+				timeout = Protocol::GRPC::Methods.parse_timeout(request.headers["grpc-timeout"])
+				deadline = if timeout
+					Async::Deadline.start(timeout)
 				end
 				
-				call = Protocol::GRPC::Call.new(request, deadline: deadline)
+				# Create call context with request and response:
+				call = Protocol::GRPC::Call.new(request, response, deadline: deadline)
 				
-				# Call the handler method on the service:
-				service.send(handler_method, input, output, call)
-				
-				# Close output stream:
-				output.close_write unless output.closed?
-				
-				# Mark trailers and add status:
-				response_headers.trailer!
-				Protocol::GRPC::Metadata.add_status_trailer!(response_headers, status: Protocol::GRPC::Status::OK)
+				if rpc_descriptor.streaming?
+					Async do |task|
+						dispatch_to_service(service, handler_method, input, output, call, deadline, parent: task)
+					end
+				else
+					# Unary call:
+					dispatch_to_service(service, handler_method, input, output, call, deadline)
+				end
 				
-				Protocol::HTTP::Response[200, response_headers, output]
+				response
 			end
 		end
 	end

data/lib/async/grpc/remote_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+module Async
+	module GRPC
+		class RemoteError < StandardError
+			def self.for(message, metadata)
+				self.new(message).tap do |error|
+					if backtrace = metadata.delete("backtrace")
+						# Backtrace is always an array (Split header format):
+						error.set_backtrace(backtrace)
+					end
+				end
+			end
+		end
+	end
+end

data/lib/async/grpc/service.rb

@@ -9,7 +9,7 @@ module Async
 	module GRPC
 		# Represents a concrete service implementation that uses an Interface.
 		# Subclass this and implement the RPC methods defined in the interface.
-		# Services are registered with DispatcherMiddleware for routing.
+		# Services are registered with Dispatcher for routing.
 		#
 		# @example Example service implementation:
 		#   class GreeterInterface < Protocol::GRPC::Interface
@@ -32,8 +32,8 @@ module Async
 		#   end
 		#
 		#   # Register with dispatcher:
-		#   dispatcher = DispatcherMiddleware.new
-		#   dispatcher.register("hello.Greeter", GreeterService.new(GreeterInterface, "hello.Greeter"))
+		#   dispatcher = Dispatcher.new
+		#   dispatcher.register(GreeterService.new(GreeterInterface, "hello.Greeter"))
 		#   server = Async::HTTP::Server.for(endpoint, dispatcher)
 		class Service
 			# Initialize a new service instance.
@@ -58,36 +58,12 @@ module Async
 				descriptions = {}
 				
 				@interface_class.rpcs.each do |pascal_case_name, rpc|
-					# Use explicit method name if provided, otherwise convert PascalCase to snake_case:
-					ruby_method_name = if rpc.method
-						rpc.method
-					else
-						snake_case_name = pascal_case_to_snake_case(pascal_case_name.to_s)
-						snake_case_name.to_sym
-					end
-					
-					descriptions[pascal_case_name.to_s] = {
-						method: ruby_method_name,
-						request_class: rpc.request_class,
-						response_class: rpc.response_class,
-						streaming: rpc.streaming
-					}
+					# rpc.method is always set (either explicitly or auto-converted in Interface.rpc)
+					descriptions[pascal_case_name.to_s] = rpc
 				end
 				
 				descriptions
 			end
-			
-		private
-			
-			# Convert PascalCase to snake_case.
-			# @parameter pascal_case [String] PascalCase string (e.g., "SayHello")
-			# @returns [String] snake_case string (e.g., "say_hello")
-			def pascal_case_to_snake_case(pascal_case)
-				pascal_case
-					.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')  # Insert underscore before capital letters followed by lowercase
-					.gsub(/([a-z\d])([A-Z])/, '\1_\2')      # Insert underscore between lowercase/digit and uppercase
-					.downcase
-			end
 		end
 	end
 end

data/lib/async/grpc/stub.rb

@@ -24,8 +24,8 @@ module Async
 					# rpc.method is always set (either explicit or auto-converted from PascalCase)
 					snake_case_method = rpc.method
 					
-					# Index by snake_case method name, storing RPC and PascalCase name for path building
-					@rpcs_by_method[snake_case_method] = [rpc, pascal_case_name]
+					# Index by snake_case method name, storing RPC (which includes name field)
+					@rpcs_by_method[snake_case_method] = rpc
 				end
 			end
 			
@@ -53,8 +53,7 @@ module Async
 					encoding = options.delete(:encoding)
 					
 					# Delegate to client.invoke with PascalCase method name (for interface lookup):
-					@client.invoke(@interface, interface_method_name, request, metadata: metadata, timeout: timeout, encoding: encoding,
-						&block)
+					@client.invoke(@interface, interface_method_name, request, metadata: metadata, timeout: timeout, encoding: encoding, &block)
 				else
 					super
 				end
@@ -78,8 +77,8 @@ module Async
 			# @returns [Array(Protocol::GRPC::RPC, Symbol) | Array(Nil, Nil)] RPC definition and PascalCase method name, or nil if not found
 			def lookup_rpc(method_name)
 				if @rpcs_by_method.key?(method_name)
-					rpc, pascal_case_name = @rpcs_by_method[method_name]
-					return [rpc, pascal_case_name]
+					rpc = @rpcs_by_method[method_name]
+					return [rpc, rpc.name]
 				end
 				
 				[nil, nil]

data/lib/async/grpc/version.rb

@@ -7,6 +7,7 @@
 module Async
 	# @namespace
 	module GRPC
-		VERSION = "0.1.0"
+		VERSION = "0.3.0"
 	end
 end
+

data/lib/async/grpc.rb

@@ -7,7 +7,7 @@ require_relative "grpc/version"
 require_relative "grpc/client"
 require_relative "grpc/service"
 require_relative "grpc/stub"
-require_relative "grpc/dispatcher_middleware"
+require_relative "grpc/dispatcher"
 
 module Async
 	module GRPC

data/readme.md

@@ -10,10 +10,9 @@ Asynchronous gRPC client and server implementation built on top of `protocol-grp
 
   - **Asynchronous client** - Wraps `Async::HTTP::Client` to provide gRPC-specific call methods with automatic message framing and status handling.
   - **Method-based stubs** - Create type-safe stubs from `Protocol::GRPC::Interface` definitions. Accepts both PascalCase and snake\_case method names for convenience.
-  - **Server middleware** - `DispatcherMiddleware` routes requests to registered services based on path.
+  - **Server middleware** - `Dispatcher` routes requests to registered services based on path.
   - **All RPC patterns** - Supports unary, server streaming, client streaming, and bidirectional streaming RPCs.
-  - **Interface-based services** - Define services using `Protocol::GRPC::Interface` with automatic PascalCase to snake\_case method name conversion for Ruby implementations.
-  - **HTTP/2 transport** - Built on `async-http` with automatic HTTP/2 multiplexing and connection pooling.
+  - **HTTP/1 and HTTP/2 transport** - Built on `async-http` with automatic HTTP/2 multiplexing and connection pooling.
 
 ## Usage
 
@@ -25,8 +24,22 @@ Please see the [project documentation](https://socketry.github.io/async-grpc/) f
 
 Please see the [project releases](https://socketry.github.io/async-grpc/releases/index) for all releases.
 
+### v0.3.0
+
+  - **Breaking**: Renamed `DispatcherMiddleware` to `Dispatcher` for cleaner API.
+  - **Breaking**: Simplified `Dispatcher#register` API to `register(service, name: service.service_name)`, eliminating redundant service name specification.
+
+### v0.2.0
+
+  - Added `Async::GRPC::RemoteError` class to encapsulate remote error details including message and backtrace extracted from response headers.
+  - Client-side error handling now extracts backtraces from response metadata and sets them on `RemoteError`, which is chained as the `cause` of `Protocol::GRPC::Error` for better debugging.
+  - Updated to use `Protocol::GRPC::Metadata.add_status!` instead of deprecated `add_status_trailer!` method.
+  - Tidy up request and response body handling.
+
 ### v0.1.0
 
+  - Initial hack.
+
 ## See Also
 
   - [protocol-grpc](https://github.com/socketry/protocol-grpc) — Protocol abstractions for gRPC that this gem builds upon.

data/releases.md

@@ -1,3 +1,17 @@
 # Releases
 
+## v0.3.0
+
+  - **Breaking**: Renamed `DispatcherMiddleware` to `Dispatcher` for cleaner API.
+  - **Breaking**: Simplified `Dispatcher#register` API to `register(service, name: service.service_name)`, eliminating redundant service name specification.
+
+## v0.2.0
+
+  - Added `Async::GRPC::RemoteError` class to encapsulate remote error details including message and backtrace extracted from response headers.
+  - Client-side error handling now extracts backtraces from response metadata and sets them on `RemoteError`, which is chained as the `cause` of `Protocol::GRPC::Error` for better debugging.
+  - Updated to use `Protocol::GRPC::Metadata.add_status!` instead of deprecated `add_status_trailer!` method.
+  - Tidy up request and response body handling.
+
 ## v0.1.0
+
+  - Initial hack.

metadata

@@ -1,12 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: async-grpc
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Samuel Williams
 bindir: bin
-cert_chain: []
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIE2DCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQsFADBhMRgwFgYDVQQDDA9zYW11
+  ZWwud2lsbGlhbXMxHTAbBgoJkiaJk/IsZAEZFg1vcmlvbnRyYW5zZmVyMRIwEAYK
+  CZImiZPyLGQBGRYCY28xEjAQBgoJkiaJk/IsZAEZFgJuejAeFw0yMjA4MDYwNDUz
+  MjRaFw0zMjA4MDMwNDUzMjRaMGExGDAWBgNVBAMMD3NhbXVlbC53aWxsaWFtczEd
+  MBsGCgmSJomT8ixkARkWDW9yaW9udHJhbnNmZXIxEjAQBgoJkiaJk/IsZAEZFgJj
+  bzESMBAGCgmSJomT8ixkARkWAm56MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
+  igKCAYEAomvSopQXQ24+9DBB6I6jxRI2auu3VVb4nOjmmHq7XWM4u3HL+pni63X2
+  9qZdoq9xt7H+RPbwL28LDpDNflYQXoOhoVhQ37Pjn9YDjl8/4/9xa9+NUpl9XDIW
+  sGkaOY0eqsQm1pEWkHJr3zn/fxoKPZPfaJOglovdxf7dgsHz67Xgd/ka+Wo1YqoE
+  e5AUKRwUuvaUaumAKgPH+4E4oiLXI4T1Ff5Q7xxv6yXvHuYtlMHhYfgNn8iiW8WN
+  XibYXPNP7NtieSQqwR/xM6IRSoyXKuS+ZNGDPUUGk8RoiV/xvVN4LrVm9upSc0ss
+  RZ6qwOQmXCo/lLcDUxJAgG95cPw//sI00tZan75VgsGzSWAOdjQpFM0l4dxvKwHn
+  tUeT3ZsAgt0JnGqNm2Bkz81kG4A2hSyFZTFA8vZGhp+hz+8Q573tAR89y9YJBdYM
+  zp0FM4zwMNEUwgfRzv1tEVVUEXmoFCyhzonUUw4nE4CFu/sE3ffhjKcXcY//qiSW
+  xm4erY3XAgMBAAGjgZowgZcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFO9t7XWuFf2SKLmuijgqR4sGDlRsMC4GA1UdEQQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MC4GA1UdEgQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MA0GCSqGSIb3DQEBCwUAA4IBgQB5sxkE
+  cBsSYwK6fYpM+hA5B5yZY2+L0Z+27jF1pWGgbhPH8/FjjBLVn+VFok3CDpRqwXCl
+  xCO40JEkKdznNy2avOMra6PFiQyOE74kCtv7P+Fdc+FhgqI5lMon6tt9rNeXmnW/
+  c1NaMRdxy999hmRGzUSFjozcCwxpy/LwabxtdXwXgSay4mQ32EDjqR1TixS1+smp
+  8C/NCWgpIfzpHGJsjvmH2wAfKtTTqB9CVKLCWEnCHyCaRVuKkrKjqhYCdmMBqCws
+  JkxfQWC+jBVeG9ZtPhQgZpfhvh+6hMhraUYRQ6XGyvBqEUe+yo6DKIT3MtGE2+CP
+  eX9i9ZWBydWb8/rvmwmX2kkcBbX0hZS1rcR593hGc61JR6lvkGYQ2MYskBveyaxt
+  Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
+  voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
+  -----END CERTIFICATE-----
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
@@ -29,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.5'
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -47,7 +76,8 @@ files:
 - design.md
 - lib/async/grpc.rb
 - lib/async/grpc/client.rb
-- lib/async/grpc/dispatcher_middleware.rb
+- lib/async/grpc/dispatcher.rb
+- lib/async/grpc/remote_error.rb
 - lib/async/grpc/service.rb
 - lib/async/grpc/stub.rb
 - lib/async/grpc/version.rb