rack-cache 1.8.0 → 1.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a52edf08cd4dca09954d3269805b240539a240f89df89e2bdda063077a4f826f
-  data.tar.gz: 3474fecb6a64d70e47531d5c9978673cf0c67a5d276aa7ccb35d5368d9be0960
+  metadata.gz: bb5dc6e1debaa841064dcf380a8015f6f63568187fda3ede9da81ed8d84041ec
+  data.tar.gz: 96c26c225e307ddaeaf6f8cbd5d219b0dacdcf18d9b36b11282af98a458af8be
 SHA512:
-  metadata.gz: 3e83d8956c8c5e25a8c4f0109e50a39f7175b46edda89e41b9d62939779439c0880b7f17fcd9aae63c47e2a4715ce7ea0678d7231135f009cffbe6b588c772af
-  data.tar.gz: 4351bd9ae5eb974590e8d39b8328a083a9bd2be4456d6966e2d0c12b35d3c28a7c367b8335296827e6490c3513cffc5b2b45b9231ec45b93f541ed61a9676c57
+  metadata.gz: b28a19dbb93f8eddce6bc7ab9e8307c9222c21131e5340db30b132c119ac8dbfd7079801365dbf987c68676f7605b26daab9bb03f996d2128c4ee9153a10006b
+  data.tar.gz: 4b810c3911b1e37dba674188165553c179da277f1ef0a7dd804afa8bc037f956f00322cfab0ab2d22a0e30e7ce44fb5eb1d07401c64b8b8c91f760c0a3c12b2c

data/CHANGES

@@ -1,4 +1,25 @@
-## next
+## 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
+
+## 1.8.0
 
   * Meta stores will purge keys when no entity store entries are found
 

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).
 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

@@ -43,7 +43,15 @@ module Rack::Cache
       else
         # the metastore referenced an entity that doesn't exist in
         # the entitystore, purge the entry from the meta-store
-        purge(key)
+        begin
+          purge(key)
+        rescue NotImplementedError
+          @@warned_on_purge ||= begin
+            warn "WARNING: Future releases may require purge implementation for #{self.class.name}"
+            true
+          end
+          nil
+        end
       end
     end
 
@@ -190,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)
@@ -215,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/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.8.0
+  version: 1.12.0
 platform: ruby
 authors:
 - Ryan Tomayko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-07 00:00:00.000000000 Z
+date: 2020-06-06 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