Error Correlation Guide

RailsErrorDashboard.configure do |config|
  config.enable_error_correlation = true
end

correlation = RailsErrorDashboard::Queries::ErrorCorrelation.new(days: 30)
versions = correlation.errors_by_version

versions.each do |version, data|
  puts "Version: #{version}"
  puts "  Total Errors: #{data[:count]}"
  puts "  Error Types: #{data[:error_types]}"
  puts "  Critical Errors: #{data[:critical_count]}"
  puts "  Platforms: #{data[:platforms].join(', ')}"
  puts "  First Seen: #{data[:first_seen]}"
  puts "  Last Seen: #{data[:last_seen]}"
end

shas = correlation.errors_by_git_sha

shas.each do |sha, data|
  puts "Commit: #{sha[0..7]}"
  puts "  Total Errors: #{data[:count]}"
  puts "  Error Types: #{data[:error_types]}"
  puts "  App Versions: #{data[:app_versions].join(', ')}"
end

problematic = correlation.problematic_releases

problematic.each do |release|
  puts "⚠️  Version #{release[:version]}"
  puts "   Errors: #{release[:error_count]}"
  puts "   Deviation: +#{release[:deviation_from_avg]}% from average"
  puts "   Critical: #{release[:critical_count]}"
  puts "   Error Types: #{release[:error_types]}"
end

# When logging errors
RailsErrorDashboard::Commands::LogError.call(
  error_type: "NoMethodError",
  message: "undefined method 'name'",
  backtrace: [...],
  app_version: "2.1.0",        # Required for version correlation
  git_sha: "a3b4c5d6e7f8",     # Optional, for commit correlation
  # ...
)

correlation = RailsErrorDashboard::Queries::ErrorCorrelation.new(days: 30)
multi_error_users = correlation.multi_error_users(min_error_types: 2)

multi_error_users.each do |user_data|
  puts "User: #{user_data[:user_email]}"
  puts "  Error Types: #{user_data[:error_type_count]}"
  puts "  Total Errors: #{user_data[:total_errors]}"
  puts "  Types: #{user_data[:error_types].join(', ')}"
end

overlap = correlation.error_type_user_overlap(
  "NoMethodError",
  "ArgumentError"
)

puts "Users with NoMethodError: #{overlap[:users_a_count]}"
puts "Users with ArgumentError: #{overlap[:users_b_count]}"
puts "Users with both: #{overlap[:overlap_count]}"
puts "Overlap percentage: #{overlap[:overlap_percentage]}%"
puts "Sample users: #{overlap[:overlapping_user_ids].join(', ')}"

# config/initializers/rails_error_dashboard.rb
RailsErrorDashboard.configure do |config|
  config.user_model = "User"  # Your user model class name
end

# When logging errors
RailsErrorDashboard::Commands::LogError.call(
  error_type: "NoMethodError",
  user_id: current_user.id,  # Required for user correlation
  # ...
)

correlation = RailsErrorDashboard::Queries::ErrorCorrelation.new(days: 30)
time_correlated = correlation.time_correlated_errors

time_correlated.each do |pair_name, data|
  puts "#{data[:error_type_a]} ↔ #{data[:error_type_b]}"
  puts "  Correlation: #{(data[:correlation] * 100).round}%"
  puts "  Strength: #{data[:strength]}"
end

def calculate_time_correlation(series_a, series_b)
  # series_a and series_b are arrays of 24 elements (hourly counts)

  # Calculate means
  mean_a = series_a.sum.to_f / 24
  mean_b = series_b.sum.to_f / 24

  # Calculate covariance and standard deviations
  covariance = 0.0
  std_a = 0.0
  std_b = 0.0

  24.times do |i|
    diff_a = series_a[i] - mean_a
    diff_b = series_b[i] - mean_b
    covariance += diff_a * diff_b
    std_a += diff_a**2
    std_b += diff_b**2
  end

  # Pearson correlation
  correlation = covariance / Math.sqrt(std_a * std_b)
  correlation.round(3)
end

correlation = RailsErrorDashboard::Queries::ErrorCorrelation.new(days: 30)
comparison = correlation.period_comparison

puts "Current Period (last #{days/2} days):"
puts "  Errors: #{comparison[:current_period][:count]}"
puts "  #{comparison[:current_period][:start]} to #{comparison[:current_period][:end]}"

puts "Previous Period (#{days/2} days before):"
puts "  Errors: #{comparison[:previous_period][:count]}"
puts "  #{comparison[:previous_period][:start]} to #{comparison[:previous_period][:end]}"

puts "Change: #{comparison[:change]} (#{comparison[:change_percentage]}%)"
puts "Trend: #{comparison[:trend]}"

correlation = ErrorCorrelation.new(days: 7)
versions = correlation.errors_by_version

v210 = versions["2.1.0"]
v205 = versions["2.0.5"]

puts "v2.1.0: #{v210[:count]} errors, #{v210[:error_types]} types"
puts "v2.0.5: #{v205[:count]} errors, #{v205[:error_types]} types"
puts "Increase: +#{v210[:count] - v205[:count]} errors"

multi_error_users = correlation.multi_error_users(min_error_types: 3)

multi_error_users.first(5).each do |user|
  puts "#{user[:user_email]}: #{user[:error_type_count]} types, #{user[:total_errors]} errors"
end

time_correlated = correlation.time_correlated_errors

# Find errors correlated with DatabaseError
database_correlated = time_correlated.select do |_, data|
  data[:error_type_a] == "DatabaseError" || data[:error_type_b] == "DatabaseError"
end

database_correlated.each do |_, data|
  other_error = data[:error_type_a] == "DatabaseError" ? data[:error_type_b] : data[:error_type_a]
  puts "#{other_error}: #{(data[:correlation] * 100).round}% correlation"
end

# Weekly checks
week1 = ErrorCorrelation.new(days: 7).period_comparison
week2 = ErrorCorrelation.new(days: 14).period_comparison
month = ErrorCorrelation.new(days: 30).period_comparison

puts "This week: #{week1[:trend]} (#{week1[:change_percentage]}%)"
puts "Last 2 weeks: #{week2[:trend]} (#{week2[:change_percentage]}%)"
puts "Last month: #{month[:trend]} (#{month[:change_percentage]}%)"

# Assume feature deployed in v2.1.0
correlation = ErrorCorrelation.new(days: 14)

# Users on new version
v210_errors = correlation.errors_by_version["2.1.0"]

# Users still on old version
v205_errors = correlation.errors_by_version["2.0.5"]

puts "New version (v2.1.0): #{v210_errors[:count]} errors"
puts "Old version (v2.0.5): #{v205_errors[:count]} errors"

# db/migrate/XXXXXX_add_correlation_columns.rb
class AddCorrelationColumns < ActiveRecord::Migration[7.0]
  def change
    add_column :rails_error_dashboard_error_logs, :app_version, :string
    add_column :rails_error_dashboard_error_logs, :git_sha, :string
    add_column :rails_error_dashboard_error_logs, :user_id, :integer

    add_index :rails_error_dashboard_error_logs, :app_version
    add_index :rails_error_dashboard_error_logs, :git_sha
    add_index :rails_error_dashboard_error_logs, :user_id
  end
end

# config/initializers/rails_error_dashboard.rb
RailsErrorDashboard.configure do |config|
  config.user_model = "User"  # Your user model class
end

# In your error handler
RailsErrorDashboard::Commands::LogError.call(
  error_type: error.class.name,
  message: error.message,
  backtrace: error.backtrace,

  # Release correlation
  app_version: ENV['APP_VERSION'] || "unknown",
  git_sha: ENV['GIT_SHA'] || `git rev-parse HEAD`.strip,

  # User correlation
  user_id: current_user&.id,

  # Other metadata
  platform: request.user_agent =~ /iPhone/ ? "iOS" : "Android",
  # ...
)

# config/application.rb
config.app_version = ENV['APP_VERSION'] || '1.0.0'

# Or read from package.json, build number, etc.

# In a scheduled job
correlation = ErrorCorrelation.new(days: 1)
problematic = correlation.problematic_releases

if problematic.any?
  AlertService.notify(
    title: "Problematic releases detected",
    releases: problematic.map { |r| "#{r[:version]} (+#{r[:deviation_from_avg]}%)" }
  )
end

# In a scheduled report
multi_error_users = correlation.multi_error_users(min_error_types: 3)
top_10 = multi_error_users.first(10)

CsTeam.send_report(
  title: "Top 10 Most Impacted Users",
  users: top_10
)

correlated = correlation.time_correlated_errors
mystery_error_corr = correlated.select do |_, data|
  data[:error_type_a] == "MysteryError" || data[:error_type_b] == "MysteryError"
end

# If all correlated errors involve ExternalAPI
# → MysteryError is caused by ExternalAPI issues

# Wait 24 hours, then check
before_fix = ErrorCorrelation.new(days: 14).period_comparison
after_fix = ErrorCorrelation.new(days: 7).period_comparison

if after_fix[:trend] == :decreasing
  puts "Fix is working! Errors down #{after_fix[:change_percentage]}%"
else
  puts "Fix didn't help. Keep investigating."
end

# Add column
rails g migration add_app_version_to_error_logs app_version:string
rails db:migrate

# Ensure errors include version
RailsErrorDashboard::Commands::LogError.call(
  app_version: ENV['APP_VERSION'],  # Must be set!
  # ...
)

# Verify configuration
RailsErrorDashboard.configuration.user_model
# => "User"

# Check if User model has email
User.column_names.include?('email')
# => true

# If using different attribute:
# Update find_user_email method in error_correlation.rb

# Check distinct error types
ErrorLog.distinct.pluck(:error_type).count
# If < 2, wait for more data

# Lower correlation threshold to see weaker correlations
# (requires code change to min correlation threshold)

# Instead of using days parameter (which splits in half)
# Query specific periods:
current = ErrorLog.where("occurred_at >= ?", deployment_date).count
previous = ErrorLog.where("occurred_at < ?", deployment_date).where("occurred_at >= ?", deployment_date - 7.days).count

correlation = RailsErrorDashboard::Queries::ErrorCorrelation.new(days: 30)

# Release correlation
correlation.errors_by_version
# => { "2.1.0" => { count: 450, error_types: 23, ... }, ... }

correlation.errors_by_git_sha
# => { "a3b4c5d6" => { count: 280, error_types: 15, ... }, ... }

correlation.problematic_releases
# => [{ version: "2.1.0", error_count: 450, deviation_from_avg: 275.0, ... }]

# User correlation
correlation.multi_error_users(min_error_types: 2)
# => [{ user_id: 45, user_email: "...", error_types: [...], total_errors: 23 }]

correlation.error_type_user_overlap("NoMethodError", "ArgumentError")
# => { users_a_count: 150, users_b_count: 120, overlap_count: 80, overlap_percentage: 66.7 }

# Time correlation
correlation.time_correlated_errors
# => { "NoMethodError <-> DatabaseError" => { correlation: 0.85, strength: :strong } }

# Period comparison
correlation.period_comparison
# => { current_period: {...}, previous_period: {...}, change: 650, change_percentage: 54.2, trend: :increasing_significantly }

# Platform-specific errors
correlation.platform_specific_errors
# => { "iOS" => [{ error_type: "...", count: 120, platform_specific: true }] }