pgbus 0.0.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6fe52568c3e3c18afc09f3ea5f0caaad2bf90010f59740191196075a93318d8
-  data.tar.gz: e0c87f85be32e39aa62d20e48f01ca8c8b5537084ba36e3f1e5aedfde0e6ada4
+  metadata.gz: 2aad79af8c595a48d879b9bad0ebaaf43d40843cdbcb9dcc7a2dad0023257e53
+  data.tar.gz: 53bda3ba2e7d1d0f1935d183193bff5b48adeca8a4da44b6d55f9ba743e62d8e
 SHA512:
-  metadata.gz: 779ada35a2d41a76236c6fca3357aa35ee1e0133274b5aa0b4370996f56aa702ef94c271e15138c7f847bcbfeb66ff3d85d9a5220050fbc5fa0ae1ca00168624
-  data.tar.gz: 55fe48235d885182b12f58ec10db8dc89ae4039e5c929cffff6f0244f4864108ef1f4887ffccf95198358565f0d9a1aab8b834282ff5439192df17e239f2a863
+  metadata.gz: c9cfcd463d6b91591f9f037969ca1b30c2dc29ba0ce7a8eeefa829ef2b12eee71c4aba0f5b8d02b3336d6cc38b04db7cc51d749ca97774d4afa4e2246f8d6ccc
+  data.tar.gz: a50591b61b5bf49a2b5e14750622ba7ca0681d3db5f47d801542a23eb3147a8b9d5a605fcd0c55264ad4068e75f3d827ad550d2d58cd2026fa8a4351f72eea8a

data/README.md

@@ -204,8 +204,6 @@ Limit how many jobs with the same key can run concurrently:
 
 ```ruby
 class ProcessOrderJob < ApplicationJob
-  include Pgbus::Concurrency
-
   limits_concurrency to: 1,
                      key: ->(order_id) { "ProcessOrder-#{order_id}" },
                      duration: 15.minutes,
@@ -237,9 +235,45 @@ end
 ### How it works
 
 1. **Enqueue**: The adapter checks a semaphore table for the concurrency key. If under the limit, it increments the counter and sends the job to PGMQ. If at the limit, it applies the `on_conflict` strategy.
-2. **Complete**: After a job succeeds or is dead-lettered, the executor decrements the semaphore and releases the next blocked job (if any).
+2. **Complete**: After a job succeeds or is dead-lettered, the executor signals the concurrency system via an `ensure` block (guaranteeing the signal fires even if the archive step fails). It first tries to promote a blocked job (atomic delete + enqueue in a single transaction). If nothing to promote, it releases the semaphore slot.
 3. **Safety net**: The dispatcher periodically cleans up expired semaphores and orphaned blocked executions to recover from crashed workers.
 
+### Concurrency compared to other backends
+
+Pgbus, SolidQueue, GoodJob, and Sidekiq all offer concurrency controls, but with fundamentally different locking strategies and trade-offs.
+
+#### Architecture comparison
+
+| | **Pgbus** | **SolidQueue** | **GoodJob** | **Sidekiq Enterprise** |
+|---|---|---|---|---|
+| **Lock backend** | PostgreSQL rows (`pgbus_semaphores` table) | PostgreSQL rows (`solid_queue_semaphores`) | PostgreSQL advisory locks (`pg_advisory_xact_lock`) | Redis sorted sets (lease-based) |
+| **Lock granularity** | Counting semaphore (allows N concurrent) | Counting semaphore (allows N concurrent) | Count query under advisory lock | Sorted set entries with TTL |
+| **Acquire mechanism** | Atomic `INSERT ... ON CONFLICT DO UPDATE WHERE value < max` (single SQL) | `UPDATE ... SET value = value + 1 WHERE value < limit` | `pg_advisory_xact_lock` then `SELECT COUNT(*)` in rolled-back txn | Redis Lua script (atomic check-and-add) |
+| **At-limit behavior** | `:block` (hold in queue), `:discard`, or `:raise` | Blocks in `solid_queue_blocked_executions` | Enqueue: silently dropped. Perform: retry with backoff (forever) | Reschedule with backoff (raises `OverLimit`, middleware re-enqueues) |
+| **Blocked job storage** | `pgbus_blocked_executions` table with priority ordering | `solid_queue_blocked_executions` table | No blocked queue — retries via ActiveJob retry mechanism | No blocked queue — job returns to Redis queue with delay |
+| **Release on completion** | `ensure` block: promote next blocked job or decrement semaphore | Inline after `finished`/`failed_with` (inside same transaction as of PR #689) | Release advisory lock via `pg_advisory_unlock` | Lease auto-expires from sorted set |
+| **Crash recovery** | Semaphore `expires_at` + dispatcher `expire_stale` cleanup | Semaphore `expires_at` + concurrency maintenance task | Advisory locks auto-release on session disconnect | TTL-based lease expiry (default 5 min) |
+| **Message lifecycle** | PGMQ visibility timeout (`FOR UPDATE SKIP LOCKED`) — message stays in queue until archived | AR-backed `claimed_executions` table | AR-backed `good_jobs` table with advisory lock per row | Redis list + sorted set |
+
+#### Key design differences
+
+**Pgbus** uses PGMQ's native `FOR UPDATE SKIP LOCKED` for message claiming and a separate semaphore table for concurrency control. This two-layer approach means the message queue and concurrency system are independent — PGMQ handles exactly-once delivery, the semaphore handles admission control. The semaphore acquire is a single atomic SQL (`INSERT ... ON CONFLICT DO UPDATE WHERE value < max`), avoiding the need for explicit row locks.
+
+**SolidQueue** uses AR models for everything — jobs, claimed executions, and semaphores all live in PostgreSQL tables. This means the entire lifecycle can be wrapped in AR transactions. However, as documented in [rails/solid_queue#689](https://github.com/rails/solid_queue/pull/689), this model is vulnerable to race conditions when semaphore expiry, job completion, and blocked-job release interleave across transactions. Pgbus avoids several of these by design: PGMQ's visibility timeout handles message recovery without a `claimed_executions` table, and there is no "release during shutdown" codepath.
+
+**GoodJob** takes a different approach entirely: advisory locks. Each job dequeue acquires a session-level advisory lock on the job row, and concurrency checks use transaction-scoped advisory locks on the concurrency key. This means the check and the perform are serialized at the database level. The downside is that advisory locks are session-scoped — if a connection is returned to the pool without unlocking, the lock persists. GoodJob handles this by auto-releasing on session disconnect, but connection pool sharing between web and worker can cause surprising behavior.
+
+**Sidekiq Enterprise** uses Redis sorted sets with TTL-based leases. Each concurrent slot is a sorted set entry with an expiry timestamp. This is fast and simple but has no durability guarantee — Redis failover can lose leases, temporarily allowing over-limit execution. The `sidekiq-unique-jobs` gem (open-source) uses a similar Lua-script approach but with more lock strategies (`:until_executing`, `:while_executing`, `:until_and_while_executing`) and configurable conflict handlers (`:reject`, `:reschedule`, `:replace`, `:raise`).
+
+#### Race condition resilience
+
+| Scenario | Pgbus | SolidQueue | GoodJob | Sidekiq |
+|---|---|---|---|---|
+| **Worker crash mid-execution** | PGMQ visibility timeout expires → message re-read. Semaphore expires via `expire_stale`. | `claimed_execution` survives → supervisor's process pruning calls `fail_all_with`. | Advisory lock released on session disconnect. | Lease TTL expires in Redis. |
+| **Blocked job released while original still executing** | Not possible — promote only happens in `signal_concurrency`, which only runs after job success/DLQ. | Fixed in PR #689 — now checks for claimed executions before releasing. | N/A — no blocked queue; retries independently. | N/A — no blocked queue. |
+| **Archive succeeds but signal fails** | `ensure` block guarantees signal fires even if archive raises. For SIGKILL: semaphore expires via dispatcher. | Fixed in PR #689 — `unblock_next_job` moved inside same transaction as `finished`. | Advisory lock released by session disconnect. | Lease auto-expires. |
+| **Concurrent enqueue and signal race** | Semaphore acquire is a single atomic SQL — no read-then-write gap. | Fixed in PR #689 — `FOR UPDATE` lock on semaphore row serializes enqueue with signal. | `pg_advisory_xact_lock` serializes the concurrency check. | Redis Lua script is atomic. |
+
 ## Batches
 
 Coordinate groups of jobs with callbacks when all complete:

data/Rakefile

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec) do |t|
@@ -11,4 +10,102 @@ require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
+namespace :bench do
+  desc "Run serialization benchmarks"
+  task :serialization do
+    ruby "benchmarks/serialization_bench.rb"
+  end
+
+  desc "Run client operation benchmarks"
+  task :client do
+    ruby "benchmarks/client_bench.rb"
+  end
+
+  desc "Run executor benchmarks"
+  task :executor do
+    ruby "benchmarks/executor_bench.rb"
+  end
+
+  desc "Run detailed memory profiling"
+  task :memory do
+    ruby "benchmarks/memory_profile.rb"
+  end
+
+  desc "Run all benchmarks"
+  task all: %i[serialization client executor]
+end
+
+desc "Run all benchmarks"
+task bench: "bench:all"
+
+desc "Build gem and verify contents"
+task :build do
+  sh("gem build pgbus.gemspec --strict")
+  gem_file = Dir["pgbus-*.gem"].first
+  abort "Gem file not found after build" unless gem_file
+
+  sh("gem unpack #{gem_file} --target /tmp/gem-verify")
+  puts "\n=== Gem contents ==="
+  sh("find /tmp/gem-verify -type f | sort")
+  sh("rm -rf /tmp/gem-verify #{gem_file}")
+end
+
+desc "Release a new version (rake release[1.2.3] or rake release[pre])"
+task :release, [:version] do |_t, args|
+  require_relative "lib/pgbus/version"
+
+  new_version = args[:version]
+  abort "Usage: rake release[X.Y.Z] or rake release[pre]" unless new_version
+
+  dirty = `git status --porcelain`.strip
+  abort "Aborting: working directory is not clean.\n#{dirty}" unless dirty.empty?
+
+  current = Pgbus::VERSION
+  prerelease = new_version.match?(/alpha|beta|rc|pre/) || new_version == "pre"
+
+  if new_version == "pre"
+    new_version = current
+    prerelease = true
+  end
+
+  tag = "v#{new_version}"
+
+  puts "Current version: #{current}"
+  puts "New version:     #{new_version}"
+  puts "Tag:             #{tag}"
+  puts "Pre-release:     #{prerelease}"
+  puts ""
+
+  # Update version file if needed
+  version_file = "lib/pgbus/version.rb"
+  if new_version != current
+    content = File.read(version_file)
+    content.sub!(/VERSION = ".*"/, "VERSION = \"#{new_version}\"")
+    File.write(version_file, content)
+    puts "Updated #{version_file}"
+  end
+
+  # Verify gem builds cleanly
+  sh("gem build pgbus.gemspec --strict")
+  sh("rm -f pgbus-*.gem")
+
+  # Commit, push, and create release
+  if new_version != current
+    sh("git add #{version_file}")
+    sh("git commit -m 'chore: bump version to #{new_version}'")
+  end
+  sh("git push origin main")
+
+  pre_flag = prerelease ? "--prerelease" : ""
+  sh("gh release create #{tag} --generate-notes --target main #{pre_flag}".strip)
+
+  puts ""
+  puts "Release #{tag} created! CI will handle the rest:"
+  puts "  - Run tests"
+  puts "  - Build + verify gem"
+  puts "  - Sign with Sigstore"
+  puts "  - Publish to RubyGems"
+  puts "  - Upload assets to the release"
+end
+
 task default: %i[spec rubocop]

data/app/controllers/pgbus/application_controller.rb

@@ -10,6 +10,14 @@ module Pgbus
 
     helper Pgbus::ApplicationHelper
 
+    # Make `pgbus` route proxy available in views (e.g. pgbus.root_path).
+    # With isolate_namespace, the non-prefixed helpers (root_path) work inside
+    # the engine, but the views use the pgbus.* proxy form for clarity.
+    def pgbus
+      @pgbus ||= Pgbus::Engine.routes.url_helpers
+    end
+    helper_method :pgbus
+
     private
 
     def data_source

data/app/controllers/pgbus/recurring_tasks_controller.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pgbus
+  class RecurringTasksController < ApplicationController
+    def index
+      case params[:frame]
+      when "recurring_tasks"
+        @recurring_tasks = data_source.recurring_tasks
+        render_frame("pgbus/recurring_tasks/tasks_table")
+      else
+        @recurring_tasks = data_source.recurring_tasks
+      end
+    end
+
+    def show
+      @task = data_source.recurring_task(params[:id])
+      redirect_to pgbus.recurring_tasks_path, alert: "Task not found" unless @task
+    end
+
+    def toggle
+      if data_source.toggle_recurring_task(params[:id])
+        redirect_to pgbus.recurring_tasks_path, notice: "Task toggled"
+      else
+        redirect_to pgbus.recurring_tasks_path, alert: "Failed to toggle task"
+      end
+    end
+
+    def enqueue
+      if data_source.enqueue_recurring_task_now(params[:id])
+        redirect_to pgbus.recurring_tasks_path, notice: "Task enqueued"
+      else
+        redirect_to pgbus.recurring_tasks_path, alert: "Failed to enqueue task"
+      end
+    end
+  end
+end

data/app/helpers/pgbus/application_helper.rb

@@ -45,6 +45,18 @@ module Pgbus
       end
     end
 
+    def pgbus_parse_message(message)
+      return {} unless message
+
+      case message
+      when Hash then message
+      when String then JSON.parse(message)
+      else {}
+      end
+    rescue JSON::ParserError
+      {}
+    end
+
     def pgbus_json_preview(json_string, max_length: 120)
       return "—" unless json_string
 
@@ -56,6 +68,35 @@ module Pgbus
       Pgbus.configuration.web_refresh_interval
     end
 
+    def pgbus_time_ago_future(time)
+      return "—" unless time
+
+      time = Time.parse(time) if time.is_a?(String)
+      seconds = (time - Time.now).to_i
+
+      if seconds <= 0
+        "now"
+      elsif seconds < 60
+        "in #{seconds}s"
+      elsif seconds < 3600
+        "in #{seconds / 60}m"
+      elsif seconds < 86_400
+        "in #{seconds / 3600}h"
+      else
+        "in #{seconds / 86_400}d"
+      end
+    end
+
+    def pgbus_recurring_health_badge(task)
+      if task[:last_run_at].nil?
+        tag.span("Pending",
+                 class: "inline-flex items-center rounded-full bg-yellow-100 px-2.5 py-0.5 text-xs font-medium text-yellow-800")
+      else
+        tag.span("Active",
+                 class: "inline-flex items-center rounded-full bg-green-100 px-2.5 py-0.5 text-xs font-medium text-green-800")
+      end
+    end
+
     def pgbus_nav_link(label, path)
       active = request.path == path || (path != pgbus.root_path && request.path.start_with?(path))
       css = if active

data/app/models/pgbus/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Pgbus
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/pgbus/batch_entry.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pgbus
+  class BatchEntry < ApplicationRecord
+    self.table_name = "pgbus_batches"
+
+    COUNTER_COLUMNS = %w[completed_jobs discarded_jobs].freeze
+
+    scope :finished, -> { where(status: "finished") }
+    scope :stale, ->(before:) { finished.where("finished_at < ?", before) }
+
+    # Atomically increment the counter and detect if this update caused the
+    # batch to finish. Uses row-level locking to prevent duplicate callbacks.
+    # Returns { just_finished:, record: } or nil if batch not found.
+    def self.increment_counter!(batch_id, column)
+      raise ArgumentError, "Invalid column: #{column}" unless COUNTER_COLUMNS.include?(column)
+
+      transaction do
+        record = lock.find_by(batch_id: batch_id)
+        return nil unless record
+
+        record.increment!(column)
+
+        just_finished = record.completed_jobs + record.discarded_jobs == record.total_jobs
+        record.update!(status: "finished", finished_at: Time.current) if just_finished && record.status != "finished"
+
+        { record: record, just_finished: just_finished && record.status == "finished" }
+      end
+    end
+  end
+end

data/app/models/pgbus/blocked_execution.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Pgbus
+  class BlockedExecution < ApplicationRecord
+    self.table_name = "pgbus_blocked_executions"
+
+    scope :for_key, ->(key) { where(concurrency_key: key) }
+    scope :expired, ->(now = Time.current) { where("expires_at < ?", now) }
+
+    # Atomic dequeue: DELETE the highest-priority non-expired row with FOR UPDATE SKIP LOCKED.
+    # Returns { queue_name:, payload: } or nil.
+    def self.release_next!(concurrency_key)
+      now = Time.now.utc
+      result = connection.exec_query(
+        <<~SQL,
+          DELETE FROM pgbus_blocked_executions
+          WHERE id = (
+            SELECT id FROM pgbus_blocked_executions
+            WHERE concurrency_key = $1
+              AND expires_at >= $2
+            ORDER BY priority ASC, created_at ASC
+            LIMIT 1
+            FOR UPDATE SKIP LOCKED
+          )
+          RETURNING queue_name, payload
+        SQL
+        "Pgbus Blocked Release",
+        [concurrency_key, now]
+      )
+
+      row = result.first
+      return nil unless row
+
+      payload = row["payload"]
+      payload = JSON.parse(payload) if payload.is_a?(String)
+
+      { queue_name: row["queue_name"], payload: payload }
+    end
+  end
+end

data/app/models/pgbus/process_entry.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pgbus
+  class ProcessEntry < ApplicationRecord
+    self.table_name = "pgbus_processes"
+
+    scope :stale, ->(threshold) { where("last_heartbeat_at < ?", threshold) }
+  end
+end

data/app/models/pgbus/processed_event.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pgbus
+  class ProcessedEvent < ApplicationRecord
+    self.table_name = "pgbus_processed_events"
+
+    scope :expired, ->(before) { where("processed_at < ?", before) }
+  end
+end

data/app/models/pgbus/recurring_execution.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pgbus
+  class RecurringExecution < ApplicationRecord
+    self.table_name = "pgbus_recurring_executions"
+
+    validates :task_key, presence: true
+    validates :run_at, presence: true
+
+    scope :for_task, ->(key) { where(task_key: key) }
+    scope :recent, ->(limit = 50) { order(run_at: :desc).limit(limit) }
+    scope :older_than, ->(time) { where("run_at < ?", time) }
+
+    # Record a recurring execution with deduplication.
+    # Uses the unique index on (task_key, run_at) to prevent duplicates.
+    # Yields to the caller to perform the actual enqueue.
+    def self.record(task_key, run_at)
+      transaction do
+        execution = create!(task_key: task_key, run_at: run_at)
+        yield execution if block_given?
+        execution
+      end
+    rescue ActiveRecord::RecordNotUnique
+      raise Pgbus::Recurring::AlreadyRecorded,
+            "Recurring task '#{task_key}' already recorded for #{run_at.iso8601}"
+    end
+
+    # Find the most recent execution for a task
+    def self.last_execution(task_key)
+      for_task(task_key).order(run_at: :desc).first
+    end
+  end
+end

data/app/models/pgbus/recurring_task.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pgbus
+  class RecurringTask < ApplicationRecord
+    self.table_name = "pgbus_recurring_tasks"
+
+    validates :key, presence: true, uniqueness: true
+    validates :schedule, presence: true
+
+    scope :static_tasks, -> { where(static: true) }
+    scope :enabled, -> { where(enabled: true) }
+    scope :disabled, -> { where(enabled: false) }
+
+    # Sync static tasks from configuration.
+    # Creates new tasks, updates existing ones, removes stale ones.
+    def self.sync_from_config!(tasks_hash)
+      transaction do
+        task_keys = tasks_hash.keys
+
+        # Upsert all configured tasks
+        tasks_hash.each do |key, options|
+          options = options.transform_keys(&:to_s)
+          record = find_or_initialize_by(key: key)
+          record.assign_attributes(
+            class_name: options["class"],
+            command: options["command"],
+            schedule: options["schedule"],
+            queue_name: options["queue"],
+            arguments: options["args"],
+            priority: options.fetch("priority", 0).to_i,
+            description: options["description"],
+            static: true
+          )
+          record.save!
+        end
+
+        # Remove static tasks no longer in config
+        static_tasks.where.not(key: task_keys).delete_all
+      end
+    end
+  end
+end

data/app/models/pgbus/semaphore.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pgbus
+  class Semaphore < ApplicationRecord
+    self.table_name = "pgbus_semaphores"
+
+    scope :expired, ->(now = Time.current) { where("expires_at < ? OR value <= 0", now) }
+
+    # Atomic conditional UPSERT. Returns :acquired or :blocked.
+    def self.acquire!(key, max_value, expires_at)
+      result = connection.exec_query(
+        <<~SQL,
+          INSERT INTO pgbus_semaphores (key, value, max_value, expires_at)
+          VALUES ($1, 1, $2, $3)
+          ON CONFLICT (key) DO UPDATE
+            SET value = pgbus_semaphores.value + 1,
+                max_value = EXCLUDED.max_value,
+                expires_at = GREATEST(pgbus_semaphores.expires_at, EXCLUDED.expires_at)
+            WHERE pgbus_semaphores.value < EXCLUDED.max_value
+          RETURNING value
+        SQL
+        "Pgbus Semaphore Acquire",
+        [key, max_value, expires_at]
+      )
+
+      result.any? ? :acquired : :blocked
+    end
+  end
+end

data/app/views/layouts/pgbus/application.html.erb

@@ -42,6 +42,7 @@
               <%= pgbus_nav_link "Dashboard", pgbus.root_path %>
               <%= pgbus_nav_link "Queues", pgbus.queues_path %>
               <%= pgbus_nav_link "Jobs", pgbus.jobs_path %>
+              <%= pgbus_nav_link "Recurring", pgbus.recurring_tasks_path %>
               <%= pgbus_nav_link "Processes", pgbus.processes_path %>
               <%= pgbus_nav_link "Events", pgbus.events_path %>
               <%= pgbus_nav_link "DLQ", pgbus.dead_letter_index_path %>

data/app/views/pgbus/dashboard/_stats_cards.html.erb

@@ -1,5 +1,5 @@
 <turbo-frame id="dashboard-stats" data-auto-refresh src="<%= pgbus.root_path(frame: 'stats') %>">
-  <div class="grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-4 mb-8">
+  <div class="grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-5 mb-8">
     <div class="rounded-lg bg-white p-5 shadow ring-1 ring-gray-200">
       <p class="text-sm font-medium text-gray-500">Queues</p>
       <p class="mt-1 text-3xl font-semibold text-gray-900"><%= @stats[:total_queues] %></p>
@@ -18,6 +18,14 @@
       </p>
     </div>
 
+    <div class="rounded-lg bg-white p-5 shadow ring-1 ring-gray-200">
+      <p class="text-sm font-medium text-gray-500">Recurring</p>
+      <p class="mt-1 text-3xl font-semibold text-gray-900"><%= @stats[:recurring_count] %></p>
+      <p class="text-xs text-gray-400">
+        <%= link_to "View tasks", pgbus.recurring_tasks_path, class: "text-blue-500 hover:text-blue-700" %>
+      </p>
+    </div>
+
     <div class="rounded-lg bg-white p-5 shadow ring-1 ring-gray-200">
       <p class="text-sm font-medium text-gray-500">Failed / DLQ</p>
       <p class="mt-1 text-3xl font-semibold <%= (@stats[:failed_count] + @stats[:dlq_depth]) > 0 ? 'text-red-600' : 'text-gray-900' %>">

data/app/views/pgbus/dead_letter/_messages_table.html.erb

@@ -4,35 +4,72 @@
       <thead class="bg-gray-50">
         <tr>
           <th class="px-4 py-3 text-left text-xs font-medium uppercase text-gray-500">ID</th>
+          <th class="px-4 py-3 text-left text-xs font-medium uppercase text-gray-500">Job Class</th>
           <th class="px-4 py-3 text-left text-xs font-medium uppercase text-gray-500">Source Queue</th>
           <th class="px-4 py-3 text-left text-xs font-medium uppercase text-gray-500">Enqueued</th>
           <th class="px-4 py-3 text-left text-xs font-medium uppercase text-gray-500">Reads</th>
-          <th class="px-4 py-3 text-left text-xs font-medium uppercase text-gray-500">Payload</th>
-          <th class="px-4 py-3 text-right text-xs font-medium uppercase text-gray-500">Actions</th>
         </tr>
       </thead>
       <tbody class="divide-y divide-gray-100">
         <% @messages.each do |m| %>
-          <tr class="hover:bg-gray-50">
-            <td class="px-4 py-3 text-sm font-mono text-gray-900"><%= m[:msg_id] %></td>
-            <td class="px-4 py-3 text-sm text-gray-700"><%= m[:queue_name] %></td>
-            <td class="px-4 py-3 text-sm text-gray-500"><%= pgbus_time_ago(m[:enqueued_at]) %></td>
-            <td class="px-4 py-3 text-sm text-gray-500"><%= m[:read_ct] %></td>
-            <td class="px-4 py-3 text-sm text-gray-600 font-mono text-xs max-w-md truncate">
-              <%= pgbus_json_preview(m[:message]) %>
-            </td>
-            <td class="px-4 py-3 text-sm text-right space-x-2">
-              <%= button_to "Retry", pgbus.retry_dead_letter_path(m[:msg_id], queue_name: m[:queue_name]), method: :post,
-                    class: "text-xs text-indigo-600 hover:text-indigo-800 font-medium",
-                    data: { turbo_frame: "_top" } %>
-              <%= button_to "Discard", pgbus.discard_dead_letter_path(m[:msg_id], queue_name: m[:queue_name]), method: :post,
-                    class: "text-xs text-red-600 hover:text-red-800 font-medium",
-                    data: { turbo_confirm: "Permanently discard?", turbo_frame: "_top" } %>
+          <% payload = pgbus_parse_message(m[:message]) %>
+          <% dlq_suffix = Pgbus.configuration.dead_letter_queue_suffix %>
+          <% source_queue = m[:queue_name].to_s.delete_suffix(dlq_suffix) %>
+          <tr>
+            <td colspan="5" class="p-0">
+              <details class="group">
+                <summary class="flex cursor-pointer hover:bg-gray-50 list-none">
+                  <span class="w-16 shrink-0 px-4 py-3 text-sm font-mono text-gray-900"><%= m[:msg_id] %></span>
+                  <span class="flex-1 px-4 py-3 text-sm font-medium text-gray-900"><%= payload["job_class"] || "—" %></span>
+                  <span class="w-40 shrink-0 px-4 py-3 text-sm text-gray-700"><%= source_queue %></span>
+                  <span class="w-28 shrink-0 px-4 py-3 text-sm text-gray-500"><%= pgbus_time_ago(m[:enqueued_at]) %></span>
+                  <span class="w-16 shrink-0 px-4 py-3 text-sm text-gray-500"><%= m[:read_ct] %></span>
+                </summary>
+                <div class="px-4 pb-4 bg-gray-50 border-t border-gray-100">
+                  <div class="flex items-center justify-between mt-3 mb-3">
+                    <span class="text-xs font-mono text-gray-400">Job ID: <%= payload["job_id"] %></span>
+                    <div class="flex space-x-2">
+                      <%= button_to "Retry", pgbus.retry_dead_letter_path(m[:msg_id], queue_name: m[:queue_name]), method: :post,
+                            class: "rounded-md bg-indigo-600 px-3 py-1.5 text-xs font-medium text-white hover:bg-indigo-500",
+                            data: { turbo_frame: "_top" } %>
+                      <%= button_to "Discard", pgbus.discard_dead_letter_path(m[:msg_id], queue_name: m[:queue_name]), method: :post,
+                            class: "rounded-md bg-red-600 px-3 py-1.5 text-xs font-medium text-white hover:bg-red-500",
+                            data: { turbo_confirm: "Permanently discard?", turbo_frame: "_top" } %>
+                    </div>
+                  </div>
+                  <div class="grid grid-cols-2 gap-4 mb-3">
+                    <div>
+                      <span class="text-xs font-medium text-gray-500">Arguments</span>
+                      <pre class="text-xs text-gray-700 bg-white rounded p-2 mt-1 overflow-x-auto max-h-40"><%= JSON.pretty_generate(payload["arguments"] || []) rescue "—" %></pre>
+                    </div>
+                    <div>
+                      <span class="text-xs font-medium text-gray-500">Metadata</span>
+                      <div class="text-xs text-gray-600 bg-white rounded p-2 mt-1 space-y-1">
+                        <% if payload["queue_name"] %><p><strong>Queue:</strong> <%= payload["queue_name"] %></p><% end %>
+                        <% if payload["priority"] %><p><strong>Priority:</strong> <%= payload["priority"] %></p><% end %>
+                        <% if payload["executions"] %><p><strong>Executions:</strong> <%= payload["executions"] %></p><% end %>
+                        <% if m[:vt] %><p><strong>Visible at:</strong> <%= m[:vt] %></p><% end %>
+                        <% if m[:last_read_at] %><p><strong>Last read:</strong> <%= m[:last_read_at] %></p><% end %>
+                      </div>
+                    </div>
+                  </div>
+                  <details class="mt-2">
+                    <summary class="text-xs font-medium text-gray-500 cursor-pointer hover:text-gray-700">Full JSON payload</summary>
+                    <pre class="text-xs text-gray-600 bg-white rounded p-2 mt-1 overflow-x-auto max-h-96"><%= JSON.pretty_generate(payload) rescue m[:message] %></pre>
+                  </details>
+                  <% if m[:headers] %>
+                    <details class="mt-2">
+                      <summary class="text-xs font-medium text-gray-500 cursor-pointer hover:text-gray-700">Headers</summary>
+                      <pre class="text-xs text-gray-600 bg-white rounded p-2 mt-1 overflow-x-auto"><%= JSON.pretty_generate(JSON.parse(m[:headers])) rescue m[:headers] %></pre>
+                    </details>
+                  <% end %>
+                </div>
+              </details>
             </td>
           </tr>
         <% end %>
         <% if @messages.empty? %>
-          <tr><td colspan="6" class="px-4 py-8 text-center text-sm text-gray-400">Dead letter queue is empty</td></tr>
+          <tr><td colspan="5" class="px-4 py-8 text-center text-sm text-gray-400">Dead letter queue is empty</td></tr>
         <% end %>
       </tbody>
     </table>