rails_error_dashboard 0.1.0 → 0.1.3

data/config/routes.rb

@@ -4,9 +4,18 @@ RailsErrorDashboard::Engine.routes.draw do
   resources :errors, only: [ :index, :show ] do
     member do
       post :resolve
+      post :assign
+      post :unassign
+      post :update_priority
+      post :snooze
+      post :unsnooze
+      post :update_status
+      post :add_comment
     end
     collection do
       get :analytics
+      get :platform_comparison
+      get :correlation
       post :batch_action
     end
   end

data/db/migrate/20251225071314_add_optimized_indexes_to_error_logs.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class AddOptimizedIndexesToErrorLogs < ActiveRecord::Migration[8.1]
+  def change
+    # Composite indexes for common query patterns
+    # These improve performance when filtering and sorting together
+
+    # Dashboard stats: Count unresolved errors from recent time periods
+    # Query: WHERE resolved = false AND occurred_at >= ?
+    add_index :rails_error_dashboard_error_logs, [ :resolved, :occurred_at ],
+              name: 'index_error_logs_on_resolved_and_occurred_at'
+
+    # Error type filtering with time ordering
+    # Query: WHERE error_type = ? ORDER BY occurred_at DESC
+    add_index :rails_error_dashboard_error_logs, [ :error_type, :occurred_at ],
+              name: 'index_error_logs_on_error_type_and_occurred_at'
+
+    # Platform filtering with time ordering
+    # Query: WHERE platform = ? ORDER BY occurred_at DESC
+    add_index :rails_error_dashboard_error_logs, [ :platform, :occurred_at ],
+              name: 'index_error_logs_on_platform_and_occurred_at'
+
+    # Deduplication lookup: Find existing unresolved errors by hash within 24 hours
+    # Query: WHERE error_hash = ? AND resolved = false AND occurred_at >= ?
+    # This is the hot path for error logging - happens on EVERY error
+    add_index :rails_error_dashboard_error_logs, [ :error_hash, :resolved, :occurred_at ],
+              name: 'index_error_logs_on_hash_resolved_occurred'
+
+    # Partial index for unresolved errors (most queries filter by resolved=false)
+    # Only indexes unresolved errors, making it smaller and faster
+    # PostgreSQL-specific but gracefully ignored on other databases
+    if postgresql?
+      add_index :rails_error_dashboard_error_logs, :occurred_at,
+                where: "resolved = false",
+                name: 'index_error_logs_on_occurred_at_unresolved'
+
+      # Full-text search index for message field (PostgreSQL only)
+      # Dramatically improves search performance
+      execute <<-SQL
+        CREATE INDEX index_error_logs_on_message_gin
+        ON rails_error_dashboard_error_logs
+        USING gin(to_tsvector('english', message))
+      SQL
+    end
+  end
+
+  def down
+    # Remove composite indexes
+    remove_index :rails_error_dashboard_error_logs, name: 'index_error_logs_on_resolved_and_occurred_at'
+    remove_index :rails_error_dashboard_error_logs, name: 'index_error_logs_on_error_type_and_occurred_at'
+    remove_index :rails_error_dashboard_error_logs, name: 'index_error_logs_on_platform_and_occurred_at'
+    remove_index :rails_error_dashboard_error_logs, name: 'index_error_logs_on_hash_resolved_occurred'
+
+    # Remove partial/GIN indexes if PostgreSQL
+    if postgresql?
+      remove_index :rails_error_dashboard_error_logs, name: 'index_error_logs_on_occurred_at_unresolved'
+      execute "DROP INDEX IF EXISTS index_error_logs_on_message_gin"
+    end
+  end
+
+  private
+
+  def postgresql?
+    ActiveRecord::Base.connection.adapter_name.downcase == 'postgresql'
+  end
+end

data/db/migrate/20251225074653_remove_environment_from_error_logs.rb

@@ -0,0 +1,26 @@
+class RemoveEnvironmentFromErrorLogs < ActiveRecord::Migration[8.1]
+  def up
+    # Remove composite index first
+    remove_index :rails_error_dashboard_error_logs,
+                 name: 'index_error_logs_on_environment_and_occurred_at',
+                 if_exists: true
+
+    # Remove single column index
+    remove_index :rails_error_dashboard_error_logs,
+                 column: :environment,
+                 if_exists: true
+
+    # Remove the column
+    remove_column :rails_error_dashboard_error_logs, :environment, :string
+  end
+
+  def down
+    # Add column back
+    add_column :rails_error_dashboard_error_logs, :environment, :string, null: false, default: 'production'
+
+    # Recreate indexes
+    add_index :rails_error_dashboard_error_logs, :environment
+    add_index :rails_error_dashboard_error_logs, [ :environment, :occurred_at ],
+              name: 'index_error_logs_on_environment_and_occurred_at'
+  end
+end

data/db/migrate/20251225085859_add_enhanced_metrics_to_error_logs.rb

@@ -0,0 +1,12 @@
+class AddEnhancedMetricsToErrorLogs < ActiveRecord::Migration[8.0]
+  def change
+    add_column :rails_error_dashboard_error_logs, :app_version, :string
+    add_column :rails_error_dashboard_error_logs, :git_sha, :string
+    add_column :rails_error_dashboard_error_logs, :priority_score, :integer
+
+    # Indexes for enhanced metrics
+    add_index :rails_error_dashboard_error_logs, :app_version
+    add_index :rails_error_dashboard_error_logs, :git_sha
+    add_index :rails_error_dashboard_error_logs, :priority_score
+  end
+end

data/db/migrate/20251225093603_add_similarity_tracking_to_error_logs.rb

@@ -0,0 +1,9 @@
+class AddSimilarityTrackingToErrorLogs < ActiveRecord::Migration[8.0]
+  def change
+    add_column :rails_error_dashboard_error_logs, :similarity_score, :float
+    add_column :rails_error_dashboard_error_logs, :backtrace_signature, :string
+
+    add_index :rails_error_dashboard_error_logs, :similarity_score
+    add_index :rails_error_dashboard_error_logs, :backtrace_signature
+  end
+end

data/db/migrate/20251225100236_create_error_occurrences.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class CreateErrorOccurrences < ActiveRecord::Migration[8.0]
+  def change
+    create_table :rails_error_dashboard_error_occurrences do |t|
+      t.references :error_log, null: false, foreign_key: { to_table: :rails_error_dashboard_error_logs }
+      t.datetime :occurred_at, null: false
+      t.integer :user_id
+      t.string :request_id
+      t.string :session_id
+
+      t.timestamps
+    end
+
+    # Index for finding co-occurring errors by time window
+    add_index :rails_error_dashboard_error_occurrences, [ :occurred_at, :error_log_id ],
+              name: 'index_error_occurrences_on_time_and_error'
+
+    # Index for finding all occurrences of a specific error
+    add_index :rails_error_dashboard_error_occurrences, :error_log_id,
+              name: 'index_error_occurrences_on_error_log'
+
+    # Index for finding errors by user
+    add_index :rails_error_dashboard_error_occurrences, :user_id,
+              name: 'index_error_occurrences_on_user'
+
+    # Index for finding errors by request
+    add_index :rails_error_dashboard_error_occurrences, :request_id,
+              name: 'index_error_occurrences_on_request'
+  end
+end

data/db/migrate/20251225101920_create_cascade_patterns.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class CreateCascadePatterns < ActiveRecord::Migration[8.0]
+  def change
+    create_table :rails_error_dashboard_cascade_patterns do |t|
+      t.references :parent_error, null: false, foreign_key: { to_table: :rails_error_dashboard_error_logs }
+      t.references :child_error, null: false, foreign_key: { to_table: :rails_error_dashboard_error_logs }
+      t.integer :frequency, default: 1, null: false
+      t.float :avg_delay_seconds
+      t.float :cascade_probability # 0.0-1.0, percentage of time parent leads to child
+      t.datetime :last_detected_at
+
+      t.timestamps
+    end
+
+    # Composite index for finding cascade patterns
+    add_index :rails_error_dashboard_cascade_patterns, [ :parent_error_id, :child_error_id ],
+              name: 'index_cascade_patterns_on_parent_and_child',
+              unique: true
+
+    # Index for finding children of a parent error
+    add_index :rails_error_dashboard_cascade_patterns, :parent_error_id,
+              name: 'index_cascade_patterns_on_parent'
+
+    # Index for finding parents of a child error
+    add_index :rails_error_dashboard_cascade_patterns, :child_error_id,
+              name: 'index_cascade_patterns_on_child'
+
+    # Index for finding by probability (for high-confidence cascades)
+    add_index :rails_error_dashboard_cascade_patterns, :cascade_probability,
+              name: 'index_cascade_patterns_on_probability'
+  end
+end

data/db/migrate/20251225102500_create_error_baselines.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class CreateErrorBaselines < ActiveRecord::Migration[8.0]
+  def change
+    create_table :rails_error_dashboard_error_baselines do |t|
+      t.string :error_type, null: false
+      t.string :platform, null: false
+      t.string :baseline_type, null: false # hourly, daily, weekly
+      t.datetime :period_start, null: false
+      t.datetime :period_end, null: false
+
+      # Statistical metrics
+      t.integer :count, null: false, default: 0
+      t.float :mean
+      t.float :std_dev
+      t.float :percentile_95
+      t.float :percentile_99
+      t.integer :sample_size, null: false, default: 0
+
+      t.timestamps
+    end
+
+    # Composite index for efficient baseline lookups
+    add_index :rails_error_dashboard_error_baselines,
+              [ :error_type, :platform, :baseline_type, :period_start ],
+              name: 'index_error_baselines_on_type_platform_baseline_period'
+
+    # Index for querying by error_type and platform
+    add_index :rails_error_dashboard_error_baselines,
+              [ :error_type, :platform ],
+              name: 'index_error_baselines_on_error_type_and_platform'
+
+    # Index for cleaning up old baselines
+    add_index :rails_error_dashboard_error_baselines,
+              :period_end,
+              name: 'index_error_baselines_on_period_end'
+  end
+end

data/db/migrate/20251226020000_add_workflow_fields_to_error_logs.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class AddWorkflowFieldsToErrorLogs < ActiveRecord::Migration[8.0]
+  def change
+    add_column :rails_error_dashboard_error_logs, :status, :string, default: 'new', null: false
+    add_column :rails_error_dashboard_error_logs, :assigned_to, :string
+    add_column :rails_error_dashboard_error_logs, :assigned_at, :datetime
+    add_column :rails_error_dashboard_error_logs, :snoozed_until, :datetime
+    add_column :rails_error_dashboard_error_logs, :priority_level, :integer, default: 0, null: false
+
+    add_index :rails_error_dashboard_error_logs, :status
+    add_index :rails_error_dashboard_error_logs, :assigned_to
+    add_index :rails_error_dashboard_error_logs, :snoozed_until
+    add_index :rails_error_dashboard_error_logs, :priority_level
+
+    # Update existing resolved errors to have status='resolved'
+    reversible do |dir|
+      dir.up do
+        execute <<-SQL
+          UPDATE rails_error_dashboard_error_logs
+          SET status = 'resolved'
+          WHERE resolved = true
+        SQL
+      end
+    end
+  end
+end

data/db/migrate/20251226020100_create_error_comments.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class CreateErrorComments < ActiveRecord::Migration[8.0]
+  def change
+    create_table :rails_error_dashboard_error_comments do |t|
+      t.references :error_log,
+                   null: false,
+                   foreign_key: { to_table: :rails_error_dashboard_error_logs }
+      t.string :author_name, null: false
+      t.text :body, null: false
+
+      t.timestamps
+    end
+
+    add_index :rails_error_dashboard_error_comments, [ :error_log_id, :created_at ],
+              name: 'index_error_comments_on_error_and_time'
+  end
+end

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

@@ -7,7 +7,194 @@ module RailsErrorDashboard
 
       desc "Installs Rails Error Dashboard and generates the necessary files"
 
+      class_option :interactive, type: :boolean, default: true, desc: "Interactive feature selection"
+      # Notification options
+      class_option :slack, type: :boolean, default: false, desc: "Enable Slack notifications"
+      class_option :email, type: :boolean, default: false, desc: "Enable email notifications"
+      class_option :discord, type: :boolean, default: false, desc: "Enable Discord notifications"
+      class_option :pagerduty, type: :boolean, default: false, desc: "Enable PagerDuty notifications"
+      class_option :webhooks, type: :boolean, default: false, desc: "Enable webhook notifications"
+      # Performance options
+      class_option :async_logging, type: :boolean, default: false, desc: "Enable async error logging"
+      class_option :error_sampling, type: :boolean, default: false, desc: "Enable error sampling (reduce volume)"
+      class_option :separate_database, type: :boolean, default: false, desc: "Use separate database for errors"
+      # Advanced analytics options
+      class_option :baseline_alerts, type: :boolean, default: false, desc: "Enable baseline anomaly alerts"
+      class_option :similar_errors, type: :boolean, default: false, desc: "Enable fuzzy error matching"
+      class_option :co_occurring_errors, type: :boolean, default: false, desc: "Enable co-occurring error detection"
+      class_option :error_cascades, type: :boolean, default: false, desc: "Enable error cascade detection"
+      class_option :error_correlation, type: :boolean, default: false, desc: "Enable error correlation analysis"
+      class_option :platform_comparison, type: :boolean, default: false, desc: "Enable platform comparison analytics"
+      class_option :occurrence_patterns, type: :boolean, default: false, desc: "Enable occurrence pattern detection"
+
+      def welcome_message
+        say "\n"
+        say "=" * 70
+        say "  📊 Rails Error Dashboard Installation", :cyan
+        say "=" * 70
+        say "\n"
+        say "Core features will be enabled automatically:", :green
+        say "  ✓ Error capture (controllers, jobs, middleware)"
+        say "  ✓ Dashboard UI at /error_dashboard"
+        say "  ✓ Real-time updates"
+        say "  ✓ Analytics & spike detection"
+        say "  ✓ 90-day error retention"
+        say "\n"
+      end
+
+      def select_optional_features
+        return unless options[:interactive] && behavior == :invoke
+        return unless $stdin.tty?  # Skip interactive mode if not running in a terminal
+
+        say "Let's configure optional features...\n", :cyan
+        say "(You can always enable/disable these later in the initializer)\n\n", :yellow
+
+        @selected_features = {}
+
+        # Feature definitions with descriptions - organized by category
+        features = [
+          # === NOTIFICATIONS ===
+          {
+            key: :slack,
+            name: "Slack Notifications",
+            description: "Send error alerts to Slack channels",
+            category: "Notifications"
+          },
+          {
+            key: :email,
+            name: "Email Notifications",
+            description: "Send error alerts via email",
+            category: "Notifications"
+          },
+          {
+            key: :discord,
+            name: "Discord Notifications",
+            description: "Send error alerts to Discord",
+            category: "Notifications"
+          },
+          {
+            key: :pagerduty,
+            name: "PagerDuty Integration",
+            description: "Critical errors to PagerDuty",
+            category: "Notifications"
+          },
+          {
+            key: :webhooks,
+            name: "Generic Webhooks",
+            description: "Send data to custom endpoints",
+            category: "Notifications"
+          },
+
+          # === PERFORMANCE & SCALABILITY ===
+          {
+            key: :async_logging,
+            name: "Async Error Logging",
+            description: "Process errors in background jobs (faster responses)",
+            category: "Performance"
+          },
+          {
+            key: :error_sampling,
+            name: "Error Sampling",
+            description: "Log only % of non-critical errors (reduce volume)",
+            category: "Performance"
+          },
+          {
+            key: :separate_database,
+            name: "Separate Error Database",
+            description: "Store errors in dedicated database",
+            category: "Performance"
+          },
+
+          # === ADVANCED ANALYTICS ===
+          {
+            key: :baseline_alerts,
+            name: "Baseline Anomaly Alerts",
+            description: "Auto-detect unusual error rate spikes",
+            category: "Advanced Analytics"
+          },
+          {
+            key: :similar_errors,
+            name: "Fuzzy Error Matching",
+            description: "Find similar errors across different hashes",
+            category: "Advanced Analytics"
+          },
+          {
+            key: :co_occurring_errors,
+            name: "Co-occurring Errors",
+            description: "Detect errors that happen together",
+            category: "Advanced Analytics"
+          },
+          {
+            key: :error_cascades,
+            name: "Error Cascade Detection",
+            description: "Identify error chains (A causes B causes C)",
+            category: "Advanced Analytics"
+          },
+          {
+            key: :error_correlation,
+            name: "Error Correlation Analysis",
+            description: "Correlate with versions, users, time",
+            category: "Advanced Analytics"
+          },
+          {
+            key: :platform_comparison,
+            name: "Platform Comparison",
+            description: "Compare iOS vs Android vs Web health",
+            category: "Advanced Analytics"
+          },
+          {
+            key: :occurrence_patterns,
+            name: "Occurrence Pattern Detection",
+            description: "Detect cyclical patterns and bursts",
+            category: "Advanced Analytics"
+          }
+        ]
+
+        features.each_with_index do |feature, index|
+          say "\n[#{index + 1}/#{features.length}] #{feature[:name]}", :cyan
+          say "    #{feature[:description]}", :light_black
+
+          # Check if feature was passed via command line option
+          if options[feature[:key]]
+            @selected_features[feature[:key]] = true
+            say "    ✓ Enabled (via --#{feature[:key]} flag)", :green
+          else
+            response = ask("    Enable? (y/N):", :yellow, limited_to: [ "y", "Y", "n", "N", "" ])
+            @selected_features[feature[:key]] = response.downcase == "y"
+
+            if @selected_features[feature[:key]]
+              say "    ✓ Enabled", :green
+            else
+              say "    ✗ Disabled", :light_black
+            end
+          end
+        end
+
+        say "\n"
+      end
+
       def create_initializer_file
+        # Notifications
+        @enable_slack = @selected_features&.dig(:slack) || options[:slack]
+        @enable_email = @selected_features&.dig(:email) || options[:email]
+        @enable_discord = @selected_features&.dig(:discord) || options[:discord]
+        @enable_pagerduty = @selected_features&.dig(:pagerduty) || options[:pagerduty]
+        @enable_webhooks = @selected_features&.dig(:webhooks) || options[:webhooks]
+
+        # Performance
+        @enable_async_logging = @selected_features&.dig(:async_logging) || options[:async_logging]
+        @enable_error_sampling = @selected_features&.dig(:error_sampling) || options[:error_sampling]
+        @enable_separate_database = @selected_features&.dig(:separate_database) || options[:separate_database]
+
+        # Advanced Analytics
+        @enable_baseline_alerts = @selected_features&.dig(:baseline_alerts) || options[:baseline_alerts]
+        @enable_similar_errors = @selected_features&.dig(:similar_errors) || options[:similar_errors]
+        @enable_co_occurring_errors = @selected_features&.dig(:co_occurring_errors) || options[:co_occurring_errors]
+        @enable_error_cascades = @selected_features&.dig(:error_cascades) || options[:error_cascades]
+        @enable_error_correlation = @selected_features&.dig(:error_correlation) || options[:error_correlation]
+        @enable_platform_comparison = @selected_features&.dig(:platform_comparison) || options[:platform_comparison]
+        @enable_occurrence_patterns = @selected_features&.dig(:occurrence_patterns) || options[:occurrence_patterns]
+
         template "initializer.rb", "config/initializers/rails_error_dashboard.rb"
       end
 
@@ -19,8 +206,96 @@ module RailsErrorDashboard
         route "mount RailsErrorDashboard::Engine => '/error_dashboard'"
       end
 
+      def show_feature_summary
+        return unless behavior == :invoke
+
+        say "\n"
+        say "=" * 70
+        say "  ✓ Installation Complete!", :green
+        say "=" * 70
+        say "\n"
+
+        say "Core Features (Always ON):", :cyan
+        say "  ✓ Error Capture", :green
+        say "  ✓ Dashboard UI", :green
+        say "  ✓ Real-time Updates", :green
+        say "  ✓ Analytics", :green
+
+        # Count optional features enabled
+        enabled_count = 0
+
+        # Notifications
+        notification_features = []
+        notification_features << "Slack" if @enable_slack
+        notification_features << "Email" if @enable_email
+        notification_features << "Discord" if @enable_discord
+        notification_features << "PagerDuty" if @enable_pagerduty
+        notification_features << "Webhooks" if @enable_webhooks
+
+        if notification_features.any?
+          say "\nNotifications:", :cyan
+          say "  ✓ #{notification_features.join(", ")}", :green
+          enabled_count += notification_features.size
+        end
+
+        # Performance
+        performance_features = []
+        performance_features << "Async Logging" if @enable_async_logging
+        performance_features << "Error Sampling" if @enable_error_sampling
+        performance_features << "Separate Database" if @enable_separate_database
+
+        if performance_features.any?
+          say "\nPerformance:", :cyan
+          say "  ✓ #{performance_features.join(", ")}", :green
+          enabled_count += performance_features.size
+        end
+
+        # Advanced Analytics
+        analytics_features = []
+        analytics_features << "Baseline Alerts" if @enable_baseline_alerts
+        analytics_features << "Fuzzy Matching" if @enable_similar_errors
+        analytics_features << "Co-occurring Errors" if @enable_co_occurring_errors
+        analytics_features << "Error Cascades" if @enable_error_cascades
+        analytics_features << "Error Correlation" if @enable_error_correlation
+        analytics_features << "Platform Comparison" if @enable_platform_comparison
+        analytics_features << "Pattern Detection" if @enable_occurrence_patterns
+
+        if analytics_features.any?
+          say "\nAdvanced Analytics:", :cyan
+          say "  ✓ #{analytics_features.join(", ")}", :green
+          enabled_count += analytics_features.size
+        end
+
+        say "\n"
+        say "Configuration Required:", :yellow if enabled_count > 0
+        say "  → Edit config/initializers/rails_error_dashboard.rb", :yellow if @enable_error_sampling
+        say "  → Set SLACK_WEBHOOK_URL in .env", :yellow if @enable_slack
+        say "  → Set ERROR_NOTIFICATION_EMAILS in .env", :yellow if @enable_email
+        say "  → Set DISCORD_WEBHOOK_URL in .env", :yellow if @enable_discord
+        say "  → Set PAGERDUTY_INTEGRATION_KEY in .env", :yellow if @enable_pagerduty
+        say "  → Set WEBHOOK_URLS in .env", :yellow if @enable_webhooks
+        say "  → Ensure Sidekiq/Solid Queue running", :yellow if @enable_async_logging
+        say "  → Configure database.yml (docs/guides/DATABASE_OPTIONS.md)", :yellow if @enable_separate_database
+
+        say "\n"
+        say "Next Steps:", :cyan
+        say "  1. Run: rails db:migrate"
+        say "  2. Update credentials in config/initializers/rails_error_dashboard.rb"
+        say "  3. Restart your Rails server"
+        say "  4. Visit http://localhost:3000/error_dashboard"
+        say "\n"
+        say "📖 Documentation:", :light_black
+        say "   • Quick Start: docs/QUICKSTART.md", :light_black
+        say "   • Complete Feature Guide: docs/FEATURES.md", :light_black
+        say "   • All Docs: docs/README.md", :light_black
+        say "\n"
+        say "⚙️  To enable/disable features later:", :light_black
+        say "   Edit config/initializers/rails_error_dashboard.rb", :light_black
+        say "\n"
+      end
+
       def show_readme
-        readme "README" if behavior == :invoke
+        # Skip the old README display since we have the new summary
       end
     end
   end