solid_cache 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d92ba4d7c045821d0c54facd1329613e497a46a2b21daffe3a14931bf9621f86
-  data.tar.gz: 46c4b4b81c48a5a5598cc2460e8c1159e69497f130116e9f855a58f8f3e52a36
+  metadata.gz: d61c50ee1ef52b34cbc3d656a65b3f7274ddd21b77963d419787ecb978e01ede
+  data.tar.gz: 612114bb0eade6e73c2d06f2cf342e1245d41ea547bda43b090a5aa6e0d552a1
 SHA512:
-  metadata.gz: 4f3505047c30f24d6f8928d439172f826becc79054a05f32b0c670b3cbb227a10b52889b1e64e2430fe2d279e98c6615bb92634c475fdb6016cd7d3c9c170c07
-  data.tar.gz: 4cb0c61cddd64a4d8093b73b06524ae5585cf5d0c70233bd31fd688b837d38c500df28479bbbb7ffa99b24e26dc3230789dad0d108f9d7fc3df4e02b0eeb0d55
+  metadata.gz: 82a744e8cec593d0cdba4acd0d7d55727d0754507664700c25a2750d2bac011f7db965f751791286e7f918802a12f38fe5e1f251cf5daf5285503d4fae664d15
+  data.tar.gz: 4fe8bf0a189e137a6ec53697d2bfb4fc755c29a2f7d3ce1ca207694a5d9ede2d17871b714416b46fac52d405c6d94dad45951c8aae97b36e8be8d66df5eed720

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2023 37signals
+Copyright (c) 37signals, LLC
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,5 +1,7 @@
 # Solid Cache
 
+**Upgrading from v0.3.0 or earlier? Please see [upgrading to version 0.4.0](upgrading_to_version_0.4.x.md)**
+
 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.
@@ -80,6 +82,7 @@ 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`)
+- `expiry_queue` - which queue to add expiry jobs to (default: `default`)
 - `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] }`
@@ -285,7 +288,7 @@ To run a test for a specific version run:
 bundle exec appraisal rails-7-1 bin/rails test
 ```
 
-After updating the dependencies in then `Gemfile` please run:
+After updating the dependencies in the `Gemfile` please run:
 
 ```shell
 $ bundle

data/app/models/solid_cache/entry/expiration.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SolidCache
+  class Entry
+    module Expiration
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def id_range
+          uncached do
+            pick(Arel.sql("max(id) - min(id) + 1")) || 0
+          end
+        end
+
+        def expire(count, max_age:, max_entries:)
+          if (ids = expiry_candidate_ids(count, max_age: max_age, max_entries: max_entries)).any?
+            delete(ids)
+          end
+        end
+
+        private
+          def expiry_candidate_ids(count, max_age:, max_entries:)
+            cache_full = max_entries && max_entries < id_range
+            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
+              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
+    end
+  end
+end

data/app/models/solid_cache/entry.rb

@@ -2,9 +2,16 @@
 
 module SolidCache
   class Entry < Record
-    # This is all quite awkward but it achieves a couple of performance aims
-    # 1. We skip the query cache
-    # 2. We avoid the overhead of building queries and active record objects
+    include Expiration
+
+    ID_BYTE_SIZE = 8
+    CREATED_AT_BYTE_SIZE = 8
+    KEY_HASH_BYTE_SIZE = 8
+    VALUE_BYTE_SIZE = 4
+    FIXED_SIZE_COLUMNS_BYTE_SIZE = ID_BYTE_SIZE + CREATED_AT_BYTE_SIZE + KEY_HASH_BYTE_SIZE + VALUE_BYTE_SIZE
+
+    self.ignored_columns += [ :key_hash, :byte_size] if SolidCache.key_hash_stage == :ignored
+
     class << self
       def write(key, value)
         upsert_all_no_query_cache([ { key: key, value: value } ])
@@ -15,23 +22,23 @@ module SolidCache
       end
 
       def read(key)
-        select_all_no_query_cache(get_sql, to_binary(key)).first
+        result = select_all_no_query_cache(get_sql, lookup_value(key)).first
+        result[1] if result&.first == key
       end
 
       def read_multi(keys)
-        serialized_keys = keys.map { |key| to_binary(key) }
-        select_all_no_query_cache(get_all_sql(serialized_keys), serialized_keys).to_h
+        key_hashes = keys.map { |key| lookup_value(key) }
+        results = select_all_no_query_cache(get_all_sql(key_hashes), key_hashes).to_h
+        results.except!(results.keys - keys)
       end
 
       def delete_by_key(key)
-        delete_no_query_cache(:key, to_binary(key))
+        delete_no_query_cache(lookup_column, lookup_value(key))
       end
 
-      def delete_matched(matcher, batch_size:)
-        like_matcher = arel_table[:key].matches(matcher, nil, true)
-        where(like_matcher).select(:id).find_in_batches(batch_size: batch_size) do |entries|
-          delete_no_query_cache(:id, entries.map(&:id))
-        end
+      def delete_multi(keys)
+        serialized_keys = keys.map { |key| lookup_value(key) }
+        delete_no_query_cache(lookup_column, serialized_keys)
       end
 
       def clear_truncate
@@ -45,7 +52,8 @@ module SolidCache
       def increment(key, amount)
         transaction do
           uncached do
-            amount += lock.where(key: key).pick(:value).to_i
+            result = lock.where(lookup_column => lookup_value(key)).pick(:key, :value)
+            amount += result[1].to_i if result&.first == key
             write(key, amount)
             amount
           end
@@ -56,48 +64,86 @@ module SolidCache
         increment(key, -amount)
       end
 
-      def id_range
-        uncached do
-          pick(Arel.sql("max(id) - min(id) + 1")) || 0
-        end
-      end
-
-      def expire(count, max_age:, max_entries:)
-        if (ids = expiry_candidate_ids(count, max_age: max_age, max_entries: max_entries)).any?
-          delete(ids)
-        end
-      end
-
       private
-        def upsert_all_no_query_cache(attributes)
-          insert_all = ActiveRecord::InsertAll.new(self, attributes, unique_by: upsert_unique_by, on_duplicate: :update, update_only: [ :value ])
+        def upsert_all_no_query_cache(payloads)
+          insert_all = ActiveRecord::InsertAll.new(
+            self,
+            add_key_hash_and_byte_size(payloads),
+            unique_by: upsert_unique_by,
+            on_duplicate: :update,
+            update_only: upsert_update_only
+          )
           sql = connection.build_insert_sql(ActiveRecord::InsertAll::Builder.new(insert_all))
 
           message = +"#{self} "
-          message << "Bulk " if attributes.many?
+          message << "Bulk " if payloads.many?
           message << "Upsert"
           # exec_query_method does not clear the query cache, exec_insert_all does
           connection.send exec_query_method, sql, message
         end
 
+        def add_key_hash_and_byte_size(payloads)
+          payloads.map do |payload|
+            payload.dup.tap do |payload|
+              if key_hash?
+                payload[:key_hash] = key_hash_for(payload[:key])
+                payload[:byte_size] = byte_size_for(payload)
+              end
+            end
+          end
+        end
+
+        def key_hash?
+          @key_hash ||= [ :indexed, :unindexed ].include?(SolidCache.key_hash_stage) &&
+            connection.column_exists?(table_name, :key_hash)
+        end
+
+        def key_hash_indexed?
+          key_hash? && SolidCache.key_hash_stage == :indexed
+        end
+
+        def lookup_column
+          key_hash_indexed? ? :key_hash : :key
+        end
+
+        def lookup_value(key)
+          key_hash_indexed? ? key_hash_for(key) : to_binary(key)
+        end
+
+        def lookup_placeholder
+          key_hash_indexed? ? 1 : "placeholder"
+        end
+
         def exec_query_method
           connection.respond_to?(:internal_exec_query) ? :internal_exec_query : :exec_query
         end
 
         def upsert_unique_by
-          connection.supports_insert_conflict_target? ? :key : nil
+          connection.supports_insert_conflict_target? ? lookup_column : nil
+        end
+
+        def upsert_update_only
+          if key_hash_indexed?
+            [ :key, :value, :byte_size ]
+          elsif key_hash?
+            [ :value, :key_hash, :byte_size ]
+          else
+            [ :value ]
+          end
         end
 
         def get_sql
-          @get_sql ||= build_sql(where(key: "placeholder").select(:value))
+          @get_sql ||= {}
+          @get_sql[lookup_column] ||= build_sql(where(lookup_column => lookup_placeholder).select(:key, :value))
         end
 
-        def get_all_sql(keys)
+        def get_all_sql(key_hashes)
           if connection.prepared_statements?
             @get_all_sql_binds ||= {}
-            @get_all_sql_binds[keys.count] ||= build_sql(where(key: keys).select(:key, :value))
+            @get_all_sql_binds[[key_hashes.count, lookup_column]] ||= build_sql(where(lookup_column => key_hashes).select(:key, :value))
           else
-            @get_all_sql_no_binds ||= build_sql(where(key: [ "placeholder1", "placeholder2" ]).select(:key, :value)).gsub("?, ?", "?")
+            @get_all_sql_no_binds ||= {}
+            @get_all_sql_no_binds[lookup_column] ||= build_sql(where(lookup_column => [ lookup_placeholder, lookup_placeholder ]).select(:key, :value)).gsub("?, ?", "?")
           end
         end
 
@@ -140,29 +186,13 @@ module SolidCache
           ActiveModel::Type::Binary.new.serialize(key)
         end
 
-        def expiry_candidate_ids(count, max_age:, max_entries:)
-          cache_full = max_entries && max_entries < id_range
-          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
-            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
+        def key_hash_for(key)
+          # Need to unpack this as a signed integer - Postgresql and SQLite don't support unsigned integers
+          Digest::SHA256.digest(key.to_s).unpack("q>").first
+        end
 
-            candidate_ids.sample(count)
-          end
+        def byte_size_for(payload)
+          payload[:key].to_s.bytesize + payload[:value].to_s.bytesize + FIXED_SIZE_COLUMNS_BYTE_SIZE
         end
     end
   end

data/db/migrate/20230724121448_create_solid_cache_entries.rb

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

data/db/migrate/20240108155507_add_key_hash_and_byte_size_to_solid_cache_entries.rb

@@ -0,0 +1,8 @@
+class AddKeyHashAndByteSizeToSolidCacheEntries < ActiveRecord::Migration[7.1]
+  def change
+    change_table :solid_cache_entries do |t|
+      t.column :key_hash,  :integer, null: true, limit: 8
+      t.column :byte_size, :integer, null: true, limit: 4
+    end
+  end
+end

data/db/migrate/20240110111600_add_key_hash_and_byte_size_indexes_and_null_constraints_to_solid_cache_entries.rb

@@ -0,0 +1,11 @@
+class AddKeyHashAndByteSizeIndexesAndNullConstraintsToSolidCacheEntries < ActiveRecord::Migration[7.1]
+  def change
+    change_table :solid_cache_entries, bulk: true do |t|
+      t.change_null :key_hash, false
+      t.change_null :byte_size, false
+      t.index  :key_hash, unique: true
+      t.index  [:key_hash, :byte_size]
+      t.index  :byte_size
+    end
+  end
+end

data/db/migrate/20240110111702_remove_key_index_from_solid_cache_entries.rb

@@ -0,0 +1,7 @@
+class RemoveKeyIndexFromSolidCacheEntries < ActiveRecord::Migration[7.1]
+  def change
+    change_table :solid_cache_entries do |t|
+      t.remove_index :key
+    end
+  end
+end

data/lib/solid_cache/cluster/execution.rb

@@ -5,7 +5,7 @@ module SolidCache
     module Execution
       def initialize(options = {})
         super(options)
-        @background = Concurrent::SingleThreadExecutor.new(max_queue: 100, fallback_policy: :discard)
+        @background = Concurrent::FixedThreadPool.new(1, max_queue: 100, fallback_policy: :discard)
         @active_record_instrumentation = options.fetch(:active_record_instrumentation, true)
       end
 

data/lib/solid_cache/cluster/expiry.rb

@@ -9,13 +9,14 @@ module SolidCache
       # This ensures there is downward pressure on the cache size while there is valid data to delete
       EXPIRY_MULTIPLIER = 1.25
 
-      attr_reader :expiry_batch_size, :expiry_method, :expire_every, :max_age, :max_entries
+      attr_reader :expiry_batch_size, :expiry_method, :expiry_queue, :expires_per_write, :max_age, :max_entries
 
       def initialize(options = {})
         super(options)
         @expiry_batch_size = options.fetch(:expiry_batch_size, 100)
         @expiry_method = options.fetch(:expiry_method, :thread)
-        @expire_every = [ (expiry_batch_size / EXPIRY_MULTIPLIER).floor, 1 ].max
+        @expiry_queue = options.fetch(:expiry_queue, :default)
+        @expires_per_write = (1 / expiry_batch_size.to_f) * EXPIRY_MULTIPLIER
         @max_age = options.fetch(:max_age, 2.weeks.to_i)
         @max_entries = options.fetch(:max_entries, nil)
 
@@ -23,41 +24,26 @@ module SolidCache
       end
 
       def track_writes(count)
-        expire_later if expiry_counter.count(count)
+        expiry_batches(count).times { expire_later }
       end
 
       private
+        def expiry_batches(count)
+          batches = (count * expires_per_write).floor
+          overflow_batch_chance = count * expires_per_write - batches
+          batches += 1 if rand < overflow_batch_chance
+          batches
+        end
+
         def expire_later
           if expiry_method == :job
-            ExpiryJob.perform_later(expiry_batch_size, shard: Entry.current_shard, max_age: max_age, max_entries: max_entries)
+            ExpiryJob
+              .set(queue: expiry_queue)
+              .perform_later(expiry_batch_size, shard: Entry.current_shard, max_age: max_age, max_entries: max_entries)
           else
             async { Entry.expire(expiry_batch_size, max_age: max_age, max_entries: max_entries) }
           end
         end
-
-        def expiry_counter
-          @expiry_counters ||= connection_names.index_with { |connection_name| Counter.new(expire_every) }
-          @expiry_counters[Entry.current_shard]
-        end
-
-        class Counter
-          attr_reader :expire_every, :counter
-
-          def initialize(expire_every)
-            @expire_every = expire_every
-            @counter = Concurrent::AtomicFixnum.new(rand(expire_every).to_i)
-          end
-
-          def count(count)
-            value = counter.increment(count)
-            new_multiple_of_expire_every?(value - count, value)
-          end
-
-          private
-            def new_multiple_of_expire_every?(first_value, second_value)
-              first_value / expire_every != second_value / expire_every
-            end
-        end
     end
   end
 end

data/lib/solid_cache/engine.rb

@@ -13,6 +13,12 @@ module SolidCache
 
       SolidCache.executor = config.solid_cache.executor
       SolidCache.connects_to = config.solid_cache.connects_to
+      if config.solid_cache.key_hash_stage
+        unless [:ignored, :unindexed, :indexed].include?(config.solid_cache.key_hash_stage)
+          raise "ArgumentError, :key_hash_stage must be :ignored, :unindexed or :indexed"
+        end
+        SolidCache.key_hash_stage = config.solid_cache.key_hash_stage
+      end
     end
 
     config.after_initialize do

data/lib/solid_cache/store/api.rb

@@ -14,20 +14,6 @@ module SolidCache
         @max_key_bytesize = options.fetch(:max_key_bytesize, DEFAULT_MAX_KEY_BYTESIZE)
       end
 
-      def delete_matched(matcher, options = {})
-        instrument :delete_matched, matcher do
-          raise ArgumentError, "Only strings are supported: #{matcher.inspect}" unless String === matcher
-          raise ArgumentError, "Strings cannot start with wildcards" if SQL_WILDCARD_CHARS.include?(matcher[0])
-
-          options ||= {}
-          batch_size = options.fetch(:batch_size, 1000)
-
-          matcher = namespace_key(matcher, options)
-
-          entry_delete_matched(matcher, batch_size)
-        end
-      end
-
       def increment(name, amount = 1, options = nil)
         options = merged_options(options)
         key = normalize_key(name, options)
@@ -119,7 +105,7 @@ module SolidCache
         end
 
         def delete_multi_entries(entries, **options)
-          entries.count { |key| delete_entry(key, **options) }
+          entry_delete_multi(entries).compact.sum
         end
 
         def serialize_entry(entry, raw: false, **options)

data/lib/solid_cache/store/entries.rb

@@ -17,12 +17,6 @@ module SolidCache
       end
 
       private
-        def entry_delete_matched(matcher, batch_size)
-          writing_all(failsafe: :delete_matched) do
-            Entry.delete_matched(matcher, batch_size: batch_size)
-          end
-        end
-
         def entry_clear
           writing_all(failsafe: :clear) do
             if clear_with == :truncate
@@ -78,6 +72,12 @@ module SolidCache
             Entry.delete_by_key(key)
           end
         end
+
+        def entry_delete_multi(entries)
+          writing_keys(entries, failsafe: :delete_multi_entries, failsafe_returning: false) do
+            Entry.delete_multi(entries)
+          end
+        end
     end
   end
 end

data/lib/solid_cache/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
-  VERSION = "0.3.0"
+  VERSION = "0.4.1"
 end

data/lib/solid_cache.rb

@@ -10,6 +10,7 @@ loader.setup
 
 module SolidCache
   mattr_accessor :executor, :connects_to
+  mattr_accessor :key_hash_stage, default: :indexed
 
   def self.all_shard_keys
     all_shards_config&.keys || []

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solid_cache
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Donal McBreen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-08 00:00:00.000000000 Z
+date: 2024-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -92,8 +92,12 @@ files:
 - Rakefile
 - app/jobs/solid_cache/expiry_job.rb
 - app/models/solid_cache/entry.rb
+- app/models/solid_cache/entry/expiration.rb
 - app/models/solid_cache/record.rb
 - db/migrate/20230724121448_create_solid_cache_entries.rb
+- db/migrate/20240108155507_add_key_hash_and_byte_size_to_solid_cache_entries.rb
+- db/migrate/20240110111600_add_key_hash_and_byte_size_indexes_and_null_constraints_to_solid_cache_entries.rb
+- db/migrate/20240110111702_remove_key_index_from_solid_cache_entries.rb
 - lib/active_support/cache/solid_cache_store.rb
 - lib/generators/solid_cache/install/USAGE
 - lib/generators/solid_cache/install/install_generator.rb
@@ -122,7 +126,9 @@ licenses:
 metadata:
   homepage_uri: http://github.com/rails/solid_cache
   source_code_uri: http://github.com/rails/solid_cache
-post_install_message:
+post_install_message: |
+  Solid Cache v0.4 contains new database migrations.
+  See https://github.com/rails/solid_cache/blob/main/upgrading_to_version_0.4.x.md for upgrade instructions.
 rdoc_options: []
 require_paths:
 - lib
@@ -137,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.1
+rubygems_version: 3.5.4
 signing_key:
 specification_version: 4
 summary: A database backed ActiveSupport::Cache::Store