rage-rb 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adfca83c806d24e4baf6e3c6401c7268e7e88495eaee9120da3a55fca08400b8
-  data.tar.gz: 7769fd22482975665a66741d0362ce5bf75318192bd6ee2850f98da952f5fe35
+  metadata.gz: 22f98c39badb0c2128b270ce3092d183f62db4bead34e8df627cf322a3697c71
+  data.tar.gz: ea49aeae3da7630f52e8c704bc042752a66b0fefc03a67d713ead33eec1fd006
 SHA512:
-  metadata.gz: 66667fbd047a4c27ebb840f4fc6fd2f60fb50d90b7f25b38048afeb5a92b1ad6f5310a4f0eacbab42b2d11a0c0de44ff4a131d197737abe13f1817a7b2267147
-  data.tar.gz: e75d8f5c615844fe837015ddaf7d2f9c4a96cdebc321ad63c79a3a1645924f2b3a7ef3fe75007243042a14bae18b001bd6cb0c919754719fb339ae42d0e90075
+  metadata.gz: e9e57e1eafda6e41112b8af0cc8d23eac629e0964b441622c48173f936f45aac95d0482b3545c5feb047dee755889c30ac63d0f63332e59d36cdff5cb1800198
+  data.tar.gz: 481b9e52062350a9923c3b0195aea555ca0b8cb0c95fa95e76d3e7cd45a27e21a817ad259aed6e1cf9d90c74c17e99b8398066e84deda7e422247a1ea59254b9

data/CHANGELOG.md

@@ -1,25 +1,44 @@
 ## [Unreleased]
 
+## [0.5.0] - 2023-11-25
+
+### Added
+
+- Add sessions for compatibility with `Sidekiq::Web` (#35).
+- Add logger (#33).
+
+### Fixed
+
+- Fixes for `FiberScheduler#io_wait` and `FiberScheduler#io_read` (#32).
+- Correctly handle exceptions in inner fibers (#34).
+- Fixes for `FiberScheduler#kernel_sleep` (#36).
+
+### Changed
+
+- Use config namespaces (#25).
+- Update `Fiber.await` signature (#36).
+
 ## [0.4.0] - 2023-10-31
 
 ### Added
 
-- Expose the `params` object.
-- Support header authentication with `authenticate_with_http_token`.
-- Add the `resources` and `namespace` route helpers.
-- Add the `mount` and `match` route helpers.
-- Allow to access request headers.
+- Expose the `params` object (#23).
+- Support header authentication with `authenticate_with_http_token` (#21).
+- Add the `resources` route helper (#20).
+- Add the `namespace` route helper by [@arikarim](https://github.com/arikarim) (#17).
+- Add the `mount` and `match` route helpers by [@arikarim](https://github.com/arikarim) (#18) (#14).
+- Allow to access request headers by [@arikarim](https://github.com/arikarim) (#15).
 - Support custom ports when starting the app with `rage s`.
 
 ## [0.3.0] - 2023-10-08
 
 ### Added
 
-- CLI `routes` task.
-- CLI `console` task.
-- `:if` and `:unless` options in `before_action`.
-- Allow to set response headers.
-- Block version of `before_action`.
+- CLI `routes` task by [@arikarim](https://github.com/arikarim) (#9).
+- CLI `console` task (#12).
+- `:if` and `:unless` options in `before_action` (#10).
+- Allow to set response headers (#11).
+- Block version of `before_action` by [@heysyam99](https://github.com/heysyam99) (#8).
 
 ## [0.2.0] - 2023-09-27
 

data/Gemfile

@@ -8,7 +8,9 @@ gemspec
 gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
+gem "http"
 gem "yard"
 
 gem "pg"
 gem "mysql2"
+gem "connection_pool", "~> 2.0"

data/README.md

@@ -49,6 +49,7 @@ Check out in-depth API docs for more information:
 - [Controller API](https://rage-rb.pages.dev/RageController/API)
 - [Routing API](https://rage-rb.pages.dev/Rage/Router/DSL/Handler)
 - [Fiber API](https://rage-rb.pages.dev/Fiber)
+- [Logger API](https://rage-rb.pages.dev/Rage/Logger)
 
 Also, see the [changelog](https://github.com/rage-rb/rage/blob/master/CHANGELOG.md) and [upcoming-releases](https://github.com/rage-rb/rage#upcoming-releases) for currently supported and planned features.
 
@@ -98,10 +99,10 @@ require "net/http"
 
 class PagesController < RageController::API
   def index
-    pages = Fiber.await(
+    pages = Fiber.await([
       Fiber.schedule { Net::HTTP.get(URI("https://httpbin.org/json")) },
       Fiber.schedule { Net::HTTP.get(URI("https://httpbin.org/html")) },
-    )
+    ])
 
     render json: { pages: pages }
   end
@@ -143,12 +144,13 @@ 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;<br>~~&emsp;• support regexp constraints (postponed)
-0.5 | Implement Iodine-based equivalent of `ActionController::Live`.<br>Use `ActionDispatch::RemoteIp`.
-0.6 | Expose the `cookies` object.<br>Expose the `send_data` and `send_file` methods.<br>Support conditional get with `etag` and `last_modified`.
-0.7 | Add request logging.
-0.8 | Collect app metrics.
-0.9 | Automatic code reloading in development.
+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.
 
 ## Development
 

data/lib/rage/all.rb

@@ -18,3 +18,10 @@ require_relative "router/handler_storage"
 require_relative "router/node"
 
 require_relative "controller/api"
+
+require_relative "logger/text_formatter"
+require_relative "logger/logger"
+
+if defined?(Sidekiq)
+  require_relative "sidekiq_session"
+end

data/lib/rage/application.rb

@@ -10,21 +10,25 @@ class Rage::Application
 
   def call(env)
     fiber = Fiber.schedule do
+      init_logger
+
       handler = @router.lookup(env)
 
-      if handler
+      response = if handler
         params = Rage::ParamsParser.prepare(env, handler[:params])
         handler[:handler].call(env, params)
       else
         [404, {}, ["Not Found"]]
       end
 
-    rescue => e
-      [500, {}, ["#{e.class}:#{e.message}\n\n#{e.backtrace.join("\n")}"]]
+    rescue Exception => e
+      exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
+      Rage.logger.error(exception_str)
+      response = [500, {}, [exception_str]]
 
     ensure
-      # notify Iodine the request can now be served
-      Iodine.publish(env["IODINE_REQUEST_ID"], "")
+      finalize_logger(env, response, params)
+      Iodine.publish(env["IODINE_REQUEST_ID"], "") # notify Iodine the request can now be served
     end
 
     # the fiber encountered blocking IO and yielded; instruct Iodine to pause the request;
@@ -34,4 +38,28 @@ class Rage::Application
       fiber.__get_result
     end
   end
+
+  private
+
+  DEFAULT_LOG_CONTEXT = {}.freeze
+  private_constant :DEFAULT_LOG_CONTEXT
+
+  def init_logger
+    Thread.current[:rage_logger] = {
+      tags: [Iodine::Rack::Utils.gen_request_tag],
+      context: DEFAULT_LOG_CONTEXT,
+      request_start: Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    }
+  end
+
+  def finalize_logger(env, response, params)
+    logger = Thread.current[:rage_logger]
+
+    duration = (
+      (Process.clock_gettime(Process::CLOCK_MONOTONIC) - logger[:request_start]) * 1000
+    ).round(2)
+
+    logger[:final] = { env:, params:, response:, duration: }
+    Rage.logger.info("")
+  end
 end

data/lib/rage/cli.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 require "thor"
-require "rage/all"
-require "irb"
+require "rack"
 
 module Rage
   class CLI < Thor
@@ -11,6 +10,7 @@ module Rage
 
     desc "new PATH", "Create a new application."
     def new(path)
+      require "rage/all"
       NewAppGenerator.start([path])
     end
 
@@ -20,9 +20,9 @@ module Rage
       app = ::Rack::Builder.parse_file("config.ru")
       app = app[0] if app.is_a?(Array)
 
-      ::Iodine.listen service: :http, handler: app, port: options[:port] || Rage.config.port
-      ::Iodine.threads = Rage.config.threads_count
-      ::Iodine.workers = Rage.config.workers_count
+      ::Iodine.listen service: :http, handler: app, port: options[:port] || Rage.config.server.port
+      ::Iodine.threads = Rage.config.server.threads_count
+      ::Iodine.workers = Rage.config.server.workers_count
 
       ::Iodine.start
     end
@@ -39,14 +39,20 @@ module Rage
 
       routes = Rage.__router.routes
       pattern = options[:grep]
-      routes.unshift({ method: "Verb", path: "Path", raw_handler: "Controller#Action" })
+      routes.unshift({ method: "Verb", path: "Path", meta: { raw_handler: "Controller#Action" } })
 
       grouped_routes = routes.each_with_object({}) do |route, memo|
         if pattern && !memo.empty?
-          next unless route[:path].match?(pattern) || route[:raw_handler].to_s.match?(pattern) || route[:method].match?(pattern)
+          next unless route[:path].match?(pattern) || route[:meta][:raw_handler].to_s.match?(pattern) || route[:method].match?(pattern)
+        end
+
+        key = [route[:path], route[:meta][:raw_handler]]
+
+        if route[:meta][:mount]
+          memo[key] = route.merge(method: "") unless route[:path].end_with?("*")
+          next
         end
 
-        key = [route[:path], route[:raw_handler]]
         if memo[key]
           memo[key][:method] += "|#{route[:method]}"
         else
@@ -68,7 +74,7 @@ module Rage
         meta = route[:constraints]
         meta.merge!(route[:defaults]) if route[:defaults]
 
-        handler = route[:raw_handler]
+        handler = route[:meta][:raw_handler]
         handler = "#{handler} #{meta}" unless meta&.empty?
 
         puts format("%-#{longest_method}s%-#{longest_path}s%s", route[:method], route[:path], handler)
@@ -78,6 +84,7 @@ module Rage
 
     desc "c", "Start the app console."
     def console
+      require "irb"
       environment
       ARGV.clear
       IRB.start

data/lib/rage/configuration.rb

@@ -1,10 +1,26 @@
 class Rage::Configuration
-  attr_accessor :port, :workers_count
-  attr_reader :threads_count
+  attr_accessor :logger, :log_formatter, :log_level
 
-  def initialize
-    @threads_count = 1
-    @workers_count = -1
-    @port = 3000
+  # used in DSL
+  def config = self
+
+  def server
+    @server ||= Server.new
+  end
+
+  class Server
+    attr_accessor :port, :workers_count
+    attr_reader :threads_count
+
+    def initialize
+      @threads_count = 1
+      @workers_count = -1
+      @port = 3000
+    end
+  end
+
+  def __finalize
+    @logger.formatter = @log_formatter if @logger && @log_formatter
+    @logger.level = @log_level if @logger && @log_level
   end
 end

data/lib/rage/controller/api.rb

@@ -50,7 +50,7 @@ class RageController::API
         ""
       end
 
-      class_eval <<-RUBY
+      class_eval <<-RUBY,  __FILE__, __LINE__ + 1
         def __run_#{action}
           #{before_actions_chunk}
           #{action}

data/lib/rage/fiber.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 class Fiber
+  AWAIT_ERROR_MESSAGE = "err"
+
   # @private
   def __set_result(result)
     @__result = result
@@ -9,30 +13,74 @@ class Fiber
     @__result
   end
 
+  # @private
+  def __set_err(err)
+    @__err = err
+  end
+
+  # @private
+  def __get_err
+    @__err
+  end
+
+  # @private
+  # pause a fiber and resume in the next iteration of the event loop
+  def self.pause
+    f = Fiber.current
+    Iodine.defer { f.resume }
+    Fiber.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.
   #
   # @param fibers [Fiber, Array<Fiber>] one or several fibers to wait on. The fibers must be created using the `Fiber.schedule` call.
   # @example
-  #   Fiber.await(
+  #   Fiber.await([
   #     Fiber.schedule { request_1 },
   #     Fiber.schedule { request_2 },
-  #   )
+  #   ])
   # @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 = Fiber.current
+  def self.await(fibers)
+    f, fibers = Fiber.current, Array(fibers)
 
-    num_wait_for = fibers.count(&:alive?)
-    return fibers.map(&:__get_result) if num_wait_for == 0
+    # 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
+
+    # 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
 
-    Iodine.subscribe("await:#{f.object_id}") do
-      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:#{f.object_id}") do |_, err|
+      if err == AWAIT_ERROR_MESSAGE
+        f.resume
+      else
+        num_wait_for -= 1
+        f.resume if num_wait_for == 0
+      end
     end
 
     Fiber.yield
     Iodine.defer { Iodine.unsubscribe("await:#{f.object_id}") }
 
-    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

@@ -3,41 +3,50 @@
 require "resolv"
 
 class Rage::FiberScheduler
+  MAX_READ = 65536
+
   def initialize
     @root_fiber = Fiber.current
   end
 
   def io_wait(io, events, timeout = nil)
     f = Fiber.current
-    ::Iodine::Scheduler.attach(io.fileno, events, timeout&.ceil || 0) { f.resume }
-    Fiber.yield
+    ::Iodine::Scheduler.attach(io.fileno, events, timeout&.ceil || 0) { |err| f.resume(err) }
 
-    events
+    err = Fiber.yield
+    if err == Errno::ETIMEDOUT::Errno
+      0
+    else
+      events
+    end
   end
 
-  # TODO: this is more synchronous than asynchronous right now
   def io_read(io, buffer, length, offset = 0)
-    loop do
-      string = ::Iodine::Scheduler.read(io.fileno, length, offset)
+    length_to_read = if length == 0
+      buffer.size > MAX_READ ? MAX_READ : buffer.size
+    else
+      length
+    end
+
+    while true
+      string = ::Iodine::Scheduler.read(io.fileno, length_to_read, offset)
 
       if string.nil?
         return offset
       end
 
       if string.empty?
-        io_wait(io, IO::READABLE)
-        next
+        return -Errno::EAGAIN::Errno
       end
 
       buffer.set_string(string, offset)
-      offset += string.bytesize
 
       size = string.bytesize
-      break if size >= length
-      length -= size
-    end
+      offset += size
+      return offset if size < length_to_read || size >= buffer.size
 
-    offset
+      Fiber.pause
+    end
   end
 
   def io_write(io, buffer, length, offset = 0)
@@ -46,15 +55,11 @@ class Rage::FiberScheduler
 
     ::Iodine::Scheduler.write(io.fileno, buffer.get_string, bytes_to_write, offset)
 
-    buffer.size - offset
+    bytes_to_write - offset
   end
 
   def kernel_sleep(duration = nil)
-    if duration
-      f = Fiber.current
-      ::Iodine.run_after((duration * 1000).to_i) { f.resume } 
-      Fiber.yield
-    end
+    block(nil, duration || 0)
   end
 
   # TODO: GC works a little strange with this closure;
@@ -75,13 +80,22 @@ class Rage::FiberScheduler
     Resolv.getaddresses(hostname)
   end
 
-  def block(blocker, timeout = nil)
-    f = Fiber.current
-    ::Iodine.subscribe("unblock:#{f.object_id}") do
-      ::Iodine.defer { ::Iodine.unsubscribe("unblock:#{f.object_id}") }
-      f.resume
+  def block(_blocker, timeout = nil)
+    f, fulfilled, channel = Fiber.current, false, "unblock:#{Fiber.current.object_id}"
+
+    resume_fiber_block = proc do
+      unless fulfilled
+        fulfilled = true
+        ::Iodine.defer { ::Iodine.unsubscribe(channel) }
+        f.resume
+      end
     end
-    # TODO support timeout
+
+    ::Iodine.subscribe(channel, &resume_fiber_block)
+    if timeout
+      ::Iodine.run_after((timeout * 1000).to_i, &resume_fiber_block)
+    end
+
     Fiber.yield
   end
 
@@ -90,15 +104,28 @@ class Rage::FiberScheduler
   end
 
   def fiber(&block)
-    f = Fiber.current
-    inner_schedule = f != @root_fiber
+    parent = Fiber.current
 
-    fiber = Fiber.new(blocking: false) do
-      Fiber.current.__set_result(block.call)
-    ensure
-      # send a message for `Fiber.await` to work
-      Iodine.publish("await:#{f.object_id}", "") if inner_schedule
+    fiber = if parent == @root_fiber
+      # the fiber to wrap a request in
+      Fiber.new(blocking: false) do
+        Fiber.current.__set_result(block.call)
+      end
+    else
+      # the fiber was created in the user code
+      logger = Thread.current[:rage_logger]
+
+      Fiber.new(blocking: false) do
+        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?
+      rescue Exception => e
+        Fiber.current.__set_err(e)
+        Iodine.publish("await:#{parent.object_id}", Fiber::AWAIT_ERROR_MESSAGE) if parent.alive?
+      end
     end
+
     fiber.resume
 
     fiber

data/lib/rage/logger/logger.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "logger"
+
+##
+# All logs in `rage` consist of two parts: keys and tags. A sample log entry might look like this:
+# ```
+# [fecbba0735355738] timestamp=2023-10-19T11:12:56+00:00 pid=1825 level=info message=hello
+# ```
+# In the log entry above, `timestamp`, `pid`, `level`, and `message` are keys, while `fecbba0735355738` is a tag.
+# 
+# Use {tagged} to add custom tags to an entry:
+# ```ruby
+# Rage.logger.tagged("ApiCall") do
+#   perform_api_call
+#   Rage.logger.info "success"
+# end
+# # => [fecbba0735355738][ApiCall] timestamp=2023-10-19T11:12:56+00:00 pid=1825 level=info message=success
+# ```
+#
+# {with_context} can be used to add custom keys:
+# ```ruby
+# cache_key = "mykey"
+# Rage.logger.with_context(cache_key: cache_key) do
+#   get_from_cache(cache_key)
+#   Rage.logger.info "cache miss"
+# end
+# # => [fecbba0735355738] timestamp=2023-10-19T11:12:56+00:00 pid=1825 level=info cache_key=mykey message=cache miss
+# ```
+#
+# `Rage::Logger` also implements the interface of Ruby's native {https://ruby-doc.org/3.2.2/stdlibs/logger/Logger.html Logger}:
+# ```ruby
+# Rage.logger.info("Initializing")
+# Rage.logger.debug { "This is a " + potentially + " expensive operation" }
+# ```
+class Rage::Logger
+  METHODS_MAP = {
+    "debug" => Logger::DEBUG,
+    "info" => Logger::INFO,
+    "warn" => Logger::WARN,
+    "error" => Logger::ERROR,
+    "fatal" => Logger::FATAL,
+    "unknown" => Logger::UNKNOWN
+  }
+  private_constant :METHODS_MAP
+
+  attr_reader :level, :formatter
+
+  # Create a new logger.
+  #
+  # @param log [Object] a filename (`String`), IO object (typically `STDOUT`, `STDERR`, or an open file), `nil` (it writes nothing) or `File::NULL` (same as `nil`)
+  # @param level [Integer] logging severity threshold
+  # @param formatter [#call] logging formatter
+  # @param shift_age [Integer, String] number of old log files to keep, or frequency of rotation  (`"daily"`, `"weekly"` or `"monthly"`). Default value is `0`, which disables log file rotation
+  # @param shift_size [Integer] maximum log file size in bytes (only applies when `shift_age` is a positive Integer)
+  # @param shift_period_suffix [String] the log file suffix format for daily, weekly or monthly rotation
+  # @param binmode sets whether the logger writes in binary mode
+  def initialize(log, level: Logger::DEBUG, formatter: Rage::TextFormatter.new, shift_age: 0, shift_size: 104857600, shift_period_suffix: "%Y%m%d", binmode: false)
+    if log && log != File::NULL
+      @logdev = Logger::LogDevice.new(log, shift_age:, shift_size:, shift_period_suffix:, binmode:)
+    end
+
+    @formatter = formatter
+    @level = level
+    define_log_methods
+  end
+
+  def level=(level)
+    @level = level
+    define_log_methods
+  end
+
+  def formatter=(formatter)
+    @formatter = formatter
+    define_log_methods
+  end
+
+  # Add custom keys to an entry.
+  #
+  # @param context [Hash] a hash of custom keys
+  # @example
+  #   Rage.logger.with_context(key: "mykey") do
+  #     Rage.logger.info "cache miss"
+  #   end
+  def with_context(context)
+    old_context = Thread.current[:rage_logger][:context]
+
+    if old_context.empty? # there's nothing in the context yet
+      Thread.current[:rage_logger][:context] = context
+    else # it's not the first `with_context` call in the chain
+      Thread.current[:rage_logger][:context] = old_context.merge(context)
+    end
+
+    yield(self)
+    true
+
+  ensure
+    Thread.current[:rage_logger][:context] = old_context
+  end
+
+  # Add a custom tag to an entry.
+  #
+  # @param tag [String] the tag to add to an entry
+  # @example
+  #   Rage.logger.tagged("ApiCall") do
+  #     Rage.logger.info "success"
+  #   end
+  def tagged(tag)
+    Thread.current[:rage_logger][:tags] << tag
+
+    yield(self)
+    true
+
+  ensure
+    Thread.current[:rage_logger][:tags].pop
+  end
+
+  alias_method :with_tag, :tagged
+
+  private
+
+  def define_log_methods
+    methods = METHODS_MAP.map do |level_name, level_val|
+      if @logdev.nil? || level_val < @level
+        # logging is disabled or the log level is higher than the current one
+        <<-RUBY
+          def #{level_name}(msg = nil)
+            false
+          end
+        RUBY
+      elsif defined?(IRB)
+        # the call was made from IRB - don't use the formatter
+        <<-RUBY
+          def #{level_name}(msg = nil)
+            @logdev.write((msg || yield) + "\n")
+          end
+        RUBY
+      elsif @formatter.class.name.start_with?("Rage::")
+        # the call was made from within the application and a built-in formatter is used;
+        # in such case we use the `gen_timestamp` method which is much faster than `Time.now.strftime`;
+        # it's not a standard approach however, so it's used with built-in formatters only
+        <<-RUBY
+          def #{level_name}(msg = nil)
+            @logdev.write(
+              @formatter.call("#{level_name}".freeze, Iodine::Rack::Utils.gen_timestamp, nil, msg || yield)
+            )
+          end
+        RUBY
+      else
+        # the call was made from within the application and a custom formatter is used;
+        # stick to the standard approach of using one of the Log Level constants as sevetiry and `Time.now` as time
+        <<-RUBY
+          def #{level_name}(msg = nil)
+            @logdev.write(
+              @formatter.call(#{level_val}, Time.now, nil, msg || yield)
+            )
+          end
+        RUBY
+      end
+    end
+
+    self.class.class_eval(methods.join("\n"))
+  end
+end

data/lib/rage/logger/text_formatter.rb

@@ -0,0 +1,46 @@
+class Rage::TextFormatter
+  def initialize
+    @pid = Process.pid
+    Iodine.on_state(:on_start) do
+      @pid = Process.pid
+    end
+  end
+
+  def call(severity, timestamp, _, message)
+    logger = Thread.current[:rage_logger]
+    tags = logger[:tags]
+
+    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"
+      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"
+      end
+    end
+
+    if tags.length == 1
+      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}"
+    else
+      tags_msg = "[#{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
+
+    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/router/backend.rb

@@ -14,8 +14,36 @@ class Rage::Router::Backend
     @constrainer = Rage::Router::Constrainer.new({})
   end
 
-  def on(method, path, handler, constraints: {}, defaults: nil)
+  def mount(path, handler, methods)
+    raise "Mount handler should respond to `call`" unless handler.respond_to?(:call)
+
     raw_handler = handler
+    is_sidekiq = handler.respond_to?(:name) && handler.name == "Sidekiq::Web"
+
+    handler = ->(env, _params) do
+      env["SCRIPT_NAME"] = path
+      sub_path = env["PATH_INFO"].delete_prefix!(path)
+      env["PATH_INFO"] = "/" if sub_path == ""
+
+      if is_sidekiq
+        Rage::SidekiqSession.with_session(env) do
+          raw_handler.call(env)
+        end
+      else
+        raw_handler.call(env)
+      end
+
+    ensure
+      env["PATH_INFO"] = "#{env["SCRIPT_NAME"]}#{sub_path}"
+    end
+
+    methods.each do |method|
+      __on(method, path, handler, {}, {}, { raw_handler:, mount: true })
+      __on(method, "#{path}/*", handler, {}, {}, { raw_handler:, mount: true })
+    end
+  end
+
+  def on(method, path, handler, constraints: {}, defaults: nil)
     raise "Path could not be empty" if path&.empty?
 
     if match_index = (path =~ OPTIONAL_PARAM_REGEXP)
@@ -29,12 +57,17 @@ class Rage::Router::Backend
       return
     end
 
+    meta = { raw_handler: handler }
+
     if handler.is_a?(String)
       raise "Invalid route handler format, expected to match the 'controller#action' pattern" unless handler =~ STRING_HANDLER_REGEXP
 
       controller, action = to_controller_class($1), $2
       run_action_method_name = controller.__register_action(action.to_sym)
 
+      meta[:controller] = $1
+      meta[:action] = $2
+
       handler = eval("->(env, params) { #{controller}.new(env, params).#{run_action_method_name} }")
     else
       raise "Non-string route handler should respond to `call`" unless handler.respond_to?(:call)
@@ -45,7 +78,7 @@ class Rage::Router::Backend
       handler = ->(env, _params) { orig_handler.call(env) }
     end
 
-    __on(method, path, handler, raw_handler, constraints, defaults)
+    __on(method, path, handler, constraints, defaults, meta)
   end
 
   def lookup(env)
@@ -55,7 +88,7 @@ class Rage::Router::Backend
 
   private
 
-  def __on(method, path, handler, raw_handler, constraints, defaults)
+  def __on(method, path, handler, constraints, defaults, meta)
     @constrainer.validate_constraints(constraints)
     # Let the constrainer know if any constraints are being used now
     @constrainer.note_usage(constraints)
@@ -162,7 +195,7 @@ class Rage::Router::Backend
       end
     end
 
-    route = { method: method, path: path, pattern: pattern, params: params, constraints: constraints, handler: handler, raw_handler: raw_handler, defaults: defaults }
+    route = { method:, path:, pattern:, params:, constraints:, handler:, defaults:, meta: }
     @routes << route
     current_node.add_route(route, @constrainer)
   end

data/lib/rage/router/dsl.rb

@@ -12,7 +12,7 @@ class Rage::Router::DSL
   ##
   # This class implements routing logic for your application, providing API similar to Rails.
   #
-  # Compared to Rails router, the most notable difference is that a wildcard segment can only be in the last section of the path and cannot be named.
+  # Compared to the Rails router, the most notable difference is that a wildcard segment can only be in the last section of the path and cannot be named.
   # Example:
   # ```ruby
   # get "/photos/*"
@@ -327,8 +327,19 @@ class Rage::Router::DSL
         via = args[1][:via]
       end
 
-      # Use match with via: :all to mount the Rack-based application
-      match(at, to: app, via:)
+      at = "/#{at}" unless at.start_with?("/")
+      at = at.delete_suffix("/") if at.end_with?("/")
+
+      http_methods = if via == :all || via.nil?
+        @default_match_methods.map { |method| method.to_s.upcase! }
+      else
+        Array(via).map! do |method|
+          raise ArgumentError, "Invalid HTTP method: #{method}" unless @default_match_methods.include?(method)
+          method.to_s.upcase!
+        end
+      end
+
+      @router.mount(at, app, http_methods)
     end
 
     private

data/lib/rage/router/handler_storage.rb

@@ -22,7 +22,7 @@ class Rage::Router::HandlerStorage
       params: params,
       constraints: constraints,
       handler: route[:handler],
-      create_params_object: compile_create_params_object(params, route[:defaults])
+      create_params_object: compile_create_params_object(params, route[:defaults], route[:meta])
     }
 
     constraints_keys = constraints.keys
@@ -47,8 +47,11 @@ class Rage::Router::HandlerStorage
 
   private
 
-  def compile_create_params_object(param_keys, defaults)
-    lines = []
+  def compile_create_params_object(param_keys, defaults, meta)
+    lines = [
+      ":controller => '#{meta[:controller]}'.freeze",
+      ":action => '#{meta[:action]}'.freeze"
+    ]
 
     param_keys.each_with_index do |key, i|
       lines << ":#{key} => param_values[#{i}]"
@@ -56,7 +59,7 @@ class Rage::Router::HandlerStorage
 
     if defaults
       defaults.except(*param_keys.map(&:to_sym)).each do |key, value|
-        lines << ":#{key} => '#{value}'"
+        lines << ":#{key} => '#{value}'.freeze"
       end
     end
 

data/lib/rage/sidekiq_session.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "digest"
+require "base64"
+
+##
+# Used **specifically** for compatibility with Sidekiq's Web interface.
+# Remove once we have real sessions or once Sidekiq's author decides they
+# don't need cookie sessions to protect against CSRF.
+#
+class Rage::SidekiqSession
+  KEY = Digest::SHA2.hexdigest(ENV["SECRET_KEY_BASE"] || File.read("Gemfile.lock") + File.read("config/routes.rb"))
+  SESSION_KEY = "rage.sidekiq.session"
+
+  def self.with_session(env)
+    env["rack.session"] = session = self.new(env)
+    response = yield
+
+    if session.changed
+      Rack::Utils.set_cookie_header!(
+        response[1],
+        SESSION_KEY,
+        { path: env["SCRIPT_NAME"], httponly: true, same_site: true, value: session.dump }
+      )
+    end
+
+    response
+  end
+
+  attr_reader :changed
+
+  def initialize(env)
+    @env = env
+    session = Rack::Utils.parse_cookies(@env)[SESSION_KEY]
+    @data = decode_session(session)
+  end
+
+  def [](key)
+    @data[key]
+  end
+
+  def[]=(key, value)
+    @changed = true
+    @data[key] = value
+  end
+
+  def to_hash
+    @data
+  end
+
+  def dump
+    encoded_data = Marshal.dump(@data)
+    signature = OpenSSL::HMAC.hexdigest("SHA256", KEY, encoded_data)
+
+    Base64.urlsafe_encode64("#{encoded_data}--#{signature}")
+  end
+
+  private
+
+  def decode_session(session)
+    return {} unless session
+
+    encoded_data, signature = Base64.urlsafe_decode64(session).split("--")
+    ref_signature = OpenSSL::HMAC.hexdigest("SHA256", KEY, encoded_data)
+
+    if Rack::Utils.secure_compare(signature, ref_signature)
+      Marshal.load(encoded_data)
+    else
+      {}
+    end
+  end
+end

data/lib/rage/templates/Rakefile

@@ -0,0 +1 @@
+require_relative "config/application"

data/lib/rage/templates/config-application.rb

@@ -1,6 +1,11 @@
 require "bundler/setup"
+require "rage"
 Bundler.require(*Rage.groups)
 
 require "rage/all"
 
+Rage.configure do
+  # use this to add settings that are constant across all environments
+end
+
 require "rage/setup"

data/lib/rage/templates/config-environments-development.rb

@@ -1,7 +1,10 @@
-Rage.configure do |config|
+Rage.configure do
   # Specify the number of server processes to run. Defaults to number of CPU cores.
-  config.workers_count = 1
+  config.server.workers_count = 1
 
   # Specify the port the server will listen on.
-  config.port = 3000
+  config.server.port = 3000
+
+  # Specify the logger
+  config.logger = Rage::Logger.new(STDOUT)
 end

data/lib/rage/templates/config-environments-production.rb

@@ -1,7 +1,11 @@
-Rage.configure do |config|
+Rage.configure do
   # Specify the number of server processes to run. Defaults to number of CPU cores.
-  # config.workers_count = ENV.fetch("WEB_CONCURRENCY", 1)
+  # config.server.workers_count = ENV.fetch("WEB_CONCURRENCY", 1)
 
   # Specify the port the server will listen on.
-  config.port = 3000
+  config.server.port = 3000
+
+  # Specify the logger
+  config.logger = Rage::Logger.new("log/production.log")
+  config.log_level = Logger::INFO
 end

data/lib/rage/templates/config-environments-test.rb

@@ -1,7 +1,10 @@
-Rage.configure do |config|
+Rage.configure do
   # Specify the number of server processes to run. Defaults to number of CPU cores.
-  config.workers_count = 1
+  config.server.workers_count = 1
 
   # Specify the port the server will listen on.
-  config.port = 3000
+  config.server.port = 3000
+
+  # Specify the logger
+  config.logger = Rage::Logger.new("log/test.log")
 end

data/lib/rage/version.rb

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

data/lib/rage-rb.rb

@@ -22,8 +22,9 @@ module Rage
     @config ||= Rage::Configuration.new
   end
 
-  def self.configure
-    yield(config)
+  def self.configure(&)
+    config.instance_eval(&)
+    config.__finalize
   end
 
   def self.env
@@ -38,6 +39,10 @@ module Rage
     @root ||= Pathname.new(".").expand_path
   end
 
+  def self.logger
+    @logger ||= config.logger
+  end
+
   module Router
     module Strategies
     end

data/rage.gemspec

@@ -29,5 +29,5 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "thor", "~> 1.0"
   spec.add_dependency "rack", "~> 2.0"
-  spec.add_dependency "rage-iodine", "~> 2.0"
+  spec.add_dependency "rage-iodine", "~> 2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rage-rb
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Roman Samoilov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-31 00:00:00.000000000 Z
+date: 2023-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
 description:
 email:
 - rsamoi@icloud.com
@@ -79,6 +79,8 @@ files:
 - lib/rage/errors.rb
 - lib/rage/fiber.rb
 - lib/rage/fiber_scheduler.rb
+- lib/rage/logger/logger.rb
+- lib/rage/logger/text_formatter.rb
 - lib/rage/params_parser.rb
 - lib/rage/request.rb
 - lib/rage/router/README.md
@@ -89,7 +91,9 @@ files:
 - lib/rage/router/node.rb
 - lib/rage/router/strategies/host.rb
 - lib/rage/setup.rb
+- lib/rage/sidekiq_session.rb
 - lib/rage/templates/Gemfile
+- lib/rage/templates/Rakefile
 - lib/rage/templates/app-controllers-application_controller.rb
 - lib/rage/templates/config-application.rb
 - lib/rage/templates/config-environments-development.rb