rage-rb 1.9.0 → 1.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8b2423a2cb780fd3f8ffc4e76a6690fff37162836e3d2d64791c7f058b3d63f
-  data.tar.gz: 86c2ee3464e5668e78409d7eae2e987c4e6a5aa54bea024c7cca694dd142019e
+  metadata.gz: 87a1aecc1f62917581dee82c9efe0d56cebc69046500eeaf7f2e73aa7f35f809
+  data.tar.gz: 6e890b8641f214b2cfbebc2fd56bc1f5a32f2f8c2281cbf8f62d3a607d05c4ad
 SHA512:
-  metadata.gz: cc810e46ff275e4595c2631f3cb5cbd19d38dd42885b393bb240ffb8b96ff6cb6f0f93015a461c469cbb88e13cbcc53288f385db590bd2562dc604a4d38b423e
-  data.tar.gz: 6be5256d0c92fd495f6afa2ba3d9f6a08cfe6058429040f10d035594ad9a54d050241fa443029836042e7435681563f36bfee89b04eecaeb31055206adff41ef
+  metadata.gz: c659a925cd991c383714d48e803a93edec1703c5e99aacd73d7c4748be00e77ec8077f6c86ec31c13c8fab373c9ef22bc11fec647b0bc233abec710967a827f4
+  data.tar.gz: a0085405ad42e00730128e942b72abf9944f9344d2e9d5b178b393f8f019b517b430a0b3bf3ac7dd8b8e575392e4f79f7c0cc8531093be3d8100a549f13583f2

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [1.10.1] - 2024-09-17
+
+### Fixed
+
+- Patch AR pool even if `Rake` is defined (#105).
+
+## [1.10.0] - 2024-09-16
+
+### Changed
+
+- Enable Rage Connection Pool by default (#103).
+- Allow to preconfigure the app for selected database (#104).
+
+### Added
+
+- Add `version` and `middleware` CLI commands (#99).
+
 ## [1.9.0] - 2024-08-24
 
 ### Added

data/Gemfile

@@ -9,7 +9,7 @@ gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
 gem "yard"
-gem "rubocop", "~> 1.65", require: false
+gem "rubocop", "~> 1.65.0", require: false
 
 group :test do
   gem "http"

data/README.md

@@ -59,6 +59,7 @@ Also, see the following integration guides:
 
 - [Rails integration](https://github.com/rage-rb/rage/wiki/Rails-integration)
 - [RSpec integration](https://github.com/rage-rb/rage/wiki/RSpec-integration)
+- [WebSockets guide](https://github.com/rage-rb/rage/wiki/WebSockets-guide)
 
 If you are a first-time contributor, make sure to check the [overview doc](https://github.com/rage-rb/rage/blob/master/OVERVIEW.md) that shows how Rage's core components interact with each other.
 
@@ -154,7 +155,7 @@ end
 ```ruby
 class BenchmarksController < ApplicationController
   def show
-    render json: World.find(rand(10_000))
+    render json: World.find(rand(1..10_000))
   end
 end
 ```
@@ -172,8 +173,8 @@ Status | Changes
 :white_check_mark: | ~~Automatic code reloading in development with Zeitwerk.~~
 :white_check_mark: | ~~Support conditional get with `etag` and `last_modified`.~~
 :white_check_mark: | ~~Expose the `cookies` and `session` objects.~~
+:white_check_mark: | ~~Implement Iodine-based equivalent of Action Cable.~~
 ⏳ | Expose the `send_data` and `send_file` methods.
-⏳ | Implement Iodine-based equivalent of Action Cable.
 
 ## Development
 

data/lib/rage/cable/channel.rb

@@ -135,7 +135,7 @@ class Rage::Cable::Channel
       end
 
       is_subscribing = action_name == :subscribed
-      activerecord_loaded = defined?(::ActiveRecord)
+      should_release_connections = Rage.config.internal.should_manually_release_ar_connections?
 
       method_name = class_eval <<~RUBY, __FILE__, __LINE__ + 1
         def __run_#{action_name}(data)
@@ -163,12 +163,10 @@ class Rage::Cable::Channel
           #{periodic_timers_chunk}
           #{rescue_handlers_chunk}
 
-          #{if activerecord_loaded
+          #{if should_release_connections
             <<~RUBY
             ensure
-              if ActiveRecord::Base.connection_pool.active_connection?
-                ActiveRecord::Base.connection_handler.clear_active_connections!
-              end
+              ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
             RUBY
           end}
         end

data/lib/rage/cli.rb

@@ -2,17 +2,57 @@
 
 require "thor"
 require "rack"
+require "rage/version"
 
 module Rage
+  class CLICodeGenerator < Thor
+    include Thor::Actions
+
+    def self.source_root
+      File.expand_path("templates", __dir__)
+    end
+
+    desc "migration NAME", "Generate a new migration."
+    def migration(name = nil)
+      return help("migration") if name.nil?
+
+      setup
+      Rake::Task["db:new_migration"].invoke(name)
+    end
+
+    desc "model NAME", "Generate a new model."
+    def model(name = nil)
+      return help("model") if name.nil?
+
+      setup
+      migration("create_#{name.pluralize}")
+      @model_name = name.classify
+      template("model-template/model.rb", "app/models/#{name.singularize.underscore}.rb")
+    end
+
+    private
+
+    def setup
+      @setup ||= begin
+        require "rake"
+        load "Rakefile"
+      end
+    end
+  end
+
   class CLI < Thor
     def self.exit_on_failure?
       true
     end
 
     desc "new PATH", "Create a new application."
-    def new(path)
+    option :database, aliases: "-d", desc: "Preconfigure for selected database.", enum: %w(mysql trilogy postgresql sqlite3)
+    option :help, aliases: "-h", desc: "Show this message."
+    def new(path = nil)
+      return help("new") if options.help? || path.nil?
+
       require "rage/all"
-      NewAppGenerator.start([path])
+      CLINewAppGenerator.start([path, options[:database]])
     end
 
     desc "s", "Start the app server."
@@ -115,6 +155,57 @@ module Rage
       IRB.start
     end
 
+    desc "middleware", "List Rack middleware stack enabled for the application"
+    def middleware
+      environment
+
+      Rage.config.middleware.middlewares.each do |middleware|
+        say "use #{middleware.first.name}"
+      end
+    end
+
+    desc "version", "Return the current version of the framework"
+    def version
+      puts Rage::VERSION
+    end
+
+    map "generate" => :g
+    desc "g TYPE", "Generate new code."
+    subcommand "g", CLICodeGenerator
+
+    map "--tasks" => :tasks
+    desc "--tasks", "See the list of available tasks."
+    def tasks
+      require "io/console"
+
+      tasks = linked_rake_tasks
+      return if tasks.empty?
+
+      _, max_width = IO.console.winsize
+      max_task_name = tasks.max_by { |task| task.name.length }.name.length + 2
+      max_comment = max_width - max_task_name - 8
+
+      tasks.each do |task|
+        comment = task.comment.length <= max_comment ? task.comment : "#{task.comment[0...max_comment - 5]}..."
+        puts sprintf("rage %-#{max_task_name}s # %s", task.name, comment)
+      end
+    end
+
+    def method_missing(method_name, *, &)
+      set_env({})
+
+      if respond_to?(method_name)
+        Rake::Task[method_name].invoke
+      else
+        suggestions = linked_rake_tasks.map(&:name)
+        raise UndefinedCommandError.new(method_name.to_s, suggestions, nil)
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      linked_rake_tasks.any? { |task| task.name == method_name.to_s } || super
+    end
+
     private
 
     def environment
@@ -126,30 +217,85 @@ module Rage
     end
 
     def set_env(options)
-      ENV["RAGE_ENV"] = options[:environment] if options[:environment]
+      if options[:environment]
+        ENV["RAGE_ENV"] = ENV["RAILS_ENV"] = options[:environment]
+      elsif ENV["RAGE_ENV"]
+        ENV["RAILS_ENV"] = ENV["RAGE_ENV"]
+      elsif ENV["RAILS_ENV"]
+        ENV["RAGE_ENV"] = ENV["RAILS_ENV"]
+      else
+        ENV["RAGE_ENV"] = ENV["RAILS_ENV"] = "development"
+      end
+    end
 
-      # at this point we don't know whether the app is running in standalone or Rails mode;
-      # we set both variables to make sure applications are running in the same environment;
-      ENV["RAILS_ENV"] = ENV["RAGE_ENV"] if ENV["RAGE_ENV"] && ENV["RAILS_ENV"] != ENV["RAGE_ENV"]
+    def linked_rake_tasks
+      require "rake"
+      Rake::TaskManager.record_task_metadata = true
+      load "Rakefile"
+
+      Rake::Task.tasks.select { |task| !task.comment.nil? && task.name.start_with?("db:") }
     end
   end
 
-  class NewAppGenerator < Thor::Group
+  class CLINewAppGenerator < Thor::Group
     include Thor::Actions
     argument :path, type: :string
+    argument :database, type: :string, required: false
 
     def self.source_root
       File.expand_path("templates", __dir__)
     end
 
+    def setup
+      @use_database = !database.nil?
+    end
+
     def create_directory
       empty_directory(path)
     end
 
     def copy_files
-      Dir.glob("*", base: self.class.source_root).each do |template|
+      inject_templates
+    end
+
+    def install_database
+      return unless @use_database
+
+      @app_name = path.tr("-", "_").downcase
+      append_to_file "#{path}/Gemfile", <<~RUBY
+
+        gem "#{get_db_gem_name}"
+        gem "activerecord"
+        gem "standalone_migrations", require: false
+      RUBY
+
+      inject_templates("db-templates")
+      inject_templates("db-templates/#{database}")
+    end
+
+    private
+
+    def inject_templates(from = nil)
+      root = "#{self.class.source_root}/#{from}"
+
+      Dir.glob("*", base: root).each do |template|
+        next if File.directory?("#{root}/#{template}")
+
         *template_path_parts, template_name = template.split("-")
-        template(template, "#{path}/#{template_path_parts.join("/")}/#{template_name}")
+        template("#{root}/#{template}", [path, *template_path_parts, template_name].join("/"))
+      end
+    end
+
+    def get_db_gem_name
+      case database
+      when "mysql"
+        "mysql2"
+      when "trilogy"
+        "trilogy"
+      when "postgresql"
+        "pg"
+      when "sqlite3"
+        "sqlite3"
       end
     end
   end

data/lib/rage/configuration.rb

@@ -130,9 +130,13 @@
 #
 # > Disables the `io_write` hook to fix the ["zero-length iov"](https://bugs.ruby-lang.org/issues/19640) error on Ruby < 3.3.
 #
-# • _RAGE_PATCH_AR_POOL_
+# • _RAGE_DISABLE_AR_POOL_PATCH_
 #
-# > Enables the `ActiveRecord::ConnectionPool` patch to optimize database connection management. Use it to increase throughput under high load.
+# > Disables the `ActiveRecord::ConnectionPool` patch and makes Rage use the original ActiveRecord implementation.
+#
+# • _RAGE_DISABLE_AR_WEAK_CONNECTIONS_
+#
+# > Instructs Rage to not reuse Active Record connections between different fibers.
 #
 class Rage::Configuration
   attr_accessor :logger
@@ -264,6 +268,22 @@ class Rage::Configuration
   class Internal
     attr_accessor :rails_mode
 
+    def patch_ar_pool?
+      !ENV["RAGE_DISABLE_AR_POOL_PATCH"] && !Rage.env.test?
+    end
+
+    # whether we should manually release AR connections;
+    # AR 7.2+ uses `with_connection` internaly, so we only need to do this for older versions;
+    def should_manually_release_ar_connections?
+      defined?(ActiveRecord) && ActiveRecord.version < Gem::Version.create("7.2.0")
+    end
+
+    # whether we should manually reconnect closed AR connections;
+    # AR 7.1+ does this automatically while executing the query;
+    def should_manually_restore_ar_connections?
+      defined?(ActiveRecord) && ActiveRecord.version < Gem::Version.create("7.1.0")
+    end
+
     def inspect
       "#<#{self.class.name}>"
     end

data/lib/rage/controller/api.rb

@@ -76,8 +76,6 @@ class RageController::API
         ""
       end
 
-      activerecord_loaded = defined?(::ActiveRecord)
-
       wrap_parameters_chunk = if __wrap_parameters_key
         <<~RUBY
           wrap_key = self.class.__wrap_parameters_key
@@ -95,9 +93,12 @@ class RageController::API
         RUBY
       end
 
+      query_cache_enabled = defined?(::ActiveRecord)
+      should_release_connections = Rage.config.internal.should_manually_release_ar_connections?
+
       class_eval <<~RUBY, __FILE__, __LINE__ + 1
         def __run_#{action}
-          #{if activerecord_loaded
+          #{if query_cache_enabled
             <<~RUBY
               ActiveRecord::Base.connection_pool.enable_query_cache!
             RUBY
@@ -119,12 +120,15 @@ class RageController::API
           #{rescue_handlers_chunk}
 
         ensure
-          #{if activerecord_loaded
+          #{if query_cache_enabled
             <<~RUBY
               ActiveRecord::Base.connection_pool.disable_query_cache!
-              if ActiveRecord::Base.connection_pool.active_connection?
-                ActiveRecord::Base.connection_handler.clear_active_connections!
-              end
+            RUBY
+          end}
+
+          #{if should_release_connections
+            <<~RUBY
+              ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
             RUBY
           end}
 

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

@@ -24,11 +24,30 @@ module Rage::Ext::ActiveRecord::ConnectionPool
     end
   end
 
+  # reconnect closed connections on checkout;
+  # only included with `Rage.config.should_manually_restore_ar_connections?`
+  module ConnectionWithVerify
+    def connection
+      conn = super
+
+      if conn.__needs_reconnect
+        conn.reconnect!
+        conn.__needs_reconnect = false
+      end
+
+      conn
+    end
+  end
+  if Rage.config.internal.should_manually_restore_ar_connections?
+    prepend ConnectionWithVerify
+  end
+
   def self.extended(instance)
     instance.class.alias_method :__checkout__, :checkout
     instance.class.alias_method :__remove__, :remove
 
     ActiveRecord::ConnectionAdapters::AbstractAdapter.attr_accessor(:__idle_since)
+    ActiveRecord::ConnectionAdapters::AbstractAdapter.attr_accessor(:__needs_reconnect)
   end
 
   def __init_rage_extension
@@ -47,7 +66,7 @@ module Rage::Ext::ActiveRecord::ConnectionPool
     @__checkout_timeout = checkout_timeout
 
     # how long a connection can be idle for before disconnecting
-    @__idle_timeout = reaper.frequency
+    @__idle_timeout = respond_to?(:db_config) ? db_config.idle_timeout : @idle_timeout
 
     # how often should we check for fibers that wait for a connection for too long
     @__timeout_worker_frequency = 0.5
@@ -65,8 +84,30 @@ module Rage::Ext::ActiveRecord::ConnectionPool
       end
     end
 
+    # monitor connections health
+    if Rage.config.internal.should_manually_restore_ar_connections?
+      Iodine.run_every(1_000) do
+        i = 0
+        while i < @__connections.length
+          conn = @__connections[i]
+
+          unless conn.__needs_reconnect
+            needs_reconnect = !conn.active? rescue true
+            if needs_reconnect
+              conn.__needs_reconnect = true
+              conn.disconnect!
+            end
+          end
+
+          i += 1
+        end
+      end
+    end
+
+    @release_connection_channel = "ext:ar-connection-released:#{object_id}"
+
     # resume blocked fibers once connections become available
-    Iodine.subscribe("ext:ar-connection-released") do
+    Iodine.subscribe(@release_connection_channel) do
       if @__blocked.length > 0 && @__connections.length > 0
         f, _ = @__blocked.shift
         f.resume
@@ -75,7 +116,7 @@ module Rage::Ext::ActiveRecord::ConnectionPool
 
     # unsubscribe on shutdown
     Iodine.on_state(:on_finish) do
-      Iodine.unsubscribe("ext:ar-connection-released")
+      Iodine.unsubscribe(@release_connection_channel)
     end
   end
 
@@ -100,7 +141,7 @@ module Rage::Ext::ActiveRecord::ConnectionPool
     if (conn = @__in_use.delete(owner))
       conn.__idle_since = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       @__connections << conn
-      Iodine.publish("ext:ar-connection-released", "", Iodine::PubSub::PROCESS) if @__blocked.length > 0
+      Iodine.publish(@release_connection_channel, "", Iodine::PubSub::PROCESS) if @__blocked.length > 0
     end
 
     conn
@@ -108,20 +149,27 @@ module Rage::Ext::ActiveRecord::ConnectionPool
 
   # Recover lost connections for the pool.
   def reap
+    crashed_fibers = nil
+
     @__in_use.each do |fiber, conn|
       unless fiber.alive?
         if conn.active?
           conn.reset!
-          release_connection(fiber)
+          (crashed_fibers ||= []) << fiber
         else
           @__in_use.delete(fiber)
           conn.disconnect!
           __remove__(conn)
+          self.automatic_reconnect = true
           @__connections += build_new_connections(1)
-          Iodine.publish("ext:ar-connection-released", "", Iodine::PubSub::PROCESS) if @__blocked.length > 0
+          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
@@ -135,6 +183,7 @@ module Rage::Ext::ActiveRecord::ConnectionPool
       conn = @__connections[i]
       if conn.__idle_since && current_time - conn.__idle_since >= minimum_idle
         conn.__idle_since = nil
+        conn.__needs_reconnect = true
         conn.disconnect!
       end
       i += 1
@@ -212,11 +261,12 @@ module Rage::Ext::ActiveRecord::ConnectionPool
     end
 
     # create a new pool
+    self.automatic_reconnect = true
     @__connections = build_new_connections
 
     # notify blocked fibers that there are new connections available
     [@__blocked.length, @__connections.length].min.times do
-      Iodine.publish("ext:ar-connection-released", "", Iodine::PubSub::PROCESS)
+      Iodine.publish(@release_connection_channel, "", Iodine::PubSub::PROCESS)
     end
   end
 

data/lib/rage/ext/setup.rb

@@ -1,19 +1,45 @@
+if defined?(ActiveRecord) && ActiveRecord.version < Gem::Version.create("6")
+  fail "Rage is only compatible with Active Record 6+. Detected Active Record version: #{ActiveRecord.version}."
+end
+
 # set ActiveSupport isolation level
 if defined?(ActiveSupport::IsolatedExecutionState)
   ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
 end
 
+# patch Active Record 6.0 to accept the role argument
+if defined?(ActiveRecord) && ActiveRecord.version < Gem::Version.create("6.1")
+  %i(active_connections? connection_pool_list clear_active_connections!).each do |m|
+    ActiveRecord::Base.connection_handler.define_singleton_method(m) do |_ = nil|
+      super()
+    end
+  end
+end
+
 # release ActiveRecord connections on yield
-if defined?(ActiveRecord) && ActiveRecord.version < Gem::Version.create("7.1.0")
-  class Fiber
-    def self.defer
-      res = Fiber.yield
+if defined?(ActiveRecord) && Rage.config.internal.patch_ar_pool?
+  if ENV["RAGE_DISABLE_AR_WEAK_CONNECTIONS"]
+    unless Rage.config.internal.should_manually_release_ar_connections?
+      puts "WARNING: The RAGE_DISABLE_AR_WEAK_CONNECTIONS setting does not have any effect with Active Record 7.2+"
+    end
+  elsif Rage.config.internal.should_manually_release_ar_connections?
+    class Fiber
+      def self.defer(fileno)
+        f = Fiber.current
+        f.__awaited_fileno = fileno
 
-      if ActiveRecord::Base.connection_pool.active_connection?
-        ActiveRecord::Base.connection_handler.clear_active_connections!
-      end
+        res = Fiber.yield
+
+        if ActiveRecord::Base.connection_handler.active_connections?(:all)
+          Iodine.defer do
+            if fileno != f.__awaited_fileno || !f.alive?
+              ActiveRecord::Base.connection_handler.connection_pool_list(:all).each { |pool| pool.release_connection(f) }
+            end
+          end
+        end
 
-      res
+        res
+      end
     end
   end
 end
@@ -30,7 +56,44 @@ if defined?(ActiveRecord::ConnectionAdapters::ConnectionPool)
   end
 end
 
+# connect to the database in standalone mode
+database_url, database_file = ENV["DATABASE_URL"], Rage.root.join("config/database.yml")
+if defined?(ActiveRecord) && !Rage.config.internal.rails_mode && (database_url || database_file.exist?)
+  # transform database URL to an object
+  database_url_config = if database_url.nil?
+    {}
+  elsif ActiveRecord.version >= Gem::Version.create("6.1.0")
+    ActiveRecord::Base.configurations
+    ActiveRecord::DatabaseConfigurations::ConnectionUrlResolver.new(database_url).to_hash
+  else
+    ActiveRecord::ConnectionAdapters::ConnectionSpecification::ConnectionUrlResolver.new(database_url).to_hash
+  end
+  database_url_config.transform_keys!(&:to_s)
+
+  # load config/database.yml
+  if database_file.exist?
+    database_file_config = begin
+      require "yaml"
+      require "erb"
+      YAML.safe_load(ERB.new(database_file.read).result, aliases: true)
+    end
+
+    # merge database URL config into the file config (only if we have one database)
+    database_file_config.transform_values! do |env_config|
+      env_config.all? { |_, v| v.is_a?(Hash) } ? env_config : env_config.merge(database_url_config)
+    end
+  end
+
+  ActiveRecord::Base.configurations = database_file_config || { Rage.env.to_s => database_url_config }
+  ActiveRecord::Base.establish_connection(Rage.env.to_sym)
+
+  unless defined?(Rake)
+    ActiveRecord::Base.logger = Rage.logger if Rage.logger.debug?
+    ActiveRecord::Base.connection_pool.with_connection {} # validate the connection
+  end
+end
+
 # patch `ActiveRecord::ConnectionPool`
-if defined?(ActiveRecord) && ENV["RAGE_PATCH_AR_POOL"] && !Rage.env.test?
+if defined?(ActiveRecord) && Rage.config.internal.patch_ar_pool?
   Rage.patch_active_record_connection_pool
 end

data/lib/rage/fiber.rb

@@ -39,6 +39,43 @@
 # Many developers see fibers as "lightweight threads" that should be used in conjunction with fiber pools, the same way we use thread pools for threads.<br>
 # Instead, it makes sense to think of fibers as regular Ruby objects. We don't use a pool of arrays when we need to create an array - we create a new object and let Ruby and the GC do their job.<br>
 # Same applies to fibers. Feel free to create as many fibers as you need on demand.
+#
+# ## Active Record Connections
+#
+# Let's consider the following controller, where we update a record in the database:
+#
+# ```ruby
+# class UsersController < RageController::API
+#   def update
+#     User.update!(params[:id], email: params[:email])
+#     render status: :ok
+#   end
+# end
+# ```
+#
+# The `User.update!` call here checks out an Active Record connection, and Rage will automatically check it back in once the action is completed. So far so good!
+#
+# Let's consider another example:
+#
+# ```ruby
+# require "net/http"
+#
+# class UsersController < RageController::API
+#   def update
+#     User.update!(params[:id], email: params[:email]) # takes 5ms
+#     Net::HTTP.post_form(URI("https://mailing.service/update"), { user_id: params[:id] }) # takes 50ms
+#     render status: :ok
+#   end
+# end
+# ```
+#
+# Here, we've added another step: once the record is updated, we will send a request to update the user's data in the mailing list service.
+#
+# However, in this case, we want to release the Active Record connection before the action is completed. You can see that we need the connection only for the `User.update!` call.
+# The next 50ms the code will spend waiting for the HTTP request to finish, and if we don't release the Active Record connection right away, other fibers won't be able to use it.
+#
+# Active Record 7.2 handles this case by using [#with_connection](https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/ConnectionPool.html#method-i-with_connection) internally.
+# With older Active Record versions, Rage handles this case on its own by keeping track of blocking calls and releasing Active Record connections between them.
 class Fiber
   # @private
   AWAIT_ERROR_MESSAGE = "err"
@@ -81,6 +118,9 @@ class Fiber
     "block:#{object_id}:#{@__block_channel_i}"
   end
 
+  # @private
+  attr_accessor :__awaited_fileno
+
   # @private
   # pause a fiber and resume in the next iteration of the event loop
   def self.pause
@@ -138,7 +178,7 @@ class Fiber
       end
     end
 
-    Fiber.yield
+    Fiber.defer(-1)
     Iodine.defer { Iodine.unsubscribe("await:#{f.object_id}") }
 
     # if num_wait_for is not 0 means we exited prematurely because of an error

data/lib/rage/fiber_scheduler.rb

@@ -14,9 +14,9 @@ class Rage::FiberScheduler
     f = Fiber.current
     ::Iodine::Scheduler.attach(io.fileno, events, timeout&.ceil || 0) { |err| f.resume(err) }
 
-    err = Fiber.defer
-    if err == Errno::ETIMEDOUT::Errno
-      0
+    err = Fiber.defer(io.fileno)
+    if err && err < 0
+      err
     else
       events
     end

data/lib/rage/logger/logger.rb

@@ -82,7 +82,7 @@ class Rage::Logger
     end
 
     @formatter = formatter
-    @level = level
+    @level = @logdev ? level : Logger::UNKNOWN
     define_log_methods
   end
 

data/lib/rage/setup.rb

@@ -9,9 +9,9 @@ end
 # Run application initializers
 Dir["#{Rage.root}/config/initializers/**/*.rb"].each { |initializer| load(initializer) }
 
+require "rage/ext/setup"
+
 # Load application classes
 Rage.code_loader.setup
 
 require_relative "#{Rage.root}/config/routes"
-
-require "rage/ext/setup"

data/lib/rage/tasks.rb

@@ -0,0 +1,33 @@
+begin
+  require "standalone_migrations"
+rescue LoadError
+end
+
+class Rage::Tasks
+  class << self
+    def init
+      load_db_tasks if defined?(StandaloneMigrations)
+    end
+
+    private
+
+    def load_db_tasks
+      StandaloneMigrations::Configurator.prepend(Module.new do
+        def configuration_file
+          @path ||= begin
+            @__tempfile = Tempfile.new
+            @__tempfile.write <<~YAML
+              config:
+                database: config/database.yml
+            YAML
+            @__tempfile.close
+
+            @__tempfile.path
+          end
+        end
+      end)
+
+      StandaloneMigrations::Tasks.load_tasks
+    end
+  end
+end

data/lib/rage/templates/Rakefile

@@ -1 +1,2 @@
 require_relative "config/application"
+Rage.load_tasks

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

@@ -2,6 +2,9 @@ require "bundler/setup"
 require "rage"
 Bundler.require(*Rage.groups)
 
+<% if @use_database -%>
+require "active_record"
+<% end -%>
 require "rage/all"
 
 Rage.configure do

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

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

data/lib/rage/templates/db-templates/app-models-application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/lib/rage/templates/db-templates/db-seeds.rb

@@ -0,0 +1,9 @@
+# This file should ensure the existence of records required to run the application in every environment (production,
+# development, test). The code here should be idempotent so that it can be executed at any point in every environment.
+# The data can then be loaded with the bin/rails db:seed command (or created alongside the database with db:setup).
+#
+# Example:
+#
+#   ["Action", "Comedy", "Drama", "Horror"].each do |genre_name|
+#     MovieGenre.find_or_create_by!(name: genre_name)
+#   end

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

@@ -0,0 +1,24 @@
+##
+# MySQL. Versions 5.5.8 and up are supported.
+#
+default: &default
+  adapter: mysql2
+  encoding: utf8mb4
+  pool: <%%= ENV.fetch("DB_MAX_CONNECTIONS") { 5 } %>
+  username: root
+  password:
+  socket: /tmp/mysql.sock
+
+development:
+  <<: *default
+  database: <%= @app_name %>_development
+
+test:
+  <<: *default
+  database: <%= @app_name %>_test
+
+production:
+  <<: *default
+  database: <%= @app_name %>_production
+  username: <%= @app_name %>
+  password: <%%= ENV["<%= @app_name.upcase %>_DATABASE_PASSWORD"] %>

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

@@ -0,0 +1,21 @@
+##
+# PostgreSQL. Versions 9.3 and up are supported.
+#
+default: &default
+  adapter: postgresql
+  encoding: unicode
+  pool: <%%= ENV.fetch("DB_MAX_CONNECTIONS") { 5 } %>
+
+development:
+  <<: *default
+  database: <%= @app_name %>_development
+
+test:
+  <<: *default
+  database: <%= @app_name %>_test
+
+production:
+  <<: *default
+  database: <%= @app_name %>_production
+  username: <%= @app_name %>
+  password: <%%= ENV["<%= @app_name.upcase %>_DATABASE_PASSWORD"] %>

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

@@ -0,0 +1,19 @@
+##
+# SQLite. Versions 3.8.0 and up are supported.
+#
+default: &default
+  adapter: sqlite3
+  pool: <%%= ENV.fetch("DB_MAX_CONNECTIONS") { 5 } %>
+  timeout: 5000
+
+development:
+  <<: *default
+  database: storage/development.sqlite3
+
+test:
+  <<: *default
+  database: storage/test.sqlite3
+
+production:
+  <<: *default
+  database: storage/production.sqlite3

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

@@ -0,0 +1,24 @@
+##
+# MySQL. Versions 5.5.8 and up are supported.
+#
+default: &default
+  adapter: trilogy
+  encoding: utf8mb4
+  pool: <%%= ENV.fetch("DB_MAX_THREADS") { 5 } %>
+  username: root
+  password:
+  socket: /tmp/mysql.sock
+
+development:
+  <<: *default
+  database: <%= @app_name %>_development
+
+test:
+  <<: *default
+  database: <%= @app_name %>_test
+
+production:
+  <<: *default
+  database: <%= @app_name %>_production
+  username: <%= @app_name %>
+  password: <%%= ENV["<%= @app_name.upcase %>_DATABASE_PASSWORD"] %>

data/lib/rage/templates/model-template/model.rb

@@ -0,0 +1,2 @@
+class <%= @model_name %> < ApplicationRecord
+end

data/lib/rage/version.rb

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

data/lib/rage-rb.rb

@@ -63,10 +63,12 @@ module Rage
     patch = proc do
       is_connected = ActiveRecord::Base.connection_pool rescue false
       if is_connected
-        puts "INFO: Patching ActiveRecord::ConnectionPool"
+        Iodine.on_state(:pre_start) { puts "INFO: Patching ActiveRecord::ConnectionPool" }
         Iodine.on_state(:on_start) do
-          ActiveRecord::Base.connection_pool.extend(Rage::Ext::ActiveRecord::ConnectionPool)
-          ActiveRecord::Base.connection_pool.__init_rage_extension
+          ActiveRecord::Base.connection_handler.connection_pool_list(:all).each do |pool|
+            pool.extend(Rage::Ext::ActiveRecord::ConnectionPool)
+            pool.__init_rage_extension
+          end
         end
       else
         puts "WARNING: DB connection is not established - can't patch ActiveRecord::ConnectionPool"
@@ -80,6 +82,10 @@ module Rage
     end
   end
 
+  def self.load_tasks
+    Rage::Tasks.init
+  end
+
   # @private
   def self.with_middlewares(app, middlewares)
     middlewares.reverse.inject(app) do |next_in_chain, (middleware, args, block)|
@@ -111,6 +117,7 @@ module Rage
     end
   end
 
+  autoload :Tasks, "rage/tasks"
   autoload :Cookies, "rage/cookies"
   autoload :Session, "rage/session"
   autoload :Cable, "rage/cable/cable"

data/rage.gemspec

@@ -29,7 +29,8 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "thor", "~> 1.0"
   spec.add_dependency "rack", "~> 2.0"
-  spec.add_dependency "rage-iodine", "~> 3.0"
+  spec.add_dependency "rage-iodine", "~> 4.0"
   spec.add_dependency "zeitwerk", "~> 2.6"
   spec.add_dependency "rack-test", "~> 2.1"
+  spec.add_dependency "rake", ">= 12.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rage-rb
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.10.1
 platform: ruby
 authors:
 - Roman Samoilov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-24 00:00:00.000000000 Z
+date: 2024-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '12.0'
 description:
 email:
 - rsamoi@icloud.com
@@ -145,6 +159,7 @@ files:
 - lib/rage/session.rb
 - lib/rage/setup.rb
 - lib/rage/sidekiq_session.rb
+- lib/rage/tasks.rb
 - lib/rage/templates/Gemfile
 - lib/rage/templates/Rakefile
 - lib/rage/templates/app-controllers-application_controller.rb
@@ -155,8 +170,16 @@ files:
 - lib/rage/templates/config-initializers-.keep
 - lib/rage/templates/config-routes.rb
 - lib/rage/templates/config.ru
+- lib/rage/templates/db-templates/app-models-application_record.rb
+- lib/rage/templates/db-templates/db-seeds.rb
+- lib/rage/templates/db-templates/mysql/config-database.yml
+- lib/rage/templates/db-templates/postgresql/config-database.yml
+- lib/rage/templates/db-templates/sqlite3/config-database.yml
+- lib/rage/templates/db-templates/trilogy/config-database.yml
 - lib/rage/templates/lib-.keep
+- lib/rage/templates/lib-tasks-.keep
 - lib/rage/templates/log-.keep
+- lib/rage/templates/model-template/model.rb
 - lib/rage/templates/public-.keep
 - lib/rage/uploaded_file.rb
 - lib/rage/version.rb