rails_error_dashboard 0.1.0 → 0.1.1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -79,6 +79,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: turbo-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -225,10 +239,11 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.5'
-description: "⚠️ BETA: Rails Error Dashboard provides error tracking with a beautiful
-  UI, multi-channel notifications (Slack, Email, Discord, PagerDuty), platform detection
-  (iOS/Android/Web/API), analytics, and optional separate database support. Works
-  with Rails 7.0-8.0. API may change before v1.0.0."
+description: 'Own your errors. Own your stack. A fully open-source, self-hosted error
+  dashboard for solo founders, indie hackers, and small teams. Professional error
+  tracking with beautiful UI, multi-channel notifications (Slack, Email, Discord,
+  PagerDuty), platform detection (iOS/Android/Web/API), and analytics. 5-minute setup,
+  works out-of-the-box. Rails 7.0-8.1 compatible. ⚠️ BETA: API may change before v1.0.0.'
 email:
 - anjan.jagirdar@gmail.com
 executables: []
@@ -243,6 +258,8 @@ files:
 - app/controllers/rails_error_dashboard/errors_controller.rb
 - app/helpers/rails_error_dashboard/application_helper.rb
 - app/jobs/rails_error_dashboard/application_job.rb
+- app/jobs/rails_error_dashboard/async_error_logging_job.rb
+- app/jobs/rails_error_dashboard/baseline_alert_job.rb
 - app/jobs/rails_error_dashboard/discord_error_notification_job.rb
 - app/jobs/rails_error_dashboard/email_error_notification_job.rb
 - app/jobs/rails_error_dashboard/pagerduty_error_notification_job.rb
@@ -250,23 +267,39 @@ files:
 - app/jobs/rails_error_dashboard/webhook_error_notification_job.rb
 - app/mailers/rails_error_dashboard/application_mailer.rb
 - app/mailers/rails_error_dashboard/error_notification_mailer.rb
-- app/models/rails_error_dashboard/application_record.rb
+- app/models/rails_error_dashboard/cascade_pattern.rb
+- app/models/rails_error_dashboard/error_baseline.rb
 - app/models/rails_error_dashboard/error_log.rb
 - app/models/rails_error_dashboard/error_logs_record.rb
+- app/models/rails_error_dashboard/error_occurrence.rb
 - app/views/layouts/rails_error_dashboard.html.erb
 - app/views/layouts/rails_error_dashboard/application.html.erb
 - app/views/rails_error_dashboard/error_notification_mailer/error_alert.html.erb
 - app/views/rails_error_dashboard/error_notification_mailer/error_alert.text.erb
+- app/views/rails_error_dashboard/errors/_error_row.html.erb
+- app/views/rails_error_dashboard/errors/_pattern_insights.html.erb
+- app/views/rails_error_dashboard/errors/_stats.html.erb
 - app/views/rails_error_dashboard/errors/analytics.html.erb
+- app/views/rails_error_dashboard/errors/correlation.html.erb
 - app/views/rails_error_dashboard/errors/index.html.erb
+- app/views/rails_error_dashboard/errors/platform_comparison.html.erb
 - app/views/rails_error_dashboard/errors/show.html.erb
 - config/routes.rb
 - db/migrate/20251224000001_create_rails_error_dashboard_error_logs.rb
 - db/migrate/20251224081522_add_better_tracking_to_error_logs.rb
 - db/migrate/20251224101217_add_controller_action_to_error_logs.rb
+- db/migrate/20251225071314_add_optimized_indexes_to_error_logs.rb
+- db/migrate/20251225074653_remove_environment_from_error_logs.rb
+- db/migrate/20251225085859_add_enhanced_metrics_to_error_logs.rb
+- db/migrate/20251225093603_add_similarity_tracking_to_error_logs.rb
+- db/migrate/20251225100236_create_error_occurrences.rb
+- db/migrate/20251225101920_create_cascade_patterns.rb
+- db/migrate/20251225102500_create_error_baselines.rb
 - lib/generators/rails_error_dashboard/install/install_generator.rb
 - lib/generators/rails_error_dashboard/install/templates/README
 - lib/generators/rails_error_dashboard/install/templates/initializer.rb
+- lib/generators/rails_error_dashboard/solid_queue/solid_queue_generator.rb
+- lib/generators/rails_error_dashboard/solid_queue/templates/queue.yml
 - lib/rails_error_dashboard.rb
 - lib/rails_error_dashboard/commands/batch_delete_errors.rb
 - lib/rails_error_dashboard/commands/batch_resolve_errors.rb
@@ -282,12 +315,21 @@ files:
 - lib/rails_error_dashboard/plugins/jira_integration_plugin.rb
 - lib/rails_error_dashboard/plugins/metrics_plugin.rb
 - lib/rails_error_dashboard/queries/analytics_stats.rb
+- lib/rails_error_dashboard/queries/baseline_stats.rb
+- lib/rails_error_dashboard/queries/co_occurring_errors.rb
 - lib/rails_error_dashboard/queries/dashboard_stats.rb
-- lib/rails_error_dashboard/queries/developer_insights.rb
+- lib/rails_error_dashboard/queries/error_cascades.rb
+- lib/rails_error_dashboard/queries/error_correlation.rb
 - lib/rails_error_dashboard/queries/errors_list.rb
-- lib/rails_error_dashboard/queries/errors_list_v2.rb
 - lib/rails_error_dashboard/queries/filter_options.rb
+- lib/rails_error_dashboard/queries/platform_comparison.rb
+- lib/rails_error_dashboard/queries/similar_errors.rb
+- lib/rails_error_dashboard/services/baseline_alert_throttler.rb
+- lib/rails_error_dashboard/services/baseline_calculator.rb
+- lib/rails_error_dashboard/services/cascade_detector.rb
+- lib/rails_error_dashboard/services/pattern_detector.rb
 - lib/rails_error_dashboard/services/platform_detector.rb
+- lib/rails_error_dashboard/services/similarity_calculator.rb
 - lib/rails_error_dashboard/value_objects/error_context.rb
 - lib/rails_error_dashboard/version.rb
 - lib/tasks/rails_error_dashboard_tasks.rake
@@ -314,5 +356,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.7.2
 specification_version: 4
-summary: Beautiful error tracking dashboard for Rails applications (BETA)
+summary: Self-hosted Rails error monitoring — free, forever. Zero SaaS fees, zero
+  lock-in.
 test_files: []

data/app/models/rails_error_dashboard/application_record.rb

@@ -1,5 +0,0 @@
-module RailsErrorDashboard
-  class ApplicationRecord < ActiveRecord::Base
-    self.abstract_class = true
-  end
-end

data/lib/rails_error_dashboard/queries/developer_insights.rb

@@ -1,277 +0,0 @@
-# frozen_string_literal: true
-
-module RailsErrorDashboard
-  module Queries
-    # Query: Developer-focused insights
-    # Provides actionable metrics instead of environment breakdowns
-    class DeveloperInsights
-      def self.call(days = 7)
-        new(days).call
-      end
-
-      def initialize(days = 7)
-        @days = days
-        @start_date = days.days.ago
-      end
-
-      def call
-        {
-          critical_metrics: critical_metrics,
-          error_trends: error_trends,
-          hot_spots: hot_spots,
-          platform_health: platform_health,
-          resolution_metrics: resolution_metrics,
-          error_velocity: error_velocity,
-          top_impacted_users: top_impacted_users,
-          recurring_issues: recurring_issues
-        }
-      end
-
-      private
-
-      def base_query
-        @base_query ||= ErrorLog.where("occurred_at >= ?", @start_date)
-      end
-
-      # Critical metrics developers care about
-      def critical_metrics
-        {
-          total_errors: base_query.count,
-          unresolved_count: base_query.unresolved.count,
-          critical_unresolved: base_query.unresolved.where(
-            error_type: critical_error_types
-          ).count,
-          new_error_types: new_error_types_count,
-          recurring_errors: base_query.where("occurrence_count > ?", 5).count,
-          errors_last_hour: ErrorLog.where("occurred_at >= ?", 1.hour.ago).count,
-          errors_trending_up: errors_trending_up?
-        }
-      end
-
-      # Error trends over time
-      def error_trends
-        {
-          hourly: hourly_distribution,
-          daily: daily_distribution,
-          by_type_over_time: type_trends
-        }
-      end
-
-      # Hot spots - where errors are concentrated
-      def hot_spots
-        {
-          top_error_types: base_query.group(:error_type)
-                                    .order("count_id DESC")
-                                    .limit(10)
-                                    .count,
-          most_frequent: base_query.order(occurrence_count: :desc)
-                                  .limit(10)
-                                  .pluck(:error_type, :message, :occurrence_count)
-                                  .map { |type, msg, count|
-                                    { error_type: type, message: msg.truncate(100), count: count }
-                                  },
-          recent_spikes: detect_spikes
-        }
-      end
-
-      # Platform health breakdown
-      def platform_health
-        platforms = base_query.group(:platform).count
-
-        {
-          by_platform: platforms,
-          ios_stability: calculate_stability("iOS"),
-          android_stability: calculate_stability("Android"),
-          api_stability: calculate_stability("API")
-        }
-      end
-
-      # Resolution metrics
-      def resolution_metrics
-        total = base_query.count
-        resolved = base_query.resolved.count
-
-        {
-          resolution_rate: total.zero? ? 0 : (resolved.to_f / total * 100).round(2),
-          average_resolution_time: average_resolution_time,
-          unresolved_age: unresolved_age_distribution,
-          resolved_today: ErrorLog.resolved
-                                 .where("resolved_at >= ?", Time.current.beginning_of_day)
-                                 .count
-        }
-      end
-
-      # Error velocity - how fast errors are being introduced
-      def error_velocity
-        current_period = base_query.count
-        previous_period = ErrorLog.where(
-          "occurred_at >= ? AND occurred_at < ?",
-          (@days * 2).days.ago,
-          @start_date
-        ).count
-
-        change = current_period - previous_period
-        change_percent = previous_period.zero? ? 0 : (change.to_f / previous_period * 100).round(2)
-
-        {
-          current_period_count: current_period,
-          previous_period_count: previous_period,
-          change: change,
-          change_percent: change_percent,
-          trend: change >= 0 ? "increasing" : "decreasing"
-        }
-      end
-
-      # Users most impacted by errors
-      def top_impacted_users
-        base_query.where.not(user_id: nil)
-                 .group(:user_id)
-                 .order("count_id DESC")
-                 .limit(10)
-                 .count
-                 .transform_keys { |user_id| user_id || "Guest" }
-      end
-
-      # Recurring issues that keep coming back
-      def recurring_issues
-        base_query.where("occurrence_count > ?", 3)
-                 .where("(last_seen_at - first_seen_at) > ?", 1.day.to_i)
-                 .order(occurrence_count: :desc)
-                 .limit(10)
-                 .pluck(:error_type, :message, :occurrence_count, :first_seen_at, :last_seen_at)
-                 .map { |type, msg, count, first, last|
-                   {
-                     error_type: type,
-                     message: msg.truncate(100),
-                     occurrence_count: count,
-                     duration_days: ((last - first) / 1.day).round(1),
-                     first_seen: first,
-                     last_seen: last
-                   }
-                 }
-      end
-
-      # Helper methods
-
-      def critical_error_types
-        %w[
-          SecurityError
-          NoMemoryError
-          SystemStackError
-          SignalException
-          ActiveRecord::StatementInvalid
-        ]
-      end
-
-      def new_error_types_count
-        # Error types that first appeared in this period
-        current_types = base_query.distinct.pluck(:error_type)
-        all_time_types = ErrorLog.where("occurred_at < ?", @start_date)
-                               .distinct
-                               .pluck(:error_type)
-
-        (current_types - all_time_types).count
-      end
-
-      def errors_trending_up?
-        last_24h = ErrorLog.where("occurred_at >= ?", 24.hours.ago).count
-        prev_24h = ErrorLog.where("occurred_at >= ? AND occurred_at < ?",
-                                 48.hours.ago, 24.hours.ago).count
-
-        last_24h > prev_24h
-      end
-
-      def hourly_distribution
-        base_query.group("EXTRACT(HOUR FROM occurred_at)")
-                 .order("EXTRACT(HOUR FROM occurred_at)")
-                 .count
-      end
-
-      def daily_distribution
-        base_query.group("DATE(occurred_at)")
-                 .order("DATE(occurred_at)")
-                 .count
-      end
-
-      def type_trends
-        # Get top 5 error types and their trend over days
-        top_types = base_query.group(:error_type)
-                             .order("count_id DESC")
-                             .limit(5)
-                             .pluck(:error_type)
-
-        trends = {}
-        top_types.each do |error_type|
-          trends[error_type] = base_query.where(error_type: error_type)
-                                        .group("DATE(occurred_at)")
-                                        .count
-        end
-
-        trends
-      end
-
-      def calculate_stability(platform)
-        total = base_query.where(platform: platform).count
-        return 100.0 if total.zero?
-
-        # Stability = 100 - (errors per 1000 requests ratio)
-        # Simplified: just show error rate
-        100.0 - [ (total.to_f / 10), 100.0 ].min
-      end
-
-      def average_resolution_time
-        resolved_errors = base_query.resolved
-                                   .where.not(resolved_at: nil)
-
-        return 0 if resolved_errors.count.zero?
-
-        total_time = resolved_errors.sum { |error|
-          (error.resolved_at - error.occurred_at).to_i
-        }
-
-        average_seconds = total_time / resolved_errors.count
-        (average_seconds / 3600.0).round(2) # Convert to hours
-      end
-
-      def unresolved_age_distribution
-        unresolved = base_query.unresolved
-
-        {
-          under_1_hour: unresolved.where("occurred_at >= ?", 1.hour.ago).count,
-          "1_24_hours": unresolved.where("occurred_at >= ? AND occurred_at < ?",
-                                       24.hours.ago, 1.hour.ago).count,
-          "1_7_days": unresolved.where("occurred_at >= ? AND occurred_at < ?",
-                                      7.days.ago, 24.hours.ago).count,
-          over_7_days: unresolved.where("occurred_at < ?", 7.days.ago).count
-        }
-      end
-
-      def detect_spikes
-        # Find error types that suddenly spiked in last 24 hours
-        last_24h = ErrorLog.where("occurred_at >= ?", 24.hours.ago)
-        prev_24h = ErrorLog.where("occurred_at >= ? AND occurred_at < ?",
-                                 48.hours.ago, 24.hours.ago)
-
-        current_counts = last_24h.group(:error_type).count
-        previous_counts = prev_24h.group(:error_type).count
-
-        spikes = []
-        current_counts.each do |error_type, current_count|
-          previous_count = previous_counts[error_type] || 0
-
-          # Spike if current is > 2x previous AND at least 5 errors
-          if current_count > previous_count * 2 && current_count >= 5
-            spikes << {
-              error_type: error_type,
-              current_count: current_count,
-              previous_count: previous_count,
-              increase_percent: previous_count.zero? ? 999 : ((current_count - previous_count).to_f / previous_count * 100).round(0)
-            }
-          end
-        end
-
-        spikes.sort_by { |s| -s[:increase_percent] }.first(5)
-      end
-    end
-  end
-end

data/lib/rails_error_dashboard/queries/errors_list_v2.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-module RailsErrorDashboard
-  module Queries
-    # Query: Fetch errors with improved filtering for developers
-    # Removes environment filtering (each env has separate DB)
-    # Adds time-based, severity, and frequency filtering
-    class ErrorsListV2
-      def self.call(filters = {})
-        new(filters).call
-      end
-
-      def initialize(filters = {})
-        @filters = filters
-      end
-
-      def call
-        query = ErrorLog.order(occurred_at: :desc)
-        # Only eager load user if User model exists
-        query = query.includes(:user) if defined?(::User)
-        query = apply_filters(query)
-        query
-      end
-
-      private
-
-      def apply_filters(query)
-        query = filter_by_timeframe(query)
-        query = filter_by_error_type(query)
-        query = filter_by_resolved(query)
-        query = filter_by_platform(query)
-        query = filter_by_severity(query)
-        query = filter_by_frequency(query)
-        query = filter_by_search(query)
-        query
-      end
-
-      # Time-based filtering (more useful than environment)
-      def filter_by_timeframe(query)
-        return query unless @filters[:timeframe].present?
-
-        case @filters[:timeframe]
-        when "last_hour"
-          query.where("occurred_at >= ?", 1.hour.ago)
-        when "today"
-          query.where("occurred_at >= ?", Time.current.beginning_of_day)
-        when "yesterday"
-          query.where("occurred_at >= ? AND occurred_at < ?",
-                     1.day.ago.beginning_of_day,
-                     Time.current.beginning_of_day)
-        when "last_7_days"
-          query.where("occurred_at >= ?", 7.days.ago)
-        when "last_30_days"
-          query.where("occurred_at >= ?", 30.days.ago)
-        when "last_90_days"
-          query.where("occurred_at >= ?", 90.days.ago)
-        else
-          query
-        end
-      end
-
-      def filter_by_error_type(query)
-        return query unless @filters[:error_type].present?
-
-        query.where(error_type: @filters[:error_type])
-      end
-
-      def filter_by_resolved(query)
-        return query unless @filters[:unresolved] == "true" || @filters[:unresolved] == true
-
-        query.unresolved
-      end
-
-      def filter_by_platform(query)
-        return query unless @filters[:platform].present?
-
-        query.where(platform: @filters[:platform])
-      end
-
-      # Filter by severity (based on error type)
-      def filter_by_severity(query)
-        return query unless @filters[:severity].present?
-
-        case @filters[:severity]
-        when "critical"
-          # Security, data loss, crashes
-          critical_errors = [
-            "SecurityError",
-            "ActiveRecord::RecordInvalid",
-            "NoMemoryError",
-            "SystemStackError",
-            "SignalException"
-          ]
-          query.where(error_type: critical_errors)
-        when "high"
-          # Business logic failures
-          high_errors = [
-            "ActiveRecord::RecordNotFound",
-            "ArgumentError",
-            "TypeError",
-            "NoMethodError"
-          ]
-          query.where(error_type: high_errors)
-        when "medium"
-          # Validation, timeouts
-          medium_errors = [
-            "ActiveRecord::RecordInvalid",
-            "Timeout::Error",
-            "Net::ReadTimeout"
-          ]
-          query.where(error_type: medium_errors)
-        else
-          query
-        end
-      end
-
-      # Filter by frequency (how often error occurs)
-      def filter_by_frequency(query)
-        return query unless @filters[:frequency].present?
-
-        case @filters[:frequency]
-        when "high"
-          # Occurs more than 10 times
-          query.where("occurrence_count > ?", 10)
-        when "medium"
-          # Occurs 3-10 times
-          query.where("occurrence_count >= ? AND occurrence_count <= ?", 3, 10)
-        when "low"
-          # Occurs 1-2 times
-          query.where("occurrence_count <= ?", 2)
-        when "recurring"
-          # Seen multiple times over more than 1 hour
-          query.where("occurrence_count > ? AND (last_seen_at - first_seen_at) > ?",
-                     1, 1.hour.to_i)
-        else
-          query
-        end
-      end
-
-      def filter_by_search(query)
-        return query unless @filters[:search].present?
-
-        search_term = "%#{@filters[:search]}%"
-        query.where("message ILIKE ? OR error_type ILIKE ? OR backtrace ILIKE ?",
-                   search_term, search_term, search_term)
-      end
-    end
-  end
-end