rails_error_dashboard 0.1.0 → 0.1.3

data/lib/rails_error_dashboard/services/baseline_calculator.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Calculates baseline statistics for error types
+    #
+    # This service analyzes historical error data to calculate statistical baselines
+    # for different time periods (hourly, daily, weekly). These baselines enable
+    # anomaly detection by establishing "normal" error behavior.
+    #
+    # Statistical methods used:
+    # - Mean and Standard Deviation
+    # - 95th and 99th Percentiles
+    # - Outlier removal (> 3 std devs)
+    #
+    # @example
+    #   BaselineCalculator.calculate_all_baselines
+    #   # Calculates baselines for all error types and platforms
+    class BaselineCalculator
+      # Lookback periods for baseline calculation
+      HOURLY_LOOKBACK = 4.weeks
+      DAILY_LOOKBACK = 12.weeks
+      WEEKLY_LOOKBACK = 1.year
+
+      # Outlier threshold (standard deviations)
+      OUTLIER_THRESHOLD = 3
+
+      def self.calculate_all_baselines
+        new.calculate_all_baselines
+      end
+
+      def self.calculate_for_error_type(error_type, platform)
+        new.calculate_for_error_type(error_type, platform)
+      end
+
+      def initialize
+        @calculated_count = 0
+      end
+
+      # Calculate baselines for all error types and platforms
+      # @return [Hash] Summary of calculated baselines
+      def calculate_all_baselines
+        return { calculated: 0, message: "ErrorBaseline table not available" } unless can_calculate?
+
+        # Get all unique combinations of error_type and platform
+        combinations = ErrorLog.distinct.pluck(:error_type, :platform).compact
+
+        combinations.each do |(error_type, platform)|
+          calculate_for_error_type(error_type, platform)
+        end
+
+        { calculated: @calculated_count }
+      end
+
+      # Calculate baselines for a specific error type and platform
+      # @param error_type [String] The error type
+      # @param platform [String] The platform
+      # @return [Hash] Summary with hourly, daily, weekly baseline info
+      def calculate_for_error_type(error_type, platform)
+        return {} unless can_calculate?
+
+        {
+          hourly: calculate_hourly_baseline(error_type, platform),
+          daily: calculate_daily_baseline(error_type, platform),
+          weekly: calculate_weekly_baseline(error_type, platform)
+        }
+      end
+
+      private
+
+      def can_calculate?
+        defined?(ErrorBaseline) && ErrorBaseline.table_exists?
+      end
+
+      # Calculate hourly baseline (last 4 weeks, by hour of day)
+      def calculate_hourly_baseline(error_type, platform)
+        period_start = HOURLY_LOOKBACK.ago.beginning_of_hour
+        period_end = Time.current.beginning_of_hour
+
+        # Get error counts grouped by hour
+        hourly_counts = ErrorLog
+          .where(error_type: error_type, platform: platform)
+          .where("occurred_at >= ?", period_start)
+          .group("strftime('%H', occurred_at)")
+          .count
+
+        return nil if hourly_counts.empty?
+
+        # Calculate statistics
+        counts = hourly_counts.values
+        stats = calculate_statistics(counts)
+
+        # Create or update baseline
+        baseline = ErrorBaseline.find_or_initialize_by(
+          error_type: error_type,
+          platform: platform,
+          baseline_type: "hourly",
+          period_start: period_start
+        )
+
+        baseline.update!(
+          period_end: period_end,
+          count: counts.sum,
+          mean: stats[:mean],
+          std_dev: stats[:std_dev],
+          percentile_95: stats[:percentile_95],
+          percentile_99: stats[:percentile_99],
+          sample_size: counts.size
+        )
+
+        @calculated_count += 1
+        baseline
+      end
+
+      # Calculate daily baseline (last 12 weeks, by day of week)
+      def calculate_daily_baseline(error_type, platform)
+        period_start = DAILY_LOOKBACK.ago.beginning_of_day
+        period_end = Time.current.beginning_of_day
+
+        # Get error counts grouped by day
+        daily_counts = ErrorLog
+          .where(error_type: error_type, platform: platform)
+          .where("occurred_at >= ?", period_start)
+          .group("DATE(occurred_at)")
+          .count
+
+        return nil if daily_counts.empty?
+
+        # Calculate statistics
+        counts = daily_counts.values
+        stats = calculate_statistics(counts)
+
+        # Create or update baseline
+        baseline = ErrorBaseline.find_or_initialize_by(
+          error_type: error_type,
+          platform: platform,
+          baseline_type: "daily",
+          period_start: period_start
+        )
+
+        baseline.update!(
+          period_end: period_end,
+          count: counts.sum,
+          mean: stats[:mean],
+          std_dev: stats[:std_dev],
+          percentile_95: stats[:percentile_95],
+          percentile_99: stats[:percentile_99],
+          sample_size: counts.size
+        )
+
+        @calculated_count += 1
+        baseline
+      end
+
+      # Calculate weekly baseline (last 1 year, by week)
+      def calculate_weekly_baseline(error_type, platform)
+        period_start = WEEKLY_LOOKBACK.ago.beginning_of_week
+        period_end = Time.current.beginning_of_week
+
+        # Get error counts grouped by week
+        weekly_counts = ErrorLog
+          .where(error_type: error_type, platform: platform)
+          .where("occurred_at >= ?", period_start)
+          .group("strftime('%Y-%W', occurred_at)")
+          .count
+
+        return nil if weekly_counts.empty?
+
+        # Calculate statistics
+        counts = weekly_counts.values
+        stats = calculate_statistics(counts)
+
+        # Create or update baseline
+        baseline = ErrorBaseline.find_or_initialize_by(
+          error_type: error_type,
+          platform: platform,
+          baseline_type: "weekly",
+          period_start: period_start
+        )
+
+        baseline.update!(
+          period_end: period_end,
+          count: counts.sum,
+          mean: stats[:mean],
+          std_dev: stats[:std_dev],
+          percentile_95: stats[:percentile_95],
+          percentile_99: stats[:percentile_99],
+          sample_size: counts.size
+        )
+
+        @calculated_count += 1
+        baseline
+      end
+
+      # Calculate statistical metrics from an array of counts
+      # Removes outliers (> 3 std devs from mean)
+      # @param counts [Array<Integer>] Array of error counts
+      # @return [Hash] Statistics hash
+      def calculate_statistics(counts)
+        return default_stats if counts.empty?
+
+        # Remove outliers
+        clean_counts = remove_outliers(counts)
+        return default_stats if clean_counts.empty?
+
+        mean = clean_counts.sum.to_f / clean_counts.size
+        variance = clean_counts.map { |c| (c - mean)**2 }.sum / clean_counts.size
+        std_dev = Math.sqrt(variance)
+
+        sorted = clean_counts.sort
+        percentile_95 = percentile(sorted, 95)
+        percentile_99 = percentile(sorted, 99)
+
+        {
+          mean: mean.round(2),
+          std_dev: std_dev.round(2),
+          percentile_95: percentile_95.round(2),
+          percentile_99: percentile_99.round(2)
+        }
+      end
+
+      # Remove outliers from counts (values > 3 std devs from mean)
+      # @param counts [Array<Integer>] Raw counts
+      # @return [Array<Integer>] Counts with outliers removed
+      def remove_outliers(counts)
+        return counts if counts.size < 3
+
+        mean = counts.sum.to_f / counts.size
+        variance = counts.map { |c| (c - mean)**2 }.sum / counts.size
+        std_dev = Math.sqrt(variance)
+
+        # Remove values more than OUTLIER_THRESHOLD std devs from mean
+        counts.select { |c| (c - mean).abs <= (OUTLIER_THRESHOLD * std_dev) }
+      end
+
+      # Calculate percentile value
+      # @param sorted_array [Array] Sorted array of numbers
+      # @param percentile [Integer] Percentile to calculate (0-100)
+      # @return [Float] Percentile value
+      def percentile(sorted_array, percentile)
+        return 0 if sorted_array.empty?
+        return sorted_array.first if sorted_array.size == 1
+
+        rank = (percentile / 100.0) * (sorted_array.size - 1)
+        lower_index = rank.floor
+        upper_index = rank.ceil
+
+        if lower_index == upper_index
+          sorted_array[lower_index].to_f
+        else
+          # Linear interpolation
+          lower_value = sorted_array[lower_index]
+          upper_value = sorted_array[upper_index]
+          fraction = rank - lower_index
+          lower_value + (upper_value - lower_value) * fraction
+        end
+      end
+
+      def default_stats
+        {
+          mean: 0.0,
+          std_dev: 0.0,
+          percentile_95: 0.0,
+          percentile_99: 0.0
+        }
+      end
+    end
+  end
+end

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