rails_error_dashboard 0.1.0 → 0.1.3

data/lib/rails_error_dashboard/queries/platform_comparison.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query object for comparing error metrics across platforms
+    #
+    # Provides analytics comparing iOS vs Android vs API vs Web platforms:
+    # - Error rates and trends
+    # - Severity distribution
+    # - Resolution times
+    # - Top errors per platform
+    # - Platform stability scores
+    # - Cross-platform errors
+    #
+    # @example
+    #   comparison = PlatformComparison.new(days: 7)
+    #   comparison.error_rate_by_platform
+    #   # => { "ios" => 150, "android" => 200, "api" => 50, "web" => 100 }
+    class PlatformComparison
+      attr_reader :days
+
+      # @param days [Integer] Number of days to analyze (default: 7)
+      def initialize(days: 7)
+        @days = days
+        @start_date = days.days.ago
+      end
+
+      # Get error count by platform for the time period
+      # @return [Hash] Platform name => error count
+      def error_rate_by_platform
+        ErrorLog
+          .where("occurred_at >= ?", @start_date)
+          .group(:platform)
+          .count
+      end
+
+      # Get severity distribution by platform
+      # @return [Hash] Platform => { severity => count }
+      def severity_distribution_by_platform
+        platforms = ErrorLog.distinct.pluck(:platform).compact
+
+        platforms.each_with_object({}) do |platform, result|
+          errors = ErrorLog
+            .where(platform: platform)
+            .where("occurred_at >= ?", @start_date)
+
+          # Calculate severity in Ruby since it's a method, not a column
+          severity_counts = Hash.new(0)
+          errors.each do |error|
+            severity_counts[error.severity] += 1
+          end
+
+          result[platform] = severity_counts
+        end
+      end
+
+      # Get average resolution time by platform
+      # @return [Hash] Platform => average hours to resolve
+      def resolution_time_by_platform
+        platforms = ErrorLog.distinct.pluck(:platform).compact
+
+        platforms.each_with_object({}) do |platform, result|
+          resolved_errors = ErrorLog
+            .where(platform: platform)
+            .where.not(resolved_at: nil)
+            .where("occurred_at >= ?", @start_date)
+
+          if resolved_errors.any?
+            total_hours = resolved_errors.sum do |error|
+              ((error.resolved_at - error.occurred_at) / 3600.0).round(2)
+            end
+            result[platform] = (total_hours / resolved_errors.count).round(2)
+          else
+            result[platform] = nil
+          end
+        end
+      end
+
+      # Get top 10 errors for each platform
+      # @return [Hash] Platform => Array of error hashes
+      def top_errors_by_platform
+        platforms = ErrorLog.distinct.pluck(:platform).compact
+
+        platforms.each_with_object({}) do |platform, result|
+          result[platform] = ErrorLog
+            .where(platform: platform)
+            .where("occurred_at >= ?", @start_date)
+            .select(:id, :error_type, :message, :occurrence_count, :occurred_at)
+            .order(occurrence_count: :desc)
+            .limit(10)
+            .map do |error|
+              {
+                id: error.id,
+                error_type: error.error_type,
+                message: error.message&.truncate(100),
+                severity: error.severity, # Calls the method
+                occurrence_count: error.occurrence_count,
+                occurred_at: error.occurred_at
+              }
+            end
+        end
+      end
+
+      # Calculate platform stability score (0-100)
+      # Higher score = more stable (fewer errors, faster resolution)
+      # @return [Hash] Platform => stability score
+      def platform_stability_scores
+        platforms = ErrorLog.distinct.pluck(:platform).compact
+        error_rates = error_rate_by_platform
+        resolution_times = resolution_time_by_platform
+
+        # Find max values for normalization
+        max_errors = error_rates.values.max || 1
+        max_resolution_time = resolution_times.values.compact.max || 1
+
+        platforms.each_with_object({}) do |platform, result|
+          error_count = error_rates[platform] || 0
+          avg_resolution = resolution_times[platform] || 0
+
+          # Normalize to 0-1 scale (inverted - lower is better)
+          error_score = 1.0 - (error_count.to_f / max_errors)
+          resolution_score = avg_resolution.positive? ? 1.0 - (avg_resolution / max_resolution_time) : 1.0
+
+          # Weight: 70% error count, 30% resolution time
+          # Convert to 0-100 scale
+          result[platform] = ((error_score * 0.7 + resolution_score * 0.3) * 100).round(1)
+        end
+      end
+
+      # Find errors that occur across multiple platforms
+      # @return [Array<Hash>] Errors with their platforms
+      def cross_platform_errors
+        # Get error types that appear on 2+ platforms
+        error_types_with_platforms = ErrorLog
+          .where("occurred_at >= ?", @start_date)
+          .group(:error_type, :platform)
+          .select(:error_type, :platform)
+          .having("COUNT(*) > 0")
+          .pluck(:error_type, :platform)
+
+        # Group by error_type to find those on multiple platforms
+        errors_by_type = error_types_with_platforms.group_by { |error_type, _| error_type }
+
+        errors_by_type
+          .select { |_, platforms| platforms.map(&:last).uniq.count > 1 }
+          .map do |error_type, platform_pairs|
+            platforms = platform_pairs.map(&:last).uniq
+            total_count = ErrorLog
+              .where(error_type: error_type, platform: platforms)
+              .where("occurred_at >= ?", @start_date)
+              .sum(:occurrence_count)
+
+            {
+              error_type: error_type,
+              platforms: platforms.sort,
+              total_occurrences: total_count,
+              platform_breakdown: platforms.each_with_object({}) do |platform, breakdown|
+                breakdown[platform] = ErrorLog
+                  .where(error_type: error_type, platform: platform)
+                  .where("occurred_at >= ?", @start_date)
+                  .sum(:occurrence_count)
+              end
+            }
+          end
+          .sort_by { |error| -error[:total_occurrences] }
+      end
+
+      # Get daily error trend by platform
+      # @return [Hash] Platform => { date => count }
+      def daily_trend_by_platform
+        platforms = ErrorLog.distinct.pluck(:platform).compact
+
+        platforms.each_with_object({}) do |platform, result|
+          result[platform] = ErrorLog
+            .where(platform: platform)
+            .where("occurred_at >= ?", @start_date)
+            .group_by_day(:occurred_at, range: @start_date..Time.current)
+            .count
+        end
+      end
+
+      # Get platform health summary
+      # @return [Hash] Platform => health metrics
+      def platform_health_summary
+        platforms = ErrorLog.distinct.pluck(:platform).compact
+        error_rates = error_rate_by_platform
+        stability_scores = platform_stability_scores
+
+        platforms.each_with_object({}) do |platform, result|
+          total_errors = error_rates[platform] || 0
+
+          # Count critical errors by checking severity method
+          critical_errors = ErrorLog
+            .where(platform: platform)
+            .where("occurred_at >= ?", @start_date)
+            .select { |error| error.severity == :critical }
+            .count
+
+          unresolved_errors = ErrorLog
+            .where(platform: platform, resolved_at: nil)
+            .where("occurred_at >= ?", @start_date)
+            .count
+
+          resolved_errors = ErrorLog
+            .where(platform: platform)
+            .where.not(resolved_at: nil)
+            .where("occurred_at >= ?", @start_date)
+            .count
+
+          resolution_rate = total_errors.positive? ? ((resolved_errors.to_f / total_errors) * 100).round(1) : 0.0
+
+          # Calculate error velocity (increasing or decreasing)
+          first_half = ErrorLog
+            .where(platform: platform)
+            .where("occurred_at >= ? AND occurred_at < ?", @start_date, @start_date + (@days / 2.0).days)
+            .count
+
+          second_half = ErrorLog
+            .where(platform: platform)
+            .where("occurred_at >= ?", @start_date + (@days / 2.0).days)
+            .count
+
+          velocity = first_half.positive? ? (((second_half - first_half).to_f / first_half) * 100).round(1) : 0.0
+
+          result[platform] = {
+            total_errors: total_errors,
+            critical_errors: critical_errors,
+            unresolved_errors: unresolved_errors,
+            resolution_rate: resolution_rate,
+            stability_score: stability_scores[platform] || 0,
+            error_velocity: velocity, # Positive = increasing, negative = decreasing
+            health_status: determine_health_status(stability_scores[platform] || 0, velocity)
+          }
+        end
+      end
+
+      private
+
+      # Determine health status based on stability score and velocity
+      # @param stability_score [Float] 0-100 stability score
+      # @param velocity [Float] Error velocity percentage
+      # @return [Symbol] :healthy, :warning, or :critical
+      def determine_health_status(stability_score, velocity)
+        if stability_score >= 80 && velocity <= 10
+          :healthy
+        elsif stability_score >= 60 && velocity <= 50
+          :warning
+        else
+          :critical
+        end
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/similar_errors.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Find errors similar to a target error using fuzzy matching
+    #
+    # Uses SimilarityCalculator to compute similarity scores based on:
+    # - Backtrace pattern similarity (70% weight)
+    # - Message similarity (30% weight)
+    #
+    # Returns errors with similarity >= threshold, sorted by score descending
+    class SimilarErrors
+      # Find similar errors
+      #
+      # @param error_id [Integer] ID of target error
+      # @param threshold [Float] Minimum similarity score (0.0-1.0), default 0.6
+      # @param limit [Integer] Maximum number of results, default 10
+      # @return [Array<Hash>] Array of {error: ErrorLog, similarity: Float}
+      def self.call(error_id, threshold: 0.6, limit: 10)
+        new(error_id, threshold: threshold, limit: limit).find_similar
+      end
+
+      def initialize(error_id, threshold: 0.6, limit: 10)
+        @error_id = error_id
+        @threshold = threshold.to_f
+        @limit = limit.to_i
+      end
+
+      def find_similar
+        target_error = ErrorLog.find_by(id: @error_id)
+        return [] unless target_error
+
+        # Find candidate errors to compare
+        candidates = find_candidates(target_error)
+
+        # Calculate similarity scores
+        similar_errors = candidates.map do |candidate|
+          score = Services::SimilarityCalculator.call(target_error, candidate)
+          next if score < @threshold
+
+          {
+            error: candidate,
+            similarity: score.round(3)
+          }
+        end.compact
+
+        # Sort by similarity score (highest first) and limit results
+        similar_errors.sort_by { |item| -item[:similarity] }.first(@limit)
+      end
+
+      private
+
+      def find_candidates(target_error)
+        # Build candidate query with multiple strategies for performance
+
+        # Strategy 1: Same backtrace signature (fastest, most precise)
+        candidates = []
+        if target_error.backtrace_signature.present?
+          candidates += ErrorLog
+                          .where(backtrace_signature: target_error.backtrace_signature)
+                          .where.not(id: target_error.id)
+                          .limit(50)
+        end
+
+        # Strategy 2: Same error type (fast, good recall)
+        if candidates.size < 20
+          candidates += ErrorLog
+                          .where(error_type: target_error.error_type)
+                          .where.not(id: target_error.id)
+                          .where.not(id: candidates.map(&:id))
+                          .limit(30)
+        end
+
+        # Strategy 3: Same platform + same first word in error type
+        # (catches similar errors like NoMethodError vs NameError)
+        if candidates.size < 20 && target_error.platform.present?
+          error_prefix = target_error.error_type&.split("::")&.last&.split(/(?=[A-Z])/, 2)&.first
+          if error_prefix.present?
+            candidates += ErrorLog
+                            .where(platform: target_error.platform)
+                            .where("error_type LIKE ?", "%#{error_prefix}%")
+                            .where.not(id: target_error.id)
+                            .where.not(id: candidates.map(&:id))
+                            .limit(20)
+          end
+        end
+
+        # Return unique candidates
+        candidates.uniq
+      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/services/baseline_alert_throttler.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Throttles baseline alerts to prevent alert fatigue
+    #
+    # Tracks when alerts were last sent for each error_type/platform combination
+    # and prevents sending duplicate alerts within the cooldown window.
+    #
+    # Uses an in-memory cache (class variable) for simplicity. For distributed
+    # systems, consider using Redis or a database-backed solution.
+    class BaselineAlertThrottler
+      @last_alert_times = {}
+      @mutex = Mutex.new
+
+      class << self
+        # Check if an alert should be sent (not in cooldown period)
+        # @param error_type [String] The error type
+        # @param platform [String] The platform
+        # @param cooldown_minutes [Integer] Cooldown period in minutes
+        # @return [Boolean] True if alert should be sent
+        def should_alert?(error_type, platform, cooldown_minutes: 120)
+          key = alert_key(error_type, platform)
+
+          @mutex.synchronize do
+            last_time = @last_alert_times[key]
+
+            # No previous alert, allow this one
+            return true if last_time.nil?
+
+            # Check if cooldown period has passed
+            Time.current > (last_time + cooldown_minutes.minutes)
+          end
+        end
+
+        # Record that an alert was sent
+        # @param error_type [String] The error type
+        # @param platform [String] The platform
+        def record_alert(error_type, platform)
+          key = alert_key(error_type, platform)
+
+          @mutex.synchronize do
+            @last_alert_times[key] = Time.current
+          end
+        end
+
+        # Get time since last alert
+        # @param error_type [String] The error type
+        # @param platform [String] The platform
+        # @return [Integer, nil] Minutes since last alert, or nil if never alerted
+        def minutes_since_last_alert(error_type, platform)
+          key = alert_key(error_type, platform)
+
+          @mutex.synchronize do
+            last_time = @last_alert_times[key]
+            return nil if last_time.nil?
+
+            ((Time.current - last_time) / 60).to_i
+          end
+        end
+
+        # Clear all alert records (useful for testing)
+        def clear!
+          @mutex.synchronize do
+            @last_alert_times.clear
+          end
+        end
+
+        # Clean up old entries (older than max_age_hours)
+        # Call periodically to prevent memory growth
+        # @param max_age_hours [Integer] Remove entries older than this (default: 24)
+        def cleanup!(max_age_hours: 24)
+          cutoff_time = max_age_hours.hours.ago
+
+          @mutex.synchronize do
+            @last_alert_times.delete_if { |_, time| time < cutoff_time }
+          end
+        end
+
+        private
+
+        def alert_key(error_type, platform)
+          "#{error_type}:#{platform}"
+        end
+      end
+    end
+  end
+end