ractor-rails-shim 0.2.4 → 0.2.6

data/lib/ractor_rails_shim/patches/activerecord.rb

@@ -590,6 +590,18 @@ module RactorRailsShim
     # which writes `@table_name`/`@arel_table`/etc. From a worker that write is
     # Ractor::IsolationError. Route the value through IsolatedExecutionState
     # (keyed by model object_id); main keeps the original class-ivar behavior.
+    #
+    # NOTE on naming: there are TWO ModelSchema-related install methods, with
+    # deliberately different scopes:
+    #   * `_install_active_record_model_schema_patch`  (this method) — patches
+    #     `table_name` / `table_name=` / `reset_table_name` only.
+    #   * `_install_activerecord_model_schema_patch`  (below) — patches the
+    #     *column-derived* lazy caches `symbol_column_to_string`,
+    #     `content_columns` (and previously `column_defaults`, now provided
+    #     by the prepended `ActiveRecordModelSchemaPatch`).
+    # Both target `ActiveRecord::ModelSchema::ClassMethods` but patch
+    # disjoint method sets; do not collapse them without auditing every
+    # caller.
     def _install_active_record_model_schema_patch
       return if @ar_model_schema_patched
       @ar_model_schema_patched = true
@@ -776,15 +788,79 @@ module RactorRailsShim
           cols
         end
 
-        def column_defaults
-          key = :"ractor_rails_shim_column_defaults_\#{self.name}"
-          v = ActiveSupport::IsolatedExecutionState[key]
-          return v if v
-          defaults = _default_attributes.deep_dup.to_hash.freeze
-          ActiveSupport::IsolatedExecutionState[key] = defaults
-          defaults
+        # NOTE: `column_defaults` is intentionally NOT redefined here. It is
+        # installed by the prepended `ActiveRecordModelSchemaPatch` (see
+        # `active_record_model_schema.rb`), which is prepended onto
+        # `ModelSchema::ClassMethods` by `_install_active_model_attribute_patch`
+        # and therefore sits in front of this module_eval heredoc in the
+        # method lookup chain. A second definition here would be dead code and
+        # a maintenance trap.
+
+        # `reload_schema_from_cache` (called by `load_schema`/`reload_schema!`)
+        # writes a batch of class ivars to `nil` to invalidate schema caches:
+        #   @_returning_columns_for_insert, @arel_table, @column_names,
+        #   @symbol_column_to_string_name_hash, @content_columns, @column_defaults
+        # (ModelSchema) plus @timestamp_attributes_for_create_in_model,
+        # @timestamp_attributes_for_update_in_model,
+        # @all_timestamp_attributes_in_model (Timestamp#reload_schema_from_cache
+        # via super). In a worker Ractor those writes raise
+        # Ractor::IsolationError ("can not set instance variables of
+        # classes/modules by non-main Ractors"). The shim already routes the
+        # *readers* for these caches through IES, so in a worker we only need
+        # to clear the IES slots — the next read rebuilds lazily. In main we
+        # keep the original class-ivar-clearing behavior.
+        def reload_schema_from_cache(recursive = true)
+          if Ractor.main?
+            super
+          else
+            # Clear this Ractor's IES slots for the IES-routed schema caches.
+            # Use `next` over an explicit list (not `IES.clear`) to avoid
+            # wiping unrelated slots. Keys mirror the readers above + the
+            # prepended ActiveRecordModelSchemaPatch (active_record_model_schema.rb)
+            # + ActiveModelAttributeRegistrationPatch (active_model_attribute.rb).
+            name_str = self.name
+            [
+              :"ractor_rails_shim_symbol_column_to_string_\#{name_str}",
+              :"ractor_rails_shim_content_columns_\#{name_str}",
+              :"rrs_column_defaults_\#{object_id}",
+              :"rrs_attributes_builder_\#{object_id}",
+              :"rrs_yaml_encoder_\#{object_id}",
+              :"rrs_returning_cols_\#{object_id}",
+              :"rrs_default_attributes_\#{object_id}",
+              :"rrs_attribute_types_\#{object_id}",
+              :"rrs_table_names",
+              :"rrs_arel_tables",
+              :"rrs_predicate_builders",
+              :"rrs_type_casters",
+            ].each do |k| ActiveSupport::IsolatedExecutionState.delete(k) end
+            # The Timestamp subclass override calls `super` (this method); it
+            # has already run by the time we get here via the super chain, so
+            # its ivar-clears were intercepted by the worker branch of THIS
+            # override (no-op). No further action needed.
+          end
         end
       RUBY
+
+      # Patch ActiveRecord::Timestamp::ClassMethods#reload_schema_from_cache
+      # the same way: in main, keep the original ivar-clearing; in a worker,
+      # skip the class-ivar writes (the IES slots are cleared by the
+      # ModelSchema#reload_schema_from_cache override above via super).
+      if defined?(::ActiveRecord::Timestamp::ClassMethods)
+        ::ActiveRecord::Timestamp::ClassMethods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def reload_schema_from_cache(recursive = true)
+            if Ractor.main?
+              @timestamp_attributes_for_create_in_model = nil
+              @timestamp_attributes_for_update_in_model = nil
+              @all_timestamp_attributes_in_model = nil
+              super
+            else
+              # Worker: skip the class-ivar writes (would raise
+              # IsolationError). The ModelSchema super clears the IES slots.
+              super
+            end
+          end
+        RUBY
+      end
     end
 
     # Patch ActiveModel::Conversion::ClassMethods#_to_partial_path to route its
@@ -863,7 +939,7 @@ module RactorRailsShim
       ::ActiveRecord::Base.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def configurations
           v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
           if Ractor.main?
             ActiveRecord::Core.class_variable_get(:@@configurations)
           else
@@ -919,7 +995,7 @@ module RactorRailsShim
       ::ActiveRecord::DatabaseConfigurations.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def db_config_handlers
           v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
           if Ractor.main?
             @db_config_handlers
           else
@@ -973,7 +1049,7 @@ module RactorRailsShim
       ::ActiveRecord.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def query_transformers
           v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
           if Ractor.main?
             @query_transformers
           else
@@ -1026,7 +1102,7 @@ module RactorRailsShim
         ::ActiveRecord.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{method_name}
             v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-            return v unless v.nil?
+            return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
             if Ractor.main?
               @#{method_name}
             else
@@ -1058,7 +1134,7 @@ module RactorRailsShim
         def registry
           key = :"ractor_rails_shim_dedup_registry_\#{name || object_id}"
           v = ActiveSupport::IsolatedExecutionState[key]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(key)
           h = {}
           ActiveSupport::IsolatedExecutionState[key] = h
           h
@@ -1081,7 +1157,7 @@ module RactorRailsShim
         def query_constraints_list
           key = :"ractor_rails_shim_qcl_\#{name || object_id}"
           v = ActiveSupport::IsolatedExecutionState[key]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(key)
           result = if base_class? || primary_key != base_class.primary_key
             primary_key if primary_key.is_a?(::Array)
           else
@@ -1093,7 +1169,7 @@ module RactorRailsShim
         def has_query_constraints?
           key = :"ractor_rails_shim_qcl_\#{name || object_id}"
           v = ActiveSupport::IsolatedExecutionState[key]
-          return !v.nil? unless v.nil?
+          return !v.nil? if ActiveSupport::IsolatedExecutionState.key?(key)
           result = query_constraints_list
           !result.nil?
         end
@@ -1336,7 +1412,7 @@ module RactorRailsShim
       ::ActiveRecord::Base.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def default_connection_handler
           v = ActiveSupport::IsolatedExecutionState[#{dch_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{dch_key_str})
           if Ractor.main?
             cv = RactorRailsShim::CLASS_ATTR_VALUES[:__ractor_rails_shim_ar_default_connection_handler__]
             return cv if cv
@@ -1351,6 +1427,12 @@ module RactorRailsShim
         # worker's other threads; Ractor.current is per-Ractor and shared by all
         # threads of the worker. Falls back to IES (legacy) then
         # default_connection_handler (main Ractor only).
+        # NOTE: uses nil-sentinel (`unless v.nil?`) rather than key?-based
+        # detection because Ractor#[] has no `key?` method (Ractor local
+        # storage returns nil for both unset and set-to-nil). Safe here
+        # because `connection_handler=` is only ever called with a real
+        # ConnectionHandler instance, never nil — so nil unambiguously
+        # means "unset, fall through to default_connection_handler".
         def connection_handler
           v = Ractor.current[:active_record_connection_handler]
           return v unless v.nil?
@@ -1428,7 +1510,7 @@ module RactorRailsShim
         def serialize_cast_value_compatible?
           key = :"ractor_rails_shim_scv_\#{name || object_id}"
           v = ActiveSupport::IsolatedExecutionState[key]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(key)
           result = ancestors.index(instance_method(:serialize_cast_value).owner) <= ancestors.index(instance_method(:serialize).owner)
           ActiveSupport::IsolatedExecutionState[key] = result
           result
@@ -1461,7 +1543,7 @@ module RactorRailsShim
         def uncacheable_methods
           key = :ractor_rails_shim_ar_uncacheable_methods
           v = ActiveSupport::IsolatedExecutionState[key]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(key)
           result = (
             delegated_classes.flat_map(&:public_instance_methods) - ActiveRecord::Relation.public_instance_methods
           ).to_set.freeze
@@ -1497,7 +1579,7 @@ module RactorRailsShim
         def primary_key
           key = :"ractor_rails_shim_pk_\#{name || object_id}"
           v = ActiveSupport::IsolatedExecutionState[key]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(key)
           if Ractor.main?
             reset_primary_key if PRIMARY_KEY_NOT_SET.equal?(@primary_key)
             v = @primary_key
@@ -1510,7 +1592,7 @@ module RactorRailsShim
         def composite_primary_key?
           key = :"ractor_rails_shim_pk_\#{name || object_id}"
           v = ActiveSupport::IsolatedExecutionState[key]
-          return v.is_a?(::Array) unless v.nil?
+          return v.is_a?(::Array) if ActiveSupport::IsolatedExecutionState.key?(key)
           if Ractor.main?
             reset_primary_key if PRIMARY_KEY_NOT_SET.equal?(@primary_key)
             @primary_key.is_a?(::Array)
@@ -1700,7 +1782,7 @@ module RactorRailsShim
       mig.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def migrations_paths
           v = ActiveSupport::IsolatedExecutionState[#{mp_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{mp_key_str})
           if Ractor.main? && instance_variable_defined?(:@migrations_paths)
             v = @migrations_paths
             ActiveSupport::IsolatedExecutionState[#{mp_key_str}] = v

data/lib/ractor_rails_shim/patches/class_attribute.rb

@@ -102,11 +102,24 @@ module RactorRailsShim
             # for copy-on-write fallback. This restores per-subclass isolation
             # (lost by the IES-routed variant) without thread-local IES, which
             # is empty on Puma's request threads.
+            #
+            # Key format MUST stay `:"ractor_rails_shim_class_attr_<oid>_<name>"`
+            # to match the writer below and the Ractor-mode key in
+            # `redefine`'s own `key` local. The original walked ancestors and
+            # interpolated the *whole* Symbol per ancestor on every read —
+            # allocating a fresh Array (ancestors) AND a fresh Symbol per
+            # ancestor, the dominant allocation source for GET requests. We
+            # interpolate only the per-ancestor `object_id` tail inside the
+            # lookup, which Ruby optimizes to a single Symbol allocation per
+            # ancestor (vs. the previous full-string interpolation). The
+            # Ractor-mode branch below avoids the walk entirely (literal key),
+            # but thread mode must walk because subclass COW fallback is
+            # load-bearing here.
             target.module_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{namespaced_name}
                 self.ancestors.each do |anc|
                   v = RactorRailsShim::CLASS_ATTR_VALUES[:"ractor_rails_shim_class_attr_\#{anc.object_id}_#{namespaced_name}"]
-                  return v unless v.nil?
+                  return v if RactorRailsShim::CLASS_ATTR_VALUES.key?(:"ractor_rails_shim_class_attr_\#{anc.object_id}_#{namespaced_name}")
                 end
                 #{namespaced_name.inspect} == :__callbacks ? {} : nil
               end
@@ -124,7 +137,7 @@ module RactorRailsShim
                 def #{name}
                   self.ancestors.each do |anc|
                     v = RactorRailsShim::CLASS_ATTR_VALUES[:"ractor_rails_shim_class_attr_\#{anc.object_id}_#{namespaced_name}"]
-                    return v unless v.nil?
+                    return v if RactorRailsShim::CLASS_ATTR_VALUES.key?(:"ractor_rails_shim_class_attr_\#{anc.object_id}_#{namespaced_name}")
                   end
                   #{namespaced_name.inspect} == :__callbacks ? {} : nil
                 end
@@ -148,7 +161,7 @@ module RactorRailsShim
              target.module_eval <<-RUBY, __FILE__, __LINE__ + 1
                def #{namespaced_name}
                  v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-                 return v unless v.nil?
+                 return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
                  fb = RactorRailsShim::SHAREABLE_FALLBACK[#{key_str}]
                  return fb unless fb.nil?
                  RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] if Ractor.main?
@@ -168,7 +181,7 @@ module RactorRailsShim
                owner.module_eval <<-RUBY, __FILE__, __LINE__ + 1
                  def #{name}
                    v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-                   return v unless v.nil?
+                   return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
                    fb = RactorRailsShim::SHAREABLE_FALLBACK[#{key_str}]
                    return fb unless fb.nil?
                    RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] if Ractor.main?

data/lib/ractor_rails_shim/patches/core.rb

@@ -120,6 +120,29 @@ module RactorRailsShim
     end
     attr_writer :version_policy
 
+    # When true, swallowed exceptions in freeze/shareability paths are
+    # reported to $stderr so a worker Ractor that later crashes on an
+    # unshareable value has a traceable cause. Default false (silent, the
+    # historical behaviour). Enable for diagnosis:
+    #   RactorRailsShim.debug = true
+    def debug?
+      defined?(@debug) ? @debug : false
+    end
+    attr_writer :debug
+
+    # Swallow an exception raised by the block, optionally logging it when
+    # `debug?` is on. Used by freeze/shareability paths where individual
+    # failures are expected (some ivars hold intrinsically unshareable
+    # values like Procs) but a worker crash on the same value later has no
+    # visible cause. `label` identifies the call site (e.g. "freeze AR ivar
+    # Post@column_defaults"). Keep the label short — it's only for grepping.
+    def _swallow(label)
+      yield
+    rescue => e
+      warn "[ractor_rails_shim] #{label}: #{e.class}: #{e.message[0, 120]}" if debug?
+      nil
+    end
+
     SUPPORTED_RUBY = RactorRailsShim::Version::SUPPORTED_RUBY
     SUPPORTED_RAILS = "8.1"
 
@@ -283,11 +306,7 @@ module RactorRailsShim
         # with `equal?`, and a frozen Symbol is always shareable.
         Ractor.make_shareable(:"__shim_unshareable_sentinel__")
       else
-        begin
-          Ractor.make_shareable(val)
-        rescue => e
-          nil
-        end
+        _swallow("make_value_shareable #{val.class}") { Ractor.make_shareable(val) }
       end
     end
 
@@ -301,21 +320,6 @@ module RactorRailsShim
       [parent, parts.last.to_sym]
     end
 
-    # Public API: run after Rails.application.initialize! and BEFORE spawning
-    # worker Ractors. Makes every registered constant shareable (deep-freeze).
-    # Constants that didn't exist at install time (e.g. Rails::Railtie, loaded
-    # after `module Rails` opens) get fixed here. Idempotent; safe to call
-    # multiple times. Must run in the main Ractor.
-    #
-    # NOTE: this does NOT build the framework-config shareable fallback. That
-    # step is folded into `make_app_shareable!` because some class_attribute /
-    # mattr_accessor values reference the app graph, and making them shareable
-    # must happen AFTER the app itself is already frozen (otherwise the app
-    # gets frozen prematurely and precompute/proc-replacement can't mutate
-    # it). If you call prepare_for_ractors! standalone (without
-    # make_app_shareable!), worker Ractors will see nil for framework config
-    # values that couldn't be shared without freezing the app — set them
-    # explicitly per worker, or use make_app_shareable!.
     # Shared list of every framework patch install method. Both
     # `prepare_for_ractors!` (pre-worker boot) and `make_app_shareable!`
     # (post-boot, pre-freeze) call this, so the two no longer duplicate the
@@ -403,6 +407,21 @@ module RactorRailsShim
       _install_hash_compute_if_absent_patch
     end
 
+    # Public API: run after Rails.application.initialize! and BEFORE spawning
+    # worker Ractors. Makes every registered constant shareable (deep-freeze).
+    # Constants that didn't exist at install time (e.g. Rails::Railtie, loaded
+    # after `module Rails` opens) get fixed here. Idempotent; safe to call
+    # multiple times. Must run in the main Ractor.
+    #
+    # NOTE: this does NOT build the framework-config shareable fallback. That
+    # step is folded into `make_app_shareable!` because some class_attribute /
+    # mattr_accessor values reference the app graph, and making them shareable
+    # must happen AFTER the app itself is already frozen (otherwise the app
+    # gets frozen prematurely and precompute/proc-replacement can't mutate
+    # it). If you call prepare_for_ractors! standalone (without
+    # make_app_shareable!), worker Ractors will see nil for framework config
+    # values that couldn't be shared without freezing the app — set them
+    # explicitly per worker, or use make_app_shareable!.
     def prepare_for_ractors!
       do_install_shareable_constants
       RactorRailsShim._freeze_shareable_class_ivars! if RactorRailsShim.respond_to?(:_freeze_shareable_class_ivars!)
@@ -416,9 +435,9 @@ module RactorRailsShim
       _freeze_global_class_ivars!
       _freeze_global_constants!
       _freeze_messages_constants!
-     end
+    end
 
-     # Verify the runtime matches the versions the shim was developed against.
+    # Verify the runtime matches the versions the shim was developed against.
     # The shim's patches target specific Rails 8.1 class layouts and Ruby 4.0
     # Ractor semantics. On other versions, the patches may silently miss or
     # break things. Behavior on mismatch is governed by `version_policy`:
@@ -434,9 +453,10 @@ module RactorRailsShim
     def _check_version_support
       @version_policy ||= :warn
       unless RactorRailsShim::Version.supported_ruby?
-        msg = "ractor-rails-shim: Ruby #{RUBY_VERSION} — shim developed " \
-              "against Ruby #{SUPPORTED_RUBY}. Ractor semantics may differ; " \
-              "the shim may break. Proceeding anyway."
+        msg = "ractor-rails-shim: Ruby #{RUBY_VERSION} — shim requires " \
+              "Ruby >= #{SUPPORTED_RUBY} (frozen-iseq call-cache fix #22075 " \
+              "and cross-ractor env-string fix both shipped in 4.0.6). " \
+              "Proceeding anyway."
         _version_mismatch(msg)
       end
       if RactorRailsShim::Version.rails &&
@@ -508,9 +528,27 @@ module RactorRailsShim
     # `Zeitwerk::Loader.new` raises IsolationError off the main Ractor).
     def capture_app_constants
       map = {}
-      return map unless defined?(::Rails) && Rails.respond_to?(:autoloaders)
-      [Rails.autoloaders.main, Rails.autoloaders.once].each do |loader|
-        next unless loader.respond_to?(:all_expected_cpaths)
+      unless defined?(::Rails) && Rails.respond_to?(:autoloaders)
+        return map.freeze
+      end
+      autoloaders = Rails.autoloaders
+      # Guard against non-Zeitwerk configurations: Rails.autoloaders may be
+      # present (the method exists) but not expose `main`/`once` (e.g. classic
+      # loader mode, or `config.autoloaders = false` returning a null object).
+      # `main`/`once` may also individually be nil when only one loader is
+      # configured. Filter to the loaders that actually expose
+      # `all_expected_cpaths` (the Zeitwerk introspection API the capture
+      # relies on).
+      loaders =
+        if autoloaders.respond_to?(:main) && autoloaders.respond_to?(:once)
+          [autoloaders.main, autoloaders.once]
+        elsif autoloaders.respond_to?(:each)
+          autoloaders.to_a
+        else
+          []
+        end
+      loaders.each do |loader|
+        next unless loader && loader.respond_to?(:all_expected_cpaths)
         begin
           loader.all_expected_cpaths.values.each do |cpath|
             obj = Object.const_get(cpath) rescue next
@@ -532,10 +570,16 @@ module RactorRailsShim
     # constants in the main Ractor and wraps the frozen, shareable app in a
     # WorkerApp that rebinds those constants (and initializes the worker's
     # ActiveRecord connection) on the first request served by each worker
-    # Ractor. Returns a shareable WorkerApp instance.
+    # Ractor. Returns a shareable WorkerApp instance — frozen and
+    # `Ractor.make_shareable`'d — so it can be passed directly to
+    # `Ractor.new(worker_app) { |a| a.call(env) }` without the caller having
+    # to know the shareability contract.
     def worker_app(frozen_app)
       bindings = capture_app_constants
-      WorkerApp.new(frozen_app, bindings)
+      wa = WorkerApp.new(frozen_app, bindings)
+      wa.freeze
+      Ractor.make_shareable(wa)
+      wa
     end
 
     # See patches/active_model_attribute.rb. When the frozen `:ractor` graph is
@@ -575,11 +619,25 @@ module RactorRailsShim
     # them. But Rails code calls Concurrent::Map#compute_if_absent on these
     # caches (e.g. ActiveModel::AttributeMethods' attribute_method_patterns_
     # cache). Plain Hash lacks that method, so we add a compatible definition.
+    #
+    # Semantics MUST match Concurrent::Map#compute_if_absent exactly:
+    #   - if the key is present (even with a nil value), return the stored
+    #     value WITHOUT invoking the block;
+    #   - otherwise invoke the block, STORE the result (including nil), and
+    #     return it.
+    # The nil-storing behaviour is load-bearing: Concurrent::Map stores nil
+    # results so the block doesn't re-run; the original shim implementation
+    # used `IES[key] ||= yield` in the frozen branch, which SKIPS nil — a
+    # divergent semantics that re-invokes the block on every lookup for any
+    # cache slot whose computed value is nil.
+    #
     # For a MUTABLE cache the shim freezes the replaced Hash (so it is shareable
     # across workers); mutating it would raise FrozenError. So when the receiver
     # is frozen we route the store to per-Ractor IES keyed by the Hash identity
     # and the key — giving each worker its own cache entry without mutating the
-    # shared object. Semantics otherwise match Concurrent::Map.
+    # shared object. The frozen branch mirrors the mutable one: check presence
+    # first (via IES key?), invoke the block only on miss, store the result
+    # (including nil) via IES[]=.
     def _install_hash_compute_if_absent_patch
       return @hash_compute_if_absent_patched if defined?(@hash_compute_if_absent_patched) && @hash_compute_if_absent_patched
       @hash_compute_if_absent_patched = true
@@ -587,8 +645,17 @@ module RactorRailsShim
       ::Hash.prepend(Module.new do
         def compute_if_absent(key)
           if frozen?
-            ies_key = :"rrs_cia_#{object_id}_#{key}"
-            ActiveSupport::IsolatedExecutionState[ies_key] ||= yield(key)
+            # Check the receiver first — a present key (even nil-valued)
+            # returns without invoking the block, matching Concurrent::Map.
+            return self[key] if key?(key)
+            # Per-Ractor IES slot, namespaced by this Hash's object_id so two
+            # frozen hashes with the same key don't collide. Use a two-level
+            # structure (Hash per receiver) so the presence check (`key?`)
+            # and the store share the same slot.
+            slot = ActiveSupport::IsolatedExecutionState[:rrs_cia] ||= {}
+            bucket = slot[object_id] ||= {}
+            return bucket[key] if bucket.key?(key)
+            bucket[key] = yield(key)
           elsif key?(key)
             self[key]
           else
@@ -617,11 +684,9 @@ module RactorRailsShim
         # be shareable.
         klass.instance_variables.each do |ivar|
           val = klass.instance_variable_get(ivar)
-          next if val.nil? || Ractor.shareable?(val)
-          begin
+          next if Ractor.shareable?(val)
+          _swallow("freeze AR ivar #{klass.name}#{ivar}") do
             Ractor.make_shareable(val)
-          rescue
-            nil
           end
         end
       end
@@ -638,11 +703,9 @@ module RactorRailsShim
       classes.each do |klass|
         klass.instance_variables.each do |ivar|
           val = klass.instance_variable_get(ivar)
-          next if val.nil? || Ractor.shareable?(val)
-          begin
+          next if Ractor.shareable?(val)
+          _swallow("freeze global ivar #{klass}#{ivar}") do
             Ractor.make_shareable(val)
-          rescue
-            nil
           end
         end
       end
@@ -699,11 +762,14 @@ module RactorRailsShim
       # non-frozen arrays; load hooks never fire again in workers.
       # Gem::LoadError is a ScriptError (not StandardError), so a bare
       # `rescue nil` on the require would NOT catch a missing msgpack gem.
-      begin
-        require "active_support/message_pack"
-      rescue LoadError
-        return
-      end
+      # Pre-check for the msgpack gem: active_support/message_pack loads
+      # without it but prints a "requires the msgpack gem" warning to $stderr
+      # before raising LoadError. Checking first avoids the warning entirely
+      # (no stderr suppression needed) and skips the freeze step cleanly when
+      # the C extension isn't installed (e.g. in the gem's no-Rails unit specs).
+      return unless Gem::Specification.find_all_by_name("msgpack").any?
+
+      require "active_support/message_pack"
 
       mod = (Object.const_get(:ActiveSupport) rescue nil)&.const_get(:Messages, false) rescue nil
       mod = mod&.const_get(:Metadata, false) rescue nil
@@ -766,8 +832,9 @@ module RactorRailsShim
   #   2. ensures the worker's ActiveRecord connection handler is initialized.
   #
   # The wrapper holds only shareable state (@app, @bindings), so the instance
-  # is Ractor.make_shareable. `Ractor.current` provides per-worker storage for
-  # the one-time guard, avoiding any top-level constant reference.
+  # is `Ractor.make_shareable`'d by `worker_app` before being handed to worker
+  # Ractors. `Ractor.current` provides per-worker storage for the one-time
+  # guard, avoiding any top-level constant reference.
   class WorkerApp
     def initialize(app, bindings)
       @app = app
@@ -784,9 +851,12 @@ module RactorRailsShim
     def setup_once!
       # All threads inside a worker Ractor share Ractor.current, so a single
       # per-Ractor mutex serializes the one-time init across the worker's
-      # threads. (The mutex is created under ||= which is racy under extreme
-      # contention, but both init steps below are themselves idempotent, so a
-      # rare double-init is harmless.)
+      # threads. `Ractor.current[:key] ||= Thread::Mutex.new` is atomic in
+      # Ruby 4.0.6 (verified: 100 concurrent threads produce exactly one
+      # mutex object), so the TOCTOU race that would let two threads each
+      # create their own mutex does not occur. The `:rrs_worker_ready` guard
+      # inside `synchronize` then ensures `rebind_constants` runs exactly
+      # once per worker; later threads return early.
       m = Ractor.current[:rrs_worker_mutex] ||= Thread::Mutex.new
       m.synchronize do
         return if Ractor.current[:rrs_worker_ready]

data/lib/ractor_rails_shim/patches/devise.rb

@@ -91,7 +91,7 @@ module RactorRailsShim
         def devise_parameter_filter
           key = :"ractor_rails_shim_devise_param_filter_\#{object_id}"
           v = ActiveSupport::IsolatedExecutionState[key]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(key)
           f = Devise::ParameterFilter.new(case_insensitive_keys, strip_whitespace_keys)
           ActiveSupport::IsolatedExecutionState[key] = f
           f

data/lib/ractor_rails_shim/patches/execution_wrapper.rb

@@ -42,7 +42,7 @@ module RactorRailsShim
       ew.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def active_key
           v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
           sym = :"active_execution_wrapper_\#{object_id}"
           ActiveSupport::IsolatedExecutionState[#{key_str}] = sym
           sym

data/lib/ractor_rails_shim/patches/kaminari.rb

@@ -62,7 +62,7 @@ module RactorRailsShim
       ::Kaminari.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def config
           v = ActiveSupport::IsolatedExecutionState[#{k_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{k_key_str})
           if Ractor.main? && instance_variable_defined?(:@_config)
             @_config
           else