rails_error_dashboard 0.1.3 → 0.1.4

data/lib/generators/rails_error_dashboard/uninstall/uninstall_generator.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Generators
+    class UninstallGenerator < Rails::Generators::Base
+      desc "Uninstalls Rails Error Dashboard and removes all associated files and data"
+
+      class_option :keep_data, type: :boolean, default: false, desc: "Keep error data in database (don't drop tables)"
+      class_option :skip_confirmation, type: :boolean, default: false, desc: "Skip confirmation prompts"
+      class_option :manual_only, type: :boolean, default: false, desc: "Show manual instructions only, don't perform automated uninstall"
+
+      def welcome_message
+        say "\n"
+        say "=" * 80
+        say "  🗑️  Rails Error Dashboard - Uninstall", :red
+        say "=" * 80
+        say "\n"
+        say "This will remove Rails Error Dashboard from your application.", :yellow
+        say "\n"
+      end
+
+      def detect_installed_components
+        @components = {
+          initializer: File.exist?("config/initializers/rails_error_dashboard.rb"),
+          route: route_mounted?,
+          migrations: migrations_exist?,
+          tables: tables_exist?,
+          gemfile: gemfile_includes_gem?
+        }
+
+        say "Detected components:", :cyan
+        say "  #{status_icon(@components[:gemfile])} Gemfile entry"
+        say "  #{status_icon(@components[:initializer])} Initializer (config/initializers/rails_error_dashboard.rb)"
+        say "  #{status_icon(@components[:route])} Route (mount RailsErrorDashboard::Engine)"
+        say "  #{status_icon(@components[:migrations])} Migrations (#{migration_count} files)"
+        say "  #{status_icon(@components[:tables])} Database tables (#{table_count} tables)"
+        say "\n"
+      end
+
+      def show_manual_instructions
+        say "=" * 80
+        say "  📖 Manual Uninstall Instructions", :cyan
+        say "=" * 80
+        say "\n"
+
+        say "Step 1: Remove from Gemfile", :yellow
+        say "  Open: Gemfile"
+        say "  Remove: gem 'rails_error_dashboard'"
+        say "  Run: bundle install"
+        say "\n"
+
+        if @components[:initializer]
+          say "Step 2: Remove initializer", :yellow
+          say "  Delete: config/initializers/rails_error_dashboard.rb"
+          say "\n"
+        end
+
+        if @components[:route]
+          say "Step 3: Remove route", :yellow
+          say "  Open: config/routes.rb"
+          say "  Remove: mount RailsErrorDashboard::Engine => '/error_dashboard'"
+          say "\n"
+        end
+
+        if @components[:migrations]
+          say "Step 4: Remove migrations", :yellow
+          say "  Delete migration files from db/migrate/:"
+          migration_files.each do |file|
+            say "    - #{File.basename(file)}", :light_black
+          end
+          say "\n"
+        end
+
+        if @components[:tables]
+          say "Step 5: Drop database tables (⚠️  DESTRUCTIVE - will delete all error data)", :yellow
+          say "  Run: rails rails_error_dashboard:db:drop"
+          say "  Or manually in rails console:"
+          say "    ActiveRecord::Base.connection.execute('DROP TABLE rails_error_dashboard_error_logs')", :light_black
+          say "    ActiveRecord::Base.connection.execute('DROP TABLE rails_error_dashboard_error_occurrences')", :light_black
+          say "    ActiveRecord::Base.connection.execute('DROP TABLE rails_error_dashboard_cascade_patterns')", :light_black
+          say "    ActiveRecord::Base.connection.execute('DROP TABLE rails_error_dashboard_error_baselines')", :light_black
+          say "    ActiveRecord::Base.connection.execute('DROP TABLE rails_error_dashboard_error_comments')", :light_black
+          say "    ActiveRecord::Migration.drop_table(:rails_error_dashboard_error_logs) rescue nil", :light_black
+          say "\n"
+        end
+
+        say "Step 6: Clean up environment variables (optional)", :yellow
+        say "  Remove from .env or environment:"
+        say "    - ERROR_DASHBOARD_USER"
+        say "    - ERROR_DASHBOARD_PASSWORD"
+        say "    - SLACK_WEBHOOK_URL"
+        say "    - ERROR_NOTIFICATION_EMAILS"
+        say "    - DISCORD_WEBHOOK_URL"
+        say "    - PAGERDUTY_INTEGRATION_KEY"
+        say "    - WEBHOOK_URLS"
+        say "    - DASHBOARD_BASE_URL"
+        say "\n"
+
+        say "Step 7: Restart your application", :yellow
+        say "  Run: rails restart (or restart your server)"
+        say "\n"
+
+        say "=" * 80
+        say "\n"
+      end
+
+      def confirm_automated_uninstall
+        return if options[:manual_only]
+        return if options[:skip_confirmation]
+
+        say "Would you like to run the automated uninstall? (recommended)", :cyan
+        say "This will:", :yellow
+        say "  ✓ Remove initializer file"
+        say "  ✓ Remove route from config/routes.rb"
+        say "  ✓ Remove migration files"
+        if options[:keep_data]
+          say "  ✗ Keep database tables and data (--keep-data flag set)", :green
+        else
+          say "  ⚠️  Drop all database tables (deletes all error data!)", :red
+        end
+        say "\n"
+
+        response = ask("Proceed with automated uninstall? (yes/no):", :yellow, limited_to: [ "yes", "no", "y", "n" ])
+
+        if response.downcase == "no" || response.downcase == "n"
+          say "\n"
+          say "Automated uninstall cancelled.", :yellow
+          say "Follow the manual instructions above to uninstall.", :cyan
+          say "\n"
+          exit 0
+        end
+
+        say "\n"
+      end
+
+      def final_data_warning
+        return if options[:manual_only]
+        return if options[:keep_data]
+        return unless @components[:tables]
+
+        say "=" * 80
+        say "  ⚠️  FINAL WARNING - Data Deletion", :red
+        say "=" * 80
+        say "\n"
+        say "You are about to PERMANENTLY DELETE all error tracking data!", :red
+        say "\n"
+        say "Database tables to be dropped:", :yellow
+        table_names.each do |table|
+          say "  • #{table}", :light_black
+        end
+        say "\n"
+        say "This action CANNOT be undone!", :red
+        say "\n"
+
+        response = ask("Type 'DELETE ALL DATA' to confirm:", :red)
+
+        if response != "DELETE ALL DATA"
+          say "\n"
+          say "Data deletion cancelled. Database tables will be kept.", :green
+          say "Use --keep-data flag to skip this warning in the future.", :cyan
+          @components[:tables] = false  # Don't drop tables
+          say "\n"
+        end
+
+        say "\n"
+      end
+
+      def remove_initializer
+        return if options[:manual_only]
+        return unless @components[:initializer]
+
+        remove_file "config/initializers/rails_error_dashboard.rb"
+        say "  ✓ Removed initializer", :green
+      end
+
+      def remove_route
+        return if options[:manual_only]
+        return unless @components[:route]
+
+        begin
+          gsub_file "config/routes.rb", /mount RailsErrorDashboard::Engine.*\n/, ""
+          say "  ✓ Removed route", :green
+        rescue => e
+          say "  ⚠️  Could not automatically remove route: #{e.message}", :yellow
+          say "  Please manually remove: mount RailsErrorDashboard::Engine => '/error_dashboard'", :yellow
+        end
+      end
+
+      def remove_migrations
+        return if options[:manual_only]
+        return unless @components[:migrations]
+
+        migration_files.each do |file|
+          remove_file file
+        end
+        say "  ✓ Removed #{migration_count} migration file(s)", :green
+      end
+
+      def drop_database_tables
+        return if options[:manual_only]
+        return if options[:keep_data]
+        return unless @components[:tables]
+
+        say "  Dropping database tables...", :yellow
+
+        # Drop tables in reverse order (to respect foreign keys)
+        tables_to_drop = [
+          "rails_error_dashboard_error_comments",
+          "rails_error_dashboard_error_occurrences",
+          "rails_error_dashboard_cascade_patterns",
+          "rails_error_dashboard_error_baselines",
+          "rails_error_dashboard_error_logs"
+        ]
+
+        dropped_count = 0
+        tables_to_drop.each do |table|
+          if ActiveRecord::Base.connection.table_exists?(table)
+            ActiveRecord::Base.connection.drop_table(table, if_exists: true)
+            dropped_count += 1
+          end
+        rescue => e
+          say "  ⚠️  Could not drop table #{table}: #{e.message}", :yellow
+        end
+
+        say "  ✓ Dropped #{dropped_count} database table(s)", :green
+      end
+
+      def show_completion_message
+        return if options[:manual_only]
+
+        say "\n"
+        say "=" * 80
+        say "  ✅ Uninstall Complete!", :green
+        say "=" * 80
+        say "\n"
+
+        say "Remaining manual steps:", :cyan
+        say "\n"
+
+        say "1. Remove from Gemfile:", :yellow
+        say "   Open: Gemfile"
+        say "   Remove: gem 'rails_error_dashboard'"
+        say "   Run: bundle install"
+        say "\n"
+
+        say "2. Restart your application:", :yellow
+        say "   Run: rails restart"
+        say "   Or: kill and restart your server process"
+        say "\n"
+
+        if options[:keep_data]
+          say "3. Database tables were kept (--keep-data flag)", :green
+          say "   To remove data later, run:", :yellow
+          say "   rails generate rails_error_dashboard:uninstall", :yellow
+          say "\n"
+        end
+
+        say "Clean up environment variables (optional):", :yellow
+        say "  • ERROR_DASHBOARD_USER, ERROR_DASHBOARD_PASSWORD"
+        say "  • SLACK_WEBHOOK_URL, ERROR_NOTIFICATION_EMAILS"
+        say "  • DISCORD_WEBHOOK_URL, PAGERDUTY_INTEGRATION_KEY"
+        say "  • WEBHOOK_URLS, DASHBOARD_BASE_URL"
+        say "\n"
+
+        say "Thank you for using Rails Error Dashboard! 👋", :cyan
+        say "\n"
+      end
+
+      private
+
+      def status_icon(present)
+        present ? "✓" : "✗"
+      end
+
+      def route_mounted?
+        return false unless File.exist?("config/routes.rb")
+        File.read("config/routes.rb").include?("RailsErrorDashboard::Engine")
+      end
+
+      def migrations_exist?
+        migration_files.any?
+      end
+
+      def migration_files
+        Dir.glob("db/migrate/*rails_error_dashboard*.rb")
+      end
+
+      def migration_count
+        migration_files.count
+      end
+
+      def tables_exist?
+        return false unless defined?(ActiveRecord::Base)
+        table_names.any? { |table| ActiveRecord::Base.connection.table_exists?(table) rescue false }
+      end
+
+      def table_names
+        [
+          "rails_error_dashboard_error_logs",
+          "rails_error_dashboard_error_occurrences",
+          "rails_error_dashboard_cascade_patterns",
+          "rails_error_dashboard_error_baselines",
+          "rails_error_dashboard_error_comments"
+        ]
+      end
+
+      def table_count
+        table_names.count { |table| ActiveRecord::Base.connection.table_exists?(table) rescue false }
+      end
+
+      def gemfile_includes_gem?
+        return false unless File.exist?("Gemfile")
+        File.read("Gemfile").match?(/gem\s+['"]rails_error_dashboard['"]/)
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/errors_list.rb

@@ -14,10 +14,11 @@ module RailsErrorDashboard
       end
 
       def call
-        query = ErrorLog.order(occurred_at: :desc)
+        query = ErrorLog
         # Only eager load user if User model exists
         query = query.includes(:user) if defined?(::User)
         query = apply_filters(query)
+        query = apply_sorting(query)
         query
       end
 
@@ -29,6 +30,8 @@ module RailsErrorDashboard
         query = filter_by_platform(query)
         query = filter_by_search(query)
         query = filter_by_severity(query)
+        query = filter_by_timeframe(query)
+        query = filter_by_frequency(query)
         # Phase 3: Workflow filters
         query = filter_by_status(query)
         query = filter_by_assignment(query)
@@ -121,14 +124,14 @@ module RailsErrorDashboard
 
       def filter_by_status(query)
         return query unless @filters[:status].present?
-        return query unless query.model.column_names.include?("status")
+        return query unless ErrorLog.column_names.include?("status")
 
         query.by_status(@filters[:status])
       end
 
       def filter_by_assignment(query)
         return query unless @filters[:assigned_to].present?
-        return query unless query.model.column_names.include?("assigned_to")
+        return query unless ErrorLog.column_names.include?("assigned_to")
 
         case @filters[:assigned_to]
         when "__unassigned__"
@@ -142,13 +145,13 @@ module RailsErrorDashboard
 
       def filter_by_priority(query)
         return query unless @filters[:priority_level].present?
-        return query unless query.model.column_names.include?("priority_level")
+        return query unless ErrorLog.column_names.include?("priority_level")
 
         query.by_priority(@filters[:priority_level])
       end
 
       def filter_by_snoozed(query)
-        return query unless query.model.column_names.include?("snoozed_until")
+        return query unless ErrorLog.column_names.include?("snoozed_until")
 
         # If hide_snoozed is checked, exclude snoozed errors
         if @filters[:hide_snoozed] == "1" || @filters[:hide_snoozed] == true
@@ -157,6 +160,75 @@ module RailsErrorDashboard
           query
         end
       end
+
+      def filter_by_timeframe(query)
+        return query unless @filters[:timeframe].present?
+
+        case @filters[:timeframe]
+        when "last_hour"
+          query.where("occurred_at >= ?", 1.hour.ago)
+        when "today"
+          query.where("occurred_at >= ?", Time.current.beginning_of_day)
+        when "yesterday"
+          query.where("occurred_at BETWEEN ? AND ?",
+                      1.day.ago.beginning_of_day,
+                      1.day.ago.end_of_day)
+        when "last_7_days"
+          query.where("occurred_at >= ?", 7.days.ago)
+        when "last_30_days"
+          query.where("occurred_at >= ?", 30.days.ago)
+        when "last_90_days"
+          query.where("occurred_at >= ?", 90.days.ago)
+        else
+          query
+        end
+      end
+
+      def filter_by_frequency(query)
+        return query unless @filters[:frequency].present?
+
+        case @filters[:frequency]
+        when "once"
+          query.where(occurrence_count: 1)
+        when "few"
+          query.where("occurrence_count BETWEEN ? AND ?", 2, 9)
+        when "frequent"
+          query.where("occurrence_count BETWEEN ? AND ?", 10, 99)
+        when "very_frequent"
+          query.where("occurrence_count >= ?", 100)
+        when "recurring"
+          # Errors that occurred multiple times AND are still active
+          query.where("occurrence_count > ?", 5)
+               .where("last_seen_at > ?", 24.hours.ago)
+        else
+          query
+        end
+      end
+
+      def apply_sorting(query)
+        sort_column = @filters[:sort_by].presence || "occurred_at"
+        sort_direction = @filters[:sort_direction].presence || "desc"
+
+        # Validate sort direction
+        sort_direction = %w[asc desc].include?(sort_direction) ? sort_direction : "desc"
+
+        # Map severity to priority for sorting (since severity is an enum/method)
+        # We'll use priority_score which factors in severity
+        case sort_column
+        when "occurred_at", "first_seen_at", "last_seen_at", "created_at", "resolved_at"
+          query.order(sort_column => sort_direction)
+        when "occurrence_count", "priority_score"
+          query.order(sort_column => sort_direction, occurred_at: :desc)
+        when "error_type", "platform", "app_version"
+          query.order(sort_column => sort_direction, occurred_at: :desc)
+        when "severity"
+          # Sort by priority_score as proxy for severity (critical=highest score)
+          query.order(priority_score: sort_direction, occurred_at: :desc)
+        else
+          # Default sort
+          query.order(occurred_at: :desc)
+        end
+      end
     end
   end
 end

data/lib/rails_error_dashboard/queries/mttr_stats.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Calculate Mean Time to Resolution (MTTR) statistics
+    # Provides metrics on how quickly errors are resolved
+    class MttrStats
+      def self.call(days = 30)
+        new(days).call
+      end
+
+      def initialize(days = 30)
+        @days = days
+        @start_date = days.days.ago
+      end
+
+      def call
+        {
+          overall_mttr: calculate_overall_mttr,
+          mttr_by_platform: mttr_by_platform,
+          mttr_by_severity: mttr_by_severity,
+          mttr_trend: mttr_trend_by_week,
+          fastest_resolution: fastest_resolution_time,
+          slowest_resolution: slowest_resolution_time,
+          total_resolved: resolved_errors.count
+        }
+      end
+
+      private
+
+      def resolved_errors
+        @resolved_errors ||= ErrorLog
+          .where.not(resolved_at: nil)
+          .where("occurred_at >= ?", @start_date)
+      end
+
+      def calculate_overall_mttr
+        return 0 if resolved_errors.empty?
+
+        total_hours = resolved_errors.sum do |error|
+          ((error.resolved_at - error.occurred_at) / 3600.0).round(2)
+        end
+        (total_hours / resolved_errors.count).round(2)
+      end
+
+      def mttr_by_platform
+        platforms = ErrorLog.distinct.pluck(:platform).compact
+
+        platforms.each_with_object({}) do |platform, result|
+          platform_resolved = resolved_errors.where(platform: platform)
+          next if platform_resolved.empty?
+
+          total_hours = platform_resolved.sum { |e| ((e.resolved_at - e.occurred_at) / 3600.0) }
+          result[platform] = (total_hours / platform_resolved.count).round(2)
+        end
+      end
+
+      def mttr_by_severity
+        {
+          critical: calculate_mttr_for_severity(:critical),
+          high: calculate_mttr_for_severity(:high),
+          medium: calculate_mttr_for_severity(:medium),
+          low: calculate_mttr_for_severity(:low)
+        }.compact
+      end
+
+      def calculate_mttr_for_severity(severity)
+        severity_errors = resolved_errors.select { |e| e.severity == severity }
+        return nil if severity_errors.empty?
+
+        total_hours = severity_errors.sum { |e| ((e.resolved_at - e.occurred_at) / 3600.0) }
+        (total_hours / severity_errors.count).round(2)
+      end
+
+      def mttr_trend_by_week
+        trends = {}
+        current_date = @start_date
+
+        while current_date < Time.current
+          week_end = current_date + 1.week
+          week_resolved = ErrorLog
+            .where.not(resolved_at: nil)
+            .where("occurred_at >= ? AND occurred_at < ?", current_date, week_end)
+
+          if week_resolved.any?
+            total_hours = week_resolved.sum { |e| ((e.resolved_at - e.occurred_at) / 3600.0) }
+            trends[current_date.to_date.to_s] = (total_hours / week_resolved.count).round(2)
+          end
+
+          current_date = week_end
+        end
+
+        trends
+      end
+
+      def fastest_resolution_time
+        return nil if resolved_errors.empty?
+
+        resolved_errors.min_by { |e| e.resolved_at - e.occurred_at }
+                       .then { |e| ((e.resolved_at - e.occurred_at) / 60.0).round } # minutes
+      end
+
+      def slowest_resolution_time
+        return nil if resolved_errors.empty?
+
+        resolved_errors.max_by { |e| e.resolved_at - e.occurred_at }
+                       .then { |e| ((e.resolved_at - e.occurred_at) / 3600.0).round(1) } # hours
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/recurring_issues.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Analyze recurring and persistent errors
+    # Returns data about high-frequency errors, persistent issues, and cyclical patterns
+    class RecurringIssues
+      def self.call(days = 30)
+        new(days).call
+      end
+
+      def initialize(days = 30)
+        @days = days
+        @start_date = days.days.ago
+      end
+
+      def call
+        {
+          high_frequency_errors: high_frequency_errors,
+          persistent_errors: persistent_errors,
+          cyclical_patterns: cyclical_patterns
+        }
+      end
+
+      private
+
+      def base_query
+        ErrorLog.where("occurred_at >= ?", @start_date)
+      end
+
+      def high_frequency_errors
+        # Errors with high occurrence count
+        base_query
+          .where("occurrence_count > ?", 10)
+          .group(:error_type)
+          .select("error_type,
+                   SUM(occurrence_count) as total_occurrences,
+                   MIN(first_seen_at) as first_occurrence,
+                   MAX(last_seen_at) as last_occurrence,
+                   COUNT(*) as unique_error_count")
+          .order("total_occurrences DESC")
+          .limit(10)
+          .map do |error|
+            first_seen = error.first_occurrence.is_a?(Time) ? error.first_occurrence : Time.parse(error.first_occurrence.to_s)
+            last_seen = error.last_occurrence.is_a?(Time) ? error.last_occurrence : Time.parse(error.last_occurrence.to_s)
+
+            {
+              error_type: error.error_type,
+              total_occurrences: error.total_occurrences,
+              first_seen: first_seen,
+              last_seen: last_seen,
+              duration_days: ((last_seen - first_seen) / 1.day).round,
+              still_active: last_seen > 24.hours.ago
+            }
+          end
+      end
+
+      def persistent_errors
+        # Errors that have been unresolved for longest time
+        base_query
+          .where(resolved: false)
+          .where("first_seen_at < ?", 7.days.ago)
+          .order("first_seen_at ASC")
+          .limit(10)
+          .map do |error|
+            {
+              id: error.id,
+              error_type: error.error_type,
+              message: error.message.to_s.truncate(100),
+              first_seen: error.first_seen_at,
+              age_days: ((Time.current - error.first_seen_at) / 1.day).round,
+              occurrence_count: error.occurrence_count,
+              platform: error.platform
+            }
+          end
+      end
+
+      def cyclical_patterns
+        # Use existing PatternDetector if available
+        return {} unless defined?(Services::PatternDetector)
+
+        top_error_types = base_query.group(:error_type).count.sort_by { |_, count| -count }.first(5).to_h.keys
+
+        top_error_types.each_with_object({}) do |error_type, result|
+          pattern = Services::PatternDetector.analyze_cyclical_pattern(
+            error_type: error_type,
+            platform: nil,
+            days: @days
+          )
+          result[error_type] = pattern if pattern[:pattern_strength] > 0.6
+        end
+      rescue NameError
+        {} # PatternDetector not available
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/lib/rails_error_dashboard.rb

@@ -8,6 +8,7 @@ require "pagy"
 require "browser"
 require "groupdate"
 require "httparty"
+require "chartkick"
 
 # Core library files
 require "rails_error_dashboard/value_objects/error_context"
@@ -32,6 +33,8 @@ require "rails_error_dashboard/queries/dashboard_stats"
 require "rails_error_dashboard/queries/analytics_stats"
 require "rails_error_dashboard/queries/filter_options"
 require "rails_error_dashboard/queries/similar_errors"
+require "rails_error_dashboard/queries/recurring_issues"
+require "rails_error_dashboard/queries/mttr_stats"
 require "rails_error_dashboard/error_reporter"
 require "rails_error_dashboard/middleware/error_catcher"