twirp 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d21a865d8176ee77a6651aabe59247ae763e1d5
-  data.tar.gz: 8d16237130c4e966f97b98f7f529f6eb82814bf0
+  metadata.gz: f3e14392e7046ad1e01f88323f3966e612dacc23
+  data.tar.gz: a12d8cc09c357bfd1501cb12594b83eacf2b0779
 SHA512:
-  metadata.gz: 2194339fba1ba02716da045f69f55e4fe7e6631f5d6eb1c1b38d7039ef913bbd08c41c919d0872d0240dae238100bb685c6b40a747133887d7494d23d5d0b3f2
-  data.tar.gz: 595aab3aca050f20139ec2a1f5e8bff184fcfd771cc9fd008fd14056850228c79974d765da76c6c08e0e93e7a9c502ba76acfacdae7acff2020e561fe5f2d8a8
+  metadata.gz: cdf630358e9d36782f10f5069aa389fb97c588092cb6b2af89a72f5763b8d63f95d70d49d576bcf294de8ec495a71eb3f1ccbdd9cf53032d84108dccfdd5a7f1
+  data.tar.gz: c33a3b5aee715484475bffef8f325753d001a7c20ea69fbb180ffd4eb80db1123a6dd4c8f815905bf45c2a60fc3394b2965fdaa16a3d28696d1408b9d57a4104

data/README.md

@@ -4,85 +4,164 @@ Twirp services and clients in Ruby.
 
 ### Installation
 Install the `twirp` gem:
+
 ```sh
 ➜ gem install twirp
 ```
 
 Use `go get` to install the ruby_twirp protoc plugin:
+
 ```sh
 ➜ go get github.com/cyrusaf/ruby-twirp/protoc-gen-twirp_ruby
 ```
 
 You will also need:
+
  - [protoc](https://github.com/golang/protobuf), the protobuf compiler. You need
    version 3+.
 
-### Haberdasher Example
+### HelloWorld Example
+
 See the `example/` folder for the final product.
 
 First create a basic `.proto` file:
+
 ```protobuf
-// haberdasher.proto
 syntax = "proto3";
 package example;
 
-service Haberdasher {
-    rpc HelloWorld(HelloWorldRequest) returns (HelloWorldResponse);
+service HelloWorld {
+    rpc Hello(HelloRequest) returns (HelloResponse);
 }
 
-message HelloWorldRequest {
+message HelloRequest {
     string name = 1;
 }
 
-message HelloWorldResponse {
+message HelloResponse {
     string message = 1;
 }
-
 ```
 
-Run the `protoc` binary to generate `gen/haberdasher_pb.rb` and `gen/haberdasher_twirp.rb`.
+Run the `protoc` binary to auto-generate `helloworld_pb.rb` and `haberdasher_twirp.rb` files:
+
 ```sh
 ➜ protoc --proto_path=. ./haberdasher.proto --ruby_out=gen --twirp_ruby_out=gen
 ```
 
-Write an implementation of our haberdasher service and attach to a rack server:
+Write a handler for the auto-generated service, this is your implementation:
+
+```ruby
+class HellowWorldHandler
+  def hello(input, env)
+    {message: "Hello #{input.name}"}
+  end
+end
+```
+
+Initialize the service with your handler and mount it as a Rack app:
+
 ```ruby
-# main.rb
 require 'rack'
 require_relative 'gen/haberdasher_pb.rb'
 require_relative 'gen/haberdasher_twirp.rb'
 
-class HaberdasherHandler
-    def hello_world(req)
-        return {message: "Hello #{req.name}"}
-    end
-end
-
-handler = HaberdasherHandler.new()
-service = Example::HaberdasherService.new(handler)
+handler = HellowWorldHandler.new()
+service = Example::HelloWorld.new(handler)
 Rack::Handler::WEBrick.run service
 ```
 
-You can also mount onto a rails service:
+You can also mount onto a rails app:
+
 ```ruby
 App::Application.routes.draw do
-  handler = HaberdasherHandler.new()
-  service = Example::HaberdasherService.new(handler)
-  mount service, at: HaberdasherService::PATH_PREFIX
+  mount service, at: service.full_name
 end
 ```
 
-Run `ruby main.rb` to start the server on port 8080:
-```sh
-➜ ruby main.rb
-```
+Twirp services accept both Protobuf and JSON messages. It is easy to `curl` your service to get a response:
 
-`curl` your server to get a response:
 ```sh
-➜ curl --request POST \
-  --url http://localhost:8080/twirp/examples.Haberdasher/HelloWorld \
+curl --request POST \
+  --url http://localhost:8080/example.HelloWorld/Hello \
   --header 'content-type: application/json' \
-  --data '{
-	"name": "World"
-  }'
+  --data '{"name":"World"}'
+```
+
+
+## Hooks
+
+In the lifecycle of a request, the Twirp service starts by routing the request to a valid
+RPC method. If routing fails, the `on_error` hook is called with a bad_route error. 
+If routing succeeds, the `before` hook is called before calling the RPC method handler, 
+and then either `on_success` or `on_error` depending if the response is a Twirp error or not. 
+
+```
+routing -> before -> handler -> on_success
+                             -> on_error
+```
+
+On every request, one and only one of `on_success` or `on_error` is called.
+
+
+If exceptions are raised, the `exception_raised` hook is called. The exceptioni is wrapped with
+an internal Twirp error, and if the `on_error` hook was not called yet, then it is called with
+the wrapped exception.
+
+
+```
+routing -> before -> handler
+                     ! exception_raised -> on_error
+```
+
+Example code with hooks:
+
+
+```ruby
+class HaberdasherHandler
+  def make_hat(size, env)
+    return {}
+  end
+end
+
+handler = HaberdasherHandler.new
+svc = Example::Haberdasher.new(handler)
+
+
+svc.before do |rack_env, env|
+  # Runs if properly routed to an rpc method, but before calling the method handler.
+  # This is the only place to read the Rack Env to access http request and middleware data.
+  # The Twirp env has the same routing info as in the handler method, e.g. :rpc_method, :input and :input_class.
+  # If it returns a Twirp::Error, the handler is not called and this error is returned instead.
+  # If an exception is raised, the exception_raised hook will be called and then on_error with the internal error.
+end
+
+svc.on_success do |env|
+  # Runs after the rpc method is handled, if it didn't return Twirp errors or raised exceptions.
+  # The env[:output] contains the serialized message of class env[:ouput_class]
+  # Returned values are ignored (even if it returns Twirp::Error).
+  # Exceptions should not happen here, but if an exception is raised the exception_raised hook will be
+  # called, however on_error will not (either on_success or on_error are called once per request).
+end
+
+svc.on_error do |twerr, env|
+  # Runs on error responses, that is:
+  #  * routing errors (env does not have routing info here)
+  #  * before filters returning Twirp errors or raising exceptions.
+  #  * hander methods returning Twirp errors or raising exceptions.
+  # Raised exceptions are wrapped with Twirp::Error.internal_with(e).
+  # Returned values are ignored (even if it returns Twirp::Error).
+  # Exceptions should not happen here, but if an exception is raised the exception_raised hook will be
+  # called without calling on_error again later.
+end
+
+svc.exception_raised do |e, env|
+  # Runs if an exception was raised from the handler or any of the hooks.
+  environment = (ENV['APP_ENV'] || ENV['RACK_ENV'] || :development).to_sym
+  case environment
+    when :development raise e
+    when :test
+      puts "[Error] #{e}\n#{e.backtrace.join("\n")}"
+  end
+end
 ```

data/example/gen/haberdasher_twirp.rb

@@ -3,9 +3,8 @@ require 'twirp'
 
 module Example
   class HaberdasherService < Twirp::Service
-    PATH_PREFIX = "/twirp/example.Haberdasher"
     package "example"
     service "Haberdasher"
-    rpc :HelloWorld, HelloWorldRequest, HelloWorldResponse, handler_method: 'hello_world'
+    rpc :HelloWorld, HelloWorldRequest, HelloWorldResponse, :handler_method => :hello_world
   end
 end

data/example/main.rb

@@ -3,11 +3,12 @@ require_relative 'gen/haberdasher_pb.rb'
 require_relative 'gen/haberdasher_twirp.rb'
 
 class HaberdasherHandler
-    def hello_world(req)
-        return {message: "Hello #{req.name}"}
-    end
+  def hello_world(req, env)
+    {message: "Hello #{req.name}"}
+  end
 end
 
 handler = HaberdasherHandler.new()
 service = Example::HaberdasherService.new(handler)
+
 Rack::Handler::WEBrick.run service

data/lib/twirp.rb

@@ -1,4 +1,3 @@
 require_relative 'twirp/version'
 require_relative 'twirp/error'
-require_relative 'twirp/exception'
 require_relative 'twirp/service'

data/lib/twirp/error.rb

@@ -1,5 +1,3 @@
-require 'json'
-
 module Twirp
 
   # Valid Twirp error codes and their mapping to related HTTP status.
@@ -28,90 +26,76 @@ module Twirp
   # List of all valid error codes in Twirp
   ERROR_CODES = ERROR_CODES_TO_HTTP_STATUS.keys
 
-  # Twirp::Error represents a valid error from a Twirp service
+  def valid_error_code?(code)
+    ERROR_CODES_TO_HTTP_STATUS.key? code # one of the valid symbols
+  end
+
+
+  # Twirp::Error represents an error response from a Twirp service.
+  # Twirp::Error is not an Exception to be raised, but a value to be returned
+  # by service handlers and received by clients.
 	class Error
 
-    # Wrap an arbitrary error as a Twirp :internal
-    def self.InternalWith(err)
-      self.new :internal, err.message, "cause" => err.class.name
+    # Use this constructors to ensure the errors have valid error codes. Example:
+    #     Twirp::Error.internal("boom")
+    #     Twirp::Error.invalid_argument("foo is mandatory", argument: "foo")
+    #     Twirp::Error.permission_denied("thou shall not pass!", target: "Balrog")
+    ERROR_CODES.each do |code|
+      define_singleton_method code do |msg, meta=nil|
+        new(code, msg, meta)
+      end
+    end
+
+    # Wrap another error as a Twirp::Error :internal.
+    def self.internal_with(err)
+      twerr = internal err.message, cause: err.class.name
+      twerr.cause = err
+      twerr
     end
 
+    attr_reader :code, :msg, :meta
+    
+    attr_accessor :cause # used when wrapping another error, but this is not serialized
+
     # Initialize a Twirp::Error
-    # The code MUST be one of the valid ERROR_CODES Symbols (e.g. :internal, :not_found, :permission_denied ...).
+    # The code must be one of the valid ERROR_CODES Symbols (e.g. :internal, :not_found, :permission_denied ...).
     # The msg is a String with the error message.
-    # The meta is optional error metadata, if included it MUST be a Hash with String keys and values.
+    # The meta is optional error metadata, if included it must be a Hash with String values.
     def initialize(code, msg, meta=nil)
-      @code = validate_code(code)
+      @code = code.to_sym
       @msg = msg.to_s
       @meta = validate_meta(meta)
     end
 
-    attr_reader :code
-    attr_reader :msg
-    
-    def meta(key)
-      @meta ||= {}
-      @meta[key]
-    end
-
-    def add_meta(key, value)
-      validate_meta_key_value(key, value)
-      @meta ||= {}
-      @meta[key] = value
-    end
-
-    def delete_meta(key)
-      @meta ||= {}
-      @meta.delete(key.to_s)
-      @meta = nil if @meta.size == 0
-    end
-
-    def as_json
+    def to_h
       h = {
         code: @code,
         msg: @msg,
       }
-      h[:meta] = @meta if @meta
+      h[:meta] = @meta unless @meta.empty?
       h
     end
 
-    def to_json
-      JSON.generate(as_json)
-    end
-
     def to_s
-      "Twirp::Error code:#{code} msg:#{msg.inspect} meta:#{meta.inspect}"
+      "<Twirp::Error code:#{code.inspect} msg:#{msg.inspect} meta:#{meta.inspect}>"
     end
 
-    private
 
-    def validate_code(code)
-      if !code.is_a? Symbol
-        raise ArgumentError.new("Twirp::Error code must be a Symbol, but it is a #{code.class.to_s}")
-      end
-      if !ERROR_CODES_TO_HTTP_STATUS.has_key? code
-        raise ArgumentError.new("Twirp::Error code :#{code} is invalid. Expected one of #{ERROR_CODES.inspect}")
-      end
-      code
-    end
+  private
 
     def validate_meta(meta)
-      return nil if !meta
+      return {} if !meta
+
       if !meta.is_a? Hash
         raise ArgumentError.new("Twirp::Error meta must be a Hash, but it is a #{meta.class.to_s}")
       end
       meta.each do |key, value| 
-        validate_meta_key_value(key, value)        
+        if !value.is_a?(String)
+          raise ArgumentError.new("Twirp::Error meta values must be Strings, but key #{key.inspect} has the value <#{value.class.to_s}> #{value.inspect}")
+        end
       end
       meta
     end
 
-    def validate_meta_key_value(key, value)
-      if !key.is_a?(String) || !value.is_a?(String)
-        raise ArgumentError.new("Twirp::Error meta must be a Hash with String keys and values. Invalid key<#{key.class}>: #{key.inspect}, value<#{value.class}>: #{value.inspect}")
-      end
-    end
-
   end
-
 end

data/lib/twirp/service.rb

@@ -1,35 +1,33 @@
+require "json"
+
 module Twirp
+
   class Service
 
     class << self
 
       # Configure service package name.
-      def package(package_name)
-        @package_name = package_name.to_s
+      def package(name)
+        @package_name = name.to_s
       end
 
       # Configure service name.
-      def service(service_name)
-        @service_name = service_name.to_s
+      def service(name)
+        @service_name = name.to_s
       end
 
       # Configure service routing to handle rpc calls.
-      def rpc(method_name, request_class, response_class, opts)
-        if !request_class.is_a?(Class)
-          raise ArgumentError.new("request_class must be a Protobuf Message class")
-        end 
-        if !response_class.is_a?(Class)
-          raise ArgumentError.new("response_class must be a Protobuf Message class")
-        end
-        if !opts || !opts[:handler_method]
-          raise ArgumentError.new("opts[:handler_method] is mandatory")
-        end
-
-        @rpcs ||= {}
-        @rpcs[method_name.to_s] = {
-          request_class: request_class,
-          response_class: response_class,
-          handler_method: opts[:handler_method],
+      def rpc(rpc_method, input_class, output_class, opts)
+        raise ArgumentError.new("input_class must be a Protobuf Message class") unless input_class.is_a?(Class) 
+        raise ArgumentError.new("output_class must be a Protobuf Message class") unless output_class.is_a?(Class)
+        raise ArgumentError.new("opts[:handler_method] is mandatory") unless opts && opts[:handler_method]
+
+        @base_envs ||= {}
+        @base_envs[rpc_method.to_s] = {
+          rpc_method: rpc_method.to_sym,
+          input_class: input_class,
+          output_class: output_class,
+          handler_method: opts[:handler_method].to_sym,
         }
       end
 
@@ -39,150 +37,205 @@ module Twirp
         @package_name.to_s
       end
 
-      # Get configured service name as String.
-      # If not configured, it defaults to the class name.
+      # Service name as String.
+      # Defaults to the current class name.
       def service_name
-        sname = @service_name.to_s
-        sname.empty? ? self.name : sname
-      end
-
-      # Get configured metadata for rpc methods.
-      def rpcs
-        @rpcs || {}
+        (@service_name || self.name).to_s
       end
 
-      # Path prefix that should be used to route requests to this service.
-      # It is based on the package and service name, in the expected Twirp URL format.
-      # The full URL would be: {BaseURL}/path_prefix/{MethodName}.
-      def path_prefix
-        "/twirp/#{service_full_name}" # e.g. "twirp/Haberdasher"
+      # Base Twirp environments for each rpc method.
+      def base_envs
+        @base_envs || {}
       end
 
-      # Service full name uniquelly identifies the service.
-      # It is the service name prefixed by the package name,
-      # for example "my.package.Haberdasher", or "Haberdasher" (if no package).
+      # Package and servicce name, as a unique identifier for the service,
+      # for example "example.v3.Haberdasher" (package "example.v3", service "Haberdasher").
+      # This can be used as a path prefix to route requests to the service, because a Twirp URL is:
+      # "#{BaseURL}/#{ServiceFullName}/#{Method]"
       def service_full_name
         package_name.empty? ? service_name : "#{package_name}.#{service_name}"
       end
 
+      # Raise exceptions instead of handling them with exception_raised hooks.
+      # Useful during tests to easily debug and catch unexpected exceptions.
+      # Default false.
+      attr_accessor :raise_exceptions
+
     end # class << self
 
 
-    # Instantiate a new service with a handler.
-    # The handler must implemnt all rpc methods required by this service.
     def initialize(handler)
-      self.class.rpcs.each do |method_name, rpc|
-        if !handler.respond_to? rpc[:handler_method]
-          raise ArgumentError.new("Handler must respond to .#{rpc[:handler_method]}(input) in order to handle the message #{method_name}.")
-        end
-      end
       @handler = handler
+
+      @before = []
+      @on_success = []
+      @on_error = []
+      @exception_raised = []
+    end
+
+    def name
+      self.class.service_name
     end
-    # Register a before hook (not implemented)
-    def before(&block)
-      # TODO... and also after hooks
+
+    def full_name
+      self.class.service_full_name # use to route requests to this servie
     end
 
+    # Setup hook blocks
+    def before(&block) @before << block; end
+    def on_success(&block) @on_success << block; end
+    def on_error(&block) @on_error << block; end
+    def exception_raised(&block) @exception_raised << block; end
+
     # Rack app handler.
-    def call(env)
-      req = Rack::Request.new(env)
-      rpc, content_type, bad_route = parse_rack_request(req)
-      if bad_route
-        return error_response(bad_route)
-      end
-        
-      proto_req = decode_request(rpc[:request_class], content_type, req.body.read)
+    def call(rack_env)
       begin
-        resp = @handler.send(rpc[:handler_method], proto_req)
-        return rack_response_from_handler(rpc, content_type, resp)
-      rescue Twirp::Exception => twerr
-        error_response(twerr)
+        env = {}
+        bad_route = route_request(rack_env, env)
+        return error_response(bad_route, env) if bad_route
+      
+        @before.each do |hook|
+          result = hook.call(rack_env, env)
+          return error_response(result, env) if result.is_a? Twirp::Error
+        end
+          
+        output = call_handler(env)
+        return error_response(output, env) if output.is_a? Twirp::Error
+        return success_response(output, env)
+
+      rescue => e
+        raise e if self.class.raise_exceptions
+        begin
+          @exception_raised.each{|hook| hook.call(e, env) }
+        rescue => hook_e
+          e = hook_e
+        end
+        
+        twerr = Twirp::Error.internal_with(e)
+        return error_response(twerr, env)
       end
     end
 
-    def path_prefix
-      self.class.path_prefix
-    end
-
-    def service_full_name
-      self.class.service_full_name
-    end
 
   private
 
-    def parse_rack_request(req)
-      if req.request_method != "POST"
-        return nil, nil, bad_route_error("HTTP request method must be POST", req)
+    # Parse request and fill env with rpc data.
+    # Returns a bad_route error if something went wrong.
+    def route_request(rack_env, env)
+      rack_request = Rack::Request.new(rack_env)
+
+      if rack_request.request_method != "POST"
+        return bad_route_error("HTTP request method must be POST", rack_request)
       end
 
-      content_type = req.env["CONTENT_TYPE"]
+      content_type = rack_request.get_header("CONTENT_TYPE")
       if content_type != "application/json" && content_type != "application/protobuf"
-        return nil, nil, bad_route_error("unexpected Content-Type: #{content_type.inspect}. Content-Type header must be one of \"application/json\" or \"application/protobuf\"", req)
+        return bad_route_error("unexpected Content-Type: #{content_type.inspect}. Content-Type header must be one of application/json or application/protobuf", rack_request)
       end
+      env[:content_type] = content_type
       
-      path_parts = req.fullpath.split("/")
-      if path_parts.size < 4 || path_parts[-2] != self.service_full_name || path_parts[-3] != "twirp"
-        return nil, nil, bad_route_error("Invalid route. Expected format: POST {BaseURL}/twirp/(package.)?{Service}/{Method}", req)
+      path_parts = rack_request.fullpath.split("/")
+      if path_parts.size < 3 || path_parts[-2] != self.full_name
+        return bad_route_error("Invalid route. Expected format: POST {BaseURL}/#{self.full_name}/{Method}", rack_request)
       end
       method_name = path_parts[-1]
 
-      rpc = self.class.rpcs[method_name]
-      if !rpc
-        return nil, nil, bad_route_error("rpc method not found: #{method_name.inspect}", req)
+      base_env = self.class.base_envs[method_name]
+      if !base_env
+        return bad_route_error("Invalid rpc method #{method_name.inspect}", rack_request)
+      end
+      env.merge!(base_env) # :rpc_method, :input_class, :output_class, :handler_method
+
+      input = nil
+      begin
+        input = decode_input(rack_request.body.read, env[:input_class], content_type)
+      rescue => e
+        return bad_route_error("Invalid request body for rpc method #{method_name.inspect} with Content-Type=#{content_type}", rack_request)
       end
 
-      return rpc, content_type, nil
+      env[:input] = input
+      env[:http_response_headers] = {}
+      return
+    end
+
+    def bad_route_error(msg, req)
+      Twirp::Error.bad_route msg, twirp_invalid_route: "#{req.request_method} #{req.fullpath}"
     end
 
-    def rack_response_from_handler(rpc, content_type, resp)
-      if resp.is_a? Twirp::Error
-        return error_response(resp)
+    def decode_input(body, input_class, content_type)
+      case content_type
+      when "application/protobuf" then input_class.decode(body)
+      when "application/json"     then input_class.decode_json(body)
       end
+    end
 
-      if resp.is_a? Hash # allow handlers to return just the attributes
-        resp = rpc[:response_class].new(resp)
+    def encode_output(output, output_class, content_type)
+      case content_type
+      when "application/protobuf" then output_class.encode(output)
+      when "application/json"     then output_class.encode_json(output)
       end
+    end
 
-      if !resp # allow handlers to return nil or false as a reponse with zero-values
-        resp = rpc[:response_class].new
+    # Call handler method and return a Protobuf Message or a Twirp::Error.
+    def call_handler(env)
+      handler_method = env[:handler_method]
+      if !@handler.respond_to?(handler_method)
+        return Twirp::Error.unimplemented("Handler method #{handler_method} is not implemented.")
       end
 
-      encoded_resp = encode_response(rpc[:response_class], content_type, resp)
-      success_response(content_type, encoded_resp)
+      out = @handler.send(handler_method, env[:input], env)
+      case out
+      when env[:output_class], Twirp::Error
+        out
+      when Hash
+        env[:output_class].new(out)
+      else
+        Twirp::Error.internal("Handler method #{handler_method} expected to return one of #{env[:output_class].name}, Hash or Twirp::Error, but returned #{out.class.name}.")
+      end
     end
 
-    def decode_request(request_class, content_type, body)
-      case content_type
-      when "application/json"
-        request_class.decode_json(body)
-      when "application/protobuf"
-        request_class.decode(body)
+    def success_response(output, env)
+      begin
+        env[:output] = output
+        @on_success.each{|hook| hook.call(env) }
+
+        headers = env[:http_response_headers].merge('Content-Type' => env[:content_type])
+        resp_body = encode_output(output, env[:output_class], env[:content_type])
+        [200, headers, [resp_body]]
+
+      rescue => e
+        return exception_response(e, env)
       end
     end
 
-    def encode_response(response_class, content_type, resp)
-      case content_type
-      when "application/json"
-        response_class.encode_json(resp)
-      when "application/protobuf"
-        response_class.encode(resp)
+    def error_response(twerr, env)
+      begin
+        @on_error.each{|hook| hook.call(twerr, env) }
+
+        status = Twirp::ERROR_CODES_TO_HTTP_STATUS[twerr.code]
+        resp_body = JSON.generate(twerr.to_h)
+        [status, error_response_headers, [resp_body]]
+
+      rescue => e
+        return exception_response(e, env)
       end
     end
 
-    def success_response(content_type, encoded_resp)
-      [200, {'Content-Type' => content_type}, [encoded_resp]]
-    end
+    def exception_response(e, env)
+      raise e if self.class.raise_exceptions
+      begin
+        @exception_raised.each{|hook| hook.call(e, env) }
+      rescue => hook_e
+        e = hook_e
+      end
 
-    def error_response(twirp_error)
-      status = Twirp::ERROR_CODES_TO_HTTP_STATUS[twirp_error.code]
-      headers = {'Content-Type' => 'application/json'} 
-      resp_body = twirp_error.to_json
-      [status, headers, [resp_body]]
+      twerr = Twirp::Error.internal_with(e)
+      resp_body = JSON.generate(twerr.to_h)
+      [500, error_response_headers, [resp_body]]
     end
 
-    def bad_route_error(msg, req)
-      meta_invalid_route = "#{req.request_method} #{req.fullpath}"
-      Twirp::Error.new(:bad_route, msg, "twirp_invalid_route" => meta_invalid_route)
+    def error_response_headers
+      {'Content-Type' => 'application/json'}
     end
 
   end