pgbus 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2253eb954ac89887e409ae1145105005492ce22b8f96c586dded75713d8cafb0
-  data.tar.gz: 84908a1e8b4d4d74dc2b713863605af3b0543a67150a9082514ad8c50fd824f2
+  metadata.gz: d895049be3463d74d039e29485fc7d26c4c06ca96419e8a46327a4be6538db1f
+  data.tar.gz: f685673eaf24780e820486b9eb1f752493caf1765241b0063293d1d8d4b98e25
 SHA512:
-  metadata.gz: 44829218ace48e2207c283ca5f0be6209a665cb31c1c636f5e96c4cf83adeadaf01a94a8548e797aec995f99f9d0b6e7984734a8506ffe0af3c5a0c02a4c251d
-  data.tar.gz: b18ac34999fea1cdda778f4f1f218b8cd8b9a72bec2f0e07560ea4b510c5cd2908a22e4e65a14e87644c0eaabc792df5fa3becc3c49f69154f2ec218815f514a
+  metadata.gz: 33cb5c4fbf7ae36a8bb82a780d39bd0a32fd2c3167d0d7aaaed74a60608778a90e32eac53c1db2808ffa5956184298a83478488a8d11edcc89b052ec5fe8b0a5
+  data.tar.gz: 4a9cc394b02ee99e1681ab26a86db25c57f38f92e901dab0c2c48c1025224bb4089009abcd865a2432c3b37a988b51511faa64be976709069a4dbef70e3ec5ed

data/Rakefile

@@ -31,7 +31,12 @@ namespace :bench do
     ruby "benchmarks/memory_profile.rb"
   end
 
-  desc "Run all benchmarks"
+  desc "Run integration benchmarks (requires PGBUS_DATABASE_URL)"
+  task :integration do
+    ruby "benchmarks/integration_bench.rb"
+  end
+
+  desc "Run all benchmarks (unit-level, no DB required)"
   task all: %i[serialization client executor]
 end
 

data/app/controllers/pgbus/api/insights_controller.rb

@@ -5,12 +5,17 @@ module Pgbus
     class InsightsController < ApplicationController
       def show
         minutes = insights_minutes
-        render json: {
+        payload = {
           summary: data_source.job_stats_summary(minutes: minutes),
           throughput: data_source.job_throughput(minutes: minutes),
           status_counts: data_source.job_status_counts(minutes: minutes),
           slowest: data_source.slowest_job_classes(minutes: minutes)
         }
+        if Pgbus::JobStat.latency_columns?
+          payload[:latency_trend] = data_source.latency_trend(minutes: minutes)
+          payload[:latency_by_queue] = data_source.latency_by_queue(minutes: minutes)
+        end
+        render json: payload
       end
     end
   end

data/app/controllers/pgbus/insights_controller.rb

@@ -6,6 +6,8 @@ module Pgbus
       @minutes = insights_minutes
       @summary = data_source.job_stats_summary(minutes: @minutes)
       @slowest = data_source.slowest_job_classes(minutes: @minutes)
+      @latency_by_queue = data_source.latency_by_queue(minutes: @minutes)
+      @latency_available = Pgbus::JobStat.latency_columns?
     end
   end
 end

data/app/controllers/pgbus/jobs_controller.rb

@@ -44,5 +44,10 @@ module Pgbus
       count = data_source.discard_all_failed
       redirect_to jobs_path, notice: "Discarded #{count} jobs."
     end
+
+    def discard_all_enqueued
+      count = data_source.discard_all_enqueued
+      redirect_to jobs_path, notice: t("pgbus.jobs.index.discard_all_enqueued_notice", count: count)
+    end
   end
 end

data/app/frontend/pgbus/modules/charts.js

@@ -12,13 +12,14 @@ function getThemeColors() {
   };
 }
 
-let throughputChart, statusChart;
+let throughputChart, statusChart, latencyChart;
 
 export function renderCharts(data, i18n) {
   const t = getThemeColors();
 
   if (throughputChart) throughputChart.destroy();
   if (statusChart) statusChart.destroy();
+  if (latencyChart) latencyChart.destroy();
 
   const throughputData = data.throughput.map(p => ({
     x: new Date(p.time).getTime(),
@@ -64,6 +65,32 @@ export function renderCharts(data, i18n) {
     const el = document.querySelector("#status-chart");
     if (el) el.innerHTML = `<p class="text-center text-sm text-gray-400 dark:text-gray-500 pt-24">${i18n.noData || "No data"}</p>`;
   }
+
+  // Latency chart (only if data is available)
+  const latencyEl = document.querySelector("#latency-chart");
+  if (latencyEl && data.latency_trend && data.latency_trend.length > 0) {
+    const avgData = data.latency_trend.map(p => ({ x: new Date(p.time).getTime(), y: p.avg_ms }));
+    const p95Data = data.latency_trend.map(p => ({ x: new Date(p.time).getTime(), y: p.p95_ms }));
+
+    latencyChart = new ApexCharts(latencyEl, {
+      series: [
+        { name: i18n.latencyAvg || "Avg", data: avgData },
+        { name: i18n.latencyP95 || "P95", data: p95Data },
+      ],
+      chart: { type: "line", height: 280, toolbar: { show: false }, background: "transparent", foreColor: t.text },
+      stroke: { curve: "smooth", width: [2, 2], dashArray: [0, 5] },
+      colors: ["#6366f1", "#f59e0b"],
+      xaxis: { type: "datetime", labels: { style: { colors: t.text } } },
+      yaxis: { labels: { style: { colors: t.text }, formatter: v => Math.round(v) + "ms" } },
+      grid: { borderColor: t.grid },
+      tooltip: { theme: t.tooltip },
+      dataLabels: { enabled: false },
+      legend: { position: "top", labels: { colors: t.text } },
+    });
+    latencyChart.render();
+  } else if (latencyEl) {
+    latencyEl.innerHTML = `<p class="text-center text-sm text-gray-400 dark:text-gray-500 pt-24">${i18n.noData || "No data"}</p>`;
+  }
 }
 
 let themeObserver = null;

data/app/models/pgbus/job_lock.rb

@@ -16,42 +16,50 @@ module Pgbus
     # Atomically try to acquire a lock.
     # Cleans up expired locks for this key first (crash recovery at acquire time).
     # Returns true if acquired, false if already locked.
-    def self.acquire!(lock_key, job_class:, ttl:, job_id: nil, state: "queued", owner_pid: nil, owner_hostname: nil)
+    #
+    # Uses raw SQL on the hot path to minimize ActiveRecord allocations
+    # (~29 objects vs ~304 per acquire+release cycle with AR query builder).
+    def self.acquire!(lock_key, job_class:, ttl:, job_id: nil, state: "queued", owner_pid: nil, owner_hostname: nil) # rubocop:disable Naming/PredicateMethod
+      expires_at = Time.current + ttl
+
       # Remove any expired lock for this key inline (last-resort TTL recovery)
-      where(lock_key: lock_key).where("expires_at < ?", Time.current).delete_all
+      connection.exec_delete(
+        "DELETE FROM #{table_name} WHERE lock_key = $1 AND expires_at < $2",
+        "JobLock Expire", [lock_key, Time.current]
+      )
 
-      result = insert(
-        {
-          lock_key: lock_key, job_class: job_class, job_id: job_id,
-          state: state, owner_pid: owner_pid, owner_hostname: owner_hostname,
-          expires_at: Time.current + ttl
-        },
-        unique_by: :lock_key
+      result = connection.exec_query(
+        "INSERT INTO #{table_name} (lock_key, job_class, job_id, state, owner_pid, owner_hostname, expires_at) " \
+        "VALUES ($1, $2, $3, $4, $5, $6, $7) ON CONFLICT (lock_key) DO NOTHING RETURNING id",
+        "JobLock Acquire", [lock_key, job_class, job_id, state, owner_pid, owner_hostname, expires_at]
       )
       result.rows.any?
-    rescue ActiveRecord::RecordNotUnique
-      false
     end
 
     # Transition a queued lock to executing state and claim ownership.
     # Called when a worker starts executing a job that was locked at enqueue time.
     def self.claim_for_execution!(lock_key, owner_pid:, owner_hostname:, ttl:)
-      where(lock_key: lock_key).update_all(
-        state: "executing",
-        owner_pid: owner_pid,
-        owner_hostname: owner_hostname,
-        expires_at: Time.current + ttl
+      connection.exec_update(
+        "UPDATE #{table_name} SET state = $1, owner_pid = $2, owner_hostname = $3, expires_at = $4 " \
+        "WHERE lock_key = $5",
+        "JobLock Claim", ["executing", owner_pid, owner_hostname, Time.current + ttl, lock_key]
       )
     end
 
     # Release a lock by key.
     def self.release!(lock_key)
-      where(lock_key: lock_key).delete_all
+      connection.exec_delete(
+        "DELETE FROM #{table_name} WHERE lock_key = $1",
+        "JobLock Release", [lock_key]
+      )
     end
 
     # Check if a lock is currently held (regardless of expiry — reaper handles orphans).
     def self.locked?(lock_key)
-      where(lock_key: lock_key).exists?
+      result = connection.select_value(
+        "SELECT 1 FROM #{table_name} WHERE lock_key = $1 LIMIT 1", "JobLock Check", [lock_key]
+      )
+      !result.nil?
     end
 
     # Reap orphaned locks: locks in 'executing' state whose owner_pid

data/app/models/pgbus/job_stat.rb

@@ -10,15 +10,19 @@ module Pgbus
     scope :dead_lettered, -> { where(status: "dead_lettered") }
 
     # Record a job execution stat. Called by the executor after each job.
-    def self.record!(job_class:, queue_name:, status:, duration_ms:)
+    def self.record!(job_class:, queue_name:, status:, duration_ms:, enqueue_latency_ms: nil, retry_count: 0)
       return unless table_exists?
 
-      create!(
+      attrs = {
         job_class: job_class,
         queue_name: queue_name,
         status: status,
         duration_ms: duration_ms
-      )
+      }
+      attrs[:enqueue_latency_ms] = enqueue_latency_ms if latency_columns?
+      attrs[:retry_count] = retry_count if latency_columns?
+
+      create!(attrs)
     rescue StandardError => e
       Pgbus.logger.debug { "[Pgbus] Failed to record job stat: #{e.message}" }
     end
@@ -34,6 +38,15 @@ module Pgbus
       @table_exists = false
     end
 
+    # Memoized — checks if the latency migration has been applied.
+    def self.latency_columns?
+      return @latency_columns if defined?(@latency_columns)
+
+      @latency_columns = table_exists? && column_names.include?("enqueue_latency_ms")
+    rescue StandardError
+      @latency_columns = false
+    end
+
     # Throughput: jobs per minute bucketed by minute for the last N minutes
     def self.throughput(minutes: 60)
       since(minutes.minutes.ago)
@@ -67,16 +80,30 @@ module Pgbus
 
     # Single-query aggregate summary using conditional counts.
     def self.summary(minutes: 60)
-      row = since(minutes.minutes.ago).pick(
-        Arel.sql("COUNT(*)"),
-        Arel.sql("COUNT(*) FILTER (WHERE status = 'success')"),
-        Arel.sql("COUNT(*) FILTER (WHERE status = 'failed')"),
-        Arel.sql("COUNT(*) FILTER (WHERE status = 'dead_lettered')"),
-        Arel.sql("ROUND(AVG(duration_ms)::numeric, 1)"),
-        Arel.sql("MAX(duration_ms)")
-      )
-
-      {
+      cols = [
+        "COUNT(*)",
+        "COUNT(*) FILTER (WHERE status = 'success')",
+        "COUNT(*) FILTER (WHERE status = 'failed')",
+        "COUNT(*) FILTER (WHERE status = 'dead_lettered')",
+        "ROUND(AVG(duration_ms)::numeric, 1)",
+        "MAX(duration_ms)"
+      ]
+      if latency_columns?
+        cols.push(
+          "ROUND(AVG(enqueue_latency_ms) FILTER (WHERE enqueue_latency_ms IS NOT NULL)::numeric, 1)",
+          "PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY enqueue_latency_ms) " \
+          "FILTER (WHERE enqueue_latency_ms IS NOT NULL)",
+          "PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY enqueue_latency_ms) " \
+          "FILTER (WHERE enqueue_latency_ms IS NOT NULL)",
+          "PERCENTILE_CONT(0.99) WITHIN GROUP (ORDER BY enqueue_latency_ms) " \
+          "FILTER (WHERE enqueue_latency_ms IS NOT NULL)",
+          "ROUND(AVG(retry_count) FILTER (WHERE retry_count IS NOT NULL)::numeric, 2)"
+        )
+      end
+
+      row = since(minutes.minutes.ago).pick(*cols.map { |c| Arel.sql(c) })
+
+      result = {
         total: row[0].to_i,
         success: row[1].to_i,
         failed: row[2].to_i,
@@ -84,6 +111,51 @@ module Pgbus
         avg_duration_ms: row[4]&.to_f || 0,
         max_duration_ms: row[5].to_i
       }
+
+      if latency_columns?
+        result.merge!(
+          avg_latency_ms: row[6]&.to_f || 0,
+          p50_latency_ms: row[7]&.to_f || 0,
+          p95_latency_ms: row[8]&.to_f || 0,
+          p99_latency_ms: row[9]&.to_f || 0,
+          avg_retries: row[10]&.to_f || 0
+        )
+      end
+
+      result
+    end
+
+    # Latency trend: average enqueue latency per minute bucketed
+    def self.latency_trend(minutes: 60)
+      return [] unless latency_columns?
+
+      since(minutes.minutes.ago)
+        .where.not(enqueue_latency_ms: nil)
+        .group("date_trunc('minute', created_at)")
+        .order(Arel.sql("date_trunc('minute', created_at)"))
+        .pluck(
+          Arel.sql("date_trunc('minute', created_at)"),
+          Arel.sql("ROUND(AVG(enqueue_latency_ms))"),
+          Arel.sql("ROUND(PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY enqueue_latency_ms))")
+        )
+        .map { |time, avg, p95| { time: time, avg_ms: avg.to_i, p95_ms: p95.to_i } }
+    end
+
+    # Average latency by queue
+    def self.avg_latency_by_queue(minutes: 60)
+      return [] unless latency_columns?
+
+      since(minutes.minutes.ago)
+        .where.not(enqueue_latency_ms: nil)
+        .group(:queue_name)
+        .order(Arel.sql("AVG(enqueue_latency_ms) DESC"))
+        .pluck(
+          :queue_name,
+          Arel.sql("ROUND(AVG(enqueue_latency_ms))"),
+          Arel.sql("ROUND(PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY enqueue_latency_ms))"),
+          Arel.sql("COUNT(*)")
+        )
+        .map { |q, avg, p95, count| { queue_name: q, avg_ms: avg.to_i, p95_ms: p95.to_i, count: count.to_i } }
     end
 
     # Cleanup old stats

data/app/views/pgbus/insights/show.html.erb

@@ -51,6 +51,32 @@
   </div>
 </div>
 
+<% if @latency_available %>
+<!-- Latency summary cards -->
+<div class="grid grid-cols-2 gap-4 sm:grid-cols-3 lg:grid-cols-5 mb-8">
+  <div class="rounded-lg bg-white dark:bg-gray-800 p-4 shadow ring-1 ring-gray-200 dark:ring-gray-700">
+    <dt class="text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.summary.avg_latency") %></dt>
+    <dd class="mt-1 text-2xl font-semibold text-gray-900 dark:text-white"><%= pgbus_ms_duration(@summary[:avg_latency_ms]) %></dd>
+  </div>
+  <div class="rounded-lg bg-white dark:bg-gray-800 p-4 shadow ring-1 ring-gray-200 dark:ring-gray-700">
+    <dt class="text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.summary.p50_latency") %></dt>
+    <dd class="mt-1 text-2xl font-semibold text-gray-900 dark:text-white"><%= pgbus_ms_duration(@summary[:p50_latency_ms]) %></dd>
+  </div>
+  <div class="rounded-lg bg-white dark:bg-gray-800 p-4 shadow ring-1 ring-gray-200 dark:ring-gray-700">
+    <dt class="text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.summary.p95_latency") %></dt>
+    <dd class="mt-1 text-2xl font-semibold text-yellow-600 dark:text-yellow-400"><%= pgbus_ms_duration(@summary[:p95_latency_ms]) %></dd>
+  </div>
+  <div class="rounded-lg bg-white dark:bg-gray-800 p-4 shadow ring-1 ring-gray-200 dark:ring-gray-700">
+    <dt class="text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.summary.p99_latency") %></dt>
+    <dd class="mt-1 text-2xl font-semibold text-orange-600 dark:text-orange-400"><%= pgbus_ms_duration(@summary[:p99_latency_ms]) %></dd>
+  </div>
+  <div class="rounded-lg bg-white dark:bg-gray-800 p-4 shadow ring-1 ring-gray-200 dark:ring-gray-700">
+    <dt class="text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.summary.avg_retries") %></dt>
+    <dd class="mt-1 text-2xl font-semibold text-gray-900 dark:text-white"><%= @summary[:avg_retries]&.round(2) || 0 %></dd>
+  </div>
+</div>
+<% end %>
+
 <!-- Charts -->
 <div class="grid grid-cols-1 lg:grid-cols-2 gap-6 mb-8">
   <div class="rounded-lg bg-white dark:bg-gray-800 p-5 shadow ring-1 ring-gray-200 dark:ring-gray-700">
@@ -63,6 +89,46 @@
   </div>
 </div>
 
+<% if @latency_available %>
+<!-- Latency chart -->
+<div class="grid grid-cols-1 gap-6 mb-8">
+  <div class="rounded-lg bg-white dark:bg-gray-800 p-5 shadow ring-1 ring-gray-200 dark:ring-gray-700">
+    <h3 class="text-sm font-medium text-gray-700 dark:text-gray-300 mb-4"><%= t("pgbus.insights.show.charts.latency") %></h3>
+    <div id="latency-chart" style="height: 280px;"></div>
+  </div>
+</div>
+
+<!-- Latency by queue -->
+<div class="rounded-lg bg-white dark:bg-gray-800 shadow ring-1 ring-gray-200 dark:ring-gray-700 mb-8">
+  <div class="px-5 py-4 border-b border-gray-200 dark:border-gray-700">
+    <h3 class="text-sm font-medium text-gray-700 dark:text-gray-300"><%= t("pgbus.insights.show.latency_by_queue.title") %></h3>
+  </div>
+  <table class="pgbus-table min-w-full divide-y divide-gray-200 dark:divide-gray-700">
+    <thead class="bg-gray-50 dark:bg-gray-900">
+      <tr>
+        <th class="px-4 py-3 text-left text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.latency_by_queue.headers.queue") %></th>
+        <th class="px-4 py-3 text-right text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.latency_by_queue.headers.count") %></th>
+        <th class="px-4 py-3 text-right text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.latency_by_queue.headers.avg") %></th>
+        <th class="px-4 py-3 text-right text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.latency_by_queue.headers.p95") %></th>
+      </tr>
+    </thead>
+    <tbody class="divide-y divide-gray-100 dark:divide-gray-700">
+      <% @latency_by_queue.each do |row| %>
+        <tr class="hover:bg-gray-50 dark:hover:bg-gray-700/50">
+          <td data-label="Queue" class="px-4 py-3 text-sm font-medium text-gray-700 dark:text-gray-300"><%= row[:queue_name] %></td>
+          <td data-label="Count" class="px-4 py-3 text-sm text-right font-mono text-gray-700 dark:text-gray-300"><%= pgbus_number(row[:count]) %></td>
+          <td data-label="Avg" class="px-4 py-3 text-sm text-right font-mono text-gray-700 dark:text-gray-300"><%= pgbus_ms_duration(row[:avg_ms]) %></td>
+          <td data-label="P95" class="px-4 py-3 text-sm text-right font-mono text-gray-700 dark:text-gray-300"><%= pgbus_ms_duration(row[:p95_ms]) %></td>
+        </tr>
+      <% end %>
+      <% if @latency_by_queue.empty? %>
+        <tr><td colspan="4" class="px-4 py-8 text-center text-sm text-gray-400 dark:text-gray-500"><%= t("pgbus.insights.show.latency_by_queue.empty") %></td></tr>
+      <% end %>
+    </tbody>
+  </table>
+</div>
+<% end %>
+
 <!-- Slowest job classes -->
 <div class="rounded-lg bg-white dark:bg-gray-800 shadow ring-1 ring-gray-200 dark:ring-gray-700">
   <div class="px-5 py-4 border-b border-gray-200 dark:border-gray-700">
@@ -100,6 +166,8 @@
     seriesName: "<%= j(t("pgbus.insights.show.charts.series_name")) %>",
     noData: "<%= j(t("pgbus.insights.show.charts.no_data")) %>",
     failedToLoad: "<%= j(t("pgbus.insights.show.charts.failed_to_load")) %>",
+    latencyAvg: "<%= j(t("pgbus.insights.show.charts.latency_avg")) %>",
+    latencyP95: "<%= j(t("pgbus.insights.show.charts.latency_p95")) %>",
   };
 
   let chartData = null;
@@ -114,9 +182,8 @@
     .then(data => { chartData = data; renderCharts(data, i18n); })
     .catch(err => {
       const msg = '<p class="text-center text-sm text-gray-400 dark:text-gray-500 pt-24">' + i18n.failedToLoad + "</p>";
-      const el1 = document.querySelector("#throughput-chart");
-      const el2 = document.querySelector("#status-chart");
-      if (el1) el1.innerHTML = msg;
-      if (el2) el2.innerHTML = msg;
+      document.querySelectorAll("#throughput-chart, #status-chart, #latency-chart").forEach(el => {
+        el.innerHTML = msg;
+      });
     });
 </script>

data/app/views/pgbus/jobs/_enqueued_table.html.erb

@@ -1,6 +1,13 @@
 <turbo-frame id="jobs-enqueued" data-auto-refresh data-src="<%= pgbus.jobs_path(request.query_parameters.merge(frame: 'enqueued')) %>">
   <div>
-    <h2 class="text-lg font-semibold text-gray-900 dark:text-white mb-3"><%= t("pgbus.jobs.enqueued_table.title") %></h2>
+    <div class="flex items-center justify-between mb-3">
+      <h2 class="text-lg font-semibold text-gray-900 dark:text-white"><%= t("pgbus.jobs.enqueued_table.title") %></h2>
+      <% if @jobs.any? %>
+        <%= button_to t("pgbus.jobs.enqueued_table.discard_all"), pgbus.discard_all_enqueued_jobs_path, method: :post,
+              class: "rounded-md bg-red-600 px-3 py-2 text-sm font-medium text-white hover:bg-red-500",
+              data: { turbo_confirm: t("pgbus.jobs.enqueued_table.discard_all_confirm"), turbo_frame: "_top" } %>
+      <% end %>
+    </div>
     <div class="overflow-hidden rounded-lg bg-white dark:bg-gray-800 shadow ring-1 ring-gray-200 dark:ring-gray-700">
       <table class="pgbus-table min-w-full divide-y divide-gray-200 dark:divide-gray-700">
         <thead class="bg-gray-50 dark:bg-gray-900">

data/config/locales/da.yml

@@ -179,6 +179,8 @@ da:
         title: Job i kø
         discard: Kassér
         discard_confirm: Kassér denne besked?
+        discard_all: Kassér alle
+        discard_all_confirm: Kassér alle ventende jobs og frigiv deres låse? Dette kan ikke fortrydes.
         retry: Prøv igen
         retry_confirm: Nulstil synlighedstimeout og prøv igen?
       failed_table:
@@ -197,6 +199,7 @@ da:
       index:
         discard_all: Kassér alle
         discard_all_confirm: Kassér alle mislykkede job?
+        discard_all_enqueued_notice: Kasserede %{count} ventende jobs og frigav deres låse.
         retry_all: Forsøg alle igen
         retry_all_confirm: Forsøg alle mislykkede job igen?
         title: Job

data/config/locales/de.yml

@@ -179,6 +179,8 @@ de:
         title: Eingereihte Jobs
         discard: Verwerfen
         discard_confirm: Diese Nachricht verwerfen?
+        discard_all: Alle verwerfen
+        discard_all_confirm: Alle eingereihten Jobs verwerfen und ihre Sperren freigeben? Dies kann nicht rückgängig gemacht werden.
         retry: Wiederholen
         retry_confirm: Sichtbarkeits-Timeout zurücksetzen und erneut versuchen?
       failed_table:
@@ -197,6 +199,7 @@ de:
       index:
         discard_all: Alle verwerfen
         discard_all_confirm: Alle fehlgeschlagenen Jobs verwerfen?
+        discard_all_enqueued_notice: "%{count} eingereihte Jobs verworfen und Sperren freigegeben."
         retry_all: Alle wiederholen
         retry_all_confirm: Alle fehlgeschlagenen Jobs wiederholen?
         title: Jobs

data/config/locales/en.yml

@@ -128,11 +128,22 @@ en:
       show:
         charts:
           failed_to_load: Failed to load chart data
+          latency: Queue Latency (ms)
+          latency_avg: Avg
+          latency_p95: P95
           no_data: No data yet
           series_name: Jobs/min
           status_distribution: Status Distribution
           throughput: Throughput (jobs/min)
         description_html: Job performance metrics for the last %{range}
+        latency_by_queue:
+          empty: No latency data yet
+          headers:
+            avg: Avg (ms)
+            count: Count
+            p95: P95 (ms)
+            queue: Queue
+          title: Latency by Queue
         slowest:
           empty: No job stats yet
           headers:
@@ -143,9 +154,14 @@ en:
           title: Slowest Job Classes (avg duration)
         summary:
           avg_duration: Avg Duration
+          avg_latency: Avg Latency
+          avg_retries: Avg Retries
           dead_lettered: Dead Lettered
           failed: Failed
           max_duration: Max Duration
+          p50_latency: P50 Latency
+          p95_latency: P95 Latency
+          p99_latency: P99 Latency
           succeeded: Succeeded
           total_jobs: Total Jobs
         time_ranges:
@@ -177,6 +193,8 @@ en:
           timezone: 'Timezone:'
           visible_at: 'Visible at:'
         discard: Discard
+        discard_all: Discard All
+        discard_all_confirm: Discard all enqueued jobs and release their locks? This cannot be undone.
         discard_confirm: Discard this message?
         retry: Retry
         retry_confirm: Reset visibility timeout and retry?
@@ -197,6 +215,7 @@ en:
       index:
         discard_all: Discard All
         discard_all_confirm: Discard all failed jobs?
+        discard_all_enqueued_notice: Discarded %{count} enqueued jobs and released their locks.
         retry_all: Retry All
         retry_all_confirm: Retry all failed jobs?
         title: Jobs

data/config/locales/es.yml

@@ -179,6 +179,8 @@ es:
         title: Trabajos en Cola
         discard: Descartar
         discard_confirm: "¿Descartar este mensaje?"
+        discard_all: Descartar todos
+        discard_all_confirm: "¿Descartar todos los trabajos en cola y liberar sus bloqueos? Esta acción no se puede deshacer."
         retry: Reintentar
         retry_confirm: "¿Restablecer tiempo de visibilidad y reintentar?"
       failed_table:
@@ -197,6 +199,7 @@ es:
       index:
         discard_all: Descartar Todo
         discard_all_confirm: "¿Descartar todos los trabajos fallidos?"
+        discard_all_enqueued_notice: Se descartaron %{count} trabajos en cola y se liberaron sus bloqueos.
         retry_all: Reintentar Todo
         retry_all_confirm: "¿Reintentar todos los trabajos fallidos?"
         title: Trabajos

data/config/locales/fi.yml

@@ -179,6 +179,8 @@ fi:
         title: Jonotetut työt
         discard: Hylkää
         discard_confirm: Hylätä tämä viesti?
+        discard_all: Hylkää kaikki
+        discard_all_confirm: Hylkää kaikki jonossa olevat tehtävät ja vapauta lukot? Tätä ei voi perua.
         retry: Yritä uudelleen
         retry_confirm: Nollaa näkyvyysaika ja yritä uudelleen?
       failed_table:
@@ -197,6 +199,7 @@ fi:
       index:
         discard_all: Hylkää kaikki
         discard_all_confirm: Hylätäänkö kaikki epäonnistuneet työt?
+        discard_all_enqueued_notice: Hylättiin %{count} jonossa olevaa tehtävää ja vapautettiin lukot.
         retry_all: Yritä uudelleen kaikki
         retry_all_confirm: Yritetäänkö uudelleen kaikki epäonnistuneet työt?
         title: Työt

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
 

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.3.0"
+  VERSION = "0.3.2"
 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.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -199,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