solid_queue_autoscaler 1.0.11 → 1.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf794daeb74474c136c8aec706793bf74617dcb610abf42df89ddb4fefd99274
-  data.tar.gz: 96ec9ad6993871c7773ff524c5d71ff3e919ff89aacba5587d5dee63aa277f5d
+  metadata.gz: bafb0cda485024f43bd0e73291bcb0bbbc7275e3f897d4a2acafbd6496140b98
+  data.tar.gz: 4b443c68ca28df2b3efd62a4cd7ae30f6cf53e978c941a1e60aa7ebd0c7befb0
 SHA512:
-  metadata.gz: 0b8dd105d028035aee534300ee1d91af9193faefe4e27c8ba3d72c98b3c401cdc52a04894bdeef0b14ebdd7a42f120e563bb378509f2a9ac046a18554c7079d0
-  data.tar.gz: 9980ac5a53affb82b264cd9e7c9bacb388d26a5ecc0116fdd1e22ce527c66ec63bc51d5fe47a492df1941df1b4d0052cfed721e7e4b62566a5c70ab885852f9c
+  metadata.gz: 943bd220740694c827afc4c3aede77cac6da3b419eda051c686b5fb07cfbb69da28b6b8d5882fcf61122bfc6991352e52b9dab2b7f05982333324efbce20205f
+  data.tar.gz: a201785b1ecc766f744a7d705f64dd1e7afaa611e004f3fb9f003a28a05a397fc412ec276a17b99c4bbad0cf89ed476884f510986e3f95e9f9385252d7e15d31

data/CHANGELOG.md

@@ -7,6 +7,61 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.15] - 2025-01-30
+
+### Fixed
+- **Fixed Heroku adapter 404 error when querying scaled-to-zero dynos** - When a dyno type is scaled to 0 and removed from Heroku's formation, the API returns 404. The adapter now handles this gracefully:
+  - `current_workers` returns 0 instead of raising an error when formation doesn't exist
+  - `scale` falls back to `batch_update` API to create the formation when `update` returns 404
+  - Added `create_formation` private method using Heroku's batch_update endpoint
+  - This enables full scale-to-zero support with `min_workers = 0`
+
+## [1.0.14] - 2025-01-18
+
+### Added
+- **SQLite and MySQL support for advisory locks** - AdvisoryLock now supports multiple database adapters:
+  - PostgreSQL: Uses native `pg_try_advisory_lock/pg_advisory_unlock`
+  - MySQL/Trilogy: Uses `GET_LOCK/RELEASE_LOCK`
+  - SQLite: Uses table-based locking with auto-created locks table
+  - Other databases: Falls back to table-based locking
+  - Automatic adapter detection via `connection.adapter_name`
+  - Stale lock cleanup (locks older than 5 minutes are removed)
+  - Lock ownership tracking (`hostname:pid:thread_id`)
+
+- **Comprehensive configuration tests** - Added 100+ tests across Rails and Sinatra dummy apps:
+  - Tests for ALL configuration options (job_queue, job_priority, scaling thresholds, cooldowns, etc.)
+  - Decision engine threshold tests verifying scaling logic
+  - End-to-end tests with mocked Heroku API verifying full scaling workflow
+  - Queue name and priority regression tests (prevents jobs going to wrong queue)
+
+- **GitHub Actions integration test workflow** - New CI job that runs dummy app tests:
+  - Runs Rails dummy app tests (62 tests)
+  - Runs Sinatra dummy app tests (58 tests)
+  - Ensures queue name, priority, and E2E scaling tests pass before release
+
+- **Release workflow now requires CI to pass** - Updated release.yml to use `workflow_run` trigger:
+  - Release only runs after CI workflow completes successfully
+  - All unit tests, integration tests, and linting must pass before publishing
+
+### Fixed
+- **Fixed test pollution in autoscale_job_spec** - Changed from using RSpec's `described_class` (which caches class references) to dynamic constant lookup, preventing stale class reference issues when tests reload the AutoscaleJob class
+
+## [1.0.13] - 2025-01-17
+
+### Fixed
+- **Fixed AutoscaleJob queue_name type mismatch** - Queue name is now converted to string when set via `apply_job_settings!`
+  - ActiveJob internally uses strings for queue names, but the configuration uses symbols
+  - This caused jobs to have symbol queue names (`:autoscaler`) instead of string (`"autoscaler"`)
+  - Now `apply_job_settings!` calls `.to_s` on the job_queue to ensure consistent string format
+
+## [1.0.12] - 2025-01-17
+
+### Fixed
+- **Fixed AutoscaleJob being enqueued to "default" queue** - Added `queue_as :autoscaler` to the job class
+  - The issue was that SolidQueue recurring jobs capture the queue name during initialization, BEFORE Rails `after_initialize` hooks run
+  - Without a static `queue_as` in the class, jobs defaulted to the "default" queue
+  - The `apply_job_settings!` method can still override this via configuration, but the default must be set in the class for SolidQueue recurring to work correctly
+
 ## [1.0.11] - 2025-01-17
 
 ### Fixed

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Migration for SolidQueueAutoscaler locks table.
+# This table is used for advisory locking on databases that don't support
+# native advisory locks (SQLite, etc.).
+#
+# NOTE: This migration is OPTIONAL. The locks table is automatically created
+# when first needed. Only use this migration if you prefer to manage the
+# table schema explicitly.
+#
+# 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 CreateSolidQueueAutoscalerLocks < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :solid_queue_autoscaler_locks, id: false do |t|
+      t.string :lock_key, null: false, primary_key: true
+      t.integer :lock_id, null: false
+      t.datetime :locked_at, null: false
+      t.string :locked_by, null: false
+    end
+
+    # Index for cleanup of stale locks
+    add_index :solid_queue_autoscaler_locks, :locked_at
+  end
+end

data/lib/solid_queue_autoscaler/adapters/base.rb

@@ -32,6 +32,10 @@ module SolidQueueAutoscaler
     #     end
     #   end
     class Base
+      # Default retry configuration for transient network errors
+      DEFAULT_MAX_RETRIES = 3
+      DEFAULT_RETRY_DELAYS = [1, 2, 4].freeze # Exponential backoff in seconds
+
       # @param config [Configuration] the autoscaler configuration
       def initialize(config:)
         @config = config
@@ -97,6 +101,32 @@ module SolidQueueAutoscaler
       def log_dry_run(message)
         logger.info("[DRY RUN] #{message}")
       end
+
+      # Executes a block with retry logic for transient errors.
+      # Uses exponential backoff with configurable delays.
+      #
+      # @param error_classes [Array<Class>] Exception classes that should trigger a retry
+      # @param max_retries [Integer] Maximum number of retry attempts (default: 3)
+      # @param delays [Array<Integer>] Delay in seconds for each retry (default: [1, 2, 4])
+      # @param retryable_check [Proc, nil] Optional proc to determine if a specific error should be retried
+      # @yield The block to execute with retry logic
+      # @return [Object] The result of the block
+      def with_retry(error_classes, max_retries: DEFAULT_MAX_RETRIES, delays: DEFAULT_RETRY_DELAYS, retryable_check: nil)
+        attempts = 0
+        begin
+          attempts += 1
+          yield
+        rescue *error_classes => e
+          should_retry = retryable_check ? retryable_check.call(e) : true
+          if attempts < max_retries && should_retry
+            delay = delays[attempts - 1] || delays.last
+            logger&.warn("[Autoscaler] #{name} API error (attempt #{attempts}/#{max_retries}), retrying in #{delay}s: #{e.message}")
+            sleep(delay)
+            retry
+          end
+          raise
+        end
+      end
     end
   end
 end

data/lib/solid_queue_autoscaler/adapters/heroku.rb

@@ -20,10 +20,6 @@ module SolidQueueAutoscaler
     #     config.process_type = 'worker'
     #   end
     class Heroku < Base
-      # Retry configuration for transient network errors
-      MAX_RETRIES = 3
-      RETRY_DELAYS = [1, 2, 4].freeze # Exponential backoff in seconds
-
       # Errors that are safe to retry (transient network issues)
       RETRYABLE_ERRORS = [
         Excon::Error::Timeout,
@@ -32,11 +28,18 @@ module SolidQueueAutoscaler
       ].freeze
 
       def current_workers
-        with_retry do
+        with_retry(RETRYABLE_ERRORS, retryable_check: method(:retryable_error?)) do
           formation = client.formation.info(app_name, process_type)
           formation['quantity']
         end
       rescue Excon::Error => e
+        # Handle 404 gracefully - formation doesn't exist means 0 workers
+        # This happens when a dyno type is scaled to 0 and removed from formation
+        if e.respond_to?(:response) && e.response&.status == 404
+          logger&.debug("[Autoscaler] Formation '#{process_type}' not found, treating as 0 workers")
+          return 0
+        end
+
         raise HerokuAPIError.new(
           "Failed to get formation info: #{e.message}",
           status_code: e.respond_to?(:response) ? e.response&.status : nil,
@@ -50,11 +53,17 @@ module SolidQueueAutoscaler
           return quantity
         end
 
-        with_retry do
+        with_retry(RETRYABLE_ERRORS, retryable_check: method(:retryable_error?)) do
           client.formation.update(app_name, process_type, { quantity: quantity })
         end
         quantity
       rescue Excon::Error => e
+        # Handle 404 by trying to create the formation via batch_update
+        # This happens when scaling up a dyno type that was previously scaled to 0
+        if e.respond_to?(:response) && e.response&.status == 404
+          return create_formation(quantity)
+        end
+
         raise HerokuAPIError.new(
           "Failed to scale #{process_type} to #{quantity}: #{e.message}",
           status_code: e.respond_to?(:response) ? e.response&.status : nil,
@@ -88,22 +97,29 @@ module SolidQueueAutoscaler
 
       private
 
-      # Executes a block with retry logic for transient network errors.
-      # Uses exponential backoff: 1s, 2s, 4s delays between retries.
-      def with_retry
-        attempts = 0
-        begin
-          attempts += 1
-          yield
-        rescue *RETRYABLE_ERRORS => e
-          if attempts < MAX_RETRIES && retryable_error?(e)
-            delay = RETRY_DELAYS[attempts - 1] || RETRY_DELAYS.last
-            logger&.warn("[Autoscaler] Heroku API error (attempt #{attempts}/#{MAX_RETRIES}), retrying in #{delay}s: #{e.message}")
-            sleep(delay)
-            retry
-          end
-          raise
+      # Creates a formation that doesn't exist using batch_update.
+      # This is needed when scaling up a dyno type that was previously scaled to 0.
+      #
+      # @param quantity [Integer] desired worker count
+      # @return [Integer] the new worker count
+      # @raise [HerokuAPIError] if the API call fails
+      def create_formation(quantity)
+        logger&.info("[Autoscaler] Formation '#{process_type}' not found, creating with quantity #{quantity}")
+
+        with_retry(RETRYABLE_ERRORS, retryable_check: method(:retryable_error?)) do
+          client.formation.batch_update(app_name, {
+            updates: [
+              { type: process_type, quantity: quantity }
+            ]
+          })
         end
+        quantity
+      rescue Excon::Error => e
+        raise HerokuAPIError.new(
+          "Failed to create formation #{process_type} with quantity #{quantity}: #{e.message}",
+          status_code: e.respond_to?(:response) ? e.response&.status : nil,
+          response_body: e.respond_to?(:response) ? e.response&.body : nil
+        )
       end
 
       # Determines if an error should be retried.

data/lib/solid_queue_autoscaler/adapters/kubernetes.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'net/http'
+
 module SolidQueueAutoscaler
   module Adapters
     # Kubernetes adapter for scaling Deployment replicas.
@@ -30,15 +32,21 @@ module SolidQueueAutoscaler
       # Kubernetes API path for apps/v1 group
       APPS_API_VERSION = 'apis/apps/v1'
 
-      # Retry configuration for transient network errors
-      MAX_RETRIES = 3
-      RETRY_DELAYS = [1, 2, 4].freeze # Exponential backoff in seconds
-
       # Default timeout for Kubernetes API calls (seconds)
       DEFAULT_TIMEOUT = 30
 
+      # Errors that are safe to retry (transient network issues)
+      RETRYABLE_ERRORS = [
+        Errno::ECONNREFUSED,
+        Errno::ETIMEDOUT,
+        Errno::ECONNRESET,
+        Net::OpenTimeout,
+        Net::ReadTimeout,
+        SocketError
+      ].freeze
+
       def current_workers
-        with_retry do
+        with_retry(RETRYABLE_ERRORS) do
           deployment = apps_client.get_deployment(deployment_name, namespace)
           deployment.spec.replicas
         end
@@ -52,7 +60,7 @@ module SolidQueueAutoscaler
           return quantity
         end
 
-        with_retry do
+        with_retry(RETRYABLE_ERRORS) do
           patch_body = { spec: { replicas: quantity } }
           apps_client.patch_deployment(deployment_name, patch_body, namespace)
         end
@@ -75,25 +83,6 @@ module SolidQueueAutoscaler
 
       private
 
-      # Executes a block with retry logic for transient network errors.
-      # Uses exponential backoff: 1s, 2s, 4s delays between retries.
-      def with_retry
-        attempts = 0
-        begin
-          attempts += 1
-          yield
-        rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, Errno::ECONNRESET,
-               Net::OpenTimeout, Net::ReadTimeout, SocketError => e
-          if attempts < MAX_RETRIES
-            delay = RETRY_DELAYS[attempts - 1] || RETRY_DELAYS.last
-            logger&.warn("[Autoscaler] Kubernetes API error (attempt #{attempts}/#{MAX_RETRIES}), retrying in #{delay}s: #{e.message}")
-            sleep(delay)
-            retry
-          end
-          raise
-        end
-      end
-
       def apps_client
         @apps_client ||= build_apps_client
       end

data/lib/solid_queue_autoscaler/advisory_lock.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 require 'zlib'
+require 'socket'
 
 module SolidQueueAutoscaler
-  # PostgreSQL advisory lock wrapper for singleton enforcement.
+  # Advisory lock wrapper for singleton enforcement.
+  # Supports both PostgreSQL (native advisory locks) and SQLite (table-based locks).
   #
-  # IMPORTANT: PgBouncer Compatibility Warning
-  # ==========================================
+  # IMPORTANT: PgBouncer Compatibility Warning (PostgreSQL only)
+  # ============================================================
   # PostgreSQL advisory locks are connection-scoped (session-level locks).
   # If you're using PgBouncer in transaction pooling mode, advisory locks
   # will NOT work correctly because:
@@ -24,6 +26,10 @@ module SolidQueueAutoscaler
   # lock acquisition always failing, PgBouncer is likely the cause.
   #
   class AdvisoryLock
+    LOCKS_TABLE_NAME = 'solid_queue_autoscaler_locks'
+    # Stale lock timeout - locks older than this are considered abandoned (5 minutes)
+    STALE_LOCK_TIMEOUT_SECONDS = 300
+
     attr_reader :lock_key, :timeout
 
     def initialize(lock_key: nil, timeout: nil, config: nil)
@@ -31,6 +37,7 @@ module SolidQueueAutoscaler
       @lock_key = lock_key || @config.lock_key
       @timeout = timeout || @config.lock_timeout_seconds
       @lock_acquired = false
+      @strategy = nil
     end
 
     def with_lock
@@ -43,20 +50,14 @@ module SolidQueueAutoscaler
     def try_lock
       return false if @lock_acquired
 
-      result = connection.select_value(
-        "SELECT pg_try_advisory_lock(#{lock_id})"
-      )
-      @lock_acquired = [true, 't'].include?(result)
+      @lock_acquired = lock_strategy.try_lock
       @lock_acquired
     end
 
     def acquire!
       return true if @lock_acquired
 
-      result = connection.select_value(
-        "SELECT pg_try_advisory_lock(#{lock_id})"
-      )
-      @lock_acquired = [true, 't'].include?(result)
+      @lock_acquired = lock_strategy.try_lock
 
       raise LockError, "Could not acquire advisory lock '#{lock_key}' (id: #{lock_id})" unless @lock_acquired
 
@@ -66,7 +67,7 @@ module SolidQueueAutoscaler
     def release
       return false unless @lock_acquired
 
-      connection.execute("SELECT pg_advisory_unlock(#{lock_id})")
+      lock_strategy.release
       @lock_acquired = false
       true
     end
@@ -87,5 +88,160 @@ module SolidQueueAutoscaler
         hash & 0x7FFFFFFF
       end
     end
+
+    def lock_strategy
+      @strategy ||= create_lock_strategy
+    end
+
+    def create_lock_strategy
+      adapter_name = connection.adapter_name.downcase
+
+      case adapter_name
+      when /postgresql/, /postgis/
+        PostgreSQLLockStrategy.new(connection: connection, lock_id: lock_id, lock_key: lock_key)
+      when /sqlite/
+        SQLiteLockStrategy.new(connection: connection, lock_id: lock_id, lock_key: lock_key)
+      when /mysql/, /trilogy/
+        MySQLLockStrategy.new(connection: connection, lock_id: lock_id, lock_key: lock_key)
+      else
+        # Fall back to table-based locking for unknown adapters
+        TableBasedLockStrategy.new(connection: connection, lock_id: lock_id, lock_key: lock_key)
+      end
+    end
+
+    # Base class for lock strategies
+    class BaseLockStrategy
+      def initialize(connection:, lock_id:, lock_key:)
+        @connection = connection
+        @lock_id = lock_id
+        @lock_key = lock_key
+      end
+
+      def try_lock
+        raise NotImplementedError, "#{self.class} must implement #try_lock"
+      end
+
+      def release
+        raise NotImplementedError, "#{self.class} must implement #release"
+      end
+
+      protected
+
+      attr_reader :connection, :lock_id, :lock_key
+    end
+
+    # PostgreSQL native advisory locks
+    class PostgreSQLLockStrategy < BaseLockStrategy
+      def try_lock
+        result = connection.select_value(
+          "SELECT pg_try_advisory_lock(#{lock_id})"
+        )
+        [true, 't'].include?(result)
+      end
+
+      def release
+        connection.execute("SELECT pg_advisory_unlock(#{lock_id})")
+        true
+      end
+    end
+
+    # MySQL named locks (GET_LOCK/RELEASE_LOCK)
+    class MySQLLockStrategy < BaseLockStrategy
+      def try_lock
+        # MySQL GET_LOCK returns 1 on success, 0 if timeout, NULL on error
+        result = connection.select_value(
+          "SELECT GET_LOCK(#{connection.quote(lock_key)}, 0)"
+        )
+        result == 1
+      end
+
+      def release
+        connection.execute("SELECT RELEASE_LOCK(#{connection.quote(lock_key)})")
+        true
+      end
+    end
+
+    # Table-based locking for databases without native advisory lock support
+    # Uses a simple locks table with INSERT/DELETE for lock management
+    class TableBasedLockStrategy < BaseLockStrategy
+      def try_lock
+        ensure_locks_table_exists!
+        cleanup_stale_locks!
+
+        # Try to insert a lock record
+        begin
+          connection.execute(<<~SQL)
+            INSERT INTO #{quoted_table_name} (lock_key, lock_id, locked_at, locked_by)
+            VALUES (#{connection.quote(lock_key)}, #{lock_id}, #{connection.quote(Time.now.utc.iso8601)}, #{connection.quote(lock_owner)})
+          SQL
+          true
+        rescue ActiveRecord::RecordNotUnique, ActiveRecord::StatementInvalid => e
+          # Lock already held by another process
+          # StatementInvalid catches SQLite's UNIQUE constraint violation
+          return false if e.message.include?('UNIQUE') || e.message.include?('duplicate')
+
+          raise
+        end
+      end
+
+      def release
+        return true unless table_exists?
+
+        connection.execute(<<~SQL)
+          DELETE FROM #{quoted_table_name}
+          WHERE lock_key = #{connection.quote(lock_key)}
+            AND locked_by = #{connection.quote(lock_owner)}
+        SQL
+        true
+      end
+
+      private
+
+      def ensure_locks_table_exists!
+        return if table_exists?
+
+        create_locks_table!
+      end
+
+      def table_exists?
+        @table_exists ||= connection.table_exists?(LOCKS_TABLE_NAME)
+      end
+
+      def create_locks_table!
+        connection.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS #{quoted_table_name} (
+            lock_key VARCHAR(255) NOT NULL PRIMARY KEY,
+            lock_id INTEGER NOT NULL,
+            locked_at DATETIME NOT NULL,
+            locked_by VARCHAR(255) NOT NULL
+          )
+        SQL
+        @table_exists = true
+      end
+
+      def cleanup_stale_locks!
+        # Remove locks older than STALE_LOCK_TIMEOUT_SECONDS
+        stale_threshold = (Time.now.utc - STALE_LOCK_TIMEOUT_SECONDS).iso8601
+        connection.execute(<<~SQL)
+          DELETE FROM #{quoted_table_name}
+          WHERE locked_at < #{connection.quote(stale_threshold)}
+        SQL
+      end
+
+      def quoted_table_name
+        connection.quote_table_name(LOCKS_TABLE_NAME)
+      end
+
+      def lock_owner
+        # Unique identifier for this process/thread
+        @lock_owner ||= "#{Socket.gethostname}:#{Process.pid}:#{Thread.current.object_id}"
+      end
+    end
+
+    # SQLite table-based locking (SQLite doesn't have advisory locks)
+    # Defined after TableBasedLockStrategy since it inherits from it
+    class SQLiteLockStrategy < TableBasedLockStrategy
+      # Inherits all behavior from TableBasedLockStrategy
+    end
   end
 end

data/lib/solid_queue_autoscaler/autoscale_job.rb

@@ -2,15 +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.
+    # Default queue - this MUST be set here (not dynamically) because SolidQueue
+    # recurring jobs capture the queue name during initialization, BEFORE
+    # Rails after_initialize hooks run.
     #
-    # To use a custom queue:
-    # 1. Set queue: in your recurring.yml (recommended)
-    # 2. Or use AutoscaleJob.set(queue: :my_queue).perform_later
+    # The apply_job_settings! method can override this after Rails initializers
+    # run, but the default must be set here for SolidQueue recurring to work.
+    #
+    # You can customize the queue via:
+    #   config.job_queue = :my_queue
+    #
+    # For SolidQueue recurring.yml, you can also set queue: directly in the YAML.
     queue_as :autoscaler
 
     discard_on ConfigurationError

data/lib/solid_queue_autoscaler/railtie.rb

@@ -11,6 +11,11 @@ module SolidQueueAutoscaler
       # Configuration happens via initializer, nothing to do here
     end
 
+    # After all initializers have run, apply job settings from configuration
+    config.after_initialize do
+      SolidQueueAutoscaler.apply_job_settings!
+    end
+
     rake_tasks do
       namespace :solid_queue_autoscaler do
         desc 'Run the autoscaler once for a specific worker (default: :default). Use WORKER=name'

data/lib/solid_queue_autoscaler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidQueueAutoscaler
-  VERSION = '1.0.11'
+  VERSION = '1.0.15'
 end

data/lib/solid_queue_autoscaler.rb

@@ -100,6 +100,33 @@ module SolidQueueAutoscaler
       end
     end
 
+    # Apply job settings (queue, priority) from configuration to AutoscaleJob.
+    # Called automatically after Rails initializers run via the railtie.
+    # Uses the first configured worker's job_queue/job_priority settings.
+    def apply_job_settings!
+      return unless defined?(AutoscaleJob)
+      return if configurations.empty?
+
+      # Use the first configured worker's settings
+      first_config = configurations.values.first
+      job_queue = first_config&.job_queue || :autoscaler
+      job_priority = first_config&.job_priority
+
+      # Set the queue_name class attribute directly (not via queue_as block)
+      # This ensures SolidQueue recurring jobs pick up the correct queue
+      # Convert to string since ActiveJob internally uses strings for queue names
+      AutoscaleJob.queue_name = job_queue.to_s
+
+      # Set priority if configured
+      if job_priority && AutoscaleJob.respond_to?(:priority=)
+        AutoscaleJob.priority = job_priority
+      end
+
+      first_config&.logger&.debug(
+        "[SolidQueueAutoscaler] AutoscaleJob configured: queue=#{job_queue}, priority=#{job_priority || 'default'}"
+      )
+    end
+
     # Verify the installation is complete and working.
     # Prints a human-friendly report (when verbose: true) and returns a VerificationResult.
     #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solid_queue_autoscaler
 version: !ruby/object:Gem::Version
-  version: 1.0.11
+  version: 1.0.15
 platform: ruby
 authors:
 - reillyse
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-17 00:00:00.000000000 Z
+date: 2026-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -122,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.18'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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: A control plane for Solid Queue on Heroku that automatically scales worker
   dynos based on queue depth, job latency, and throughput. Uses PostgreSQL advisory
   locks for singleton behavior and the Heroku Platform API for scaling.
@@ -143,6 +157,7 @@ files:
 - lib/generators/solid_queue_autoscaler/migration_generator.rb
 - lib/generators/solid_queue_autoscaler/templates/README
 - lib/generators/solid_queue_autoscaler/templates/create_solid_queue_autoscaler_events.rb.erb
+- lib/generators/solid_queue_autoscaler/templates/create_solid_queue_autoscaler_locks.rb.erb
 - lib/generators/solid_queue_autoscaler/templates/create_solid_queue_autoscaler_state.rb.erb
 - lib/generators/solid_queue_autoscaler/templates/initializer.rb
 - lib/solid_queue_autoscaler.rb