px-service-client 1.2.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db46c3146668dad3c40c3a5cabc1feaf4743b745
-  data.tar.gz: 94824bed638685d41404aee9739453fdc2f79280
+  metadata.gz: 9a10d1168c3cd74e1fb75eb062481a9aa8dfa25d
+  data.tar.gz: 81dd905f9e51020552ed8c655c11678e8fe5fdc5
 SHA512:
-  metadata.gz: 232d9cee11917707c1463cc1d53a9b1336225ef4cb22d5611a3dce074eb6b2feb9ca7e3b5420b69018f0d4acfa847407b37426519482ffd501df2c66875a1a59
-  data.tar.gz: 1d1b736be0ebc4a91957c09832a34ae892e16690d4f4df9dca211496bc6deb5c3d2f8f46e534999373b0ea51821453ce08cac9dd64a9c0e8bec64b8c2a85f340
+  metadata.gz: 53fce4eecc310c99c01ccf635de6616d46dc61edcfb40362657caf28390a99a3b6b51dc502812dbb5c4e006cd90d735295d812bfee4903452ceb2f4fe1069e5e
+  data.tar.gz: 43d57237b4ab1e3b8f2882baa419ad14fb784cce1f270690d11fcd72268ff046bb1b012c4b96236b08546666a5525e8817671e4b5a6f837bd2a2549eaf122833

data/README.md

@@ -38,14 +38,20 @@ This gem includes several common features used in 500px service client libraries
 The features are:
 
 #### Px::Service::Client::Base
-This class provides a basic `make_request(method, url, ...)` method that produces an asynchronous request. The method immediately returns a `Future`. It works together with `Multiplexer`(discussed below) and uses [Typhoeus](https://github.com/typhoeus/typhoeus)  as the underlying HTTP client to support asynchronicity. 
+This class provides a basic `make_request(method, url, ...)` method that produces an asynchronous request. The method immediately returns a `Future`. It works together with `Multiplexer`(discussed below) and uses [Typhoeus](https://github.com/typhoeus/typhoeus)  as the underlying HTTP client to support asynchronicity.
 
-**Customized clients usually inherit this class and include other features/mixins, if needed.**  
+**Clients should subclass this class and include other features/mixins, if needed.**  
+
+# Optional
+config do |config|
+  config.statsd_client = Statsd.new(host, port)
+end
 
-See the following secion for an example of how to use `make_request` and `Multiplexer`. 
+
+See the following section for an example of how to use `make_request` and `Multiplexer`.
 
 #### Px::Service::Client::Multiplexer
-This class works together with `Px::Service::Client::Base` sub-classes to support request parallel execution. 
+This class works together with `Px::Service::Client::Base` sub-classes to support request parallel execution.
 
 Example:
 
@@ -62,9 +68,9 @@ end
 multi.run # a blocking call, like hydra.run
 
 ```
-`multi.context` encapsulates the block into a [`Fiber`](http://ruby-doc.org/core-2.2.0/Fiber.html) object and immediately runs (or `resume`, in Fiber's term) that fiber until the block explicitly gives up control. The method returns `multi` itself. 
+`multi.context` encapsulates the block into a [`Fiber`](http://ruby-doc.org/core-2.2.0/Fiber.html) object and immediately runs (or `resume`, in Fiber's term) that fiber until the block explicitly gives up control. The method returns `multi` itself.
 
-`multi.do(request_or_future,retries)` queues the request into `hydra`. It always returns a `Future`. A  [`Typhoeus::Request`](https://github.com/typhoeus/typhoeus) will be converted into a `Future ` in this call. 
+`multi.do(request_or_future,retries)` queues the request into `hydra`. It always returns a `Future`. A  [`Typhoeus::Request`](https://github.com/typhoeus/typhoeus) will be converted into a `Future ` in this call.
 
 Finally, `multi.run` starts `hydra` to execute the requests in parallel. The request is made as soon as the multiplexer is started. You get the results of the request by evaluating the value of the `Future`.
 
@@ -76,21 +82,18 @@ Provides client-side response caching of service requests.
 include Px::Service::Client::Caching
 
 # Optional
-caching do |config|
-  config.cache_strategy = :none
+config do |config|
   config.cache_expiry = 30.seconds
-  config.max_page = nil
-  config.cache_options = {}
-  config.cache_options[:policy_group] = 'general'
+  config.cache_default_policy_group = 'general'
   config.cache_client =  Dalli::Client.new(...)
-  config.cache_logger = Logger.new(STDOUT) # or Rails.logger, for example
+  config.cache_logger = Logger.new(STDOUT) # or Rails.logger, for example.  Can be nil.
 end
 
 # An example of a cached request
 result = cache_request(url, :last_resort, refresh_probability: 1) do
 	req = make_request(method, url)
 	response = @multi.do(req)
-	
+
 	# cache_request() expects a future that returns the result to be cached
 	Px::Service::Client::Future.new do  
 		JSON.parse(response.body)
@@ -98,7 +101,7 @@ result = cache_request(url, :last_resort, refresh_probability: 1) do
 end
 ```
 
-`cache_request` expects a block that returns a `Future` object. The return value (usually the response body) of that future will be cached.  `cache_request` always returns a future. By evaluating the future, i.e., via the `Future.value!` call, you get the result (whether cached or not). 
+`cache_request` expects a block that returns a `Future` object. The return value (usually the response body) of that future will be cached.  `cache_request` always returns a future. By evaluating the future, i.e., via the `Future.value!` call, you get the result (whether cached or not).
 
 
 **Note**: DO NOT cache the `Typhoeus::Response` directly (See the below code snippet), because the response object cannot be serializable to be stored in memcached. That's the reason why we see warning message: `You are trying to cache a Ruby object which cannot be serialized to memcached.`
@@ -107,24 +110,24 @@ end
 # An incorrect example of using cache_request()
 cache_request(url, :last_resort) do
 	req = make_request(method, url)
-	response = @multi.do(req)   # DO NOT do this 
+	response = @multi.do(req)   # DO NOT do this
 end
 
-``` 
+```
 Responses are cached in either a *last-resort* or *first-resort* manner.
 
 *last-resort* means that the cached value is only used when the service client request fails (with a
 `ServiceError`). If the service client request succeeds, there is a chance that the cache value may get refreshed. The `refresh_probability` is provided to let the cached value
-be refreshed probabilistically (rather than on every request). 
+be refreshed probabilistically (rather than on every request).
 
-If the service client request fails and there is a `ServiceError`, `cache_logger` will record the exception message, and attempt to read the existing cache value. 
+If the service client request fails and there is a `ServiceError`, `cache_logger` will record the exception message, and attempt to read the existing cache value.
 
-*first-resort* means that the cached value is always used, if present.  If the cached value is present but expired, the it sends the service client request and, if the request succeeds, it refreshes the cached value expiry. If the request fails, it uses the expired cached value, but the value remain expired. A retry may be needed. 
+*first-resort* means that the cached value is always used, if present.  If the cached value is present but expired, the it sends the service client request and, if the request succeeds, it refreshes the cached value expiry. If the request fails, it uses the expired cached value, but the value remain expired. A retry may be needed.
 
 
 
 #### Px::Service::Client::CircuitBreaker
-This mixin overrides `Px::Service::Client::Base#make_request` method and implements the circuit breaker pattern. 
+This mixin overrides `Px::Service::Client::Base#make_request` method and implements the circuit breaker pattern.
 
 ```ruby
 include Px::Service::Client::CircuitBreaker
@@ -146,7 +149,7 @@ Adds a circuit breaker to the client.  `make_request` always returns `Future`
 
 The circuit will open on any exception from the wrapped method, or if the request runs for longer than the `invocation_timeout`.
 
-If the circuit is open, any future request will be get an error message wrapped in `Px::Service::ServiceError`. 
+If the circuit is open, any future request will be get an error message wrapped in `Px::Service::ServiceError`.
 
 By default, `Px::Service::ServiceRequestError` is excluded by the handler. That is, when the request fails with a `ServiceRequestError` exceptions, the same `ServiceRequestError` will be raised. But it does NOT increase the failure count or trip the breaker, as these exceptions indicate an error on the caller's part (e.g. an HTTP 4xx error).
 
@@ -156,37 +159,37 @@ Every instance of the class that includes the `CircuitBreaker` concern will shar
 This module is based on (and uses) the [Circuit Breaker](https://github.com/wsargent/circuit_breaker) gem by Will Sargent.
 
 #### Px::Service::Client::HmacSigning
-Similar to `Px::Service::Client::CircuitBreaker`, this mixin overrides `Px::Service::Client::Base#make_request` method and appends a HMAC signature in the request header. 
+Similar to `Px::Service::Client::CircuitBreaker`, this mixin overrides `Px::Service::Client::Base#make_request` method and appends a HMAC signature in the request header.
 
-To use this mixin: 
+To use this mixin:
 
 ```ruby
 class MyClient < Px::Service::Client::Base
 	include Px::Service::Client::HmacSigning
 
 	#optional
-	hmac_signing do |config|
-		config.key = 'mykey'
-		config.keyspan = 300
+	config do |config|
+		config.hmac_secret = 'mykey'
+		config.hmac_keyspan = 300
 	end
 end
 ```
 
-Note: `key` and `keyspan` are class variables and shared among instances of the same class. 
+Note: `key` and `keyspan` are class variables and shared among instances of the same class.
 
-The signature is produced from the secret key, a nonce, HTTP method, url, query, body. The nonce is generated from the timestamp. 
+The signature is produced from the secret key, a nonce, HTTP method, url, query, body. The nonce is generated from the timestamp.
 
-To retrieve and verify the signature: 
+To retrieve and verify the signature:
 
 ```ruby
 # Make a request with signed headers
-resp = make_request(method, url, query, headers, body) 
+resp = make_request(method, url, query, headers, body)
 
 signature = resp.request.options[:headers]["X-Service-Auth"]
 timestamp = resp.request.options[:headers]["Timestamp"]
 
 # Call the class method to regenerate the signature
-expected_signature = MyClient.generate_signature(method, url, query, body, timestamp) 
+expected_signature = MyClient.generate_signature(method, url, query, body, timestamp)
 
 # assert signature == expected_signature
 ```
@@ -197,7 +200,7 @@ expected_signature = MyClient.generate_signature(method, url, query, body, times
   def get_something(page, page_size)
     response = JSON.parse(http_get("http://some/url?p=#{page}&l=#{page_size}"))
     return Px::Service::Client::ListResponse(page_size, response, "items")
-  end 
+  end
 ```
 
 Wraps a deserialized response.  A `ListResponse` implements the Ruby `Enumerable` module, as well

data/lib/px/service/client/base.rb

@@ -1,7 +1,31 @@
 module Px::Service::Client
   class Base
     cattr_accessor :logger
-    
+
+    class DefaultConfig < OpenStruct
+      def initialize
+        super
+        self.statsd_client = NullStatsdClient.new
+      end
+    end
+
+    ##
+    # Configure the client
+    def self.config
+      @config ||= DefaultConfig.new
+      yield(@config) if block_given?
+      @config
+    end
+
+    # Make class config available to instances
+    def config
+      if block_given?
+        self.class.config { |c| yield(c) }
+      else
+        self.class.config
+      end
+    end
+
     private
 
     def parsed_body(response)
@@ -19,6 +43,22 @@ module Px::Service::Client
     ##
     # Make the request
     def make_request(method, uri, query: nil, headers: nil, body: nil, timeout: 0)
+      stats_tags = [
+        "method:#{method.downcase}",
+      ]
+      if uri.respond_to?(:path)
+        stats_tags << "host:#{uri.host}"
+        stats_tags << "path:#{uri.path}"
+      else
+        actual_uri = URI(uri)
+        stats_tags << "host:#{actual_uri.host}"
+        stats_tags << "path:#{actual_uri.path}"
+      end
+
+      _make_request(method, uri, query: query, headers: headers, body: body, timeout: timeout, stats_tags: stats_tags)
+    end
+
+    def _make_request(method, uri, query: nil, headers: nil, body: nil, timeout: nil, stats_tags: [])
       req = Typhoeus::Request.new(
         uri,
         method: method,
@@ -32,11 +72,26 @@ module Px::Service::Client
 
       req.on_complete do |response|
         elapsed = (Time.now - start_time) * 1000
+        config.statsd_client.histogram("request.duration", elapsed.to_i, tags: stats_tags)
+        config.statsd_client.increment("response.count", tags: stats_tags + ["httpstatus:#{response.response_code}"])
+        case
+        when response.response_code > 100 && response.response_code < 199
+          config.statsd_client.increment("response.status_1xx.count", tags: stats_tags)
+        when response.response_code > 200 && response.response_code < 299
+          config.statsd_client.increment("response.status_2xx.count", tags: stats_tags)
+        when response.response_code > 300 && response.response_code < 399
+          config.statsd_client.increment("response.status_3xx.count", tags: stats_tags)
+        when response.response_code > 400 && response.response_code < 499
+          config.statsd_client.increment("response.status_4xx.count", tags: stats_tags)
+        when response.response_code > 500
+          config.statsd_client.increment("response.status_5xx.count", tags: stats_tags)
+        end
         logger.debug "Completed request #{method.to_s.upcase} #{uri}, took #{elapsed.to_i}ms, got status #{response.response_code}" if logger
       end
 
       RetriableResponseFuture.new(req)
     end
 
+
   end
 end

data/lib/px/service/client/caching.rb

@@ -18,42 +18,26 @@ module Px::Service::Client
 
     included do
       cattr_accessor :cache_client, :cache_logger
-    end
 
-    module ClassMethods
-      DefaultConfig = Struct.new(:cache_strategy, :cache_expiry, :max_page, :cache_options, :cache_logger, :cache_client) do
-        def initialize
-          self.cache_strategy = :none
-          self.cache_expiry = 30.seconds
-          self.max_page = nil
-          self.cache_options = {}
-          self.cache_options[:policy_group] = 'general'
-          self.cache_logger = nil
-          self.cache_client = nil
-        end
+      config do |config|
+        config.cache_expiry = 30.seconds
+        config.cache_default_policy_group = 'general'
+        config.cache_logger = nil
+        config.cache_client = nil
       end
 
-      ##
-      # Set the caching behaviour
-      def caching(&block)
-        @cache_config ||= DefaultConfig.new
-        yield(@cache_config) if block_given?
-        @cache_config
-      end
-    end
-    
-    def config
-      @cache_config || self.class.caching
+      # DEPRECATED: Use .config (base class method) instead
+      alias_method :caching, :config
     end
 
-    def cache_request(url, strategy: nil, policy_group: config.cache_options[:policy_group], expires_in: config.cache_expiry, refresh_probability: 1, &block)
+    def cache_request(url, strategy: nil, policy_group: config.cache_default_policy_group, expires_in: config.cache_expiry, refresh_probability: 1)
       case strategy
         when :last_resort
-          cache_last_resort(url, policy_group: policy_group, expires_in: expires_in, refresh_probability: refresh_probability, &block)
+          cache_last_resort(url, policy_group: policy_group, expires_in: expires_in, refresh_probability: refresh_probability) { yield  }
         when :first_resort
-          cache_first_resort(url, policy_group: policy_group, expires_in: expires_in, &block)
+          cache_first_resort(url, policy_group: policy_group, expires_in: expires_in) { yield }
         else
-          no_cache(&block)
+          no_cache { yield }
       end
     end
 
@@ -63,10 +47,15 @@ module Px::Service::Client
     # Use the cache as a last resort.  This path will make the request each time, caching the result
     # on success.  If an exception occurs, the cache is checked for a result.  If the cache has a result, it's
     # returned and the cache entry is touched to prevent expiry.  Otherwise, the original exception is re-raised.
-    def cache_last_resort(url, policy_group: 'general', expires_in: nil, refresh_probability: 1, &block)
+    def cache_last_resort(url, policy_group: 'general', expires_in: nil, refresh_probability: 1)
+      tags = [
+        "type:last_resort",
+        "policy_group:#{policy_group}",
+      ]
+
       # Note we use a smaller refresh window here (technically, could even use 0)
       # since we don't really need the "expired but not really expired" behaviour when caching as a last resort.
-      retry_response = block.call
+      retry_response = yield
 
       Future.new do
         begin
@@ -76,16 +65,21 @@ module Px::Service::Client
 
           # Only store a new result if we roll a 0
           r = rand(refresh_probability)
-          entry.store(expires_in, refresh_window: 1.minute) if r == 0
+          if r == 0
+            entry.store(expires_in, refresh_window: 1.minute)
+            config.statsd_client.increment("caching.write.count", tags: tags)
+          end
           resp
         rescue Px::Service::ServiceError => ex
-          cache_logger.error "Service responded with exception: #{ex.class.name}: #{ex.message}\n#{ex.backtrace.join('\n')}" if cache_logger
+          config.cache_logger.error "Service responded with exception: #{ex.class.name}: #{ex.message}\n#{ex.backtrace.join('\n')}" if config.cache_logger
           entry = CacheEntry.fetch(config.cache_client, url, policy_group)
           if entry.nil?
             # Re-raise the error, no cached response
+            config.statsd_client.increment("caching.fetch.count", tags: tags + ["result:miss"])
             raise ex
           end
 
+          config.statsd_client.increment("caching.fetch.count", tags: tags + ["result:hit"])
           entry.touch(expires_in, refresh_window: 1.minute)
           entry.data
         end
@@ -97,7 +91,11 @@ module Px::Service::Client
     # or if the cache entry has expired.  It follows logic similar to ActiveSupport::Cache.  If the cache entry
     # has expired (but is still present) and the request fails, the cached value is still returned, as if this was
     # cache_last_resort.
-    def cache_first_resort(url, policy_group: 'general', expires_in: nil, &block)
+    def cache_first_resort(url, policy_group: 'general', expires_in: nil)
+      tags = [
+        "type:last_resort",
+        "policy_group:#{policy_group}",
+      ]
       entry = CacheEntry.fetch(config.cache_client, url, policy_group)
 
       if entry
@@ -106,13 +104,15 @@ module Px::Service::Client
           # calling the block, but to prevent lots of others from also trying to refresh, first it updates
           # the expiry date on the entry so that other callers that come in while we're requesting the update
           # don't also try to update the cache.
+          config.statsd_client.increment("caching.fetch.count", tags: tags + ["result:expired"])
           entry.touch(expires_in)
         else
+          config.statsd_client.increment("caching.fetch.count", tags: tags + ["result:hit"])
           return Future.new { entry.data }
         end
       end
 
-      retry_response = block.call
+      retry_response = yield
 
       Future.new do
         begin
@@ -120,15 +120,18 @@ module Px::Service::Client
           resp = retry_response.value!
           entry = CacheEntry.new(config.cache_client, url, policy_group, resp)
           entry.store(expires_in)
+          config.statsd_client.increment("caching.write.count", tags: tags)
           resp
         rescue Px::Service::ServiceError => ex
-          cache_logger.error "Service responded with exception: #{ex.class.name}: #{ex.message}\n#{ex.backtrace.join('\n')}" if cache_logger
+          config.cache_logger.error "Service responded with exception: #{ex.class.name}: #{ex.message}\n#{ex.backtrace.join('\n')}" if config.cache_logger
 
           entry = CacheEntry.fetch(config.cache_client, url, policy_group)
           if entry.nil?
             # Re-raise the error, no cached response
+            # config.statsd_client.increment("caching.fetch.count", tags: tags + ["result:miss"])
             raise ex
           end
+          config.statsd_client.increment("caching.fetch.count", tags: tags + ["result:hit"])
 
           # Set the entry to be expired again (but reset the refresh window).  This allows the next call to try again
           # (assuming the circuit breaker is reset) but keeps the value in the cache in the meantime
@@ -141,8 +144,8 @@ module Px::Service::Client
       Future.new { ex }
     end
 
-    def no_cache(&block)
-      retry_response = block.call
+    def no_cache
+      retry_response = yield
 
       Future.new do
         raise ArgumentError.new('Block did not return a Future.') unless retry_response.is_a?(Future)

data/lib/px/service/client/circuit_breaker.rb

@@ -18,12 +18,12 @@ module Px::Service::Client
         ::CircuitBreaker::CircuitState.new
       end
 
-      alias_method_chain :make_request, :breaker
+      alias_method_chain :_make_request, :breaker
     end
 
     ##
     # Make the request, respecting the circuit breaker, if configured
-    def make_request_with_breaker(method, uri, query: nil, headers: nil, body: nil)
+    def _make_request_with_breaker(method, uri, query: nil, headers: nil, body: nil, timeout: nil, stats_tags: [])
       state = self.class.circuit_state
       handler = self.class.circuit_handler
 
@@ -38,20 +38,27 @@ module Px::Service::Client
         end
       end
 
-      retry_request = make_request_without_breaker(
+      config.statsd_client.increment("breakers.ready.count", tags: stats_tags) if circuit_state.half_open?
+
+      retry_request = _make_request_without_breaker(
         method,
         uri,
         query: query,
         headers: headers,
         body: body,
-        timeout: handler.invocation_timeout)
+        timeout: handler.invocation_timeout,
+        stats_tags: stats_tags)
 
       retry_request.request.on_complete do |response|
         # Wait for request to exhaust retries
         if retry_request.completed?
           if response.response_code >= 500 || response.response_code == 0
+            config.statsd_client.increment("breakers.fail.count", tags: stats_tags)
+            config.statsd_client.increment("breakers.tripped.count", tags: stats_tags) if circuit_state.closed?
+
             handler.on_failure(state)
           else
+            config.statsd_client.increment("breakers.reset.count", tags: stats_tags) unless circuit_state.closed?
             handler.on_success(state)
           end
         end

data/lib/px/service/client/hmac_signing.rb

@@ -2,43 +2,33 @@ module Px::Service::Client
   module HmacSigning
     extend ActiveSupport::Concern
     included do
-      alias_method_chain :make_request, :signing
-      
+      alias_method_chain :_make_request, :signing
+
       cattr_accessor :secret do
         DEFAULT_SECRET
       end
-      
+
       cattr_accessor  :keyspan do
         DEFAULT_KEYSPAN
       end
-      
-    end   
 
-    module ClassMethods      
-      DefaultConfig = Struct.new(:secret, :keyspan) do
-        def initialize
-          self.secret = DEFAULT_SECRET
-          self.keyspan = DEFAULT_KEYSPAN
-        end
+      # Default config for signing
+      config do |config|
+        config.hmac_secret = DEFAULT_SECRET
+        config.hmac_keyspan = DEFAULT_KEYSPAN
       end
 
-      # initialize the config variables (including secret, keyspan) for hmac siging
-      def hmac_signing(&block)
-        @signing_config = DefaultConfig.new
-        
-        # use default config if no block is given
-        if block_given?
-          yield(@signing_config)        
-          self.secret = @signing_config.secret
-          self.keyspan = @signing_config.keyspan
-        end
-      end
-      
+      ##
+      # DEPRECATED: Use .config (base class method) instead
+      alias_method :hmac_signing, :config
+    end
+
+    module ClassMethods
       ##
       # Generate a nonce that's used to expire message after keyspan seconds
       def generate_signature(method, uri, query, body, timestamp)
-        secret = self.secret
-        keyspan = self.keyspan
+        secret = self.config.hmac_secret
+        keyspan = self.config.hmac_keyspan
         nonce = (timestamp - (timestamp % keyspan)) + keyspan
         data = "#{method.capitalize},#{uri},#{query},#{body},#{nonce.to_s}"
         digest = OpenSSL::Digest.new('sha256')
@@ -46,21 +36,23 @@ module Px::Service::Client
         return Base64.urlsafe_encode64(digest).strip()
       end
     end
-    
-    def make_request_with_signing(method, uri, query: nil, headers: nil, body: nil)
+
+    def _make_request_with_signing(method, uri, query: nil, headers: nil, body: nil, timeout: nil, stats_tags: [])
       timestamp = Time.now.to_i
       signature = self.class.generate_signature(method, uri, query, body, timestamp)
-      
+
       headers = {} if headers.nil?
       headers.merge!("X-Service-Auth" => signature)
       headers.merge!("Timestamp" => timestamp)
 
-      make_request_without_signing(
+      _make_request_without_signing(
           method,
           uri,
           query: query,
           headers: headers,
-          body: body)
+          body: body,
+          timeout: timeout,
+          stats_tags: stats_tags)
     end
 
   end

data/lib/px/service/client/null_statsd_client.rb

@@ -0,0 +1,30 @@
+module Px::Service::Client
+  # Does nothing, gracefully
+  class NullStatsdClient
+    def increment(*args)
+    end
+
+    def gauge(*args)
+    end
+
+    def histogram(*args)
+    end
+
+    def time(*args)
+      yield if block_given?
+    end
+
+    def timing(*args)
+    end
+
+    def set(*args)
+    end
+
+    def count(*args)
+    end
+
+    def batch(*args)
+      yield(self) if block_given?
+    end
+  end
+end

data/lib/px/service/client/version.rb

@@ -1,7 +1,7 @@
 module Px
   module Service
     module Client
-      VERSION = "1.2.3"
+      VERSION = "2.0.0"
     end
   end
 end

data/lib/px/service/client.rb

@@ -14,6 +14,7 @@ end
 
 require "px/service/client/version"
 require "px/service/client/future"
+require "px/service/client/null_statsd_client"
 require "px/service/client/caching"
 require "px/service/client/circuit_breaker"
 require "px/service/client/hmac_signing"

data/spec/px/service/client/base_spec.rb

@@ -6,8 +6,9 @@ describe Px::Service::Client::Base do
   let(:dalli) { Dalli::Client.new(dalli_host, dalli_options) }
 
   subject {
-    Px::Service::Client::Base.include(Px::Service::Client::Caching).tap do |c|
-      c.caching do |config|
+    Class.new(Px::Service::Client::Base).tap do |c|
+      c.include(Px::Service::Client::Caching)
+      c.config do |config|
         config.cache_client = dalli
       end
     end.new
@@ -20,6 +21,30 @@ describe Px::Service::Client::Base do
       headers: { "Content-Type" => "application/json"} )
   end
 
+  describe '#config' do
+    let(:other_subclass) {
+      Class.new(Px::Service::Client::Base).tap do |c|
+        c.include(Px::Service::Client::Caching)
+      end.new
+    }
+
+    context "when there are separate subclasses" do
+      before :each do
+        subject.config do |c|
+          c.subject_field = "value"
+        end
+      end
+
+      it "sets the config value on the subject" do
+        expect(subject.config.subject_field).to eq("value")
+      end
+
+      it "does not set the config value on other subclasses" do
+        expect(other_subclass.config.subject_field).not_to eq("value")
+      end
+    end
+  end
+
   describe '#make_request' do
     let(:url) { 'http://localhost:3000/path' }
 
@@ -308,4 +333,3 @@ describe Px::Service::Client::Base do
     end
   end
 end
-  

data/spec/px/service/client/caching/caching_spec.rb

@@ -7,11 +7,13 @@ describe Px::Service::Client::Caching do
   let(:dalli) { Dalli::Client.new(dalli_host, dalli_options) }
 
   subject {
-    Class.new.include(Px::Service::Client::Caching).tap do |c|
+    Class.new(Px::Service::Client::Base).tap do |c|
+      c.include(Px::Service::Client::Caching)
+      
       # Anonymous classes don't have a name.  Stub out :name so that things work
       allow(c).to receive(:name).and_return("Caching")
 
-      c.caching do |config|
+      c.config do |config|
         config.cache_client = dalli
       end
     end.new
@@ -71,7 +73,7 @@ describe Px::Service::Client::Caching do
 
   shared_examples_for "a request with no cached response" do
     it "raises the exception" do
-      expect { 
+      expect {
         subject.cache_request(url, strategy: strategy) do
           raise Px::Service::ServiceError.new("Error", 500)
         end.value!
@@ -85,7 +87,7 @@ describe Px::Service::Client::Caching do
 
     context 'when cache client is not set' do
       before :each do
-        subject.class.caching do |config|
+        subject.config do |config|
           config.cache_client = nil
         end
       end
@@ -109,7 +111,7 @@ describe Px::Service::Client::Caching do
     context "when there is a cached response" do
       context 'when cache client is not set' do
         before :each do
-          subject.class.caching do |config|
+          subject.config do |config|
             config.cache_client = nil
           end
         end
@@ -164,7 +166,7 @@ describe Px::Service::Client::Caching do
     context "when there is a cached response" do
       context 'when cache client is not set' do
         before :each do
-          subject.class.caching do |config|
+          subject.config do |config|
             config.cache_client = nil
           end
         end

data/spec/px/service/client/hmac_signing_spec.rb

@@ -8,21 +8,23 @@ describe Px::Service::Client::HmacSigning do
       c.include(Px::Service::Client::HmacSigning)
     end
   }
-  
+
   let(:another_class) {
-    Class.new(Px::Service::Client::Base).include(Px::Service::Client::HmacSigning).tap do |c|
-      c.hmac_signing do |signing_config|
-        signing_config.secret = "different secret"
+    Class.new(Px::Service::Client::Base).tap do |c|
+      c.include(Px::Service::Client::HmacSigning)
+
+      c.config do |config|
+        config.hmac_secret = "different secret"
       end
     end
   }
-  
+
   subject { subject_class.new }
   let(:another_object) { another_class.new }
-  
+
   describe '#make_request' do
     context "when the underlying request method succeeds" do
-      let(:url) { 'http://localhost:3000/path' }      
+      let(:url) { 'http://localhost:3000/path' }
       let(:resp) { subject.send(:make_request, 'get', url) }
       let(:headers) { resp.request.options[:headers] }
 
@@ -34,7 +36,7 @@ describe Px::Service::Client::HmacSigning do
         expect(headers).to have_key("X-Service-Auth")
         expect(headers).to have_key("Timestamp")
       end
-      
+
       let(:resp2) { another_object.send(:make_request, 'get', url) }
       let(:headers2) { resp2.request.options[:headers] }
       it "is different from the object of another class with a different key" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: px-service-client
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Chris Micacchi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-19 00:00:00.000000000 Z
+date: 2016-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: will_paginate
@@ -221,6 +221,7 @@ files:
 - lib/px/service/client/hmac_signing.rb
 - lib/px/service/client/list_response.rb
 - lib/px/service/client/multiplexer.rb
+- lib/px/service/client/null_statsd_client.rb
 - lib/px/service/client/retriable_response_future.rb
 - lib/px/service/client/version.rb
 - lib/px/service/errors.rb