rails_error_dashboard 0.1.0 → 0.1.3

data/lib/rails_error_dashboard/plugin_registry.rb

@@ -18,13 +18,13 @@ module RailsErrorDashboard
         end
 
         if plugins.any? { |p| p.name == plugin.name }
-          Rails.logger.warn("Plugin '#{plugin.name}' is already registered, skipping")
+          RailsErrorDashboard::Logger.warn("Plugin '#{plugin.name}' is already registered, skipping")
           return false
         end
 
         plugins << plugin
         plugin.on_register
-        Rails.logger.info("Registered plugin: #{plugin.name} (#{plugin.version})")
+        RailsErrorDashboard::Logger.info("Registered plugin: #{plugin.name} (#{plugin.version})")
         true
       end
 

data/lib/rails_error_dashboard/plugins/audit_log_plugin.rb

@@ -33,7 +33,6 @@ module RailsErrorDashboard
           error_id: error_log.id,
           error_type: error_log.error_type,
           platform: error_log.platform,
-          environment: error_log.environment,
           timestamp: Time.current
         )
       end

data/lib/rails_error_dashboard/plugins/jira_integration_plugin.rb

@@ -55,14 +55,14 @@ module RailsErrorDashboard
 
         ticket_data = {
           project: { key: @jira_project_key },
-          summary: "[#{error_log.environment}] #{error_log.error_type}",
+          summary: "#{error_log.error_type}",
           description: build_description(error_log),
           issuetype: { name: "Bug" },
           priority: { name: jira_priority(error_log) },
-          labels: [ "rails-error-dashboard", error_log.platform, error_log.environment ]
+          labels: [ "rails-error-dashboard", error_log.platform ].compact
         }
 
-        Rails.logger.info("Would create Jira ticket: #{ticket_data.to_json}")
+        RailsErrorDashboard::Logger.info("Would create Jira ticket: #{ticket_data.to_json}")
 
         # Actual implementation:
         # require 'httparty'
@@ -81,7 +81,6 @@ module RailsErrorDashboard
           *Error Type:* #{error_log.error_type}
           *Message:* #{error_log.message}
           *Platform:* #{error_log.platform}
-          *Environment:* #{error_log.environment}
           *Severity:* #{error_log.severity}
           *Controller:* #{error_log.controller_name}
           *Action:* #{error_log.action_name}

data/lib/rails_error_dashboard/plugins/metrics_plugin.rb

@@ -27,7 +27,6 @@ module RailsErrorDashboard
         increment_counter("errors.new", error_log)
         increment_counter("errors.by_type.#{sanitize_metric_name(error_log.error_type)}", error_log)
         increment_counter("errors.by_platform.#{error_log.platform || 'unknown'}", error_log)
-        increment_counter("errors.by_environment.#{error_log.environment}", error_log)
       end
 
       def on_error_recurred(error_log)
@@ -57,7 +56,7 @@ module RailsErrorDashboard
         # Datadog::Statsd.increment(metric_name, tags: metric_tags(data))
 
         # For demonstration, just log
-        Rails.logger.info("Metrics: #{metric_name} - #{data.is_a?(Hash) ? data : data.class.name}")
+        RailsErrorDashboard::Logger.info("Metrics: #{metric_name} - #{data.is_a?(Hash) ? data : data.class.name}")
       end
 
       def metric_tags(data)
@@ -65,7 +64,6 @@ module RailsErrorDashboard
 
         [
           "platform:#{data.platform || 'unknown'}",
-          "environment:#{data.environment}",
           "severity:#{data.severity}"
         ]
       end

data/lib/rails_error_dashboard/queries/analytics_stats.rb

@@ -21,12 +21,12 @@ module RailsErrorDashboard
           errors_over_time: errors_over_time,
           errors_by_type: errors_by_type,
           errors_by_platform: errors_by_platform,
-          errors_by_environment: errors_by_environment,
           errors_by_hour: errors_by_hour,
           top_users: top_affected_users,
           resolution_rate: resolution_rate,
           mobile_errors: mobile_errors_count,
-          api_errors: api_errors_count
+          api_errors: api_errors_count,
+          pattern_insights: pattern_insights
         }
       end
 
@@ -61,10 +61,6 @@ module RailsErrorDashboard
         base_query.group(:platform).count
       end
 
-      def errors_by_environment
-        base_query.group(:environment).count
-      end
-
       def errors_by_hour
         base_query.group_by_hour(:occurred_at).count
       end
@@ -103,6 +99,48 @@ module RailsErrorDashboard
       def api_errors_count
         base_query.where("platform IS NULL OR platform = ?", "API").count
       end
+
+      #  Pattern insights for top error types
+      # Analyzes occurrence patterns and bursts for top 5 error types
+      def pattern_insights
+        return {} unless defined?(Services::PatternDetector)
+
+        # Get top 5 error types by count
+        top_errors = errors_by_type.first(5)
+
+        insights = {}
+        top_errors.each do |error_type, _count|
+          # Get platform for this error type (most common platform)
+          platform = base_query.where(error_type: error_type)
+                              .group(:platform)
+                              .count
+                              .max_by { |_, count| count }
+                              &.first || "API"
+
+          # Analyze pattern for this error type
+          pattern = Services::PatternDetector.analyze_cyclical_pattern(
+            error_type: error_type,
+            platform: platform,
+            days: @days
+          )
+
+          # Detect bursts
+          bursts = Services::PatternDetector.detect_bursts(
+            error_type: error_type,
+            platform: platform,
+            days: [ 7, @days ].min # Use 7 days for burst detection, or less if analyzing shorter period
+          )
+
+          insights[error_type] = {
+            pattern: pattern,
+            bursts: bursts,
+            has_pattern: pattern[:pattern_type] != :none,
+            has_bursts: bursts.any?
+          }
+        end
+
+        insights
+      end
     end
   end
 end

data/lib/rails_error_dashboard/queries/baseline_stats.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Calculate and retrieve baseline statistics for error types
+    #
+    # Provides methods to get hourly, daily, and weekly baselines for error types.
+    # Baselines help establish "normal" error behavior for anomaly detection.
+    #
+    # @example
+    #   baseline = BaselineStats.hourly_baseline("NoMethodError", "iOS")
+    #   # => { mean: 5.2, std_dev: 2.1, percentile_95: 9.0, ... }
+    class BaselineStats
+      def self.hourly_baseline(error_type, platform)
+        new(error_type, platform).hourly_baseline
+      end
+
+      def self.daily_baseline(error_type, platform)
+        new(error_type, platform).daily_baseline
+      end
+
+      def self.weekly_baseline(error_type, platform)
+        new(error_type, platform).weekly_baseline
+      end
+
+      def initialize(error_type, platform)
+        @error_type = error_type
+        @platform = platform
+      end
+
+      # Get the most recent hourly baseline
+      # Covers last 4 weeks of data, aggregated by hour of day
+      # @return [ErrorBaseline, nil] Most recent hourly baseline or nil
+      def hourly_baseline
+        return nil unless defined?(ErrorBaseline) && ErrorBaseline.table_exists?
+
+        ErrorBaseline
+          .for_error_type(@error_type)
+          .for_platform(@platform)
+          .hourly
+          .recent
+          .first
+      end
+
+      # Get the most recent daily baseline
+      # Covers last 12 weeks of data, aggregated by day of week
+      # @return [ErrorBaseline, nil] Most recent daily baseline or nil
+      def daily_baseline
+        return nil unless defined?(ErrorBaseline) && ErrorBaseline.table_exists?
+
+        ErrorBaseline
+          .for_error_type(@error_type)
+          .for_platform(@platform)
+          .daily
+          .recent
+          .first
+      end
+
+      # Get the most recent weekly baseline
+      # Covers last 1 year of data, aggregated by week
+      # @return [ErrorBaseline, nil] Most recent weekly baseline or nil
+      def weekly_baseline
+        return nil unless defined?(ErrorBaseline) && ErrorBaseline.table_exists?
+
+        ErrorBaseline
+          .for_error_type(@error_type)
+          .for_platform(@platform)
+          .weekly
+          .recent
+          .first
+      end
+
+      # Get all baselines for an error type and platform
+      # @return [Hash] Hash with :hourly, :daily, :weekly keys
+      def all_baselines
+        {
+          hourly: hourly_baseline,
+          daily: daily_baseline,
+          weekly: weekly_baseline
+        }
+      end
+
+      # Check if current count is anomalous based on best available baseline
+      # Uses hourly baseline if available, falls back to daily, then weekly
+      # @param current_count [Integer] Current error count
+      # @param sensitivity [Integer] Standard deviations threshold (default: 2)
+      # @return [Hash] { anomaly: true/false, level: Symbol, baseline_type: String }
+      def check_anomaly(current_count, sensitivity: 2)
+        baseline = hourly_baseline || daily_baseline || weekly_baseline
+
+        if baseline.nil?
+          return { anomaly: false, level: nil, baseline_type: nil, message: "No baseline available" }
+        end
+
+        level = baseline.anomaly_level(current_count, sensitivity: sensitivity)
+
+        {
+          anomaly: level.present?,
+          level: level,
+          baseline_type: baseline.baseline_type,
+          threshold: baseline.threshold(sensitivity: sensitivity),
+          std_devs_above: baseline.std_devs_above_mean(current_count)
+        }
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/co_occurring_errors.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Find errors that occur together in time (co-occurring errors)
+    #
+    # This query analyzes error occurrences to find patterns of errors
+    # that happen within the same time window, which can indicate:
+    # - Cascading failures (one error causes another)
+    # - Related errors from the same underlying issue
+    # - Correlated errors from the same feature/endpoint
+    #
+    # @example Find errors that occur with NoMethodError
+    #   co_occurring = CoOccurringErrors.call(error_log_id: 123, window_minutes: 5)
+    #   co_occurring.each do |result|
+    #     puts "#{result[:error].error_type} occurred #{result[:frequency]} times together"
+    #   end
+    class CoOccurringErrors
+      # Find co-occurring errors
+      #
+      # @param error_log_id [Integer] ID of target error
+      # @param window_minutes [Integer] Time window in minutes (default: 5)
+      # @param min_frequency [Integer] Minimum co-occurrence count (default: 2)
+      # @param limit [Integer] Maximum number of results (default: 10)
+      # @return [Array<Hash>] Array of {error: ErrorLog, frequency: Integer, avg_delay_seconds: Float}
+      def self.call(error_log_id:, window_minutes: 5, min_frequency: 2, limit: 10)
+        new(error_log_id, window_minutes: window_minutes, min_frequency: min_frequency, limit: limit).find_co_occurring
+      end
+
+      def initialize(error_log_id, window_minutes: 5, min_frequency: 2, limit: 10)
+        @error_log_id = error_log_id
+        @window_minutes = window_minutes.to_i
+        @min_frequency = min_frequency.to_i
+        @limit = limit.to_i
+      end
+
+      def find_co_occurring
+        target_error = ErrorLog.find_by(id: @error_log_id)
+        return [] unless target_error
+
+        # Get all occurrences of the target error
+        target_occurrences = ErrorOccurrence.where(error_log_id: @error_log_id)
+        return [] if target_occurrences.empty?
+
+        # For each occurrence, find other errors in the time window
+        co_occurrence_data = Hash.new { |h, k| h[k] = { count: 0, delays: [] } }
+
+        target_occurrences.find_each do |occurrence|
+          window = @window_minutes.minutes
+          start_time = occurrence.occurred_at - window
+          end_time = occurrence.occurred_at + window
+
+          # Find other error occurrences in this time window
+          nearby_occurrences = ErrorOccurrence
+                                .in_time_window(start_time, end_time)
+                                .where.not(error_log_id: @error_log_id)
+                                .includes(:error_log)
+
+          nearby_occurrences.each do |nearby|
+            error_log_id = nearby.error_log_id
+            co_occurrence_data[error_log_id][:count] += 1
+
+            # Calculate delay (negative = before, positive = after target error)
+            delay = (nearby.occurred_at - occurrence.occurred_at).to_f
+            co_occurrence_data[error_log_id][:delays] << delay
+          end
+        end
+
+        # Filter by minimum frequency and build results
+        results = co_occurrence_data.select { |_id, data| data[:count] >= @min_frequency }.map do |error_log_id, data|
+          error = ErrorLog.find(error_log_id)
+          avg_delay = data[:delays].sum / data[:delays].size
+
+          {
+            error: error,
+            frequency: data[:count],
+            avg_delay_seconds: avg_delay.round(2)
+          }
+        end
+
+        # Sort by frequency (most common first) and limit results
+        results.sort_by { |r| -r[:frequency] }.first(@limit)
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/dashboard_stats.rb

@@ -16,9 +16,21 @@ module RailsErrorDashboard
           total_month: ErrorLog.where("occurred_at >= ?", 30.days.ago).count,
           unresolved: ErrorLog.unresolved.count,
           resolved: ErrorLog.resolved.count,
-          by_environment: ErrorLog.group(:environment).count,
           by_platform: ErrorLog.group(:platform).count,
-          top_errors: top_errors
+          top_errors: top_errors,
+          #  Trend visualizations
+          errors_trend_7d: errors_trend_7d,
+          errors_by_severity_7d: errors_by_severity_7d,
+          spike_detected: spike_detected?,
+          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
 
@@ -32,6 +44,234 @@ module RailsErrorDashboard
                 .first(10)
                 .to_h
       end
+
+      # Get 7-day error trend (daily counts)
+      def errors_trend_7d
+        ErrorLog.where("occurred_at >= ?", 7.days.ago)
+                .group_by_day(:occurred_at, range: 7.days.ago.to_date..Date.current, default_value: 0)
+                .count
+      end
+
+      # Get error counts by severity for last 7 days
+      def errors_by_severity_7d
+        last_7_days = ErrorLog.where("occurred_at >= ?", 7.days.ago)
+
+        {
+          critical: last_7_days.select { |e| e.severity == :critical }.count,
+          high: last_7_days.select { |e| e.severity == :high }.count,
+          medium: last_7_days.select { |e| e.severity == :medium }.count,
+          low: last_7_days.select { |e| e.severity == :low }.count
+        }
+      end
+
+      # Detect if there's an error spike
+      #  Uses baselines if available, falls back to simple 2x average
+      def spike_detected?
+        return false if errors_trend_7d.empty?
+
+        today_count = ErrorLog.where("occurred_at >= ?", Time.current.beginning_of_day).count
+
+        # Try baseline-based detection first
+        if baseline_anomaly_detected?(today_count)
+          return true
+        end
+
+        # Fall back to simple 2x average detection
+        avg_count = errors_trend_7d.values.sum / 7.0
+        return false if avg_count.zero?
+
+        today_count >= (avg_count * 2)
+      end
+
+      # Get spike information
+      #  Enhanced with baseline information
+      def spike_info
+        return nil unless spike_detected?
+
+        today_count = ErrorLog.where("occurred_at >= ?", Time.current.beginning_of_day).count
+        avg_count = (errors_trend_7d.values.sum / 7.0).round(1)
+
+        info = {
+          today_count: today_count,
+          avg_count: avg_count,
+          multiplier: (today_count / avg_count).round(1),
+          severity: spike_severity(today_count / avg_count)
+        }
+
+        # Add baseline info if available
+        baseline_info = baseline_anomaly_info(today_count)
+        info.merge!(baseline_info) if baseline_info.present?
+
+        info
+      end
+
+      # Check if baseline indicates anomaly
+      def baseline_anomaly_detected?(_count)
+        return false unless defined?(Queries::BaselineStats)
+
+        # Check most common error types for anomalies
+        ErrorLog.distinct.pluck(:error_type, :platform).compact.any? do |(error_type, platform)|
+          stats = Queries::BaselineStats.new(error_type, platform)
+          error_count = ErrorLog.where(
+            error_type: error_type,
+            platform: platform
+          ).where("occurred_at >= ?", Time.current.beginning_of_day).count
+
+          result = stats.check_anomaly(error_count, sensitivity: 2)
+          result[:anomaly]
+        end
+      end
+
+      # Get baseline anomaly information
+      def baseline_anomaly_info(_total_count)
+        return nil unless defined?(Queries::BaselineStats)
+
+        # Find the most anomalous error type
+        anomalies = ErrorLog.distinct.pluck(:error_type, :platform).compact.map do |(error_type, platform)|
+          stats = Queries::BaselineStats.new(error_type, platform)
+          error_count = ErrorLog.where(
+            error_type: error_type,
+            platform: platform
+          ).where("occurred_at >= ?", Time.current.beginning_of_day).count
+
+          result = stats.check_anomaly(error_count, sensitivity: 2)
+          next unless result[:anomaly]
+
+          {
+            error_type: error_type,
+            platform: platform,
+            count: error_count,
+            level: result[:level],
+            std_devs_above: result[:std_devs_above]
+          }
+        end.compact
+
+        return nil if anomalies.empty?
+
+        # Return info about worst anomaly
+        worst = anomalies.max_by { |a| a[:std_devs_above] || 0 }
+        {
+          baseline_detected: true,
+          anomaly_error_type: worst[:error_type],
+          anomaly_platform: worst[:platform],
+          anomaly_level: worst[:level],
+          std_devs_above: worst[:std_devs_above]&.round(1)
+        }
+      end
+
+      # Determine spike severity based on multiplier
+      def spike_severity(multiplier)
+        case multiplier
+        when 0...2
+          :normal
+        when 2...5
+          :elevated
+        when 5...10
+          :high
+        else
+          :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/error_cascades.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Find cascade patterns for an error (what causes it, what it causes)
+    #
+    # A cascade is when one error leads to another within a time window.
+    # This helps identify root causes vs symptoms.
+    #
+    # @example
+    #   cascades = ErrorCascades.call(error_id: 123)
+    #   cascades[:parents]  # Errors that cause this one
+    #   cascades[:children] # Errors this one causes
+    class ErrorCascades
+      def self.call(error_id:, min_probability: 0.5)
+        new(error_id, min_probability: min_probability).find_cascades
+      end
+
+      def initialize(error_id, min_probability: 0.5)
+        @error_id = error_id
+        @min_probability = min_probability.to_f
+      end
+
+      def find_cascades
+        return { parents: [], children: [] } unless defined?(CascadePattern)
+        return { parents: [], children: [] } unless CascadePattern.table_exists?
+
+        target_error = ErrorLog.find_by(id: @error_id)
+        return { parents: [], children: [] } unless target_error
+
+        {
+          parents: find_parent_cascades,
+          children: find_child_cascades
+        }
+      end
+
+      private
+
+      def find_parent_cascades
+        # Errors that cause this error (this error is the child)
+        CascadePattern
+          .by_child(@error_id)
+          .where("cascade_probability >= ?", @min_probability)
+          .includes(:parent_error)
+          .order(cascade_probability: :desc)
+          .map do |pattern|
+            {
+              error: pattern.parent_error,
+              frequency: pattern.frequency,
+              probability: pattern.cascade_probability,
+              avg_delay_seconds: pattern.avg_delay_seconds
+            }
+          end
+      end
+
+      def find_child_cascades
+        # Errors caused by this error (this error is the parent)
+        CascadePattern
+          .by_parent(@error_id)
+          .where("cascade_probability >= ?", @min_probability)
+          .includes(:child_error)
+          .order(cascade_probability: :desc)
+          .map do |pattern|
+            {
+              error: pattern.child_error,
+              frequency: pattern.frequency,
+              probability: pattern.cascade_probability,
+              avg_delay_seconds: pattern.avg_delay_seconds
+            }
+          end
+      end
+    end
+  end
+end