ractor-rails-shim 0.2.2 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49ca69607b89c8817a961657ddccd6a3c1a3e87084ef0ec34090b91bce396b22
-  data.tar.gz: cc35444b2078ea06545412a8c6e0d44dd03d2e07c3c2fd99f7a9e930a6fb897e
+  metadata.gz: 267a3734452aa4069b68599b193d8bebd3fa6e386836ec9ec4238d9667f6b37a
+  data.tar.gz: 748ee127a59a4e7cc0b90b16ff7339edb2dfd6cde3b15df01c1ff29d910d05c3
 SHA512:
-  metadata.gz: 88badfc12887a028b39500559256df576e7317e2dbb9f9e4ee170f116279724a07aef6d3ab4a2bae848c12e04bbc56eb6ffc5c487a54f400aa60ff8b8ef3b0fe
-  data.tar.gz: 95751eb76405f35d3fa1b2f53c89f2d459af19e7503156597d282f23a3c7da2ac71d6836dc54d80c7991b1e623d66c30fd72e67001530d4636fc7846177ed89d
+  metadata.gz: fdd580e1b1c24d324dfc9067a323dff580acd612ac8cfc2551424d4d359d5fc93d55c7ae7a9825efecad3103ef2c59b1b481a34d9270471f23fd19747dc9a52c
+  data.tar.gz: '0523817853ccdfc9444c0815fcb943b7cb3f745519b5baf6683e269e60c81889f97500e7e9e34da7bd3da7e74a3fd3033c5bbd25c4de6296337735ed6fd8301c'

data/CHANGELOG.md

@@ -7,9 +7,73 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### Changed
-- Improved the published gem summary and description (gemspec). Metadata-only
-  release — no code changes.
+## [0.2.5]
+
+### Fixed
+- **Nil-sentinel storage bug in IES-routed accessors.** The shim's
+  `mattr_accessor` / `class_attribute` / Rails-module / AR / Rack / Devise /
+  Kaminari / I18n / Inflector / ActionView / ActionController /
+  ActionDispatch / Zeitwerk / ExecutionWrapper readers used
+  `return v unless v.nil?` to detect "no per-Ractor override has been set."
+  That made `Foo.x = nil` (or `= false`) indistinguishable from "never set,"
+  so the reader silently fell through to the default/fallback instead of the
+  user's explicit `nil`/`false` — a divergence from threaded Rails, where
+  class variables distinguish "undefined" (`class_variable_defined?` is
+  false) from "set to nil." Replaced the nil-sentinel with `<storage>.key?`
+  at every IES / `CLASS_ATTR_VALUES` / `SHAREABLE_FALLBACK` reader so any
+  explicit assignment — including `nil` and `false` — wins over the
+  fallback. The single `Ractor.current[:active_record_connection_handler]`
+  reader keeps the nil-sentinel (with an explanatory comment) because
+  `Ractor#[]` has no `key?` method and `connection_handler=` is never called
+  with nil in practice. 58 sites transformed across 13 patch files.
+  Regression specs in `spec/sentinel_spec.rb` cover the
+  `mattr_accessor :flag, default: true; Flag = nil; Flag # => nil` and
+  `class_attribute :setting, default: :on; Setting = nil; Setting # => nil`
+  cases.
+
+- **`Ractor::IsolationError` in worker schema reload.** When a worker Ractor
+  hit a cold schema (e.g. first request after boot, or after
+  `ActiveRecord::Base.connection_handler.clear_all_connections!`),
+  `ModelSchema::ClassMethods#reload_schema_from_cache` and
+  `Timestamp::ClassMethods#reload_schema_from_cache` wrote to class instance
+  variables (`@columns`, `@columns_hash`, …) on the shared model classes,
+  raising `Ractor::IsolationError: can not set instance variables of
+  classes/modules by non-main Ractors`. Patched both methods (plus
+  `AttributeRegistration::ClassMethods#reset_default_attributes!`) to clear
+  the worker's IES slots instead of writing class ivars, so the next read
+  re-derives the schema in the worker's own IES. Without this, any worker
+  that reloaded its schema crashed the first request after the reload.
+
+## [0.2.4]
+
+### Performance
+- **class_attribute reader (ractor mode) is now allocation-free.** The
+  generated `__class_attr_*` accessors previously walked `self.ancestors` and
+  built a fresh `Symbol` via string interpolation for *every* ancestor on
+  *every* read — the dominant allocation source for GET requests (a Rails class
+  has 20–40 ancestors, and class_attribute is read constantly: controller
+  filters, view partial paths, AR `strict_loading`, form builder, logger, …).
+  In ractor mode the writer already collapses every write to the defining
+  owner's single key, so the ancestor walk was dead code. The reader now does a
+  single literal-symbol lookup against `IsolatedExecutionState[key]` then
+  `SHAREABLE_FALLBACK[key]`, eliminating the per-read `Array` + `Symbol`
+  churn. This cuts request allocations substantially and, with them, the
+  garbage-collection share of CPU time (was ~33% of CPU on `GET /posts`).
+
+## [0.2.3]
+
+### Fixed
+- **Cold `GET /up` `SystemStackError` in worker Ractors (kino `:ractor`).**
+  Rails' `ActionDispatch::Routing::RouteSet#generate_url_helpers` builds a
+  module whose `self.included(base)` hook re-dups the module and re-includes
+  it while `!base._routes.equal?(@_proxy._routes)`. Under the frozen,
+  Ractor-shareable app graph a worker Ractor's controller reports
+  `base._routes` as `nil`, so the equality never holds and the hook
+  re-includes forever (empty Ruby backtrace, first request only; respawns and
+  later requests are fine). The shim's `route_helpers.rb` `generate_url_helpers`
+  override now bounds the reinclude to once per base, preserving the
+  route-alignment intent without the infinite loop. Verified: cold `GET /up`
+  returns 200 in `kino -m ractor`; both `:ractor` and `:threaded` modes clean.
 
 ## [0.2.2]
 
@@ -22,8 +86,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   `ActiveRecord::ConnectionNotEstablished` on the very first request. Setup is
   now serialized with a per-Ractor `Thread::Mutex`, and `rebind_constants`
   re-fetches each namespace parent so concurrent setup cannot clobber a module
-  out from under another thread. `kino :ractor (-w5 -t5)` now serves all
-  endpoints with 0 failures.
+  out from under another thread.
+- **Per-thread ActiveRecord connection handler (intermittent
+  `ConnectionNotEstablished` on `kino :ractor -w5 -t5`).** `init_worker_ar_connections!`
+  stored the per-Ractor `ConnectionHandler` in `ActiveSupport::IsolatedExecutionState`,
+  which is **per-thread** (`Thread.attr_accessor`). The init thread set it, but
+  the other worker threads in the same Ractor saw `nil` →
+  `ConnectionNotEstablished: No connection handler for Ractor X` on a fraction of
+  requests. The handler now lives in `Ractor.current` (per-Ractor, shared by all
+  of the worker's threads), and `ActiveRecord::Base.connection_handler` reads it
+  there first.
+- **Write-path `Ractor::IsolationError` on `redirect_to @post`
+  (`kino :ractor -w5 -t5`, `POST /posts`).** `ActiveModel::AttributeMethods::
+  ClassMethods#attribute_method_patterns_cache` stored a mutable `Concurrent::Map`
+  in a class instance variable (unshareable). Hit via `redirect_to @post` →
+  `respond_to?` → `matched_attribute_method`, raising from worker Ractors. The
+  cache is now routed through `Ractor.current` (per-Ractor, keyed per class) and
+  populated lazily per Ractor — content is deterministic, so per-Ractor
+  recomputation is correct.
+
+  With these three fixes, `kino :ractor (-w5 -t5)` serves `/up`, `GET /posts`,
+  and `POST /posts` (authenticated write + 302) with 0 transport failures and 0
+  server errors under sustained load.
 
 ### Added — ActiveRecord query-path ractor-safety (Blocker 1 deep work)
 - `RactorRailsShim.worker_ar_init(app)` — a shareable Rack middleware that

data/README.md

@@ -5,7 +5,7 @@ A monkey-patch shim that reroutes Rails' class-level instance variable accessors
 **Status:** proof-of-concept / stopgap. The goal is for Rails to do this upstream, at which point this gem becomes a no-op and can be removed.
 
 **Current status:** on a full Rails 8.1 app (Devise 5, Propshaft, Kaminari,
-PG) under Ruby 4.0.5, worker Ractors serve **every** routable action —
+PG) under **official Ruby 4.0.6**, worker Ractors serve **every** routable action —
 `GET /up`, full ERB view rendering, Devise sign-in/sign-out (CSRF issuance
 **and** validation), and authenticated Devise **writes** (`POST /posts` → 302,
 row persisted). A worker Ractor dispatches `GET /up` → **HTTP 200** via
@@ -16,9 +16,13 @@ and patches the raw class-ivar accessors Rails reads per-request
 `PathRegistry`, `I18n`, `AbstractController` lazy ivars, `Rack::Request`/`Utils`,
 `ExecutionContext`, etc.).
 
-**Known limitation:** sustained *concurrent* writes in a worker Ractor can still
-crash with a frozen-iseq SIGBUS (a Ruby 4.0 Ractor-model issue); reads and
-single writes are stable.
+**No patched Ruby or kino required.** Official Ruby 4.0.6 ships the frozen-iseq
+call-cache fix (#22075) and the cross-ractor env-string fix, so the SIGBUS crashes
+that previously required the DDKatch patched Ruby/kino forks are resolved in core.
+Both SIGBUS classes were the only reason a patched build was ever needed; on 4.0.6
+the shim runs `kino -m ractor` on the official `kino` gem under sustained read
+**and** write load (verified: 0 transport failures / 0 server errors across
+`/up`, `GET /posts`, `POST /posts` in the benchmark matrix).
 
 ## Requirements
 
@@ -35,14 +39,11 @@ run a Rails app in Ractor mode is
 developed and tested against a real Rails 8.1 app **served by kino**; that is
 the configuration it is verified against.
 
-**Patched kino:** the shim was validated against a kino build carrying a
-per-ractor env-string cache fix that removes a cross-ractor SIGBUS during
-sustained writes. The patch is published at
-[DDKatch/kino](https://github.com/DDKatch/kino) on the
-`ractor-per-ractor-env-cache` branch. Use that fork (rather than upstream
-`yaroslav/kino`) if you hit write-path crashes. To build it: clone the fork,
-check out that branch, then `asdf local rust 1.85.0 && cargo build --release`
-(the native extension is compiled by the Rails app's `bundle install`).
+**kino:** the Ractor-mode server is
+[kino](https://github.com/yaroslav/kino) (`kino -m ractor`). On official Ruby
+4.0.6 the **upstream `kino` gem (0.1.3) works as-is** — no fork or patch is
+required. (Historically a DDKatch/kino fork carried a per-ractor env-string
+cache fix; that fix is in official 4.0.6, so the fork is obsolete.)
 
 **Benchmarks:** throughput/latency/memory of this shim + the test app under
 kino `:ractor` vs Puma vs Falcon are documented in
@@ -72,7 +73,7 @@ This is the primary blocker preventing Rails from running in Ractor mode (see th
 
 ## How it works
 
-The shim reroutes the accessor methods through `ActiveSupport::IsolatedExecutionState`, which is thread-local storage (`Thread.current[:key]`). Each Ractor has its own threads, so each Ractor gets its own slot automatically — verified on Ruby 4.0.5. Rails already uses this primitive for `ActiveRecord::ConnectionHandling.connection_handler` (for thread safety), so the pattern is proven in production.
+The shim reroutes the accessor methods through `ActiveSupport::IsolatedExecutionState`, which is thread-local storage (`Thread.current[:key]`). Each Ractor has its own threads, so each Ractor gets its own slot automatically — verified on Ruby 4.0.6. Rails already uses this primitive for `ActiveRecord::ConnectionHandling.connection_handler` (for thread safety), so the pattern is proven in production.
 
 Two storage paths, depending on the state's shape:
 

data/lib/ractor_rails_shim/patches/action_controller.rb

@@ -118,8 +118,17 @@ module RactorRailsShim
         # (Hash class→bool) built at prepare_for_ractors! time. Workers read
         # the registry; main reads its live @abstract ivar (set by abstract!
         # / inherited). `internal_methods` loops on abstract?.
+        #
+        # The registry is frozen with `Ractor.make_shareable` at install time so
+        # it can travel the shared app graph. Mutating a frozen Hash raises
+        # FrozenError, so `abstract!` only writes the live ivar (main) and
+        # guards the registry write behind a mutability check. `abstract!`
+        # after install in main is a no-op on the registry (already captured);
+        # callers that need to flip a class to abstract post-install should
+        # rebuild the registry (rare — abstract! is a boot-time declaration).
         def abstract!
-          RactorRailsShim._abstract_registry[self] = true if Ractor.main?
+          reg = RactorRailsShim._abstract_registry
+          reg[self] = true if reg && !reg.frozen? && Ractor.main?
           @abstract = true if Ractor.main?
         end
 

data/lib/ractor_rails_shim/patches/action_dispatch.rb

@@ -101,7 +101,7 @@ module RactorRailsShim
       req.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def parameter_parsers
           v = ActiveSupport::IsolatedExecutionState[#{pp_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{pp_key_str})
           if Ractor.main? && instance_variable_defined?(:@parameter_parsers)
             v = @parameter_parsers
             ActiveSupport::IsolatedExecutionState[#{pp_key_str}] = v

data/lib/ractor_rails_shim/patches/action_view.rb

@@ -85,7 +85,7 @@ module RactorRailsShim
       lc.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def registered_details
           v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
           if Ractor.main? && instance_variable_defined?(:@registered_details)
             @registered_details
           else
@@ -257,7 +257,7 @@ module RactorRailsShim
       dk.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def view_context_class
           v = ActiveSupport::IsolatedExecutionState[#{vcc_key_str2}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{vcc_key_str2})
           if Ractor.main? && instance_variable_defined?(:@view_context_class)
             v = @view_context_class
             ActiveSupport::IsolatedExecutionState[#{vcc_key_str2}] = v

data/lib/ractor_rails_shim/patches/active_model_attribute.rb

@@ -64,6 +64,23 @@ module RactorRailsShim
           types
         end
       end
+
+      # `reset_default_attributes!` (called by `reload_schema_from_cache` via
+      # the Attributes → Timestamp → ModelSchema super chain) writes
+      # `@default_attributes = nil` and `@attribute_types = nil` class ivars.
+      # In a worker Ractor those writes raise Ractor::IsolationError. The
+      # shim routes the *readers* above through IES, so in a worker we clear
+      # the IES slots instead (the next read rebuilds lazily). In main we keep
+      # the original class-ivar-clearing behavior.
+      def reset_default_attributes!
+        if Ractor.main?
+          @default_attributes = nil
+          @attribute_types = nil
+        else
+          ActiveSupport::IsolatedExecutionState.delete(:"rrs_default_attributes_#{object_id}")
+          ActiveSupport::IsolatedExecutionState.delete(:"rrs_attribute_types_#{object_id}")
+        end
+      end
     end
   end
 

data/lib/ractor_rails_shim/patches/active_support.rb

@@ -98,7 +98,7 @@ module RactorRailsShim
             # In a worker Ractor, class_attribute-backed `__callbacks`
             # falls back to the empty default (see class_attribute.rb /
             # make_shareable.rb), so controller `before_action` /
-            # `after_action` filters are normally SKIPED. For
+            # `after_action` filters are normally SKIPPED. For
             # `:process_action` we replay the captured SYMBOL filters
             # (see make_shareable!#_capture_controller_callbacks!)
             # so actions that depend on a before_action (e.g. `set_post`
@@ -186,7 +186,7 @@ module RactorRailsShim
       notif.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def notifier
           v = ActiveSupport::IsolatedExecutionState[#{nkey_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{nkey_str})
           if Ractor.main? && instance_variable_defined?(:@notifier)
             @notifier
           else
@@ -212,7 +212,7 @@ module RactorRailsShim
         def instance(locale = :en)
           if locale == :en
             v = ActiveSupport::IsolatedExecutionState[#{en_key_str}]
-            return v unless v.nil?
+            return v if ActiveSupport::IsolatedExecutionState.key?(#{en_key_str})
             if Ractor.main?
               existing = instance_variable_get(:@__en_instance__) if instance_variable_defined?(:@__en_instance__)
               ActiveSupport::IsolatedExecutionState[#{en_key_str}] = existing
@@ -302,7 +302,7 @@ module RactorRailsShim
       ::ActiveSupport.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def error_reporter
           v = ActiveSupport::IsolatedExecutionState[#{er_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{er_key_str})
           if Ractor.main? && instance_variable_defined?(:@error_reporter)
             @error_reporter
           else
@@ -343,7 +343,7 @@ module RactorRailsShim
       cfg.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def default_locale
           v = ActiveSupport::IsolatedExecutionState[#{dl_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{dl_key_str})
           if Ractor.main? && defined?(@@default_locale)
             cv = @@default_locale
             ActiveSupport::IsolatedExecutionState[#{dl_key_str}] = cv
@@ -360,7 +360,7 @@ module RactorRailsShim
         end
         def locale
           v = ActiveSupport::IsolatedExecutionState[#{l_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{l_key_str})
           default_locale
         end
         def locale=(locale)
@@ -380,7 +380,7 @@ module RactorRailsShim
         # set config.i18n.available_locales explicitly.
         def available_locales
           v = ActiveSupport::IsolatedExecutionState[#{av_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{av_key_str})
           if Ractor.main?
             if defined?(@@available_locales) && (cv = @@available_locales)
               ActiveSupport::IsolatedExecutionState[#{av_key_str}] = cv
@@ -404,7 +404,7 @@ module RactorRailsShim
         end
         def available_locales_set
           v = ActiveSupport::IsolatedExecutionState[#{avs_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{avs_key_str})
           if Ractor.main? && defined?(@@available_locales_set) && (cv = @@available_locales_set)
             ActiveSupport::IsolatedExecutionState[#{avs_key_str}] = cv
             return cv
@@ -424,7 +424,7 @@ module RactorRailsShim
         # documented I18n default).
         def enforce_available_locales
           v = ActiveSupport::IsolatedExecutionState[:ractor_rails_shim_i18n_enforce]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(:ractor_rails_shim_i18n_enforce)
           if Ractor.main? && defined?(@@enforce_available_locales)
             cv = @@enforce_available_locales
             ActiveSupport::IsolatedExecutionState[:ractor_rails_shim_i18n_enforce] = cv
@@ -469,7 +469,7 @@ module RactorRailsShim
         # main; workers reload translations from disk via these paths.
         def load_path
           v = ActiveSupport::IsolatedExecutionState[:ractor_rails_shim_i18n_load_path]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(:ractor_rails_shim_i18n_load_path)
           if Ractor.main?
             lp = (defined?(@@load_path) && @@load_path) || []
             lp = lp.dup.freeze if lp.respond_to?(:freeze) && !lp.frozen?
@@ -493,7 +493,7 @@ module RactorRailsShim
         # DEFAULT_INTERPOLATION_PATTERNS constant).
         def default_separator
           v = ActiveSupport::IsolatedExecutionState[:ractor_rails_shim_i18n_sep]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(:ractor_rails_shim_i18n_sep)
           if Ractor.main?
             cv = defined?(@@default_separator) ? @@default_separator : "."
             ActiveSupport::IsolatedExecutionState[:ractor_rails_shim_i18n_sep] = cv
@@ -509,7 +509,7 @@ module RactorRailsShim
         end
         def exception_handler
           v = ActiveSupport::IsolatedExecutionState[:ractor_rails_shim_i18n_exc]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(:ractor_rails_shim_i18n_exc)
           if Ractor.main?
             cv = defined?(@@exception_handler) ? @@exception_handler : ::I18n::ExceptionHandler.new
             ActiveSupport::IsolatedExecutionState[:ractor_rails_shim_i18n_exc] = cv
@@ -525,7 +525,7 @@ module RactorRailsShim
         end
         def missing_interpolation_argument_handler
           v = ActiveSupport::IsolatedExecutionState[:ractor_rails_shim_i18n_miss]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(:ractor_rails_shim_i18n_miss)
           if Ractor.main?
             cv = defined?(@@missing_interpolation_argument_handler) ? @@missing_interpolation_argument_handler : lambda do |missing_key, provided_hash, string|
                 raise ::I18n::MissingInterpolationArgument.new(missing_key, provided_hash, string)
@@ -545,7 +545,7 @@ module RactorRailsShim
         end
         def interpolation_patterns
           v = ActiveSupport::IsolatedExecutionState[:ractor_rails_shim_i18n_ip]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(:ractor_rails_shim_i18n_ip)
           if Ractor.main?
             cv = defined?(@@interpolation_patterns) ? @@interpolation_patterns : ::I18n::DEFAULT_INTERPOLATION_PATTERNS.dup
             ActiveSupport::IsolatedExecutionState[:ractor_rails_shim_i18n_ip] = cv
@@ -599,7 +599,7 @@ module RactorRailsShim
         i18n.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
           def fallbacks
             v = ActiveSupport::IsolatedExecutionState[#{fb_key_str}]
-            return v unless v.nil?
+            return v if ActiveSupport::IsolatedExecutionState.key?(#{fb_key_str})
             if Ractor.main? && defined?(@@fallbacks)
               cv = @@fallbacks
               if cv
@@ -622,7 +622,7 @@ module RactorRailsShim
           tag.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
             def implementation
               v = ActiveSupport::IsolatedExecutionState[#{tag_key_str}]
-              return v unless v.nil?
+              return v if ActiveSupport::IsolatedExecutionState.key?(#{tag_key_str})
               if Ractor.main? && defined?(@@implementation)
                 cv = @@implementation
                 ActiveSupport::IsolatedExecutionState[#{tag_key_str}] = cv
@@ -781,7 +781,7 @@ module RactorRailsShim
       ec.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def after_change_callbacks
           v = ActiveSupport::IsolatedExecutionState[#{acb_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{acb_key_str})
           if Ractor.main? && instance_variable_defined?(:@after_change_callbacks)
             v = @after_change_callbacks
             ActiveSupport::IsolatedExecutionState[#{acb_key_str}] = v
@@ -797,7 +797,7 @@ module RactorRailsShim
         end
         def nestable
           v = ActiveSupport::IsolatedExecutionState[#{nest_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{nest_key_str})
           if Ractor.main? && instance_variable_defined?(:@nestable)
             v = @nestable
             ActiveSupport::IsolatedExecutionState[#{nest_key_str}] = v
@@ -855,7 +855,7 @@ module RactorRailsShim
       ls.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def logger
           v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
           if Ractor.main? && instance_variable_defined?(:@logger)
             @logger
           elsif defined?(::Rails) && ::Rails.respond_to?(:logger)
@@ -890,7 +890,7 @@ module RactorRailsShim
       rl.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def check!
           v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
           result = check.call
           ActiveSupport::IsolatedExecutionState[#{key_str}] = result
           result

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
@@ -135,50 +148,53 @@ module RactorRailsShim
                 end
               RUBY
             end
-           else
-            target.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{namespaced_name}
-                self.ancestors.each do |anc|
-                  k = :"ractor_rails_shim_class_attr_\#{anc.object_id}_#{namespaced_name}"
-                  v = ActiveSupport::IsolatedExecutionState[k]
-                  return v unless v.nil?
-                  fb = RactorRailsShim::SHAREABLE_FALLBACK[k]
-                  return fb unless fb.nil?
-                end
-                RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] if Ractor.main?
-              end
+            else
+             # Ractor mode: the writer (below) ALWAYS targets this owner's single
+             # `key` (#{key_str}), so there is no per-subclass copy-on-write to
+             # resolve by walking ancestors. The original `self.ancestors.each`
+             # + per-ancestor Symbol interpolation allocated a fresh Array AND a
+             # Symbol per ancestor on EVERY read — the dominant allocation source
+             # for GET requests. Replace it with a direct literal-key lookup
+             # (zero per-read allocation). The per-Ractor value already lives in
+             # ActiveSupport::IsolatedExecutionState[key]; SHAREABLE_FALLBACK[key]
+             # is the frozen, shared default built at prepare_for_ractors! time.
+             target.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+               def #{namespaced_name}
+                 v = ActiveSupport::IsolatedExecutionState[#{key_str}]
+                 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?
+               end
 
-              def #{namespaced_name}=(new_value)
-                ActiveSupport::IsolatedExecutionState[#{key_str}] = new_value
-                RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] = new_value if Ractor.main?
-                new_value
-              end
-            RUBY
+               def #{namespaced_name}=(new_value)
+                 ActiveSupport::IsolatedExecutionState[#{key_str}] = new_value
+                 RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] = new_value if Ractor.main?
+                 new_value
+               end
+             RUBY
 
-            # When owner is a module's singleton class, the original also
-            # defines a public reader `def #{name} { value }` on owner directly
-            # (block-based). Override it with the IES-routed version + fallback.
-            if owner.singleton_class? && owner.attached_object.is_a?(Module)
-              owner.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-                def #{name}
-                  self.ancestors.each do |anc|
-                    k = :"ractor_rails_shim_class_attr_\#{anc.object_id}_#{namespaced_name}"
-                    v = ActiveSupport::IsolatedExecutionState[k]
-                    return v unless v.nil?
-                    fb = RactorRailsShim::SHAREABLE_FALLBACK[k]
-                    return fb unless fb.nil?
-                  end
-                  RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] if Ractor.main?
-                end
+             # When owner is a module's singleton class, the original also
+             # defines a public reader `def #{name} { value }` on owner directly
+             # (block-based). Override it with the IES-routed version + fallback.
+             if owner.singleton_class? && owner.attached_object.is_a?(Module)
+               owner.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                 def #{name}
+                   v = ActiveSupport::IsolatedExecutionState[#{key_str}]
+                   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?
+                 end
 
-                def #{name}=(new_value)
-                  ActiveSupport::IsolatedExecutionState[#{key_str}] = new_value
-                  RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] = new_value if Ractor.main?
-                  new_value
-                end
-              RUBY
-            end
-          end
+                 def #{name}=(new_value)
+                   ActiveSupport::IsolatedExecutionState[#{key_str}] = new_value
+                   RactorRailsShim::CLASS_ATTR_VALUES[#{key_str}] = new_value if Ractor.main?
+                   new_value
+                 end
+               RUBY
+             end
+           end
         end
 
         # redefine_method is used by `redefine` internally and by other call

data/lib/ractor_rails_shim/patches/core.rb

@@ -617,7 +617,7 @@ module RactorRailsShim
         # be shareable.
         klass.instance_variables.each do |ivar|
           val = klass.instance_variable_get(ivar)
-          next if val.nil? || Ractor.shareable?(val)
+          next if Ractor.shareable?(val)
           begin
             Ractor.make_shareable(val)
           rescue
@@ -638,7 +638,7 @@ 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)
+          next if Ractor.shareable?(val)
           begin
             Ractor.make_shareable(val)
           rescue

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

data/lib/ractor_rails_shim/patches/make_shareable.rb

@@ -349,8 +349,16 @@ module RactorRailsShim
         # calls `#to_proc` and then requires the result to be a real Proc.
         # Return a frozen no-op lambda so the implicit conversion succeeds and
         # the (side-effect-free) call is a true no-op, matching `#call`.
+        #
+        # The lambda is a shareable constant (frozen at class load), NOT
+        # memoized on `@_to_proc`: NoOpProc instances are deep-frozen by
+        # `Ractor.make_shareable` during `make_app_shareable!`, so an
+        # `@_to_proc ||= ...` write would raise FrozenError on the frozen
+        # instance. A constant avoids the write entirely and is safe to share.
+        NO_OP_LAMBDA = ->(*) { nil }.freeze
+        Ractor.make_shareable(NO_OP_LAMBDA)
         def to_proc
-          @_to_proc ||= ->(*) { nil }.freeze
+          NO_OP_LAMBDA
         end
       end
       class Callable

data/lib/ractor_rails_shim/patches/mattr_accessor.rb

@@ -81,7 +81,7 @@ module RactorRailsShim
             singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{sym}
                 v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-                return v unless v.nil?
+                return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
 
                 if #{!!shareable}
                   if class_variable_defined?(#{cv_str})
@@ -128,7 +128,7 @@ module RactorRailsShim
               module_eval <<-RUBY, __FILE__, __LINE__ + 1
                 def #{sym}
                   v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-                  return v unless v.nil?
+                  return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
                   if Ractor.main?
                     self.class.class_variable_defined?(#{cv_str}) ? self.class.class_variable_get(#{cv_str}) : nil
                   else

data/lib/ractor_rails_shim/patches/orm_adapter.rb

@@ -21,7 +21,7 @@ module RactorRailsShim
         def to_adapter
           key = :"ractor_rails_shim_orm_adapter_\#{object_id}"
           v = ActiveSupport::IsolatedExecutionState[key]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(key)
           adapter = self::OrmAdapter.new(self)
           ActiveSupport::IsolatedExecutionState[key] = adapter
           adapter

data/lib/ractor_rails_shim/patches/rack.rb

@@ -56,7 +56,7 @@ module RactorRailsShim
       req.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def forwarded_priority
           v = ActiveSupport::IsolatedExecutionState[#{fp_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{fp_key_str})
           if Ractor.main? && instance_variable_defined?(:@forwarded_priority)
             @forwarded_priority
           else
@@ -70,7 +70,7 @@ module RactorRailsShim
         end
         def x_forwarded_proto_priority
           v = ActiveSupport::IsolatedExecutionState[#{xp_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{xp_key_str})
           if Ractor.main? && instance_variable_defined?(:@x_forwarded_proto_priority)
             @x_forwarded_proto_priority
           else
@@ -105,7 +105,7 @@ module RactorRailsShim
       u.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def default_query_parser
           v = ActiveSupport::IsolatedExecutionState[#{dqp_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{dqp_key_str})
           if Ractor.main? && instance_variable_defined?(:@default_query_parser)
             v = @default_query_parser
             ActiveSupport::IsolatedExecutionState[#{dqp_key_str}] = v
@@ -116,7 +116,7 @@ module RactorRailsShim
         end
         def multipart_total_part_limit
           v = ActiveSupport::IsolatedExecutionState[#{mtp_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{mtp_key_str})
           if Ractor.main? && instance_variable_defined?(:@multipart_total_part_limit)
             v = @multipart_total_part_limit
             ActiveSupport::IsolatedExecutionState[#{mtp_key_str}] = v
@@ -127,7 +127,7 @@ module RactorRailsShim
         end
         def multipart_file_limit
           v = ActiveSupport::IsolatedExecutionState[#{mfl_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{mfl_key_str})
           if Ractor.main? && instance_variable_defined?(:@multipart_file_limit)
             v = @multipart_file_limit
             ActiveSupport::IsolatedExecutionState[#{mfl_key_str}] = v

data/lib/ractor_rails_shim/patches/rails_module.rb

@@ -36,6 +36,13 @@ module RactorRailsShim
     # :class fires when `rails.rb` opens `module Rails` (module bodies fire
     # as :class); once the constant is assigned, we patch once and disable
     # the hook.
+    #
+    # Two flags are intentional and guard *different* things:
+    #   @rails_load_hook_installed — the TracePoint one-shot is armed (so we
+    #     don't stack multiple TracePoints on repeated `install` calls).
+    #   @rails_module_patched — the patch itself has been applied (checked
+    #     again inside the TracePoint block and in `patch_rails_module!`
+    #     because the immediate-path caller also goes through that method).
     def install_rails_load_hook
       return if @rails_load_hook_installed
       @rails_load_hook_installed = true
@@ -89,7 +96,7 @@ module RactorRailsShim
         # slot is empty until they boot their own app).
         def application
           v = ActiveSupport::IsolatedExecutionState[#{k[:application].inspect}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{k[:application].inspect})
           if Ractor.main?
             super
           else
@@ -108,7 +115,7 @@ module RactorRailsShim
         # value at make_app_shareable! time) when their own IES slot is empty.
         def app_class
           v = ActiveSupport::IsolatedExecutionState[#{k[:app_class].inspect}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{k[:app_class].inspect})
           return super if Ractor.main?
           RactorRailsShim::SHAREABLE_FALLBACK[#{k[:app_class].inspect}]
         end
@@ -120,7 +127,7 @@ module RactorRailsShim
 
         def cache
           v = ActiveSupport::IsolatedExecutionState[#{k[:cache].inspect}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{k[:cache].inspect})
           return super if Ractor.main?
           RactorRailsShim::SHAREABLE_FALLBACK[#{k[:cache].inspect}]
         end
@@ -132,7 +139,7 @@ module RactorRailsShim
 
         def logger
           v = ActiveSupport::IsolatedExecutionState[#{k[:logger].inspect}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{k[:logger].inspect})
           return super if Ractor.main?
           # Loggers are intrinsically mutable (formatters hold tag stacks,
           # logdevs hold IO + Mutex) and can't be shared read-only. Build a
@@ -152,7 +159,7 @@ module RactorRailsShim
 
         def backtrace_cleaner
           v = ActiveSupport::IsolatedExecutionState[#{k[:backtrace_cleaner].inspect}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{k[:backtrace_cleaner].inspect})
           return super if Ractor.main?
           RactorRailsShim::SHAREABLE_FALLBACK[#{k[:backtrace_cleaner].inspect}]
         end
@@ -167,7 +174,7 @@ module RactorRailsShim
         # lazily builds and caches in @_env.
         def env
           v = ActiveSupport::IsolatedExecutionState[#{k[:env].inspect}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{k[:env].inspect})
           if Ractor.main?
             super
           else

data/lib/ractor_rails_shim/patches/route_helpers.rb

@@ -93,6 +93,27 @@ module RactorRailsShim
           mod = _rrs_orig_generate_url_helpers(supports_path)
           mod.module_eval("def _routes\n  @_routes || ::Rails.application.routes\nend", __FILE__, __LINE__ + 1)
           mod.module_eval("def _generate_paths_by_default\n  " + supports_path.inspect + "\nend", __FILE__, __LINE__ + 1)
+
+          # Bound the stock `self.included` reinclude (actionpack
+          # action_dispatch/routing/route_set.rb). That hook re-dups the module
+          # and re-includes it while `!base._routes.equal?(@_proxy._routes)`.
+          # Under the frozen, Ractor-shareable app graph a worker Ractor's
+          # controller can report `_routes` as nil, so the equality never holds
+          # and the reinclude loops forever (SystemStackError on the very first
+          # request, e.g. GET /up -> Rails::HealthController). The intent is to
+          # re-align `_routes` per base exactly once; bound it to one reinclude
+          # per base so the loop can never happen while preserving that intent.
+          seen = ::Set.new
+          mod.instance_variable_set(:@_rrs_reinclude_seen, seen)
+          mod.singleton_class.class_eval do
+            alias_method :_rrs_orig_self_included, :included
+            def included(base)
+              seen = instance_variable_get(:@_rrs_reinclude_seen)
+              return if seen.include?(base.object_id)
+              seen << base.object_id
+              _rrs_orig_self_included(base)
+            end
+          end
           mod
         end
       RUBY

data/lib/ractor_rails_shim/patches/zeitwerk_registry.rb

@@ -23,6 +23,13 @@ module RactorRailsShim
       else
         # Defer until Zeitwerk loads. A TracePoint(:class) fires when
         # `module Registry` opens. One-shot.
+        #
+        # Two flags guard different things (mirrors `rails_module.rb`):
+        #   @zeitwerk_patched          — `install_zeitwerk_registry` ran
+        #                                 (so we don't arm a second TracePoint).
+        #   @zeitwerk_registry_patched — the actual patch was applied (checked
+        #                                 again inside the TracePoint block and
+        #                                 in `patch_zeitwerk_registry!`).
         @zw_tp = TracePoint.new(:class) do |trace|
           if defined?(::Zeitwerk::Registry) && !@zeitwerk_registry_patched
             @zw_tp.disable
@@ -69,7 +76,7 @@ module RactorRailsShim
         reader_patch.module_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{ivar}
             v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-            return v unless v.nil?
+            return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
             if Ractor.main?
               existing = instance_variable_get(#{ivar_str}) if instance_variable_defined?(#{ivar_str})
               if existing

data/lib/ractor_rails_shim/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RactorRailsShim
-  VERSION = "0.2.2"
+  VERSION = "0.2.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ractor-rails-shim
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.5
 platform: ruby
 authors:
 - dev