solid_cache 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0649423e526a66fa9554f73d215e7e49c6ff093c004c1641d72a670a33688468'
-  data.tar.gz: ad56d9f53b6b0c6f9dcc049771a187e95c5e2cceeabeaa07286f96212f5b0fb7
+  metadata.gz: d92ba4d7c045821d0c54facd1329613e497a46a2b21daffe3a14931bf9621f86
+  data.tar.gz: 46c4b4b81c48a5a5598cc2460e8c1159e69497f130116e9f855a58f8f3e52a36
 SHA512:
-  metadata.gz: 900011771476bff6c3b3ec5abe087a0dcf00596f6e200dec961aa7e13f3ad4d978d9ac8858d3912b8bc0bc63a8742de4e925bd04b120d15badb890448946f4c2
-  data.tar.gz: c9fd66e658ec1e38f628c592053f330179571a7299a1d4e6bae88a959996c10c4d7df158c30c9827464e0c3af526a4b5c0100f55f51c5b3e563e73b5af93226a
+  metadata.gz: 4f3505047c30f24d6f8928d439172f826becc79054a05f32b0c670b3cbb227a10b52889b1e64e2430fe2d279e98c6615bb92634c475fdb6016cd7d3c9c170c07
+  data.tar.gz: 4cb0c61cddd64a4d8093b73b06524ae5585cf5d0c70233bd31fd688b837d38c500df28479bbbb7ffa99b24e26dc3230789dad0d108f9d7fc3df4e02b0eeb0d55

data/README.md

@@ -1,6 +1,6 @@
 # Solid Cache
 
-Solid Cache is a database-backed Active Support cache store implementation. 
+Solid Cache is a database-backed Active Support cache store implementation.
 
 Using SQL databases backed by SSDs we can have caches that are much larger and cheaper than traditional memory only Redis or Memcached backed caches.
 
@@ -58,7 +58,7 @@ $ bin/rails db:migrate
 There are two options that can be set on the engine:
 
 - `executor` - the [Rails executor](https://guides.rubyonrails.org/threading_and_code_execution.html#executor) used to wrap asynchronous operations, defaults to the app executor
-- `connects_to` - a custom connects to value for the abstract `SolidCache::Record` active record model. Requires for sharding and/or using a separate cache database to the main app.
+- `connects_to` - a custom connects to value for the abstract `SolidCache::Record` active record model. Required for sharding and/or using a separate cache database to the main app.
 
 These can be set in your Rails configuration:
 
@@ -80,19 +80,19 @@ Solid Cache supports these options in addition to the standard `ActiveSupport::C
 - `error_handler` - a Proc to call to handle any `ActiveRecord::ActiveRecordError`s that are raises (default: log errors as warnings)
 - `expiry_batch_size` - the batch size to use when deleting old records (default: `100`)
 - `expiry_method` - what expiry method to use `thread` or `job` (default: `thread`)
-- `max_age` - the maximum age of entries in the cache (default: `2.weeks.to_i`)
-- `max_entries` - the maximum number of entries allowed in the cache (default: `2.weeks.to_i`)
+- `max_age` - the maximum age of entries in the cache (default: `2.weeks.to_i`). Can be set to `nil`, but this is not recommended unless using `max_entries` to limit the size of the cache.
+- `max_entries` - the maximum number of entries allowed in the cache (default: `nil`, meaning no limit)
 - `cluster` - a Hash of options for the cache database cluster, e.g `{ shards: [:database1, :database2, :database3] }`
 - `clusters` - and Array of Hashes for multiple cache clusters (ignored if `:cluster` is set)
 - `active_record_instrumentation` - whether to instrument the cache's queries (default: `true`)
-- `clear_with` - clear the cache with `:truncate` or `:delete` (default `truncate`, except for when Rails.env.test? then `delete`)
+- `clear_with` - clear the cache with `:truncate` or `:delete` (default `truncate`, except for when `Rails.env.test?` then `delete`)
 - `max_key_bytesize` - the maximum size of a normalized key in bytes (default `1024`)
 
 For more information on cache clusters see [Sharding the cache](#sharding-the-cache)
 
 ### Cache expiry
 
-Solid Cache tracks writes to the cache. For every write it increments a counter by 1. Once the counter reaches 80% of the `expiry_batch_size` it add a task to run on a background thread. That task will:
+Solid Cache tracks writes to the cache. For every write it increments a counter by 1. Once the counter reaches 80% of the `expiry_batch_size` it adds a task to run on a background thread. That task will:
 
 1. Check if we have exceeded the `max_entries` value (if set) by subtracting the max and min IDs from the `SolidCache::Entry` table (this is an estimate that ignores any gaps).
 2. If we have it will delete `expiry_batch_size` entries
@@ -109,7 +109,7 @@ If you want the cache expiry to be run in a background job instead of a thread,
 Add database configuration to database.yml, e.g.:
 
 ```
-development
+development:
   cache:
     database: cache_development
     host: 127.0.0.1
@@ -135,7 +135,7 @@ $ mv db/migrate/*.solid_cache.rb db/cache/migrate
 Set the engine configuration to point to the new database:
 ```
 Rails.application.configure do
-  config.solid_cache.connects_to = { default: { writing: :cache } }
+  config.solid_cache.connects_to = { database: { writing: :cache } }
 end
 ```
 
@@ -155,7 +155,7 @@ To shard:
 3. Pass the shards for the cache to use via the cluster option
 
 For example:
-```ruby
+```yml
 # config/database.yml
 production:
   cache_shard1:
@@ -167,8 +167,9 @@ production:
   cache_shard3:
     database: cache3_production
     host: cache3-db
+```
 
-
+```ruby
 # config/environment/production.rb
 Rails.application.configure do
   config.solid_cache.connects_to = {
@@ -203,7 +204,7 @@ Rails.application.configure do
   }
 
   primary_cluster = { shards: [ :cache_primary_shard1, :cache_primary_shard2 ] }
-  secondary_cluster = { shards: [ :cache_primary_shard1, :cache_primary_shard2 ] }
+  secondary_cluster = { shards: [ :cache_secondary_shard1, :cache_secondary_shard2 ] }
   config.cache_store = [ :solid_cache_store, clusters: [ primary_cluster, secondary_cluster ] ]
 end
 ```
@@ -250,19 +251,48 @@ The Solid Cache migrations try to create an index with 1024 byte entries. If tha
 
 ## Development
 
-Run the tests with `bin/rails test`. These will run against SQLite.
+Run the tests with `bin/rails test`. By default, these will run against SQLite.
 
-You can also run the tests against MySQL and Postgres. First start up the databases:
+You can also run the tests against MySQL and PostgreSQL. First start up the databases:
 
 ```shell
 $ docker compose up -d
 ```
 
-Then run the tests for the target database
+Next, setup the database schema:
+
+```shell
+$ TARGET_DB=mysql bin/rails db:setup
+$ TARGET_DB=postgres bin/rails db:setup
 ```
+
+
+Then run the tests for the target database:
+
+```shell
 $ TARGET_DB=mysql bin/rails test
 $ TARGET_DB=postgres bin/rails test
 ```
 
+### Testing with multiple Rails version
+
+Solid Cache relies on [appraisal](https://github.com/thoughtbot/appraisal/tree/main) to test
+multiple Rails version.
+
+To run a test for a specific version run:
+
+```shell
+bundle exec appraisal rails-7-1 bin/rails test
+```
+
+After updating the dependencies in then `Gemfile` please run:
+
+```shell
+$ bundle
+$ appraisal update
+```
+
+This ensures that all the Rails versions dependencies are updated.
+
 ## License
 Solid Cache is licensed under MIT.

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "bundler/setup"
 
 APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)

data/app/jobs/solid_cache/expiry_job.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class ExpiryJob < ActiveJob::Base
     def perform(count, shard: nil, max_age:, max_entries:)

data/app/models/solid_cache/entry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Entry < Record
     # This is all quite awkward but it achieves a couple of performance aims
@@ -21,10 +23,6 @@ module SolidCache
         select_all_no_query_cache(get_all_sql(serialized_keys), serialized_keys).to_h
       end
 
-      def expire(ids)
-        delete_no_query_cache(:id, ids) if ids.any?
-      end
-
       def delete_by_key(key)
         delete_no_query_cache(:key, to_binary(key))
       end
@@ -78,8 +76,12 @@ module SolidCache
           message = +"#{self} "
           message << "Bulk " if attributes.many?
           message << "Upsert"
-          # exec_query does not clear the query cache, exec_insert_all does
-          connection.exec_query sql, message
+          # exec_query_method does not clear the query cache, exec_insert_all does
+          connection.send exec_query_method, sql, message
+        end
+
+        def exec_query_method
+          connection.respond_to?(:internal_exec_query) ? :internal_exec_query : :exec_query
         end
 
         def upsert_unique_by
@@ -113,7 +115,7 @@ module SolidCache
             if connection.prepared_statements?
               result = connection.select_all(sanitize_sql(query), "#{name} Load", Array(values), preparable: true)
             else
-              result = connection.select_all(sanitize_sql([ query, values ]), "#{name} Load", nil, preparable: false)
+              result = connection.select_all(sanitize_sql([ query, values ]), "#{name} Load", Array(values), preparable: false)
             end
 
             result.cast_values(SolidCache::Entry.attribute_types)
@@ -140,14 +142,26 @@ module SolidCache
 
         def expiry_candidate_ids(count, max_age:, max_entries:)
           cache_full = max_entries && max_entries < id_range
-          min_created_at = max_age.seconds.ago
+          return [] unless cache_full || max_age
+
+          # In the case of multiple concurrent expiry operations, it is desirable to
+          # reduce the overlap of entries being addressed by each. For that reason,
+          # retrieve more ids than are being expired, and use random
+          # sampling to reduce that number to the actual intended count.
+          retrieve_count = count * 3
 
           uncached do
-            order(:id)
-              .limit(count * 3)
-              .pluck(:id, :created_at)
-              .filter_map { |id, created_at| id if cache_full || created_at < min_created_at }
-              .sample(count)
+            candidates = order(:id).limit(retrieve_count)
+
+            candidate_ids = if cache_full
+              candidates.pluck(:id)
+            else
+              min_created_at = max_age.seconds.ago
+              candidates.pluck(:id, :created_at)
+                        .filter_map { |id, created_at| id if created_at < min_created_at }
+            end
+
+            candidate_ids.sample(count)
           end
         end
     end

data/app/models/solid_cache/record.rb

@@ -1,21 +1,21 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Record < ActiveRecord::Base
     NULL_INSTRUMENTER = ActiveSupport::Notifications::Instrumenter.new(ActiveSupport::Notifications::Fanout.new)
 
     self.abstract_class = true
 
-    connects_to **SolidCache.connects_to if SolidCache.connects_to
+    connects_to(**SolidCache.connects_to) if SolidCache.connects_to
 
     class << self
-      def disable_instrumentation
-        connection.with_instrumenter(NULL_INSTRUMENTER) do
-          yield
-        end
+      def disable_instrumentation(&block)
+        connection.with_instrumenter(NULL_INSTRUMENTER, &block)
       end
 
       def with_shard(shard, &block)
-        if shard && shard != Record.current_shard
-          Record.connected_to(shard: shard, &block)
+        if shard && SolidCache.connects_to
+          connected_to(shard: shard, role: default_role, prevent_writes: false, &block)
         else
           block.call
         end

data/db/migrate/20230724121448_create_solid_cache_entries.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CreateSolidCacheEntries < ActiveRecord::Migration[7.0]
   def change
     create_table :solid_cache_entries do |t|

data/lib/active_support/cache/solid_cache_store.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module Cache
     SolidCacheStore = SolidCache::Store

data/lib/generators/solid_cache/install/install_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class SolidCache::InstallGenerator < Rails::Generators::Base
   class_option :skip_migrations,    type: :boolean, default: nil,
                                     desc: "Skip migrations"

data/lib/solid_cache/cluster/connections.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Cluster
     module Connections

data/lib/solid_cache/cluster/execution.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Cluster
     module Execution

data/lib/solid_cache/cluster/expiry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "concurrent/atomic/atomic_fixnum"
 
 module SolidCache
@@ -34,7 +36,7 @@ module SolidCache
         end
 
         def expiry_counter
-          @expiry_counters ||= connection_names.to_h { |connection_name| [ connection_name, Counter.new(expire_every) ] }
+          @expiry_counters ||= connection_names.index_with { |connection_name| Counter.new(expire_every) }
           @expiry_counters[Entry.current_shard]
         end
 

data/lib/solid_cache/cluster/stats.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Cluster
     module Stats
@@ -6,7 +8,7 @@ module SolidCache
       end
 
       def stats
-        stats = {
+        {
           connections: connections.count,
           connection_stats: connections_stats
         }

data/lib/solid_cache/cluster.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module SolidCache
   class Cluster

data/lib/solid_cache/connections/sharded.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   module Connections
     class Sharded

data/lib/solid_cache/connections/single.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   module Connections
     class Single

data/lib/solid_cache/connections/unmanaged.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   module Connections
     class Unmanaged

data/lib/solid_cache/connections.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   module Connections
     def self.from_config(options)

data/lib/solid_cache/engine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support"
 
 module SolidCache

data/lib/solid_cache/maglev_hash.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 # See https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/44824.pdf
 
 module SolidCache
   class MaglevHash
     attr_reader :nodes
 
-    #  Must be prime
+    # Must be prime
     TABLE_SIZE = 2053
 
     def initialize(nodes)

data/lib/solid_cache/store/api.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Store
     module Api
@@ -74,7 +76,7 @@ module SolidCache
         end
 
         def read_multi_entries(names, **options)
-          keys_and_names = names.to_h { |name| [ normalize_key(name, options), name ] }
+          keys_and_names = names.index_by { |name| normalize_key(name, options) }
           serialized_entries = read_serialized_entries(keys_and_names.keys)
 
           keys_and_names.each_with_object({}) do |(key, name), results|
@@ -88,7 +90,14 @@ module SolidCache
             if entry.expired?
               delete_entry(key, **options)
             elsif !entry.mismatched?(version)
-              results[name] = entry.value
+              if defined? ActiveSupport::Cache::DeserializationError
+                begin
+                  results[name] = entry.value
+                rescue ActiveSupport::Cache::DeserializationError
+                end
+              else
+                results[name] = entry.value
+              end
             end
           end
         end

data/lib/solid_cache/store/clusters.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Store
     module Clusters
@@ -20,11 +22,9 @@ module SolidCache
       end
 
       private
-        def reading_key(key, failsafe:, failsafe_returning: nil)
+        def reading_key(key, failsafe:, failsafe_returning: nil, &block)
           failsafe(failsafe, returning: failsafe_returning) do
-            primary_cluster.with_connection_for(key) do
-              yield
-            end
+            primary_cluster.with_connection_for(key, &block)
           end
         end
 
@@ -65,13 +65,11 @@ module SolidCache
           end
         end
 
-        def writing_all(failsafe:, failsafe_returning: nil)
+        def writing_all(failsafe:, failsafe_returning: nil, &block)
           first_cluster_sync_rest_async do |cluster, async|
             cluster.connection_names.each do |connection|
               failsafe(failsafe, returning: failsafe_returning) do
-                cluster.with_connection(connection, async: async) do
-                  yield
-                end
+                cluster.with_connection(connection, async: async, &block)
               end
             end
           end

data/lib/solid_cache/store/entries.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Store
     module Entries

data/lib/solid_cache/store/failsafe.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Store
     module Failsafe

data/lib/solid_cache/store.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Store < ActiveSupport::Cache::Store
     include Api, Clusters, Entries, Failsafe

data/lib/solid_cache/version.rb

@@ -1,3 +1,3 @@
 module SolidCache
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/solid_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "zeitwerk"
 require "solid_cache/engine"
 
@@ -17,12 +19,12 @@ module SolidCache
     connects_to && connects_to[:shards]
   end
 
-  def self.each_shard
+  def self.each_shard(&block)
     return to_enum(:each_shard) unless block_given?
 
     if (shards = all_shards_config&.keys)
       shards.each do |shard|
-        Record.connected_to(shard: shard) { yield }
+        Record.with_shard(shard, &block)
       end
     else
       yield

data/lib/tasks/solid_cache_tasks.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 desc "Copy over the migration, and set cache"
 namespace :solid_cache do
   task :install do

metadata

@@ -1,17 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: solid_cache
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Donal McBreen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-02 00:00:00.000000000 Z
+date: 2024-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -109,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.17
+rubygems_version: 3.5.1
 signing_key:
 specification_version: 4
 summary: A database backed ActiveSupport::Cache::Store