solid_queue_autoscaler 1.0.10 → 1.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39531d30eeaa5c53e6c5f4fb01f106b586ebe9b0243be5d7e6ae7748d591c52f
-  data.tar.gz: f8a4035f055d66f9ce04d6450653c86cc9ee6cd632145db26e0b8c2c2085a731
+  metadata.gz: cf794daeb74474c136c8aec706793bf74617dcb610abf42df89ddb4fefd99274
+  data.tar.gz: 96ec9ad6993871c7773ff524c5d71ff3e919ff89aacba5587d5dee63aa277f5d
 SHA512:
-  metadata.gz: df8dca7f8a6e75ee7feea851c3120af1fe522e273e7b937d1df02988bc8297dc72094ea272095db490c80ae4d617bb47f15e5adbee26bd36706373f0c020c7cb
-  data.tar.gz: aa902d3745ab5992f5698bb130078170217ed389511aba8f6669704fafe1e04a7ab8df7ff2391104af75951d4ce68941f3cf15df0bf3c1c2cae05e1d4d26648e
+  metadata.gz: 0b8dd105d028035aee534300ee1d91af9193faefe4e27c8ba3d72c98b3c401cdc52a04894bdeef0b14ebdd7a42f120e563bb378509f2a9ac046a18554c7079d0
+  data.tar.gz: 9980ac5a53affb82b264cd9e7c9bacb388d26a5ecc0116fdd1e22ce527c66ec63bc51d5fe47a492df1941df1b4d0052cfed721e7e4b62566a5c70ab885852f9c

data/CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.11] - 2025-01-17
+
+### Fixed
+
+#### Critical Fixes
+- **Thread safety** - Fixed race condition in mutex initialization (`scaler.rb`). Changed from lazy `@cooldown_mutex ||= Mutex.new` to thread-safe class constant `COOLDOWN_MUTEX`
+- **SQL injection prevention** - Added regex validation for `table_prefix` configuration to only allow `[a-z0-9_]+` pattern
+- **PgBouncer documentation** - Added prominent warning in `advisory_lock.rb` about incompatibility with PgBouncer transaction pooling mode
+
+#### High Priority Fixes
+- **CooldownTracker caching** - Added 5-minute TTL for `table_exists?` cache and `reset_table_exists_cache!` method for manual invalidation
+- **ScaleEvent naming** - Renamed `create!` to `create` (non-bang) since it catches exceptions and returns nil. Added `create!` as deprecated alias for backward compatibility
+- **Decision struct mutation** - Fixed mutation of Decision struct when clamping target workers. Now creates a new Decision instead of modifying the existing one
+- **ZeroDivisionError prevention** - Added validation that `scale_up_jobs_per_worker`, `scale_up_latency_per_worker`, and `scale_down_jobs_per_worker` must be > 0 when using proportional scaling
+
+#### Medium Priority Fixes
+- **Retry logic for adapters** - Added exponential backoff retry (3 attempts with 1s/2s/4s delays) for transient network errors in both Heroku and Kubernetes adapters
+- **Time parsing** - Fixed timezone handling in `cooldown_tracker.rb` to properly handle Time, DateTime, and String values
+- **Dashboard query optimization** - Batched cooldown state retrieval in `worker_status` to reduce database queries
+- **Metrics nil handling** - `oldest_job_age_seconds` now returns `0.0` instead of `nil` when no jobs exist
+- **Kubernetes timeout** - Added 30-second timeout configuration to kubeclient API calls
+
+#### Low Priority Fixes
+- **Safe logger calls** - Added safe navigation (`logger&.warn`) throughout to prevent nil errors
+- **SQL table quoting** - Now uses `connection.quote_table_name()` for all table name interpolations
+- **Rails.logger nil check** - Added proper nil check before using `Rails.logger` in `scale_event.rb`
+
 ## [1.0.10] - 2025-01-17
 
 ### Fixed

data/lib/solid_queue_autoscaler/adapters/heroku.rb

@@ -20,9 +20,22 @@ 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,
+        Excon::Error::Socket,
+        Excon::Error::HTTPStatus
+      ].freeze
+
       def current_workers
-        formation = client.formation.info(app_name, process_type)
-        formation['quantity']
+        with_retry do
+          formation = client.formation.info(app_name, process_type)
+          formation['quantity']
+        end
       rescue Excon::Error => e
         raise HerokuAPIError.new(
           "Failed to get formation info: #{e.message}",
@@ -37,7 +50,9 @@ module SolidQueueAutoscaler
           return quantity
         end
 
-        client.formation.update(app_name, process_type, { quantity: quantity })
+        with_retry do
+          client.formation.update(app_name, process_type, { quantity: quantity })
+        end
         quantity
       rescue Excon::Error => e
         raise HerokuAPIError.new(
@@ -73,6 +88,36 @@ 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
+        end
+      end
+
+      # Determines if an error should be retried.
+      # Retries timeouts and 5xx errors, but not 4xx client errors.
+      def retryable_error?(error)
+        return true unless error.respond_to?(:response) && error.response
+
+        status = error.response.status
+        return true if status.nil?
+
+        # Retry server errors (5xx), not client errors (4xx)
+        status >= 500 || status == 429 # Also retry rate limiting
+      end
+
       def client
         @client ||= PlatformAPI.connect_oauth(api_key)
       end

data/lib/solid_queue_autoscaler/adapters/kubernetes.rb

@@ -30,9 +30,18 @@ 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
+
       def current_workers
-        deployment = apps_client.get_deployment(deployment_name, namespace)
-        deployment.spec.replicas
+        with_retry do
+          deployment = apps_client.get_deployment(deployment_name, namespace)
+          deployment.spec.replicas
+        end
       rescue StandardError => e
         raise KubernetesAPIError.new("Failed to get deployment info: #{e.message}", original_error: e)
       end
@@ -43,8 +52,10 @@ module SolidQueueAutoscaler
           return quantity
         end
 
-        patch_body = { spec: { replicas: quantity } }
-        apps_client.patch_deployment(deployment_name, patch_body, namespace)
+        with_retry do
+          patch_body = { spec: { replicas: quantity } }
+          apps_client.patch_deployment(deployment_name, patch_body, namespace)
+        end
         quantity
       rescue StandardError => e
         raise KubernetesAPIError.new("Failed to scale deployment #{deployment_name} to #{quantity}: #{e.message}",
@@ -64,6 +75,25 @@ 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
@@ -95,7 +125,11 @@ module SolidQueueAutoscaler
           api_endpoint,
           'v1',
           auth_options: auth_options,
-          ssl_options: ssl_options
+          ssl_options: ssl_options,
+          timeouts: {
+            open: DEFAULT_TIMEOUT,
+            read: DEFAULT_TIMEOUT
+          }
         )
       end
 
@@ -112,7 +146,11 @@ module SolidQueueAutoscaler
           api_endpoint,
           'v1',
           ssl_options: context.ssl_options,
-          auth_options: context.auth_options
+          auth_options: context.auth_options,
+          timeouts: {
+            open: DEFAULT_TIMEOUT,
+            read: DEFAULT_TIMEOUT
+          }
         )
       end
 

data/lib/solid_queue_autoscaler/advisory_lock.rb

@@ -3,6 +3,26 @@
 require 'zlib'
 
 module SolidQueueAutoscaler
+  # PostgreSQL advisory lock wrapper for singleton enforcement.
+  #
+  # IMPORTANT: PgBouncer Compatibility Warning
+  # ==========================================
+  # 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:
+  #   1. Each query may run on a different backend connection
+  #   2. The lock acquired on one connection won't be visible on another
+  #   3. The lock may be "released" when returned to the pool
+  #
+  # Solutions:
+  #   - Use PgBouncer in session pooling mode for the queue database
+  #   - Use a direct connection (bypass PgBouncer) for the autoscaler
+  #   - Disable advisory locks and use external coordination (Redis, etc.)
+  #   - Set config.persist_cooldowns = false and rely on a single process
+  #
+  # If you're seeing multiple autoscalers running simultaneously or
+  # lock acquisition always failing, PgBouncer is likely the cause.
+  #
   class AdvisoryLock
     attr_reader :lock_key, :timeout
 

data/lib/solid_queue_autoscaler/configuration.rb

@@ -175,6 +175,21 @@ module SolidQueueAutoscaler
         errors << 'table_prefix cannot be nil or empty'
       elsif !table_prefix.to_s.end_with?('_')
         errors << 'table_prefix must end with an underscore'
+      elsif !table_prefix.to_s.match?(/\A[a-z0-9_]+\z/)
+        errors << 'table_prefix must contain only lowercase letters, numbers, and underscores'
+      end
+
+      # Validate proportional scaling settings to prevent ZeroDivisionError
+      if scaling_strategy == :proportional
+        if scale_up_jobs_per_worker.nil? || scale_up_jobs_per_worker <= 0
+          errors << 'scale_up_jobs_per_worker must be > 0 for proportional scaling'
+        end
+        if scale_up_latency_per_worker.nil? || scale_up_latency_per_worker <= 0
+          errors << 'scale_up_latency_per_worker must be > 0 for proportional scaling'
+        end
+        if scale_down_jobs_per_worker.nil? || scale_down_jobs_per_worker <= 0
+          errors << 'scale_down_jobs_per_worker must be > 0 for proportional scaling'
+        end
       end
 
       unless VALID_SCALING_STRATEGIES.include?(scaling_strategy)

data/lib/solid_queue_autoscaler/cooldown_tracker.rb

@@ -13,16 +13,24 @@ module SolidQueueAutoscaler
       @config = config || SolidQueueAutoscaler.config
       @key = key
       @table_exists = nil
+      @table_exists_checked_at = nil
+    end
+
+    # Resets the cached table_exists? result.
+    # Call this after running migrations to re-check table existence.
+    def reset_table_exists_cache!
+      @table_exists = nil
+      @table_exists_checked_at = nil
     end
 
     def last_scale_up_at
       return nil unless table_exists?
 
       result = connection.select_value(<<~SQL)
-        SELECT last_scale_up_at FROM #{TABLE_NAME}
+        SELECT last_scale_up_at FROM #{quoted_table_name}
         WHERE key = #{connection.quote(key)}
       SQL
-      result ? Time.parse(result.to_s) : nil
+      parse_time_result(result)
     rescue ArgumentError
       nil
     end
@@ -31,10 +39,10 @@ module SolidQueueAutoscaler
       return nil unless table_exists?
 
       result = connection.select_value(<<~SQL)
-        SELECT last_scale_down_at FROM #{TABLE_NAME}
+        SELECT last_scale_down_at FROM #{quoted_table_name}
         WHERE key = #{connection.quote(key)}
       SQL
-      result ? Time.parse(result.to_s) : nil
+      parse_time_result(result)
     rescue ArgumentError
       nil
     end
@@ -57,7 +65,7 @@ module SolidQueueAutoscaler
       return false unless table_exists?
 
       connection.execute(<<~SQL)
-        DELETE FROM #{TABLE_NAME} WHERE key = #{connection.quote(key)}
+        DELETE FROM #{quoted_table_name} WHERE key = #{connection.quote(key)}
       SQL
       true
     end
@@ -92,12 +100,23 @@ module SolidQueueAutoscaler
       [remaining, 0].max
     end
 
+    # Cache TTL for table existence check (5 minutes)
+    TABLE_EXISTS_CACHE_TTL = 300
+
     def table_exists?
-      return @table_exists unless @table_exists.nil?
+      # Return cached result if still valid
+      if !@table_exists.nil? && @table_exists_checked_at
+        cache_age = Time.now - @table_exists_checked_at
+        return @table_exists if cache_age < TABLE_EXISTS_CACHE_TTL
+      end
 
       @table_exists = connection.table_exists?(TABLE_NAME)
+      @table_exists_checked_at = Time.now
+      @table_exists
     rescue StandardError
       @table_exists = false
+      @table_exists_checked_at = Time.now
+      @table_exists
     end
 
     def state
@@ -105,7 +124,7 @@ module SolidQueueAutoscaler
 
       row = connection.select_one(<<~SQL)
         SELECT last_scale_up_at, last_scale_down_at, updated_at
-        FROM #{TABLE_NAME}
+        FROM #{quoted_table_name}
         WHERE key = #{connection.quote(key)}
       SQL
 
@@ -124,6 +143,28 @@ module SolidQueueAutoscaler
       @config.connection
     end
 
+    def quoted_table_name
+      connection.quote_table_name(TABLE_NAME)
+    end
+
+    # Safely parses a time value from the database.
+    # Handles Time, DateTime, String, and nil values.
+    def parse_time_result(value)
+      return nil if value.nil?
+
+      case value
+      when Time, DateTime
+        value.to_time
+      when String
+        Time.parse(value)
+      else
+        # Try to convert to time if possible
+        value.respond_to?(:to_time) ? value.to_time : Time.parse(value.to_s)
+      end
+    rescue ArgumentError, TypeError
+      nil
+    end
+
     def upsert_state(last_scale_up_at: nil, last_scale_down_at: nil)
       now = Time.current
       quoted_key = connection.quote(key)
@@ -132,7 +173,7 @@ module SolidQueueAutoscaler
       if last_scale_up_at
         quoted_time = connection.quote(last_scale_up_at)
         connection.execute(<<~SQL)
-          INSERT INTO #{TABLE_NAME} (key, last_scale_up_at, created_at, updated_at)
+          INSERT INTO #{quoted_table_name} (key, last_scale_up_at, created_at, updated_at)
           VALUES (#{quoted_key}, #{quoted_time}, #{quoted_now}, #{quoted_now})
           ON CONFLICT (key) DO UPDATE SET
             last_scale_up_at = EXCLUDED.last_scale_up_at,
@@ -141,7 +182,7 @@ module SolidQueueAutoscaler
       elsif last_scale_down_at
         quoted_time = connection.quote(last_scale_down_at)
         connection.execute(<<~SQL)
-          INSERT INTO #{TABLE_NAME} (key, last_scale_down_at, created_at, updated_at)
+          INSERT INTO #{quoted_table_name} (key, last_scale_down_at, created_at, updated_at)
           VALUES (#{quoted_key}, #{quoted_time}, #{quoted_now}, #{quoted_now})
           ON CONFLICT (key) DO UPDATE SET
             last_scale_down_at = EXCLUDED.last_scale_down_at,

data/lib/solid_queue_autoscaler/dashboard.rb

@@ -11,12 +11,15 @@ module SolidQueueAutoscaler
         workers = SolidQueueAutoscaler.registered_workers
         workers = [:default] if workers.empty?
 
-        workers.each_with_object({}) do |name, status|
-          status[name] = worker_status(name)
+        # Batch collect metrics once per worker to reduce DB queries
+        workers.each_with_object({}) do |name, result|
+          result[name] = worker_status(name)
         end
       end
 
       # Returns status for a specific worker
+      # Note: Each call makes several DB queries. For multiple workers,
+      # consider caching or using status() which can batch some queries.
       # @param name [Symbol] Worker name
       # @return [Hash] Status information
       def worker_status(name)
@@ -24,6 +27,9 @@ module SolidQueueAutoscaler
         metrics = safe_metrics(name)
         tracker = CooldownTracker.new(config: config, key: name.to_s)
 
+        # Batch cooldown state retrieval into one DB call
+        cooldown_state = tracker.state
+
         {
           name: name,
           enabled: config.enabled?,
@@ -45,8 +51,8 @@ module SolidQueueAutoscaler
           cooldowns: {
             scale_up_remaining: tracker.scale_up_cooldown_remaining.round,
             scale_down_remaining: tracker.scale_down_cooldown_remaining.round,
-            last_scale_up: tracker.last_scale_up_at,
-            last_scale_down: tracker.last_scale_down_at
+            last_scale_up: cooldown_state[:last_scale_up_at],
+            last_scale_down: cooldown_state[:last_scale_down_at]
           },
           thresholds: {
             scale_up_queue_depth: config.scale_up_queue_depth,

data/lib/solid_queue_autoscaler/metrics.rb

@@ -72,7 +72,9 @@ module SolidQueueAutoscaler
         #{queue_filter_clause}
       SQL
       result = connection.select_value(sql)
-      result.to_f
+      # Return 0 if no jobs exist (result is nil) instead of nil.to_f which returns 0.0
+      # This makes the return value more predictable and avoids nil-related issues
+      result.nil? ? 0.0 : result.to_f
     end
 
     def jobs_per_minute
@@ -141,32 +143,33 @@ module SolidQueueAutoscaler
     end
 
     # Table name helpers using configurable prefix
+    # Uses quote_table_name for SQL safety
     def table_prefix
       @config.table_prefix
     end
 
     def ready_executions_table
-      "#{table_prefix}ready_executions"
+      connection.quote_table_name("#{table_prefix}ready_executions")
     end
 
     def jobs_table
-      "#{table_prefix}jobs"
+      connection.quote_table_name("#{table_prefix}jobs")
     end
 
     def claimed_executions_table
-      "#{table_prefix}claimed_executions"
+      connection.quote_table_name("#{table_prefix}claimed_executions")
     end
 
     def failed_executions_table
-      "#{table_prefix}failed_executions"
+      connection.quote_table_name("#{table_prefix}failed_executions")
     end
 
     def blocked_executions_table
-      "#{table_prefix}blocked_executions"
+      connection.quote_table_name("#{table_prefix}blocked_executions")
     end
 
     def processes_table
-      "#{table_prefix}processes"
+      connection.quote_table_name("#{table_prefix}processes")
     end
   end
 end

data/lib/solid_queue_autoscaler/scale_event.rb

@@ -167,16 +167,18 @@ module SolidQueueAutoscaler
       end
 
       # Creates a new scale event record.
+      # Returns nil if the table doesn't exist or on error (does not raise).
       # @param attrs [Hash] Event attributes
       # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
-      # @return [ScaleEvent] The created event
-      def create!(attrs, connection: nil)
+      # @return [ScaleEvent, nil] The created event, or nil on failure
+      def create(attrs, connection: nil)
         conn = connection || default_connection
         return nil unless table_exists?(conn)
 
         now = Time.current
+        quoted_table = conn.quote_table_name(TABLE_NAME)
         sql = <<~SQL
-          INSERT INTO #{TABLE_NAME}
+          INSERT INTO #{quoted_table}
             (worker_name, action, from_workers, to_workers, reason,
              queue_depth, latency_seconds, metrics_json, dry_run, created_at)
           VALUES
@@ -199,10 +201,18 @@ module SolidQueueAutoscaler
         new(attrs.merge(id: id, created_at: now))
       rescue StandardError => e
         # Log but don't fail if event recording fails
-        Rails.logger.warn("[Autoscaler] Failed to record event: #{e.message}") if defined?(Rails)
+        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+          Rails.logger.warn("[Autoscaler] Failed to record event: #{e.message}")
+        end
         nil
       end
 
+      # Alias for backward compatibility
+      # @deprecated Use {#create} instead
+      def create!(attrs, connection: nil)
+        create(attrs, connection: connection)
+      end
+
       # Finds recent events.
       # @param limit [Integer] Maximum number of events to return
       # @param worker_name [String, nil] Filter by worker name
@@ -213,11 +223,12 @@ module SolidQueueAutoscaler
         return [] unless table_exists?(conn)
 
         filter = worker_name ? "WHERE worker_name = #{conn.quote(worker_name)}" : ''
+        quoted_table = conn.quote_table_name(TABLE_NAME)
 
         sql = <<~SQL
           SELECT id, worker_name, action, from_workers, to_workers, reason,
                  queue_depth, latency_seconds, metrics_json, dry_run, created_at
-          FROM #{TABLE_NAME}
+          FROM #{quoted_table}
           #{filter}
           ORDER BY created_at DESC
           LIMIT #{limit.to_i}
@@ -237,10 +248,11 @@ module SolidQueueAutoscaler
         conn = connection || default_connection
         return [] unless table_exists?(conn)
 
+        quoted_table = conn.quote_table_name(TABLE_NAME)
         sql = <<~SQL
           SELECT id, worker_name, action, from_workers, to_workers, reason,
                  queue_depth, latency_seconds, metrics_json, dry_run, created_at
-          FROM #{TABLE_NAME}
+          FROM #{quoted_table}
           WHERE action = #{conn.quote(action)}
           ORDER BY created_at DESC
           LIMIT #{limit.to_i}
@@ -261,6 +273,7 @@ module SolidQueueAutoscaler
         return default_stats unless table_exists?(conn)
 
         worker_filter = worker_name ? "AND worker_name = #{conn.quote(worker_name)}" : ''
+        quoted_table = conn.quote_table_name(TABLE_NAME)
 
         sql = <<~SQL
           SELECT
@@ -268,7 +281,7 @@ module SolidQueueAutoscaler
             COUNT(*) as count,
             AVG(queue_depth) as avg_queue_depth,
             AVG(latency_seconds) as avg_latency
-          FROM #{TABLE_NAME}
+          FROM #{quoted_table}
           WHERE created_at >= #{conn.quote(since)}
           #{worker_filter}
           GROUP BY action
@@ -289,9 +302,10 @@ module SolidQueueAutoscaler
         return 0 unless table_exists?(conn)
 
         cutoff = Time.current - keep_days.days
+        quoted_table = conn.quote_table_name(TABLE_NAME)
 
         sql = <<~SQL
-          DELETE FROM #{TABLE_NAME}
+          DELETE FROM #{quoted_table}
           WHERE created_at < #{conn.quote(cutoff)}
         SQL
 
@@ -320,8 +334,9 @@ module SolidQueueAutoscaler
         return 0 unless table_exists?(conn)
 
         time_filter = since ? "WHERE created_at >= #{conn.quote(since)}" : ''
+        quoted_table = conn.quote_table_name(TABLE_NAME)
 
-        sql = "SELECT COUNT(*) FROM #{TABLE_NAME} #{time_filter}"
+        sql = "SELECT COUNT(*) FROM #{quoted_table} #{time_filter}"
         conn.select_value(sql).to_i
       rescue StandardError
         0
@@ -367,7 +382,8 @@ module SolidQueueAutoscaler
           result[:recent_events] = count(since: 24.hours.ago, connection: conn)
 
           # Get last event time
-          sql = "SELECT MAX(created_at) FROM #{TABLE_NAME}"
+          quoted_table = conn.quote_table_name(TABLE_NAME)
+          sql = "SELECT MAX(created_at) FROM #{quoted_table}"
           last_at = conn.select_value(sql)
           result[:last_event_at] = last_at ? parse_time(last_at) : nil
         rescue StandardError => e

data/lib/solid_queue_autoscaler/scaler.rb

@@ -25,9 +25,13 @@ module SolidQueueAutoscaler
     end
 
     # Per-configuration cooldown tracking for multi-worker support
+    # Thread-safe mutex for cooldown tracking - defined as constant to avoid
+    # race condition where lazy initialization could create multiple mutexes
+    COOLDOWN_MUTEX = Mutex.new
+
     class << self
       def cooldown_mutex
-        @cooldown_mutex ||= Mutex.new
+        COOLDOWN_MUTEX
       end
 
       def cooldowns
@@ -158,12 +162,17 @@ module SolidQueueAutoscaler
       target = decision.to.clamp(@config.min_workers, @config.max_workers)
       
       if target != decision.to
-        logger.warn(
+        logger&.warn(
           "[Autoscaler] Clamping target from #{decision.to} to #{target} " \
           "(limits: #{@config.min_workers}-#{@config.max_workers})"
         )
-        # Ensure decision reflects the clamped target for logging and events
-        decision.to = target
+        # Create a new decision with the clamped target instead of mutating
+        decision = DecisionEngine::Decision.new(
+          action: decision.action,
+          from: decision.from,
+          to: target,
+          reason: decision.reason
+        )
       end
       
       @adapter.scale(target)
@@ -250,7 +259,7 @@ module SolidQueueAutoscaler
 
     def log_decision(decision, metrics)
       worker_label = @config.name == :default ? '' : "[#{@config.name}] "
-      logger.info(
+      logger&.info(
         "[Autoscaler] #{worker_label}Evaluated: action=#{decision.action} " \
         "workers=#{decision.from}->#{decision.to} " \
         "queue_depth=#{metrics.queue_depth} " \
@@ -262,7 +271,7 @@ module SolidQueueAutoscaler
     def log_scale_action(decision)
       prefix = @config.dry_run? ? '[DRY RUN] ' : ''
       worker_label = @config.name == :default ? '' : "[#{@config.name}] "
-      logger.info(
+      logger&.info(
         "#{prefix}[Autoscaler] #{worker_label}Scaling #{decision.action}: " \
         "#{decision.from} -> #{decision.to} workers (#{decision.reason})"
       )
@@ -281,7 +290,7 @@ module SolidQueueAutoscaler
     end
 
     def skipped_result(reason, decision: nil, metrics: nil)
-      logger.debug("[Autoscaler] Skipped: #{reason}")
+      logger&.debug("[Autoscaler] Skipped: #{reason}")
 
       # Record skipped events
       record_skipped_event(reason, decision, metrics)
@@ -296,7 +305,7 @@ module SolidQueueAutoscaler
     end
 
     def error_result(error)
-      logger.error("[Autoscaler] Error: #{error.class}: #{error.message}")
+      logger&.error("[Autoscaler] Error: #{error.class}: #{error.message}")
 
       # Record error events
       record_error_event(error)
@@ -315,7 +324,7 @@ module SolidQueueAutoscaler
     def record_scale_event(decision, metrics)
       return unless @config.record_events?
 
-      ScaleEvent.create!(
+      ScaleEvent.create(
         {
           worker_name: @config.name.to_s,
           action: decision.action.to_s,
@@ -334,7 +343,7 @@ module SolidQueueAutoscaler
     def record_skipped_event(reason, decision, metrics)
       return unless @config.record_events?
 
-      ScaleEvent.create!(
+      ScaleEvent.create(
         {
           worker_name: @config.name.to_s,
           action: 'skipped',
@@ -353,7 +362,7 @@ module SolidQueueAutoscaler
     def record_error_event(error)
       return unless @config.record_events?
 
-      ScaleEvent.create!(
+      ScaleEvent.create(
         {
           worker_name: @config.name.to_s,
           action: 'error',

data/lib/solid_queue_autoscaler/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid_queue_autoscaler
 version: !ruby/object:Gem::Version
-  version: 1.0.10
+  version: 1.0.11
 platform: ruby
 authors:
 - reillyse