rails_lens 0.2.4 → 0.2.6

data/lib/rails_lens/model_detector.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'concurrent'
-
 module RailsLens
   class ModelDetector
     class << self
@@ -128,7 +126,7 @@ module RailsLens
         trace_filtering = options[:trace_filtering] || ENV.fetch('RAILS_LENS_TRACE_FILTERING', nil)
 
         original_count = models.size
-        Rails.logger.debug { "[ModelDetector] Starting with #{original_count} models" } if trace_filtering
+        RailsLens.logger.debug { "[ModelDetector] Starting with #{original_count} models" } if trace_filtering
 
         # Remove anonymous classes and non-class objects
         before_count = models.size
@@ -159,7 +157,7 @@ module RailsLens
               end
             end
             if excluded && trace_filtering
-              Rails.logger.debug do
+              RailsLens.logger.debug do
                 "[ModelDetector] Excluding #{model.name}: matched exclude pattern"
               end
             end
@@ -184,12 +182,12 @@ module RailsLens
               end
             end
             if included && trace_filtering
-              Rails.logger.debug do
+              RailsLens.logger.debug do
                 "[ModelDetector] Including #{model.name}: matched include pattern"
               end
             end
             if !included && trace_filtering
-              Rails.logger.debug { "[ModelDetector] Excluding #{model.name}: did not match include patterns" }
+              RailsLens.logger.debug { "[ModelDetector] Excluding #{model.name}: did not match include patterns" }
             end
             included
           end
@@ -198,17 +196,20 @@ 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
-        excluded_tables = RailsLens.config.schema[:exclude_tables]
+        excluded_tables = RailsLens.excluded_tables
         before_count = models.size
         models = models.reject do |model|
           begin
             excluded = excluded_tables.include?(model.table_name)
             if excluded && trace_filtering
-              Rails.logger.debug do
+              RailsLens.logger.debug do
                 "[ModelDetector] Excluding #{model.name}: table '#{model.table_name}' in exclude_tables config"
               end
             end
@@ -217,7 +218,7 @@ module RailsLens
             # This can happen in multi-db setups if the connection is not yet established
             # We will assume the model should be kept in this case
             if trace_filtering
-              Rails.logger.debug do
+              RailsLens.logger.debug do
                 "[ModelDetector] Keeping #{model.name}: connection not defined, assuming keep"
               end
             end
@@ -225,7 +226,7 @@ module RailsLens
           end
         rescue ActiveRecord::StatementInvalid => e
           if trace_filtering
-            Rails.logger.debug do
+            RailsLens.logger.debug do
               "[ModelDetector] Keeping #{model.name}: database error checking exclude_tables - #{e.message}"
             end
           end
@@ -234,11 +235,11 @@ module RailsLens
         log_filter_step('Configuration exclude_tables', before_count, models.size, trace_filtering)
 
         if trace_filtering
-          Rails.logger.debug do
+          RailsLens.logger.debug do
             "[ModelDetector] Final result: #{models.size} models after all filtering"
           end
         end
-        Rails.logger.debug { "[ModelDetector] Final models: #{models.map(&:name).join(', ')}" } if trace_filtering
+        RailsLens.logger.debug { "[ModelDetector] Final models: #{models.map(&:name).join(', ')}" } if trace_filtering
 
         models
       end
@@ -248,68 +249,187 @@ module RailsLens
 
         filtered_count = before_count - after_count
         if filtered_count.positive?
-          Rails.logger.debug do
+          RailsLens.logger.debug do
             "[ModelDetector] #{step_name}: filtered out #{filtered_count} models (#{before_count} -> #{after_count})"
           end
         else
-          Rails.logger.debug { "[ModelDetector] #{step_name}: no models filtered (#{after_count} remain)" }
+          RailsLens.logger.debug { "[ModelDetector] #{step_name}: no models filtered (#{after_count} remain)" }
         end
       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'
+            RailsLens.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'
+          RailsLens.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/mysql.rb

@@ -144,10 +144,10 @@ module RailsLens
             result[1] # Engine is typically the second column
           end
         rescue ActiveRecord::StatementInvalid => e
-          Rails.logger.debug { "Failed to fetch storage engine for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch storage engine for #{table_name}: #{e.message}" }
           nil
         rescue => e
-          Rails.logger.debug { "MySQL error fetching storage engine: #{e.message}" }
+          RailsLens.logger.debug { "MySQL error fetching storage engine: #{e.message}" }
           nil
         end
 
@@ -164,10 +164,10 @@ module RailsLens
 
           collation&.split('_')&.first
         rescue ActiveRecord::StatementInvalid => e
-          Rails.logger.debug { "Failed to fetch charset for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch charset for #{table_name}: #{e.message}" }
           nil
         rescue => e
-          Rails.logger.debug { "MySQL error fetching charset: #{e.message}" }
+          RailsLens.logger.debug { "MySQL error fetching charset: #{e.message}" }
           nil
         end
 
@@ -182,10 +182,10 @@ module RailsLens
             result[14] # Collation is typically the 15th column
           end
         rescue ActiveRecord::StatementInvalid => e
-          Rails.logger.debug { "Failed to fetch collation for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch collation for #{table_name}: #{e.message}" }
           nil
         rescue => e
-          Rails.logger.debug { "MySQL error fetching collation: #{e.message}" }
+          RailsLens.logger.debug { "MySQL error fetching collation: #{e.message}" }
           nil
         end
 
@@ -229,11 +229,11 @@ module RailsLens
           count.to_i.positive?
         rescue ActiveRecord::StatementInvalid => e
           # Table doesn't exist or no permission to query information_schema
-          Rails.logger.debug { "Failed to check partitions for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to check partitions for #{table_name}: #{e.message}" }
           false
         rescue => e
           # MySQL specific errors (connection issues, etc)
-          Rails.logger.debug { "MySQL error checking partitions: #{e.message}" }
+          RailsLens.logger.debug { "MySQL error checking partitions: #{e.message}" }
           false
         end
 
@@ -259,10 +259,10 @@ module RailsLens
           end
         rescue ActiveRecord::StatementInvalid => e
           # Permission denied or table doesn't exist
-          Rails.logger.debug { "Failed to fetch partitions for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch partitions for #{table_name}: #{e.message}" }
         rescue => e
           # MySQL specific errors
-          Rails.logger.debug { "MySQL error fetching partitions: #{e.message}" }
+          RailsLens.logger.debug { "MySQL error fetching partitions: #{e.message}" }
         end
 
         def add_partitions_toml(lines)
@@ -297,10 +297,10 @@ module RailsLens
           lines << ']'
         rescue ActiveRecord::StatementInvalid => e
           # Permission denied or table doesn't exist
-          Rails.logger.debug { "Failed to fetch partitions for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch partitions for #{table_name}: #{e.message}" }
         rescue => e
           # MySQL specific errors
-          Rails.logger.debug { "MySQL error fetching partitions: #{e.message}" }
+          RailsLens.logger.debug { "MySQL error fetching partitions: #{e.message}" }
         end
 
         def add_view_dependencies_toml(lines, view_info)
@@ -345,7 +345,7 @@ module RailsLens
             dependencies: row[1].to_s.split(',').reject(&:empty?)
           }
         rescue ActiveRecord::StatementInvalid, Mysql2::Error => e
-          Rails.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
           nil
         end
 

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

@@ -150,11 +150,11 @@ module RailsLens
           end
         rescue ActiveRecord::StatementInvalid => e
           # Table doesn't exist or other database error
-          Rails.logger.debug { "Failed to fetch check constraints for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch check constraints for #{table_name}: #{e.message}" }
           []
         rescue PG::Error => e
           # PostgreSQL specific errors
-          Rails.logger.debug { "PostgreSQL error fetching check constraints: #{e.message}" }
+          RailsLens.logger.debug { "PostgreSQL error fetching check constraints: #{e.message}" }
           []
         end
 
@@ -164,11 +164,11 @@ module RailsLens
           connection.column_comment(table_name, column_name)
         rescue ActiveRecord::StatementInvalid => e
           # Table or column doesn't exist
-          Rails.logger.debug { "Failed to fetch column comment for #{table_name}.#{column_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch column comment for #{table_name}.#{column_name}: #{e.message}" }
           nil
         rescue PG::Error => e
           # PostgreSQL specific errors
-          Rails.logger.debug { "PostgreSQL error fetching column comment: #{e.message}" }
+          RailsLens.logger.debug { "PostgreSQL error fetching column comment: #{e.message}" }
           nil
         end
 
@@ -178,11 +178,11 @@ module RailsLens
           connection.table_comment(table_name)
         rescue ActiveRecord::StatementInvalid => e
           # Table doesn't exist
-          Rails.logger.debug { "Failed to fetch table comment for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch table comment for #{table_name}: #{e.message}" }
           nil
         rescue PG::Error => e
           # PostgreSQL specific errors
-          Rails.logger.debug { "PostgreSQL error fetching table comment: #{e.message}" }
+          RailsLens.logger.debug { "PostgreSQL error fetching table comment: #{e.message}" }
           nil
         end
 
@@ -292,7 +292,7 @@ module RailsLens
             dependencies: row[2] || []
           }
         rescue ActiveRecord::StatementInvalid, PG::Error => e
-          Rails.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
           nil
         end
 

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

@@ -93,10 +93,10 @@ module RailsLens
             lines << 'FOREIGN_KEYS_ENABLED: false' if fk_status && fk_status['foreign_keys'].zero?
           rescue ActiveRecord::StatementInvalid => e
             # SQLite doesn't recognize the pragma or access denied
-            Rails.logger.debug { "Failed to fetch SQLite foreign_keys pragma: #{e.message}" }
+            RailsLens.logger.debug { "Failed to fetch SQLite foreign_keys pragma: #{e.message}" }
           rescue SQLite3::Exception => e
             # SQLite specific errors (database locked, etc)
-            Rails.logger.debug { "SQLite error fetching pragmas: #{e.message}" }
+            RailsLens.logger.debug { "SQLite error fetching pragmas: #{e.message}" }
           end
         end
 
@@ -113,10 +113,10 @@ module RailsLens
             end
           rescue ActiveRecord::StatementInvalid => e
             # SQLite doesn't recognize the pragma or access denied
-            Rails.logger.debug { "Failed to fetch SQLite foreign_keys pragma: #{e.message}" }
+            RailsLens.logger.debug { "Failed to fetch SQLite foreign_keys pragma: #{e.message}" }
           rescue SQLite3::Exception => e
             # SQLite specific errors (database locked, etc)
-            Rails.logger.debug { "SQLite error fetching pragmas: #{e.message}" }
+            RailsLens.logger.debug { "SQLite error fetching pragmas: #{e.message}" }
           end
         end
 
@@ -164,7 +164,7 @@ module RailsLens
             dependencies: tables.sort
           }
         rescue ActiveRecord::StatementInvalid, SQLite3::Exception => e
-          Rails.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
           nil
         end