ractor-rails-shim 0.2.0

data/lib/ractor_rails_shim/patches/devise.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+# Patch for Devise (5.0). Two blockers for worker Ractors:
+#
+# 1. Devise::Controllers::UrlHelpers#generate_helpers! defines every helper
+#    (session_path, new_session_path, user_password_path, ...) via
+#    `define_method method do |resource_or_scope, *args| ... end` — a block
+#    that captures the MAIN ractor's binding. Calling `session_path(...)` from
+#    a worker raises "defined with an un-shareable Proc in a different Ractor".
+#    Fix: redefine each helper via string eval (no captured binding); the body
+#    replicates the original exactly, delegating to the underlying Rails route
+#    helper via `context.send(method, *args)` (the real helpers are already
+#    patched in action_dispatch.rb).
+#
+# 2. The helper body (and Devise::Mapping.find_scope!) reads `Devise.mappings`,
+#    which reads the `@@mappings` class variable — unreadable from a worker
+#    Ractor. Fix: snapshot `Devise.mappings` as a shareable Hash at prepare
+#    time and have the patched `Devise.mappings` reader return it in workers
+#    (skipping the main-ractor route reload).
+
+module RactorRailsShim
+  # Devise defines several top-level mutable Array/Hash constants
+  # (TRUE_VALUES, FALSE_VALUES, NO_INPUT, ALL, CONTROLLERS, ROUTES,
+  # STRATEGIES, URL_HELPERS) that are NOT frozen, hence non-shareable — a
+  # worker Ractor raises "can not access non-shareable objects in constant
+  # Devise::TRUE_VALUES ..." when it reads them (e.g. remember_me? ->
+  # TRUE_VALUES). These are populated during boot and never mutated in
+  # :ractor mode (frozen graph, no reloading), so deep-freeze + const_set
+  # them shareable at prepare time.
+  SHAREABLE_CONSTANTS.concat([
+    "Devise::TRUE_VALUES",
+    "Devise::FALSE_VALUES",
+    "Devise::NO_INPUT",
+    "Devise::ALL",
+    "Devise::CONTROLLERS",
+    "Devise::ROUTES",
+    "Devise::STRATEGIES",
+    "Devise::URL_HELPERS",
+  ])
+
+  class << self
+    # Devise::FailureApp.call memoizes its Rack endpoint in a class-level ivar
+    # (`@respond ||= action(:respond)`). A worker Ractor cannot set instance
+    # variables on a shared class/module, so calling it raises "can not set
+    # instance variables of classes/modules by non-main Ractors". Route the
+    # memoized endpoint through IsolatedExecutionState (per-Ractor), so each
+    # worker builds and caches its own copy without mutating the shared class.
+    def _install_devise_failure_app_patch
+      return if @devise_failure_app_patched
+      @devise_failure_app_patched = true
+      _register_patch :devise_failure_app, "5.0"
+      return unless defined?(::Devise::FailureApp)
+      ::Devise::FailureApp.singleton_class.module_eval <<-'RUBY', __FILE__, __LINE__ + 1
+        def call(env)
+          respond = ActiveSupport::IsolatedExecutionState[:ractor_rails_shim_devise_failure_respond] ||= action(:respond)
+          respond.call(env)
+        end
+      RUBY
+      # Devise::FailureApp#relative_url_root reads `config.action_controller
+      # .try(:relative_url_root)`. `config.action_controller` is a
+      # Rails::Railtie::Configuration whose `relative_url_root` is NOT a real
+      # method, so `try` triggers `method_missing`, which reads the `@@options`
+      # class variable — unreadable from a worker Ractor. `Rails.application
+      # .config.relative_url_root` IS a real method on
+      # Rails::Application::Configuration (no method_missing, no class var), so
+      # use just that; for the common case (no relative root) it returns nil.
+      if defined?(::Devise::FailureApp)
+        ::Devise::FailureApp.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def relative_url_root
+            @relative_url_root ||= Rails.application.config.relative_url_root
+          end
+        RUBY
+      end
+    end
+
+    # Devise::Models::Authenticatable::ClassMethods#devise_parameter_filter
+    # memoizes `@devise_parameter_filter ||= Devise::ParameterFilter.new(...)`
+    # on the MODEL CLASS. A worker Ractor cannot set an instance variable on a
+    # shared class/module, so calling it raises "can not set instance variables
+    # of classes/modules by non-main Ractors". Route the memoized filter through
+    # IsolatedExecutionState (per-Ractor), keyed by the (shared, stable) class
+    # object_id. `case_insensitive_keys` / `strip_whitespace_keys` are
+    # class_attribute values the shim already routes through IES, so they read
+    # fine in a worker.
+    def _install_devise_authenticatable_patch
+      return if @devise_authenticatable_patched
+      @devise_authenticatable_patched = true
+      _register_patch :devise_authenticatable, "5.0"
+      return unless defined?(::Devise::Models::Authenticatable::ClassMethods)
+      ::Devise::Models::Authenticatable::ClassMethods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def devise_parameter_filter
+          key = :"ractor_rails_shim_devise_param_filter_\#{object_id}"
+          v = ActiveSupport::IsolatedExecutionState[key]
+          return v unless v.nil?
+          f = Devise::ParameterFilter.new(case_insensitive_keys, strip_whitespace_keys)
+          ActiveSupport::IsolatedExecutionState[key] = f
+          f
+        end
+      RUBY
+    end
+
+    def _install_devise_url_helpers_patch
+      return if @devise_url_helpers_patched
+      @devise_url_helpers_patched = true
+      _register_patch :devise_url_helpers, "5.0"
+      return unless defined?(::Devise::Controllers::UrlHelpers)
+
+      mod = ::Devise::Controllers::UrlHelpers
+
+      # Patch Devise.mappings FIRST (before the snapshot below) so every
+      # subsequent read — including the snapshot — does NOT trigger a route
+      # reload. Routes are fully drawn by Rails.application.initialize! before
+      # prepare_for_ractors! runs, so @@mappings is already populated in main;
+      # workers read the shareable snapshot instead. The ORIGINAL
+      # Devise.mappings calls reload_routes_unless_loaded, which during
+      # prepare collapses the RouteSet to a single railtie route (rails/info)
+      # that then gets frozen into the shared app graph — breaking routing for
+      # every worker Ractor.
+      if defined?(::Devise) && ::Devise.respond_to?(:mappings)
+        ::Devise.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def mappings
+            return RactorRailsShim::DEVISE_MAPPINGS if !Ractor.main? && RactorRailsShim.const_defined?(:DEVISE_MAPPINGS)
+            ::Devise.class_variable_get(:@@mappings)
+          end
+        RUBY
+      end
+
+      # Capture a shareable snapshot of Devise.mappings in MAIN (after routes
+      # are drawn). The real Mapping objects hold an unshareable failure-app
+      # lambda and a default-proc Hash, so we can't share them directly; build
+      # a DeviseMappingSnapshot per scope (see make_shareable.rb). Workers read
+      # this via the patched Devise.mappings reader.
+      if Ractor.main? && defined?(::Devise)
+        begin
+          h = ::Devise.mappings
+          snap = {}
+          h.each { |scope, mapping| snap[scope] = _devise_mapping_snapshot(mapping) }
+          snap = Ractor.make_shareable(snap) rescue nil
+          const_set(:DEVISE_MAPPINGS, snap) if snap
+        rescue
+          nil
+        end
+      end
+
+      # Redefine each generated helper via string eval (no captured binding).
+      # Replicate the EXACT body of Devise::Controllers::UrlHelpers.generate_helpers!
+      # (lib/devise/controllers/url_helpers.rb): the helper does NOT call the
+      # alias method on the context — it reconstructs the REAL route helper name
+      # from `action` + `scope` + `module_name` (e.g. alias `session_path` ->
+      # real `user_session_path`) and sends THAT to the context. Bake in
+      # `action`/`module_name`/`path_or_url` as literals; `scope` is resolved
+      # per-call from the argument, so interpolate it at runtime (\\#{scope}).
+      routes = ::Devise::URL_HELPERS.slice(*(::Devise.mappings.values.map(&:used_helpers).flatten.uniq))
+      routes.each do |module_name, actions|
+        [:path, :url].each do |path_or_url|
+          actions.each do |action|
+            action_prefix = action ? "#{action}_" : ""
+            method = :"#{action_prefix}#{module_name}_#{path_or_url}"
+            mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{method}(resource_or_scope, *args)
+                scope = Devise::Mapping.find_scope!(resource_or_scope)
+                router_name = Devise.mappings[scope].router_name
+                context = router_name ? send(router_name) : _devise_route_context
+                context.send("#{action_prefix}\#{scope}_#{module_name}_#{path_or_url}", *args)
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ractor_rails_shim/patches/execution_wrapper.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# Patch ActiveSupport::ExecutionWrapper.active_key to not write a class
+# ivar from a worker Ractor. The original is `@active_key ||= :"..."`,
+# a raw class-ivar write — illegal from non-main Ractors. The value is a
+# frozen Symbol (pure function of object_id), so we route the cache
+# through IES (per-Ractor; each Ractor computes the same Symbol from the
+# same object_id, so the cached value is identical across Ractors).
+# ExecutionWrapper is the base for Reloader/Executor; `active_key` is
+# called on every request via ActionDispatch::Executor middleware.
+#
+# Also patches ActiveSupport::Callbacks#run_callbacks to tolerate nil
+# __callbacks, and ActiveSupport::Notifications.notifier to not read @notifier.
+
+module RactorRailsShim
+  class << self
+    def install_execution_wrapper
+      return if @exec_wrapper_patched
+      @exec_wrapper_patched = true
+      _register_patch :execution_wrapper, "8.1"
+      if defined?(::ActiveSupport::ExecutionWrapper)
+        patch_execution_wrapper!
+      else
+        @ew_tp = TracePoint.new(:class) do |trace|
+          if defined?(::ActiveSupport::ExecutionWrapper) && !@exec_wrapper_registry_patched
+            @ew_tp.disable
+            patch_execution_wrapper!
+          end
+        end
+        @ew_tp.enable
+      end
+    end
+
+    def patch_execution_wrapper!
+      return if @exec_wrapper_registry_patched
+      @exec_wrapper_registry_patched = true
+      ew = ::ActiveSupport::ExecutionWrapper
+      key = :ractor_rails_shim_exec_wrapper_active_key
+      key_str = key.inspect
+      # active_key returns :"active_execution_wrapper_<object_id>"; a frozen
+      # Symbol is shareable. Compute it once per Ractor and cache in IES.
+      ew.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def active_key
+          v = ActiveSupport::IsolatedExecutionState[#{key_str}]
+          return v unless v.nil?
+          sym = :"active_execution_wrapper_\#{object_id}"
+          ActiveSupport::IsolatedExecutionState[#{key_str}] = sym
+          sym
+        end
+      RUBY
+
+      # Patch ActiveSupport::Callbacks#run_callbacks to tolerate a nil
+      # __callbacks (the case in worker Ractors whose class_attribute fallback
+      # couldn't be made shareable because callback chains hold frozen,
+      # self-capturing Procs). For a frozen, read-only shared app the boot-time
+      # callbacks (ExecutionContext push/pop, CurrentAttributes clear) already
+      # ran in the main Ractor at boot; worker Ractors don't need to re-run
+      # them per request (CurrentAttributes/ExecutionContext are thread-local,
+      # hence per-Ractor, and start empty in a fresh worker). When __callbacks
+      # is nil, run_callbacks just yields the block — matching the empty-chain
+      # fast path in the original. (Method body lives in active_support.rb.)
+      _install_callbacks_nil_safe_patch
+
+      # Patch ActiveSupport::Notifications.notifier to not read the @notifier
+      # class ivar from a worker Ractor. The original is `attr_accessor
+      # :notifier` with `@notifier = Fanout.new` set at module load — a raw
+      # class ivar holding a Fanout (which has a Mutex + subscriber Procs,
+      # both unshareable). Workers get their own per-Ractor Fanout (no
+      # subscribers — instrumentation is a no-op in workers, which is correct
+      # for a read-only shared app where log subscribers already ran in main).
+      # `notifier` is read by `instrumenter` (per-request via Rails::Rack::Logger).
+      # (Method body lives in active_support.rb.)
+      _install_notifications_notifier_patch
+    end
+  end
+end

data/lib/ractor_rails_shim/patches/kaminari.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Patch Kaminari::config to not read the @_config class ivar from a worker
+# Ractor.
+#
+# Blocker 2 (from NEXT_STEPS.md):
+#   Kaminari.config reads @_config directly at kaminari/config.rb:14:
+#     def self.config; @_config ||= Kaminari::Configuration.new end
+#   Not mattr_accessor-backed, so the shim's mattr rewrite doesn't catch it.
+#   Reading @_config from a worker raises
+#   Ractor::IsolationError (@_config from Kaminari).
+#
+# Fix: Targeted patch like the Warden hooks patch. Route Kaminari.config
+# through IES; in the main ractor return the existing @_config; in workers
+# return a shareable fallback (the config object made shareable via
+# Ractor.make_shareable). The config is a simple value object (integers,
+# symbols, nils) — all shareable when frozen.
+
+module RactorRailsShim
+  class << self
+    def _install_kaminari_config_patch
+      return if @kaminari_patched
+      @kaminari_patched = true
+      _register_patch :kaminari_config, "8.1"
+      return unless defined?(::Kaminari)
+
+      # In the main ractor, capture the config object and make it shareable.
+      shareable_config = nil
+      if Ractor.main?
+        begin
+          cfg = ::Kaminari.instance_variable_get(:@_config) rescue nil
+          if cfg
+            begin
+              Ractor.make_shareable(cfg)
+              shareable_config = cfg
+            rescue => e
+              # If the config can't be made shareable (unlikely — it's all
+              # integers/symbols/nil), build a fresh one with defaults.
+              shareable_config = Ractor.make_shareable(::Kaminari::Config.new)
+            end
+          else
+            shareable_config = Ractor.make_shareable(::Kaminari::Config.new)
+          end
+        rescue => e
+          # Best-effort
+        end
+      end
+      shareable_config ||= Ractor.make_shareable(::Kaminari::Config.new) rescue nil
+
+      # Store the shareable config as a constant so workers can read it.
+      if shareable_config
+        verbose, $VERBOSE = $VERBOSE, nil
+        begin
+          const_set(:KAMINARI_SHAREABLE_CONFIG, shareable_config)
+        ensure
+          $VERBOSE = verbose
+        end
+      end
+
+      k_key = :ractor_rails_shim_kaminari_config
+      k_key_str = k_key.inspect
+      ::Kaminari.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def config
+          v = ActiveSupport::IsolatedExecutionState[#{k_key_str}]
+          return v unless v.nil?
+          if Ractor.main? && instance_variable_defined?(:@_config)
+            @_config
+          else
+            RactorRailsShim::KAMINARI_SHAREABLE_CONFIG
+          end
+        end
+
+        def config=(val)
+          ActiveSupport::IsolatedExecutionState[#{k_key_str}] = val
+        end
+      RUBY
+
+      # Register so the shareable fallback builder knows about it.
+      CLASS_ATTRIBUTES << ["Kaminari", :config, k_key, nil] if shareable_config
+    end
+  end
+end