gouda 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f36a7c7b361cb8008f34b4a178c6bf1eb2a358e95502d0550fc14fef78ef5ed7
+  data.tar.gz: 6d2bc5778d6284f212189f4311e575393c5d9c1da13e4618f0b9a5d6ace9e954
+SHA512:
+  metadata.gz: 71a324a3bae3ee17c2ed547915b1cc841442059c30f0c85138f1b220a7c9dc2b307e6d0363fba12069be0b893ce74e1cefe81f5d3fc1ceec427b56a7331be256
+  data.tar.gz: 8e9d521dc92ccd14175611e21535ed9e5b71610e74c22fd4038e11a16c104b9fc73d93431e1e9aae38bb37e739d91447f3739ddd8099083e4d6e821db1426ea5

data/.github/workflows/ci.yml

@@ -0,0 +1,36 @@
+name: CI
+
+on:
+  - push
+
+env:
+  BUNDLE_PATH: vendor/bundle
+
+jobs:
+  test:
+    name: Tests
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:15-alpine
+        env:
+          POSTGRES_PASSWORD: postgres
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 100ms
+          --health-timeout 1s
+          --health-retries 100
+
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.2'
+          bundler-cache: true
+      - name: "Tests and Lint"
+        run: bundle exec rake

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock

data/.rubocop.yml

@@ -0,0 +1,10 @@
+require: standard
+
+AllCops:
+  TargetRubyVersion: 3.1
+
+inherit_gem:
+  standard: config/base.yml
+
+# Don't define any actual rubocop config here - this file is only used for
+# proper editor support, and not used on CI, formatters, nor anywhere else.

data/.ruby-version

@@ -0,0 +1 @@
+3.2.2

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-05-27
+
+- Initial release
+

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+gemspec
+
+gem "standard", require: false
+gem "rake", "~> 13.0"
+gem "minitest", "~> 5.0"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Cheddar Payments BV
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,17 @@
+Gouda is an ActiveJob adapter used at Cheddar. It requires PostgreSQL and a recent version of Rails.
+
+⚠️ At the moment Gouda is only used internally at Cheddar. We do not provide support for it, nor do we accept
+issues or feature requests. This is likely to change in the future.
+
+## Installation
+
+```
+$ bundle add gouda
+$ bundle install
+$ bin/rails g gouda:install
+```
+
+## Usage
+
+At the moment the Gouda UI is proprietary, so this gem only provides a "headless" implementation. We expect this to change in the future.
+

data/Rakefile

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+
+  file_name = ARGV[1]
+
+  t.test_files = if file_name
+    [file_name]
+  else
+    FileList["test/**/*_test.rb"]
+  end
+end
+
+task default: :test

data/gouda.gemspec

@@ -0,0 +1,32 @@
+require_relative "lib/gouda/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "gouda"
+  spec.version = Gouda::VERSION
+  spec.summary = "Job Scheduler"
+  spec.description = "Job Scheduler for Rails"
+  spec.authors = ["Sebastian van Hesteren", "Julik Tarkhanov"]
+  spec.email = ["sebastian@cheddar.me", "me@julik.nl"]
+  spec.homepage = "https://rubygems.org/gems/gouda"
+  spec.license = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+  spec.require_paths = ["lib"]
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/cheddar-me/gouda"
+  spec.metadata["changelog_uri"] = "https://github.com/cheddar-me/gouda/CHANGELOG.md"
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+
+  spec.add_dependency "activerecord", "~> 7"
+  spec.add_dependency "activesupport", "~> 7"
+  spec.add_dependency "railties", "~> 7"
+  spec.add_dependency "activejob", "~> 7"
+  spec.add_dependency "fugit", "~> 1.10.1"
+
+  spec.add_development_dependency "pg"
+  spec.add_development_dependency "debug"
+  spec.add_development_dependency "pry"
+end

data/lib/active_job/queue_adapters/gouda_adapter.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ActiveJob # :nodoc:
+  module QueueAdapters # :nodoc:
+    class GoudaAdapter < Gouda::Adapter
+    end
+  end
+end

data/lib/generators/gouda/install_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Gouda
+  # Rails generator used for setting up Gouda in a Rails application.
+  # Run it with +bin/rails g gouda:install+ in your console.
+
+  class InstallGenerator < Rails::Generators::Base
+    include ActiveRecord::Generators::Migration
+
+    TEMPLATES = File.join(File.dirname(__FILE__), "templates/install")
+    source_paths << TEMPLATES
+
+    class_option :database, type: :string, aliases: %i[--db], desc: "The database for your migration. By default, the current environment's primary database is used."
+
+    # Generates monolithic migration file that contains all database changes.
+    def create_migration_file
+      migration_template "migrations/create_gouda_tables.rb.erb", File.join(db_migrate_path, "create_gouda_tables.rb")
+    end
+
+    private
+
+    def migration_version
+      "[#{ActiveRecord::VERSION::STRING.to_f}]"
+    end
+  end
+end

data/lib/generators/gouda/templates/install/migrations/create_gouda_tables.rb.erb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class CreateGoudaWorkloads < ActiveRecord::Migration<%= migration_version %>
+  def change
+    Gouda.create_tables(self)
+  end
+end

data/lib/gouda/active_job_extensions/concurrency.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Gouda
+  module ActiveJobExtensions
+    module Concurrency
+      extend ActiveSupport::Concern
+
+      VALID_TYPES = [String, Symbol, Numeric, Date, Time, TrueClass, FalseClass, NilClass].freeze
+
+      included do
+        class_attribute :gouda_concurrency_config, instance_accessor: false, default: {}
+      end
+
+      class_methods do
+        def gouda_control_concurrency_with(total_limit: nil, perform_limit: nil, enqueue_limit: nil, key: nil)
+          raise ArgumentError, "Need one of total_limit, perform_limit, enqueue_limit" if [total_limit, perform_limit, enqueue_limit].all?(&:blank?)
+          raise ArgumentError, "The only available limit is 1" if [total_limit, perform_limit, enqueue_limit].any? { |v| v.is_a?(Integer) && v != 1 }
+
+          if total_limit
+            perform_limit = total_limit
+            enqueue_limit = total_limit
+          end
+
+          self.gouda_concurrency_config = {perform_limit:, enqueue_limit:, key:}
+        end
+      end
+
+      # This method will be tried by the Gouda adapter
+      def enqueue_concurrency_key
+        job_config = self.class.try(:gouda_concurrency_config)
+        return unless job_config
+        return unless job_config[:enqueue_limit]
+
+        _gouda_concurrency_extension_key_via_config || _gouda_concurrency_extension_automatic_key_from_class_and_args
+      end
+
+      # This method will be tried by the Gouda adapter
+      def execution_concurrency_key
+        job_config = self.class.try(:gouda_concurrency_config)
+        return unless job_config
+        return unless job_config[:perform_limit]
+
+        _gouda_concurrency_extension_key_via_config || _gouda_concurrency_extension_automatic_key_from_class_and_args
+      end
+
+      # Generates automatic serialized sha1 key
+      def _gouda_concurrency_extension_automatic_key_from_class_and_args
+        # To have a stable serialization of an ActiveJob we can re-use the method defined by
+        # ActiveJob itself. We need to have the job class name and all the arguments, and for arguments
+        # which are ActiveRecords or derivatives - we want them converted into global IDs. This also avoids
+        # having attributes of the argument ActiveModels contribute to the concurrency key.
+        # Add "cursor_position" from job-iteration so that different offsets of the same job can run
+        # concurrently.
+        pertinent_job_attributes = serialize.slice("job_class", "arguments", "priority", "cursor_position")
+        Digest::SHA1.hexdigest(JSON.dump(pertinent_job_attributes))
+      end
+
+      # Generates the concurrency key from the configuration
+      def _gouda_concurrency_extension_key_via_config
+        key = self.class.gouda_concurrency_config[:key]
+        return if key.blank?
+
+        key = key.respond_to?(:call) ? instance_exec(&key) : key
+        raise TypeError, "Concurrency key must be a String; was a #{key.class}" unless VALID_TYPES.any? { |type| key.is_a?(type) }
+
+        key
+      end
+    end
+  end
+end

data/lib/gouda/active_job_extensions/interrupts.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Gouda
+  module ActiveJobExtensions
+    module Interrupts
+      extend ActiveSupport::Concern
+
+      included do
+        around_perform do |job, block|
+          # The @gouda_workload_interrupted_at ivar gets set on the job when the Workload
+          # gets reaped as a zombie. It contains the last know heartbeat of the job, assuming
+          # that it got interrupted around that particular time. The ivar gets persisted not
+          # into the original Workload (which gets marked "finished") but into the new Workload
+          # which the reap_zombie_workloads method enqueues.
+          if job.interrupted_at
+            Gouda.logger.warn { "Job: #{job.class.name} #{job.job_id} was previously interrupted" }
+            # The job is going to be re-enqueued it InterruptError is marked as retriable. We need
+            # to remove `interrupted_at` otherwise it will get raised again once that new job
+            # starts executing - which is not what we want
+            interrupted_error_time = job.interrupted_at
+            job.interrupted_at = nil
+
+            raise Gouda::InterruptError, "Job was interrupted around #{interrupted_error_time}"
+          end
+          block.call
+        end
+
+        # This overrides ActiveJob::Base to also set the "interrupted_at" value, which Gouda
+        # supplies in the active_job_data hash. The value is needed so that the job can correctly
+        # raise an InterruptError after an interruption, and we have to do it here so that we can
+        # still use ActiveJob::Base.execute, which Appsignal overloads.
+        # We also need to retain the scheduler_key value so that retries which ActiveJob does for us
+        # preserve that value when remarshaling the job
+        def self.deserialize(active_job_data)
+          super.tap do |job|
+            job.interrupted_at = active_job_data["interrupted_at"]
+            job.scheduler_key = active_job_data["scheduler_key"]
+          end
+        end
+
+        attr_accessor :interrupted_at
+        attr_accessor :scheduler_key
+      end
+    end
+  end
+end

data/lib/gouda/adapter.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+# Acts as an ActiveJob adapter
+
+class Gouda::Adapter
+  prepend Gouda::BulkAdapterExtension
+
+  ENQUEUE_ERROR_MESSAGE = <<~ERR
+    The job has been rejected due to a matching enqueue concurrency key
+  ERR
+
+  # Enqueues the ActiveJob job to be performed.
+  # For use by Rails; you should generally not call this directly.
+  # @param active_job [ActiveJob::Base] the job to be enqueued from +#perform_later+
+  # @return [String, nil] the ID of the inserted workload or nil if the insert did not go through (due to concurrency)
+  def enqueue(active_job)
+    # This is the method that gets called by ActiveJob internally (from inside the ActiveJob::Base instance
+    # method). This is also when ActiveJob runs the enqueue callbacks. After this method returns
+    # ActiveJob will set @successfully_enqueued inside the job to `true` as long as no
+    # EnqueueError has been raised. This is, of course, incompatible with bulk-enqueueing (which we want)
+    # to use by default. What we can do is verify the value of the property set by our `enqueue_all` method,
+    # and raise the exception based on that.
+    enqueue_all([active_job])
+    if active_job.enqueue_error
+      Gouda.logger.warn { "Error #{active_job.enqueue_error.inspect} for Gouda workload (#{active_job.job_id})" }
+      raise active_job.enqueue_error
+    end
+    active_job.provider_job_id
+  end
+
+  # Enqueues an ActiveJob job to be run at a specific time.
+  # For use by Rails; you should generally not call this directly.
+  # @param active_job [ActiveJob::Base] the job to be enqueued from +#perform_later+
+  # @param timestamp [Integer, nil] the epoch time to perform the job
+  # @return [String, nil] the ID of the inserted Gouda or nil if the insert did not go through (due to concurrency)
+  def enqueue_at(active_job, timestamp_int)
+    active_job.scheduled_at = Time.at(timestamp_int).utc
+    enqueue_all([active_job])
+    if active_job.enqueue_error
+      Gouda.logger.warn { "Error #{active_job.enqueue_error.inspect} for Gouda workload (#{active_job.job_id})" }
+      raise active_job.enqueue_error
+    end
+    active_job.provider_job_id
+  end
+
+  # Enqueues multiple ActiveJobs.
+  # For use by Rails; you should generally not call this directly.
+  # @param active_job [ActiveJob::Base] the job to be enqueued from +#perform_later+
+  # @param timestamp [Integer, nil] the epoch time to perform the job
+  # @return [Integer] the number of jobs which were successfully sent to the queue
+  def enqueue_all(active_jobs)
+    t_now = Time.now.utc
+    bulk_insert_attributes = active_jobs.map.with_index do |active_job, i|
+      # We can't pregenerate an ID because we want to INSERT .. ON CONFLICT DO NOTHING
+      # and we want Postgres to use _all_ unique indexes for it, which would include a conflict of IDs -
+      # so some jobs could get silently rejected because of a duplicate ID. However unlikely this can better be prevented.
+      # We can't tell Postgres to ignore conflicts on _both_ the scheduler key and the enqueue concurrency key but not on
+      # the ID - it is either "all indexes" or "just one", but never "this index and that index". MERGE https://www.postgresql.org/docs/current/sql-merge.html
+      # is in theory capable of solving this but let's not complicate things all to hastily, the hour is getting late
+      {
+        active_job_id: active_job.job_id, # Multiple jobs can have the same ID due to retries, job-iteration etc.
+        scheduled_at: active_job.scheduled_at || t_now,
+        scheduler_key: active_job.scheduler_key, # So that the scheduler_key gets retained between retries
+        priority: active_job.priority,
+        execution_concurrency_key: extract_execution_concurrency_key(active_job),
+        enqueue_concurrency_key: extract_enqueue_concurrency_key(active_job),
+        queue_name: active_job.queue_name || "default",
+        active_job_class_name: active_job.class.to_s,
+        serialized_params: active_job.serialize.except("provider_job_id"), # For when a job which gets retried
+        interrupted_at: active_job.interrupted_at, # So that an exception can be raised when this job gets executed
+        position_in_bulk: i,
+        state: "enqueued"
+      }
+    end
+
+    # Filter out all the jobs with the same (and present) concurrency key and scheduler key
+    bulk_insert_attributes = filter_by_unique_not_nil_hash_key(bulk_insert_attributes, :enqueue_concurrency_key)
+    bulk_insert_attributes = filter_by_unique_not_nil_hash_key(bulk_insert_attributes, :scheduler_key)
+
+    # Do a bulk insert. For jobs with an enqueue concurrency key there will be no enqueue
+    # as the default for insert_all is to DO NOTHING. An exception would be nice but we are after performance here.
+    # Use batches of 500 so that we do not exceed the maximum statement size or do not create a transaction for the
+    # insert which times out
+    inserted_ids_and_positions = bulk_insert_attributes.each_slice(500).flat_map do |chunk|
+      ActiveSupport::Notifications.instrument("insert_all.gouda", {n_rows: chunk.size}) do |payload|
+        rows = Gouda::Workload.insert_all(chunk, returning: [:id, :position_in_bulk])
+        payload[:inserted_jobs] = rows.length
+        payload[:rejected_jobs] = chunk.size - rows.length
+        rows
+      end
+    end
+
+    # Mark all the jobs we ended up not enqueuing as such. If these jobs are getting enqueued "one by one"
+    # then their callbacks have already run, and they are already set to `successfully_enqueued = true`. If
+    # they are enqueued using `enqueue_all` directly there are no guarantees, as `enqueue_all` is a fairly new
+    # Rails feature. Now is the moment we need to "fish out" our bulk enqueue position and use it to detect
+    # which jobs did get enqueued and which didn't. Yes, this is a bit roundabout - but otherwise we could
+    # have a unique index and DO NOTHING just on the enqueue concurrency key
+    inserted_ids_and_positions.each do |row|
+      i = row.fetch("position_in_bulk")
+      active_jobs[i].provider_job_id = row.fetch("id")
+      active_jobs[i].successfully_enqueued = true
+    end
+    _, failed_enqueue = active_jobs.partition(&:successfully_enqueued?)
+    failed_enqueue.each do |active_job|
+      active_job.successfully_enqueued = false
+      active_job.enqueue_error = ActiveJob::EnqueueError.new(ENQUEUE_ERROR_MESSAGE)
+    end
+
+    # And return how many jobs we _did_ enqueue
+    inserted_ids_and_positions.length
+  end
+
+  # The whole point of Gouda is actually co-committing jobs with the business objects they use. The
+  # changes in Rails are directed towards shifting the job enqueues into an after_commit hook, so
+  # that the jobs - when they start executing - will always find the committed business-objects in
+  # the database. It is their attempt at ensuring read-after-write consistency in the face of two
+  # separate data stores. However, with a DB-based job queue which is using the same database
+  # as the rest of the application, we actually want the opposite - if a transaction commits,
+  # we want it to commit both the jobs to be done on the business objects and the business objects
+  # themselves. Folding the job enqueues into the same transaction can also be a great improvement
+  # to performance. Some of our jobs also imply that a job was generated as a result of a business
+  # model change. With after_commit, there is a subtle race condition where your application may
+  # crash between you doing the COMMIT on your transaction and the after_commit hooks executing.
+  # We want to avoid this in Gouda and always have a guarantee that if our main models committed,
+  # so did the jobs that use them.
+  # So: tell ActiveJob that we prefer the jobs to be co-committed.
+  #
+  # See https://github.com/rails/rails/pull/51426
+  def enqueue_after_transaction_commit?
+    false
+  end
+
+  private
+
+  def combine_enqueue_concurrency_key(enqueue_concurrency_key, scheduler_key, cursor_position)
+    # We also include the scheduler key into the enqueue key. This is done for the following reasons:
+    # Our scheduler always schedules "next subsequent" job once a job completes or fails. If we already have
+    # a job scheduled for execution way in the future (say - next month), and the enqueue concurrency key is set,
+    # we will need to manually remove it from the queue if we want to run its instance sooner. We could define a
+    # unique index on (enqueue_concurrency_key, scheduler_key) - but that would make our enqueue concurrency keys
+    # because NULLs in the scheduler_key are not considered equal to each other. We could mofidy our index statement
+    # with NULLS NOT DISTINCT - see https://www.postgresql.org/docs/current/indexes-unique.html - but that would
+    # create another problem. We want NULLs to _be_ distinct for the enqueue_concurrency_key column, but we want them
+    # to _not_ be distinct for the scheduler_key column (one off-scheduler job eneuqued at most for the same
+    # scheduler_key value). Postgres does not give us this ability, sadly. So the way to go about it is to
+    # mix the scheduler key (name of the scheduled task + cron pattern and whatnot) into the enqueue_concurrency_key
+    # value itself - this provides us with all the necessary properties.
+    # For job-iteration we need to do the same so that we can have multiple jobs enqueued with the same key but
+    # different cursor positions
+    [enqueue_concurrency_key, scheduler_key, cursor_position].compact.join(":")
+  end
+
+  def extract_enqueue_concurrency_key(active_job)
+    ck_value = active_job.try(:enqueue_concurrency_key)
+    return unless ck_value.present?
+
+    enqueueing_as = active_job.try(:scheduler_key).present? ? "scheduled" : "immediate"
+    combine_enqueue_concurrency_key(ck_value, enqueueing_as, active_job.try(:cursor_position))
+  end
+
+  def extract_execution_concurrency_key(active_job)
+    active_job.try(:execution_concurrency_key)
+  end
+
+  # Finds all hashes in the given attributes which have the same value of the given attribute and preserves just one
+  # in the returned array. We need to do that for both the scheduler key and the enqueue concurrency key.
+  def filter_by_unique_not_nil_hash_key(bulk_insert_attributes, key_name)
+    # This is not as nice as a combo of partition/unique_by and whatnot but it is linear time, so there.
+    seen = Set.new
+    bulk_insert_attributes.filter do |item|
+      maybe_key = item.fetch(key_name)
+      if maybe_key && seen.include?(maybe_key)
+        false
+      elsif maybe_key
+        seen << maybe_key
+        true
+      else
+        true
+      end
+    end
+  end
+end

data/lib/gouda/bulk.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Gouda
+  def self.in_bulk(&blk)
+    if Thread.current[:gouda_bulk_buffer].nil?
+      Thread.current[:gouda_bulk_buffer] = []
+      retval = yield
+      buf, Thread.current[:gouda_bulk_buffer] = Thread.current[:gouda_bulk_buffer], nil
+      enqueue_jobs_via_their_adapters(buf)
+      retval
+    else # There already is an open bulk
+      yield
+    end
+  end
+
+  # This method exists in edge Rails so probably can be replaced later:
+  # https://github.com/rails/rails/commit/9b62f88a2fde0d2bf8c4f6e3bcd06ecba7ca9d8d
+  def self.enqueue_jobs_via_their_adapters(active_jobs)
+    jobs_per_adapter = active_jobs.compact.group_by { |aj| aj.class.queue_adapter }
+    jobs_per_adapter.each_pair do |adapter, active_jobs|
+      if adapter.respond_to?(:enqueue_all)
+        adapter.enqueue_all(active_jobs)
+      else
+        active_jobs.each { |aj| adapter.enqueue(aj) }
+      end
+    end
+  end
+
+  module BulkAdapterExtension
+    def enqueue_all(active_jobs)
+      if Thread.current[:gouda_bulk_buffer]
+        Thread.current[:gouda_bulk_buffer].append(*active_jobs)
+        active_jobs
+      else
+        super
+      end
+    end
+  end
+end

data/lib/gouda/job_fuse.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Gouda::JobFuse < ActiveRecord::Base
+  self.table_name = "gouda_job_fuses"
+  self.primary_key = :active_job_class_name
+end

data/lib/gouda/migrations/create_gouda_tables.rb.erb

@@ -0,0 +1,5 @@
+class CreateGoudaTables < ActiveRecord::Migration<%= migration_version %>
+  def change
+    Gouda.create_tables(self)
+  end
+end

data/lib/gouda/queue_constraints.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Gouda
+  module AnyQueue
+    def self.to_sql
+      "1=1"
+    end
+  end
+
+  class OnlyQueuesConstraint < Struct.new(:queue_names)
+    def to_sql
+      placeholders = (["?"] * queue_names.length).join(",")
+      ActiveRecord::Base.sanitize_sql_array([<<~SQL, *queue_names])
+        queue_name IN (#{placeholders})
+      SQL
+    end
+  end
+
+  class ExceptQueueConstraint < Struct.new(:queue_names)
+    def to_sql
+      placeholders = (["?"] * queue_names.length).join(",")
+      ActiveRecord::Base.sanitize_sql_array([<<~SQL, *queue_names])
+        queue_name NOT IN (#{placeholders})
+      SQL
+    end
+  end
+
+  def self.parse_queue_constraint(constraint_str_from_envvar)
+    parsed = queue_parser(constraint_str_from_envvar)
+    if parsed[:include]
+      OnlyQueuesConstraint.new(parsed[:include])
+    elsif parsed[:exclude]
+      ExceptQueueConstraint.new(parsed[:exclude])
+    else
+      AnyQueue
+    end
+  end
+
+  # Parse a string representing a group of queues into a more readable data
+  # structure.
+  # @param string [String] Queue string
+  # @return [Hash]
+  #   How to match a given queue. It can have the following keys and values:
+  #   - +{ all: true }+ indicates that all queues match.
+  #   - +{ exclude: Array<String> }+ indicates the listed queue names should
+  #     not match.
+  #   - +{ include: Array<String> }+ indicates the listed queue names should
+  #     match.
+  # @example
+  #   Gouda::QueueConstraints.queue_parser('-queue1,queue2')
+  #   => { exclude: [ 'queue1', 'queue2' ] }
+  def self.queue_parser(string)
+    string = string.presence || "*"
+
+    case string.first
+    when "-"
+      exclude_queues = true
+      string = string[1..]
+    when "+"
+      string = string[1..]
+    end
+
+    queues = string.split(",").map(&:strip)
+
+    if queues.include?("*")
+      {all: true}
+    elsif exclude_queues
+      {exclude: queues}
+    else
+      {include: queues}
+    end
+  end
+end