rage-rb 1.18.0 → 1.19.0

data/lib/rage/controller/api.rb

@@ -9,7 +9,7 @@ class RageController::API
     # returns the name of the newly defined method;
     # rubocop:disable Layout/IndentationWidth, Layout/EndAlignment, Layout/HeredocIndentation
     def __register_action(action)
-      raise Rage::Errors::RouterError, "The action '#{action}' could not be found for #{self}" unless method_defined?(action)
+      raise Rage::Errors::RouterError, "The action `#{action}` could not be found in the `#{self}` controller. This is likely due to route helpers pointing to non-existent actions in the controller. Please check your routes and ensure that all referenced actions exist." unless method_defined?(action)
 
       around_actions_total = 0
 
@@ -153,7 +153,13 @@ class RageController::API
             <<~RUBY
               context = {}
               append_info_to_payload(context)
-              Thread.current[:rage_logger][:context] = context
+
+              log_context = Thread.current[:rage_logger][:context]
+              if log_context.empty?
+                Thread.current[:rage_logger][:context] = context
+              else
+                Thread.current[:rage_logger][:context] = log_context.merge(context)
+              end
             RUBY
           end}
         end
@@ -448,7 +454,7 @@ class RageController::API
   # Get the request object. See {Rage::Request}.
   # @return [Rage::Request]
   def request
-    @request ||= Rage::Request.new(@__env)
+    @request ||= Rage::Request.new(@__env, controller: self)
   end
 
   # Get the response object. See {Rage::Response}.
@@ -635,6 +641,12 @@ class RageController::API
     !still_fresh
   end
 
+  # Get the name of the currently executed action.
+  # @return [String] the name of the currently executed action
+  def action_name
+    @__params[:action]
+  end
+
   # @private
   # for comatibility with `Rails.application.routes.recognize_path`
   def self.binary_params_for?(_)

data/lib/rage/deferred/context.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+##
+# Context for deferred tasks.
+# The class encapsulates the context associated with a deferred task, and allows to store it without modifying the task instance.
+#
+class Rage::Deferred::Context
+  def self.build(task, args, kwargs, storage: nil)
+    logger = Thread.current[:rage_logger]
+
+    [
+      task,
+      args.empty? ? nil : args,
+      kwargs.empty? ? nil : kwargs,
+      nil,
+      logger&.dig(:tags),
+      logger&.dig(:context)
+    ]
+  end
+
+  def self.get_task(context)
+    context[0]
+  end
+
+  def self.get_args(context)
+    context[1]
+  end
+
+  def self.get_kwargs(context)
+    context[2]
+  end
+
+  def self.get_attempts(context)
+    context[3]
+  end
+
+  def self.inc_attempts(context)
+    context[3] = context[3].to_i + 1
+  end
+
+  def self.get_log_tags(context)
+    context[4]
+  end
+
+  def self.get_log_context(context)
+    context[5]
+  end
+end

data/lib/rage/deferred/deferred.rb

@@ -88,7 +88,7 @@ end
 require_relative "task"
 require_relative "queue"
 require_relative "proxy"
-require_relative "metadata"
+require_relative "context"
 require_relative "backends/disk"
 require_relative "backends/nil"
 

data/lib/rage/deferred/queue.rb

@@ -10,7 +10,7 @@ class Rage::Deferred::Queue
   end
 
   # Write the task to the storage and schedule it for execution.
-  def enqueue(task_metadata, delay: nil, delay_until: nil, task_id: nil)
+  def enqueue(context, delay: nil, delay_until: nil, task_id: nil)
     apply_backpressure if @backpressure
 
     publish_in, publish_at = if delay
@@ -21,14 +21,14 @@ class Rage::Deferred::Queue
       [delay_until_i - current_time_i, delay_until_i] if delay_until_i > current_time_i
     end
 
-    persisted_task_id = @backend.add(task_metadata, publish_at:, task_id:)
-    schedule(persisted_task_id, task_metadata, publish_in:)
+    persisted_task_id = @backend.add(context, publish_at:, task_id:)
+    schedule(persisted_task_id, context, publish_in:)
   end
 
   # Schedule the task for execution.
-  def schedule(task_id, task_metadata, publish_in: nil)
+  def schedule(task_id, context, publish_in: nil)
     publish_in_ms = publish_in.to_i * 1_000 if publish_in && publish_in > 0
-    task = Rage::Deferred::Metadata.get_task(task_metadata)
+    task = Rage::Deferred::Context.get_task(context)
     @backlog_size += 1 unless publish_in_ms
 
     Iodine.run_after(publish_in_ms) do
@@ -38,14 +38,14 @@ class Rage::Deferred::Queue
         Fiber.schedule do
           Iodine.task_inc!
 
-          is_completed = task.new.__perform(task_metadata)
+          is_completed = task.new.__perform(context)
 
           if is_completed
             @backend.remove(task_id)
           else
-            attempts = Rage::Deferred::Metadata.inc_attempts(task_metadata)
+            attempts = Rage::Deferred::Context.inc_attempts(context)
             if task.__should_retry?(attempts)
-              enqueue(task_metadata, delay: task.__next_retry_in(attempts), task_id:)
+              enqueue(context, delay: task.__next_retry_in(attempts), task_id:)
             else
               @backend.remove(task_id)
             end

data/lib/rage/deferred/task.rb

@@ -41,34 +41,36 @@ module Rage::Deferred::Task
   end
 
   # @private
-  def __with_optional_log_tag(tag)
-    if tag
-      Rage.logger.tagged(tag) { yield }
-    else
-      yield
+  def __perform(context)
+    args = Rage::Deferred::Context.get_args(context)
+    kwargs = Rage::Deferred::Context.get_kwargs(context)
+    attempts = Rage::Deferred::Context.get_attempts(context)
+
+    restore_log_info(context)
+
+    task_log_context = { task: self.class.name }
+    task_log_context[:attempt] = attempts + 1 if attempts
+
+    Rage.logger.with_context(task_log_context) do
+      perform(*args, **kwargs)
+      true
+    rescue Rage::Deferred::TaskFailed
+      false
+    rescue Exception => e
+      Rage.logger.error("Deferred task failed with exception: #{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}")
+      false
     end
   end
 
-  # @private
-  def __perform(metadata)
-    args = Rage::Deferred::Metadata.get_args(metadata)
-    kwargs = Rage::Deferred::Metadata.get_kwargs(metadata)
-    attempts = Rage::Deferred::Metadata.get_attempts(metadata)
-    request_id = Rage::Deferred::Metadata.get_request_id(metadata)
-
-    context = { task: self.class.name }
-    context[:attempt] = attempts + 1 if attempts
+  private def restore_log_info(context)
+    log_tags = Rage::Deferred::Context.get_log_tags(context)
+    log_context = Rage::Deferred::Context.get_log_context(context)
 
-    Rage.logger.with_context(context) do
-      __with_optional_log_tag(request_id) do
-        perform(*args, **kwargs)
-        true
-      rescue Rage::Deferred::TaskFailed
-        false
-      rescue Exception => e
-        Rage.logger.error("Deferred task failed with exception: #{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}")
-        false
-      end
+    if log_tags.is_a?(Array)
+      Thread.current[:rage_logger] = { tags: log_tags, context: log_context }
+    elsif log_tags
+      # support the previous format where only `request_id` was passed
+      Thread.current[:rage_logger] = { tags: [log_tags], context: {} }
     end
   end
 
@@ -79,10 +81,12 @@ module Rage::Deferred::Task
   module ClassMethods
     def enqueue(*args, delay: nil, delay_until: nil, **kwargs)
       Rage::Deferred.__queue.enqueue(
-        Rage::Deferred::Metadata.build(self, args, kwargs),
+        Rage::Deferred::Context.build(self, args, kwargs),
         delay:,
         delay_until:
       )
+
+      nil
     end
 
     # @private

data/lib/rage/env.rb

@@ -1,5 +1,16 @@
 # frozen_string_literal: true
 
+##
+# {Rage::Env Rage::Env} represents the current environment of the Rage application.
+#
+# The class automatically detects the application's current environment by checking the `RAGE_ENV`, `RAILS_ENV`, and `RACK_ENV` environment variables.
+# It provides predicate methods to check which environment is active.
+#
+# @example
+#   # Start the application with `rage s -e preprod`
+#   Rage.env.development? # => false
+#   Rage.env.preprod?     # => true
+#
 class Rage::Env
   STANDARD_ENVS = %w(development test staging production)
 
@@ -28,6 +39,10 @@ class Rage::Env
     @env.to_sym
   end
 
+  def to_str
+    @env
+  end
+
   def to_s
     @env
   end

data/lib/rage/hooks.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+# @private
 module Hooks
   def hooks
     @hooks ||= Hash.new { |h, k| h[k] = [] }

data/lib/rage/internal.rb

@@ -30,6 +30,20 @@ class Rage::Internal
       RUBY
     end
 
+    # Build a string representation of keyword arguments based on the parameters expected by the method.
+    # @param method [Method, Proc] the method to build arguments for
+    # @param arguments [Hash] the arguments to include in the string representation
+    # @return [String] the string representation of the method arguments
+    def build_arguments(method, arguments)
+      expected_parameters = method.parameters
+
+      arguments.filter_map { |arg_name, arg_value|
+        if expected_parameters.any? { |param_type, param_name| param_name == arg_name || param_type == :keyrest }
+          "#{arg_name}: #{arg_value}"
+        end
+      }.join(", ")
+    end
+
     private
 
     def dynamic_name_seed

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