rails_error_dashboard 0.1.1 → 0.1.4

data/lib/rails_error_dashboard/queries/dashboard_stats.rb

@@ -22,7 +22,15 @@ module RailsErrorDashboard
           errors_trend_7d: errors_trend_7d,
           errors_by_severity_7d: errors_by_severity_7d,
           spike_detected: spike_detected?,
-          spike_info: spike_info
+          spike_info: spike_info,
+          # New metrics for Overview dashboard
+          error_rate: error_rate,
+          affected_users_today: affected_users_today,
+          affected_users_yesterday: affected_users_yesterday,
+          affected_users_change: affected_users_change,
+          trend_percentage: trend_percentage,
+          trend_direction: trend_direction,
+          top_errors_by_impact: top_errors_by_impact
         }
       end
 
@@ -164,6 +172,106 @@ module RailsErrorDashboard
           :critical
         end
       end
+
+      # Calculate error rate as a percentage
+      # Since we don't track total requests, we'll use error count as proxy
+      # In the future, this could be: (errors / total_requests) * 100
+      def error_rate
+        today_errors = ErrorLog.where("occurred_at >= ?", Time.current.beginning_of_day).count
+        return 0.0 if today_errors.zero?
+
+        # For now, use a simple heuristic: errors per hour today
+        # Assume we want < 1 error per hour = good (< 1%)
+        # 1-5 errors per hour = warning (1-5%)
+        # > 5 errors per hour = critical (> 5%)
+        hours_today = ((Time.current - Time.current.beginning_of_day) / 1.hour).round(1)
+        hours_today = 1.0 if hours_today < 1.0 # Avoid division by zero in early morning
+
+        errors_per_hour = today_errors / hours_today
+        # Convert to percentage scale (0-100)
+        # Scale: 0 errors/hr = 0%, 1 error/hr = 1%, 10 errors/hr = 10%, etc.
+        [ errors_per_hour, 100.0 ].min.round(1)
+      end
+
+      # Count distinct users affected by errors today
+      def affected_users_today
+        ErrorLog.where("occurred_at >= ?", Time.current.beginning_of_day)
+                .where.not(user_id: nil)
+                .distinct
+                .count(:user_id)
+      end
+
+      # Count distinct users affected by errors yesterday
+      def affected_users_yesterday
+        ErrorLog.where("occurred_at >= ? AND occurred_at < ?",
+                      1.day.ago.beginning_of_day,
+                      Time.current.beginning_of_day)
+                .where.not(user_id: nil)
+                .distinct
+                .count(:user_id)
+      end
+
+      # Calculate change in affected users (today vs yesterday)
+      def affected_users_change
+        today = affected_users_today
+        yesterday = affected_users_yesterday
+
+        return 0 if today.zero? && yesterday.zero?
+        return today if yesterday.zero?
+
+        today - yesterday
+      end
+
+      # Calculate percentage change in errors (today vs yesterday)
+      def trend_percentage
+        today = ErrorLog.where("occurred_at >= ?", Time.current.beginning_of_day).count
+        yesterday = ErrorLog.where("occurred_at >= ? AND occurred_at < ?",
+                                  1.day.ago.beginning_of_day,
+                                  Time.current.beginning_of_day).count
+
+        return 0.0 if today.zero? && yesterday.zero?
+        return 100.0 if yesterday.zero? && today.positive?
+
+        ((today - yesterday).to_f / yesterday * 100).round(1)
+      end
+
+      # Determine trend direction (increasing, decreasing, stable)
+      def trend_direction
+        trend = trend_percentage
+
+        if trend > 10
+          :increasing
+        elsif trend < -10
+          :decreasing
+        else
+          :stable
+        end
+      end
+
+      # Get top 5 errors ranked by impact score
+      # Impact = affected_users_count × occurrence_count
+      def top_errors_by_impact
+        ErrorLog.where("occurred_at >= ?", 7.days.ago)
+                .group(:error_type, :id)
+                .select("error_type, id, occurrence_count,
+                        COUNT(DISTINCT user_id) as affected_users,
+                        COUNT(DISTINCT user_id) * occurrence_count as impact_score")
+                .order("impact_score DESC")
+                .limit(5)
+                .map do |error|
+                  full_error = ErrorLog.find(error.id)
+                  {
+                    id: error.id,
+                    error_type: error.error_type,
+                    message: full_error.message&.truncate(80),
+                    severity: full_error.severity,
+                    occurrence_count: error.occurrence_count,
+                    affected_users: error.affected_users.to_i,
+                    impact_score: error.impact_score.to_i,
+                    occurred_at: full_error.occurred_at
+                  }
+                end
+      end
     end
   end
 end

data/lib/rails_error_dashboard/queries/errors_list.rb

@@ -14,10 +14,11 @@ module RailsErrorDashboard
       end
 
       def call
-        query = ErrorLog.order(occurred_at: :desc)
+        query = ErrorLog
         # Only eager load user if User model exists
         query = query.includes(:user) if defined?(::User)
         query = apply_filters(query)
+        query = apply_sorting(query)
         query
       end
 
@@ -29,6 +30,13 @@ module RailsErrorDashboard
         query = filter_by_platform(query)
         query = filter_by_search(query)
         query = filter_by_severity(query)
+        query = filter_by_timeframe(query)
+        query = filter_by_frequency(query)
+        # Phase 3: Workflow filters
+        query = filter_by_status(query)
+        query = filter_by_assignment(query)
+        query = filter_by_priority(query)
+        query = filter_by_snoozed(query)
         query
       end
 
@@ -39,14 +47,23 @@ module RailsErrorDashboard
       end
 
       def filter_by_resolved(query)
-        # Default to unresolved only if no explicit filter is set
-        # If unresolved param is explicitly false (boolean, string, or "0"), show all errors
-        # Otherwise, default to showing only unresolved errors
-        if @filters[:unresolved] == false || @filters[:unresolved] == "false" || @filters[:unresolved] == "0"
-          # Show all errors (resolved and unresolved)
+        # Handle unresolved filter with explicit true/false values
+        # When checkbox is unchecked: unresolved=false → show all errors
+        # When checkbox is checked: unresolved=true → show only unresolved errors
+        # When no filter: nil → default to unresolved only
+
+        case @filters[:unresolved]
+        when false, "false", "0"
+          # Explicitly show all errors (resolved and unresolved)
           query
+        when true, "true", "1"
+          # Explicitly show only unresolved errors
+          query.unresolved
+        when nil, ""
+          # Default: show only unresolved errors when no filter is set
+          query.unresolved
         else
-          # Default: show only unresolved errors
+          # Fallback: show only unresolved errors
           query.unresolved
         end
       end
@@ -102,6 +119,116 @@ module RailsErrorDashboard
 
         query.where(error_type: error_types)
       end
+
+      # Phase 3: Workflow filter methods
+
+      def filter_by_status(query)
+        return query unless @filters[:status].present?
+        return query unless ErrorLog.column_names.include?("status")
+
+        query.by_status(@filters[:status])
+      end
+
+      def filter_by_assignment(query)
+        return query unless @filters[:assigned_to].present?
+        return query unless 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])
+        end
+      end
+
+      def filter_by_priority(query)
+        return query unless @filters[:priority_level].present?
+        return query unless ErrorLog.column_names.include?("priority_level")
+
+        query.by_priority(@filters[:priority_level])
+      end
+
+      def filter_by_snoozed(query)
+        return query unless ErrorLog.column_names.include?("snoozed_until")
+
+        # If hide_snoozed is checked, exclude snoozed errors
+        if @filters[:hide_snoozed] == "1" || @filters[:hide_snoozed] == true
+          query.active
+        else
+          query
+        end
+      end
+
+      def filter_by_timeframe(query)
+        return query unless @filters[:timeframe].present?
+
+        case @filters[:timeframe]
+        when "last_hour"
+          query.where("occurred_at >= ?", 1.hour.ago)
+        when "today"
+          query.where("occurred_at >= ?", Time.current.beginning_of_day)
+        when "yesterday"
+          query.where("occurred_at BETWEEN ? AND ?",
+                      1.day.ago.beginning_of_day,
+                      1.day.ago.end_of_day)
+        when "last_7_days"
+          query.where("occurred_at >= ?", 7.days.ago)
+        when "last_30_days"
+          query.where("occurred_at >= ?", 30.days.ago)
+        when "last_90_days"
+          query.where("occurred_at >= ?", 90.days.ago)
+        else
+          query
+        end
+      end
+
+      def filter_by_frequency(query)
+        return query unless @filters[:frequency].present?
+
+        case @filters[:frequency]
+        when "once"
+          query.where(occurrence_count: 1)
+        when "few"
+          query.where("occurrence_count BETWEEN ? AND ?", 2, 9)
+        when "frequent"
+          query.where("occurrence_count BETWEEN ? AND ?", 10, 99)
+        when "very_frequent"
+          query.where("occurrence_count >= ?", 100)
+        when "recurring"
+          # Errors that occurred multiple times AND are still active
+          query.where("occurrence_count > ?", 5)
+               .where("last_seen_at > ?", 24.hours.ago)
+        else
+          query
+        end
+      end
+
+      def apply_sorting(query)
+        sort_column = @filters[:sort_by].presence || "occurred_at"
+        sort_direction = @filters[:sort_direction].presence || "desc"
+
+        # Validate sort direction
+        sort_direction = %w[asc desc].include?(sort_direction) ? sort_direction : "desc"
+
+        # Map severity to priority for sorting (since severity is an enum/method)
+        # We'll use priority_score which factors in severity
+        case sort_column
+        when "occurred_at", "first_seen_at", "last_seen_at", "created_at", "resolved_at"
+          query.order(sort_column => sort_direction)
+        when "occurrence_count", "priority_score"
+          query.order(sort_column => sort_direction, occurred_at: :desc)
+        when "error_type", "platform", "app_version"
+          query.order(sort_column => sort_direction, occurred_at: :desc)
+        when "severity"
+          # Sort by priority_score as proxy for severity (critical=highest score)
+          query.order(priority_score: sort_direction, occurred_at: :desc)
+        else
+          # Default sort
+          query.order(occurred_at: :desc)
+        end
+      end
     end
   end
 end

data/lib/rails_error_dashboard/queries/mttr_stats.rb

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

data/lib/rails_error_dashboard/queries/recurring_issues.rb

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

data/lib/rails_error_dashboard/services/backtrace_parser.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Service: Parse and categorize backtrace frames
+    # Filters out framework noise to show only relevant application code
+    class BacktraceParser
+      # Match both formats:
+      # /path/file.rb:123:in `method'
+      # /path/file.rb:123:in 'ClassName#method'
+      FRAME_PATTERN = %r{^(.+):(\d+)(?::in [`'](.+)['`])?$}
+
+      def self.parse(backtrace_string)
+        new(backtrace_string).parse
+      end
+
+      def initialize(backtrace_string)
+        @backtrace_string = backtrace_string
+      end
+
+      def parse
+        return [] if @backtrace_string.blank?
+
+        lines = @backtrace_string.split("\n")
+        lines.map.with_index do |line, index|
+          parse_frame(line.strip, index)
+        end.compact
+      end
+
+      private
+
+      def parse_frame(line, index)
+        match = line.match(FRAME_PATTERN)
+        return nil unless match
+
+        file_path = match[1]
+        line_number = match[2].to_i
+        method_name = match[3] || "(unknown)"
+
+        {
+          index: index,
+          file_path: file_path,
+          line_number: line_number,
+          method_name: method_name,
+          category: categorize_frame(file_path),
+          full_line: line,
+          short_path: shorten_path(file_path)
+        }
+      end
+
+      def categorize_frame(file_path)
+        # Application code (highest priority)
+        return :app if app_code?(file_path)
+
+        # Gem code (dependencies)
+        return :gem if gem_code?(file_path)
+
+        # Rails framework
+        return :framework if rails_code?(file_path)
+
+        # Ruby core/stdlib
+        :ruby_core
+      end
+
+      def app_code?(file_path)
+        # Match /app/, /lib/ directories in the application
+        file_path.include?("/app/") ||
+          (file_path.include?("/lib/") && !file_path.include?("/gems/") && !file_path.include?("/ruby/"))
+      end
+
+      def gem_code?(file_path)
+        file_path.include?("/gems/") ||
+          file_path.include?("/bundler/gems/") ||
+          file_path.include?("/vendor/bundle/")
+      end
+
+      def rails_code?(file_path)
+        file_path.include?("/railties-") ||
+          file_path.include?("/actionpack-") ||
+          file_path.include?("/actionview-") ||
+          file_path.include?("/activerecord-") ||
+          file_path.include?("/activesupport-") ||
+          file_path.include?("/actioncable-") ||
+          file_path.include?("/activejob-") ||
+          file_path.include?("/actionmailer-") ||
+          file_path.include?("/activestorage-") ||
+          file_path.include?("/actionmailbox-") ||
+          file_path.include?("/actiontext-") ||
+          file_path.include?("/rails-")
+      end
+
+      def shorten_path(file_path)
+        # Remove gem version numbers and long paths
+        # /Users/.../.gem/ruby/3.4.0/gems/activerecord-8.0.4/lib/... → activerecord/.../file.rb
+        if file_path.include?("/gems/")
+          parts = file_path.split("/gems/").last
+          gem_and_path = parts.split("/", 2)
+          gem_name = gem_and_path.first.split("-").first # Remove version
+          path_in_gem = gem_and_path.last
+          "#{gem_name}/#{path_in_gem}"
+        # /path/to/app/controllers/... → app/controllers/...
+        elsif file_path.include?("/app/")
+          file_path.split("/app/").last.prepend("app/")
+        elsif file_path.include?("/lib/") && !file_path.include?("/ruby/")
+          file_path.split("/lib/").last.prepend("lib/")
+        else
+          # Just show filename for Ruby core
+          File.basename(file_path)
+        end
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/version.rb

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

data/lib/rails_error_dashboard.rb

@@ -1,16 +1,19 @@
 require "rails_error_dashboard/version"
 require "rails_error_dashboard/engine"
 require "rails_error_dashboard/configuration"
+require "rails_error_dashboard/logger"
 
 # External dependencies
 require "pagy"
 require "browser"
 require "groupdate"
 require "httparty"
+require "chartkick"
 
 # Core library files
 require "rails_error_dashboard/value_objects/error_context"
 require "rails_error_dashboard/services/platform_detector"
+require "rails_error_dashboard/services/backtrace_parser"
 require "rails_error_dashboard/services/similarity_calculator"
 require "rails_error_dashboard/services/cascade_detector"
 require "rails_error_dashboard/services/baseline_calculator"
@@ -30,6 +33,8 @@ require "rails_error_dashboard/queries/dashboard_stats"
 require "rails_error_dashboard/queries/analytics_stats"
 require "rails_error_dashboard/queries/filter_options"
 require "rails_error_dashboard/queries/similar_errors"
+require "rails_error_dashboard/queries/recurring_issues"
+require "rails_error_dashboard/queries/mttr_stats"
 require "rails_error_dashboard/error_reporter"
 require "rails_error_dashboard/middleware/error_catcher"