rails-fast-cache 1.1.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca141bb50fad8045f8dd6c9e47a75bca1cebc3c753189bb376eb9bc3fd0ac784
-  data.tar.gz: c6b28ef4c1bb3ee5702a4904faaad71f783d602bbda2e79bdc6d8c20391a6eff
+  metadata.gz: 7b640d149e3e9b254fc1cf8566ab7b1885a6cd8fe3c1e878b73617326162f008
+  data.tar.gz: fa2fb11469f474771186a7bfba11786ff9df7417ddb5be3722ecb767e069d9e4
 SHA512:
-  metadata.gz: 3e2ffd591f426ee5ee7edb136ec3cb1fa692601a6804942a9774125ae9389113d13d23297adb3ed1b2be2b924d8f798fe1ae0152ddec193963ea467c0f53dc56
-  data.tar.gz: 37fc88731af7baa47967f53db7cc4cccc53a64555f00f1df65348b51888a793951d3d8cd1e2d5d92e531246a2475e47a352a7358f09f033ac85567ef99214ce7
+  metadata.gz: '08f9552be354ffb3791d626585c3b3d6dc9a6615a979019e692efc038c2cc70fccb9f5dd02e3bee7546078cbf3745a8d3ee727f6976bec84bd8089ada8ff80f4'
+  data.tar.gz: 38c368e09b77e4ed2e7493e4683a80709046be8f9f7fc9810db77bad428994d458132325c3be3a0ba709beae8e5e637f1cb6512cfb1793a9d9432af5d685d740

data/lib/rails-fast-cache/async_writes.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RailsFastCache
+  module AsyncWrites
+    attr_accessor :rails_fast_cache_scheduler, :rails_fast_cache_logger
+
+    def write(name, value, options = nil)
+      rails_fast_cache_scheduler.post { perform_async_write { super(name, value, options) } }
+      true
+    end
+
+    def write_multi(hash, options = nil)
+      rails_fast_cache_scheduler.post { perform_async_write { super(hash, options) } }
+      true
+    end
+
+    private
+
+    def perform_async_write
+      yield
+    rescue StandardError => e
+      rails_fast_cache_logger&.error("[rails-fast-cache] async write failed: #{e.class}: #{e.message}")
+      nil
+    end
+  end
+end

data/lib/rails-fast-cache/scheduler.rb

@@ -1,20 +1,40 @@
 # frozen_string_literal: true
 
+require 'concurrent'
+
 module RailsFastCache
   class Scheduler
     EXECUTOR_OPTIONS = {
       min_threads: ENV.fetch('RAILS_MAX_THREADS', 3).to_i,
       max_threads: ENV.fetch('RAILS_MAX_THREADS', 3).to_i,
-      max_queue: 100,
+      max_queue: ENV.fetch('RAILS_FAST_CACHE_MAX_QUEUE', 100).to_i,
       fallback_policy: :caller_runs
     }.freeze
 
-    def self.queue_adapter
-      @queue_adapter ||= ActiveJob::QueueAdapters::AsyncAdapter.new(**EXECUTOR_OPTIONS)
+    def initialize
+      @executor = Concurrent::ThreadPoolExecutor.new(**EXECUTOR_OPTIONS)
+      @inflight = Concurrent::AtomicFixnum.new(0)
+      @idle = Concurrent::Event.new
+      @idle.set
+    end
+
+    def post(&block)
+      @inflight.increment
+      @idle.reset
+      @executor.post do
+        block.call
+      ensure
+        @idle.set if @inflight.decrement.zero?
+      end
+    end
+
+    def flush(timeout = nil)
+      @idle.wait(timeout)
     end
 
-    def self.shutdown
-      @queue_adapter&.shutdown(wait: true)
+    def shutdown(wait: true)
+      @executor.shutdown
+      @executor.wait_for_termination if wait
     end
   end
 end

data/lib/rails-fast-cache/store.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-require 'active_job'
 require 'active_support'
 require 'active_support/core_ext'
 
+require_relative 'async_writes'
 require_relative 'brotli_compressor'
 require_relative 'scheduler'
-require_relative 'write_job'
-require_relative 'write_multi_job'
 
 module RailsFastCache
   class Store < ::ActiveSupport::Cache::Store
@@ -22,47 +20,56 @@ module RailsFastCache
       :fetch,
       :fetch_multi,
       :increment,
-      :key_matcher,
       :mute,
-      :new,
+      :namespace,
+      :namespace=,
+      :options,
       :read,
+      :read_counter,
       :read_multi,
+      :silence,
       :silence!,
+      :silence?,
+      :write,
+      :write_counter,
+      :write_multi,
       to: :@cache_store
     )
     delegate_missing_to :@cache_store
 
-    cattr_accessor :cache_store
-
     def self.supports_cache_versioning?
       true
     end
 
-    def self.shutdown
-      RailsFastCache::Scheduler.shutdown
-    end
-
     def initialize(cache_store, *parameters)
       options = parameters.extract_options!
       options[:compressor] ||= RailsFastCache::BrotliCompressor if !options.key?(:coder) && cache_store != :memory_store
       options[:serializer] ||= :message_pack unless options.key?(:coder)
 
       @cache_store = ActiveSupport::Cache.lookup_store(cache_store, *parameters, **options)
-      self.class.cache_store = @cache_store
-    end
+      @scheduler = RailsFastCache::Scheduler.new
 
-    def write(name, value, options = nil)
-      WriteJob.perform_later(@cache_store, name, value, options)
-      true
+      unless @cache_store.singleton_class.include?(RailsFastCache::AsyncWrites)
+        @cache_store.singleton_class.prepend(RailsFastCache::AsyncWrites)
+      end
+      @cache_store.rails_fast_cache_scheduler = @scheduler
+      @cache_store.rails_fast_cache_logger = @cache_store.logger
     end
 
-    def write_multi(hash, options = nil)
-      WriteMultiJob.perform_later(@cache_store, hash, options)
-      true
+    def flush(timeout = nil)
+      @scheduler.flush(timeout)
     end
 
     def shutdown
-      self.class.shutdown
+      @scheduler.shutdown(wait: true)
+    end
+
+    def write_serialized_entry(...)
+      @cache_store.send(:write_serialized_entry, ...)
+    end
+
+    def read_serialized_entry(...)
+      @cache_store.send(:read_serialized_entry, ...)
     end
   end
 end

data/lib/rails-fast-cache/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsFastCache
-  VERSION = '1.1.0'
+  VERSION = '2.0.2'
 end

data/spec/rails-fast-cache/async_writes_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RailsFastCache::AsyncWrites do
+  let(:logger) { instance_double('Logger', error: nil) }
+
+  def build_store(cache_store_sym = :memory_store)
+    RailsFastCache::Store.new(cache_store_sym)
+  end
+
+  describe '#write' do
+    it 'returns true immediately without waiting for the write to complete' do
+      store = build_store
+      result = nil
+      expect {
+        result = store.write('key', 'value')
+      }.not_to raise_error
+      expect(result).to be(true)
+      store.shutdown
+    end
+
+    it 'makes the value available after flush' do
+      store = build_store
+      store.write('async_key', 'async_value')
+      store.flush
+      expect(store.read('async_key')).to eq('async_value')
+      store.shutdown
+    end
+
+    it 'does not recurse into the async wrapper (inner write called exactly once)' do
+      store = build_store
+      inner = store.instance_variable_get(:@cache_store)
+      call_count = 0
+      original_write_entry = inner.method(:write_entry)
+      allow(inner).to receive(:write_entry) do |*args, **kwargs|
+        call_count += 1
+        original_write_entry.call(*args, **kwargs)
+      end
+      store.write('recurse_key', 'value')
+      store.flush
+      expect(call_count).to eq(1)
+      store.shutdown
+    end
+
+    it 'logs an error on failure but does not raise' do
+      store = build_store
+      inner = store.instance_variable_get(:@cache_store)
+      inner.rails_fast_cache_logger = logger
+      allow(inner).to receive(:write_entry).and_raise('boom')
+      expect { store.write('fail_key', 'value') }.not_to raise_error
+      store.flush
+      expect(logger).to have_received(:error).with(a_string_including('boom'))
+      store.shutdown
+    end
+  end
+
+  describe '#write_multi' do
+    it 'returns the hash immediately without waiting for the write to complete' do
+      store = build_store
+      hash = { 'k1' => 'v1', 'k2' => 'v2' }
+      result = store.write_multi(hash)
+      expect(result).to be_truthy
+      store.shutdown
+    end
+
+    it 'makes all values available after flush' do
+      store = build_store
+      store.write_multi('mk1' => 'mv1', 'mk2' => 'mv2')
+      store.flush
+      expect(store.read('mk1')).to eq('mv1')
+      expect(store.read('mk2')).to eq('mv2')
+      store.shutdown
+    end
+  end
+end

data/spec/rails-fast-cache/store_spec.rb

@@ -46,9 +46,106 @@ describe RailsFastCache::Store do
     test_write(cache_store)
   end
 
+  describe '#options' do
+    it 'reflects options passed to the underlying cache store' do
+      store = RailsFastCache::Store.new(:memory_store, expires_in: 42)
+
+      expect(store.options[:expires_in]).to eq(42)
+    end
+  end
+
+  describe '#silence?' do
+    it 'reflects the underlying cache store mute state' do
+      store = RailsFastCache::Store.new(:memory_store)
+
+      store.mute { expect(store.silence?).to be true }
+      expect(store.silence?).to be_falsy
+    end
+  end
+
+  describe '#namespace' do
+    it 'reflects the namespace passed to the underlying cache store' do
+      store = RailsFastCache::Store.new(:memory_store, namespace: 'test_ns')
+
+      expect(store.namespace).to eq('test_ns')
+    end
+  end
+
+  describe '#read_counter and #write_counter' do
+    it 'delegates counter operations to the underlying cache store' do
+      store = RailsFastCache::Store.new(:memory_store)
+      store.write_counter('store_spec_counter', 1)
+      store.flush
+
+      expect(store.read_counter('store_spec_counter')).to eq(1)
+    end
+  end
+
   def initialize_store(cache_store)
     store = RailsFastCache::Store.new(*cache_store)
     store.delete_matched('store_spec_*')
     store
   end
 end
+
+  describe '#flush' do
+    it 'drains pending async writes without shutting down the pool' do
+      store = RailsFastCache::Store.new(:memory_store)
+      store.write('flush_key', 'flush_value')
+      store.flush
+      expect(store.read('flush_key')).to eq('flush_value')
+      # pool still alive: a subsequent write works
+      store.write('flush_key2', 'v2')
+      store.flush
+      expect(store.read('flush_key2')).to eq('v2')
+      store.shutdown
+    end
+  end
+
+  describe '#fetch' do
+    it 'returns the block value synchronously even though the cache write is deferred' do
+      store = RailsFastCache::Store.new(:memory_store)
+      result = store.fetch('fetch_key') { 'computed' }
+      expect(result).to eq('computed')
+      store.shutdown
+    end
+
+    it 'populates the cache asynchronously on a miss (value present after flush)' do
+      store = RailsFastCache::Store.new(:memory_store)
+      store.fetch('async_fetch_key') { 'fetched_value' }
+      expect(store.read('async_fetch_key')).to be_nil.or eq('fetched_value')
+      store.flush
+      expect(store.read('async_fetch_key')).to eq('fetched_value')
+      store.shutdown
+    end
+
+    it 'does not re-execute the block on a cache hit' do
+      store = RailsFastCache::Store.new(:memory_store)
+      store.fetch('hit_key') { 'original' }
+      store.flush
+      calls = 0
+      store.fetch('hit_key') { calls += 1; 'new' }
+      expect(calls).to eq(0)
+      store.shutdown
+    end
+  end
+
+  describe '#supports_cache_versioning?' do
+    it 'returns true' do
+      expect(RailsFastCache::Store.supports_cache_versioning?).to be(true)
+    end
+  end
+
+  describe 'per-instance isolation' do
+    it 'each Store owns an independent scheduler (shutdown of one does not affect the other)' do
+      store_a = RailsFastCache::Store.new(:memory_store)
+      store_b = RailsFastCache::Store.new(:memory_store)
+      store_a.write('iso_key', 'iso_value')
+      store_a.shutdown
+      # store_b's pool is unaffected
+      store_b.write('iso_key2', 'iso_value2')
+      store_b.shutdown
+      expect(store_b.read('iso_key2')).to eq('iso_value2')
+    end
+  end
+

metadata

@@ -1,29 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: rails-fast-cache
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.2
 platform: ruby
 authors:
 - Filippo Liverani
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-02 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activejob
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -118,13 +117,12 @@ files:
 - LICENSE.txt
 - README.md
 - lib/rails-fast-cache.rb
+- lib/rails-fast-cache/async_writes.rb
 - lib/rails-fast-cache/brotli_compressor.rb
-- lib/rails-fast-cache/non_serializing_job.rb
 - lib/rails-fast-cache/scheduler.rb
 - lib/rails-fast-cache/store.rb
 - lib/rails-fast-cache/version.rb
-- lib/rails-fast-cache/write_job.rb
-- lib/rails-fast-cache/write_multi_job.rb
+- spec/rails-fast-cache/async_writes_spec.rb
 - spec/rails-fast-cache/brotli_compressor_spec.rb
 - spec/rails-fast-cache/store_spec.rb
 - spec/spec_helper.rb
@@ -132,7 +130,6 @@ homepage: https://github.com/filippoliverani/rails-fast-cache
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -147,12 +144,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.18
-signing_key:
+rubygems_version: 4.0.15
 specification_version: 4
 summary: Drop-in improvement for Rails cache, providing enhanced performance with
   asynchronous processing and better default serialization and compression
 test_files:
+- spec/rails-fast-cache/async_writes_spec.rb
 - spec/rails-fast-cache/brotli_compressor_spec.rb
 - spec/rails-fast-cache/store_spec.rb
 - spec/spec_helper.rb

data/lib/rails-fast-cache/non_serializing_job.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_job'
-require_relative 'scheduler'
-
-module RailsFastCache
-  class NonSerializingJob < ::ActiveJob::Base
-    self.logger = nil
-    self.log_arguments = false
-    self.queue_adapter = RailsFastCache::Scheduler.queue_adapter
-
-    def deserialize_arguments(serialized_arguments)
-      serialized_arguments
-    end
-
-    def serialize_arguments(arguments)
-      arguments
-    end
-  end
-end

data/lib/rails-fast-cache/write_job.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'non_serializing_job'
-
-module RailsFastCache
-  class WriteJob < NonSerializingJob
-    def perform(cache_store, name, value, options)
-      cache_store.write(name, value, options)
-    end
-  end
-end

data/lib/rails-fast-cache/write_multi_job.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'non_serializing_job'
-
-module RailsFastCache
-  class WriteMultiJob < NonSerializingJob
-    def perform(cache_store, hash, options)
-      cache_store.write_multi(hash, options)
-    end
-  end
-end