response_bank 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a5d65c4fd4310708e807cde576efeebdc590c16eb8e16190aef77a715ed48c2
-  data.tar.gz: 498da7cd7cfcc2da09b517e6694093551e79288ec4e52e815950448353ba4a0f
+  metadata.gz: 7d25739f9bd846e1cd3364a422cc90590b32fcb5f7e56cd307af0e83f0d5ddac
+  data.tar.gz: 14c1a7f96abcc45025cee9f998342fb6185779774dc72986ebb1a5bbcb96c413
 SHA512:
-  metadata.gz: 5985c959c55ebf8917d9687dd0e3c3d82cae36684f7466d7c1d1805097da2fd57cadaa6efa9f7d618a757e24949a7e493aefe0e298f5c0254d9b595f7871bba8
-  data.tar.gz: 5bc8ac60f2d2ce149120a8f0bc98aca57899511359f5a67a125b6cc3894edf0043dffad8be635ae9fa95a9d1b295220a091b0d2faa118982f9740eac5e3d6786
+  metadata.gz: b6120bc7a707fa5ddd1cd3a143e40681e375864b075fe0e74b1128cc4ee460690400a70c47599772addba8d2bee56b02ce14a820c5e4af376f0eaa154f1fe88c
+  data.tar.gz: 5ae1545f2c40d7abbf06b8ba43c8d353cb171fc97ce667fa280c5f991c37f7e514c7673898a99242e446f9975ef22f4cb91eaa053165664a9c309fa4d6b39197

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

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
-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", "Link", "Surrogate-Keys", "Cache-Tags"].freeze
+
     REQUESTED_WITH = "HTTP_X_REQUESTED_WITH"
     ACCEPT = "HTTP_ACCEPT"
     USER_AGENT = "HTTP_USER_AGENT"
@@ -13,18 +16,14 @@ module ResponseBank
 
     def call(env)
       env['cacheable.cache'] = false
-      gzip = env['gzip'] = env['HTTP_ACCEPT_ENCODING'].to_s.include?("gzip")
+      content_encoding = env['response_bank.server_cache_encoding'] = ResponseBank.check_encoding(env)
 
       status, headers, body = @app.call(env)
 
       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"
-          end
         end
 
         if [200, 404, 301].include?(status) && env['cacheable.miss']
@@ -36,31 +35,35 @@ module ResponseBank
             body.each { |part| body_string << part }
           end
 
-          body_gz = ResponseBank.compress(body_string)
+          body_compressed = nil
+          if body_string && body_string != ""
+            headers['Content-Encoding'] = content_encoding
+            body_compressed = ResponseBank.compress(body_string, content_encoding)
+          end
 
+          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_compressed, 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
+          # since we had to generate the compressed version already we may
           # as well serve it if the client wants it
-          if gzip
-            headers['Content-Encoding'] = "gzip"
-            body = [body_gz]
+          if body_compressed
+            if env['HTTP_ACCEPT_ENCODING'].to_s.include?(content_encoding)
+              body = [body_compressed]
+            else
+              # Remove content-encoding header for response with compressed content
+              headers.delete('Content-Encoding')
+            end
           end
         end
 
@@ -80,14 +83,5 @@ module ResponseBank
       Time.now.to_i
     end
 
-    def ie_ajax_request?(env)
-      return false unless !env[USER_AGENT].nil? && !env[USER_AGENT].empty?
-
-      if env[REQUESTED_WITH] == "XmlHttpRequest" || env[ACCEPT] == "application/json"
-        UserAgent.parse(env["HTTP_USER_AGENT"]).is_a?(UserAgent::Browsers::InternetExplorer)
-      else
-        false
-      end
-    end
   end
 end

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)
-      "cacheable:#{Digest::MD5.hexdigest(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, encoding: @env['response_bank.server_cache_encoding'])
     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, @serve_unversioned ? "*" : 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,74 @@ 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.merge!(headers)
 
-          [status, @headers, [body]]
+        # if a cache key hit and client doesn't match encoding, return the raw body
+        if !@env['HTTP_ACCEPT_ENCODING'].to_s.include?(@headers['Content-Encoding'])
+          ResponseBank.log("uncompressing payload for client as client doesn't require encoding")
+          body = ResponseBank.decompress(body, @headers['Content-Encoding'])
+          @headers.delete('Content-Encoding')
         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.3.0"
 end

data/lib/response_bank.rb

@@ -3,6 +3,7 @@ require 'response_bank/middleware'
 require 'response_bank/railtie' if defined?(Rails)
 require 'response_bank/response_cache_handler'
 require 'msgpack'
+require 'brotli'
 
 module ResponseBank
   class << self
@@ -29,17 +30,26 @@ module ResponseBank
       backing_cache_store.read(cache_key, raw: true)
     end
 
-    def compress(content)
-      io = StringIO.new
-      gz = Zlib::GzipWriter.new(io)
-      gz.write(content)
-      io.string
-    ensure
-      gz.close
+    def compress(content, encoding = "gzip")
+      case encoding
+      when 'gzip'
+        Zlib.gzip(content, level: Zlib::BEST_COMPRESSION)
+      when 'br'
+        Brotli.deflate(content, mode: :text, quality: 7)
+      else
+        raise ArgumentError, "Unsupported encoding: #{encoding}"
+      end
     end
 
-    def decompress(content)
-      Zlib::GzipReader.new(StringIO.new(content)).read
+    def decompress(content, encoding = "gzip")
+      case encoding
+      when 'gzip'
+        Zlib.gunzip(content)
+      when 'br'
+        Brotli.inflate(content)
+      else
+        raise ArgumentError, "Unsupported encoding: #{encoding}"
+      end
     end
 
     def cache_key_for(data)
@@ -49,17 +59,20 @@ 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]
+
+        key = %{#{key}:#{hash_value_str(data[:version])}} if data[:version]
 
-        version = hash_value_str(data[:version])
+        # add the encoding to only the cache key but don't expose this detail in the entity_tag
+        key = %{#{key}:#{hash_value_str(data[:encoding])}} if data[:encoding] && data[:encoding] != "gzip"
 
-        [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
@@ -67,6 +80,17 @@ module ResponseBank
       end
     end
 
+    def check_encoding(env, default_encoding = 'br')
+      if env['HTTP_ACCEPT_ENCODING'].to_s.include?('br')
+        'br'
+      elsif env['HTTP_ACCEPT_ENCODING'].to_s.include?('gzip')
+        'gzip'
+      else
+        # No encoding requested from client, but we still need to cache the page in server cache
+        default_encoding
+      end
+    end
+
     private
 
     def hash_value_str(data)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: response_bank
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Tobias Lütke
@@ -9,10 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-04 00:00:00.000000000 Z
+date: 2023-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: useragent
+  name: msgpack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -26,7 +26,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: msgpack
+  name: brotli
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -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,28 @@ 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'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
-  name: tzinfo-data
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2019.3
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2019.3
+        version: '0'
 description: 
 email:
 - tobi@shopify.com
@@ -139,14 +139,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.10
 signing_key: 
 specification_version: 4
 summary: Simple response caching for Ruby applications