rails_error_dashboard 0.1.0 → 0.1.1

data/lib/rails_error_dashboard/services/cascade_detector.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Detects cascade patterns by analyzing error occurrences
+    #
+    # Runs periodically to find errors that consistently follow other errors,
+    # indicating a causal relationship.
+    class CascadeDetector
+      # Time window to look for cascades (errors within this window may be related)
+      DETECTION_WINDOW = 60.seconds
+
+      # Minimum times a pattern must occur to be considered a cascade
+      MIN_CASCADE_FREQUENCY = 3
+
+      # Minimum probability threshold (% of time parent leads to child)
+      MIN_CASCADE_PROBABILITY = 0.7
+
+      def self.call(lookback_hours: 24)
+        new(lookback_hours: lookback_hours).detect_cascades
+      end
+
+      def initialize(lookback_hours: 24)
+        @lookback_hours = lookback_hours
+        @detected_count = 0
+      end
+
+      def detect_cascades
+        return { detected: 0, updated: 0 } unless can_detect?
+
+        # Get recent error occurrences
+        start_time = @lookback_hours.hours.ago
+        occurrences = ErrorOccurrence.where("occurred_at >= ?", start_time).order(:occurred_at)
+
+        # For each error occurrence, find potential children
+        patterns_found = Hash.new { |h, k| h[k] = { delays: [], count: 0 } }
+
+        occurrences.each do |parent_occ|
+          # Find occurrences within detection window
+          potential_children = ErrorOccurrence
+            .where("occurred_at > ? AND occurred_at <= ?",
+                   parent_occ.occurred_at,
+                   parent_occ.occurred_at + DETECTION_WINDOW)
+            .where.not(error_log_id: parent_occ.error_log_id)
+
+          potential_children.each do |child_occ|
+            key = [ parent_occ.error_log_id, child_occ.error_log_id ]
+            delay = (child_occ.occurred_at - parent_occ.occurred_at).to_f
+
+            patterns_found[key][:delays] << delay
+            patterns_found[key][:count] += 1
+          end
+        end
+
+        # Filter and save cascade patterns
+        updated_count = 0
+        patterns_found.each do |(parent_id, child_id), data|
+          next if data[:count] < MIN_CASCADE_FREQUENCY
+
+          # Find or create cascade pattern
+          pattern = CascadePattern.find_or_initialize_by(
+            parent_error_id: parent_id,
+            child_error_id: child_id
+          )
+
+          avg_delay = data[:delays].sum / data[:delays].size
+
+          if pattern.new_record?
+            pattern.frequency = data[:count]
+            pattern.avg_delay_seconds = avg_delay
+            pattern.last_detected_at = Time.current
+            pattern.save
+            @detected_count += 1
+          else
+            # Update existing pattern
+            pattern.increment_detection!(avg_delay)
+            updated_count += 1
+          end
+
+          # Calculate probability
+          pattern.calculate_probability!
+        end
+
+        { detected: @detected_count, updated: updated_count }
+      end
+
+      private
+
+      def can_detect?
+        defined?(CascadePattern) && CascadePattern.table_exists? &&
+        defined?(ErrorOccurrence) && ErrorOccurrence.table_exists?
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/pattern_detector.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Service object for detecting occurrence patterns in errors
+    #
+    # Provides two main pattern detection capabilities:
+    # 1. Cyclical patterns - Daily/weekly rhythms (e.g., business hours pattern)
+    # 2. Burst detection - Many errors in short time period
+    #
+    # @example Cyclical pattern
+    #   pattern = PatternDetector.analyze_cyclical_pattern(
+    #     error_type: "NoMethodError",
+    #     platform: "ios",
+    #     days: 30
+    #   )
+    #   # => {
+    #   #   pattern_type: :business_hours,
+    #   #   peak_hours: [9, 10, 11, 14, 15],
+    #   #   hourly_distribution: { 0 => 5, 1 => 3, ... },
+    #   #   pattern_strength: 0.8
+    #   # }
+    #
+    # @example Burst detection
+    #   bursts = PatternDetector.detect_bursts(
+    #     error_type: "NoMethodError",
+    #     platform: "ios",
+    #     days: 7
+    #   )
+    #   # => [{
+    #   #   start_time: <Time>,
+    #   #   end_time: <Time>,
+    #   #   duration_seconds: 300,
+    #   #   error_count: 25,
+    #   #   burst_intensity: :high
+    #   # }]
+    class PatternDetector
+      # Analyze cyclical patterns in error occurrences
+      #
+      # Detects:
+      # - Business hours pattern (9am-5pm peak)
+      # - Night pattern (midnight-6am peak)
+      # - Weekend pattern (Sat-Sun peak)
+      # - Uniform pattern (no clear pattern)
+      #
+      # @param error_type [String] The error type to analyze
+      # @param platform [String] The platform (iOS, Android, API, etc.)
+      # @param days [Integer] Number of days to analyze (default: 30)
+      # @return [Hash] Pattern analysis with type, peaks, distribution, and strength
+      def self.analyze_cyclical_pattern(error_type:, platform:, days: 30)
+        start_date = days.days.ago
+
+        # Get all error occurrences for this error type/platform
+        errors = ErrorLog
+          .where(error_type: error_type, platform: platform)
+          .where("occurred_at >= ?", start_date)
+
+        return empty_pattern if errors.empty?
+
+        # Group by hour of day (0-23)
+        hourly_distribution = Hash.new(0)
+        weekday_distribution = Hash.new(0)
+
+        errors.each do |error|
+          hour = error.occurred_at.hour
+          wday = error.occurred_at.wday # 0 = Sunday, 6 = Saturday
+          hourly_distribution[hour] += 1
+          weekday_distribution[wday] += 1
+        end
+
+        # Calculate pattern type and peaks
+        pattern_type = determine_pattern_type(hourly_distribution, weekday_distribution)
+        peak_hours = find_peak_hours(hourly_distribution)
+        pattern_strength = calculate_pattern_strength(hourly_distribution)
+
+        {
+          pattern_type: pattern_type,
+          peak_hours: peak_hours,
+          hourly_distribution: hourly_distribution,
+          weekday_distribution: weekday_distribution,
+          pattern_strength: pattern_strength,
+          total_errors: errors.count,
+          analysis_days: days
+        }
+      end
+
+      # Detect error bursts (sequences where errors occur rapidly)
+      #
+      # A burst is defined as a sequence where inter-arrival time < 1 minute
+      # Burst intensity:
+      # - :high - 20+ errors in burst
+      # - :medium - 10-19 errors
+      # - :low - 5-9 errors
+      #
+      # @param error_type [String] The error type to analyze
+      # @param platform [String] The platform
+      # @param days [Integer] Number of days to analyze (default: 7)
+      # @return [Array<Hash>] Array of burst metadata
+      def self.detect_bursts(error_type:, platform:, days: 7)
+        start_date = days.days.ago
+
+        # Get all error occurrences sorted by time
+        errors = ErrorLog
+          .where(error_type: error_type, platform: platform)
+          .where("occurred_at >= ?", start_date)
+          .order(:occurred_at)
+
+        return [] if errors.count < 5 # Need at least 5 errors to detect a burst
+
+        # Get all occurrence timestamps
+        timestamps = errors.flat_map do |error|
+          # If error has error_occurrences, use those timestamps
+          if error.respond_to?(:error_occurrences) && error.error_occurrences.any?
+            error.error_occurrences.pluck(:occurred_at)
+          else
+            # Otherwise use the error's occurred_at repeated by occurrence_count
+            Array.new(error.occurrence_count || 1, error.occurred_at)
+          end
+        end.sort
+
+        return [] if timestamps.size < 5
+
+        # Detect bursts: sequences where inter-arrival < 60 seconds
+        bursts = []
+        current_burst = nil
+
+        timestamps.each_with_index do |timestamp, i|
+          next if i.zero?
+
+          inter_arrival = timestamp - timestamps[i - 1]
+
+          if inter_arrival <= 60 # 60 seconds threshold
+            # Start new burst or continue existing
+            if current_burst.nil?
+              current_burst = {
+                start_time: timestamps[i - 1],
+                timestamps: [ timestamps[i - 1], timestamp ]
+              }
+            else
+              current_burst[:timestamps] << timestamp
+            end
+          else
+            # End current burst if it exists and has enough errors
+            if current_burst && current_burst[:timestamps].size >= 5
+              bursts << finalize_burst(current_burst)
+            end
+            current_burst = nil
+          end
+        end
+
+        # Don't forget the last burst
+        if current_burst && current_burst[:timestamps].size >= 5
+          bursts << finalize_burst(current_burst)
+        end
+
+        bursts
+      end
+
+      private
+
+      # Empty pattern result
+      def self.empty_pattern
+        {
+          pattern_type: :none,
+          peak_hours: [],
+          hourly_distribution: {},
+          weekday_distribution: {},
+          pattern_strength: 0.0,
+          total_errors: 0,
+          analysis_days: 0
+        }
+      end
+
+      # Determine the pattern type based on hour and weekday distributions
+      def self.determine_pattern_type(hourly_dist, weekday_dist)
+        return :none if hourly_dist.empty?
+
+        # Calculate average errors per hour
+        avg_per_hour = hourly_dist.values.sum.to_f / 24
+
+        # Find peak hours (>2x average)
+        peak_hours = hourly_dist.select { |_, count| count > avg_per_hour * 2 }.keys.sort
+
+        # Business hours pattern: peaks between 9am-5pm
+        business_hours = (9..17).to_a
+        business_peaks = peak_hours & business_hours
+        if business_peaks.size >= 3
+          return :business_hours
+        end
+
+        # Night pattern: peaks between midnight-6am
+        night_hours = (0..6).to_a
+        night_peaks = peak_hours & night_hours
+        if night_peaks.size >= 2
+          return :night
+        end
+
+        # Weekend pattern: most errors on Sat/Sun
+        if weekday_dist.any?
+          weekend_count = (weekday_dist[0] || 0) + (weekday_dist[6] || 0) # Sun + Sat
+          total_count = weekday_dist.values.sum
+          if weekend_count > total_count * 0.5
+            return :weekend
+          end
+        end
+
+        # No clear pattern
+        :uniform
+      end
+
+      # Find peak hours (hours with >2x average)
+      def self.find_peak_hours(hourly_dist)
+        return [] if hourly_dist.empty?
+
+        avg = hourly_dist.values.sum.to_f / 24
+        hourly_dist.select { |_, count| count > avg * 2 }.keys.sort
+      end
+
+      # Calculate pattern strength (0.0-1.0)
+      # Measures how concentrated the errors are in peak hours
+      def self.calculate_pattern_strength(hourly_dist)
+        return 0.0 if hourly_dist.empty?
+
+        total = hourly_dist.values.sum
+        return 0.0 if total.zero?
+
+        # Calculate coefficient of variation (std dev / mean)
+        # Higher variation = stronger pattern
+        values = (0..23).map { |h| hourly_dist[h] || 0 }
+        mean = total.to_f / 24
+        variance = values.sum { |v| (v - mean)**2 } / 24
+        std_dev = Math.sqrt(variance)
+
+        # Normalize to 0-1 scale (coefficient of variation)
+        # Divide by sqrt(mean) to get a rough 0-1 scale
+        cv = mean > 0 ? std_dev / mean : 0
+        [ cv.round(2), 1.0 ].min
+      end
+
+      # Finalize burst metadata
+      def self.finalize_burst(burst_data)
+        start_time = burst_data[:start_time]
+        end_time = burst_data[:timestamps].last
+        duration = end_time - start_time
+        count = burst_data[:timestamps].size
+
+        {
+          start_time: start_time,
+          end_time: end_time,
+          duration_seconds: duration.round(1),
+          error_count: count,
+          burst_intensity: classify_burst_intensity(count)
+        }
+      end
+
+      # Classify burst intensity based on error count
+      def self.classify_burst_intensity(count)
+        if count >= 20
+          :high
+        elsif count >= 10
+          :medium
+        else
+          :low
+        end
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/similarity_calculator.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Calculates similarity scores between errors using multiple algorithms
+    #
+    # Combines:
+    # - Backtrace similarity (Jaccard index on stack frames) - 70% weight
+    # - Message similarity (Levenshtein distance) - 30% weight
+    #
+    # Returns a similarity score from 0.0 (completely different) to 1.0 (identical)
+    class SimilarityCalculator
+      # Calculate similarity between two errors
+      #
+      # @param error1 [ErrorLog] First error to compare
+      # @param error2 [ErrorLog] Second error to compare
+      # @return [Float] Similarity score from 0.0 to 1.0
+      def self.call(error1, error2)
+        new(error1, error2).calculate
+      end
+
+      def initialize(error1, error2)
+        @error1 = error1
+        @error2 = error2
+      end
+
+      def calculate
+        # Quick return for same error
+        return 1.0 if @error1.id == @error2.id
+
+        # Quick return for different platforms (per user config - same platform only)
+        return 0.0 if different_platforms?
+
+        backtrace_score = calculate_backtrace_similarity
+        message_score = calculate_message_similarity
+
+        # Weighted combination: backtrace 70%, message 30%
+        (backtrace_score * 0.7) + (message_score * 0.3)
+      end
+
+      private
+
+      def different_platforms?
+        return false if @error1.platform.nil? || @error2.platform.nil?
+        @error1.platform != @error2.platform
+      end
+
+      # Calculate Jaccard similarity on backtrace frames
+      # Jaccard = intersection / union
+      def calculate_backtrace_similarity
+        frames1 = extract_frames(@error1.backtrace)
+        frames2 = extract_frames(@error2.backtrace)
+
+        return 0.0 if frames1.empty? || frames2.empty?
+
+        intersection = (frames1 & frames2).size
+        union = (frames1 | frames2).size
+
+        return 0.0 if union.zero?
+
+        intersection.to_f / union
+      end
+
+      # Calculate normalized Levenshtein distance on messages
+      # Returns 1.0 for identical messages, decreasing as they differ
+      def calculate_message_similarity
+        msg1 = normalize_message(@error1.message)
+        msg2 = normalize_message(@error2.message)
+
+        return 1.0 if msg1 == msg2
+        return 0.0 if msg1.empty? || msg2.empty?
+
+        distance = levenshtein_distance(msg1, msg2)
+        max_length = [ msg1.length, msg2.length ].max
+
+        return 0.0 if max_length.zero?
+
+        # Convert distance to similarity (1.0 = identical, 0.0 = completely different)
+        1.0 - (distance.to_f / max_length)
+      end
+
+      # Extract meaningful frames from backtrace
+      # Format: "file.rb:123:in `method_name`" => "file.rb:method_name"
+      def extract_frames(backtrace)
+        return [] if backtrace.blank?
+
+        lines = backtrace.is_a?(String) ? backtrace.split("\n") : backtrace
+        lines.first(20).map do |line|  # Only consider first 20 frames
+          # 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
+
+      # Normalize message for comparison
+      # Already normalized during error logging, but ensure consistency
+      def normalize_message(message)
+        return "" if message.nil?
+
+        message
+          .gsub(/#<\w+:0x[0-9a-f]+>/i, "__OBJ__")   # Object inspections - temp placeholder
+          .gsub(/0x[0-9a-f]+/i, "__HEX__")          # Hex addresses - temp placeholder
+          .gsub(/"[^"]*"/, '""')                     # Quoted strings to ""
+          .gsub(/'[^']*'/, "''")                     # Single quotes to ''
+          .downcase                                   # Convert to lowercase
+          .gsub(/\d+/, "n")                           # Numbers to n (lowercase)
+          .gsub(/__hex__/, "0xhex")                   # Replace placeholder with final value
+          .gsub(/__obj__/, "#<obj>")                  # Replace placeholder with final value
+          .strip
+      end
+
+      # Calculate Levenshtein distance (edit distance) between two strings
+      # Classic dynamic programming algorithm
+      def levenshtein_distance(str1, str2)
+        return str2.length if str1.empty?
+        return str1.length if str2.empty?
+
+        # Create matrix
+        matrix = Array.new(str1.length + 1) { Array.new(str2.length + 1, 0) }
+
+        # Initialize first row and column
+        (0..str1.length).each { |i| matrix[i][0] = i }
+        (0..str2.length).each { |j| matrix[0][j] = j }
+
+        # Fill matrix
+        (1..str1.length).each do |i|
+          (1..str2.length).each do |j|
+            cost = str1[i - 1] == str2[j - 1] ? 0 : 1
+            matrix[i][j] = [
+              matrix[i - 1][j] + 1,      # deletion
+              matrix[i][j - 1] + 1,      # insertion
+              matrix[i - 1][j - 1] + cost # substitution
+            ].min
+          end
+        end
+
+        matrix[str1.length][str2.length]
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/value_objects/error_context.rb

@@ -6,7 +6,7 @@ module RailsErrorDashboard
     # Extracts and normalizes context information from various sources
     class ErrorContext
       attr_reader :user_id, :request_url, :request_params, :user_agent, :ip_address, :platform,
-                  :controller_name, :action_name
+                  :controller_name, :action_name, :request_id, :session_id
 
       def initialize(context, source = nil)
         @context = context
@@ -20,6 +20,8 @@ module RailsErrorDashboard
         @platform = detect_platform
         @controller_name = extract_controller_name
         @action_name = extract_action_name
+        @request_id = extract_request_id
+        @session_id = extract_session_id
       end
 
       def to_h
@@ -143,6 +145,30 @@ module RailsErrorDashboard
 
         nil
       end
+
+      def extract_request_id
+        # From Rails request
+        return @context[:request]&.request_id if @context[:request]&.respond_to?(:request_id)
+
+        # From explicit context
+        return @context[:request_id] if @context[:request_id]
+
+        # From job ID (for background jobs)
+        return @context[:job]&.job_id if @context[:job]
+        return @context[:jid] if @context[:jid]
+
+        nil
+      end
+
+      def extract_session_id
+        # From Rails session
+        return @context[:request]&.session&.id if @context[:request]&.session
+
+        # From explicit context
+        return @context[:session_id] if @context[:session_id]
+
+        nil
+      end
     end
   end
 end

data/lib/rails_error_dashboard/version.rb

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

data/lib/rails_error_dashboard.rb

@@ -11,6 +11,16 @@ require "httparty"
 # Core library files
 require "rails_error_dashboard/value_objects/error_context"
 require "rails_error_dashboard/services/platform_detector"
+require "rails_error_dashboard/services/similarity_calculator"
+require "rails_error_dashboard/services/cascade_detector"
+require "rails_error_dashboard/services/baseline_calculator"
+require "rails_error_dashboard/services/baseline_alert_throttler"
+require "rails_error_dashboard/services/pattern_detector"
+require "rails_error_dashboard/queries/co_occurring_errors"
+require "rails_error_dashboard/queries/error_cascades"
+require "rails_error_dashboard/queries/baseline_stats"
+require "rails_error_dashboard/queries/platform_comparison"
+require "rails_error_dashboard/queries/error_correlation"
 require "rails_error_dashboard/commands/log_error"
 require "rails_error_dashboard/commands/resolve_error"
 require "rails_error_dashboard/commands/batch_resolve_errors"
@@ -19,6 +29,7 @@ require "rails_error_dashboard/queries/errors_list"
 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/error_reporter"
 require "rails_error_dashboard/middleware/error_catcher"
 
@@ -28,12 +39,22 @@ require "rails_error_dashboard/plugin_registry"
 
 module RailsErrorDashboard
   class << self
-    attr_accessor :configuration
-  end
+    attr_writer :configuration
+
+    # Get or initialize configuration
+    def configuration
+      @configuration ||= Configuration.new
+    end
 
-  def self.configure
-    self.configuration ||= Configuration.new
-    yield(configuration)
+    # Configure the gem
+    def configure
+      yield(configuration)
+    end
+
+    # Reset configuration to defaults
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
   end
 
   # Register a plugin
@@ -55,6 +76,33 @@ module RailsErrorDashboard
     PluginRegistry.plugins
   end
 
-  # Initialize with default configuration
-  self.configuration = Configuration.new
+  # Register a callback for when any error is logged
+  # @param block [Proc] The callback to execute, receives error_log as parameter
+  # @example
+  #   RailsErrorDashboard.on_error_logged do |error_log|
+  #     puts "Error logged: #{error_log.error_type}"
+  #   end
+  def self.on_error_logged(&block)
+    configuration.notification_callbacks[:error_logged] << block if block_given?
+  end
+
+  # Register a callback for when a critical error is logged
+  # @param block [Proc] The callback to execute, receives error_log as parameter
+  # @example
+  #   RailsErrorDashboard.on_critical_error do |error_log|
+  #     PagerDuty.trigger(error_log)
+  #   end
+  def self.on_critical_error(&block)
+    configuration.notification_callbacks[:critical_error] << block if block_given?
+  end
+
+  # Register a callback for when an error is resolved
+  # @param block [Proc] The callback to execute, receives error_log as parameter
+  # @example
+  #   RailsErrorDashboard.on_error_resolved do |error_log|
+  #     Slack.notify("Error #{error_log.id} resolved")
+  #   end
+  def self.on_error_resolved(&block)
+    configuration.notification_callbacks[:error_resolved] << block if block_given?
+  end
 end