pgbus 0.3.3 → 0.3.4

data/config/locales/en.yml

@@ -44,6 +44,12 @@ en:
       index:
         discard_all: Discard All
         discard_all_confirm: Permanently discard all DLQ messages?
+        discard_selected: Discard Selected
+        discard_selected_confirm: Discard selected DLQ messages?
+        discarded_selected:
+          one: Discarded 1 DLQ message.
+          other: Discarded %{count} DLQ messages.
+        none_selected: No messages selected.
         retry_all: Retry All
         retry_all_confirm: Retry all DLQ messages?
         title: Dead Letter Queue
@@ -114,6 +120,9 @@ en:
         not_found: Event not found
         title: Event %{event_id}
     helpers:
+      bulk_select_all: Select all
+      bulk_select_row: Select %{id}
+      bulk_selected: selected
       paused_badge: Paused
       queue_badge:
         dlq: DLQ
@@ -216,6 +225,12 @@ en:
         discard_all: Discard All
         discard_all_confirm: Discard all failed jobs?
         discard_all_enqueued_notice: Discarded %{count} enqueued jobs and released their locks.
+        discard_selected: Discard Selected
+        discard_selected_confirm: Discard selected items?
+        discarded_selected:
+          one: Discarded 1 selected item.
+          other: Discarded %{count} selected items.
+        none_selected: No items selected.
         retry_all: Retry All
         retry_all_confirm: Retry all failed jobs?
         title: Jobs
@@ -253,18 +268,29 @@ en:
       toggle_menu: Toggle menu
     locks:
       index:
+        all_locks_discarded:
+          one: Discarded 1 lock.
+          other: Discarded %{count} locks.
         description: Active uniqueness locks preventing duplicate job execution
+        discard: Discard
+        discard_all: Discard All
+        discard_all_confirm: Permanently discard all locks? This may allow duplicate job execution.
+        discard_confirm: Discard this lock? The associated job may be enqueued again.
+        discard_selected: Discard Selected
+        discard_selected_confirm: Discard selected locks?
         empty: No active locks
-        executing: Executing
         headers:
           age: Age
-          expires: Expires
-          job_class: Job Class
           lock_key: Lock Key
-          owner: Owner
-          state: State
-        queued: Queued
-        title: Job Locks
+          msg_id: Message ID
+          queue_name: Queue
+        lock_discard_failed: Could not discard lock.
+        lock_discarded: Lock discarded.
+        locks_discarded:
+          one: Discarded 1 lock.
+          other: Discarded %{count} locks.
+        none_selected: No locks selected.
+        title: Uniqueness Keys
     outbox:
       index:
         description: Transactional outbox entries pending publication to PGMQ

data/config/locales/es.yml

@@ -239,16 +239,12 @@ es:
       index:
         description: Bloqueos de unicidad activos que impiden la ejecución duplicada del trabajo
         empty: No hay bloqueos activos
-        executing: Ejecutando
         headers:
           age: Antigüedad
-          expires: Expira
-          job_class: Clase de trabajo
           lock_key: Clave de bloqueo
-          owner: Propietario
-          state: Estado
-        queued: En cola
-        title: Bloqueos de trabajo
+          msg_id: ID de mensaje
+          queue_name: Cola
+        title: Claves de unicidad
     outbox:
       index:
         description: Entradas de bandeja de salida transaccional pendientes de publicación en PGMQ

data/config/locales/fi.yml

@@ -239,16 +239,12 @@ fi:
       index:
         description: Aktiiviset ainutlaatuisuuden lukot estävät päällekkäisen työn suorittamisen
         empty: Ei aktiivisia lukkoja
-        executing: Suoritetaan
         headers:
           age: Ikä
-          expires: Vanhenee
-          job_class: Työluokka
           lock_key: Lukon avain
-          owner: Omistaja
-          state: Tila
-        queued: Jonossa
-        title: Työn lukot
+          msg_id: Viestin tunnus
+          queue_name: Jono
+        title: Yksikäsitteisyysavaimet
     outbox:
       index:
         description: Transaktionaaliset lähetyslaatikon merkinnät odottavat julkaisua PGMQ:lle

data/config/locales/fr.yml

@@ -239,16 +239,12 @@ fr:
       index:
         description: Verrous d'unicité actifs empêchant l'exécution de travaux en double
         empty: Aucun verrou actif
-        executing: Exécution
         headers:
           age: Âge
-          expires: Expire
-          job_class: Classe de travail
           lock_key: Clé de verrou
-          owner: Propriétaire
-          state: État
-        queued: En file d'attente
-        title: Verrous de travail
+          msg_id: ID du message
+          queue_name: File
+        title: Clés d'unicité
     outbox:
       index:
         description: Entrées de boîte d'envoi transactionnelle en attente de publication vers PGMQ

data/config/locales/it.yml

@@ -239,16 +239,12 @@ it:
       index:
         description: Blocchi di unicità attivi che impediscono l'esecuzione duplicata del lavoro
         empty: Nessun blocco attivo
-        executing: In esecuzione
         headers:
           age: Età
-          expires: Scade
-          job_class: Classe del lavoro
           lock_key: Chiave di blocco
-          owner: Proprietario
-          state: Stato
-        queued: In coda
-        title: Blocchi del lavoro
+          msg_id: ID messaggio
+          queue_name: Coda
+        title: Chiavi di unicità
     outbox:
       index:
         description: Voci dell'outbox transazionali in attesa di pubblicazione su PGMQ

data/config/locales/ja.yml

@@ -239,16 +239,12 @@ ja:
       index:
         description: 重複ジョブ実行を防ぐアクティブなユニークロック
         empty: アクティブなロックはありません
-        executing: 実行中
         headers:
           age: 経過時間
-          expires: 有効期限
-          job_class: ジョブクラス
           lock_key: ロックキー
-          owner: 所有者
-          state: 状態
-        queued: キューに追加済み
-        title: ジョブロック
+          msg_id: メッセージID
+          queue_name: キュー
+        title: 一意性キー
     outbox:
       index:
         description: PGMQへの公開待ちのトランザクショナルアウトボックスエントリ

data/config/locales/nb.yml

@@ -239,16 +239,12 @@ nb:
       index:
         description: Aktive unike låser som forhindrer duplisert jobbkjøring
         empty: Ingen aktive låser
-        executing: Utfører
         headers:
           age: Alder
-          expires: Utløper
-          job_class: Jobbklasse
           lock_key: Låsenøkkel
-          owner: Eier
-          state: Status
-        queued: I kø
-        title: Jobblåser
+          msg_id: Meldings-ID
+          queue_name: Kø
+        title: Unikhetsnøkler
     outbox:
       index:
         description: Transaksjonelle utgående postkasseoppføringer som venter på publisering til PGMQ

data/config/locales/nl.yml

@@ -239,16 +239,12 @@ nl:
       index:
         description: Actieve uniekheidsvergrendelingen voorkomen dubbele taakuitvoering
         empty: Geen actieve vergrendelingen
-        executing: Uitvoeren
         headers:
           age: Leeftijd
-          expires: Verloopt
-          job_class: Taakklasse
           lock_key: Vergrendelingssleutel
-          owner: Eigenaar
-          state: Status
-        queued: In wachtrij
-        title: Taakvergrendelingen
+          msg_id: Bericht-ID
+          queue_name: Wachtrij
+        title: Uniciteitsleutels
     outbox:
       index:
         description: Transactionele uitgaande berichten wachten op publicatie naar PGMQ

data/config/locales/pt.yml

@@ -239,16 +239,12 @@ pt:
       index:
         description: Bloqueios de exclusividade ativos impedindo a execução duplicada do trabalho
         empty: Nenhum bloqueio ativo
-        executing: Executando
         headers:
           age: Idade
-          expires: Expira
-          job_class: Classe do Trabalho
           lock_key: Chave de Bloqueio
-          owner: Proprietário
-          state: Estado
-        queued: Na fila
-        title: Bloqueios de Trabalho
+          msg_id: ID da mensagem
+          queue_name: Fila
+        title: Chaves de unicidade
     outbox:
       index:
         description: Entradas da caixa de saída transacional pendentes de publicação para PGMQ

data/config/locales/sv.yml

@@ -239,16 +239,12 @@ sv:
       index:
         description: Aktiva unika lås som förhindrar duplicerad jobbexekvering
         empty: Inga aktiva lås
-        executing: Utför
         headers:
           age: Ålder
-          expires: Upphör
-          job_class: Jobbklass
           lock_key: Låsningsnyckel
-          owner: Ägare
-          state: Status
-        queued: I kö
-        title: Jobblås
+          msg_id: Meddelande-ID
+          queue_name: Kö
+        title: Unikhetsnycklar
     outbox:
       index:
         description: Transaktionella utboxposter som väntar på publicering till PGMQ

data/config/routes.rb

@@ -22,6 +22,8 @@ Pgbus::Engine.routes.draw do
       post :retry_all
       post :discard_all
       post :discard_all_enqueued
+      post :discard_selected_failed
+      post :discard_selected_enqueued
     end
   end
 
@@ -48,11 +50,20 @@ Pgbus::Engine.routes.draw do
     collection do
       post :retry_all
       post :discard_all
+      post :discard_selected
     end
   end
 
   resources :outbox, only: [:index], controller: "outbox"
-  resources :locks, only: [:index]
+  resources :locks, only: [:index] do
+    member do
+      post :discard
+    end
+    collection do
+      post :discard_selected
+      post :discard_all
+    end
+  end
   resource :insights, only: [:show], controller: "insights"
 
   get :set_locale, to: "locale#update"

data/lib/generators/pgbus/migrate_job_locks_generator.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Pgbus
+  module Generators
+    class MigrateJobLocksGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Migrate pgbus_job_locks to lightweight pgbus_uniqueness_keys table"
+
+      class_option :database,
+                   type: :string,
+                   default: nil,
+                   desc: "Use a separate database for pgbus tables (e.g. --database=pgbus)"
+
+      def create_migration_file
+        if separate_database?
+          migration_template "migrate_job_locks_to_uniqueness_keys.rb.erb",
+                             "db/pgbus_migrate/migrate_pgbus_job_locks_to_uniqueness_keys.rb"
+        else
+          migration_template "migrate_job_locks_to_uniqueness_keys.rb.erb",
+                             "db/migrate/migrate_pgbus_job_locks_to_uniqueness_keys.rb"
+        end
+      end
+
+      def display_post_install
+        say ""
+        say "Pgbus uniqueness keys migration created!", :green
+        say ""
+        say "This migration will:"
+        say "  1. Create the new pgbus_uniqueness_keys table (3 columns, 1 index)"
+        say "  2. Migrate existing locks from pgbus_job_locks"
+        say "  3. Drop the old pgbus_job_locks table (8 columns, 3 indexes)"
+        say ""
+        say "Next steps:"
+        say "  1. Run: rails db:migrate#{":#{options[:database]}" if separate_database?}"
+        say "  2. Restart pgbus: bin/pgbus start"
+        say ""
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::Migration.current_version}]"
+      end
+
+      def separate_database?
+        options[:database].present?
+      end
+    end
+  end
+end

data/lib/generators/pgbus/templates/add_uniqueness_keys.rb.erb

@@ -0,0 +1,13 @@
+class AddPgbusUniquenessKeys < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :pgbus_uniqueness_keys, id: false do |t|
+      t.string :lock_key, null: false
+      t.string :queue_name, null: false
+      t.bigint :msg_id, null: false
+      t.datetime :created_at, null: false, default: -> { "CURRENT_TIMESTAMP" }
+    end
+
+    add_index :pgbus_uniqueness_keys, :lock_key,
+      unique: true, name: "idx_pgbus_uniqueness_keys_key"
+  end
+end

data/lib/generators/pgbus/templates/migrate_job_locks_to_uniqueness_keys.rb.erb

@@ -0,0 +1,33 @@
+class MigratePgbusJobLocksToUniquenessKeys < ActiveRecord::Migration<%= migration_version %>
+  def up
+    # Create the new lightweight uniqueness keys table
+    unless table_exists?(:pgbus_uniqueness_keys)
+      create_table :pgbus_uniqueness_keys, id: false do |t|
+        t.string :lock_key, null: false
+        t.string :queue_name, null: false
+        t.bigint :msg_id, null: false
+        t.datetime :created_at, null: false, default: -> { "CURRENT_TIMESTAMP" }
+      end
+
+      add_index :pgbus_uniqueness_keys, :lock_key,
+        unique: true, name: "idx_pgbus_uniqueness_keys_key"
+    end
+
+    # Drop the old table. Require it to be empty — active locks should be
+    # drained before migrating (stop workers, let VT expire, restart).
+    if table_exists?(:pgbus_job_locks)
+      count = execute("SELECT COUNT(*) FROM pgbus_job_locks").first["count"].to_i
+      if count > 0
+        raise "pgbus_job_locks has #{count} active lock(s). " \
+              "Drain workers and wait for locks to clear before migrating."
+      end
+
+      drop_table :pgbus_job_locks
+    end
+  end
+
+  def down
+    raise ActiveRecord::IrreversibleMigration,
+          "Cannot safely reconstruct pgbus_job_locks from pgbus_uniqueness_keys"
+  end
+end

data/lib/pgbus/active_job/executor.rb

@@ -7,9 +7,10 @@ module Pgbus
     class Executor
       attr_reader :client, :config
 
-      def initialize(client: Pgbus.client, config: Pgbus.configuration)
+      def initialize(client: Pgbus.client, config: Pgbus.configuration, stat_buffer: nil)
         @client = client
         @config = config
+        @stat_buffer = stat_buffer
       end
 
       def execute(message, queue_name, source_queue: nil)
@@ -29,15 +30,14 @@ module Pgbus
         job_class = payload["job_class"]
         uniqueness_key = Uniqueness.extract_key(payload)
         uniqueness_strategy = Uniqueness.extract_strategy(payload)
-        uniqueness_ttl = payload[Uniqueness::TTL_KEY] || Uniqueness::DEFAULT_LOCK_TTL
 
         if uniqueness_key
           case uniqueness_strategy
           when :until_executed
-            # Transition the queued lock to executing state with our PID.
-            # The lock was acquired at enqueue time — now we claim ownership
-            # so the reaper can correlate it with our heartbeat.
-            Uniqueness.claim_for_execution!(uniqueness_key, ttl: uniqueness_ttl)
+            # No claim step needed — PGMQ's visibility timeout is the execution lock.
+            # The uniqueness key row was inserted at enqueue time and will be
+            # released on completion or DLQ.
+            nil
           when :while_executing
             # Acquire the lock now. If another worker is already executing
             # this job, skip it — VT will expire and it'll be retried.
@@ -96,18 +96,20 @@ module Pgbus
       def record_stat(payload, queue_name, status, start_time, message: nil)
         return unless config.stats_enabled
 
-        duration_ms = ((monotonic_now - start_time) * 1000).round
-        enqueue_latency_ms = compute_enqueue_latency(message)
-        retry_count = message ? [message.read_ct.to_i - 1, 0].max : 0
-
-        JobStat.record!(
+        attrs = {
           job_class: payload&.dig("job_class") || "unknown",
           queue_name: queue_name,
           status: status,
-          duration_ms: duration_ms,
-          enqueue_latency_ms: enqueue_latency_ms,
-          retry_count: retry_count
-        )
+          duration_ms: ((monotonic_now - start_time) * 1000).round,
+          enqueue_latency_ms: compute_enqueue_latency(message),
+          retry_count: message ? [message.read_ct.to_i - 1, 0].max : 0
+        }
+
+        if @stat_buffer
+          @stat_buffer.push(attrs)
+        else
+          JobStat.record!(**attrs)
+        end
       rescue StandardError => e
         Pgbus.logger.debug { "[Pgbus] Stat recording failed: #{e.message}" }
       end
@@ -115,18 +117,30 @@ module Pgbus
       def compute_enqueue_latency(message)
         return unless message
 
-        enqueued_at_str = message.enqueued_at
-        return unless enqueued_at_str
+        enqueued_at = message.enqueued_at
+        return unless enqueued_at
+
+        # Fast path: numeric epoch (float seconds) avoids Time.parse entirely.
+        # PGMQ returns enqueued_at as a Time or string depending on the driver.
+        case enqueued_at
+        when Numeric
+          [((Time.now.to_f - enqueued_at) * 1000).round, 0].max
+        when Time
+          [((Time.now.utc - enqueued_at.utc) * 1000).round, 0].max
+        else
+          parse_enqueue_latency_from_string(enqueued_at.to_s)
+        end
+      rescue ArgumentError, TypeError
+        nil
+      end
 
-        str = enqueued_at_str.to_s
+      def parse_enqueue_latency_from_string(str)
         # PGMQ enqueued_at is TIMESTAMPTZ (always UTC internally).
         # If the string lacks an explicit offset, assume UTC to avoid
         # misinterpretation when the system timezone is non-UTC.
         str = "#{str} UTC" unless str.match?(/[+-]\d{2}:?\d{2}\s*$|Z\s*$/i)
         enqueued_at = Time.parse(str)
         [((Time.now.utc - enqueued_at) * 1000).round, 0].max
-      rescue ArgumentError, TypeError
-        nil
       end
 
       def handle_failure(_message, _queue_name, error)

data/lib/pgbus/client.rb

@@ -76,8 +76,7 @@ module Pgbus
     def send_batch(queue_name, payloads, headers: nil, delay: 0)
       full_name = config.queue_name(queue_name)
       ensure_queue(queue_name)
-      serialized = payloads.map { |p| serialize(p) }
-      serialized_headers = headers&.map { |h| h.nil? ? nil : serialize(h) }
+      serialized, serialized_headers = serialize_batch(payloads, headers)
       Instrumentation.instrument("pgbus.client.send_batch", queue: full_name, size: payloads.size) do
         synchronized { @pgmq.produce_batch(full_name, serialized, headers: serialized_headers, delay: delay) }
       end
@@ -378,5 +377,22 @@ module Pgbus
         JSON.generate(data)
       end
     end
+
+    # Single-pass serialization of payloads and optional headers.
+    # Avoids two separate .map iterations over the same index range.
+    def serialize_batch(payloads, headers)
+      serialized = Array.new(payloads.size)
+      serialized_headers = headers ? Array.new(headers.size) : nil
+
+      payloads.each_with_index do |p, i|
+        serialized[i] = serialize(p)
+        if serialized_headers && i < headers.size
+          h = headers[i]
+          serialized_headers[i] = h.nil? ? nil : serialize(h)
+        end
+      end
+
+      [serialized, serialized_headers]
+    end
   end
 end

data/lib/pgbus/process/dispatcher.rb

@@ -144,16 +144,39 @@ module Pgbus
       end
 
       def cleanup_job_locks
-        # Primary: reap orphaned locks whose owner worker is no longer alive.
-        # Cross-references (owner_pid, owner_hostname) against pgbus_processes heartbeats.
-        reaped = JobLock.reap_orphaned!
-        Pgbus.logger.info { "[Pgbus] Reaped #{reaped} orphaned job locks" } if reaped.positive?
-
-        # Last resort: clean up locks with expired TTL (handles case where
-        # even the reaper/supervisor is dead and locks are truly abandoned).
-        expired = JobLock.cleanup_expired!
-        Pgbus.logger.debug { "[Pgbus] Cleaned up #{expired} expired job locks" } if expired.positive?
-        # No rescue here — let run_if_due handle the error and retry next tick
+        # Clean up orphaned uniqueness keys whose msg_id no longer exists
+        # in any PGMQ queue. This handles the rare case where a message is
+        # lost (e.g., queue table truncated) but the uniqueness key remains.
+        reaped = reap_orphaned_uniqueness_keys
+        Pgbus.logger.info { "[Pgbus] Reaped #{reaped} orphaned uniqueness keys" } if reaped.positive?
+      end
+
+      def reap_orphaned_uniqueness_keys
+        keys = UniquenessKey.all.to_a
+        return 0 if keys.empty?
+
+        threshold = Time.current - (config.visibility_timeout * 2)
+
+        orphaned = keys.select do |key|
+          # msg_id == 0 means pre-produce placeholder or :while_executing lock.
+          # These are live locks — never reap them based on msg_id alone.
+          # Only reap if old enough that the job is certainly gone.
+          next false if key.msg_id.zero? && (!key.created_at || key.created_at >= threshold)
+          next true if key.msg_id.zero? && key.created_at && key.created_at < threshold
+
+          # For real msg_ids, only reap if stale (old enough that VT has
+          # long expired). The message itself may still be in the queue
+          # awaiting retry — age is the only safe signal without scanning
+          # every queue table.
+          key.created_at && key.created_at < threshold
+        end
+
+        return 0 if orphaned.empty?
+
+        UniquenessKey.where(lock_key: orphaned.map(&:lock_key)).delete_all
+      rescue StandardError => e
+        Pgbus.logger.warn { "[Pgbus] Uniqueness key cleanup failed: #{e.message}" }
+        0
       end
 
       def cleanup_outbox

data/lib/pgbus/process/worker.rb

@@ -25,7 +25,8 @@ module Pgbus
         @rate_counter = RateCounter.new(:processed, :failed, :dequeued)
         @started_at = Time.current
         @started_at_monotonic = monotonic_now
-        @executor = Pgbus::ActiveJob::Executor.new
+        @stat_buffer = config.stats_enabled ? Pgbus::StatBuffer.new : nil
+        @executor = Pgbus::ActiveJob::Executor.new(stat_buffer: @stat_buffer)
         @pool = Concurrent::FixedThreadPool.new(threads)
         @circuit_breaker = Pgbus::CircuitBreaker.new(config: config)
         @queue_lock = QueueLock.new if @single_active_consumer
@@ -62,6 +63,7 @@ module Pgbus
           break if @lifecycle.draining? && @pool.queue_length.zero?
 
           claim_and_execute if @lifecycle.can_process?
+          @stat_buffer&.flush_if_due
           @wake_signal.wait(timeout: config.polling_interval) if @lifecycle.draining? || @lifecycle.paused?
         end
 
@@ -318,6 +320,7 @@ module Pgbus
         Pgbus.logger.info { "[Pgbus] Worker draining thread pool..." }
         @pool.shutdown
         @pool.wait_for_termination(30)
+        @stat_buffer&.stop
         @queue_lock&.unlock_all
         @heartbeat&.stop
         restore_signals