rails_error_dashboard 0.5.7 → 0.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cfea703e2d74b6771503d098e3bc5f048ec781923ee08a1692e34bbf28c9734
-  data.tar.gz: 4b77fb5c2dd00920d2eaca85b92d35dcbb19282408dee936584deffd2e7126a6
+  metadata.gz: 18faae83cf7bba23409732000c1cb230ba7ef067f23a454084445f754df4be0d
+  data.tar.gz: ad82e112e173f8247cf31b214b040ba82e4035040bbdf14d8c53a5782db36bb1
 SHA512:
-  metadata.gz: 1bcc5f0f868d3e864deccdfbe23a0a3c3e1da03f3cfb49208724f61deceaf7047bba7c1d3f19358a75e1a254336059894a55bec79656f67e55217eec18c34d19
-  data.tar.gz: 810aa6c9a5db5300d4f6f5964ce92aa06dada34dfc7b513e782a914de8a3f0baf7e35b8b03056b9a1060b018b8dca0d6b51534f528211e779c008a77060fa10d
+  metadata.gz: 0d0032aeb56ccc44a8c8966da338f75c37e71002534fd0bbf3e019cfe0582df37638e50863e8d4a77212731c1190de214d521521df2e986a23d36a575748d5d9
+  data.tar.gz: 4862e358faa4a87f1091e33cf08c0e654a7e959b8af551a1223e3c9d098d383d503342aa8c2fb4d66f20c95fc4864276df631be6b93bcdd22ef50269516ef997

data/README.md

@@ -4,6 +4,7 @@
 [![Downloads](https://img.shields.io/gem/dt/rails_error_dashboard)](https://rubygems.org/gems/rails_error_dashboard)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Tests](https://github.com/AnjanJ/rails_error_dashboard/workflows/Tests/badge.svg)](https://github.com/AnjanJ/rails_error_dashboard/actions)
+[![Sponsor](https://img.shields.io/badge/Sponsor-GitHub%20Sponsors-ea4aaa?logo=githubsponsors)](https://github.com/sponsors/AnjanJ)
 [![Buy Me A Coffee](https://img.shields.io/badge/Buy%20Me%20A%20Coffee-support-yellow?logo=buymeacoffee)](https://buymeacoffee.com/anjanj)
 
 **Self-hosted Rails error monitoring — free, forever.**
@@ -131,15 +132,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>
 
@@ -453,9 +480,9 @@ Special thanks to [@bonniesimon](https://github.com/bonniesimon), [@gundestrup](
 
 ## Support
 
-If this gem saves you some headaches (or some money on error tracking SaaS), consider buying me a coffee. It keeps the project going and lets me know people are finding it useful.
+If this gem saves you some headaches (or some money on error tracking SaaS), consider sponsoring the project. It keeps RED going and lets me know people are finding it useful.
 
-<a href="https://www.buymeacoffee.com/anjanj" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" width="200"></a>
+<a href="https://github.com/sponsors/AnjanJ" target="_blank"><img src="https://img.shields.io/badge/Sponsor_on_GitHub-ea4aaa?style=for-the-badge&logo=githubsponsors&logoColor=white" alt="Sponsor on GitHub"></a>&nbsp;&nbsp;<a href="https://www.buymeacoffee.com/anjanj" target="_blank"><img src="https://img.shields.io/badge/Buy_Me_A_Coffee-FFDD00?style=for-the-badge&logo=buymeacoffee&logoColor=black" alt="Buy Me A Coffee"></a>
 
 ---
 

data/app/controllers/rails_error_dashboard/errors_controller.rb

@@ -75,12 +75,16 @@ 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)
       @error_markdown = Services::MarkdownErrorFormatter.call(@error, related_errors: @related_errors)
 
+      # Fetch platform issue state and comments if linked
+      @platform_issue = fetch_platform_issue(@error)
+      @platform_comments = fetch_platform_comments(@error)
+
       # Dispatch plugin event for error viewed
       RailsErrorDashboard::PluginRegistry.dispatch(:on_error_viewed, @error)
     end
@@ -139,9 +143,28 @@ 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 successfully"
+        flash[:new_issue_url] = result[:issue_url]
+      else
+        flash[:alert] = "Failed to create issue: #{result[:error]}"
+      end
+      redirect_to error_path(params[:id], anchor: "issue-tracking")
+    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], anchor: "issue-tracking")
     end
 
     def analytics
@@ -432,6 +455,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"
@@ -510,6 +554,39 @@ module RailsErrorDashboard
       @applications = Application.ordered_by_name.pluck(:name, :id)
     end
 
+    def fetch_platform_issue(error)
+      return nil unless error.external_issue_url.present? && error.external_issue_number.present?
+      return nil unless RailsErrorDashboard.configuration.enable_issue_tracking
+
+      cache_key = "red/issue_state/#{error.external_issue_provider}/#{error.external_issue_number}"
+      Rails.cache.fetch(cache_key, expires_in: 60.seconds) do
+        client = Services::IssueTrackerClient.from_config
+        return nil unless client
+
+        result = client.fetch_issue(number: error.external_issue_number)
+        result[:success] ? result : nil
+      end
+    rescue => e
+      nil
+    end
+
+    def fetch_platform_comments(error)
+      return [] unless error.external_issue_url.present? && error.external_issue_number.present?
+      return [] unless RailsErrorDashboard.configuration.enable_issue_tracking
+
+      # Cache for 60 seconds to avoid API hammering on page refreshes
+      cache_key = "red/issue_comments/#{error.external_issue_provider}/#{error.external_issue_number}"
+      Rails.cache.fetch(cache_key, expires_in: 60.seconds) do
+        client = Services::IssueTrackerClient.from_config
+        return [] unless client
+
+        result = client.fetch_comments(number: error.external_issue_number, per_page: 20)
+        result[:success] ? result[:comments] : []
+      end
+    rescue => e
+      []
+    end
+
     def check_default_credentials
       @default_credentials_warning = RailsErrorDashboard.configuration.default_credentials?
     end

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