rage-rb 1.19.1 → 1.20.0

data/lib/rage/deferred/middleware_chain.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class Rage::Deferred::MiddlewareChain
+  def initialize(enqueue_middleware:, perform_middleware:)
+    @enqueue_middleware = enqueue_middleware
+    @perform_middleware = perform_middleware
+
+    build_enqueue_chain!
+    build_perform_chain!
+  end
+
+  private
+
+  def build_enqueue_chain!
+    raw_arguments = {
+      phase: ":enqueue",
+      args: "Rage::Deferred::Context.get_or_create_args(context)",
+      kwargs: "Rage::Deferred::Context.get_or_create_kwargs(context)",
+      context: "Rage::Deferred::Context.get_or_create_user_context(context)",
+      task_class: "Rage::Deferred::Context.get_task(context)",
+      delay: "delay",
+      delay_until: "delay_until"
+    }
+
+    self.class.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+      def with_enqueue_middleware(context, delay:, delay_until:)
+        #{build_middleware_chain(:@enqueue_middleware, raw_arguments)}
+      end
+    RUBY
+  end
+
+  def build_perform_chain!
+    raw_arguments = {
+      phase: ":perform",
+      args: "Rage::Deferred::Context.get_or_create_args(context)",
+      kwargs: "Rage::Deferred::Context.get_or_create_kwargs(context)",
+      context: "Rage::Deferred::Context.get_or_create_user_context(context)",
+      task_class: "task.class",
+      task: "task"
+    }
+
+    self.class.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+      def with_perform_middleware(context, task:)
+        #{build_middleware_chain(:@perform_middleware, raw_arguments)}
+      end
+    RUBY
+  end
+
+  def build_middleware_chain(middlewares_var, raw_arguments)
+    middlewares = instance_variable_get(middlewares_var)
+    i = middlewares.length
+
+    middlewares.reverse.inject("yield") do |memo, middleware_with_args|
+      middleware, _, _ = middleware_with_args
+      arguments = Rage::Internal.build_arguments(middleware.instance_method(:call), raw_arguments)
+      i -= 1
+
+      <<~RUBY
+        middleware, args, block = #{middlewares_var}[#{i}]
+
+        middleware.new(*args, &block).call(#{arguments}) do
+          #{memo}
+        end
+      RUBY
+    end
+  end
+end

data/lib/rage/deferred/task.rb

@@ -37,29 +37,55 @@ module Rage::Deferred::Task
   BACKOFF_INTERVAL = 5
   private_constant :BACKOFF_INTERVAL
 
+  # @private
+  CONTEXT_KEY = :__rage_deferred_execution_context
+
   def perform
   end
 
+  # Access metadata for the current task execution.
+  # @return [Rage::Deferred::Metadata] the metadata object for the current task execution
+  # @example
+  #   class MyTask
+  #     include Rage::Deferred::Task
+  #
+  #     def perform
+  #       puts meta.retries
+  #     end
+  #   end
+  def meta
+    Rage::Deferred::Metadata
+  end
+
   # @private
   def __perform(context)
-    args = Rage::Deferred::Context.get_args(context)
-    kwargs = Rage::Deferred::Context.get_kwargs(context)
-    attempts = Rage::Deferred::Context.get_attempts(context)
-
     restore_log_info(context)
 
+    attempts = Rage::Deferred::Context.get_attempts(context)
     task_log_context = { task: self.class.name }
     task_log_context[:attempt] = attempts + 1 if attempts
 
-    Rage.logger.with_context(task_log_context) do
-      perform(*args, **kwargs)
-      true
-    rescue Rage::Deferred::TaskFailed
-      false
-    rescue Exception => e
-      Rage.logger.error("Deferred task failed with exception: #{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}")
-      false
+    Fiber[CONTEXT_KEY] = context
+
+    Rage::Telemetry.tracer.span_deferred_task_process(task: self, context:) do
+      Rage::Deferred.__middleware_chain.with_perform_middleware(context, task: self) do
+        Rage.logger.with_context(task_log_context) do
+          args = Rage::Deferred::Context.get_args(context)
+          kwargs = Rage::Deferred::Context.get_kwargs(context)
+
+          perform(*args, **kwargs)
+        end
+      end
     end
+
+    true
+  rescue Exception => 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")}")
+      end
+    end
+    false
   end
 
   private def restore_log_info(context)
@@ -80,11 +106,13 @@ module Rage::Deferred::Task
 
   module ClassMethods
     def enqueue(*args, delay: nil, delay_until: nil, **kwargs)
-      Rage::Deferred.__queue.enqueue(
-        Rage::Deferred::Context.build(self, args, kwargs),
-        delay:,
-        delay_until:
-      )
+      context = Rage::Deferred::Context.build(self, args, kwargs)
+
+      Rage::Telemetry.tracer.span_deferred_task_enqueue(task_class: self, context:) do
+        Rage::Deferred.__middleware_chain.with_enqueue_middleware(context, delay:, delay_until:) do
+          Rage::Deferred.__queue.enqueue(context, delay:, delay_until:)
+        end
+      end
 
       nil
     end

data/lib/rage/events/events.rb

@@ -39,7 +39,9 @@ module Rage::Events
   #   Rage::Events.publish(MyEvent.new, context: { published_at: Time.now })
   def self.publish(event, context: nil)
     handler = __event_handlers[event.class] || __build_event_handler(event.class)
-    handler.call(event, context)
+    Rage::Telemetry.tracer.span_events_event_publish(event:, context:) do
+      handler.call(event, context)
+    end
 
     nil
   end
@@ -71,8 +73,6 @@ module Rage::Events
   # @private
   def self.__build_event_handler(event_class)
     subscriber_calls = __get_subscribers(event_class).map do |subscriber_class|
-      subscriber_class.__register_rescue_handlers
-
       arguments = "event"
 
       context_type, _ = subscriber_class.instance_method(:call).parameters.find do |param_type, param_name|

data/lib/rage/events/subscriber.rb

@@ -79,16 +79,28 @@ module Rage::Events::Subscriber
 
   # @private
   def __call(event, context: nil)
-    Rage.logger.with_context(self.class.__log_context) do
-      context.nil? ? call(event) : call(event, context: context.freeze)
-    rescue Exception => _e
-      e = self.class.__rescue_handlers ? __run_rescue_handlers(_e) : _e
-
-      if e
-        Rage.logger.error("Subscriber failed with exception: #{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}")
-        raise Rage::Deferred::TaskFailed if self.class.__is_deferred
+    Rage::Telemetry.tracer.span_events_subscriber_process(event:, context:, subscriber: self) do
+      Rage.logger.with_context(self.class.__log_context) do
+        with_exception_handler do
+          context.nil? ? call(event) : call(event, context: context.freeze)
+        end
       end
     end
+  rescue Exception => e
+    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
+  end
+
+  private
+
+  def __deferred_suppress_exception_logging?
+    true
+  end
+
+  def with_exception_handler
+    yield
   end
 
   module ClassMethods
@@ -136,6 +148,14 @@ module Rage::Events::Subscriber
       end
 
       @__rescue_handlers.unshift([klasses, with])
+
+      rebuild_exception_handler!
+    end
+
+    # Check if the subscriber is executed in the background.
+    # @return [Boolean] `true` if the subscriber is deferred, `false` otherwise
+    def deferred?
+      @__is_deferred
     end
 
     # @private
@@ -144,29 +164,20 @@ module Rage::Events::Subscriber
       klass.subscribe_to(*@__event_classes, deferred: @__is_deferred) if @__event_classes
     end
 
-    # @private
-    def __register_rescue_handlers
-      return if method_defined?(:__run_rescue_handlers, false) || @__rescue_handlers.nil?
-
-      matcher_calls = @__rescue_handlers.map do |klasses, handler|
-        handler_call = instance_method(handler).arity == 0 ? handler : "#{handler}(exception)"
+    private
 
+    def rebuild_exception_handler!
+      rescue_calls = @__rescue_handlers.map do |klasses, handler|
         <<~RUBY
-          when #{klasses.join(", ")}
-            #{handler_call}
-            nil
+          rescue #{klasses.join(", ")} => e
+            method(:#{handler}).arity == 0 ? #{handler} : #{handler}(e)
         RUBY
       end
 
       class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def __run_rescue_handlers(exception)
-          case exception
-          #{matcher_calls.join("\n")}
-          else
-            exception
-          end
-        rescue Exception => e
-          e
+        private def with_exception_handler
+          yield
+          #{rescue_calls.join("\n")}
         end
       RUBY
     end

data/lib/rage/fiber.rb

@@ -158,43 +158,45 @@ class Fiber
     f, fibers = Fiber.current, Array(fibers)
     await_channel = f.__await_channel(true)
 
-    # check which fibers are alive (i.e. have yielded) and which have errored out
-    i, err, num_wait_for = 0, nil, 0
-    while i < fibers.length
-      if fibers[i].alive?
-        num_wait_for += 1
-      else
-        err = fibers[i].__get_err
-        break if err
+    Rage::Telemetry.tracer.span_core_fiber_await(fibers:) do
+      # check which fibers are alive (i.e. have yielded) and which have errored out
+      i, err, num_wait_for = 0, nil, 0
+      while i < fibers.length
+        if fibers[i].alive?
+          num_wait_for += 1
+        else
+          err = fibers[i].__get_err
+          break if err
+        end
+        i += 1
       end
-      i += 1
-    end
 
-    # raise if one of the fibers has errored out or return the result if none have yielded
-    if err
-      raise err
-    elsif num_wait_for == 0
-      return fibers.map!(&:__get_result)
-    end
+      # raise if one of the fibers has errored out or return the result if none have yielded
+      if err
+        raise err
+      elsif num_wait_for == 0
+        return fibers.map!(&:__get_result)
+      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
-      else
-        num_wait_for -= 1
-        f.resume if num_wait_for == 0
+      # 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
+        else
+          num_wait_for -= 1
+          f.resume if num_wait_for == 0
+        end
       end
-    end
 
-    Fiber.defer(-1)
-    Iodine.defer { Iodine.unsubscribe(await_channel) }
+      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
-      raise fibers.find(&:__get_err).__get_err
-    else
-      fibers.map!(&:__get_result)
+      # if num_wait_for is not 0 means we exited prematurely because of an error
+      if num_wait_for > 0
+        raise fibers.find(&:__get_err).__get_err
+      else
+        fibers.map!(&:__get_result)
+      end
     end
   end
 

data/lib/rage/fiber_scheduler.rb

@@ -120,7 +120,9 @@ class Rage::FiberScheduler
       # the fiber to wrap a request in
       Fiber.new(blocking: false) do
         Fiber.current.__set_id
-        Fiber.current.__set_result(block.call)
+        Rage::Telemetry.tracer.span_core_fiber_dispatch do
+          Fiber.current.__set_result(block.call)
+        end
       end
     else
       # the fiber was created in the user code
@@ -128,7 +130,9 @@ class Rage::FiberScheduler
 
       Fiber.new(blocking: false) do
         Thread.current[:rage_logger] = logger
-        Fiber.current.__set_result(block.call)
+        Rage::Telemetry.tracer.span_core_fiber_spawn(parent:) do
+          Fiber.current.__set_result(block.call)
+        end
         # send a message for `Fiber.await` to work
         Iodine.publish(parent.__await_channel, "", Iodine::PubSub::PROCESS) if parent.alive?
       rescue Exception => e

data/lib/rage/logger/logger.rb

@@ -209,7 +209,13 @@ class Rage::Logger
         RUBY
       elsif @external_logger.is_a?(External::Dynamic)
         # a callable object is used as a logger
-        parameters = Rage::Internal.build_arguments(@external_logger.wrapped, {
+        call_method = if @external_logger.wrapped.is_a?(Proc)
+          @external_logger.wrapped
+        else
+          @external_logger.wrapped.method(:call)
+        end
+
+        parameters = Rage::Internal.build_arguments(call_method, {
           severity: ":#{level_name}",
           tags: "logger[:tags].freeze",
           context: "logger[:context].freeze",

data/lib/rage/middleware/body_finalizer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Rage::BodyFinalizer
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    response = @app.call(env)
+    response[2].close
+
+    response
+  end
+end

data/lib/rage/middleware/cors.rb

@@ -14,20 +14,20 @@ class Rage::Cors
     end
 
     response = @app.call(env)
-    response[1]["Access-Control-Allow-Credentials"] = @allow_credentials if @allow_credentials
-    response[1]["Access-Control-Expose-Headers"] = @expose_headers if @expose_headers
+    response[1]["access-control-allow-credentials"] = @allow_credentials if @allow_credentials
+    response[1]["access-control-expose-headers"] = @expose_headers if @expose_headers
 
     response
   ensure
     if !$! && (origin = @cors_check.call(env))
       headers = response[1]
-      headers["Access-Control-Allow-Origin"] = origin
+      headers["access-control-allow-origin"] = origin
       if @origins != "*"
-        vary = headers["Vary"]
+        vary = headers["vary"]
         if vary.nil?
-          headers["Vary"] = "Origin"
+          headers["vary"] = "Origin"
         elsif vary != "Origin"
-          headers["Vary"] += ", Origin"
+          headers["vary"] += ", Origin"
         end
       end
     end
@@ -98,21 +98,21 @@ class Rage::Cors
 
   def create_headers
     headers = {
-      "Access-Control-Allow-Origin" => "",
-      "Access-Control-Allow-Methods" => @methods
+      "access-control-allow-origin" => "",
+      "access-control-allow-methods" => @methods
     }
 
     if @allow_headers
-      headers["Access-Control-Allow-Headers"] = @allow_headers
+      headers["access-control-allow-headers"] = @allow_headers
     end
     if @expose_headers
-      headers["Access-Control-Expose-Headers"] = @expose_headers
+      headers["access-control-expose-headers"] = @expose_headers
     end
     if @max_age
-      headers["Access-Control-Max-Age"] = @max_age
+      headers["access-control-max-age"] = @max_age
     end
     if @allow_credentials
-      headers["Access-Control-Allow-Credentials"] = @allow_credentials
+      headers["access-control-allow-credentials"] = @allow_credentials
     end
 
     headers

data/lib/rage/middleware/request_id.rb

@@ -24,7 +24,7 @@ class Rage::RequestId
   def call(env)
     env["rage.request_id"] = validate_external_request_id(env["HTTP_X_REQUEST_ID"])
     response = @app.call(env)
-    response[1]["X-Request-Id"] = env["rage.request_id"]
+    response[1]["x-request-id"] = env["rage.request_id"]
 
     response
   end

data/lib/rage/openapi/openapi.rb

@@ -48,13 +48,13 @@ module Rage::OpenAPI
         spec_url = "#{scheme}://#{host}#{path}/json"
         page = ERB.new(File.read("#{__dir__}/index.html.erb")).result(binding)
 
-        [200, { "Content-Type" => "text/html; charset=UTF-8" }, [page]]
+        [200, { "content-type" => "text/html; charset=UTF-8" }, [page]]
       end
     end
 
     json_app = ->(env) do
       spec = (__data_cache[[:spec, namespace]] ||= build(namespace:).to_json)
-      [200, { "Content-Type" => "application/json" }, [spec]]
+      [200, { "content-type" => "application/json" }, [spec]]
     end
 
     app = ->(env) do

data/lib/rage/response.rb

@@ -4,25 +4,30 @@ require "digest"
 require "time"
 
 class Rage::Response
-  ETAG_HEADER = "ETag"
-  LAST_MODIFIED_HEADER = "Last-Modified"
+  ETAG_HEADER = "etag"
+  LAST_MODIFIED_HEADER = "last-modified"
 
   # @private
-  def initialize(headers, body)
-    @headers = headers
-    @body = body
+  def initialize(controller)
+    @controller = controller
+  end
+
+  # Returns the HTTP status code of the response.
+  # @return [Integer]
+  def status
+    @controller.__status
   end
 
   # Returns the content of the response as a string. This contains the contents of any calls to `render`.
   # @return [String]
   def body
-    @body[0] || ""
+    @controller.__body[0] || ""
   end
 
   # Returns the headers for the response.
   # @return [Hash]
   def headers
-    @headers
+    @controller.__headers
   end
 
   # Returns ETag response header or +nil+ if it's empty.

data/lib/rage/rspec.rb

@@ -14,23 +14,6 @@ require_relative "#{Rage.root}/config/application"
 # verify the environment
 abort("The test suite is running in #{Rage.env} mode instead of 'test'!") unless Rage.env.test?
 
-# mock fiber methods as RSpec tests don't run concurrently
-class Fiber
-  def self.schedule(&block)
-    fiber = Fiber.new(blocking: true) do
-      Fiber.current.__set_id
-      Fiber.current.__set_result(block.call)
-    end
-    fiber.resume
-
-    fiber
-  end
-
-  def self.await(fibers)
-    Array(fibers).map(&:__get_result)
-  end
-end
-
 # define request helpers
 module RageRequestHelpers
   include Rack::Test::Methods
@@ -96,6 +79,23 @@ end
 # include request helpers
 RSpec.configure do |config|
   config.include(RageRequestHelpers, type: :request)
+
+  # mock fiber methods as RSpec tests don't run concurrently
+  config.before do
+    allow(Fiber).to receive(:schedule) do |&block|
+      fiber = Fiber.new(blocking: true) do
+        Fiber.current.__set_id
+        Fiber.current.__set_result(block.call)
+      end
+      fiber.resume
+
+      fiber
+    end
+
+    allow(Fiber).to receive(:await) do |fibers|
+      Array(fibers).map(&:__get_result)
+    end
+  end
 end
 
 # patch MockResponse class

data/lib/rage/setup.rb

@@ -14,9 +14,9 @@ require "rage/ext/setup"
 # Load application classes
 Rage.code_loader.setup
 
+require_relative "#{Rage.root}/config/routes"
+
 # Run after_initialize hooks
 Rage.config.run_after_initialize!
 
-require_relative "#{Rage.root}/config/routes"
-
 Rage.config.internal.initialized!