rails_error_dashboard 0.5.7 → 0.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cfea703e2d74b6771503d098e3bc5f048ec781923ee08a1692e34bbf28c9734
-  data.tar.gz: 4b77fb5c2dd00920d2eaca85b92d35dcbb19282408dee936584deffd2e7126a6
+  metadata.gz: dc2ad274b6cf17149a3d60eecb3c6cde4280379e8c74c870be26530641267f8b
+  data.tar.gz: b8bb6d9e448631bb294663b73d33379c7da33e0cba5ab97d79949b1860070cc3
 SHA512:
-  metadata.gz: 1bcc5f0f868d3e864deccdfbe23a0a3c3e1da03f3cfb49208724f61deceaf7047bba7c1d3f19358a75e1a254336059894a55bec79656f67e55217eec18c34d19
-  data.tar.gz: 810aa6c9a5db5300d4f6f5964ce92aa06dada34dfc7b513e782a914de8a3f0baf7e35b8b03056b9a1060b018b8dca0d6b51534f528211e779c008a77060fa10d
+  metadata.gz: 2f1b87689dc7d3be38a036ead3d2e63236265ebe6a7135503e6cff3231a97f87b5203bc9f6b8da86e23735401f26616688adbe43bf2e225f6f3fce6cd808f0d3
+  data.tar.gz: da68e7b4b68b14f9a8dd349f7c5ccd0704844a4da2d77f97556e9cf3ebda1577d59ba54acb844a3d8de59704c16bf494065e6d23d83abfee07b6ca1a28b7afd8

data/README.md

@@ -131,15 +131,41 @@ Requires breadcrumbs to be enabled.
 
 ![Cache Health](docs/images/cache-health.png)
 
-**ActionCable Health** — Track WebSocket channel actions, transmissions, subscription confirmations, and rejections. Dashboard page at `/errors/actioncable_health_summary` with channel breakdown sorted by rejections. System health snapshot captures live connection count and adapter. No error tracker surfaces this alongside HTTP errors.
+**ActionCable Health** — Track WebSocket channel actions, transmissions, subscription confirmations, and rejections. Dashboard page at `/errors/actioncable_health_summary` with channel breakdown sorted by rejections. System health snapshot captures live connection count and adapter.
 
 ```ruby
 config.enable_actioncable_tracking = true  # requires enable_breadcrumbs = true
 ```
 
+**ActiveStorage Health** — Track file uploads, downloads, deletes, and existence checks across storage services (Disk, S3, GCS, Azure — any ActiveStorage backend). Dashboard page at `/errors/activestorage_health_summary` with per-service operation counts, average and slowest durations. Helps identify slow storage operations correlating with errors.
+
+```ruby
+config.enable_activestorage_tracking = true  # requires enable_breadcrumbs = true
+```
+
 [Complete documentation →](docs/FEATURES.md#job-health-page)
 </details>
 
+<details>
+<summary><strong>Issue Tracking — GitHub, GitLab, Codeberg</strong></summary>
+
+Create, link, and manage issues directly from error detail pages. Supports GitHub, GitLab, and Codeberg/Gitea/Forgejo with provider auto-detection.
+
+- **Manual:** "Create Issue" button + "Link Existing Issue" URL input
+- **Auto-create:** On first occurrence and/or severity threshold — configurable
+- **Lifecycle sync:** Resolve → close issue, recur → reopen + comment (throttled)
+- **Two-way webhooks:** Issue closed/reopened on platform syncs to dashboard
+- **RED branding:** Issues show "Created by RED (Rails Error Dashboard)"
+
+```ruby
+config.enable_issue_tracking = true
+config.issue_tracker_token = ENV["RED_BOT_TOKEN"]
+# Provider and repo auto-detected from git_repository_url
+```
+
+[Complete documentation →](docs/guides/CONFIGURATION.md)
+</details>
+
 <details>
 <summary><strong>Source Code Integration + Git Blame</strong></summary>
 

data/app/controllers/rails_error_dashboard/errors_controller.rb

@@ -75,7 +75,7 @@ module RailsErrorDashboard
 
     def show
       # Eagerly load associations to avoid N+1 queries
-      # - comments: Used in the comments section (@error.comments.count, @error.comments.recent_first)
+      # - comments: Audit trail (workflow comments from snooze/mute/status changes)
       # - parent_cascade_patterns/child_cascade_patterns: Used if cascade detection is enabled
       @error = ErrorLog.includes(:comments, :parent_cascade_patterns, :child_cascade_patterns).find(params[:id])
       @related_errors = @error.related_errors(limit: 5, application_id: @current_application_id)
@@ -139,9 +139,41 @@ module RailsErrorDashboard
       redirect_to error_path(result[:error])
     end
 
-    def add_comment
-      @error = Commands::AddErrorComment.call(params[:id], author_name: params[:author_name], body: params[:body])
-      redirect_to error_path(@error)
+    def create_issue
+      dashboard_url = error_url(params[:id])
+      result = Commands::CreateIssue.call(params[:id], dashboard_url: dashboard_url)
+
+      if result[:success]
+        flash[:notice] = "Issue created: #{result[:issue_url]}"
+      else
+        flash[:alert] = "Failed to create issue: #{result[:error]}"
+      end
+      redirect_to error_path(params[:id])
+    end
+
+    def link_issue
+      result = Commands::LinkExistingIssue.call(params[:id], issue_url: params[:issue_url])
+
+      if result[:success]
+        flash[:notice] = "Issue linked successfully"
+      else
+        flash[:alert] = "Failed to link issue: #{result[:error]}"
+      end
+      redirect_to error_path(params[:id])
+    end
+
+    def unlink_issue
+      error = ErrorLog.find(params[:id])
+      error.update!(
+        external_issue_url: nil,
+        external_issue_number: nil,
+        external_issue_provider: nil
+      )
+      flash[:notice] = "Issue unlinked"
+      redirect_to error_path(error)
+    rescue => e
+      flash[:alert] = "Failed to unlink issue: #{e.message}"
+      redirect_to error_path(params[:id])
     end
 
     def analytics
@@ -432,6 +464,27 @@ module RailsErrorDashboard
       @pagy, @channels = pagy(:offset, all_channels, limit: params[:per_page] || 25)
     end
 
+    def activestorage_health_summary
+      unless RailsErrorDashboard.configuration.enable_activestorage_tracking &&
+             RailsErrorDashboard.configuration.enable_breadcrumbs
+        flash[:alert] = "ActiveStorage tracking is not enabled. Enable enable_activestorage_tracking and enable_breadcrumbs in config/initializers/rails_error_dashboard.rb"
+        redirect_to errors_path
+        return
+      end
+
+      days = (params[:days] || 30).to_i
+      @days = days
+      result = Queries::ActiveStorageSummary.call(days, application_id: @current_application_id)
+      all_services = result[:services]
+
+      # Summary stats (computed before pagination)
+      @unique_services = all_services.size
+      @total_operations = all_services.sum { |s| s[:total_operations] }
+      @errors_with_storage = all_services.sum { |s| s[:error_count] }
+
+      @pagy, @services = pagy(:offset, all_services, limit: params[:per_page] || 25)
+    end
+
     def diagnostic_dumps
       unless RailsErrorDashboard.configuration.enable_diagnostic_dump
         flash[:alert] = "Diagnostic dumps are not enabled. Enable them in config/initializers/rails_error_dashboard.rb"

data/app/controllers/rails_error_dashboard/webhooks_controller.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Receives webhooks from GitHub/GitLab/Codeberg for two-way issue sync.
+  #
+  # When an issue is closed/reopened on the platform, the corresponding
+  # error in the dashboard is resolved/reopened to match.
+  #
+  # Security: HMAC signature verification for each provider.
+  # - GitHub:   X-Hub-Signature-256 (HMAC-SHA256)
+  # - GitLab:   X-Gitlab-Token (shared secret)
+  # - Codeberg: X-Gitea-Signature (HMAC-SHA256)
+  class WebhooksController < ActionController::Base
+    skip_before_action :verify_authenticity_token
+
+    before_action :verify_webhook_enabled
+    before_action :verify_signature
+
+    def receive
+      provider = params[:provider]
+      payload = parse_payload
+
+      return head :ok unless payload
+
+      case provider
+      when "github"
+        handle_github(payload)
+      when "gitlab"
+        handle_gitlab(payload)
+      when "codeberg"
+        handle_codeberg(payload)
+      else
+        head :not_found
+        return
+      end
+
+      head :ok
+    rescue => e
+      Rails.logger.error("[RailsErrorDashboard] Webhook error: #{e.class}: #{e.message}")
+      head :ok # Always return 200 to prevent webhook retries on our errors
+    end
+
+    private
+
+    def verify_webhook_enabled
+      unless RailsErrorDashboard.configuration.enable_issue_webhooks
+        head :not_found
+      end
+    end
+
+    def verify_signature
+      provider = params[:provider]
+      secret = RailsErrorDashboard.configuration.issue_webhook_secret
+
+      unless secret.present?
+        Rails.logger.warn("[RailsErrorDashboard] Webhook received but no issue_webhook_secret configured")
+        head :unauthorized
+        return
+      end
+
+      body = request.body.read
+      request.body.rewind
+
+      verified = case provider
+      when "github"
+        verify_github_signature(body, secret)
+      when "gitlab"
+        verify_gitlab_token(secret)
+      when "codeberg"
+        verify_codeberg_signature(body, secret)
+      else
+        false
+      end
+
+      head :unauthorized unless verified
+    end
+
+    def verify_github_signature(body, secret)
+      signature = request.headers["X-Hub-Signature-256"]
+      return false unless signature
+
+      expected = "sha256=" + OpenSSL::HMAC.hexdigest("SHA256", secret, body)
+      ActiveSupport::SecurityUtils.secure_compare(expected, signature)
+    end
+
+    def verify_gitlab_token(secret)
+      token = request.headers["X-Gitlab-Token"]
+      return false unless token
+
+      ActiveSupport::SecurityUtils.secure_compare(secret, token)
+    end
+
+    def verify_codeberg_signature(body, secret)
+      signature = request.headers["X-Gitea-Signature"]
+      return false unless signature
+
+      expected = OpenSSL::HMAC.hexdigest("SHA256", secret, body)
+      ActiveSupport::SecurityUtils.secure_compare(expected, signature)
+    end
+
+    def parse_payload
+      JSON.parse(request.body.read)
+    rescue JSON::ParserError
+      nil
+    ensure
+      request.body.rewind
+    end
+
+    # GitHub: issues webhook fires with action: opened/closed/reopened
+    def handle_github(payload)
+      return unless payload["action"].in?(%w[closed reopened])
+
+      issue_number = payload.dig("issue", "number")
+      return unless issue_number
+
+      error = find_error_by_issue(issue_number, "github")
+      return unless error
+
+      case payload["action"]
+      when "closed"
+        resolve_error(error, "Closed on GitHub by #{payload.dig("sender", "login")}")
+      when "reopened"
+        reopen_error(error)
+      end
+    end
+
+    # GitLab: issue webhook fires with object_attributes.action
+    def handle_gitlab(payload)
+      action = payload.dig("object_attributes", "action")
+      return unless action.in?(%w[close reopen])
+
+      issue_iid = payload.dig("object_attributes", "iid")
+      return unless issue_iid
+
+      error = find_error_by_issue(issue_iid, "gitlab")
+      return unless error
+
+      case action
+      when "close"
+        resolve_error(error, "Closed on GitLab by #{payload.dig("user", "username")}")
+      when "reopen"
+        reopen_error(error)
+      end
+    end
+
+    # Codeberg/Gitea/Forgejo: issue webhook fires with action
+    def handle_codeberg(payload)
+      return unless payload["action"].in?(%w[closed reopened])
+
+      issue_number = payload.dig("issue", "number")
+      return unless issue_number
+
+      error = find_error_by_issue(issue_number, "codeberg")
+      return unless error
+
+      case payload["action"]
+      when "closed"
+        resolve_error(error, "Closed on Codeberg by #{payload.dig("sender", "login")}")
+      when "reopened"
+        reopen_error(error)
+      end
+    end
+
+    def find_error_by_issue(issue_number, provider)
+      ErrorLog.find_by(
+        external_issue_number: issue_number,
+        external_issue_provider: provider
+      )
+    end
+
+    def resolve_error(error, message)
+      return if error.resolved?
+
+      Commands::ResolveError.call(
+        error.id,
+        resolved_by_name: "Webhook",
+        resolution_comment: message
+      )
+    end
+
+    def reopen_error(error)
+      return unless error.resolved?
+
+      error.update!(
+        resolved: false,
+        resolved_at: nil,
+        status: "new",
+        reopened_at: Time.current
+      )
+    end
+  end
+end

data/app/jobs/rails_error_dashboard/add_issue_recurrence_comment_job.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Background job to add a recurrence comment on a linked issue.
+  #
+  # Triggered via :on_error_recurred plugin hook.
+  # Throttled: max 1 comment per hour per error to prevent spam on
+  # high-frequency errors.
+  class AddIssueRecurrenceCommentJob < ApplicationJob
+    queue_as :error_notifications
+
+    retry_on StandardError, wait: :polynomially_longer, attempts: 2
+    discard_on ActiveRecord::RecordNotFound
+
+    THROTTLE_INTERVAL = 3600 # 1 hour
+
+    # Track last comment time per error to throttle
+    @@last_comment_at = {}
+
+    def perform(error_log_id)
+      # Throttle: max 1 comment per hour per error
+      if throttled?(error_log_id)
+        Rails.logger.debug("[RailsErrorDashboard] Skipping recurrence comment for error #{error_log_id} — throttled")
+        return
+      end
+
+      error = ErrorLog.find(error_log_id)
+      return unless error.external_issue_url.present? && error.external_issue_number.present?
+
+      client = Services::IssueTrackerClient.from_config
+      return unless client
+
+      comment = "Error occurred again (#{error.occurrence_count} total occurrences).\n\n"
+      comment += "- **Last seen:** #{error.last_seen_at&.utc&.strftime("%Y-%m-%d %H:%M:%S UTC")}\n"
+      comment += "- **First seen:** #{error.first_seen_at&.utc&.strftime("%Y-%m-%d %H:%M:%S UTC")}"
+      comment += "\n\n---\n*[RED](https://github.com/AnjanJ/rails_error_dashboard) (Rails Error Dashboard)*"
+
+      result = client.add_comment(number: error.external_issue_number, body: comment)
+
+      if result[:success]
+        record_comment(error_log_id)
+        Rails.logger.info("[RailsErrorDashboard] Added recurrence comment on issue ##{error.external_issue_number}")
+      else
+        Rails.logger.error("[RailsErrorDashboard] Failed to add recurrence comment: #{result[:error]}")
+      end
+    rescue ActiveRecord::RecordNotFound
+      # Error was deleted
+    rescue => e
+      Rails.logger.error("[RailsErrorDashboard] AddIssueRecurrenceCommentJob failed: #{e.class}: #{e.message}")
+      raise # retry
+    end
+
+    private
+
+    def throttled?(error_log_id)
+      last = @@last_comment_at[error_log_id]
+      last && (Time.current - last) < THROTTLE_INTERVAL
+    end
+
+    def record_comment(error_log_id)
+      @@last_comment_at[error_log_id] = Time.current
+      # Cleanup old entries to prevent memory growth
+      cleanup_stale_entries if @@last_comment_at.size > 1000
+    end
+
+    def cleanup_stale_entries
+      cutoff = Time.current - THROTTLE_INTERVAL
+      @@last_comment_at.reject! { |_, t| t < cutoff }
+    end
+  end
+end

data/app/jobs/rails_error_dashboard/close_linked_issue_job.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Background job to close a linked issue when an error is resolved.
+  #
+  # Triggered via :on_error_resolved plugin hook.
+  # Adds a comment before closing: "Resolved in Rails Error Dashboard by {name}"
+  class CloseLinkedIssueJob < ApplicationJob
+    queue_as :error_notifications
+
+    retry_on StandardError, wait: :polynomially_longer, attempts: 2
+    discard_on ActiveRecord::RecordNotFound
+
+    def perform(error_log_id)
+      error = ErrorLog.find(error_log_id)
+      return unless error.external_issue_url.present? && error.external_issue_number.present?
+
+      client = Services::IssueTrackerClient.from_config
+      return unless client
+
+      # Add resolution comment
+      resolved_by = error.resolved_by_name.presence || "a team member"
+      comment = "**Resolved** by #{resolved_by}."
+      comment += "\n\nResolution: #{error.resolution_comment}" if error.resolution_comment.present?
+      comment += "\n\n---\n*[RED](https://github.com/AnjanJ/rails_error_dashboard) (Rails Error Dashboard)*"
+
+      client.add_comment(number: error.external_issue_number, body: comment)
+
+      # Close the issue
+      result = client.close_issue(number: error.external_issue_number)
+      if result[:success]
+        Rails.logger.info("[RailsErrorDashboard] Closed issue ##{error.external_issue_number} for error #{error_log_id}")
+      else
+        Rails.logger.error("[RailsErrorDashboard] Failed to close issue ##{error.external_issue_number}: #{result[:error]}")
+      end
+    rescue ActiveRecord::RecordNotFound
+      # Error was deleted
+    rescue => e
+      Rails.logger.error("[RailsErrorDashboard] CloseLinkedIssueJob failed: #{e.class}: #{e.message}")
+      raise # retry
+    end
+  end
+end

data/app/jobs/rails_error_dashboard/create_issue_job.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Background job for creating issues on GitHub/GitLab/Codeberg.
+  #
+  # Used by auto-create (triggered from plugin hooks) and can be
+  # called directly for deferred issue creation.
+  #
+  # Retry strategy: 3 attempts with exponential backoff.
+  # Circuit breaker: skips if >5 failures in the last 10 minutes
+  # (tracked via class-level counter, reset on success).
+  class CreateIssueJob < ApplicationJob
+    queue_as :error_notifications
+
+    retry_on StandardError, wait: :polynomially_longer, attempts: 3
+    discard_on ActiveRecord::RecordNotFound
+
+    # Simple circuit breaker — class-level failure tracking
+    @@recent_failures = []
+    CIRCUIT_BREAKER_THRESHOLD = 5
+    CIRCUIT_BREAKER_WINDOW = 600 # 10 minutes
+
+    def perform(error_log_id, dashboard_url: nil)
+      if circuit_open?
+        Rails.logger.warn("[RailsErrorDashboard] CreateIssueJob circuit breaker open — skipping")
+        return
+      end
+
+      result = Commands::CreateIssue.call(error_log_id, dashboard_url: dashboard_url)
+
+      if result[:success]
+        record_success
+        Rails.logger.info("[RailsErrorDashboard] Issue created for error #{error_log_id}: #{result[:issue_url]}")
+      else
+        record_failure
+        Rails.logger.error("[RailsErrorDashboard] Failed to create issue for error #{error_log_id}: #{result[:error]}")
+        # Don't retry on "already has a linked issue" or "not configured"
+        return if result[:error]&.include?("already has") || result[:error]&.include?("not configured")
+        raise "Issue creation failed: #{result[:error]}" # triggers retry
+      end
+    rescue ActiveRecord::RecordNotFound
+      # Error was deleted — discard silently
+    rescue => e
+      record_failure
+      raise # re-raise for retry
+    end
+
+    private
+
+    def circuit_open?
+      cleanup_old_failures
+      @@recent_failures.size >= CIRCUIT_BREAKER_THRESHOLD
+    end
+
+    def record_failure
+      @@recent_failures << Time.current
+    end
+
+    def record_success
+      @@recent_failures.clear
+    end
+
+    def cleanup_old_failures
+      cutoff = Time.current - CIRCUIT_BREAKER_WINDOW
+      @@recent_failures.reject! { |t| t < cutoff }
+    end
+  end
+end

data/app/jobs/rails_error_dashboard/reopen_linked_issue_job.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Background job to reopen a linked issue when an error recurs after resolution.
+  #
+  # Triggered via :on_error_reopened plugin hook.
+  # Adds a comment: "Error recurred — reopened automatically. Occurrence #{count}"
+  class ReopenLinkedIssueJob < ApplicationJob
+    queue_as :error_notifications
+
+    retry_on StandardError, wait: :polynomially_longer, attempts: 2
+    discard_on ActiveRecord::RecordNotFound
+
+    def perform(error_log_id)
+      error = ErrorLog.find(error_log_id)
+      return unless error.external_issue_url.present? && error.external_issue_number.present?
+
+      client = Services::IssueTrackerClient.from_config
+      return unless client
+
+      # Reopen the issue
+      result = client.reopen_issue(number: error.external_issue_number)
+
+      # Add recurrence comment
+      comment = "**Reopened** — error recurred.\n\n"
+      comment += "- **Occurrences:** #{error.occurrence_count}\n"
+      comment += "- **Last seen:** #{error.last_seen_at&.utc&.strftime("%Y-%m-%d %H:%M:%S UTC")}"
+      comment += "\n\n---\n*[RED](https://github.com/AnjanJ/rails_error_dashboard) (Rails Error Dashboard)*"
+
+      client.add_comment(number: error.external_issue_number, body: comment)
+
+      if result[:success]
+        Rails.logger.info("[RailsErrorDashboard] Reopened issue ##{error.external_issue_number} for error #{error_log_id}")
+      else
+        Rails.logger.error("[RailsErrorDashboard] Failed to reopen issue ##{error.external_issue_number}: #{result[:error]}")
+      end
+    rescue ActiveRecord::RecordNotFound
+      # Error was deleted
+    rescue => e
+      Rails.logger.error("[RailsErrorDashboard] ReopenLinkedIssueJob failed: #{e.class}: #{e.message}")
+      raise # retry
+    end
+  end
+end

data/app/models/rails_error_dashboard/error_log.rb

@@ -37,7 +37,8 @@ module RailsErrorDashboard
     # Association for tracking individual error occurrences
     has_many :error_occurrences, class_name: "RailsErrorDashboard::ErrorOccurrence", dependent: :destroy
 
-    # Association for comment threads (Phase 3: Workflow Integration)
+    # Comments used as internal audit trail for workflow actions (snooze, mute, status changes).
+    # Manual comment form removed in v0.6 — discussion now lives on issue tracker.
     has_many :comments, class_name: "RailsErrorDashboard::ErrorComment", foreign_key: :error_log_id, dependent: :destroy
 
     # Cascade pattern associations

data/app/views/layouts/rails_error_dashboard.html.erb

@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
   <head>
-    <title><%= content_for?(:page_title) ? "#{content_for(:page_title)} | " : "" %><%= Rails.application.class.module_parent_name %> - Error Dashboard</title>
+    <title><%= content_for?(:page_title) ? "#{content_for(:page_title)} | " : "" %><%= Rails.application.class.module_parent_name %> - RED</title>
     <meta name="viewport" content="width=device-width,initial-scale=1">
     <meta name="turbo-visit-control" content="reload">
     <% if respond_to?(:csrf_meta_tags) %>
@@ -1547,18 +1547,24 @@ body.dark-mode .sidebar-section-body { background: var(--ctp-mantle); }
             end
           %>
           <% if has_root %>
-            <a class="navbar-brand" href="<%= root_url %>" title="Back to <%= Rails.application.class.module_parent_name %>">
+            <a class="navbar-brand d-flex align-items-center" href="<%= root_url %>" title="Back to <%= Rails.application.class.module_parent_name %>">
               <i class="bi bi-bug-fill"></i>
               <span class="d-none d-sm-inline"><%= Rails.application.class.module_parent_name %></span>
               <span class="d-none d-md-inline text-white-50 mx-2">|</span>
-              <span class="d-none d-md-inline">Error Dashboard</span>
+              <span class="d-none d-md-inline">
+                <strong>RED</strong>
+                <small class="text-white-50 ms-1" style="font-size: 0.65em; vertical-align: middle;">Rails Error Dashboard</small>
+              </span>
             </a>
           <% else %>
-            <span class="navbar-brand">
+            <span class="navbar-brand d-flex align-items-center">
               <i class="bi bi-bug-fill"></i>
               <span class="d-none d-sm-inline"><%= Rails.application.class.module_parent_name %></span>
               <span class="d-none d-md-inline text-white-50 mx-2">|</span>
-              <span class="d-none d-md-inline">Error Dashboard</span>
+              <span class="d-none d-md-inline">
+                <strong>RED</strong>
+                <small class="text-white-50 ms-1" style="font-size: 0.65em; vertical-align: middle;">Rails Error Dashboard</small>
+              </span>
             </span>
           <% end %>
         </div>
@@ -1681,6 +1687,13 @@ body.dark-mode .sidebar-section-body { background: var(--ctp-mantle); }
                   <% end %>
                 </li>
               <% end %>
+              <% if RailsErrorDashboard.configuration.enable_activestorage_tracking && RailsErrorDashboard.configuration.enable_breadcrumbs %>
+                <li class="nav-item">
+                  <%= link_to activestorage_health_summary_errors_path(nav_params), class: "nav-link #{request.path == activestorage_health_summary_errors_path ? 'active' : ''}" do %>
+                    <i class="bi bi-cloud-arrow-up"></i> ActiveStorage
+                  <% end %>
+                </li>
+              <% end %>
               <% if RailsErrorDashboard.configuration.enable_system_health %>
                 <li class="nav-item">
                   <%= link_to job_health_summary_errors_path(nav_params), class: "nav-link #{request.path == job_health_summary_errors_path ? 'active' : ''}" do %>
@@ -1820,7 +1833,7 @@ body.dark-mode .sidebar-section-body { background: var(--ctp-mantle); }
       <div class="container">
         <p class="text-muted mb-1">
           <i class="bi bi-bug-fill text-primary"></i>
-          Built with <a href="https://github.com/AnjanJ/rails_error_dashboard" target="_blank" class="text-decoration-none">Rails Error Dashboard</a>
+          Built with <a href="https://github.com/AnjanJ/rails_error_dashboard" target="_blank" class="text-decoration-none"><strong>RED</strong> — Rails Error Dashboard</a>
         </p>
         <p class="text-muted small mb-0">
           Created by <a href="https://www.anjan.dev/" target="_blank" class="text-decoration-none">Anjan Jagirdar</a>