rails_error_dashboard 0.1.36 → 0.1.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aae0da8a196598bd4a8ab5955e07684c4cb8dd1b959e821c6d35c514abcb3fea
-  data.tar.gz: 9479ae765eaaa528dd62d8c6cfe3e4bab8dbf66af056c8ef4210f432d9fc3f71
+  metadata.gz: 2e6cc2792ac8e61248b57b513ac64f02426ee651bb9cf07c3d4557760f8d7d31
+  data.tar.gz: 9450f4745f01d22c8eef4e5988c745d89f7951d318a7f625a8839b1eebd371f5
 SHA512:
-  metadata.gz: 25640c5213a9b56ca9392945cd74319d216a8dae4e81966d2f64920202e7ab9e92ce214b2c710f6d1e0561753bc6dc5ec7c5e840ba701365099a3b9cd0803deb
-  data.tar.gz: 651df5b45d9547541482185aea74dd357140f74fd879f15f4d5c90073b1e3e50f98e29a64e3d00ebd1c439878d959e03bbaf5e31add1566e2f4808ef424b4fc2
+  metadata.gz: 49a0c0f2988e1dfe03a40599693411d4a55690be71b7f7921d3dc6e305bc9f2bb54e2792bea7ad8a956127a7d87abf565b81e935536e8b37adbfe844fd017025
+  data.tar.gz: c040c6f3ea54b21d6c23addd72c9a787075e17cc4413c5a88c911c7e06c6376e3d5969bea85f106c53bb8b226a155b5ad01646626372488496120f580475cec7

data/README.md

@@ -29,9 +29,9 @@ Experience the full dashboard with 250+ realistic Rails errors, LOTR-themed demo
 ---
 
 ### ⚠️ BETA SOFTWARE
-This Rails Engine is in beta and under active development. While functional and tested (935+ tests passing), the API may change before v1.0.0. Use in production at your own discretion.
+This Rails Engine is in beta and under active development. While functional and tested (1,300+ tests passing, including browser-based system tests), the API may change before v1.0.0. Use in production at your own discretion.
 
-**Supports**: Rails 7.0 - 8.0 (+ edge 8.1) | Ruby 3.2 - 3.4
+**Supports**: Rails 7.0 - 8.1 | Ruby 3.2 - 4.0
 
 ---
 
@@ -638,6 +638,47 @@ Clean, maintainable, testable architecture you can understand and modify.
 
 ---
 
+## 🧪 Testing
+
+1,300+ tests covering unit, integration, and browser-based system tests.
+
+### Running Tests
+
+```bash
+# Run all tests
+bundle exec rspec
+
+# Run unit/integration tests only (fast)
+bundle exec rspec --exclude-pattern "spec/system/**/*"
+
+# Run system tests only (requires Chrome)
+bundle exec rspec spec/system/
+
+# Run with visible browser for debugging
+HEADLESS=false bundle exec rspec spec/system/
+
+# Run with Chrome DevTools inspector
+INSPECTOR=true HEADLESS=false bundle exec rspec spec/system/
+
+# Run with coverage report
+COVERAGE=true bundle exec rspec
+```
+
+### System Tests (Browser-Based)
+
+System tests use **Capybara + Cuprite** (Chrome DevTools Protocol) to simulate real user interactions — opening modals, filling forms, clicking buttons, and verifying page content. No Selenium or chromedriver management needed.
+
+**Requirements:** Chrome or Chromium installed locally.
+
+```bash
+# Verify Chrome is available
+which google-chrome || which chromium-browser || which chromium
+
+# macOS: Chrome is typically at /Applications/Google Chrome.app
+```
+
+---
+
 ## 🤝 Contributing
 
 We welcome contributions! Here's how to get started:

data/app/controllers/rails_error_dashboard/application_controller.rb

@@ -1,6 +1,6 @@
 module RailsErrorDashboard
   class ApplicationController < ActionController::Base
-    include Pagy::Backend
+    include Pagy::Method
 
     # Enable features that are disabled in API-only mode
     # These are ONLY enabled for Error Dashboard routes, not the entire app
@@ -12,11 +12,10 @@ module RailsErrorDashboard
 
     protect_from_forgery with: :exception
 
-    # Make Pagy helpers available in views
-    helper Pagy::Frontend
-
     # CRITICAL: Ensure dashboard errors never break the app
     # Catch all exceptions and render user-friendly error page
+    # NOTE: rescue_from is checked in reverse declaration order (last = highest priority).
+    # The generic handler must be declared FIRST so specific handlers below take precedence.
     rescue_from StandardError do |exception|
       # Log the error for debugging
       Rails.logger.error("[RailsErrorDashboard] Dashboard controller error: #{exception.class} - #{exception.message}")
@@ -32,5 +31,21 @@ module RailsErrorDashboard
              status: :internal_server_error,
              layout: false
     end
+
+    # Handle record not found — return 404 instead of 500
+    rescue_from ActiveRecord::RecordNotFound do |exception|
+      Rails.logger.warn("[RailsErrorDashboard] Record not found: #{exception.message}")
+      render plain: "The requested error was not found.\n\n" \
+                    "It may have been deleted or the ID is invalid.\n\n" \
+                    "Error: #{exception.message}",
+             status: :not_found,
+             layout: false
+    end
+
+    # Handle Pagy pagination errors — redirect to page 1
+    rescue_from Pagy::RangeError, Pagy::OptionError do |exception|
+      Rails.logger.warn("[RailsErrorDashboard] Pagination error: #{exception.message}")
+      redirect_to request.path, status: :moved_permanently
+    end
   end
 end

data/app/controllers/rails_error_dashboard/errors_controller.rb

@@ -2,8 +2,6 @@
 
 module RailsErrorDashboard
   class ErrorsController < ApplicationController
-    include Pagy::Backend
-
     before_action :authenticate_dashboard_user!
     before_action :set_application_context
 
@@ -51,14 +49,8 @@ module RailsErrorDashboard
         @multi_error_users = []
       end
 
-      # Get critical alerts (critical/high severity errors from last hour)
-      # Filter by priority_level in database instead of loading all records into memory
-      @critical_alerts = ErrorLog
-        .where("occurred_at >= ?", 1.hour.ago)
-        .where(resolved_at: nil)
-        .where(priority_level: [ 3, 4 ]) # 3 = high, 4 = critical (based on severity enum)
-      @critical_alerts = @critical_alerts.where(application_id: @current_application_id) if @current_application_id.present?
-      @critical_alerts = @critical_alerts.order(occurred_at: :desc).limit(10)
+      # Get critical alerts using Query
+      @critical_alerts = Queries::CriticalAlerts.call(application_id: @current_application_id)
     end
 
     def index
@@ -66,7 +58,7 @@ module RailsErrorDashboard
       errors_query = Queries::ErrorsList.call(filter_params)
 
       # Paginate with Pagy
-      @pagy, @errors = pagy(errors_query, items: params[:per_page] || 25)
+      @pagy, @errors = pagy(:offset, errors_query, limit: params[:per_page] || 25)
 
       # Get dashboard stats using Query (pass application filter)
       @stats = Queries::DashboardStats.call(application_id: @current_application_id)
@@ -75,15 +67,7 @@ module RailsErrorDashboard
       filter_options = Queries::FilterOptions.call(application_id: @current_application_id)
       @error_types = filter_options[:error_types]
       @platforms = filter_options[:platforms]
-
-      # Get all distinct assignees for the assignee filter dropdown
-      assignee_query = ErrorLog.where.not(assigned_to: nil)
-      # Filter by application if specified
-      assignee_query = assignee_query.where(application_id: @current_application_id) if @current_application_id.present?
-      @assignees = assignee_query.select(:assigned_to)
-                                 .distinct
-                                 .pluck(:assigned_to)
-                                 .sort
+      @assignees = filter_options[:assignees]
     end
 
     def show
@@ -109,67 +93,40 @@ module RailsErrorDashboard
       redirect_to error_path(@error)
     end
 
-    # Phase 3: Workflow Integration Actions
+    # Phase 3: Workflow Integration Actions (via Commands)
 
     def assign
-      @error = ErrorLog.find(params[:id])
-      @error.assign_to!(params[:assigned_to])
-      redirect_to error_path(@error)
-    rescue => e
+      @error = Commands::AssignError.call(params[:id], assigned_to: params[:assigned_to])
       redirect_to error_path(@error)
     end
 
     def unassign
-      @error = ErrorLog.find(params[:id])
-      @error.unassign!
-      redirect_to error_path(@error)
-    rescue => e
+      @error = Commands::UnassignError.call(params[:id])
       redirect_to error_path(@error)
     end
 
     def update_priority
-      @error = ErrorLog.find(params[:id])
-      @error.update!(priority_level: params[:priority_level])
-      redirect_to error_path(@error)
-    rescue => e
+      @error = Commands::UpdateErrorPriority.call(params[:id], priority_level: params[:priority_level])
       redirect_to error_path(@error)
     end
 
     def snooze
-      @error = ErrorLog.find(params[:id])
-      @error.snooze!(params[:hours].to_i, reason: params[:reason])
-      redirect_to error_path(@error)
-    rescue => e
+      @error = Commands::SnoozeError.call(params[:id], hours: params[:hours].to_i, reason: params[:reason])
       redirect_to error_path(@error)
     end
 
     def unsnooze
-      @error = ErrorLog.find(params[:id])
-      @error.unsnooze!
-      redirect_to error_path(@error)
-    rescue => e
+      @error = Commands::UnsnoozeError.call(params[:id])
       redirect_to error_path(@error)
     end
 
     def update_status
-      @error = ErrorLog.find(params[:id])
-      if @error.update_status!(params[:status], comment: params[:comment])
-        redirect_to error_path(@error)
-      else
-        redirect_to error_path(@error)
-      end
-    rescue => e
-      redirect_to error_path(@error)
+      result = Commands::UpdateErrorStatus.call(params[:id], status: params[:status], comment: params[:comment])
+      redirect_to error_path(result[:error])
     end
 
     def add_comment
-      @error = ErrorLog.find(params[:id])
-      @error.comments.create!(
-        author_name: params[:author_name],
-        body: params[:body]
-      )
-      redirect_to error_path(@error)
-    rescue => e
+      @error = Commands::AddErrorComment.call(params[:id], author_name: params[:author_name], body: params[:body])
       redirect_to error_path(@error)
     end
 

data/app/jobs/rails_error_dashboard/baseline_alert_job.rb

@@ -71,7 +71,7 @@ module RailsErrorDashboard
     end
 
     def send_slack_notification(error_log, anomaly_data, config)
-      payload = build_slack_payload(error_log, anomaly_data, config)
+      payload = Services::BaselineAlertPayloadBuilder.slack_payload(error_log, anomaly_data)
 
       HTTParty.post(
         config.slack_webhook_url,
@@ -83,8 +83,6 @@ module RailsErrorDashboard
     end
 
     def send_email_notification(error_log, _anomaly_data, _config)
-      # Use existing email notification infrastructure if available
-      # For now, log that email would be sent
       Rails.logger.info(
         "Baseline alert email would be sent for #{error_log.error_type}"
       )
@@ -93,7 +91,7 @@ module RailsErrorDashboard
     end
 
     def send_discord_notification(error_log, anomaly_data, config)
-      payload = build_discord_payload(error_log, anomaly_data, config)
+      payload = Services::BaselineAlertPayloadBuilder.discord_payload(error_log, anomaly_data)
 
       HTTParty.post(
         config.discord_webhook_url,
@@ -105,7 +103,7 @@ module RailsErrorDashboard
     end
 
     def send_webhook_notification(error_log, anomaly_data, config)
-      payload = build_webhook_payload(error_log, anomaly_data)
+      payload = Services::BaselineAlertPayloadBuilder.webhook_payload(error_log, anomaly_data)
 
       config.webhook_urls.each do |url|
         HTTParty.post(
@@ -119,145 +117,11 @@ module RailsErrorDashboard
     end
 
     def send_pagerduty_notification(error_log, _anomaly_data, _config)
-      # Use existing PagerDuty notification infrastructure if available
       Rails.logger.info(
         "Baseline alert PagerDuty notification for #{error_log.error_type}"
       )
     rescue => e
       Rails.logger.error("Failed to send baseline alert to PagerDuty: #{e.message}")
     end
-
-    # Build Slack message payload
-    def build_slack_payload(error_log, anomaly_data, config)
-      {
-        text: "🚨 Baseline Anomaly Alert",
-        blocks: [
-          {
-            type: "header",
-            text: {
-              type: "plain_text",
-              text: "🚨 Baseline Anomaly Detected"
-            }
-          },
-          {
-            type: "section",
-            fields: [
-              {
-                type: "mrkdwn",
-                text: "*Error Type:*\n#{error_log.error_type}"
-              },
-              {
-                type: "mrkdwn",
-                text: "*Platform:*\n#{error_log.platform}"
-              },
-              {
-                type: "mrkdwn",
-                text: "*Severity:*\n#{anomaly_level_emoji(anomaly_data[:level])} #{anomaly_data[:level].to_s.upcase}"
-              },
-              {
-                type: "mrkdwn",
-                text: "*Standard Deviations:*\n#{anomaly_data[:std_devs_above]&.round(1)}σ above baseline"
-              }
-            ]
-          },
-          {
-            type: "section",
-            text: {
-              type: "mrkdwn",
-              text: "*Message:*\n```#{error_log.message.truncate(200)}```"
-            }
-          },
-          {
-            type: "section",
-            text: {
-              type: "mrkdwn",
-              text: "*Baseline Info:*\nThreshold: #{anomaly_data[:threshold]&.round(1)} errors\nBaseline Type: #{anomaly_data[:baseline_type]}"
-            }
-          },
-          {
-            type: "actions",
-            elements: [
-              {
-                type: "button",
-                text: {
-                  type: "plain_text",
-                  text: "View in Dashboard"
-                },
-                url: dashboard_url(error_log, config)
-              }
-            ]
-          }
-        ]
-      }
-    end
-
-    # Build Discord embed payload
-    def build_discord_payload(error_log, anomaly_data, config)
-      {
-        embeds: [
-          {
-            title: "🚨 Baseline Anomaly Detected",
-            color: anomaly_color(anomaly_data[:level]),
-            fields: [
-              { name: "Error Type", value: error_log.error_type, inline: true },
-              { name: "Platform", value: error_log.platform, inline: true },
-              { name: "Severity", value: anomaly_data[:level].to_s.upcase, inline: true },
-              { name: "Standard Deviations", value: "#{anomaly_data[:std_devs_above]&.round(1)}σ above baseline", inline: true },
-              { name: "Threshold", value: "#{anomaly_data[:threshold]&.round(1)} errors", inline: true },
-              { name: "Baseline Type", value: anomaly_data[:baseline_type] || "N/A", inline: true },
-              { name: "Message", value: "```#{error_log.message.truncate(200)}```", inline: false }
-            ],
-            url: dashboard_url(error_log, config),
-            timestamp: Time.current.iso8601
-          }
-        ]
-      }
-    end
-
-    # Build generic webhook payload
-    def build_webhook_payload(error_log, anomaly_data)
-      {
-        event: "baseline_anomaly",
-        timestamp: Time.current.iso8601,
-        error: {
-          id: error_log.id,
-          type: error_log.error_type,
-          message: error_log.message,
-          platform: error_log.platform,
-          severity: error_log.severity.to_s,
-          occurred_at: error_log.occurred_at.iso8601
-        },
-        anomaly: {
-          level: anomaly_data[:level].to_s,
-          std_devs_above: anomaly_data[:std_devs_above],
-          threshold: anomaly_data[:threshold],
-          baseline_type: anomaly_data[:baseline_type]
-        },
-        dashboard_url: dashboard_url(error_log, RailsErrorDashboard.configuration)
-      }
-    end
-
-    def anomaly_level_emoji(level)
-      case level
-      when :critical then "🔴"
-      when :high then "🟠"
-      when :elevated then "🟡"
-      else "⚪"
-      end
-    end
-
-    def anomaly_color(level)
-      case level
-      when :critical then 15158332 # Red
-      when :high then 16744192 # Orange
-      when :elevated then 16776960 # Yellow
-      else 9807270 # Gray
-      end
-    end
-
-    def dashboard_url(error_log, config)
-      base_url = config.dashboard_base_url || "http://localhost:3000"
-      "#{base_url}/error_dashboard/errors/#{error_log.id}"
-    end
   end
 end

data/app/jobs/rails_error_dashboard/discord_error_notification_job.rb

@@ -13,7 +13,7 @@ module RailsErrorDashboard
 
       return unless webhook_url.present?
 
-      payload = build_discord_payload(error_log)
+      payload = Services::DiscordPayloadBuilder.call(error_log)
 
       HTTParty.post(
         webhook_url,
@@ -25,88 +25,5 @@ module RailsErrorDashboard
       Rails.logger.error("[RailsErrorDashboard] Failed to send Discord notification: #{e.message}")
       Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
     end
-
-    private
-
-    def build_discord_payload(error_log)
-      {
-        embeds: [ {
-          title: "🚨 New Error: #{error_log.error_type}",
-          description: truncate_message(error_log.message),
-          color: severity_color(error_log),
-          fields: [
-            {
-              name: "Platform",
-              value: error_log.platform || "Unknown",
-              inline: true
-            },
-            {
-              name: "Occurrences",
-              value: error_log.occurrence_count.to_s,
-              inline: true
-            },
-            {
-              name: "Controller",
-              value: error_log.controller_name || "N/A",
-              inline: true
-            },
-            {
-              name: "Action",
-              value: error_log.action_name || "N/A",
-              inline: true
-            },
-            {
-              name: "First Seen",
-              value: format_time(error_log.first_seen_at),
-              inline: true
-            },
-            {
-              name: "Location",
-              value: extract_first_backtrace_line(error_log.backtrace),
-              inline: false
-            }
-          ],
-          footer: {
-            text: "Rails Error Dashboard"
-          },
-          timestamp: error_log.occurred_at.iso8601
-        } ]
-      }
-    end
-
-    def severity_color(error_log)
-      case error_log.severity
-      when :critical
-        16711680 # Red
-      when :high
-        16744192 # Orange
-      when :medium
-        16776960 # Yellow
-      else
-        8421504  # Gray
-      end
-    end
-
-    def truncate_message(message, length = 200)
-      return "" if message.nil?
-      message.length > length ? "#{message[0...length]}..." : message
-    end
-
-    def format_time(time)
-      return "N/A" if time.nil?
-      time.strftime("%Y-%m-%d %H:%M:%S UTC")
-    end
-
-    def extract_first_backtrace_line(backtrace)
-      return "N/A" if backtrace.nil?
-
-      lines = backtrace.is_a?(String) ? backtrace.lines : backtrace
-      first_line = lines.first&.strip
-
-      return "N/A" if first_line.nil?
-
-      # Truncate if too long
-      first_line.length > 100 ? "#{first_line[0...100]}..." : first_line
-    end
   end
 end

data/app/jobs/rails_error_dashboard/pagerduty_error_notification_job.rb

@@ -19,7 +19,7 @@ module RailsErrorDashboard
       routing_key = RailsErrorDashboard.configuration.pagerduty_integration_key
       return unless routing_key.present?
 
-      payload = build_pagerduty_payload(error_log, routing_key)
+      payload = Services::PagerdutyPayloadBuilder.call(error_log, routing_key: routing_key)
 
       response = HTTParty.post(
         PAGERDUTY_EVENTS_API,
@@ -35,71 +35,5 @@ module RailsErrorDashboard
       Rails.logger.error("[RailsErrorDashboard] Failed to send PagerDuty notification: #{e.message}")
       Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
     end
-
-    private
-
-    def build_pagerduty_payload(error_log, routing_key)
-      {
-        routing_key: routing_key,
-        event_action: "trigger",
-        payload: {
-          summary: "Critical Error: #{error_log.error_type} in #{error_log.platform}",
-          severity: "critical",
-          source: error_source(error_log),
-          component: error_log.controller_name || "Unknown",
-          group: error_log.error_type,
-          class: error_log.error_type,
-          custom_details: {
-            message: error_log.message,
-            controller: error_log.controller_name,
-            action: error_log.action_name,
-            platform: error_log.platform,
-            occurrences: error_log.occurrence_count,
-            first_seen_at: error_log.first_seen_at&.iso8601,
-            last_seen_at: error_log.last_seen_at&.iso8601,
-            request_url: error_log.request_url,
-            backtrace: extract_backtrace_summary(error_log.backtrace),
-            error_id: error_log.id
-          }
-        },
-        links: dashboard_links(error_log),
-        client: "Rails Error Dashboard",
-        client_url: dashboard_url(error_log)
-      }
-    end
-
-    def error_source(error_log)
-      if error_log.controller_name && error_log.action_name
-        "#{error_log.controller_name}##{error_log.action_name}"
-      elsif error_log.request_url
-        error_log.request_url
-      else
-        error_log.platform || "Rails Application"
-      end
-    end
-
-    def extract_backtrace_summary(backtrace)
-      return [] if backtrace.nil?
-
-      lines = backtrace.is_a?(String) ? backtrace.lines : backtrace
-      lines.first(10).map(&:strip)
-    end
-
-    def dashboard_links(error_log)
-      [
-        {
-          href: dashboard_url(error_log),
-          text: "View in Error Dashboard"
-        }
-      ]
-    end
-
-    def dashboard_url(error_log)
-      # This will need to be configured per deployment
-      # For now, return a placeholder
-      config = RailsErrorDashboard.configuration
-      base_url = config.dashboard_base_url || "http://localhost:3000"
-      "#{base_url}/error_dashboard/errors/#{error_log.id}"
-    end
   end
 end