newshound 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c28e3edb5bdc1e1c6af7b0ec4ea8e171fc912670515c19a1bef53f0a2e78f2c5
-  data.tar.gz: e15c37e225e9140e112fd250ac860e555fe02606d1a6dfed40094f435fa94600
+  metadata.gz: e1f84ab484771f1f20e2ef1e27877c0eec621e1a260cc7439a67ec0d2c750036
+  data.tar.gz: 4eb10cad58543c5b40897beedea39ce7ccfeb438303c8de36ae0577a2f2a2a3e
 SHA512:
-  metadata.gz: f89d1b069823ba254f663caf2efe01d4667d560bfc47739b04a98f4653fd3f6f747998aa3594be7848a770bf5f26bbeb705dfa0873d937fbb53565f5310dd252
-  data.tar.gz: ce5a04dfc26b9782da9a308299d9ccc04273aa3ceb260256b9deb951ddf2f9b25b771cbcbcab5d56f46d33b4155b17821d02ca9e55cb6fafd4772c12388f9425
+  metadata.gz: 0d867822e4cd529f0e9b2a2a624ff586da589ccac751cd14f0355ca5bd1bf1643f95ee4ac3ed357ae98a1ccaeb2b7ed437020d2a475507932ae2bf10c69ff596
+  data.tar.gz: e1c6f082a2067af2fc8261a0416bb45b53b1f03147976eb221734bd8cd734eeec220aaa76bad8e35e382264c113f22784a10b2f58476bd9b6630f6e5ec0a4c2a

data/CHANGELOG.md

@@ -5,21 +5,34 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [1.0.2] - 2026-04-03
+## [1.1.0] - 2026-08-04
 
 ### Added
 
-- Bugsink exception source adapter for HTTP-based error tracking (6d3e2a1)
-- exception_source_config option for passing connection details to adapters (6d3e2a1)
-- Minimize button for banner (c686227)
-
-## [1.0.1] - 2026-03-17
+- config.position option for pinning the banner to the bottom of the viewport (1350e11)
+- Separate failing and expired job counts (a6957bd)
+- Close button that clears the banner from the current page (b6d3330)
 
 ### Changed
 
-- The authorize_with initializer will generate with the method inside the configure block. (2d6ef48)
+- Banner CSS uses flat per-element classes instead of nested selectors (a75c3cd)
+- Banner state classes renamed to newshound-banner-collapsed and newshound-banner-minimized (7e95fac)
+- The banner alerts on expired jobs only, not ones still retrying (a6957bd)
+- failed_jobs_threshold is now expired_jobs_threshold, with an alias (a6957bd)
+
+### Fixed
+
+- Minimizing no longer leaves an empty strip where the banner was (b6d3330)
+- Resolved errors no longer appear in the banner (b80e8c9)
+- Repeat occurrences of one error collapse to a single row (b80e8c9)
+- Minimizing no longer hides the banner from genuinely new problems (57dbdf5)
+
+## [1.0.3] - 2026-04-21
 
 ### Added
 
-- Configurable banner links for exceptions, jobs, and warnings via string path patterns (1df1636)
-- Record ID in format_for_banner output for linking to individual records (e06d040)
+- failed_jobs_threshold configuration option (0caac13)
+
+### Changed
+
+- Skip banner injection when there is nothing notable to display (0caac13)

data/README.md

@@ -4,11 +4,11 @@ A Ruby gem that displays real-time exceptions and job statuses in a collapsible
 
 ## Features
 
-- 🎯 **Real-time Web UI Banner** - Shows exceptions and job statuses at the top of every page
+- 🎯 **Real-time Web UI Banner** - Shows exceptions and job statuses at the top or bottom of every page
 - 🔐 **Role-Based Access** - Only visible to authorized users (developers, admins, etc.)
 - 📊 **Que Job Monitoring** - Real-time queue health and job status
 - 🚨 **Exception Tracking** - Recent exceptions from exception-track
-- 🎨 **Collapsible UI** - Clean, non-intrusive banner that expands on click
+- 🎨 **Collapsible UI** - Expand, minimize to a corner pill, or close it out of the way
 - ⚡ **Zero Configuration** - Automatically injects into HTML responses
 - 🔧 **Highly Customizable** - Configure roles and authorization logic
 
@@ -42,6 +42,9 @@ Newshound.configure do |config|
   # Maximum number of exceptions to show in banner
   config.exception_limit = 10
 
+  # Which viewport edge the banner attaches to (:top or :bottom)
+  config.position = :top
+
   # User roles that can view the banner
   config.authorized_roles = [:developer, :super_user]
 
@@ -50,6 +53,77 @@ Newshound.configure do |config|
 end
 ```
 
+### Exception Sources
+
+`config.exception_source` picks where exceptions come from, and `config.exception_source_config` passes options to that source.
+
+| Source | Reads from | Options |
+| --- | --- | --- |
+| `:exception_track` (default) | the `exception-track` gem | none |
+| `:solid_errors` | the `solid_errors` gem | `unresolved_only` |
+| `:bugsink` | the Bugsink API | `url`, `token`, `project_id` (all required) |
+
+```ruby
+Newshound.configure do |config|
+  config.exception_source = :solid_errors
+  config.exception_source_config = {unresolved_only: true}
+end
+```
+
+#### Solid Errors and `unresolved_only`
+
+**`unresolved_only` defaults to `true`, which changes what the banner shows for apps upgrading from 1.0.x.** Older versions listed `SolidErrors::Occurrence` rows, which carry no resolved state, so resolving an error in your `/errors` UI left the banner lit.
+
+With the default, the banner lists one row per unresolved `SolidErrors::Error`:
+
+- Resolving an error removes it from the banner.
+- An error that happened 300 times takes one banner slot instead of 300.
+- The location slot shows the occurrence count — "300 occurrences" — rather than `controller#action`, because request context is recorded per occurrence and an error row has none.
+
+Banner links still point at the error, so `config.exception_links = {show: "/errors/:id"}` resolves the same way in both modes.
+
+Set `unresolved_only: false` to go back to listing individual occurrences.
+
+### Banner Position
+
+By default the banner is fixed to the top of the viewport, and the page body gets matching top padding so the banner never covers content.
+
+Set `config.position = :bottom` to move it to the bottom edge. A bottom banner floats over the page and reserves no space at all — nothing shifts, and the panel expands upward when you click the header. It does overlap whatever sits at the very bottom of the page, which is the tradeoff for leaving layout untouched.
+
+Bottom placement suits apps with their own fixed header or sticky navigation, where a top banner would overlay the nav or throw off scroll-position calculations.
+
+```ruby
+Newshound.configure do |config|
+  config.position = :bottom
+end
+```
+
+Any value other than `:top` or `:bottom` raises an `ArgumentError`.
+
+### Job Statistics
+
+Que tracks two distinct trouble states, and Newshound reports them separately:
+
+- **Failing** — the job errored but still has retries left. These usually clear themselves and are not worth an alert.
+- **Expired** — the job ran out of retries. Nothing will run it again until a person does something.
+
+Only expired jobs trigger the banner. `config.expired_jobs_threshold` sets how many are tolerated before it appears:
+
+```ruby
+Newshound.configure do |config|
+  # Show the banner as soon as a single job expires
+  config.expired_jobs_threshold = 0
+end
+```
+
+The default is 0. Since an expired job is already dead, raising the threshold means hiding jobs that need attention — raise it only if you have a backlog you have deliberately decided to ignore.
+
+`failed_jobs_threshold` is the old name for this setting and still works. It used to gate every errored job, retrying ones included, so a value chosen to absorb transient retries is now suppressing that many genuinely dead jobs. Drop it to 0 when you rename it.
+
+`queue_statistics` and `job_counts_by_type` also still return a `:failed` key, the union of failing and expired. Its value is unchanged from earlier versions, but it is deprecated — read `:failing` and `:expired` instead.
+
+Job links follow the same split. `job_links[:failing]` and `job_links[:expired]` point the two stats at your dashboard; `job_links[:failed]` is accepted as the old name for `:failing`.
+
 ### Advanced: Custom Authorization
 
 If the default role-based authorization doesn't fit your needs, you can provide custom logic:
@@ -92,27 +166,44 @@ Newshound uses Rails middleware to automatically inject a banner into HTML respo
 1. ✅ Appears automatically on all HTML pages
 2. 🔒 Only visible to users with authorized roles
 3. 📊 Shows real-time data from your exception and job queues
-4. 🎨 Collapses to save space, expands on click
-5. 🚀 No JavaScript dependencies, pure CSS animations
+4. 🎨 Collapses, minimizes, or closes out of the way (see [Banner Controls](#banner-controls))
+5. 🚀 No build step and no framework — it ships its own CSS and JS inline
 
 ## Banner Content
 
 The banner displays:
 
 ### Exception Section
-- Recent exceptions from exception-track
+- Recent exceptions from the configured exception source
 - Exception class and message
-- Controller/action where it occurred
+- Controller/action where it occurred, or the occurrence count (see [Exception Sources](#exception-sources))
 - Timestamp
 - Visual indicators (🟢 all clear / 🔴 errors)
 
 ### Job Queue Section
 - **Ready to Run**: Jobs waiting to execute
 - **Scheduled**: Jobs scheduled for future execution
-- **Failed**: Jobs in retry queue
+- **Failing**: Jobs that errored and will retry
+- **Expired**: Jobs that ran out of retries
 - **Completed Today**: Successfully finished jobs
 - Color-coded health status
 
+## Banner Controls
+
+The banner header carries three buttons, all keyboard accessible:
+
+| Control | Does |
+| --- | --- |
+| ▼ Toggle details | Expands or collapses the exception and job sections. Clicking anywhere on the header does the same. |
+| − Minimize | Shrinks the banner to a 🐕 pill in the corner. Click the pill to bring the banner back. |
+| × Close | Removes the banner from the current page so you can reach whatever it was covering. |
+
+Closing is a per-page escape hatch, not an opt-out: the next page shows the banner as the minimized pill, so you still get the signal. Minimize and close both persist to `localStorage` under `newshound-minimized`, and restoring from the pill clears it.
+
+Minimizing is not permanent either. Newshound stores a signature of what you were looking at when you minimized — the exception count, the newest exception id, the same two for warnings, and the failed job count — under `newshound-signature`. When any of those numbers is higher on a later page, something has gone wrong that you have not seen, so the banner comes back as the thin bar and the stored flag is dropped. Numbers that only fall — someone worked through the backlog — are not news, and the pill stays put.
+
+There is no setting to make minimize stick. A banner you can silence forever is one that eventually leaves you blind, which is the failure this whole thing exists to prevent. To turn the banner off entirely, set `config.enabled = false` or narrow `authorized_roles`.
+
 ## User Requirements
 
 Your User model should have a `role` attribute that matches one of the configured `authorized_roles`. Common patterns:
@@ -211,7 +302,13 @@ This gem uses [Reissue](https://github.com/SOFware/reissue) for release manageme
 - **que** >= 1.0 (for job monitoring)
 - **exception-track** >= 0.1 (for exception tracking)
 
-## Upgrading from 0.1.x
+## Upgrading
+
+### Resolved errors now drop out of the banner
+
+Apps on `config.exception_source = :solid_errors` get the new `unresolved_only` default of `true` with no config change, so the banner stops showing errors you have resolved and collapses repeat occurrences into one row. See [Solid Errors and `unresolved_only`](#solid-errors-and-unresolved_only) for what the banner looks like either way, and set `unresolved_only: false` to keep the old listing.
+
+### From 0.1.x
 
 If you were using the previous Slack-based version:
 

data/lib/generators/newshound/install/templates/newshound.rb

@@ -1,26 +1,41 @@
 # frozen_string_literal: true
 
 Newshound.configure do |config|
-  # Enable or disable Newshound completely
-  # When enabled, the banner will be shown to authorized users
-  # Default is true
+  # Enable or disable Newshound completely When enabled, the banner will be shown to
+  # authorized users Default is true
   config.enabled = true
 
-  # Maximum number of exceptions to include in banner
-  # Default is 10
+  # Maximum number of exceptions to include in banner Default is 10
   config.exception_limit = 10
 
   # Exception source to use for exceptions
   # Default is :exception_track
-  config.exception_source = :exception_track # or :solid_errors
+  config.exception_source = :exception_track # or :solid_errors, :bugsink
 
-  # Job source adapter for monitoring background jobs
-  # Uncomment and set to enable job monitoring in the banner
+  # Options passed to the exception source
+  # :solid_errors shows one row per unresolved error, so resolving an error in
+  # your /errors UI clears it from the banner Set unresolved_only: false to list
+  # individual occurrences instead
+  # config.exception_source_config = {unresolved_only: true}
+
+  # Job source adapter for monitoring background jobs Uncomment and set to enable job
+  # monitoring in the banner
   # config.job_source = :que # or a custom adapter instance
   # See Newshound::Jobs::Base for the adapter interface
 
-  # User roles that are authorized to view the Newshound banner
-  # These should match the role values in your User model
+  # Number of expired jobs at or below which the banner is suppressed
+  # Expired jobs are out of retries, so 0 is the recommended value
+  # Jobs that are still retrying never trigger the banner
+  # Default is 0 (any expired job triggers the banner)
+  # config.expired_jobs_threshold = 0
+
+  # Which viewport edge the banner attaches to, :top or :bottom
+  # Use :bottom to keep the banner clear of fixed headers and sticky navigation
+  # Default is :top
+  # config.position = :bottom
+
+  # User roles that are authorized to view the Newshound banner These should match
+  # the role values in your User model
   # Default is [:developer, :super_user]
   config.authorized_roles = [:developer, :super_user]
 
@@ -29,8 +44,8 @@ Newshound.configure do |config|
   # Default is :current_user
   config.current_user_method = :current_user
 
-  # Links for banner items
-  # Configure paths so banner items link to your exception/job dashboards.
+  # Links for banner items Configure paths so banner items link to your exception/job
+  # dashboards.
   # Use :id in show paths to interpolate the record ID.
   #
   # config.exception_links = {
@@ -42,7 +57,8 @@ Newshound.configure do |config|
   #   index: "/background_jobs",
   #   show: "/background_jobs/jobs/:id",
   #   scheduled: "/background_jobs/scheduled",
-  #   failed: "/background_jobs/failed",
+  #   failing: "/background_jobs/failing",
+  #   expired: "/background_jobs/expired",
   #   completed: "/background_jobs/completed"
   # }
   #

data/lib/newshound/configuration.rb

@@ -2,12 +2,22 @@
 
 module Newshound
   class Configuration
+    POSITIONS = %i[top bottom].freeze
+
     attr_accessor :exception_limit, :enabled, :authorized_roles,
       :current_user_method, :authorization_block, :exception_source,
       :exception_source_config,
       :warning_source, :warning_limit, :job_source,
+      :expired_jobs_threshold,
       :exception_links, :job_links, :warning_links
 
+    # The pre-1.0.4 name. It now gates expired jobs rather than every errored job,
+    # so a value tuned to absorb retries is worth revisiting.
+    alias_method :failed_jobs_threshold, :expired_jobs_threshold
+    alias_method :failed_jobs_threshold=, :expired_jobs_threshold=
+
+    attr_reader :position
+
     def initialize
       @exception_limit = 10
       @enabled = true
@@ -19,9 +29,21 @@ module Newshound
       @warning_source = nil
       @warning_limit = 10
       @job_source = nil
+      @expired_jobs_threshold = 0
       @exception_links = {}
       @job_links = {}
       @warning_links = {}
+      @position = :top
+    end
+
+    # Which viewport edge the banner attaches to, :top or :bottom
+    def position=(value)
+      unless POSITIONS.include?(value)
+        raise ArgumentError,
+          "Invalid position: #{value.inspect}. Must be :top or :bottom"
+      end
+
+      @position = value
     end
 
     # Allow custom authorization logic

data/lib/newshound/exceptions/solid_errors.rb

@@ -1,7 +1,20 @@
 module Newshound
   module Exceptions
     class SolidErrors < Base
+      LAST_OCCURRED_AT = "MAX(solid_errors_occurrences.created_at) AS last_occurred_at"
+      OCCURRENCE_COUNT = "COUNT(solid_errors_occurrences.id) AS occurrence_count"
+
+      # Pass `unresolved_only: false` in exception_source_config to list raw
+      # occurrence rows instead of one row per unresolved error.
+      def initialize(config = {})
+        super
+        config = config.transform_keys(&:to_sym)
+        @unresolved_only = config.fetch(:unresolved_only, true)
+      end
+
       def recent(time_range:, limit:)
+        return unresolved_errors(time_range, limit) if @unresolved_only
+
         ::SolidErrors::Occurrence
           .where("created_at >= ?", time_range.ago)
           .order(created_at: :desc)
@@ -13,8 +26,8 @@ module Newshound
 
         <<~TEXT
           *#{number}. #{details[:title]}*
-          • *Time:* #{exception.created_at.strftime("%I:%M %p")}
-          #{format_controller(details)}
+          • *Time:* #{details[:time]}
+          #{format_location(details)}
           #{format_message(details)}
         TEXT
       end
@@ -23,32 +36,80 @@ module Newshound
         details = parse_exception_details(exception)
 
         {
-          id: exception.try(:error)&.id || exception.try(:id),
+          id: banner_id(exception),
           title: details[:title],
           message: details[:message].truncate(100),
           location: details[:location],
-          time: exception.created_at.strftime("%I:%M %p")
+          time: details[:time]
         }
       end
 
       private
 
+      # Apps build /errors/:id links from this, so both modes report the error id.
+      def banner_id(exception)
+        return exception.id if @unresolved_only
+
+        exception.try(:error)&.id || exception.try(:id)
+      end
+
+      # Resolved state lives on the parent error, so listing errors rather than
+      # occurrences is what lets the /errors UI quiet the banner. Grouping also keeps
+      # one error hit 300 times from filling every banner slot.
+      def unresolved_errors(time_range, limit)
+        ::SolidErrors::Error
+          .unresolved
+          .joins(:occurrences)
+          .where(solid_errors_occurrences: {created_at: time_range.ago..})
+          .group(:id)
+          .select("solid_errors.*", LAST_OCCURRED_AT, OCCURRENCE_COUNT)
+          .order("last_occurred_at DESC")
+          .limit(limit)
+      end
+
       def parse_exception_details(exception)
+        @unresolved_only ? error_details(exception) : occurrence_details(exception)
+      end
+
+      # Request context is recorded per occurrence, so an error row has none to
+      # offer the location slot. The occurrence count is what grouping produces,
+      # and it is already selected.
+      def error_details(exception)
+        {
+          title: exception.exception_class.presence || "Unknown Exception",
+          message: exception.message.presence.to_s,
+          location: occurrence_summary(exception),
+          location_label: "Occurrences",
+          time: format_time(exception.last_occurred_at)
+        }
+      end
+
+      def occurrence_details(exception)
         context_data = parse_context(exception)
         controller = context_data["controller"]
         action = context_data["action"]
-
         error_record = exception.try(:error)
+        message = error_record&.message.presence || context_data["message"].presence
 
         {
           title: error_record&.exception_class.presence || "Unknown Exception",
-          message: error_record&.message.presence&.to_s || context_data["message"].presence&.to_s || +"",
+          message: message.to_s,
           location: (controller && action) ? "#{controller}##{action}" : +"",
-          controller: controller,
-          action: action
+          location_label: "Controller",
+          time: format_time(exception.created_at)
         }
       end
 
+      def occurrence_summary(exception)
+        count = exception.occurrence_count.to_i
+        "#{count} #{(count == 1) ? "occurrence" : "occurrences"}"
+      end
+
+      # MAX() comes back as a String on some adapters.
+      def format_time(time)
+        time.in_time_zone.strftime("%I:%M %p")
+      end
+
       def parse_context(exception)
         return {} unless exception.respond_to?(:context) && exception.context.present?
 
@@ -64,10 +125,10 @@ module Newshound
         {}
       end
 
-      def format_controller(details)
-        return +"" unless details in {controller: String, action: String}
+      def format_location(details)
+        return +"" if details[:location].blank?
 
-        "• *Controller:* #{details[:location]}\n"
+        "• *#{details[:location_label]}:* #{details[:location]}\n"
       end
 
       def format_message(details)

data/lib/newshound/job_reporter.rb

@@ -60,13 +60,20 @@ module Newshound
       lines = ["*Job Counts by Type:*"]
 
       counts.each do |job_class, stats|
-        status_emoji = (stats[:failed] > 0) ? "⚠️" : "✅"
-        lines << "• #{status_emoji} *#{job_class}*: #{stats[:total]} total (#{stats[:success]} success, #{stats[:failed]} failed)"
+        breakdown = "#{stats[:success]} success, #{stats[:failing].to_i} failing, #{stats[:expired].to_i} expired"
+        lines << "• #{job_status_emoji(stats)} *#{job_class}*: #{stats[:total]} total (#{breakdown})"
       end
 
       lines.join("\n")
     end
 
+    def job_status_emoji(stats)
+      return "⚠️" if stats[:expired].to_i > 0
+      return "🟡" if stats[:failing].to_i > 0
+
+      "✅"
+    end
+
     def queue_health_section
       stats = job_source.queue_statistics
 
@@ -80,17 +87,21 @@ module Newshound
     end
 
     def format_queue_health(stats)
-      health_emoji = if stats[:failed] > 10
+      failing = stats[:failing].to_i
+      expired = stats[:expired].to_i
+
+      health_emoji = if expired > 0
         "🔴"
       else
-        (stats[:failed] > 5) ? "🟡" : "🟢"
+        (failing > 0) ? "🟡" : "🟢"
       end
 
       <<~TEXT
         *Queue Health #{health_emoji}*
         • *Ready to Run:* #{stats[:ready]}
         • *Scheduled:* #{stats[:scheduled]}
-        • *Failed (Retry Queue):* #{stats[:failed]}
+        • *Failing (Will Retry):* #{failing}
+        • *Expired (Out of Retries):* #{expired}
         • *Completed Today:* #{stats[:finished_today]}
       TEXT
     end

data/lib/newshound/jobs/base.rb

@@ -18,21 +18,25 @@ module Newshound
     class Base
       # Returns queue-level statistics
       #
-      # @return [Hash] with keys :ready, :scheduled, :failed, :finished_today
+      # @return [Hash] with keys :ready, :scheduled, :failing, :expired, :failed,
+      #   :finished_today. :failing counts jobs that errored and will retry,
+      #   :expired counts jobs that are out of retries. :failed is the union and is
+      #   deprecated.
       def queue_statistics
         raise NotImplementedError, "#{self.class} must implement #queue_statistics"
       end
 
       # Returns job counts grouped by job class
       #
-      # @return [Hash] job_class => { success:, failed:, total: }
+      # @return [Hash] job_class => { success:, failing:, expired:, failed:, total: }
       def job_counts_by_type
         raise NotImplementedError, "#{self.class} must implement #job_counts_by_type"
       end
 
       # Returns data formatted for the banner UI
       #
-      # @return [Hash] with key :queue_stats containing ready_to_run, scheduled, failed, completed_today
+      # @return [Hash] with key :queue_stats containing ready_to_run, scheduled,
+      #   failing, expired, failed, completed_today
       def format_for_banner
         stats = queue_statistics
 
@@ -40,6 +44,9 @@ module Newshound
           queue_stats: {
             ready_to_run: stats[:ready],
             scheduled: stats[:scheduled],
+            failing: stats[:failing],
+            # Adapters written before the failing/expired split report only :failed.
+            expired: stats.fetch(:expired) { stats[:failed] },
             failed: stats[:failed],
             completed_today: stats[:finished_today]
           }

data/lib/newshound/jobs/que.rb

@@ -9,6 +9,9 @@ module Newshound
         @logger = logger || (defined?(Rails) ? Rails.logger : Logger.new($stdout))
       end
 
+      # Que separates two trouble states: a failing job has errored but still has
+      # retries left, an expired job has run out of them and needs a human. :failed
+      # is the union of the two, kept for callers written before the split.
       def queue_statistics
         conn = ActiveRecord::Base.connection
         current_time = conn.quote(Time.now)
@@ -17,37 +20,40 @@ module Newshound
         {
           ready: count_jobs("finished_at IS NULL AND expired_at IS NULL AND run_at <= #{current_time}"),
           scheduled: count_jobs("finished_at IS NULL AND expired_at IS NULL AND run_at > #{current_time}"),
+          failing: count_jobs("error_count > 0 AND finished_at IS NULL AND expired_at IS NULL"),
+          expired: count_jobs("expired_at IS NOT NULL"),
           failed: count_jobs("error_count > 0 AND finished_at IS NULL"),
           finished_today: count_jobs("finished_at >= #{beginning_of_day}")
         }
       rescue => e
         logger.error "Failed to fetch Que statistics: #{e.message}"
-        {ready: 0, scheduled: 0, failed: 0, finished_today: 0}
+        {ready: 0, scheduled: 0, failing: 0, expired: 0, failed: 0, finished_today: 0}
       end
 
       def job_counts_by_type
         results = ActiveRecord::Base.connection.execute(<<~SQL)
-          SELECT job_class, error_count, COUNT(*) as count
+          SELECT job_class,
+                 COUNT(*) FILTER (WHERE error_count = 0 AND expired_at IS NULL) AS success,
+                 COUNT(*) FILTER (WHERE error_count > 0 AND expired_at IS NULL) AS failing,
+                 COUNT(*) FILTER (WHERE expired_at IS NOT NULL) AS expired,
+                 COUNT(*) AS total
           FROM que_jobs
           WHERE finished_at IS NULL
-          GROUP BY job_class, error_count
+          GROUP BY job_class
           ORDER BY job_class
         SQL
 
         results.each_with_object({}) do |row, hash|
-          job_class = row["job_class"]
-          error_count = row["error_count"].to_i
-          count = row["count"].to_i
+          failing = row["failing"].to_i
+          expired = row["expired"].to_i
 
-          hash[job_class] ||= {success: 0, failed: 0, total: 0}
-
-          if error_count.zero?
-            hash[job_class][:success] += count
-          else
-            hash[job_class][:failed] += count
-          end
-
-          hash[job_class][:total] += count
+          hash[row["job_class"]] = {
+            success: row["success"].to_i,
+            failing:,
+            expired:,
+            failed: failing + expired,
+            total: row["total"].to_i
+          }
         end
       rescue => e
         logger.error "Failed to fetch job counts: #{e.message}"

data/lib/newshound/middleware/banner_injector.rb

@@ -19,8 +19,9 @@ module Newshound
         return [status, headers, response] unless controller
         return [status, headers, response] unless Newshound::Authorization.authorized?(controller)
 
-        # Get banner HTML
+        # Get banner HTML (nil when nothing notable to display)
         banner_html = generate_banner_html
+        return [status, headers, response] unless banner_html
 
         # Inject banner after <body> tag
         new_response = inject_banner(response, banner_html)
@@ -62,135 +63,394 @@ module Newshound
         job_data = job_reporter.banner_data
         warning_data = warning_reporter.banner_data
 
-        # Generate HTML from template
+        return nil unless notable_data?(exception_data, job_data, warning_data)
+
         render_banner(exception_data, job_data, warning_data)
       end
 
+      # Only expired jobs are worth interrupting someone over. Failing jobs still
+      # have retries left and usually clear themselves.
+      def notable_data?(exception_data, job_data, warning_data)
+        exception_count = exception_data[:exceptions]&.length || 0
+        expired_jobs = job_data.dig(:queue_stats, :expired) || 0
+        warning_count = warning_data[:warnings]&.length || 0
+        threshold = Newshound.configuration.expired_jobs_threshold
+
+        exception_count > 0 || warning_count > 0 || expired_jobs > threshold
+      end
+
+      # The stylesheet is a sibling of the banner so closing can remove the banner
+      # without taking the `html body` padding rule down with it.
       def render_banner(exception_data, job_data, warning_data = {})
         <<~HTML
-          <div id="newshound-banner" class="newshound-banner newshound-collapsed">
-            #{render_styles}
-            <div class="newshound-header" onclick="document.getElementById('newshound-banner').classList.toggle('newshound-collapsed'); window.newshoundUpdatePadding();">
+          #{render_styles}
+          <div id="newshound-banner" class="#{positioned_class(:banner)} newshound-banner-collapsed" data-newshound-signature="#{escape_html(banner_signature(exception_data, job_data, warning_data))}">
+            <div class="newshound-header" data-newshound-action="toggle">
               <span class="newshound-title">
                 🐕 Newshound
                 #{summary_badge(exception_data, job_data, warning_data)}
               </span>
               <span class="newshound-header-controls">
-                <span class="newshound-minimize" onclick="event.stopPropagation(); document.getElementById('newshound-banner').classList.add('newshound-minimized'); localStorage.setItem('newshound-minimized','1'); window.newshoundUpdatePadding();" title="Minimize">−</span>
-                <span class="newshound-toggle">▼</span>
+                #{render_header_controls}
               </span>
             </div>
-            <div class="newshound-content">
+            <div class="#{positioned_class(:content)}">
               #{render_exceptions(exception_data)}
               #{render_warnings(warning_data)}
               #{render_jobs(job_data)}
             </div>
-            <div class="newshound-restore" onclick="document.getElementById('newshound-banner').classList.remove('newshound-minimized'); localStorage.removeItem('newshound-minimized'); window.newshoundUpdatePadding();" title="Restore Newshound">
-              🐕
-            </div>
+            #{render_restore_control}
           </div>
           #{render_script}
         HTML
       end
 
+      # Two sections, compared by different rules. The counts only rise when there is
+      # something unseen, so the script reads a rise as news and a fall as cleanup.
+      # The id lists catch one item arriving while another is cleared, which leaves
+      # the counts unchanged, and they work for sources whose ids are not numbers.
+      def banner_signature(exception_data, job_data, warning_data)
+        exceptions = exception_data[:exceptions] || []
+        warnings = warning_data[:warnings] || []
+
+        [
+          [exceptions.length, warnings.length, actionable_jobs(job_data)].join(","),
+          item_ids(exceptions),
+          item_ids(warnings)
+        ].join("|")
+      end
+
+      # Mirror what the banner itself treats as worth showing: jobs at or below the
+      # threshold never raise it, so a rise within that tolerance is not news either.
+      # Adapters predating the failing/expired split report :failed alone.
+      def actionable_jobs(job_data)
+        stats = job_data[:queue_stats] || {}
+        count = stats.fetch(:expired) { stats[:failed] } || 0
+
+        (count > Newshound.configuration.failed_jobs_threshold) ? count : 0
+      end
+
+      def item_ids(items)
+        items.filter_map { |item| item[:id] }.join(",")
+      end
+
+      def render_header_controls
+        <<~HTML
+          <button type="button" class="newshound-control newshound-toggle" data-newshound-action="toggle" aria-expanded="false" aria-label="Toggle Newshound details" title="Toggle details">▼</button>
+          <button type="button" class="newshound-control newshound-minimize" data-newshound-action="minimize" aria-label="Minimize Newshound" title="Minimize to a corner pill">−</button>
+          <button type="button" class="newshound-control newshound-close" data-newshound-action="close" aria-label="Close Newshound" title="Close (returns minimized on the next page)">×</button>
+        HTML
+      end
+
+      # The only way back once the banner is minimized, so it is always rendered and
+      # always focusable.
+      def render_restore_control
+        <<~HTML
+          <button type="button" class="newshound-control newshound-restore" data-newshound-action="restore" aria-label="Restore Newshound" title="Restore Newshound">🐕</button>
+        HTML
+      end
+
       def render_script
         <<~JS
           <script>
             (function() {
-              // Restore minimized state from localStorage
-              if (localStorage.getItem('newshound-minimized')) {
-                document.getElementById('newshound-banner').classList.add('newshound-minimized');
+              function banner() {
+                return document.getElementById('newshound-banner');
               }
 
-              var cachedPriority, cachedBodyRule;
+              // Read once: closing detaches the banner, and the flag is written
+              // after that.
+              var signature = banner().getAttribute('data-newshound-signature');
 
-              // Detect once whether any non-newshound stylesheet uses !important on body padding-top
-              function detectPriority() {
-                var styles = document.querySelectorAll('style:not(#newshound-styles)');
-
-                for (var i = 0; i < styles.length; i++) {
-                  if (styles[i].textContent.match(/body\\s*{[^}]*padding-top[^;]*!important/s)) {
-                    return 'important';
-                  }
-                }
+              // localStorage throws in some private-browsing modes, and a throw here
+              // would leave a control half-applied.
+              function rememberMinimized() {
+                try {
+                  localStorage.setItem('newshound-minimized', '1');
+                  localStorage.setItem('newshound-signature', signature);
+                } catch (e) {}
+              }
 
+              function forgetMinimized() {
                 try {
-                  for (var s = 0; s < document.styleSheets.length; s++) {
-                    var sheet = document.styleSheets[s];
-                    if (sheet.ownerNode && sheet.ownerNode.id === 'newshound-styles') continue;
-                    var rules = sheet.cssRules || [];
-                    for (var r = 0; r < rules.length; r++) {
-                      if (rules[r].selectorText === 'body' &&
-                          rules[r].style.getPropertyPriority('padding-top') === 'important') {
-                        return 'important';
-                      }
-                    }
-                  }
+                  localStorage.removeItem('newshound-minimized');
+                  localStorage.removeItem('newshound-signature');
                 } catch (e) {}
+              }
 
-                return '';
+              function wasMinimized() {
+                try {
+                  return localStorage.getItem('newshound-minimized') === '1';
+                } catch (e) {
+                  return false;
+                }
               }
 
-              // Find the html body rule in the newshound stylesheet once
-              function findBodyRule() {
-                var styleEl = document.getElementById('newshound-styles');
-                if (!styleEl || !styleEl.sheet) return null;
-                var rules = styleEl.sheet.cssRules;
-                for (var i = 0; i < rules.length; i++) {
-                  if (rules[i].selectorText === 'html body') return rules[i];
+              // Any number that has risen since the developer minimized the banner
+              // is a problem they have not seen yet. Anything else — a number that
+              // fell, or a signature this version cannot read — is not news.
+              function hasNewNews() {
+                var seen;
+                try { seen = localStorage.getItem('newshound-signature'); } catch (e) {}
+                if (!seen) return true;
+
+                var now = signature.split('|');
+                var before = seen.split('|');
+                if (now.length !== before.length) return true;
+
+                if (hasRisen(now[0], before[0])) return true;
+
+                for (var s = 1; s < now.length; s++) {
+                  if (hasUnseenId(now[s], before[s])) return true;
                 }
-                return null;
+
+                return false;
               }
 
-              window.newshoundUpdatePadding = function() {
-                setTimeout(function() {
-                  var banner = document.getElementById('newshound-banner');
-                  if (!banner) return;
+              function hasRisen(counts, seenCounts) {
+                var now = counts.split(',');
+                var before = seenCounts.split(',');
+                if (now.length !== before.length) return true;
 
-                  if (cachedBodyRule === undefined) cachedBodyRule = findBodyRule();
-                  if (!cachedBodyRule) return;
+                for (var i = 0; i < now.length; i++) {
+                  if (Number(now[i]) > Number(before[i])) return true;
+                }
+
+                return false;
+              }
 
-                  if (cachedPriority === undefined) cachedPriority = detectPriority();
+              // Clearing an item leaves every remaining id already seen, so only an
+              // arrival counts.
+              function hasUnseenId(current, seen) {
+                if (!current) return false;
 
-                  cachedBodyRule.style.setProperty('padding-top', banner.offsetHeight + 'px', cachedPriority);
-                }, 300);
-              };
+                var known = seen ? seen.split(',') : [];
+                var ids = current.split(',');
 
-              if (document.readyState === 'loading') {
-                document.addEventListener('DOMContentLoaded', window.newshoundUpdatePadding);
-              } else {
-                window.newshoundUpdatePadding();
+                for (var i = 0; i < ids.length; i++) {
+                  if (known.indexOf(ids[i]) === -1) return true;
+                }
+
+                return false;
               }
 
-              window.addEventListener('resize', window.newshoundUpdatePadding);
+              // Applied before the padding script below takes its first measurement.
+              // A minimize lasts only until the next problem the developer has not
+              // seen, so it cannot leave them blind.
+              if (wasMinimized()) {
+                if (hasNewNews()) {
+                  forgetMinimized();
+                } else {
+                  banner().classList.add('newshound-banner-minimized');
+                }
+              }
+
+              #{render_controls_script}
+
+              #{render_padding_script}
             })();
           </script>
         JS
       end
 
+      def render_controls_script
+        <<~JS
+          var actions = {
+            toggle: function(el) {
+              var expanded = !el.classList.toggle('newshound-banner-collapsed');
+              var toggle = el.querySelector('.newshound-toggle');
+              if (toggle) toggle.setAttribute('aria-expanded', expanded ? 'true' : 'false');
+            },
+            // Minimize and restore each hide the control the keyboard is sitting on,
+            // so each hands focus to the one that replaces it.
+            minimize: function(el) {
+              el.classList.add('newshound-banner-minimized');
+              rememberMinimized();
+              focusControl(el, '.newshound-restore');
+            },
+            restore: function(el) {
+              el.classList.remove('newshound-banner-minimized');
+              forgetMinimized();
+              focusControl(el, '.newshound-minimize');
+            },
+            // Closing clears the current page; the flag brings the banner back as a
+            // pill on the next load rather than suppressing it for good.
+            close: function(el) {
+              el.remove();
+              rememberMinimized();
+            }
+          };
+
+          function focusControl(el, selector) {
+            var control = el.querySelector(selector);
+            if (control) control.focus();
+          }
+
+          // Scoped to the banner so a second injection cannot stack listeners that
+          // outlive it.
+          banner().addEventListener('click', function(event) {
+            if (!event.target.closest) return;
+
+            var trigger = event.target.closest('[data-newshound-action]');
+            if (!trigger) return;
+
+            var action = actions[trigger.getAttribute('data-newshound-action')];
+            var el = banner();
+            if (!action || !el) return;
+
+            action(el);
+            if (window.newshoundUpdatePadding) window.newshoundUpdatePadding();
+          });
+        JS
+      end
+
+      # A bottom banner floats over the page, so there is no space to reserve. The
+      # delegated click handler still calls this, so it has to exist either way.
+      def render_padding_script
+        return "window.newshoundUpdatePadding = function() {};" if bottom?
+
+        <<~JS
+          var cachedPriority, cachedBodyRule;
+
+          // Detect once whether any non-newshound stylesheet uses !important on the body padding we set
+          function detectPriority() {
+            var styles = document.querySelectorAll('style:not(#newshound-styles)');
+
+            for (var i = 0; i < styles.length; i++) {
+              if (styles[i].textContent.match(/body\\s*{[^}]*padding-top[^;]*!important/s)) {
+                return 'important';
+              }
+            }
+
+            try {
+              for (var s = 0; s < document.styleSheets.length; s++) {
+                var sheet = document.styleSheets[s];
+                if (sheet.ownerNode && sheet.ownerNode.id === 'newshound-styles') continue;
+                var rules = sheet.cssRules || [];
+                for (var r = 0; r < rules.length; r++) {
+                  if (rules[r].selectorText === 'body' &&
+                      rules[r].style.getPropertyPriority('padding-top') === 'important') {
+                    return 'important';
+                  }
+                }
+              }
+            } catch (e) {}
+
+            return '';
+          }
+
+          // Find the html body rule in the newshound stylesheet once
+          function findBodyRule() {
+            var styleEl = document.getElementById('newshound-styles');
+            if (!styleEl || !styleEl.sheet) return null;
+            var rules = styleEl.sheet.cssRules;
+            for (var i = 0; i < rules.length; i++) {
+              if (rules[i].selectorText === 'html body') return rules[i];
+            }
+            return null;
+          }
+
+          function applyPadding(offset) {
+            if (cachedBodyRule === undefined) cachedBodyRule = findBodyRule();
+            if (!cachedBodyRule) return;
+
+            if (cachedPriority === undefined) cachedPriority = detectPriority();
+
+            cachedBodyRule.style.setProperty('padding-top', offset + 'px', cachedPriority);
+          }
+
+          window.newshoundUpdatePadding = function() {
+            var el = banner();
+
+            // A closed banner is gone and a minimized one is a floating corner pill,
+            // so neither displaces the page.
+            if (!el || el.classList.contains('newshound-banner-minimized')) {
+              applyPadding(0);
+              return;
+            }
+
+            // Measure only once the content's max-height transition has settled.
+            setTimeout(function() { applyPadding(el.offsetHeight); }, 300);
+          };
+
+          if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', window.newshoundUpdatePadding);
+          } else {
+            window.newshoundUpdatePadding();
+          }
+
+          window.addEventListener('resize', window.newshoundUpdatePadding);
+        JS
+      end
+
       def render_styles
         <<~CSS
           <style id="newshound-styles">
-            html body {
-              padding-top: 50px;
-              transition: padding-top 0.3s ease-out;
-            }
+            #{render_body_padding_styles}
+            /* Everything that varies by position or state is a custom property set
+               on the banner. The rules below inherit those values, so each element
+               is styled by its own flat selector instead of by its ancestry. */
             .newshound-banner {
+              --newshound-content-display: block;
+              --newshound-content-max-height: 400px;
+              --newshound-content-overflow: auto;
+              --newshound-divider: 1px solid rgba(255,255,255,0.2);
+              --newshound-header-display: flex;
+              --newshound-restore-display: none;
+              --newshound-corner-radius: 0;
               position: fixed;
-              top: 0;
               left: 0;
               right: 0;
               background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
               color: white;
               z-index: 10000;
-              box-shadow: 0 2px 10px rgba(0,0,0,0.3);
+              box-shadow: var(--newshound-shadow);
+              border-radius: var(--newshound-corner-radius);
               font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
               font-size: 14px;
             }
+            .newshound-banner-top {
+              --newshound-shadow: 0 2px 10px rgba(0,0,0,0.3);
+              --newshound-toggle-rotation: 0deg;
+              --newshound-collapsed-toggle-rotation: -90deg;
+              --newshound-minimized-shadow: -2px 2px 6px rgba(0,0,0,0.2);
+              --newshound-minimized-corner-radius: 0 0 0 8px;
+              top: 0;
+            }
+            /* Laid out in reverse so the header still sits on the viewport edge and
+               the panel expands upward into the page. */
+            .newshound-banner-bottom {
+              --newshound-shadow: 0 -2px 10px rgba(0,0,0,0.3);
+              --newshound-toggle-rotation: 180deg;
+              --newshound-collapsed-toggle-rotation: 270deg;
+              --newshound-minimized-shadow: -2px -2px 6px rgba(0,0,0,0.2);
+              --newshound-minimized-corner-radius: 8px 0 0 0;
+              bottom: 0;
+              display: flex;
+              flex-direction: column-reverse;
+            }
+            /* State comes after position so it wins the properties they share. */
+            .newshound-banner-collapsed {
+              --newshound-content-max-height: 0px;
+              --newshound-content-overflow: hidden;
+              --newshound-divider: none;
+              --newshound-toggle-rotation: var(--newshound-collapsed-toggle-rotation);
+            }
+            .newshound-banner-minimized {
+              /* Taken out of layout rather than collapsed to zero height: a
+                 shrink-to-fit banner otherwise sizes itself to the hidden
+                 content's width. */
+              --newshound-content-display: none;
+              --newshound-header-display: none;
+              --newshound-restore-display: flex;
+              --newshound-shadow: var(--newshound-minimized-shadow);
+              --newshound-corner-radius: var(--newshound-minimized-corner-radius);
+              left: auto;
+            }
             .newshound-header {
               padding: 12px 20px;
               cursor: pointer;
-              display: flex;
+              display: var(--newshound-header-display, flex);
               justify-content: space-between;
               align-items: center;
               user-select: none;
@@ -220,20 +480,21 @@ module Newshound
             }
             .newshound-toggle {
               transition: transform 0.3s;
-            }
-            .newshound-banner.newshound-collapsed .newshound-toggle {
-              transform: rotate(-90deg);
+              transform: rotate(var(--newshound-toggle-rotation, 0deg));
             }
             .newshound-content {
-              max-height: 400px;
-              overflow-y: auto;
-              border-top: 1px solid rgba(255,255,255,0.2);
+              display: var(--newshound-content-display, block);
+              max-height: var(--newshound-content-max-height, 400px);
+              overflow: var(--newshound-content-overflow, auto);
               transition: max-height 0.3s ease-out;
             }
-            .newshound-banner.newshound-collapsed .newshound-content {
-              max-height: 0;
-              overflow: hidden;
-              border-top: none;
+            /* The divider sits between the header and the panel, which means the
+               top edge of the content at the top and its bottom edge at the bottom. */
+            .newshound-content-top {
+              border-top: var(--newshound-divider);
+            }
+            .newshound-content-bottom {
+              border-bottom: var(--newshound-divider);
             }
             .newshound-section {
               padding: 15px 20px;
@@ -306,64 +567,84 @@ module Newshound
               align-items: center;
               gap: 12px;
             }
-            .newshound-minimize {
-              cursor: pointer;
-              font-size: 18px;
-              font-weight: 700;
+            .newshound-control {
+              background: none;
+              border: 0;
+              margin: 0;
+              padding: 0 4px;
+              color: inherit;
+              font: inherit;
               line-height: 1;
+              cursor: pointer;
               opacity: 0.7;
-              padding: 0 4px;
             }
-            .newshound-minimize:hover {
+            .newshound-control:hover,
+            .newshound-control:focus-visible {
               opacity: 1;
             }
-            .newshound-restore {
-              display: none;
-            }
-            .newshound-banner.newshound-minimized .newshound-header {
-              display: none;
+            .newshound-control:focus-visible {
+              outline: 2px solid #fff;
+              outline-offset: 2px;
             }
-            .newshound-banner.newshound-minimized .newshound-content {
-              max-height: 0;
-              overflow: hidden;
-              border-top: none;
+            .newshound-minimize,
+            .newshound-close {
+              font-size: 18px;
+              font-weight: 700;
             }
-            .newshound-banner.newshound-minimized .newshound-restore {
-              display: flex;
+            .newshound-restore {
+              display: var(--newshound-restore-display, none);
               align-items: center;
               justify-content: center;
               width: 36px;
               height: 36px;
-              cursor: pointer;
+              padding: 0;
+              opacity: 1;
               font-size: 16px;
               user-select: none;
             }
-            .newshound-banner.newshound-minimized {
-              left: auto;
-              border-radius: 0 0 0 8px;
-              box-shadow: -2px 2px 6px rgba(0,0,0,0.2);
-            }
           </style>
         CSS
       end
 
+      def bottom?
+        Newshound.configuration.position == :bottom
+      end
+
+      # Position is settled before a byte of HTML goes out, so elements that differ
+      # between the two edges say so themselves -- "newshound-content
+      # newshound-content-bottom" -- rather than making the stylesheet work it out
+      # from an ancestor.
+      def positioned_class(name)
+        "newshound-#{name} newshound-#{name}-#{Newshound.configuration.position}"
+      end
+
+      # Only a top banner pushes the page down; a bottom one floats over it.
+      def render_body_padding_styles
+        return "" if bottom?
+
+        <<~CSS
+          html body {
+            padding-top: 50px;
+            transition: padding-top 0.3s ease-out;
+          }
+        CSS
+      end
+
       def summary_badge(exception_data, job_data, warning_data = {})
         exception_count = exception_data[:exceptions]&.length || 0
-        failed_jobs = job_data.dig(:queue_stats, :failed) || 0
+        expired_jobs = job_data.dig(:queue_stats, :expired) || 0
         warning_count = warning_data[:warnings]&.length || 0
+        threshold = Newshound.configuration.expired_jobs_threshold
 
-        if exception_count > 0 || failed_jobs > 10
+        if exception_count > 0
           badge_class = "newshound-error"
-          text = "#{exception_count} exceptions, #{failed_jobs} failed jobs"
-        elsif warning_count > 0 || failed_jobs > 5
+          text = "#{exception_count} exceptions"
+        else
           badge_class = "newshound-warning"
           parts = []
           parts << "#{warning_count} warnings" if warning_count > 0
-          parts << "#{failed_jobs} failed jobs" if failed_jobs > 5
+          parts << "#{expired_jobs} expired jobs" if expired_jobs > threshold
           text = parts.join(", ")
-        else
-          badge_class = "newshound-success"
-          text = "All clear"
         end
 
         %(<span class="newshound-badge #{badge_class}">#{text}</span>)
@@ -437,13 +718,17 @@ module Newshound
           section_title
         end
 
+        # :failed is the pre-1.0.4 link key and pointed at the retry queue.
+        failing_link = links[:failing] || links[:failed]
+
         <<~HTML
           <div class="newshound-section">
             <div class="newshound-section-title">#{title_html}</div>
             <div class="newshound-grid">
               #{render_job_stat(stats[:ready_to_run] || 0, "Ready", links[:index])}
               #{render_job_stat(stats[:scheduled] || 0, "Scheduled", links[:scheduled])}
-              #{render_job_stat(stats[:failed] || 0, "Failed", links[:failed])}
+              #{render_job_stat(stats[:failing] || 0, "Failing", failing_link)}
+              #{render_job_stat(stats[:expired] || 0, "Expired", links[:expired])}
               #{render_job_stat(stats[:completed_today] || 0, "Completed Today", links[:completed])}
             </div>
           </div>
@@ -465,6 +750,7 @@ module Newshound
 
       def escape_html(text)
         return +"" unless text.present?
+
         text.to_s
           .gsub("&", "&amp;")
           .gsub("<", "&lt;")

data/lib/newshound/railtie.rb

@@ -42,7 +42,8 @@ module Newshound
           puts "Job Queue Report:"
           puts "  Ready to run: #{stats[:ready_to_run] || 0}"
           puts "  Scheduled: #{stats[:scheduled] || 0}"
-          puts "  Failed: #{stats[:failed] || 0}"
+          puts "  Failing: #{stats[:failing] || 0}"
+          puts "  Expired: #{stats[:expired] || 0}"
           puts "  Completed today: #{stats[:completed_today] || 0}"
         end
       end

data/lib/newshound/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Newshound
-  VERSION = "1.0.2"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: newshound
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Savannah Moore