thrifter 0.1.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f749536c8bf5a2560c17986f6ef8a38828aedc22
-  data.tar.gz: 3a1e08e6e213162ac77ceffb70c329bfa7ce0756
+  metadata.gz: d7eda9c8d9e79e117d147b9e6bca186d85c538dc
+  data.tar.gz: b00587a8f32c3690c68f504343b4a650026d0299
 SHA512:
-  metadata.gz: 6429f24abd079c31a99e0701dbe051d9f63716776175028a56c9a65526486fc606cdcc8e107ccffcad77ae9cc75c2c52c84dbe2f24fb611f77cd5cb105f48686
-  data.tar.gz: 4344478d6dc7553594d54b89f274ad4854e196e01c20d36fc219fbc356113068282fa6e113611ced192e6add67b693b85706f5535cfa82b70ddaf377e0193a21
+  metadata.gz: ad10cce350e1a4f0690c39aec5f80cdefa40415309ec19162bdfbd410be8d40bd2af861628215e8de6946271c7e1b945b9eab815722e647b2bb82177fba11e0c
+  data.tar.gz: a156b72b2740ea7f145c5add008ead3212483484ad2020b4e47e3e02ef7b911dfcea0fc9095f7386c81e1a612750f9d11ed52059babe339cde0327183deea041

data/README.md

@@ -30,7 +30,7 @@ Or install it yourself as:
 
 ## Usage
 
-`Thrifer` is a factory (similar to `DelegateClass`) for building
+`Thrifter` is a factory (similar to `DelegateClass`) for building
 client classes. It can be used like `DelegateClass` or like `Struct`.
 The result is subclasses of `Thrifter::Client`. The classes use the
 same methods to make RPCs. For example if the thrift service has a
@@ -42,7 +42,7 @@ RPC. Here are some examples.
 ServiceClient = Thrifter.build(MyService::Client)
 
 The struct style take a block as well
-ServiceClient = Thrifer.build(MyService::Client) do
+ServiceClient = Thrifter.build(MyService::Client) do
   def custom_method(args)
     # something something
   end
@@ -65,7 +65,7 @@ production vs test). All settings are documented below. `uri` is the
 most important! It must be set to instantiate clients.
 
 ```ruby
-class MyClient < Thrifer.build(MyService::Client)
+class MyClient < Thrifter.build(MyService::Client)
   # Thrift specific things
   config.transport = Thrift::FramedTransport
   config.protocol = Thrift::BinaryTransport
@@ -76,6 +76,7 @@ class MyClient < Thrifer.build(MyService::Client)
 
   # Network Settings
   config.rpc_timeout = 0.15
+  config.keep_alive = true
 
   # Required to instantiate the client!
   config.uri = 'tcp://foo:2383'
@@ -168,15 +169,15 @@ solution for different use cases.
 #### Pinging
 
 Components in a system may need to inquire if other systems are
-available before continuing. `Thrifer::Ping` is just that.
+available before continuing. `Thrifter::Ping` is just that.
 `Thrifter::Ping` assumes the service has a `ping` RPC. If your
 service does not have one (or is named differently) simply implement
 the `ping` method on the class. Any successful response will count as
 up, anything else will not.
 
 ```ruby
-class MyService < Thrifer.build(MyService::Client)
-  include Thrifer::Ping
+class MyService < Thrifter.build(MyService::Client)
+  include Thrifter::Ping
 
   # Define a ping method if the service does not have one
   def ping
@@ -215,7 +216,7 @@ middleware in whatever code configurres that environment. Only static
 middleware should be configured directly in the class itself.
 
 A middleware must implement the `call` method and accept at least one
-argument to `initialize`. The `call` method recieves a `Thrifer::RPC`.
+argument to `initialize`. The `call` method recieves a `Thrifter::RPC`.
 `Thrifter::RPC` is a sipmle struct with a `name` and `args` methods.
 Here's an example:
 

data/lib/thrifter.rb

@@ -12,6 +12,10 @@ require 'middleware'
 require 'connection_pool'
 
 module Thrifter
+  ClientError = Tnt.boom do |ex|
+    "#{ex.class}: #{ex.message}"
+  end
+
   RPC = Struct.new(:name, :args)
 
   class MiddlewareStack < Middleware::Builder
@@ -40,6 +44,7 @@ module Thrifter
   Configuration = Struct.new :transport, :protocol,
     :pool_size, :pool_timeout,
     :uri, :rpc_timeout,
+    :keep_alive,
     :stack, :statsd
 
   class << self
@@ -76,13 +81,21 @@ module Thrifter
 
   class Client
     class Dispatcher
-      include Concord.new(:app, :transport, :client)
+      attr_reader :app, :transport, :client, :config
+
+      def initialize(app, transport, client, config)
+        @app, @transport, @client, @config = app, transport, client, config
+      end
 
       def call(rpc)
-        transport.open
-        client.send rpc.name, *rpc.args
-      ensure
+        transport.open unless transport.open?
+
+        client.send(rpc.name, *rpc.args).tap do
+          transport.close unless config.keep_alive
+        end
+      rescue => ex
         transport.close
+        raise ex
       end
     end
 
@@ -114,11 +127,12 @@ module Thrifter
       def inherited(base)
         base.config = Configuration.new
         base.configure do |config|
+          config.keep_alive = true
           config.transport = Thrift::FramedTransport
           config.protocol = Thrift::BinaryProtocol
           config.pool_size = 12
-          config.pool_timeout = 0.1
-          config.rpc_timeout = 0.3
+          config.pool_timeout = 2
+          config.rpc_timeout = 2
           config.statsd = NullStatsd.new
           config.stack = MiddlewareStack.new
         end
@@ -142,7 +156,8 @@ module Thrifter
         # Insert metrics here so metrics are as close to the network
         # as possible. This excludes time in any middleware an
         # application may have configured.
-        stack.use Metrics, config.statsd
+        stack.use ClientMetrics, config.statsd
+        stack.use RpcMetrics, config.statsd
 
         if client
           stack.use DirectDispatcher, client
@@ -151,7 +166,7 @@ module Thrifter
           transport = config.transport.new socket
           protocol = config.protocol.new transport
 
-          stack.use Dispatcher, transport, client_class.new(protocol)
+          stack.use Dispatcher, transport, client_class.new(protocol), config
         end
 
         stack.finalize!
@@ -181,4 +196,5 @@ require_relative 'thrifter/extensions/retriable'
 
 require_relative 'thrifter/middleware/error_wrapping'
 require_relative 'thrifter/middleware/validation'
-require_relative 'thrifter/middleware/metrics'
+require_relative 'thrifter/middleware/client_metrics'
+require_relative 'thrifter/middleware/rpc_metrics'

data/lib/thrifter/extensions/retriable.rb

@@ -1,10 +1,11 @@
 module Thrifter
-  RetryError = Tnt.boom do |count, rpc|
-    "#{rpc} RPC unsuccessful after #{count} times"
+  RetryError = Tnt.boom do |count, rpc, exception|
+    "#{rpc} RPC unsuccessful after #{count} times. #{exception.class}: #{exception.message}"
   end
 
   module Retry
-    RETRIABLE_ERRORS = [
+    DEFAULT_RETRIABLE_ERRORS = [
+      ClientError,
       Thrift::TransportException,
       Thrift::ProtocolException,
       Thrift::ApplicationException,
@@ -17,10 +18,13 @@ module Thrifter
     ]
 
     class Proxy < BasicObject
-      attr_reader :tries, :interval, :client
+      attr_reader :tries, :interval, :client, :retriable
 
-      def initialize(client, tries, interval)
-        @client, @tries, @interval = client, tries, interval
+      def initialize(client, tries, interval, retriable)
+        @client = client
+        @tries = tries
+        @interval = interval
+        @retriable = DEFAULT_RETRIABLE_ERRORS + Array(retriable)
       end
 
       private
@@ -35,19 +39,19 @@ module Thrifter
         begin
           counter = counter + 1
           client.send name, *args
-        rescue *RETRIABLE_ERRORS => ex
+        rescue *retriable => ex
           if counter < tries
             sleep interval
             retry
           else
-            raise RetryError.new(tries, name)
+            raise RetryError.new(tries, name, ex)
           end
         end
       end
     end
 
-    def with_retry(tries: 5, interval: 0.01)
-      proxy = Proxy.new self, tries, interval
+    def with_retry(tries: 5, interval: 0.01, retriable: [ ])
+      proxy = Proxy.new self, tries, interval, retriable
       yield proxy if block_given?
       proxy
     end

data/lib/thrifter/middleware/client_metrics.rb

@@ -0,0 +1,37 @@
+module Thrifter
+  class ClientMetrics
+    include Concord.new(:app, :statsd)
+
+    def call(rpc)
+      statsd.increment 'rpc.outgoing'
+
+      response = statsd.time "rpc.latency" do #{rpc.name do
+        app.call rpc
+      end
+
+      statsd.increment 'rpc.success'
+
+      response
+    rescue Thrift::TransportException => ex
+      statsd.increment 'rpc.error'
+      statsd.increment 'rpc.error.transport'
+      raise ex
+    rescue Thrift::ProtocolException => ex
+      statsd.increment 'rpc.error'
+      statsd.increment 'rpc.error.protocol'
+      raise ex
+    rescue Thrift::ApplicationException => ex
+      statsd.increment 'rpc.error'
+      statsd.increment 'rpc.error.application'
+      raise ex
+    rescue Timeout::Error => ex
+      statsd.increment 'rpc.error'
+      statsd.increment 'rpc.error.timeout'
+      raise ex
+    rescue => ex
+      statsd.increment 'rpc.error'
+      statsd.increment 'rpc.error.other'
+      raise ex
+    end
+  end
+end

data/lib/thrifter/middleware/error_wrapping.rb

@@ -1,8 +1,4 @@
 module Thrifter
-  ClientError = Tnt.boom do |ex|
-    "#{ex.class}: #{ex.message}"
-  end
-
   class ErrorWrapping
     WRAP = [
       Thrift::TransportException,

data/lib/thrifter/middleware/rpc_metrics.rb

@@ -0,0 +1,86 @@
+module Thrifter
+  class RpcMetrics
+    include Concord.new(:app, :statsd)
+
+    def call(rpc)
+      statsd.increment "rpc.#{rpc.name}.outgoing"
+
+      response = statsd.time "rpc.#{rpc.name}.latency" do
+        app.call rpc
+      end
+
+      statsd.increment "rpc.#{rpc.name}.success"
+
+      response
+    rescue Thrift::TransportException => ex
+      statsd.increment "rpc.#{rpc.name}.error"
+      case ex.type
+      when Thrift::TransportException::UNKNOWN
+        statsd.increment "rpc.#{rpc.name}.error.transport.unknown"
+      when Thrift::TransportException::NOT_OPEN
+        statsd.increment "rpc.#{rpc.name}.error.transport.not_open"
+      when Thrift::TransportException::ALREADY_OPEN
+        statsd.increment "rpc.#{rpc.name}.error.transport.already_open"
+      when Thrift::TransportException::TIMED_OUT
+        statsd.increment "rpc.#{rpc.name}.error.transport.timeout"
+      when Thrift::TransportException::END_OF_FILE
+        statsd.increment "rpc.#{rpc.name}.error.transport.eof"
+      end
+      raise ex
+    rescue Thrift::ProtocolException => ex
+      statsd.increment "rpc.#{rpc.name}.error"
+      case ex.type
+      when Thrift::ProtocolException::UNKNOWN
+        statsd.increment "rpc.#{rpc.name}.error.protocol.unknown"
+      when Thrift::ProtocolException::INVALID_DATA
+        statsd.increment "rpc.#{rpc.name}.error.protocol.invalid_data"
+      when Thrift::ProtocolException::NEGATIVE_SIZE
+        statsd.increment "rpc.#{rpc.name}.error.protocol.negative_size"
+      when Thrift::ProtocolException::SIZE_LIMIT
+        statsd.increment "rpc.#{rpc.name}.error.protocol.size_limit"
+      when Thrift::ProtocolException::BAD_VERSION
+        statsd.increment "rpc.#{rpc.name}.error.protocol.bad_version"
+      when Thrift::ProtocolException::NOT_IMPLEMENTED
+        statsd.increment "rpc.#{rpc.name}.error.protocol.not_implemented"
+      when Thrift::ProtocolException::DEPTH_LIMIT
+        statsd.increment "rpc.#{rpc.name}.error.protocol.depth_limit"
+      end
+      raise ex
+    rescue Thrift::ApplicationException => ex
+      statsd.increment "rpc.#{rpc.name}.error"
+      case ex.type
+      when Thrift::ApplicationException::UNKNOWN
+        statsd.increment "rpc.#{rpc.name}.error.application.unknown"
+      when Thrift::ApplicationException::UNKNOWN_METHOD
+        statsd.increment "rpc.#{rpc.name}.error.application.unknown_method"
+      when Thrift::ApplicationException::INVALID_MESSAGE_TYPE
+        statsd.increment "rpc.#{rpc.name}.error.application.invalid_message_type"
+      when Thrift::ApplicationException::WRONG_METHOD_NAME
+        statsd.increment "rpc.#{rpc.name}.error.application.wrong_method_name"
+      when Thrift::ApplicationException::BAD_SEQUENCE_ID
+        statsd.increment "rpc.#{rpc.name}.error.application.bad_sequence_id"
+      when Thrift::ApplicationException::MISSING_RESULT
+        statsd.increment "rpc.#{rpc.name}.error.application.missing_result"
+      when Thrift::ApplicationException::INTERNAL_ERROR
+        statsd.increment "rpc.#{rpc.name}.error.application.internal_error"
+      when Thrift::ApplicationException::PROTOCOL_ERROR
+        statsd.increment "rpc.#{rpc.name}.error.application.protocol_error"
+      when Thrift::ApplicationException::INVALID_TRANSFORM
+        statsd.increment "rpc.#{rpc.name}.error.application.invalid_transform"
+      when Thrift::ApplicationException::INVALID_PROTOCOL
+        statsd.increment "rpc.#{rpc.name}.error.application.invalid_protocol"
+      when Thrift::ApplicationException::UNSUPPORTED_CLIENT_TYPE
+        statsd.increment "rpc.#{rpc.name}.error.application.unsupported_client_type"
+      end
+      raise ex
+    rescue Timeout::Error => ex
+      statsd.increment "rpc.#{rpc.name}.error"
+      statsd.increment "rpc.#{rpc.name}.error.timeout"
+      raise ex
+    rescue => ex
+      statsd.increment "rpc.#{rpc.name}.error"
+      statsd.increment "rpc.#{rpc.name}.error.other"
+      raise ex
+    end
+  end
+end

data/lib/thrifter/version.rb

@@ -1,3 +1,3 @@
 module Thrifter
-  VERSION = "0.1.3"
+  VERSION = "1.0.0"
 end

data/test/acceptance_test.rb

@@ -23,6 +23,11 @@ class AcceptanceTest < MiniTest::Unit::TestCase
     @uri = URI('tcp://localhost:9090')
   end
 
+  def test_defaults_to_keep_alive
+    client = Thrifter.build TestClient
+    assert client.config.keep_alive
+  end
+
   def test_defaults_to_framed_transport
     client = Thrifter.build TestClient
     assert_equal Thrift::FramedTransport, client.config.transport
@@ -40,12 +45,12 @@ class AcceptanceTest < MiniTest::Unit::TestCase
 
   def test_has_reasonable_default_pool_timeout
     client = Thrifter.build TestClient
-    assert_equal 0.1, client.config.pool_timeout
+    assert_equal 2, client.config.pool_timeout
   end
 
   def test_has_reasonable_default_rpc_timeout
     client = Thrifter.build TestClient
-    assert_equal 0.3, client.config.rpc_timeout
+    assert_equal 2, client.config.rpc_timeout
   end
 
   def test_defaults_to_null_statd
@@ -121,7 +126,7 @@ class AcceptanceTest < MiniTest::Unit::TestCase
     client = Thrifter.build TestClient
     client.config.uri = uri
 
-    socket, transport, protocol = stub, stub(open: nil, close: nil), stub
+    socket, transport, protocol = stub, stub(open: nil, close: nil, open?: false), stub
 
     Thrift::Socket.expects(:new).
       with(uri.host, uri.port, client.config.rpc_timeout).
@@ -210,10 +215,42 @@ class AcceptanceTest < MiniTest::Unit::TestCase
     assert_equal :stubbed_response, thrifter.echo(:request)
   end
 
-  def test_close_the_transport_on_successful_rpc
-    transport = mock
+  def test_does_not_close_transport_when_keep_alive_set
+    transport = mock open?: false
+    client = Thrifter.build TestClient
+    client.config.keep_alive = true
+    client.config.uri = uri
+    client.config.transport.stubs(:new).returns(transport)
+
+    transport.expects(:open)
+    transport.expects(:close).never
+
+    thrifter = client.new
+    thrifter.echo message
+  end
+
+  def test_closes_transport_if_error_occurs_when_keep_alive_set
+    transport = mock open?: false
+    client = Thrifter.build BrokenTestClient
+    client.config.keep_alive = true
+    client.config.uri = uri
+    client.config.transport.stubs(:new).returns(transport)
+
+    transport.expects(:open)
+    transport.expects(:close)
+
+    thrifter = client.new
+
+    assert_raises SimulatedError do
+      thrifter.echo message
+    end
+  end
+
+  def test_close_the_transport_on_successful_rpc_when_no_keep_alive
+    transport = mock open?: false
     client = Thrifter.build TestClient
     client.config.uri = uri
+    client.config.keep_alive = false
     client.config.transport.stubs(:new).returns(transport)
 
     transport.expects(:open)
@@ -223,10 +260,11 @@ class AcceptanceTest < MiniTest::Unit::TestCase
     thrifter.echo message
   end
 
-  def test_close_the_transport_if_client_fails
-    transport = mock
+  def test_close_the_transport_if_rpc_fails_when_no_keep_alive
+    transport = mock open?: false
     client = Thrifter.build BrokenTestClient
     client.config.uri = uri
+    client.config.keep_alive = false
     client.config.transport.stubs(:new).returns(transport)
 
     transport.expects(:open)

data/test/extensions/retry_test.rb

@@ -2,6 +2,7 @@ require_relative '../test_helper'
 
 class RetryTest < MiniTest::Unit::TestCase
   JunkError = Class.new StandardError
+  KnownError = Class.new StandardError
 
   class RetryClient < Thrifter.build(TestService::Client)
     include Thrifter::Retry
@@ -14,7 +15,7 @@ class RetryTest < MiniTest::Unit::TestCase
   end
 
   def known_errors
-    Thrifter::Retry::RETRIABLE_ERRORS
+    Thrifter::Retry::DEFAULT_RETRIABLE_ERRORS
   end
 
   def test_does_not_retry_on_unexpected_errors
@@ -43,9 +44,39 @@ class RetryTest < MiniTest::Unit::TestCase
     assert :response == result, 'return value incorrect'
   end
 
+  def test_retries_on_exceptions_specified_explicitly
+    thrift_client = mock
+    retries = sequence(:retries)
+    thrift_client.expects(:echo).with(:request).in_sequence(retries).raises(KnownError)
+    thrift_client.expects(:echo).with(:request).in_sequence(retries).returns(:response)
+    TestService::Client.stubs(:new).returns(thrift_client)
+
+    client = RetryClient.new
+
+    result = client.with_retry({ tries: 2, interval: 0.01, retriable: KnownError }).echo(:request)
+
+    assert :response == result, 'return value incorrect'
+  end
+
+  def test_retries_on_exceptions_specified_in_array
+    thrift_client = mock
+    retries = sequence(:retries)
+    thrift_client.expects(:echo).with(:request).in_sequence(retries).raises(KnownError)
+    thrift_client.expects(:echo).with(:request).in_sequence(retries).returns(:response)
+    TestService::Client.stubs(:new).returns(thrift_client)
+
+    client = RetryClient.new
+
+    result = client.with_retry({ tries: 2, interval: 0.01, retriable: [ KnownError ] }).echo(:request)
+
+    assert :response == result, 'return value incorrect'
+  end
+
   def test_fails_if_does_not_respond_successfully
+    err = known_errors.sample
+
     thrift_client = mock
-    thrift_client.expects(:echo).with(:request).raises(known_errors.sample).times(5)
+    thrift_client.expects(:echo).with(:request).raises(err).times(5)
     TestService::Client.stubs(:new).returns(thrift_client)
 
     client = RetryClient.new
@@ -56,6 +87,7 @@ class RetryTest < MiniTest::Unit::TestCase
 
     assert_match /5/, error.message, 'Error not descriptive'
     assert_match /echo/, error.message, 'Error not descriptive'
+    assert_match /#{err.to_s}/, error.message, 'Missing error details'
   end
 
   def test_retries_on_application_exception
@@ -74,6 +106,10 @@ class RetryTest < MiniTest::Unit::TestCase
     assert_includes known_errors, Timeout::Error
   end
 
+  def test_retries_on_wrapped_client_error
+    assert_includes known_errors, Thrifter::ClientError
+  end
+
   def test_retries_on_econrefused
     assert_includes known_errors, Errno::ECONNREFUSED
   end

data/test/middleware/{metrics_test.rb → client_metrics_test.rb}

@@ -1,6 +1,6 @@
 require_relative '../test_helper'
 
-class MetricsTest < MiniTest::Unit::TestCase
+class ClientMetricsTest < MiniTest::Unit::TestCase
   attr_reader :rpc
 
   def setup
@@ -9,14 +9,16 @@ class MetricsTest < MiniTest::Unit::TestCase
     @rpc = Thrifter::RPC.new(:foo, :args)
   end
 
-  def test_times_each_rpc
+  def test_happy_path_calls
     app = stub
     app.stubs(:call).with(rpc)
 
     statsd = mock
-    statsd.expects(:time).with(rpc.name).yields.returns(:response)
+    statsd.expects(:time).with('rpc.latency').yields.returns(:response)
+    statsd.expects(:increment).with('rpc.success')
+    statsd.expects(:increment).with('rpc.outgoing')
 
-    middleware = Thrifter::Metrics.new app, statsd
+    middleware = Thrifter::ClientMetrics.new app, statsd
     result = middleware.call rpc
 
     assert :response == result, 'Return value incorrect'
@@ -28,9 +30,11 @@ class MetricsTest < MiniTest::Unit::TestCase
 
     statsd = mock
     statsd.expects(:time).yields
-    statsd.expects(:increment).with('errors.transport')
+    statsd.expects(:increment).with('rpc.outgoing')
+    statsd.expects(:increment).with('rpc.error.transport')
+    statsd.expects(:increment).with('rpc.error')
 
-    middleware = Thrifter::Metrics.new app, statsd
+    middleware = Thrifter::ClientMetrics.new app, statsd
 
     assert_raises Thrift::TransportException do
       middleware.call rpc
@@ -43,9 +47,11 @@ class MetricsTest < MiniTest::Unit::TestCase
 
     statsd = mock
     statsd.expects(:time).yields
-    statsd.expects(:increment).with('errors.protocol')
+    statsd.expects(:increment).with('rpc.outgoing')
+    statsd.expects(:increment).with('rpc.error.protocol')
+    statsd.expects(:increment).with('rpc.error')
 
-    middleware = Thrifter::Metrics.new app, statsd
+    middleware = Thrifter::ClientMetrics.new app, statsd
 
     assert_raises Thrift::ProtocolException do
       middleware.call rpc
@@ -58,9 +64,11 @@ class MetricsTest < MiniTest::Unit::TestCase
 
     statsd = mock
     statsd.expects(:time).yields
-    statsd.expects(:increment).with('errors.application')
+    statsd.expects(:increment).with('rpc.outgoing')
+    statsd.expects(:increment).with('rpc.error.application')
+    statsd.expects(:increment).with('rpc.error')
 
-    middleware = Thrifter::Metrics.new app, statsd
+    middleware = Thrifter::ClientMetrics.new app, statsd
 
     assert_raises Thrift::ApplicationException do
       middleware.call rpc
@@ -73,9 +81,11 @@ class MetricsTest < MiniTest::Unit::TestCase
 
     statsd = mock
     statsd.expects(:time).yields
-    statsd.expects(:increment).with('errors.timeout')
+    statsd.expects(:increment).with('rpc.outgoing')
+    statsd.expects(:increment).with('rpc.error.timeout')
+    statsd.expects(:increment).with('rpc.error')
 
-    middleware = Thrifter::Metrics.new app, statsd
+    middleware = Thrifter::ClientMetrics.new app, statsd
 
     assert_raises Timeout::Error do
       middleware.call rpc
@@ -88,9 +98,11 @@ class MetricsTest < MiniTest::Unit::TestCase
 
     statsd = mock
     statsd.expects(:time).yields
-    statsd.expects(:increment).with('errors.other')
+    statsd.expects(:increment).with('rpc.outgoing')
+    statsd.expects(:increment).with('rpc.error.other')
+    statsd.expects(:increment).with('rpc.error')
 
-    middleware = Thrifter::Metrics.new app, statsd
+    middleware = Thrifter::ClientMetrics.new app, statsd
 
     assert_raises StandardError do
       middleware.call rpc

data/test/middleware/rpc_metrics_test.rb

@@ -0,0 +1,497 @@
+require_relative '../test_helper'
+
+class RpcMetricsTest < MiniTest::Unit::TestCase
+  attr_reader :rpc
+
+  def setup
+    super
+
+    @rpc = Thrifter::RPC.new(:foo, :args)
+  end
+
+  def test_happy_path
+    app = stub
+    app.stubs(:call).with(rpc)
+
+    statsd = mock
+    statsd.expects(:time).with("rpc.#{rpc.name}.latency").yields.returns(:response)
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.success")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+    result = middleware.call rpc
+
+    assert :response == result, 'Return value incorrect'
+  end
+
+  def test_counts_unknown_transport_exceptions_and_reraises
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::TransportException.new(
+      Thrift::TransportException::UNKNOWN
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.transport.unknown")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::TransportException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_not_open_transport_exceptions_and_reraises
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::TransportException.new(
+      Thrift::TransportException::NOT_OPEN
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.transport.not_open")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::TransportException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_already_open_transport_exceptions_and_reraises
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::TransportException.new(
+      Thrift::TransportException::ALREADY_OPEN
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.transport.already_open")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::TransportException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_timed_out_transport_exceptions_and_reraises
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::TransportException.new(
+      Thrift::TransportException::TIMED_OUT
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.transport.timeout")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::TransportException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_eof_transport_exceptions_and_reraises
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::TransportException.new(
+      Thrift::TransportException::END_OF_FILE
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.transport.eof")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::TransportException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_unknown_protocol_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ProtocolException.new(
+      Thrift::ProtocolException::UNKNOWN
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.protocol.unknown")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ProtocolException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_invalid_data_protocol_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ProtocolException.new(
+      Thrift::ProtocolException::INVALID_DATA
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.protocol.invalid_data")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ProtocolException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_negative_size_protocol_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ProtocolException.new(
+      Thrift::ProtocolException::NEGATIVE_SIZE
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.protocol.negative_size")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ProtocolException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_size_limit_protocol_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ProtocolException.new(
+      Thrift::ProtocolException::SIZE_LIMIT
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.protocol.size_limit")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ProtocolException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_bad_version_protocol_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ProtocolException.new(
+      Thrift::ProtocolException::BAD_VERSION
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.protocol.bad_version")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ProtocolException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_not_implemented_protocol_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ProtocolException.new(
+      Thrift::ProtocolException::NOT_IMPLEMENTED
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.protocol.not_implemented")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ProtocolException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_depth_limit_protocol_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ProtocolException.new(
+      Thrift::ProtocolException::DEPTH_LIMIT
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.protocol.depth_limit")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ProtocolException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_unknown_application_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ApplicationException.new(
+      Thrift::ApplicationException::UNKNOWN
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.application.unknown")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ApplicationException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_unknown_method_application_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ApplicationException.new(
+      Thrift::ApplicationException::UNKNOWN_METHOD
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.application.unknown_method")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ApplicationException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_invalid_message_type_application_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ApplicationException.new(
+      Thrift::ApplicationException::INVALID_MESSAGE_TYPE
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.application.invalid_message_type")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ApplicationException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_wrong_method_name_application_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ApplicationException.new(
+      Thrift::ApplicationException::WRONG_METHOD_NAME
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.application.wrong_method_name")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ApplicationException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_bad_sequence_id_application_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ApplicationException.new(
+      Thrift::ApplicationException::BAD_SEQUENCE_ID
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.application.bad_sequence_id")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ApplicationException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_missing_result_application_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ApplicationException.new(
+      Thrift::ApplicationException::MISSING_RESULT
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.application.missing_result")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ApplicationException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_internal_error_application_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ApplicationException.new(
+      Thrift::ApplicationException::INTERNAL_ERROR
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.application.internal_error")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ApplicationException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_protocol_error_application_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ApplicationException.new(
+      Thrift::ApplicationException::PROTOCOL_ERROR
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.application.protocol_error")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ApplicationException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_invalid_transform_application_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ApplicationException.new(
+      Thrift::ApplicationException::INVALID_TRANSFORM
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.application.invalid_transform")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ApplicationException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_invalid_protocol_application_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ApplicationException.new(
+      Thrift::ApplicationException::INVALID_PROTOCOL
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.application.invalid_protocol")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ApplicationException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_unsupported_client_type_application_exceptions
+    app = stub
+    app.stubs(:call).with(rpc).raises(Thrift::ApplicationException.new(
+      Thrift::ApplicationException::UNSUPPORTED_CLIENT_TYPE
+    ))
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.application.unsupported_client_type")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Thrift::ApplicationException do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_timeouts
+    app = stub
+    app.stubs(:call).with(rpc).raises(Timeout::Error)
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.timeout")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises Timeout::Error do
+      middleware.call rpc
+    end
+  end
+
+  def test_counts_other_errors
+    app = stub
+    app.stubs(:call).with(rpc).raises(StandardError)
+
+    statsd = mock
+    statsd.expects(:time).yields
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error.other")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.outgoing")
+    statsd.expects(:increment).with("rpc.#{rpc.name}.error")
+
+    middleware = Thrifter::RpcMetrics.new app, statsd
+
+    assert_raises StandardError do
+      middleware.call rpc
+    end
+  end
+end

data/test/test_helper.rb

@@ -23,6 +23,10 @@ class FakeTransport
 
   end
 
+  def open?
+    false
+  end
+
   def close
 
   end

data/thrifter.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.name          = "thrifter"
   spec.version       = Thrifter::VERSION
   spec.authors       = ["ahawkins"]
-  spec.email         = ["adam@hawkins.io"]
+  spec.email         = ["hi@ahawkins.me"]
   spec.summary       = %q{Production ready Thrift client with improved semantics}
   spec.description   = %q{}
   spec.homepage      = "https://github.com/saltside/thrifter"
@@ -30,7 +30,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "mocha"
-  spec.add_development_dependency "sidekiq"
+  spec.add_development_dependency "sidekiq", "~> 4.2"
   spec.add_development_dependency "sidekiq-thrift_arguments"
   spec.add_development_dependency "eventmachine"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: thrifter
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 1.0.0
 platform: ruby
 authors:
 - ahawkins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-07 00:00:00.000000000 Z
+date: 2017-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thrift
@@ -168,16 +168,16 @@ dependencies:
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: sidekiq-thrift_arguments
   requirement: !ruby/object:Gem::Requirement
@@ -208,7 +208,7 @@ dependencies:
         version: '0'
 description: ''
 email:
-- adam@hawkins.io
+- hi@ahawkins.me
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -227,8 +227,9 @@ files:
 - lib/thrifter/extensions/ping.rb
 - lib/thrifter/extensions/queueing.rb
 - lib/thrifter/extensions/retriable.rb
+- lib/thrifter/middleware/client_metrics.rb
 - lib/thrifter/middleware/error_wrapping.rb
-- lib/thrifter/middleware/metrics.rb
+- lib/thrifter/middleware/rpc_metrics.rb
 - lib/thrifter/middleware/validation.rb
 - lib/thrifter/version.rb
 - script/monkey-client
@@ -238,8 +239,9 @@ files:
 - test/extensions/ping_test.rb
 - test/extensions/queueing_test.rb
 - test/extensions/retry_test.rb
+- test/middleware/client_metrics_test.rb
 - test/middleware/error_wrapping_test.rb
-- test/middleware/metrics_test.rb
+- test/middleware/rpc_metrics_test.rb
 - test/middleware/validation_test.rb
 - test/test_helper.rb
 - thrifter.gemspec
@@ -266,7 +268,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Production ready Thrift client with improved semantics
@@ -275,7 +277,8 @@ test_files:
 - test/extensions/ping_test.rb
 - test/extensions/queueing_test.rb
 - test/extensions/retry_test.rb
+- test/middleware/client_metrics_test.rb
 - test/middleware/error_wrapping_test.rb
-- test/middleware/metrics_test.rb
+- test/middleware/rpc_metrics_test.rb
 - test/middleware/validation_test.rb
 - test/test_helper.rb

data/lib/thrifter/middleware/metrics.rb

@@ -1,26 +0,0 @@
-module Thrifter
-  class Metrics
-    include Concord.new(:app, :statsd)
-
-    def call(rpc)
-      statsd.time rpc.name do
-        app.call rpc
-      end
-    rescue Thrift::TransportException => ex
-      statsd.increment 'errors.transport'
-      raise ex
-    rescue Thrift::ProtocolException => ex
-      statsd.increment 'errors.protocol'
-      raise ex
-    rescue Thrift::ApplicationException => ex
-      statsd.increment 'errors.application'
-      raise ex
-    rescue Timeout::Error => ex
-      statsd.increment 'errors.timeout'
-      raise ex
-    rescue => ex
-      statsd.increment 'errors.other'
-      raise ex
-    end
-  end
-end