async_render 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f4233e16eefe728ce0620a058495d7daecaee4a591f433b3637d01c5489896a2
+  data.tar.gz: dc2d826a7de38fd8140f696cdc2abd64080ccaa8ec0ad291a3645e68b065b62e
+SHA512:
+  metadata.gz: 7bebb2d37c302a42c6af8847850cb6efab86ea40576a31673db7ca9604f19cf091cb9e59326b05fb6fe4c21aee2d1f425ec0919ecfc6e70835ea5d07b56a2450
+  data.tar.gz: 9930ca4a9f7db3225ca6fb9407ba62c673a57e70eb2b6dfcf0ed24cf90035ef6836a5f76fa924cd52729ad98e7b32d1b597c76737d7a8934be0d77cae66c0ab3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Igor Kasyanchuk
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,212 @@
+# async_render in Ruby on Rails 🚀
+
+![AsyncRender Logo](docs/idea.gif)
+
+A Rails gem that enables asynchronous view rendering with warmup capabilities and in-memory memoization to significantly improve your application's performance.
+
+On my pet project and my benchmark, I've seen 5-15% improvement in response time. It's really hard to say how much it will improve your application, but it's worth a try.
+
+## ⚡ Ideal use case
+
+- you have heavy partials
+- you have partials, with calculations inside, that can be done in background
+- your partials has none or a few dependencies on locals
+- you have HTML request format (see `Limitations` section)
+- you are curious about performance :)
+
+## ✨ Features
+
+![AsyncRender Logo](docs/idea.png)
+
+### 🔄 Async Rendering
+Render multiple view partials asynchronously in background threads, reducing overall page load time by executing independent renders concurrently.
+
+### 🔥 Warmup Rendering
+Pre-render partials in your controller actions before the main view is processed. This allows expensive computations to start early and be ready when needed. This must be used in combination with async rendering.
+
+### 💾 Memoized Rendering
+Cache rendered partials in memory across requests within the same Ruby process, eliminating redundant rendering of static or rarely-changing content. Warning: do not use it for large amount of content, it will eat up your memory.
+
+### ⚡ Smart Thread Pool Management
+Automatically configures thread pool size based on your database connection pool and Rails configuration to prevent resource contention.
+
+## 📦 Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'async_render'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+### Generator
+
+After installation, run the generator to create an initializer:
+
+```bash
+rails generate async_render:install
+```
+
+This will create `config/initializers/async_render.rb` with all available configuration options.
+
+## Configuration
+
+The initializer file allows you to configure AsyncRender:
+
+```ruby
+AsyncRender.configure do |config|
+  # Enable/disable async rendering (default: true)
+  config.enabled = Rails.env.production?
+
+  # Timeout for async operations in seconds (default: 10)
+  config.timeout = 10
+
+  # Custom thread pool executor (optional)
+  # config.executor = Concurrent::FixedThreadPool.new(10)
+
+  # Custom state serialization for thread-local data (optional)
+  # config.dump_state_proc = -> { { current_user: Current.user&.id } }
+  # config.restore_state_proc = ->(state) { Current.user = User.find_by(id: state[:current_user]) }
+end
+```
+
+## Usage
+
+### Async Rendering
+
+Use `async_render` in your views to render partials asynchronously:
+
+```erb
+<!-- app/views/products/show.html.erb -->
+<div class="container">
+  <%= async_render 'shared/expensive_sidebar', { user: current_user } %>
+
+  <div class="main-content">
+    <%= @product.name %>
+  </div>
+
+  <%= async_render 'products/recommendations', { product: @product } %>
+</div>
+```
+
+### Warmup Rendering
+
+Pre-render partials in your controller to start expensive operations early:
+
+```ruby
+class ProductsController < ApplicationController
+  # Define warmups for specific actions
+  before_action :find_product
+
+  warmups only: [:show] do
+    warmup_render 'shared/expensive_sidebar', { user: current_user }
+    warmup_render 'products/recommendations', { product: @product }
+  end
+
+  def show
+  end
+
+  private
+
+  def find_product
+    @product = Product.find(params[:id])
+  end
+end
+```
+
+Then use the warmed-up partials in your views:
+
+```erb
+<!-- The warmup_render in the controller pre-calculates these -->
+<%= async_render 'shared/expensive_sidebar', user: current_user %>
+<%= async_render 'products/recommendations', product: @product %>
+```
+
+### Memoized Rendering
+
+For content that rarely changes, use memoized rendering to cache results in memory:
+
+```erb
+<!-- This will be rendered once and cached in memory -->
+<%= memoized_render 'shared/footer' %>
+
+<!-- With locals - cached based on the locals hash -->
+<%= memoized_render 'users/avatar', { user: current_user } %>
+
+<!-- With custom formats -->
+<%= memoized_render 'api/response', { user: @user } %>
+```
+
+## How It Works
+
+![AsyncRender Logo](docs/how.png)
+
+1. **Async Rendering**: When you use `async_render`, the gem returns a placeholder immediately and schedules the actual rendering in a background thread
+2. **Middleware Processing**: A Rack middleware intercepts the response and replaces placeholders with the actual rendered content.
+3. **Thread Safety**: The gem handles thread-local state properly, ensuring CurrentAttributes and other thread-local data work correctly
+4. **Automatic Pool Sizing**: Thread pool size is automatically determined based on your database pool size and Rails configuration
+
+## Best Practices
+
+### ⚠️ Limitations
+
+- doesn't work with view_components yet, just didn't try yet
+- partials you render in background doesn't have access to the request, so you need to pass "current_user" as locals
+- if you use "Current" attributes, you need to pass them as locals, or pass as state to render (see `dump_state_proc` and `restore_state_proc` in the initializer)
+- warmup rendering under the hood uses simply before_action, so you need to prepare data in the controller action, not in the view.
+- for now only HTML request format is supported, but I'm working on it.
+
+### ✅ Do
+
+- Use async rendering for expensive, independent view components
+- Warmup partials that you know will be needed
+- Memoize static or rarely-changing content
+- Monitor your database connection pool usage
+
+### ❌ Don't
+
+- Use async rendering for trivial partials (overhead may exceed benefits)
+- Share mutable state between parallel renders
+- Rely on request-specific data without proper state management
+- Use excessive async rendering that could exhaust database connections
+
+## Performance Considerations
+
+- The gem automatically limits parallelism based on available database connections
+- Default timeout is 10 seconds for async operations
+- Memoized content persists for the lifetime of the Ruby process
+- Consider memory usage when memoizing large amounts of content
+
+## TODO
+
+- [ ] add support for view_components
+- [ ] add support for turbo_stream
+- [ ] improve performance? what we can do to make it faster?
+- [ ] support for different cache stores for memoized rendering
+- [ ] support for nested async rendering
+- [ ] added instrumentation for async rendering
+- [ ] better error handling
+- [ ] better documentation
+- [ ] better state management for thread variables
+- [ ] better compatibility with "render" method, if AsyncRender is disabled, 100% fallback to the original render method. This kind of fallback is already implemented, but I think it can be improved.
+
+## Benchmarks
+
+I used local and pet project to benchmark the gem.
+
+I also used `oha` to benchmark the gem.
+
+I do not specify the exact numbers, but I can say that the gem is working as expected. Once gem will be more mature, I will add more benchmarks.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/igorkasyanchuk/async_render.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/config/routes.rb

@@ -0,0 +1,2 @@
+AsyncRender::Engine.routes.draw do
+end

data/lib/async_render/async_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module AsyncRender
+  module AsyncHelper
+    include AsyncRender::Utils
+
+    POOL = AsyncRender.executor
+
+    def async_render(partial, locals = {})
+      return render(partial, locals) unless AsyncRender.enabled
+
+      AsyncRender::Current.skip_middleware = false
+
+      warmup_key = build_memoized_render_key(partial, locals)
+      placeholder = AsyncRender::Current.warmup_partials[warmup_key]
+      return placeholder if placeholder
+
+      token       = generate_token(partial)
+      placeholder = (AsyncRender::PLACEHOLDER_TEMPLATE % token).html_safe
+      state       = AsyncRender.dump_state_proc&.call
+
+      AsyncRender::Current.async_futures[token] = Concurrent::Promises.future_on(POOL) do
+        AsyncRender::Executor.new(partial:, locals:, state:).call
+      end
+
+      placeholder
+    end
+  end
+end

data/lib/async_render/controller.rb

@@ -0,0 +1,20 @@
+require "active_support/concern"
+
+module AsyncRender
+  # Controller concern to set up per-request async rendering context
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      around_action :async_rendering
+    end
+
+    private
+
+    def async_rendering
+      # AsyncRender::Current.async_futures = Concurrent::Hash.new
+      # AsyncRender::Current.warmup_partials = Concurrent::Hash.new
+      yield
+    end
+  end
+end

data/lib/async_render/current.rb

@@ -0,0 +1,9 @@
+require "concurrent-ruby"
+
+module AsyncRender
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :skip_middleware, default: true
+    attribute :async_futures, default: Concurrent::Hash.new
+    attribute :warmup_partials, default: Concurrent::Hash.new
+  end
+end

data/lib/async_render/engine.rb

@@ -0,0 +1,23 @@
+module AsyncRender
+  class Engine < ::Rails::Engine
+    isolate_namespace AsyncRender
+
+    initializer "async_render.middleware" do |app|
+      app.middleware.use AsyncRender::Middleware
+    end
+
+    initializer "async_render.helper" do
+      ActiveSupport.on_load :action_view do
+        include AsyncRender::AsyncHelper
+        include AsyncRender::MemoizedHelper
+      end
+    end
+
+    initializer "async_render.warmup" do
+      ActiveSupport.on_load :action_controller do
+        include AsyncRender::Warmup
+        include AsyncRender::Controller
+      end
+    end
+  end
+end

data/lib/async_render/executor.rb

@@ -0,0 +1,39 @@
+module AsyncRender
+  class Executor
+    def initialize(partial:, locals:, state:, formats: [ :html ])
+      @partial = partial
+      @locals = locals
+      @state = state
+      @formats = formats
+    end
+
+    def call
+      # Wrap in Rails executor for proper request-local state
+      Rails.application.executor.wrap do
+        # Ensure we have a database connection for this thread
+        begin
+          AsyncRender.restore_state_proc&.call(state)
+          ApplicationController.renderer.render(partial:, locals:, formats:)
+        rescue => e
+          Rails.logger.error { "Error rendering #{partial}: #{e.message}" }
+          e.backtrace.each { |line| Rails.logger.error { "  #{line}" } }
+
+          if Rails.env.local?
+            <<~HTML
+              <p style='background-color:red;color:white'>
+                Error rendering #{ERB::Util.html_escape(partial)}: #{ERB::Util.html_escape(e.message)}<br>
+                #{ERB::Util.html_escape(e.backtrace.join("\n")).gsub("\n", "<br>")}
+              </p>
+            HTML
+          else
+            ""
+          end
+        end
+      end
+    end
+
+    private
+
+    attr_reader :partial, :locals, :context, :state, :formats
+  end
+end

data/lib/async_render/memoized_helper.rb

@@ -0,0 +1,16 @@
+module AsyncRender
+  module MemoizedHelper
+    include AsyncRender::Utils
+
+    def memoized_render(partial, locals = nil, formats: [ :html ], **locals_kw)
+      return render(partial, locals) unless AsyncRender.enabled
+
+      effective_locals = normalize_locals(locals, locals_kw)
+      key = build_memoized_render_key(partial, effective_locals)
+      AsyncRender.memoized_cache.compute_if_absent(key) do
+        Rails.logger.info "[AsyncRender] Memoizing: #{partial}" if Rails.env.local?
+        ApplicationController.renderer.render(partial: partial, locals: effective_locals, formats: formats)
+      end
+    end
+  end
+end

data/lib/async_render/middleware.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# lib/async_render/middleware.rb
+require "concurrent"
+require "securerandom"
+
+module AsyncRender
+  class Middleware
+    HTML_TYPE = %r{\Atext/html}.freeze
+    PATTERN_PREFIX = "<!--ASYNC-PLACEHOLDER:".freeze
+    PATTERN_REGEXP = /<!--ASYNC-PLACEHOLDER:([0-9a-z\.\/]+)-->/.freeze
+
+    def initialize(app)
+      @app = app
+    end
+
+    # def benchmark
+    #   Benchmark.bm(100) do |x|
+    #     html = ("hello" * 10000) + "hello<!--ASYNC-PLACEHOLDER:123-->World" + ("hello" * 10000)
+    #     token_to_fragment = { "123" => "Hello" }
+
+    #     x.report("replace") do
+    #       1000.times do
+    #         html1 = html.dup
+
+    #         html1.gsub!(PATTERN_REGEXP) do |match|
+    #           token = Regexp.last_match(1)
+    #           token_to_fragment.fetch(token, "")
+    #         end
+
+    #         # puts 1
+    #         # puts html1
+    #       end
+    #     end
+
+    #     token_to_fragment_2 = { "<!--ASYNC-PLACEHOLDER:123-->" => "Hello" }
+
+    #     x.report("each") do
+    #       1000.times do
+    #         html2 = html.dup
+
+    #         token_to_fragment.each do |token, fragment|
+    #           html2[token] = fragment
+    #         end
+
+    #         # puts 2
+    #         # puts html2
+    #       end
+    #     end
+    #   end
+    # end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+
+      return [ status, headers, body ] if skip?
+
+      if html?(headers)
+        html = +""
+        begin
+          body.each { |part| html << part }
+        ensure
+          body.close if body.respond_to?(:close)
+        end
+
+        return [ status, headers, [ html ] ] if !html.include?(PATTERN_PREFIX)
+
+        # Wait with timeout and collect fragments
+        token_to_fragment = {}
+        futures_hash = AsyncRender::Current.async_futures
+
+        if futures_hash.any?
+          # Create array of [token, future] pairs to maintain association
+          futures_array = futures_hash.to_a
+
+          # Wait for all futures to complete with timeout
+          all_futures = Concurrent::Promises.zip(*futures_array.map(&:last))
+          all_futures.wait(AsyncRender.timeout)
+
+          # Collect results - check each future individually
+          futures_array.each do |token, future|
+            token_to_fragment[token] = future.fulfilled? ? future.value : ""
+          end
+        end
+
+        # token_to_fragment.each do |token, fragment|
+        #   Rails.logger.info { "[AsyncRender] Replacing: #{token}" } if Rails.env.local?
+        #   html[token] = fragment
+        # end
+
+        # Single-pass replacement using regex
+        html.gsub!(PATTERN_REGEXP) do |match|
+          token = Regexp.last_match(1)
+          Rails.logger.info { "[AsyncRender] Replacing: #{token}" } if Rails.env.local?
+          token_to_fragment.fetch(token, "")
+        end
+
+        AsyncRender::Current.async_futures.clear
+        AsyncRender::Current.warmup_partials.clear
+
+        headers["Content-Length"] = html.bytesize.to_s if headers["Content-Length"]
+        [ status, headers, [ html ] ]
+      else
+        [ status, headers, body ]
+      end
+    end
+
+    private
+
+    def skip?
+      AsyncRender::Current.skip_middleware || !AsyncRender.enabled
+    end
+
+    def html?(headers)
+      headers["Content-Type"]&.match?(HTML_TYPE)
+    end
+
+    def wait_or_empty(future, timeout = AsyncRender.timeout)
+      future.wait(timeout)
+      future.fulfilled? ? future.value : ""
+    end
+  end
+end

data/lib/async_render/utils.rb

@@ -0,0 +1,25 @@
+module AsyncRender
+  module Utils
+    def generate_token(partial)
+      # Fast random token generation using Random.bytes
+      partial_id = partial.downcase.gsub(/[^a-z0-9\/]/, "").slice(0, 100)
+      random_hex = Random.bytes(5).unpack1("H*")
+      "#{partial_id}/#{random_hex}"
+    end
+
+    def build_memoized_render_key(partial, locals)
+      return partial if locals.nil? || locals.empty?
+      [ partial, locals.to_a.sort_by { |(k, _)| k.to_s } ]
+    end
+
+    def normalize_locals(locals, locals_kw)
+      if locals.nil?
+        locals_kw
+      elsif locals_kw.empty?
+        locals
+      else
+        locals.merge(locals_kw)
+      end
+    end
+  end
+end

data/lib/async_render/version.rb

@@ -0,0 +1,3 @@
+module AsyncRender
+  VERSION = "0.1.0"
+end

data/lib/async_render/warmup.rb

@@ -0,0 +1,50 @@
+require "active_support/concern"
+
+module AsyncRender
+  module Warmup
+    extend ActiveSupport::Concern
+
+    include AsyncRender::Utils
+
+    POOL = AsyncRender.executor
+
+    class_methods do
+      # Usage:
+      #   warmups only: [:show] do
+      #     warmup_render('users/menu', user: current_user)
+      #     warmup_render('users/sidebar')
+      #   end
+      def warmups(**filters, &block)
+        before_action(**filters) do
+          instance_exec(&block) if block
+        end
+      end
+
+      # Backwards compatibility with earlier name
+      alias_method :warmup_render_before_action, :warmups
+    end
+
+    # Queue an async render for a partial so views can reference it via placeholders.
+    # The result is stitched into the HTML by the middleware.
+    def warmup_render(partial, locals = {})
+      return unless AsyncRender.enabled
+
+      AsyncRender::Current.skip_middleware = false
+
+      warmup_key = build_memoized_render_key(partial, locals)
+      placeholder = AsyncRender::Current.warmup_partials[warmup_key]
+      return placeholder if placeholder
+
+      token       = generate_token(partial)
+      placeholder = (AsyncRender::PLACEHOLDER_TEMPLATE % token).html_safe
+      state       = AsyncRender.dump_state_proc&.call
+      AsyncRender::Current.warmup_partials[warmup_key] = placeholder
+
+      AsyncRender::Current.async_futures[token] = Concurrent::Promises.future_on(POOL) do
+        AsyncRender::Executor.new(partial:, locals:, state:).call
+      end
+
+      placeholder
+    end
+  end
+end

data/lib/async_render.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "async_render/version"
+require "async_render/controller"
+require "async_render/engine"
+require "async_render/middleware"
+require "async_render/current"
+require "async_render/utils"
+require "concurrent"
+
+module AsyncRender
+  PLACEHOLDER_PREFIX = "<!--ASYNC-PLACEHOLDER:".freeze
+  PLACEHOLDER_SUFFIX = "-->".freeze
+  PLACEHOLDER_TEMPLATE = "#{PLACEHOLDER_PREFIX}%s#{PLACEHOLDER_SUFFIX}".freeze
+
+  mattr_accessor :enabled
+  mattr_accessor :timeout
+  mattr_accessor :executor
+  mattr_accessor :dump_state_proc
+  mattr_accessor :restore_state_proc
+
+  @@enabled = true
+  @@timeout = 10
+  @@executor = nil
+  @@dump_state_proc = nil
+  @@restore_state_proc = nil
+
+  def self.configure
+    yield self
+  end
+
+  # Lazily build a conservative default executor sized to avoid DB pool contention.
+  def self.executor
+    @@executor ||= build_default_executor
+  end
+
+  # Global, process-local memoized cache for rendered fragments or values
+  # NOTE: This persists across requests in the Ruby process
+  def self.memoized_cache
+    @memoized_cache ||= Concurrent::Map.new
+  end
+
+  def self.reset_memoized_cache!
+    @memoized_cache = Concurrent::Map.new
+  end
+
+  def self.build_default_executor
+    # Heuristics: cap by AR pool size and RAILS_MAX_THREADS, with a sane upper bound.
+    ar_pool_size = begin
+      defined?(ActiveRecord) && ActiveRecord::Base.connection_pool&.size
+    rescue StandardError
+      nil
+    end
+
+    puma_max_threads = Integer(ENV["RAILS_MAX_THREADS"]) rescue nil
+
+    # Defaults
+    hard_cap = 16
+    max_threads = [ ar_pool_size, puma_max_threads, hard_cap ].compact.min || 8
+    min_threads = [ 2, max_threads ].min
+
+    # Concurrent::ThreadPoolExecutor.new(
+    #   min_threads: min_threads,
+    #   max_threads: max_threads,
+    #   idletime: 60,
+    #   max_queue: 1_000,
+    #   fallback_policy: :caller_runs
+    # )
+    #
+    Concurrent::FixedThreadPool.new(
+      max_threads,
+      idletime: 60,
+      max_queue: 1_000,
+      fallback_policy: :caller_runs
+    )
+    #
+    # Concurrent::CachedThreadPool.new(
+    #   min_threads: min_threads,
+    #   max_threads: max_threads,
+    #   max_queue: 1_000,
+    #   fallback_policy: :caller_runs
+    # )
+  end
+end
+
+require "async_render/executor"
+require "async_render/warmup"
+require "async_render/async_helper"
+require "async_render/memoized_helper"

data/lib/generators/async_render/install/install_generator.rb

@@ -0,0 +1,17 @@
+module AsyncRender
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates an AsyncRender initializer file"
+
+      def copy_initializer
+        template "async_render.rb", "config/initializers/async_render.rb"
+      end
+
+      def show_readme
+        readme "README" if behavior == :invoke
+      end
+    end
+  end
+end

data/lib/generators/async_render/install/templates/README

@@ -0,0 +1,28 @@
+===============================================================================
+
+AsyncRender has been successfully installed! 🎉
+
+Next steps:
+
+1. Review the configuration in config/initializers/async_render.rb
+   and adjust settings according to your needs.
+
+2. Include the controller concern in your ApplicationController:
+
+   class ApplicationController < ActionController::Base
+     include AsyncRender::Controller
+   end
+
+3. Start using parallel rendering in your views:
+
+   <%= async_render 'expensive_partial', locals: { user: current_user } %>
+
+4. For more advanced usage, check out:
+   - Warmup rendering for pre-loading partials
+   - Memoized rendering for caching rendered content
+   - Custom thread pool configuration
+
+See the full documentation at:
+https://github.com/igorkasyanchuk/async_render
+
+===============================================================================

data/lib/generators/async_render/install/templates/async_render.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+AsyncRender.configure do |config|
+  # Enable or disable parallel rendering
+  # Default: true
+  # config.enabled = true
+
+  # Enable only in production for better performance
+  # config.enabled = Rails.env.production?
+
+  # Timeout for async operations in seconds
+  # Default: 10
+  # config.timeout = 10
+
+  # Custom thread pool executor (optional)
+  # By default, AsyncRender will create a thread pool sized based on your
+  # database connection pool and RAILS_MAX_THREADS environment variable
+  # config.executor = Concurrent::FixedThreadPool.new(10)
+
+  # Custom state serialization for thread-local data (optional)
+  # Use this to preserve Current attributes or other thread-local state
+  # across async renders
+  #
+  # Example:
+  # config.dump_state_proc = lambda do
+  #   {
+  #     current_user_id: Current.user&.id,
+  #     request_id: Current.request_id,
+  #     locale: I18n.locale
+  #   }
+  # end
+  #
+  # config.restore_state_proc = lambda do |state|
+  #   Current.user = User.find_by(id: state[:current_user_id]) if state[:current_user_id]
+  #   Current.request_id = state[:request_id]
+  #   I18n.locale = state[:locale] if state[:locale]
+  # end
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: async_render
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Igor Kasyanchuk
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kaminari
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Async render in Rails
+email:
+- igorkasyanchuk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- config/routes.rb
+- lib/async_render.rb
+- lib/async_render/async_helper.rb
+- lib/async_render/controller.rb
+- lib/async_render/current.rb
+- lib/async_render/engine.rb
+- lib/async_render/executor.rb
+- lib/async_render/memoized_helper.rb
+- lib/async_render/middleware.rb
+- lib/async_render/utils.rb
+- lib/async_render/version.rb
+- lib/async_render/warmup.rb
+- lib/generators/async_render/install/install_generator.rb
+- lib/generators/async_render/install/templates/README
+- lib/generators/async_render/install/templates/async_render.rb
+homepage: https://github.com/igorkasyanchuk/async_render
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/igorkasyanchuk/async_render
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Async render in Rails
+test_files: []