rage-rb 1.23.0 → 1.24.0

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/internal.rb

@@ -64,24 +64,33 @@ class Rage::Internal
       name_segments.join(":")
     end
 
+    LOCK_FILE_SUFFIX = rand(0x100000000).to_s(36)
+
     # Pick a worker process to execute a block of code.
     # This is useful for ensuring that certain code is only executed by a single worker in a multi-worker setup, e.g. for broadcasting messages to known streams or for running periodic tasks.
     # @yield The block of code to be executed by the picked worker
-    def pick_a_worker(&block)
-      @lock_file, lock_path = Tempfile.new.yield_self { |file| [file, file.path] }
+    def pick_a_worker(purpose:, &block)
+      attempt = proc do
+        lock_path = Pathname.new(Dir.tmpdir).join("rage-#{purpose}-lock-#{LOCK_FILE_SUFFIX}")
 
-      Iodine.on_state(:on_start) do
-        worker_lock = File.new(lock_path)
+        lock_file = File.open(lock_path, File::CREAT | File::WRONLY)
 
-        if worker_lock.flock(File::LOCK_EX | File::LOCK_NB)
-          @worker_lock = worker_lock
+        if lock_file.flock(File::LOCK_EX | File::LOCK_NB)
+          Iodine.on_state(:on_finish) { File.unlink(lock_file) if File.exist?(lock_file) }
+          worker_locks << lock_file
           block.call
         end
       end
+
+      Iodine.running? ? attempt.call : Iodine.on_state(:on_start) { attempt.call }
     end
 
     private
 
+    def worker_locks
+      @worker_locks ||= []
+    end
+
     def dynamic_name_seed
       @dynamic_name_seed ||= ("a".."j").to_a.permutation
     end

data/lib/rage/middleware/fiber_wrapper.rb

@@ -20,6 +20,7 @@ class Rage::FiberWrapper
     rescue Exception => e
       exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
       Rage.logger << exception_str
+      Rage::Errors.report(e)
       if Rage.env.development?
         [500, {}, [exception_str]]
       else

data/lib/rage/openapi/builder.rb

@@ -21,7 +21,7 @@ class Rage::OpenAPI::Builder
   end
 
   def run
-    parser = Rage::OpenAPI::Parser.new
+    parser = Rage::OpenAPI::Parser.new(@nodes)
 
     @routes.each do |controller, routes|
       next if skip_controller?(controller)

data/lib/rage/openapi/converter.rb

@@ -137,6 +137,10 @@ class Rage::OpenAPI::Converter
       end
     end
 
+    if (dynamic_schemas = @nodes.schema_registry).any?
+      (@spec["components"]["schemas"] ||= {}).merge!(dynamic_schemas)
+    end
+
     @spec["tags"] = @used_tags.sort.map { |tag| { "name" => tag } }
 
     @spec
@@ -177,7 +181,7 @@ class Rage::OpenAPI::Converter
           @used_security_schemes << auth_entry.merge(name: auth_name)
         end
 
-        { auth_name => [] }
+        { auth_name => node.auth_scopes.fetch(auth_name, []) }
       end
     end
   end

data/lib/rage/openapi/nodes/method.rb

@@ -3,7 +3,7 @@
 class Rage::OpenAPI::Nodes::Method
   attr_reader :controller, :action, :parents
   attr_accessor :http_method, :http_path, :summary, :tag, :deprecated, :private, :description,
-    :request, :responses, :parameters
+    :request, :responses, :parameters, :auth_scopes
 
   # @param controller [RageController::API]
   # @param action [String]
@@ -15,6 +15,7 @@ class Rage::OpenAPI::Nodes::Method
 
     @responses = {}
     @parameters = {}
+    @auth_scopes = {}
   end
 
   def root

data/lib/rage/openapi/nodes/root.rb

@@ -20,12 +20,13 @@
 #            Nodes::Method<index>   Nodes::Method<show>                  Nodes::Method<show>
 #
 class Rage::OpenAPI::Nodes::Root
-  attr_reader :leaves
+  attr_reader :leaves, :schema_registry
   attr_accessor :version, :title
 
   def initialize
     @parent_nodes_cache = {}
     @leaves = []
+    @schema_registry = {}
   end
 
   # @return [Array<Rage::OpenAPI::Nodes::Parent>]

data/lib/rage/openapi/openapi.rb

@@ -120,7 +120,7 @@ module Rage::OpenAPI
 
   # @private
   def self.__try_parse_collection(str)
-    if str =~ /^Array<([\w\s:\(\)]+)>$/ || str =~ /^\[([\w\s:\(\)]+)\]$/
+    if str =~ /^Array<([\w\s:\(\),]+)>$/ || str =~ /^\[([\w\s:\(\),]+)\]$/
       [true, $1]
     else
       [false, str]

data/lib/rage/openapi/parser.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
 class Rage::OpenAPI::Parser
+  # @param root [Rage::OpenAPI::Nodes::Root]
+  def initialize(root)
+    @root = root
+  end
+
   # @param node [Rage::OpenAPI::Nodes::Parent]
   # @param comments [Array<Prism::InlineComment>]
   def parse_dangling_comments(node, comments)
@@ -125,7 +130,8 @@ class Rage::OpenAPI::Parser
         else
           parsed = Rage::OpenAPI::Parsers::Request.parse(
             request,
-            namespace: Rage::OpenAPI.__module_parent(node.controller)
+            namespace: Rage::OpenAPI.__module_parent(node.controller),
+            root: @root
           )
 
           if parsed
@@ -138,6 +144,9 @@ class Rage::OpenAPI::Parser
       elsif expression =~ /@param\s/
         parse_param_tag(expression, node, comments[i])
 
+      elsif expression =~ /@auth_scope\s/
+        parse_auth_scope_tag(expression, node, comments[i])
+
       elsif expression =~ /@internal\b/
         # no-op
         children = find_children(comments[i + 1..], node)
@@ -203,7 +212,8 @@ class Rage::OpenAPI::Parser
     else
       parsed = Rage::OpenAPI::Parsers::Response.parse(
         response_data,
-        namespace: Rage::OpenAPI.__module_parent(node.controller)
+        namespace: Rage::OpenAPI.__module_parent(node.controller),
+        root: @root
       )
 
       if parsed
@@ -256,6 +266,67 @@ class Rage::OpenAPI::Parser
     end
   end
 
+  def parse_auth_scope_tag(expression, node, comment)
+    content = expression.split(" ", 2)[1]
+
+    unless content
+      Rage::OpenAPI.__log_warn "invalid `@auth_scope` tag detected at #{location_msg(comment)}; expected [scope1, scope2] syntax"
+      return
+    end
+
+    parsed = YAML.safe_load(content)
+
+    if parsed.is_a?(Array)
+      scheme_name = nil
+      scopes = parsed.map(&:to_s)
+    elsif parsed.is_a?(String)
+      scheme_name = parsed.split(" ", 2)[0]
+      scopes_str = content.split(" ", 2)[1]
+
+      unless scopes_str
+        Rage::OpenAPI.__log_warn "invalid `@auth_scope` tag detected at #{location_msg(comment)}; expected [scope1, scope2] syntax"
+        return
+      end
+
+      scopes = YAML.safe_load(scopes_str)
+
+      unless scopes.is_a?(Array)
+        Rage::OpenAPI.__log_warn "invalid `@auth_scope` tag detected at #{location_msg(comment)}; expected [scope1, scope2] syntax"
+        return
+      end
+
+      scopes = scopes.map(&:to_s)
+    else
+      Rage::OpenAPI.__log_warn "invalid `@auth_scope` tag detected at #{location_msg(comment)}; expected [scope1, scope2] syntax"
+      return
+    end
+
+    if scheme_name.nil?
+      auth_entries = node.auth
+      if auth_entries.empty?
+        Rage::OpenAPI.__log_warn "no auth schemes found for `@auth_scope` shorthand at #{location_msg(comment)}; define an @auth tag on the controller first"
+        return
+      elsif auth_entries.length > 1
+        Rage::OpenAPI.__log_warn "ambiguous `@auth_scope` shorthand at #{location_msg(comment)}; multiple auth schemes found, specify the scheme name explicitly"
+        return
+      end
+      scheme_name = auth_entries[0][:name]
+    else
+      auth_names = node.auth.map { |e| e[:name] }
+      unless auth_names.include?(scheme_name)
+        Rage::OpenAPI.__log_warn "unknown scheme `#{scheme_name}` in `@auth_scope` tag at #{location_msg(comment)}; available schemes: #{auth_names.join(", ")}"
+        return
+      end
+    end
+
+    if node.auth_scopes.key?(scheme_name)
+      Rage::OpenAPI.__log_warn "duplicate `@auth_scope` tag for `#{scheme_name}` detected at #{location_msg(comment)}"
+      return
+    end
+
+    node.auth_scopes[scheme_name] = scopes
+  end
+
   def parse_param_tag(expression, node, comment)
     param = expression[7..].strip
 

data/lib/rage/openapi/parsers/ext/alba.rb

@@ -3,8 +3,10 @@
 class Rage::OpenAPI::Parsers::Ext::Alba
   attr_reader :namespace
 
-  def initialize(namespace: Object, **)
+  def initialize(namespace: Object, root: Rage::OpenAPI::Nodes::Root.new, **)
     @namespace = namespace
+    @root = root
+    @parsing_stack = Set.new
   end
 
   def known_definition?(str)
@@ -15,10 +17,27 @@ class Rage::OpenAPI::Parsers::Ext::Alba
   end
 
   def parse(klass_str)
-    __parse(klass_str).build_schema
+    _, raw_klass_str = Rage::OpenAPI.__try_parse_collection(klass_str)
+    visitor = __parse(klass_str)
+
+    if @root.schema_registry.key?(raw_klass_str)
+      clean = { "type" => "object" }
+      clean["properties"] = visitor.schema if visitor.schema.any?
+      @root.schema_registry[raw_klass_str] = clean
+    end
+
+    visitor.build_schema
   end
 
   def __parse_nested(klass_str)
+    is_collection, raw_klass_str = Rage::OpenAPI.__try_parse_collection(klass_str)
+
+    if @parsing_stack.include?(raw_klass_str)
+      @root.schema_registry[raw_klass_str] ||= nil
+      ref = { "$ref" => "#/components/schemas/#{raw_klass_str}" }
+      return is_collection ? { "type" => "array", "items" => ref } : ref
+    end
+
     __parse(klass_str).tap { |visitor|
       visitor.root_key = visitor.root_key_for_collection = visitor.root_key_proc = visitor.key_transformer = nil
     }.build_schema
@@ -27,6 +46,13 @@ class Rage::OpenAPI::Parsers::Ext::Alba
   def __parse(klass_str)
     is_collection, klass_str = Rage::OpenAPI.__try_parse_collection(klass_str)
 
+    # return an empty visitor if we're already parsing this class;
+    # this serves as a recursion guard, specifically for the inheritance logic in `Visitor#visit_class_node`
+    if @parsing_stack.include?(klass_str)
+      return Visitor.new(self, is_collection)
+    end
+    @parsing_stack.add(klass_str)
+
     klass = @namespace.const_get(klass_str)
     source_path, _ = Object.const_source_location(klass.name)
     ast = Prism.parse_file(source_path)
@@ -34,6 +60,8 @@ class Rage::OpenAPI::Parsers::Ext::Alba
     visitor = Visitor.new(self, is_collection)
     ast.value.accept(visitor)
 
+    @parsing_stack.delete(klass_str)
+
     visitor
   end
 

data/lib/rage/openapi/parsers/request.rb

@@ -7,9 +7,9 @@ class Rage::OpenAPI::Parsers::Request
     Rage::OpenAPI::Parsers::Ext::ActiveRecord
   ]
 
-  def self.parse(request_tag, namespace:)
+  def self.parse(request_tag, namespace:, root:)
     parser = AVAILABLE_PARSERS.find do |parser_class|
-      parser = parser_class.new(namespace:)
+      parser = parser_class.new(namespace:, root:)
       break parser if parser.known_definition?(request_tag)
     end
 

data/lib/rage/openapi/parsers/response.rb

@@ -8,9 +8,9 @@ class Rage::OpenAPI::Parsers::Response
     Rage::OpenAPI::Parsers::YAML
   ]
 
-  def self.parse(response_tag, namespace:)
+  def self.parse(response_tag, namespace:, root:)
     parser = AVAILABLE_PARSERS.find do |parser_class|
-      parser = parser_class.new(namespace:)
+      parser = parser_class.new(namespace:, root:)
       break parser if parser.known_definition?(response_tag)
     end
 

data/lib/rage/openapi/parsers/yaml.rb

@@ -1,16 +1,20 @@
 # frozen_string_literal: true
 
 class Rage::OpenAPI::Parsers::YAML
+  # @private
+  class OptionalParam < String
+  end
+
   def initialize(**)
   end
 
   def known_definition?(yaml)
-    object = YAML.safe_load(yaml) rescue nil
+    object = process_yaml(yaml) rescue nil
     !!object && object.is_a?(Enumerable)
   end
 
   def parse(yaml)
-    __parse(YAML.safe_load(yaml))
+    __parse(process_yaml(yaml))
   end
 
   private
@@ -22,6 +26,8 @@ class Rage::OpenAPI::Parsers::YAML
       spec = { "type" => "object", "properties" => {} }
 
       object.each do |key, value|
+        key = OptionalParam.new(key[0...-1]) if key.end_with?("?")
+
         spec["properties"][key] = if value.is_a?(Enumerable)
           __parse(value)
         else
@@ -29,6 +35,8 @@ class Rage::OpenAPI::Parsers::YAML
         end
       end
 
+      spec["required"] = spec["properties"].keys.select { |k| !k.is_a?(OptionalParam) }
+
     elsif object.is_a?(Array) && object.length == 1
       spec = { "type" => "array", "items" => object[0].is_a?(Enumerable) ? __parse(object[0]) : type_to_spec(object[0]) }
 
@@ -39,9 +47,23 @@ class Rage::OpenAPI::Parsers::YAML
     spec
   end
 
-  private
-
   def type_to_spec(type)
-    Rage::OpenAPI.__type_to_spec(type) || { "type" => "string", "enum" => [type] }
+    is_collection, type_str = if type.is_a?(String)
+      Rage::OpenAPI.__try_parse_collection(type)
+    else
+      [false, type]
+    end
+
+    spec = Rage::OpenAPI.__type_to_spec(type_str) || { "type" => "string", "enum" => [type_str] }
+
+    if is_collection
+      { "type" => "array", "items" => spec }
+    else
+      spec
+    end
+  end
+
+  def process_yaml(str)
+    YAML.safe_load(str.gsub(/Array<([^>]+)>/, '[\1]'))
   end
 end

data/lib/rage/params_parser.rb

@@ -14,9 +14,9 @@ class Rage::ParamsParser
     end
 
     request_params = if content_type.start_with?("application/json")
-      json_parse(env["rack.input"].read)
+      json_parse(env["rack.input"].tap { |io| io.rewind }.read)
     elsif content_type.start_with?("application/x-www-form-urlencoded")
-      Iodine::Rack::Utils.parse_urlencoded_nested_query(env["rack.input"].read)
+      Iodine::Rack::Utils.parse_urlencoded_nested_query(env["rack.input"].tap { |io| io.rewind }.read)
     elsif content_type.start_with?("multipart/form-data")
       Iodine::Rack::Utils.parse_multipart(env["rack.input"], content_type)
     end

data/lib/rage/pubsub/adapters/redis.rb

@@ -40,7 +40,7 @@ class Rage::PubSub::Adapters::Redis
 
     @trimming_strategy = redis_version < Gem::Version.create("6.2.0") ? :maxlen : :minid
 
-    Rage::Internal.pick_a_worker do
+    Rage::Internal.pick_a_worker(purpose: "redis-pubsub") do
       puts("INFO: #{Process.pid} is managing Redis subscriptions.") if Rage.logger.info?
       poll
     end
@@ -136,6 +136,7 @@ class Rage::PubSub::Adapters::Redis
 
       rescue RedisClient::Error => e
         Rage.logger.error("Subscriber error: #{e.message} (#{e.class})")
+        Rage::Errors.report(e)
         sleep error_backoff_intervals.next
       rescue SystemCallError => e
         @stopping ? break : raise(e)

data/lib/rage/router/dsl.rb

@@ -62,6 +62,8 @@ class Rage::Router::DSL
       @router = router
 
       @default_actions = %i(index create show update destroy)
+      @default_actions += %i(new edit) if Rage.config.router.form_actions
+
       @default_match_methods = %i(get post put patch delete head)
       @scope_opts = %i(module path controller)
 
@@ -359,6 +361,8 @@ class Rage::Router::DSL
         get("/:#{_param}", to: "#{resource}#show") if actions.include?(:show)
         patch("/:#{_param}", to: "#{resource}#update") if actions.include?(:update)
         put("/:#{_param}", to: "#{resource}#update") if actions.include?(:update)
+        get("/new", to: "#{resource}#new") if actions.include?(:new)
+        get("/:#{_param}/edit", to: "#{resource}#edit") if actions.include?(:edit)
         delete("/:#{_param}", to: "#{resource}#destroy") if actions.include?(:destroy)
 
         scope(path: ":#{to_singular(resource)}_#{_param}", controller: resource, &block) if block
@@ -379,7 +383,6 @@ class Rage::Router::DSL
     #   # PATCH  /photo => photos#update
     #   # PUT    /photo => photos#update
     #   # DELETE /photo => photos#destroy
-    # @note This helper doesn't generate the `new` and `edit` routes.
     # @note :param is not supported for singular resources.
     def resource(*_resources, **opts, &block)
       if _resources.length > 1
@@ -389,7 +392,7 @@ class Rage::Router::DSL
 
       _module, _path, _only, _except = opts.values_at(:module, :path, :only, :except)
 
-      actions = __filter_actions(%i(create show update destroy), _only, _except)
+      actions = __filter_actions(@default_actions - [:index], _only, _except)
 
       resource_name = _resources[0].to_s
       controller_name = to_plural(resource_name)
@@ -398,6 +401,8 @@ class Rage::Router::DSL
         get("/", to: "#{controller_name}#show") if actions.include?(:show)
         patch("/", to: "#{controller_name}#update") if actions.include?(:update)
         put("/", to: "#{controller_name}#update") if actions.include?(:update)
+        get("/new", to: "#{controller_name}#new") if actions.include?(:new)
+        get("/edit", to: "#{controller_name}#edit") if actions.include?(:edit)
         delete("/", to: "#{controller_name}#destroy") if actions.include?(:destroy)
 
         scope(controller: controller_name, &block) if block

data/lib/rage/sse/application.rb

@@ -63,6 +63,7 @@ class Rage::SSE::Application
       end
     rescue => e
       Rage.logger.error("SSE stream failed with exception: #{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}")
+      Rage::Errors.report(e)
     ensure
       Iodine.task_dec!
     end

data/lib/rage/telemetry/tracer.rb

@@ -74,6 +74,7 @@ class Rage::Telemetry::Tracer
           #{calls_chain}
         rescue Exception => e
           Rage.logger.error("Telemetry handler failed with error \#{e}:\\n\#{e.backtrace.join("\\n")}")
+          Rage::Errors.report(e)
         end
 
         unless yield_called