gouda 0.1.16 → 0.2.0

data/lib/gouda/worker.rb

@@ -2,6 +2,7 @@
 
 require "securerandom"
 require "gouda/version"
+require "async"
 
 module Gouda
   POLL_INTERVAL_DURATION_SECONDS = 1
@@ -109,83 +110,173 @@ module Gouda
     end
   end
 
-  # Start looping, taking work from the queue and performing it, over multiple worker threads.
-  # Once the `check_shutdown` callable returns `true` the threads will cleanly terminate and the method will return (so it is blocking).
-  #
-  # @param n_threads[Integer] how many _worker_ threads to start. Another thread will be started for housekeeping, so ideally this should be the size of your connection pool minus 1
-  # @param check_shutdown[#call] A callable object (can be a Proc etc.). Once starts returning `true` the worker threads and the housekeeping thread will cleanly exit
-  def self.worker_loop(n_threads:, check_shutdown: TrapShutdownCheck.new, queue_constraint: Gouda::AnyQueue)
-    # We need quite a few things when starting the loop - we have to be far enough into the Rails bootup sequence
-    # that both the application and the executor are available
+  # Worker class that supports both threaded and hybrid (threads + fibers) execution modes
+  class Worker
+    # Start looping, taking work from the queue and performing it, over multiple worker threads.
+    # Once the `check_shutdown` callable returns `true` the threads will cleanly terminate and the method will return (so it is blocking).
     #
-    # raise "Rails is not loaded yet" unless defined?(Rails) && Rails.respond_to?(:application)
-    # raise "Rails application is not loaded yet" unless Rails.application
-    # raise "Rails executor not available yet" unless Rails.application.executor
+    # @param n_threads[Integer] how many _worker_ threads to start. Another thread will be started for housekeeping, so ideally this should be the size of your connection pool minus 1
+    # @param check_shutdown[#call] A callable object (can be a Proc etc.). Once starts returning `true` the worker threads and the housekeeping thread will cleanly exit
+    # @param use_fibers[Boolean] whether to use fibers within each thread for higher concurrency
+    # @param fibers_per_thread[Integer] how many fibers to run per thread (only used if use_fibers is true)
+    def self.worker_loop(n_threads:, check_shutdown: TrapShutdownCheck.new, queue_constraint: Gouda::AnyQueue, use_fibers: false, fibers_per_thread: 1)
+      check_shutdown = CombinedShutdownCheck.new(*check_shutdown) if !check_shutdown.respond_to?(:call) && check_shutdown.is_a?(Array)
 
-    check_shutdown = CombinedShutdownCheck.new(*check_shutdown) if !check_shutdown.respond_to?(:call) && check_shutdown.is_a?(Array)
+      log_worker_configuration(n_threads, use_fibers, fibers_per_thread)
+      setup_fiber_environment if use_fibers
 
-    worker_id = [Socket.gethostname, Process.pid, SecureRandom.uuid].join("-")
+      worker_id = generate_worker_id
+      executing_workload_ids = ThreadSafeSet.new
 
-    executing_workload_ids = ThreadSafeSet.new
+      raise ArgumentError, "You need at least 1 worker thread, but you requested #{n_threads}" if n_threads < 1
 
-    raise ArgumentError, "You need at least 1 worker thread, but you requested #{n_threads}" if n_threads < 1
-    worker_threads = n_threads.times.map do
-      Thread.new do
-        worker_id_and_thread_id = [worker_id, "t0x#{Thread.current.object_id.to_s(16)}"].join("-")
-        loop do
-          break if check_shutdown.call
+      worker_threads = if use_fibers
+        create_hybrid_worker_threads(n_threads, fibers_per_thread, worker_id, queue_constraint, executing_workload_ids, check_shutdown)
+      else
+        create_threaded_worker_threads(n_threads, worker_id, queue_constraint, executing_workload_ids, check_shutdown)
+      end
+
+      run_housekeeping_loop(executing_workload_ids, check_shutdown)
+    ensure
+      worker_threads&.map(&:join)
+    end
 
-          did_process = Gouda.config.app_executor.wrap do
-            Gouda::Workload.checkout_and_perform_one(executing_on: worker_id_and_thread_id, queue_constraint: queue_constraint, in_progress: executing_workload_ids)
+    class << self
+      private
+
+      def log_worker_configuration(n_threads, use_fibers, fibers_per_thread)
+        if use_fibers
+          Gouda.logger.info("Using hybrid scheduler (threads + fibers)")
+          Gouda.logger.info("Worker threads: #{n_threads}")
+          Gouda.logger.info("Fibers per thread: #{fibers_per_thread}")
+          Gouda.logger.info("Total concurrency: #{n_threads * fibers_per_thread}")
+        else
+          Gouda.logger.info("Using thread-based scheduler")
+          Gouda.logger.info("Worker threads: #{n_threads}")
+        end
+      end
+
+      def setup_fiber_environment
+        # Check Rails isolation level configuration
+        Gouda::FiberDatabaseSupport.check_fiber_isolation_level
+      end
+
+      def generate_worker_id
+        [Socket.gethostname, Process.pid, SecureRandom.uuid].join("-")
+      end
+
+      def create_hybrid_worker_threads(n_threads, fibers_per_thread, worker_id, queue_constraint, executing_workload_ids, check_shutdown)
+        n_threads.times.map do |thread_index|
+          Thread.new do
+            # Each thread runs its own fiber scheduler
+            Async do |task|
+              # Create multiple fibers within this thread
+              fiber_tasks = fibers_per_thread.times.map do |fiber_index|
+                task.async do |worker_task|
+                  worker_id_and_fiber_id = generate_execution_id(worker_id, thread: true, fiber: true)
+
+                  run_worker_loop(worker_id_and_fiber_id, queue_constraint, executing_workload_ids, check_shutdown, worker_task)
+                end
+              end
+
+              # Wait for all fibers in this thread to complete
+              fiber_tasks.each(&:wait)
+            end
           end
+        end
+      end
 
-          # If no job was retrieved the queue is likely empty. Relax the polling then and ease off.
-          # If a job was retrieved it is likely that a burst has just been enqueued, and we do not
-          # sleep but proceed to attempt to retrieve the next job right after.
-          jitter_sleep_interval = POLL_INTERVAL_DURATION_SECONDS + (POLL_INTERVAL_DURATION_SECONDS * 0.25)
-          sleep_with_interruptions(jitter_sleep_interval, check_shutdown) unless did_process
-        rescue => e
-          warn "Uncaught exception during perform (#{e.class} - #{e}"
+      def create_threaded_worker_threads(n_threads, worker_id, queue_constraint, executing_workload_ids, check_shutdown)
+        n_threads.times.map do
+          Thread.new do
+            worker_id_and_thread_id = generate_execution_id(worker_id, thread: true, fiber: false)
+            run_worker_loop(worker_id_and_thread_id, queue_constraint, executing_workload_ids, check_shutdown)
+          end
         end
       end
-    end
 
-    # Do the housekeeping tasks on main
-    loop do
-      break if check_shutdown.call
+      def generate_execution_id(worker_id, thread: false, fiber: false)
+        parts = [worker_id]
+        parts << "thread-#{Thread.current.object_id.to_s(16)}" if thread
+        parts << "fiber-#{Fiber.current.object_id.to_s(16)}" if fiber
+        parts.join("-")
+      end
 
-      Gouda.config.app_executor.wrap do
-        # Mark known executing jobs as such. If a worker process is killed or the machine it is running on dies,
-        # a stale timestamp can indicate to us that the job was orphaned and is marked as "executing"
-        # even though the worker it was running on has failed for whatever reason.
-        # Later on we can figure out what to do with those jobs (re-enqueue them or toss them)
-        Gouda.suppressing_sql_logs do # these updates will also be very frequent with long-running jobs
-          Gouda::Workload.where(id: executing_workload_ids.to_a, state: "executing").update_all(executing_on: worker_id, last_execution_heartbeat_at: Time.now.utc)
+      def run_worker_loop(execution_id, queue_constraint, executing_workload_ids, check_shutdown, fiber_task = nil)
+        loop do
+          break if check_shutdown.call
+
+          begin
+            did_process = Gouda.config.app_executor.wrap do
+              Gouda::Workload.checkout_and_perform_one(
+                executing_on: execution_id,
+                queue_constraint: queue_constraint,
+                in_progress: executing_workload_ids
+              )
+            end
+
+            # If no job was retrieved, sleep with appropriate scheduler
+            unless did_process
+              jitter_sleep_interval = POLL_INTERVAL_DURATION_SECONDS + (POLL_INTERVAL_DURATION_SECONDS * 0.25)
+              sleep_with_interruptions(jitter_sleep_interval, check_shutdown, fiber_task)
+            end
+          rescue => e
+            Gouda.logger.warn "Uncaught exception during perform (#{e.class} - #{e})"
+          end
         end
+      end
+
+      def run_housekeeping_loop(executing_workload_ids, check_shutdown)
+        loop do
+          break if check_shutdown.call
 
-        # Find jobs which just hung and clean them up (mark them as "finished" and enqueue replacement workloads if possible)
-        Gouda::Workload.reap_zombie_workloads
-      rescue => e
-        Gouda.instrument(:exception, {exception: e})
-        warn "Uncaught exception during housekeeping (#{e.class} - #{e}"
+          begin
+            Gouda.config.app_executor.wrap do
+              # Mark known executing jobs as such. If a worker process is killed or the machine it is running on dies,
+              # a stale timestamp can indicate to us that the job was orphaned and is marked as "executing"
+              # even though the worker it was running on has failed for whatever reason.
+              # Later on we can figure out what to do with those jobs (re-enqueue them or toss them)
+              Gouda.suppressing_sql_logs do # these updates will also be very frequent with long-running jobs
+                Gouda::Workload.where(id: executing_workload_ids.to_a, state: "executing").update_all(last_execution_heartbeat_at: Time.now.utc)
+              end
+
+              # Find jobs which just hung and clean them up (mark them as "finished" and enqueue replacement workloads if possible)
+              Gouda::Workload.reap_zombie_workloads
+            end
+          rescue => e
+            Gouda.instrument(:exception, {exception: e})
+            Gouda.logger.warn "Uncaught exception during housekeeping (#{e.class} - #{e})"
+          end
+
+          # Jitter the sleep so that the workers booted at the same time do not all dogpile
+          randomized_sleep_duration_s = POLL_INTERVAL_DURATION_SECONDS + (POLL_INTERVAL_DURATION_SECONDS.to_f * rand)
+          sleep_with_interruptions(randomized_sleep_duration_s, check_shutdown)
+        end
       end
 
-      # Jitter the sleep so that the workers booted at the same time do not all dogpile
-      randomized_sleep_duration_s = POLL_INTERVAL_DURATION_SECONDS + (POLL_INTERVAL_DURATION_SECONDS.to_f * rand)
-      sleep_with_interruptions(randomized_sleep_duration_s, check_shutdown)
+      # Unified sleep method that works with both threads and fibers
+      def sleep_with_interruptions(n_seconds, must_abort_proc, fiber_task = nil)
+        start_time_seconds = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        check_interval_seconds = Gouda.config.polling_sleep_interval_seconds
+
+        loop do
+          return if must_abort_proc.call
+          return if Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time_seconds >= n_seconds
+
+          sleep(check_interval_seconds)
+        end
+      end
     end
-  ensure
-    worker_threads&.map(&:join)
   end
 
-  def self.sleep_with_interruptions(n_seconds, must_abort_proc)
-    start_time_seconds = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    # remaining_seconds = n_seconds
-    check_interval_seconds = Gouda.config.polling_sleep_interval_seconds
-    loop do
-      return if must_abort_proc.call
-      return if Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time_seconds >= n_seconds
-      sleep(check_interval_seconds)
-    end
+  # Module-level convenience method that delegates to Worker.worker_loop
+  def self.worker_loop(n_threads:, check_shutdown: TrapShutdownCheck.new, queue_constraint: Gouda::AnyQueue, use_fibers: false, fibers_per_thread: 1)
+    Worker.worker_loop(
+      n_threads: n_threads,
+      check_shutdown: check_shutdown,
+      queue_constraint: queue_constraint,
+      use_fibers: use_fibers,
+      fibers_per_thread: fibers_per_thread
+    )
   end
 end

data/lib/gouda/workload.rb

@@ -239,4 +239,21 @@ class Gouda::Workload < ActiveRecord::Base
   def active_job_data
     serialized_params.deep_dup.merge("provider_job_id" => id, "interrupted_at" => interrupted_at, "scheduler_key" => scheduler_key) # TODO: is this memory-economical?
   end
+
+  # Returns true if this workload was executed using async execution (hybrid mode with fibers)
+  def uses_async_execution?
+    executing_on&.include?("fiber-")
+  end
+
+  # Returns true if this workload was executed on a thread
+  def executed_on_thread?
+    executing_on&.include?("thread-")
+  end
+
+  # Returns the execution context type (:fiber, :thread, or :unknown)
+  def execution_context
+    return :fiber if uses_async_execution?
+    return :thread if executed_on_thread?
+    :unknown
+  end
 end

data/lib/gouda.rb

@@ -32,6 +32,10 @@ module Gouda
     # that is using Gouda. The config values will be ignored though.
     config_accessor(:logger, default: nil)
     config_accessor(:log_level, default: nil)
+
+    # Fiber-specific configuration options
+    config_accessor(:fibers_per_thread, default: 1)  # Number of fibers per worker thread
+    config_accessor(:use_fiber_scheduler, default: false)
   end
 
   class InterruptError < StandardError
@@ -41,6 +45,11 @@ module Gouda
   end
 
   def self.start
+    start_with_scheduler_type
+  end
+
+  # Enhanced start method that chooses between thread and thread+fiber execution
+  def self.start_with_scheduler_type
     queue_constraint = if ENV["GOUDA_QUEUES"]
       Gouda.parse_queue_constraint(ENV["GOUDA_QUEUES"])
     else
@@ -48,9 +57,18 @@ module Gouda
     end
 
     logger.info("Gouda version: #{Gouda::VERSION}")
-    logger.info("Worker threads: #{Gouda.config.worker_thread_count}")
 
-    worker_loop(n_threads: Gouda.config.worker_thread_count, queue_constraint: queue_constraint)
+    # Determine execution parameters based on configuration
+    use_fibers = Gouda.config.use_fiber_scheduler
+    fibers_per_thread = use_fibers ? Gouda.config.fibers_per_thread : 1
+
+    # Single worker loop call that handles both execution modes
+    Worker.worker_loop(
+      n_threads: Gouda.config.worker_thread_count,
+      queue_constraint: queue_constraint,
+      use_fibers: use_fibers,
+      fibers_per_thread: fibers_per_thread
+    )
   end
 
   def self.config
@@ -72,7 +90,7 @@ module Gouda
     # is just an ActiveJob adapter and the Workload is just an ActiveRecord, in the end.
     # So it should be up to the developer of the app, not to us, to set the logger up
     # and configure out. There are also gems such as "stackdriver" from Google which
-    # rather unceremonously overwrite the Rails logger with their own. If that happens,
+    # rather unceremoniously overwrite the Rails logger with their own. If that happens,
     # it is the choice of the user to do so - and we should honor that choice. Same for
     # the logging level - the Rails logger level must take precendence. Same for logger
     # broadcasts which get set up, for example, by the Rails console when you start it.
@@ -139,4 +157,57 @@ module Gouda
       t.timestamps
     end
   end
+
+  def self.setup_fiber_environment
+    # Check Rails isolation level configuration (non-destructive)
+    Gouda::FiberDatabaseSupport.check_fiber_isolation_level
+  end
+
+  # Database configuration helpers for fiber mode
+  module FiberDatabaseSupport
+    def self.check_fiber_isolation_level
+      return unless defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+
+      begin
+        current_isolation = ActiveSupport.isolation_level
+
+        # Check if we're using PostgreSQL
+        using_postgresql = false
+        begin
+          if defined?(ActiveRecord::Base) && ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+            using_postgresql = true
+          end
+        rescue
+          # If we can't determine the adapter, assume we might be using PostgreSQL to be safe
+          using_postgresql = true
+        end
+
+        if current_isolation != :fiber && using_postgresql
+          logger.warn("=" * 80)
+          logger.warn("FIBER SCHEDULER CONFIGURATION WARNING")
+          logger.warn("=" * 80)
+          logger.warn("Gouda fiber mode is enabled with PostgreSQL but Rails isolation level is set to: #{current_isolation}")
+          logger.warn("For optimal fiber-based performance and to avoid potential issues with PostgreSQL,")
+          logger.warn("you should set the Rails isolation level to :fiber")
+          logger.warn("")
+          logger.warn("Add this to your config/application.rb:")
+          logger.warn("  config.active_support.isolation_level = :fiber")
+          logger.warn("")
+          logger.warn("This ensures ActiveRecord connection pools work correctly with fibers")
+          logger.warn("and PostgreSQL connections, and can prevent segfaults with Ruby 3.4+.")
+          logger.warn("=" * 80)
+        elsif current_isolation == :fiber
+          logger.info("Rails isolation level correctly set to :fiber for fiber-based execution")
+        elsif !using_postgresql
+          logger.info("Non-PostgreSQL database detected - isolation level configuration may not be required")
+        end
+      rescue => e
+        logger.warn("Could not check Rails isolation level: #{e.message}")
+      end
+    end
+
+    def self.logger
+      Gouda.logger
+    end
+  end
 end