postburner 1.0.0.rc.2 → 1.0.0.rc.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87f24f24d68086fe55b2fe315d36bc3ec9104a242066d6a78f5b61e2633f673d
-  data.tar.gz: 9ed74afc5b63a477ee254e4812f1db19fd7d9c94064afa7084d5ec6d62ee7af9
+  metadata.gz: fc5a8c616b4bf393b03fdc5d2bef57eb03e1a9b9dc06fe592f89b3d1238c2606
+  data.tar.gz: 40fe3028ce331e7ecbc6facb5829b845272ce66c14578cdd12b79a4495de85ce
 SHA512:
-  metadata.gz: a1a9bca8fe3cc955cb9f60c6f459cf3514bfe127806c7dda710cdd0e89822b1d398887b72d23c1f414deb5575621d829e7496f51ac6491485e9444190e70f8f6
-  data.tar.gz: d916eaaa41debc35e5460b9360e1bb5717bc93a1b16d180d774dd2a49b3fd106ffb1a80ee0c74595eb9b42939669273e623fac460e75d5c1706b2ccab23b834f
+  metadata.gz: 2e3095d5efd3761db840b44461f42f127269608a6070ead2e9b5751054e3875e11098d34ac9232237baa27350ec46fbf8413a80adde99feae0115bedd9b08e68
+  data.tar.gz: 3a38ad87ba8692bae49462dbf6ac8e0013cb64209200c44201a25e5cb5d2c73ea14719753f279da4ce7da016d1af581a446bec7ad97af035f4884d645c12fefe

data/CHANGELOG.md

@@ -1,5 +1,73 @@
 # Changelog
 
+## v1.0.0.rc.4 - 2026-06-10
+
+### Added
+- `Postburner::OrphanedJob` — inert STI placeholder loaded when a row's `type` column references a deleted or renamed class. Prevents `ActiveRecord::SubclassNotFound` from crashing callers (e.g. the admin queued-jobs index). `perform` and `queue!`/`requeue!` raise `Postburner::Job::OrphanedJobError`. `readonly?` returns `true` to prevent Rails' `ensure_proper_type` from overwriting the original `type` string. `remove!` (soft-delete) and `destroy` still work. No migration required.
+- `Postburner::Job::OrphanedJobError` — raised by `OrphanedJob#perform` and `#queue!`/`#requeue!`.
+- `Postburner::Job#orphaned?` — predicate; always `false` on the base class, `true` on `OrphanedJob`.
+- `Postburner::Job.find_sti_class` override — rescues `ActiveRecord::SubclassNotFound` and returns `Postburner::OrphanedJob` instead.
+- Partial indexes on `postburner_jobs` (`idx_pbjobs_active_run_at`, `idx_pbjobs_processed`, `idx_pbjobs_unqueued`) tuned to the admin UI's default queries, keeping the jobs list fast on large tables.
+- `JobsController#index` now accepts a `scope` param (`active`, `processed`, `unqueued`, `all`) and defaults to `active`, so the default page load matches the `idx_pbjobs_active_run_at` predicate.
+
+### Changed
+- `postburner_jobs.lag` is now `bigint` instead of `integer`, to avoid overflow on jobs that sit in the queue long enough to exceed the 32-bit range.
+
+### Upgrade notes
+- This is a **template mutation**, not an additive migration. Existing rc.x installs will need to either re-run `rails generate postburner:install` (and merge the migration by hand) or manually add an equivalent migration that creates the three partial indexes. Failing to do either is **non-catastrophic** — the admin UI will simply remain slow on large `postburner_jobs` tables until the indexes are in place.
+- The `lag` column type change (`integer` → `bigint`) is also a template mutation. Existing installs should add a migration along the lines of `change_column :postburner_jobs, :lag, :bigint` to avoid overflow once lag values exceed the 32-bit range.
+
+Example migration covering both the `lag` widening and the three partial indexes:
+
+```ruby
+class UpgradePostburnerJobsForRc4 < ActiveRecord::Migration[7.2]
+  disable_ddl_transaction!
+
+  def up
+    # Widen lag to bigint to avoid 32-bit overflow on long-queued jobs.
+    # ~24.9 days -> ~292.5 million years
+    change_column :postburner_jobs, :lag, :bigint
+
+    # Partial indexes tuned to the admin UI's default queries.
+    add_index :postburner_jobs, :run_at,
+      name: 'idx_pbjobs_active_run_at',
+      where: '(processed_at IS NULL AND removed_at IS NULL AND queued_at IS NOT NULL)',
+      algorithm: :concurrently
+
+    add_index :postburner_jobs, :processed_at,
+      name: 'idx_pbjobs_processed',
+      order: { processed_at: :desc },
+      where: '(processed_at IS NOT NULL)',
+      algorithm: :concurrently
+
+    add_index :postburner_jobs, [:removed_at, :created_at],
+      name: 'idx_pbjobs_unqueued',
+      order: { created_at: :desc },
+      where: '(queued_at IS NULL AND removed_at IS NULL)',
+      algorithm: :concurrently
+  end
+
+  def down
+    remove_index :postburner_jobs, name: 'idx_pbjobs_unqueued', algorithm: :concurrently
+    remove_index :postburner_jobs, name: 'idx_pbjobs_processed', algorithm: :concurrently
+    remove_index :postburner_jobs, name: 'idx_pbjobs_active_run_at', algorithm: :concurrently
+
+    change_column :postburner_jobs, :lag, :integer
+  end
+end
+```
+
+Notes:
+- `disable_ddl_transaction!` + `algorithm: :concurrently` is recommended for production tables of any size — it builds the indexes without holding a long write lock. Drop both if you're on a small dev table and want a single transactional migration.
+- `change_column ... :bigint` on PostgreSQL is an in-place type widening for `integer → bigint` and is fast (no full table rewrite), but it does take a brief `ACCESS EXCLUSIVE` lock — schedule accordingly on hot tables.
+- Adjust `ActiveRecord::Migration[7.2]` to match your app's Rails version.
+
+## v1.0.0.rc.3
+
+## v1.0.0.rc.2
+
+## v1.0.0.rc.1
+
 ## v0.7.0 - 2022-10-24
 
 ### Added

data/README.md

@@ -85,7 +85,7 @@ bundle exec rake postburner:work WORKER=default
 
 ## Table of Contents
 
-- [Why](#why)
+- [Why Postburner?](#why-postburner)
 - [Quick Start](#quick-start)
 - [Usage](#usage)
   - [Standard Jobs](#standard-jobs)
@@ -106,7 +106,7 @@ bundle exec rake postburner:work WORKER=default
 - [Installation](#installation)
 - [Web UI - v2 Coming Soon](#web-ui)
 
-## Why
+## Why Postburner?
 
 Postburner supports Async, Queues, Delayed, Priorities, Timeouts, and Retries from the [Backend Matrix](https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html). But uniquely, priorities are per job, in addition to the class level. Timeouts are per job and class level as well, and can be extended dynamically. Postburner also supports scheduling jobs at fixed intervals, cron expressions, and calendar-aware anchor points.
 
@@ -927,6 +927,53 @@ test "tracked job logs execution" do
 end
 ```
 
+### Testing Emails
+
+Standard ActiveJob test assertions (`assert_enqueued_emails`, `assert_enqueued_jobs`) work when using the `:test` ActiveJob adapter in your test environment, which is the Rails default:
+
+```ruby
+class EmailTest < ActiveSupport::TestCase
+  # assert_enqueued_emails works — Rails' :test adapter tracks the enqueue
+  test "welcome email is enqueued" do
+    assert_enqueued_emails 1 do
+      UserMailer.welcome(user).deliver_later
+    end
+  end
+
+  # assert_emails works — the job executes inline, delivering the email
+  test "welcome email is sent" do
+    assert_emails 1 do
+      SendWelcomeEmail.perform_later(user.id)
+    end
+  end
+end
+```
+
+**How this works:** `assert_enqueued_emails` and `assert_enqueued_jobs` are powered by Rails' `:test` ActiveJob adapter, which tracks enqueued jobs in an in-memory array. Postburner's queue strategies (`InlineTestQueue`, etc.) control `Postburner::Job` subclasses separately. The two systems coexist — ActiveJob assertions use the `:test` adapter, `Postburner::Job` assertions use database queries.
+
+By default, Rails uses the `:test` adapter in test mode unless you override it. Since you set `:postburner` as your adapter in `config/application.rb`, you should set it back to `:test` for your test environment:
+
+```ruby
+# config/environments/test.rb
+config.active_job.queue_adapter = :test
+```
+
+This is standard practice for any ActiveJob adapter (Sidekiq, SolidQueue, etc.) — the production adapter handles real execution, and the `:test` adapter enables Rails' built-in assertion helpers. Without this, `assert_enqueued_emails` will not work because Postburner's adapter executes jobs rather than tracking them in an array.
+
+**`Postburner::Mailer`** bypasses ActiveJob entirely, so `assert_enqueued_emails` cannot see these jobs regardless of adapter. Assert on side effects instead:
+
+```ruby
+test "mailer job sends email" do
+  job = Postburner::Mailer.delivery(UserMailer, :welcome).with(user_id: 1)
+
+  assert_emails 1 do
+    job.queue!  # Executes inline in test mode, delivering the email
+  end
+
+  assert job.reload.processed_at
+end
+```
+
 ### Switching Queue Strategies
 
 For tests requiring specific queue behaviors, use `switch_queue_strategy!` and `restore_queue_strategy!`:
@@ -2031,13 +2078,15 @@ Postburner uses [Beaneater](https://github.com/beanstalkd/beaneater) as the Ruby
 
 ### Connection Methods
 
+Postburner uses **thread-local connections** — each thread gets its own Beanstalkd socket, matching the pattern used by worker threads. This is safe under multi-threaded servers like Puma.
+
 ```ruby
-# Get a cached Beaneater connection (returns Beaneater instance)
+# Get the thread-local Beaneater connection (returns Beaneater instance)
 conn = Postburner.connection
 conn.tubes.to_a      # List all tubes
 conn.beanstalk.stats # Server statistics
 
-# Block form - yields connection, recommended for one-off operations
+# Block form - yields thread-local connection
 Postburner.connected do |conn|
   conn.tubes.to_a  # List all tubes
   conn.tubes['postburner.production.critical'].stats
@@ -2045,6 +2094,19 @@ Postburner.connected do |conn|
 end
 ```
 
+**Shutdown cleanup:**
+
+On process shutdown, call `disconnect_all!` to close every thread's connection cleanly:
+
+```ruby
+# config/puma.rb
+on_worker_shutdown do
+  Postburner.disconnect_all!
+end
+```
+
+This is optional — Ruby closes sockets on process exit — but gives you clean logs and explicit teardown.
+
 ### Job-Level Access
 
 ```ruby
@@ -2248,7 +2310,7 @@ beanstalkd -l 127.0.0.1 -p 11300 -b /var/lib/beanstalkd
 
 ```ruby
 # Gemfile
-gem 'postburner', '~> 1.0.0.pre.18'
+gem 'postburner', '~> 1.0.0.rc.2
 ```
 
 ```bash

data/app/controllers/postburner/jobs_controller.rb

@@ -2,12 +2,41 @@ require_dependency "postburner/application_controller"
 
 module Postburner
   class JobsController < ApplicationController
+    # Scopes align with the partial indexes defined in the install
+    # migration. Keeping the controller's default query matched to an
+    # index predicate keeps the admin UI fast on large tables.
+    SCOPES = %w[ active processed unqueued all ].freeze
+    DEFAULT_SCOPE = 'active'.freeze
+
     def index
-      @jobs = Job.order(queued_at: :desc, created_at: :desc)
+      @scope = SCOPES.include?(params[:scope]) ? params[:scope] : DEFAULT_SCOPE
+      @jobs = scoped_jobs(@scope)
     end
 
     def show
       @job = Job.find(params[:id])
     end
+
+    private
+
+    def scoped_jobs(scope)
+      case scope
+      when 'active'
+        # Uses idx_pbjobs_active_run_at
+        Job.where(processed_at: nil, removed_at: nil)
+           .where.not(queued_at: nil)
+           .order(run_at: :asc)
+      when 'processed'
+        # Uses idx_pbjobs_processed
+        Job.where.not(processed_at: nil)
+           .order(processed_at: :desc)
+      when 'unqueued'
+        # Uses idx_pbjobs_unqueued
+        Job.where(queued_at: nil, removed_at: nil)
+           .order(created_at: :desc)
+      else
+        Job.order(queued_at: :desc, created_at: :desc)
+      end
+    end
   end
 end

data/app/models/postburner/job.rb

@@ -88,6 +88,30 @@ module Postburner
 
     validates :sid, presence: {strict: true}
 
+    # Resolves an STI type name to a class, falling back to OrphanedJob when the
+    # original class no longer exists. This tolerates rows whose `type` column
+    # references a deleted or renamed job class, preventing
+    # ActiveRecord::SubclassNotFound from crashing callers (e.g. the admin
+    # queued-jobs page).
+    #
+    # @param type_name [String] The value stored in the `type` column
+    # @return [Class] The resolved class, or {Postburner::OrphanedJob} if missing
+    #
+    def self.find_sti_class(type_name)
+      super
+    rescue ActiveRecord::SubclassNotFound
+      Postburner::OrphanedJob
+    end
+
+    # Returns whether this job instance is an orphaned placeholder.
+    #
+    # Always false on the base class. Overridden to return true in
+    # {Postburner::OrphanedJob}.
+    #
+    # @return [Boolean]
+    #
+    def orphaned? = false
+
     # Abstract method to be implemented by subclasses.
     #
     # This method contains the actual work logic for the job. It is called
@@ -220,6 +244,15 @@ module Postburner
     #
     class AlreadyProcessed < StandardError; end
 
+    # Exception raised when attempting to perform or enqueue an orphaned job whose
+    # original class no longer exists in the application.
+    #
+    # @example
+    #   job = Postburner::Job.find(id)  # loads as OrphanedJob if class is gone
+    #   job.perform  # => raises OrphanedJobError
+    #
+    class OrphanedJobError < StandardError; end
+
     # Exception raised when a job is executed before its scheduled run_at time.
     #
     # In production (Queue/NiceQueue), this is handled by re-inserting with delay.

data/app/models/postburner/mailer.rb

@@ -50,6 +50,20 @@ module Postburner
   # @example Queue to specific queue
   #   Postburner::Mailer.delivery(UserMailer, :welcome).with(user_id: 1).queue!(queue: 'bulk_mailers')
   #
+  # == Testing
+  #
+  # Because Postburner::Mailer bypasses ActiveJob, Rails' +assert_enqueued_emails+
+  # will not detect these jobs. Use +assert_emails+ (which checks actual deliveries)
+  # or assert on the job record:
+  #
+  #   # Assert email was delivered (inline in test mode)
+  #   assert_emails 1 do
+  #     Postburner::Mailer.delivery(UserMailer, :welcome).with(user_id: 1).queue!
+  #   end
+  #
+  #   # Assert job was processed
+  #   assert job.reload.processed_at
+  #
   # @see Postburner::Job Base class for tracked jobs
   # @see Postburner::Configuration#default_mailer_queue Configuration option
   class Mailer < Job

data/app/models/postburner/orphaned_job.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Postburner
+  # Inert STI placeholder loaded when a Postburner::Job row's `type` column
+  # references a class that no longer exists in the application.
+  #
+  # ## Why readonly?
+  #
+  # Rails' `ensure_proper_type` (called via `save`/`update`) would overwrite the
+  # original `type` value with `'Postburner::OrphanedJob'`, permanently destroying
+  # the record of which class was missing. `readonly?` returning true prevents all
+  # `save`/`update` paths and therefore blocks `ensure_proper_type` from running.
+  #
+  # Rails' `instantiate` reads the `type` column verbatim when loading records from
+  # the database and does NOT call `ensure_proper_type`, so the original class name
+  # is preserved on load. This class is only ever instantiated via the
+  # `find_sti_class` fallback in {Postburner::Job}, never created directly.
+  #
+  # ## Why remove! is overridden here
+  #
+  # In Rails 8.1+, `update_column` respects `readonly?` and raises
+  # `ActiveRecord::ReadOnlyRecord`. The base `Commands#remove!` calls
+  # `update_column(:removed_at, ...)` — so it would be blocked too. This subclass
+  # overrides `remove!` to use `self.class.where(id: self.id).update_all(...)` which
+  # operates at the relation level (bypasses both `readonly?` and all instance
+  # callbacks) while still soft-deleting the row. Admins can therefore safely
+  # soft-remove orphaned rows without restoring the missing class.
+  #
+  # ## Usage
+  #
+  # This class is loaded automatically by {Postburner::Job.find_sti_class} when a
+  # row's type is unresolvable. You should never instantiate it directly in
+  # application code.
+  #
+  # @example Typical lifecycle
+  #   # A DB row exists with type: 'Flex::TriggerNoShowDeliveriesJob' (class deleted)
+  #   job = Postburner::Job.find(42)
+  #   job.class         # => Postburner::OrphanedJob
+  #   job.type          # => 'Flex::TriggerNoShowDeliveriesJob'
+  #   job.orphaned?     # => true
+  #   job.missing_class_name  # => 'Flex::TriggerNoShowDeliveriesJob'
+  #   job.perform             # => raises Postburner::Job::OrphanedJobError
+  #   job.remove!             # soft-deletes fine despite readonly?
+  #
+  class OrphanedJob < Job
+    # Returns the original class name stored in the `type` column — the deleted
+    # or renamed class that this placeholder stands in for.
+    #
+    # @return [String]
+    #
+    def missing_class_name
+      self.type.to_s
+    end
+
+    # Always true; identifies this instance as an orphaned placeholder.
+    #
+    # @return [Boolean]
+    #
+    def orphaned? = true
+
+    # Raises {Postburner::Job::OrphanedJobError} because the original job class
+    # no longer exists and there is no implementation to run.
+    #
+    # @raise [Postburner::Job::OrphanedJobError] always
+    #
+    def perform(*)
+      raise Postburner::Job::OrphanedJobError,
+        "Cannot perform orphaned job ##{self.id}: class '#{self.missing_class_name}' no longer exists"
+    end
+
+    # Raises {Postburner::Job::OrphanedJobError} because re-enqueuing a job whose
+    # class is gone would only produce another unperformable entry.
+    #
+    # @raise [Postburner::Job::OrphanedJobError] always
+    #
+    def queue!(*)
+      raise Postburner::Job::OrphanedJobError,
+        "Cannot enqueue orphaned job ##{self.id}: class '#{self.missing_class_name}' no longer exists"
+    end
+    alias_method :requeue!, :queue!
+
+    # Soft-deletes this orphaned row by setting `removed_at`, bypassing the
+    # `readonly?` guard via a relation-level `update_all` call (which does not go
+    # through instance save/update and therefore does not trigger
+    # `ensure_proper_type` either).
+    #
+    # Idempotent: does nothing if already removed.
+    #
+    # @return [void]
+    #
+    def remove!
+      return if self.removed_at
+
+      self.delete!
+      now = Time.current
+      self.class.where(id: self.id).update_all(removed_at: now)
+      self.removed_at = now
+    end
+
+    # Prevents saves that would allow Rails' ensure_proper_type to overwrite the
+    # original `type` value with 'Postburner::OrphanedJob'.
+    #
+    # @return [Boolean] always true
+    #
+    def readonly? = true
+  end
+end

data/app/models/postburner/schedule.rb

@@ -366,6 +366,11 @@ module Postburner
 
       execution.save!
 
+      # Reload so instrumented timestamps reflect persisted (microsecond)
+      # precision rather than the in-memory nanosecond values, matching what
+      # consumers see after a DB roundtrip (see #enqueue! reload below).
+      execution.reload
+
       # Instrument execution creation
       ActiveSupport::Notifications.instrument('create.schedule_execution.postburner', {
         schedule: Postburner::Instrumentation.schedule_payload(self),

data/lib/generators/postburner/install/install_generator.rb

@@ -1,3 +1,5 @@
+require 'time'
+
 class Postburner::InstallGenerator < Rails::Generators::Base
   source_root File.expand_path('templates', __dir__)
   include Rails::Generators::Migration
@@ -28,11 +30,15 @@ class Postburner::InstallGenerator < Rails::Generators::Base
     _max = timestamps.max || timestamp[-2..-1].to_i
     _next = _max + 1
     raise "MISSING NEXT" if _next.blank?
-    migration_number = "#{stem}#{_next}"
-    if migration_number.length != 14
-      raise "INCORRECT LENGTH stem=#{stem} _next=#{_next} _max=#{_max}"
+
+    # When seconds overflow past 99, roll forward by 1 minute and reset.
+    if _next > 99
+      rolled = Time.parse("#{stem}00 UTC") + 60
+      stem = rolled.strftime('%Y%m%d%H%M')
+      _next = 0
     end
-    migration_number
+
+    "#{stem}#{_next.to_s.rjust(2, '0')}"
   end
 
   private

data/lib/generators/postburner/install/templates/migrations/create_postburner_jobs.rb.erb

@@ -13,7 +13,7 @@ class CreatePostburnerJobs < ActiveRecord::Migration<%= migration_version %>
       t.datetime :processing_at
       t.datetime :processed_at
       t.datetime :removed_at
-      t.integer :lag
+      t.bigint :lag
       t.integer :duration
       t.integer :attempt_count
       t.integer :error_count
@@ -37,6 +37,22 @@ class CreatePostburnerJobs < ActiveRecord::Migration<%= migration_version %>
       t.index [ :error_count ]
       t.index [ :log_count ]
 
+      # Partial indexes tuned to the admin UI's default queries. Kept
+      # alongside the single-column indexes above: the single-column
+      # indexes still serve ad-hoc queries, while these partials keep
+      # the hot-path listing queries fast on large tables.
+      t.index :run_at,
+        name: 'idx_pbjobs_active_run_at',
+        where: 'processed_at IS NULL AND removed_at IS NULL AND queued_at IS NOT NULL'
+      t.index :processed_at,
+        name: 'idx_pbjobs_processed',
+        order: { processed_at: :desc },
+        where: 'processed_at IS NOT NULL'
+      t.index [ :removed_at, :created_at ],
+        name: 'idx_pbjobs_unqueued',
+        order: { created_at: :desc },
+        where: 'queued_at IS NULL AND removed_at IS NULL'
+
       # Add these or more depending on what you want to search for.
       #t.index [ :attempts ], using: :gin
       #t.index [ :errata ], using: :gin

data/lib/postburner/version.rb

@@ -1,3 +1,3 @@
 module Postburner
-  VERSION = '1.0.0.rc.2'
+  VERSION = '1.0.0.rc.4'
 end

data/lib/postburner.rb

@@ -319,31 +319,31 @@ module Postburner
   #   conn = Postburner.connection
   #   conn.tubes['my.tube'].stats
   #
-  # @note Connection is cached in @_connection instance variable
+  # @note Connection is cached in Thread.current[:postburner_connection] (thread-local)
   # @note Automatically reconnects if connection is not active
   #
   # @see #connected
   #
   def self.connection
-    @_connection ||= Postburner::Connection.new
-    @_connection.reconnect! unless @_connection.connected?
-    @_connection
+    Thread.current[:postburner_connection] ||= Postburner::Connection.new
+    conn = Thread.current[:postburner_connection]
+    conn.reconnect! unless conn.connected?
+    conn
   end
 
   # Yields a Beanstalkd connection or returns cached connection.
   #
-  # When called with a block, yields the connection and ensures it's closed
-  # after the block completes. When called without a block, returns the
-  # cached connection.
+  # When called with a block, yields the thread-local connection.
+  # When called without a block, returns the thread-local connection.
   #
   # @overload connected
   #   Returns the cached Beanstalkd connection.
   #   @return [Postburner::Connection] Beanstalkd connection
   #
   # @overload connected {|conn| ... }
-  #   Yields connection and ensures cleanup.
+  #   Yields connection for the duration of the block.
   #   @yieldparam conn [Postburner::Connection] Beanstalkd connection
-  #   @return [void]
+  #   @return [Object] return value of the block
   #
   # @example With block (recommended)
   #   Postburner.connected do |conn|
@@ -351,7 +351,6 @@ module Postburner
   #       puts tube.name
   #     end
   #   end
-  #   # Connection automatically closed
   #
   # @example Without block
   #   conn = Postburner.connected
@@ -364,19 +363,44 @@ module Postburner
   #   end
   #
   # @see #connection
+  # @see #disconnect_all!
   #
   def self.connected
     if block_given?
-      begin
-        yield connection
-      ensure
-        connection.close if connection
-      end
+      yield connection
     else
       connection
     end
   end
 
+  # Closes and clears Beanstalkd connections on all known threads.
+  #
+  # Call this on worker shutdown to release sockets cleanly. Because connections
+  # are thread-local, a single `connection.close` call from the main thread would
+  # only close that thread's socket. This method iterates every live thread and
+  # closes each thread's connection, if any.
+  #
+  # @return [void]
+  #
+  # @example Puma worker shutdown (config/puma.rb)
+  #   on_worker_shutdown do
+  #     Postburner.disconnect_all!
+  #   end
+  #
+  def self.disconnect_all!
+    Thread.list.each do |thread|
+      if (conn = thread[:postburner_connection])
+        begin
+          conn.close if conn.respond_to?(:close) && conn.connected?
+        rescue => e
+          warn "Postburner: failed to close connection on shutdown: #{e.message}" if $VERBOSE
+        ensure
+          thread[:postburner_connection] = nil
+        end
+      end
+    end
+  end
+
   # Clears jobs from specified tubes or shows stats for all tubes.
   #
   # High-level method with formatted output. Delegates to Connection#clear_tubes!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: postburner
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc.2
+  version: 1.0.0.rc.4
 platform: ruby
 authors:
 - Matt Smith
@@ -138,6 +138,7 @@ files:
 - app/models/postburner/application_record.rb
 - app/models/postburner/job.rb
 - app/models/postburner/mailer.rb
+- app/models/postburner/orphaned_job.rb
 - app/models/postburner/schedule.rb
 - app/models/postburner/schedule_execution.rb
 - app/models/postburner/tracked_job.rb