inherit the isolation level from Rails by default

Author: jamis

lib/config/locales/en.yml

@@ -716,12 +716,13 @@ en:
           message: "The isolation level '%{level}' is not supported."
           summary: >
             You requested an isolation level of '%{level}', which is not
-            supported. Only `:thread` and `:fiber` isolation levels are
-            currently supported; note that the `:fiber` level is only
-            supported on Ruby versions 3.2 and higher.
+            supported. Only `:rails`, `:thread` and `:fiber` isolation
+            levels are currently supported; note that the `:fiber` level is
+            only supported on Ruby versions 3.2 and higher.
           resolution: >
             Use `:thread` as the isolation level. If you are using Ruby 3.2
-            or higher, you may also use `:fiber`.
+            or higher, you may also use `:fiber`. If using Rails 7+, you
+            may also use `:rails` to inherit the isolation level from Rails.
         validations:
           message: "Validation of %{document} failed."
           summary: "The following errors were found: %{errors}"

lib/mongoid/config.rb

@@ -110,13 +110,16 @@ module Config
     # to `:global_thread_pool`.
     option :global_executor_concurrency, default: nil
 
+    VALID_ISOLATION_LEVELS = %i[ rails thread fiber ].freeze
+
     # Defines the isolation level that Mongoid uses to store its internal
     # state.
     #
-    # This option may be set to either `:thread` (the default) or `:fiber`.
-    #
-    # If set to `:thread`, Mongoid will use thread-local storage to manage
-    # its internal state.
+    # Valid values are:
+    # - `:rails` - Uses the isolation level that Rails currently has
+    #  configured. (This is the default.)
+    # - `:thread` - Uses thread-local storage.
+    # - `:fiber` - Uses fiber-local storage (only supported in Ruby 3.2+).
     #
     # If set to `:fiber`, Mongoid will use fiber-local storage instead. This
     # may be necessary if you are using libraries like Falcon, which use
@@ -125,8 +128,46 @@ module Config
     # Note that the `:fiber` isolation level is only supported in Ruby 3.2
     # and later, due to semantic differences in how fiber storage is handled
     # in earlier Ruby versions.
-    option :isolation_level, default: :thread, on_change: -> (level) do
-      if %i[ thread fiber ].exclude?(level)
+    option :isolation_level, default: :rails, on_change: -> (level) do
+      validate_isolation_level!(level)
+    end
+
+    # Returns the (potentially-dereferenced) isolation level that Mongoid
+    # will use to store its internal state. If `isolation_level` is set to
+    # `:rails`, this will return the isolation level that Rails is current
+    # configured to use (`ActiveSupport::IsolatedExecutionState.isolation_level`).
+    #
+    # If using an older version of Rails that does not support
+    # ActiveSupport::IsolatedExecutionState, this will return `:thread`
+    # instead.
+    #
+    # @api private
+    def real_isolation_level
+      return isolation_level unless isolation_level == :rails
+
+      if defined?(ActiveSupport::IsolatedExecutionState)
+        ActiveSupport::IsolatedExecutionState.isolation_level.tap do |level|
+          # We can't guarantee that Rails will always support the same
+          # isolation levels as Mongoid, so we check here to make sure
+          # it's something we can work with.
+          validate_isolation_level!(level)
+        end
+      else
+        # The default, if Rails does not support IsolatedExecutionState,
+        :thread
+      end
+    end
+
+    # Checks to see if the provided isolation level is something that Mongoid
+    # supports. Raises Errors::UnsupportedIsolationLevel if it is not.
+    #
+    # This will also raise an error if the isolation level is set to `:fiber`
+    # and the Ruby version is less than 3.2, since fiber-local storage
+    # is not supported in earlier Ruby versions.
+    #
+    # @api private
+    def validate_isolation_level!(level)
+      unless VALID_ISOLATION_LEVELS.include?(level)
         raise Errors::UnsupportedIsolationLevel.new(level)
       end
 

lib/mongoid/threaded.rb

@@ -42,16 +42,16 @@ module Threaded
     # This is useful for making sure the state is clean when starting a new
     # thread or fiber.
     #
-    # The value of Mongoid::Config.isolation_level is used to determine
+    # The value of Mongoid::Config.real_isolation_level is used to determine
     # whether to reset the storage for the current thread or fiber.
     def reset!
-      case Config.isolation_level
+      case Config.real_isolation_level
       when :thread
         Thread.current.thread_variable_set(STORAGE_KEY, nil)
       when :fiber
         Fiber[STORAGE_KEY] = nil
       else
-        raise "Unknown isolation level: #{Config.isolation_level.inspect}"
+        raise "Unknown isolation level: #{Config.real_isolation_level.inspect}"
       end
     end
 
@@ -517,7 +517,7 @@ def unset_current_scope(klass)
 
     # Returns the current thread- or fiber-local storage as a Hash.
     def storage
-      case Config.isolation_level
+      case Config.real_isolation_level
       when :thread
         storage_hash = Thread.current.thread_variable_get(STORAGE_KEY)
 
@@ -532,7 +532,7 @@ def storage
         Fiber[STORAGE_KEY] ||= {}
 
       else
-        raise "Unknown isolation level: #{Config.isolation_level.inspect}"
+        raise "Unknown isolation level: #{Config.real_isolation_level.inspect}"
       end
     end
   end

spec/integration/isolation_state_spec.rb

@@ -55,6 +55,65 @@ def fiber_operation(value)
     end
   end
 
+  context 'when set to :rails' do
+    config_override :isolation_level, :rails
+    
+    def self.with_rails_isolation_level(level)
+      puts "Rails version: #{ActiveSupport.version}"
+      around do |example|
+        saved, ActiveSupport::IsolatedExecutionState.isolation_level =
+          ActiveSupport::IsolatedExecutionState.isolation_level, level
+        example.run
+      ensure
+        ActiveSupport::IsolatedExecutionState.isolation_level = saved
+      end
+    end
+
+    context 'when using Rails < 7' do
+      max_rails_version '6.99'
+
+      it 'returns :thread' do
+        expect(Mongoid::Config.isolation_level).to eq(:rails)
+        expect(Mongoid::Config.real_isolation_level).to eq(:thread)
+      end
+    end
+
+    context 'when using Rails >= 7' do
+      min_rails_version '7.0'
+
+      context 'when IsolatedExecutionState.isolation_level is set to :thread' do
+        with_rails_isolation_level :thread
+
+        it 'returns :thread' do
+          expect(Mongoid::Config.isolation_level).to eq(:rails)
+          expect(Mongoid::Config.real_isolation_level).to eq(:thread)
+        end
+      end
+
+      context 'when IsolatedExecutionState.isolation_level is set to :fiber' do
+        with_rails_isolation_level :fiber
+
+        context 'when Ruby version is >= 3.2' do
+          ruby_version_gte '3.2'
+
+          it 'returns :fiber' do
+            expect(Mongoid::Config.isolation_level).to eq(:rails)
+            expect(Mongoid::Config.real_isolation_level).to eq(:fiber)
+          end
+        end
+
+        context 'when Ruby version is < 3.2' do
+          ruby_version_lt '3.2'
+
+          it 'raises an error' do
+            expect(Mongoid::Config.isolation_level).to eq(:rails)
+            expect { Mongoid::Config.real_isolation_level }.to raise_error(Mongoid::Errors::UnsupportedIsolationLevel)
+          end
+        end
+      end
+    end
+  end
+
   context 'when set to :thread' do
     config_override :isolation_level, :thread