faraday_throttler 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ecd40afc7d5acf7024059f4fcd820accc8da1bd1
-  data.tar.gz: 67e615a50d4067f00175991e00b1161b624bbb7a
+  metadata.gz: 8f579e07afd3e9eaef5e05bfad056a6334cf5f32
+  data.tar.gz: 0d714c032c901eb44c75974a6fdfe7ab69946e4c
 SHA512:
-  metadata.gz: 4c3cc18b494510df0da3d56210bc1fee14518b1d9f9ff012d601af0dfcdfbccbee8c3d3a5bee0e4bf4c57a189dbd7b5f6dbc9939aa525072df4c28fcd73a6988
-  data.tar.gz: 026e803e53c5097b8c8623555932eb87826d7908ebdc209c3b81f1b96682fd9a9ebc642096a7c692999f489c15e3891a6e431cf4732aae3f7d92a086e668597c
+  metadata.gz: a401855bca195c3b855b31160df610490395238ad6f626b5561d93db05ed616c5bf922f70cd994a83043b7c10bf690c7f676e15fc5d1ad9065912028eb10c43e
+  data.tar.gz: 274a82b0fed4d985b230298725b0e3ef10aa8c0634a986294d7c5b92228e594074d816d1b8a4bc0f757ba359a10da02731d0384290df09b333f383ed655a5dc2

data/README.md

@@ -8,6 +8,10 @@ Configurable Faraday middleware for Ruby HTTP clients that:
 * does its best to return cached or placeholder responses to clients while backend service is unavailable or slow.
 * optionally uses Redis to rate-limit outgoing requests across processes and servers.
 
+## Use case
+
+Use this gem if you want to help avoid request [stampedes](https://en.wikipedia.org/wiki/Cache_stampede) to your backend APIs. For example after front-end cache expiration. This middleware can help you limit the number and rate of concurrent requests to the backend, while serving useful cached or hard-coded responses back to the client when the backend is not inmediatly available.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -28,7 +32,7 @@ Or install it yourself as:
 
 ### Defaults
 
-The defaul configuration use an in-memory lock and in-memory cache. Not suitable for multi-server deployments.
+The defaul configuration uses an in-memory lock and in-memory cache. Not suitable for multi-server deployments.
 
 ```ruby
 require 'faraday'
@@ -55,11 +59,11 @@ resp = client.get('/foobar')
 resp.body
 ```
 
-The configuration above will only issue 1 request every 3 seconds to `my.api.com/foobar`. Requests to the same path will wait for up to 2 seconds for current _in-flight_ request to finish. 
+The configuration above will only issue 1 request every 3 seconds to `my.api.com/foobar`. Requests to the same path will wait for up to 2 seconds for current _in-flight_ request to finish.
 
-If an in-flight request finishes within that period, queued requests will respond with the same data.
+If an in-flight request finishes within the wait period, queued requests will respond with the same data, and the data will be cached as a fallback.
 
-If the in-flight request doesn't finish within 2 seconds, queued requests will attempt to serve a previous response from the same resource from cache.
+If the in-flight request doesn't finish within 2 seconds (wait period), queued requests will attempt to serve a previous response from the same resource from cache.
 
 If no matching response found in cache, a default fallback response will be used (status 204 No Content). Fallback responses can be cofigured.
 

data/lib/faraday_throttler/middleware.rb

@@ -80,7 +80,16 @@ module FaradayThrottler
         #
         # `request_id` is the result of cache_key_resolver#call, normally an MD5 hash of the request full URL.
         # `state` can be one of :fresh, :cached, :timeout, :fallback
-        gauge: nil
+        gauge: nil,
+
+        # If async is TRUE, sending the request and populating the cache from the response
+        # will happen asynchronously in a thread, while the main thread will
+        # poll the cache for the duration of the :wait period.
+        # If the cache is populated within that period, the newly cached response will be returned
+        # Otherwise the fallback response will be returned.
+        # The main difference is that, when async: false, a fresh request will block until it gets data from the server.
+        # When async: true, a fresh request will try to respond with (possibly stale) cached data ASAP while the new response is cached in the background.
+        async: false
     )
 
       validate_dep! lock, :lock, :set
@@ -98,7 +107,7 @@ module FaradayThrottler
       @timeout = timeout.to_i
       @fallbacks = fallbacks
       @gauge = gauge || Gauge.new(rate: @rate, wait: @wait)
-
+      @async = async
       validate_dep! @gauge, :gauge, :start, :update, :finish
 
       super app
@@ -115,17 +124,10 @@ module FaradayThrottler
       gauge.start cache_key, start
 
       if lock.set(lock_key, gauge.rate(cache_key))
-        begin
-          with_timeout(timeout) {
-            app.call(request_env).on_complete do |response_env|
-              cache.set cache_key, response_env
-              gauge.finish cache_key, :fresh
-              debug_headers response_env, :fresh, start
-            end
-          }
-        rescue ::Timeout::Error => e
-          gauge.update cache_key, :timeout
-          serve_from_cache_or_fallback request_env, cache_key, start
+        if async?
+          handle_async(request_env, cache_key, start)
+        else
+          handle_sync(request_env, cache_key, start)
         end
       else
         serve_from_cache_or_fallback request_env, cache_key, start
@@ -135,6 +137,34 @@ module FaradayThrottler
     private
     attr_reader :app, :lock, :cache, :lock_key_resolver, :cache_key_resolver, :rate, :wait, :timeout, :fallbacks, :gauge
 
+    def async?
+      @async
+    end
+
+    def handle_sync(request_env, cache_key, start)
+      with_timeout(timeout) {
+        fetch_and_cache(request_env, cache_key, start)
+      }
+    rescue ::Timeout::Error => e
+      gauge.update cache_key, :timeout
+      serve_from_cache_or_fallback request_env, cache_key, start
+    end
+
+    def handle_async(request_env, cache_key, start)
+      Thread.new do
+        fetch_and_cache(request_env, cache_key, start)
+      end
+      serve_from_cache_or_fallback request_env, cache_key, start
+    end
+
+    def fetch_and_cache(request_env, cache_key, start)
+      app.call(request_env).on_complete do |response_env|
+        cache.set cache_key, response_env
+        gauge.finish cache_key, :fresh
+        debug_headers response_env, :fresh, start
+      end
+    end
+
     def serve_from_cache_or_fallback(request_env, cache_key, start)
       if cached_response = cache.get(cache_key, gauge.wait(cache_key))
         gauge.finish cache_key, :cached

data/lib/faraday_throttler/version.rb

@@ -1,3 +1,3 @@
 module FaradayThrottler
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faraday_throttler
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Ismael Celis
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-11-12 00:00:00.000000000 Z
+date: 2016-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -120,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Redis-backed request throttler requests to protect backend APIs against request