Reloading rails middleware without restarting the server in development

I thought that at some point Rails was smart enough replacing middleware code at runtime, but I may be wrong.

Here is what I came up with, circumventing Ruby class loading craziness and leveraging Rails class reloading.

Add the middleware to the stack:

# config/environments/development.rb
[...]
config.middleware.use "SomeMiddleware", "some_additional_paramter"

Make use of auto-reloading, but make sure that the running rails instance and the already initialized middleware object keep "forgetting" about the actual code that is executed:

# app/middlewares/some_middleware.rb
class SomeMiddleware
  def initialize(*args)
    @args = args
  end

  def call(env)
    "#{self.class}::Logic".constantize.new(*@args).call(env)
  end

  class Logic
    def initialize(app, additional)
      @app        = app
      @additional = additional
    end

    def call(env)
      [magic]
      @app.call(env)
    end
  end
end

Changes in Logic should be picked up by rails auto reloading on each request.

I think that this actually might become a useful gem!

Building up on @phoet's answer we can actually wrap any middleware with this kind of lazy loading, which I found even more useful:

class ReloadableMiddleware
  def initialize(app, middleware_module_name, *middleware_args)
    @app = app
    @name = middleware_module_name
    @args = middleware_args
  end

  def call(env)
    # Lazily initialize the middleware item and call it immediately
    @name.constantize.new(@app, *@args).call(env)
  end
end

It can be then hooked into the Rails config with any other middleware as its first argument, given as a string:

Rails.application.config.middleware.use ReloadableMiddleware, 'YourMiddleware'

Alternatively - I packaged it into a gem called reloadable_middleware, which can be used like so:

Rails.application.config.middleware.use ReloadableMiddleware.wrap(YourMiddleware)

In Rails 6 with the new default Zeitwork code loader, this works for me:

# at the top of config/application.rb, after Bundler.require    

# Load the middleware. It will later be hot-reloaded in config.to_prepare
Dir["./app/middleware/*.rb"].each do |middleware|
  load middleware
end

Below it in the section that configures your class Application, add hot-reloading in config.to_prepare:

middleware = "#{Rails.root}/app/middleware"
Rails.autoloaders.main.ignore(middleware)

# Run before every request in development mode, or before the first request in production
config.to_prepare do
  Dir.glob("#{middleware}/*.rb").each do |middleware|
    load middleware
  end
end