solid_cache_mongoid 0.1.0

data/lib/solid_cache_mongoid/store/connections.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module SolidCacheMongoid
+  class Store
+    module Connections
+      def initialize(options = {})
+        super(options)
+      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 connections
+        @connections ||= SolidCacheMongoid::Connections.from_config
+      end
+
+      private
+        def setup!
+          connections
+        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 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, grouped_keys|
+            failsafe(failsafe, returning: failsafe_returning) do
+              with_connection(connection) do
+                yield grouped_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, grouped_entries|
+            failsafe(failsafe, returning: failsafe_returning) do
+              with_connection(connection) do
+                yield grouped_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_mongoid/store/entries.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module SolidCacheMongoid
+  class Store
+    module Entries
+      attr_reader :clear_with
+
+      def initialize(options = {})
+        super(options)
+
+        # Truncating in test mode breaks transactional tests in MySQL (not in Postgres though)
+        @clear_with = options.fetch(:clear_with) { Rails.env.test? ? :delete : :truncate }&.to_sym
+
+        unless [ :truncate, :delete ].include?(clear_with)
+          raise ArgumentError, "`clear_with` must be either ``:truncate`` or ``:delete`"
+        end
+      end
+
+      private
+        def entry_clear
+          writing_all(failsafe: :clear, failsafe_returning: nil) do
+            if clear_with == :truncate
+              Entry.clear_truncate
+            else
+              Entry.clear_delete
+            end
+          end
+        end
+
+        def entry_lock_and_write(key, &block)
+          writing_key(key, failsafe: :increment) do
+            Entry.lock_and_write(key) do |value|
+              block.call(value).tap { |result| track_writes(1) if result }
+            end
+          end
+        end
+
+        def entry_read(key)
+          reading_key(key, failsafe: :read_entry) do
+            Entry.read(key)
+          end
+        end
+
+        def entry_read_multi(keys)
+          reading_keys(keys, failsafe: :read_multi_mget, failsafe_returning: {}) do |keys|
+            Entry.read_multi(keys)
+          end
+        end
+
+        def entry_write(key, payload)
+          writing_key(key, failsafe: :write_entry, failsafe_returning: nil) do
+            Entry.write(key, payload)
+            track_writes(1)
+            true
+          end
+        end
+
+        def entry_write_multi(entries)
+          writing_keys(entries, failsafe: :write_multi_entries, failsafe_returning: false) do |entries|
+            Entry.write_multi(entries)
+            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) > 0
+          end
+        end
+
+        def entry_delete_multi(entries)
+          writing_keys(entries, failsafe: :delete_multi_entries, failsafe_returning: 0) do
+            Entry.delete_by_key(*entries)
+          end
+        end
+    end
+  end
+end

data/lib/solid_cache_mongoid/store/execution.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SolidCacheMongoid
+  class Store
+    module Execution
+      def initialize(options = {})
+        super(options)
+        @background = Concurrent::FixedThreadPool.new(1, max_queue: 100, fallback_policy: :discard)
+        @active_record_instrumentation = options.fetch(:active_record_instrumentation, true)
+      end
+
+      private
+        def async(&block)
+          @background << ->() do
+            wrap_in_rails_executor do
+              setup_instrumentation(&block)
+            end
+          rescue Exception => exception
+            error_handler&.call(method: :async, exception: exception, returning: nil)
+          end
+        end
+
+        def execute(async, &block)
+          if async
+            async(&block)
+          else
+            setup_instrumentation(&block)
+          end
+        end
+
+        def wrap_in_rails_executor(&block)
+          if SolidCacheMongoid.executor
+            SolidCacheMongoid.executor.wrap(&block)
+          else
+            block.call
+          end
+        end
+
+        def active_record_instrumentation?
+          @active_record_instrumentation
+        end
+
+        def setup_instrumentation(&block)
+          if active_record_instrumentation?
+            block.call
+          else
+            Entry.disable_instrumentation(&block)
+          end
+        end
+    end
+  end
+end

data/lib/solid_cache_mongoid/store/expiry.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SolidCacheMongoid
+  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
+      EXPIRY_MULTIPLIER = 2
+
+      attr_reader :expiry_batch_size, :expiry_method, :expiry_queue, :expires_per_write, :max_age, :max_entries, :max_size
+
+      def initialize(options = {})
+        super(options)
+        @expiry_batch_size = options.fetch(:expiry_batch_size, 100)
+        @expiry_method = options.fetch(:expiry_method, :thread)
+        @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)
+        @max_size = options.fetch(:max_size, nil)
+
+        raise ArgumentError, "Expiry method must be one of `:thread` or `:job`" unless [ :thread, :job ].include?(expiry_method)
+      end
+
+      def track_writes(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
+          max_options = { max_age: max_age, max_entries: max_entries, max_size: max_size }
+          if expiry_method == :job
+            ExpiryJob
+              .set(queue: expiry_queue)
+              .perform_later(expiry_batch_size, **max_options)
+          else
+            async { Entry.expire(expiry_batch_size, **max_options) }
+          end
+        end
+    end
+  end
+end

data/lib/solid_cache_mongoid/store/failsafe.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module SolidCacheMongoid
+  class Store
+    module Failsafe
+      TRANSIENT_MONGOID_ERRORS = [
+        ::Mongo::Error::SocketError,
+        ::Mongo::Error::SocketTimeoutError,
+        ::Mongo::Error::NoServerAvailable,
+        ::Mongo::Error::OperationFailure,
+        ::Mongo::Error::TimeoutError,
+        ::Mongo::Error::ServerTimeoutError
+      ]
+
+      DEFAULT_ERROR_HANDLER = ->(method:, returning:, exception:) do
+        if Store.logger
+          Store.logger.error { "SolidCacheStore: #{method} failed, returned #{returning.inspect}: #{exception.class}: #{exception.message}" }
+        end
+      end
+
+      def initialize(options = {})
+        super(options)
+
+        @error_handler = options.fetch(:error_handler, DEFAULT_ERROR_HANDLER)
+      end
+
+      private
+        attr_reader :error_handler
+
+        def failsafe(method, returning: nil)
+          yield
+        rescue *TRANSIENT_MONGOID_ERRORS => error
+          ActiveSupport.error_reporter&.report(error, handled: true, severity: :warning)
+          error_handler&.call(method: method, exception: error, returning: returning)
+          returning
+        end
+    end
+  end
+end

data/lib/solid_cache_mongoid/store/stats.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SolidCacheMongoid
+  class Store
+    module Stats
+      def initialize(options = {})
+        super(options)
+      end
+
+      def stats
+        {
+          connections: 1,
+          connection_stats: connection_stats
+        }
+      end
+
+      private
+        def connection_stats
+          oldest_created_at = Entry.order_by([:id, :asc]).pick(:created_at)
+
+          {
+            max_age: max_age,
+            oldest_age: oldest_created_at ? Time.now - oldest_created_at : nil,
+            max_entries: max_entries,
+            entries: Entry.id_range
+          }
+        end
+    end
+  end
+end

data/lib/solid_cache_mongoid/store.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SolidCacheMongoid
+  class Store < ActiveSupport::Cache::Store
+    include Api, Connections, Entries, Execution, Expiry, Failsafe, Stats
+    prepend ActiveSupport::Cache::Strategy::LocalCache
+
+    def initialize(options = {})
+      super(SolidCacheMongoid.configuration.store_options.merge(options))
+    end
+
+    def self.supports_cache_versioning?
+      true
+    end
+
+    def setup!
+      super
+    end
+  end
+end

data/lib/solid_cache_mongoid/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SolidCacheMongoid
+  VERSION = "0.1.0"
+end

data/lib/solid_cache_mongoid.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "solid_cache_mongoid/engine"
+
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/active_support")
+loader.ignore("#{__dir__}/generators")
+loader.setup
+
+module SolidCacheMongoid
+  mattr_accessor :executor
+  mattr_accessor :configuration, default: Configuration.new
+end
+
+loader.eager_load

data/lib/tasks/solid_cache_tasks.rake

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+desc "Copy over the migration, and set cache"
+namespace :solid_cache_mongoid do
+  task :install do
+    Rails::Command.invoke :generate, [ "solid_cache_mongoid:install" ]
+  end
+end
+
+
+require "solid_cache_mongoid/version"
+
+desc "Pushing solid_cache_mongoid-#{SolidCacheMongoid::VERSION}.gem to rubygems"
+task :release do
+  package = "pkg/solid_cache_mongoid-#{SolidCacheMongoid::VERSION}.gem"
+  ::FURY_CMD = "gem push #{package}"
+  ::ERROR_PACKAGE_NOT_FOUND = "Error: gem #{package} is not found"
+
+  if File.exist? package
+    system(FURY_CMD, exception: true)
+  else
+    STDERR.puts ERROR_PACKAGE_NOT_FOUND
+    exit 1
+  end
+end

metadata

@@ -0,0 +1,201 @@
+--- !ruby/object:Gem::Specification
+name: solid_cache_mongoid
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Donal McBreen
+- Duvan Hernandez
+bindir: bin
+cert_chain: []
+date: 2025-12-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: mongoid-locker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+- !ruby/object:Gem::Dependency
+  name: debug
+  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: mocha
+  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: msgpack
+  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'
+description: A database backed ActiveSupport::Cache::Store
+email:
+- donal@37signals.com
+- duvanherfi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/jobs/solid_cache_mongoid/expiry_job.rb
+- app/models/solid_cache_mongoid/entry.rb
+- app/models/solid_cache_mongoid/entry/expiration.rb
+- app/models/solid_cache_mongoid/entry/size.rb
+- app/models/solid_cache_mongoid/entry/size/estimate.rb
+- app/models/solid_cache_mongoid/entry/size/moving_average_estimate.rb
+- app/models/solid_cache_mongoid/record.rb
+- lib/active_support/cache/solid_cache_mongoid_store.rb
+- lib/generators/solid_cache/install/USAGE
+- lib/generators/solid_cache/install/install_generator.rb
+- lib/generators/solid_cache/install/templates/config/cache.yml.tt
+- lib/generators/solid_cache/install/templates/db/cache_schema.rb
+- lib/generators/solid_cache/install/templates/db/cache_structure.mysql.sql
+- lib/generators/solid_cache/install/templates/db/cache_structure.postgresql.sql
+- lib/generators/solid_cache/install/templates/db/cache_structure.sqlite3.sql
+- lib/solid_cache_mongoid.rb
+- lib/solid_cache_mongoid/configuration.rb
+- lib/solid_cache_mongoid/connections.rb
+- lib/solid_cache_mongoid/connections/unmanaged.rb
+- lib/solid_cache_mongoid/engine.rb
+- lib/solid_cache_mongoid/store.rb
+- lib/solid_cache_mongoid/store/api.rb
+- lib/solid_cache_mongoid/store/connections.rb
+- lib/solid_cache_mongoid/store/entries.rb
+- lib/solid_cache_mongoid/store/execution.rb
+- lib/solid_cache_mongoid/store/expiry.rb
+- lib/solid_cache_mongoid/store/failsafe.rb
+- lib/solid_cache_mongoid/store/stats.rb
+- lib/solid_cache_mongoid/version.rb
+- lib/tasks/solid_cache_tasks.rake
+homepage: http://github.com/duvanherfi/solid_cache_mongoid
+licenses:
+- MIT
+metadata:
+  homepage_uri: http://github.com/duvanherfi/solid_cache_mongoid
+  source_code_uri: http://github.com/duvanherfi/solid_cache_mongoid
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: A database backed ActiveSupport::Cache::Store
+test_files: []