sidekiq_smart_cache 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0bfe51b0884c74e8f916b2e07a756b14fa41810dc3c137225bc978ac6a41ab81
+  data.tar.gz: e5c34d6795f47aa5b4ba17e7ca538ada975cdef8406c113a8107b205cd540955
+SHA512:
+  metadata.gz: b66ae306d585ac20cf6b0e5d47bd634cb1fb36ba4e51b041c33eb3f77471190405cb4a64face8a53b578425e85f9bf85a345fd869f262ce91516941fab17e168
+  data.tar.gz: 2fc77d0ad12e9c317dddb1d6a8358256fb86f74330ed1fde78a71e61fa9914a6dd55ff8406a57770de8b0476615ff0ac7ceba6ddf3dc0f93d999c3007d896249

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 Bill Kirtley
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,134 @@
+# SidekiqSmartCache
+
+Generate and cache objects using sidekiq, with thundering herd prevention and client timeouts.
+
+Say you have a resource that's expensive to calculate (a heavy database query) and would like to use it in a web page.
+
+But you'd rather the web page show an empty value (or a "check back later" placeholder) than take too long to render.
+
+And you'd like to ensure that if there are multiple actions requesting that page at once, that the database only has to fill the query once.  (You want to prevent a [thundering herd problem](https://en.wikipedia.org/wiki/Thundering_herd_problem))
+
+## Usage
+
+Say your `Widget` class has a method `do_a_thing` that is sometimes quite expensive to calculate, but returns a value you'd like to include in a web page, as long as the value can be made available in five seconds.  Once calculated, the value is valid for ten minutes, and all renderings of the page can show that same value.
+
+In the controller:
+
+```ruby
+promise = SidekiqSmartCache::Promise.new(klass: Widget, method: :do_a_thing, expires_in: 10 * 60)
+if promise.ready_within?(5.seconds)
+  # Render using the generated thing
+  @thing = promise.value
+else
+  # Render some "try again in a bit" presentation
+end
+```
+
+If no other workers are currently calculating the value, this will queue up a sidekiq job to call `Widget.do_a_thing`.  If other workers are currently calculating, it will not start another, preventing the thundering herd.
+
+Then it will wait as much as 5 seconds for a value to be returned.
+
+If in the end, value is nil, offer a default or "try again" presentation to the user.
+
+Also supported: passing arguments, calling an instance method on an object in the database, and explicitly naming your cache tag.
+
+```ruby
+SidekiqSmartCache::Promise.new(
+  object: widget, method: :do_an_instance_thing, args: ['fun', 12],
+  expires_in: 10.minutes
+)
+```
+
+If your results are (or contain) other than the YAML.safe_load list (TrueClass, FalseClass, NilClass, Numeric, String, Array, Hash) plus Symbol and Time, configure with an initializer:
+
+```
+SidekiqSmartCache.allowed_classes = [MyFavoriteClass]
+```
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sidekiq_smart_cache'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install sidekiq_smart_cache
+```
+
+Add an initializer:
+```ruby
+Rails.configuration.to_prepare do
+  SidekiqSmartCache.logger = Rails.logger
+  SidekiqSmartCache.redis_pool = Sidekiq.redis_pool
+  SidekiqSmartCache.cache_prefix = ENV['RAILS_CACHE_ID']
+end
+```
+
+## Model mix-in
+
+Let's assume your User class has a active_user_count class method that is expensive to calculate
+
+Declaring `make_class_action_cacheable :active_user_count` will add:
+
+ * `User.active_user_count_without_caching` - always performs the full calculation synchronously, doesn't touch the cache.
+ * `User.refresh_active_user_count` - always performs the full calculation synchronously, populating the cache with the new value.
+ * `User.active_user_count` (the original name) - will now fetch from the cache, only recalculating if the cache is absent or stale.
+ * `User.active_user_count_if_available` will now fetch from the cache but not recalculate, returning nil if the cache is absent or stale.
+ * `User.active_user_count_cache_tag` - the cache tag used to store calculated results. Probably not useful to clients.
+ * `User.active_user_count_promise` - returns a Promise object
+
+Call `promise.fetch(5.seconds)` to wait up to five seconds for a new value, returning nil on timeout.
+
+Call `promise.fetch!(5.seconds)` to wait up to five seconds for a new value, raising `SidekiqSmartCache::TimeoutError` on timeout.
+
+Use <tt>make_instance_action_cacheable</tt> for the equivalent set of instance methods.
+Your models must respond to <tt>to_param</tt> with a unique string suitable for constructing a cache key.
+The class must respond to <tt>find</tt> and return an object that responds to the method.
+
+## Testing
+
+# Setup
+```
+bundle install
+pushd test/dummy
+bundle exec rake db:create db:migrate db:test:prepare
+popd
+bundle exec bin/test
+```
+# Tidy
+
+The test database is using sqlite, so `rm test/dummy/db/*.sqlite3` is a sincere way to reset context.
+
+# Debugging
+Test a single file:
+```
+bin/test test/model_test.rb -n test_cache_tag_generation
+```
+
+Open a SQL shell on a database:
+```
+sqlite3 test/dummy/db/test.sqlite3
+```
+
+Test with a specific Sidekiq version:
+```
+BUNDLE_GEMFILE=gemfiles/Gemfile-sidekiq7 bundle exec bin/test
+```
+
+Specify a non-default redis for both sidekiq and the cache:
+```
+REDIS_PROVIDER=REDIS_URL REDIS_URL=redis://localhost:6380 BUNDLE_GEMFILE=gemfiles/Gemfile-sidekiq7 bundle exec bin/test
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,33 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SidekiqSmartCache'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/sidekiq_smart_cache/interlock.rb

@@ -0,0 +1,27 @@
+module SidekiqSmartCache
+  class Interlock
+    delegate :redis, to: SidekiqSmartCache
+    attr_accessor :cache_tag, :job_interlock_timeout
+
+    def initialize(cache_tag, job_interlock_timeout=nil)
+      @cache_tag = cache_tag
+      @job_interlock_timeout = job_interlock_timeout
+    end
+
+    def key
+      cache_tag + '/in-progress'
+    end
+
+    def working?
+      redis.get(key)
+    end
+
+    def lock_job?
+      redis.set(key, 'winner!', nx: true) && redis.expire(key, job_interlock_timeout)
+    end
+
+    def clear
+      redis.del(key)
+    end
+  end
+end

data/lib/sidekiq_smart_cache/model.rb

@@ -0,0 +1,109 @@
+require 'active_support/concern'
+module SidekiqSmartCache::Model
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    # Takes a class or instance action, makes it operate lazy-loaded through a cache, and adds a couple of related actions to the class.
+    #
+    # === Example
+    #
+    # A User class has a active_user_count class method that is expensive to calculate
+    #
+    # Declaring <tt>make_class_action_cacheable :active_user_count</tt> will add:
+    #
+    # * <tt>User.active_user_count_without_caching</tt> - always performs the full calculation synchronously, doesn't touch the cache.
+    # * <tt>User.refresh_active_user_count</tt> - always performs the full calculation synchronously, populating the cache with the new value.
+    # * <tt>User.active_user_count</tt> (the original name) - will now fetch from the cache, only recalculating if the cache is absent or stale.
+    # * <tt>User.active_user_count_if_available</tt> will now fetch from the cache but not recalculate, returning nil if the cache is absent or stale.
+    # * <tt>User.active_user_count_cache_tag</tt> - the cache tag used to store calculated results. Probably not useful to clients.
+    # * <tt>User.active_user_count_promise</tt> - returns a promise object
+    #
+    # Call <tt>promise.fetch(5.seconds)</tt> to wait up to five seconds for a new value, returning nil on timeout
+    # Call <tt>promise.fetch!(5.seconds)</tt> to wait up to five seconds for a new value, raising SidekiqSmartCache::TimeoutError on timeout
+    #
+    # Use <tt>make_instance_action_cacheable</tt> for the equivalent set of instance methods.
+    # Your models must respond to <tt>to_param</tt> with a unique string suitable for constructing a cache key.
+    # The class must respond to <tt>find(param)</tt> and return an object that responds to the method.
+    #
+    # === Options
+    # [:cache_tag]
+    #   Specifies the cache tag to use.
+    #   A default cache tag will include the cache_prefix, so will implicitly flush on each release.
+    #
+    # [:expires_in]
+    #   Specifies a period after which a cached result will be invalid. Default one hour.
+    #
+    # [:job_interlock_timeout]
+    #   When a new value is needed, prevents new refresh jobs from being dispatched.
+    #
+    # Option examples:
+    #   make_action_cacheable :active_user_count, expires_in: 12.hours, job_interlock_timeout: 10.minutes
+    #   make_instance_action_cacheable :median_post_length, expires_in: 1.hour, job_interlock_timeout: 1.minute
+    delegate :cache_prefix, to: SidekiqSmartCache
+
+    def make_action_cacheable(name, options = {})
+      cache_tag = options[:cache_tag] || [cache_prefix, self.name, name].join('.')
+      cache_options = options.slice(:expires_in, :job_interlock_timeout)
+      instance_method = options[:instance_method]
+      without_caching_name = "#{name}_without_caching"
+      promise_method_name = "#{name}_promise"
+
+      promise_method = ->(*args) do
+        promise_args = cache_options.merge(
+          method: without_caching_name,
+          args: args
+        )
+
+        if instance_method
+          promise_args[:klass] = self.class.name
+          promise_args[:object_param] = to_param
+        else
+          promise_args[:klass] = self.name
+        end
+        SidekiqSmartCache::Promise.new(**promise_args)
+      end
+
+      if_available_method = ->(*args) do
+        send(promise_method_name, *args).existing_value
+      end
+
+      cache_tag_method = ->(*args) do
+        send(promise_method_name, *args).cache_tag
+      end
+
+      with_caching_method = ->(*args) do
+        send(promise_method_name, *args).fetch(24.hours) # close enough to forever?
+      end
+
+      without_caching_method = ->(*args) do
+        method(name).super_method.call(*args)
+      end
+
+      refresh_method = ->(*args) do
+        send(promise_method_name, *args).perform_now
+      end
+
+      prefix_module = Module.new
+      prefix_module.send(:define_method, "#{name}_if_available", if_available_method)
+      prefix_module.send(:define_method, "#{name}_cache_tag", cache_tag_method)
+      prefix_module.send(:define_method, name, with_caching_method)
+      prefix_module.send(:define_method, without_caching_name, without_caching_method)
+      prefix_module.send(:define_method, promise_method_name, promise_method)
+      prefix_module.send(:define_method, "refresh_#{name}", refresh_method)
+
+      if instance_method
+        prepend prefix_module
+      else
+        singleton_class.prepend prefix_module
+      end
+    end
+
+    def make_class_action_cacheable(name, options = {})
+      make_action_cacheable(name, options)
+    end
+
+    def make_instance_action_cacheable(name, options = {})
+      make_action_cacheable(name, options.merge(instance_method: true))
+    end
+  end
+end

data/lib/sidekiq_smart_cache/promise.rb

@@ -0,0 +1,120 @@
+module SidekiqSmartCache
+  class Promise
+    attr_accessor :klass, :object_param, :method, :expires_in, :args, :job_interlock_timeout
+    attr_accessor :timed_out
+    delegate :redis, :log, to: SidekiqSmartCache
+    delegate :working?, to: :interlock
+    delegate :value, to: :result
+    delegate :created_at, to: :result, prefix: true
+
+    def initialize(klass: nil, object: nil, object_param: nil, method:, args: nil,
+                   cache_tag: nil, expires_in: 1.hour, job_interlock_timeout: nil)
+      if object
+        @klass = object.class.to_s
+        @object_param = object.to_param
+      elsif klass
+        @klass = klass.to_s
+        @object_param = object_param
+      else
+        raise "Must provide either klass or object"
+      end
+      raise "Must provide method" unless method
+      @method = method.to_s
+      @expires_in = expires_in.to_i
+      @job_interlock_timeout = job_interlock_timeout || @expires_in
+      @args = args
+      @cache_tag = cache_tag
+    end
+
+    def cache_tag
+      @cache_tag ||= begin
+        [
+          klass,
+          (object_param || '.'),
+          method,
+          (Digest::MD5.hexdigest(args.compact.to_json) if args.present?)
+        ].compact * '/'
+      end
+    end
+
+    def interlock
+      @_interlock ||= Interlock.new(cache_tag, job_interlock_timeout)
+    end
+
+    def perform_now
+      Worker.new.perform(klass, object_param, method, args, cache_tag, expires_in)
+    end
+
+    def enqueue_job!
+      Worker.perform_async(klass, object_param, method, args, cache_tag, expires_in)
+    end
+
+    def execute_and_wait!(timeout, stale_on_timeout: false)
+      execute_and_wait(timeout, raise_on_timeout: true, stale_on_timeout: stale_on_timeout)
+    end
+
+    def result
+      Result.load_from(cache_tag)
+    end
+
+    def stale_value_available?
+      !!result&.stale?
+    end
+
+    def existing_value(allow_stale: false)
+      if((existing = result) && (allow_stale || existing.fresh?))
+        existing.value
+      end
+    end
+
+    def ready_within?(timeout)
+      execute_and_wait(timeout)
+      !timed_out
+    end
+
+    def timed_out?
+      !!timed_out
+    end
+
+    def start
+      # Start a job if no other client has
+      if interlock.lock_job?
+        log('promise enqueuing calculator job')
+        enqueue_job!
+      else
+        log('promise calculator job already working')
+      end
+      self # for chaining
+    end
+
+    def execute_and_wait(timeout, raise_on_timeout: false, stale_on_timeout: false)
+      previous_result = result
+      if previous_result&.fresh?
+        # found a previously fresh message
+        @timed_out = false
+        return previous_result.value
+      else
+        start
+
+        # either a job was already running or we started one, now wait for an answer
+        if redis.wait_for_done_message(cache_tag, timeout.to_i)
+          # ready now, fetch it
+          log('promise calculator job finished')
+          @timed_out = false
+          result.value
+        elsif previous_result && stale_on_timeout
+          log('promise timed out awaiting calculator job, serving stale')
+          previous_result.value
+        else
+          log('promise timed out awaiting calculator job')
+          @timed_out = true
+          raise TimeoutError if raise_on_timeout
+        end
+      end
+    end
+
+    alias_method :fetch!, :execute_and_wait!
+    alias_method :fetch, :execute_and_wait
+
+  end
+end

data/lib/sidekiq_smart_cache/redis.rb

@@ -0,0 +1,94 @@
+module SidekiqSmartCache
+  BLOCKING_COMMANDS = %i[ brpop ].freeze
+  COMMANDS = BLOCKING_COMMANDS + %i[ get set lpush expire flushdb del ].freeze
+
+  ERROR_TO_CATCH = if defined?(::RedisClient)
+    ::RedisClient::CommandError
+  else
+    ::Redis::CommandError
+  end
+
+  class Redis
+    def initialize(pool)
+      @pool = pool
+    end
+
+    def job_completion_key(key)
+      key + '/done'
+    end
+
+    def send_done_message(key)
+      lpush(job_completion_key(key), 'done')
+      expire(job_completion_key(key), 1)
+    end
+
+    def wait_for_done_message(key, timeout)
+      return true if defined?(Sidekiq::Testing) && Sidekiq::Testing.inline?
+
+      if brpop(job_completion_key(key), timeout: timeout.to_i)
+        # log_msg("got done message for #{key}")
+        send_done_message(key) # put it back for any other readers
+        true
+      end
+    end
+
+    def log_msg(msg) # WIP all this
+      Rails.logger.info("#{Time.now.iso8601(3)} #{Thread.current[:name]} redis #{msg}")
+    end
+
+    def method_missing(name, ...)
+      @pool.with do |r|
+        if COMMANDS.include? name
+          retryable = true
+          begin
+            # log_msg("#{name} #{args}")
+            if r.respond_to?(name)
+              # old redis gem implements methods including `brpop` and `flusdb`
+              r.send(name, ...)
+            elsif BLOCKING_COMMANDS.include? name
+              # support redis-client semantics
+              make_blocking_call(r, name, ...)
+            else
+              r.call(name.to_s.upcase, ...)
+            end
+            # stolen from sidekiq - Thanks Mike!
+            # Quietly consume this one and return nil
+          rescue ERROR_TO_CATCH => ex
+            # 2550 Failover can cause the server to become a replica, need
+            # to disconnect and reopen the socket to get back to the primary.
+            if retryable && ex.message =~ /READONLY/
+              r.disconnect!
+              retryable = false
+              retry
+            end
+            raise
+          end
+        else
+          super
+        end
+      end
+    end
+
+    def make_blocking_call(r, name, *args)
+      # The Redis `brpop` implementation seems to allow timeout to be the last argument
+      # or a key in a hash `timeout: 5`, so:
+      # `r.brpop('key1', 'key2', 5)` - wait five seconds for either queue
+      # `r.brpop('key1', 'key2', timeout: 5)` - same
+      # `r.brpop('key1', 'key2')` - wait forever on either queue
+      timeout = if args.last.is_a?(Hash)
+        options = args.pop
+        options[:timeout]
+      else
+        args.pop
+      end
+
+      # With RedisClient, the doc is a little thin, but it looks like we want to start with the timeout
+      # then the verb, then the array of keys
+      # and end with ... a 0?
+      blocking_call_args = [timeout, name.to_s.upcase] + args + [0]
+      r.blocking_call(*blocking_call_args)
+    rescue ::RedisClient::TimeoutError
+      nil # quietly return nil in this case
+    end
+  end
+end

data/lib/sidekiq_smart_cache/result.rb

@@ -0,0 +1,38 @@
+class Result
+  class << self
+    delegate :redis, :allowed_classes, to: SidekiqSmartCache
+  end
+  attr_accessor :value, :valid_until, :created_at, :cache_prefix
+
+  def self.persist(cache_tag, value, expires_in)
+    structure = {
+      value: value,
+      created_at: Time.now,
+      valid_until: Time.now + expires_in,
+      cache_prefix: SidekiqSmartCache.cache_prefix
+    }
+    result_lifetime = 1.month.to_i # ??? maybe a function of expires_in ???
+    redis.set(cache_tag, structure.to_yaml)
+    redis.expire(cache_tag, result_lifetime)
+  end
+
+  def self.load_from(cache_tag)
+    raw = redis.get(cache_tag)
+    new(YAML.safe_load(raw, allowed_classes)) if raw
+  end
+
+  def initialize(result)
+    @value = result[:value]
+    @created_at = result[:created_at]
+    @valid_until = result[:valid_until]
+    @cache_prefix = result[:cache_prefix]
+  end
+
+  def fresh?
+    !stale?
+  end
+
+  def stale?
+    (Time.now > valid_until) || (cache_prefix != SidekiqSmartCache.cache_prefix)
+  end
+end

data/lib/sidekiq_smart_cache/version.rb

@@ -0,0 +1,3 @@
+module SidekiqSmartCache
+  VERSION = '0.1.0'
+end

data/lib/sidekiq_smart_cache/worker.rb

@@ -0,0 +1,26 @@
+require 'sidekiq'
+
+module SidekiqSmartCache
+  class Worker
+    include Sidekiq::Worker
+    delegate :redis, to: SidekiqSmartCache
+
+    def perform(klass, instance_id, method, args, cache_tag, expires_in)
+      all_args = [method]
+      if args.is_a?(Array)
+        all_args += args
+      elsif args
+        all_args << args
+      end
+      subject = Object.const_get(klass)
+      subject = subject.find(instance_id) if instance_id
+      result = subject.send(*all_args)
+      Result.persist(cache_tag, result, expires_in)
+      redis.send_done_message(cache_tag)
+      result
+    ensure
+      # remove the interlock key
+      Interlock.new(cache_tag).clear
+    end
+  end
+end

data/lib/sidekiq_smart_cache.rb

@@ -0,0 +1,30 @@
+require "sidekiq_smart_cache/worker"
+require "sidekiq_smart_cache/interlock"
+require "sidekiq_smart_cache/model"
+require "sidekiq_smart_cache/promise"
+require "sidekiq_smart_cache/redis"
+require "sidekiq_smart_cache/result"
+
+module SidekiqSmartCache
+  class TimeoutError < StandardError; end
+
+  class << self
+    attr_accessor :cache_prefix, :redis_pool, :logger, :log_level
+
+    def allowed_classes
+      (@allowed_classes || []) + [Time, Symbol]
+    end
+
+    def allowed_classes=(extra_classes)
+      @allowed_classes = extra_classes
+    end
+  end
+
+  def self.log(message)
+    logger.send((log_level || :info), message) if logger
+  end
+
+  def self.redis
+    @redis ||= Redis.new(redis_pool)
+  end
+end

data/lib/tasks/sidekiq_smart_cache_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :sidekiq_smart_cache do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq_smart_cache
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Bill Kirtley
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-06-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Cache objects in redis, generated with thundering herd prevention via
+  sidekiq.
+email:
+- bill.kirtley@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/sidekiq_smart_cache.rb
+- lib/sidekiq_smart_cache/interlock.rb
+- lib/sidekiq_smart_cache/model.rb
+- lib/sidekiq_smart_cache/promise.rb
+- lib/sidekiq_smart_cache/redis.rb
+- lib/sidekiq_smart_cache/result.rb
+- lib/sidekiq_smart_cache/version.rb
+- lib/sidekiq_smart_cache/worker.rb
+- lib/tasks/sidekiq_smart_cache_tasks.rake
+homepage: https://github.com/cluesque/sidekiq_smart_cache
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: Cache objects in redis, generated with thundering herd prevention via sidekiq.
+test_files: []