rails_error_dashboard 0.1.1 → 0.1.4

data/app/controllers/rails_error_dashboard/errors_controller.rb

@@ -6,6 +6,30 @@ module RailsErrorDashboard
 
     before_action :authenticate_dashboard_user!
 
+    def overview
+      # Get dashboard stats using Query
+      @stats = Queries::DashboardStats.call
+
+      # Get platform health summary (if enabled)
+      if RailsErrorDashboard.configuration.enable_platform_comparison
+        comparison = Queries::PlatformComparison.new(days: 7)
+        @platform_health = comparison.platform_health_summary
+        @platform_scores = comparison.platform_stability_scores
+      else
+        @platform_health = {}
+        @platform_scores = {}
+      end
+
+      # Get critical alerts (critical/high severity errors from last hour)
+      @critical_alerts = ErrorLog
+        .where("occurred_at >= ?", 1.hour.ago)
+        .where(resolved_at: nil)
+        .select { |error| [ :critical, :high ].include?(error.severity) }
+        .sort_by(&:occurred_at)
+        .reverse
+        .first(10)
+    end
+
     def index
       # Use Query to get filtered errors
       errors_query = Queries::ErrorsList.call(filter_params)
@@ -42,6 +66,70 @@ module RailsErrorDashboard
       redirect_to error_path(@error)
     end
 
+    # Phase 3: Workflow Integration Actions
+
+    def assign
+      @error = ErrorLog.find(params[:id])
+      @error.assign_to!(params[:assigned_to])
+      redirect_to error_path(@error)
+    rescue => e
+      redirect_to error_path(@error)
+    end
+
+    def unassign
+      @error = ErrorLog.find(params[:id])
+      @error.unassign!
+      redirect_to error_path(@error)
+    rescue => e
+      redirect_to error_path(@error)
+    end
+
+    def update_priority
+      @error = ErrorLog.find(params[:id])
+      @error.update!(priority_level: params[:priority_level])
+      redirect_to error_path(@error)
+    rescue => e
+      redirect_to error_path(@error)
+    end
+
+    def snooze
+      @error = ErrorLog.find(params[:id])
+      @error.snooze!(params[:hours].to_i, reason: params[:reason])
+      redirect_to error_path(@error)
+    rescue => e
+      redirect_to error_path(@error)
+    end
+
+    def unsnooze
+      @error = ErrorLog.find(params[:id])
+      @error.unsnooze!
+      redirect_to error_path(@error)
+    rescue => e
+      redirect_to error_path(@error)
+    end
+
+    def update_status
+      @error = ErrorLog.find(params[:id])
+      if @error.update_status!(params[:status], comment: params[:comment])
+        redirect_to error_path(@error)
+      else
+        redirect_to error_path(@error)
+      end
+    rescue => e
+      redirect_to error_path(@error)
+    end
+
+    def add_comment
+      @error = ErrorLog.find(params[:id])
+      @error.comments.create!(
+        author_name: params[:author_name],
+        body: params[:body]
+      )
+      redirect_to error_path(@error)
+    rescue => e
+      redirect_to error_path(@error)
+    end
+
     def analytics
       days = (params[:days] || 30).to_i
       @days = days
@@ -58,6 +146,22 @@ module RailsErrorDashboard
       @resolution_rate = analytics[:resolution_rate]
       @mobile_errors = analytics[:mobile_errors]
       @api_errors = analytics[:api_errors]
+
+      # Get recurring issues data
+      recurring = Queries::RecurringIssues.call(days)
+      @recurring_data = recurring
+
+      # Get release correlation data
+      correlation = Queries::ErrorCorrelation.new(days: days)
+      @errors_by_version = correlation.errors_by_version
+      @problematic_releases = correlation.problematic_releases
+      @release_comparison = calculate_release_comparison
+
+      # Get MTTR data
+      mttr_data = Queries::MttrStats.call(days)
+      @mttr_stats = mttr_data
+      @overall_mttr = mttr_data[:overall_mttr]
+      @mttr_by_platform = mttr_data[:mttr_by_platform]
     end
 
     def platform_comparison
@@ -133,13 +237,43 @@ module RailsErrorDashboard
 
     private
 
+    def calculate_release_comparison
+      return {} if @errors_by_version.empty? || @errors_by_version.count < 2
+
+      versions_sorted = @errors_by_version.sort_by { |_, data| data[:last_seen] || Time.at(0) }.reverse
+      latest = versions_sorted.first
+      previous = versions_sorted.second
+
+      return {} if latest.nil? || previous.nil?
+
+      {
+        latest_version: latest[0],
+        latest_count: latest[1][:count],
+        latest_critical: latest[1][:critical_count],
+        previous_version: previous[0],
+        previous_count: previous[1][:count],
+        previous_critical: previous[1][:critical_count],
+        change_percentage: previous[1][:count] > 0 ? ((latest[1][:count] - previous[1][:count]).to_f / previous[1][:count] * 100).round(1) : 0.0
+      }
+    end
+
     def filter_params
       {
         error_type: params[:error_type],
         unresolved: params[:unresolved],
         platform: params[:platform],
         search: params[:search],
-        severity: params[:severity]
+        severity: params[:severity],
+        timeframe: params[:timeframe],
+        frequency: params[:frequency],
+        # Phase 3: Workflow filter params
+        status: params[:status],
+        assigned_to: params[:assigned_to],
+        priority_level: params[:priority_level],
+        hide_snoozed: params[:hide_snoozed],
+        # Sorting params
+        sort_by: params[:sort_by],
+        sort_direction: params[:sort_direction]
       }
     end
 

data/app/helpers/rails_error_dashboard/application_helper.rb

@@ -1,21 +1,97 @@
 module RailsErrorDashboard
   module ApplicationHelper
     # Returns Bootstrap color class for error severity
+    # Uses Catppuccin Mocha colors in dark theme via CSS variables
     # @param severity [Symbol] The severity level (:critical, :high, :medium, :low, :info)
     # @return [String] Bootstrap color class (danger, warning, info, secondary)
     def severity_color(severity)
       case severity&.to_sym
       when :critical
-        "danger"
+        "danger"   # Maps to --ctp-red in dark mode
       when :high
-        "warning"
+        "warning"  # Maps to --ctp-peach in dark mode
       when :medium
-        "info"
+        "info"     # Maps to --ctp-blue in dark mode
       when :low
-        "secondary"
+        "secondary" # Maps to --ctp-overlay1 in dark mode
       else
         "secondary"
       end
     end
+
+    # Returns CSS variable for severity color (for inline styles)
+    # Useful when you need to set background-color or color directly
+    # @param severity [Symbol] The severity level
+    # @return [String] CSS variable reference
+    def severity_color_var(severity)
+      case severity&.to_sym
+      when :critical
+        "var(--ctp-red)"
+      when :high
+        "var(--ctp-peach)"
+      when :medium
+        "var(--ctp-blue)"
+      when :low
+        "var(--ctp-overlay1)"
+      else
+        "var(--ctp-overlay1)"
+      end
+    end
+
+    # Returns platform-specific color class
+    # @param platform [String] Platform name (ios, android, web, api)
+    # @return [String] CSS color variable
+    def platform_color_var(platform)
+      case platform&.downcase
+      when "ios"
+        "var(--platform-ios)"
+      when "android"
+        "var(--platform-android)"
+      when "web"
+        "var(--platform-web)"
+      when "api"
+        "var(--platform-api)"
+      else
+        "var(--text-color)"
+      end
+    end
+
+    # Returns the current user name for filtering "My Errors"
+    # Uses configured dashboard username or system username
+    # @return [String] Current user identifier
+    def current_user_name
+      RailsErrorDashboard.configuration.dashboard_username || ENV["USER"] || "unknown"
+    end
+
+    # Generates a sortable column header link
+    # @param label [String] The column label to display
+    # @param column [String] The column name to sort by
+    # @return [String] HTML safe link with sort indicator
+    def sortable_header(label, column)
+      current_sort = params[:sort_by]
+      current_direction = params[:sort_direction] || "desc"
+
+      # Determine new direction: if clicking same column, toggle; otherwise default to desc
+      new_direction = if current_sort == column
+        current_direction == "asc" ? "desc" : "asc"
+      else
+        "desc"
+      end
+
+      # Choose icon based on current state
+      icon = if current_sort == column
+        current_direction == "asc" ? "▲" : "▼"
+      else
+        "⇅"  # Unsorted indicator
+      end
+
+      # Preserve existing filter params while adding sort params
+      link_params = params.permit!.to_h.merge(sort_by: column, sort_direction: new_direction)
+
+      link_to errors_path(link_params), class: "text-decoration-none" do
+        content_tag(:span, "#{label} ", class: current_sort == column ? "fw-bold" : "") +
+        content_tag(:span, icon, class: "text-muted small")
+      end
+    end
   end
 end

data/app/helpers/rails_error_dashboard/backtrace_helper.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module BacktraceHelper
+    # Parse backtrace string into structured frames
+    def parse_backtrace(backtrace_string)
+      Services::BacktraceParser.parse(backtrace_string)
+    end
+
+    # Filter to show only application code
+    def filter_app_code(frames)
+      frames.select { |f| f[:category] == :app }
+    end
+
+    # Filter to show framework/gem code
+    def filter_framework_code(frames)
+      frames.reject { |f| f[:category] == :app }
+    end
+
+    # Get icon for frame category
+    def frame_icon(category)
+      case category
+      when :app
+        '<i class="bi bi-code-square text-success"></i>'.html_safe
+      when :gem
+        '<i class="bi bi-box text-info"></i>'.html_safe
+      when :framework
+        '<i class="bi bi-gear text-warning"></i>'.html_safe
+      when :ruby_core
+        '<i class="bi bi-gem text-secondary"></i>'.html_safe
+      else
+        '<i class="bi bi-question-circle text-muted"></i>'.html_safe
+      end
+    end
+
+    # Get color class for frame category
+    def frame_color_class(category)
+      case category
+      when :app
+        "text-success fw-bold"
+      when :gem
+        "text-info"
+      when :framework
+        "text-warning"
+      when :ruby_core
+        "text-secondary"
+      else
+        "text-muted"
+      end
+    end
+
+    # Get background color class for frame
+    # Uses Catppuccin-themed backtrace frame classes from _components.scss
+    def frame_bg_class(category)
+      case category
+      when :app
+        "backtrace-frame frame-app"
+      when :gem
+        "backtrace-frame frame-gem"
+      when :framework
+        "backtrace-frame frame-framework"
+      when :ruby_core
+        "backtrace-frame frame-ruby-core"
+      else
+        ""
+      end
+    end
+
+    # Format category name
+    def frame_category_name(category)
+      case category
+      when :app
+        "Your Code"
+      when :gem
+        "Gem"
+      when :framework
+        "Rails Framework"
+      when :ruby_core
+        "Ruby Core"
+      else
+        "Unknown"
+      end
+    end
+
+    # Count frames by category
+    def frame_count_by_category(frames)
+      frames.group_by { |f| f[:category] }
+            .transform_values(&:count)
+    end
+  end
+end

data/app/helpers/rails_error_dashboard/overview_helper.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module OverviewHelper
+    # All helper methods return Bootstrap semantic classes (success, warning, danger)
+    # These automatically map to Catppuccin Mocha colors in dark theme via CSS variables:
+    # - success → --ctp-green
+    # - warning → --ctp-peach
+    # - danger → --ctp-red
+    def error_rate_border_class(rate)
+      return "border-success" if rate < 1.0
+      return "border-warning" if rate < 5.0
+      "border-danger"
+    end
+
+    def error_rate_text_class(rate)
+      return "text-success" if rate < 1.0
+      return "text-warning" if rate < 5.0
+      "text-danger"
+    end
+
+    def trend_arrow(value)
+      return "→" if value.zero?
+      value > 0 ? "↑" : "↓"
+    end
+
+    def trend_color_class(value)
+      return "text-muted" if value.zero?
+      value > 0 ? "text-danger" : "text-success"
+    end
+
+    def trend_text(direction)
+      case direction
+      when :increasing
+        "Increasing"
+      when :decreasing
+        "Decreasing"
+      else
+        "Stable"
+      end
+    end
+
+    def severity_icon(severity)
+      case severity
+      when :critical
+        "🔴"
+      when :high
+        "🟠"
+      when :medium
+        "🟡"
+      else
+        "⚪"
+      end
+    end
+
+    def health_status_color(status)
+      case status
+      when :healthy
+        "success"
+      when :warning
+        "warning"
+      else
+        "danger"
+      end
+    end
+
+    def health_status_text(status)
+      case status
+      when :healthy
+        "✅ Healthy"
+      when :warning
+        "⚠️ Warning"
+      else
+        "🔴 Critical"
+      end
+    end
+  end
+end

data/app/helpers/rails_error_dashboard/user_agent_helper.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module UserAgentHelper
+    # Parse user agent string into browser, OS, and device info
+    def parse_user_agent(user_agent_string)
+      return default_user_agent_info if user_agent_string.blank?
+
+      browser = Browser.new(user_agent_string)
+
+      {
+        browser_name: browser_name(browser),
+        browser_version: browser.version,
+        os_name: os_name(browser),
+        device_type: device_type(browser),
+        platform: browser.platform.to_s.titleize,
+        is_mobile: browser.device.mobile?,
+        is_tablet: browser.device.tablet?,
+        is_bot: browser.bot?
+      }
+    rescue StandardError => e
+      Rails.logger.warn "[RailsErrorDashboard] Failed to parse user agent: #{e.message}"
+      default_user_agent_info
+    end
+
+    # Get browser icon based on browser name
+    def browser_icon(browser_info)
+      return '<i class="bi bi-question-circle text-muted"></i>'.html_safe if browser_info.blank?
+
+      case browser_info[:browser_name]&.downcase
+      when "chrome"
+        '<i class="bi bi-browser-chrome text-warning"></i>'.html_safe
+      when "firefox"
+        '<i class="bi bi-browser-firefox text-danger"></i>'.html_safe
+      when "safari"
+        '<i class="bi bi-browser-safari text-primary"></i>'.html_safe
+      when "edge"
+        '<i class="bi bi-browser-edge text-info"></i>'.html_safe
+      else
+        '<i class="bi bi-globe text-secondary"></i>'.html_safe
+      end
+    end
+
+    # Get OS icon based on OS name
+    def os_icon(browser_info)
+      return '<i class="bi bi-question-circle text-muted"></i>'.html_safe if browser_info.blank?
+
+      case browser_info[:os_name]&.downcase
+      when /windows/
+        '<i class="bi bi-windows text-primary"></i>'.html_safe
+      when /mac|darwin/
+        '<i class="bi bi-apple text-secondary"></i>'.html_safe
+      when /linux/
+        '<i class="bi bi-ubuntu text-danger"></i>'.html_safe
+      when /android/
+        '<i class="bi bi-android2 text-success"></i>'.html_safe
+      when /ios|iphone|ipad/
+        '<i class="bi bi-apple text-secondary"></i>'.html_safe
+      else
+        '<i class="bi bi-cpu text-muted"></i>'.html_safe
+      end
+    end
+
+    # Get device icon based on device type
+    def device_icon(browser_info)
+      return '<i class="bi bi-question-circle text-muted"></i>'.html_safe if browser_info.blank?
+
+      if browser_info[:is_mobile]
+        '<i class="bi bi-phone text-success"></i>'.html_safe
+      elsif browser_info[:is_tablet]
+        '<i class="bi bi-tablet text-info"></i>'.html_safe
+      else
+        '<i class="bi bi-laptop text-secondary"></i>'.html_safe
+      end
+    end
+
+    private
+
+    def browser_name(browser)
+      return "Chrome" if browser.chrome?
+      return "Firefox" if browser.firefox?
+      return "Safari" if browser.safari?
+      return "Edge" if browser.edge?
+      return "Opera" if browser.opera?
+      return "Internet Explorer" if browser.ie?
+      "Unknown"
+    end
+
+    def os_name(browser)
+      return "Windows" if browser.platform.windows?
+      return "macOS" if browser.platform.mac?
+      return "Linux" if browser.platform.linux?
+      return "Android" if browser.platform.android?
+      return "iOS" if browser.platform.ios?
+      "Unknown"
+    end
+
+    def device_type(browser)
+      return "Mobile" if browser.device.mobile?
+      return "Tablet" if browser.device.tablet?
+      return "Bot" if browser.bot?
+      "Desktop"
+    end
+
+    def default_user_agent_info
+      {
+        browser_name: "Unknown",
+        browser_version: nil,
+        os_name: "Unknown",
+        device_type: "Unknown",
+        platform: "Unknown",
+        is_mobile: false,
+        is_tablet: false,
+        is_bot: false
+      }
+    end
+  end
+end

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