rails_lens 0.2.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7eaa2e258c8608dfd893bb5220840fc9febce43478aca9573ae0dbb885b33bf5
-  data.tar.gz: ed99614fc744e7f32e6c439a8f61e99b5d94787a684c694fbca7ed1eb546e6c6
+  metadata.gz: b150328b6771f2de4015820d40e3942c10b41903687f800fd4b068f79605deeb
+  data.tar.gz: 2d67fc7fd815b1af80c3cb9e1ad8b94e1166129fc3a1eb24e28958ad3e625b47
 SHA512:
-  metadata.gz: 0fc9a2a6d597e0d5a5e9b5e1c5eddf79bdca77448e780686fd28eabc26c5085829fe543595bdde05d31949a0e5ca42475bd379d89b9d552c128c06070d7a555c
-  data.tar.gz: 3982294a0d8a11b0ba516a7f90dc5595b488a3dcae79ef874c8d7d0cb0369f4a6438304adf1dd476d3aa8542bd445ec44022b549dcdeb48bf63084b5bebdd22d
+  metadata.gz: 0b9f944f8e7be0f11789817a49f168f7be310e6742207897029c20540b701c525da861a1b49cdcbeee0690a9bd6424fbace720e6bb42fd5d9d81b46cd244ed88
+  data.tar.gz: 22f3bc6e6223ad726c2fc3cf617c37af1e587e466119fd1138965e38ff51cb9128b441b5081214e79f9e2d334b8ec7990e437bdfb20257783a40a194f572ebfc

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.2.5](https://github.com/seuros/rails_lens/compare/rails_lens/v0.2.4...rails_lens/v0.2.5) (2025-07-31)
+
+
+### Bug Fixes
+
+* change strategy to cover database with hundrends of connections pool ([#12](https://github.com/seuros/rails_lens/issues/12)) ([7054d35](https://github.com/seuros/rails_lens/commit/7054d3582bfee41f0050725c2bd23e80c5898486))
+
+## [0.2.4](https://github.com/seuros/rails_lens/compare/rails_lens/v0.2.3...rails_lens/v0.2.4) (2025-07-31)
+
+
+### Bug Fixes
+
+* centralize connection management to prevent "too many clients" errors ([#10](https://github.com/seuros/rails_lens/issues/10)) ([1f9adf9](https://github.com/seuros/rails_lens/commit/1f9adf9b7dd0648add324492189c1322726da52f))
+
 ## [0.2.3](https://github.com/seuros/rails_lens/compare/rails_lens/v0.2.2...rails_lens/v0.2.3) (2025-07-31)
 
 

data/lib/rails_lens/analyzers/generated_columns.rb

@@ -25,7 +25,7 @@ module RailsLens
       def detect_generated_columns
         # PostgreSQL system query to find generated columns
         sql = <<-SQL.squish
-          SELECT#{' '}
+          SELECT
             a.attname AS column_name,
             pg_get_expr(d.adbin, d.adrelid) AS generation_expression
           FROM pg_attribute a

data/lib/rails_lens/analyzers/notes.rb

@@ -399,24 +399,24 @@ module RailsLens
         case @connection.adapter_name.downcase
         when 'postgresql'
           result = @connection.exec_query(<<~SQL.squish, 'Check PostgreSQL View Existence')
-            SELECT 1 FROM information_schema.views#{' '}
+            SELECT 1 FROM information_schema.views
             WHERE table_name = '#{@connection.quote_string(view_name)}'
             UNION ALL
-            SELECT 1 FROM pg_matviews#{' '}
+            SELECT 1 FROM pg_matviews
             WHERE matviewname = '#{@connection.quote_string(view_name)}'
             LIMIT 1
           SQL
           result.rows.any?
         when 'mysql', 'mysql2'
           result = @connection.exec_query(<<~SQL.squish, 'Check MySQL View Existence')
-            SELECT 1 FROM information_schema.views#{' '}
+            SELECT 1 FROM information_schema.views
             WHERE table_name = '#{@connection.quote_string(view_name)}'
             LIMIT 1
           SQL
           result.rows.any?
         when 'sqlite', 'sqlite3'
           result = @connection.exec_query(<<~SQL.squish, 'Check SQLite View Existence')
-            SELECT 1 FROM sqlite_master#{' '}
+            SELECT 1 FROM sqlite_master
             WHERE type = 'view' AND name = '#{@connection.quote_string(view_name)}'
             LIMIT 1
           SQL

data/lib/rails_lens/model_detector.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'concurrent'
-
 module RailsLens
   class ModelDetector
     class << self
@@ -82,10 +80,10 @@ module RailsLens
       def check_postgresql_view(connection, table_name)
         # Check both regular views and materialized views
         result = connection.exec_query(<<~SQL.squish, 'Check PostgreSQL View')
-          SELECT 1 FROM information_schema.views#{' '}
+          SELECT 1 FROM information_schema.views
           WHERE table_name = '#{connection.quote_string(table_name)}'
           UNION ALL
-          SELECT 1 FROM pg_matviews#{' '}
+          SELECT 1 FROM pg_matviews
           WHERE matviewname = '#{connection.quote_string(table_name)}'
           LIMIT 1
         SQL
@@ -94,7 +92,7 @@ module RailsLens
 
       def check_mysql_view(connection, table_name)
         result = connection.exec_query(<<~SQL.squish, 'Check MySQL View')
-          SELECT 1 FROM information_schema.views#{' '}
+          SELECT 1 FROM information_schema.views
           WHERE table_name = '#{connection.quote_string(table_name)}'
           AND table_schema = DATABASE()
           LIMIT 1
@@ -104,7 +102,7 @@ module RailsLens
 
       def check_sqlite_view(connection, table_name)
         result = connection.exec_query(<<~SQL.squish, 'Check SQLite View')
-          SELECT 1 FROM sqlite_master#{' '}
+          SELECT 1 FROM sqlite_master
           WHERE type = 'view' AND name = '#{connection.quote_string(table_name)}'
           LIMIT 1
         SQL
@@ -198,7 +196,10 @@ module RailsLens
 
         # Exclude abstract models and models without valid tables
         before_count = models.size
-        models = filter_models_concurrently(models, trace_filtering, options)
+
+        # Use connection management during model filtering to prevent connection exhaustion
+        models = filter_models_with_connection_management(models, trace_filtering, options)
+
         log_filter_step('Abstract/invalid table removal', before_count, models.size, trace_filtering)
 
         # Exclude tables from configuration
@@ -257,59 +258,178 @@ module RailsLens
       end
 
       def filter_models_concurrently(models, trace_filtering, options = {})
-        # Use concurrent futures to check table existence in parallel
-        futures = models.map do |model|
-          Concurrent::Future.execute do
-            should_exclude = false
-            reason = nil
-
-            begin
-              # Skip abstract models unless explicitly included
-              if model.abstract_class? && !options[:include_abstract]
-                should_exclude = true
-                reason = 'abstract class'
-              # For abstract models that are included, skip table checks
-              elsif model.abstract_class? && options[:include_abstract]
-                reason = 'abstract class (included)'
-              # Skip models without configured tables
-              elsif !model.table_name
-                should_exclude = true
-                reason = 'no table name'
-              # Skip models whose tables don't exist
-              elsif !model.table_exists?
-                should_exclude = true
-                reason = "table '#{model.table_name}' does not exist"
-              # Additional check: Skip models that don't have any columns
-              elsif model.columns.empty?
-                should_exclude = true
-                reason = "table '#{model.table_name}' has no columns"
-              else
-                reason = "table '#{model.table_name}' exists with #{model.columns.size} columns"
-              end
-            rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotDefined => e
+        puts "ModelDetector: Sequential filtering #{models.size} models..." if options[:verbose]
+        # Process models sequentially to prevent concurrent database connections
+        results = models.map do |model|
+          should_exclude = false
+          reason = nil
+
+          begin
+            # Skip abstract models unless explicitly included
+            if model.abstract_class? && !options[:include_abstract]
+              should_exclude = true
+              reason = 'abstract class'
+            # For abstract models that are included, skip table checks
+            elsif model.abstract_class? && options[:include_abstract]
+              reason = 'abstract class (included)'
+            # Skip models without configured tables
+            elsif !model.table_name
               should_exclude = true
-              reason = "database error checking model - #{e.message}"
-            rescue NameError, NoMethodError => e
+              reason = 'no table name'
+            # Skip models whose tables don't exist
+            elsif !model.table_exists?
               should_exclude = true
-              reason = "method error checking model - #{e.message}"
-            rescue StandardError => e
-              # Catch any other errors and exclude the model to prevent ERD corruption
+              reason = "table '#{model.table_name}' does not exist"
+            # Additional check: Skip models that don't have any columns
+            elsif model.columns.empty?
               should_exclude = true
-              reason = "unexpected error checking model - #{e.message}"
+              reason = "table '#{model.table_name}' has no columns"
+            else
+              reason = "table '#{model.table_name}' exists with #{model.columns.size} columns"
             end
+          rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotDefined => e
+            should_exclude = true
+            reason = "database error checking model - #{e.message}"
+          rescue NameError, NoMethodError => e
+            should_exclude = true
+            reason = "method error checking model - #{e.message}"
+          rescue StandardError => e
+            # Catch any other errors and exclude the model to prevent ERD corruption
+            should_exclude = true
+            reason = "unexpected error checking model - #{e.message}"
+          end
 
-            if trace_filtering
-              action = should_exclude ? 'Excluding' : 'Keeping'
-              Rails.logger.debug { "[ModelDetector] #{action} #{model.name}: #{reason}" }
+          if trace_filtering
+            action = should_exclude ? 'Excluding' : 'Keeping'
+            Rails.logger.debug { "[ModelDetector] #{action} #{model.name}: #{reason}" }
+          end
+
+          { model: model, exclude: should_exclude }
+        end
+
+        # Filter out excluded models
+        results.reject { |result| result[:exclude] }.pluck(:model)
+      end
+
+      def filter_models_with_connection_management(models, trace_filtering, options = {})
+        # Group models by connection pool first
+        models_by_pool = models.group_by do |model|
+          model.connection_pool
+        rescue StandardError
+          nil
+        end
+
+        # Assign orphaned models to primary pool
+        if models_by_pool[nil]&.any?
+          begin
+            primary_pool = ApplicationRecord.connection_pool
+            models_by_pool[primary_pool] ||= []
+            models_by_pool[primary_pool].concat(models_by_pool[nil])
+            models_by_pool.delete(nil)
+          rescue StandardError
+            # Keep orphaned models for individual processing
+          end
+        end
+
+        all_pools = models_by_pool.keys.compact
+        valid_models = []
+
+        models_by_pool.each do |pool, pool_models|
+          if pool
+            # Disconnect other pools before processing this one
+            all_pools.each do |p|
+              next if p == pool
+
+              begin
+                p.disconnect! if p.connected?
+              rescue StandardError
+                # Ignore disconnect errors
+              end
             end
 
-            { model: model, exclude: should_exclude }
+            # Process models with managed connection
+            pool.with_connection do |connection|
+              pool_models.each do |model|
+                result = filter_single_model(model, connection, trace_filtering, options)
+                valid_models << model unless result[:exclude]
+              end
+            end
+          else
+            # Fallback for models without pools
+            pool_models.each do |model|
+              result = filter_single_model(model, nil, trace_filtering, options)
+              valid_models << model unless result[:exclude]
+            end
           end
         end
 
-        # Wait for all futures to complete and filter results
-        results = futures.map(&:value!)
-        results.reject { |result| result[:exclude] }.pluck(:model)
+        valid_models
+      end
+
+      def filter_single_model(model, connection, trace_filtering, options)
+        should_exclude = false
+        reason = nil
+
+        begin
+          # Skip abstract models unless explicitly included
+          if model.abstract_class? && !options[:include_abstract]
+            should_exclude = true
+            reason = 'abstract class'
+          # For abstract models that are included, skip table checks
+          elsif model.abstract_class? && options[:include_abstract]
+            reason = 'abstract class (included)'
+          # Skip models without configured tables
+          elsif !model.table_name
+            should_exclude = true
+            reason = 'no table name'
+          # Skip models whose tables don't exist (use connection if available)
+          elsif connection ? !table_exists_with_connection?(model, connection) : !model.table_exists?
+            should_exclude = true
+            reason = "table '#{model.table_name}' does not exist"
+          # Additional check: Skip models that don't have any columns
+          elsif connection ? columns_empty_with_connection?(model, connection) : model.columns.empty?
+            should_exclude = true
+            reason = "table '#{model.table_name}' has no columns"
+          else
+            column_count = connection ? get_column_count_with_connection(model, connection) : model.columns.size
+            reason = "table '#{model.table_name}' exists with #{column_count} columns"
+          end
+        rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotDefined => e
+          should_exclude = true
+          reason = "database error checking model - #{e.message}"
+        rescue NameError, NoMethodError => e
+          should_exclude = true
+          reason = "method error checking model - #{e.message}"
+        rescue StandardError => e
+          # Catch any other errors and exclude the model to prevent corruption
+          should_exclude = true
+          reason = "unexpected error checking model - #{e.message}"
+        end
+
+        if trace_filtering
+          action = should_exclude ? 'Excluding' : 'Keeping'
+          Rails.logger.debug { "[ModelDetector] #{action} #{model.name}: #{reason}" }
+        end
+
+        { model: model, exclude: should_exclude }
+      end
+
+      def table_exists_with_connection?(model, connection)
+        connection.table_exists?(model.table_name)
+      rescue StandardError
+        false
+      end
+
+      def columns_empty_with_connection?(model, connection)
+        connection.columns(model.table_name).empty?
+      rescue StandardError
+        true
+      end
+
+      def get_column_count_with_connection(model, connection)
+        connection.columns(model.table_name).size
+      rescue StandardError
+        0
       end
 
       def has_sti_column?(model)

data/lib/rails_lens/providers/schema_provider.rb

@@ -12,8 +12,12 @@ module RailsLens
       end
 
       def process(model_class, connection = nil)
-        # Use passed connection or fall back to model's connection
-        conn = connection || model_class.connection
+        # Always require a connection to be passed to prevent connection pool exhaustion
+        if connection.nil?
+          raise ArgumentError, 'SchemaProvider requires a connection to be passed to prevent connection pool exhaustion'
+        end
+
+        conn = connection
 
         if model_class.abstract_class?
           # For abstract classes, show database connection information in TOML format

data/lib/rails_lens/schema/adapters/database_info.rb

@@ -104,8 +104,8 @@ module RailsLens
           return [] unless adapter_name == 'PostgreSQL'
 
           connection.select_values(<<-SQL.squish)
-            SELECT schema_name#{' '}
-            FROM information_schema.schemata#{' '}
+            SELECT schema_name
+            FROM information_schema.schemata
             WHERE schema_name NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
             ORDER BY schema_name
           SQL

data/lib/rails_lens/schema/adapters/mysql.rb

@@ -319,7 +319,7 @@ module RailsLens
         # Fetch all view metadata in a single consolidated query
         def fetch_view_metadata
           result = connection.exec_query(<<~SQL.squish, 'MySQL View Metadata')
-            SELECT#{' '}
+            SELECT
               v.is_updatable,
               COALESCE(
                 (

data/lib/rails_lens/schema/adapters/postgresql.rb

@@ -247,17 +247,15 @@ module RailsLens
           result = connection.exec_query(<<~SQL.squish, 'PostgreSQL View Metadata')
             WITH view_info AS (
               -- Check for materialized view
-              SELECT#{' '}
+              SELECT
                 'materialized' as view_type,
                 false as is_updatable,
                 mv.matviewname as view_name
               FROM pg_matviews mv
               WHERE mv.matviewname = '#{connection.quote_string(table_name)}'
-            #{'  '}
               UNION ALL
-            #{'  '}
               -- Check for regular view
-              SELECT#{' '}
+              SELECT
                 'regular' as view_type,
                 CASE WHEN v.is_updatable = 'YES' THEN true ELSE false END as is_updatable,
                 v.table_name as view_name
@@ -274,7 +272,7 @@ module RailsLens
               AND c2.relkind IN ('r', 'v', 'm')
               AND d.deptype = 'n'
             )
-            SELECT#{' '}
+            SELECT
               vi.view_type,
               vi.is_updatable,
               COALESCE(

data/lib/rails_lens/schema/adapters/sqlite3.rb

@@ -136,7 +136,7 @@ module RailsLens
         # Fetch all view metadata in a single consolidated query
         def fetch_view_metadata
           result = connection.exec_query(<<~SQL.squish, 'SQLite View Metadata')
-            SELECT sql FROM sqlite_master#{' '}
+            SELECT sql FROM sqlite_master
             WHERE type = 'view' AND name = '#{connection.quote_string(table_name)}'
             LIMIT 1
           SQL
@@ -186,7 +186,7 @@ module RailsLens
 
         def view_definition
           result = connection.exec_query(<<~SQL.squish, 'SQLite View Definition')
-            SELECT sql FROM sqlite_master#{' '}
+            SELECT sql FROM sqlite_master
             WHERE type = 'view' AND name = '#{connection.quote_string(table_name)}'
             LIMIT 1
           SQL

data/lib/rails_lens/schema/annotation_manager.rb

@@ -61,7 +61,58 @@ module RailsLens
 
       def generate_annotation
         pipeline = AnnotationPipeline.new
-        results = pipeline.process(model_class)
+
+        # If we have a connection set by annotate_all, use it to process all providers
+        if @connection
+          results = { schema: nil, sections: [], notes: [] }
+
+          pipeline.instance_variable_get(:@providers).each do |provider|
+            next unless provider.applicable?(model_class)
+
+            begin
+              result = provider.process(model_class, @connection)
+
+              case provider.type
+              when :schema
+                results[:schema] = result
+              when :section
+                results[:sections] << result if result
+              when :notes
+                results[:notes].concat(Array(result))
+              end
+            rescue StandardError => e
+              warn "Provider #{provider.class} error for #{model_class}: #{e.message}"
+            end
+          end
+        else
+          # Fallback: Use the model's connection pool with proper management
+          # This path is used when annotating individual models
+          warn "Using fallback connection management for #{model_class.name}" if RailsLens.config.verbose
+
+          # Force connection management even in fallback mode
+          results = { schema: nil, sections: [], notes: [] }
+
+          model_class.connection_pool.with_connection do |connection|
+            pipeline.instance_variable_get(:@providers).each do |provider|
+              next unless provider.applicable?(model_class)
+
+              begin
+                result = provider.process(model_class, connection)
+
+                case provider.type
+                when :schema
+                  results[:schema] = result
+                when :section
+                  results[:sections] << result if result
+                when :notes
+                  results[:notes].concat(Array(result))
+                end
+              rescue StandardError => e
+                warn "Provider #{provider.class} error for #{model_class}: #{e.message}"
+              end
+            end
+          end
+        end
 
         annotation = Annotation.new
 
@@ -91,7 +142,13 @@ module RailsLens
       end
 
       def self.annotate_all(options = {})
+        # Convert models option to include option for ModelDetector
+        if options[:models]
+          options[:include] = options[:models]
+        end
+
         models = ModelDetector.detect_models(options)
+        puts "Detected #{models.size} models for annotation" if options[:verbose]
 
         # Filter abstract classes based on options
         if options[:include_abstract]
@@ -105,53 +162,110 @@ module RailsLens
 
         results = { annotated: [], skipped: [], failed: [] }
 
-        models.each do |model|
-          # Ensure model is actually a class, not a hash or other object
-          unless model.is_a?(Class)
-            results[:failed] << { model: model.inspect, error: "Expected Class, got #{model.class}" }
-            next
-          end
+        # Group models by their connection pool to process each database separately
+        models_by_connection_pool = models.group_by do |model|
+          pool = model.connection_pool
+          pool
+        rescue StandardError => e
+          puts "Model #{model.name} -> NO POOL (#{e.message})" if options[:verbose]
+          nil # Models without connection pools will use primary pool
+        end
 
-          # Skip models without tables or with missing tables (but not abstract classes)
-          unless model.abstract_class? || model.table_exists?
-            results[:skipped] << model.name
-            warn "Skipping #{model.name} - table does not exist" if options[:verbose]
-            next
+        # Force models without connection pools to use the primary connection pool
+        if models_by_connection_pool[nil]&.any?
+          begin
+            primary_pool = ApplicationRecord.connection_pool
+            models_by_connection_pool[primary_pool] ||= []
+            models_by_connection_pool[primary_pool].concat(models_by_connection_pool[nil])
+            models_by_connection_pool.delete(nil)
+          rescue StandardError => e
+            puts "Failed to assign to primary pool: #{e.message}" if options[:verbose]
           end
+        end
 
-          manager = new(model)
+        # Get all connection pools first
+        all_pools = get_all_connection_pools(models_by_connection_pool)
 
-          # Determine file path based on options
-          file_path = if options[:models_path]
-                        File.join(options[:models_path], "#{model.name.underscore}.rb")
-                      else
-                        nil # Use default model_file_path
-                      end
+        # Log initial connection status (removed verbose output)
 
-          # Allow external files when models_path is provided (for testing)
-          allow_external = options[:models_path].present?
+        models_by_connection_pool.each do |connection_pool, pool_models|
+          if connection_pool
+            # Disconnect all OTHER connection pools before processing this one
+            disconnect_other_pools(connection_pool, all_pools, options)
 
-          if manager.annotate_file(file_path, allow_external_files: allow_external)
-            results[:annotated] << model.name
+            # Process all models for this database using a single connection
+            connection_pool.with_connection do |connection|
+              pool_models.each do |model|
+                process_model_with_connection(model, connection, results, options)
+              end
+            end
           else
-            results[:skipped] << model.name
+            # This should not happen anymore since we assign orphaned models to primary pool
+            # Use primary connection pool as fallback to avoid creating new connections
+            begin
+              primary_pool = ApplicationRecord.connection_pool
+              primary_pool.with_connection do |connection|
+                pool_models.each do |model|
+                  process_model_with_connection(model, connection, results, options)
+                end
+              end
+            rescue StandardError => e
+              # Last resort: process without connection management (will create multiple connections)
+              pool_models.each do |model|
+                process_model_with_connection(model, nil, results, options)
+              end
+            end
           end
-        rescue ActiveRecord::StatementInvalid => e
-          # Handle database-related errors (missing tables, schemas, etc.)
-          results[:skipped] << model.name
-          warn "Skipping #{model.name} - database error: #{e.message}" if options[:verbose]
-        rescue StandardError => e
-          model_name = if model.is_a?(Class) && model.respond_to?(:name)
-                         model.name
-                       else
-                         model.inspect
-                       end
-          results[:failed] << { model: model_name, error: e.message }
         end
 
         results
       end
 
+      def self.process_model_with_connection(model, connection, results, options)
+        # Ensure model is actually a class, not a hash or other object
+        unless model.is_a?(Class)
+          results[:failed] << { model: model.inspect, error: "Expected Class, got #{model.class}" }
+          return
+        end
+
+        # Skip models without tables or with missing tables (but not abstract classes)
+        unless model.abstract_class? || model.table_exists?
+          results[:skipped] << model.name
+          return
+        end
+
+        manager = new(model)
+
+        # Set the connection in the manager if provided
+        manager.instance_variable_set(:@connection, connection) if connection
+
+        # Determine file path based on options
+        file_path = if options[:models_path]
+                      File.join(options[:models_path], "#{model.name.underscore}.rb")
+                    else
+                      nil # Use default model_file_path
+                    end
+
+        # Allow external files when models_path is provided (for testing)
+        allow_external = options[:models_path].present?
+
+        if manager.annotate_file(file_path, allow_external_files: allow_external)
+          results[:annotated] << model.name
+        else
+          results[:skipped] << model.name
+        end
+      rescue ActiveRecord::StatementInvalid
+        # Handle database-related errors (missing tables, schemas, etc.)
+        results[:skipped] << model.name
+      rescue StandardError => e
+        model_name = if model.is_a?(Class) && model.respond_to?(:name)
+                       model.name
+                     else
+                       model.inspect
+                     end
+        results[:failed] << { model: model_name, error: e.message }
+      end
+
       def self.remove_all(options = {})
         models = ModelDetector.detect_models(options)
         results = { removed: [], skipped: [], failed: [] }
@@ -170,6 +284,45 @@ module RailsLens
         results
       end
 
+      def self.disconnect_other_pools(current_pool, all_pools, options = {})
+        all_pools.each do |pool|
+          next if pool == current_pool || pool.nil?
+
+          begin
+            if pool.connected?
+              pool.disconnect!
+            end
+          rescue StandardError => e
+            warn "Failed to disconnect pool: #{e.message}"
+          end
+        end
+      end
+
+      def self.get_all_connection_pools(models_by_pool)
+        models_by_pool.keys.compact
+      end
+
+      def self.log_connection_status(all_pools, options = {})
+        return unless options[:verbose]
+
+        puts "\n=== Connection Pool Status ==="
+        all_pools.each do |pool|
+          next unless pool
+
+          begin
+            name = pool.db_config&.name || 'unknown'
+            connected = pool.connected?
+            size = pool.size
+            checked_out = pool.stat[:busy]
+
+            puts "Pool #{name}: connected=#{connected}, size=#{size}, busy=#{checked_out}"
+          rescue StandardError => e
+            puts "Pool status error: #{e.message}"
+          end
+        end
+        puts "================================\n"
+      end
+
       private
 
       def add_annotation(content, _file_path = nil)

data/lib/rails_lens/tasks/schema.rake

@@ -9,7 +9,14 @@ namespace :rails_lens do
       options = {}
       options[:include_abstract] = true if ENV['INCLUDE_ABSTRACT'] == 'true'
 
-      puts 'Annotating models with schema information...'
+      # Support model filtering via environment variable
+      if ENV['MODELS']
+        model_list = ENV['MODELS'].split(',').map(&:strip)
+        options[:models] = model_list
+        puts "Filtering to specific models: #{model_list.join(', ')}"
+      end
+
+      options[:verbose] = true # Force verbose mode to see connection management
       results = RailsLens.annotate_models(options)
 
       if results[:annotated].any?

data/lib/rails_lens/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_lens
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.5
 platform: ruby
 authors:
 - Abdelkader Boudih