composite_cache_store 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b6a9480fa18ff9ed0c17318f3ea093c6f8b586b4595427ff9b1056e7c0e9a5f
-  data.tar.gz: 5e9af188c3726dbebec690aabcb838f426e9d26f9c96e48d291b3bb8083a28bc
+  metadata.gz: bcf1949baebddee06f0ba0ec038fed2c56885f10558cc8fa7a362d96dbd7b112
+  data.tar.gz: 435c6f4599e46a80235d8867d3d2812c61fbd012c425f74cce13cbd07df96dd8
 SHA512:
-  metadata.gz: 636f9164938ce4dc6d5fbfc54d24e0e2e0870b8822c770b13bfdb293f02ac5fe4787bc0d9f883a398563f0e8210dcdfd7e89824298cc2dff20c03d4a9a98efea
-  data.tar.gz: c4b79fefc6e70e02243ab8cfdf2c662de139e1e2b3062cd2f171d078cefb2869dae0c8a035d1269be5238015a020d378b77b9288cc42e630858eb91866641706
+  metadata.gz: b75956e16c3e2f1d6f2142f661e59b54e6b5ef3f9efa5c7630e7fd580d8f1e74354df78f0e4eab54c0573d1926ce47b6dae7ccd371cc2a54c1e052a76184b1e2
+  data.tar.gz: 1b756102d631603fead6e33fa37e7e8c2f58a60dc7b428d3c7f5d0e81913a6350b244aedef0386930a1ee37609fdccc034efb816fe29fc33b9ac3f6c8d85af34

data/README.md

@@ -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 "outer cache" with a local in-memory "inner cache".
+When both caches are warm, a read hit on the local in-memory 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 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 as the remote inner-cache
+
+    # 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.2"
 end

data/lib/composite_cache_store.rb

@@ -4,120 +4,136 @@ require "active_support/cache"
 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
+    layers.each do |store|
+      result = store.read_multi(...)
+      return result if result.present?
+    end
+    nil
   end
 
   def silence!
-    outer.silence!
-    inner.silence!
+    layers.each { |store| store.silence! }
   end
 
+  # Only applies expiration options to the outermost cache
+  # Inner caches use their global expiration options
   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|
+      if store == layers.last
+        store.write(name, value, options)
+      else
+        store.write(name, value, options.except(:expires_in, :expires_at))
+      end
+    end
   end
 
+  # Only applies expiration options to the outermost cache
+  # Inner caches use their global expiration options
   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|
+      if store == layers.last
+        store.write_multi(hash, options)
+      else
+        store.write_multi(hash, options.except(:expires_in, :expires_at))
+      end
+    end
   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.2
 platform: ruby
 authors:
 - Nate Hopkins (hopsoft)
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-11 00:00:00.000000000 Z
+date: 2023-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport