lru_redux_store 0.1.0.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6bcc0e3bda88de5344be1eed33c06f985ad9ec76e252cfd4732830c24afe5760
+  data.tar.gz: 53478ad2d249f38690225ca43606f5e290cf6ab16de659f3d067459cf08ae9b8
+SHA512:
+  metadata.gz: c148200eb44a574e137cf57b4c9340055ed261db1c68cd54e0c8d02dbcfac1140893ec58576675cb2adbafdce584db4f6d14e56e55936a99380daea0e445ea3a
+  data.tar.gz: 1104df0afb5b9112424b5c0366cd98d2e38d59fe10df7420d68ef9649656b6ae8401986169662091993244399a6c1bc090574a918dc87b2d14480e3ba001cd99

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,35 @@
+inherit_from:
+  - .rubocop_todo.yml
+
+plugins:
+  - rubocop-rails
+  - rubocop-performance
+  - rubocop-rspec
+
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.3
+  SuggestExtensions: false
+  Exclude:
+    - bench/**/*
+
+Style/Documentation:
+  Enabled: false
+
+Gemspec/DevelopmentDependencies:
+  Enabled: false
+
+# One class implements the entire cache store API surface.
+Metrics/ClassLength:
+  Max: 110
+
+# This gem runs outside Rails: no Time.zone is configured, and wall-clock
+# Time.now is what the store and the backing sin_lru_redux cache use.
+Rails/TimeZone:
+  Enabled: false
+
+# ActiveSupport::Cache::Store#fetch takes options as its second positional
+# argument, not a default value, so the Hash#fetch rewrite does not apply.
+Style/RedundantFetchBlock:
+  Exclude:
+    - spec/**/*_spec.rb

data/.ruby-version

@@ -0,0 +1 @@
+4.0.5

data/Appraisals

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+appraise 'rails-7.2' do
+  gem 'rails', '~> 7.2.0'
+end
+
+appraise 'rails-8.0' do
+  gem 'rails', '~> 8.0.2'
+end
+
+appraise 'rails-8.1' do
+  gem 'rails', '~> 8.1.0'
+end
+
+appraise 'rails-edge' do
+  gem 'rails', github: 'rails/rails'
+end

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lru_redux_store.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2026 jonathan schatz
+
+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,72 @@
+# LruReduxStore
+
+This gem provides an [`ActiveSupport::Cache::Store`](https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html) implementation backed by [`sin_lru_redux`](https://github.com/cadenza-tech/sin_lru_redux), an "efficient and thread-safe LRU cache". It's a drop-in alternative to `ActiveSupport::Cache::MemoryStore` that's bounded by entry count instead of estimated byte size.
+
+## Requirements
+
+This gem requires `activesupport` >= `7.2` and `ruby` >= `3.3`.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add lru_redux_store
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install lru_redux_store
+```
+
+## Problem
+
+`ActiveSupport::Cache::MemoryStore` does its housekeeping in batches. Expired entries pile up until a write pushes the cache over its size cap, and that write then sweeps the whole cache: it scans every entry for expired ones and deletes least recently used entries until enough space is free. The sweep runs while holding the lock every other cache operation needs, so one unlucky request stalls for the whole thing and every concurrent request queues behind it.
+
+This gem does the same housekeeping incrementally. Each access evicts whatever has already expired, and a write that overflows `max_size` evicts a single entry, so the work is spread across every operation instead of concentrated in occasional pauses.
+
+## How it works
+
+The store keeps its data in a `LruRedux::TTL::ThreadSafeCache`. `max_size` caps the number of entries. When a write would exceed it, the least recently used entry is evicted.
+
+If you pass `expires_in` the backing cache enforces it as a Time To Live eviction strategy. TTL eviction occurs on every access and takes precedence over LRU eviction, meaning a 'live' value will never be evicted over an expired one. `cleanup` triggers a TTL eviction manually. Without `expires_in` the behavior is identical to a plain LRU cache: nothing ever expires and entries only leave through LRU eviction, `delete`, `delete_matched`, or `clear`.
+
+Values are copied on the way in and out, matching `MemoryStore`. The coder is a vendored copy of `MemoryStore`'s `DupCoder`: strings are duplicated and everything else takes a `Marshal` round-trip, so a write stores a private copy and every read returns a fresh one. Mutating a value you got from `fetch` never affects other readers.
+
+Like `MemoryStore` this cache is per-process. Each process gets its own copy and they don't talk to each other, so don't use it for anything that needs to be consistent across processes.
+
+`increment`, `decrement`, `delete_matched`, and `cleanup` are all supported and emit the same `cache_*` instrumentation events as `MemoryStore`, so `ActiveSupport::Notifications` subscribers and log subscribers work unchanged.
+
+## Usage
+
+```ruby
+config.cache_store = :lru_redux_store, { max_size: 10_000, expires_in: 1.hour }
+```
+
+Both options are optional. `max_size` defaults to `1000`. Leave `expires_in` off and entries never expire, they just age out of the LRU.
+
+You can also use the store directly:
+
+```ruby
+cache = LruReduxStore::Store.new(max_size: 10_000)
+cache.fetch('some-key') { expensive_computation }
+```
+
+`expires_in` passed to an individual `write` or `fetch` call is honored the same way it is with any other cache store.
+
+## Benchmarks
+
+tl;dr - this gem trades a little per-operation speed for the absence of large pauses
+
+See [bench/README.md](bench/README.md) for the setup and full numbers. Reads and writes are slightly slower than `MemoryStore` because eviction and expiry work happens on every operation, but there's never a full-cache sweep, so worst-case latency stays flat where `MemoryStore` stalls for several milliseconds at a time (in the TTL benchmark those sweeps eat over 20% of total write time).
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/modosc/lru_redux_store.

data/Rakefile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)

data/bench/README.md

@@ -0,0 +1,79 @@
+# Benchmarks
+
+Run these with `bundle exec`:
+
+```bash
+bundle exec ruby bench/bench.rb
+bundle exec ruby bench/bench_ttl.rb
+bundle exec ruby bench/bench_prune.rb
+bundle exec ruby bench/bench_prune_ttl.rb
+```
+
+`bench.rb` and `bench_ttl.rb` measure throughput, with and without a TTL. `bench_prune.rb` and `bench_prune_ttl.rb` measure per-write latency under sustained eviction pressure. MemoryStore is bounded by bytes and LruReduxStore by entries, so the latency benchmarks calibrate themselves first: they run the same write stream against a throwaway MemoryStore, record how many entries it holds when its first prune fires, and use that count as LruReduxStore's `max_size`. Both stores reach capacity and start evicting at the same write.
+
+## Results
+
+Apple silicon laptop, ruby 4.0.2, activesupport 8.1.3. 1m operations for the throughput runs, 200k unique-key writes for the latency runs.
+
+### Throughput
+
+```
+** LRU Benchmarks (no TTL) **
+                                                    user     system      total        real
+LruRedux::ThreadSafeCache                       0.231287   0.000707   0.231994 (  0.232720)
+LruRedux::TTL::ThreadSafeCache (TTL disabled)   0.339670   0.000962   0.340632 (  0.340927)
+ActiveSupport::Cache::MemoryStore               1.897356   0.006356   1.903712 (  1.905111)
+LruReduxStore::Store                            2.148409   0.007220   2.155629 (  2.158542)
+LruReduxStore::Store (1k entries, ~50% miss)    3.451640   0.013249   3.464889 (  3.468145)
+
+** TTL Benchmarks **
+                                                        user     system      total        real
+LruRedux::TTL::ThreadSafeCache                      0.619437   0.002868   0.622305 (  0.622808)
+ActiveSupport::Cache::MemoryStore (TTL enabled)     2.095064   0.011191   2.106255 (  2.110231)
+LruReduxStore::Store (TTL enabled)                  2.829217   0.024145   2.853362 (  2.881794)
+LruReduxStore::Store (TTL, 1k entries, ~50% miss)   4.601842   0.031277   4.633119 (  4.651033)
+```
+
+### Write latency under eviction pressure
+
+```
+** Write latency under sustained eviction pressure (200000 unique-key writes, no TTL) **
+
+calibration: a 4mb MemoryStore holds 12049 entries of this shape; its first prune fired at write 12050.
+LruReduxStore gets max_size 12049, so its first eviction happens at write 12050.
+
+ActiveSupport::Cache::MemoryStore (size: 4mb)
+  total   0.58s   p50     2.00us   p99     3.00us   max    2998.00us
+  entries at end: 10862, evictions: 189138
+  prune events: 63, longest 1.88ms, cumulative 79.40ms (13.7% of total time)
+  cleanup sweeps: 63, longest 1.17ms, cumulative 47.10ms (8.2% of total time)
+
+LruReduxStore::Store (max_size: 12049)
+  total   0.71s   p50     3.00us   p99     9.00us   max    3805.00us
+  entries at end: 12049, evictions: 187951
+  prune events: none
+  cleanup sweeps: none
+```
+
+```
+** Write latency under sustained expiry pressure (200000 unique-key writes, 25ms TTL) **
+
+calibration: a 4mb MemoryStore holds 12049 entries of this shape; its first prune fired at write 12050.
+LruReduxStore gets max_size 12049 and the same 25ms TTL.
+
+ActiveSupport::Cache::MemoryStore (size: 4mb, expires_in: 0.025)
+  total   0.64s   p50     2.00us   p99     3.00us   max    6957.00us
+  entries at end: 11666, evicted or expired: 188334
+  prune events: 40, longest 0.02ms, cumulative 0.29ms (0.0% of total time)
+  cleanup sweeps: 40, longest 6.86ms, cumulative 139.37ms (21.6% of total time)
+
+LruReduxStore::Store (max_size: 12049, expires_in: 0.025)
+  total   0.85s   p50     3.00us   p99     9.00us   max    1724.00us
+  entries at end: 6334, evicted or expired: 193666
+  prune events: none
+  cleanup sweeps: none
+```
+
+## Analysis
+
+Median write latency is identical and throughput is close, with LruReduxStore a little slower per operation since it pays for eviction and expiry on every write. The difference is where MemoryStore does that work: synchronized prune and cleanup passes that stall a single write for several milliseconds while every other thread queues behind the lock, and once entries are actually expiring those sweeps eat over 20% of total write time. LruReduxStore has no batch phase at all, so its worst case stays flat.

data/bench/bench.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'benchmark'
+require 'lru_redux'
+require 'active_support'
+require 'active_support/cache'
+require 'active_support/cache/memory_store'
+require 'active_support/notifications'
+require 'lru_redux_store'
+
+# Raw sin_lru_redux caches, for reference.
+redux_thread_safe = LruRedux::ThreadSafeCache.new(1_000)
+redux_ttl_disabled = LruRedux::TTL::ThreadSafeCache.new(1_000)
+
+# MemoryStore's 32mb default cap holds the entire rand(2_000) keyspace (~100%
+# hit rate), so give LruReduxStore::Store enough slots to do the same; the
+# bounded variant shows the cost of a ~50% miss rate.
+memory_store = ActiveSupport::Cache::MemoryStore.new
+lru_redux_store = LruReduxStore::Store.new(max_size: 2_000)
+lru_redux_store_bounded = LruReduxStore::Store.new(max_size: 1_000)
+
+puts '** LRU Benchmarks (no TTL) **'
+Benchmark.bmbm do |bm|
+  bm.report 'LruRedux::ThreadSafeCache' do
+    1_000_000.times { redux_thread_safe.getset(rand(2_000)) { :value } }
+  end
+
+  bm.report 'LruRedux::TTL::ThreadSafeCache (TTL disabled)' do
+    1_000_000.times { redux_ttl_disabled.getset(rand(2_000)) { :value } }
+  end
+
+  bm.report 'ActiveSupport::Cache::MemoryStore' do
+    1_000_000.times { memory_store.fetch(rand(2_000)) { :value } }
+  end
+
+  bm.report 'LruReduxStore::Store' do
+    1_000_000.times { lru_redux_store.fetch(rand(2_000)) { :value } }
+  end
+
+  bm.report 'LruReduxStore::Store (1k entries, ~50% miss)' do
+    1_000_000.times { lru_redux_store_bounded.fetch(rand(2_000)) { :value } }
+  end
+end

data/bench/bench_prune.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'active_support'
+require 'active_support/cache'
+require 'active_support/cache/memory_store'
+require 'active_support/notifications'
+require 'lru_redux_store'
+
+# MemoryStore prunes when a write pushes its estimated byte size over the cap:
+# that write runs cleanup (a scan of every entry in the cache) and then deletes
+# least recently used entries one at a time until the size is back under 75% of
+# the cap, all while holding the monitor every other cache operation needs.
+#
+# The two stores bound themselves differently (bytes vs entries), so to keep
+# the comparison as close as possible the entry cap is calibrated rather than
+# assumed: a throwaway MemoryStore runs the same write stream and we record how
+# many entries it actually holds when its first prune fires. LruReduxStore gets
+# that number as max_size, so both stores reach capacity and start evicting at
+# the same write index. The remaining difference is the thing being measured:
+# MemoryStore evicts ~25% of the cache in one synchronized burst, LruReduxStore
+# evicts one entry per write.
+
+VALUE = 'x' * 100
+WRITES = 200_000
+MEMORY_STORE_BYTES = 4 * 1024 * 1024
+
+def calibrate_capacity
+  probe = ActiveSupport::Cache::MemoryStore.new(size: MEMORY_STORE_BYTES)
+  data = probe.instance_variable_get(:@data)
+  pruned = false
+  subscriber = ActiveSupport::Notifications.subscribe('cache_prune.active_support') { pruned = true }
+  peak = 0
+  writes = 0
+  until pruned
+    probe.write("key-#{writes}", VALUE)
+    writes += 1
+    peak = data.size if data.size > peak
+    raise 'MemoryStore never pruned during calibration' if writes >= WRITES
+  end
+  [peak, writes]
+ensure
+  ActiveSupport::Notifications.unsubscribe(subscriber)
+end
+
+def measure_writes(store)
+  latencies = Array.new(WRITES)
+  WRITES.times do |i|
+    key = "key-#{i}"
+    t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    store.write(key, VALUE)
+    latencies[i] = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+  end
+  latencies.sort!
+  {
+    total: latencies.sum,
+    p50: latencies[WRITES / 2],
+    p99: latencies[(WRITES * 0.99).floor],
+    max: latencies.last
+  }
+end
+
+def report_events(name, durations, total)
+  if durations.empty?
+    puts "  #{name}: none"
+  else
+    puts format('  %s: %d, longest %.2fms, cumulative %.2fms (%.1f%% of total time)',
+                name, durations.size, durations.max * 1_000, durations.sum * 1_000, (durations.sum / total) * 100)
+  end
+end
+
+# MemoryStore#prune runs its cleanup pass (the expired-entry sweep of the
+# whole cache) before its instrument(:prune) block starts, so prune event
+# durations exclude it. cache_cleanup events are tracked separately or that
+# sweep cost would disappear from the numbers.
+def report(label, stats, entries_at_end, prunes, cleanups)
+  puts label
+  puts format('  total %6.2fs   p50 %8.2fus   p99 %8.2fus   max %10.2fus',
+              stats[:total], stats[:p50] * 1_000_000, stats[:p99] * 1_000_000, stats[:max] * 1_000_000)
+  puts format('  entries at end: %d, evictions: %d', entries_at_end, WRITES - entries_at_end)
+  report_events('prune events', prunes, stats[:total])
+  report_events('cleanup sweeps', cleanups, stats[:total])
+  puts
+end
+
+entry_capacity, first_prune_at = calibrate_capacity
+
+puts "** Write latency under sustained eviction pressure (#{WRITES} unique-key writes, no TTL) **"
+puts
+puts format('calibration: a %dmb MemoryStore holds %d entries of this shape; its first prune fired at write %d.',
+            MEMORY_STORE_BYTES / 1024 / 1024, entry_capacity, first_prune_at)
+puts format('LruReduxStore gets max_size %d, so its first eviction happens at write %d.',
+            entry_capacity, entry_capacity + 1)
+puts
+
+prunes = []
+cleanups = []
+prune_subscriber = ActiveSupport::Notifications.subscribe('cache_prune.active_support') do |_name, started, finished, _id, _payload|
+  prunes << (finished - started)
+end
+cleanup_subscriber = ActiveSupport::Notifications.subscribe('cache_cleanup.active_support') do |_name, started, finished, _id, _payload|
+  cleanups << (finished - started)
+end
+
+memory_store = ActiveSupport::Cache::MemoryStore.new(size: MEMORY_STORE_BYTES)
+stats = measure_writes(memory_store)
+entries = memory_store.instance_variable_get(:@data).size
+report "ActiveSupport::Cache::MemoryStore (size: #{MEMORY_STORE_BYTES / 1024 / 1024}mb)",
+       stats, entries, prunes, cleanups
+
+prunes = []
+cleanups = []
+lru_redux_store = LruReduxStore::Store.new(max_size: entry_capacity)
+stats = measure_writes(lru_redux_store)
+entries = lru_redux_store.instance_variable_get(:@data).count
+report "LruReduxStore::Store (max_size: #{entry_capacity})", stats, entries, prunes, cleanups
+
+ActiveSupport::Notifications.unsubscribe(prune_subscriber)
+ActiveSupport::Notifications.unsubscribe(cleanup_subscriber)

data/bench/bench_prune_ttl.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'active_support'
+require 'active_support/cache'
+require 'active_support/cache/memory_store'
+require 'active_support/notifications'
+require 'lru_redux_store'
+
+# TTL variant of bench_prune.rb. The TTL is short enough that entries expire
+# while the benchmark is still running, which is where the two stores differ
+# most. MemoryStore never removes an entry at expiry: expired entries keep
+# counting toward the byte cap until a read touches them or a prune's cleanup
+# phase sweeps the whole cache, so expiration work arrives in the same
+# synchronized bursts as eviction work. LruReduxStore's backing cache pops
+# expired entries incrementally on every access instead.
+#
+# Capacity is calibrated the same way as bench_prune.rb: a throwaway
+# MemoryStore runs the same write stream and we record how many entries it
+# holds when its first prune fires, then LruReduxStore gets that number as
+# max_size. Both stores also get the same TTL.
+
+VALUE = 'x' * 100
+WRITES = 200_000
+MEMORY_STORE_BYTES = 4 * 1024 * 1024
+
+# ~25ms: shorter than the time it takes either store to fill to capacity, so
+# expiry is the dominant force rather than LRU eviction.
+TTL = 0.025
+
+def calibrate_capacity
+  probe = ActiveSupport::Cache::MemoryStore.new(size: MEMORY_STORE_BYTES, expires_in: TTL)
+  data = probe.instance_variable_get(:@data)
+  pruned = false
+  subscriber = ActiveSupport::Notifications.subscribe('cache_prune.active_support') { pruned = true }
+  peak = 0
+  writes = 0
+  until pruned
+    probe.write("key-#{writes}", VALUE)
+    writes += 1
+    peak = data.size if data.size > peak
+    raise 'MemoryStore never pruned during calibration' if writes >= WRITES
+  end
+  [peak, writes]
+ensure
+  ActiveSupport::Notifications.unsubscribe(subscriber)
+end
+
+def measure_writes(store)
+  latencies = Array.new(WRITES)
+  WRITES.times do |i|
+    key = "key-#{i}"
+    t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    store.write(key, VALUE)
+    latencies[i] = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+  end
+  latencies.sort!
+  {
+    total: latencies.sum,
+    p50: latencies[WRITES / 2],
+    p99: latencies[(WRITES * 0.99).floor],
+    max: latencies.last
+  }
+end
+
+def report_events(name, durations, total)
+  if durations.empty?
+    puts "  #{name}: none"
+  else
+    puts format('  %s: %d, longest %.2fms, cumulative %.2fms (%.1f%% of total time)',
+                name, durations.size, durations.max * 1_000, durations.sum * 1_000, (durations.sum / total) * 100)
+  end
+end
+
+# MemoryStore#prune runs its cleanup pass (the expired-entry sweep of the
+# whole cache) before its instrument(:prune) block starts, so prune event
+# durations exclude it. cache_cleanup events are tracked separately or the
+# expiry sweep cost would disappear from the numbers.
+def report(label, stats, entries_at_end, prunes, cleanups)
+  puts label
+  puts format('  total %6.2fs   p50 %8.2fus   p99 %8.2fus   max %10.2fus',
+              stats[:total], stats[:p50] * 1_000_000, stats[:p99] * 1_000_000, stats[:max] * 1_000_000)
+  puts format('  entries at end: %d, evicted or expired: %d', entries_at_end, WRITES - entries_at_end)
+  report_events('prune events', prunes, stats[:total])
+  report_events('cleanup sweeps', cleanups, stats[:total])
+  puts
+end
+
+entry_capacity, first_prune_at = calibrate_capacity
+
+puts "** Write latency under sustained expiry pressure (#{WRITES} unique-key writes, #{(TTL * 1000).to_i}ms TTL) **"
+puts
+puts format('calibration: a %dmb MemoryStore holds %d entries of this shape; its first prune fired at write %d.',
+            MEMORY_STORE_BYTES / 1024 / 1024, entry_capacity, first_prune_at)
+puts format('LruReduxStore gets max_size %d and the same %dms TTL.', entry_capacity, (TTL * 1000).to_i)
+puts
+
+prunes = []
+cleanups = []
+prune_subscriber = ActiveSupport::Notifications.subscribe('cache_prune.active_support') do |_name, started, finished, _id, _payload|
+  prunes << (finished - started)
+end
+cleanup_subscriber = ActiveSupport::Notifications.subscribe('cache_cleanup.active_support') do |_name, started, finished, _id, _payload|
+  cleanups << (finished - started)
+end
+
+memory_store = ActiveSupport::Cache::MemoryStore.new(size: MEMORY_STORE_BYTES, expires_in: TTL)
+stats = measure_writes(memory_store)
+entries = memory_store.instance_variable_get(:@data).size
+report "ActiveSupport::Cache::MemoryStore (size: #{MEMORY_STORE_BYTES / 1024 / 1024}mb, expires_in: #{TTL})",
+       stats, entries, prunes, cleanups
+
+prunes = []
+cleanups = []
+lru_redux_store = LruReduxStore::Store.new(max_size: entry_capacity, expires_in: TTL)
+stats = measure_writes(lru_redux_store)
+entries = lru_redux_store.instance_variable_get(:@data).count
+report "LruReduxStore::Store (max_size: #{entry_capacity}, expires_in: #{TTL})", stats, entries, prunes, cleanups
+
+ActiveSupport::Notifications.unsubscribe(prune_subscriber)
+ActiveSupport::Notifications.unsubscribe(cleanup_subscriber)

data/bench/bench_ttl.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'benchmark'
+require 'lru_redux'
+require 'active_support'
+require 'active_support/cache'
+require 'active_support/cache/memory_store'
+require 'active_support/notifications'
+require 'lru_redux_store'
+
+TTL = 5 * 60
+
+# Raw sin_lru_redux TTL cache, for reference.
+redux_ttl_thread_safe = LruRedux::TTL::ThreadSafeCache.new(1_000, TTL)
+
+# Same keyspace/capacity reasoning as bench.rb: 2k slots for the head-to-head
+# with MemoryStore, 1k for the bounded ~50% miss variant.
+memory_store = ActiveSupport::Cache::MemoryStore.new(expires_in: TTL)
+lru_redux_store = LruReduxStore::Store.new(max_size: 2_000, expires_in: TTL)
+lru_redux_store_bounded = LruReduxStore::Store.new(max_size: 1_000, expires_in: TTL)
+
+puts '** TTL Benchmarks **'
+Benchmark.bmbm do |bm|
+  bm.report 'LruRedux::TTL::ThreadSafeCache' do
+    1_000_000.times { redux_ttl_thread_safe.getset(rand(2_000)) { :value } }
+  end
+
+  bm.report 'ActiveSupport::Cache::MemoryStore (TTL enabled)' do
+    1_000_000.times { memory_store.fetch(rand(2_000)) { :value } }
+  end
+
+  bm.report 'LruReduxStore::Store (TTL enabled)' do
+    1_000_000.times { lru_redux_store.fetch(rand(2_000)) { :value } }
+  end
+
+  bm.report 'LruReduxStore::Store (TTL, 1k entries, ~50% miss)' do
+    1_000_000.times { lru_redux_store_bounded.fetch(rand(2_000)) { :value } }
+  end
+end

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'lru_redux_store'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/active_support/cache/lru_redux_store.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'lru_redux_store'
+
+module ActiveSupport # :nodoc:
+  module Cache # :nodoc:
+    # Registers the store under the name ActiveSupport::Cache expects, so
+    # <tt>config.cache_store = :lru_redux_store</tt> resolves to
+    # LruReduxStore::Store.
+    LruReduxStore = LruReduxStore::Store
+  end
+end

data/lib/lru_redux_store/dup_coder.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module LruReduxStore
+  # Vendored copy of ActiveSupport::Cache::MemoryStore::DupCoder (activesupport
+  # 8.1.3, MIT license). DupCoder is :nodoc: internal API, so we carry our own
+  # copy rather than referencing it:
+  # https://github.com/rails/rails/blob/v8.1.3/activesupport/lib/active_support/cache/memory_store.rb
+  #
+  # Dups string values and marshals everything else so the cache never shares
+  # object references with callers. A write stores a private copy and every
+  # read returns a fresh one.
+  module DupCoder # :nodoc:
+    extend self
+
+    MARSHAL_SIGNATURE = "\x04\x08".b.freeze
+
+    def dump(entry)
+      if entry.value && entry.value != true && !entry.value.is_a?(Numeric)
+        ActiveSupport::Cache::Entry.new(dump_value(entry.value), expires_at: entry.expires_at, version: entry.version)
+      else
+        entry
+      end
+    end
+
+    def dump_compressed(entry, threshold)
+      compressed_entry = entry.compressed(threshold)
+      compressed_entry.compressed? ? compressed_entry : dump(entry)
+    end
+
+    def load(entry)
+      if !entry.compressed? && entry.value.is_a?(String)
+        ActiveSupport::Cache::Entry.new(load_value(entry.value), expires_at: entry.expires_at, version: entry.version)
+      else
+        entry
+      end
+    end
+
+    private
+
+    def dump_value(value)
+      if value.is_a?(String) && !value.start_with?(MARSHAL_SIGNATURE)
+        value.dup
+      else
+        Marshal.dump(value)
+      end
+    end
+
+    def load_value(string)
+      if string.start_with?(MARSHAL_SIGNATURE)
+        # only strings produced by dump_value above carry the marshal
+        # signature, so this never loads untrusted external data
+        Marshal.load(string) # rubocop:disable Security/MarshalLoad
+      else
+        string.dup
+      end
+    end
+  end
+end

data/lib/lru_redux_store/store.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/cache'
+require 'active_support/core_ext/integer/time'
+require 'objspace'
+require 'sin_lru_redux'
+
+module LruReduxStore
+  # A thread-safe cache store implementation which stores everything in memory
+  # in the same process, backed by LruRedux::TTL::ThreadSafeCache. Unlike
+  # ActiveSupport::Cache::MemoryStore it is bounded by entry count rather than
+  # estimated byte size, and eviction and expiry happen incrementally on each
+  # access instead of in periodic full-cache pruning passes.
+  class Store < ActiveSupport::Cache::Store
+    # Creates a new store. Accepts the standard ActiveSupport::Cache::Store
+    # options plus:
+    #
+    # * +max_size+ - the maximum number of entries (default 1000). The least
+    #   recently used entry is evicted when a write would exceed it.
+    # * +expires_in+ - optional TTL enforced by the backing cache. Without it
+    #   entries never expire and only leave through LRU eviction.
+    def initialize(options = nil)
+      options ||= {}
+      # dup/marshal values so the cache never shares object references with
+      # callers, matching MemoryStore. pass coder: nil to store raw values
+      options[:coder] = DupCoder unless options.key?(:coder) || options.key?(:serializer)
+      # Disable compression by default.
+      options[:compress] ||= false
+      # store-level expiry is enforced solely by the backing TTL cache; keep
+      # expires_in out of @options so the base class never embeds it in entries
+      @expires_in = options.delete(:expires_in)
+      super
+      @max_size = options[:max_size] || 1000
+      @data = build_data_cache
+
+      @cache_size = 0
+    end
+
+    # Advertise cache versioning support.
+    def self.supports_cache_versioning?
+      true
+    end
+
+    # Delete all data stored in a given cache store.
+    def clear(_options = nil)
+      @data.clear
+      @cache_size = 0
+    end
+
+    # Deletes cache entries if the cache key matches a given pattern.
+    def delete_matched(matcher, options = nil)
+      options = merged_options options
+      matcher = key_matcher matcher, options
+
+      instrument :delete_matched, matcher.inspect do
+        keys = @data.to_a.map(&:first)
+        keys.each do |key|
+          delete_entry(key, **options) if key.match matcher
+        end
+      end
+    end
+
+    # Preemptively iterates through all stored keys and removes the ones which have expired.
+    def cleanup(_options = nil)
+      _instrument(:cleanup, size: @data.count) do
+        synchronize { @data.expire }
+      end
+    end
+
+    # Increment a cached integer value. Returns the updated value.
+    #
+    # If the key is unset, it will be set to +amount+:
+    #
+    #   cache.increment("foo") # => 1
+    #   cache.increment("bar", 100) # => 100
+    #
+    # To set a specific value, call #write:
+    #
+    #   cache.write("baz", 5)
+    #   cache.increment("baz") # => 6
+    #
+    def increment(name, amount = 1, **options)
+      instrument(:increment, name, amount: amount) do
+        modify_value(name, amount, **options)
+      end
+    end
+
+    # Decrement a cached integer value. Returns the updated value.
+    #
+    # If the key is unset or has expired, it will be set to +-amount+.
+    #
+    #   cache.decrement("foo") # => -1
+    #
+    # To set a specific value, call #write:
+    #
+    #   cache.write("baz", 5)
+    #   cache.decrement("baz") # => 4
+    #
+    def decrement(name, amount = 1, **options)
+      instrument(:decrement, name, amount: amount) do
+        modify_value(name, -amount, **options)
+      end
+    end
+
+    # Synchronize calls to the cache. This should be called wherever the underlying cache implementation
+    # is not thread safe.
+    def synchronize(&) # :nodoc:
+      @data.synchronize(&)
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class.name} entries=#{@data.count}, size=#{@cache_size}, options=#{@options.inspect}>"
+    end
+
+    # Fixed per-entry bookkeeping cost in bytes, counted toward the reported
+    # cache size on top of each key and payload. Matches MemoryStore.
+    PER_ENTRY_OVERHEAD = 240
+
+    private
+
+    def build_data_cache
+      if @expires_in
+        LruRedux::TTL::ThreadSafeCache.new @max_size, @expires_in.to_f
+      else
+        # the TTL argument defaults to :none, and the behavior of a TTL cache
+        # with the TTL set to :none is identical to the LRU cache
+        LruRedux::TTL::ThreadSafeCache.new @max_size
+      end
+    end
+
+    def cached_size(key, payload)
+      ObjectSpace.memsize_of(key.to_s) + ObjectSpace.memsize_of(payload) + PER_ENTRY_OVERHEAD
+    end
+
+    def read_entry(key, **_options)
+      deserialize_entry(@data[key])
+    end
+
+    def exists?(key, **_options)
+      @data.key? key
+    end
+
+    def write_entry(key, entry, **options) # rubocop:disable Naming/PredicateMethod
+      return false if options[:unless_exist] && exist?(key, namespace: nil)
+
+      payload = serialize_entry(entry, **options)
+      old_payload = @data[key]
+      if old_payload
+        @cache_size -= (ObjectSpace.memsize_of(old_payload) - ObjectSpace.memsize_of(payload))
+      else
+        @cache_size += cached_size(key, payload)
+      end
+      @data[key] = payload
+      true
+    end
+
+    def delete_entry(key, **_options) # rubocop:disable Naming/PredicateMethod
+      payload = @data.delete key
+      @cache_size -= cached_size(key, payload) if payload
+      !!payload
+    end
+
+    # Modifies the amount of an integer value that is stored in the cache.
+    # If the key is not found it is created and set to +amount+.
+    def modify_value(name, amount, **options) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      options = merged_options options
+      key     = normalize_key name, options
+      version = normalize_version name, options
+
+      synchronize do
+        entry = read_entry(key, **options)
+
+        if !entry || entry.expired? || entry.mismatched?(version)
+          write(name, Integer(amount), options)
+          amount
+        else
+          num = entry.value.to_i + amount
+          entry = ActiveSupport::Cache::Entry.new(num, version: entry.version)
+          write_entry(key, entry)
+          num
+        end
+      end
+    end
+  end
+end

data/lib/lru_redux_store/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module LruReduxStore
+  # Current release version.
+  VERSION = '0.1.0.alpha'
+end

data/lib/lru_redux_store.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/active_support")
+loader.setup
+
+require 'active_support/cache'
+
+# An ActiveSupport::Cache::Store implementation backed by sin_lru_redux, an
+# efficient and thread-safe LRU cache. See LruReduxStore::Store.
+module LruReduxStore
+end
+
+loader.eager_load

data/lru_redux_store.gemspec

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lru_redux_store/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'lru_redux_store'
+  spec.version = LruReduxStore::VERSION
+  spec.authors = ['jonathan schatz']
+  spec.email = ['modosc@users.noreply.github.com']
+
+  spec.summary = 'An ActiveSupport::Cache::Store backed by sin_lru_redux.'
+  spec.description = 'A bounded, thread-safe, in-memory cache store for Rails. ' \
+                     'Backed by sin_lru_redux for O(1) LRU eviction with optional TTL, ' \
+                     'it stores raw values with no serialization and emits the same ' \
+                     'interface as ActiveSupport::Cache::Store.'
+  spec.homepage = 'https://github.com/modosc/lru_redux_store'
+  spec.required_ruby_version = '>= 3.3.0'
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/modosc/lru_redux_store'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+  spec.metadata['licenses'] = 'MIT'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  File.basename(__FILE__)
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'appraisal', '~> 2.5.0'
+  spec.add_development_dependency 'benchmark'
+  spec.add_development_dependency 'bundler', '>= 2.4.18'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rake', '~> 13.4.0'
+  spec.add_development_dependency 'rspec', '~> 3.13.0'
+  spec.add_development_dependency 'rspec-rails', '~> 8.0.2'
+  spec.add_development_dependency 'rubocop', '~> 1.88.2'
+  spec.add_development_dependency 'rubocop-performance', '~> 1.26.0'
+  spec.add_development_dependency 'rubocop-rails', '~> 2.35.5'
+  spec.add_development_dependency 'rubocop-rspec', '~> 3.10.2'
+  spec.add_dependency 'activesupport', '>= 7.2.0'
+  spec.add_dependency 'sin_lru_redux', '>= 2.5.2'
+  spec.add_dependency 'zeitwerk', '>= 2.5.0'
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/sig/lru_redux_store.rbs

@@ -0,0 +1,4 @@
+module LruReduxStore
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,266 @@
+--- !ruby/object:Gem::Specification
+name: lru_redux_store
+version: !ruby/object:Gem::Version
+  version: 0.1.0.alpha
+platform: ruby
+authors:
+- jonathan schatz
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.18
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.18
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.4.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.13.0
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.0.2
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.88.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.88.2
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.26.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.26.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.35.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.35.5
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.2
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+- !ruby/object:Gem::Dependency
+  name: sin_lru_redux
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.2
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+description: A bounded, thread-safe, in-memory cache store for Rails. Backed by sin_lru_redux
+  for O(1) LRU eviction with optional TTL, it stores raw values with no serialization
+  and emits the same interface as ActiveSupport::Cache::Store.
+email:
+- modosc@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".ruby-version"
+- Appraisals
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bench/README.md
+- bench/bench.rb
+- bench/bench_prune.rb
+- bench/bench_prune_ttl.rb
+- bench/bench_ttl.rb
+- bin/console
+- bin/setup
+- lib/active_support/cache/lru_redux_store.rb
+- lib/lru_redux_store.rb
+- lib/lru_redux_store/dup_coder.rb
+- lib/lru_redux_store/store.rb
+- lib/lru_redux_store/version.rb
+- lru_redux_store.gemspec
+- sig/lru_redux_store.rbs
+homepage: https://github.com/modosc/lru_redux_store
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/modosc/lru_redux_store
+  source_code_uri: https://github.com/modosc/lru_redux_store
+  rubygems_mfa_required: 'true'
+  licenses: MIT
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.12
+specification_version: 4
+summary: An ActiveSupport::Cache::Store backed by sin_lru_redux.
+test_files: []