rage-rb 1.25.1 → 1.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13987c313721651366f9145e9b80d8a83f74c3b16346f2d79b83c3517566d3f7
-  data.tar.gz: ec0c134f49ac88bdd99023b576e00cd057c84e231114d90a43f03d46471bbc55
+  metadata.gz: 7ad60525da974b198db62787784804444e9ad8cb768119a2eeea7f45aefaa93f
+  data.tar.gz: 8bac8c6ac175b486e61bf64a1ca574e590e14bcbacbec0e0da6de59d905de3b9
 SHA512:
-  metadata.gz: 645c87d57e772def70e5c7e298e0383d66551e9ad7d55a3b9eb56e1789c98e119bca6b66e8eb98c7b938b1ae20122a7fad1ab4c508529d328b0436c2ddabe17b
-  data.tar.gz: e1548c087c43f39767484247cb271f625275669f089a22b18e06a5a11a7e4dd39ffe47c6772117b39e62cf1b33c242b343a3b6aaff00bb3aff5501f3473d77a5
+  metadata.gz: 1bd4700b5265c58df651b026c546a2cbe452577bd5f225cdbdfd4f0334d857c024d3d22743fed4db4d98be3eb71ad30e656106ecae80c55cbbc4f0883f0ae619
+  data.tar.gz: 3033c718ad816739c81ff79fa825f662943ea02c9aeade6cd6c5bfb68be6800e9fa79c06d57c3430f623db9f0b41e015e921711bcdf407014e4c0fb62c96ba20

data/Appraisals

@@ -1,7 +1,3 @@
-appraise "active_record_7_0" do
-  gem "activerecord", "~> 7.0.0"
-end
-
 appraise "active_record_7_1" do
   gem "activerecord", "~> 7.1.0"
 end

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 ## [Unreleased]
 
+## [1.26.0] - 2026-07-07
+
+### Added
+
+- [OpenAPI] Add support for blueprint inheritance. Child blueprints now inherit fields from parent blueprints.
+- [OpenAPI] Refactor `Rage::OpenAPI::Parsers::Ext::Blueprinter` using live reflection instead of Prism AST traversal to simplify schema extraction
+- Connection pool improvements (#301).
+- [OpenAPI] Add Blueprinter association parsing with cycle detection (#291)
+- [OpenAPI] Add support for the `view:` option in Blueprinter parser.
+- Add `Rage::Daemon` (#339).
+- Enable non-blocking process monitoring (#341).
+- Allow to suppress FiberWrapper warnings (#347).
+- Add the Extension API (#344).
+
+### Fixed
+
+- [CI] Check all changed PR file pages when requiring changelog updates.
+- [API] Ignore `If-Modified-Since` when `If-None-Match` is present.
+- [API] Use weak comparison for `If-None-Match` validation.
+- [Deferred] Ignore missing temp files during async disk storage cleanup.
+- [Request] Treat IPv6 literals as non-domain hosts.
+- [Router] Fall back to `SERVER_NAME` when deriving exact host constraints.
+- [Cookies] Use request host fallback when resolving cookie domains.
+- [Cookies] Match array-based cookie domains case-insensitively.
+- [API] Reject invalid status symbols in `head` and `render`.
+
 ## [1.25.1] - 2026-06-08
 
 ### Fixed

data/Gemfile

@@ -26,4 +26,5 @@ group :test do
   gem "prism"
   gem "redis-client"
   gem "appraisal", "~> 2.5"
+  gem "blueprinter"
 end

data/Rakefile

@@ -17,6 +17,9 @@ task :appraise do |_, args|
     puts ">> Appraising #{ext_version}"
 
     gem_name = ext_version.sub(/_\d+(_\d+)*$/, "")
-    system "bundle exec appraisal #{ext_version} rspec spec/ext/#{gem_name}/"
+
+    Pathname.new("spec/ext").join(gem_name).glob("*_spec.rb").each do |spec|
+      system("bundle exec appraisal #{ext_version} rspec #{spec}", exception: true)
+    end
   end
 end

data/lib/rage/configuration.rb

@@ -289,6 +289,14 @@ class Rage::Configuration
   end
   # @!endgroup
 
+  # @!group Daemons
+  # Allows configuring daemon settings.
+  # @return [Rage::Configuration::Daemons]
+  def daemons
+    @daemons ||= Daemons.new
+  end
+  # @!endgroup
+
   # @private
   def pubsub
     @pubsub ||= PubSub.new
@@ -630,12 +638,36 @@ class Rage::Configuration
     def initialize
       super
       @objects = [[Rage::FiberWrapper]]
+      @suppress_fiber_wrapper_warning = false
+    end
+
+    # Suppress warnings when inserting middleware before {Rage::FiberWrapper}.
+    #
+    # By default, Rage warns when middleware is inserted before {Rage::FiberWrapper} because such middleware
+    # runs outside the fiber-based request context. This means the middleware won't benefit from Rage's
+    # non-blocking I/O scheduling and must handle the custom response format.
+    #
+    # Use this method when you intentionally want middleware to run outside the request fiber, for example,
+    # to serve static assets without the overhead of creating a fiber for each request.
+    #
+    # @yield The block within which middleware insertion warnings are suppressed
+    # @example Suppress warnings when inserting a static file server
+    #   Rage.configure do
+    #     config.middleware.allow_outside_request_fiber! do
+    #       config.middleware.insert_before 0, MyStaticFileServer
+    #     end
+    #   end
+    def allow_outside_request_fiber!
+      @suppress_fiber_wrapper_warning = true
+      yield
+    ensure
+      @suppress_fiber_wrapper_warning = false
     end
 
     private
 
     def validate!(index, middleware)
-      if index == 0 && @objects[0][0] == Rage::FiberWrapper
+      if index == 0 && @objects[0][0] == Rage::FiberWrapper && !@suppress_fiber_wrapper_warning
         puts "WARNING: inserting the `#{middleware}` middleware before `Rage::FiberWrapper` may cause undefined behavior."
       end
     end
@@ -1115,6 +1147,48 @@ class Rage::Configuration
     end
   end
 
+  class Daemons
+    # @private
+    def initialize
+      @klasses = []
+    end
+
+    # @private
+    attr_reader :klasses
+
+    # Register a new daemon.
+    # @param daemon [Class]
+    # @example
+    #   Rage.configure do
+    #     config.daemons << FileWatcher
+    #   end
+    def <<(daemon)
+      validate!(daemon)
+      @klasses << daemon
+    end
+
+    alias_method :push, :<<
+
+    # Remove a registered daemon.
+    # @param daemon [Class]
+    # @example
+    #   Rage.configure do
+    #     config.daemons.delete(FileWatcher)
+    #   end
+    def delete(daemon)
+      validate!(daemon)
+      @klasses.delete(daemon)
+    end
+
+    private
+
+    def validate!(klass)
+      if !klass.is_a?(Class) || !klass.ancestors.include?(Rage::Daemon)
+        raise ArgumentError, "Cannot add `#{klass}` as a daemon; should inherit `Rage::Daemon`"
+      end
+    end
+  end
+
   # @private
   class PubSub
     attr_reader :adapter

data/lib/rage/controller/api.rb

@@ -499,13 +499,7 @@ class RageController::API
       @__status = 200
     end
 
-    if status
-      @__status = if status.is_a?(Symbol)
-        ::Rack::Utils::SYMBOL_TO_STATUS_CODE[status]
-      else
-        status
-      end
-    end
+    @__status = ::Rack::Utils.status_code(status) if status
 
     if sse
       raise ArgumentError, "Cannot render both a standard body and an SSE stream." unless @__body.empty?
@@ -531,12 +525,7 @@ class RageController::API
   #   head 429
   def head(status)
     @__rendered = true
-
-    @__status = if status.is_a?(Symbol)
-      ::Rack::Utils::SYMBOL_TO_STATUS_CODE[status]
-    else
-      status
-    end
+    @__status = ::Rack::Utils.status_code(status)
   end
 
   # Set response headers.

data/lib/rage/cookies.rb

@@ -201,14 +201,14 @@ class Rage::Cookies
     end
 
     if (domain = value[:domain])
-      host = @env["HTTP_HOST"]&.sub(/:\d+\z/, "")
+      host = Rack::Request.new(@env).host
 
       processed_domain = if domain.is_a?(String)
         domain
       elsif domain == :all
         DomainName(host).domain
       elsif domain.is_a?(Array)
-        host if domain.include?(host)
+        domain.find { |candidate| candidate.casecmp?(host) } if host
       end
     end
 

data/lib/rage/daemon.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+##
+# `Rage::Daemon` is an abstraction for running long-lived background processes alongside your application.
+# Use daemons for tasks that need to run continuously, such as listening to message queues, consuming streaming APIs,
+# or maintaining persistent connections to external services.
+#
+# The framework automatically manages daemon lifecycle:
+# - Daemons are started when the server boots
+# - If a daemon exits or crashes, Rage restarts it with exponential backoff
+# - If a worker process dies, Rage restarts the daemon in another worker
+# - On server shutdown, daemons are gracefully stopped
+#
+# ## Defining a Daemon
+#
+# Create a daemon by subclassing `Rage::Daemon` and implementing the {#perform} method:
+#
+# ```ruby
+# class RedisListener < Rage::Daemon
+#   def perform
+#     redis = Redis.new
+#
+#     redis.subscribe("notifications") do |on|
+#       on.message do |channel, message|
+#         Rage::Cable.broadcast("notifications", message)
+#       end
+#     end
+#   end
+# end
+# ```
+#
+# ## Registering Daemons
+#
+# Register daemons in your application configuration:
+#
+# ```ruby
+# # config/application.rb
+# Rage.configure do
+#   config.daemons << RedisListener
+# end
+# ```
+#
+# ## Daemon Scope
+#
+# By default, daemons run in exactly one worker process per server. Use {scope scope} to change this behavior:
+#
+# ```ruby
+# class MetricsCollector < Rage::Daemon
+#   scope :worker
+#
+#   def perform
+#     # runs in every worker process
+#   end
+# end
+# ```
+#
+# ## Stopping a Daemon
+#
+# Return {Stop} from {#perform} to explicitly stop a daemon without triggering a restart:
+#
+# ```ruby
+# class BatchProcessor < Rage::Daemon
+#   def perform
+#     while (batch = Batch.next_pending)
+#       process(batch)
+#     end
+#
+#     Stop  # all batches processed, stop the daemon
+#   end
+# end
+# ```
+#
+# ## Cleanup
+#
+# Implement the `cleanup` method to release resources when a daemon stops or restarts:
+#
+# ```ruby
+# class StreamConsumer < Rage::Daemon
+#   def perform
+#     @connection = StreamingAPI.connect
+#     @connection.each { |event| process(event) }
+#   end
+#
+#   def cleanup
+#     @connection&.close
+#   end
+# end
+# ```
+#
+# The `cleanup` method is called:
+# - When {#perform} returns normally
+# - When {#perform} raises an exception (before restart)
+# - When the server is shutting down
+#
+class Rage::Daemon
+  # A sentinel value that can be returned from {#perform} to explicitly stop the daemon.
+  # When returned, the daemon will not be restarted.
+  # @example
+  #   def perform
+  #     return Stop if shutdown_requested?
+  #     # ...
+  #   end
+  Stop = Object.new
+
+  INITIAL_BACKOFF = 0.1
+  private_constant :INITIAL_BACKOFF
+
+  MAX_BACKOFF = 30
+  private_constant :MAX_BACKOFF
+
+  BACKOFF_RESET_INTERVAL = 30
+  private_constant :BACKOFF_RESET_INTERVAL
+
+  class << self
+    # @private
+    attr_accessor :__level
+
+    # Configures the scope at which the daemon runs.
+    #
+    # By default, daemons run in one worker process per server (`:node` scope).
+    # Use this method to change the scope when a different behavior is needed.
+    #
+    # @param level [Symbol] the scope level
+    # @option level :node One instance per server (default). Rage uses IPC to coordinate
+    #   which worker runs the daemon. If that worker dies, the daemon restarts in another worker.
+    # @option level :worker One instance per worker process. Use this when the daemon performs
+    #   work that needs to run in parallel across workers.
+    #
+    # @example Running in every worker
+    #   class MetricsCollector < Rage::Daemon
+    #     scope :worker
+    #
+    #     def perform
+    #       # runs in every worker process
+    #     end
+    #   end
+    def scope(level)
+      unless level == :worker || level == :node
+        raise ArgumentError, "Invalid scope level: #{level.inspect}. Valid options are :node and :worker."
+      end
+
+      @__level = level
+    end
+
+    # @private
+    def inherited(klass)
+      klass.__level = __level
+    end
+
+    # @private
+    def __perform
+      if __level.nil? || __level == :node
+        Rage::Internal.pick_a_worker(purpose: "daemon-#{name}") { __execute }
+      else
+        __execute
+      end
+    end
+
+    private
+
+    def __execute
+      Iodine.on_state(:start_shutdown) do
+        @__stopping = true
+      end
+
+      Fiber.schedule do
+        backoff = INITIAL_BACKOFF
+
+        Rage.logger.with_context(daemon: name) do
+          loop do
+            started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+            begin
+              instance = new
+              result = instance.perform
+              break if result.equal?(Stop) || @__stopping
+              Rage.logger.warn("Daemon exited, restarting...")
+            rescue => e
+              break if @__stopping
+              Rage.logger.error("Daemon failed with exception: #{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}")
+              Rage::Errors.report(e)
+            ensure
+              __cleanup(instance)
+            end
+
+            # reset backoff if ran successfully for a while
+            backoff = INITIAL_BACKOFF if Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at > BACKOFF_RESET_INTERVAL
+            sleep(backoff / 2 + rand * backoff / 2)
+            backoff = (backoff * 2).clamp(INITIAL_BACKOFF, MAX_BACKOFF)
+          end
+        end
+      end
+    end # class << self
+
+    def __cleanup(instance)
+      instance.cleanup if instance.respond_to?(:cleanup)
+    rescue => e
+      Rage.logger.error("Cleanup hook failed with exception: #{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}")
+      Rage::Errors.report(e)
+    end
+  end
+
+  # The main entry point for the daemon's work.
+  #
+  # Implement this method to define what the daemon does. The method should contain
+  # the daemon's main loop or blocking operation. When this method returns normally,
+  # Rage logs a warning and restarts the daemon. Return {Stop} to explicitly stop
+  # the daemon without triggering a restart.
+  #
+  # @return [Object] return {Stop} to stop the daemon; any other return value triggers a restart
+  # @example Listening to a Redis channel
+  #   def perform
+  #     redis = Redis.new
+  #     redis.subscribe("events") do |on|
+  #       on.message { |_, msg| handle(msg) }
+  #     end
+  #   end
+  # @example Polling a queue
+  #   def perform
+  #     loop do
+  #       message = queue.pop
+  #       process(message)
+  #     end
+  #   end
+  # @example Processing until complete
+  #   def perform
+  #     while (item = fetch_next_item)
+  #       process(item)
+  #     end
+  #
+  #     Stop
+  #   end
+  def perform
+  end
+end
+
+Iodine.on_state(:on_start) do
+  Fiber.set_scheduler(Rage::FiberScheduler.new) unless Fiber.scheduler
+  Rage.config.daemons.klasses.each { |klass| klass.__perform }
+end

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

@@ -241,8 +241,7 @@ class Rage::Deferred::Backends::Disk
 
     # delete the old storage ensuring the copied data has already been written to disk
     Iodine.run_after(@fsync_frequency) do
-      old_storage.close
-      File.unlink(old_storage.path)
+      cleanup_storage(old_storage)
     end
   end
 
@@ -267,8 +266,13 @@ class Rage::Deferred::Backends::Disk
     end
 
     Iodine.run_after(@fsync_frequency) do
-      storage.close
-      File.unlink(storage.path)
+      cleanup_storage(storage)
     end
   end
+
+  def cleanup_storage(storage)
+    path = storage.path
+    storage.close
+    File.unlink(path) if File.exist?(path)
+  end
 end

data/lib/rage/ext/active_record/connection_pool.rb

@@ -11,7 +11,11 @@ module Rage::Ext::ActiveRecord::ConnectionPool
       @arr << el
     end
 
-    def shift
+    def unshift(el)
+      @arr.unshift(el)
+    end
+
+    def pop
       nil
     end
 
@@ -59,18 +63,27 @@ module Rage::Ext::ActiveRecord::ConnectionPool
     # in the format of { Fiber => Connection }
     @__in_use = {}
 
-    # a list of all DB connections that are currently idle
-    @__connections = build_new_connections
-
     # how long a fiber can wait for a connection to become available
     @__checkout_timeout = checkout_timeout
 
     # how long a connection can be idle for before disconnecting
     @__idle_timeout = respond_to?(:db_config) ? db_config.idle_timeout : @idle_timeout
 
+    # pool will maintain at least this many connections
+    @__min_connections = respond_to?(:min_connections) ? min_connections : 0
+
+    # connections older than this are automatically disconnected
+    @__max_age = respond_to?(:max_age) ? max_age : Float::INFINITY
+
+    # seconds between keepalive pings on idle connections
+    @__keepalive = respond_to?(:keepalive) ? keepalive : nil
+
     # how often should we check for fibers that wait for a connection for too long
     @__timeout_worker_frequency = 0.5
 
+    # a list of all DB connections that are currently idle
+    @__connections = build_new_connections
+
     # reject fibers that wait for a connection for more than `@__checkout_timeout`
     Iodine.run_every((@__timeout_worker_frequency * 1_000).to_i) do
       if @__blocked.length > 0
@@ -105,6 +118,8 @@ module Rage::Ext::ActiveRecord::ConnectionPool
     end
 
     @release_connection_channel = "ext:ar-connection-released:#{object_id}"
+    @__owner_thread = Thread.current
+    @__background_maintenance_disabled = (ActiveRecord.version < Gem::Version.create("8.1"))
 
     # resume blocked fibers once connections become available
     Iodine.subscribe(@release_connection_channel) do
@@ -118,6 +133,14 @@ module Rage::Ext::ActiveRecord::ConnectionPool
     Iodine.on_state(:on_finish) do
       Iodine.unsubscribe(@release_connection_channel)
     end
+
+    Iodine.run_every((db_config.reaping_frequency * 1_000).to_i) do
+      reap
+      flush
+      disconnected = retire_old_connections
+      keep_alive
+      preconnect if disconnected
+    end
   end
 
   # Returns true if there is an open connection being used for the current fiber.
@@ -127,12 +150,10 @@ module Rage::Ext::ActiveRecord::ConnectionPool
 
   # Retrieve the connection associated with the current fiber, or obtain one if necessary.
   def connection
-    @__in_use[Fiber.current] ||= @__connections.shift || begin
-      fiber, blocked_since = Fiber.current, Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      @__blocked[fiber] = blocked_since
+    @__in_use[Fiber.current] ||= @__connections.pop || begin
+      @__blocked[Fiber.current] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       Fiber.yield
-
-      @__connections.shift
+      @__connections.pop
     end
   end
 
@@ -149,45 +170,125 @@ module Rage::Ext::ActiveRecord::ConnectionPool
 
   # Recover lost connections for the pool.
   def reap
-    crashed_fibers = nil
+    return unless Thread.current == @__owner_thread
 
-    @__in_use.each do |fiber, conn|
+    dead = nil
+
+    @__in_use.delete_if do |fiber, conn|
       unless fiber.alive?
+        (dead ||= []) << [fiber, conn]
+        true
+      end
+    end
+
+    dead&.each do |fiber, conn|
+      Fiber.schedule do
         if conn.active?
           conn.reset!
-          (crashed_fibers ||= []) << fiber
+          @__in_use[fiber] = conn
+          release_connection(fiber)
         else
-          @__in_use.delete(fiber)
           conn.disconnect!
           __remove__(conn)
           self.automatic_reconnect = true
-          @__connections += build_new_connections(1)
+          @__connections.unshift(*build_new_connections(1))
           Iodine.publish(@release_connection_channel, "", Iodine::PubSub::PROCESS) if @__blocked.length > 0
         end
       end
     end
-
-    if crashed_fibers
-      crashed_fibers.each { |fiber| release_connection(fiber) }
-    end
   end
 
   # Disconnect all connections that have been idle for at least
   # `minimum_idle` seconds. Connections currently checked out, or that were
   # checked in less than `minimum_idle` seconds ago, are unaffected.
   def flush(minimum_idle = @__idle_timeout)
-    return if minimum_idle.nil? || @__connections.length == 0
+    return if Thread.current != @__owner_thread || minimum_idle.nil? || @__connections.length == 0
 
-    current_time, i = Process.clock_gettime(Process::CLOCK_MONOTONIC), 0
-    while i < @__connections.length
+    current_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    i = @__connections.length - 1
+    connections_to_preserve = @__min_connections
+
+    while i >= 0
       conn = @__connections[i]
+
+      if connections_to_preserve > 0 && conn.connected? && conn.verified?
+        connections_to_preserve -= 1
+        i -= 1
+        next
+      end
+
       if conn.__idle_since && current_time - conn.__idle_since >= minimum_idle
         conn.__idle_since = nil
         conn.__needs_reconnect = true
         conn.disconnect!
       end
+      i -= 1
+    end
+  end
+
+  # Disconnect connections exceeding `max_age`
+  def retire_old_connections(max_age = @__max_age)
+    return false if max_age.nil? || max_age.infinite?
+
+    i, disconnected = 0, false
+
+    while i < @__connections.length
+      conn = @__connections[i]
+      if (conn.connection_age || 0) >= conn.pool_jitter(max_age)
+        conn.disconnect!
+        disconnected = true
+      end
       i += 1
     end
+
+    disconnected
+  end
+
+  # Ping idle connections to prevent firewall/server timeouts
+  def keep_alive(threshold = @__keepalive)
+    return if threshold.nil? || @__connections.length == 0
+
+    to_ping = nil
+
+    @__connections.delete_if do |conn|
+      if (conn.seconds_since_last_activity || 0) >= conn.pool_jitter(threshold)
+        (to_ping ||= []) << conn
+        true
+      end
+    end
+
+    to_ping&.each do |conn|
+      Fiber.schedule do
+        if conn.active?
+          @__connections << conn
+        else
+          conn.disconnect!
+          @__connections.unshift(conn)
+        end
+        Iodine.publish(@release_connection_channel, "", Iodine::PubSub::PROCESS) if @__blocked.length > 0
+      end
+    end
+  end
+
+  # Proactively establish DB connections
+  def preconnect
+    return if @__connections.length == 0 || @__background_maintenance_disabled
+
+    active_connections_count = @__in_use.length + @__connections.count { |conn| conn.connected? && conn.verified? }
+
+    while @__min_connections - active_connections_count > 0
+      i = @__connections.rindex { |conn| !conn.connected? || !conn.verified? }
+      return unless i
+
+      Fiber.schedule do
+        conn = @__connections.delete_at(i)
+        conn.connect! rescue nil
+        @__connections << conn
+        Iodine.publish(@release_connection_channel, "", Iodine::PubSub::PROCESS) if @__blocked.length > 0
+      end
+
+      active_connections_count += 1
+    end
   end
 
   # Disconnect all currently idle connections. Connections currently checked out are unaffected.
@@ -234,6 +335,8 @@ module Rage::Ext::ActiveRecord::ConnectionPool
   # Raises `ActiveRecord::ExclusiveConnectionTimeoutError` if unable to gain ownership of all
   # connections in the pool within a timeout interval (default duration is `checkout_timeout * 2` seconds).
   def disconnect(raise_on_acquisition_timeout = true, disconnect_attempts = 0)
+    return if @__connections.is_a?(BlackHoleList)
+
     # allow request fibers to release connections, but block from acquiring new ones
     if disconnect_attempts == 0
       @__connections = BlackHoleList.new(@__connections)
@@ -288,6 +391,10 @@ module Rage::Ext::ActiveRecord::ConnectionPool
     connection
   end
 
+  def maintainable?
+    false
+  end
+
   # Check in a database connection back into the pool, indicating that you no longer need this connection.
   def checkin(conn)
     fiber = @__in_use.key(conn)
@@ -328,8 +435,12 @@ module Rage::Ext::ActiveRecord::ConnectionPool
   private
 
   def build_new_connections(num_connections = size)
-    (1..num_connections).map do
+    connections = (1..num_connections).map do
       __checkout__.tap { |conn| conn.__idle_since = Process.clock_gettime(Process::CLOCK_MONOTONIC) }
     end
+
+    Iodine.defer { preconnect }
+
+    connections
   end
 end

data/lib/rage/extension.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# @private
+# This needs much more work to make it public, but it's already enough for inertia-rage.
+class Rage::Extension
+  class << self
+    def initializer(id = name, before: nil, after: nil, &block)
+      __initializers[id] << block
+    end
+
+    def configure(&block)
+      __configurations << block
+    end
+
+    def before_server_start(&block)
+      Iodine.on_state(:pre_start, &block)
+    end
+
+    def __initializers
+      @@initializers ||= Hash.new { |h, k| h[k] = [] }
+    end
+
+    def __configurations
+      @@configurations ||= []
+    end
+  end
+end

data/lib/rage/fiber_scheduler.rb

@@ -152,6 +152,11 @@ class Rage::FiberScheduler
     end
   end
 
+  # Wait for a specified process.
+  def process_wait(pid, flags)
+    Thread.new { Process::Status.wait(pid, flags) }.value
+  end
+
   # Create and schedule a new non-blocking fiber, handling request and user-spawned fibers differently.
   def fiber(&block)
     parent = Fiber.current

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

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
 class Rage::OpenAPI::Parsers::Ext::Blueprinter
+  class InvalidViewError < StandardError; end
+
   def initialize(namespace: Object, root: Rage::OpenAPI::Nodes::Root.new, **)
     @namespace = namespace
     @root = root
+    @parsing_stack = Set.new
   end
 
   def known_definition?(str)
@@ -14,97 +17,71 @@ class Rage::OpenAPI::Parsers::Ext::Blueprinter
   end
 
   def parse(klass_str)
-    visitor = __parse(klass_str)
-    visitor.build_schema
-  end
-
-  def __parse(klass_str)
-    is_collection, klass_str, _ = Rage::OpenAPI.__parse_serializer_args(klass_str)
+    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)
 
-    klass = @namespace.const_get(klass_str)
-    source_path, _ = Object.const_source_location(klass.name)
-    ast = Prism.parse_file(source_path)
-
-    visitor = Visitor.new(self, is_collection)
-    ast.value.accept(visitor)
+    if @root.schema_registry.key?(raw_klass_str)
+      @root.schema_registry[raw_klass_str] = is_collection ? schema["items"] : schema
+    end
 
-    visitor
+    schema
+  rescue InvalidViewError => e
+    Rage::OpenAPI.__log_warn e.message
   end
 
-  class VisitorContext
-    attr_accessor :symbols, :keywords, :strings
+  private
 
-    def initialize
-      @symbols = []
-      @strings = []
-      @keywords = {}
-    end
-  end
+  def build_schema(klass, is_collection, serializer_options = nil)
+    @parsing_stack.add(klass.name)
 
-  class Visitor < Prism::Visitor
-    attr_accessor :schema
+    view_name = serializer_options&.key?(:view) ? serializer_options[:view] : :default
+    reflections = klass.reflections
+    view = reflections[view_name]
+    raise InvalidViewError, "invalid view #{view_name}" unless view
 
-    def initialize(parser, is_collection)
-      @parser = parser
-      @is_collection = is_collection
+    identifier_fields = extract_fields(reflections[:identifier])
+    default_fields = extract_fields(view)
+    association_fields = extract_associations(view)
 
-      @context = nil
-      @schema = {}
-      @segment = @schema
-      @identifier = {}
-    end
+    @parsing_stack.delete(klass.name)
 
-    def build_schema
-      result = { "type" => "object" }
+    schema = identifier_fields.merge(default_fields.merge(association_fields).sort.to_h)
 
-      properties = {}
-      properties.merge!(@identifier)
-      properties.merge!(@schema.sort.to_h)
+    result = { "type" => "object" }
+    result["properties"] = schema if schema.any?
+    result = { "type" => "array", "items" => result } if is_collection
+    result
+  end
 
-      result["properties"] = properties if properties.any?
-      result = { "type" => "array", "items" => result } if @is_collection
-      result
+  def extract_fields(view)
+    view.fields.each_with_object({}) do |(_, field), properties|
+      properties[field.display_name.to_s] = { "type" => "string" }
     end
+  end
 
-    def visit_call_node(node)
-      case node.name
-      when :identifier
-        context = with_context { visit(node.arguments) }
-        @identifier[context.symbols.first] = { "type" => "string" }
-
-      when :fields, :field
-        context = with_context { visit(node.arguments) }
-
-        if context.keywords["name"]
-          @segment[context.keywords["name"]] = { "type" => "string" }
-        elsif node.block
-          @segment[context.symbols.first] = { "type" => "string" } if context.symbols.first
-          @segment[context.strings.first] = { "type" => "string" } if context.strings.first
-        else
-          context.symbols.each { |symbol| @segment[symbol] = { "type" => "string" } }
-          context.strings.each { |string| @segment[string] = { "type" => "string" } }
-        end
+  def extract_associations(view)
+    view.associations.each_with_object({}) do |(_, association), properties|
+      blueprint = association.blueprint
+      name, display_name = association.name.to_s, association.display_name.to_s
+      is_collection = collection_association?(name)
+
+      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}" }
+      else
+        build_schema(blueprint, false)
       end
-    end
-
-    def visit_assoc_node(node)
-      @context.keywords[node.key.value] = node.value.unescaped
-    end
 
-    def visit_symbol_node(node)
-      @context.symbols << node.value
-    end
-
-    def visit_string_node(node)
-      @context.strings << node.unescaped
+      properties[display_name] = is_collection ? { "type" => "array", "items" => item_schema } : item_schema
     end
+  end
 
-    private
+  def collection_association?(name)
+    return true unless name.respond_to?(:singularize)
 
-    def with_context
-      @context = VisitorContext.new
-      yield
-      @context
-    end
+    name.singularize != name
   end
 end

data/lib/rage/request.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "ipaddr"
 require "time"
 
 class Rage::Request
@@ -168,16 +169,18 @@ class Rage::Request
   #  request.fresh?(last_modified: Time.utc(2023, 12, 15))
   #  request.fresh?(etag: "123")
   def fresh?(etag:, last_modified:)
+    request_if_none_match = if_none_match
+    request_not_modified_since = if_not_modified_since
+
     # Always render response when no freshness information
     # is provided in the request.
-    return false unless if_none_match || if_not_modified_since
+    return false unless request_if_none_match || request_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
-    )
+    if request_if_none_match
+      etag_matches?(requested_etags: request_if_none_match, response_etag: etag)
+    else
+      not_modified?(request_not_modified_since: request_not_modified_since, response_last_modified: last_modified)
+    end
   end
 
   # Get the domain part of the request.
@@ -245,7 +248,14 @@ class Rage::Request
   end
 
   def named_host?(host)
-    !IP_HOST_REGEXP.match?(host)
+    host && !ip_host?(host)
+  end
+
+  def ip_host?(host)
+    IP_HOST_REGEXP.match?(host) || IPAddr.new(host.delete_prefix("[").delete_suffix("]"))
+    true
+  rescue IPAddr::InvalidAddressError
+    false
   end
 
   def if_none_match
@@ -263,8 +273,10 @@ class Rage::Request
 
     return true if requested_etags.empty?
     return false if response_etag.nil?
+    return true if requested_etags.include?("*")
 
-    requested_etags.include?(response_etag) || requested_etags.include?("*")
+    response_etag = weak_etag(response_etag)
+    requested_etags.any? { |requested_etag| weak_etag(requested_etag) == response_etag }
   end
 
   def not_modified?(request_not_modified_since:, response_last_modified:)
@@ -274,6 +286,10 @@ class Rage::Request
     request_not_modified_since >= response_last_modified
   end
 
+  private def weak_etag(etag)
+    etag.delete_prefix("W/")
+  end
+
   # @private
   class Headers
     HTTP = "HTTP_"

data/lib/rage/router/constrainer.rb

@@ -69,7 +69,7 @@ class Rage::Router::Constrainer
       # Optimization: inline the derivation for the common built in constraints
       if !strategy.custom?
         if key == :host
-          lines << "   host: env['HTTP_HOST'.freeze]&.sub(/:\\d+\\z/, ''.freeze),"
+          lines << "   host: env['HTTP_HOST'.freeze]&.sub(/:\\d+\\z/, ''.freeze) || env['SERVER_NAME'.freeze],"
         else
           raise ArgumentError, "unknown non-custom strategy for compiling constraint derivation function"
         end

data/lib/rage/setup.rb

@@ -7,6 +7,7 @@ rescue LoadError
 end
 
 # Run application initializers
+Rage::Extension.__initializers.values.flatten.each(&:call) if Rage::Extension.subclasses.any?
 Dir["#{Rage.root}/config/initializers/**/*.rb"].each { |initializer| load(initializer) }
 
 require "rage/ext/setup"

data/lib/rage/templates/db-templates/mysql/config-database.yml

@@ -4,7 +4,7 @@
 default: &default
   adapter: mysql2
   encoding: utf8mb4
-  pool: <%%= ENV.fetch("DB_MAX_CONNECTIONS") { 5 } %>
+  max_connections: <%%= ENV.fetch("DB_MAX_CONNECTIONS") { 5 } %>
   username: root
   password:
   socket: /tmp/mysql.sock

data/lib/rage/templates/db-templates/postgresql/config-database.yml

@@ -4,7 +4,7 @@
 default: &default
   adapter: postgresql
   encoding: unicode
-  pool: <%%= ENV.fetch("DB_MAX_CONNECTIONS") { 5 } %>
+  max_connections: <%%= ENV.fetch("DB_MAX_CONNECTIONS") { 5 } %>
 
 development:
   <<: *default

data/lib/rage/templates/db-templates/sqlite3/config-database.yml

@@ -3,7 +3,7 @@
 #
 default: &default
   adapter: sqlite3
-  pool: <%%= ENV.fetch("DB_MAX_CONNECTIONS") { 5 } %>
+  max_connections: <%%= ENV.fetch("DB_MAX_CONNECTIONS") { 5 } %>
   timeout: 5000
 
 development:

data/lib/rage/templates/db-templates/trilogy/config-database.yml

@@ -4,7 +4,7 @@
 default: &default
   adapter: trilogy
   encoding: utf8mb4
-  pool: <%%= ENV.fetch("DB_MAX_THREADS") { 5 } %>
+  max_connections: <%%= ENV.fetch("DB_MAX_THREADS") { 5 } %>
   username: root
   password:
   socket: /tmp/mysql.sock

data/lib/rage/version.rb

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

data/lib/rage-rb.rb

@@ -84,6 +84,12 @@ module Rage
   #     config.log_level = :debug
   #   end
   def self.configure(&)
+    if Rage::Extension.subclasses.any? && !@__extension_config_applied
+      Rage::Extension.__configurations.each { |block| config.instance_eval(&block) }
+      config.__finalize
+      @__extension_config_applied = true
+    end
+
     config.instance_eval(&)
     config.__finalize
   end
@@ -198,6 +204,7 @@ module Rage
   autoload :Deferred, "rage/deferred/deferred"
   autoload :Events, "rage/events/events"
   autoload :PubSub, "rage/pubsub/pubsub"
+  autoload :Daemon, "rage/daemon"
 end
 
 module RageController
@@ -206,3 +213,4 @@ end
 
 require_relative "rage/env"
 require_relative "rage/internal"
+require_relative "rage/extension"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rage-rb
 version: !ruby/object:Gem::Version
-  version: 1.25.1
+  version: 1.26.0
 platform: ruby
 authors:
 - Roman Samoilov
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '5.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '5.5'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -158,6 +158,7 @@ files:
 - lib/rage/controller/api.rb
 - lib/rage/controller/renderers.rb
 - lib/rage/cookies.rb
+- lib/rage/daemon.rb
 - lib/rage/deferred/backends/disk.rb
 - lib/rage/deferred/backends/nil.rb
 - lib/rage/deferred/context.rb
@@ -174,6 +175,7 @@ files:
 - lib/rage/events/subscriber.rb
 - lib/rage/ext/active_record/connection_pool.rb
 - lib/rage/ext/setup.rb
+- lib/rage/extension.rb
 - lib/rage/fiber.rb
 - lib/rage/fiber_scheduler.rb
 - lib/rage/hooks.rb