solid_cache 0.6.0 → 1.0.0

data/lib/solid_cache/configuration.rb

@@ -2,12 +2,15 @@
 
 module SolidCache
   class Configuration
-    attr_reader :store_options, :connects_to, :executor, :size_estimate_samples
+    attr_reader :store_options, :connects_to, :executor, :size_estimate_samples, :encrypt, :encryption_context_properties
 
-    def initialize(store_options: {}, database: nil, databases: nil, connects_to: nil, executor: nil, size_estimate_samples: 10_000)
+    def initialize(store_options: {}, database: nil, databases: nil, connects_to: nil, executor: nil, encrypt: false, encryption_context_properties: nil, size_estimate_samples: 10_000)
       @store_options = store_options
       @size_estimate_samples = size_estimate_samples
       @executor = executor
+      @encrypt = encrypt
+      @encryption_context_properties = encryption_context_properties
+      @encryption_context_properties ||= default_encryption_context_properties if encrypt?
       set_connects_to(database: database, databases: databases, connects_to: connects_to)
     end
 
@@ -19,6 +22,10 @@ module SolidCache
       sharded? ? connects_to[:shards].keys : []
     end
 
+    def encrypt?
+      encrypt.present?
+    end
+
     private
       def set_connects_to(database:, databases:, connects_to:)
         if [database, databases, connects_to].compact.size > 1
@@ -37,5 +44,16 @@ module SolidCache
             nil
           end
       end
+
+      def default_encryption_context_properties
+        require "active_record/encryption/message_pack_message_serializer"
+
+        {
+          # No need to compress, the cache does that already
+          encryptor: ActiveRecord::Encryption::Encryptor.new(compress: false),
+          # Binary column only serializer that is 40% more efficient than the default MessageSerializer
+          message_serializer: ActiveRecord::Encryption::MessagePackMessageSerializer.new
+        }
+      end
   end
 end

data/lib/solid_cache/connections/sharded.rb

@@ -5,10 +5,9 @@ module SolidCache
     class Sharded
       attr_reader :names, :nodes, :consistent_hash
 
-      def initialize(names, nodes)
+      def initialize(names)
         @names = names
-        @nodes = nodes
-        @consistent_hash = MaglevHash.new(@nodes.keys)
+        @consistent_hash = MaglevHash.new(names)
       end
 
       def with_each(&block)
@@ -35,7 +34,7 @@ module SolidCache
 
       private
         def shard_for(key)
-          nodes[consistent_hash.node(key)]
+          consistent_hash.node(key)
         end
     end
   end

data/lib/solid_cache/connections.rb

@@ -7,13 +7,8 @@ module SolidCache
         case options
         when NilClass
           names = SolidCache.configuration.shard_keys
-          nodes = names.to_h { |name| [ name, name ] }
         when Array
           names = options.map(&:to_sym)
-          nodes = names.to_h { |name| [ name, name ] }
-        when Hash
-          names = options.keys.map(&:to_sym)
-          nodes = options.to_h { |names, nodes| [ nodes.to_sym, names.to_sym ] }
         end
 
         if (unknown_shards = names - SolidCache.configuration.shard_keys).any?
@@ -23,7 +18,7 @@ module SolidCache
         if names.size == 1
           Single.new(names.first)
         else
-          Sharded.new(names, nodes)
+          Sharded.new(names)
         end
       else
         Unmanaged.new

data/lib/solid_cache/engine.rb

@@ -18,6 +18,8 @@ module SolidCache
 
       options[:connects_to] = config.solid_cache.connects_to if config.solid_cache.connects_to
       options[:size_estimate_samples] = config.solid_cache.size_estimate_samples if config.solid_cache.size_estimate_samples
+      options[:encrypt] = config.solid_cache.encrypt if config.solid_cache.encrypt
+      options[:encryption_context_properties] = config.solid_cache.encryption_context_properties if config.solid_cache.encryption_context_properties
 
       SolidCache.configuration = SolidCache::Configuration.new(**options)
 
@@ -33,5 +35,13 @@ module SolidCache
     config.after_initialize do
       Rails.cache.setup! if Rails.cache.is_a?(Store)
     end
+
+    config.after_initialize do
+      if SolidCache.configuration.encrypt? && SolidCache::Record.connection.adapter_name == "PostgreSQL"
+        raise \
+          "Cannot enable encryption for Solid Cache: Active Record Encryption does not currently support " \
+          "encrypting binary columns on PostgreSQL"
+      end
+    end
   end
 end

data/lib/solid_cache/store/api.rb

@@ -39,16 +39,27 @@ module SolidCache
           entry_read(key)
         end
 
-        def write_entry(key, entry, raw: false, **options)
+        def write_entry(key, entry, raw: false, unless_exist: false, **options)
           payload = serialize_entry(entry, raw: raw, **options)
-          # No-op for us, but this writes it to the local cache
-          write_serialized_entry(key, payload, raw: raw, **options)
 
-          entry_write(key, payload)
+          if unless_exist
+            written = false
+            entry_lock_and_write(key) do |value|
+              if value.nil? || deserialize_entry(value, **options).expired?
+                written = true
+                payload
+              end
+            end
+          else
+            written = entry_write(key, payload)
+          end
+
+          write_serialized_entry(key, payload, raw: raw, returning: written, **options)
+          written
         end
 
-        def write_serialized_entry(key, payload, raw: false, unless_exist: false, expires_in: nil, race_condition_ttl: nil, **options)
-          true
+        def write_serialized_entry(key, payload, raw: false, unless_exist: false, expires_in: nil, race_condition_ttl: nil, returning: true, **options)
+          returning
         end
 
         def read_serialized_entries(keys)

data/lib/solid_cache/store/connections.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module SolidCache
+  class Store
+    module Connections
+      attr_reader :shard_options
+
+      def initialize(options = {})
+        super(options)
+        if options[:clusters].present?
+          if options[:clusters].size > 1
+            raise ArgumentError, "Multiple clusters are no longer supported"
+          else
+            ActiveSupport.deprecator.warn(":clusters is deprecated, use :shards instead.")
+          end
+          @shard_options = options.fetch(:clusters).first[:shards]
+        elsif options[:cluster].present?
+          ActiveSupport.deprecator.warn(":cluster is deprecated, use :shards instead.")
+          @shard_options = options.fetch(:cluster, {})[:shards]
+        else
+          @shard_options = options.fetch(:shards, nil)
+        end
+
+        if [ Array, NilClass ].none? { |klass| @shard_options.is_a? klass }
+          raise ArgumentError, "`shards` is a `#{@shard_options.class.name}`, it should be Array or nil"
+        end
+      end
+
+      def with_each_connection(async: false, &block)
+        return enum_for(:with_each_connection) unless block_given?
+
+        connections.with_each do
+          execute(async, &block)
+        end
+      end
+
+      def with_connection_for(key, async: false, &block)
+        connections.with_connection_for(key) do
+          execute(async, &block)
+        end
+      end
+
+      def with_connection(name, async: false, &block)
+        connections.with(name) do
+          execute(async, &block)
+        end
+      end
+
+      def group_by_connection(keys)
+        connections.assign(keys)
+      end
+
+      def connection_names
+        connections.names
+      end
+
+      def connections
+        @connections ||= SolidCache::Connections.from_config(@shard_options)
+      end
+
+      private
+        def setup!
+          connections
+        end
+
+        def reading_key(key, failsafe:, failsafe_returning: nil, &block)
+          failsafe(failsafe, returning: failsafe_returning) do
+            with_connection_for(key, &block)
+          end
+        end
+
+        def reading_keys(keys, failsafe:, failsafe_returning: nil)
+          group_by_connection(keys).map do |connection, keys|
+            failsafe(failsafe, returning: failsafe_returning) do
+              with_connection(connection) do
+                yield keys
+              end
+            end
+          end
+        end
+
+
+        def writing_key(key, failsafe:, failsafe_returning: nil, &block)
+          failsafe(failsafe, returning: failsafe_returning) do
+            with_connection_for(key, &block)
+          end
+        end
+
+        def writing_keys(entries, failsafe:, failsafe_returning: nil)
+          group_by_connection(entries).map do |connection, entries|
+            failsafe(failsafe, returning: failsafe_returning) do
+              with_connection(connection) do
+                yield entries
+              end
+            end
+          end
+        end
+
+        def writing_all(failsafe:, failsafe_returning: nil, &block)
+          connection_names.map do |connection|
+            failsafe(failsafe, returning: failsafe_returning) do
+              with_connection(connection, &block)
+            end
+          end.first
+        end
+    end
+  end
+end

data/lib/solid_cache/store/entries.rb

@@ -29,7 +29,9 @@ module SolidCache
 
         def entry_lock_and_write(key, &block)
           writing_key(key, failsafe: :increment) do
-            Entry.lock_and_write(key, &block)
+            Entry.lock_and_write(key) do |value|
+              block.call(value).tap { |result| track_writes(1) if result }
+            end
           end
         end
 
@@ -46,30 +48,30 @@ module SolidCache
         end
 
         def entry_write(key, payload)
-          writing_key(key, failsafe: :write_entry, failsafe_returning: nil) do |cluster|
+          writing_key(key, failsafe: :write_entry, failsafe_returning: nil) do
             Entry.write(key, payload)
-            cluster.track_writes(1)
+            track_writes(1)
             true
           end
         end
 
         def entry_write_multi(entries)
-          writing_keys(entries, failsafe: :write_multi_entries, failsafe_returning: false) do |cluster, entries|
+          writing_keys(entries, failsafe: :write_multi_entries, failsafe_returning: false) do |entries|
             Entry.write_multi(entries)
-            cluster.track_writes(entries.count)
+            track_writes(entries.count)
             true
           end
         end
 
         def entry_delete(key)
           writing_key(key, failsafe: :delete_entry, failsafe_returning: false) do
-            Entry.delete_by_key(key)
+            Entry.delete_by_key(key) > 0
           end
         end
 
         def entry_delete_multi(entries)
           writing_keys(entries, failsafe: :delete_multi_entries, failsafe_returning: 0) do
-            Entry.delete_multi(entries)
+            Entry.delete_by_key(*entries)
           end
         end
     end

data/lib/solid_cache/{cluster → store}/execution.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module SolidCache
-  class Cluster
+  class Store
     module Execution
       def initialize(options = {})
         super(options)
@@ -16,7 +16,7 @@ module SolidCache
           @background << ->() do
             wrap_in_rails_executor do
               connections.with(current_shard) do
-                instrument(&block)
+                setup_instrumentation(&block)
               end
             end
           rescue Exception => exception
@@ -28,7 +28,7 @@ module SolidCache
           if async
             async(&block)
           else
-            instrument(&block)
+            setup_instrumentation(&block)
           end
         end
 
@@ -44,7 +44,7 @@ module SolidCache
           @active_record_instrumentation
         end
 
-        def instrument(&block)
+        def setup_instrumentation(&block)
           if active_record_instrumentation?
             block.call
           else

data/lib/solid_cache/{cluster → store}/expiry.rb

@@ -3,7 +3,7 @@
 require "concurrent/atomic/atomic_fixnum"
 
 module SolidCache
-  class Cluster
+  class Store
     module Expiry
       # For every write that we do, we attempt to delete EXPIRY_MULTIPLIER times as many records.
       # This ensures there is downward pressure on the cache size while there is valid data to delete

data/lib/solid_cache/{cluster → store}/stats.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 module SolidCache
-  class Cluster
+  class Store
     module Stats
       def initialize(options = {})
-        super()
+        super(options)
       end
 
       def stats

data/lib/solid_cache/store.rb

@@ -2,7 +2,7 @@
 
 module SolidCache
   class Store < ActiveSupport::Cache::Store
-    include Api, Clusters, Entries, Failsafe
+    include Api, Connections, Entries, Execution, Expiry, Failsafe, Stats
     prepend ActiveSupport::Cache::Strategy::LocalCache
 
     def initialize(options = {})
@@ -16,9 +16,5 @@ module SolidCache
     def setup!
       super
     end
-
-    def stats
-      primary_cluster.stats
-    end
   end
 end

data/lib/solid_cache/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidCache
-  VERSION = "0.6.0"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solid_cache
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Donal McBreen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-20 00:00:00.000000000 Z
+date: 2024-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,42 +16,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: activejob
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
@@ -106,25 +106,18 @@ files:
 - Rakefile
 - app/jobs/solid_cache/expiry_job.rb
 - app/models/solid_cache/entry.rb
+- app/models/solid_cache/entry/encryption.rb
 - app/models/solid_cache/entry/expiration.rb
 - app/models/solid_cache/entry/size.rb
 - app/models/solid_cache/entry/size/estimate.rb
 - app/models/solid_cache/entry/size/moving_average_estimate.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
+- db/migrate/20240820123641_create_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
 - lib/generators/solid_cache/install/templates/config/solid_cache.yml.tt
 - lib/solid_cache.rb
-- lib/solid_cache/cluster.rb
-- lib/solid_cache/cluster/connections.rb
-- lib/solid_cache/cluster/execution.rb
-- lib/solid_cache/cluster/expiry.rb
-- lib/solid_cache/cluster/stats.rb
 - lib/solid_cache/configuration.rb
 - lib/solid_cache/connections.rb
 - lib/solid_cache/connections/sharded.rb
@@ -134,9 +127,12 @@ files:
 - lib/solid_cache/maglev_hash.rb
 - lib/solid_cache/store.rb
 - lib/solid_cache/store/api.rb
-- lib/solid_cache/store/clusters.rb
+- lib/solid_cache/store/connections.rb
 - lib/solid_cache/store/entries.rb
+- lib/solid_cache/store/execution.rb
+- lib/solid_cache/store/expiry.rb
 - lib/solid_cache/store/failsafe.rb
+- lib/solid_cache/store/stats.rb
 - lib/solid_cache/version.rb
 - lib/tasks/solid_cache_tasks.rake
 homepage: http://github.com/rails/solid_cache
@@ -162,7 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: A database backed ActiveSupport::Cache::Store

data/db/migrate/20230724121448_create_solid_cache_entries.rb

@@ -1,11 +0,0 @@
-class CreateSolidCacheEntries < ActiveRecord::Migration[7.0]
-  def change
-    create_table :solid_cache_entries do |t|
-      t.binary   :key,        null: false,   limit: 1024
-      t.binary   :value,      null: false,   limit: 512.megabytes
-      t.datetime :created_at, null: false
-
-      t.index    :key,        unique: true
-    end
-  end
-end

data/db/migrate/20240108155507_add_key_hash_and_byte_size_to_solid_cache_entries.rb

@@ -1,8 +0,0 @@
-class AddKeyHashAndByteSizeToSolidCacheEntries < ActiveRecord::Migration[7.0]
-  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

@@ -1,11 +0,0 @@
-class AddKeyHashAndByteSizeIndexesAndNullConstraintsToSolidCacheEntries < ActiveRecord::Migration[7.0]
-  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

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

data/lib/solid_cache/cluster/connections.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module SolidCache
-  class Cluster
-    module Connections
-      attr_reader :shard_options
-
-      def initialize(options = {})
-        super(options)
-        @shard_options = options.fetch(:shards, nil)
-
-        if [ Hash, Array, NilClass ].none? { |klass| @shard_options.is_a? klass }
-          raise ArgumentError, "`shards` is a `#{@shard_options.class.name}`, it should be one of Array, Hash or nil"
-        end
-      end
-
-      def with_each_connection(async: false, &block)
-        return enum_for(:with_each_connection) unless block_given?
-
-        connections.with_each do
-          execute(async, &block)
-        end
-      end
-
-      def with_connection_for(key, async: false, &block)
-        connections.with_connection_for(key) do
-          execute(async, &block)
-        end
-      end
-
-      def with_connection(name, async: false, &block)
-        connections.with(name) do
-          execute(async, &block)
-        end
-      end
-
-      def group_by_connection(keys)
-        connections.assign(keys)
-      end
-
-      def connection_names
-        connections.names
-      end
-
-      def connections
-        @connections ||= SolidCache::Connections.from_config(@shard_options)
-      end
-
-      private
-        def setup!
-          connections
-        end
-    end
-  end
-end

data/lib/solid_cache/cluster.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module SolidCache
-  class Cluster
-    include Connections, Execution, Expiry, Stats
-
-    attr_reader :error_handler
-
-    def initialize(options = {})
-      @error_handler = options[:error_handler]
-      super(options)
-    end
-
-    def setup!
-      super
-    end
-  end
-end