rails_error_dashboard 0.1.0 → 0.1.1

data/app/models/rails_error_dashboard/cascade_pattern.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Tracks cascade patterns where one error causes another
+  #
+  # A cascade pattern represents a causal relationship between errors:
+  # Parent Error → Child Error
+  #
+  # For example: DatabaseConnectionError → NoMethodError
+  # When a database connection fails, subsequent code may try to call
+  # methods on nil objects, causing NoMethodError.
+  #
+  # @attr parent_error_id [Integer] The error that happens first (potential cause)
+  # @attr child_error_id [Integer] The error that happens after (potential effect)
+  # @attr frequency [Integer] How many times this cascade has been observed
+  # @attr avg_delay_seconds [Float] Average time between parent and child
+  # @attr cascade_probability [Float] Likelihood (0.0-1.0) that parent causes child
+  # @attr last_detected_at [DateTime] When this cascade was last observed
+  class CascadePattern < ErrorLogsRecord
+    self.table_name = "rails_error_dashboard_cascade_patterns"
+
+    belongs_to :parent_error, class_name: "RailsErrorDashboard::ErrorLog"
+    belongs_to :child_error, class_name: "RailsErrorDashboard::ErrorLog"
+
+    validates :parent_error_id, presence: true
+    validates :child_error_id, presence: true
+    validates :frequency, presence: true, numericality: { greater_than: 0 }
+    validate :parent_and_child_must_be_different
+
+    scope :high_confidence, -> { where("cascade_probability >= ?", 0.7) }
+    scope :frequent, ->(min_frequency = 3) { where("frequency >= ?", min_frequency) }
+    scope :recent, -> { order(last_detected_at: :desc) }
+    scope :by_parent, ->(error_id) { where(parent_error_id: error_id) }
+    scope :by_child, ->(error_id) { where(child_error_id: error_id) }
+
+    # Update cascade pattern stats
+    def increment_detection!(delay_seconds)
+      self.frequency += 1
+
+      # Update average delay using incremental formula
+      if avg_delay_seconds.present?
+        self.avg_delay_seconds = ((avg_delay_seconds * (frequency - 1)) + delay_seconds) / frequency
+      else
+        self.avg_delay_seconds = delay_seconds
+      end
+
+      self.last_detected_at = Time.current
+      save
+    end
+
+    # Calculate cascade probability based on frequency
+    # Probability = (times child follows parent) / (total parent occurrences)
+    def calculate_probability!
+      parent_occurrence_count = parent_error.error_occurrences.count
+      return if parent_occurrence_count.zero?
+
+      self.cascade_probability = (frequency.to_f / parent_occurrence_count).round(3)
+      save
+    end
+
+    # Check if this is a strong cascade pattern
+    def strong_cascade?
+      cascade_probability.present? && cascade_probability >= 0.7 && frequency >= 3
+    end
+
+    private
+
+    def parent_and_child_must_be_different
+      if parent_error_id == child_error_id
+        errors.add(:child_error_id, "cannot be the same as parent error")
+      end
+    end
+  end
+end

data/app/models/rails_error_dashboard/error_baseline.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Stores baseline statistics for error types
+  #
+  # Baselines are calculated periodically (hourly, daily, weekly) to establish
+  # "normal" error behavior. This enables anomaly detection by comparing current
+  # error counts against historical baselines.
+  #
+  # @attr error_type [String] The type of error (e.g., "NoMethodError")
+  # @attr platform [String] Platform (iOS, Android, API, Web)
+  # @attr baseline_type [String] Time period type (hourly, daily, weekly)
+  # @attr period_start [DateTime] Start of the period this baseline covers
+  # @attr period_end [DateTime] End of the period this baseline covers
+  # @attr count [Integer] Total errors in this period
+  # @attr mean [Float] Average error count
+  # @attr std_dev [Float] Standard deviation
+  # @attr percentile_95 [Float] 95th percentile
+  # @attr percentile_99 [Float] 99th percentile
+  # @attr sample_size [Integer] Number of periods in the sample
+  class ErrorBaseline < ErrorLogsRecord
+    self.table_name = "rails_error_dashboard_error_baselines"
+
+    BASELINE_TYPES = %w[hourly daily weekly].freeze
+
+    validates :error_type, presence: true
+    validates :platform, presence: true
+    validates :baseline_type, presence: true, inclusion: { in: BASELINE_TYPES }
+    validates :period_start, presence: true
+    validates :period_end, presence: true
+    validates :count, presence: true, numericality: { greater_than_or_equal_to: 0 }
+    validates :sample_size, presence: true, numericality: { greater_than_or_equal_to: 0 }
+
+    validate :period_end_after_period_start
+
+    scope :for_error_type, ->(error_type) { where(error_type: error_type) }
+    scope :for_platform, ->(platform) { where(platform: platform) }
+    scope :hourly, -> { where(baseline_type: "hourly") }
+    scope :daily, -> { where(baseline_type: "daily") }
+    scope :weekly, -> { where(baseline_type: "weekly") }
+    scope :recent, -> { order(period_start: :desc) }
+
+    # Check if a given count is anomalous compared to this baseline
+    # @param current_count [Integer] Current error count to check
+    # @param sensitivity [Integer] Number of standard deviations (default: 2)
+    # @return [Symbol, nil] :elevated, :high, :critical, or nil if normal
+    def anomaly_level(current_count, sensitivity: 2)
+      return nil if mean.nil? || std_dev.nil?
+      return nil if current_count <= mean
+
+      std_devs_above = (current_count - mean) / std_dev
+
+      case std_devs_above
+      when sensitivity..(sensitivity + 1)
+        :elevated
+      when (sensitivity + 1)..(sensitivity + 2)
+        :high
+      when (sensitivity + 2)..Float::INFINITY
+        :critical
+      else
+        nil
+      end
+    end
+
+    # Check if current count is above baseline
+    # @param current_count [Integer] Current error count
+    # @param sensitivity [Integer] Number of standard deviations (default: 2)
+    # @return [Boolean] True if count exceeds baseline + (sensitivity * std_dev)
+    def exceeds_baseline?(current_count, sensitivity: 2)
+      return false if mean.nil? || std_dev.nil?
+      current_count > (mean + (sensitivity * std_dev))
+    end
+
+    # Get the threshold for anomaly detection
+    # @param sensitivity [Integer] Number of standard deviations (default: 2)
+    # @return [Float, nil] Threshold value or nil if stats not available
+    def threshold(sensitivity: 2)
+      return nil if mean.nil? || std_dev.nil?
+      mean + (sensitivity * std_dev)
+    end
+
+    # Calculate how many standard deviations above mean
+    # @param current_count [Integer] Current error count
+    # @return [Float, nil] Number of standard deviations or nil
+    def std_devs_above_mean(current_count)
+      return nil if mean.nil? || std_dev.nil? || std_dev.zero?
+      (current_count - mean) / std_dev
+    end
+
+    private
+
+    def period_end_after_period_start
+      return if period_start.nil? || period_end.nil?
+
+      if period_end <= period_start
+        errors.add(:period_end, "must be after period_start")
+      end
+    end
+  end
+end

data/app/models/rails_error_dashboard/error_log.rb

@@ -12,15 +12,26 @@ module RailsErrorDashboard
       belongs_to :user, optional: true
     end
 
+    # Association for tracking individual error occurrences
+    has_many :error_occurrences, class_name: "RailsErrorDashboard::ErrorOccurrence", dependent: :destroy
+
+    # Cascade pattern associations
+    # parent_cascade_patterns: patterns where this error is the CHILD (errors that cause this error)
+    has_many :parent_cascade_patterns, class_name: "RailsErrorDashboard::CascadePattern",
+             foreign_key: :child_error_id, dependent: :destroy
+    # child_cascade_patterns: patterns where this error is the PARENT (errors this error causes)
+    has_many :child_cascade_patterns, class_name: "RailsErrorDashboard::CascadePattern",
+             foreign_key: :parent_error_id, dependent: :destroy
+    has_many :cascade_parents, through: :parent_cascade_patterns, source: :parent_error
+    has_many :cascade_children, through: :child_cascade_patterns, source: :child_error
+
     validates :error_type, presence: true
     validates :message, presence: true
-    validates :environment, presence: true
     validates :occurred_at, presence: true
 
     scope :unresolved, -> { where(resolved: false) }
     scope :resolved, -> { where(resolved: true) }
     scope :recent, -> { order(occurred_at: :desc) }
-    scope :by_environment, ->(env) { where(environment: env) }
     scope :by_error_type, ->(type) { where(error_type: type) }
     scope :by_type, ->(type) { where(error_type: type) }
     scope :by_platform, ->(platform) { where(platform: platform) }
@@ -30,9 +41,14 @@ module RailsErrorDashboard
     # Set defaults and tracking
     before_validation :set_defaults, on: :create
     before_create :set_tracking_fields
+    before_create :set_release_info
+    after_create :calculate_priority_score
+
+    # Turbo Stream broadcasting
+    after_create_commit :broadcast_new_error
+    after_update_commit :broadcast_error_update
 
     def set_defaults
-      self.environment ||= Rails.env.to_s
       self.platform ||= "API"
     end
 
@@ -43,6 +59,18 @@ module RailsErrorDashboard
       self.occurrence_count ||= 1
     end
 
+    def set_release_info
+      return unless respond_to?(:app_version=)
+      self.app_version ||= fetch_app_version
+      self.git_sha ||= fetch_git_sha
+    end
+
+    def calculate_priority_score
+      return unless respond_to?(:priority_score=)
+      self.priority_score = compute_priority_score
+      save if persisted?
+    end
+
     # Generate unique hash for error grouping
     # Includes controller/action for better context-aware grouping
     def generate_error_hash
@@ -74,7 +102,13 @@ module RailsErrorDashboard
     end
 
     # Get severity level
+    # Checks custom severity rules first, then falls back to default classification
     def severity
+      # Check custom severity rules first
+      custom_severity = RailsErrorDashboard.configuration.custom_severity_rules[error_type]
+      return custom_severity.to_sym if custom_severity.present?
+
+      # Fall back to default classification
       return :critical if CRITICAL_ERROR_TYPES.include?(error_type)
       return :high if HIGH_SEVERITY_ERROR_TYPES.include?(error_type)
       return :medium if MEDIUM_SEVERITY_ERROR_TYPES.include?(error_type)
@@ -171,6 +205,143 @@ module RailsErrorDashboard
           .limit(limit)
     end
 
+    # Extract backtrace frames for similarity comparison
+    def backtrace_frames
+      return [] if backtrace.blank?
+
+      # Handle different backtrace formats
+      lines = if backtrace.is_a?(Array)
+        backtrace
+      elsif backtrace.is_a?(String)
+        # Check if it's a serialized array (starts with "[")
+        if backtrace.strip.start_with?("[")
+          # Try to parse as JSON array
+          begin
+            JSON.parse(backtrace)
+          rescue JSON::ParserError
+            # Fall back to newline split
+            backtrace.split("\n")
+          end
+        else
+          backtrace.split("\n")
+        end
+      else
+        []
+      end
+
+      lines.first(20).map do |line|
+        # Extract file path and method name, ignore line numbers
+        if line =~ %r{([^/]+\.rb):.*?in `(.+)'$}
+          "#{Regexp.last_match(1)}:#{Regexp.last_match(2)}"
+        elsif line =~ %r{([^/]+\.rb)}
+          Regexp.last_match(1)
+        end
+      end.compact.uniq
+    end
+
+    # Calculate backtrace signature for fast similarity matching
+    # Signature is a hash of the unique file paths in the backtrace
+    def calculate_backtrace_signature
+      frames = backtrace_frames
+      return nil if frames.empty?
+
+      # Create signature from sorted file paths (order-independent)
+      file_paths = frames.map { |frame| frame.split(":").first }.sort
+      Digest::SHA256.hexdigest(file_paths.join("|"))[0..15]
+    end
+
+    # Find similar errors using fuzzy matching
+    # @param threshold [Float] Minimum similarity score (0.0-1.0), default 0.6
+    # @param limit [Integer] Maximum results, default 10
+    # @return [Array<Hash>] Array of {error: ErrorLog, similarity: Float}
+    def similar_errors(threshold: 0.6, limit: 10)
+      return [] unless persisted?
+      return [] unless RailsErrorDashboard.configuration.enable_similar_errors
+      Queries::SimilarErrors.call(id, threshold: threshold, limit: limit)
+    end
+
+    # Find errors that occur together in time
+    # @param window_minutes [Integer] Time window in minutes (default: 5)
+    # @param min_frequency [Integer] Minimum co-occurrence count (default: 2)
+    # @param limit [Integer] Maximum results (default: 10)
+    # @return [Array<Hash>] Array of {error: ErrorLog, frequency: Integer, avg_delay_seconds: Float}
+    def co_occurring_errors(window_minutes: 5, min_frequency: 2, limit: 10)
+      return [] unless persisted?
+      return [] unless RailsErrorDashboard.configuration.enable_co_occurring_errors
+      return [] unless defined?(Queries::CoOccurringErrors)
+
+      Queries::CoOccurringErrors.call(
+        error_log_id: id,
+        window_minutes: window_minutes,
+        min_frequency: min_frequency,
+        limit: limit
+      )
+    end
+
+    # Find cascade patterns (what causes this error, what this error causes)
+    # @param min_probability [Float] Minimum cascade probability (0.0-1.0), default 0.5
+    # @return [Hash] {parents: Array, children: Array} of cascade patterns
+    def error_cascades(min_probability: 0.5)
+      return { parents: [], children: [] } unless persisted?
+      return { parents: [], children: [] } unless RailsErrorDashboard.configuration.enable_error_cascades
+      return { parents: [], children: [] } unless defined?(Queries::ErrorCascades)
+
+      Queries::ErrorCascades.call(error_id: id, min_probability: min_probability)
+    end
+
+    # Get baseline statistics for this error type
+    # @return [Hash] {hourly: ErrorBaseline, daily: ErrorBaseline, weekly: ErrorBaseline}
+    def baselines
+      return {} unless RailsErrorDashboard.configuration.enable_baseline_alerts
+      return {} unless defined?(Queries::BaselineStats)
+
+      Queries::BaselineStats.new(error_type, platform).all_baselines
+    end
+
+    # Check if this error is anomalous compared to baseline
+    # @param sensitivity [Integer] Standard deviations threshold (default: 2)
+    # @return [Hash] Anomaly check result
+    def baseline_anomaly(sensitivity: 2)
+      return { anomaly: false, message: "Feature disabled" } unless RailsErrorDashboard.configuration.enable_baseline_alerts
+      return { anomaly: false, message: "No baseline available" } unless defined?(Queries::BaselineStats)
+
+      # Get count of this error type today
+      today_count = ErrorLog.where(
+        error_type: error_type,
+        platform: platform
+      ).where("occurred_at >= ?", Time.current.beginning_of_day).count
+
+      Queries::BaselineStats.new(error_type, platform).check_anomaly(today_count, sensitivity: sensitivity)
+    end
+
+    # Detect cyclical occurrence patterns (daily/weekly rhythms)
+    # @param days [Integer] Number of days to analyze (default: 30)
+    # @return [Hash] Pattern analysis result
+    def occurrence_pattern(days: 30)
+      return {} unless RailsErrorDashboard.configuration.enable_occurrence_patterns
+      return {} unless defined?(Services::PatternDetector)
+
+      Services::PatternDetector.analyze_cyclical_pattern(
+        error_type: error_type,
+        platform: platform,
+        days: days
+      )
+    end
+
+    # Detect error bursts (many errors in short time)
+    # @param days [Integer] Number of days to analyze (default: 7)
+    # @return [Array<Hash>] Array of burst metadata
+    def error_bursts(days: 7)
+      return [] unless RailsErrorDashboard.configuration.enable_occurrence_patterns
+      return [] unless defined?(Services::PatternDetector)
+
+      Services::PatternDetector.detect_bursts(
+        error_type: error_type,
+        platform: platform,
+        days: days
+      )
+    end
+
     private
 
     # Override user association to use configured user model
@@ -181,5 +352,157 @@ module RailsErrorDashboard
       end
       super
     end
+
+    # Turbo Stream broadcasting methods
+    def broadcast_new_error
+      return unless defined?(Turbo)
+
+      platforms = ErrorLog.distinct.pluck(:platform).compact
+      show_platform = platforms.size > 1
+
+      Turbo::StreamsChannel.broadcast_prepend_to(
+        "error_list",
+        target: "error_list",
+        partial: "rails_error_dashboard/errors/error_row",
+        locals: { error: self, show_platform: show_platform }
+      )
+      broadcast_replace_stats
+    rescue => e
+      Rails.logger.error("Failed to broadcast new error: #{e.message}")
+    end
+
+    def broadcast_error_update
+      return unless defined?(Turbo)
+
+      platforms = ErrorLog.distinct.pluck(:platform).compact
+      show_platform = platforms.size > 1
+
+      Turbo::StreamsChannel.broadcast_replace_to(
+        "error_list",
+        target: "error_#{id}",
+        partial: "rails_error_dashboard/errors/error_row",
+        locals: { error: self, show_platform: show_platform }
+      )
+      broadcast_replace_stats
+    rescue => e
+      Rails.logger.error("Failed to broadcast error update: #{e.message}")
+    end
+
+    def broadcast_replace_stats
+      return unless defined?(Turbo)
+
+      stats = Queries::DashboardStats.call
+      Turbo::StreamsChannel.broadcast_replace_to(
+        "error_list",
+        target: "dashboard_stats",
+        partial: "rails_error_dashboard/errors/stats",
+        locals: { stats: stats }
+      )
+    rescue => e
+      Rails.logger.error("Failed to broadcast stats update: #{e.message}")
+    end
+
+    # Enhanced Metrics: Release/Version Tracking
+    def fetch_app_version
+      RailsErrorDashboard.configuration.app_version || ENV["APP_VERSION"] || detect_version_from_file
+    end
+
+    def fetch_git_sha
+      RailsErrorDashboard.configuration.git_sha || ENV["GIT_SHA"] || detect_git_sha
+    end
+
+    def detect_version_from_file
+      version_file = Rails.root.join("VERSION")
+      return File.read(version_file).strip if File.exist?(version_file)
+      nil
+    end
+
+    def detect_git_sha
+      return nil unless File.exist?(Rails.root.join(".git"))
+      `git rev-parse --short HEAD 2>/dev/null`.strip.presence
+    rescue => e
+      Rails.logger.debug("Could not detect git SHA: #{e.message}")
+      nil
+    end
+
+    # Enhanced Metrics: Smart Priority Scoring
+    # Score: 0-100 based on severity, frequency, recency, and user impact
+    def compute_priority_score
+      severity_score = severity_to_score(severity)
+      frequency_score = frequency_to_score(occurrence_count)
+      recency_score = recency_to_score(occurred_at)
+      user_impact_score = user_impact_to_score
+
+      # Weighted average
+      (severity_score * 0.4 + frequency_score * 0.25 + recency_score * 0.2 + user_impact_score * 0.15).round
+    end
+
+    def severity_to_score(sev)
+      case sev
+      when :critical then 100
+      when :high then 75
+      when :medium then 50
+      when :low then 25
+      else 10
+      end
+    end
+
+    def frequency_to_score(count)
+      # Logarithmic scale: 1 occurrence = 10, 10 = 50, 100 = 90, 1000+ = 100
+      return 10 if count <= 1
+      return 100 if count >= 1000
+
+      (10 + (Math.log10(count) * 30)).clamp(10, 100).round
+    end
+
+    def recency_to_score(time)
+      hours_ago = ((Time.current - time) / 1.hour).to_i
+      return 100 if hours_ago < 1      # Last hour = 100
+      return 80 if hours_ago < 24      # Last 24h = 80
+      return 50 if hours_ago < 168     # Last week = 50
+      return 20 if hours_ago < 720     # Last month = 20
+      10                                # Older = 10
+    end
+
+    def user_impact_to_score
+      return 0 unless user_id.present?
+
+      # Calculate what % of users are affected by this error type
+      total_users = unique_users_affected
+      return 0 if total_users.zero?
+
+      # Scale: 1 user = 10, 10 users = 50, 100+ users = 100
+      (10 + (Math.log10(total_users + 1) * 30)).clamp(0, 100).round
+    end
+
+    def unique_users_affected
+      ErrorLog.where(error_type: error_type, resolved: false)
+              .where.not(user_id: nil)
+              .distinct
+              .count(:user_id)
+    end
+
+    # Public method: Get user impact percentage
+    def user_impact_percentage
+      return 0 unless user_id.present?
+
+      affected_users = unique_users_affected
+      return 0 if affected_users.zero?
+
+      # Get total active users from config or estimate
+      total_users = RailsErrorDashboard.configuration.total_users_for_impact || estimate_total_users
+      return 0 if total_users.zero?
+
+      ((affected_users.to_f / total_users) * 100).round(1)
+    end
+
+    def estimate_total_users
+      # Estimate based on users who had any activity in last 30 days
+      if defined?(::User)
+        ::User.where("created_at >= ?", 30.days.ago).count
+      else
+        100 # Default fallback
+      end
+    end
   end
 end

data/app/models/rails_error_dashboard/error_occurrence.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Tracks individual occurrences of errors for co-occurrence analysis
+  #
+  # Each time an error is logged, we create an ErrorOccurrence record
+  # to track when it happened, who was affected, and what request caused it.
+  # This allows us to find errors that occur together in time windows.
+  class ErrorOccurrence < ErrorLogsRecord
+    self.table_name = "rails_error_dashboard_error_occurrences"
+
+    belongs_to :error_log, class_name: "RailsErrorDashboard::ErrorLog"
+
+    # Only define user association if User model exists
+    if defined?(::User)
+      belongs_to :user, optional: true
+    end
+
+    validates :occurred_at, presence: true
+    validates :error_log_id, presence: true
+
+    scope :recent, -> { order(occurred_at: :desc) }
+    scope :in_time_window, ->(start_time, end_time) { where(occurred_at: start_time..end_time) }
+    scope :for_user, ->(user_id) { where(user_id: user_id) }
+    scope :for_request, ->(request_id) { where(request_id: request_id) }
+    scope :for_session, ->(session_id) { where(session_id: session_id) }
+
+    # Find occurrences within a time window around this occurrence
+    # @param window_minutes [Integer] Time window in minutes (default: 5)
+    # @return [ActiveRecord::Relation] Other occurrences in the time window
+    def nearby_occurrences(window_minutes: 5)
+      window = window_minutes.minutes
+      start_time = occurred_at - window
+      end_time = occurred_at + window
+
+      self.class
+        .in_time_window(start_time, end_time)
+        .where.not(id: id) # Exclude self
+    end
+
+    # Find other error types that occurred near this occurrence
+    # @param window_minutes [Integer] Time window in minutes (default: 5)
+    # @return [ActiveRecord::Relation] ErrorLog records of co-occurring errors
+    def co_occurring_error_types(window_minutes: 5)
+      occurrence_ids = nearby_occurrences(window_minutes: window_minutes).pluck(:error_log_id)
+      ErrorLog.where(id: occurrence_ids).where.not(error_type: error_log.error_type).distinct
+    end
+  end
+end