rage-rb 1.17.1 → 1.19.0

data/lib/rage/log_processor.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+class Rage::LogProcessor
+  DEFAULT_LOG_CONTEXT = {}.freeze
+  private_constant :DEFAULT_LOG_CONTEXT
+
+  attr_reader :dynamic_tags, :dynamic_context
+
+  def initialize
+    rebuild!
+  end
+
+  def add_custom_context(context_objects)
+    @custom_context = context_objects
+    rebuild!
+  end
+
+  def add_custom_tags(tag_objects)
+    @custom_tags = tag_objects
+    rebuild!
+  end
+
+  def finalize_request_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(nil)
+    logger[:final] = nil
+  end
+
+  private
+
+  def build_static_tags
+    calls = @custom_tags&.filter_map&.with_index do |tag_object, i|
+      if tag_object.is_a?(String)
+        "@custom_tags[#{i}]"
+      elsif tag_object.respond_to?(:to_str)
+        "@custom_tags[#{i}].to_str"
+      end
+    end
+
+    unless calls&.any?
+      return "[env[\"rage.request_id\"]]"
+    end
+
+    "[env[\"rage.request_id\"], #{calls.join(", ")}]"
+  end
+
+  def build_static_context
+    calls = @custom_context&.filter_map&.with_index do |context_object, i|
+      "@custom_context[#{i}]" if context_object.is_a?(Hash)
+    end
+
+    unless calls&.any?
+      return "DEFAULT_LOG_CONTEXT"
+    end
+
+    if calls.one?
+      calls[0]
+    else
+      "{}.merge!(#{calls.join(", ")})"
+    end
+  end
+
+  def build_dynamic_tags_proc
+    calls = @custom_tags&.filter_map&.with_index do |tag_object, i|
+      if tag_object.respond_to?(:call)
+        "*@custom_tags[#{i}].call"
+      end
+    end
+
+    return unless calls&.any?
+
+    eval <<~RUBY
+      ->() do
+        [#{calls.join(", ")}]
+      end
+    RUBY
+  end
+
+  def build_dynamic_context_proc
+    calls = @custom_context&.filter_map&.with_index do |context_object, i|
+      if context_object.respond_to?(:call)
+        "@custom_context[#{i}].call || DEFAULT_LOG_CONTEXT"
+      end
+    end
+
+    return unless calls&.any?
+
+    eval <<~RUBY
+      ->() do
+        {}.merge!(#{calls.join(", ")})
+      end
+    RUBY
+  end
+
+  def rebuild!
+    @dynamic_tags = build_dynamic_tags_proc
+    @dynamic_context = build_dynamic_context_proc
+
+    self.class.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+      def init_request_logger(env)
+        env["rage.request_id"] ||= Iodine::Rack::Utils.gen_request_tag
+
+        Thread.current[:rage_logger] = {
+          tags: #{build_static_tags},
+          context: #{build_static_context},
+          request_start: Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        }
+      end
+    RUBY
+  end
+end

data/lib/rage/logger/json_formatter.rb

@@ -1,3 +1,22 @@
+##
+# JSON formatter for Rage logger.
+#
+# Produces log lines in JSON format, including tags, context, and request details if available.
+#
+# Example log line:
+#
+# ```json
+# {"tags":["fecbba0735355738"],"timestamp":"2025-10-19T11:12:56+00:00","pid":"1825","level":"info","method":"GET","path":"/api/v1/resource","controller":"Api::V1::ResourceController","action":"index","status":200,"duration":0.15}
+# ```
+#
+# Use {Rage.configure Rage.configure} to set the formatter:
+#
+# ```ruby
+# Rage.configure do |config|
+#   config.log_formatter = Rage::JSONFormatter.new
+# end
+# ```
+#
 class Rage::JSONFormatter
   def initialize
     @pid = Process.pid.to_s
@@ -15,32 +34,32 @@ class Rage::JSONFormatter
       context.each { |k, v| context_msg << "\"#{k}\":#{v.to_json}," }
     end
 
-    if (final = logger[:final])
-      params, env = final[:params], final[:env]
-      if params && params[:controller]
-        return "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"info\",\"method\":\"#{env["REQUEST_METHOD"]}\",\"path\":\"#{env["PATH_INFO"]}\",\"controller\":\"#{Rage::Router::Util.path_to_name(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}\""
+    tags_msg = if tags.length == 1
+      "{\"tags\":[\"#{tags[0]}\"],"
     elsif tags.length == 2
-      tags_msg = "{\"tags\":[\"#{tags[0]}\",\"#{tags[1]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
+      "{\"tags\":[\"#{tags[0]}\",\"#{tags[1]}\"],"
     elsif tags.length == 0
-      tags_msg = "{\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
+      "{"
     else
-      tags_msg = "{\"tags\":[\"#{tags[0]}\",\"#{tags[1]}\""
+      msg = "{\"tags\":[\"#{tags[0]}\",\"#{tags[1]}\""
       i = 2
       while i < tags.length
-        tags_msg << ",\"#{tags[i]}\""
+        msg << ",\"#{tags[i]}\""
         i += 1
       end
-      tags_msg << "],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
+      msg << "],"
+    end
+
+    if (final = logger[:final])
+      params, env = final[:params], final[:env]
+      if params && params[:controller]
+        return "#{tags_msg}\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"info\",\"method\":\"#{env["REQUEST_METHOD"]}\",\"path\":\"#{env["PATH_INFO"]}\",\"controller\":\"#{Rage::Router::Util.path_to_name(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_msg}\"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
 
-    "#{tags_msg},#{context_msg}\"message\":\"#{message}\"}\n"
+    "#{tags_msg}\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\",#{context_msg}\"message\":\"#{message}\"}\n"
   end
 end

data/lib/rage/logger/logger.rb

@@ -51,18 +51,30 @@ require "logger"
 # end
 # ```
 class Rage::Logger
+  # @private
   METHODS_MAP = {
-    "debug" => Logger::DEBUG,
-    "info" => Logger::INFO,
-    "warn" => Logger::WARN,
-    "error" => Logger::ERROR,
-    "fatal" => Logger::FATAL,
-    "unknown" => Logger::UNKNOWN
+    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
 
+  # @private
+  attr_reader :dynamic_tags, :dynamic_context
+
+  # @private
+  attr_reader :external_logger
+
+  # @private
+  module External
+    Static = Data.define(:wrapped)
+    Dynamic = Data.define(:wrapped)
+  end
+
   # 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`)
@@ -73,7 +85,10 @@ class Rage::Logger
   # @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)
-    @logdev = if log && log != File::NULL
+    @logdev = if log.class.name.start_with?("Rage::Logger::External::")
+      @external_logger = log
+      Logger::LogDevice.new(STDERR)
+    elsif log && log != File::NULL
       Logger::LogDevice.new(log, shift_age:, shift_size:, shift_period_suffix:, binmode:)
     end
 
@@ -83,17 +98,38 @@ class Rage::Logger
 
     @formatter = formatter
     @level = @logdev ? level : Logger::UNKNOWN
-    define_log_methods
+    rebuild!
   end
 
+  # Set the logging severity threshold.
+  # @param level [Integer] logging severity threshold
   def level=(level)
     @level = level
-    define_log_methods
+    rebuild!
   end
 
+  # Set the logging formatter.
+  # @param formatter [#call] logging formatter
   def formatter=(formatter)
     @formatter = formatter
-    define_log_methods
+    rebuild!
+  end
+
+  # Write the given `msg` to the log with no formatting.
+  def <<(msg)
+    @logdev&.write(msg)
+  end
+
+  # @private
+  def dynamic_tags=(dynamic_tags)
+    @dynamic_tags = dynamic_tags
+    rebuild!
+  end
+
+  # @private
+  def dynamic_context=(dynamic_context)
+    @dynamic_context = dynamic_context
+    rebuild!
   end
 
   # Add custom keys to an entry.
@@ -119,29 +155,37 @@ class Rage::Logger
 
   # Add a custom tag to an entry.
   #
-  # @param tag [String] the tag to add to an entry
+  # @param tags [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: [], context: {} })[:tags] << tag
+  def tagged(*tags)
+    old_tags = (Thread.current[:rage_logger] ||= { tags: [], context: {} })[:tags]
+    Thread.current[:rage_logger][:tags] = old_tags + tags
     yield(self)
   ensure
-    Thread.current[:rage_logger][:tags].pop
+    Thread.current[:rage_logger][:tags] = old_tags
   end
 
   alias_method :with_tag, :tagged
 
+  # Check if the debug level is enabled.
   def debug? = @level <= Logger::DEBUG
+  # Check if the error level is enabled.
   def error? = @level <= Logger::ERROR
+  # Check if the fatal level is enabled.
   def fatal? = @level <= Logger::FATAL
+  # Check if the info level is enabled.
   def info? = @level <= Logger::INFO
+  # Check if the warn level is enabled.
   def warn? = @level <= Logger::WARN
+  # Check if the unknown level is enabled.
+  def unknown? = @level <= Logger::UNKNOWN
 
   private
 
-  def define_log_methods
+  def rebuild!
     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
@@ -150,25 +194,55 @@ class Rage::Logger
             false
           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
+      elsif @external_logger.is_a?(External::Static)
+        # an object that implements Ruby's Logger interface is used as a logger
+        <<~RUBY
           def #{level_name}(msg = nil)
-            @logdev.write(
-              @formatter.call("#{level_name}".freeze, Iodine::Rack::Utils.gen_timestamp, nil, msg || yield)
-            )
+            #{with_dynamic_tags_and_context do
+              <<~RUBY
+                @external_logger.wrapped.#{level_name}(
+                  #{build_formatter_call(level_name, level_val)}
+                )
+              RUBY
+            end}
+          end
+        RUBY
+      elsif @external_logger.is_a?(External::Dynamic)
+        # a callable object is used as a logger
+        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",
+          message: "block_given? ? yield : msg",
+          request_info: "logger[:final].freeze"
+        })
+
+        <<~RUBY
+          def #{level_name}(msg = nil)
+            #{with_dynamic_tags_and_context do
+              <<~RUBY
+                logger = Thread.current[:rage_logger] || { tags: [], context: {} }
+                @external_logger.wrapped.call(#{parameters})
+              RUBY
+            end}
           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
+        <<~RUBY
           def #{level_name}(msg = nil)
-            @logdev.write(
-              @formatter.call(#{level_val}, Time.now, nil, msg || yield)
-            )
+            #{with_dynamic_tags_and_context do
+              <<~RUBY
+                @logdev.write(
+                  #{build_formatter_call(level_name, level_val)}
+                )
+              RUBY
+            end}
           end
         RUBY
       end
@@ -176,4 +250,36 @@ class Rage::Logger
 
     self.class.class_eval(methods.join("\n"))
   end
+
+  def build_formatter_call(level_name, level_val)
+    if @formatter.class.name.start_with?("Rage::")
+      # a built-in formatter is used - 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
+        @formatter.call("#{level_name}".freeze, Iodine::Rack::Utils.gen_timestamp, nil, block_given? ? yield : msg)
+      RUBY
+    else
+      # a custom formatter is used - stick to the standard approach of using one of the
+      # Log Level constants as severity and `Time.now` as time
+      <<~RUBY
+        @formatter.call(#{level_val}, Time.now, nil, block_given? ? yield : msg)
+      RUBY
+    end
+  end
+
+  def with_dynamic_tags_and_context
+    do_calls, end_calls = [], []
+
+    if @dynamic_tags
+      do_calls << "tagged(*@dynamic_tags.call) do"
+      end_calls << "end"
+    end
+
+    if @dynamic_context
+      do_calls << "with_context(@dynamic_context.call) do"
+      end_calls << "end"
+    end
+
+    "#{do_calls.join("\n")}\n#{yield}\n#{end_calls.join("\n")}"
+  end
 end

data/lib/rage/logger/text_formatter.rb

@@ -1,3 +1,20 @@
+##
+# Text formatter for Rage logger.
+#
+# Example log line:
+#
+# ```
+# [fecbba0735355738] timestamp=2025-10-19T11:12:56+00:00 pid=1825 level=info method=GET path=/api/v1/resource controller=Api::V1::ResourceController action=index status=200 duration=0.15
+# ```
+#
+# Use {Rage.configure Rage.configure} to set the formatter:
+#
+# ```ruby
+# Rage.configure do |config|
+#   config.log_formatter = Rage::TextFormatter.new
+# end
+# ```
+#
 class Rage::TextFormatter
   def initialize
     @pid = Process.pid
@@ -17,11 +34,13 @@ class Rage::TextFormatter
 
     if (final = logger[:final])
       params, env = final[:params], final[:env]
+      tags = tags.map { |tag| "[#{tag}]" }.join
+
       if params && params[:controller]
-        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} controller=#{Rage::Router::Util.path_to_name(params[:controller])} action=#{params[:action]} #{context_msg}status=#{final[:response][0]} duration=#{final[:duration]}\n"
+        return "#{tags} timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} controller=#{Rage::Router::Util.path_to_name(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"]} #{context_msg}status=#{final[:response][0]} duration=#{final[:duration]}\n"
+        return "#{tags} 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
 

data/lib/rage/middleware/fiber_wrapper.rb

@@ -17,6 +17,14 @@ class Rage::FiberWrapper
   def call(env)
     fiber = Fiber.schedule do
       @app.call(env)
+    rescue Exception => e
+      exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
+      Rage.logger << exception_str
+      if Rage.env.development?
+        [500, {}, [exception_str]]
+      else
+        [500, {}, []]
+      end
     ensure
       # notify Iodine the request can now be resumed
       Iodine.publish(Fiber.current.__get_id, "", Iodine::PubSub::PROCESS)

data/lib/rage/middleware/reloader.rb

@@ -5,29 +5,24 @@ class Rage::Reloader
     Iodine.on_state(:on_start) do
       Rage.code_loader.check_updated!
     end
+
     @app = app
+    @mutex = Mutex.new
   end
 
   def call(env)
     with_reload do
       @app.call(env)
     end
-  rescue Exception => e
-    exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
-    puts(exception_str)
-    [500, {}, [exception_str]]
   end
 
   private
 
   def with_reload
-    if Rage.code_loader.check_updated!
-      Fiber.new(blocking: true) {
-        Rage.code_loader.reload
-        yield
-      }.resume
-    else
-      yield
+    @mutex.synchronize do
+      Rage.code_loader.reload if Rage.code_loader.check_updated!
     end
+
+    yield
   end
 end

data/lib/rage/request.rb

@@ -36,8 +36,11 @@ class Rage::Request
   KNOWN_HTTP_METHODS = (RFC2616 + RFC2518 + RFC3253 + RFC3648 + RFC3744 + RFC5323 + RFC4791 + RFC5789).to_set
 
   # @private
-  def initialize(env)
+  # @param env [Hash] Rack env
+  # @param controller [RageController::API]
+  def initialize(env, controller: nil)
     @env = env
+    @controller = controller
   end
 
   # Check if the request was made using TLS/SSL which is if http or https protocol is used inside the URL.
@@ -203,6 +206,20 @@ class Rage::Request
 
   alias_method :uuid, :request_id
 
+  # Get the route URI pattern matched for this request.
+  # @return [String] the route URI pattern
+  # @example
+  #   # For a route defined as:
+  #   #   get "/users/:id", to: "users#show"
+  #   request.route_uri_pattern # => "/users/:id"
+  def route_uri_pattern
+    if @controller
+      Rage::Router::Util.route_uri_pattern(@controller.class, @controller.action_name)
+    else
+      path
+    end
+  end
+
   private
 
   def rack_request

data/lib/rage/response.rb

@@ -16,7 +16,7 @@ class Rage::Response
   # Returns the content of the response as a string. This contains the contents of any calls to `render`.
   # @return [String]
   def body
-    @body[0]
+    @body[0] || ""
   end
 
   # Returns the headers for the response.

data/lib/rage/router/util.rb

@@ -31,6 +31,14 @@ class Rage::Router::Util
         @@names_map[str] = path_to_class(str).name
       end
     end
+
+    @@uri_patterns_map = Hash.new { |h, k| h[k] = {} }
+
+    def route_uri_pattern(controller_class, action_name)
+      @@uri_patterns_map[controller_class][action_name] ||= Rage.__router.routes.find { |route|
+        route[:meta][:controller_class] == controller_class && route[:meta][:action] == action_name
+      }[:path]
+    end
   end
 
   # @private

data/lib/rage/setup.rb

@@ -18,3 +18,5 @@ Rage.code_loader.setup
 Rage.config.run_after_initialize!
 
 require_relative "#{Rage.root}/config/routes"
+
+Rage.config.internal.initialized!

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

@@ -8,4 +8,5 @@ Rage.configure do
   # Specify the logger
   config.logger = Rage::Logger.new(STDOUT)
   config.log_level = Logger::INFO
+  config.log_formatter = Rage::JSONFormatter.new
 end

data/lib/rage/version.rb

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