response_bank 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a5d65c4fd4310708e807cde576efeebdc590c16eb8e16190aef77a715ed48c2
-  data.tar.gz: 498da7cd7cfcc2da09b517e6694093551e79288ec4e52e815950448353ba4a0f
+  metadata.gz: 75476fbf8271b8744fdca486f31ddfff585ab0680e29c600e25393d24b6b6fbb
+  data.tar.gz: 6092909983069ec5689e4e6ada0d241e632331fd6c97fb94e4ce5029c4cf228a
 SHA512:
-  metadata.gz: 5985c959c55ebf8917d9687dd0e3c3d82cae36684f7466d7c1d1805097da2fd57cadaa6efa9f7d618a757e24949a7e493aefe0e298f5c0254d9b595f7871bba8
-  data.tar.gz: 5bc8ac60f2d2ce149120a8f0bc98aca57899511359f5a67a125b6cc3894edf0043dffad8be635ae9fa95a9d1b295220a091b0d2faa118982f9740eac5e3d6786
+  metadata.gz: ccade0feb4bcc259e6bd0d3435799960014f204031b564ca88892e5c80afce36997f266b91acb0eb2af1e64f80488af49166fe4a99ab2d31874cac9827e37eaa
+  data.tar.gz: 5e74d777bfd30f8eed957d5ed07d11ffab8e6d4d462194277b7a38c28b70728445d0c598a26173020fc1d26c3c11410aabc6cf7f79f5a06cd806546a687cff7e

data/README.md

@@ -1,126 +1,128 @@
-# ResponseBank [![Build Status](https://secure.travis-ci.org/Shopify/response_bank.png)](http://travis-ci.org/Shopify/response_bank)
+# ResponseBank [![Build Status](https://secure.travis-ci.org/Shopify/response_bank.png)](http://travis-ci.org/Shopify/response_bank) [![CI Status](https://github.com/Shopify/response_bank/actions/workflows/ci.yml/badge.svg)](https://github.com/Shopify/response_bank/actions/workflows/ci.yml)
 
-### Features
+## Features
 
 * Serve gzip'd content
 * Add ETag and 304 Not Modified headers
 * Generational caching
 * No explicit expiry
 
-### Support
+## Support
 
 This gem supports the following versions of Ruby and Rails:
 
-* Ruby 2.4.0+
-* Rails 5.0.0+
+* Ruby 2.7.0+
+* Rails 6.0.0+
 
-### Usage
+## Usage
 
 1. include the gem in your Gemfile
 
-```ruby
-gem 'response_bank'
-```
+    ```ruby
+    gem 'response_bank'
+    ```
 
 2. add an initializer file. We need to configure the `acquire_lock` method, set the cache store and the logger
 
-```ruby
-require 'response_bank'
+    ```ruby
+    require 'response_bank'
 
-module ResponseBank
-  LOCK_TTL = 90
+    module ResponseBank
+      LOCK_TTL = 90
 
-  class << self
-    def acquire_lock(cache_key)
-      cache_store.write("#{cache_key}:lock", '1', unless_exist: true, expires_in: LOCK_TTL, raw: true)
+      class << self
+        def acquire_lock(cache_key)
+          cache_store.write("#{cache_key}:lock", '1', unless_exist: true, expires_in: LOCK_TTL, raw: true)
+        end
+      end
     end
-  end
-end
 
-ResponseBank.cache_store = ActiveSupport::Cache.lookup_store(Rails.configuration.cache_store)
-ResponseBank.logger = Rails.logger
+    ResponseBank.cache_store = ActiveSupport::Cache.lookup_store(Rails.configuration.cache_store)
+    ResponseBank.logger = Rails.logger
 
-```
+    ```
 
 3. enables caching on your application
-```ruby
-config.action_controller.perform_caching = true
-```
+
+    ```ruby
+    config.action_controller.perform_caching = true
+    ```
 
 4. use `#response_cache` method to any desired controller's action
 
-```ruby
-class PostsController < ApplicationController
-  def show
-    response_cache do
-      @post = @shop.posts.find(params[:id])
-      respond_with(@post)
+    ```ruby
+    class PostsController < ApplicationController
+      def show
+        response_cache do
+          @post = @shop.posts.find(params[:id])
+          respond_with(@post)
+        end
+      end
     end
-  end
-end
-```
+    ```
 
 5. **(optional)** set a custom TTL for the cache by overriding the `write_to_backing_cache_store` method in your initializer file
-```ruby
-module ResponseBank
-  CACHE_TTL = 30.minutes
-  def write_to_backing_cache_store(_env, key, payload, expires_in: CACHE_TTL)
-    cache_store.write(key, payload, raw: true, expires_in: expires_in)
-  end
-end
-```
 
-6. **(optional)** override custom cache key data. For default, cache key is defined by URL and query string
+    ```ruby
+    module ResponseBank
+      CACHE_TTL = 30.minutes
+      def write_to_backing_cache_store(_env, key, payload, expires_in: nil)
+        cache_store.write(key, payload, raw: true, expires_in: expires_in || CACHE_TTL)
+      end
+    end
+    ```
 
-```ruby
-class PostsController < ApplicationController
-  before_action :set_shop
+6. **(optional)** override custom cache key data. For default, cache key is defined by URL and query string
 
-  def index
-    response_cache do
-      @post = @shop.posts
-      respond_with(@post)
+    ```ruby
+    class PostsController < ApplicationController
+      before_action :set_shop
+
+      def index
+        response_cache do
+          @post = @shop.posts
+          respond_with(@post)
+        end
+      end
+
+      def show
+        response_cache do
+          @post = @shop.posts.find(params[:id])
+          respond_with(@post)
+        end
+      end
+
+      def another_action
+        # custom cache key data
+        cache_key = {
+          action: action_name,
+          format: request.format,
+          shop_updated_at: @shop.updated_at
+          # you may add more keys here
+        }
+        response_cache cache_key do
+          @post = @shop.posts.find(params[:id])
+          respond_with(@post)
+        end
+      end
+
+      # override default cache key data globally per class
+      def cache_key_data
+        {
+          action: action_name,
+          format: request.format,
+          params: params.slice(:id),
+          shop_version: @shop.version
+          # you may add more keys here
+        }
+      end
+
+      def set_shop
+        # @shop = ...
+      end
     end
-  end
+    ```
 
-  def show
-    response_cache do
-      @post = @shop.posts.find(params[:id])
-      respond_with(@post)
-    end
-  end
-
-  def another_action
-    # custom cache key data
-    cache_key = {
-      action: action_name,
-      format: request.format,
-      shop_updated_at: @shop.updated_at
-      # you may add more keys here
-    }
-    response_cache cache_key do
-      @post = @shop.posts.find(params[:id])
-      respond_with(@post)
-    end
-  end
-
-  # override default cache key data globally per class
-  def cache_key_data
-    {
-      action: action_name,
-      format: request.format,
-      params: params.slice(:id),
-      shop_version: @shop.version
-      # you may add more keys here
-     }
-  end
-
-  def set_shop
-    # @shop = ...
-  end
-end
-```
-
-### License
+## License
 
 ResponseBank is released under the [MIT License](LICENSE.txt).

data/lib/response_bank/middleware.rb

@@ -3,6 +3,10 @@ require 'useragent'
 
 module ResponseBank
   class Middleware
+    # Limit the cached headers
+    # TODO: Make this lowercase/case-insentitive as per rfc2616 §4.2
+    CACHEABLE_HEADERS = ["Location", "Content-Type", "ETag", "Content-Encoding", "Last-Modified", "Cache-Control", "Expires", "Surrogate-Keys", "Cache-Tags"].freeze
+
     REQUESTED_WITH = "HTTP_X_REQUESTED_WITH"
     ACCEPT = "HTTP_ACCEPT"
     USER_AGENT = "HTTP_USER_AGENT"
@@ -20,7 +24,6 @@ module ResponseBank
       if env['cacheable.cache']
         if [200, 404, 301, 304].include?(status)
           headers['ETag'] = env['cacheable.key']
-          headers['X-Alternate-Cache-Key'] = env['cacheable.unversioned-key']
 
           if ie_ajax_request?(env)
             headers["Expires"] = "-1"
@@ -38,22 +41,18 @@ module ResponseBank
 
           body_gz = ResponseBank.compress(body_string)
 
+          cached_headers = headers.slice(*CACHEABLE_HEADERS)
           # Store result
-          cache_data = [status, headers['Content-Type'], body_gz, timestamp]
-          cache_data << headers['Location'] if status == 301
+          cache_data = [status, cached_headers, body_gz, timestamp]
 
           ResponseBank.write_to_cache(env['cacheable.key']) do
             payload = MessagePack.dump(cache_data)
             ResponseBank.write_to_backing_cache_store(
               env,
-              env['cacheable.key'],
+              env['cacheable.unversioned-key'],
               payload,
               expires_in: env['cacheable.versioned-cache-expiry'],
             )
-
-            if env['cacheable.unversioned-key']
-              ResponseBank.write_to_backing_cache_store(env, env['cacheable.unversioned-key'], payload)
-            end
           end
 
           # since we had to generate the gz version above already we may

data/lib/response_bank/response_cache_handler.rb

@@ -3,6 +3,8 @@ require 'digest/md5'
 
 module ResponseBank
   class ResponseCacheHandler
+    CACHE_KEY_SCHEMA_VERSION = 1
+
     def initialize(
       key_data:,
       version_data:,
@@ -25,12 +27,13 @@ module ResponseBank
       @force_refill_cache = force_refill_cache
       @cache_store = cache_store
       @headers = headers || {}
+      @key_schema_version = @env.key?('cacheable.key_version') ? @env.key['cacheable.key_version'] : CACHE_KEY_SCHEMA_VERSION
     end
 
     def run!
       @env['cacheable.cache']           = true
-      @env['cacheable.key']             = versioned_key_hash
-      @env['cacheable.unversioned-key'] = unversioned_key_hash
+      @env['cacheable.key']             = entity_tag_hash
+      @env['cacheable.unversioned-key'] = cache_key_hash
 
       ResponseBank.log(cacheable_info_dump)
 
@@ -41,32 +44,32 @@ module ResponseBank
       end
     end
 
-    def versioned_key_hash
-      @versioned_key_hash ||= key_hash(versioned_key)
+    def entity_tag_hash
+      @entity_tag_hash ||= hash(entity_tag)
     end
 
-    def unversioned_key_hash
-      @unversioned_key_hash ||= key_hash(unversioned_key)
+    def cache_key_hash
+      @cache_key_hash ||= hash(cache_key)
     end
 
     private
 
-    def key_hash(key)
+    def hash(key)
       "cacheable:#{Digest::MD5.hexdigest(key)}"
     end
 
-    def versioned_key
-      @versioned_key ||= ResponseBank.cache_key_for(key: @key_data, version: @version_data)
+    def entity_tag
+      @entity_tag ||= ResponseBank.cache_key_for(key: @key_data, version: @version_data, key_schema_version: @key_schema_version)
     end
 
-    def unversioned_key
-      @unversioned_key ||= ResponseBank.cache_key_for(key: @key_data)
+    def cache_key
+      @cache_key ||= ResponseBank.cache_key_for(key: @key_data, key_schema_version: @key_schema_version)
     end
 
     def cacheable_info_dump
       log_info = [
-        "Raw cacheable.key: #{versioned_key}",
-        "cacheable.key: #{versioned_key_hash}",
+        "Raw cacheable.key: #{entity_tag}",
+        "cacheable.key: #{entity_tag_hash}",
       ]
 
       if @env['HTTP_IF_NONE_MATCH']
@@ -78,42 +81,19 @@ module ResponseBank
 
     def try_to_serve_from_cache
       # Etag
-      response = serve_from_browser_cache(versioned_key_hash)
-
+      response = serve_from_browser_cache(entity_tag_hash, @env['HTTP_IF_NONE_MATCH'])
       return response if response
 
-      # Memcached
-      response = if @serve_unversioned
-        serve_from_cache(unversioned_key_hash, "Cache hit: server (unversioned)")
-      else
-        serve_from_cache(versioned_key_hash, "Cache hit: server")
-      end
-
+      response = serve_from_cache(cache_key_hash, entity_tag_hash, @cache_age_tolerance)
       return response if response
 
-      @env['cacheable.locked'] ||= false
-
-      if @env['cacheable.locked'] || ResponseBank.acquire_lock(versioned_key_hash)
-        # execute if we can get the lock
-        @env['cacheable.locked'] = true
-      elsif serving_from_noncurrent_but_recent_version_acceptable?
-        # serve a stale version
-        response = serve_from_cache(unversioned_key_hash, "Cache hit: server (recent)", @cache_age_tolerance)
-
-        return response if response
-      end
-
       # No cache hit; this request cannot be handled from cache.
       # Yield to the controller and mark for writing into cache.
       refill_cache
     end
 
-    def serving_from_noncurrent_but_recent_version_acceptable?
-      @cache_age_tolerance > 0
-    end
-
-    def serve_from_browser_cache(cache_key_hash)
-      if @env["HTTP_IF_NONE_MATCH"] == cache_key_hash
+    def serve_from_browser_cache(entity_tag, if_none_match)
+      if etag_matches?(entity_tag, if_none_match)
         @env['cacheable.miss']  = false
         @env['cacheable.store'] = 'client'
 
@@ -126,7 +106,7 @@ module ResponseBank
       end
     end
 
-    def serve_from_cache(cache_key_hash, message, cache_age_tolerance = nil)
+    def serve_from_cache(cache_key_hash, match_entity_tag = "*", cache_age_tolerance = nil)
       raw = ResponseBank.read_from_backing_cache_store(@env, cache_key_hash, backing_cache_store: @cache_store)
 
       if raw
@@ -135,37 +115,73 @@ module ResponseBank
         @env['cacheable.miss']  = false
         @env['cacheable.store'] = 'server'
 
-        status, content_type, body, timestamp, location = hit
+        status, headers, body, timestamp = hit
 
-        if cache_age_tolerance && page_too_old?(timestamp, cache_age_tolerance)
-          ResponseBank.log("Found an unversioned cache entry, but it was too old (#{timestamp})")
+        @env['cacheable.locked'] ||= false
 
-          nil
+        # to preserve the unversioned/versioned logging messages from past releases we split the match_entity_tag test
+        if match_entity_tag == "*"
+          ResponseBank.log("Cache hit: server (unversioned)")
+          # page tolerance only applies for versioned + etag mismatch
+        elsif etag_matches?(headers['ETag'], match_entity_tag)
+          ResponseBank.log("Cache hit: server")
         else
-          @headers['Content-Type'] = content_type
-
-          @headers['Location'] = location if location
-
-          if @env["gzip"]
-            @headers['Content-Encoding'] = "gzip"
+          # cache miss; check to see if any parallel requests already are regenerating the cache
+          if ResponseBank.acquire_lock(match_entity_tag)
+            # execute if we can get the lock
+            @env['cacheable.locked'] = true
+            return
+          elsif stale_while_revalidate?(timestamp, cache_age_tolerance)
+            # cache is being regenerated, can we avoid piling on and use a stale version in the interim?
+            ResponseBank.log("Cache hit: server (recent)")
           else
-            # we have to uncompress because the client doesn't support gzip
-            ResponseBank.log("uncompressing for client without gzip")
-            body = ResponseBank.decompress(body)
+            ResponseBank.log("Found an unversioned cache entry, but it was too old (#{timestamp})")
+            return
           end
+        end
 
-          ResponseBank.log(message)
+        # version check
+        # unversioned but tolerance threshold
+        # regen
+        @headers = @headers.merge(headers)
 
-          [status, @headers, [body]]
+        if @env["gzip"]
+          @headers['Content-Encoding'] = "gzip"
+        else
+          # we have to uncompress because the client doesn't support gzip
+          ResponseBank.log("uncompressing for client without gzip")
+          body = ResponseBank.decompress(body)
         end
+        [status, @headers, [body]]
       end
     end
 
-    def page_too_old?(timestamp, cache_age_tolerance)
-      !timestamp || timestamp < (Time.now.to_i - cache_age_tolerance)
+    def etag_matches?(entity_tag, if_none_match)
+      # Support for Etag variations including:
+      # If-None-Match: abc
+      # If-None-Match: "abc"
+      # If-None-Match: W/"abc"
+      # If-None-Match: "abc", "def"
+      # If-None-Match: "*"
+      return false unless entity_tag
+      return false unless if_none_match
+
+      # strictly speaking an unquoted etag is not valid, yet common
+      # to avoid unintended greedy matches in we check for naked entity then includes with quoted entity values
+      if_none_match == "*" || if_none_match == entity_tag || if_none_match.include?(%{"#{entity_tag}"})
+    end
+
+    def stale_while_revalidate?(timestamp, cache_age_tolerance)
+      return false if !cache_age_tolerance
+      return false if !timestamp
+
+      timestamp >= (Time.now.to_i - cache_age_tolerance)
     end
 
     def refill_cache
+      # non cache hits do not yet have the lock
+      ResponseBank.acquire_lock(entity_tag_hash) unless @env['cacheable.locked']
+      @env['cacheable.locked'] = true
       @env['cacheable.miss'] = true
 
       ResponseBank.log("Refilling cache")

data/lib/response_bank/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module ResponseBank
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/lib/response_bank.rb

@@ -49,17 +49,17 @@ module ResponseBank
 
         key = hash_value_str(data[:key])
 
-        return key unless data.key?(:version)
+        key = %{#{data[:key_schema_version]}:#{key}} if data[:key_schema_version]
 
-        version = hash_value_str(data[:version])
+        key = %{#{key}:#{hash_value_str(data[:version])}} if data[:version]
 
-        [key, version].join(":")
+        key
       when Array
         data.inspect
       when Time, DateTime
         data.to_i
       when Date
-        data.to_time.to_i
+        data.to_s # Date#to_i does not support timezones, using iso8601 instead
       when true, false, Integer, Symbol, String
         data.inspect
       else

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: response_bank
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Tobias Lütke
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-04 00:00:00.000000000 Z
+date: 2023-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: useragent
@@ -45,28 +45,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.13.0
+        version: 5.18.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.13.0
+        version: 5.18.0
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.10.0
+        version: 2.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.10.0
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -87,28 +87,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: tzinfo-data
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.2019.3
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.2019.3
+        version: '6.1'
 description: 
 email:
 - tobi@shopify.com
@@ -139,14 +125,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.20
+rubygems_version: 3.4.9
 signing_key: 
 specification_version: 4
 summary: Simple response caching for Ruby applications