rack-cache 1.9.0 → 1.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5127a4c26d9bf722dffb6743e6d0231f623ce59348ba3eba525867cb2cc3fc9
-  data.tar.gz: 474db5a34c1ac449c871e76f5716f717102d4adf27af5fe7190d3523293202e6
+  metadata.gz: faa3fda2990457be314ac3643ed59e28487459ed4022c6ef1682c4922389dee7
+  data.tar.gz: baf2634fa406e4c6da7e17339b4309217ba5ad99cda998fc67a0eeff369b513c
 SHA512:
-  metadata.gz: f66cdddd9326db331ac3bfc50eda836ae87ae1f596803bee7203a232d457bcf97c2b26c6a0575cee69252c5e9c8122bed4e6fd00b387002127300b17bb0a4cae
-  data.tar.gz: ee479aacff602c4ca20856b73508a9a795ad1eabf1d08e7221be4b5877fd16ab6d31fb4f91b39f38d599ba934022a722b3bf15106e34c765e667f6a9b67b5bf7
+  metadata.gz: 91d096f1cd9808a4d7983175af2549bc900a2b6ce3547799b30c11c8f9b233d874f0f1c6e64a36dbefda3161d12df50c696ba32e05f85ec7c34a825183499c01
+  data.tar.gz: 510a3c91dc5b06a6f87985f846a001ab543679e909902cdef7a2ebf96bd3efdedfc9e2b778d959e51b379dddf5fbb8d3ae4adac085a18228af2694c285327df7

data/CHANGES

@@ -1,3 +1,20 @@
+## 1.12.0
+
+ * Add a fault_tolerant flag to fail-over to stale cache
+
+## 1.11.1
+
+ * when ignoring parts of the query, remove query in key when all params are ignored
+
+## 1.11.0
+
+ * Add a proc to allow ignoring parts of the query string in the key
+
+## 1.10.0
+
+  * Pass Options To Underlying Storage Driver
+  * bump required ruby version to 2.3
+
 ## 1.9.0
 
   * make purge not raise when not implemented

data/README.md

@@ -16,7 +16,7 @@ validation (Last-Modified, ETag) information:
 
 For more information about Rack::Cache features and usage, see:
 
-http://rtomayko.github.com/rack-cache/
+https://rtomayko.github.com/rack-cache/
 
 Rack::Cache is not overly optimized for performance. The main goal of the
 project is to provide a portable, easy-to-configure, and standards-based
@@ -70,7 +70,7 @@ You should now see `Rack::Cache` listed in the middleware pipeline:
 
     rake middleware
 
-[more information](http://snippets.aktagon.com/snippets/302-how-to-setup-and-use-rack-cache-with-rails)
+[more information](https://snippets.aktagon.com/snippets/302-how-to-setup-and-use-rack-cache-with-rails)
 
 Using with Dalli
 ----------------
@@ -97,7 +97,7 @@ Does not persist response bodies (no disk/memory used).<br/>
 Responses from the cache will have an empty body.<br/>
 Clients must ignore these empty cached response (check for X-Rack-Cache response header).<br/>
 Atm cannot handle streamed responses, patch needed.
- 
+
 ```Ruby
 require 'rack/cache'
 
@@ -109,6 +109,18 @@ use Rack::Cache,
 run app
 ```
 
+Ignoring tracking parameters in cache keys
+-----------------
+
+It's fairly common to include tracking parameters which don't affect the content
+of the page. Since Rack::Cache uses the full URL as part of the cache key, this
+can cause unneeded churn in your cache. If you're using the default key class
+`Rack::Cache::Key`, you can configure a proc to ignore certain keys/values like
+so:
+
+```Ruby
+Rack::Cache::Key.query_string_ignore = proc { |k, v| k =~ /^(trk|utm)_/ }
+```
+
 License: MIT<br/>
 [![Build Status](https://travis-ci.org/rtomayko/rack-cache.svg)](https://travis-ci.org/rtomayko/rack-cache)
-

data/lib/rack/cache/context.rb

@@ -19,6 +19,7 @@ module Rack::Cache
       @backend = backend
       @trace = []
       @env = nil
+      @options = options
 
       initialize_options options
       yield self if block_given?
@@ -31,14 +32,14 @@ module Rack::Cache
     # value effects the result of this method immediately.
     def metastore
       uri = options['rack-cache.metastore']
-      storage.resolve_metastore_uri(uri)
+      storage.resolve_metastore_uri(uri, @options)
     end
 
     # The configured EntityStore instance. Changing the rack-cache.entitystore
     # value effects the result of this method immediately.
     def entitystore
       uri = options['rack-cache.entitystore']
-      storage.resolve_entitystore_uri(uri)
+      storage.resolve_entitystore_uri(uri, @options)
     end
 
     # The Rack call interface. The receiver acts as a prototype and runs
@@ -160,10 +161,12 @@ module Rack::Cache
     end
 
     # Try to serve the response from cache. When a matching cache entry is
-    # found and is fresh, use it as the response without forwarding any
-    # request to the backend. When a matching cache entry is found but is
-    # stale, attempt to #validate the entry with the backend using conditional
-    # GET. When no matching cache entry is found, trigger #miss processing.
+    # found and is fresh, use it as the response without forwarding any request
+    # to the backend. When a matching cache entry is found but is stale, attempt
+    # to #validate the entry with the backend using conditional GET.
+    # If validation raises an exception and fault tolerant caching is enabled,
+    # serve the stale cache entry.
+    # When no matching cache entry is found, trigger miss processing.
     def lookup
       if @request.no_cache? && allow_reload?
         record :reload
@@ -182,7 +185,11 @@ module Rack::Cache
             entry
           else
             record :stale
-            validate(entry)
+            if fault_tolerant?
+              validate_with_stale_cache_failover(entry)
+            else
+              validate(entry)
+            end
           end
         else
           record :miss
@@ -191,6 +198,17 @@ module Rack::Cache
       end
     end
 
+    # Returns stale cache on exception.
+    def validate_with_stale_cache_failover(entry)
+      validate(entry)
+    rescue => e
+      record :connnection_failed
+      age = entry.age.to_s
+      entry.headers['Age'] = age
+      record "Fail-over to stale cache data with age #{age} due to #{e.class.name}: #{e}"
+      entry
+    end
+
     # Validate that the cache entry is fresh. The original request is used
     # as a template for a conditional GET request with the backend.
     def validate(entry)

data/lib/rack/cache/entity_store.rb

@@ -33,10 +33,10 @@ module Rack::Cache
 
     # Stores entity bodies on the heap using a Hash object.
     class Heap < EntityStore
-
       # Create the store with the specified backing Hash.
-      def initialize(hash={})
+      def initialize(hash={}, options = {})
         @hash = hash
+        @options = options
       end
 
       # Determine whether the response body with the specified key (SHA1)
@@ -71,8 +71,8 @@ module Rack::Cache
         nil
       end
 
-      def self.resolve(uri)
-        new
+      def self.resolve(uri, options = {})
+        new({}, options)
       end
     end
 

data/lib/rack/cache/key.rb

@@ -4,6 +4,21 @@ module Rack::Cache
   class Key
     include Rack::Utils
 
+    # A proc for ignoring parts of query strings when generating a key. This is
+    # useful when you have parameters like `utm` or `trk` that don't affect the
+    # content on the page and are unique per-visitor or campaign. Parameters
+    # like these will be part of the key and cause a lot of churn.
+    #
+    # The block will be passed a key and value which are the name and value of
+    # that parameter.
+    #
+    # Example:
+    #   `Rack::Cache::Key.query_string_ignore = proc { |k, v| k =~ /^(trk|utm)_/ }`
+    #
+    class << self
+      attr_accessor :query_string_ignore
+    end
+
     # Implement .call, since it seems like the "Rack-y" thing to do. Plus, it
     # opens the door for cache key generators to just be blocks.
     def self.call(request)
@@ -42,11 +57,12 @@ module Rack::Cache
     def query_string
       return nil if @request.query_string.to_s.empty?
 
-      @request.query_string.split(/[&;] */n).
-        map { |p| p.split('=', 2).map{ |s| unescape(s) } }.
-        sort.
-        map { |k,v| "#{escape(k)}=#{escape(v)}" }.
-        join('&')
+      parts = @request.query_string.split(/[&;] */n)
+      parts.map! { |p| p.split('=', 2).map!{ |s| unescape(s) } }
+      parts.sort!
+      parts.reject!(&self.class.query_string_ignore)
+      parts.map! { |k,v| "#{escape(k)}=#{escape(v)}" }
+      parts.empty? ? nil : parts.join('&')
     end
   end
 end

data/lib/rack/cache/meta_store.rb

@@ -198,8 +198,9 @@ module Rack::Cache
     # Concrete MetaStore implementation that uses a simple Hash to store
     # request/response pairs on the heap.
     class Heap < MetaStore
-      def initialize(hash={})
+      def initialize(hash={}, options = {})
         @hash = hash
+        @options = options
       end
 
       def read(key)
@@ -223,8 +224,8 @@ module Rack::Cache
         @hash
       end
 
-      def self.resolve(uri)
-        new
+      def self.resolve(uri, options = {})
+        new({}, options)
       end
     end
 

data/lib/rack/cache/options.rb

@@ -107,6 +107,10 @@ module Rack::Cache
     # be used.
     option_accessor :use_native_ttl
 
+    # Specifies whether to serve a request from a stale cache entry if
+    # the attempt to revalidate the cache entry raises an exception.
+    option_accessor :fault_tolerant
+
     # The underlying options Hash. During initialization (or outside of a
     # request), this is a default values Hash. During a request, this is the
     # Rack environment Hash. The default values Hash is merged in underneath
@@ -149,6 +153,7 @@ module Rack::Cache
         'rack-cache.allow_reload'     => false,
         'rack-cache.allow_revalidate' => false,
         'rack-cache.use_native_ttl'   => false,
+        'rack-cache.fault_tolerant'   => false,
       }
       self.options = options
     end

data/lib/rack/cache/response.rb

@@ -40,6 +40,7 @@ module Rack::Cache
     def initialize_copy(other)
       super
       @headers = other.headers.dup
+      @cache_control = nil
     end
 
     # Return the status, headers, and body in a three-tuple.

data/lib/rack/cache/storage.rb

@@ -14,12 +14,12 @@ module Rack::Cache
       @entitystores = {}
     end
 
-    def resolve_metastore_uri(uri)
-      @metastores[uri.to_s] ||= create_store(MetaStore, uri)
+    def resolve_metastore_uri(uri, options = {})
+      @metastores[uri.to_s] ||= create_store(MetaStore, uri, options)
     end
 
-    def resolve_entitystore_uri(uri)
-      @entitystores[uri.to_s] ||= create_store(EntityStore, uri)
+    def resolve_entitystore_uri(uri, options = {})
+      @entitystores[uri.to_s] ||= create_store(EntityStore, uri, options)
     end
 
     def clear
@@ -30,12 +30,13 @@ module Rack::Cache
 
   private
 
-    def create_store(type, uri)
+    def create_store(type, uri, options = {})
       if uri.respond_to?(:scheme) || uri.respond_to?(:to_str)
         uri = URI.parse(uri) unless uri.respond_to?(:scheme)
         if type.const_defined?(uri.scheme.upcase)
           klass = type.const_get(uri.scheme.upcase)
-          klass.resolve(uri)
+          return klass.resolve(uri) if klass.method(:resolve).arity == 1
+          klass.resolve(uri, options)
         else
           fail "Unknown storage provider: #{uri.to_s}"
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-cache
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.12.1
 platform: ruby
 authors:
 - Ryan Tomayko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-26 00:00:00.000000000 Z
+date: 2020-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -156,15 +156,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.3
 signing_key: 
 specification_version: 4
 summary: HTTP Caching for Rack