solid_terminator 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: eebd10e8944a7298814632a848c9f0d9d858591384b0787c714a5f7e958d98a2
+  data.tar.gz: 072a76c8bc904536248aa0eeb2b3ed7ed9a0bb3e9f37c24655112bcf0894b190
+SHA512:
+  metadata.gz: 4d6bc234cdd8edf4427e378bf155425492b45100115705ef289fba803a63fff236c7458560b00057c2e18c17384809654bca333b4e8e323f6862095e6869c720
+  data.tar.gz: 7928aa7bf48a113df6d440736556a24fb75b400e42221f57f9bda607ae952f61a4324aef4b15d4e9e5ee7eefba2b37975a22533bc2368b9f8f364f74f244781f

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.1.0] - 2026-06-06
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Meszaros Istvan-Abel
+
+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,262 @@
+# SolidTerminator
+
+*Hasta la vista, ActiveJob.*
+
+Terminate a specific in-progress [SolidQueue](https://github.com/rails/solid_queue) job without stopping the worker process or affecting any other running jobs.
+
+SolidQueue has no native per-job termination. Sending `TERM`/`QUIT` to a worker kills every job running on it. SolidTerminator fills that gap by raising a custom exception on exactly the thread running the target job.
+
+## How it works
+
+1. **Web server** — `SolidTerminator.terminate!(active_job_id)` inserts a row into `solid_queue_terminations`.
+2. **Worker** — one monitor thread per worker process polls the table every 5 seconds (configurable). When it finds a row matching a locally-running job, it raises `SolidTerminator::JobTerminated` on that job's thread via `Thread#raise`.
+3. **Job** — jobs that include `SolidTerminator::Terminable` rescue the exception, write a `TerminatedExecution` audit record, and stop cleanly.
+
+The monitor skips the DB query entirely when no jobs are running — zero overhead at idle.
+
+If the job catches the exception internally and keeps running, the termination row stays in the table and the monitor raises again on the next poll. Termination keeps retrying until the job actually stops.
+
+## Requirements
+
+- Ruby >= 3.1
+- Rails >= 7.1
+- SolidQueue >= 1.0
+
+## Installation
+
+Add to your `Gemfile`:
+
+```ruby
+gem "solid_terminator"
+```
+
+Run the install generator:
+
+```bash
+bin/rails generate solid_terminator:install
+```
+
+This copies two migrations and an initializer. Then run migrations.
+
+**Single-database apps** (SolidQueue shares the main database):
+
+```bash
+bin/rails db:migrate
+```
+
+**Multi-database apps** (SolidQueue uses a dedicated database, typically keyed `queue` in `database.yml`):
+
+```bash
+bin/rails db:migrate:queue
+```
+
+> If your queue database key is not `queue`, pass `--database=<key>` to the generator:
+> ```bash
+> bin/rails generate solid_terminator:install --database=jobs
+> ```
+
+The generator creates two tables:
+
+| Table | Purpose |
+|---|---|
+| `solid_queue_terminations` | Termination signal — almost always empty |
+| `solid_queue_terminated_executions` | Audit trail of every terminated job |
+
+## Usage
+
+### Make a job terminable
+
+Include `SolidTerminator::Terminable` in any job you want to be able to terminate:
+
+```ruby
+class MyJob < ApplicationJob
+  include SolidTerminator::Terminable
+
+  def perform
+    loop do
+      do_some_work
+    end
+  end
+end
+```
+
+The concern registers the job's thread when execution starts and deregisters it when execution ends — whether the job succeeds, fails, or is terminated.
+
+### Graceful cleanup on termination
+
+`JobTerminated` propagates through your job's `perform` like any other exception. Use `ensure` for cleanup that must always run, and `rescue` if you need to react to termination specifically:
+
+```ruby
+class MyJob < ApplicationJob
+  include SolidTerminator::Terminable
+
+  def perform
+    acquire_lock
+    do_long_work
+  rescue SolidTerminator::JobTerminated
+    release_lock      # clean up before the job stops
+    raise             # always re-raise so SolidTerminator can finish
+  ensure
+    close_connections # runs on success, failure, and termination
+  end
+end
+```
+
+> **Important:** Always re-raise `JobTerminated` after your cleanup. If you swallow it, the termination row stays in the database and the monitor will raise again on the next poll until the job stops.
+
+### Request termination
+
+From a controller, background job, console, or anywhere in your app:
+
+```ruby
+SolidTerminator.terminate!(active_job_id)
+```
+
+The job's thread receives `SolidTerminator::JobTerminated` within the next polling interval (default 5 seconds) and stops cleanly. Calling `terminate!` twice for the same job is safe — the duplicate is silently ignored.
+
+**From a controller:**
+
+```ruby
+class JobsController < ApplicationController
+  def destroy
+    SolidTerminator.terminate!(params[:active_job_id])
+    head :accepted
+  end
+end
+```
+
+**From the Rails console:**
+
+```ruby
+SolidTerminator.terminate!("9a7b3c2d-1234-5678-abcd-ef0123456789")
+```
+
+### Find the active_job_id
+
+`active_job_id` is the UUID assigned by ActiveJob. Capture it at enqueue time:
+
+```ruby
+job = MyJob.perform_later(args)
+job.job_id  # => "9a7b3c2d-..."
+```
+
+Find currently running jobs via SolidQueue's claimed executions:
+
+```ruby
+SolidQueue::ClaimedExecution
+  .joins(:job)
+  .where(solid_queue_jobs: { class_name: 'MyJob' })
+  .pluck('solid_queue_jobs.active_job_id')
+```
+
+Or find any enqueued/running job by class:
+
+```ruby
+SolidQueue::Job.where(class_name: 'MyJob').pluck(:active_job_id)
+```
+
+## Terminated jobs
+
+When a job is terminated, SolidTerminator writes a `SolidQueue::TerminatedExecution` record so you have a queryable audit trail.
+
+### Query
+
+```ruby
+# All terminated jobs, newest first
+SolidQueue::TerminatedExecution.ordered
+
+# Filter by queue
+SolidQueue::TerminatedExecution.where(queue_name: 'critical')
+```
+
+Each record exposes: `job_id`, `queue_name`, `priority`, `terminated_at`.
+
+### Retry a terminated job
+
+Re-enqueue the original job with its original arguments:
+
+```ruby
+SolidQueue::TerminatedExecution.find_by(job_id: sq_job_id).retry
+```
+
+This destroys the `TerminatedExecution` record and enqueues a new job in a single transaction.
+
+## Configuration
+
+The generator creates `config/initializers/solid_terminator.rb` with all available options:
+
+```ruby
+SolidTerminator.configure do |config|
+  # How often the monitor thread polls for termination requests (seconds).
+  # config.polling_interval = 5  # default: 5
+
+  # Route logs to Rails.logger instead of a dedicated file.
+  # config.logger = Rails.logger
+
+  # Log file path. Ignored when config.logger is set.
+  # config.log_file = Rails.root.join("log", "solid_terminator.log")  # default
+
+  # Log verbosity. Default: Logger::INFO.
+  # Logger::DEBUG adds per-poll trace lines; Logger::WARN suppresses routine messages.
+  # config.log_level = Logger::INFO
+end
+```
+
+## Deployment topologies
+
+Works across all SolidQueue topologies without any topology-specific configuration:
+
+| Topology | Behaviour |
+|---|---|
+| Puma plugin (in-process) | Monitor starts with the worker thread pool |
+| Separate `bin/jobs` process | One monitor per `bin/jobs` instance |
+| Multiple worker processes on one host | One monitor per process; registry is process-local |
+| Multiple hosts | Works automatically — each host's workers manage their own jobs |
+
+The thread registry and `Thread#raise` always operate within the same OS process, so no cross-host signalling is needed. A termination row created on any host is picked up by whichever worker is running the job, because each monitor only queries for jobs in its own process-local registry.
+
+## Design decisions
+
+**Why a separate table instead of Redis or PostgreSQL LISTEN/NOTIFY?**
+Works with PostgreSQL, MySQL, and SQLite out of the box — no extra infrastructure required. The table is almost always empty, so polling is essentially free.
+
+**Why `Thread#raise` instead of process signals?**
+Workers run a thread pool. A signal would interrupt every thread in the process; `Thread#raise` targets exactly the right one without disturbing other jobs.
+
+**Why does `JobTerminated` inherit from `Exception` instead of `StandardError`?**
+`rescue => e` only catches `StandardError`. Inheriting from `Exception` means the termination signal propagates through typical job error-handling code without being accidentally swallowed. Jobs that do have a `rescue Exception` handler will simply receive the exception again on the next poll until they stop.
+
+**Why inherit from `SolidQueue::Record`?**
+Ensures both tables live in the same database as the rest of SolidQueue, including multi-database setups that use `connects_to`.
+
+## Roadmap
+
+Planned improvements — no particular order:
+
+**Signaling adapters**
+- Redis pub/sub adapter — lower latency for stacks that already have Redis
+- PostgreSQL `LISTEN/NOTIFY` adapter — zero extra infra for PG-only apps
+- Pluggable adapter interface so custom adapters can be dropped in
+
+**Termination control**
+- Timeout-based auto-termination — automatically terminate a job that exceeds a configured runtime
+- Grace period — wait N seconds after signaling before re-raising, allowing the job to reach a natural checkpoint
+- Bulk termination — `SolidTerminator.terminate_all!(class_name:)` or by queue name
+
+**Observability**
+- ActiveSupport notifications (`solid_terminator.terminated`, `solid_terminator.monitor_error`) for APM integration and custom hooks
+- `TerminatedExecution` retention policy and auto-cleanup of old records
+- Termination status query — `SolidTerminator.termination_pending?(active_job_id)`
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec          # run tests
+bundle exec rubocop        # lint
+bundle exec rubocop -A     # lint with auto-fix
+```
+
+## License
+
+MIT

data/lib/generators/solid_terminator/install_generator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module SolidTerminator
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path('templates', __dir__)
+
+      class_option :database,
+                   type: :string,
+                   aliases: '-d',
+                   desc: 'Target database key from database.yml (default: auto-detected from queue DB config).'
+
+      def self.next_migration_number(dirname)
+        ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def copy_migrations
+        migration_template \
+          'create_solid_queue_terminations.rb',
+          File.join(target_migrations_dir, 'create_solid_queue_terminations.rb')
+
+        migration_template \
+          'create_solid_queue_terminated_executions.rb',
+          File.join(target_migrations_dir, 'create_solid_queue_terminated_executions.rb')
+      end
+
+      def create_initializer
+        template 'initializer.rb', 'config/initializers/solid_terminator.rb'
+      end
+
+      private
+
+      def target_migrations_dir
+        db_key = options[:database] || 'queue'
+        db_config = ActiveRecord::Base.configurations.find_db_config(db_key)
+        Array(db_config&.migrations_paths).first || 'db/migrate'
+      end
+
+      def migration_version
+        "[#{ActiveRecord::Migration.current_version}]"
+      end
+    end
+  end
+end

data/lib/generators/solid_terminator/templates/create_solid_queue_terminated_executions.rb

@@ -0,0 +1,15 @@
+class CreateSolidQueueTerminatedExecutions < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :solid_queue_terminated_executions do |t|
+      t.bigint   :job_id,        null: false
+      t.integer  :priority,      default: 0, null: false
+      t.string   :queue_name,    null: false
+      t.datetime :terminated_at, null: false
+      t.datetime :created_at,    null: false
+    end
+
+    add_index :solid_queue_terminated_executions, :job_id, unique: true
+    add_index :solid_queue_terminated_executions, %i[queue_name priority job_id],
+              name: 'index_solid_queue_terminated_executions_for_filtering'
+  end
+end

data/lib/generators/solid_terminator/templates/create_solid_queue_terminations.rb

@@ -0,0 +1,10 @@
+class CreateSolidQueueTerminations < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :solid_queue_terminations do |t|
+      t.string   :active_job_id, null: false
+      t.datetime :created_at,    null: false
+    end
+
+    add_index :solid_queue_terminations, :active_job_id, unique: true
+  end
+end

data/lib/generators/solid_terminator/templates/initializer.rb

@@ -0,0 +1,14 @@
+SolidTerminator.configure do |config|
+  # How often the monitor thread polls for termination requests (seconds).
+  # config.polling_interval = 5
+
+  # Use Rails.logger (or any Logger-compatible object) instead of a dedicated file.
+  # config.logger = Rails.logger
+
+  # Log file path. Defaults to log/solid_terminator.log. Ignored when config.logger is set.
+  # config.log_file = Rails.root.join("log", "solid_terminator.log")
+
+  # Log level. Defaults to Logger::INFO.
+  # Use Logger::DEBUG for verbose output, Logger::WARN to suppress routine messages.
+  # config.log_level = Logger::INFO
+end

data/lib/solid_terminator/claimed_execution_patch.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SolidTerminator
+  module ClaimedExecutionPatch
+    def perform
+      result = execute
+      handle_result(result)
+    ensure
+      unblock_next_job
+    end
+
+    private
+
+    def handle_result(result)
+      if result.success?
+        finished
+      elsif result.error.is_a?(SolidTerminator::JobTerminated)
+        finish_terminated
+      else
+        failed_with(result.error)
+        raise result.error
+      end
+    end
+
+    def finish_terminated
+      transaction do
+        job.finished!
+        destroy!
+      end
+    end
+  end
+end

data/lib/solid_terminator/configuration.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module SolidTerminator
+  class Configuration
+    attr_accessor :polling_interval
+    attr_reader :log_file, :log_level
+
+    def initialize
+      @polling_interval = 5
+      @log_level = Logger::INFO
+    end
+
+    def log_file=(path)
+      @log_file = path
+      @logger = nil
+    end
+
+    def log_level=(level)
+      @log_level = level
+      @logger.level = level if @logger && !@external_logger
+    end
+
+    def logger=(logger)
+      @logger = logger
+      @external_logger = true
+    end
+
+    def logger
+      @logger ||= Logger.new(log_file || default_log_path).tap do |l|
+        l.progname = 'SolidTerminator'
+        l.level    = @log_level
+      end
+    end
+
+    private
+
+    def default_log_path
+      defined?(Rails) && Rails.root ? Rails.root.join('log', 'solid_terminator.log') : $stdout
+    end
+  end
+end

data/lib/solid_terminator/engine.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'rails'
+
+module SolidTerminator
+  class Engine < Rails::Engine
+    config.to_prepare do
+      require 'solid_terminator/termination'
+      require 'solid_terminator/terminated_execution'
+      require 'solid_terminator/claimed_execution_patch'
+      SolidQueue::ClaimedExecution.prepend(SolidTerminator::ClaimedExecutionPatch)
+    end
+
+    config.after_initialize do
+      if defined?(SolidQueue)
+        SolidQueue.on_worker_start { SolidTerminator.start_monitor }
+        SolidQueue.on_worker_stop  { SolidTerminator.stop_monitor }
+      end
+    end
+  end
+end

data/lib/solid_terminator/job_terminated.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SolidTerminator
+  class JobTerminated < Exception; end # rubocop:disable Lint/InheritException
+end

data/lib/solid_terminator/monitor.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module SolidTerminator
+  class Monitor
+    def initialize(interval: SolidTerminator.configuration.polling_interval)
+      @interval = interval
+      @mutex    = Mutex.new
+      @stopped  = false
+    end
+
+    def start
+      logger.info("Monitor starting (polling every #{@interval}s)")
+      @thread = Thread.new { run }
+      @thread.name = 'SolidTerminator::Monitor'
+      @thread
+    end
+
+    def stop
+      logger.info('Monitor stopping')
+      @mutex.synchronize { @stopped = true }
+      begin
+        @thread&.wakeup
+      rescue ThreadError
+        nil
+      end
+      @thread&.join(@interval + 2)
+    end
+
+    private
+
+    def stopped?
+      @mutex.synchronize { @stopped }
+    end
+
+    def run
+      retries = 0
+      until stopped?
+        check_for_terminations
+        sleep @interval
+      end
+    rescue ActiveRecord::StatementInvalid => e
+      logger.error("Monitor stopped — table missing, run migrations. #{e.message}")
+    rescue StandardError => e
+      retries = on_run_error(e, retries)
+      retry unless stopped?
+    end
+
+    def on_run_error(error, retries)
+      retries += 1
+      logger.error("Monitor error (attempt #{retries}): #{error.class}: #{error.message}. Retrying in #{@interval}s.")
+      sleep @interval
+      retries
+    end
+
+    def check_for_terminations
+      job_ids = ThreadRegistry.snapshot
+      if job_ids.nil?
+        logger.debug('Skipping — no jobs registered')
+      else
+        process_terminations(job_ids)
+        ThreadRegistry.purge_dead_threads
+      end
+    end
+
+    def process_terminations(job_ids)
+      return if job_ids.empty?
+
+      logger.debug("Checking for terminations (#{job_ids.size} job(s) registered)")
+      Termination.for_jobs(job_ids).each { |t| signal_termination(t) }
+    end
+
+    def signal_termination(termination)
+      thread = ThreadRegistry.thread_for(termination.active_job_id)
+      return if thread.nil?
+
+      return clean_stale_entry(termination) unless thread.alive?
+
+      logger.info("Raising termination on job #{termination.active_job_id}")
+      begin
+        thread.raise(JobTerminated, "Job #{termination.active_job_id} terminated")
+      rescue ThreadError
+        logger.warn("Thread for job #{termination.active_job_id} died before signal; will retry next poll")
+      end
+      # Row stays: job's ensure deletes it on clean exit; if the job swallows the exception
+      # the row persists so the monitor retries next poll rather than silently giving up.
+    end
+
+    def clean_stale_entry(termination)
+      logger.warn("Thread for job #{termination.active_job_id} is dead; cleaning up stale entry")
+      ThreadRegistry.deregister(termination.active_job_id)
+      termination.destroy
+    end
+
+    def logger
+      SolidTerminator.configuration.logger
+    end
+  end
+end

data/lib/solid_terminator/terminable.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SolidTerminator
+  module Terminable
+    extend ActiveSupport::Concern
+
+    included do
+      around_perform :with_termination_handling
+    end
+
+    private
+
+    def with_termination_handling
+      current_thread = Thread.current
+      st_logger.debug("Job #{job_id} registered for termination monitoring")
+      ThreadRegistry.register(job_id)
+      yield
+    rescue JobTerminated => e
+      on_job_terminated(current_thread, e)
+    ensure
+      ThreadRegistry.deregister(job_id, current_thread)
+      st_logger.debug("Job #{job_id} deregistered from termination monitoring")
+      cleanup_termination_row
+    end
+
+    def on_job_terminated(current_thread, error)
+      # Deregister before cleanup so the monitor does not re-raise mid-cleanup.
+      ThreadRegistry.deregister(job_id, current_thread)
+      handle_job_terminated(error)
+    end
+
+    def handle_job_terminated(error)
+      st_logger.info("Job #{job_id} terminated: #{error.message}")
+      SolidQueue::TerminatedExecution.record_termination(self)
+      raise
+    end
+
+    def cleanup_termination_row
+      Termination.where(active_job_id: job_id).delete_all
+    rescue StandardError => e
+      st_logger.error("Failed to delete termination row for job #{job_id}: #{e.class}: #{e.message}")
+    end
+
+    def st_logger
+      SolidTerminator.configuration.logger
+    end
+  end
+end

data/lib/solid_terminator/terminated_execution.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SolidQueue
+  class TerminatedExecution < SolidQueue::Execution
+    scope :ordered, -> { order(terminated_at: :desc) }
+
+    def self.record_termination(active_job)
+      sq_job = SolidQueue::Job.find_by(active_job_id: active_job.job_id)
+      return nil unless sq_job
+
+      create!(job_id: sq_job.id, queue_name: sq_job.queue_name, priority: sq_job.priority, terminated_at: Time.current)
+    rescue StandardError => e
+      SolidTerminator.configuration.logger.error(
+        "Failed to record termination for job #{active_job.job_id}: #{e.class}: #{e.message}"
+      )
+      nil
+    end
+
+    def retry
+      active_job = ActiveJob::Base.deserialize(job.arguments)
+      transaction do
+        destroy!
+        active_job.enqueue
+      end
+    end
+  end
+end

data/lib/solid_terminator/termination.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SolidTerminator
+  class Termination < SolidQueue::Record
+    self.table_name = 'solid_queue_terminations'
+
+    validates :active_job_id, presence: true, uniqueness: true
+
+    scope :for_jobs, ->(job_ids) { where(active_job_id: job_ids) }
+  end
+end

data/lib/solid_terminator/thread_registry.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SolidTerminator
+  module ThreadRegistry
+    @mutex    = Mutex.new
+    @registry = {}
+
+    class << self
+      def register(active_job_id, thread = Thread.current)
+        @mutex.synchronize { @registry[active_job_id] = thread }
+      end
+
+      def deregister(active_job_id, thread = nil)
+        @mutex.synchronize do
+          return if thread && !@registry[active_job_id].equal?(thread)
+
+          @registry.delete(active_job_id)
+        end
+      end
+
+      def thread_for(active_job_id)
+        @mutex.synchronize { @registry[active_job_id] }
+      end
+
+      def active_job_ids
+        @mutex.synchronize { @registry.keys.dup }
+      end
+
+      def snapshot
+        @mutex.synchronize do
+          return nil if @registry.empty?
+
+          @registry.keys.dup
+        end
+      end
+
+      def purge_dead_threads
+        @mutex.synchronize { @registry.delete_if { |_, t| !t.alive? } }
+      end
+
+      def empty?
+        @mutex.synchronize { @registry.empty? }
+      end
+    end
+  end
+end

data/lib/solid_terminator/version.rb

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

data/lib/solid_terminator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'active_job'
+require 'active_support'
+
+require 'solid_terminator/version'
+require 'solid_terminator/job_terminated'
+require 'solid_terminator/configuration'
+require 'solid_terminator/thread_registry'
+require 'solid_terminator/terminable'
+require 'solid_terminator/monitor'
+require 'solid_terminator/engine' if defined?(Rails::Engine)
+
+module SolidTerminator
+  @monitor_mutex = Mutex.new
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def terminate!(active_job_id)
+      configuration.logger.info("Termination requested for job #{active_job_id}")
+      Termination.create!(active_job_id: active_job_id)
+    rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => e
+      raise if e.is_a?(ActiveRecord::RecordInvalid) && !e.record.errors.of_kind?(:active_job_id, :taken)
+
+      configuration.logger.warn("Termination already requested for job #{active_job_id}")
+    end
+
+    def start_monitor
+      @monitor_mutex.synchronize do
+        return if @monitor
+
+        @monitor = Monitor.new
+        @monitor.start
+      end
+    end
+
+    def stop_monitor
+      @monitor_mutex.synchronize do
+        @monitor&.stop
+        @monitor = nil
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: solid_terminator
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Meszaros Istvan-Abel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: solid_queue
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Adds per-job termination to SolidQueue via a monitor thread and Thread#raise
+email:
+- meszarosistvan97@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/generators/solid_terminator/install_generator.rb
+- lib/generators/solid_terminator/templates/create_solid_queue_terminated_executions.rb
+- lib/generators/solid_terminator/templates/create_solid_queue_terminations.rb
+- lib/generators/solid_terminator/templates/initializer.rb
+- lib/solid_terminator.rb
+- lib/solid_terminator/claimed_execution_patch.rb
+- lib/solid_terminator/configuration.rb
+- lib/solid_terminator/engine.rb
+- lib/solid_terminator/job_terminated.rb
+- lib/solid_terminator/monitor.rb
+- lib/solid_terminator/terminable.rb
+- lib/solid_terminator/terminated_execution.rb
+- lib/solid_terminator/termination.rb
+- lib/solid_terminator/thread_registry.rb
+- lib/solid_terminator/version.rb
+homepage: https://github.com/IstvanMs/solid_terminator
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/IstvanMs/solid_terminator
+  bug_tracker_uri: https://github.com/IstvanMs/solid_terminator/issues
+  changelog_uri: https://github.com/IstvanMs/solid_terminator/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.27
+signing_key: 
+specification_version: 4
+summary: Terminate specific in-progress SolidQueue jobs without stopping the worker
+test_files: []