rails_error_dashboard 0.1.0 → 0.1.3

data/app/models/rails_error_dashboard/error_comment.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Model: ErrorComment
+  # Represents a comment/note on an error for team collaboration
+  class ErrorComment < ErrorLogsRecord
+    self.table_name = "rails_error_dashboard_error_comments"
+
+    belongs_to :error_log, class_name: "RailsErrorDashboard::ErrorLog"
+
+    validates :author_name, presence: true, length: { maximum: 255 }
+    validates :body, presence: true, length: { maximum: 10_000 }
+
+    scope :recent_first, -> { order(created_at: :desc) }
+    scope :oldest_first, -> { order(created_at: :asc) }
+
+    # Get formatted timestamp for display
+    def formatted_time
+      created_at.strftime("%b %d, %Y at %I:%M %p")
+    end
+
+    # Check if comment was created recently (within last hour)
+    def recent?
+      created_at > 1.hour.ago
+    end
+  end
+end

data/app/models/rails_error_dashboard/error_log.rb

@@ -12,27 +12,55 @@ module RailsErrorDashboard
       belongs_to :user, optional: true
     end
 
+    # Association for tracking individual error occurrences
+    has_many :error_occurrences, class_name: "RailsErrorDashboard::ErrorOccurrence", dependent: :destroy
+
+    # Association for comment threads (Phase 3: Workflow Integration)
+    has_many :comments, class_name: "RailsErrorDashboard::ErrorComment", foreign_key: :error_log_id, 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) }
     scope :last_24_hours, -> { where("occurred_at >= ?", 24.hours.ago) }
     scope :last_week, -> { where("occurred_at >= ?", 1.week.ago) }
 
+    # Phase 3: Workflow Integration scopes
+    scope :active, -> { where("snoozed_until IS NULL OR snoozed_until < ?", Time.current) }
+    scope :snoozed, -> { where("snoozed_until IS NOT NULL AND snoozed_until >= ?", Time.current) }
+    scope :by_status, ->(status) { where(status: status) }
+    scope :assigned, -> { where.not(assigned_to: nil) }
+    scope :unassigned, -> { where(assigned_to: nil) }
+    scope :by_assignee, ->(name) { where(assigned_to: name) }
+    scope :by_priority, ->(level) { where(priority_level: level) }
+
     # 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 +71,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 +114,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)
@@ -145,6 +191,139 @@ module RailsErrorDashboard
       Commands::ResolveError.call(id, resolution_data)
     end
 
+    # Phase 3: Workflow Integration methods
+
+    # Assignment methods
+    def assign_to!(assignee_name)
+      update!(
+        assigned_to: assignee_name,
+        assigned_at: Time.current,
+        status: "in_progress" # Auto-transition to in_progress when assigned
+      )
+    end
+
+    def unassign!
+      update!(
+        assigned_to: nil,
+        assigned_at: nil
+      )
+    end
+
+    def assigned?
+      assigned_to.present?
+    end
+
+    # Snooze methods
+    def snooze!(hours, reason: nil)
+      snooze_until = hours.hours.from_now
+      # Store snooze reason in comments if provided
+      if reason.present?
+        comments.create!(
+          author_name: assigned_to || "System",
+          body: "Snoozed for #{hours} hours: #{reason}"
+        )
+      end
+      update!(snoozed_until: snooze_until)
+    end
+
+    def unsnooze!
+      update!(snoozed_until: nil)
+    end
+
+    def snoozed?
+      snoozed_until.present? && snoozed_until >= Time.current
+    end
+
+    # Priority methods
+    def priority_label
+      case priority_level
+      when 3 then "Critical"
+      when 2 then "High"
+      when 1 then "Medium"
+      when 0 then "Low"
+      else "Unset"
+      end
+    end
+
+    def priority_color
+      case priority_level
+      when 3 then "danger"    # Critical = red
+      when 2 then "warning"   # High = orange
+      when 1 then "info"      # Medium = blue
+      when 0 then "secondary" # Low = gray
+      else "light"
+      end
+    end
+
+    def calculate_priority
+      # Automatic priority calculation based on severity and frequency
+      severity_weight = case severity
+      when :critical then 3
+      when :high then 2
+      when :medium then 1
+      else 0
+      end
+
+      frequency_weight = if occurrence_count >= 100
+        3
+      elsif occurrence_count >= 10
+        2
+      elsif occurrence_count >= 5
+        1
+      else
+        0
+      end
+
+      # Take the higher of severity or frequency
+      [ severity_weight, frequency_weight ].max
+    end
+
+    # Status transition methods
+    def status_badge_color
+      case status
+      when "new" then "primary"
+      when "in_progress" then "info"
+      when "investigating" then "warning"
+      when "resolved" then "success"
+      when "wont_fix" then "secondary"
+      else "light"
+      end
+    end
+
+    def can_transition_to?(new_status)
+      # Define valid status transitions
+      valid_transitions = {
+        "new" => [ "in_progress", "investigating", "wont_fix" ],
+        "in_progress" => [ "investigating", "resolved", "new" ],
+        "investigating" => [ "resolved", "in_progress", "wont_fix" ],
+        "resolved" => [ "new" ], # Can reopen if error recurs
+        "wont_fix" => [ "new" ]  # Can reopen
+      }
+
+      valid_transitions[status]&.include?(new_status) || false
+    end
+
+    def update_status!(new_status, comment: nil)
+      return false unless can_transition_to?(new_status)
+
+      transaction do
+        update!(status: new_status)
+
+        # Auto-resolve if status is "resolved"
+        update!(resolved: true) if new_status == "resolved"
+
+        # Add comment about status change
+        if comment.present?
+          comments.create!(
+            author_name: assigned_to || "System",
+            body: "Status changed to #{new_status}: #{comment}"
+          )
+        end
+      end
+
+      true
+    end
+
     # Get error statistics
     def self.statistics(days = 7)
       start_date = days.days.ago
@@ -171,6 +350,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 +497,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