solid_queue 0.3.0 → 0.3.2

data/lib/solid_queue/log_subscriber.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "active_support/log_subscriber"
+
+class SolidQueue::LogSubscriber < ActiveSupport::LogSubscriber
+  def dispatch_scheduled(event)
+    debug formatted_event(event, action: "Dispatch scheduled jobs", **event.payload.slice(:batch_size, :size))
+  end
+
+  def release_many_claimed(event)
+    debug formatted_event(event, action: "Release claimed jobs", **event.payload.slice(:size))
+  end
+
+  def release_claimed(event)
+    debug formatted_event(event, action: "Release claimed job", **event.payload.slice(:job_id, :process_id))
+  end
+
+  def retry_all(event)
+    debug formatted_event(event, action: "Retry failed jobs", **event.payload.slice(:jobs_size, :size))
+  end
+
+  def retry(event)
+    debug formatted_event(event, action: "Retry failed job", **event.payload.slice(:job_id))
+  end
+
+  def discard_all(event)
+    debug formatted_event(event, action: "Discard jobs", **event.payload.slice(:jobs_size, :size, :status))
+  end
+
+  def discard(event)
+    debug formatted_event(event, action: "Discard job", **event.payload.slice(:job_id, :status))
+  end
+
+  def release_many_blocked(event)
+    debug formatted_event(event, action: "Unblock jobs", **event.payload.slice(:limit, :size))
+  end
+
+  def release_blocked(event)
+    debug formatted_event(event, action: "Release blocked job", **event.payload.slice(:job_id, :concurrency_key, :released))
+  end
+
+  def enqueue_recurring_task(event)
+    attributes = event.payload.slice(:task, :at, :active_job_id)
+
+    if event.payload[:other_adapter]
+      debug formatted_event(event, action: "Enqueued recurring task outside Solid Queue", **attributes)
+    else
+      action = attributes[:active_job_id].present? ? "Enqueued recurring task" : "Skipped recurring task – already dispatched"
+      info formatted_event(event, action: action, **attributes)
+    end
+  end
+
+  def start_process(event)
+    process = event.payload[:process]
+
+    attributes = {
+      pid: process.pid,
+      hostname: process.hostname
+    }.merge(process.metadata)
+
+    info formatted_event(event, action: "Started #{process.kind}", **attributes)
+  end
+
+  def shutdown_process(event)
+    process = event.payload[:process]
+
+    attributes = {
+      pid: process.pid,
+      hostname: process.hostname
+    }.merge(process.metadata)
+
+    info formatted_event(event, action: "Shut down #{process.kind}", **attributes)
+  end
+
+  def register_process(event)
+    process_kind = event.payload[:kind]
+    attributes = event.payload.slice(:pid, :hostname)
+
+    if error = event.payload[:error]
+      warn formatted_event(event, action: "Error registering #{process_kind}", **attributes.merge(error: formatted_error(error)))
+    else
+      info formatted_event(event, action: "Register #{process_kind}", **attributes)
+    end
+  end
+
+  def deregister_process(event)
+    process = event.payload[:process]
+
+    attributes = {
+      process_id: process.id,
+      pid: process.pid,
+      hostname: process.hostname,
+      last_heartbeat_at: process.last_heartbeat_at,
+      claimed_size: process.claimed_executions.size,
+      pruned: event.payload
+    }
+
+    if error = event.payload[:error]
+      warn formatted_event(event, action: "Error deregistering #{process.kind}", **attributes.merge(error: formatted_error(error)))
+    else
+      info formatted_event(event, action: "Deregister #{process.kind}", **attributes)
+    end
+  end
+
+  def prune_processes(event)
+    debug formatted_event(event, action: "Prune dead processes", **event.payload.slice(:size))
+  end
+
+  def thread_error(event)
+    error formatted_event(event, action: "Error in thread", error: formatted_error(event.payload[:error]))
+  end
+
+  def graceful_termination(event)
+    attributes = event.payload.slice(:supervisor_pid, :supervised_pids)
+
+    if event.payload[:shutdown_timeout_exceeded]
+      warn formatted_event(event, action: "Supervisor wasn't terminated gracefully - shutdown timeout exceeded", **attributes)
+    else
+      info formatted_event(event, action: "Supervisor terminated gracefully", **attributes)
+    end
+  end
+
+  def immediate_termination(event)
+    info formatted_event(event, action: "Supervisor terminated immediately", **event.payload.slice(:supervisor_pid, :supervised_pids))
+  end
+
+  def unhandled_signal_error(event)
+    error formatted_event(event, action: "Received unhandled signal", **event.payload.slice(:signal))
+  end
+
+  def replace_fork(event)
+    status = event.payload[:status]
+    attributes = event.payload.slice(:pid).merge \
+      status: (status.exitstatus || "no exit status set"),
+      pid_from_status: status.pid,
+      signaled: status.signaled?,
+      stopsig: status.stopsig,
+      termsig: status.termsig
+
+    if replaced_fork = event.payload[:fork]
+      info formatted_event(event, action: "Replaced terminated #{replaced_fork.kind}", **attributes.merge(hostname: replaced_fork.hostname))
+    else
+      warn formatted_event(event, action: "Tried to replace forked process but it had already died", **attributes)
+    end
+  end
+
+  private
+    def formatted_event(event, action:, **attributes)
+      "SolidQueue-#{SolidQueue::VERSION} #{action} (#{event.duration.round(1)}ms)  #{formatted_attributes(**attributes)}"
+    end
+
+    def formatted_attributes(**attributes)
+      attributes.map { |attr, value| "#{attr}: #{value.inspect}" }.join(", ")
+    end
+
+    def formatted_error(error)
+      [ error.class, error.message ].compact.join(" ")
+    end
+
+    # Use the logger configured for SolidQueue
+    def logger
+      SolidQueue.logger
+    end
+end

data/lib/solid_queue/processes/base.rb

@@ -5,6 +5,22 @@ module SolidQueue
     class Base
       include Callbacks # Defines callbacks needed by other concerns
       include AppExecutor, Registrable, Interruptible, Procline
+
+      def kind
+        self.class.name.demodulize
+      end
+
+      def hostname
+        @hostname ||= Socket.gethostname.force_encoding(Encoding::UTF_8)
+      end
+
+      def pid
+        @pid ||= ::Process.pid
+      end
+
+      def metadata
+        {}
+      end
     end
   end
 end

data/lib/solid_queue/processes/interruptible.rb

@@ -10,7 +10,7 @@ module SolidQueue::Processes
       SELF_PIPE_BLOCK_SIZE = 11
 
       def interrupt
-        self_pipe[:writer].write_nonblock( "." )
+        self_pipe[:writer].write_nonblock(".")
       rescue Errno::EAGAIN, Errno::EINTR
         # Ignore writes that would block and retry
         # if another signal arrived while writing

data/lib/solid_queue/processes/poller.rb

@@ -10,6 +10,10 @@ module SolidQueue::Processes
       attr_accessor :polling_interval
     end
 
+    def metadata
+      super.merge(polling_interval: polling_interval)
+    end
+
     private
       def run
         if mode.async?
@@ -30,7 +34,9 @@ module SolidQueue::Processes
           end
         end
       ensure
-        run_callbacks(:shutdown) { shutdown }
+        SolidQueue.instrument(:shutdown_process, process: self) do
+          run_callbacks(:shutdown) { shutdown }
+        end
       end
 
       def poll
@@ -44,9 +50,5 @@ module SolidQueue::Processes
           yield
         end
       end
-
-      def metadata
-        super.merge(polling_interval: polling_interval)
-      end
   end
 end

data/lib/solid_queue/processes/registrable.rb

@@ -11,18 +11,13 @@ module SolidQueue::Processes
       after_shutdown :deregister
     end
 
-    def inspect
-      "#{kind}(pid=#{process_pid}, hostname=#{hostname}, metadata=#{metadata})"
-    end
-    alias to_s inspect
-
     private
       attr_accessor :process
 
       def register
         @process = SolidQueue::Process.register \
           kind: self.class.name.demodulize,
-          pid: process_pid,
+          pid: pid,
           hostname: hostname,
           supervisor: try(:supervisor),
           metadata: metadata.compact
@@ -37,7 +32,10 @@ module SolidQueue::Processes
       end
 
       def launch_heartbeat
-        @heartbeat_task = Concurrent::TimerTask.new(execution_interval: SolidQueue.process_heartbeat_interval) { heartbeat }
+        @heartbeat_task = Concurrent::TimerTask.new(execution_interval: SolidQueue.process_heartbeat_interval) do
+          wrap_in_app_executor { heartbeat }
+        end
+
         @heartbeat_task.execute
       end
 
@@ -48,21 +46,5 @@ module SolidQueue::Processes
       def heartbeat
         process.heartbeat
       end
-
-      def kind
-        self.class.name.demodulize
-      end
-
-      def hostname
-        @hostname ||= Socket.gethostname.force_encoding(Encoding::UTF_8)
-      end
-
-      def process_pid
-        @pid ||= ::Process.pid
-      end
-
-      def metadata
-        {}
-      end
   end
 end

data/lib/solid_queue/processes/runnable.rb

@@ -8,7 +8,10 @@ module SolidQueue::Processes
 
     def start
       @stopping = false
-      run_callbacks(:boot) { boot }
+
+      SolidQueue.instrument(:start_process, process: self) do
+        run_callbacks(:boot) { boot }
+      end
 
       run
     end
@@ -30,8 +33,6 @@ module SolidQueue::Processes
           register_signal_handlers
           set_procline
         end
-
-        SolidQueue.logger.info("[SolidQueue] Starting #{self}")
       end
 
       def shutting_down?

data/lib/solid_queue/processes/signals.rb

@@ -38,7 +38,7 @@ module SolidQueue::Processes
         when :QUIT
           request_immediate_termination
         else
-          SolidQueue.logger.warn "Received unhandled signal #{signal}"
+          SolidQueue.instrument :unhandled_signal_error, signal: signal
         end
       end
 

data/lib/solid_queue/supervisor.rb

@@ -4,8 +4,6 @@ module SolidQueue
   class Supervisor < Processes::Base
     include Processes::Signals
 
-    after_boot :launch_process_prune
-
     class << self
       def start(mode: :work, load_configuration_from: nil)
         SolidQueue.supervisor = true
@@ -23,6 +21,8 @@ module SolidQueue
     def start
       run_callbacks(:boot) { boot }
 
+      start_forks
+      launch_process_prune
       supervise
     rescue Processes::GracefulTerminationRequested
       graceful_termination
@@ -42,8 +42,6 @@ module SolidQueue
       end
 
       def supervise
-        start_forks
-
         loop do
           procline "supervising #{forks.keys.join(", ")}"
 
@@ -63,15 +61,15 @@ module SolidQueue
         end
       end
 
+      def start_forks
+        configured_processes.each { |configured_process| start_fork(configured_process) }
+      end
+
       def launch_process_prune
         @prune_task = Concurrent::TimerTask.new(run_now: true, execution_interval: SolidQueue.process_alive_threshold) { prune_dead_processes }
         @prune_task.execute
       end
 
-      def start_forks
-        configured_processes.each { |configured_process| start_fork(configured_process) }
-      end
-
       def shutdown
         stop_process_prune
         restore_default_signal_handlers
@@ -79,19 +77,24 @@ module SolidQueue
       end
 
       def graceful_termination
-        SolidQueue.logger.info("[SolidQueue] Terminating gracefully...")
-        term_forks
+        SolidQueue.instrument(:graceful_termination, supervisor_pid: ::Process.pid, supervised_pids: forks.keys) do |payload|
+          term_forks
 
-        wait_until(SolidQueue.shutdown_timeout, -> { all_forks_terminated? }) do
-          reap_terminated_forks
-        end
+          wait_until(SolidQueue.shutdown_timeout, -> { all_forks_terminated? }) do
+            reap_terminated_forks
+          end
 
-        immediate_termination unless all_forks_terminated?
+          unless all_forks_terminated?
+            payload[:shutdown_timeout_exceeded] = true
+            immediate_termination
+          end
+        end
       end
 
       def immediate_termination
-        SolidQueue.logger.info("[SolidQueue] Terminating immediately...")
-        quit_forks
+        SolidQueue.instrument(:immediate_termination, supervisor_pid: ::Process.pid, supervised_pids: forks.keys) do
+          quit_forks
+        end
       end
 
       def term_forks
@@ -111,9 +114,7 @@ module SolidQueue
       end
 
       def prune_dead_processes
-        wrap_in_app_executor do
-          SolidQueue::Process.prune
-        end
+        wrap_in_app_executor { SolidQueue::Process.prune }
       end
 
       def start_fork(configured_process)
@@ -147,11 +148,11 @@ module SolidQueue
       end
 
       def replace_fork(pid, status)
-        if supervised_fork = forks.delete(pid)
-          SolidQueue.logger.info "[SolidQueue] Restarting fork[#{status.pid}] (status: #{status.exitstatus})"
-          start_fork(supervised_fork)
-        else
-          SolidQueue.logger.info "[SolidQueue] Tried to replace fork[#{pid}] (status: #{status.exitstatus}, fork[#{status.pid}]), but it had already died  (status: #{status.exitstatus})"
+        SolidQueue.instrument(:replace_fork, supervisor_pid: ::Process.pid, pid: pid, status: status) do |payload|
+          if supervised_fork = forks.delete(pid)
+            payload[:fork] = supervised_fork
+            start_fork(supervised_fork)
+          end
         end
       end
 

data/lib/solid_queue/version.rb

@@ -1,3 +1,3 @@
 module SolidQueue
-  VERSION = "0.3.0"
+  VERSION = "0.3.2"
 end

data/lib/solid_queue/worker.rb

@@ -14,6 +14,10 @@ module SolidQueue
       @pool = Pool.new(options[:threads], on_idle: -> { wake_up })
     end
 
+    def metadata
+      super.merge(queues: queues.join(","), thread_pool_size: pool.size)
+    end
+
     private
       def poll
         claim_executions.then do |executions|
@@ -32,10 +36,10 @@ module SolidQueue
       end
 
       def shutdown
-        super
-
         pool.shutdown
         pool.wait_for_termination(SolidQueue.shutdown_timeout)
+
+        super
       end
 
       def all_work_completed?
@@ -45,9 +49,5 @@ module SolidQueue
       def set_procline
         procline "waiting for jobs in #{queues.join(",")}"
       end
-
-      def metadata
-        super.merge(queues: queues.join(","), thread_pool_size: pool.size)
-      end
   end
 end

data/lib/solid_queue.rb

@@ -6,6 +6,9 @@ require "solid_queue/engine"
 require "active_job"
 require "active_job/queue_adapters"
 
+require "active_support"
+require "active_support/core_ext/numeric/time"
+
 require "zeitwerk"
 
 loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
@@ -15,7 +18,11 @@ loader.ignore("#{__dir__}/puma")
 loader.setup
 
 module SolidQueue
-  mattr_accessor :logger, default: ActiveSupport::Logger.new($stdout)
+  extend self
+
+  DEFAULT_LOGGER = ActiveSupport::Logger.new($stdout)
+
+  mattr_accessor :logger, default: DEFAULT_LOGGER
   mattr_accessor :app_executor, :on_thread_error, :connects_to
 
   mattr_accessor :use_skip_locked, default: true
@@ -25,6 +32,8 @@ module SolidQueue
 
   mattr_accessor :shutdown_timeout, default: 5.seconds
 
+  mattr_accessor :enqueue_after_transaction_commit, default: false
+
   mattr_accessor :silence_polling, default: true
 
   mattr_accessor :supervisor_pidfile
@@ -34,17 +43,21 @@ module SolidQueue
   mattr_accessor :clear_finished_jobs_after, default: 1.day
   mattr_accessor :default_concurrency_control_period, default: 3.minutes
 
-  class << self
-    def supervisor?
-      supervisor
-    end
+  def supervisor?
+    supervisor
+  end
 
-    def silence_polling?
-      silence_polling
-    end
+  def silence_polling?
+    silence_polling
+  end
+
+  def preserve_finished_jobs?
+    preserve_finished_jobs
+  end
 
-    def preserve_finished_jobs?
-      preserve_finished_jobs
-    end
+  def instrument(channel, **options, &block)
+    ActiveSupport::Notifications.instrument("#{channel}.solid_queue", **options, &block)
   end
+
+  ActiveSupport.run_load_hooks(:solid_queue, self)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solid_queue
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Rosa Gutierrez
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-20 00:00:00.000000000 Z
+date: 2024-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -56,30 +56,30 @@ dependencies:
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.2
+        version: 1.3.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.2
+        version: 1.3.1
 - !ruby/object:Gem::Dependency
   name: fugit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.9.0
+        version: 1.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.9.0
+        version: 1.11.0
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
@@ -164,6 +164,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails-omakase
+  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: Database-backed Active Job backend.
 email:
 - rosa@37signals.com
@@ -214,6 +228,7 @@ files:
 - lib/solid_queue/dispatcher/recurring_schedule.rb
 - lib/solid_queue/dispatcher/recurring_task.rb
 - lib/solid_queue/engine.rb
+- lib/solid_queue/log_subscriber.rb
 - lib/solid_queue/pool.rb
 - lib/solid_queue/processes/base.rb
 - lib/solid_queue/processes/callbacks.rb
@@ -225,19 +240,16 @@ files:
 - lib/solid_queue/processes/runnable.rb
 - lib/solid_queue/processes/signals.rb
 - lib/solid_queue/processes/supervised.rb
-- lib/solid_queue/recurring_tasks/manager.rb
-- lib/solid_queue/recurring_tasks/schedule.rb
-- lib/solid_queue/recurring_tasks/task.rb
 - lib/solid_queue/supervisor.rb
 - lib/solid_queue/tasks.rb
 - lib/solid_queue/version.rb
 - lib/solid_queue/worker.rb
-homepage: https://github.com/basecamp/solid_queue
+homepage: https://github.com/rails/solid_queue
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/basecamp/solid_queue
-  source_code_uri: https://github.com/basecamp/solid_queue
+  homepage_uri: https://github.com/rails/solid_queue
+  source_code_uri: https://github.com/rails/solid_queue
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -253,7 +265,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Database-backed Active Job backend.

data/lib/solid_queue/recurring_tasks/manager.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module SolidQueue
-  module RecurringTasks
-    class Manager < Processes::Base
-      include Processes::Runnable
-
-      attr_accessor :schedule
-
-      after_boot :load_schedule
-      before_shutdown :unload_schedule
-
-      def initialize(tasks)
-        @schedule = Schedule.new(tasks)
-      end
-
-      private
-        def load_schedule
-          schedule.load_tasks
-        end
-
-        def unload_schedule
-          schedule.unload_tasks
-        end
-
-        def metadata
-          super.merge(schedule: schedule.tasks)
-        end
-    end
-  end
-end