rails_error_dashboard 0.1.0 → 0.1.1

data/app/controllers/rails_error_dashboard/application_controller.rb

@@ -8,5 +8,23 @@ module RailsErrorDashboard
 
     # 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
+    rescue_from StandardError do |exception|
+      # Log the error for debugging
+      Rails.logger.error("[RailsErrorDashboard] Dashboard controller error: #{exception.class} - #{exception.message}")
+      Rails.logger.error("Request: #{request.path} (#{request.method})")
+      Rails.logger.error("Params: #{params.inspect}")
+      Rails.logger.error(exception.backtrace&.first(10)&.join("\n")) if exception.backtrace
+
+      # Render user-friendly error page
+      render plain: "The Error Dashboard encountered an issue displaying this page.\n\n" \
+                    "Your application is unaffected - this is only a dashboard display error.\n\n" \
+                    "Error: #{exception.message}\n\n" \
+                    "Check Rails logs for details: [RailsErrorDashboard]",
+             status: :internal_server_error,
+             layout: false
+    end
   end
 end

data/app/controllers/rails_error_dashboard/errors_controller.rb

@@ -18,7 +18,6 @@ module RailsErrorDashboard
 
       # Get filter options using Query
       filter_options = Queries::FilterOptions.call
-      @environments = filter_options[:environments]
       @error_types = filter_options[:error_types]
       @platforms = filter_options[:platforms]
     end
@@ -54,7 +53,6 @@ module RailsErrorDashboard
       @errors_over_time = analytics[:errors_over_time]
       @errors_by_type = analytics[:errors_by_type]
       @errors_by_platform = analytics[:errors_by_platform]
-      @errors_by_environment = analytics[:errors_by_environment]
       @errors_by_hour = analytics[:errors_by_hour]
       @top_users = analytics[:top_users]
       @resolution_rate = analytics[:resolution_rate]
@@ -62,6 +60,30 @@ module RailsErrorDashboard
       @api_errors = analytics[:api_errors]
     end
 
+    def platform_comparison
+      # Check if feature is enabled
+      unless RailsErrorDashboard.configuration.enable_platform_comparison
+        flash[:alert] = "Platform Comparison is not enabled. Enable it in config/initializers/rails_error_dashboard.rb"
+        redirect_to errors_path
+        return
+      end
+
+      days = (params[:days] || 7).to_i
+      @days = days
+
+      # Use Query to get platform comparison data
+      comparison = Queries::PlatformComparison.new(days: days)
+
+      @error_rate_by_platform = comparison.error_rate_by_platform
+      @severity_distribution = comparison.severity_distribution_by_platform
+      @resolution_times = comparison.resolution_time_by_platform
+      @top_errors_by_platform = comparison.top_errors_by_platform
+      @stability_scores = comparison.platform_stability_scores
+      @cross_platform_errors = comparison.cross_platform_errors
+      @daily_trends = comparison.daily_trend_by_platform
+      @platform_health = comparison.platform_health_summary
+    end
+
     def batch_action
       error_ids = params[:error_ids] || []
       action_type = params[:action_type]
@@ -88,15 +110,36 @@ module RailsErrorDashboard
       redirect_to errors_path
     end
 
+    def correlation
+      # Check if feature is enabled
+      unless RailsErrorDashboard.configuration.enable_error_correlation
+        flash[:alert] = "Error Correlation is not enabled. Enable it in config/initializers/rails_error_dashboard.rb"
+        redirect_to errors_path
+        return
+      end
+
+      days = (params[:days] || 30).to_i
+      @days = days
+      correlation = Queries::ErrorCorrelation.new(days: days)
+
+      @errors_by_version = correlation.errors_by_version
+      @errors_by_git_sha = correlation.errors_by_git_sha
+      @problematic_releases = correlation.problematic_releases
+      @multi_error_users = correlation.multi_error_users(min_error_types: 2)
+      @time_correlated_errors = correlation.time_correlated_errors
+      @period_comparison = correlation.period_comparison
+      @platform_specific_errors = correlation.platform_specific_errors
+    end
+
     private
 
     def filter_params
       {
-        environment: params[:environment],
         error_type: params[:error_type],
         unresolved: params[:unresolved],
         platform: params[:platform],
-        search: params[:search]
+        search: params[:search],
+        severity: params[:severity]
       }
     end
 

data/app/helpers/rails_error_dashboard/application_helper.rb

@@ -1,4 +1,21 @@
 module RailsErrorDashboard
   module ApplicationHelper
+    # Returns Bootstrap color class for error severity
+    # @param severity [Symbol] The severity level (:critical, :high, :medium, :low, :info)
+    # @return [String] Bootstrap color class (danger, warning, info, secondary)
+    def severity_color(severity)
+      case severity&.to_sym
+      when :critical
+        "danger"
+      when :high
+        "warning"
+      when :medium
+        "info"
+      when :low
+        "secondary"
+      else
+        "secondary"
+      end
+    end
   end
 end

data/app/jobs/rails_error_dashboard/application_job.rb

@@ -1,4 +1,23 @@
 module RailsErrorDashboard
   class ApplicationJob < ActiveJob::Base
+    # CRITICAL: Ensure job failures don't break the app or spam error logs
+    # Retry failed jobs with exponential backoff, but limit attempts
+    retry_on StandardError, wait: :exponentially_longer, attempts: 3
+
+    # Global exception handling for all dashboard jobs
+    rescue_from StandardError do |exception|
+      # Log the error for debugging but don't propagate
+      Rails.logger.error("[RailsErrorDashboard] Job #{self.class.name} failed: #{exception.class} - #{exception.message}")
+      Rails.logger.error("Job arguments: #{arguments.inspect}")
+      Rails.logger.error("Attempt: #{executions}/3") if respond_to?(:executions)
+      Rails.logger.error(exception.backtrace&.first(10)&.join("\n")) if exception.backtrace
+
+      # Re-raise to trigger retry mechanism (up to 3 attempts)
+      # After 3 attempts, ActiveJob will discard the job and log it
+      raise exception if executions < 3
+
+      # If we've exhausted retries, log and give up gracefully
+      Rails.logger.error("[RailsErrorDashboard] Job #{self.class.name} discarded after #{executions} attempts")
+    end
   end
 end

data/app/jobs/rails_error_dashboard/async_error_logging_job.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Background job for asynchronous error logging
+  # This prevents error logging from blocking the main request/response cycle
+  class AsyncErrorLoggingJob < ApplicationJob
+    queue_as :default
+
+    # Performs async error logging
+    # @param exception_data [Hash] Serialized exception data
+    # @param context [Hash] Error context (request, user, etc.)
+    def perform(exception_data, context)
+      # Reconstruct the exception from serialized data
+      exception = reconstruct_exception(exception_data)
+
+      # Log the error synchronously in the background job
+      # Call .new().call to bypass async check (we're already async)
+      Commands::LogError.new(exception, context).call
+    rescue => e
+      # Don't let async job errors break the job queue
+      Rails.logger.error("AsyncErrorLoggingJob failed: #{e.message}")
+      Rails.logger.error("Backtrace: #{e.backtrace&.first(5)&.join("\n")}")
+    end
+
+    private
+
+    # Reconstruct exception from serialized data
+    # @param data [Hash] Serialized exception data
+    # @return [Exception] Reconstructed exception object
+    def reconstruct_exception(data)
+      # Get or create the exception class
+      exception_class = begin
+        data[:class_name].constantize
+      rescue NameError
+        # If class doesn't exist, use StandardError
+        StandardError
+      end
+
+      # Create new exception with the original message
+      exception = exception_class.new(data[:message])
+
+      # Restore the backtrace
+      exception.set_backtrace(data[:backtrace]) if data[:backtrace]
+
+      exception
+    end
+  end
+end

data/app/jobs/rails_error_dashboard/baseline_alert_job.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Sends baseline anomaly alerts through configured notification channels
+  #
+  # This job is triggered when an error exceeds baseline thresholds.
+  # It respects cooldown periods to prevent alert fatigue and sends
+  # notifications through all enabled channels (Slack, Email, Discord, etc.)
+  class BaselineAlertJob < ApplicationJob
+    queue_as :default
+
+    # @param error_log_id [Integer] The error log that triggered the alert
+    # @param anomaly_data [Hash] Anomaly information from baseline check
+    def perform(error_log_id, anomaly_data)
+      error_log = ErrorLog.find_by(id: error_log_id)
+      return unless error_log
+
+      config = RailsErrorDashboard.configuration
+
+      # Check if we should send alert (cooldown check)
+      unless Services::BaselineAlertThrottler.should_alert?(
+        error_log.error_type,
+        error_log.platform,
+        cooldown_minutes: config.baseline_alert_cooldown_minutes
+      )
+        Rails.logger.info(
+          "Baseline alert throttled for #{error_log.error_type} on #{error_log.platform}"
+        )
+        return
+      end
+
+      # Record that we're sending an alert
+      Services::BaselineAlertThrottler.record_alert(
+        error_log.error_type,
+        error_log.platform
+      )
+
+      # Send notifications through all enabled channels
+      send_notifications(error_log, anomaly_data, config)
+    end
+
+    private
+
+    def send_notifications(error_log, anomaly_data, config)
+      # Slack notification
+      if config.enable_slack_notifications && config.slack_webhook_url.present?
+        send_slack_notification(error_log, anomaly_data, config)
+      end
+
+      # Email notification
+      if config.enable_email_notifications && config.notification_email_recipients.any?
+        send_email_notification(error_log, anomaly_data, config)
+      end
+
+      # Discord notification
+      if config.enable_discord_notifications && config.discord_webhook_url.present?
+        send_discord_notification(error_log, anomaly_data, config)
+      end
+
+      # Webhook notification
+      if config.enable_webhook_notifications && config.webhook_urls.any?
+        send_webhook_notification(error_log, anomaly_data, config)
+      end
+
+      # PagerDuty for critical anomalies
+      if config.enable_pagerduty_notifications &&
+         config.pagerduty_integration_key.present? &&
+         anomaly_data[:level] == :critical
+        send_pagerduty_notification(error_log, anomaly_data, config)
+      end
+    end
+
+    def send_slack_notification(error_log, anomaly_data, config)
+      payload = build_slack_payload(error_log, anomaly_data, config)
+
+      HTTParty.post(
+        config.slack_webhook_url,
+        body: payload.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+    rescue => e
+      Rails.logger.error("Failed to send baseline alert to Slack: #{e.message}")
+    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}"
+      )
+    rescue => e
+      Rails.logger.error("Failed to send baseline alert email: #{e.message}")
+    end
+
+    def send_discord_notification(error_log, anomaly_data, config)
+      payload = build_discord_payload(error_log, anomaly_data, config)
+
+      HTTParty.post(
+        config.discord_webhook_url,
+        body: payload.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+    rescue => e
+      Rails.logger.error("Failed to send baseline alert to Discord: #{e.message}")
+    end
+
+    def send_webhook_notification(error_log, anomaly_data, config)
+      payload = build_webhook_payload(error_log, anomaly_data)
+
+      config.webhook_urls.each do |url|
+        HTTParty.post(
+          url,
+          body: payload.to_json,
+          headers: { "Content-Type" => "application/json" }
+        )
+      end
+    rescue => e
+      Rails.logger.error("Failed to send baseline alert to webhook: #{e.message}")
+    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

@@ -18,11 +18,12 @@ module RailsErrorDashboard
       HTTParty.post(
         webhook_url,
         body: payload.to_json,
-        headers: { "Content-Type" => "application/json" }
+        headers: { "Content-Type" => "application/json" },
+        timeout: 10  # CRITICAL: 10 second timeout to prevent hanging
       )
     rescue StandardError => e
-      Rails.logger.error("Failed to send Discord notification: #{e.message}")
-      Rails.logger.error(e.backtrace.join("\n"))
+      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
@@ -39,11 +40,6 @@ module RailsErrorDashboard
               value: error_log.platform || "Unknown",
               inline: true
             },
-            {
-              name: "Environment",
-              value: error_log.environment || "Unknown",
-              inline: true
-            },
             {
               name: "Occurrences",
               value: error_log.occurrence_count.to_s,

data/app/jobs/rails_error_dashboard/email_error_notification_job.rb

@@ -13,7 +13,8 @@ module RailsErrorDashboard
 
       ErrorNotificationMailer.error_alert(error_log, recipients).deliver_now
     rescue => e
-      Rails.logger.error("Failed to send email notification: #{e.message}")
+      Rails.logger.error("[RailsErrorDashboard] Failed to send email notification: #{e.message}")
+      Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
     end
   end
 end

data/app/jobs/rails_error_dashboard/pagerduty_error_notification_job.rb

@@ -24,15 +24,16 @@ module RailsErrorDashboard
       response = HTTParty.post(
         PAGERDUTY_EVENTS_API,
         body: payload.to_json,
-        headers: { "Content-Type" => "application/json" }
+        headers: { "Content-Type" => "application/json" },
+        timeout: 10  # CRITICAL: 10 second timeout to prevent hanging
       )
 
       unless response.success?
-        Rails.logger.error("PagerDuty API error: #{response.code} - #{response.body}")
+        Rails.logger.error("[RailsErrorDashboard] PagerDuty API error: #{response.code} - #{response.body}")
       end
     rescue StandardError => e
-      Rails.logger.error("Failed to send PagerDuty notification: #{e.message}")
-      Rails.logger.error(e.backtrace.join("\n"))
+      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
@@ -53,7 +54,6 @@ module RailsErrorDashboard
             controller: error_log.controller_name,
             action: error_log.action_name,
             platform: error_log.platform,
-            environment: error_log.environment,
             occurrences: error_log.occurrence_count,
             first_seen_at: error_log.first_seen_at&.iso8601,
             last_seen_at: error_log.last_seen_at&.iso8601,

data/app/jobs/rails_error_dashboard/slack_error_notification_job.rb

@@ -26,19 +26,27 @@ module RailsErrorDashboard
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = true
 
+      # CRITICAL: Add timeouts to prevent hanging the job queue
+      http.open_timeout = 5  # 5 seconds to establish connection
+      http.read_timeout = 10  # 10 seconds to read response
+
       request = Net::HTTP::Post.new(uri.path, { "Content-Type" => "application/json" })
       request.body = slack_payload(error_log).to_json
 
       response = http.request(request)
 
       unless response.is_a?(Net::HTTPSuccess)
-        Rails.logger.error("Slack notification failed: #{response.code} - #{response.body}")
+        Rails.logger.error("[RailsErrorDashboard] Slack notification failed: #{response.code} - #{response.body}")
       end
+    rescue Timeout::Error, Errno::ECONNREFUSED, SocketError, Net::OpenTimeout, Net::ReadTimeout => e
+      # Network errors - log and fail gracefully
+      Rails.logger.error("[RailsErrorDashboard] Slack HTTP request failed: #{e.class} - #{e.message}")
+      nil
     end
 
     def slack_payload(error_log)
       {
-        text: "🚨 New Error in #{error_log.environment.titleize} Environment",
+        text: "🚨 New Error Alert",
         blocks: [
           {
             type: "header",
@@ -55,10 +63,6 @@ module RailsErrorDashboard
                 type: "mrkdwn",
                 text: "*Error Type:*\n`#{error_log.error_type}`"
               },
-              {
-                type: "mrkdwn",
-                text: "*Environment:*\n#{error_log.environment.titleize}"
-              },
               {
                 type: "mrkdwn",
                 text: "*Platform:*\n#{platform_emoji(error_log.platform)} #{error_log.platform || 'Unknown'}"

data/app/jobs/rails_error_dashboard/webhook_error_notification_job.rb

@@ -23,8 +23,8 @@ module RailsErrorDashboard
         send_webhook(url, payload, error_log)
       end
     rescue StandardError => e
-      Rails.logger.error("Failed to send webhook notification: #{e.message}")
-      Rails.logger.error(e.backtrace.join("\n"))
+      Rails.logger.error("[RailsErrorDashboard] Failed to send webhook notification: #{e.message}")
+      Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
     end
 
     private
@@ -39,14 +39,14 @@ module RailsErrorDashboard
           "X-Error-Dashboard-Event" => "error.created",
           "X-Error-Dashboard-ID" => error_log.id.to_s
         },
-        timeout: 10 # 10 second timeout
+        timeout: 10  # CRITICAL: 10 second timeout to prevent hanging
       )
 
       unless response.success?
-        Rails.logger.warn("Webhook failed for #{url}: #{response.code}")
+        Rails.logger.warn("[RailsErrorDashboard] Webhook failed for #{url}: #{response.code}")
       end
     rescue StandardError => e
-      Rails.logger.error("Webhook error for #{url}: #{e.message}")
+      Rails.logger.error("[RailsErrorDashboard] Webhook error for #{url}: #{e.message}")
     end
 
     def build_webhook_payload(error_log)
@@ -59,7 +59,6 @@ module RailsErrorDashboard
           message: error_log.message,
           severity: error_log.severity.to_s,
           platform: error_log.platform,
-          environment: error_log.environment,
           controller: error_log.controller_name,
           action: error_log.action_name,
           occurrence_count: error_log.occurrence_count,

data/app/mailers/rails_error_dashboard/application_mailer.rb

@@ -3,6 +3,6 @@
 module RailsErrorDashboard
   class ApplicationMailer < ActionMailer::Base
     default from: -> { RailsErrorDashboard.configuration.notification_email_from }
-    layout "mailer"
+    layout false
   end
 end

data/app/mailers/rails_error_dashboard/error_notification_mailer.rb

@@ -8,7 +8,7 @@ module RailsErrorDashboard
 
       mail(
         to: recipients,
-        subject: "🚨 [#{error_log.environment.upcase}] #{error_log.error_type}: #{truncate_subject(error_log.message)}"
+        subject: "🚨 #{error_log.error_type}: #{truncate_subject(error_log.message)}"
       )
     end