rails_error_dashboard 0.1.0

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/app/assets/stylesheets/rails_error_dashboard/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/rails_error_dashboard/application_controller.rb

@@ -0,0 +1,12 @@
+module RailsErrorDashboard
+  class ApplicationController < ActionController::Base
+    include Pagy::Backend
+
+    layout "rails_error_dashboard"
+
+    protect_from_forgery with: :exception
+
+    # Make Pagy helpers available in views
+    helper Pagy::Frontend
+  end
+end

data/app/controllers/rails_error_dashboard/errors_controller.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  class ErrorsController < ApplicationController
+    include Pagy::Backend
+
+    before_action :authenticate_dashboard_user!
+
+    def index
+      # Use Query to get filtered errors
+      errors_query = Queries::ErrorsList.call(filter_params)
+
+      # Paginate with Pagy
+      @pagy, @errors = pagy(errors_query, items: params[:per_page] || 25)
+
+      # Get dashboard stats using Query
+      @stats = Queries::DashboardStats.call
+
+      # 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
+
+    def show
+      @error = ErrorLog.find(params[:id])
+      @related_errors = @error.related_errors(limit: 5)
+
+      # Dispatch plugin event for error viewed
+      RailsErrorDashboard::PluginRegistry.dispatch(:on_error_viewed, @error)
+    end
+
+    def resolve
+      # Use Command to resolve error
+      @error = Commands::ResolveError.call(
+        params[:id],
+        resolved_by_name: params[:resolved_by_name],
+        resolution_comment: params[:resolution_comment],
+        resolution_reference: params[:resolution_reference]
+      )
+
+      redirect_to error_path(@error)
+    end
+
+    def analytics
+      days = (params[:days] || 30).to_i
+      @days = days
+
+      # Use Query to get analytics data
+      analytics = Queries::AnalyticsStats.call(days)
+
+      @error_stats = analytics[:error_stats]
+      @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]
+      @mobile_errors = analytics[:mobile_errors]
+      @api_errors = analytics[:api_errors]
+    end
+
+    def batch_action
+      error_ids = params[:error_ids] || []
+      action_type = params[:action_type]
+
+      result = case action_type
+      when "resolve"
+        Commands::BatchResolveErrors.call(
+          error_ids,
+          resolved_by_name: params[:resolved_by_name],
+          resolution_comment: params[:resolution_comment]
+        )
+      when "delete"
+        Commands::BatchDeleteErrors.call(error_ids)
+      else
+        { success: false, count: 0, errors: [ "Invalid action type" ] }
+      end
+
+      if result[:success]
+        flash[:notice] = "Successfully #{action_type}d #{result[:count]} error(s)"
+      else
+        flash[:alert] = "Batch operation failed: #{result[:errors].join(', ')}"
+      end
+
+      redirect_to errors_path
+    end
+
+    private
+
+    def filter_params
+      {
+        environment: params[:environment],
+        error_type: params[:error_type],
+        unresolved: params[:unresolved],
+        platform: params[:platform],
+        search: params[:search]
+      }
+    end
+
+    def authenticate_dashboard_user!
+      return if skip_authentication?
+
+      authenticate_or_request_with_http_basic do |username, password|
+        ActiveSupport::SecurityUtils.secure_compare(
+          username,
+          RailsErrorDashboard.configuration.dashboard_username
+        ) &
+        ActiveSupport::SecurityUtils.secure_compare(
+          password,
+          RailsErrorDashboard.configuration.dashboard_password
+        )
+      end
+    end
+
+    def skip_authentication?
+      !RailsErrorDashboard.configuration.require_authentication ||
+        (Rails.env.development? && !RailsErrorDashboard.configuration.require_authentication_in_development)
+    end
+  end
+end

data/app/helpers/rails_error_dashboard/application_helper.rb

@@ -0,0 +1,4 @@
+module RailsErrorDashboard
+  module ApplicationHelper
+  end
+end

data/app/jobs/rails_error_dashboard/application_job.rb

@@ -0,0 +1,4 @@
+module RailsErrorDashboard
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/rails_error_dashboard/discord_error_notification_job.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "httparty"
+
+module RailsErrorDashboard
+  # Job to send error notifications to Discord via webhook
+  class DiscordErrorNotificationJob < ApplicationJob
+    queue_as :default
+
+    def perform(error_log_id)
+      error_log = ErrorLog.find(error_log_id)
+      webhook_url = RailsErrorDashboard.configuration.discord_webhook_url
+
+      return unless webhook_url.present?
+
+      payload = build_discord_payload(error_log)
+
+      HTTParty.post(
+        webhook_url,
+        body: payload.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+    rescue StandardError => e
+      Rails.logger.error("Failed to send Discord notification: #{e.message}")
+      Rails.logger.error(e.backtrace.join("\n"))
+    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: "Environment",
+              value: error_log.environment || "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/email_error_notification_job.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  class EmailErrorNotificationJob < ApplicationJob
+    queue_as :error_notifications
+
+    def perform(error_log_id)
+      error_log = ErrorLog.find_by(id: error_log_id)
+      return unless error_log
+
+      recipients = RailsErrorDashboard.configuration.notification_email_recipients
+      return unless recipients.present?
+
+      ErrorNotificationMailer.error_alert(error_log, recipients).deliver_now
+    rescue => e
+      Rails.logger.error("Failed to send email notification: #{e.message}")
+    end
+  end
+end

data/app/jobs/rails_error_dashboard/pagerduty_error_notification_job.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "httparty"
+
+module RailsErrorDashboard
+  # Job to send critical error notifications to PagerDuty
+  # Only triggers for critical severity errors
+  class PagerdutyErrorNotificationJob < ApplicationJob
+    queue_as :default
+
+    PAGERDUTY_EVENTS_API = "https://events.pagerduty.com/v2/enqueue"
+
+    def perform(error_log_id)
+      error_log = ErrorLog.find(error_log_id)
+
+      # Only trigger PagerDuty for critical errors
+      return unless error_log.critical?
+
+      routing_key = RailsErrorDashboard.configuration.pagerduty_integration_key
+      return unless routing_key.present?
+
+      payload = build_pagerduty_payload(error_log, routing_key)
+
+      response = HTTParty.post(
+        PAGERDUTY_EVENTS_API,
+        body: payload.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+
+      unless response.success?
+        Rails.logger.error("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"))
+    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,
+            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,
+            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

data/app/jobs/rails_error_dashboard/slack_error_notification_job.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  class SlackErrorNotificationJob < ApplicationJob
+    queue_as :error_notifications
+
+    def perform(error_log_id)
+      error_log = ErrorLog.find_by(id: error_log_id)
+      return unless error_log
+
+      webhook_url = RailsErrorDashboard.configuration.slack_webhook_url
+      return unless webhook_url.present?
+
+      send_slack_notification(error_log, webhook_url)
+    rescue => e
+      Rails.logger.error("Failed to send Slack notification: #{e.message}")
+    end
+
+    private
+
+    def send_slack_notification(error_log, webhook_url)
+      require "net/http"
+      require "json"
+
+      uri = URI(webhook_url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+
+      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}")
+      end
+    end
+
+    def slack_payload(error_log)
+      {
+        text: "🚨 New Error in #{error_log.environment.titleize} Environment",
+        blocks: [
+          {
+            type: "header",
+            text: {
+              type: "plain_text",
+              text: "🚨 Error Alert",
+              emoji: true
+            }
+          },
+          {
+            type: "section",
+            fields: [
+              {
+                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'}"
+              },
+              {
+                type: "mrkdwn",
+                text: "*Occurred:*\n#{error_log.occurred_at.strftime('%B %d, %Y at %I:%M %p')}"
+              }
+            ]
+          },
+          {
+            type: "section",
+            text: {
+              type: "mrkdwn",
+              text: "*Message:*\n```#{truncate_message(error_log.message)}```"
+            }
+          },
+          user_section(error_log),
+          request_section(error_log),
+          {
+            type: "actions",
+            elements: [
+              {
+                type: "button",
+                text: {
+                  type: "plain_text",
+                  text: "View Details",
+                  emoji: true
+                },
+                url: dashboard_url(error_log),
+                style: "primary"
+              }
+            ]
+          },
+          {
+            type: "context",
+            elements: [
+              {
+                type: "mrkdwn",
+                text: "Error ID: #{error_log.id}"
+              }
+            ]
+          }
+        ].compact
+      }
+    end
+
+    def user_section(error_log)
+      return nil unless error_log.user_id.present?
+
+      user_email = error_log.user&.email || "User ##{error_log.user_id}"
+
+      {
+        type: "section",
+        fields: [
+          {
+            type: "mrkdwn",
+            text: "*User:*\n#{user_email}"
+          },
+          {
+            type: "mrkdwn",
+            text: "*IP Address:*\n#{error_log.ip_address || 'N/A'}"
+          }
+        ]
+      }
+    end
+
+    def request_section(error_log)
+      return nil unless error_log.request_url.present?
+
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: "*Request URL:*\n`#{truncate_message(error_log.request_url, 200)}`"
+        }
+      }
+    end
+
+    def platform_emoji(platform)
+      case platform&.downcase
+      when "ios"
+        "📱"
+      when "android"
+        "🤖"
+      when "api"
+        "🔌"
+      else
+        "💻"
+      end
+    end
+
+    def truncate_message(message, length = 500)
+      return "" unless message
+      message.length > length ? "#{message[0...length]}..." : message
+    end
+
+    def dashboard_url(error_log)
+      # Generate URL to error dashboard
+      # This will need to be configured based on your app's URL
+      base_url = RailsErrorDashboard.configuration.dashboard_base_url || "http://localhost:3000"
+      "#{base_url}/error_dashboard/errors/#{error_log.id}"
+    end
+  end
+end

data/app/jobs/rails_error_dashboard/webhook_error_notification_job.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "httparty"
+
+module RailsErrorDashboard
+  # Job to send error notifications to custom webhook URLs
+  # Supports multiple webhooks for different integrations
+  class WebhookErrorNotificationJob < ApplicationJob
+    queue_as :default
+
+    def perform(error_log_id)
+      error_log = ErrorLog.find(error_log_id)
+      webhook_urls = RailsErrorDashboard.configuration.webhook_urls
+
+      return unless webhook_urls.present?
+
+      # Ensure webhook_urls is an array
+      urls = Array(webhook_urls)
+
+      payload = build_webhook_payload(error_log)
+
+      urls.each do |url|
+        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"))
+    end
+
+    private
+
+    def send_webhook(url, payload, error_log)
+      response = HTTParty.post(
+        url,
+        body: payload.to_json,
+        headers: {
+          "Content-Type" => "application/json",
+          "User-Agent" => "RailsErrorDashboard/1.0",
+          "X-Error-Dashboard-Event" => "error.created",
+          "X-Error-Dashboard-ID" => error_log.id.to_s
+        },
+        timeout: 10 # 10 second timeout
+      )
+
+      unless response.success?
+        Rails.logger.warn("Webhook failed for #{url}: #{response.code}")
+      end
+    rescue StandardError => e
+      Rails.logger.error("Webhook error for #{url}: #{e.message}")
+    end
+
+    def build_webhook_payload(error_log)
+      {
+        event: "error.created",
+        timestamp: Time.current.iso8601,
+        error: {
+          id: error_log.id,
+          type: error_log.error_type,
+          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,
+          first_seen_at: error_log.first_seen_at&.iso8601,
+          last_seen_at: error_log.last_seen_at&.iso8601,
+          occurred_at: error_log.occurred_at.iso8601,
+          resolved: error_log.resolved,
+          request: {
+            url: error_log.request_url,
+            params: parse_request_params(error_log.request_params),
+            user_agent: error_log.user_agent,
+            ip_address: error_log.ip_address
+          },
+          user: {
+            id: error_log.user_id
+          },
+          backtrace: extract_backtrace(error_log.backtrace),
+          metadata: {
+            error_hash: error_log.error_hash,
+            dashboard_url: dashboard_url(error_log)
+          }
+        }
+      }
+    end
+
+    def parse_request_params(params_json)
+      return {} if params_json.nil?
+      JSON.parse(params_json)
+    rescue JSON::ParserError
+      {}
+    end
+
+    def extract_backtrace(backtrace)
+      return [] if backtrace.nil?
+
+      lines = backtrace.is_a?(String) ? backtrace.lines : backtrace
+      lines.first(20).map(&:strip)
+    end
+
+    def dashboard_url(error_log)
+      config = RailsErrorDashboard.configuration
+      base_url = config.dashboard_base_url || "http://localhost:3000"
+      "#{base_url}/error_dashboard/errors/#{error_log.id}"
+    end
+  end
+end

data/app/mailers/rails_error_dashboard/application_mailer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  class ApplicationMailer < ActionMailer::Base
+    default from: -> { RailsErrorDashboard.configuration.notification_email_from }
+    layout "mailer"
+  end
+end