rails_error_dashboard 0.1.29 → 0.1.30

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/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

@@ -152,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)

data/lib/rails_error_dashboard/services/error_normalizer.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Smart error message normalization for better error grouping
+    #
+    # Replaces dynamic values (IDs, UUIDs, timestamps, etc.) with placeholders
+    # while preserving semantic meaning. This improves error deduplication accuracy
+    # compared to naive "replace all numbers" approach.
+    #
+    # @example
+    #   ErrorNormalizer.normalize("User 123 not found")
+    #   # => "User :id not found"
+    #
+    #   ErrorNormalizer.normalize("Expected 2 arguments, got 5")
+    #   # => "Expected 2 arguments, got 5" (preserves meaningful numbers)
+    #
+    class ErrorNormalizer
+      # Patterns for smart normalization
+      # Order matters: more specific patterns should come first
+      PATTERNS = {
+        # UUIDs (e.g., "550e8400-e29b-41d4-a716-446655440000")
+        uuid: /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i,
+
+        # Memory addresses (e.g., "<User:0x00007f8b1a2b3c4d>", "0x00007f8b1a2b3c4d")
+        # MUST come before hash_id to match memory addresses first
+        memory_address: /#?<[^>]+:0x[0-9a-f]+>/i,
+        hex_address: /\b0x[0-9a-f]{8,16}\b/i,
+
+        # Timestamps (ISO8601 and common formats)
+        # Remove timezone offset separately to avoid leaving it behind
+        timestamp_iso: /\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?/,
+        timestamp_unix: /\btimestamp[:\s]+\d{10,13}\b/i,
+
+        # Tokens and API keys (long alphanumeric strings)
+        # MUST come before large_number to match long tokens first
+        token: /\b[a-z0-9]{32,}\b/i,
+
+        # Object IDs and database IDs (e.g., "User #123", "id: 456", "ID=789")
+        # MUST come before hash_id to match specific ID patterns first
+        object_id: /(?:#|(?:id|ID)(?:\s*[=:#]\s*|\s+))\d+\b/,
+        # Ruby-style object references (e.g., "User:123", "#<User:123>")
+        hash_id: /#?<?[A-Z]\w*:\d+>?/,
+
+        # File paths with dynamic components (but check for UUIDs in path first)
+        # More specific pattern: match /tmp/ followed by UUID-like or hash-like segment
+        temp_path: %r{/(?:tmp|var/tmp|private/tmp)/(?:[a-z0-9_-]+/)*[a-z0-9_-]+(?:\.[a-z0-9]+)?},
+
+        # Numbered URL paths - MUST come before large_number
+        # Capture the leading slash with the number, and optional trailing slash
+        numbered_path: %r{/\d+(?=/|$)}, # e.g., "/api/users/123/posts" → "/api/users:numbered_path/posts"
+
+        # Email addresses (preserve domain, replace local part)
+        email: /\b[\w.+-]+@[\w.-]+\.[a-z]{2,}\b/i,
+
+        # IP addresses
+        ipv4: /\b(?:\d{1,3}\.){3}\d{1,3}\b/,
+        ipv6: /\b(?:[0-9a-f]{1,4}:){7}[0-9a-f]{1,4}\b/i,
+
+        # Hexadecimal values (but not in memory addresses - already handled)
+        hex_value: /\b0x[0-9a-f]+\b/i,
+
+        # Standalone large numbers (likely IDs, but preserve small numbers < 1000)
+        # MUST come last to avoid matching parts of other patterns
+        large_number: /\b\d{4,}\b/
+      }.freeze
+
+      class << self
+        # Normalize an error message by replacing dynamic values with placeholders
+        #
+        # @param message [String] the error message to normalize
+        # @return [String] the normalized message
+        def normalize(message)
+          return "" if message.nil?
+          return message if message.strip.empty? # Preserve whitespace-only strings
+
+          normalized = message.dup
+
+          # Apply each pattern in order
+          PATTERNS.each do |type, pattern|
+            normalized.gsub!(pattern, ":#{type}")
+          end
+
+          # Clean up leftover timezone offsets that weren't caught by timestamp pattern
+          normalized.gsub!(/\s+[+-]\d{2}:\d{2}$/, "")
+
+          normalized
+        end
+
+        # Extract significant backtrace frames, skipping gem/vendor code
+        #
+        # @param backtrace [String] the full backtrace string
+        # @param count [Integer] number of frames to extract (default: 3)
+        # @return [String, nil] the significant frames joined with "|"
+        def extract_significant_frames(backtrace, count: 3)
+          return nil if backtrace.blank?
+
+          frames = backtrace.split("\n")
+            .map(&:strip)
+            .reject { |line| gem_or_vendor_code?(line) }
+            .reject { |line| ruby_stdlib_code?(line) }
+            .first(count)
+            .map { |line| extract_file_and_method(line) }
+            .compact
+
+          frames.empty? ? nil : frames.join("|")
+        end
+
+        private
+
+        # Check if a backtrace line is from gem/vendor code
+        def gem_or_vendor_code?(line)
+          line.include?("vendor/bundle") ||
+            line.include?("gems/") ||
+            line.include?(".gem/ruby")
+        end
+
+        # Check if a backtrace line is from Ruby standard library
+        def ruby_stdlib_code?(line)
+          line.include?("/ruby/") ||
+            line.include?("/lib/ruby/") ||
+            line.match?(%r{ruby-\d+\.\d+\.\d+/lib})
+        end
+
+        # Extract file path and method name from a backtrace line
+        # Example: "/app/models/user.rb:10:in `name'" => "/app/models/user.rb:name"
+        def extract_file_and_method(line)
+          # Match pattern: file.rb:line:in `method'
+          match = line.match(%r{^(.+\.rb):(\d+)(?::in `(.+)')?})
+          return nil unless match
+
+          file = match[1]
+          method = match[3]
+
+          # Remove absolute path prefix for consistency
+          file = file.sub(%r{.*/(?=app/)}, "")
+
+          method ? "#{file}:#{method}" : file
+        end
+      end
+    end
+  end
+end