rails_error_dashboard 0.1.0

data/db/migrate/20251224000001_create_rails_error_dashboard_error_logs.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class CreateRailsErrorDashboardErrorLogs < ActiveRecord::Migration[7.0]
+  def change
+    create_table :rails_error_dashboard_error_logs do |t|
+      # Error details
+      t.string :error_type, null: false
+      t.text :message, null: false
+      t.text :backtrace
+
+      # Context
+      t.integer :user_id
+      t.text :request_url
+      t.text :request_params
+      t.text :user_agent
+      t.string :ip_address
+      t.string :environment, null: false
+      t.string :platform
+
+      # Resolution tracking
+      t.boolean :resolved, default: false, null: false
+      t.text :resolution_comment
+      t.string :resolution_reference
+      t.string :resolved_by_name
+      t.datetime :resolved_at
+
+      # Timestamps
+      t.datetime :occurred_at, null: false
+      t.timestamps
+    end
+
+    # Indexes for performance
+    add_index :rails_error_dashboard_error_logs, :user_id
+    add_index :rails_error_dashboard_error_logs, :error_type
+    add_index :rails_error_dashboard_error_logs, :environment
+    add_index :rails_error_dashboard_error_logs, :resolved
+    add_index :rails_error_dashboard_error_logs, :occurred_at
+    add_index :rails_error_dashboard_error_logs, :platform
+  end
+end

data/db/migrate/20251224081522_add_better_tracking_to_error_logs.rb

@@ -0,0 +1,13 @@
+class AddBetterTrackingToErrorLogs < ActiveRecord::Migration[8.1]
+  def change
+    add_column :rails_error_dashboard_error_logs, :error_hash, :string
+    add_column :rails_error_dashboard_error_logs, :first_seen_at, :datetime
+    add_column :rails_error_dashboard_error_logs, :last_seen_at, :datetime
+    add_column :rails_error_dashboard_error_logs, :occurrence_count, :integer, default: 1, null: false
+
+    add_index :rails_error_dashboard_error_logs, :error_hash
+    add_index :rails_error_dashboard_error_logs, :first_seen_at
+    add_index :rails_error_dashboard_error_logs, :last_seen_at
+    add_index :rails_error_dashboard_error_logs, :occurrence_count
+  end
+end

data/db/migrate/20251224101217_add_controller_action_to_error_logs.rb

@@ -0,0 +1,10 @@
+class AddControllerActionToErrorLogs < ActiveRecord::Migration[8.1]
+  def change
+    add_column :rails_error_dashboard_error_logs, :controller_name, :string
+    add_column :rails_error_dashboard_error_logs, :action_name, :string
+
+    # Add composite index for efficient querying by controller/action
+    add_index :rails_error_dashboard_error_logs, [ :controller_name, :action_name, :error_hash ],
+              name: 'index_error_logs_on_controller_action_hash'
+  end
+end

data/lib/generators/rails_error_dashboard/install/install_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Installs Rails Error Dashboard and generates the necessary files"
+
+      def create_initializer_file
+        template "initializer.rb", "config/initializers/rails_error_dashboard.rb"
+      end
+
+      def copy_migrations
+        rake "rails_error_dashboard:install:migrations"
+      end
+
+      def add_route
+        route "mount RailsErrorDashboard::Engine => '/error_dashboard'"
+      end
+
+      def show_readme
+        readme "README" if behavior == :invoke
+      end
+    end
+  end
+end

data/lib/generators/rails_error_dashboard/install/templates/README

@@ -0,0 +1,33 @@
+===============================================================================
+
+Rails Error Dashboard has been installed!
+
+Next steps:
+
+1. Run migrations:
+   rails db:migrate
+
+2. (Optional) If you want to use a separate database for error logs:
+   - Set USE_SEPARATE_ERROR_DB=true in your .env file
+   - Configure error_logs database in config/database.yml
+   - Run: rails db:create:error_logs
+   - Run: rails db:migrate:error_logs
+
+3. Start your Rails server:
+   rails server
+
+4. Visit the error dashboard:
+   http://localhost:3000/error_dashboard
+
+5. Default credentials (change in config/initializers/rails_error_dashboard.rb):
+   Username: admin
+   Password: password
+
+6. (Optional) Set up Slack notifications:
+   - Set SLACK_WEBHOOK_URL in your .env file
+   - Errors will be sent to your Slack channel automatically
+
+For more information, visit:
+https://github.com/anjanjagirdar/rails_error_dashboard
+
+===============================================================================

data/lib/generators/rails_error_dashboard/install/templates/initializer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+RailsErrorDashboard.configure do |config|
+  # Dashboard authentication credentials
+  # Change these in production or use environment variables
+  config.dashboard_username = ENV.fetch("ERROR_DASHBOARD_USER", "admin")
+  config.dashboard_password = ENV.fetch("ERROR_DASHBOARD_PASSWORD", "password")
+
+  # Require authentication for dashboard access
+  # Set to false to disable authentication (not recommended in production)
+  config.require_authentication = true
+
+  # Require authentication even in development mode
+  # Set to true if you want to test authentication in development
+  config.require_authentication_in_development = false
+
+  # User model for associations (defaults to 'User')
+  # Change this if your user model has a different name
+  config.user_model = "User"
+
+  # === NOTIFICATION SETTINGS ===
+  #
+  # Notifications are sent asynchronously via the :error_notifications queue
+  # Works with: Solid Queue (Rails 8.1+), Sidekiq, Delayed Job, Resque, etc.
+  #
+  # For Sidekiq, add to config/sidekiq.yml:
+  #   :queues:
+  #     - error_notifications
+  #     - default
+  #
+  # For Solid Queue (Rails 8.1+), add to config/queue.yml:
+  #   workers:
+  #     - queues: error_notifications
+  #       threads: 3
+
+  # Slack notifications
+  config.enable_slack_notifications = true
+  config.slack_webhook_url = ENV["SLACK_WEBHOOK_URL"]
+
+  # Email notifications
+  config.enable_email_notifications = true
+  config.notification_email_recipients = ENV.fetch("ERROR_NOTIFICATION_EMAILS", "").split(",").map(&:strip)
+  config.notification_email_from = ENV.fetch("ERROR_NOTIFICATION_FROM", "errors@example.com")
+
+  # Dashboard base URL (used in notification links)
+  # Example: 'https://myapp.com' or 'http://localhost:3000'
+  config.dashboard_base_url = ENV["DASHBOARD_BASE_URL"]
+
+  # Use a separate database for error logs (optional)
+  # See documentation for setup instructions: docs/SEPARATE_ERROR_DATABASE.md
+  config.use_separate_database = ENV.fetch("USE_SEPARATE_ERROR_DB", "false") == "true"
+
+  # Retention policy - number of days to keep error logs
+  # Old errors will be automatically deleted after this many days
+  config.retention_days = 90
+
+  # Enable/disable error catching middleware
+  # Set to false if you want to handle errors differently
+  config.enable_middleware = true
+
+  # Enable/disable Rails.error subscriber
+  # Set to false if you don't want to use Rails error reporting
+  config.enable_error_subscriber = true
+end

data/lib/rails_error_dashboard/commands/batch_delete_errors.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Commands
+    # Command: Delete multiple errors at once
+    # This is a write operation that destroys multiple ErrorLog records
+    class BatchDeleteErrors
+      def self.call(error_ids)
+        new(error_ids).call
+      end
+
+      def initialize(error_ids)
+        @error_ids = Array(error_ids).compact
+      end
+
+      def call
+        return { success: false, count: 0, errors: [ "No error IDs provided" ] } if @error_ids.empty?
+
+        errors = ErrorLog.where(id: @error_ids)
+        count = errors.count
+        error_ids_to_delete = errors.pluck(:id)
+
+        errors.destroy_all
+
+        # Dispatch plugin event for batch deleted errors
+        PluginRegistry.dispatch(:on_errors_batch_deleted, error_ids_to_delete) if error_ids_to_delete.any?
+
+        {
+          success: true,
+          count: count,
+          total: @error_ids.size,
+          errors: []
+        }
+      rescue => e
+        Rails.logger.error("Batch delete failed: #{e.message}")
+        { success: false, count: 0, total: @error_ids.size, errors: [ e.message ] }
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/commands/batch_resolve_errors.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Commands
+    # Command: Resolve multiple errors at once
+    # This is a write operation that updates multiple ErrorLog records
+    class BatchResolveErrors
+      def self.call(error_ids, resolved_by_name: nil, resolution_comment: nil)
+        new(error_ids, resolved_by_name, resolution_comment).call
+      end
+
+      def initialize(error_ids, resolved_by_name = nil, resolution_comment = nil)
+        @error_ids = Array(error_ids).compact
+        @resolved_by_name = resolved_by_name
+        @resolution_comment = resolution_comment
+      end
+
+      def call
+        return { success: false, count: 0, errors: [ "No error IDs provided" ] } if @error_ids.empty?
+
+        errors = ErrorLog.where(id: @error_ids)
+
+        resolved_count = 0
+        failed_ids = []
+
+        resolved_errors = []
+
+        errors.each do |error|
+          begin
+            error.update!(
+              resolved: true,
+              resolved_at: Time.current,
+              resolved_by_name: @resolved_by_name,
+              resolution_comment: @resolution_comment
+            )
+            resolved_count += 1
+            resolved_errors << error
+          rescue => e
+            failed_ids << error.id
+            Rails.logger.error("Failed to resolve error #{error.id}: #{e.message}")
+          end
+        end
+
+        # Dispatch plugin event for batch resolved errors
+        PluginRegistry.dispatch(:on_errors_batch_resolved, resolved_errors) if resolved_errors.any?
+
+        {
+          success: failed_ids.empty?,
+          count: resolved_count,
+          total: @error_ids.size,
+          failed_ids: failed_ids,
+          errors: failed_ids.empty? ? [] : [ "Failed to resolve #{failed_ids.size} error(s)" ]
+        }
+      rescue => e
+        Rails.logger.error("Batch resolve failed: #{e.message}")
+        { success: false, count: 0, total: @error_ids.size, errors: [ e.message ] }
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Commands
+    # Command: Log an error to the database
+    # This is a write operation that creates an ErrorLog record
+    class LogError
+      def self.call(exception, context = {})
+        new(exception, context).call
+      end
+
+      def initialize(exception, context = {})
+        @exception = exception
+        @context = context
+      end
+
+      def call
+        error_context = ValueObjects::ErrorContext.new(@context, @context[:source])
+
+        # Build error attributes
+        attributes = {
+          error_type: @exception.class.name,
+          message: @exception.message,
+          backtrace: @exception.backtrace&.join("\n"),
+          user_id: error_context.user_id,
+          request_url: error_context.request_url,
+          request_params: error_context.request_params,
+          user_agent: error_context.user_agent,
+          ip_address: error_context.ip_address,
+          environment: Rails.env,
+          platform: error_context.platform,
+          controller_name: error_context.controller_name,
+          action_name: error_context.action_name,
+          occurred_at: Time.current
+        }
+
+        # Generate error hash for deduplication (including controller/action context)
+        error_hash = generate_error_hash(@exception, error_context.controller_name, error_context.action_name)
+
+        # Find existing error or create new one
+        # This ensures accurate occurrence tracking
+        error_log = ErrorLog.find_or_increment_by_hash(error_hash, attributes.merge(error_hash: error_hash))
+
+        # Send notifications only for new errors (not increments)
+        # Check if this is first occurrence or error was just created
+        if error_log.occurrence_count == 1
+          send_notifications(error_log)
+          # Dispatch plugin event for new error
+          PluginRegistry.dispatch(:on_error_logged, error_log)
+        else
+          # Dispatch plugin event for error recurrence
+          PluginRegistry.dispatch(:on_error_recurred, error_log)
+        end
+
+        error_log
+      rescue => e
+        # Don't let error logging cause more errors
+        Rails.logger.error("Failed to log error: #{e.message}")
+        Rails.logger.error("Backtrace: #{e.backtrace&.first(5)&.join("\n")}")
+        nil
+      end
+
+      private
+
+      # Generate consistent hash for error deduplication
+      # Same hash = same error type
+      # Note: This is also defined in ErrorLog model for backward compatibility
+      def generate_error_hash(exception, controller_name = nil, action_name = nil)
+        # Hash components:
+        # 1. Error class (NoMethodError, ArgumentError, etc.)
+        # 2. Normalized message (replace numbers, quoted strings)
+        # 3. First stack frame file (ignore line numbers)
+        # 4. Controller name (for context-aware grouping)
+        # 5. Action name (for context-aware grouping)
+
+        normalized_message = exception.message
+          &.gsub(/\d+/, "N")                    # Replace numbers: "User 123" -> "User N"
+          &.gsub(/"[^"]*"/, '""')               # Replace quoted strings: "foo" -> ""
+          &.gsub(/'[^']*'/, "''")               # Replace single quoted strings
+          &.gsub(/0x[0-9a-f]+/i, "0xHEX")       # Replace hex addresses
+          &.gsub(/#<[^>]+>/, "#<OBJ>")          # Replace object inspections
+
+        # Get first meaningful stack frame (skip gems, focus on app code)
+        first_app_frame = exception.backtrace&.find { |frame|
+          # Look for app code, not gems
+          frame.include?("/app/") || frame.include?("/lib/") || !frame.include?("/gems/")
+        }
+
+        # Extract just the file path, not line number
+        file_path = first_app_frame&.split(":")&.first
+
+        # Generate hash including controller/action for better grouping
+        digest_input = [
+          exception.class.name,
+          normalized_message,
+          file_path,
+          controller_name, # Context: which controller
+          action_name      # Context: which action
+        ].compact.join("|")
+
+        Digest::SHA256.hexdigest(digest_input)[0..15]
+      end
+
+      def send_notifications(error_log)
+        config = RailsErrorDashboard.configuration
+
+        # Send Slack notification
+        if config.enable_slack_notifications && config.slack_webhook_url.present?
+          SlackErrorNotificationJob.perform_later(error_log.id)
+        end
+
+        # Send email notification
+        if config.enable_email_notifications && config.notification_email_recipients.present?
+          EmailErrorNotificationJob.perform_later(error_log.id)
+        end
+
+        # Send Discord notification
+        if config.enable_discord_notifications && config.discord_webhook_url.present?
+          DiscordErrorNotificationJob.perform_later(error_log.id)
+        end
+
+        # Send PagerDuty notification (critical errors only)
+        if config.enable_pagerduty_notifications && config.pagerduty_integration_key.present?
+          PagerdutyErrorNotificationJob.perform_later(error_log.id)
+        end
+
+        # Send webhook notifications
+        if config.enable_webhook_notifications && config.webhook_urls.present?
+          WebhookErrorNotificationJob.perform_later(error_log.id)
+        end
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/commands/resolve_error.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Commands
+    # Command: Mark an error as resolved
+    # This is a write operation that updates an ErrorLog record
+    class ResolveError
+      def self.call(error_id, resolution_data = {})
+        new(error_id, resolution_data).call
+      end
+
+      def initialize(error_id, resolution_data = {})
+        @error_id = error_id
+        @resolution_data = resolution_data
+      end
+
+      def call
+        error = ErrorLog.find(@error_id)
+
+        error.update!(
+          resolved: true,
+          resolved_at: Time.current,
+          resolved_by_name: @resolution_data[:resolved_by_name],
+          resolution_comment: @resolution_data[:resolution_comment],
+          resolution_reference: @resolution_data[:resolution_reference]
+        )
+
+        # Dispatch plugin event for resolved error
+        PluginRegistry.dispatch(:on_error_resolved, error)
+
+        error
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/configuration.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  class Configuration
+    # Dashboard authentication
+    attr_accessor :dashboard_username
+    attr_accessor :dashboard_password
+    attr_accessor :require_authentication
+    attr_accessor :require_authentication_in_development
+
+    # User model (for associations)
+    attr_accessor :user_model
+
+    # Notifications
+    attr_accessor :slack_webhook_url
+    attr_accessor :notification_email_recipients
+    attr_accessor :notification_email_from
+    attr_accessor :dashboard_base_url
+    attr_accessor :enable_slack_notifications
+    attr_accessor :enable_email_notifications
+
+    # Discord notifications
+    attr_accessor :discord_webhook_url
+    attr_accessor :enable_discord_notifications
+
+    # PagerDuty notifications (critical errors only)
+    attr_accessor :pagerduty_integration_key
+    attr_accessor :enable_pagerduty_notifications
+
+    # Generic webhook notifications
+    attr_accessor :webhook_urls
+    attr_accessor :enable_webhook_notifications
+
+    # Separate database configuration
+    attr_accessor :use_separate_database
+
+    # Retention policy (days to keep errors)
+    attr_accessor :retention_days
+
+    # Enable/disable error catching middleware
+    attr_accessor :enable_middleware
+
+    # Enable/disable Rails.error subscriber
+    attr_accessor :enable_error_subscriber
+
+    def initialize
+      # Default values
+      @dashboard_username = ENV.fetch("ERROR_DASHBOARD_USER", "admin")
+      @dashboard_password = ENV.fetch("ERROR_DASHBOARD_PASSWORD", "password")
+      @require_authentication = true
+      @require_authentication_in_development = false
+
+      @user_model = "User"
+
+      # Notification settings
+      @slack_webhook_url = ENV["SLACK_WEBHOOK_URL"]
+      @notification_email_recipients = ENV.fetch("ERROR_NOTIFICATION_EMAILS", "").split(",").map(&:strip)
+      @notification_email_from = ENV.fetch("ERROR_NOTIFICATION_FROM", "errors@example.com")
+      @dashboard_base_url = ENV["DASHBOARD_BASE_URL"]
+      @enable_slack_notifications = true
+      @enable_email_notifications = true
+
+      # Discord notification settings
+      @discord_webhook_url = ENV["DISCORD_WEBHOOK_URL"]
+      @enable_discord_notifications = false
+
+      # PagerDuty notification settings (critical errors only)
+      @pagerduty_integration_key = ENV["PAGERDUTY_INTEGRATION_KEY"]
+      @enable_pagerduty_notifications = false
+
+      # Generic webhook settings (array of URLs)
+      @webhook_urls = ENV.fetch("WEBHOOK_URLS", "").split(",").map(&:strip).reject(&:empty?)
+      @enable_webhook_notifications = false
+
+      @use_separate_database = ENV.fetch("USE_SEPARATE_ERROR_DB", "false") == "true"
+
+      @retention_days = 90
+
+      @enable_middleware = true
+      @enable_error_subscriber = true
+    end
+  end
+end

data/lib/rails_error_dashboard/engine.rb

@@ -0,0 +1,20 @@
+module RailsErrorDashboard
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsErrorDashboard
+
+    # Initialize the engine
+    initializer "rails_error_dashboard.middleware" do |app|
+      # Add error catching middleware if enabled
+      if RailsErrorDashboard.configuration.enable_middleware
+        app.config.middleware.insert_before 0, RailsErrorDashboard::Middleware::ErrorCatcher
+      end
+    end
+
+    # Subscribe to Rails error reporter
+    config.after_initialize do
+      if RailsErrorDashboard.configuration.enable_error_subscriber
+        Rails.error.subscribe(RailsErrorDashboard::ErrorReporter.new)
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/error_reporter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Centralized Error Reporting for ALL errors in the application
+# Uses Rails 7+ built-in error reporter - single source of truth
+#
+# This catches errors from:
+# - Controllers (via ErrorHandler concern)
+# - Background Jobs (via ActiveJob integration)
+# - Sidekiq (via ActiveJob)
+# - Services (if they use Rails.error.handle)
+# - Model callbacks
+# - Rake tasks
+# - Console
+# - Anywhere in the app
+#
+# Based on Rails 7+ Error Reporting Guide:
+# https://guides.rubyonrails.org/error_reporting.html
+
+module RailsErrorDashboard
+  class ErrorReporter
+    def report(error, handled:, severity:, context:, source: nil)
+      # Skip low-severity warnings
+      return if handled && severity == :warning
+
+      # Extract context information
+      error_context = ValueObjects::ErrorContext.new(context, source)
+
+      # Log to our error dashboard using Command
+      Commands::LogError.call(error, error_context.to_h.merge(source: source))
+    rescue => e
+      # Don't let error logging cause more errors
+      Rails.logger.error("ErrorReporter failed: #{e.message}")
+    end
+  end
+end

data/lib/rails_error_dashboard/middleware/error_catcher.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Rack Middleware: Final safety net for uncaught errors
+# This catches errors that somehow escape controller error handling
+# Positioned at the Rack layer (outermost layer of Rails)
+#
+# Middleware stack order (outer to inner):
+# 1. ErrorCatcher (this file) ← Catches everything
+# 2. ActionDispatch middleware
+# 3. Rails routing
+# 4. Controllers (with ErrorHandler concern)
+#
+# This ensures NO error goes unreported
+
+module RailsErrorDashboard
+  module Middleware
+    class ErrorCatcher
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      rescue => exception
+        # Report to Rails.error (will be logged by our ErrorReporter)
+        Rails.error.report(exception,
+          handled: false,
+          severity: :error,
+          context: {
+            request: ActionDispatch::Request.new(env),
+            middleware: true
+          },
+          source: "rack.middleware"
+        )
+
+        # Re-raise to let Rails handle the response
+        raise exception
+      end
+    end
+  end
+end