composite_cache_store 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b6a9480fa18ff9ed0c17318f3ea093c6f8b586b4595427ff9b1056e7c0e9a5f
-  data.tar.gz: 5e9af188c3726dbebec690aabcb838f426e9d26f9c96e48d291b3bb8083a28bc
+  metadata.gz: 689876c5fc7b2bd00343817eac73b522a0687482aaaeb1058a471c7fcac275e7
+  data.tar.gz: dba46b9f25d1302377dd0fb64c9765a8c6016545f78fdb57444282e6b4d94cd8
 SHA512:
-  metadata.gz: 636f9164938ce4dc6d5fbfc54d24e0e2e0870b8822c770b13bfdb293f02ac5fe4787bc0d9f883a398563f0e8210dcdfd7e89824298cc2dff20c03d4a9a98efea
-  data.tar.gz: c4b79fefc6e70e02243ab8cfdf2c662de139e1e2b3062cd2f171d078cefb2869dae0c8a035d1269be5238015a020d378b77b9288cc42e630858eb91866641706
+  metadata.gz: a04ad705343eea18cdd44d399cbd2264b11fa7eb91a6be8c0d98960b8937510abd77a780a95c816217bf2752cf7fde885dbf423b04aaee11024280876e19f994
+  data.tar.gz: 72bcee27ef6647b444582c481dfa011fedbb587d540537d193a3f1042965bf16e7cb740ed059f6483b7926afdd99dd2b84fe80715665ea8908dcf2c3efc1ca0f

data/README.md

@@ -1,6 +1,6 @@
 # CompositeCacheStore
 
-### A composite cache store comprised of 2 ActiveSupport::Cache::Store instances
+### A composite cache store comprised of layered ActiveSupport::Cache::Store instances
 
 <!-- Tocer[start]: Auto-generated, don't remove. -->
 
@@ -27,9 +27,12 @@ While these services are robust and performant, they can also be a source of lat
 __A composite (or layered) cache can mitigate these risks__
 by reducing traffic and backpressure on the persistence service.
 
-Consider a composite cache that wraps a remote Redis-backed store with an local in-memory store.
-When both caches are warm, a read hit on the local in-memory store will return instantly, avoiding the overhead
-of inter-process communication (IPC) and/or network traffic _(with its attendant data marshaling and socket/wire noise)._
+Consider a composite cache that wraps a remote Redis-backed "layer 2 cache" with a local in-memory "layer 1 cache".
+When both caches are warm, a read hit on the local in-memory "layer 1 cache" returns instantly and avoids the overhead of
+inter-process communication (IPC) and/or network traffic _(with its attendant data marshaling and socket/wire noise)_
+associated with accessing the remote Redis-backed "layer 2 cache".
+
+To summarize: __Reads prioritize the inner cache and fall back to the outer cache.__
 
 ## Sponsors
 
@@ -68,12 +71,17 @@ end
 ```ruby
 # config/initializers/composite_cache_store.rb
 def Rails.composite_cache
-  @store ||= CompositeCacheStore.new(
-    inner_cache_store: Rails.cache, # use whatever makes sense for your app as the remote inner-cache
-    outer_cache_store: ActiveSupport::Cache::MemoryStore.new( # employs an LRU eviction policy
-      expires_in: 15.minutes, # constrain entry lifetime so the local outer-cache doesn't drift out of sync
-      size: 32.megabytes # constrain max memory used by the local outer-cache
-    )
+  @composite_cache ||= CompositeCacheStore.new(
+    # Layer 1 cache (inner) - employs an LRU eviction policy
+    ActiveSupport::Cache::MemoryStore.new(
+      expires_in: 15.minutes, # constrain entry lifetime so the local cache doesn't drift out of sync
+      size: 32.megabytes # constrain max memory used by the local cache
+    ),
+
+    # Layer 2 cache (outer)
+    Rails.cache, # use whatever makes sense for your app
+
+    # additional layers are optional
   )
 end
 ```
@@ -85,8 +93,8 @@ A composite cache is ideal for mitigating hot spot latency in frequently invoked
 ```ruby
 # method that's invoked frequently by multiple processes
 def hotspot
-  # NOTE: the expires_in option is only applied to the remote inner-cache
-  #       the local outer-cache uses its globally configured expiration policy
+  # NOTE: expiration options are only applied to the outermost cache
+  #       inner caches use their globally configured expiration policy
   Rails.composite_cache.fetch("example/slow/operation", expires_in: 12.hours) do
     # a slow operation
   end

data/lib/composite_cache_store/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class CompositeCacheStore
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/lib/composite_cache_store.rb

@@ -1,123 +1,149 @@
 # frozen_string_literal: true
 
-require "active_support/cache"
+require "active_support/all"
 require_relative "composite_cache_store/version"
 
 class CompositeCacheStore
-  DEFAULT_OUTER_OPTIONS = {
+  DEFAULT_LAYER_1_OPTIONS = {
     expires_in: 5.minutes,
     size: 16.megabytes
   }
 
-  DEFAULT_INNER_OPTIONS = {
+  DEFAULT_LAYER_2_OPTIONS = {
     expires_in: 1.day,
     size: 32.megabytes
   }
 
-  attr_reader :outer_cache_store, :inner_cache_store
-
-  alias_method :outer, :outer_cache_store
-  alias_method :inner, :inner_cache_store
+  attr_reader :layers
 
   # Returns a new CompositeCacheStore instance
-  # - inner_cache_store: An ActiveSupport::Cache::Store instance to use for the inner cache store (typically remote)
-  # - outer_cache_store: An ActiveSupport::Cache::Store instance to use for the outer cache store (typically local)
-  def initialize(options = {})
-    options ||= {}
+  def initialize(*layers)
+    if layers.blank?
+      layers << ActiveSupport::Cache::MemoryStore.new(DEFAULT_LAYER_1_OPTIONS)
+      layers << ActiveSupport::Cache::MemoryStore.new(DEFAULT_LAYER_2_OPTIONS)
+    end
 
-    @inner_cache_store = options[:inner_cache_store]
-    @inner_cache_store = ActiveSupport::Cache::MemoryStore.new(DEFAULT_INNER_OPTIONS) unless inner.is_a?(ActiveSupport::Cache::Store)
+    message = "All layers must be instances of ActiveSupport::Cache::Store"
+    layers.each do |layer|
+      raise ArgumentError.new(message) unless layer.is_a?(ActiveSupport::Cache::Store)
+    end
 
-    @outer_cache_store = options[:outer_cache_store]
-    @outer_cache_store = ActiveSupport::Cache::MemoryStore.new(DEFAULT_OUTER_OPTIONS) unless outer.is_a?(ActiveSupport::Cache::Store)
+    layers.freeze
+    @layers = layers
   end
 
   def cleanup(...)
-    outer.cleanup(...)
-    inner.cleanup(...)
+    layers.each { |store| store.cleanup(...) }
   end
 
   def clear(...)
-    outer.clear(...)
-    inner.clear(...)
+    layers.each { |store| store.clear(...) }
   end
 
   def decrement(...)
-    outer.decrement(...)
-    inner.decrement(...)
+    layers.each { |store| store.decrement(...) }
   end
 
   def delete(...)
-    outer.delete(...)
-    inner.delete(...)
+    layers.each { |store| store.delete(...) }
   end
 
   def delete_matched(...)
-    outer.delete_matched(...)
-    inner.delete_matched(...)
+    layers.each { |store| store.delete_matched(...) }
   end
 
   def delete_multi(...)
-    outer.delete_multi(...)
-    inner.delete_multi(...)
+    layers.each { |store| store.delete_multi(...) }
   end
 
   def exist?(...)
-    outer.exist?(...) || inner.exist?(...)
+    layers.each do |store|
+      return true if store.exist?(...)
+    end
+    false
   end
 
   def fetch(*args, &block)
-    outer.fetch(*args) do
-      inner.fetch(*args, &block)
+    f = ->(store) do
+      return store.fetch(*args, &block) if store == layers.last
+      store.fetch(*args) { f.call(layers[layers.index(store) + 1]) }
     end
+    f.call(layers.first)
   end
 
   def fetch_multi(*args, &block)
-    outer.fetch_multi(*args) do
-      inner.fetch_multi(*args, &block)
+    fm = ->(store) do
+      return store.fetch_multi(*args, &block) if store == layers.last
+      store.fetch_multi(*args) { fm.call(layers[layers.index(store) + 1]) }
     end
+    fm.call(layers.first)
   end
 
-  # write
   def increment(...)
-    outer.increment(...)
-    inner.increment(...)
+    layers.each { |store| store.increment(...) }
   end
 
   def mute
-    outer.mute do
-      inner.mute do
-        yield
-      end
+    m = ->(store) do
+      return store.mute { yield } if store == layers.last
+      store.mute { m.call(layers[layers.index(store) + 1]) }
     end
+    m.call(layers.first)
   end
 
   def read(*args)
-    outer.fetch(*args) do
-      inner.read(*args)
+    r = ->(store) do
+      return store.read(*args) if store == layers.last
+      store.fetch(*args) { r.call(layers[layers.index(store) + 1]) }
     end
+    r.call(layers.first)
   end
 
   def read_multi(...)
-    result = outer.read_multi(...)
-    result = inner.read_multi(...) if result.blank?
-    result
+    missed_layers = []
+    layers.each do |store|
+      hash = store.read_multi(...)
+      if hash.present?
+        missed_layers.each { |s| s.write_multi(hash) }
+        return hash
+      end
+      missed_layers << store
+    end
+    {}
   end
 
   def silence!
-    outer.silence!
-    inner.silence!
+    layers.each { |store| store.silence! }
   end
 
   def write(name, value, options = nil)
-    options ||= {}
-    outer.write(name, value, options.except(:expires_in)) # ? accept expires_in if less than outer.config[:expires_in] ?
-    inner.write(name, value, options)
+    layers.each do |store|
+      store.write name, value, permitted_options(store, options)
+    end
   end
 
   def write_multi(hash, options = nil)
-    options ||= {}
-    outer.write_multi(hash, options.except(:expires_in)) # ? accept expires_in if less than outer.config[:expires_in] ?
-    inner.write_multi(hash, options)
+    layers.each do |store|
+      store.write_multi hash, permitted_options(store, options)
+    end
+  end
+
+  private
+
+  def permitted_options(store, options = {})
+    return options if options.blank?
+    return options if keep_expiration?(store, options)
+    options.except(:expires_in, :expires_at)
+  end
+
+  def keep_expiration?(store, options = {})
+    return true if store == layers.last
+    return true unless store.options[:expires_in]
+
+    expires_in = options[:expires_in]
+    expires_in ||= Time.current - options[:expires_at] if options[:expires_at]
+    return false unless expires_in
+
+    expires_in < store.options[:expires_in]
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: composite_cache_store
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Nate Hopkins (hopsoft)
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-11 00:00:00.000000000 Z
+date: 2023-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -82,7 +82,7 @@ dependencies:
         version: '0'
 description: |
   Enhanced application performance with faster reads, data redundancy,
-  and reduced backpressure on the inner cache store.
+  and reduced backpressure on the outer cache store.
 email:
 - natehop@gmail.com
 executables: []
@@ -118,5 +118,6 @@ requirements: []
 rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
-summary: A composite cache store comprised of 2 ActiveSupport::Cache::Store instances
+summary: A composite cache store comprised of layered ActiveSupport::Cache::Store
+  instances
 test_files: []