solid_queue_autoscaler 1.0.7 → 1.0.9

data/lib/generators/solid_queue_autoscaler/migration_generator.rb

@@ -10,19 +10,195 @@ module SolidQueueAutoscaler
 
       source_root File.expand_path('templates', __dir__)
 
-      desc 'Creates the migration for SolidQueueAutoscaler state table'
+      class_option :database, type: :string, default: nil,
+                   desc: 'Specify database for multi-database setups (e.g., --database=queue)'
 
-      def create_migration_file
+      desc 'Creates migrations for SolidQueueAutoscaler tables'
+
+      def create_migration_files
+        detected_config = detect_database_config
+        migration_dir = determine_migration_directory(detected_config)
+        db_name = effective_database_name(detected_config)
+
+        # Show what we detected
+        print_detection_info(detected_config, migration_dir)
+
+        # Create state table migration
         migration_template 'create_solid_queue_autoscaler_state.rb.erb',
-                           'db/migrate/create_solid_queue_autoscaler_state.rb'
+                           "#{migration_dir}/create_solid_queue_autoscaler_state.rb"
+
+        # Create events table migration
+        migration_template 'create_solid_queue_autoscaler_events.rb.erb',
+                           "#{migration_dir}/create_solid_queue_autoscaler_events.rb"
+
+        print_instructions(migration_dir, db_name)
       end
 
       private
 
+      # Detect database configuration for SolidQueue.
+      # Returns a hash with :database_name, :migrations_path, :is_multi_db.
+      def detect_database_config
+        result = { database_name: nil, migrations_path: nil, is_multi_db: false }
+
+        # Check if Rails database config is available
+        return result unless defined?(Rails) && Rails.application
+
+        db_configs = Rails.application.config.database_configuration
+        env_config = db_configs[Rails.env.to_s] || {}
+
+        # Look for a 'queue' database configuration (Rails multi-DB naming convention).
+        # SolidQueue typically uses 'queue' as the database name.
+        queue_config = find_queue_database_config(env_config)
+
+        if queue_config
+          result[:is_multi_db] = true
+          result[:database_name] = queue_config[:name]
+          result[:migrations_path] = queue_config[:migrations_path]
+        end
+
+        result
+      rescue StandardError => e
+        say '  (Could not detect database config: ' + e.message + ')', :yellow
+        { database_name: nil, migrations_path: nil, is_multi_db: false }
+      end
+
+      # Find the queue database configuration from environment config.
+      def find_queue_database_config(env_config)
+        # Rails 7+ multi-database format: { 'primary' => {...}, 'queue' => {...} }
+        # Look for common queue database names.
+        queue_db_names = %w[queue solid_queue queue_database]
+
+        queue_db_names.each do |db_name|
+          if env_config[db_name].is_a?(Hash)
+            config = env_config[db_name]
+            migrations_path = normalize_migrations_path(config['migrations_paths'], db_name)
+            return { name: db_name, migrations_path: migrations_path }
+          end
+        end
+
+        # Check if any database config has migrations_paths containing 'queue'.
+        env_config.each do |name, config|
+          next unless config.is_a?(Hash)
+          next if name == 'primary' # Skip primary database
+
+          migrations_paths = config['migrations_paths']
+          path_str = normalize_migrations_path(migrations_paths, name)
+          if path_str.include?('queue')
+            return { name: name, migrations_path: path_str }
+          end
+        end
+
+        nil
+      end
+
+      # Normalize migrations_paths which can be a string or array.
+      def normalize_migrations_path(migrations_paths, db_name)
+        case migrations_paths
+        when String
+          migrations_paths
+        when Array
+          migrations_paths.first || "db/#{db_name}_migrate"
+        else
+          "db/#{db_name}_migrate"
+        end
+      end
+
+      # Determine the migration directory to use.
+      def determine_migration_directory(detected_config)
+        # 1. Explicit --database option takes precedence
+        if options[:database]
+          return 'db/' + options[:database] + '_migrate'
+        end
+
+        # 2. If we detected a queue database with migrations_path, use it
+        if detected_config[:is_multi_db] && detected_config[:migrations_path]
+          return detected_config[:migrations_path]
+        end
+
+        # 3. Default to standard migrate directory
+        'db/migrate'
+      end
+
+      # Get the effective database name for running migrations.
+      def effective_database_name(detected_config)
+        return options[:database] if options[:database]
+        return detected_config[:database_name] if detected_config[:is_multi_db]
+
+        nil
+      end
+
+      def print_detection_info(detected_config, migration_dir)
+        say ''
+
+        if options[:database]
+          say '📁 Using specified database: ' + options[:database], :green
+        elsif detected_config[:is_multi_db]
+          say '📁 Auto-detected multi-database setup!', :green
+          say '   Database: ' + detected_config[:database_name].to_s, :green
+          say '   Migration path: ' + detected_config[:migrations_path].to_s, :green
+        else
+          say '📁 Using standard migration directory', :green
+
+          # Runtime check: warn if SolidQueue appears to use separate connection
+          if solidqueue_uses_separate_connection?
+            say ''
+            say '⚠️  Warning: SolidQueue appears to use a separate database connection!', :yellow
+            say '   But we could not detect the migrations_paths from database.yml.', :yellow
+            say '   If tables end up in the wrong database, re-run with:', :yellow
+            say '   rails g solid_queue_autoscaler:migration --database=queue', :yellow
+            say ''
+          end
+        end
+
+        say '   Placing migrations in: ' + migration_dir + '/', :blue
+        say ''
+      end
+
+      # Check at runtime if SolidQueue uses a separate database connection.
+      def solidqueue_uses_separate_connection?
+        return false unless defined?(SolidQueue::Record)
+        return false unless SolidQueue::Record.respond_to?(:connection)
+
+        sq_pool = SolidQueue::Record.connection_pool
+        ar_pool = ActiveRecord::Base.connection_pool
+
+        sq_pool.db_config.database != ar_pool.db_config.database
+      rescue StandardError
+        false
+      end
+
+      def print_instructions(migration_dir, db_name)
+        say '✅ Migrations generated successfully!', :green
+        say ''
+        say '📖 To run the migrations:', :blue
+
+        if db_name
+          # Multi-database setup
+          say '   rails db:migrate:' + db_name.to_s, :cyan
+          say ''
+          say '   Or if that does not work:', :blue
+          say '   DATABASE=' + db_name.to_s + ' rails db:migrate', :cyan
+        elsif migration_dir != 'db/migrate'
+          # Custom migration directory without detected database name
+          db_from_path = migration_dir.sub('db/', '').sub('_migrate', '')
+          say '   rails db:migrate:' + db_from_path, :cyan
+        else
+          # Standard single-database
+          say '   rails db:migrate', :cyan
+        end
+
+        say ''
+        say '🔍 To verify setup after migration:', :blue
+        say '   SolidQueueAutoscaler.verify_setup!', :cyan
+        say ''
+      end
+
       def migration_version
         return unless defined?(ActiveRecord::VERSION)
 
-        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+        '[' + ActiveRecord::VERSION::MAJOR.to_s + '.' +
+          ActiveRecord::VERSION::MINOR.to_s + ']'
       end
     end
   end

data/lib/generators/solid_queue_autoscaler/templates/README

@@ -5,24 +5,45 @@ SolidQueueAutoscaler has been installed!
 Next steps:
 
 1. Set environment variables:
-   - HEROKU_API_KEY: Generate with `heroku authorizations:create -d "Solid Queue Autoscaler"`
+   - HEROKU_API_KEY: Generate with `heroku authorizations:create -d 'Solid Queue Autoscaler'`
    - HEROKU_APP_NAME: Your Heroku app name
 
-2. Run the migration generator for persistent cooldown tracking:
+2. Run the migration generator:
 
+   SINGLE DATABASE (SolidQueue uses same database as your app):
+   ---------------------------------------------------------------
    rails generate solid_queue_autoscaler:migration
    rails db:migrate
 
-3. Review config/initializers/solid_queue_autoscaler.rb and adjust thresholds
+   MULTI-DATABASE (SolidQueue in separate 'queue' database):
+   ---------------------------------------------------------------
+   The generator will auto-detect your setup and place migrations
+   in the correct directory (e.g., db/queue_migrate/).
 
-4. Add the recurring job to config/recurring.yml:
+   rails generate solid_queue_autoscaler:migration
+   rails db:migrate:queue
+
+   Or specify explicitly:
+   rails generate solid_queue_autoscaler:migration --database=queue
+   rails db:migrate:queue
+
+3. Verify installation:
+
+   rails console
+   > SolidQueueAutoscaler.verify_setup!
+
+   This will check that tables are in the correct database.
+
+4. Review config/initializers/solid_queue_autoscaler.rb and adjust thresholds
+
+5. Add the recurring job to config/recurring.yml:
 
    autoscaler:
      class: SolidQueueAutoscaler::AutoscaleJob
      queue: autoscaler
      schedule: every 30 seconds
 
-5. Configure a dedicated queue in config/queue.yml:
+6. Configure a dedicated queue in config/queue.yml:
 
    queues:
      - autoscaler
@@ -34,7 +55,7 @@ Next steps:
      - queues: [default]
        threads: 5
 
-6. Test with dry_run mode before enabling in production
+7. Test with dry_run mode before enabling in production
 
 For more information, see: https://github.com/reillyse/solid_queue_autoscaler
 

data/lib/generators/solid_queue_autoscaler/templates/create_solid_queue_autoscaler_events.rb.erb

@@ -1,24 +1,31 @@
 # frozen_string_literal: true
 
+# Migration for SolidQueueAutoscaler events table (for dashboard and event history).
+#
+# For multi-database setups (SolidQueue in separate database):
+#   This migration should be placed in db/queue_migrate/ (or your queue DB's migration path)
+#   Run with: rails db:migrate:queue
+#
+# For single-database setups:
+#   Place in db/migrate/ and run: rails db:migrate
+#
 class CreateSolidQueueAutoscalerEvents < ActiveRecord::Migration<%= migration_version %>
   def change
     create_table :solid_queue_autoscaler_events do |t|
-      t.string :worker_name, null: false
+      t.string :worker_name, null: false, default: 'default'
       t.string :action, null: false
-      t.integer :from_workers, null: false, default: 0
-      t.integer :to_workers, null: false, default: 0
-      t.text :reason
-      t.integer :queue_depth, default: 0
-      t.float :latency_seconds, default: 0.0
-      t.jsonb :metrics_json
+      t.integer :from_workers, null: false
+      t.integer :to_workers, null: false
+      t.string :reason
+      t.integer :queue_depth
+      t.float :latency_seconds
+      t.text :metrics_json
       t.boolean :dry_run, default: false
-
       t.datetime :created_at, null: false
     end
 
+    add_index :solid_queue_autoscaler_events, :created_at
     add_index :solid_queue_autoscaler_events, :worker_name
     add_index :solid_queue_autoscaler_events, :action
-    add_index :solid_queue_autoscaler_events, :created_at
-    add_index :solid_queue_autoscaler_events, %i[worker_name created_at]
   end
 end

data/lib/generators/solid_queue_autoscaler/templates/create_solid_queue_autoscaler_state.rb.erb

@@ -1,5 +1,14 @@
 # frozen_string_literal: true
 
+# Migration for SolidQueueAutoscaler cooldown state table.
+#
+# For multi-database setups (SolidQueue in separate database):
+#   This migration should be placed in db/queue_migrate/ (or your queue DB's migration path)
+#   Run with: rails db:migrate:queue
+#
+# For single-database setups:
+#   Place in db/migrate/ and run: rails db:migrate
+#
 class CreateSolidQueueAutoscalerState < ActiveRecord::Migration<%= migration_version %>
   def change
     create_table :solid_queue_autoscaler_state do |t|

data/lib/generators/solid_queue_autoscaler/templates/initializer.rb

@@ -55,4 +55,10 @@ SolidQueueAutoscaler.configure do |config|
   config.record_events = true
   # Also record no_change events (verbose, generates many records)
   # config.record_all_events = false
+
+  # AutoscaleJob Settings
+  # Queue for the autoscaler job (use a fast/high-priority Solid Queue queue)
+  config.job_queue = :autoscaler
+  # Priority for the autoscaler job (lower = higher priority, nil = default)
+  # config.job_priority = 0  # Uncomment to set highest priority
 end

data/lib/solid_queue_autoscaler/autoscale_job.rb

@@ -2,7 +2,17 @@
 
 module SolidQueueAutoscaler
   class AutoscaleJob < ActiveJob::Base
+    # IMPORTANT: Use a static queue name so SolidQueue recurring jobs work correctly.
+    # When using SolidQueue recurring.yml without specifying queue:, SolidQueue
+    # checks the job class's queue_name attribute. A dynamic queue_as block
+    # returns a Proc that isn't evaluated by recurring jobs, causing jobs to
+    # go to 'default' queue instead.
+    #
+    # To use a custom queue:
+    # 1. Set queue: in your recurring.yml (recommended)
+    # 2. Or use AutoscaleJob.set(queue: :my_queue).perform_later
     queue_as :autoscaler
+
     discard_on ConfigurationError
 
     # Scale a specific worker type, or all workers if :all is passed

data/lib/solid_queue_autoscaler/configuration.rb

@@ -63,6 +63,12 @@ module SolidQueueAutoscaler
     # Dashboard/event recording settings
     attr_accessor :record_events, :record_all_events
 
+    # Cooldown persistence (survives process restarts)
+    attr_accessor :persist_cooldowns
+
+    # AutoscaleJob settings
+    attr_accessor :job_queue, :job_priority
+
     def initialize
       # Configuration name (auto-set when using named configurations)
       @name = :default
@@ -128,6 +134,13 @@ module SolidQueueAutoscaler
       # Dashboard/event recording settings
       @record_events = true # Record scale events to database
       @record_all_events = false # Also record no_change events (verbose)
+
+      # Cooldown persistence (survives process restarts, requires migration)
+      @persist_cooldowns = true
+
+      # AutoscaleJob settings
+      @job_queue = :autoscaler # Queue name for the autoscaler job
+      @job_priority = nil # Job priority (lower = higher priority, nil = default)
     end
 
     # Returns the lock key, auto-generating based on name if not explicitly set

data/lib/solid_queue_autoscaler/scale_event.rb

@@ -48,6 +48,124 @@ module SolidQueueAutoscaler
     end
 
     class << self
+      # Diagnostic method to help debug why events aren't being saved.
+      # @param config [Configuration, nil] Configuration to check (uses default if nil)
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter, nil] Database connection
+      # @return [Hash] Diagnostic information
+      def debug_event_saving(config: nil, connection: nil)
+        config ||= SolidQueueAutoscaler.config rescue nil
+        conn = connection || default_connection rescue nil
+
+        diagnostics = {
+          timestamp: Time.current,
+          config_present: !config.nil?,
+          connection_present: !conn.nil?,
+          record_events_setting: nil,
+          connection_available: false,
+          record_events_effective: false,
+          table_exists: false,
+          can_query: false,
+          can_insert: false,
+          issues: [],
+          connection_class: nil,
+          error: nil
+        }
+
+        # Check config settings
+        if config
+          diagnostics[:record_events_setting] = config.record_events
+          diagnostics[:connection_available] = config.connection_available?
+          diagnostics[:record_events_effective] = config.record_events?
+
+          unless config.record_events
+            diagnostics[:issues] << 'config.record_events is false'
+          end
+
+          unless config.connection_available?
+            diagnostics[:issues] << 'config.connection_available? returned false'
+          end
+        else
+          diagnostics[:issues] << 'No configuration found'
+        end
+
+        # Check connection
+        if conn
+          diagnostics[:connection_class] = conn.class.name
+
+          # Check table exists
+          begin
+            diagnostics[:table_exists] = conn.table_exists?(TABLE_NAME)
+            unless diagnostics[:table_exists]
+              diagnostics[:issues] << "Table '#{TABLE_NAME}' does not exist. Run: rails generate solid_queue_autoscaler:dashboard"
+            end
+          rescue StandardError => e
+            diagnostics[:issues] << "Error checking table existence: #{e.message}"
+          end
+
+          # Check can query
+          if diagnostics[:table_exists]
+            begin
+              conn.select_value("SELECT COUNT(*) FROM #{TABLE_NAME}")
+              diagnostics[:can_query] = true
+            rescue StandardError => e
+              diagnostics[:issues] << "Error querying table: #{e.message}"
+            end
+          end
+
+          # Check can insert (with rollback)
+          if diagnostics[:can_query]
+            begin
+              # Try a test insert that we'll check but not actually commit
+              test_sql = <<~SQL
+                INSERT INTO #{TABLE_NAME}
+                  (worker_name, action, from_workers, to_workers, reason,
+                   queue_depth, latency_seconds, metrics_json, dry_run, created_at)
+                VALUES
+                  (#{conn.quote('_debug_test')},
+                   #{conn.quote('skipped')},
+                   #{conn.quote(0)},
+                   #{conn.quote(0)},
+                   #{conn.quote('debug test - should be deleted')},
+                   #{conn.quote(0)},
+                   #{conn.quote(0.0)},
+                   #{conn.quote(nil)},
+                   #{conn.quote(true)},
+                   #{conn.quote(Time.current)})
+                RETURNING id
+              SQL
+
+              result = conn.execute(test_sql)
+              test_id = result.first&.fetch('id', nil)
+
+              if test_id
+                diagnostics[:can_insert] = true
+                # Clean up test record
+                conn.execute("DELETE FROM #{TABLE_NAME} WHERE id = #{test_id}")
+              else
+                diagnostics[:issues] << 'INSERT succeeded but no id returned'
+              end
+            rescue StandardError => e
+              diagnostics[:issues] << "Error inserting test record: #{e.message}"
+            end
+          end
+        else
+          diagnostics[:issues] << 'No database connection available'
+        end
+
+        # Summary
+        diagnostics[:would_save_events] = diagnostics[:record_events_effective] &&
+                                          diagnostics[:table_exists] &&
+                                          diagnostics[:can_insert]
+
+        diagnostics
+      rescue StandardError => e
+        {
+          timestamp: Time.current,
+          error: "#{e.class}: #{e.message}",
+          issues: ["Unexpected error during diagnostics: #{e.message}"]
+        }
+      end
+
       # Creates a new scale event record.
       # @param attrs [Hash] Event attributes
       # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
@@ -209,6 +327,71 @@ module SolidQueueAutoscaler
         0
       end
 
+      # Returns diagnostic information to help debug event storage issues.
+      # Use this method in Rails console to understand why events might not be stored.
+      #
+      # @example Check why events aren't being stored
+      #   SolidQueueAutoscaler::ScaleEvent.diagnostics
+      #   # => { table_exists: false, error: "Table does not exist..." }
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Hash] Diagnostic information
+      def diagnostics(connection: nil)
+        conn = connection || default_connection
+        result = {
+          table_name: TABLE_NAME,
+          connection_class: conn.class.name,
+          table_exists: false,
+          event_count: 0,
+          recent_events: 0,
+          last_event_at: nil,
+          error: nil
+        }
+
+        # Check table existence
+        begin
+          result[:table_exists] = conn.table_exists?(TABLE_NAME)
+        rescue StandardError => e
+          result[:error] = "Failed to check table existence: #{e.message}"
+          return result
+        end
+
+        unless result[:table_exists]
+          result[:error] = "Table does not exist. Run: rails generate solid_queue_autoscaler:migration && rails db:migrate"
+          return result
+        end
+
+        # Get event counts
+        begin
+          result[:event_count] = count(connection: conn)
+          result[:recent_events] = count(since: 24.hours.ago, connection: conn)
+
+          # Get last event time
+          sql = "SELECT MAX(created_at) FROM #{TABLE_NAME}"
+          last_at = conn.select_value(sql)
+          result[:last_event_at] = last_at ? parse_time(last_at) : nil
+        rescue StandardError => e
+          result[:error] = "Failed to query events: #{e.message}"
+        end
+
+        # Add configuration info
+        begin
+          config = SolidQueueAutoscaler.config
+          result[:config] = {
+            record_events: config.record_events,
+            record_all_events: config.record_all_events,
+            record_events_effective: config.record_events?,
+            connection_available: config.connection_available?
+          }
+        rescue StandardError => e
+          result[:config_error] = e.message
+        end
+
+        result
+      rescue StandardError => e
+        { error: "Diagnostics failed: #{e.message}" }
+      end
+
       private
 
       def default_connection