solid_queue_web 1.4.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0d9757682265e639856df718934858d99390e8ca06ff14cb575b117db105932
-  data.tar.gz: a6c0ca7e495f76467cde1aabb0f54674c1439a5489913b4fe9d95837df3acd03
+  metadata.gz: cb357c2f74fd24c1a394d54fe2aa53c0fd62a965c3b08e4e359b086243f66e51
+  data.tar.gz: c00154198de848c521c53d02124dcc194fdd54c31e67860a6f70554ad5e055da
 SHA512:
-  metadata.gz: 41ff634f54cb990c14c57870835f62e091a36130c26e0ecdca0a9fbe07f6ed70b9f128a41d22b59177f03cd21497c3bda9fc17e3044e3fcb843a6031ad9ece3d
-  data.tar.gz: 15ed48fde349d58b1f2778cd9b0cf5a8e502ccd74f610a23368665f938fe36c3d66041400eeb96b3aa196d03a5dd56c7becfbd6b743b055cba60ee01e4cb6c3b
+  metadata.gz: cb41d51eafd160f58fd7e54f8b0be6c95e9f488d43d8c6c32720c9a21e108643df38d6957d3aed50cc4f675d456425a3907a7aee37ab39d423a3a9705b050a5e
+  data.tar.gz: b272217dd76d4fd7f383815b3604acaae7cfdf9ed9bd8c2132539b3c65036398bd9a99431b73b1804fe84d0b47bbe7f0abcc6ad84fb4a6ff770e2630e97c7989

data/README.md

@@ -12,10 +12,46 @@ A monitoring and management dashboard for [Solid Queue](https://github.com/rails
 
 ![SolidQueueWeb dashboard](docs/solid-queue-web.png)
 
+## Table of Contents
+
+- [The problem](#the-problem)
+- [Why SolidQueueWeb?](#why-solidqueueweb)
+- [Real-world use case](#real-world-use-case)
+- [Features](#features)
+- [Compatibility](#compatibility)
+- [Installation](#installation)
+- [Mounting the engine](#mounting-the-engine)
+- [Configuration](#configuration)
+- [Webhook alerts](#webhook-alerts)
+  - [Failure threshold alerts](#failure-threshold-alerts)
+  - [Queue depth alerts](#queue-depth-alerts)
+  - [Slow job alerts](#slow-job-alerts)
+  - [Stale process alerts](#stale-process-alerts)
+- [Admin audit log](#admin-audit-log)
+  - [Setup](#setup)
+  - [Identity](#identity)
+  - [Audited actions](#audited-actions)
+- [Metrics endpoint](#metrics-endpoint)
+- [Read replica support](#read-replica-support)
+- [i18n](#i18n)
+  - [Adding a custom locale](#adding-a-custom-locale)
+- [Extensibility](#extensibility)
+  - [Custom dashboard cards](#custom-dashboard-cards)
+  - [Custom nav links](#custom-nav-links)
+- [Roadmap](#roadmap)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
 ## The problem
 
 Solid Queue ships without a web interface. When jobs fail, queues back up, or workers go silent in production, the only options are `rails console` or raw SQL queries. SolidQueueWeb gives your team a real-time dashboard to inspect, retry, and discard jobs without leaving the browser — and without standing up any additional infrastructure.
 
+[↑ Back to top](#table-of-contents)
+
+---
+
 ## Why SolidQueueWeb?
 
 - Purpose-built for Solid Queue — uses its native models directly, no adapters
@@ -24,6 +60,10 @@ Solid Queue ships without a web interface. When jobs fail, queues back up, or wo
 - Built for Rails 8 — Turbo Frames for in-place updates, Stimulus for dynamic search and auto-refresh, Pagy for efficient pagination
 - Inspired by Sidekiq Web UI and the GoodJob dashboard, adapted for the Solid Queue ecosystem
 
+[↑ Back to top](#table-of-contents)
+
+---
+
 ## Real-world use case
 
 A Rails app processes order confirmations, email notifications, and report generation through Solid Queue. An operations team needs to:
@@ -35,6 +75,10 @@ A Rails app processes order confirmations, email notifications, and report gener
 
 SolidQueueWeb surfaces all of this in a browser UI available at any route you choose.
 
+[↑ Back to top](#table-of-contents)
+
+---
+
 ## Features
 
 - **Dashboard** — stat cards showing counts for ready, scheduled, running, blocked, and failed jobs, plus queues, recurring tasks, and processes; "Done (1h)" and "Done (24h)" throughput cards; a "Throughput — Last 12 Hours" bar chart (blue) and a "Queue Depth — Last 12 Hours" bar chart (purple) showing hourly snapshots of active job count; pure CSS, no charting library; auto-refreshes every 5 seconds
@@ -54,11 +98,19 @@ SolidQueueWeb surfaces all of this in a browser UI available at any route you ch
 - **CSV export** — "Export CSV" button on the jobs, failed jobs, and history pages downloads all records matching the current filters; columns are tailored per view
 - **Slow job detection** — when `slow_job_threshold` is configured, claimed jobs running longer than the threshold are flagged with an orange row, a "slow" badge, and a "Running For" duration column on the Running tab; a "Slow Jobs" warning card appears on the dashboard with a link to the Running tab
 - **Job wait time** — the Running tab shows a "Wait Time" column with how long each job waited in the queue from enqueue to pickup; also exported as `wait_time_seconds` in the claimed-status CSV
+- **Admin audit log** — every discard, retry, queue pause, and resume is recorded to a `solid_queue_web_audit_events` table and viewable at `/jobs/audit` with action/actor/queue filters and CSV export; actor identity captured via the optional `current_actor` config block; requires running the install generator to create the table
 - **Webhook alerts** — set `alert_webhook_url` and `alert_failure_threshold` to receive a POST request whenever the failed job count meets or exceeds the threshold; set `alert_queue_thresholds` for per-queue depth alerts; set `alert_slow_job_count_threshold` (requires `slow_job_threshold`) for slow-job count alerts; set `alert_stale_process_threshold` for stale-worker alerts; all fire asynchronously with a configurable cooldown (default 1 h) to prevent repeated alerts
 - **Performance analytics** — per-job-class statistics at `/jobs/performance` showing run count, average, p50, p95, p99, standard deviation, min, and max duration; sorted by p95 descending so the slowest classes surface first; high std dev surfaces inconsistent jobs worth investigating; period filter scopes to 1h / 24h / 7d or all time; each class name links to the filtered History view
 - **Failed job trend chart** — a "Failures — Last 12 Hours" bar chart on the dashboard shows failures per hour over the last 12 hours; bars are red, making failure spikes visible before clicking into the failed jobs list
 - **Error frequency report** — `GET /jobs/failed_jobs/errors` groups all failed jobs by error class and message prefix, shows a count per group, and surfaces a sample backtrace in an expandable row; sorted by count descending so the most common errors appear first; accessible via the "Error Summary" button on the Failed Jobs page
 - **Metrics / health endpoint** — `GET /jobs/metrics.json` returns a machine-readable JSON document with job counts, throughput, per-queue depth and pause state, and process health summary; suitable for Prometheus scraping, uptime monitors, or external dashboards; `slow_jobs` count included when `slow_job_threshold` is configured
+- **i18n** — all UI strings (page titles, table headers, buttons, empty states, flash messages) are backed by `config/locales/en.yml`; locale switching via `?locale=` param or session; add a custom locale by supplying a YAML file in your host app and registering it with `config.available_locales`
+- **Custom dashboard cards** — `config.dashboard_cards` accepts an array of `{ title:, stats:, link: }` hashes rendered after the built-in queue stat cards; `stats:` is a lambda returning a `{ label => value }` hash evaluated at render time; `link:` is an optional header link
+- **Custom nav links** — `config.nav_links` accepts an array of `{ label:, url: }` hashes appended to the main navigation bar after the built-in links
+
+[↑ Back to top](#table-of-contents)
+
+---
 
 ## Compatibility
 
@@ -70,6 +122,10 @@ SolidQueueWeb surfaces all of this in a browser UI available at any route you ch
 
 Tested on Ruby 3.3, 3.4, and 4.0.
 
+[↑ Back to top](#table-of-contents)
+
+---
+
 ## Installation
 
 Add to your application's Gemfile:
@@ -84,6 +140,10 @@ Then run:
 bundle install
 ```
 
+[↑ Back to top](#table-of-contents)
+
+---
+
 ## Mounting the engine
 
 Add to your `config/routes.rb`:
@@ -94,6 +154,10 @@ mount SolidQueueWeb::Engine, at: "/jobs"
 
 The dashboard will be available at `/jobs`.
 
+[↑ Back to top](#table-of-contents)
+
+---
+
 ## Configuration
 
 All settings are optional — the dashboard works with zero configuration. Create `config/initializers/solid_queue_web.rb` to customize behavior:
@@ -111,8 +175,12 @@ SolidQueueWeb.configure do |config|
   config.alert_slow_job_count_threshold  = 5          # fire when slow job count >= this (default: nil = disabled)
   config.alert_stale_process_threshold  = 1          # fire when stale process count >= this (default: nil = disabled)
   config.alert_webhook_cooldown         = 1800       # seconds between repeated alerts per alert type (default: 3600)
+  config.current_actor                  = -> { current_user&.email } # identity for audit log (default: nil)
   config.connects_to                = { reading: :reading, writing: :writing } # read replica (default: nil)
   config.time_zone                  = "America/New_York" # display timezone for all timestamps (default: nil = UTC)
+  config.available_locales          = [:en, :fr]         # locales available for switching (default: [:en])
+  config.nav_links                  = [{ label: "Admin", url: "/admin" }] # extra nav links (default: [])
+  config.dashboard_cards            = [{ title: "My App", stats: -> { { "Users" => User.count } } }] # custom stat cards (default: [])
 end
 
 SolidQueueWeb.authenticate do
@@ -124,8 +192,16 @@ end
 
 No authentication is enforced by default. When the `authenticate` block returns falsy, HTTP Basic auth is used as a fallback.
 
+[↑ Back to top](#table-of-contents)
+
+---
+
 ## Webhook alerts
 
+The engine supports four webhook alert types, each firing asynchronously with a configurable cooldown to prevent repeated alerts.
+
+### Failure threshold alerts
+
 Set `alert_webhook_url` and `alert_failure_threshold` to receive a POST request whenever the failed job count meets or exceeds the threshold. This is useful for paging an on-call team or triggering a Slack notification via an incoming webhook.
 
 ```ruby
@@ -160,7 +236,7 @@ The request body is JSON:
 
 The webhook fires asynchronously in a background thread so dashboard page loads are never delayed. HTTP errors are logged to `Rails.logger` and swallowed. The cooldown window prevents repeated alerts while the count stays elevated — the clock resets on each app restart.
 
-## Queue depth alerts
+### Queue depth alerts
 
 Set `alert_queue_thresholds` to fire a webhook when any queue's ready job count meets or exceeds a per-queue limit:
 
@@ -185,7 +261,7 @@ The same `alert_webhook_url` endpoint(s) receive the payload, with a distinct ev
 
 Cooldown is tracked independently per queue, so a persistently deep "critical" queue does not suppress alerts for "default". The shared `alert_webhook_cooldown` setting applies to each queue separately.
 
-## Slow job alerts
+### Slow job alerts
 
 Set `alert_slow_job_count_threshold` to fire a webhook when the number of currently-running slow jobs meets or exceeds a count. This requires `slow_job_threshold` to also be configured — it defines what "slow" means.
 
@@ -211,7 +287,7 @@ The same `alert_webhook_url` endpoint(s) receive the payload with a distinct eve
 
 The alert fires on every dashboard page load while the condition persists, subject to the cooldown window.
 
-## Stale process alerts
+### Stale process alerts
 
 Set `alert_stale_process_threshold` to fire a webhook when the number of stale workers meets or exceeds a count. A process is considered stale when its `last_heartbeat_at` has not been updated within `SolidQueue.process_alive_threshold` (default 5 minutes). A stale worker means jobs in its queues have silently stopped processing.
 
@@ -236,6 +312,54 @@ The same `alert_webhook_url` endpoint(s) receive the payload with a distinct eve
 
 The alert fires on every dashboard page load while the condition persists, subject to the cooldown window.
 
+[↑ Back to top](#table-of-contents)
+
+---
+
+## Admin audit log
+
+Every discard, retry, queue pause, and resume action is recorded to a `solid_queue_web_audit_events` table and viewable at `/jobs/audit`.
+
+### Setup
+
+The audit log requires an opt-in migration. Run the install generator to copy it to your application:
+
+```bash
+rails generate solid_queue_web:install:migrations
+rails db:migrate
+```
+
+### Identity
+
+Set `SolidQueueWeb.current_actor` to a block that returns the current user's identity as a string. The block is evaluated in controller context, so you have access to helpers like `current_user`:
+
+```ruby
+SolidQueueWeb.configure do |config|
+  config.current_actor = -> { current_user&.email }
+end
+```
+
+If not configured, the actor column is left `nil`.
+
+### Audited actions
+
+| Action | Trigger |
+|---|---|
+| `job_discarded` | Single job discarded from the jobs list |
+| `jobs_discarded` | Bulk or selection discard from the jobs list |
+| `failed_job_retried` | Single failed job retried |
+| `failed_jobs_retried` | Bulk or selection retry of failed jobs |
+| `failed_job_discarded` | Single failed job discarded |
+| `failed_jobs_discarded` | Bulk or selection discard of failed jobs |
+| `queue_paused` | Queue paused |
+| `queue_resumed` | Queue resumed |
+
+The audit log page at `/jobs/audit` supports filtering by action, actor, and queue name. All records can be exported as CSV.
+
+[↑ Back to top](#table-of-contents)
+
+---
+
 ## Metrics endpoint
 
 `GET /jobs/metrics.json` returns a machine-readable JSON document suitable for Prometheus scraping, uptime monitors, or external dashboards. No configuration is required — the endpoint is available as soon as the engine is mounted.
@@ -278,6 +402,10 @@ When `slow_job_threshold` is configured, a `slow_jobs` integer is also included
 
 The endpoint respects the same authentication and `connects_to` settings as the rest of the dashboard. A process is counted as **stale** when its `last_heartbeat_at` is older than `SolidQueue.process_alive_threshold` (default: 5 minutes).
 
+[↑ Back to top](#table-of-contents)
+
+---
+
 ## Read replica support
 
 Set `connects_to` with both `reading:` and `writing:` keys to enable automatic role switching. GET requests are routed to the reading role; POST/DELETE/PATCH requests use the writing role.
@@ -297,16 +425,104 @@ config.connects_to = { role: :writing }
 
 When `connects_to` is `nil` (the default), no connection switching occurs and single-database apps are unaffected.
 
+[↑ Back to top](#table-of-contents)
+
+---
+
+## i18n
+
+All dashboard UI strings — page titles, table headers, button labels, empty states, and flash messages — are backed by `config/locales/en.yml` in the gem. The engine ships with **English (`en`)** only.
+
+The selected locale is stored in the session and applied via `I18n.with_locale`, so it persists across requests without touching the host application's locale. The `?locale=` query param takes precedence over the session value, making it easy to deep-link to a specific language.
+
+```ruby
+SolidQueueWeb.configure do |config|
+  # Locales available for switching (default: [:en]).
+  config.available_locales = [:en, :fr]
+end
+```
+
+### Adding a custom locale
+
+1. Create a locale file in your host application under `config/locales/`, e.g. `config/locales/solid_queue_web.fr.yml`.
+2. Nest all keys under `fr > solid_queue_web:` — use [`config/locales/en.yml`](config/locales/en.yml) in the gem as a reference for the full key list.
+3. Register the locale:
+
+```ruby
+config.available_locales = [:en, :fr]
+```
+
+Rails will pick up the file automatically via its standard `config.i18n.load_path`; no additional configuration is needed.
+
+[↑ Back to top](#table-of-contents)
+
+---
+
+## Extensibility
+
+### Custom dashboard cards
+
+`config.dashboard_cards` adds custom stat cards to the dashboard after the built-in queue cards. Each card accepts three keys:
+
+| Key | Type | Description |
+|-----|------|-------------|
+| `title` | String | Card heading (required) |
+| `link` | `{ label:, url: }` | Optional header link rendered top-right |
+| `stats` | Lambda | Optional — called at render time; must return a `{ label => value }` hash |
+
+```ruby
+SolidQueueWeb.configure do |config|
+  config.dashboard_cards = [
+    {
+      title: "My App",
+      link:  { label: "View Admin", url: "/admin" },
+      stats: -> { { "Users" => User.count, "Premium" => User.premium.count } }
+    }
+  ]
+end
+```
+
+The `stats` lambda runs on every dashboard render, so keep it fast. Defaults to `[]` — no custom cards appear when unconfigured.
+
+### Custom nav links
+
+`config.nav_links` appends extra links to the main navigation bar after the built-in links. Use it to link back to your host application's admin pages or related tools.
+
+```ruby
+SolidQueueWeb.configure do |config|
+  config.nav_links = [
+    { label: "Back to App", url: "/" },
+    { label: "Admin",       url: "/admin" }
+  ]
+end
+```
+
+Defaults to `[]` — no extra links appear when unconfigured.
+
+[↑ Back to top](#table-of-contents)
+
+---
+
 ## Roadmap
 
 See [ROADMAP.md](ROADMAP.md) for the full post-1.0 feature plan, organized by release milestone.
 
 Pull requests for any of these are welcome. See [Contributing](#contributing) below.
 
+[↑ Back to top](#table-of-contents)
+
+---
+
 ## Contributing
 
 Bug reports and pull requests are welcome on [GitHub](https://github.com/eclectic-coding/solid_queue_web).
 
+[↑ Back to top](#table-of-contents)
+
+---
+
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+[↑ Back to top](#table-of-contents)

data/app/assets/stylesheets/solid_queue_web/_04_table.css

@@ -19,6 +19,34 @@
   font-weight: 600;
 }
 
+.sqd-card__body {
+  padding: 0.75rem 1rem;
+  display: flex;
+  flex-direction: column;
+}
+
+.sqd-custom-stat {
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+  font-size: 13px;
+  padding: 0.375rem 0;
+  border-bottom: 1px solid var(--border);
+}
+
+.sqd-custom-stat:last-child {
+  border-bottom: none;
+}
+
+.sqd-custom-stat__label {
+  color: var(--muted);
+}
+
+.sqd-custom-stat__value {
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+}
+
 table {
   width: 100%;
   border-collapse: collapse;

data/app/controllers/solid_queue_web/application_controller.rb

@@ -8,10 +8,20 @@ module SolidQueueWeb
     STAGGER_INTERVALS  = { "5s" => 5.seconds, "10s" => 10.seconds, "30s" => 30.seconds, "1m" => 1.minute }.freeze
 
     before_action :authenticate!
+    around_action :with_locale
     around_action :with_database_connection
 
     private
 
+    def with_locale
+      available = SolidQueueWeb.available_locales.map(&:to_s)
+      locale = params[:locale].presence_in(available) ||
+               session[:solid_queue_web_locale].presence_in(available) ||
+               I18n.default_locale.to_s
+      session[:solid_queue_web_locale] = locale
+      I18n.with_locale(locale) { yield }
+    end
+
     def with_database_connection
       config = SolidQueueWeb.connects_to
       return yield unless config
@@ -37,5 +47,25 @@ module SolidQueueWeb
     def request_basic_auth
       request_http_basic_authentication("Solid Queue Dashboard")
     end
+
+    def record_audit(action, job_class: nil, queue_name: nil, item_count: 1)
+      AuditEvent.create!(
+        action:     action,
+        actor:      resolve_current_actor,
+        job_class:  job_class,
+        queue_name: queue_name,
+        item_count: item_count
+      )
+    rescue => e
+      Rails.logger.error("[SolidQueueWeb] Audit log failed: #{e.message}")
+    end
+
+    def resolve_current_actor
+      block = SolidQueueWeb.current_actor
+      instance_exec(&block) if block
+    rescue => e
+      Rails.logger.error("[SolidQueueWeb] current_actor block failed: #{e.message}")
+      nil
+    end
   end
 end

data/app/controllers/solid_queue_web/audit_controller.rb

@@ -0,0 +1,43 @@
+module SolidQueueWeb
+  class AuditController < ApplicationController
+    before_action :set_filters
+
+    def index
+      scope = audit_scope
+      respond_to do |format|
+        format.html { @pagy, @audit_events = pagy(scope) }
+        format.csv do
+          send_data audit_csv(scope),
+                    filename: "audit-log-#{Date.today}.csv",
+                    type: "text/csv", disposition: "attachment"
+        end
+      end
+    end
+
+    private
+
+    def set_filters
+      @action_filter = params[:action_filter].presence_in(AuditEvent::ACTIONS)
+      @actor_filter  = params[:actor].presence
+      @queue_filter  = params[:queue].presence
+    end
+
+    def audit_scope
+      scope = AuditEvent.recent
+      scope = scope.where(action:     @action_filter) if @action_filter
+      scope = scope.where(actor:      @actor_filter)  if @actor_filter
+      scope = scope.where(queue_name: @queue_filter)  if @queue_filter
+      scope
+    end
+
+    def audit_csv(scope)
+      CSV.generate(headers: true) do |csv|
+        csv << %w[id action actor job_class queue_name item_count created_at]
+        scope.each do |event|
+          csv << [event.id, event.action, event.actor, event.job_class,
+                  event.queue_name, event.item_count, event.created_at.iso8601]
+        end
+      end
+    end
+  end
+end

data/app/controllers/solid_queue_web/blocked_jobs_controller.rb

@@ -3,9 +3,9 @@ module SolidQueueWeb
     def destroy
       jobs = SolidQueue::BlockedExecution.includes(:job).map(&:job)
       SolidQueue::BlockedExecution.discard_all_from_jobs(jobs)
-      redirect_to root_path, notice: "#{jobs.size} blocked #{"job".pluralize(jobs.size)} discarded."
+      redirect_to root_path, notice: t("solid_queue_web.flash.blocked_jobs_discarded", count: jobs.size)
     rescue => e
-      redirect_to root_path, alert: "Could not discard blocked jobs: #{e.message}"
+      redirect_to root_path, alert: t("solid_queue_web.flash.cannot_discard_blocked_jobs", error: e.message)
     end
   end
 end

data/app/controllers/solid_queue_web/failed_jobs/arguments_controller.rb

@@ -5,11 +5,11 @@ module SolidQueueWeb
       new_arguments = JSON.parse(params[:arguments])
       execution.job.update!(arguments: new_arguments)
       execution.retry
-      redirect_to failed_jobs_path, notice: "Job arguments updated and queued for retry."
+      redirect_to failed_jobs_path, notice: t("solid_queue_web.flash.arguments_updated")
     rescue JSON::ParserError
-      redirect_to job_path(execution.job), alert: "Invalid JSON: could not parse arguments."
+      redirect_to job_path(execution.job), alert: t("solid_queue_web.flash.invalid_json")
     rescue => e
-      redirect_to failed_jobs_path, alert: "Could not update job: #{e.message}"
+      redirect_to failed_jobs_path, alert: t("solid_queue_web.flash.cannot_update_job", error: e.message)
     end
   end
 end

data/app/controllers/solid_queue_web/failed_jobs/selections_controller.rb

@@ -6,10 +6,11 @@ module SolidQueueWeb
         executions = SolidQueue::FailedExecution.where(id: ids)
         jobs = executions.includes(:job).map(&:job)
         SolidQueue::FailedExecution.retry_all(jobs)
+        record_audit("failed_jobs_retried", item_count: jobs.size)
         redirect_to failed_jobs_path,
-          notice: "#{jobs.size} #{"job".pluralize(jobs.size)} queued for retry."
+          notice: t("solid_queue_web.flash.jobs_retried", count: jobs.size)
       rescue => e
-        redirect_to failed_jobs_path, alert: "Could not retry jobs: #{e.message}"
+        redirect_to failed_jobs_path, alert: t("solid_queue_web.flash.cannot_retry_jobs", error: e.message)
       end
 
       def destroy
@@ -17,10 +18,11 @@ module SolidQueueWeb
         executions = SolidQueue::FailedExecution.where(id: ids)
         jobs = executions.includes(:job).map(&:job)
         SolidQueue::FailedExecution.discard_all_from_jobs(jobs)
+        record_audit("failed_jobs_discarded", item_count: jobs.size)
         redirect_to failed_jobs_path,
-          notice: "#{jobs.size} #{"job".pluralize(jobs.size)} discarded."
+          notice: t("solid_queue_web.flash.jobs_discarded", count: jobs.size)
       rescue => e
-        redirect_to failed_jobs_path, alert: "Could not discard jobs: #{e.message}"
+        redirect_to failed_jobs_path, alert: t("solid_queue_web.flash.cannot_discard_jobs", error: e.message)
       end
     end
   end

data/app/controllers/solid_queue_web/failed_jobs_controller.rb

@@ -17,7 +17,7 @@ module SolidQueueWeb
       executions = params[:id] ? [SolidQueue::FailedExecution.find(params[:id])] : filtered_scope.to_a
       perform_discard(executions)
     rescue => e
-      redirect_to failed_jobs_path, alert: "Could not discard job: #{e.message}"
+      redirect_to failed_jobs_path, alert: t("solid_queue_web.flash.cannot_discard_job", error: e.message)
     end
 
     private
@@ -37,9 +37,11 @@ module SolidQueueWeb
 
     def perform_discard(executions)
       jobs = executions.map(&:job)
+      action = params[:id] ? "failed_job_discarded" : "failed_jobs_discarded"
       SolidQueue::FailedExecution.discard_all_from_jobs(jobs)
+      record_audit(action, job_class: jobs.first&.class_name, queue_name: jobs.first&.queue_name, item_count: jobs.size)
       redirect_to failed_jobs_path(queue: @queue, q: @search, period: @period),
-        notice: "#{jobs.size} #{"job".pluralize(jobs.size)} discarded."
+        notice: t("solid_queue_web.flash.jobs_discarded", count: jobs.size)
     end
 
     def sortable_columns

data/app/controllers/solid_queue_web/jobs/selections_controller.rb

@@ -4,17 +4,18 @@ module SolidQueueWeb
       def destroy
         status = params[:status]
         period = params[:period].presence_in(PERIOD_DURATIONS.keys)
-        raise ArgumentError, "Cannot discard #{status} jobs." unless Job::DISCARDABLE.include?(status)
+        raise ArgumentError, t("solid_queue_web.flash.cannot_discard", status: status) unless Job::DISCARDABLE.include?(status)
         model = Job::EXECUTION_MODELS[status]
         ids = Array(params[:ids]).map(&:to_i).reject(&:zero?)
         jobs = model.where(id: ids).includes(:job).map(&:job)
         model.discard_all_from_jobs(jobs)
+        record_audit("jobs_discarded", item_count: jobs.size)
         redirect_to jobs_path(status: status, period: period),
-          notice: "#{jobs.size} #{"job".pluralize(jobs.size)} discarded."
+          notice: t("solid_queue_web.flash.jobs_discarded", count: jobs.size)
       rescue ArgumentError => e
         redirect_to jobs_path(status: status), alert: e.message
       rescue => e
-        redirect_to jobs_path(status: status), alert: "Could not discard jobs: #{e.message}"
+        redirect_to jobs_path(status: status), alert: t("solid_queue_web.flash.cannot_discard_jobs", error: e.message)
       end
     end
   end

data/app/controllers/solid_queue_web/jobs_controller.rb

@@ -30,21 +30,25 @@ module SolidQueueWeb
       model = Job.execution_model_for!(@status)
       if params[:id]
         @execution = model.find(params[:id])
+        discarded_job = @execution.job
         @execution.discard
+        record_audit("job_discarded", job_class: discarded_job&.class_name, queue_name: discarded_job&.queue_name)
         @remaining_count = filtered_scope(model).count
         respond_to do |format|
           format.turbo_stream
-          format.html { redirect_to jobs_return_path, notice: "Job discarded." }
+          format.html { redirect_to jobs_return_path, notice: t("solid_queue_web.flash.job_discarded") }
         end
       else
         jobs = filtered_scope(model).map(&:job)
         model.discard_all_from_jobs(jobs)
-        redirect_to jobs_return_path, notice: "#{jobs.size} #{"job".pluralize(jobs.size)} discarded."
+        record_audit("jobs_discarded", item_count: jobs.size)
+        redirect_to jobs_return_path, notice: t("solid_queue_web.flash.jobs_discarded", count: jobs.size)
       end
     rescue ArgumentError => e
       redirect_to jobs_return_path, alert: e.message
     rescue => e
-      redirect_to jobs_return_path, alert: "Could not discard #{params[:id] ? "job" : "jobs"}: #{e.message}"
+      msg = params[:id] ? t("solid_queue_web.flash.cannot_discard_job", error: e.message) : t("solid_queue_web.flash.cannot_discard_jobs", error: e.message)
+      redirect_to jobs_return_path, alert: msg
     end
 
     private

data/app/controllers/solid_queue_web/queues/jobs_controller.rb

@@ -21,19 +21,19 @@ module SolidQueueWeb
           @remaining_count = filtered_scope(model).count
           respond_to do |format|
             format.turbo_stream
-            format.html { redirect_to queue_jobs_path(queue_name: @queue, status: @status), notice: "Job discarded." }
+            format.html { redirect_to queue_jobs_path(queue_name: @queue, status: @status), notice: t("solid_queue_web.flash.job_discarded") }
           end
         else
           jobs = filtered_scope(model).map(&:job)
           model.discard_all_from_jobs(jobs)
           redirect_to queue_jobs_path(queue_name: @queue, status: @status),
-            notice: "#{jobs.size} #{"job".pluralize(jobs.size)} discarded."
+            notice: t("solid_queue_web.flash.jobs_discarded", count: jobs.size)
         end
       rescue ArgumentError => e
         redirect_to queue_jobs_path(queue_name: @queue, status: @status), alert: e.message
       rescue => e
-        redirect_to queue_jobs_path(queue_name: @queue, status: @status),
-          alert: "Could not discard #{params[:id] ? "job" : "jobs"}: #{e.message}"
+        msg = params[:id] ? t("solid_queue_web.flash.cannot_discard_job", error: e.message) : t("solid_queue_web.flash.cannot_discard_jobs", error: e.message)
+        redirect_to queue_jobs_path(queue_name: @queue, status: @status), alert: msg
       end
 
       private
@@ -51,7 +51,7 @@ module SolidQueueWeb
       end
 
       def execution_model_for!(status)
-        raise ArgumentError, "Cannot discard #{status} jobs from this page." unless Job::DISCARDABLE.include?(status)
+        raise ArgumentError, t("solid_queue_web.flash.cannot_discard_from_queue", status: status) unless Job::DISCARDABLE.include?(status)
         Job::EXECUTION_MODELS[status]
       end
     end