solid_queue_web 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0aea2023ccc5983daeb0781f0b56105492179d638822d9d6c4a853e7296f3258
-  data.tar.gz: 0b430cccb3b56335a562451f0d598390a4a3f81d2abb1ad5122ce3233fa5663c
+  metadata.gz: cb357c2f74fd24c1a394d54fe2aa53c0fd62a965c3b08e4e359b086243f66e51
+  data.tar.gz: c00154198de848c521c53d02124dcc194fdd54c31e67860a6f70554ad5e055da
 SHA512:
-  metadata.gz: f654b581b1bddc2c2559d39fa09cfc83c0bc664268ba085770179476fbed468e672341025f1d34f5e64c8cb9fc9127914d0d1601a073cc7fb19df03ed890c369
-  data.tar.gz: 5c4794c4ab5e1f5bd5e33aaa4b6630f5de7c4289c55b6506d2f21493c9b63e4e24680b03c2cd1554812426b3b285c5cf640adc079f4b5a9fe93916bcbbd9b3c3
+  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
@@ -60,6 +104,13 @@ SolidQueueWeb surfaces all of this in a browser UI available at any route you ch
 - **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
 
@@ -71,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:
@@ -85,6 +140,10 @@ Then run:
 bundle install
 ```
 
+[↑ Back to top](#table-of-contents)
+
+---
+
 ## Mounting the engine
 
 Add to your `config/routes.rb`:
@@ -95,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:
@@ -115,6 +178,9 @@ SolidQueueWeb.configure do |config|
   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
@@ -126,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
@@ -162,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:
 
@@ -187,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.
 
@@ -213,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.
 
@@ -238,11 +312,15 @@ 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`.
 
-### Installation
+### Setup
 
 The audit log requires an opt-in migration. Run the install generator to copy it to your application:
 
@@ -278,6 +356,10 @@ If not configured, the actor column is left `nil`.
 
 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.
@@ -320,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.
@@ -339,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

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

@@ -8,9 +8,9 @@ module SolidQueueWeb
         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
@@ -20,9 +20,9 @@ module SolidQueueWeb
         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
@@ -41,7 +41,7 @@ module SolidQueueWeb
       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,18 +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

@@ -36,18 +36,19 @@ module SolidQueueWeb
         @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)
         record_audit("jobs_discarded", item_count: jobs.size)
-        redirect_to jobs_return_path, notice: "#{jobs.size} #{"job".pluralize(jobs.size)} discarded."
+        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

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

@@ -5,18 +5,18 @@ module SolidQueueWeb
         queue = SolidQueue::Queue.find_by_name(params[:queue_name])
         queue.pause
         record_audit("queue_paused", queue_name: queue.name)
-        redirect_to queues_path, notice: "Queue \"#{queue.name}\" paused."
+        redirect_to queues_path, notice: t("solid_queue_web.flash.queue_paused", name: queue.name)
       rescue => e
-        redirect_to queues_path, alert: "Could not pause queue: #{e.message}"
+        redirect_to queues_path, alert: t("solid_queue_web.flash.cannot_pause_queue", error: e.message)
       end
 
       def destroy
         queue = SolidQueue::Queue.find_by_name(params[:queue_name])
         queue.resume
         record_audit("queue_resumed", queue_name: queue.name)
-        redirect_to queues_path, notice: "Queue \"#{queue.name}\" resumed."
+        redirect_to queues_path, notice: t("solid_queue_web.flash.queue_resumed", name: queue.name)
       rescue => e
-        redirect_to queues_path, alert: "Could not resume queue: #{e.message}"
+        redirect_to queues_path, alert: t("solid_queue_web.flash.cannot_resume_queue", error: e.message)
       end
     end
   end

data/app/controllers/solid_queue_web/recurring_tasks/runs_controller.rb

@@ -5,14 +5,14 @@ module SolidQueueWeb
       result = task.enqueue(at: Time.current)
 
       if result
-        redirect_to recurring_tasks_path, notice: "\"#{task.key}\" queued for immediate execution."
+        redirect_to recurring_tasks_path, notice: t("solid_queue_web.flash.task_queued", key: task.key)
       else
-        redirect_to recurring_tasks_path, alert: "Could not enqueue \"#{task.key}\" — it may have just run."
+        redirect_to recurring_tasks_path, alert: t("solid_queue_web.flash.cannot_enqueue_task", key: task.key)
       end
     rescue ActiveRecord::RecordNotFound
-      redirect_to recurring_tasks_path, alert: "Recurring task not found."
+      redirect_to recurring_tasks_path, alert: t("solid_queue_web.flash.task_not_found")
     rescue => e
-      redirect_to recurring_tasks_path, alert: "Could not run task: #{e.message}"
+      redirect_to recurring_tasks_path, alert: t("solid_queue_web.flash.cannot_run_task", error: e.message)
     end
   end
 end

data/app/controllers/solid_queue_web/retry_failed_jobs_controller.rb

@@ -8,7 +8,7 @@ module SolidQueueWeb
 
       if params[:stagger].present? && executions.size > 1
         interval = STAGGER_INTERVALS[params[:stagger]]
-        raise ArgumentError, "Invalid stagger interval." unless interval
+        raise ArgumentError, t("solid_queue_web.flash.invalid_stagger") unless interval
         executions.each_with_index do |execution, i|
           execution.job.update!(scheduled_at: i.zero? ? nil : Time.current + (i * interval))
           execution.retry
@@ -23,17 +23,16 @@ module SolidQueueWeb
     rescue ArgumentError => e
       redirect_to failed_jobs_path, alert: e.message
     rescue => e
-      redirect_to failed_jobs_path, alert: "Could not retry job: #{e.message}"
+      redirect_to failed_jobs_path, alert: t("solid_queue_web.flash.cannot_retry_job", error: e.message)
     end
 
     private
 
     def retry_notice(count)
-      label = "#{count} #{"job".pluralize(count)}"
       if params[:stagger].present? && count > 1
-        "#{label} queued for retry, staggered #{params[:stagger]} apart."
+        t("solid_queue_web.flash.jobs_retried_staggered", count: count, stagger: params[:stagger])
       else
-        "#{label} queued for retry."
+        t("solid_queue_web.flash.jobs_retried", count: count)
       end
     end
 

data/app/controllers/solid_queue_web/scheduled_jobs_controller.rb

@@ -8,10 +8,10 @@ module SolidQueueWeb
       SolidQueue::Job.where(id: job_ids).update_all(scheduled_at: 1.second.ago)
 
       redirect_to jobs_path(status: "scheduled", period: @period),
-        notice: "#{job_ids.size} #{"job".pluralize(job_ids.size)} scheduled to run immediately."
+        notice: t("solid_queue_web.flash.jobs_run_immediately", count: job_ids.size)
     rescue => e
       redirect_to jobs_path(status: "scheduled", period: @period),
-        alert: "Could not run jobs: #{e.message}"
+        alert: t("solid_queue_web.flash.cannot_run_jobs", error: e.message)
     end
 
     def update
@@ -26,14 +26,14 @@ module SolidQueueWeb
       respond_to do |format|
         format.turbo_stream
         format.html do
-          notice = @run_now ? "Job scheduled to run immediately." : "Job rescheduled by +#{params[:offset]}."
+          notice = @run_now ? t("solid_queue_web.flash.job_run_immediately") : t("solid_queue_web.flash.job_rescheduled", offset: params[:offset])
           redirect_to jobs_path(status: "scheduled", period: @period), notice: notice
         end
       end
     rescue ArgumentError => e
       redirect_to jobs_path(status: "scheduled"), alert: e.message
     rescue => e
-      redirect_to jobs_path(status: "scheduled"), alert: "Could not reschedule job: #{e.message}"
+      redirect_to jobs_path(status: "scheduled"), alert: t("solid_queue_web.flash.cannot_reschedule_job", error: e.message)
     end
 
     private
@@ -46,7 +46,7 @@ module SolidQueueWeb
 
     def resolve_new_time(execution, offset)
       return 1.second.ago if offset == "now"
-      raise ArgumentError, "Invalid offset." unless PERIOD_DURATIONS.key?(offset)
+      raise ArgumentError, t("solid_queue_web.flash.invalid_offset") unless PERIOD_DURATIONS.key?(offset)
 
       execution.scheduled_at + PERIOD_DURATIONS[offset]
     end