rage-rb 1.26.1 → 1.28.0

data/lib/rage/deferred/backends/nil.rb

@@ -4,13 +4,27 @@ class Rage::Deferred::Backends::Nil
   def initialize(**)
   end
 
-  def add(_, **)
+  def add_task(_, **)
   end
 
-  def remove(_)
+  def remove_task(_)
   end
 
   def pending_tasks
     []
   end
+
+  def add_dead_task(_, _, _, **)
+  end
+
+  def list_dead_tasks(**)
+    []
+  end
+
+  def find_dead_task(_)
+  end
+
+  def remove_dead_tasks(_)
+    0
+  end
 end

data/lib/rage/deferred/deferred.rb

@@ -70,7 +70,7 @@ module Rage::Deferred
       __queue.schedule(task_id, task_wrapper, publish_in:)
     rescue => e
       puts "ERROR: Failed to load deferred task #{task_id}: #{e.class} (#{e.message}). Removing task from the queue."
-      __backend.remove(task_id)
+      __backend.remove_task(task_id)
     end
   end
 
@@ -99,6 +99,10 @@ module Rage::Deferred
 
   class PushTimeout < StandardError
   end
+
+  # Raised when a dead-tasks store operation cannot acquire the lock within the retry budget.
+  class DeadTasksLockTimeout < StandardError
+  end
 end
 
 require_relative "task"

data/lib/rage/deferred/queue.rb

@@ -21,7 +21,7 @@ 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(context, publish_at:, task_id:)
+    persisted_task_id = @backend.add_task(context, publish_at:, task_id:)
     schedule(persisted_task_id, context, publish_in:)
   end
 
@@ -41,14 +41,14 @@ class Rage::Deferred::Queue
           result = task.new.__perform(context)
 
           if result == true
-            @backend.remove(task_id)
+            @backend.remove_task(task_id)
           else
             attempts = Rage::Deferred::Context.inc_attempts(context)
             retry_in = task.__next_retry_in(attempts, result)
             if retry_in
               enqueue(context, delay: retry_in, task_id:)
             else
-              @backend.remove(task_id)
+              abandon_task(task_id, context, result, task_class: task, attempts:)
             end
           end
 
@@ -74,4 +74,9 @@ class Rage::Deferred::Queue
       end
     end
   end
+
+  def abandon_task(task_id, context, result, task_class:, attempts:)
+    @backend.add_dead_task(task_id, context, result, task_class:, attempts:)
+    @backend.remove_task(task_id)
+  end
 end

data/lib/rage/deferred/task.rb

@@ -73,6 +73,7 @@ module Rage::Deferred::Task
         Rage.logger.with_context(task_log_context) do
           args = Rage::Deferred::Context.get_args(context)
           kwargs = Rage::Deferred::Context.get_kwargs(context)
+          kwargs ||= {} if RUBY_VERSION.start_with?("3.3.")
 
           perform(*args, **kwargs)
         end

data/lib/rage/fiber_scheduler.rb

@@ -75,19 +75,23 @@ class Rage::FiberScheduler
     Fiber.pause if duration.nil? || duration < 1
   end
 
-  # TODO: GC works a little strange with this closure;
-  #
-  # def timeout_after(duration, exception_class = Timeout::Error, *exception_arguments, &block)
-  #   fiber, block_status = Fiber.current, :running
-  #   ::Iodine.run_after((duration * 1000).to_i) do
-  #     fiber.raise(exception_class, exception_arguments) if block_status == :running
-  #   end
-
-  #   result = block.call
-  #   block_status = :finished
-
-  #   result
-  # end
+  if ENV["RAGE_ENABLE_NON_BLOCKING_TIMEOUT"]
+    def timeout_after(duration, exception_class = Timeout::Error, *exception_arguments, &block)
+      f, fulfilled = Fiber.current, false
+
+      ::Iodine.run_after((duration * 1000).to_i) do
+        if !fulfilled && f.alive?
+          fulfilled = true
+          f.__wait_generation += 1
+          f.raise(exception_class, *exception_arguments)
+        end
+      end
+
+      block.call
+    ensure
+      fulfilled = true
+    end
+  end
 
   # Resolve a hostname to IP addresses, caching results for 60 seconds.
   def address_resolve(hostname)

data/lib/rage/hooks.rb

@@ -10,7 +10,7 @@ module Hooks
     hooks[hook_family] << callback if callback.is_a?(Proc)
   end
 
-  def run_hooks_for!(hook_family, context = nil)
+  def run_hooks_for(hook_family, context = nil)
     hooks[hook_family].each do |callback|
       if context
         context.instance_exec(&callback)
@@ -19,6 +19,11 @@ module Hooks
       end
     end
 
+    true
+  end
+
+  def run_hooks_for!(hook_family, context = nil)
+    run_hooks_for(hook_family, context)
     @hooks[hook_family] = []
 
     true

data/lib/rage/logger/logger.rb

@@ -60,11 +60,13 @@ class Rage::Logger
     fatal: Logger::FATAL,
     unknown: Logger::UNKNOWN
   }
+  REDACTED = "[REDACTED]"
+  private_constant :REDACTED
 
   attr_reader :level, :formatter
 
   # @private
-  attr_reader :dynamic_tags, :dynamic_context
+  attr_reader :dynamic_tags, :dynamic_context, :log_redact_keys
 
   # @private
   attr_reader :external_logger
@@ -132,6 +134,19 @@ class Rage::Logger
     rebuild!
   end
 
+  # @private
+  def log_redact_keys=(log_redact_keys)
+    if log_redact_keys&.any?
+      @log_redact_keys = log_redact_keys
+      @log_redact_keys_matcher = Regexp.union(log_redact_keys.map { |key| Regexp.new(Regexp.escape(key), Regexp::IGNORECASE) })
+    else
+      @log_redact_keys = nil
+      @log_redact_keys_matcher = nil
+    end
+
+    rebuild!
+  end
+
   # Add custom keys to an entry.
   #
   # @param context [Hash] a hash of custom keys
@@ -196,7 +211,7 @@ class Rage::Logger
         RUBY
       elsif @external_logger.is_a?(External::Static)
         # an object that implements Ruby's Logger interface is used as a logger
-        write_call = <<~RUBY
+        write_call = build_redacted_context_call(<<~RUBY)
           @external_logger.wrapped.#{level_name}(
             #{build_formatter_call(level_name, level_val)}
           )
@@ -233,7 +248,7 @@ class Rage::Logger
           request_info: "Fiber[:__rage_logger_final].freeze"
         })
 
-        write_call = <<~RUBY
+        write_call = build_redacted_context_call(<<~RUBY)
           @external_logger.wrapped.call(#{parameters})
         RUBY
 
@@ -253,7 +268,7 @@ class Rage::Logger
           end
         RUBY
       else
-        write_call = <<~RUBY
+        write_call = build_redacted_context_call(<<~RUBY)
           @logdev.write(
             #{build_formatter_call(level_name, level_val)}
           )
@@ -296,6 +311,42 @@ class Rage::Logger
     end
   end
 
+  def build_redacted_context_call(write_call)
+    return write_call unless @log_redact_keys
+
+    <<~RUBY
+      with_redacted_context do
+        #{write_call}
+      end
+    RUBY
+  end
+
+  def with_redacted_context
+    context = Fiber[:__rage_logger_context]
+    return yield if context.nil? || context.empty?
+
+    Fiber[:__rage_logger_context] = redact_value(context)
+    yield
+  ensure
+    Fiber[:__rage_logger_context] = context
+  end
+
+  def redact_value(value)
+    if value.is_a?(Hash)
+      value.each_with_object({}) do |(key, nested_value), redacted|
+        redacted[key] = if @log_redact_keys_matcher.match?(key)
+          REDACTED
+        else
+          redact_value(nested_value)
+        end
+      end
+    elsif value.is_a?(Array)
+      value.map { |item| redact_value(item) }
+    else
+      value
+    end
+  end
+
   def with_dynamic_tags_and_context
     do_calls, end_calls = [], []
 

data/lib/rage/openapi/index.html.erb

@@ -13,7 +13,7 @@
     <script>
       window.onload = () => {
         window.ui = SwaggerUIBundle({
-          url: '<%= spec_url %>',
+          url: window.location.pathname.replace(/\/?$/, "/json"),
           dom_id: '#swagger-ui',
         });
       };

data/lib/rage/openapi/openapi.rb

@@ -42,11 +42,9 @@ module Rage::OpenAPI
   #     run Rage.openapi.application(namespace: "Api::V2")
   #   end
   def self.application(namespace: nil)
-    html_app = ->(env) do
+    html_app = ->(_) do
       __data_cache[[:page, namespace]] ||= begin
-        scheme, host, path = env["rack.url_scheme"], env["HTTP_HOST"], env["SCRIPT_NAME"]
-        spec_url = "#{scheme}://#{host}#{path}/json"
-        page = ERB.new(File.read("#{__dir__}/index.html.erb")).result(binding)
+        page = ERB.new(File.read("#{__dir__}/index.html.erb")).result
 
         [200, { "content-type" => "text/html; charset=UTF-8" }, [page]]
       end
@@ -120,7 +118,7 @@ module Rage::OpenAPI
 
   # @private
   def self.__try_parse_collection(str)
-    if str =~ /^Array<([\w\s:\(\),]+)>$/ || str =~ /^\[([\w\s:\(\),]+)\]$/
+    if str =~ /^Array<([\w\s:\(\),'\"]+)>$/ || str =~ /^\[([\w\s:\(\),'\"]+)\]$/
       [true, $1]
     else
       [false, str]
@@ -202,9 +200,20 @@ module Rage::OpenAPI
 
   # @private
   def self.__log_warn(log)
+    @__warnings << log if @__warnings
     puts "[OpenAPI] WARNING: #{log}"
   end
 
+  # @private
+  # @return [Array<String>] the warnings logged inside the block
+  def self.__collect_warnings
+    @__warnings = []
+    yield
+    @__warnings
+  ensure
+    @__warnings = nil
+  end
+
   module Nodes
   end
 

data/lib/rage/openapi/parsers/ext/blueprinter.rb

@@ -20,9 +20,10 @@ class Rage::OpenAPI::Parsers::Ext::Blueprinter
     is_collection, raw_klass_str, serializer_options = Rage::OpenAPI.__parse_serializer_args(klass_str)
     klass = @namespace.const_get(raw_klass_str)
     schema = build_schema(klass, is_collection, serializer_options)
+    registry_key = "#{raw_klass_str}_#{serializer_options[:view] || :default}"
 
-    if @root.schema_registry.key?(raw_klass_str)
-      @root.schema_registry[raw_klass_str] = is_collection ? schema["items"] : schema
+    if @root.schema_registry.key?(registry_key)
+      @root.schema_registry[registry_key] = is_collection ? schema["items"] : schema
     end
 
     schema
@@ -32,26 +33,31 @@ class Rage::OpenAPI::Parsers::Ext::Blueprinter
 
   private
 
-  def build_schema(klass, is_collection, serializer_options = nil)
-    @parsing_stack.add(klass.name)
-
-    view_name = serializer_options&.key?(:view) ? serializer_options[:view] : :default
+  def build_schema(klass, is_collection, serializer_options)
+    view_name = serializer_options&.key?(:view) ? serializer_options[:view].to_sym : :default
     reflections = klass.reflections
     view = reflections[view_name]
     raise InvalidViewError, "invalid view #{view_name}" unless view
 
+    @parsing_stack.add([klass.name, view_name])
+
     identifier_fields = extract_fields(reflections[:identifier])
     default_fields = extract_fields(view)
     association_fields = extract_associations(view)
 
-    @parsing_stack.delete(klass.name)
+    @parsing_stack.delete([klass.name, view_name])
 
     schema = identifier_fields.merge(default_fields.merge(association_fields).sort.to_h)
 
     result = { "type" => "object" }
     result["properties"] = schema if schema.any?
     result = { "type" => "array", "items" => result } if is_collection
-    result
+
+    if serializer_options&.key?(:root)
+      { "type" => "object", "properties" => { serializer_options[:root].to_s => result } }
+    else
+      result
+    end
   end
 
   def extract_fields(view)
@@ -65,14 +71,16 @@ class Rage::OpenAPI::Parsers::Ext::Blueprinter
       blueprint = association.blueprint
       name, display_name = association.name.to_s, association.display_name.to_s
       is_collection = collection_association?(name)
+      serializer_options = { view: association.view }
 
       item_schema = if blueprint.is_a?(Proc)
         { "type" => "object" }
-      elsif @parsing_stack.include?(blueprint.name)
-        @root.schema_registry[blueprint.name] ||= nil
-        { "$ref" => "#/components/schemas/#{blueprint.name}" }
+      elsif @parsing_stack.include?([blueprint.name, association.view])
+        schema_key = "#{blueprint.name}_#{association.view}"
+        @root.schema_registry[schema_key] ||= nil
+        { "$ref" => "#/components/schemas/#{schema_key}" }
       else
-        build_schema(blueprint, false)
+        build_schema(blueprint, false, serializer_options)
       end
 
       properties[display_name] = is_collection ? { "type" => "array", "items" => item_schema } : item_schema

data/lib/rage/router/README.md

@@ -1,6 +1,6 @@
 This is an almost complete rewrite of https://github.com/delvedor/find-my-way.
 
-Currently, the only constraint supported is the `host` constraint. Regexp constraints are likely to be added. Custom/lambda constraints are unlikely to be added.
+Currently, the only constraint supported is the `host` constraint. The constraint value can be either a string or a regular expression. Custom/lambda constraints are unlikely to be added.
 
 Compared to the Rails router, the most notable difference except constraints is that a wildcard segment can only be in the last section of the path and cannot be named.
 

data/lib/rage/router/backend.rb

@@ -35,13 +35,17 @@ class Rage::Router::Backend
       # by the time the app is called, `rack.input` is already consumed in `Rage::ParamsParser`
       env["rack.input"].rewind
 
-      env["SCRIPT_NAME"] = path
-      sub_path = env["PATH_INFO"].delete_prefix!(path)
-      env["PATH_INFO"] = "/" if sub_path == ""
+      script_name = env["SCRIPT_NAME"]
+      path_info = env["PATH_INFO"]
+
+      env["SCRIPT_NAME"] = "#{script_name}#{path}"
+      sub_path = path_info.delete_prefix(path)
+      env["PATH_INFO"] = sub_path == "" ? "/" : sub_path
 
       handler.call(env)
     ensure
-      env["PATH_INFO"] = "#{env["SCRIPT_NAME"]}#{sub_path}"
+      env["SCRIPT_NAME"] = script_name
+      env["PATH_INFO"] = path_info
     end
 
     methods.each do |method|

data/lib/rage/router/dsl.rb

@@ -420,11 +420,11 @@ class Rage::Router::DSL
       at = at.delete_suffix("/") if at.end_with?("/")
 
       http_methods = if via == :all || via.nil?
-        @default_match_methods.map { |method| method.to_s.upcase! }
+        @default_match_methods.map { |method| method.to_s.upcase }
       else
-        Array(via).map! do |method|
+        Array(via).map do |method|
           raise ArgumentError, "Invalid HTTP method: #{method}" unless @default_match_methods.include?(method)
-          method.to_s.upcase!
+          method.to_s.upcase
         end
       end
 
@@ -501,8 +501,7 @@ class Rage::Router::DSL
     end
 
     def to_singular(str)
-      @active_support_loaded ||= str.respond_to?(:singularize) || :false
-      return str.singularize if @active_support_loaded != :false
+      return str.singularize if str.respond_to?(:singularize)
 
       @endings ||= {
         "ves" => "fe",
@@ -519,8 +518,7 @@ class Rage::Router::DSL
     end
 
     def to_plural(str)
-      @active_support_loaded ||= str.respond_to?(:pluralize) || :false
-      return str.pluralize if @active_support_loaded != :false
+      return str.pluralize if str.respond_to?(:pluralize)
 
       str.end_with?("s") ? str : "#{str}s"
     end

data/lib/rage/tasks.rb

@@ -7,6 +7,7 @@ class Rage::Tasks
   class << self
     def init
       load_db_tasks if defined?(StandaloneMigrations)
+      load_rage_tasks
       load_app_tasks
     end
 
@@ -40,5 +41,9 @@ class Rage::Tasks
     def load_app_tasks
       Dir[Rage.root.join("lib/tasks/**/*.rake")].each { |file| load file }
     end
+
+    def load_rage_tasks
+      Dir[File.expand_path("tasks/**/*.rake", __dir__)].each { |file| load file }
+    end
   end
 end

data/lib/rage/telemetry/capacity.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Rage::Telemetry
+  ##
+  # The `Rage::Telemetry::Capacity` module exposes framework-owned runtime
+  # state - metrics describing the server's current load and resource utilization
+  # that cannot be derived from existing spans.
+  #
+  # Unlike spans, capacity metrics aren't tied to a specific operation or
+  # event, they reflect the server state at the moment they are read, and
+  # are meant to be sampled periodically rather than triggered by handlers.
+  #
+  # Combine with {Rage::Telemetry.every} to report a metric on a fixed
+  # interval:
+  #
+  #     Rage::Telemetry.every(1000) do
+  #       MyMetrics.gauge("server.queued_connections", Rage::Telemetry::Capacity.queued_connections)
+  #     end
+  #
+  # @see Rage::Telemetry.every
+  #
+  module Capacity
+    class << self
+      # Returns the number of established connections currently waiting in the
+      # kernel accept queue for the server listening sockets. This is the
+      # count of clients that have already completed the TCP handshake but
+      # haven't yet been picked up by the application via `accept()`.
+      #
+      # A value that stays bigger than 0 is a sign the server isn't accepting
+      # connections fast enough to keep up with incoming traffic.
+      #
+      # @raise [NotImplementedError] on non-Linux systems
+      # @return [Integer] the accept-queue depth
+      def queued_connections
+        accept_queue_depth = Iodine::Perf.queued_connections
+        raise NotImplementedError if accept_queue_depth.nil?
+
+        accept_queue_depth
+      end
+    end
+  end
+end

data/lib/rage/telemetry/telemetry.rb

@@ -36,6 +36,24 @@ module Rage::Telemetry
     __registry.keys
   end
 
+  # Registers a block to be executed repeatedly at a fixed interval while the server is running.
+  # The block runs inside a fiber, so blocking I/O inside it (e.g. flushing metrics to a
+  # collector) will not block the server.
+  #
+  # @param interval_ms [Integer] the execution interval in milliseconds
+  # @example Periodically sample GC stats
+  #   Rage::Telemetry.every(1000) { MyMetrics.record_gc_stats(GC.stat) }
+  def self.every(interval_ms, &block)
+    Iodine.run_every(interval_ms) do
+      Fiber.schedule do
+        block.call
+      rescue => e
+        Rage.logger.error("#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}")
+        Rage::Errors.report(e)
+      end
+    end
+  end
+
   # @private
   def self.__registry
     @__registry ||= Spans.constants.each_with_object({}) do |const, memo|
@@ -121,4 +139,5 @@ end
 
 require_relative "tracer"
 require_relative "handler"
+require_relative "capacity"
 Dir["#{__dir__}/spans/*.rb"].each { |span| require_relative span }

data/lib/rage/version.rb

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

data/lib/rage-rb.rb

@@ -182,6 +182,9 @@ module Rage
     alias_method :configuration, :config
   end
 
+  module CLI
+  end
+
   module Router
     module Strategies
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rage-rb
 version: !ruby/object:Gem::Version
-  version: 1.26.1
+  version: 1.28.0
 platform: ruby
 authors:
 - Roman Samoilov
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.5'
+        version: '5.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.5'
+        version: '5.6'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -152,6 +152,10 @@ files:
 - lib/rage/cable/protocols/raw_web_socket_json.rb
 - lib/rage/cable/router.rb
 - lib/rage/cli.rb
+- lib/rage/cli/base.rb
+- lib/rage/cli/code_generator.rb
+- lib/rage/cli/new_app_generator.rb
+- lib/rage/cli/openapi.rb
 - lib/rage/cli/skills.rb
 - lib/rage/code_loader.rb
 - lib/rage/configuration.rb
@@ -233,6 +237,7 @@ files:
 - lib/rage/sse/sse.rb
 - lib/rage/sse/stream.rb
 - lib/rage/tasks.rb
+- lib/rage/telemetry/capacity.rb
 - lib/rage/telemetry/handler.rb
 - lib/rage/telemetry/spans/await_fiber.rb
 - lib/rage/telemetry/spans/broadcast_cable_stream.rb