gouda 0.1.0

data/lib/gouda/railtie.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Gouda
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      task preload: :setup do
+        if defined?(Rails) && Rails.respond_to?(:application)
+          if Rails.application.config.eager_load
+            ActiveSupport.run_load_hooks(:before_eager_load, Rails.application)
+            Rails.application.config.eager_load_namespaces.each(&:eager_load!)
+          end
+        end
+      end
+    end
+
+    initializer "gouda.configure_rails_initialization" do
+      Gouda.config.app_executor = if defined?(Rails) && Rails.respond_to?(:application)
+        Rails.application.executor
+      else
+        ActiveSupport::Executor
+      end
+    end
+
+    initializer "gouda.active_job.extensions" do
+      ActiveSupport.on_load :active_job do
+        include Gouda::ActiveJobExtensions::Interrupts
+      end
+    end
+
+    generators do
+      require "generators/gouda/install_generator"
+    end
+
+    # The `to_prepare` block which is executed once in production
+    # and before each request in development.
+    config.to_prepare do
+      Gouda::Scheduler.update_schedule_from_config!
+
+      if defined?(Rails) && Rails.respond_to?(:application)
+        config_from_rails = Rails.application.config.try(:gouda)
+        if config_from_rails
+          Gouda.config.cleanup_preserved_jobs_before = config_from_rails[:cleanup_preserved_jobs_before]
+          Gouda.config.preserve_job_records = config_from_rails[:preserve_job_records]
+          Gouda.config.polling_sleep_interval_seconds = config_from_rails[:polling_sleep_interval_seconds]
+          Gouda.config.worker_thread_count = config_from_rails[:worker_thread_count]
+          if Gouda.config.logger
+            Gouda.config.logger.level = config_from_rails[:log_level] || Gouda.config.log_level
+          end
+        end
+      else
+        Gouda.config.preserve_job_records = false
+        Gouda.config.polling_sleep_interval_seconds = 0.2
+        Gouda.config.logger.level = Gouda.config.log_level
+      end
+    end
+  end
+end

data/lib/gouda/scheduler.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+# Timers handles jobs which run either on a Cron schedule or using arbitrary time intervals
+
+require "fugit"
+module Gouda::Scheduler
+  # A timer entry is either a Cron pattern or an interval duration, and configures which job needs to be scheduled
+  # and when
+  class Entry < Struct.new(:name, :cron, :interval_seconds, :job_class, :kwargs, :args, :set, keyword_init: true)
+    def scheduler_key
+      [name, interval_seconds, cron, job_class].compact.join("_")
+    end
+
+    def next_at
+      if interval_seconds
+        first_existing = Gouda::Workload.where(scheduler_key: scheduler_key).where("scheduled_at > NOW()").order("scheduled_at DESC").pluck(:scheduled_at).first
+        (first_existing || Time.now.utc) + interval_seconds
+      elsif cron
+        fugit = Fugit::Cron.parse(cron)
+        raise ArgumentError, "Unable to parse cron pattern #{cron.inspect}" unless fugit
+        Time.at(fugit.next_time.to_i).utc
+      end
+    end
+
+    def build_active_job
+      next_at = self.next_at
+      return unless next_at
+
+      job_class = self.job_class.constantize
+
+      active_job = kwargs_value.present? ? job_class.new(*args_value, **kwargs_value) : job_class.new(*args_value) # This method supports ruby2_keywords
+      active_job.scheduled_at = next_at
+      active_job.scheduler_key = scheduler_key
+
+      set_value.present? ? active_job.set(set_value) : active_job
+    end
+
+    private
+
+    def set_value
+      value = set || {}
+      value.respond_to?(:call) ? value.call : value
+    end
+
+    def args_value
+      value = args || []
+      value.respond_to?(:call) ? value.call : value
+    end
+
+    def kwargs_value
+      value = kwargs || nil
+      value.respond_to?(:call) ? value.call : value
+    end
+  end
+
+  def self.update_schedule_from_config!(cron_table_hash = nil)
+    Gouda.logger.info "Updating scheduled workload entries..."
+    if cron_table_hash.blank?
+      config_from_rails = Rails.application.config.try(:gouda)
+
+      cron_table_hash = if config_from_rails.present?
+        config_from_rails.dig(:cron).to_h if config_from_rails.dig(:enable_cron)
+      elsif Gouda.config.enable_cron
+        Gouda.config.cron
+      end
+
+      return unless cron_table_hash
+    end
+
+    defaults = {cron: nil, interval_seconds: nil, kwargs: nil, args: nil}
+    @cron_table = cron_table_hash.map do |(name, cron_entry_params)|
+      # `class` is a reserved keyword and a method that exists on every Ruby object so...
+      cron_entry_params[:job_class] ||= cron_entry_params.delete(:class)
+      params_with_defaults = defaults.merge(cron_entry_params)
+      Entry.new(name:, **params_with_defaults)
+    end
+  end
+
+  def self.enqueue_next_scheduled_workload_for(finished_workload)
+    return unless finished_workload.scheduler_key
+
+    timer_table = @cron_table.to_a.index_by(&:scheduler_key)
+    timer_entry = timer_table[finished_workload.scheduler_key]
+    return unless timer_entry
+
+    Gouda.enqueue_jobs_via_their_adapters([timer_entry.build_active_job])
+  end
+
+  def self.entries
+    @cron_table || []
+  end
+
+  def self.update_scheduled_workloads!
+    table_entries = @cron_table || []
+
+    # Remove any cron keyed workloads which no longer match config-wise
+    known_keys = table_entries.map(&:scheduler_key).uniq
+    Gouda::Workload.transaction do
+      Gouda::Workload.where.not(scheduler_key: known_keys).delete_all
+
+      # Insert the next iteration for every "next" entry in the crontab.
+      active_jobs_to_enqueue = table_entries.filter_map(&:build_active_job)
+      Gouda.logger.info "#{active_jobs_to_enqueue.size} job(s) to enqueue from the scheduler."
+      enqjobs = Gouda.enqueue_jobs_via_their_adapters(active_jobs_to_enqueue)
+      Gouda.logger.info "#{enqjobs.size} scheduled job(s) enqueued."
+    end
+  end
+end

data/lib/gouda/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Gouda
+  VERSION = "0.1.0"
+end

data/lib/gouda/worker.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "gouda/version"
+
+module Gouda
+  POLL_INTERVAL_DURATION_SECONDS = 1
+
+  # Is used for keeping the IDs of currently executing jobs on this worker in a thread-safe way.
+  # These IDs are used to update the heartbeat timestamps during execution. We need just three
+  # methods here - add to a set, remove from a set, and convert the set into an array for a SQL query
+  # with `WHERE id IN`.
+  class ThreadSafeSet
+    def initialize
+      @set = Set.new
+      @mutex = Mutex.new
+    end
+
+    def add(value)
+      @mutex.synchronize { @set.add(value) }
+      value
+    end
+
+    def delete(value)
+      @mutex.synchronize { @set.delete(value) }
+      value
+    end
+
+    def to_a
+      @mutex.synchronize { @set.to_a }
+    end
+  end
+
+  # Returns `true` once a given timer has elapsed.
+  # This is useful to terminate a worker after a certain amount of time
+  class TimerShutdownCheck
+    def initialize(seconds_float)
+      @dt = seconds_float
+      @st = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def call
+      (Process.clock_gettime(Process::CLOCK_MONOTONIC) - @st) > @dt
+    end
+  end
+
+  # Captures UNIX signals (TERM and INT) and then returns true. Once you initialize the
+  # this check you install signal handlers, meaning that the worker will not raise `Interrupt`
+  # from any theads but will get the space it needs to terminate cleanly. At least for SIGINT
+  # and SIGTERM this is very desirable. This is the default shutdown check.
+  class TrapShutdownCheck
+    def initialize
+      @did_trap = false
+      @did_log = false
+      Signal.trap(:TERM) do
+        @did_trap = :TERM
+      end
+      Signal.trap(:INT) do
+        @did_trap = :INT
+      end
+    end
+
+    def call
+      if @did_trap
+        @did_log ||= begin
+          warn("Gouda worker signaled to terminate via SIG#{@did_trap}")
+          true
+        end
+        true
+      else
+        false
+      end
+    end
+  end
+
+  # This shutdown check will return `true` once there
+  # are no enqueued jobs to process for this worker. This
+  # can be used to run a worker just as long as there are jobs to handle
+  # and then to let it quit by itself (handy for spot instances and the like)
+  class EmptyQueueShutdownCheck
+    def initialize(queue_constraint = Gouda::AnyQueue)
+      @queue_constraint = queue_constraint
+    end
+
+    def call
+      # return false unless Rails.application # Rails is still booting and there is no application defined
+
+      Gouda.config.app_executor.wrap do
+        Gouda::Workload.waiting_to_start(queue_constraint: @queue_constraint).none?
+      end
+    rescue # If the DB connection cannot be checked out etc
+      false
+    end
+  end
+
+  # A wrapping callable which returns `true` if any of the
+  # given callables return true. This can be used to combine a timed shutdown ("in 30 seconds")
+  # with a signal handler shutdown ("shutdown on SIGTERM/SIGINT")
+  class CombinedShutdownCheck
+    # @param callables_for_condition[#call] other shutdown checks
+    def initialize(*callables_for_condition)
+      @conditions = callables_for_condition
+    end
+
+    def call
+      # Once one shutdown check told us to shut down there is no point to query all the others
+      @memo ||= @conditions.any?(&:call)
+    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
+    #
+    # 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
+
+    check_shutdown = CombinedShutdownCheck.new(*check_shutdown) if !check_shutdown.respond_to?(:call) && check_shutdown.is_a?(Array)
+
+    worker_id = [Socket.gethostname, Process.pid, SecureRandom.uuid].join("-")
+
+    executing_workload_ids = ThreadSafeSet.new
+
+    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
+
+          did_process = Gouda.config.app_executor.wrap do
+            Gouda::Workload.checkout_and_perform_one(executing_on: worker_id_and_thread_id, queue_constraint:, in_progress: executing_workload_ids)
+          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}"
+        end
+      end
+    end
+
+    # Do the housekeeping tasks on main
+    loop do
+      break if check_shutdown.call
+
+      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::Workload.where(id: executing_workload_ids.to_a, state: "executing").update_all(executing_on: worker_id, last_execution_heartbeat_at: Time.now.utc)
+
+        # 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
+        # Appsignal.add_exception(e)
+        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
+  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
+  end
+end

data/lib/gouda/workload.rb

@@ -0,0 +1,214 @@
+# # frozen_string_literal: true
+
+# This model is called "workload" for a reason. The ActiveJob can be enqueued multiple times with
+# the same job ID which gets generated by Rails. These multiple enqueues of the same job are not
+# exactly copies of one another. When you use job-iteration for example, your job will be retried with a different
+# cursor position value. When you use ActiveJob `rescue_from` as well - the job will be retried and keep the same
+# active job ID, but it then gets returned into the queue "in some way". What we want is that the records in our
+# table represent a unit of work that the worker has to execute "at some point". If the same job gets enqueued multiple
+# times due to retries or pause/resume we want the enqueues to be separate workloads, which can fail or succeed
+# independently. This also allows the queue records to be "append-only" which allows the records to be pruned
+# on a regular basis. This is why they are called "workloads" and not "jobs". "Executions" is a great term used
+# by good_job but it seems that it is not clear what has the "identity". With the Workload the ID of the workload
+# is the "provider ID" for ActiveJob. It is therefore possible (and likely) that multiple Workloads will exist
+# sharing the same ActiveJob ID.
+class Gouda::Workload < ActiveRecord::Base
+  ZOMBIE_MAX_THRESHOLD = "5 minutes"
+
+  self.table_name = "gouda_workloads"
+  # GoodJob calls these "enqueued" but they are more like
+  # "waiting to start" - jobs which have been scheduled past now,
+  # or haven't been scheduled to a particular time, are in the "enqueued"
+  # state and match the queue constraint
+  scope :waiting_to_start, ->(queue_constraint: Gouda::AnyQueue) {
+    condition_for_ready_to_execute_jobs = <<~SQL
+      #{queue_constraint.to_sql}
+      AND execution_concurrency_key NOT IN (
+        SELECT execution_concurrency_key FROM #{quoted_table_name} WHERE state = 'executing' AND execution_concurrency_key IS NOT NULL
+      )
+      AND state = 'enqueued'
+      AND (scheduled_at <= clock_timestamp())
+    SQL
+
+    where(Arel.sql(condition_for_ready_to_execute_jobs))
+  }
+
+  scope :errored, -> { where("error != '{}'") }
+  scope :retried, -> { where("(serialized_params -> 'exception_executions') != '{}' AND state != 'finished'") }
+  scope :finished, -> { where(state: "finished") }
+  scope :enqueued, -> { where(state: "enqueued") }
+  scope :executing, -> { where(state: "executing") }
+
+  def self.queue_names
+    connection.select_values("SELECT DISTINCT(queue_name) FROM #{quoted_table_name} ORDER BY queue_name ASC")
+  end
+
+  def self.prune
+    if Gouda.config.preserve_job_records
+      where(state: "finished").where("execution_finished_at < ?", Gouda.cleanup_preserved_jobs_before.ago).delete_all
+    else
+      where(state: "finished").delete_all
+    end
+  end
+
+  # Re-enqueue zombie workloads which have been left to rot due to machine kills, worker OOM kills and the like
+  # With a lock so no single zombie job gets enqueued more than once
+  # And wrapped in transactions with the possibility to roll back a single workload without it rollbacking the entire batch
+  def self.reap_zombie_workloads
+    uncached do # again needed due to the use of clock_timestamp() in the SQL
+      transaction do
+        zombie_workloads_scope = Gouda::Workload.lock("FOR UPDATE SKIP LOCKED").where("state = 'executing' AND last_execution_heartbeat_at < (clock_timestamp() - interval '#{ZOMBIE_MAX_THRESHOLD}')")
+        zombie_workloads_scope.find_each(batch_size: 1000) do |workload|
+          # with_lock will start its own transaction
+          workload.with_lock("FOR UPDATE SKIP LOCKED") do
+            Gouda.logger.info { "Reviving (re-enqueueing) Gouda workload #{workload.id} after interruption" }
+
+            # Appsignal.increment_counter("gouda_workloads_revived", 1, job_class: workload.active_job_class_name)
+
+            interrupted_at = workload.last_execution_heartbeat_at
+            workload.update!(state: "finished", interrupted_at:, last_execution_heartbeat_at: Time.now.utc, execution_finished_at: Time.now.utc)
+            revived_job = ActiveJob::Base.deserialize(workload.active_job_data)
+            # Save the interrupted_at timestamp so that upon execution the new job will raise a Gouda::Interrpupted exception.
+            # The exception can then be handled like any other ActiveJob exception (using rescue_from or similar).
+            revived_job.interrupted_at = interrupted_at
+            revived_job.enqueue
+          end
+        rescue ActiveRecord::RecordNotFound
+          # This will happen if we have selected the zombie workload in the outer block, but
+          # by the point we reload it and take a FOR UPDATE SKIP LOCKED lock another worker is
+          # already reaping it - a call to `reload` will cause a RecordNotFound, since Postgres
+          # will hide the row from us. This is what we want in fact - we want to progress to
+          # the next row. So we allow the code to proceed, as we expect that the other worker
+          # (which stole the workload from us) will have set it to "state=finished" by the time we reattempt
+          # our SELECT with conditions
+          Gouda.logger.debug { "Gouda workload #{workload.id} cannot be reaped as it was hijacked by another worker" }
+        end
+      end
+    end
+  end
+
+  # Lock the next workload and mark it as executing
+  def self.checkout_and_lock_one(executing_on:, queue_constraint: Gouda::AnyQueue)
+    where_query = <<~SQL
+      #{queue_constraint.to_sql}
+      AND workloads.state = 'enqueued'
+      AND NOT EXISTS (
+        SELECT NULL
+        FROM #{quoted_table_name} AS concurrent
+        WHERE concurrent.state =                     'executing'
+          AND concurrent.execution_concurrency_key = workloads.execution_concurrency_key
+      )
+      AND workloads.scheduled_at <= clock_timestamp()
+    SQL
+    # Enter a txn just to mark this job as being executed "by us". This allows us to avoid any
+    # locks during execution itself, including advisory locks
+    jobs = Gouda::Workload
+      .select("workloads.*")
+      .from("#{quoted_table_name} AS workloads")
+      .where(where_query)
+      .order("workloads.priority ASC NULLS LAST")
+      .lock("FOR UPDATE SKIP LOCKED")
+      .limit(1)
+
+    _first_available_workload = ActiveSupport::Notifications.instrument("checkout_and_lock_one.gouda", {queue_constraint: queue_constraint.to_sql}) do |payload|
+      payload[:condition_sql] = jobs.to_sql
+      payload[:retried_checkouts_due_to_concurrent_exec] = 0
+      uncached do # Necessary because we SELECT with a clock_timestamp() which otherwise gets cached by ActiveRecord query cache
+        transaction do
+          jobs.first.tap do |job|
+            job&.update!(state: "executing", executing_on:, last_execution_heartbeat_at: Time.now.utc, execution_started_at: Time.now.utc)
+          end
+        rescue ActiveRecord::RecordNotUnique
+          # It can happen that due to a race the `execution_concurrency_key NOT IN` does not capture
+          # a job which _just_ entered the "executing" state, apparently after we do our SELECT. This will happen regardless
+          # whether we are using a CTE or a sub-SELECT
+          payload[:retried_checkouts_due_to_concurrent_exec] += 1
+          nil
+        end
+      end
+    end
+  end
+
+  # Get a new workload and call perform
+  # @param in_progress[#add,#delete] Used for tracking work in progress for heartbeats
+  def self.checkout_and_perform_one(executing_on:, queue_constraint: Gouda::AnyQueue, in_progress: Set.new)
+    # Select a job and mark it as "executing" which will make it unavailable to any other
+    workload = checkout_and_lock_one(executing_on:, queue_constraint:)
+    if workload
+      in_progress.add(workload.id)
+      workload.perform_and_update_state!
+    end
+  ensure
+    in_progress.delete(workload.id) if workload
+  end
+
+  def enqueued_at
+    Time.parse(serialized_params["enqueued_at"]) if serialized_params["enqueued_at"]
+  end
+
+  def perform_and_update_state!
+    ActiveSupport::Notifications.instrument("perform_job.gouda", {workload: self}) do |instrument_payload|
+      extras = {}
+      if Gouda::JobFuse.exists?(active_job_class_name: active_job_class_name)
+        extras[:error] = {class_name: "WorkloadSkippedError", message: "Skipped because of a fuse at #{Time.now.utc}"}
+      else
+        job_result = ActiveJob::Base.execute(active_job_data)
+
+        if job_result.is_a?(Exception)
+          # When an exception is handled, let's say we have a retry_on <exception> in our job, we end up here
+          # and it won't be rescueed
+          handled_error = job_result
+          update!(error: error_hash(handled_error))
+        end
+
+        instrument_payload[:value] = job_result
+        instrument_payload[:handled_error] = handled_error
+
+        job_result
+      end
+    rescue => exception_not_retried_by_active_job
+      # When a job fails and is not retryable it will end up here.
+      update!(error: error_hash(exception_not_retried_by_active_job))
+      instrument_payload[:unhandled_error] = exception_not_retried_by_active_job
+      Gouda.logger.error { exception_not_retried_by_active_job }
+      exception_not_retried_by_active_job # Return the exception instead of re-raising it
+    ensure
+      update!(state: "finished", last_execution_heartbeat_at: Time.now.utc, execution_finished_at: Time.now.utc, **extras)
+      # If the workload that just finished was a scheduled workload (via timer/cron) enqueue the next execution.
+      # Otherwise the next job will only get enqueued once the config is reloaded
+      Gouda::Scheduler.enqueue_next_scheduled_workload_for(self)
+    end
+  end
+
+  def schedule_now!
+    with_lock do
+      return if state != "enqueued"
+
+      update!(scheduled_at: Time.now.utc)
+    end
+  end
+
+  def mark_finished!
+    with_lock do
+      now = Time.now.utc
+      execution_started_at ||= now
+
+      return if state == "finished"
+
+      update!(
+        state: "finished", last_execution_heartbeat_at: now,
+        execution_finished_at: now, execution_started_at: execution_started_at,
+        error: {class_name: "RemovedError", message: "Manually removed at #{now}"}
+      )
+      Gouda::Scheduler.enqueue_next_scheduled_workload_for(self)
+    end
+  end
+
+  def error_hash(error)
+    {class_name: error.class.to_s, backtrace: error.backtrace.to_a, message: error.message}
+  end
+
+  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
+end

data/lib/gouda.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext/numeric/time"
+require "active_support/configurable"
+require "rails/railtie"
+require_relative "gouda/bulk"
+require_relative "gouda/adapter"
+require_relative "gouda/scheduler"
+require_relative "gouda/railtie" if defined?(Rails::Railtie)
+require_relative "gouda/workload"
+require_relative "gouda/worker"
+require_relative "gouda/job_fuse"
+require_relative "gouda/queue_constraints"
+require_relative "gouda/active_job_extensions/interrupts"
+require_relative "gouda/active_job_extensions/concurrency"
+require_relative "active_job/queue_adapters/gouda_adapter"
+
+module Gouda
+  class Gouda::Configuration
+    include ActiveSupport::Configurable
+
+    config_accessor(:preserve_job_records, default: false)
+    config_accessor(:cleanup_preserved_jobs_before, default: 3.hours)
+    config_accessor(:polling_sleep_interval_seconds, default: 0.2)
+    config_accessor(:worker_thread_count, default: 1)
+    config_accessor(:logger, default: ActiveSupport::Logger.new($stdout))
+    config_accessor(:app_executor)
+    config_accessor(:cron, default: {})
+    config_accessor(:enable_cron, default: true)
+    # Log levels are:
+    # constant    |   level
+    # Logger::DEBUG   (0)
+    # Logger::INFO    (1)
+    # Logger::WARN    (2)
+    # Logger::ERROR   (3)
+    # Logger::FATAL   (4)
+    # Logger::UNKNOWN (5)
+    config_accessor(:log_level, default: Logger::DEBUG)
+  end
+
+  class InterruptError < StandardError
+  end
+
+  class ConcurrencyExceededError < StandardError
+  end
+
+  def self.start
+    Gouda::Scheduler.update_scheduled_workloads!
+
+    queue_constraint = if ENV["GOUDA_QUEUES"]
+      Gouda.parse_queue_constraint(ENV["GOUDA_QUEUES"])
+    else
+      Gouda::AnyQueue
+    end
+
+    Gouda.logger.info("Gouda version: #{Gouda::VERSION}")
+    Gouda.logger.info("Worker threads: #{Gouda.config.worker_thread_count}")
+
+    Gouda.worker_loop(n_threads: Gouda.config.worker_thread_count, queue_constraint:)
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.configure
+    yield config
+  end
+
+  def self.logger
+    Gouda.config.logger
+  end
+
+  def self.create_tables(active_record_schema)
+    active_record_schema.create_enum :gouda_workload_state, %w[enqueued executing finished]
+    active_record_schema.create_table :gouda_workloads, id: :uuid do |t|
+      t.uuid :active_job_id, null: false
+      t.timestamp :scheduled_at, null: false
+      t.timestamp :execution_started_at
+      t.timestamp :execution_finished_at
+      t.timestamp :last_execution_heartbeat_at
+      t.timestamp :interrupted_at, null: true
+
+      t.string :scheduler_key, null: true
+      t.string :queue_name, null: false, default: "default"
+      t.integer :priority
+      t.string :active_job_class_name, null: false
+      t.jsonb :serialized_params
+      t.jsonb :error, default: {}, null: false
+      t.enum :state, enum_type: :gouda_workload_state, default: "enqueued", null: false
+      t.string :execution_concurrency_key
+      t.string :enqueue_concurrency_key
+      t.string :executing_on
+      t.integer :position_in_bulk
+
+      t.timestamps
+    end
+
+    active_record_schema.add_index :gouda_workloads, [:priority, :id, :scheduled_at], where: "state = 'enqueued'", name: :gouda_checkout_all_index
+    active_record_schema.add_index :gouda_workloads, [:id, :last_execution_heartbeat_at], where: "state = 'executing'", name: :gouda_last_heartbeat_index
+    active_record_schema.add_index :gouda_workloads, [:enqueue_concurrency_key], where: "state = 'enqueued' AND enqueue_concurrency_key IS NOT NULL", unique: true, name: :guard_double_enqueue
+    active_record_schema.add_index :gouda_workloads, [:scheduler_key], where: "state = 'enqueued' AND scheduler_key IS NOT NULL", unique: true, name: :guard_double_schedule
+    active_record_schema.add_index :gouda_workloads, [:execution_concurrency_key], where: "state = 'executing' AND execution_concurrency_key IS NOT NULL", unique: true, name: :guard_double_exec
+    active_record_schema.add_index :gouda_workloads, [:active_job_id], name: :same_job_display_idx
+    active_record_schema.add_index :gouda_workloads, [:priority], order: {priority: "ASC NULLS LAST"}, name: :ordered_priority_idx
+    active_record_schema.add_index :gouda_workloads, [:last_execution_heartbeat_at], name: :index_gouda_workloads_on_last_execution_heartbeat_at
+    active_record_schema.add_index :gouda_workloads, [:scheduler_key], name: :index_gouda_workloads_on_scheduler_key
+
+    active_record_schema.create_table :gouda_job_fuses, id: false do |t|
+      t.string :active_job_class_name, null: false
+
+      t.timestamps
+    end
+  end
+end