pgbus 0.2.9 → 0.3.1

data/config/locales/fr.yml

@@ -179,6 +179,8 @@ fr:
         title: Travaux en file d'attente
         discard: Rejeter
         discard_confirm: Rejeter ce message ?
+        discard_all: Tout supprimer
+        discard_all_confirm: Supprimer tous les travaux en file d'attente et libérer leurs verrous ? Cette action est irréversible.
         retry: Réessayer
         retry_confirm: Réinitialiser le délai de visibilité et réessayer ?
       failed_table:
@@ -197,6 +199,7 @@ fr:
       index:
         discard_all: Tout ignorer
         discard_all_confirm: Ignorer tous les travaux échoués ?
+        discard_all_enqueued_notice: "%{count} travaux en file d'attente supprimés et verrous libérés."
         retry_all: Tout réessayer
         retry_all_confirm: Réessayer tous les travaux échoués ?
         title: Travaux

data/config/locales/it.yml

@@ -179,6 +179,8 @@ it:
         title: Lavori in coda
         discard: Scarta
         discard_confirm: Scartare questo messaggio?
+        discard_all: Scarta tutti
+        discard_all_confirm: Scartare tutti i lavori in coda e rilasciare i relativi blocchi? Questa azione non può essere annullata.
         retry: Riprova
         retry_confirm: Reimpostare il timeout di visibilità e riprovare?
       failed_table:
@@ -197,6 +199,7 @@ it:
       index:
         discard_all: Scarta Tutto
         discard_all_confirm: Scartare tutti i lavori falliti?
+        discard_all_enqueued_notice: Scartati %{count} lavori in coda e rilasciati i relativi blocchi.
         retry_all: Riprova Tutto
         retry_all_confirm: Riprova tutti i lavori falliti?
         title: Lavori

data/config/locales/ja.yml

@@ -179,6 +179,8 @@ ja:
         title: キューに入れられたジョブ
         discard: 破棄
         discard_confirm: このメッセージを破棄しますか？
+        discard_all: すべて破棄
+        discard_all_confirm: キュー内のすべてのジョブを破棄し、ロックを解放しますか？この操作は元に戻せません。
         retry: リトライ
         retry_confirm: 可視性タイムアウトをリセットしてリトライしますか？
       failed_table:
@@ -197,6 +199,7 @@ ja:
       index:
         discard_all: すべて破棄
         discard_all_confirm: すべての失敗したジョブを破棄しますか？
+        discard_all_enqueued_notice: "%{count}件のキュー内ジョブを破棄し、ロックを解放しました。"
         retry_all: すべてリトライ
         retry_all_confirm: すべての失敗したジョブをリトライしますか？
         title: ジョブ

data/config/locales/nb.yml

@@ -179,6 +179,8 @@ nb:
         title: Kølagte jobber
         discard: Forkast
         discard_confirm: Forkaste denne meldingen?
+        discard_all: Forkast alle
+        discard_all_confirm: Forkast alle køede jobber og frigi låsene? Dette kan ikke angres.
         retry: Prøv igjen
         retry_confirm: Tilbakestill synlighetstidsavbrudd og prøv igjen?
       failed_table:
@@ -197,6 +199,7 @@ nb:
       index:
         discard_all: Forkast alle
         discard_all_confirm: Forkast alle mislykkede jobber?
+        discard_all_enqueued_notice: Forkastet %{count} køede jobber og frigitt låsene.
         retry_all: Prøv alle på nytt
         retry_all_confirm: Prøv alle mislykkede jobber på nytt?
         title: Jobber

data/config/locales/nl.yml

@@ -179,6 +179,8 @@ nl:
         title: Taken in de wachtrij
         discard: Verwerpen
         discard_confirm: Dit bericht verwerpen?
+        discard_all: Alles verwijderen
+        discard_all_confirm: Alle taken in de wachtrij verwijderen en hun vergrendelingen vrijgeven? Dit kan niet ongedaan worden gemaakt.
         retry: Opnieuw proberen
         retry_confirm: Zichtbaarheidstimeout resetten en opnieuw proberen?
       failed_table:
@@ -197,6 +199,7 @@ nl:
       index:
         discard_all: Alles Verwijderen
         discard_all_confirm: Alle mislukte taken verwijderen?
+        discard_all_enqueued_notice: "%{count} taken in de wachtrij verwijderd en vergrendelingen vrijgegeven."
         retry_all: Alles Opnieuw Proberen
         retry_all_confirm: Alle mislukte taken opnieuw proberen?
         title: Taken

data/config/locales/pt.yml

@@ -179,6 +179,8 @@ pt:
         title: Trabalhos Enfileirados
         discard: Descartar
         discard_confirm: Descartar esta mensagem?
+        discard_all: Descartar todos
+        discard_all_confirm: Descartar todos os trabalhos na fila e liberar seus bloqueios? Esta ação não pode ser desfeita.
         retry: Tentar novamente
         retry_confirm: Redefinir tempo de visibilidade e tentar novamente?
       failed_table:
@@ -197,6 +199,7 @@ pt:
       index:
         discard_all: Descartar Todos
         discard_all_confirm: Descartar todos os trabalhos falhados?
+        discard_all_enqueued_notice: Descartados %{count} trabalhos na fila e bloqueios liberados.
         retry_all: Tentar Novamente Todos
         retry_all_confirm: Tentar novamente todos os trabalhos falhados?
         title: Trabalhos

data/config/locales/sv.yml

@@ -179,6 +179,8 @@ sv:
         title: Köade jobb
         discard: Kassera
         discard_confirm: Kassera detta meddelande?
+        discard_all: Kassera alla
+        discard_all_confirm: Kassera alla köade jobb och frigör deras lås? Detta kan inte ångras.
         retry: Försök igen
         retry_confirm: Återställ synlighetstimeout och försök igen?
       failed_table:
@@ -197,6 +199,7 @@ sv:
       index:
         discard_all: Kassera alla
         discard_all_confirm: Kassera alla misslyckade jobb?
+        discard_all_enqueued_notice: Kasserade %{count} köade jobb och frigjorde deras lås.
         retry_all: Försök igen alla
         retry_all_confirm: Försök igen alla misslyckade jobb?
         title: Jobb

data/config/routes.rb

@@ -21,6 +21,7 @@ Pgbus::Engine.routes.draw do
     collection do
       post :retry_all
       post :discard_all
+      post :discard_all_enqueued
     end
   end
 
@@ -60,4 +61,9 @@ Pgbus::Engine.routes.draw do
     get :stats, to: "stats#show"
     get :insights, to: "insights#show"
   end
+
+  scope :frontend, controller: :frontends, defaults: { version: Pgbus::VERSION.tr(".", "-") } do
+    get "modules/:version/:id", action: :module, as: :frontend_module, constraints: { format: "js" }
+    get "static/:version/:id", action: :static, as: :frontend_static
+  end
 end

data/lib/generators/pgbus/add_job_stats_latency_generator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Pgbus
+  module Generators
+    class AddJobStatsLatencyGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Add enqueue latency and retry count columns to pgbus_job_stats"
+
+      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 "add_job_stats_latency.rb.erb",
+                             "db/pgbus_migrate/add_pgbus_job_stats_latency.rb"
+        else
+          migration_template "add_job_stats_latency.rb.erb",
+                             "db/migrate/add_pgbus_job_stats_latency.rb"
+        end
+      end
+
+      def display_post_install
+        say ""
+        say "Pgbus job stats latency columns installed!", :green
+        say ""
+        say "Next steps:"
+        say "  1. Run: rails db:migrate#{":#{options[:database]}" if separate_database?}"
+        say "  2. Queue latency and retry metrics are now tracked automatically"
+        say "  3. View latency insights at /pgbus/insights"
+        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_job_stats_latency.rb.erb

@@ -0,0 +1,9 @@
+class AddPgbusJobStatsLatency < ActiveRecord::Migration<%= migration_version %>
+  def change
+    add_column :pgbus_job_stats, :enqueue_latency_ms, :bigint
+    add_column :pgbus_job_stats, :retry_count, :integer, default: 0
+
+    add_index :pgbus_job_stats, [:queue_name, :created_at],
+      name: "idx_pgbus_job_stats_queue_time"
+  end
+end

data/lib/pgbus/active_job/executor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "time"
+
 module Pgbus
   module ActiveJob
     class Executor
@@ -20,7 +22,7 @@ module Pgbus
           signal_concurrency(payload)
           signal_batch_discarded(payload)
           Uniqueness.release_lock(Uniqueness.extract_key(payload))
-          record_stat(payload, queue_name, "dead_lettered", execution_start)
+          record_stat(payload, queue_name, "dead_lettered", execution_start, message: message)
           return :dead_lettered
         end
 
@@ -56,12 +58,12 @@ module Pgbus
         end
 
         instrument("pgbus.job_completed", queue: queue_name, job_class: job_class)
-        record_stat(payload, queue_name, "success", execution_start)
+        record_stat(payload, queue_name, "success", execution_start, message: message)
         :success
       rescue StandardError => e
         handle_failure(message, queue_name, e)
         instrument("pgbus.job_failed", queue: queue_name, job_class: payload&.dig("job_class"), error: e.class.name)
-        record_stat(payload, queue_name, "failed", execution_start)
+        record_stat(payload, queue_name, "failed", execution_start, message: message)
         # Don't signal concurrency on transient failure — the job will be retried.
         # Semaphore is released only on success or dead-lettering.
         :failed
@@ -91,20 +93,37 @@ module Pgbus
         ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       end
 
-      def record_stat(payload, queue_name, status, start_time)
+      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!(
           job_class: payload&.dig("job_class") || "unknown",
           queue_name: queue_name,
           status: status,
-          duration_ms: duration_ms
+          duration_ms: duration_ms,
+          enqueue_latency_ms: enqueue_latency_ms,
+          retry_count: retry_count
         )
       rescue StandardError => e
         Pgbus.logger.debug { "[Pgbus] Stat recording failed: #{e.message}" }
       end
 
+      def compute_enqueue_latency(message)
+        return unless message
+
+        enqueued_at_str = message.enqueued_at
+        return unless enqueued_at_str
+
+        enqueued_at = Time.parse(enqueued_at_str.to_s)
+        [((Time.now.utc - enqueued_at) * 1000).round, 0].max
+      rescue ArgumentError, TypeError
+        nil
+      end
+
       def handle_failure(_message, _queue_name, error)
         Pgbus.logger.error { "[Pgbus] Job failed: #{error.class}: #{error.message}" }
         Pgbus.logger.debug { error.backtrace&.join("\n") }

data/lib/pgbus/recurring/schedule.rb

@@ -17,10 +17,24 @@ module Pgbus
       def enqueue_task(task, run_at:)
         queue = resolve_queue(task)
 
+        # Check uniqueness lock before enqueuing. If the job class declares
+        # ensures_uniqueness, we acquire the lock here so duplicate recurring
+        # enqueues are rejected while a previous instance is still queued or running.
+        if uniqueness_locked?(task)
+          Pgbus.logger.debug do
+            "[Pgbus] Recurring task #{task.key} skipped: uniqueness lock held"
+          end
+          return
+        end
+
         RecurringExecution.record(task.key, run_at) do
           payload = build_payload(task)
           headers = build_headers(task, run_at)
 
+          # Inject uniqueness metadata into the payload so the worker knows
+          # to release the lock after execution.
+          payload = inject_uniqueness_metadata(task, payload)
+
           Pgbus.client.ensure_queue(queue)
           Pgbus.client.send_message(queue, payload, headers: headers)
 
@@ -97,6 +111,78 @@ module Pgbus
           "pgbus.recurring_schedule" => task.schedule
         }
       end
+
+      # Check if the job class has ensures_uniqueness and if its lock is currently held.
+      # Returns true if the lock is held (skip enqueue), false otherwise.
+      def uniqueness_locked?(task)
+        return false unless task.class_name
+
+        job_class = task.class_name.safe_constantize
+        return false unless job_class
+        return false unless job_class.respond_to?(:pgbus_uniqueness)
+
+        config = job_class.pgbus_uniqueness
+        return false unless config
+        return false unless config[:strategy] == :until_executed
+
+        key = resolve_uniqueness_key(config, task)
+        return false unless key
+
+        # Try to acquire the lock. If it fails, the lock is already held.
+        acquired = JobLock.acquire!(
+          key,
+          job_class: task.class_name,
+          job_id: "recurring-#{task.key}",
+          state: "queued",
+          ttl: config[:lock_ttl]
+        )
+        # If we acquired it, great — the message will be enqueued with the lock held.
+        # If not, a previous instance is still queued/running.
+        !acquired
+      rescue StandardError => e
+        Pgbus.logger.warn { "[Pgbus] Uniqueness check failed for #{task.key}: #{e.message}" }
+        false # Fail open — allow enqueue if uniqueness check errors
+      end
+
+      # Resolve the uniqueness key for a recurring task.
+      # For no-argument recurring jobs, the key defaults to the class name.
+      def resolve_uniqueness_key(config, task)
+        key_proc = config[:key]
+        args = task.arguments || []
+
+        if args.empty?
+          key_proc.call
+        else
+          key_proc.call(*args)
+        end
+      rescue StandardError => e
+        Pgbus.logger.warn { "[Pgbus] Could not resolve uniqueness key for #{task.key}: #{e.message}" }
+        nil
+      end
+
+      # Inject uniqueness metadata into the payload so the executor releases
+      # the lock after the job completes.
+      # Only inject for :until_executed strategy — :while_executing locks are
+      # acquired at execution time by the executor, not by the scheduler.
+      def inject_uniqueness_metadata(task, payload)
+        return payload unless task.class_name
+
+        job_class = task.class_name.safe_constantize
+        return payload unless job_class.respond_to?(:pgbus_uniqueness)
+
+        config = job_class.pgbus_uniqueness
+        return payload unless config
+        return payload unless config[:strategy] == :until_executed
+
+        key = resolve_uniqueness_key(config, task)
+        return payload unless key
+
+        payload.merge(
+          Pgbus::Uniqueness::METADATA_KEY => key,
+          Pgbus::Uniqueness::STRATEGY_KEY => config[:strategy].to_s,
+          Pgbus::Uniqueness::TTL_KEY => config[:lock_ttl]
+        )
+      end
     end
   end
 end

data/lib/pgbus/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pgbus
-  VERSION = "0.2.9"
+  VERSION = "0.3.1"
 end

data/lib/pgbus/web/data_source.rb

@@ -113,9 +113,31 @@ module Pgbus
       end
 
       def discard_job(queue_name, msg_id)
+        release_lock_for_message(queue_name, msg_id)
         @client.archive_message(queue_name, msg_id.to_i, prefixed: false)
       end
 
+      def discard_all_enqueued
+        dlq_suffix = Pgbus.configuration.dead_letter_queue_suffix
+        queues = queues_with_metrics.reject { |q| q[:name].end_with?(dlq_suffix) }
+        total = 0
+
+        queues.each do |q|
+          messages = query_queue_messages_raw(q[:name], 10_000, 0)
+          next if messages.empty?
+
+          release_locks_for_messages(messages)
+
+          ids = messages.map { |m| m[:msg_id].to_i }
+          @client.archive_batch(q[:name], ids, prefixed: false)
+          total += ids.size
+        rescue StandardError => e
+          Pgbus.logger.debug { "[Pgbus::Web] Error discarding enqueued messages from #{q[:name]}: #{e.message}" }
+        end
+
+        total
+      end
+
       # Failed events
       def failed_events(page: 1, per_page: 25)
         offset = (page - 1) * per_page
@@ -170,6 +192,9 @@ module Pgbus
       end
 
       def discard_failed_event(id)
+        event = failed_event(id)
+        release_lock_for_payload(event["payload"]) if event
+
         connection.exec_delete(
           "DELETE FROM pgbus_failed_events WHERE id = $1", "Pgbus Delete Failed Event", [id.to_i]
         )
@@ -207,6 +232,8 @@ module Pgbus
       end
 
       def discard_all_failed
+        release_locks_for_failed_events
+
         result = connection.execute("DELETE FROM pgbus_failed_events")
         result.cmd_tuples
       rescue StandardError => e
@@ -273,6 +300,7 @@ module Pgbus
 
       def discard_dlq_message(queue_name, msg_id)
         # queue_name here is the full DLQ name (already prefixed)
+        release_lock_for_message(queue_name, msg_id)
         @client.delete_message(queue_name, msg_id.to_i, prefixed: false)
         true
       rescue StandardError => e
@@ -296,6 +324,8 @@ module Pgbus
         messages = dlq_messages(page: 1, per_page: 1000)
         return 0 if messages.empty?
 
+        release_locks_for_messages(messages)
+
         # Group by queue for batch delete — one call per DLQ instead of N calls
         messages.group_by { |m| m[:queue_name] }.sum do |queue_name, msgs|
           ids = msgs.map { |m| m[:msg_id].to_i }
@@ -552,6 +582,20 @@ module Pgbus
         []
       end
 
+      def latency_trend(minutes: 60)
+        JobStat.latency_trend(minutes: minutes)
+      rescue StandardError => e
+        Pgbus.logger.debug { "[Pgbus::Web] Error fetching latency trend: #{e.message}" }
+        []
+      end
+
+      def latency_by_queue(minutes: 60)
+        JobStat.avg_latency_by_queue(minutes: minutes)
+      rescue StandardError => e
+        Pgbus.logger.debug { "[Pgbus::Web] Error fetching latency by queue: #{e.message}" }
+        []
+      end
+
       # Subscriber registry
       def registered_subscribers
         EventBus::Registry.instance.subscribers.map do |s|
@@ -719,6 +763,69 @@ module Pgbus
         Pgbus.logger.debug { "[Pgbus::Web] Invalid recurring task arguments JSON: #{e.message}" }
         []
       end
+
+      # --- Lock cleanup helpers ---
+
+      # Extract uniqueness key from a queue message and release its lock.
+      def release_lock_for_message(queue_name, msg_id)
+        row = connection.select_one(
+          "SELECT * FROM pgmq.q_#{sanitize_name(queue_name)} WHERE msg_id = $1",
+          "Pgbus Job Detail",
+          [msg_id.to_i]
+        )
+        return unless row
+
+        release_lock_for_payload(row["message"])
+      rescue StandardError => e
+        Pgbus.logger.debug { "[Pgbus::Web] Error releasing lock for message #{msg_id}: #{e.message}" }
+      end
+
+      # Extract uniqueness key from a JSON payload string and release its lock.
+      def release_lock_for_payload(payload_str)
+        return unless payload_str
+
+        payload = payload_str.is_a?(String) ? JSON.parse(payload_str) : payload_str
+        key = payload[Uniqueness::METADATA_KEY]
+        JobLock.release!(key) if key
+      rescue JSON::ParserError => e
+        Pgbus.logger.debug { "[Pgbus::Web] Error parsing payload for lock release: #{e.message}" }
+      end
+
+      # Extract uniqueness keys from a collection of formatted messages and
+      # release all associated locks in a single query.
+      def release_locks_for_messages(messages)
+        keys = messages.filter_map do |m|
+          payload = m[:message]
+          next unless payload
+
+          parsed = payload.is_a?(String) ? JSON.parse(payload) : payload
+          parsed[Uniqueness::METADATA_KEY]
+        rescue JSON::ParserError
+          nil
+        end
+
+        JobLock.where(lock_key: keys).delete_all if keys.any?
+      rescue StandardError => e
+        Pgbus.logger.debug { "[Pgbus::Web] Error releasing locks for messages: #{e.message}" }
+      end
+
+      # Collect uniqueness keys from all failed events and release their locks.
+      def release_locks_for_failed_events
+        rows = connection.select_all(
+          "SELECT payload FROM pgbus_failed_events", "Pgbus Collect Failed Keys"
+        )
+
+        keys = rows.to_a.filter_map do |row|
+          payload = JSON.parse(row["payload"])
+          payload[Uniqueness::METADATA_KEY]
+        rescue JSON::ParserError
+          nil
+        end
+
+        JobLock.where(lock_key: keys).delete_all if keys.any?
+      rescue StandardError => e
+        Pgbus.logger.debug { "[Pgbus::Web] Error releasing locks for failed events: #{e.message}" }
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgbus
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.3.1
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -127,6 +127,7 @@ files:
 - app/controllers/pgbus/dashboard_controller.rb
 - app/controllers/pgbus/dead_letter_controller.rb
 - app/controllers/pgbus/events_controller.rb
+- app/controllers/pgbus/frontends_controller.rb
 - app/controllers/pgbus/insights_controller.rb
 - app/controllers/pgbus/jobs_controller.rb
 - app/controllers/pgbus/locale_controller.rb
@@ -135,6 +136,12 @@ files:
 - app/controllers/pgbus/processes_controller.rb
 - app/controllers/pgbus/queues_controller.rb
 - app/controllers/pgbus/recurring_tasks_controller.rb
+- app/frontend/pgbus/application.js
+- app/frontend/pgbus/modules/charts.js
+- app/frontend/pgbus/style.css
+- app/frontend/pgbus/tailwind.css
+- app/frontend/pgbus/vendor/apexcharts.js
+- app/frontend/pgbus/vendor/turbo.js
 - app/helpers/pgbus/application_helper.rb
 - app/models/pgbus/application_record.rb
 - app/models/pgbus/batch_entry.rb
@@ -192,12 +199,14 @@ files:
 - lib/active_job/queue_adapters/pgbus_adapter.rb
 - lib/generators/pgbus/add_job_locks_generator.rb
 - lib/generators/pgbus/add_job_stats_generator.rb
+- lib/generators/pgbus/add_job_stats_latency_generator.rb
 - lib/generators/pgbus/add_outbox_generator.rb
 - lib/generators/pgbus/add_queue_states_generator.rb
 - lib/generators/pgbus/add_recurring_generator.rb
 - lib/generators/pgbus/install_generator.rb
 - lib/generators/pgbus/templates/add_job_locks.rb.erb
 - lib/generators/pgbus/templates/add_job_stats.rb.erb
+- lib/generators/pgbus/templates/add_job_stats_latency.rb.erb
 - lib/generators/pgbus/templates/add_outbox.rb.erb
 - lib/generators/pgbus/templates/add_queue_states.rb.erb
 - lib/generators/pgbus/templates/add_recurring_tables.rb.erb