rage-rb 1.23.0 → 1.25.0

data/lib/rage/configuration.rb

@@ -219,6 +219,14 @@ class Rage::Configuration
   end
   # @!endgroup
 
+  # @!group Error Reporter Configuration
+  # Allows configuring error reporters.
+  # @return [Rage::Configuration::ErrorReporters]
+  def error_reporters
+    @error_reporters ||= ErrorReporters.new
+  end
+  # @!endgroup
+
   # @!group OpenAPI Configuration
   # Allows configuring OpenAPI settings.
   # @return [Rage::Configuration::OpenAPI]
@@ -265,6 +273,22 @@ class Rage::Configuration
   end
   # @!endgroup
 
+  # @!group Router Configuration
+  # Allows configuring router settings.
+  # @return [Rage::Configuration::Router]
+  def router
+    @router ||= Router.new
+  end
+  # @!endgroup
+
+  # @!group Blocking Operation Pool Configuration
+  # Allows configuring the thread pool for offloading native calls.
+  # @return [Rage::Configuration::BlockingOperationPool]
+  def blocking_operation_pool
+    @blocking_operation_pool ||= BlockingOperationPool.new
+  end
+  # @!endgroup
+
   # @private
   def pubsub
     @pubsub ||= PubSub.new
@@ -278,7 +302,7 @@ class Rage::Configuration
   # @private
   def run_after_initialize!
     run_hooks_for!(:after_initialize, self)
-    __finalize
+    __finalize(true)
   end
 
   class LogContext
@@ -378,6 +402,60 @@ class Rage::Configuration
     end
   end
 
+  class ErrorReporters
+    # @private
+    def initialize
+      @objects = []
+    end
+
+    # @private
+    def objects
+      @objects.dup
+    end
+
+    # Add a new error reporter.
+    # Error reporters should respond to `#call` and accept one of:
+    # - `call(exception)`
+    # - `call(exception, context: {})`
+    #
+    # @param reporter [#call]
+    # @return [self]
+    # @example
+    #   Rage.configure do
+    #     config.error_reporters << SentryReporter.new
+    #   end
+    def <<(reporter)
+      validate_input!(reporter)
+      return self if @objects.include?(reporter)
+
+      @objects << reporter
+      Rage::Errors.__send__(:__register_reporter, reporter)
+
+      self
+    end
+
+    alias_method :push, :<<
+
+    # Remove an error reporter.
+    # @param reporter [#call] the reporter to remove
+    # @example
+    #   reporter = SentryReporter.new
+    #   Rage.configure do
+    #     config.error_reporters.delete(reporter)
+    #   end
+    def delete(reporter)
+      deleted = @objects.delete(reporter)
+      Rage::Errors.__send__(:__unregister_reporter, reporter) if deleted
+      deleted
+    end
+
+    private
+
+    def validate_input!(reporter)
+      raise ArgumentError, "error reporter must respond to #call" unless reporter.respond_to?(:call)
+    end
+  end
+
   class Server
     # @!attribute port
     #   Specify the port the server will listen on.
@@ -632,33 +710,6 @@ class Rage::Configuration
         end
       end
     end
-
-    # @private
-    def config
-      @config ||= begin
-        config_file = Rage.root.join("config/cable.yml")
-
-        if config_file.exist?
-          yaml = ERB.new(config_file.read).result
-          YAML.safe_load(yaml, aliases: true, symbolize_names: true)[Rage.env.to_sym] || {}
-        else
-          {}
-        end
-      end
-    end
-
-    # @private
-    def adapter_config
-      config.except(:adapter)
-    end
-
-    # @private
-    def adapter
-      case config[:adapter]
-      when "redis"
-        Rage::Cable::Adapters::Redis.new(adapter_config)
-      end
-    end
   end
 
   class PublicFileServer
@@ -707,6 +758,46 @@ class Rage::Configuration
     # @private
     def initialize
       @configured = false
+      @schedule_blocks = []
+    end
+
+    # Schedule a periodic task to run at a fixed interval.
+    # @example
+    #   Rage.configure do
+    #     config.deferred.schedule do
+    #       every 5.minutes, task: ClearCache
+    #     end
+    #   end
+    def schedule(&block)
+      @schedule_blocks << block
+    end
+
+    # @private
+    # Evaluates all stored schedule blocks and returns the collected tasks.
+    # Called at boot time after all app constants are loaded.
+    def scheduled_tasks
+      @schedule_blocks.flat_map do |block|
+        dsl = ScheduleDSL.new
+        dsl.instance_eval(&block)
+        dsl.tasks
+      end
+    end
+
+    # @private
+    class ScheduleDSL
+      attr_reader :tasks
+
+      def initialize
+        @tasks = []
+      end
+
+      # Registers a task to run on a fixed interval (in seconds)
+      def every(interval, task:)
+        unless task.is_a?(Class) && task.include?(Rage::Deferred::Task)
+          raise ArgumentError, "#{task} must be a class that includes Rage::Deferred::Task"
+        end
+        @tasks << { interval:, task: }
+      end
     end
 
     # Returns the backend instance used by `Rage::Deferred`.
@@ -988,6 +1079,42 @@ class Rage::Configuration
     attr_accessor :key
   end
 
+  class Router
+    # @!attribute form_actions
+    #   Enable the automatic generation of `new` and `edit` routes via resource helpers.
+    #   @return [Boolean]
+    #   @example Enable form actions
+    #     Rage.configure do
+    #       config.router.form_actions = true
+    #     end
+    attr_accessor :form_actions
+  end
+
+  class BlockingOperationPool
+    # @!attribute enabled
+    #   Enable a background thread pool for offloading native calls that can be executed outside the GVL, freeing
+    #   the main server thread to continue processing other requests. This acts as a preemption mechanism: native calls
+    #   won't stall requests, as the OS will context-switch between the server thread and the worker threads.
+    #   Defaults to `false`.
+    #   @return [Boolean]
+    #   @example Enable the thread pool
+    #     Rage.configure do
+    #       config.blocking_operation_pool.enabled = true
+    #     end
+    #
+    # @!attribute size
+    #   Specify the number of threads in the pool. Defaults to `1`. A single thread is sufficient in most cases
+    #   because the pool's goal is context switching, not parallelization.
+    #   @return [Integer]
+    attr_accessor :enabled, :size
+
+    # @private
+    def initialize
+      @enabled = false
+      @size = 1
+    end
+  end
+
   # @private
   class PubSub
     attr_reader :adapter
@@ -1004,6 +1131,7 @@ class Rage::Configuration
     def config
       @config ||= begin
         config_file = Rage.root.join("config/pubsub.yml")
+        config_file = Rage.root.join("config/cable.yml") unless config_file.exist?
 
         config = if config_file.exist?
           yaml = ERB.new(config_file.read).result
@@ -1053,7 +1181,7 @@ class Rage::Configuration
   end
 
   # @private
-  def __finalize
+  def __finalize(before_boot = false)
     if @logger
       @logger.formatter = @log_formatter if @log_formatter
       @logger.level = @log_level if @log_level
@@ -1075,6 +1203,15 @@ class Rage::Configuration
       @logger.dynamic_tags = Rage.__log_processor.dynamic_tags
     end
 
+    if before_boot && @blocking_operation_pool&.enabled
+      if defined?(Rage::FiberScheduler::BlockingOperationWait)
+        Iodine.on_state(:pre_start) { puts "INFO: Using blocking operation pool" }
+        Rage::FiberScheduler.include(Rage::FiberScheduler::BlockingOperationWait)
+      else
+        puts "WARNING: Blocking operation pool is not supported on Ruby #{RUBY_VERSION}"
+      end
+    end
+
     if defined?(::Rack::Events) && middleware.include?(::Rack::Events)
       middleware.delete(Rage::BodyFinalizer)
       middleware.insert_before(::Rack::Events, Rage::BodyFinalizer)

data/lib/rage/controller/api.rb

@@ -185,32 +185,6 @@ class RageController::API
       klass.__wrap_parameters_options = __wrap_parameters_options
     end
 
-    # @private
-    @@__dynamic_name_seed = ("a".."i").to_a.permutation
-
-    # @private
-    # define a method based on a block
-    def define_dynamic_method(block)
-      name = @@__dynamic_name_seed.next.join
-      define_method("__rage_dynamic_#{name}", block)
-    end
-
-    # @private
-    # define a method that will call a specified method if a condition is `true` or yield if `false`
-    def define_maybe_yield(method_name)
-      name = @@__dynamic_name_seed.next.join
-
-      class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def __rage_dynamic_#{name}(condition)
-          if condition
-            #{method_name} { yield }
-          else
-            yield
-          end
-        end
-      RUBY
-    end
-
     # @private
     def __register_renderer(name, block)
       prepend(RageController::Renderers) unless ancestors.include?(RageController::Renderers)
@@ -240,7 +214,7 @@ class RageController::API
     def rescue_from(*klasses, with: nil, &block)
       unless with
         if block_given?
-          with = define_dynamic_method(block)
+          with = Rage::Internal.define_dynamic_method(self, block)
         else
           raise ArgumentError, "No handler provided. Pass the `with` keyword argument or provide a block."
         end
@@ -314,7 +288,7 @@ class RageController::API
     #   end
     def around_action(action_name = nil, **opts, &block)
       action = prepare_action_params(action_name, **opts, &block)
-      action.merge!(around: true, wrapper: define_maybe_yield(action[:name]))
+      action.merge!(around: true, wrapper: Rage::Internal.define_maybe_yield(self, action[:name]))
 
       if @__before_actions && @__before_actions.frozen?
         @__before_actions = @__before_actions.dup
@@ -429,7 +403,7 @@ class RageController::API
     # used by `before_action` and `after_action`
     def prepare_action_params(action_name = nil, **opts, &block)
       if block_given?
-        action_name = define_dynamic_method(block)
+        action_name = Rage::Internal.define_dynamic_method(self, block)
       elsif action_name.nil?
         raise ArgumentError, "No handler provided. Pass the `action_name` parameter or provide a block."
       end
@@ -444,8 +418,8 @@ class RageController::API
         unless: _unless
       }
 
-      action[:if] = define_dynamic_method(action[:if]) if action[:if].is_a?(Proc)
-      action[:unless] = define_dynamic_method(action[:unless]) if action[:unless].is_a?(Proc)
+      action[:if] = Rage::Internal.define_dynamic_method(self, action[:if]) if action[:if].is_a?(Proc)
+      action[:unless] = Rage::Internal.define_dynamic_method(self, action[:unless]) if action[:unless].is_a?(Proc)
 
       action
     end
@@ -584,13 +558,13 @@ class RageController::API
   def authenticate_with_http_token
     auth_header = @__env["HTTP_AUTHORIZATION"]
 
-    payload = if auth_header&.start_with?("Bearer")
+    payload = if auth_header&.start_with?("Bearer ")
       auth_header[7..]
-    elsif auth_header&.start_with?("Token")
+    elsif auth_header&.start_with?("Token ")
       auth_header[6..]
     end
 
-    return unless payload
+    return if payload.nil? || payload.empty?
 
     token = if payload.start_with?("token=")
       payload[6..]
@@ -601,6 +575,8 @@ class RageController::API
     token.delete_prefix!('"')
     token.delete_suffix!('"')
 
+    return if token.empty?
+
     yield token
   end
 

data/lib/rage/cookies.rb

@@ -201,7 +201,7 @@ class Rage::Cookies
     end
 
     if (domain = value[:domain])
-      host = @env["HTTP_HOST"]
+      host = @env["HTTP_HOST"]&.sub(/:\d+\z/, "")
 
       processed_domain = if domain.is_a?(String)
         domain

data/lib/rage/deferred/deferred.rb

@@ -82,10 +82,16 @@ module Rage::Deferred
     )
   end
 
+  # @private
+  def self.__start_scheduler
+    Rage::Deferred::Scheduler.start(Rage.config.deferred.scheduled_tasks)
+  end
+
   # @private
   def self.__initialize
     __middleware_chain
     __load_tasks
+    __start_scheduler
   end
 
   module Backends
@@ -96,6 +102,7 @@ module Rage::Deferred
 end
 
 require_relative "task"
+require_relative "scheduler"
 require_relative "queue"
 require_relative "proxy"
 require_relative "context"

data/lib/rage/deferred/metadata.rb

@@ -30,6 +30,14 @@ class Rage::Deferred::Metadata
       !!task.__next_retry_in(attempts, nil)
     end
 
+    # Returns the number of seconds until the next retry, or `nil` if no retry will occur.
+    # The result is memoized per attempt so that the value reported here matches what the queue uses to schedule the retry.
+    # @return [Numeric, nil] retry delay in seconds, or `nil` if the task won't be retried
+    def will_retry_in
+      task = Rage::Deferred::Context.get_task(context)
+      task.__next_retry_in(attempts, nil)
+    end
+
     private
 
     def context

data/lib/rage/deferred/scheduler.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# @private
+class Rage::Deferred::Scheduler
+  def self.start(tasks)
+    return if tasks.empty?
+
+    Rage::Internal.pick_a_worker(purpose: "deferred-scheduler") do
+      puts("INFO: #{Process.pid} is managing scheduled tasks.") if Rage.logger.info?
+      register_timers(tasks)
+    end
+  end
+
+  def self.register_timers(tasks)
+    tasks.each do |entry|
+      interval = (entry[:interval] * 1000).to_i
+
+      if Rage.env.development?
+        Iodine.run_every(interval) { Object.const_get(entry[:task].name).enqueue }
+      else
+        Iodine.run_every(interval) { entry[:task].enqueue }
+      end
+    end
+  end
+end

data/lib/rage/deferred/task.rb

@@ -31,15 +31,16 @@
 # ```
 #
 module Rage::Deferred::Task
-  MAX_ATTEMPTS = 5
+  MAX_ATTEMPTS = 20
   private_constant :MAX_ATTEMPTS
 
-  BACKOFF_INTERVAL = 5
-  private_constant :BACKOFF_INTERVAL
-
   # @private
   CONTEXT_KEY = :__rage_deferred_execution_context
 
+  # @private
+  RETRY_IN_CACHE_VAR = :@__rage_deferred_retry_in
+  private_constant :RETRY_IN_CACHE_VAR
+
   def perform
   end
 
@@ -80,6 +81,8 @@ module Rage::Deferred::Task
 
     true
   rescue Exception => e
+    Rage::Errors.report(e)
+
     unless respond_to?(:__deferred_suppress_exception_logging?, true) && __deferred_suppress_exception_logging?
       Rage.logger.with_context(task_log_context) do
         Rage.logger.error("Deferred task failed with exception: #{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}")
@@ -175,6 +178,17 @@ module Rage::Deferred::Task
 
     # @private
     def __next_retry_in(attempts, exception)
+      f = Fiber.current
+
+      if f.instance_variable_defined?(RETRY_IN_CACHE_VAR)
+        f.instance_variable_get(RETRY_IN_CACHE_VAR)
+      else
+        f.instance_variable_set(RETRY_IN_CACHE_VAR, __calculate_next_retry_in(attempts, exception))
+      end
+    end
+
+    # @private
+    def __calculate_next_retry_in(attempts, exception)
       max = @__max_retries || MAX_ATTEMPTS
       return if attempts > max
 
@@ -191,7 +205,7 @@ module Rage::Deferred::Task
 
     # @private
     def __default_backoff(attempt)
-      rand(BACKOFF_INTERVAL * 2**attempt) + 1
+      (attempt**4) + 10 + (rand(15) * attempt)
     end
   end
 end

data/lib/rage/errors.rb

@@ -1,4 +1,87 @@
+# frozen_string_literal: true
+
 module Rage::Errors
+  ReporterEntry = Struct.new(:reporter, :method_name)
+  private_constant :ReporterEntry
+
+  @reporters = []
+  @next_reporter_id = 0
+
+  class << self
+    # Forward an exception to all registered reporters.
+    #
+    # @param exception [Exception]
+    # @param context [Hash]
+    # @return [nil]
+    def report(exception, context: {})
+      return if @reporters.empty?
+      return if exception.instance_variable_defined?(:@_rage_error_reported)
+
+      ensure_backtrace(exception)
+
+      @reporters.each do |entry|
+        __send__(entry.method_name, entry.reporter, exception, context)
+      rescue => e
+        Rage.logger.error("Error reporter #{entry.reporter.class} failed while reporting #{exception.class}: #{e.class} (#{e.message})")
+      end
+
+      exception.instance_variable_set(:@_rage_error_reported, true) unless exception.frozen?
+
+      nil
+    end
+
+    # @private
+    def __register_reporter(reporter)
+      raise ArgumentError, "error reporter must respond to #call" unless reporter.respond_to?(:call)
+
+      reporter_id = @next_reporter_id
+      @next_reporter_id += 1
+      method_name = :"__report_#{reporter_id}"
+
+      arguments = Rage::Internal.build_arguments(
+        reporter.method(:call),
+        { context: "context" }
+      )
+      call_arguments = arguments.empty? ? "" : ", #{arguments}"
+
+      singleton_class.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def #{method_name}(reporter, exception, context)
+          reporter.call(exception#{call_arguments})
+        end
+      RUBY
+
+      @reporters << ReporterEntry.new(reporter, method_name)
+
+      self
+    end
+
+    # @private
+    def __unregister_reporter(reporter)
+      @reporters.delete_if do |entry|
+        next false unless entry.reporter == reporter
+
+        singleton_class.remove_method(entry.method_name) if singleton_class.method_defined?(entry.method_name)
+        true
+      end
+
+      self
+    end
+
+    private
+
+    def ensure_backtrace(exception)
+      return if exception.frozen?
+      return unless exception.backtrace.nil?
+
+      begin
+        raise exception
+      rescue exception.class
+      end
+    end
+
+    private :__register_reporter, :__unregister_reporter
+  end
+
   class BadRequest < StandardError
   end
 

data/lib/rage/events/subscriber.rb

@@ -90,7 +90,12 @@ module Rage::Events::Subscriber
     Rage.logger.with_context(self.class.__log_context) do
       Rage.logger.error("Subscriber failed with exception: #{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}")
     end
-    raise e if self.class.__is_deferred
+
+    if self.class.__is_deferred
+      raise e
+    else
+      Rage::Errors.report(e)
+    end
   end
 
   private

data/lib/rage/fiber.rb

@@ -111,23 +111,7 @@ class Fiber
   end
 
   # @private
-  def __block_channel(force = false)
-    @__block_channel_i ||= 0
-    @__block_channel_i += 1 if force
-
-    "block:#{object_id}:#{@__block_channel_i}"
-  end
-
-  # @private
-  def __await_channel(force = false)
-    @__fiber_channel_i ||= 0
-    @__fiber_channel_i += 1 if force
-
-    "await:#{object_id}:#{@__fiber_channel_i}"
-  end
-
-  # @private
-  attr_accessor :__awaited_fileno
+  attr_accessor :__awaited_fileno, :__wait_generation, :__block_channel, :__await_channel
 
   # @private
   # pause a fiber and resume in the next iteration of the event loop
@@ -156,7 +140,10 @@ class Fiber
   # @note This method should only be used when multiple fibers have to be processed in parallel. There's no need to use `Fiber.await` for single IO calls.
   def self.await(fibers)
     f, fibers = Fiber.current, Array(fibers)
-    await_channel = f.__await_channel(true)
+
+    f.__wait_generation ||= 0
+    gen = (f.__wait_generation += 1)
+    channel = f.__await_channel = "await:#{f.object_id}:#{gen}"
 
     Rage::Telemetry.tracer.span_core_fiber_await(fibers:) do
       # check which fibers are alive (i.e. have yielded) and which have errored out
@@ -179,17 +166,21 @@ class Fiber
       end
 
       # wait on async fibers; resume right away if one of the fibers errors out
-      Iodine.subscribe(await_channel) do |_, err|
-        if err == AWAIT_ERROR_MESSAGE
-          f.resume
+      Iodine.subscribe(channel) do |_, err|
+        done = if err == AWAIT_ERROR_MESSAGE
+          true
         else
           num_wait_for -= 1
-          f.resume if num_wait_for == 0
+          num_wait_for == 0
+        end
+
+        if done
+          Iodine.defer { Iodine.unsubscribe(channel) }
+          f.resume if f.alive? && gen == f.__wait_generation
         end
       end
 
       Fiber.defer(-1)
-      Iodine.defer { Iodine.unsubscribe(await_channel) }
 
       # if num_wait_for is not 0 means we exited prematurely because of an error
       if num_wait_for > 0