thrift_server 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9558c4785c5f60c3178add28862c2074d0a45ed9
+  data.tar.gz: af9ce55e5055cca900ff4d32f48558bb21d5a158
+SHA512:
+  metadata.gz: 3ec3fd8f56101e485a8f03654cbb921f6d1f5f047b1f408e20da258d11231d5b0e77a0124bd614b2af13f224baeb9776abbc4ea18b93d3c8db3f9813a986d05f
+  data.tar.gz: 8696c6d72a71ed0c6307dd88bd722d40109abbcc0761da9033294808f3a0d0c8e9cfc607c818ef29abed3a7c6eb381ea7acaa0b486e2a889dfd27015fcfce38f

data/.dockerignore

@@ -0,0 +1,3 @@
+.git
+.vagrant
+tmp

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+vendor/cache
+gen-rb/

data/Dockerfile

@@ -0,0 +1,12 @@
+FROM ruby:2.1
+
+RUN mkdir -p /usr/src/app
+WORKDIR /usr/src/app
+
+ADD Gemfile /usr/src/app/Gemfile
+ADD lib/thrift_server/version.rb /usr/src/app/lib/thrift_server/version.rb
+ADD thrift_server.gemspec /usr/src/app/thrift_server.gemspec
+
+RUN bundle install
+
+CMD [ "bundle", "console" ]

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in thrift_server.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 ahawkins
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Makefile

@@ -0,0 +1,43 @@
+APP:=thrift_server
+
+.DEFAULT_GOAL:=build
+
+APP_RUN:=docker run --rm -t -v $(CURDIR):/usr/src/app $(APP)
+
+gen-rb/echo_service.rb: echo_service.thrift
+	docker run --rm -t -v $(CURDIR):/data thrift:0.9.2 \
+		thrift -o /data --gen rb /data/$<
+
+.PHONY: thrift
+thrift: gen-rb/echo_service.rb
+
+tmp/image: Dockerfile Gemfile lib/thrift_server/version.rb thrift_server.gemspec
+	docker build -t $(APP) .
+	mkdir -p $(@D)
+	docker inspect -f '{{.Id}}' $(APP) >> $@
+
+.PHONY: build
+build: tmp/image
+
+.PHONY: test-unit
+test-unit: tmp/image
+	$(APP_RUN) bundle exec rake
+
+.PHONY: test-network
+test-network: tmp/image gen-rb/echo_service.rb
+	-@docker stop server > /dev/null 2>&1
+	-@docker rm -v server > /dev/null 2>&1
+	docker run -d --name server -v $(CURDIR):/usr/src/app $(APP) ruby echo_server.rb
+	docker run --rm -t -v $(CURDIR):/usr/src/app --link server:server $(APP) ruby echo_client.rb server 9090
+
+.PHONY: test-ci
+test-ci: test-unit test-network
+
+.PHONY: clean
+clean:
+	-docker stop server > /dev/null 2>&1
+	-docker rm -v server > /dev/null 2>&1
+	@mkdir -p tmp
+	@touch tmp/image
+	cat tmp/image | xargs --no-run-if-empty docker rmi
+	rm -rf tmp/image

data/README.md

@@ -0,0 +1,108 @@
+# ThriftServer
+
+Encapsulate bolierplate code and functionality for running Thrift
+servers in Ruby. Bundled functionality:
+
+* Error tracking
+* Metrics on each RPC
+* Logging on each RPC
+* Middleware based approaching making it easy to extend
+* Binary protocol
+* Framed transport
+* Thread pool sever
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'thrift_server'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install thrift_server
+
+## Usage
+
+The libary is defined to wrapping Thrift's processor classes in useful
+functionality for production servers. You must provide objects
+required to implement the behavior. Here's an example from
+[echo\_server.rb](echo_server.rb).
+
+    server = ThriftServer.build(EchoService::Processor, Handler.new, {
+        logger: Logger.new($stdout),
+        statsd: Statsd.new,
+        error_tracker: ErrorTracker.new
+    })
+
+    # Now call serve to start it
+    server.serve
+
+The first arument is a generated `Thrift::Processor` subclass. The second
+is your implementation of the define protocol. The options hash
+defines all the misc objecs and settings. The following options are
+available:
+
+* `logger:` - a `Logger` instance
+* `statsd:` - a `Statsd` instance from the [statsd-ruby gem](https://github.com/reinh/statsd)
+* `error_tracker:` object that implement `#track(rpc, error). Use
+  `ThriftServer::HoneybaderErrorTracker` if unsure
+* `threads:` - number of threads to run. Defaults to `4`
+* `port:` - port to run server on. Defaults to `9090`
+
+## Middleware
+
+The library uses a middleware approach to implement preprocessing of
+each RPC before handing it off the original handler. You can
+implement your own middleware easily. The middleware must respond to
+`call` and accept a `ThriftServer::RPC` object.
+`ThriftServer::RPC` is a simple struct with two members: `name` and
+`args`. Here's an example that dumps the `args` to stdout.
+
+    class ExampleMiddleware
+        include Concord.new(:app)
+
+        def call(rpc)
+            puts rpc.args.inspect
+            app.call rpc
+        end
+    end
+
+New middleware can be added at build time or afterwards.
+
+    ThriftServer::build processor, handler, options do |stack|
+        stack.use ExampleMiddlware
+    end
+
+Middleware can also be added after the server is built
+
+    server = ThriftServer::build processor, handler, options
+    server.use ExampleMiddleware
+    serve.serve # start it!
+
+## Implementation
+
+`ThriftServer` used metaprogramming and delegating to implement the
+funcationality. `build` used the processor class to determine which
+methods are required by the protocol. A middleware stack is created
+using the object passed in the `options` hash. A delegate class is
+created to wrap each method call to pass through the stack before
+calling the defined handler. A subclass of the processor is defined to
+wrap the handler provided in `initialize` in the delegate class.
+
+## Development
+
+    $ vagrant up
+    $ vagrant ssh
+    $ cd /vagrant
+    $ make test-ci
+
+## Contributing
+
+1. Create your feature branch (`git checkout -b my-new-feature`)
+2. Commit your changes (`git commit -am 'Add some feature'`)
+3. Push to the branch (`git push origin my-new-feature`)
+4. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |f|
+  f.test_files = Rake::FileList['test/**/*_test.rb']
+end
+
+task :benchmark do
+  ruby "benchmark/server.rb"
+end
+
+task default: :test

data/Vagrantfile

@@ -0,0 +1,14 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  config.vm.box = "ubuntu/trusty64"
+
+  config.vm.provision "docker" do |docker|
+    docker.pull_images "ruby:2.1"
+    docker.pull_images "thrift:0.9.2"
+  end
+end

data/benchmark/server.rb

@@ -0,0 +1,44 @@
+require 'bundler/setup'
+require 'thrift_server'
+
+require 'benchmark/ips'
+require 'logger-better'
+require 'middleware'
+
+class NullStatsd
+  def time(*) ; yield ; end
+  def increment(*) ; end
+end
+
+class NullErrorTracker
+  def track(*) ; end
+end
+
+class FakeProcessor
+  include Concord.new(:handler)
+
+  def process_someRPC
+    handler.someRPC
+  end
+end
+
+class FakeHandler
+  def someRPC
+    :response
+  end
+end
+
+Benchmark.ips do |x|
+  x.time = 20
+  x.warmup = 5
+
+  processor = ThriftServer.wrap(FakeProcessor, {
+    logger: NullLogger.new,
+    statsd: NullStatsd.new,
+    error_tracker: NullErrorTracker.new
+  })
+
+  server = processor.new FakeHandler.new
+
+  x.report("server") { server.process_someRPC }
+end

data/echo_client.rb

@@ -0,0 +1,35 @@
+$stdout.sync = true
+$stderr.sync = true
+
+require 'bundler/setup'
+require 'thrift_server'
+
+$LOAD_PATH << "#{__dir__}/gen-rb"
+
+require 'echo_service'
+
+host, port = ARGV[0], ARGV[1]
+
+if !host || !port
+  $stdout.puts "usage: echo_client HOST PORT"
+  abort
+end
+
+logger = Logger.new $stdout
+
+transport = Thrift::FramedTransport.new(Thrift::Socket.new(host, port.to_i))
+transport.open
+
+protocol = Thrift::BinaryProtocol.new transport
+client = EchoService::Client.new protocol
+
+result = client.echo "testing"
+
+transport.close
+
+if result == 'testing'
+  $stdout.puts 'OK'
+else
+  $stderr.puts 'Message not echoed'
+  abort
+end

data/echo_server.rb

@@ -0,0 +1,33 @@
+$stdout.sync = true
+$stderr.sync = true
+
+require 'bundler/setup'
+require 'thrift_server'
+
+$LOAD_PATH << "#{__dir__}/gen-rb"
+
+require 'echo_service'
+
+class Handler
+  def echo(msg)
+    msg
+  end
+end
+
+class ErrorTracker
+  def track(*)
+
+  end
+end
+
+logger = Logger.new $stdout
+
+server = ThriftServer.build(EchoService::Processor, Handler.new, {
+  logger: logger,
+  statsd: Statsd.new,
+  error_tracker: ErrorTracker.new
+})
+
+logger.info 'Starting server'
+
+server.serve

data/echo_service.thrift

@@ -0,0 +1,3 @@
+service EchoService {
+  string echo(1: string message)
+}

data/lib/thrift_server.rb

@@ -0,0 +1,110 @@
+require "thrift_server/version"
+
+require 'thrift'
+require 'middleware'
+require 'concord'
+require 'forwardable'
+require 'honeybadger'
+require 'statsd-ruby'
+
+require_relative 'thrift_server/logging_middleware'
+require_relative 'thrift_server/metrics_middleware'
+require_relative 'thrift_server/error_tracking_middleware'
+require_relative 'thrift_server/honeybadger_error_tracker'
+
+class ThriftServer
+  RPC = Struct.new(:name, :args)
+
+  class MiddlewareStack < Middleware::Builder
+    def finalize!
+      stack.freeze
+      to_app
+    end
+  end
+
+  class StackDelegate
+    class Dispatcher
+      include Concord.new(:app, :handler)
+
+      def call(rpc)
+        handler.send rpc.name, *rpc.args
+      end
+    end
+
+    extend Forwardable
+
+    include Concord.new(:stack, :handler)
+
+    def_delegator :stack, :use
+
+    def call(rpc)
+      app.call rpc
+    end
+
+    private
+    def app
+      @app ||= finalize_stack!
+    end
+
+    def finalize_stack!
+      stack.use Dispatcher, handler
+      stack.finalize!
+    end
+  end
+
+  class << self
+    def build(processor, handler, options = { }, &block)
+      stack = wrap(processor, options, &block).new handler
+      transport = Thrift::ServerSocket.new options.fetch(:port, 9090)
+      transport_factory = Thrift::FramedTransportFactory.new
+
+      Thrift::ThreadPoolServer.new stack, transport, transport_factory, nil, options.fetch(:threads, 4)
+    end
+
+    def wrap(processor, options = { })
+      rpcs = processor.instance_methods.select { |m| m =~ /^process_(.+)$/ }
+
+      logger = options.fetch :logger do
+        fail ArgumentError, ':logger required'
+      end
+
+      statsd = options.fetch :statsd do
+        fail ArgumentError, ':statsd required'
+      end
+
+      error_tracker = options.fetch :error_tracker do
+        fail ArgumentError, ':error_tracker required'
+      end
+
+      stack = MiddlewareStack.new
+      stack.use ErrorTrackingMiddleware, error_tracker
+      stack.use MetricsMiddleware, statsd
+      stack.use LoggingMiddleware, logger
+
+      yield stack if block_given?
+
+      wrapped = Class.new processor do
+        extend Forwardable
+
+        def_delegator :@handler, :use
+
+        define_method :initialize do |handler|
+          stack_delegator = Class.new StackDelegate
+          stack_delegator.module_eval do
+            rpcs.each do |method|
+              rpc_name = method.to_s.match(/^process_(.+)$/)[1]
+
+              define_method rpc_name.to_sym do |*args|
+                call RPC.new(rpc_name, args)
+              end
+            end
+          end
+
+          super stack_delegator.new(stack, handler)
+        end
+      end
+
+      wrapped
+    end
+  end
+end

data/lib/thrift_server/error_tracking_middleware.rb

@@ -0,0 +1,12 @@
+class ThriftServer
+  class ErrorTrackingMiddleware
+    include Concord.new(:app, :logger)
+
+    def call(rpc)
+      app.call rpc
+    rescue => ex
+      logger.track rpc, ex
+      raise ex
+    end
+  end
+end

data/lib/thrift_server/honeybadger_error_tracker.rb

@@ -0,0 +1,11 @@
+class ThriftServer
+  class HoneybadgerErrorTracker
+    def initialize(client = Honeybadger)
+      @client = client
+    end
+
+    def track(rpc, error)
+      @client.notify_or_ignore error
+    end
+  end
+end

data/lib/thrift_server/logging_middleware.rb

@@ -0,0 +1,13 @@
+class ThriftServer
+  class LoggingMiddleware
+    include Concord.new(:app, :logger)
+
+    def call(rpc)
+      logger.info "Incoming RPC: #{rpc.name}"
+      app.call rpc
+    rescue => ex
+      logger.error ex
+      raise ex
+    end
+  end
+end

data/lib/thrift_server/metrics_middleware.rb

@@ -0,0 +1,14 @@
+class ThriftServer
+  class MetricsMiddleware
+    include Concord.new(:app, :statsd)
+
+    def call(rpc)
+      statsd.time rpc.name do
+        app.call rpc
+      end
+    rescue => ex
+      statsd.increment 'errors'
+      raise ex
+    end
+  end
+end

data/lib/thrift_server/version.rb

@@ -0,0 +1,3 @@
+class ThriftServer
+  VERSION = "0.1.0"
+end

data/script/buildbox/ci

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+set -eou pipefail
+
+make test-ci clean

data/script/buildbox/step_failed

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+set -eou pipefail
+
+make clean

data/test/acceptance_test.rb

@@ -0,0 +1,225 @@
+require_relative 'test_helper'
+
+class AcceptanceTest < MiniTest::Unit::TestCase
+  attr_reader :processor
+
+  def setup
+    @processor = Processor(:getItems)
+  end
+
+  def wrap(klass, &block)
+    ThriftServer.wrap(processor, {
+      logger: NullLogger.new,
+      statsd: FakeStatsd.new,
+      error_tracker: NullErrorTracker.new,
+    }, &block)
+  end
+
+  def test_wrap_fails_if_no_logger
+    ex = assert_raises ArgumentError do
+      ThriftServer.wrap(processor, {
+        statsd: FakeStatsd.new,
+        error_tracker: NullErrorTracker.new,
+      })
+    end
+
+    assert_match /logger/, ex.to_s
+  end
+
+  def test_wrap_fails_if_no_stats
+    ex = assert_raises ArgumentError do
+      ThriftServer.wrap(processor, {
+        logger: NullLogger.new,
+        error_tracker: NullErrorTracker.new,
+      })
+    end
+
+    assert_match /statsd/, ex.to_s
+  end
+
+  def test_wrap_fails_if_no_error_tracker
+    ex = assert_raises ArgumentError do
+      ThriftServer.wrap(processor, {
+        logger: NullLogger.new,
+        statsd: FakeStatsd.new
+      })
+    end
+
+    assert_match /error_tracker/, ex.to_s
+  end
+
+  def test_wraps_methods_defined_by_the_protocol
+    handler = stub
+    handler.expects(:getItems).with(:request).returns(:response)
+
+    stack = wrap(processor).new(handler)
+
+    assert_equal :response, stack.process_getItems(:request)
+  end
+
+  def test_can_add_new_middleware_after_wrapping
+    handler = mock
+    handler.expects(:getItems).with(:modified_args)
+
+    stack = wrap(processor).new(handler)
+
+    test_middleware = Class.new do
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env.args = :modified_args
+        @app.call env
+      end
+    end
+
+    stack.use test_middleware
+
+    stack.process_getItems :request
+  end
+
+  def test_cannot_add_middleware_to_stack_after_first_rpc
+    handler = stub getItems: :response
+
+    stack = wrap(processor).new(handler)
+
+    stack.process_getItems :request
+
+    ex = assert_raises RuntimeError do
+      stack.use ->(rpc) { rpc }
+    end
+
+    assert_match /frozen/, ex.to_s
+  end
+
+  def test_wrap_yields_the_middleware_stack
+    handler = mock
+    handler.expects(:getItems).with(:from_block)
+
+    test_middleware = Class.new do
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env.args = :from_block
+        @app.call env
+      end
+    end
+
+    stack_processor = wrap processor do |stack|
+      stack.use test_middleware
+    end
+    stack = stack_processor.new(handler)
+
+    stack.process_getItems :request
+  end
+
+  def test_build_returns_thread_pool_server
+    handler = stub getItems: :response
+    server = ThriftServer.build(processor, handler, {
+      logger: NullLogger.new,
+      statsd: FakeStatsd.new,
+      error_tracker: NullErrorTracker.new
+    })
+
+    assert_instance_of Thrift::ThreadPoolServer, server
+  end
+
+  def test_build_defaults_to_port_9090
+    handler = stub getItems: :response
+    server = ThriftServer.build(processor, handler, {
+      logger: NullLogger.new,
+      statsd: FakeStatsd.new,
+      error_tracker: NullErrorTracker.new
+    })
+
+    assert_equal 9090, server.port
+  end
+
+  def test_build_accepts_port_options
+    handler = stub getItems: :response
+    server = ThriftServer.build(processor, handler, {
+      logger: NullLogger.new,
+      statsd: FakeStatsd.new,
+      error_tracker: NullErrorTracker.new,
+      port: 5000
+    })
+
+    assert_equal 5000, server.port
+  end
+
+  def test_build_defaults_to_4_threads
+    handler = stub getItems: :response
+    server = ThriftServer.build(processor, handler, {
+      logger: NullLogger.new,
+      statsd: FakeStatsd.new,
+      error_tracker: NullErrorTracker.new
+    })
+
+    assert_equal 4, server.threads
+  end
+
+  def test_build_accepts_threads_option
+    handler = stub getItems: :response
+    server = ThriftServer.build(processor, handler, {
+      logger: NullLogger.new,
+      statsd: FakeStatsd.new,
+      error_tracker: NullErrorTracker.new,
+      threads: 8
+    })
+
+    assert_equal 8, server.threads
+  end
+
+  def test_builds_creates_server_with_framed_transport
+    handler = stub getItems: :response
+    server = ThriftServer.build(processor, handler, {
+      logger: NullLogger.new,
+      statsd: FakeStatsd.new,
+      error_tracker: NullErrorTracker.new
+    })
+
+    assert_instance_of Thrift::FramedTransportFactory, server.transport_factory
+  end
+
+  def test_build_uses_server_socket_transport
+    handler = stub getItems: :response
+    server = ThriftServer.build(processor, handler, {
+      logger: NullLogger.new,
+      statsd: FakeStatsd.new,
+      error_tracker: NullErrorTracker.new
+    })
+
+    assert_instance_of Thrift::ServerSocket, server.server_transport
+  end
+
+  def test_build_creates_server_with_binary_protocol
+    handler = stub getItems: :response
+    server = ThriftServer.build(processor, handler, {
+      logger: NullLogger.new,
+      statsd: FakeStatsd.new,
+      error_tracker: NullErrorTracker.new
+    })
+
+    assert_instance_of Thrift::BinaryProtocolFactory, server.protocol_factory
+  end
+
+  def test_buil_accepts_a_block_to_customize_the_middleware_stack
+    handler = stub getItems: :response
+    block_yielded = false
+
+    server = ThriftServer.build(processor, handler, {
+      logger: NullLogger.new,
+      statsd: FakeStatsd.new,
+      error_tracker: NullErrorTracker.new
+    }) do |stack|
+      block_yielded = true
+
+      assert_instance_of ThriftServer::MiddlewareStack, stack
+    end
+
+    assert block_yielded, 'Block not used'
+  end
+end

data/test/error_tracking_middleware_test.rb

@@ -0,0 +1,25 @@
+require_relative 'test_helper'
+
+class ErrorTrackingMiddlewareTest < MiniTest::Unit::TestCase
+  attr_reader :rpc
+
+  def setup
+    @rpc = ThriftServer::RPC.new :foo, :bar
+  end
+
+  def test_logs_errors
+    error = TestError.new
+
+    logger = mock
+    logger.expects(:track).with(rpc, error)
+
+    app = stub
+    app.stubs(:call).raises(error)
+
+    middleware = ThriftServer::ErrorTrackingMiddleware.new app, logger
+
+    assert_raises TestError do
+      middleware.call rpc
+    end
+  end
+end

data/test/honeybadger_error_tracking_test.rb

@@ -0,0 +1,12 @@
+require_relative 'test_helper'
+
+class HoneybadgerErrorTrackerTest < MiniTest::Unit::TestCase
+  def test_logs_according_to_honeybadger_api
+    client = mock
+    client.expects(:notify_or_ignore).with(:error)
+
+    tracker = ThriftServer::HoneybadgerErrorTracker.new client
+
+    tracker.track :rpc, :error
+  end
+end

data/test/logging_middleware_test.rb

@@ -0,0 +1,42 @@
+require_relative 'test_helper'
+
+class LoggingMiddlewareTest < MiniTest::Unit::TestCase
+  attr_reader :output, :logger, :rpc
+
+  def setup
+    @output = StringIO.new
+    @logger = Logger.new output
+    @rpc = ThriftServer::RPC.new :foo, :bar
+  end
+
+  def test_logs_incoming_rpcs_names
+    app = stub call: :result
+
+    middleware = ThriftServer::LoggingMiddleware.new(app, logger)
+
+    middleware.call rpc
+
+    assert_logged output, 'INFO'
+    assert_logged output, rpc.name
+  end
+
+  def test_logs_errors
+    app = stub
+    app.stubs(:call).raises(TestError)
+
+    middleware = ThriftServer::LoggingMiddleware.new(app, logger)
+
+    assert_raises TestError do
+      middleware.call rpc
+    end
+
+    assert_logged output, 'ERROR'
+    assert_logged output, 'TestError'
+  end
+
+  private
+  def assert_logged(log, text)
+    log.rewind
+    assert log.read.include?(text.to_s), "#{text} not logged"
+  end
+end

data/test/metrics_middleware_test.rb

@@ -0,0 +1,51 @@
+require_relative 'test_helper'
+
+class MetricsMiddlewareTest < MiniTest::Unit::TestCase
+  attr_reader :rpc
+
+  def setup
+    @rpc = ThriftServer::RPC.new :foo, :bar
+  end
+
+  def test_times_the_rpc
+    app = stub call: :result
+
+    statsd = Class.new FakeStatsd do
+      attr_reader :timer
+
+      def time(*args)
+        @timer = args.first
+        yield
+      end
+    end.new
+
+    middleware = ThriftServer::MetricsMiddleware.new(app, statsd)
+
+    middleware.call rpc
+
+    assert statsd.timer, 'Timer not recorded'
+    assert_equal rpc.name, statsd.timer
+  end
+
+  def test_increments_a_counter_on_failed_rpcs
+    app = stub
+    app.stubs(:call).raises(TestError)
+
+    statsd = Class.new FakeStatsd do
+      attr_reader :counter
+
+      def increment(*args)
+        @counter = args.first
+      end
+    end.new
+
+    middleware = ThriftServer::MetricsMiddleware.new(app, statsd)
+
+    assert_raises TestError do
+      middleware.call rpc
+    end
+
+    assert statsd.counter, 'Counter not updated'
+    assert_equal 'errors', statsd.counter
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,60 @@
+require 'bundler/setup'
+require 'thrift_server'
+
+require 'stringio'
+require 'logger-better'
+
+require 'minitest/autorun'
+require 'mocha/mini_test'
+
+TestError = Class.new StandardError
+
+class FakeStatsd
+  def time(*)
+    yield
+  end
+
+  def increment(*)
+
+  end
+end
+
+class NullErrorTracker
+  def track(*)
+
+  end
+end
+
+def Processor(*rpcs)
+  Class.new do
+    def initialize(handler)
+      @handler = handler
+    end
+
+    rpcs.each do |method_name|
+      define_method "process_#{method_name}" do |*args|
+        # nothing to do, this is just a stub to create objects inline
+        # with the generate thrift processors
+        @handler.send method_name, *args
+      end
+    end
+  end
+end
+
+# Monkey patch attr readers to test various server settings
+module Thrift
+  class ServerSocket
+    attr_reader :port
+  end
+
+  class ThreadPoolServer
+    attr_reader :server_transport, :transport_factory, :protocol_factory
+    def threads
+      @thread_q.max
+    end
+
+    def port
+      server_transport.port
+    end
+  end
+end

data/thrift_server.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'thrift_server/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "thrift_server"
+  spec.version       = ThriftServer::VERSION
+  spec.authors       = ["ahawkins"]
+  spec.email         = ["adam@saltside.se"]
+  spec.summary       = %q{Encapsulate error handling, logging, and metrics for thrift servers}
+  spec.description   = %q{}
+  spec.homepage      = "https://github.com/saltside/thrift_server-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "statsd-ruby"
+  spec.add_dependency "middleware"
+  spec.add_dependency "concord"
+  spec.add_dependency "honeybadger"
+  spec.add_dependency "thrift"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "logger-better"
+  spec.add_development_dependency "benchmark-ips"
+end

metadata

@@ -0,0 +1,218 @@
+--- !ruby/object:Gem::Specification
+name: thrift_server
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ahawkins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: statsd-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: concord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: honeybadger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thrift
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: logger-better
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- adam@saltside.se
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".dockerignore"
+- ".gitignore"
+- Dockerfile
+- Gemfile
+- LICENSE.txt
+- Makefile
+- README.md
+- Rakefile
+- Vagrantfile
+- benchmark/server.rb
+- echo_client.rb
+- echo_server.rb
+- echo_service.thrift
+- lib/thrift_server.rb
+- lib/thrift_server/error_tracking_middleware.rb
+- lib/thrift_server/honeybadger_error_tracker.rb
+- lib/thrift_server/logging_middleware.rb
+- lib/thrift_server/metrics_middleware.rb
+- lib/thrift_server/version.rb
+- script/buildbox/ci
+- script/buildbox/step_failed
+- test/acceptance_test.rb
+- test/error_tracking_middleware_test.rb
+- test/honeybadger_error_tracking_test.rb
+- test/logging_middleware_test.rb
+- test/metrics_middleware_test.rb
+- test/test_helper.rb
+- thrift_server.gemspec
+homepage: https://github.com/saltside/thrift_server-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Encapsulate error handling, logging, and metrics for thrift servers
+test_files:
+- test/acceptance_test.rb
+- test/error_tracking_middleware_test.rb
+- test/honeybadger_error_tracking_test.rb
+- test/logging_middleware_test.rb
+- test/metrics_middleware_test.rb
+- test/test_helper.rb