rails_error_dashboard 0.1.28 → 0.1.30

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

@@ -27,6 +27,9 @@ module RailsErrorDashboard
       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"
+      # Developer tools options
+      class_option :source_code_integration, type: :boolean, default: false, desc: "Enable source code viewer (NEW!)"
+      class_option :git_blame, type: :boolean, default: false, desc: "Enable git blame integration (NEW!)"
 
       def welcome_message
         say "\n"
@@ -148,6 +151,20 @@ module RailsErrorDashboard
             name: "Occurrence Pattern Detection",
             description: "Detect cyclical patterns and bursts",
             category: "Advanced Analytics"
+          },
+
+          # === DEVELOPER TOOLS ===
+          {
+            key: :source_code_integration,
+            name: "Source Code Integration (NEW!)",
+            description: "View source code directly in error details",
+            category: "Developer Tools"
+          },
+          {
+            key: :git_blame,
+            name: "Git Blame Integration (NEW!)",
+            description: "Show git blame info (author, commit, timestamp)",
+            category: "Developer Tools"
           }
         ]
 
@@ -197,6 +214,10 @@ module RailsErrorDashboard
         @enable_platform_comparison = @selected_features&.dig(:platform_comparison) || options[:platform_comparison]
         @enable_occurrence_patterns = @selected_features&.dig(:occurrence_patterns) || options[:occurrence_patterns]
 
+        # Developer Tools
+        @enable_source_code_integration = @selected_features&.dig(:source_code_integration) || options[:source_code_integration]
+        @enable_git_blame = @selected_features&.dig(:git_blame) || options[:git_blame]
+
         template "initializer.rb", "config/initializers/rails_error_dashboard.rb"
       end
 
@@ -268,6 +289,17 @@ module RailsErrorDashboard
           enabled_count += analytics_features.size
         end
 
+        # Developer Tools
+        developer_tools_features = []
+        developer_tools_features << "Source Code Integration" if @enable_source_code_integration
+        developer_tools_features << "Git Blame" if @enable_git_blame
+
+        if developer_tools_features.any?
+          say "\nDeveloper Tools:", :cyan
+          say "  ✓ #{developer_tools_features.join(", ")}", :green
+          enabled_count += developer_tools_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

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

@@ -22,8 +22,9 @@ RailsErrorDashboard.configure do |config|
   # User model for error associations
   config.user_model = "User"
 
-  # Error retention policy (days to keep errors before auto-deletion)
-  config.retention_days = 90
+  # Error retention policy - nil means keep forever (no automatic deletion)
+  # To manually cleanup old errors: rails error_dashboard:cleanup_resolved DAYS=90
+  config.retention_days = nil
 
   # ============================================================================
   # NOTIFICATION SETTINGS
@@ -120,8 +121,8 @@ RailsErrorDashboard.configure do |config|
   # config.async_adapter = :sidekiq  # Options: :sidekiq, :solid_queue, :async
 
 <% end -%>
-  # Backtrace size limiting (reduces storage by ~80%)
-  config.max_backtrace_lines = 50
+  # Backtrace size limiting (100 lines is industry standard: Rollbar, Airbrake, Bugsnag)
+  config.max_backtrace_lines = 100
 
 <% if @enable_error_sampling -%>
   # Error Sampling - ENABLED
@@ -262,6 +263,38 @@ RailsErrorDashboard.configure do |config|
   config.enable_occurrence_patterns = false
 
 <% end -%>
+  # ============================================================================
+  # DEVELOPER TOOLS (NEW!)
+  # ============================================================================
+
+<% if @enable_source_code_integration -%>
+  # Source Code Integration - ENABLED (NEW!)
+  # View source code directly in error details with inline viewer
+  config.enable_source_code_integration = true
+  # To disable: Set config.enable_source_code_integration = false
+
+<% else -%>
+  # Source Code Integration - DISABLED (NEW!)
+  # To enable: Set config.enable_source_code_integration = true
+  config.enable_source_code_integration = false
+
+<% end -%>
+<% if @enable_git_blame -%>
+  # Git Blame Integration - ENABLED (NEW!)
+  # Show git blame info (author, commit, timestamp) for each source line
+  config.enable_git_blame = true
+  # To disable: Set config.enable_git_blame = false
+
+<% else -%>
+  # Git Blame Integration - DISABLED (NEW!)
+  # To enable: Set config.enable_git_blame = true (requires Git installed)
+  config.enable_git_blame = false
+
+<% end -%>
+  # Repository settings (auto-detected from git remote, optional override)
+  # config.repository_url = ENV["REPOSITORY_URL"]  # e.g., "https://github.com/user/repo"
+  # config.repository_branch = ENV.fetch("REPOSITORY_BRANCH", "main")  # Default branch
+
   # ============================================================================
   # INTERNAL LOGGING (Silent by Default)
   # ============================================================================

data/lib/rails_error_dashboard/configuration.rb

@@ -88,6 +88,14 @@ module RailsErrorDashboard
     attr_accessor :baseline_alert_severities # Array of severities to alert on (default: [:critical, :high])
     attr_accessor :baseline_alert_cooldown_minutes # Minutes between alerts for same error type (default: 120)
 
+    # Source code integration (show code in backtrace)
+    attr_accessor :enable_source_code_integration  # Master switch (default: false)
+    attr_accessor :source_code_context_lines       # Lines before/after (default: 5)
+    attr_accessor :enable_git_blame                # Show git blame (default: false)
+    attr_accessor :source_code_cache_ttl           # Cache TTL in seconds (default: 3600)
+    attr_accessor :only_show_app_code_source       # Hide gems/stdlib (default: true)
+    attr_accessor :git_branch_strategy             # :commit_sha, :current_branch, :main (default: :commit_sha)
+
     # Notification callbacks (managed via helper methods, not set directly)
     attr_reader :notification_callbacks
 
@@ -100,7 +108,7 @@ module RailsErrorDashboard
       @dashboard_username = ENV.fetch("ERROR_DASHBOARD_USER", "gandalf")
       @dashboard_password = ENV.fetch("ERROR_DASHBOARD_PASSWORD", "youshallnotpass")
 
-      @user_model = "User"
+      @user_model = nil  # Auto-detect if not set
 
       # Multi-app support defaults
       @application_name = ENV["APPLICATION_NAME"]  # Auto-detected if not set
@@ -128,7 +136,9 @@ module RailsErrorDashboard
 
       @use_separate_database = ENV.fetch("USE_SEPARATE_ERROR_DB", "false") == "true"
 
-      @retention_days = 90
+      # Retention policy - nil means keep forever (no automatic deletion)
+      # Users can run 'rails error_dashboard:cleanup_resolved DAYS=90' to manually clean up
+      @retention_days = nil
 
       @enable_middleware = true
       @enable_error_subscriber = true
@@ -139,7 +149,7 @@ module RailsErrorDashboard
       @sampling_rate = 1.0 # 100% by default
       @async_logging = false
       @async_adapter = :sidekiq # Battle-tested default
-      @max_backtrace_lines = 50
+      @max_backtrace_lines = 100 # Matches industry standard (Rollbar, Airbrake)
 
       # Rate limiting defaults
       @enable_rate_limiting = false # OFF by default (opt-in)
@@ -165,6 +175,14 @@ module RailsErrorDashboard
       @baseline_alert_severities = [ :critical, :high ] # Alert on critical and high severity anomalies
       @baseline_alert_cooldown_minutes = ENV.fetch("BASELINE_ALERT_COOLDOWN", "120").to_i
 
+      # Source code integration defaults - OFF by default (opt-in)
+      @enable_source_code_integration = false  # Master switch
+      @source_code_context_lines = 5  # Show ±5 lines around target line
+      @enable_git_blame = false  # Show git blame info
+      @source_code_cache_ttl = 3600  # 1 hour cache
+      @only_show_app_code_source = true  # Hide gem/vendor code for security
+      @git_branch_strategy = :commit_sha  # Use error's git_sha (most accurate)
+
       # Internal logging defaults - SILENT by default
       @enable_internal_logging = false  # Opt-in for debugging
       @log_level = :silent  # Silent by default, use :debug, :info, :warn, :error, or :silent
@@ -180,5 +198,144 @@ module RailsErrorDashboard
     def reset!
       initialize
     end
+
+    # Validate configuration values
+    # Raises ConfigurationError if any validation fails
+    #
+    # @raise [ConfigurationError] if configuration is invalid
+    # @return [true] if configuration is valid
+    def validate!
+      errors = []
+
+      # Validate sampling_rate (must be between 0.0 and 1.0)
+      if sampling_rate && (sampling_rate < 0.0 || sampling_rate > 1.0)
+        errors << "sampling_rate must be between 0.0 and 1.0 (got: #{sampling_rate})"
+      end
+
+      # Validate retention_days (must be positive)
+      if retention_days && retention_days < 1
+        errors << "retention_days must be at least 1 day (got: #{retention_days})"
+      end
+
+      # Validate max_backtrace_lines (must be positive)
+      if max_backtrace_lines && max_backtrace_lines < 1
+        errors << "max_backtrace_lines must be at least 1 (got: #{max_backtrace_lines})"
+      end
+
+      # Validate rate_limit_per_minute (must be positive if rate limiting enabled)
+      if enable_rate_limiting && rate_limit_per_minute && rate_limit_per_minute < 1
+        errors << "rate_limit_per_minute must be at least 1 (got: #{rate_limit_per_minute})"
+      end
+
+      # Validate baseline alert threshold (must be positive)
+      if enable_baseline_alerts && baseline_alert_threshold_std_devs && baseline_alert_threshold_std_devs <= 0
+        errors << "baseline_alert_threshold_std_devs must be positive (got: #{baseline_alert_threshold_std_devs})"
+      end
+
+      # Validate baseline alert cooldown (must be positive)
+      if enable_baseline_alerts && baseline_alert_cooldown_minutes && baseline_alert_cooldown_minutes < 1
+        errors << "baseline_alert_cooldown_minutes must be at least 1 (got: #{baseline_alert_cooldown_minutes})"
+      end
+
+      # Validate baseline alert severities (must be valid symbols)
+      if enable_baseline_alerts && baseline_alert_severities
+        valid_severities = %i[critical high medium low]
+        invalid_severities = baseline_alert_severities - valid_severities
+        if invalid_severities.any?
+          errors << "baseline_alert_severities contains invalid values: #{invalid_severities.inspect}. " \
+                    "Valid options: #{valid_severities.inspect}"
+        end
+      end
+
+      # Validate async_adapter (must be valid adapter)
+      if async_logging && async_adapter
+        valid_adapters = %i[sidekiq solid_queue async]
+        unless valid_adapters.include?(async_adapter)
+          errors << "async_adapter must be one of #{valid_adapters.inspect} (got: #{async_adapter.inspect})"
+        end
+      end
+
+      # Validate notification dependencies
+      if enable_slack_notifications && (slack_webhook_url.nil? || slack_webhook_url.strip.empty?)
+        errors << "slack_webhook_url is required when enable_slack_notifications is true"
+      end
+
+      if enable_email_notifications && notification_email_recipients.empty?
+        errors << "notification_email_recipients is required when enable_email_notifications is true"
+      end
+
+      if enable_discord_notifications && (discord_webhook_url.nil? || discord_webhook_url.strip.empty?)
+        errors << "discord_webhook_url is required when enable_discord_notifications is true"
+      end
+
+      if enable_pagerduty_notifications && (pagerduty_integration_key.nil? || pagerduty_integration_key.strip.empty?)
+        errors << "pagerduty_integration_key is required when enable_pagerduty_notifications is true"
+      end
+
+      if enable_webhook_notifications && webhook_urls.empty?
+        errors << "webhook_urls is required when enable_webhook_notifications is true"
+      end
+
+      # Validate separate database configuration
+      if use_separate_database && (database.nil? || database.to_s.strip.empty?)
+        errors << "database configuration is required when use_separate_database is true"
+      end
+
+      # Validate log level (must be valid symbol)
+      if log_level
+        valid_log_levels = %i[debug info warn error fatal silent]
+        unless valid_log_levels.include?(log_level)
+          errors << "log_level must be one of #{valid_log_levels.inspect} (got: #{log_level.inspect})"
+        end
+      end
+
+      # Validate total_users_for_impact (must be positive if set)
+      if total_users_for_impact && total_users_for_impact < 1
+        errors << "total_users_for_impact must be at least 1 (got: #{total_users_for_impact})"
+      end
+
+      # Raise exception if any errors found
+      raise ConfigurationError, errors if errors.any?
+
+      true
+    end
+
+    # Get the effective user model (auto-detected if not configured)
+    #
+    # @return [String, nil] User model class name
+    def effective_user_model
+      return @user_model if @user_model.present?
+
+      RailsErrorDashboard::Helpers::UserModelDetector.detect_user_model
+    end
+
+    # Get the effective total users count (auto-detected if not configured)
+    # Caches the result for 5 minutes to avoid repeated queries
+    #
+    # @return [Integer, nil] Total users count
+    def effective_total_users
+      return @total_users_for_impact if @total_users_for_impact.present?
+
+      # Cache auto-detected value for 5 minutes
+      @total_users_cache ||= {}
+      cache_key = :auto_detected_count
+      cached_at = @total_users_cache[:cached_at]
+
+      if cached_at && (Time.current - cached_at) < 300 # 5 minutes
+        return @total_users_cache[cache_key]
+      end
+
+      count = RailsErrorDashboard::Helpers::UserModelDetector.detect_total_users
+
+      @total_users_cache[cache_key] = count
+      @total_users_cache[:cached_at] = Time.current
+
+      count
+    end
+
+    # Clear the total users cache
+    def clear_total_users_cache!
+      @total_users_cache = {}
+    end
   end
 end

data/lib/rails_error_dashboard/configuration_error.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Custom exception for configuration validation errors
+  # Provides clear, actionable error messages when configuration is invalid
+  class ConfigurationError < StandardError
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors.is_a?(Array) ? errors : [ errors ]
+      super(build_message)
+    end
+
+    private
+
+    def build_message
+      header = "Rails Error Dashboard configuration is invalid:\n\n"
+      body = @errors.map.with_index(1) { |error, index| "  #{index}. #{error}" }.join("\n")
+      footer = "\n\nPlease fix these issues in config/initializers/rails_error_dashboard.rb"
+
+      header + body + footer
+    end
+  end
+end

data/lib/rails_error_dashboard/engine.rb

@@ -2,6 +2,11 @@ module RailsErrorDashboard
   class Engine < ::Rails::Engine
     isolate_namespace RailsErrorDashboard
 
+    # Serve static files from engine's public directory
+    initializer "rails_error_dashboard.assets" do |app|
+      app.middleware.use ::ActionDispatch::Static, "#{root}/public"
+    end
+
     # Configure database connection for error models
     # This runs early, before middleware setup, but after database.yml is loaded
     initializer "rails_error_dashboard.database", before: :load_config_initializers do
@@ -38,6 +43,18 @@ module RailsErrorDashboard
       end
     end
 
+    # Validate configuration after initialization
+    initializer "rails_error_dashboard.validate_config", after: :load_config_initializers do
+      config.after_initialize do
+        begin
+          RailsErrorDashboard.configuration.validate!
+        rescue ConfigurationError => e
+          Rails.logger.error "[Rails Error Dashboard] #{e.message}"
+          raise
+        end
+      end
+    end
+
     # Subscribe to Rails error reporter
     config.after_initialize do
       if RailsErrorDashboard.configuration.enable_error_subscriber

data/lib/rails_error_dashboard/helpers/user_model_detector.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Helpers
+    # Automatically detects the User model and total users count
+    # Handles both single database and separate database setups
+    class UserModelDetector
+      class << self
+        # Auto-detect the user model name
+        # Returns the configured model if set, otherwise tries to detect User model
+        #
+        # @return [String, nil] The user model class name or nil if not found
+        def detect_user_model
+          # Return configured model if explicitly set
+          configured_model = RailsErrorDashboard.configuration.user_model
+          return configured_model if configured_model.present? && configured_model != "User"
+
+          # Try to detect User model
+          return "User" if user_model_exists?
+
+          # Check for common alternatives
+          %w[Account Member Person].each do |model_name|
+            return model_name if model_exists?(model_name)
+          end
+
+          nil
+        end
+
+        # Auto-detect total users count
+        # Returns the configured value if set, otherwise queries the user model
+        #
+        # @return [Integer, nil] Total users count or nil if unavailable
+        def detect_total_users
+          # Return configured value if explicitly set
+          configured_count = RailsErrorDashboard.configuration.total_users_for_impact
+          return configured_count if configured_count.present?
+
+          # Try to query user model count
+          user_model_name = detect_user_model
+          return nil unless user_model_name
+
+          query_user_count(user_model_name)
+        rescue StandardError => e
+          # Silently return nil if query fails (DB not accessible, model doesn't have count, etc.)
+          log_error("Failed to query user count: #{e.message}")
+          nil
+        end
+
+        # Check if User model exists and is loaded
+        #
+        # @return [Boolean]
+        def user_model_exists?
+          model_exists?("User")
+        end
+
+        # Check if a specific model exists and is loaded
+        #
+        # @param [String] model_name The model class name to check
+        # @return [Boolean]
+        def model_exists?(model_name)
+          # Check if model file exists
+          return false unless model_file_exists?(model_name)
+
+          # Try to constantize the model
+          begin
+            model_class = model_name.constantize
+            model_class.is_a?(Class) && model_class < ActiveRecord::Base
+          rescue NameError, LoadError
+            false
+          end
+        end
+
+        # Check if model file exists in app/models
+        #
+        # @param [String] model_name The model class name to check
+        # @return [Boolean]
+        def model_file_exists?(model_name)
+          return false unless defined?(Rails)
+
+          # Convert to snake_case filename (e.g., "User" -> "user.rb")
+          filename = model_name.underscore + ".rb"
+          model_path = Rails.root.join("app", "models", filename)
+
+          File.exist?(model_path)
+        end
+
+        # Query the user count from the model
+        # Handles connection to main database even if error dashboard uses separate DB
+        #
+        # @param [String] model_name The model class name to query
+        # @return [Integer, nil] User count or nil if query fails
+        def query_user_count(model_name)
+          model_class = model_name.constantize
+
+          # Ensure we're querying the main database, not the error dashboard database
+          # User models always connect to the primary/main database
+          if model_class.respond_to?(:count)
+            # Use a timeout to avoid hanging the dashboard
+            Timeout.timeout(5) do
+              model_class.count
+            end
+          end
+        rescue NameError, LoadError => e
+          log_error("Model not found: #{model_name} - #{e.message}")
+          nil
+        rescue Timeout::Error => e
+          log_error("Timeout querying #{model_name}.count - #{e.message}")
+          nil
+        rescue StandardError => e
+          log_error("Error querying #{model_name}.count: #{e.message}")
+          nil
+        end
+
+        # Get user impact percentage for an error
+        # Calculates percentage of users affected based on unique_users_count
+        #
+        # @param [Integer] unique_users_count Number of unique users affected
+        # @return [Float, nil] Percentage or nil if total users unavailable
+        def calculate_user_impact(unique_users_count)
+          return nil unless unique_users_count.present? && unique_users_count.positive?
+
+          total_users = detect_total_users
+          return nil unless total_users.present? && total_users.positive?
+
+          ((unique_users_count.to_f / total_users) * 100).round(2)
+        end
+
+        private
+
+        def log_error(message)
+          return unless RailsErrorDashboard.configuration.enable_internal_logging
+
+          Rails.logger.warn("[RailsErrorDashboard::UserModelDetector] #{message}")
+        end
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/analytics_stats.rb

@@ -100,8 +100,7 @@ module RailsErrorDashboard
                   .count
                   .sort_by { |_, count| -count }
                   .first(10)
-                  .map { |user_id, count| [ find_user_email(user_id, user_model), count ] }
-                  .to_h
+                  .map { |user_id, count| { user_id: user_id, email: find_user_email(user_id, user_model), count: count } }
       end
 
       def find_user_email(user_id, user_model)

data/lib/rails_error_dashboard/queries/dashboard_stats.rb

@@ -38,7 +38,8 @@ module RailsErrorDashboard
               affected_users_change: affected_users_change,
               trend_percentage: trend_percentage,
               trend_direction: trend_direction,
-              top_errors_by_impact: top_errors_by_impact
+              top_errors_by_impact: top_errors_by_impact,
+              average_resolution_time: average_resolution_time
             }
           end
         rescue => e
@@ -66,7 +67,8 @@ module RailsErrorDashboard
             affected_users_change: 0,
             trend_percentage: 0.0,
             trend_direction: :stable,
-            top_errors_by_impact: []
+            top_errors_by_impact: [],
+            average_resolution_time: nil
           }
         end
       end
@@ -308,7 +310,7 @@ module RailsErrorDashboard
         end
       end
 
-      # Get top 5 errors ranked by impact score
+      # Get top 6 errors ranked by impact score
       # Impact = affected_users_count × occurrence_count
       def top_errors_by_impact
         base_scope.where("occurred_at >= ?", 7.days.ago)
@@ -317,7 +319,7 @@ module RailsErrorDashboard
                         COUNT(DISTINCT user_id) as affected_users,
                         COUNT(DISTINCT user_id) * occurrence_count as impact_score")
                 .order("impact_score DESC")
-                .limit(5)
+                .limit(6)
                 .map do |error|
                   full_error = ErrorLog.find(error.id)
                   {
@@ -332,6 +334,19 @@ module RailsErrorDashboard
                   }
                 end
       end
+
+      # Calculate average resolution time (MTTR) in hours for the last 30 days
+      def average_resolution_time
+        resolved_errors = base_scope.resolved.where("resolved_at >= ?", 30.days.ago)
+        return nil if resolved_errors.empty?
+
+        total_seconds = resolved_errors.sum do |error|
+          (error.resolved_at - error.occurred_at).to_i
+        end
+
+        average_seconds = total_seconds / resolved_errors.count.to_f
+        (average_seconds / 3600.0).round(2) # Convert to hours
+      end
     end
   end
 end

data/lib/rails_error_dashboard/queries/errors_list.rb

@@ -29,6 +29,7 @@ module RailsErrorDashboard
         query = filter_by_resolved(query)
         query = filter_by_platform(query)
         query = filter_by_application(query)
+        query = filter_by_user_id(query)
         query = filter_by_search(query)
         query = filter_by_severity(query)
         query = filter_by_timeframe(query)
@@ -82,6 +83,12 @@ module RailsErrorDashboard
         query.where(application_id: @filters[:application_id])
       end
 
+      def filter_by_user_id(query)
+        return query unless @filters[:user_id].present?
+
+        query.where(user_id: @filters[:user_id])
+      end
+
       def filter_by_search(query)
         return query unless @filters[:search].present?
 
@@ -145,17 +152,29 @@ module RailsErrorDashboard
       end
 
       def filter_by_assignment(query)
-        return query unless @filters[:assigned_to].present?
         return query unless ErrorLog.column_names.include?("assigned_to")
 
-        case @filters[:assigned_to]
-        when "__unassigned__"
-          query.unassigned
-        when "__assigned__"
-          query.assigned
-        else
-          query.by_assignee(@filters[:assigned_to])
+        # Handle assigned_to filter (All/Unassigned/Assigned)
+        if @filters[:assigned_to].present?
+          case @filters[:assigned_to]
+          when "__unassigned__"
+            query = query.unassigned
+          when "__assigned__"
+            query = query.assigned
+            # If assignee_name is also provided, filter by specific assignee
+            if @filters[:assignee_name].present?
+              query = query.by_assignee(@filters[:assignee_name])
+            end
+          else
+            # Specific assignee name provided in assigned_to
+            query = query.by_assignee(@filters[:assigned_to])
+          end
+        elsif @filters[:assignee_name].present?
+          # If only assignee_name is provided without assigned_to filter
+          query = query.by_assignee(@filters[:assignee_name])
         end
+
+        query
       end
 
       def filter_by_priority(query)