rails_error_dashboard 0.1.0 → 0.1.3

data/app/jobs/rails_error_dashboard/application_job.rb

@@ -1,4 +1,23 @@
 module RailsErrorDashboard
   class ApplicationJob < ActiveJob::Base
+    # CRITICAL: Ensure job failures don't break the app or spam error logs
+    # Retry failed jobs with exponential backoff, but limit attempts
+    retry_on StandardError, wait: :exponentially_longer, attempts: 3
+
+    # Global exception handling for all dashboard jobs
+    rescue_from StandardError do |exception|
+      # Log the error for debugging but don't propagate
+      Rails.logger.error("[RailsErrorDashboard] Job #{self.class.name} failed: #{exception.class} - #{exception.message}")
+      Rails.logger.error("Job arguments: #{arguments.inspect}")
+      Rails.logger.error("Attempt: #{executions}/3") if respond_to?(:executions)
+      Rails.logger.error(exception.backtrace&.first(10)&.join("\n")) if exception.backtrace
+
+      # Re-raise to trigger retry mechanism (up to 3 attempts)
+      # After 3 attempts, ActiveJob will discard the job and log it
+      raise exception if executions < 3
+
+      # If we've exhausted retries, log and give up gracefully
+      Rails.logger.error("[RailsErrorDashboard] Job #{self.class.name} discarded after #{executions} attempts")
+    end
   end
 end

data/app/jobs/rails_error_dashboard/async_error_logging_job.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Background job for asynchronous error logging
+  # This prevents error logging from blocking the main request/response cycle
+  class AsyncErrorLoggingJob < ApplicationJob
+    queue_as :default
+
+    # Performs async error logging
+    # @param exception_data [Hash] Serialized exception data
+    # @param context [Hash] Error context (request, user, etc.)
+    def perform(exception_data, context)
+      # Reconstruct the exception from serialized data
+      exception = reconstruct_exception(exception_data)
+
+      # Log the error synchronously in the background job
+      # Call .new().call to bypass async check (we're already async)
+      Commands::LogError.new(exception, context).call
+    rescue => e
+      # Don't let async job errors break the job queue
+      Rails.logger.error("AsyncErrorLoggingJob failed: #{e.message}")
+      Rails.logger.error("Backtrace: #{e.backtrace&.first(5)&.join("\n")}")
+    end
+
+    private
+
+    # Reconstruct exception from serialized data
+    # @param data [Hash] Serialized exception data
+    # @return [Exception] Reconstructed exception object
+    def reconstruct_exception(data)
+      # Get or create the exception class
+      exception_class = begin
+        data[:class_name].constantize
+      rescue NameError
+        # If class doesn't exist, use StandardError
+        StandardError
+      end
+
+      # Create new exception with the original message
+      exception = exception_class.new(data[:message])
+
+      # Restore the backtrace
+      exception.set_backtrace(data[:backtrace]) if data[:backtrace]
+
+      exception
+    end
+  end
+end

data/app/jobs/rails_error_dashboard/baseline_alert_job.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Sends baseline anomaly alerts through configured notification channels
+  #
+  # This job is triggered when an error exceeds baseline thresholds.
+  # It respects cooldown periods to prevent alert fatigue and sends
+  # notifications through all enabled channels (Slack, Email, Discord, etc.)
+  class BaselineAlertJob < ApplicationJob
+    queue_as :default
+
+    # @param error_log_id [Integer] The error log that triggered the alert
+    # @param anomaly_data [Hash] Anomaly information from baseline check
+    def perform(error_log_id, anomaly_data)
+      error_log = ErrorLog.find_by(id: error_log_id)
+      return unless error_log
+
+      config = RailsErrorDashboard.configuration
+
+      # Check if we should send alert (cooldown check)
+      unless Services::BaselineAlertThrottler.should_alert?(
+        error_log.error_type,
+        error_log.platform,
+        cooldown_minutes: config.baseline_alert_cooldown_minutes
+      )
+        Rails.logger.info(
+          "Baseline alert throttled for #{error_log.error_type} on #{error_log.platform}"
+        )
+        return
+      end
+
+      # Record that we're sending an alert
+      Services::BaselineAlertThrottler.record_alert(
+        error_log.error_type,
+        error_log.platform
+      )
+
+      # Send notifications through all enabled channels
+      send_notifications(error_log, anomaly_data, config)
+    end
+
+    private
+
+    def send_notifications(error_log, anomaly_data, config)
+      # Slack notification
+      if config.enable_slack_notifications && config.slack_webhook_url.present?
+        send_slack_notification(error_log, anomaly_data, config)
+      end
+
+      # Email notification
+      if config.enable_email_notifications && config.notification_email_recipients.any?
+        send_email_notification(error_log, anomaly_data, config)
+      end
+
+      # Discord notification
+      if config.enable_discord_notifications && config.discord_webhook_url.present?
+        send_discord_notification(error_log, anomaly_data, config)
+      end
+
+      # Webhook notification
+      if config.enable_webhook_notifications && config.webhook_urls.any?
+        send_webhook_notification(error_log, anomaly_data, config)
+      end
+
+      # PagerDuty for critical anomalies
+      if config.enable_pagerduty_notifications &&
+         config.pagerduty_integration_key.present? &&
+         anomaly_data[:level] == :critical
+        send_pagerduty_notification(error_log, anomaly_data, config)
+      end
+    end
+
+    def send_slack_notification(error_log, anomaly_data, config)
+      payload = build_slack_payload(error_log, anomaly_data, config)
+
+      HTTParty.post(
+        config.slack_webhook_url,
+        body: payload.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+    rescue => e
+      Rails.logger.error("Failed to send baseline alert to Slack: #{e.message}")
+    end
+
+    def send_email_notification(error_log, _anomaly_data, _config)
+      # Use existing email notification infrastructure if available
+      # For now, log that email would be sent
+      Rails.logger.info(
+        "Baseline alert email would be sent for #{error_log.error_type}"
+      )
+    rescue => e
+      Rails.logger.error("Failed to send baseline alert email: #{e.message}")
+    end
+
+    def send_discord_notification(error_log, anomaly_data, config)
+      payload = build_discord_payload(error_log, anomaly_data, config)
+
+      HTTParty.post(
+        config.discord_webhook_url,
+        body: payload.to_json,
+        headers: { "Content-Type" => "application/json" }
+      )
+    rescue => e
+      Rails.logger.error("Failed to send baseline alert to Discord: #{e.message}")
+    end
+
+    def send_webhook_notification(error_log, anomaly_data, config)
+      payload = build_webhook_payload(error_log, anomaly_data)
+
+      config.webhook_urls.each do |url|
+        HTTParty.post(
+          url,
+          body: payload.to_json,
+          headers: { "Content-Type" => "application/json" }
+        )
+      end
+    rescue => e
+      Rails.logger.error("Failed to send baseline alert to webhook: #{e.message}")
+    end
+
+    def send_pagerduty_notification(error_log, _anomaly_data, _config)
+      # Use existing PagerDuty notification infrastructure if available
+      Rails.logger.info(
+        "Baseline alert PagerDuty notification for #{error_log.error_type}"
+      )
+    rescue => e
+      Rails.logger.error("Failed to send baseline alert to PagerDuty: #{e.message}")
+    end
+
+    # Build Slack message payload
+    def build_slack_payload(error_log, anomaly_data, config)
+      {
+        text: "🚨 Baseline Anomaly Alert",
+        blocks: [
+          {
+            type: "header",
+            text: {
+              type: "plain_text",
+              text: "🚨 Baseline Anomaly Detected"
+            }
+          },
+          {
+            type: "section",
+            fields: [
+              {
+                type: "mrkdwn",
+                text: "*Error Type:*\n#{error_log.error_type}"
+              },
+              {
+                type: "mrkdwn",
+                text: "*Platform:*\n#{error_log.platform}"
+              },
+              {
+                type: "mrkdwn",
+                text: "*Severity:*\n#{anomaly_level_emoji(anomaly_data[:level])} #{anomaly_data[:level].to_s.upcase}"
+              },
+              {
+                type: "mrkdwn",
+                text: "*Standard Deviations:*\n#{anomaly_data[:std_devs_above]&.round(1)}σ above baseline"
+              }
+            ]
+          },
+          {
+            type: "section",
+            text: {
+              type: "mrkdwn",
+              text: "*Message:*\n```#{error_log.message.truncate(200)}```"
+            }
+          },
+          {
+            type: "section",
+            text: {
+              type: "mrkdwn",
+              text: "*Baseline Info:*\nThreshold: #{anomaly_data[:threshold]&.round(1)} errors\nBaseline Type: #{anomaly_data[:baseline_type]}"
+            }
+          },
+          {
+            type: "actions",
+            elements: [
+              {
+                type: "button",
+                text: {
+                  type: "plain_text",
+                  text: "View in Dashboard"
+                },
+                url: dashboard_url(error_log, config)
+              }
+            ]
+          }
+        ]
+      }
+    end
+
+    # Build Discord embed payload
+    def build_discord_payload(error_log, anomaly_data, config)
+      {
+        embeds: [
+          {
+            title: "🚨 Baseline Anomaly Detected",
+            color: anomaly_color(anomaly_data[:level]),
+            fields: [
+              { name: "Error Type", value: error_log.error_type, inline: true },
+              { name: "Platform", value: error_log.platform, inline: true },
+              { name: "Severity", value: anomaly_data[:level].to_s.upcase, inline: true },
+              { name: "Standard Deviations", value: "#{anomaly_data[:std_devs_above]&.round(1)}σ above baseline", inline: true },
+              { name: "Threshold", value: "#{anomaly_data[:threshold]&.round(1)} errors", inline: true },
+              { name: "Baseline Type", value: anomaly_data[:baseline_type] || "N/A", inline: true },
+              { name: "Message", value: "```#{error_log.message.truncate(200)}```", inline: false }
+            ],
+            url: dashboard_url(error_log, config),
+            timestamp: Time.current.iso8601
+          }
+        ]
+      }
+    end
+
+    # Build generic webhook payload
+    def build_webhook_payload(error_log, anomaly_data)
+      {
+        event: "baseline_anomaly",
+        timestamp: Time.current.iso8601,
+        error: {
+          id: error_log.id,
+          type: error_log.error_type,
+          message: error_log.message,
+          platform: error_log.platform,
+          severity: error_log.severity.to_s,
+          occurred_at: error_log.occurred_at.iso8601
+        },
+        anomaly: {
+          level: anomaly_data[:level].to_s,
+          std_devs_above: anomaly_data[:std_devs_above],
+          threshold: anomaly_data[:threshold],
+          baseline_type: anomaly_data[:baseline_type]
+        },
+        dashboard_url: dashboard_url(error_log, RailsErrorDashboard.configuration)
+      }
+    end
+
+    def anomaly_level_emoji(level)
+      case level
+      when :critical then "🔴"
+      when :high then "🟠"
+      when :elevated then "🟡"
+      else "⚪"
+      end
+    end
+
+    def anomaly_color(level)
+      case level
+      when :critical then 15158332 # Red
+      when :high then 16744192 # Orange
+      when :elevated then 16776960 # Yellow
+      else 9807270 # Gray
+      end
+    end
+
+    def dashboard_url(error_log, config)
+      base_url = config.dashboard_base_url || "http://localhost:3000"
+      "#{base_url}/error_dashboard/errors/#{error_log.id}"
+    end
+  end
+end

data/app/jobs/rails_error_dashboard/discord_error_notification_job.rb

@@ -18,11 +18,12 @@ module RailsErrorDashboard
       HTTParty.post(
         webhook_url,
         body: payload.to_json,
-        headers: { "Content-Type" => "application/json" }
+        headers: { "Content-Type" => "application/json" },
+        timeout: 10  # CRITICAL: 10 second timeout to prevent hanging
       )
     rescue StandardError => e
-      Rails.logger.error("Failed to send Discord notification: #{e.message}")
-      Rails.logger.error(e.backtrace.join("\n"))
+      Rails.logger.error("[RailsErrorDashboard] Failed to send Discord notification: #{e.message}")
+      Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
     end
 
     private
@@ -39,11 +40,6 @@ module RailsErrorDashboard
               value: error_log.platform || "Unknown",
               inline: true
             },
-            {
-              name: "Environment",
-              value: error_log.environment || "Unknown",
-              inline: true
-            },
             {
               name: "Occurrences",
               value: error_log.occurrence_count.to_s,

data/app/jobs/rails_error_dashboard/email_error_notification_job.rb

@@ -13,7 +13,8 @@ module RailsErrorDashboard
 
       ErrorNotificationMailer.error_alert(error_log, recipients).deliver_now
     rescue => e
-      Rails.logger.error("Failed to send email notification: #{e.message}")
+      Rails.logger.error("[RailsErrorDashboard] Failed to send email notification: #{e.message}")
+      Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
     end
   end
 end

data/app/jobs/rails_error_dashboard/pagerduty_error_notification_job.rb

@@ -24,15 +24,16 @@ module RailsErrorDashboard
       response = HTTParty.post(
         PAGERDUTY_EVENTS_API,
         body: payload.to_json,
-        headers: { "Content-Type" => "application/json" }
+        headers: { "Content-Type" => "application/json" },
+        timeout: 10  # CRITICAL: 10 second timeout to prevent hanging
       )
 
       unless response.success?
-        Rails.logger.error("PagerDuty API error: #{response.code} - #{response.body}")
+        Rails.logger.error("[RailsErrorDashboard] PagerDuty API error: #{response.code} - #{response.body}")
       end
     rescue StandardError => e
-      Rails.logger.error("Failed to send PagerDuty notification: #{e.message}")
-      Rails.logger.error(e.backtrace.join("\n"))
+      Rails.logger.error("[RailsErrorDashboard] Failed to send PagerDuty notification: #{e.message}")
+      Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
     end
 
     private
@@ -53,7 +54,6 @@ module RailsErrorDashboard
             controller: error_log.controller_name,
             action: error_log.action_name,
             platform: error_log.platform,
-            environment: error_log.environment,
             occurrences: error_log.occurrence_count,
             first_seen_at: error_log.first_seen_at&.iso8601,
             last_seen_at: error_log.last_seen_at&.iso8601,

data/app/jobs/rails_error_dashboard/slack_error_notification_job.rb

@@ -26,19 +26,27 @@ module RailsErrorDashboard
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = true
 
+      # CRITICAL: Add timeouts to prevent hanging the job queue
+      http.open_timeout = 5  # 5 seconds to establish connection
+      http.read_timeout = 10  # 10 seconds to read response
+
       request = Net::HTTP::Post.new(uri.path, { "Content-Type" => "application/json" })
       request.body = slack_payload(error_log).to_json
 
       response = http.request(request)
 
       unless response.is_a?(Net::HTTPSuccess)
-        Rails.logger.error("Slack notification failed: #{response.code} - #{response.body}")
+        Rails.logger.error("[RailsErrorDashboard] Slack notification failed: #{response.code} - #{response.body}")
       end
+    rescue Timeout::Error, Errno::ECONNREFUSED, SocketError, Net::OpenTimeout, Net::ReadTimeout => e
+      # Network errors - log and fail gracefully
+      Rails.logger.error("[RailsErrorDashboard] Slack HTTP request failed: #{e.class} - #{e.message}")
+      nil
     end
 
     def slack_payload(error_log)
       {
-        text: "🚨 New Error in #{error_log.environment.titleize} Environment",
+        text: "🚨 New Error Alert",
         blocks: [
           {
             type: "header",
@@ -55,10 +63,6 @@ module RailsErrorDashboard
                 type: "mrkdwn",
                 text: "*Error Type:*\n`#{error_log.error_type}`"
               },
-              {
-                type: "mrkdwn",
-                text: "*Environment:*\n#{error_log.environment.titleize}"
-              },
               {
                 type: "mrkdwn",
                 text: "*Platform:*\n#{platform_emoji(error_log.platform)} #{error_log.platform || 'Unknown'}"

data/app/jobs/rails_error_dashboard/webhook_error_notification_job.rb

@@ -23,8 +23,8 @@ module RailsErrorDashboard
         send_webhook(url, payload, error_log)
       end
     rescue StandardError => e
-      Rails.logger.error("Failed to send webhook notification: #{e.message}")
-      Rails.logger.error(e.backtrace.join("\n"))
+      Rails.logger.error("[RailsErrorDashboard] Failed to send webhook notification: #{e.message}")
+      Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
     end
 
     private
@@ -39,14 +39,14 @@ module RailsErrorDashboard
           "X-Error-Dashboard-Event" => "error.created",
           "X-Error-Dashboard-ID" => error_log.id.to_s
         },
-        timeout: 10 # 10 second timeout
+        timeout: 10  # CRITICAL: 10 second timeout to prevent hanging
       )
 
       unless response.success?
-        Rails.logger.warn("Webhook failed for #{url}: #{response.code}")
+        Rails.logger.warn("[RailsErrorDashboard] Webhook failed for #{url}: #{response.code}")
       end
     rescue StandardError => e
-      Rails.logger.error("Webhook error for #{url}: #{e.message}")
+      Rails.logger.error("[RailsErrorDashboard] Webhook error for #{url}: #{e.message}")
     end
 
     def build_webhook_payload(error_log)
@@ -59,7 +59,6 @@ module RailsErrorDashboard
           message: error_log.message,
           severity: error_log.severity.to_s,
           platform: error_log.platform,
-          environment: error_log.environment,
           controller: error_log.controller_name,
           action: error_log.action_name,
           occurrence_count: error_log.occurrence_count,

data/app/mailers/rails_error_dashboard/application_mailer.rb

@@ -3,6 +3,6 @@
 module RailsErrorDashboard
   class ApplicationMailer < ActionMailer::Base
     default from: -> { RailsErrorDashboard.configuration.notification_email_from }
-    layout "mailer"
+    layout false
   end
 end

data/app/mailers/rails_error_dashboard/error_notification_mailer.rb

@@ -8,7 +8,7 @@ module RailsErrorDashboard
 
       mail(
         to: recipients,
-        subject: "🚨 [#{error_log.environment.upcase}] #{error_log.error_type}: #{truncate_subject(error_log.message)}"
+        subject: "🚨 #{error_log.error_type}: #{truncate_subject(error_log.message)}"
       )
     end
 

data/app/models/rails_error_dashboard/cascade_pattern.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Tracks cascade patterns where one error causes another
+  #
+  # A cascade pattern represents a causal relationship between errors:
+  # Parent Error → Child Error
+  #
+  # For example: DatabaseConnectionError → NoMethodError
+  # When a database connection fails, subsequent code may try to call
+  # methods on nil objects, causing NoMethodError.
+  #
+  # @attr parent_error_id [Integer] The error that happens first (potential cause)
+  # @attr child_error_id [Integer] The error that happens after (potential effect)
+  # @attr frequency [Integer] How many times this cascade has been observed
+  # @attr avg_delay_seconds [Float] Average time between parent and child
+  # @attr cascade_probability [Float] Likelihood (0.0-1.0) that parent causes child
+  # @attr last_detected_at [DateTime] When this cascade was last observed
+  class CascadePattern < ErrorLogsRecord
+    self.table_name = "rails_error_dashboard_cascade_patterns"
+
+    belongs_to :parent_error, class_name: "RailsErrorDashboard::ErrorLog"
+    belongs_to :child_error, class_name: "RailsErrorDashboard::ErrorLog"
+
+    validates :parent_error_id, presence: true
+    validates :child_error_id, presence: true
+    validates :frequency, presence: true, numericality: { greater_than: 0 }
+    validate :parent_and_child_must_be_different
+
+    scope :high_confidence, -> { where("cascade_probability >= ?", 0.7) }
+    scope :frequent, ->(min_frequency = 3) { where("frequency >= ?", min_frequency) }
+    scope :recent, -> { order(last_detected_at: :desc) }
+    scope :by_parent, ->(error_id) { where(parent_error_id: error_id) }
+    scope :by_child, ->(error_id) { where(child_error_id: error_id) }
+
+    # Update cascade pattern stats
+    def increment_detection!(delay_seconds)
+      self.frequency += 1
+
+      # Update average delay using incremental formula
+      if avg_delay_seconds.present?
+        self.avg_delay_seconds = ((avg_delay_seconds * (frequency - 1)) + delay_seconds) / frequency
+      else
+        self.avg_delay_seconds = delay_seconds
+      end
+
+      self.last_detected_at = Time.current
+      save
+    end
+
+    # Calculate cascade probability based on frequency
+    # Probability = (times child follows parent) / (total parent occurrences)
+    def calculate_probability!
+      parent_occurrence_count = parent_error.error_occurrences.count
+      return if parent_occurrence_count.zero?
+
+      self.cascade_probability = (frequency.to_f / parent_occurrence_count).round(3)
+      save
+    end
+
+    # Check if this is a strong cascade pattern
+    def strong_cascade?
+      cascade_probability.present? && cascade_probability >= 0.7 && frequency >= 3
+    end
+
+    private
+
+    def parent_and_child_must_be_different
+      if parent_error_id == child_error_id
+        errors.add(:child_error_id, "cannot be the same as parent error")
+      end
+    end
+  end
+end

data/app/models/rails_error_dashboard/error_baseline.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Stores baseline statistics for error types
+  #
+  # Baselines are calculated periodically (hourly, daily, weekly) to establish
+  # "normal" error behavior. This enables anomaly detection by comparing current
+  # error counts against historical baselines.
+  #
+  # @attr error_type [String] The type of error (e.g., "NoMethodError")
+  # @attr platform [String] Platform (iOS, Android, API, Web)
+  # @attr baseline_type [String] Time period type (hourly, daily, weekly)
+  # @attr period_start [DateTime] Start of the period this baseline covers
+  # @attr period_end [DateTime] End of the period this baseline covers
+  # @attr count [Integer] Total errors in this period
+  # @attr mean [Float] Average error count
+  # @attr std_dev [Float] Standard deviation
+  # @attr percentile_95 [Float] 95th percentile
+  # @attr percentile_99 [Float] 99th percentile
+  # @attr sample_size [Integer] Number of periods in the sample
+  class ErrorBaseline < ErrorLogsRecord
+    self.table_name = "rails_error_dashboard_error_baselines"
+
+    BASELINE_TYPES = %w[hourly daily weekly].freeze
+
+    validates :error_type, presence: true
+    validates :platform, presence: true
+    validates :baseline_type, presence: true, inclusion: { in: BASELINE_TYPES }
+    validates :period_start, presence: true
+    validates :period_end, presence: true
+    validates :count, presence: true, numericality: { greater_than_or_equal_to: 0 }
+    validates :sample_size, presence: true, numericality: { greater_than_or_equal_to: 0 }
+
+    validate :period_end_after_period_start
+
+    scope :for_error_type, ->(error_type) { where(error_type: error_type) }
+    scope :for_platform, ->(platform) { where(platform: platform) }
+    scope :hourly, -> { where(baseline_type: "hourly") }
+    scope :daily, -> { where(baseline_type: "daily") }
+    scope :weekly, -> { where(baseline_type: "weekly") }
+    scope :recent, -> { order(period_start: :desc) }
+
+    # Check if a given count is anomalous compared to this baseline
+    # @param current_count [Integer] Current error count to check
+    # @param sensitivity [Integer] Number of standard deviations (default: 2)
+    # @return [Symbol, nil] :elevated, :high, :critical, or nil if normal
+    def anomaly_level(current_count, sensitivity: 2)
+      return nil if mean.nil? || std_dev.nil?
+      return nil if current_count <= mean
+
+      std_devs_above = (current_count - mean) / std_dev
+
+      case std_devs_above
+      when sensitivity..(sensitivity + 1)
+        :elevated
+      when (sensitivity + 1)..(sensitivity + 2)
+        :high
+      when (sensitivity + 2)..Float::INFINITY
+        :critical
+      else
+        nil
+      end
+    end
+
+    # Check if current count is above baseline
+    # @param current_count [Integer] Current error count
+    # @param sensitivity [Integer] Number of standard deviations (default: 2)
+    # @return [Boolean] True if count exceeds baseline + (sensitivity * std_dev)
+    def exceeds_baseline?(current_count, sensitivity: 2)
+      return false if mean.nil? || std_dev.nil?
+      current_count > (mean + (sensitivity * std_dev))
+    end
+
+    # Get the threshold for anomaly detection
+    # @param sensitivity [Integer] Number of standard deviations (default: 2)
+    # @return [Float, nil] Threshold value or nil if stats not available
+    def threshold(sensitivity: 2)
+      return nil if mean.nil? || std_dev.nil?
+      mean + (sensitivity * std_dev)
+    end
+
+    # Calculate how many standard deviations above mean
+    # @param current_count [Integer] Current error count
+    # @return [Float, nil] Number of standard deviations or nil
+    def std_devs_above_mean(current_count)
+      return nil if mean.nil? || std_dev.nil? || std_dev.zero?
+      (current_count - mean) / std_dev
+    end
+
+    private
+
+    def period_end_after_period_start
+      return if period_start.nil? || period_end.nil?
+
+      if period_end <= period_start
+        errors.add(:period_end, "must be after period_start")
+      end
+    end
+  end
+end