rage-rb 0.6.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0eed317e69386a2c2cc765df7be687be754934801390e96013902e78670171eb
-  data.tar.gz: 44c899c5843d112ca222df4b863852df9e3728a63954ee3b5ab4ffd2cffd4e2e
+  metadata.gz: 9bb19c01aee898bea43a41450feeb655f94bde8277a4f9c18cab6b9d1accbb47
+  data.tar.gz: fe4806d8a2bfbb71496a720371cc8416b5283c9b8284c1a72ec46384ee234348
 SHA512:
-  metadata.gz: 4e158fd8202e9c6e4f94a7b243383c34f2179306a10724978083b6599197197221915857540ae2beb5ea98a5f602c6507bec89d192a57706b3aae2203c75a8a3
-  data.tar.gz: e9723bb6a0ef7b1a67db08799e3429ae4c2e9f88894afb9e614645673df7cb4e019107f0ca1339eb521fa7958fd259ca032385f98fdbddacd59415d960f0c347
+  metadata.gz: 43d06881f297512724588c06637a29eefcb8308fc1c086a09b013c4291d4ca58cf7b2ab482b1c1276a3e4a88544a71e95289268cc896d479cb92135f31555bf8
+  data.tar.gz: 9af4f8816208451c18ff3b31d7d5a7e230561af93753d1ee0f8177f515b92f3dd2c47007b7f65be823ceeb69b6338683a05c57eb1a13e17cfe769b87e4ef2540

data/.yardopts

@@ -1 +1 @@
---exclude lib/rage/templates --markup markdown --no-private -o doc
+--exclude lib/rage/templates --exclude lib/rage/rspec --exclude lib/rage/rails --markup markdown --no-private -o doc

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 ## [Unreleased]
 
+## [1.0.0] - 2024-03-13
+
+### Added
+
+- RSpec integration (#60).
+- Add DNS cache (#65).
+- Allow to disable the `FiberScheduler#io_write` hook (#63).
+
+### Fixed
+
+- Preload fiber ID (#62).
+- Release ActiveRecord connections on yield (#66).
+- Logger fixes (#64).
+- Fix publish calls in cluster mode (#67).
+
+## [0.7.0] - 2024-01-09
+
+- Add conditional GET using `stale?` by [@tonekk](https://github.com/tonekk) (#55).
+- Add Rails integration (#57).
+- Add JSON log formatter (#59).
+
 ## [0.6.0] - 2023-12-22
 
 ### Added

data/README.md

@@ -143,17 +143,17 @@ end
 
 ## Upcoming releases
 
-Version | Changes
-------- |------------
-0.2 :white_check_mark: | ~~Gem configuration by env.<br>Add `skip_before_action`.<br>Add `rescue_from`.<br>Router updates:<br>&emsp;• make the `root` helper work correctly with `scope`;<br>&emsp;• support the `defaults` option;~~
-0.3 :white_check_mark: | ~~CLI updates:<br>&emsp;• `routes` task;<br>&emsp;• `console` task;<br>Support the `:if` and `:unless` options in `before_action`.<br>Allow to set response headers.~~
-0.4 :white_check_mark: | ~~Expose the `params` object.<br>Support header authentication with `authenticate_with_http_token`.<br>Router updates:<br>&emsp;• add the `resources` route helper;<br>&emsp;• add the `namespace` route helper;~~
-0.5 :white_check_mark:  | ~~Add request logging.~~
-0.6 | Automatic code reloading in development with Zeitwerk.
-0.7 | Expose the `send_data` and `send_file` methods.
-0.8 | Support conditional get with `etag` and `last_modified`.
-0.9 | Expose the `cookies` and `session` objects.
-1.0 | Implement Iodine-based equivalent of Action Cable.
+Status | Changes
+-- | ------------
+:white_check_mark: | ~~Gem configuration by env.<br>Add `skip_before_action`.<br>Add `rescue_from`.<br>Router updates:<br>&emsp;• make the `root` helper work correctly with `scope`;<br>&emsp;• support the `defaults` option;~~
+:white_check_mark: | ~~CLI updates:<br>&emsp;• `routes` task;<br>&emsp;• `console` task;<br>Support the `:if` and `:unless` options in `before_action`.<br>Allow to set response headers.~~
+:white_check_mark: | ~~Expose the `params` object.<br>Support header authentication with `authenticate_with_http_token`.<br>Router updates:<br>&emsp;• add the `resources` route helper;<br>&emsp;• add the `namespace` route helper;~~
+:white_check_mark:  | ~~Add request logging.~~
+:white_check_mark: | ~~Automatic code reloading in development with Zeitwerk.~~
+:white_check_mark: | ~~Support conditional get with `etag` and `last_modified`.~~
+⏳ | Expose the `send_data` and `send_file` methods.
+⏳ | Expose the `cookies` and `session` objects.
+⏳ | Implement Iodine-based equivalent of Action Cable.
 
 ## Development
 

data/lib/rage/all.rb

@@ -6,6 +6,7 @@ require_relative "fiber"
 require_relative "fiber_scheduler"
 require_relative "configuration"
 require_relative "request"
+require_relative "response"
 require_relative "uploaded_file"
 require_relative "errors"
 require_relative "params_parser"
@@ -21,6 +22,7 @@ require_relative "router/node"
 require_relative "controller/api"
 
 require_relative "logger/text_formatter"
+require_relative "logger/json_formatter"
 require_relative "logger/logger"
 
 require_relative "middleware/fiber_wrapper"

data/lib/rage/application.rb

@@ -3,6 +3,7 @@
 class Rage::Application
   def initialize(router)
     @router = router
+    @exception_app = build_exception_app
   end
 
   def call(env)
@@ -17,10 +18,11 @@ class Rage::Application
       [404, {}, ["Not Found"]]
     end
 
+  rescue Rage::Errors::BadRequest => e
+    response = @exception_app.call(400, e)
+
   rescue Exception => e
-    exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
-    Rage.logger.error(exception_str)
-    response = [500, {}, [exception_str]]
+    response = @exception_app.call(500, e)
 
   ensure
     finalize_logger(env, response, params)
@@ -50,4 +52,20 @@ class Rage::Application
     Rage.logger.info("")
     logger[:final] = nil
   end
+
+  def build_exception_app
+    if Rage.env.development?
+      ->(status, e) do
+        exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
+        Rage.logger.error(exception_str)
+        [status, {}, [exception_str]]
+      end
+    else
+      ->(status, e) do
+        exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
+        Rage.logger.error(exception_str)
+        [status, {}, []]
+      end
+    end
+  end
 end

data/lib/rage/cli.rb

@@ -18,13 +18,14 @@ module Rage
     option :port, aliases: "-p", desc: "Runs Rage on the specified port - defaults to 3000."
     option :environment, aliases: "-e", desc: "Specifies the environment to run this server under (test/development/production)."
     option :binding, aliases: "-b", desc: "Binds Rails to the specified IP - defaults to 'localhost' in development and '0.0.0.0' in other environments."
+    option :config, aliases: "-c", desc: "Uses a custom rack configuration."
     option :help, aliases: "-h", desc: "Show this message."
     def server
       return help("server") if options.help?
 
       set_env(options)
 
-      app = ::Rack::Builder.parse_file("config.ru")
+      app = ::Rack::Builder.parse_file(options[:config] || "config.ru")
       app = app[0] if app.is_a?(Array)
 
       port = options[:port] || Rage.config.server.port
@@ -114,6 +115,12 @@ module Rage
 
     def environment
       require File.expand_path("config/application.rb", Dir.pwd)
+
+      # in Rails mode we delegate code loading to Rails, and thus need
+      # to manually load application code for CLI utilities to work
+      if Rage.config.internal.rails_mode
+        require "rage/setup"
+      end
     end
 
     def set_env(options)

data/lib/rage/code_loader.rb

@@ -4,11 +4,12 @@ require "zeitwerk"
 
 class Rage::CodeLoader
   def initialize
-    @loader = Zeitwerk::Loader.new
     @reloading = false
   end
 
   def setup
+    @loader = Zeitwerk::Loader.new
+
     autoload_path = "#{Rage.root}/app"
     enable_reloading = Rage.env.development?
     enable_eager_loading = !Rage.env.development? && !Rage.env.test?
@@ -23,13 +24,24 @@ class Rage::CodeLoader
     @loader.eager_load if enable_eager_loading
   end
 
+  # in standalone mode - reload the code and the routes
   def reload
+    return unless @loader
+
     @reloading = true
     @loader.reload
     Rage.__router.reset_routes
     load("#{Rage.root}/config/routes.rb")
   end
 
+  # in Rails mode - reset the routes; everything else will be done by Rails
+  def rails_mode_reload
+    return if @loader
+
+    @reloading = true
+    Rage.__router.reset_routes
+  end
+
   def reloading?
     @reloading
   end

data/lib/rage/configuration.rb

@@ -109,6 +109,10 @@ class Rage::Configuration
     @middleware ||= Middleware.new
   end
 
+  def internal
+    @internal ||= Internal.new
+  end
+
   class Server
     attr_accessor :port, :workers_count, :timeout, :max_clients
     attr_reader :threads_count
@@ -160,6 +164,15 @@ class Rage::Configuration
     end
   end
 
+  # @private
+  class Internal
+    attr_accessor :rails_mode, :rails_console
+
+    def inspect
+      "#<#{self.class.name}>"
+    end
+  end
+
   # @private
   def __finalize
     if @logger

data/lib/rage/controller/api.rb

@@ -75,8 +75,16 @@ class RageController::API
         ""
       end
 
+      activerecord_loaded = Rage.config.internal.rails_mode && defined?(::ActiveRecord)
+
       class_eval <<~RUBY,  __FILE__, __LINE__ + 1
         def __run_#{action}
+          #{if activerecord_loaded
+            <<~RUBY
+              ActiveRecord::Base.connection_pool.enable_query_cache!
+            RUBY
+          end}
+
           #{before_actions_chunk}
           #{action}
 
@@ -90,6 +98,24 @@ class RageController::API
           [@__status, @__headers, @__body]
 
           #{rescue_handlers_chunk}
+
+        ensure
+          #{if activerecord_loaded
+            <<~RUBY
+              ActiveRecord::Base.connection_pool.disable_query_cache!
+              if ActiveRecord::Base.connection_pool.active_connection?
+                ActiveRecord::Base.connection_handler.clear_active_connections!
+              end
+            RUBY
+          end}
+
+          #{if method_defined?(:append_info_to_payload) || private_method_defined?(:append_info_to_payload)
+            <<~RUBY
+              context = {}
+              append_info_to_payload(context)
+              Thread.current[:rage_logger][:context] = context
+            RUBY
+          end}
         end
       RUBY
     end
@@ -196,6 +222,16 @@ class RageController::API
       end
     end
 
+    # Register a new `after_action` hook. Calls with the same `action_name` will overwrite the previous ones.
+    #
+    # @param action_name [String, nil] the name of the callback to add
+    # @param [Hash] opts action options
+    # @option opts [Symbol, Array<Symbol>] :only restrict the callback to run only for specific actions
+    # @option opts [Symbol, Array<Symbol>] :except restrict the callback to run for all actions except specified
+    # @option opts [Symbol, Proc] :if only run the callback if the condition is true
+    # @option opts [Symbol, Proc] :unless only run the callback if the condition is false
+    # @example
+    #   after_action :log_detailed_metrics, only: :create
     def after_action(action_name = nil, **opts, &block)
       action = prepare_action_params(action_name, **opts, &block)
 
@@ -268,22 +304,26 @@ class RageController::API
     end
   end # class << self
 
-  # @private
-  DEFAULT_HEADERS = { "content-type" => "application/json; charset=utf-8" }.freeze
-
   # @private
   def initialize(env, params)
     @__env = env
     @__params = params
-    @__status, @__headers, @__body = 204, DEFAULT_HEADERS, []
+    @__status, @__headers, @__body = 204, { "content-type" => "application/json; charset=utf-8" }, []
     @__rendered = false
   end
 
   # Get the request object. See {Rage::Request}.
+  # @return [Rage::Request]
   def request
     @request ||= Rage::Request.new(@__env)
   end
 
+  # Get the response object. See {Rage::Response}.
+  # @return [Rage::Response]
+  def response
+    @response ||= Rage::Response.new(@__headers, @__body)
+  end
+
   # Send a response to the client.
   #
   # @param json [String, Object] send a json response to the client; objects like arrays will be serialized automatically
@@ -339,11 +379,10 @@ class RageController::API
 
   # Set response headers.
   #
+  # @return [Hash]
   # @example
   #   headers["Content-Type"] = "application/pdf"
   def headers
-    # copy-on-write implementation for the headers object
-    @__headers = {}.merge!(@__headers) if DEFAULT_HEADERS.equal?(@__headers)
     @__headers
   end
 
@@ -357,11 +396,24 @@ class RageController::API
   def authenticate_with_http_token
     auth_header = @__env["HTTP_AUTHORIZATION"]
 
-    if auth_header&.start_with?("Bearer")
-      yield auth_header[7..]
+    payload = if auth_header&.start_with?("Bearer")
+      auth_header[7..]
     elsif auth_header&.start_with?("Token")
-      yield auth_header[6..]
+      auth_header[6..]
     end
+
+    return unless payload
+
+    token = if payload.start_with?("token=")
+      payload[6..]
+    else
+      payload
+    end
+
+    token.delete_prefix!('"')
+    token.delete_suffix!('"')
+
+    yield token
   end
 
   if !defined?(::ActionController::Parameters)
@@ -389,4 +441,40 @@ class RageController::API
       @params ||= ActionController::Parameters.new(@__params)
     end
   end
+
+  # Checks if the request is stale to decide if the action has to be rendered or the cached version is still valid. Use this method to implement conditional GET.
+  #
+  # @param etag [String] The etag of the requested resource.
+  # @param last_modified [Time] The last modified time of the requested resource.
+  # @return [Boolean] True if the response is stale, false otherwise.
+  # @example
+  #  stale?(etag: "123", last_modified: Time.utc(2023, 12, 15))
+  #  stale?(last_modified: Time.utc(2023, 12, 15))
+  #  stale?(etag: "123")
+  # @note `stale?` will set the response status to 304 if the request is fresh. This side effect will cause a double render error, if `render` gets called after this method. Make sure to implement a proper conditional in your action to prevent this from happening:
+  #  ```ruby
+  #  if stale?(etag: "123")
+  #    render json: { hello: "world" }
+  #  end
+  #  ```
+  def stale?(etag: nil, last_modified: nil)
+    still_fresh = request.fresh?(etag:, last_modified:)
+
+    head :not_modified if still_fresh
+    !still_fresh
+  end
+
+  # @private
+  # for comatibility with `Rails.application.routes.recognize_path`
+  def self.binary_params_for?(_)
+    false
+  end
+
+  # @!method append_info_to_payload(payload)
+  #   Define this method to add more information to request logs.
+  #   @param [Hash] payload the payload to add additional information to
+  #   @example
+  #     def append_info_to_payload(payload)
+  #       payload[:response] = response.body
+  #     end
 end

data/lib/rage/fiber.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 class Fiber
+  # @private
   AWAIT_ERROR_MESSAGE = "err"
 
   # @private
@@ -23,14 +24,14 @@ class Fiber
     @__err
   end
 
-   # @private
-  def __get_id
-    @__rage_id ||= object_id.to_s
+  # @private
+  def __set_id
+    @__rage_id = object_id.to_s
   end
 
-  # @private
-  def __yielded?
-    !@__rage_id.nil?
+   # @private
+  def __get_id
+    @__rage_id
   end
 
   # @private
@@ -49,6 +50,13 @@ class Fiber
     Fiber.yield
   end
 
+  # @private
+  # under normal circumstances, the method is a copy of `yield`, but it can be overriden to perform
+  # additional steps on yielding, e.g. releasing AR connections; see "lib/rage/rails.rb"
+  class << self
+    alias_method :defer, :yield
+  end
+
   # Wait on several fibers at the same time. Calling this method will automatically pause the current fiber, allowing the
   #   server to process other requests. Once all fibers have completed, the current fiber will be automatically resumed.
   #

data/lib/rage/fiber_scheduler.rb

@@ -7,13 +7,14 @@ class Rage::FiberScheduler
 
   def initialize
     @root_fiber = Fiber.current
+    @dns_cache = {}
   end
 
   def io_wait(io, events, timeout = nil)
     f = Fiber.current
     ::Iodine::Scheduler.attach(io.fileno, events, timeout&.ceil || 0) { |err| f.resume(err) }
 
-    err = Fiber.yield
+    err = Fiber.defer
     if err == Errno::ETIMEDOUT::Errno
       0
     else
@@ -49,13 +50,15 @@ class Rage::FiberScheduler
     end
   end
 
-  def io_write(io, buffer, length, offset = 0)
-    bytes_to_write = length
-    bytes_to_write = buffer.size if length == 0
+  unless ENV["RAGE_DISABLE_IO_WRITE"]
+    def io_write(io, buffer, length, offset = 0)
+      bytes_to_write = length
+      bytes_to_write = buffer.size if length == 0
 
-    ::Iodine::Scheduler.write(io.fileno, buffer.get_string, bytes_to_write, offset)
+      ::Iodine::Scheduler.write(io.fileno, buffer.get_string, bytes_to_write, offset)
 
-    bytes_to_write - offset
+      bytes_to_write - offset
+    end
   end
 
   def kernel_sleep(duration = nil)
@@ -77,7 +80,13 @@ class Rage::FiberScheduler
   # end
 
   def address_resolve(hostname)
-    Resolv.getaddresses(hostname)
+    @dns_cache[hostname] ||= begin
+      ::Iodine.run_after(60_000) do
+        @dns_cache[hostname] = nil
+      end
+
+      Resolv.getaddresses(hostname)
+    end
   end
 
   def block(_blocker, timeout = nil)
@@ -100,7 +109,7 @@ class Rage::FiberScheduler
   end
 
   def unblock(_blocker, fiber)
-    ::Iodine.publish(fiber.__block_channel, "")
+    ::Iodine.publish(fiber.__block_channel, "", Iodine::PubSub::PROCESS)
   end
 
   def fiber(&block)
@@ -109,6 +118,7 @@ class Rage::FiberScheduler
     fiber = if parent == @root_fiber
       # the fiber to wrap a request in
       Fiber.new(blocking: false) do
+        Fiber.current.__set_id
         Fiber.current.__set_result(block.call)
       end
     else
@@ -119,10 +129,10 @@ class Rage::FiberScheduler
         Thread.current[:rage_logger] = logger
         Fiber.current.__set_result(block.call)
         # send a message for `Fiber.await` to work
-        Iodine.publish("await:#{parent.object_id}", "") if parent.alive?
+        Iodine.publish("await:#{parent.object_id}", "", Iodine::PubSub::PROCESS) if parent.alive?
       rescue Exception => e
         Fiber.current.__set_err(e)
-        Iodine.publish("await:#{parent.object_id}", Fiber::AWAIT_ERROR_MESSAGE) if parent.alive?
+        Iodine.publish("await:#{parent.object_id}", Fiber::AWAIT_ERROR_MESSAGE, Iodine::PubSub::PROCESS) if parent.alive?
       end
     end
 

data/lib/rage/logger/json_formatter.rb

@@ -0,0 +1,46 @@
+class Rage::JSONFormatter
+  def initialize
+    @pid = Process.pid.to_s
+    Iodine.on_state(:on_start) do
+      @pid = Process.pid.to_s
+    end
+  end
+
+  def call(severity, timestamp, _, message)
+    logger = Thread.current[:rage_logger] || { tags: [], context: {} }
+    tags, context = logger[:tags], logger[:context]
+
+    if !context.empty?
+      context_msg = ""
+      context.each { |k, v| context_msg << "\"#{k}\":#{v.to_json}," }
+    end
+
+    if final = logger[:final]
+      params, env = final[:params], final[:env]
+      if params
+        return "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"info\",\"method\":\"#{env["REQUEST_METHOD"]}\",\"path\":\"#{env["PATH_INFO"]}\",\"controller\":\"#{params[:controller]}\",\"action\":\"#{params[:action]}\",#{context_msg}\"status\":#{final[:response][0]},\"duration\":#{final[:duration]}}\n"
+      else
+        # no controller/action keys are written if there are no params
+        return "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"info\",\"method\":\"#{env["REQUEST_METHOD"]}\",\"path\":\"#{env["PATH_INFO"]}\",#{context_msg}\"status\":#{final[:response][0]},\"duration\":#{final[:duration]}}\n"
+      end
+    end
+
+    if tags.length == 1
+      tags_msg = "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
+    elsif tags.length == 2
+      tags_msg = "{\"tags\":[\"#{tags[0]}\",\"#{tags[1]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
+    elsif tags.length == 0
+      tags_msg = "{\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
+    else
+      tags_msg = "{\"tags\":[\"#{tags[0]}\",\"#{tags[1]}\""
+      i = 2
+      while i < tags.length
+        tags_msg << ",\"#{tags[i]}\""
+        i += 1
+      end
+      tags_msg << "],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
+    end
+
+    "#{tags_msg},#{context_msg}\"message\":\"#{message}\"}\n"
+  end
+end

data/lib/rage/logger/logger.rb

@@ -83,7 +83,7 @@ class Rage::Logger
   #     Rage.logger.info "cache miss"
   #   end
   def with_context(context)
-    old_context = Thread.current[:rage_logger][:context]
+    old_context = (Thread.current[:rage_logger] ||= { tags: [], context: {} })[:context]
 
     if old_context.empty? # there's nothing in the context yet
       Thread.current[:rage_logger][:context] = context
@@ -92,8 +92,6 @@ class Rage::Logger
     end
 
     yield(self)
-    true
-
   ensure
     Thread.current[:rage_logger][:context] = old_context
   end
@@ -106,17 +104,20 @@ class Rage::Logger
   #     Rage.logger.info "success"
   #   end
   def tagged(tag)
-    Thread.current[:rage_logger][:tags] << tag
-
+    (Thread.current[:rage_logger] ||= { tags: [], context: {} })[:tags] << tag
     yield(self)
-    true
-
   ensure
     Thread.current[:rage_logger][:tags].pop
   end
 
   alias_method :with_tag, :tagged
 
+  def debug? = @level <= Logger::DEBUG
+  def error? = @level <= Logger::ERROR
+  def fatal? = @level <= Logger::FATAL
+  def info? = @level <= Logger::INFO
+  def warn? = @level <= Logger::WARN
+
   private
 
   def define_log_methods
@@ -128,8 +129,8 @@ class Rage::Logger
             false
           end
         RUBY
-      elsif defined?(IRB)
-        # the call was made from IRB - don't use the formatter
+      elsif (Rage.config.internal.rails_mode ? Rage.config.internal.rails_console : defined?(IRB))
+        # the call was made from the console - don't use the formatter
         <<-RUBY
           def #{level_name}(msg = nil)
             @logdev.write((msg || yield) + "\n")

data/lib/rage/logger/text_formatter.rb

@@ -7,16 +7,21 @@ class Rage::TextFormatter
   end
 
   def call(severity, timestamp, _, message)
-    logger = Thread.current[:rage_logger]
-    tags = logger[:tags]
+    logger = Thread.current[:rage_logger] || { tags: [], context: {} }
+    tags, context = logger[:tags], logger[:context]
+
+    if !context.empty?
+      context_msg = ""
+      context.each { |k, v| context_msg << "#{k}=#{v} " }
+    end
 
     if final = logger[:final]
       params, env = final[:params], final[:env]
       if params
-        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} controller=#{params[:controller]} action=#{params[:action]} status=#{final[:response][0]} duration=#{final[:duration]}\n"
+        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} controller=#{params[:controller]} action=#{params[:action]} #{context_msg}status=#{final[:response][0]} duration=#{final[:duration]}\n"
       else
         # no controller/action keys are written if there are no params
-        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} status=#{final[:response][0]} duration=#{final[:duration]}\n"
+        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} #{context_msg}status=#{final[:response][0]} duration=#{final[:duration]}\n"
       end
     end
 
@@ -24,6 +29,8 @@ class Rage::TextFormatter
       tags_msg = "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=#{severity}"
     elsif tags.length == 2
       tags_msg = "[#{tags[0]}][#{tags[1]}] timestamp=#{timestamp} pid=#{@pid} level=#{severity}"
+    elsif tags.length == 0
+      tags_msg = "timestamp=#{timestamp} pid=#{@pid} level=#{severity}"
     else
       tags_msg = "[#{tags[0]}][#{tags[1]}]"
       i = 2
@@ -34,13 +41,6 @@ class Rage::TextFormatter
       tags_msg << " timestamp=#{timestamp} pid=#{@pid} level=#{severity}"
     end
 
-    context = logger[:context]
-
-    if !context.empty?
-      context_msg = ""
-      context.each { |k, v| context_msg << "#{k}=#{v} " }
-    end
-
     "#{tags_msg} #{context_msg}message=#{message}\n"
   end
 end

data/lib/rage/middleware/cors.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 class Rage::Cors
+  # @private
   def initialize(app, *, &)
     @app = app
     instance_eval(&)
   end
 
+  # @private
   def call(env)
     if env["REQUEST_METHOD"] == "OPTIONS"
       return (response = @cors_response)
@@ -17,7 +19,7 @@ class Rage::Cors
 
     response
   ensure
-    if origin = @cors_check.call(env)
+    if !$! && origin = @cors_check.call(env)
       headers = response[1]
       headers["Access-Control-Allow-Origin"] = origin
       if @origins != "*"

data/lib/rage/middleware/fiber_wrapper.rb

@@ -17,7 +17,7 @@ class Rage::FiberWrapper
       @app.call(env)
     ensure
       # notify Iodine the request can now be resumed
-      Iodine.publish(Fiber.current.__get_id, "", Iodine::PubSub::PROCESS) if Fiber.current.__yielded?
+      Iodine.publish(Fiber.current.__get_id, "", Iodine::PubSub::PROCESS)
     end
 
     # the fiber encountered blocking IO and yielded; instruct Iodine to pause the request

data/lib/rage/rails.rb

@@ -0,0 +1,77 @@
+if Gem::Version.new(Rails.version) < Gem::Version.new(6)
+  fail "Rage is only compatible with Rails 6+. Detected Rails version: #{Rails.version}."
+end
+
+# load the framework
+require "rage/all"
+
+# patch Rack
+Iodine.patch_rack
+
+# configure the framework
+Rage.config.internal.rails_mode = true
+
+# make sure log formatter is not used in console
+Rails.application.console do
+  Rage.config.internal.rails_console = true
+  Rage.logger.level = Rage.logger.level if Rage.logger # trigger redefining log methods
+end
+
+# patch ActiveRecord's connection pool
+if defined?(ActiveRecord)
+  Rails.configuration.after_initialize do
+    module ActiveRecord::ConnectionAdapters
+      class ConnectionPool
+        def connection_cache_key(_)
+          Fiber.current
+        end
+      end
+    end
+  end
+end
+
+# release ActiveRecord connections on yield
+if defined?(ActiveRecord)
+  class Fiber
+    def self.defer
+      res = Fiber.yield
+
+      if ActiveRecord::Base.connection_pool.active_connection?
+        ActiveRecord::Base.connection_handler.clear_active_connections!
+      end
+
+      res
+    end
+  end
+end
+
+# plug into Rails' Zeitwerk instance to reload the code
+Rails.autoloaders.main.on_setup do
+  if Iodine.running?
+    Rage.code_loader.rails_mode_reload
+  end
+end
+
+# patch `ActionDispatch::Reloader` to synchronize `reload!` calls
+Rails.configuration.after_initialize do
+  conditional_mutex = Module.new do
+    def call(env)
+      @mutex ||= Mutex.new
+      if Rails.application.reloader.check!
+        @mutex.synchronize { super }
+      else
+        super
+      end
+    end
+  end
+
+  ActionDispatch::Reloader.prepend(conditional_mutex)
+end
+
+# clone Rails logger
+Rails.configuration.after_initialize do
+  if Rails.logger && !Rage.logger
+    rails_logdev = Rails.logger.instance_variable_get(:@logdev)
+    Rage.config.logger = Rage::Logger.new(rails_logdev) if rails_logdev.is_a?(Logger::LogDevice)
+  end
+end

data/lib/rage/request.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "time"
+
 class Rage::Request
   # @private
   def initialize(env)
@@ -14,6 +16,55 @@ class Rage::Request
     @headers ||= Headers.new(@env)
   end
 
+  # Check if the request is fresh.
+  # @param etag [String] The etag of the requested resource.
+  # @param last_modified [Time] The last modified time of the requested resource.
+  # @return [Boolean] True if the request is fresh, false otherwise.
+  # @example
+  #  request.fresh?(etag: "123", last_modified: Time.utc(2023, 12, 15))
+  #  request.fresh?(last_modified: Time.utc(2023, 12, 15))
+  #  request.fresh?(etag: "123")
+  def fresh?(etag:, last_modified:)
+    # Always render response when no freshness information
+    # is provided in the request.
+    return false unless if_none_match || if_not_modified_since
+
+    etag_matches?(
+      requested_etags: if_none_match, response_etag: etag
+    ) && not_modified?(
+      request_not_modified_since: if_not_modified_since,
+      response_last_modified: last_modified
+    )
+  end
+
+  private
+
+  def if_none_match
+    headers["HTTP_IF_NONE_MATCH"]
+  end
+
+  def if_not_modified_since
+    headers["HTTP_IF_MODIFIED_SINCE"] ? Time.httpdate(headers["HTTP_IF_MODIFIED_SINCE"]) : nil
+  rescue ArgumentError
+    nil
+  end
+
+  def etag_matches?(requested_etags:, response_etag:)
+    requested_etags = requested_etags ? requested_etags.split(",").each(&:strip!) : []
+
+    return true if requested_etags.empty?
+    return false if response_etag.nil?
+
+    requested_etags.include?(response_etag) || requested_etags.include?("*")
+  end
+
+  def not_modified?(request_not_modified_since:, response_last_modified:)
+    return true if request_not_modified_since.nil?
+    return false if response_last_modified.nil?
+
+    request_not_modified_since >= response_last_modified
+  end
+
   # @private
   class Headers
     HTTP = "HTTP_"

data/lib/rage/response.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Rage::Response
+  # @private
+  def initialize(headers, body)
+    @headers = headers
+    @body = body
+  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]
+  end
+
+  # Returns the headers for the response.
+  # @return [Hash]
+  def headers
+    @headers
+  end
+end

data/lib/rage/router/dsl.rb

@@ -7,6 +7,8 @@ class Rage::Router::DSL
 
   def draw(&block)
     Handler.new(@router).instance_eval(&block)
+    # propagate route definitions to Rails for `rails routes` to work
+    Rails.application.routes.draw(&block) if Rage.config.internal.rails_mode
   end
 
   ##
@@ -283,7 +285,7 @@ class Rage::Router::DSL
       end
 
       _module, _path, _only, _except, _param = opts.values_at(:module, :path, :only, :except, :param)
-      raise ":param option can't contain colons" if _param&.include?(":")
+      raise ":param option can't contain colons" if _param.to_s.include?(":")
 
       _only = Array(_only) if _only
       _except = Array(_except) if _except

data/lib/rage/rspec.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "rack/test"
+require "json"
+
+# set up environment
+ENV["RAGE_ENV"] ||= ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "test"
+
+# load the app
+require "bundler/setup"
+require "rage"
+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(_)
+    # no-op
+  end
+end
+
+# define request helpers
+module RageRequestHelpers
+  include Rack::Test::Methods
+
+  alias_method :response, :last_response
+
+  APP = Rack::Builder.parse_file("#{Rage.root}/config.ru").yield_self do |app|
+    app.is_a?(Array) ? app[0] : app
+  end
+
+  def app
+    APP
+  end
+
+  %w(get options head).each do |method_name|
+    class_eval <<~RUBY, __FILE__, __LINE__ + 1
+      def #{method_name}(path, params: {}, headers: {})
+        request("#{method_name.upcase}", path, params: params, headers: headers)
+      end
+    RUBY
+  end
+
+  %w(post put patch delete).each do |method_name|
+    class_eval <<~RUBY, __FILE__, __LINE__ + 1
+      def #{method_name}(path, params: {}, headers: {}, as: nil)
+        if as == :json
+          params = params.to_json
+          headers["content-type"] = "application/json"
+        end
+
+        request("#{method_name.upcase}", path, params: params, headers: headers.merge("IODINE_HAS_BODY" => !params.empty?))
+      end
+    RUBY
+  end
+
+  def request(method, path, params: {}, headers: {})
+    if headers.any?
+      headers = headers.transform_keys do |k|
+        if k.downcase == "content-type"
+          "CONTENT_TYPE"
+        elsif k.downcase == "content-length"
+          "CONTENT_LENGTH"
+        elsif k.upcase == k
+          k
+        else
+          "HTTP_#{k.tr("-", "_").upcase! || k}"
+        end
+      end
+    end
+
+    custom_request(method, path, params, headers)
+  end
+
+  def host!(host)
+    @__host = host
+  end
+
+  def default_host
+    @__host || "example.org"
+  end
+end
+
+# include request helpers
+RSpec.configure do |config|
+  config.include(RageRequestHelpers, type: :request)
+end
+
+# patch MockResponse class
+class Rack::MockResponse
+  def parsed_body
+    if headers["content-type"].start_with?("application/json")
+      JSON.parse(body)
+    else
+      body
+    end
+  end
+
+  def code
+    status.to_s
+  end
+
+  alias_method :response_code, :status
+end
+
+# define http status matcher
+RSpec::Matchers.matcher :have_http_status do |expected|
+  codes = Rack::Utils::SYMBOL_TO_STATUS_CODE
+
+  failure_message do |response|
+    actual = response.status
+
+    if expected.is_a?(Integer)
+      "expected the response to have status code #{expected} but it was #{actual}"
+    elsif expected == :success
+      "expected the response to have a success status code (2xx) but it was #{actual}"
+    elsif expected == :error
+      "expected the response to have an error status code (5xx) but it was #{actual}"
+    elsif expected == :missing
+      "expected the response to have a missing status code (404) but it was #{actual}"
+    else
+      "expected the response to have status code :#{expected} (#{codes[expected]}) but it was :#{codes.key(actual)} (#{actual})"
+    end
+  end
+
+  failure_message_when_negated do |response|
+    actual = response.status
+
+    if expected.is_a?(Integer)
+      "expected the response not to have status code #{expected} but it was #{actual}"
+    elsif expected == :success
+      "expected the response not to have a success status code (2xx) but it was #{actual}"
+    elsif expected == :error
+      "expected the response not to have an error status code (5xx) but it was #{actual}"
+    elsif expected == :missing
+      "expected the response not to have a missing status code (404) but it was #{actual}"
+    else
+      "expected the response not to have status code :#{expected} (#{codes[expected]}) but it was :#{codes.key(actual)} (#{actual})"
+    end
+  end
+
+  match do |response|
+    actual = response.status
+
+    case expected
+    when :success
+      actual >= 200 && actual < 300
+    when :error
+      actual >= 500
+    when :missing
+      actual == 404
+    when Symbol
+      actual == codes.fetch(expected)
+    else
+      actual == expected
+    end
+  end
+end
+
+if defined? RSpec::Rails::Matchers
+  module RSpec::Rails::Matchers
+    def have_http_status(_)
+      super
+    end
+  end
+end

data/lib/rage/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rage
-  VERSION = "0.6.0"
+  VERSION = "1.0.0"
 end

data/lib/rage-rb.rb

@@ -45,6 +45,24 @@ module Rage
 
   def self.load_middlewares(rack_builder)
     config.middleware.middlewares.each do |middleware, args, block|
+      # in Rails compatibility mode we first check if the middleware is a part of the Rails middleware stack;
+      # if it is - it is expected to be built using `ActionDispatch::MiddlewareStack::Middleware#build`, but Rack
+      # expects the middleware to respond to `#new`, so we wrap the middleware into a helper module
+      if Rage.config.internal.rails_mode
+        rails_middleware = Rails.application.config.middleware.middlewares.find { |m| m.name == middleware.name }
+        if rails_middleware
+          wrapper = Module.new do
+            extend self
+            attr_accessor :middleware
+            def new(app, *, &)
+              middleware.build(app)
+            end
+          end
+          wrapper.middleware = rails_middleware
+          middleware = wrapper
+        end
+      end
+
       rack_builder.use(middleware, *args, &block)
     end
   end

data/rage.gemspec

@@ -31,4 +31,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "rack", "~> 2.0"
   spec.add_dependency "rage-iodine", "~> 3.0"
   spec.add_dependency "zeitwerk", "~> 2.6"
+  spec.add_dependency "rack-test", "~> 2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rage-rb
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Roman Samoilov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-22 00:00:00.000000000 Z
+date: 2024-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
 description:
 email:
 - rsamoi@icloud.com
@@ -95,13 +109,16 @@ files:
 - lib/rage/errors.rb
 - lib/rage/fiber.rb
 - lib/rage/fiber_scheduler.rb
+- lib/rage/logger/json_formatter.rb
 - lib/rage/logger/logger.rb
 - lib/rage/logger/text_formatter.rb
 - lib/rage/middleware/cors.rb
 - lib/rage/middleware/fiber_wrapper.rb
 - lib/rage/middleware/reloader.rb
 - lib/rage/params_parser.rb
+- lib/rage/rails.rb
 - lib/rage/request.rb
+- lib/rage/response.rb
 - lib/rage/router/README.md
 - lib/rage/router/backend.rb
 - lib/rage/router/constrainer.rb
@@ -109,6 +126,7 @@ files:
 - lib/rage/router/handler_storage.rb
 - lib/rage/router/node.rb
 - lib/rage/router/strategies/host.rb
+- lib/rage/rspec.rb
 - lib/rage/setup.rb
 - lib/rage/sidekiq_session.rb
 - lib/rage/templates/Gemfile