activerecord_cached 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 051daa89ebda43ea098a7f152e567730f1a71f4794919ac4ac3ca8ec98936526
-  data.tar.gz: 829ea885b15719e2c77357f4caa1c6d39d4c221719fcca39a295eb41af1e0256
+  metadata.gz: 0e2aee53321cb1679b2d0a98406614eb9c718ae07fa80a6c156ccfcb2ecb4a5d
+  data.tar.gz: a36a4dc08fdb12b3020c44f4ab0210f0754c3504db1a22c4712d4c2b7a53adab
 SHA512:
-  metadata.gz: d98b20830828b808644df5b31a6a917a40af2aba50808e003c4b2b92d08f1b27297ba140ae61a4ea82c7c8c27ac0927545576734cf2b5f05074556d4daedcadf
-  data.tar.gz: ba34d2b20e9f07d13eb40b4bee773ed048eea9546d78e298b1ec0aa3c67c8012c170dad502b1d226d1ed3f50de54e12623f8abd6fa79d404d3e560fe2907990e
+  metadata.gz: ef43829aac59b7f8b9bc5a0aea7deaff9002ee532a94f91f9d5339e1160660242a3199a437c115233ba3cd6672c17f17c172f4d7cc09423000d991f118aa64c6
+  data.tar.gz: e428cf58d5b5f7af8b5034ec9e6b46ac6f5141a7bf8489d20604e3b47fe8287b1cd14b1109825cfa46e80179800ab459faf506f1d410916b308b0a8c8fc32529

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [1.1.0] - 2024-01-25
+
+## Added
+
+- cache expiry and race_condition_ttl
+
+## Fixed
+
+- some race conditions that would affect cache clearing by CRUD operations
+- size mentioned in warning message when using a custom MemoryStore
+
 ## [1.0.0] - 2024-01-23
 
 - Initial release

data/lib/activerecord_cached/activerecord_extensions.rb

@@ -29,13 +29,8 @@ module ActiveRecordCached
   ActiveRecord::Base.singleton_class.prepend BaseExtension
   ActiveRecord::Relation.prepend RelationExtension
 
-  # bust cache on individual record changes - this module is included
-  # automatically into models that use cached methods.
-  module CRUDCallbacks
-    def self.included(base)
-      base.after_commit { self.class.clear_cached_values }
-    end
-  end
+  # bust cache on individual record changes
+  ActiveRecord::Base.after_commit { self.class.clear_cached_values }
 
   # bust cache on mass operations
   module MassOperationWrapper

data/lib/activerecord_cached/cache.rb

@@ -1,50 +1,66 @@
 module ActiveRecordCached
   def fetch(relation, method, args)
     key = ['ActiveRecordCached', relation.to_sql, method, args.sort].join(':')
-    model = relation.klass
-    prepare(model)
-    cache_store.fetch(key) do
-      log_model_cache_key(model, key)
+    cache_store.fetch(key, expires_in: 1.day + rand(300).seconds, race_condition_ttl: 10.seconds) do
+      # The gem keeps track of all cache keys used for each model for easy clearing.
+      # Using #delete_matched would be too slow on large redis instances.
+      log_model_cache_key(relation.klass, key)
       query_db(relation, method, args)
     end
   end
 
   def clear_for_model(model)
-    keys = cache_keys_per_model
-    return unless model_keys = keys.delete(model)&.keys
+    synchronize do
+      hash = fetch_cache_keys_per_model
+      return unless model_keys = hash.delete(model)&.keys
 
-    cache_store.delete_multi(model_keys)
-    cache_store.write(CACHE_KEYS_KEY, keys)
+      # delete from the key list first so that if a fetch comes in right after,
+      # it can write the key to the list again
+      write_cache_keys_per_model(hash)
+      cache_store.delete_multi(model_keys)
+    end
   end
 
   def clear_all
-    all_keys = cache_keys_per_model.values.flat_map(&:keys)
-    cache_store.delete_multi(all_keys)
-    cache_store.delete(CACHE_KEYS_KEY)
+    synchronize do
+      all_keys = fetch_cache_keys_per_model.values.flat_map(&:keys)
+      write_cache_keys_per_model({})
+      cache_store.delete_multi(all_keys)
+    end
   end
 
   private
 
-  def prepare(model)
-    return if CRUDCallbacks.in?(model.included_modules)
-
-    PREPARE_MUTEX.synchronize do
-      CRUDCallbacks.in?(model.included_modules) || model.include(CRUDCallbacks)
+  def log_model_cache_key(model, key)
+    synchronize do
+      hash = fetch_cache_keys_per_model
+      (hash[model] ||= {})[key] = true
+      write_cache_keys_per_model(hash)
     end
   end
 
-  PREPARE_MUTEX = Mutex.new
+  def synchronize(&block)
+    cache_store_semaphore.synchronize(&block)
+  end
+
+  require 'monitor'
+  MONITOR = Monitor.new
 
-  def log_model_cache_key(model, key)
-    keys = cache_keys_per_model
-    (keys[model] ||= {})[key] = true
-    cache_store.write(CACHE_KEYS_KEY, keys)
+  def cache_store_semaphore
+    case cache_store
+    when ActiveSupport::Cache::MemoryStore then MONITOR
+    when ActiveSupport::Cache::RedisCacheStore then RedisMutex.new(cache_store.redis)
+    end
   end
 
-  def cache_keys_per_model
+  def fetch_cache_keys_per_model
     cache_store.read(CACHE_KEYS_KEY) || {}
   end
 
+  def write_cache_keys_per_model(val)
+    cache_store.write(CACHE_KEYS_KEY, val)
+  end
+
   CACHE_KEYS_KEY = 'ActiveRecordCached:cache_keys_per_model'
 
   def query_db(rel, method, args)

data/lib/activerecord_cached/configuration.rb

@@ -10,7 +10,9 @@ module ActiveRecordCached
   end
 
   def cache_store=(val)
-    val.is_a?(ActiveSupport::Cache::Store) || raise(ArgumentError, 'pass an ActiveSupport::Cache::Store')
+    val.is_a?(ActiveSupport::Cache::MemoryStore) ||
+      val.is_a?(ActiveSupport::Cache::RedisCacheStore) ||
+      raise(ArgumentError, 'pass a MemoryStore or RedisCacheStore')
     @cache_store = store_with_limit_warning(val)
   end
 
@@ -45,7 +47,7 @@ module ActiveRecordCached
 
     store.singleton_class.prepend(Module.new do
       def prune(...)
-        ActiveRecordCached.send(:warn_max_total_bytes_exceeded)
+        ActiveRecordCached.send(:warn_max_total_bytes_exceeded, @max_size)
         super
       end
     end)

data/lib/activerecord_cached/limit_checks.rb

@@ -10,8 +10,8 @@ module ActiveRecordCached
     end
   end
 
-  def warn_max_total_bytes_exceeded
-    warn_limit_reached("Store size >= #{max_total_bytes} max_total_bytes")
+  def warn_max_total_bytes_exceeded(store_size = nil)
+    warn_limit_reached("Store size >= #{store_size || max_total_bytes} max_total_bytes")
   end
 
   def warn_limit_reached(info)

data/lib/activerecord_cached/redis_mutex.rb

@@ -0,0 +1,31 @@
+module ActiveRecordCached
+  class RedisMutex
+    KEY = 'ActiveRecordCached:RedisMutex'
+    MAX_HOLD_TIME = 2
+    LOCK_ACQUIRER = "return redis.call('setnx', KEYS[1], 1) == 1 and redis.call('expire', KEYS[1], KEYS[2]) and 1 or 0"
+
+    def initialize(redis)
+      @redis = redis.then(&:itself)
+    end
+
+    def synchronize(&block)
+      acquire_lock
+      begin
+        block.call
+      ensure
+        release_lock
+      end
+    end
+
+    private
+
+    def acquire_lock
+      sleep_t = 0.005
+      while @redis.eval(LOCK_ACQUIRER, [KEY, MAX_HOLD_TIME]) != 1 do sleep(sleep_t *= 1.6) end
+    end
+
+    def release_lock
+      @redis.del(KEY)
+    end
+  end
+end

data/lib/activerecord_cached/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordCached
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/activerecord_cached.rb

@@ -8,6 +8,7 @@ require_relative "activerecord_cached/cache"
 require_relative "activerecord_cached/configuration"
 require_relative "activerecord_cached/limit_checks"
 require_relative "activerecord_cached/railtie" if defined?(::Rails::Railtie)
+require_relative "activerecord_cached/redis_mutex"
 require_relative "activerecord_cached/version"
 
 module ActiveRecordCached

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_cached
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Janosch Müller
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-23 00:00:00.000000000 Z
+date: 2024-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -56,6 +56,7 @@ files:
 - lib/activerecord_cached/configuration.rb
 - lib/activerecord_cached/limit_checks.rb
 - lib/activerecord_cached/railtie.rb
+- lib/activerecord_cached/redis_mutex.rb
 - lib/activerecord_cached/version.rb
 homepage: https://github.com/jaynetics/activerecord_cached
 licenses: