after_migrate 0.2.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9d807edc34ee3c61bcda0ef4fd2319f80bac36c3bcd1cd1e2a46eb9f5e44f28
-  data.tar.gz: 16547159bf93c5a192a38a1e92d441bcd9690412b8d58ae163f59f8bc2da71bb
+  metadata.gz: 23144c2fac25e5be5c8965155dc54b03b8859063fe00a43d033e9c3bed415f8a
+  data.tar.gz: e40e59a694376551d73261e59d214e8ebfe460ee0ab5961116873a22bc9b019f
 SHA512:
-  metadata.gz: a7e76304080055fe4b9669d9895b9fb3709266c89e29deb2e39b3d408a29ba88ef1b99ebe951e693da446d2c97fda40ba416b71fae517234b65975e250b6635d
-  data.tar.gz: 14823ec925953300f85d28586a232111f945c2b9b8fb20bdaa4bf9d3057f8467dec2eb76defda50317a5811bbd6f7071bf71bb195f188950ab2a340030e0b2a5
+  metadata.gz: a1ff650538cacd552d26399df13507a0e4f5a71581e32bff0d1e2686ea3d8b8a86e44ef96a7143892ef7cef79a720135489ac174b09ade876b722465b916fc18
+  data.tar.gz: 977f7a020023cad34941b24046982d0563f30340cfefe6a196feb83915c7ec5d6a148707cc596749ad0d2ced9a5e64ec55c926d6869d3bd0c853edbd4617dbd8

data/.gitlocalexclude

@@ -0,0 +1,2 @@
+.ai/
+.claude/

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.2.4] - 2026-06-01
+
+### Added
+- `config.store_options` for store-specific settings, e.g. `config.store_options_for(:redis)[:client]`
+
+### Changed
+- Store-specific configuration now flows through `config.store_options` while preserving compatibility accessors such as `config.store_path`, `config.redis`, `config.redis_key_prefix`, and `config.redis_ttl`
+- `config.run_id` now defaults from `AFTER_MIGRATE_RUN_ID`, falling back to `default`
+
 ## [0.2.3] - 2026-06-01
 
 ### Added

data/CLAUDE.md

@@ -22,7 +22,7 @@ This is a Rails gem that automatically runs database maintenance (`ANALYZE`, `VA
 
 2. **`Collector`** (`lib/after_migrate/collector.rb`) — receives every SQL notification, filters to DDL/DML statements (CREATE/ALTER/DROP/INSERT/UPDATE/DELETE), calls the adapter-specific parser, and accumulates table names into `AfterMigrate.affected_tables` (a `Concurrent::Map<schema, Concurrent::Set<table_name>>`).
 
-3. **`AfterMigrate.store`** (`lib/after_migrate/store.rb`) — defaults to an in-memory `Concurrent::Map` wrapped by `AfterMigrate::Stores::Memory`. `AfterMigrate.affected_tables`, `merge_tables`, and `reset!` delegate to the store. The memory store persists across multiple rake task invocations inside one Ruby process and is cleared by `AfterMigrate.run!` (or `AfterMigrate.reset!`). This replaces the old `Current` (`ActiveSupport::CurrentAttributes`) which was reset after every migration.
+3. **`AfterMigrate.store`** (`lib/after_migrate/store.rb`) — defaults to an in-memory `Concurrent::Map` wrapped by `AfterMigrate::Stores::Memory`. `AfterMigrate.affected_tables`, `merge_tables`, and `reset!` delegate to the store. The memory store persists across multiple rake task invocations inside one Ruby process and is cleared by `AfterMigrate.run!` (or `AfterMigrate.reset!`). This replaces the old `Current` (`ActiveSupport::CurrentAttributes`) which was reset after every migration. Alternate backends: `FileStore` (JSON, cross-invocation) and `RedisStore` (cross-process, for parallel/multi-tenant runs). `RedisStore#resolved_redis` memoizes the resolved client per store instance, so `config.redis` is only materialized once — pass a `ConnectionPool` (the store calls `pool.with`) or a memoized client, never a `-> { Redis.new }` proc that builds a connection per call (that opens one connection per SQL statement and exhausts the Redis connection limit under concurrency).
 
 4. **`Executor`** (`lib/after_migrate/executor.rb`) — iterates `AfterMigrate.affected_tables` and calls the correct adapter's `optimize_tables`. Respects the `analyze` config option (`only_affected_tables` / `all_tables` / `none`). Always calls `AfterMigrate.reset!` in its `ensure` block.
 
@@ -45,13 +45,13 @@ This is a Rails gem that automatically runs database maintenance (`ANALYZE`, `VA
 
 Config values are in `AfterMigrate::Configuration` (initialized in `lib/after_migrate.rb`):
 
-| Option                | Default                  | Values                                             |
-|-----------------------|--------------------------|----------------------------------------------------|
-| `enabled`             | `true`                   | bool                                               |
-| `verbose`             | `true`                   | bool                                               |
-| `vacuum`              | `true`                   | bool (PostgreSQL only)                             |
-| `analyze`             | `"only_affected_tables"` | `"only_affected_tables"`, `"all_tables"`, `"none"` |
-| `rake_tasks_enhanced` | `true`                   | bool                                               |
+| Option                | Default                  | Values                                                  |
+|-----------------------|--------------------------|---------------------------------------------------------|
+| `enabled`             | `true`                   | bool                                                    |
+| `verbose`             | `true`                   | bool                                                    |
+| `vacuum`              | `true`                   | bool (PostgreSQL only)                                  |
+| `analyze`             | `"only_affected_tables"` | `"only_affected_tables"`, `"all_tables"`, `"none"`      |
+| `rake_tasks_enhanced` | `true`                   | bool                                                    |
 | `defer`               | `true`                   | bool — skip auto-run; call `AfterMigrate.run!` manually |
 
 ## Multi-tenant usage

data/README.md

@@ -81,6 +81,41 @@ AfterMigrate.configure do |config|
   config.rake_tasks_enhanced = true
 end
 ```
+
+### Store backends
+
+The collected table names are kept in a store. Choose one with `config.store`:
+
+- `:memory` (default) — a process-local `Concurrent::Map`. Fine for a single-process migration.
+- `:file` — JSON file, shared across rake invocations in the same run.
+- `:redis` — shared across processes; use this for parallel / multi-tenant migrations.
+
+```ruby
+config.store = :redis
+```
+
+> [!IMPORTANT]
+> **Redis: always pass a pooled or memoized client — never a proc that builds a new connection per call.**
+>
+> `config.redis` is read on *every* collected SQL statement. If it returns a
+> fresh `Redis.new` each time (e.g. `config.redis = -> { Redis.new(...) }`),
+> every statement opens a new, unpooled connection. Under parallel or
+> multi-tenant migrations this exhausts the Redis server connection limit
+> (`Connection refused` / `max number of clients reached`).
+>
+> Recommended — a thread-safe `ConnectionPool` (the store uses `pool.with`):
+>
+> ```ruby
+> config.store = :redis
+> config.redis = ConnectionPool.new(size: 2, timeout: 5) { Redis.new(url: ENV["REDIS_URL"]) }
+> ```
+>
+> A memoized single client also works for sequential migrations:
+>
+> ```ruby
+> config.redis = -> { @after_migrate_redis ||= Redis.new(url: ENV["REDIS_URL"]) }
+> ```
+
 ---
 
 ## 🚢 Releasing

data/lib/after_migrate/store.rb

@@ -181,12 +181,18 @@ module AfterMigrate
         block.call(redis)
       end
 
+      # Memoized so a plain client or a `-> { Redis.new }` proc only ever
+      # produces one connection per store instance. Without this, `with_redis`
+      # re-invokes the proc on every merge_tables/affected_tables call, opening
+      # a fresh unpooled connection per SQL statement — which exhausts the
+      # Redis server's connection limit under parallel/multi-tenant migrations.
+      # Pass a ConnectionPool as config.redis for thread-safe concurrency.
       def resolved_redis
-        client = @redis.respond_to?(:call) ? @redis.call : @redis
-        return client if client
-        return Redis.new if defined?(Redis)
-
-        raise 'AfterMigrate Redis store requires config.redis or the redis gem'
+        @resolved_redis ||= begin
+          client = @redis.respond_to?(:call) ? @redis.call : @redis
+          client ||= Redis.new if defined?(Redis)
+          client || raise('AfterMigrate Redis store requires config.redis or the redis gem')
+        end
       end
     end
   end

data/lib/after_migrate/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AfterMigrate
-  VERSION = '0.2.3'
+  VERSION = '0.2.5'
 end

data/lib/after_migrate.rb

@@ -9,7 +9,7 @@ require 'after_migrate/railtie'
 module AfterMigrate
   class Configuration
     attr_accessor :enabled, :verbose, :vacuum, :analyze, :rake_tasks_enhanced, :defer,
-                  :store, :store_path, :run_id, :redis, :redis_key_prefix, :redis_ttl
+                  :store, :run_id, :store_options
 
     def initialize
       @enabled = true
@@ -19,11 +19,53 @@ module AfterMigrate
       @rake_tasks_enhanced = true
       @defer = true
       @store = :memory
-      @store_path = 'tmp/after_migrate/affected_tables.json'
-      @run_id = nil
-      @redis = nil
-      @redis_key_prefix = 'after_migrate'
-      @redis_ttl = 24 * 60 * 60
+      @run_id = ENV.fetch('AFTER_MIGRATE_RUN_ID', 'default')
+      @store_options = {
+        file: {
+          path: 'tmp/after_migrate/affected_tables.json'
+        },
+        redis: {
+          client: nil,
+          key_prefix: 'after_migrate',
+          ttl: 24 * 60 * 60
+        }
+      }
+    end
+
+    def store_path
+      store_options_for(:file)[:path]
+    end
+
+    def store_path=(value)
+      store_options_for(:file)[:path] = value
+    end
+
+    def redis
+      store_options_for(:redis)[:client]
+    end
+
+    def redis=(value)
+      store_options_for(:redis)[:client] = value
+    end
+
+    def redis_key_prefix
+      store_options_for(:redis)[:key_prefix]
+    end
+
+    def redis_key_prefix=(value)
+      store_options_for(:redis)[:key_prefix] = value
+    end
+
+    def redis_ttl
+      store_options_for(:redis)[:ttl]
+    end
+
+    def redis_ttl=(value)
+      store_options_for(:redis)[:ttl] = value
+    end
+
+    def store_options_for(store_name)
+      store_options[store_name.to_sym] ||= {}
     end
   end
 
@@ -72,17 +114,15 @@ module AfterMigrate
     def store_key
       [
         configuration.store.to_s,
-        configuration.store_path.to_s,
         configuration.run_id.to_s,
-        configuration.redis_key_prefix.to_s,
-        configuration.redis_ttl.to_s
+        configuration.store_options_for(configuration.store).hash
       ]
     end
 
     def build_store
       case configuration.store.to_s
       when 'file'
-        Stores::FileStore.new(path: configuration.store_path, run_id: configuration.run_id)
+        file_store
       when 'redis'
         redis_store
       else
@@ -90,12 +130,21 @@ module AfterMigrate
       end
     end
 
+    def file_store
+      options = configuration.store_options_for(:file)
+      Stores::FileStore.new(
+        path: options.fetch(:path),
+        run_id: options.fetch(:run_id, configuration.run_id)
+      )
+    end
+
     def redis_store
+      options = configuration.store_options_for(:redis)
       Stores::RedisStore.new(
-        redis: configuration.redis,
-        key_prefix: configuration.redis_key_prefix,
-        run_id: configuration.run_id,
-        ttl: configuration.redis_ttl
+        redis: options[:client],
+        key_prefix: options.fetch(:key_prefix),
+        run_id: options.fetch(:run_id, configuration.run_id),
+        ttl: options.fetch(:ttl)
       )
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: after_migrate
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.5
 platform: ruby
 authors:
 - Nikolay Moskvin
@@ -48,6 +48,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".gitlocalexclude"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"