rails_error_dashboard 0.1.23 → 0.1.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8ebc7a75413a15752df2dc4a425f0c2dc046480e92d394d68212646360787e9
-  data.tar.gz: c4174fc14f0e8c9ca2da761bf7895f0ff5d3cf85d99470b31705dc748d9083f2
+  metadata.gz: eb29048c8c0c29401f6295d9e2b1d797cd82908b81197f906a9df5a6f221a182
+  data.tar.gz: 63f26da41e171cc6956edb1bb5a0027a8c67a37bc94ff323665d4c34a2673d1e
 SHA512:
-  metadata.gz: 33ab7875fcef261cc93f8af9ac7a7203e5b1c49a708baf247e63c7c2c9e40932d1fa21eb25c34f8b1f0d4e4f63dff3f1fdbb43f0f2b7b252575de6aaccd9cd08
-  data.tar.gz: 9213caf3f27b27b6a04e0dc198da8e45c7561734f6c5f14f8ccbaf150f17015b3e6693c05a14b4c73e47674ca6d12ae90f75097167e65ec80d47f03e7de9e507
+  metadata.gz: a12dfcad4a1f99763ed15bb861d3937ed577eaf2eaa89b66d99dda8fc50e63cf093d76c01dbfb226f18a4181a57352183f2ddfd8678009b02e247f0ae0d651d0
+  data.tar.gz: b213451cd2c971ab5c583f2301917a87f2c79d4b5c26526abaa72dfa59bbcc8db949cc4c7452a854966229648a7ae43f861484306e55701e780070ef72054b9b

data/README.md

@@ -16,6 +16,8 @@ gem 'rails_error_dashboard'
 
 **5-minute setup** · **Works out-of-the-box** · **100% Rails + Postgres** · **No vendor lock-in**
 
+📖 **[Full Documentation](https://anjanj.github.io/rails_error_dashboard/)** · 🎮 **[Live Demo](https://rails-error-dashboard.anjan.dev)** · 💎 **[RubyGems](https://rubygems.org/gems/rails_error_dashboard)**
+
 ### 🎮 Try the Live Demo
 
 **See it in action:** [https://rails-error-dashboard.anjan.dev](https://rails-error-dashboard.anjan.dev)
@@ -586,6 +588,7 @@ config.webhook_urls = ['https://yourapp.com/hooks/errors']
 - **[Error Trend Visualizations](docs/guides/ERROR_TREND_VISUALIZATIONS.md)** - Charts & analytics
 
 ### Advanced
+- **[Multi-App Support](docs/MULTI_APP_PERFORMANCE.md)** - Track multiple applications
 - **[Plugin System](docs/PLUGIN_SYSTEM.md)** - Build custom integrations
 - **[API Reference](docs/API_REFERENCE.md)** - Complete API documentation
 - **[Customization Guide](docs/CUSTOMIZATION.md)** - Customize everything

data/app/controllers/rails_error_dashboard/errors_controller.rb

@@ -5,14 +5,32 @@ module RailsErrorDashboard
     include Pagy::Backend
 
     before_action :authenticate_dashboard_user!
+    before_action :set_application_context
+
+    FILTERABLE_PARAMS = %i[
+      error_type
+      unresolved
+      platform
+      application_id
+      search
+      severity
+      timeframe
+      frequency
+      status
+      assigned_to
+      priority_level
+      hide_snoozed
+      sort_by
+      sort_direction
+    ].freeze
 
     def overview
-      # Get dashboard stats using Query
-      @stats = Queries::DashboardStats.call
+      # Get dashboard stats using Query (pass application filter)
+      @stats = Queries::DashboardStats.call(application_id: @current_application_id)
 
-      # Get platform health summary (if enabled)
+      # Get platform health summary (if enabled, pass application filter)
       if RailsErrorDashboard.configuration.enable_platform_comparison
-        comparison = Queries::PlatformComparison.new(days: 7)
+        comparison = Queries::PlatformComparison.new(days: 7, application_id: @current_application_id)
         @platform_health = comparison.platform_health_summary
         @platform_scores = comparison.platform_stability_scores
       else
@@ -26,8 +44,8 @@ module RailsErrorDashboard
         .where("occurred_at >= ?", 1.hour.ago)
         .where(resolved_at: nil)
         .where(priority_level: [ 3, 4 ]) # 3 = high, 4 = critical (based on severity enum)
-        .order(occurred_at: :desc)
-        .limit(10)
+      @critical_alerts = @critical_alerts.where(application_id: @current_application_id) if @current_application_id.present?
+      @critical_alerts = @critical_alerts.order(occurred_at: :desc).limit(10)
     end
 
     def index
@@ -38,10 +56,10 @@ module RailsErrorDashboard
       @pagy, @errors = pagy(errors_query, items: params[:per_page] || 25)
 
       # Get dashboard stats using Query (pass application filter)
-      @stats = Queries::DashboardStats.call(application_id: params[:application_id])
+      @stats = Queries::DashboardStats.call(application_id: @current_application_id)
 
-      # Get filter options using Query
-      filter_options = Queries::FilterOptions.call
+      # Get filter options using Query (pass application filter)
+      filter_options = Queries::FilterOptions.call(application_id: @current_application_id)
       @error_types = filter_options[:error_types]
       @platforms = filter_options[:platforms]
       @applications = filter_options[:applications]
@@ -52,7 +70,7 @@ module RailsErrorDashboard
       # - comments: Used in the comments section (@error.comments.count, @error.comments.recent_first)
       # - parent_cascade_patterns/child_cascade_patterns: Used if cascade detection is enabled
       @error = ErrorLog.includes(:comments, :parent_cascade_patterns, :child_cascade_patterns).find(params[:id])
-      @related_errors = @error.related_errors(limit: 5)
+      @related_errors = @error.related_errors(limit: 5, application_id: @current_application_id)
 
       # Dispatch plugin event for error viewed
       RailsErrorDashboard::PluginRegistry.dispatch(:on_error_viewed, @error)
@@ -139,7 +157,7 @@ module RailsErrorDashboard
       @days = days
 
       # Use Query to get analytics data (pass application filter)
-      analytics = Queries::AnalyticsStats.call(days, application_id: params[:application_id])
+      analytics = Queries::AnalyticsStats.call(days, application_id: @current_application_id)
 
       @error_stats = analytics[:error_stats]
       @errors_over_time = analytics[:errors_over_time]
@@ -151,18 +169,18 @@ module RailsErrorDashboard
       @mobile_errors = analytics[:mobile_errors]
       @api_errors = analytics[:api_errors]
 
-      # Get recurring issues data
-      recurring = Queries::RecurringIssues.call(days)
+      # Get recurring issues data (pass application filter)
+      recurring = Queries::RecurringIssues.call(days, application_id: @current_application_id)
       @recurring_data = recurring
 
-      # Get release correlation data
-      correlation = Queries::ErrorCorrelation.new(days: days)
+      # Get release correlation data (pass application filter)
+      correlation = Queries::ErrorCorrelation.new(days: days, application_id: @current_application_id)
       @errors_by_version = correlation.errors_by_version
       @problematic_releases = correlation.problematic_releases
       @release_comparison = calculate_release_comparison
 
-      # Get MTTR data
-      mttr_data = Queries::MttrStats.call(days)
+      # Get MTTR data (pass application filter)
+      mttr_data = Queries::MttrStats.call(days, application_id: @current_application_id)
       @mttr_stats = mttr_data
       @overall_mttr = mttr_data[:overall_mttr]
       @mttr_by_platform = mttr_data[:mttr_by_platform]
@@ -179,8 +197,8 @@ module RailsErrorDashboard
       days = (params[:days] || 7).to_i
       @days = days
 
-      # Use Query to get platform comparison data
-      comparison = Queries::PlatformComparison.new(days: days)
+      # Use Query to get platform comparison data (pass application filter)
+      comparison = Queries::PlatformComparison.new(days: days, application_id: @current_application_id)
 
       @error_rate_by_platform = comparison.error_rate_by_platform
       @severity_distribution = comparison.severity_distribution_by_platform
@@ -228,7 +246,7 @@ module RailsErrorDashboard
 
       days = (params[:days] || 30).to_i
       @days = days
-      correlation = Queries::ErrorCorrelation.new(days: days)
+      correlation = Queries::ErrorCorrelation.new(days: days, application_id: @current_application_id)
 
       @errors_by_version = correlation.errors_by_version
       @errors_by_git_sha = correlation.errors_by_git_sha
@@ -266,24 +284,11 @@ module RailsErrorDashboard
     end
 
     def filter_params
-      {
-        error_type: params[:error_type],
-        unresolved: params[:unresolved],
-        platform: params[:platform],
-        application_id: params[:application_id],
-        search: params[:search],
-        severity: params[:severity],
-        timeframe: params[:timeframe],
-        frequency: params[:frequency],
-        # Phase 3: Workflow filter params
-        status: params[:status],
-        assigned_to: params[:assigned_to],
-        priority_level: params[:priority_level],
-        hide_snoozed: params[:hide_snoozed],
-        # Sorting params
-        sort_by: params[:sort_by],
-        sort_direction: params[:sort_direction]
-      }
+      params.permit(*FILTERABLE_PARAMS).to_h.symbolize_keys
+    end
+
+    def set_application_context
+      @current_application_id = params[:application_id].presence
     end
 
     def authenticate_dashboard_user!

data/app/helpers/rails_error_dashboard/application_helper.rb

@@ -81,6 +81,15 @@ module RailsErrorDashboard
       RailsErrorDashboard.configuration.dashboard_username || ENV["USER"] || "unknown"
     end
 
+    # Returns a sanitized hash of filter params safe for query links
+    # @param extra_keys [Array<Symbol>] Additional permitted keys for specific contexts
+    # @return [Hash] Whitelisted params for building URLs
+    def permitted_filter_params(extra_keys: [])
+      base_keys = RailsErrorDashboard::ErrorsController::FILTERABLE_PARAMS + %i[page per_page days]
+      allowed_keys = base_keys + Array(extra_keys)
+      params.permit(*allowed_keys).to_h.symbolize_keys
+    end
+
     # Generates a sortable column header link
     # @param label [String] The column label to display
     # @param column [String] The column name to sort by
@@ -103,8 +112,8 @@ module RailsErrorDashboard
         "⇅"  # Unsorted indicator
       end
 
-      # Preserve existing filter params while adding sort params
-      link_params = params.permit!.to_h.merge(sort_by: column, sort_direction: new_direction)
+      # Preserve whitelisted filter params while adding sort params
+      link_params = permitted_filter_params.merge(sort_by: column, sort_direction: new_direction)
 
       link_to errors_path(link_params), class: "text-decoration-none" do
         content_tag(:span, "#{label} ", class: current_sort == column ? "fw-bold" : "") +

data/app/models/rails_error_dashboard/application.rb

@@ -12,22 +12,32 @@ module RailsErrorDashboard
     scope :ordered_by_name, -> { order(:name) }
 
     # Class method for finding or creating with caching
-    # Only caches successful finds, not creates (to avoid caching nil on creation failures)
+    # Caches application IDs (not objects) to avoid stale ActiveRecord references
+    # This is safer with transactional fixtures and database rollbacks
     def self.find_or_create_by_name(name)
-      # Try to find in cache or database first
-      cached = Rails.cache.read("error_dashboard/application/#{name}")
-      return cached if cached
+      # Try to find ID in cache
+      cached_id = Rails.cache.read("error_dashboard/application_id/#{name}")
+      if cached_id
+        # Verify the cached ID still exists in database
+        # (could have been deleted in tests with transactional rollback)
+        cached_record = find_by(id: cached_id)
+        return cached_record if cached_record
+        # Cache was stale, clear it
+        Rails.cache.delete("error_dashboard/application_id/#{name}")
+      end
 
-      # Try to find existing
+      # Try to find existing in database
       found = find_by(name: name)
       if found
-        Rails.cache.write("error_dashboard/application/#{name}", found, expires_in: 1.hour)
+        # Cache the ID (not the object) for future lookups
+        Rails.cache.write("error_dashboard/application_id/#{name}", found.id, expires_in: 1.hour)
         return found
       end
 
-      # Create if not found (don't cache until successful)
+      # Create if not found
       created = create!(name: name)
-      Rails.cache.write("error_dashboard/application/#{name}", created, expires_in: 1.hour)
+      # Cache the ID (not the object)
+      Rails.cache.write("error_dashboard/application_id/#{name}", created.id, expires_in: 1.hour)
       created
     end
 

data/app/models/rails_error_dashboard/error_log.rb

@@ -390,11 +390,11 @@ module RailsErrorDashboard
     end
 
     # Find related errors of the same type
-    def related_errors(limit: 5)
-      self.class.where(error_type: error_type)
-          .where.not(id: id)
-          .order(occurred_at: :desc)
-          .limit(limit)
+    def related_errors(limit: 5, application_id: nil)
+      scope = self.class.where(error_type: error_type)
+              .where.not(id: id)
+      scope = scope.where(application_id: application_id) if application_id.present?
+      scope.order(occurred_at: :desc).limit(limit)
     end
 
     # Extract backtrace frames for similarity comparison

data/app/models/rails_error_dashboard/error_logs_record.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
-# Abstract base class for models stored in the error_logs database
+# Abstract base class for models stored in the error dashboard database
 #
 # By default, this connects to the same database as the main application.
 #
-# To enable a separate error logs database:
+# To enable a separate error dashboard database:
 # 1. Set use_separate_database: true in the gem configuration
-# 2. Configure error_logs_database settings in config/database.yml
-# 3. Run: rails db:create:error_logs
-# 4. Run: rails db:migrate:error_logs
+# 2. Set database: :error_dashboard (or your custom name) in the gem configuration
+# 3. Configure error_dashboard settings in config/database.yml
+# 4. Run: rails db:create
+# 5. Run: rails db:migrate
 #
 # Benefits of separate database:
 # - Performance isolation (error logging doesn't slow down user requests)
@@ -25,10 +26,8 @@ module RailsErrorDashboard
   class ErrorLogsRecord < ActiveRecord::Base
     self.abstract_class = true
 
-    # Connect to error_logs database (or primary if not using separate DB)
-    # Only connect to separate database if configuration is enabled
-    if RailsErrorDashboard.configuration&.use_separate_database
-      connects_to database: { writing: :error_logs, reading: :error_logs }
-    end
+    # Database connection will be configured by the engine initializer
+    # after the user's configuration is loaded
+    # See lib/rails_error_dashboard/engine.rb
   end
 end

data/app/views/layouts/rails_error_dashboard.html.erb

@@ -866,16 +866,20 @@
                 <% end %>
               </button>
               <ul class="dropdown-menu dropdown-menu-end" aria-labelledby="appSwitcher">
+                <%
+                  base_route_params = request.path_parameters.slice(:controller, :action)
+                  current_filter_params = permitted_filter_params
+                %>
                 <li>
                   <%= link_to "All Applications",
-                      url_for(params.permit!.except(:controller, :action, :application_id)),
+                      url_for(base_route_params.merge(current_filter_params.except(:application_id))),
                       class: "dropdown-item #{'active' unless params[:application_id].present?}" %>
                 </li>
                 <li><hr class="dropdown-divider"></li>
                 <% @applications.each do |app_name, app_id| %>
                   <li>
                     <%= link_to app_name,
-                        url_for(params.permit!.except(:controller, :action).merge(application_id: app_id)),
+                        url_for(base_route_params.merge(current_filter_params.merge(application_id: app_id))),
                         class: "dropdown-item #{params[:application_id].to_s == app_id.to_s ? 'active' : ''}" %>
                   </li>
                 <% end %>
@@ -996,6 +1000,19 @@
       </div>
     </div>
 
+    <!-- Footer -->
+    <footer class="mt-5 py-4 text-center border-top">
+      <div class="container">
+        <p class="text-muted mb-1">
+          <i class="bi bi-bug-fill text-primary"></i>
+          Built with <a href="https://github.com/AnjanJ/rails_error_dashboard" target="_blank" class="text-decoration-none">Rails Error Dashboard</a>
+        </p>
+        <p class="text-muted small mb-0">
+          Created by <a href="https://www.anjan.dev/" target="_blank" class="text-decoration-none">Anjan Jagirdar</a>
+        </p>
+      </div>
+    </footer>
+
     <!-- Bootstrap JS -->
     <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
 

data/app/views/rails_error_dashboard/errors/index.html.erb

@@ -158,7 +158,7 @@
         <% active_filters.each do |filter| %>
           <%
             # Build URL without this specific filter
-            filter_params = params.permit!.except(:controller, :action, filter[:param])
+            filter_params = permitted_filter_params.except(filter[:param])
           %>
           <%= link_to errors_path(filter_params), class: "badge bg-primary text-decoration-none filter-pill" do %>
             <%= filter[:label] %>

data/db/migrate/20260106094233_add_application_to_error_logs.rb

@@ -7,11 +7,11 @@ class AddApplicationToErrorLogs < ActiveRecord::Migration[7.0]
     add_index :rails_error_dashboard_error_logs, :application_id
 
     add_index :rails_error_dashboard_error_logs,
-              [:application_id, :occurred_at],
+              [ :application_id, :occurred_at ],
               name: 'index_error_logs_on_app_occurred'
 
     add_index :rails_error_dashboard_error_logs,
-              [:application_id, :resolved],
+              [ :application_id, :resolved ],
               name: 'index_error_logs_on_app_resolved'
   end
 

data/lib/generators/rails_error_dashboard/install/install_generator.rb

@@ -18,6 +18,7 @@ module RailsErrorDashboard
       class_option :async_logging, type: :boolean, default: false, desc: "Enable async error logging"
       class_option :error_sampling, type: :boolean, default: false, desc: "Enable error sampling (reduce volume)"
       class_option :separate_database, type: :boolean, default: false, desc: "Use separate database for errors"
+      class_option :database, type: :string, default: nil, desc: "Database name to use for errors (e.g., 'error_dashboard')"
       # Advanced analytics options
       class_option :baseline_alerts, type: :boolean, default: false, desc: "Enable baseline anomaly alerts"
       class_option :similar_errors, type: :boolean, default: false, desc: "Enable fuzzy error matching"
@@ -185,6 +186,7 @@ module RailsErrorDashboard
         @enable_async_logging = @selected_features&.dig(:async_logging) || options[:async_logging]
         @enable_error_sampling = @selected_features&.dig(:error_sampling) || options[:error_sampling]
         @enable_separate_database = @selected_features&.dig(:separate_database) || options[:separate_database]
+        @database_name = options[:database]
 
         # Advanced Analytics
         @enable_baseline_alerts = @selected_features&.dig(:baseline_alerts) || options[:baseline_alerts]
@@ -275,7 +277,14 @@ module RailsErrorDashboard
         say "  → Set PAGERDUTY_INTEGRATION_KEY in .env", :yellow if @enable_pagerduty
         say "  → Set WEBHOOK_URLS in .env", :yellow if @enable_webhooks
         say "  → Ensure Sidekiq/Solid Queue running", :yellow if @enable_async_logging
-        say "  → Configure database.yml (docs/guides/DATABASE_OPTIONS.md)", :yellow if @enable_separate_database
+        if @enable_separate_database
+          if @database_name
+            say "  → Configure '#{@database_name}' database in database.yml", :yellow
+          else
+            say "  → Configure database in database.yml and set config.database", :yellow
+          end
+          say "    See docs/guides/DATABASE_OPTIONS.md for details", :yellow
+        end
 
         say "\n"
         say "Next Steps:", :cyan

data/lib/generators/rails_error_dashboard/install/templates/initializer.rb

@@ -153,6 +153,11 @@ RailsErrorDashboard.configure do |config|
   # Errors will be stored in a dedicated database
   # See docs/guides/DATABASE_OPTIONS.md for setup instructions
   config.use_separate_database = true
+<% if @database_name -%>
+  config.database = :<%= @database_name %>
+<% else -%>
+  # config.database = :error_dashboard  # Uncomment and set your database name
+<% end -%>
   # To disable: Set config.use_separate_database = false
 
 <% else -%>
@@ -160,6 +165,7 @@ RailsErrorDashboard.configure do |config|
   # Errors are stored in your main application database
   # To enable: Set config.use_separate_database = true and configure database.yml
   config.use_separate_database = false
+  # config.database = :error_dashboard  # Database name when using separate database
 
 <% end -%>
   # ============================================================================

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -143,15 +143,15 @@ module RailsErrorDashboard
       # Find or create application for multi-app support
       def find_or_create_application
         app_name = RailsErrorDashboard.configuration.application_name ||
-                   ENV['APPLICATION_NAME'] ||
+                   ENV["APPLICATION_NAME"] ||
                    (defined?(Rails) && Rails.application.class.module_parent_name) ||
-                   'Rails Application'
+                   "Rails Application"
 
         Application.find_or_create_by_name(app_name)
       rescue => e
         RailsErrorDashboard::Logger.error("[RailsErrorDashboard] Failed to find/create application: #{e.message}")
         # Fallback: try to find any application or create default
-        Application.first || Application.create!(name: 'Default Application')
+        Application.first || Application.create!(name: "Default Application")
       end
 
       # Trigger notification callbacks for error logging

data/lib/rails_error_dashboard/engine.rb

@@ -2,6 +2,20 @@ module RailsErrorDashboard
   class Engine < ::Rails::Engine
     isolate_namespace RailsErrorDashboard
 
+    # Configure database connection for error models
+    # This runs early, before middleware setup, but after database.yml is loaded
+    initializer "rails_error_dashboard.database", before: :load_config_initializers do
+      config.after_initialize do
+        if RailsErrorDashboard.configuration&.use_separate_database
+          database_name = RailsErrorDashboard.configuration&.database || :error_dashboard
+
+          RailsErrorDashboard::ErrorLogsRecord.connects_to(
+            database: { writing: database_name, reading: database_name }
+          )
+        end
+      end
+    end
+
     # Initialize the engine
     initializer "rails_error_dashboard.middleware" do |app|
       # Enable Flash middleware for Error Dashboard routes in API-only apps

data/lib/rails_error_dashboard/queries/error_correlation.rb

@@ -14,11 +14,13 @@ module RailsErrorDashboard
     #   correlation.errors_by_version
     #   # => { "1.0.0" => { count: 100, error_types: 15, critical_count: 5 } }
     class ErrorCorrelation
-      attr_reader :days
+      attr_reader :days, :application_id
 
       # @param days [Integer] Number of days to analyze (default: 30)
-      def initialize(days: 30)
+      # @param application_id [Integer, nil] Optional application ID to filter by
+      def initialize(days: 30, application_id: nil)
         @days = days
+        @application_id = application_id
         @start_date = days.days.ago
       end
 
@@ -285,7 +287,9 @@ module RailsErrorDashboard
       private
 
       def base_query
-        ErrorLog.where("occurred_at >= ?", @start_date)
+        scope = ErrorLog.where("occurred_at >= ?", @start_date)
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
       end
 
       # Check if app_version column exists

data/lib/rails_error_dashboard/queries/filter_options.rb

@@ -5,17 +5,29 @@ module RailsErrorDashboard
     # Query: Fetch available filter options
     # This is a read operation that returns distinct values for filters
     class FilterOptions
-      def self.call
-        new.call
+      def self.call(application_id: nil)
+        new(application_id: application_id).call
+      end
+
+      def initialize(application_id: nil)
+        @application_id = application_id
       end
 
       def call
         {
-          error_types: ErrorLog.distinct.pluck(:error_type).compact.sort,
-          platforms: ErrorLog.distinct.pluck(:platform).compact,
+          error_types: base_scope.distinct.pluck(:error_type).compact.sort,
+          platforms: base_scope.distinct.pluck(:platform).compact,
           applications: Application.ordered_by_name.pluck(:name, :id)
         }
       end
+
+      private
+
+      def base_scope
+        scope = ErrorLog.all
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
+      end
     end
   end
 end

data/lib/rails_error_dashboard/queries/mttr_stats.rb

@@ -5,12 +5,13 @@ module RailsErrorDashboard
     # Query: Calculate Mean Time to Resolution (MTTR) statistics
     # Provides metrics on how quickly errors are resolved
     class MttrStats
-      def self.call(days = 30)
-        new(days).call
+      def self.call(days = 30, application_id: nil)
+        new(days, application_id: application_id).call
       end
 
-      def initialize(days = 30)
+      def initialize(days = 30, application_id: nil)
         @days = days
+        @application_id = application_id
         @start_date = days.days.ago
       end
 
@@ -29,9 +30,13 @@ module RailsErrorDashboard
       private
 
       def resolved_errors
-        @resolved_errors ||= ErrorLog
-          .where.not(resolved_at: nil)
-          .where("occurred_at >= ?", @start_date)
+        @resolved_errors ||= begin
+          scope = ErrorLog
+            .where.not(resolved_at: nil)
+            .where("occurred_at >= ?", @start_date)
+          scope = scope.where(application_id: @application_id) if @application_id.present?
+          scope
+        end
       end
 
       def calculate_overall_mttr
@@ -44,7 +49,9 @@ module RailsErrorDashboard
       end
 
       def mttr_by_platform
-        platforms = ErrorLog.distinct.pluck(:platform).compact
+        platforms_scope = ErrorLog.all
+        platforms_scope = platforms_scope.where(application_id: @application_id) if @application_id.present?
+        platforms = platforms_scope.distinct.pluck(:platform).compact
 
         platforms.each_with_object({}) do |platform, result|
           platform_resolved = resolved_errors.where(platform: platform)
@@ -81,6 +88,7 @@ module RailsErrorDashboard
           week_resolved = ErrorLog
             .where.not(resolved_at: nil)
             .where("occurred_at >= ? AND occurred_at < ?", current_date, week_end)
+          week_resolved = week_resolved.where(application_id: @application_id) if @application_id.present?
 
           if week_resolved.any?
             total_hours = week_resolved.sum { |e| ((e.resolved_at - e.occurred_at) / 3600.0) }

data/lib/rails_error_dashboard/queries/platform_comparison.rb

@@ -17,18 +17,32 @@ module RailsErrorDashboard
     #   comparison.error_rate_by_platform
     #   # => { "ios" => 150, "android" => 200, "api" => 50, "web" => 100 }
     class PlatformComparison
-      attr_reader :days
+      attr_reader :days, :application_id
 
       # @param days [Integer] Number of days to analyze (default: 7)
-      def initialize(days: 7)
+      # @param application_id [Integer, nil] Optional application ID to filter by
+      def initialize(days: 7, application_id: nil)
         @days = days
+        @application_id = application_id
         @start_date = days.days.ago
       end
 
+      private
+
+      # Base scope that filters by application when present
+      # @return [ActiveRecord::Relation]
+      def base_scope
+        scope = ErrorLog.all
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
+      end
+
+      public
+
       # Get error count by platform for the time period
       # @return [Hash] Platform name => error count
       def error_rate_by_platform
-        ErrorLog
+        base_scope
           .where("occurred_at >= ?", @start_date)
           .group(:platform)
           .count
@@ -37,10 +51,10 @@ module RailsErrorDashboard
       # Get severity distribution by platform
       # @return [Hash] Platform => { severity => count }
       def severity_distribution_by_platform
-        platforms = ErrorLog.distinct.pluck(:platform).compact
+        platforms = base_scope.distinct.pluck(:platform).compact
 
         platforms.each_with_object({}) do |platform, result|
-          errors = ErrorLog
+          errors = base_scope
             .where(platform: platform)
             .where("occurred_at >= ?", @start_date)
 
@@ -57,10 +71,10 @@ module RailsErrorDashboard
       # Get average resolution time by platform
       # @return [Hash] Platform => average hours to resolve
       def resolution_time_by_platform
-        platforms = ErrorLog.distinct.pluck(:platform).compact
+        platforms = base_scope.distinct.pluck(:platform).compact
 
         platforms.each_with_object({}) do |platform, result|
-          resolved_errors = ErrorLog
+          resolved_errors = base_scope
             .where(platform: platform)
             .where.not(resolved_at: nil)
             .where("occurred_at >= ?", @start_date)
@@ -79,10 +93,10 @@ module RailsErrorDashboard
       # Get top 10 errors for each platform
       # @return [Hash] Platform => Array of error hashes
       def top_errors_by_platform
-        platforms = ErrorLog.distinct.pluck(:platform).compact
+        platforms = base_scope.distinct.pluck(:platform).compact
 
         platforms.each_with_object({}) do |platform, result|
-          result[platform] = ErrorLog
+          result[platform] = base_scope
             .where(platform: platform)
             .where("occurred_at >= ?", @start_date)
             .select(:id, :error_type, :message, :occurrence_count, :occurred_at)
@@ -105,7 +119,7 @@ module RailsErrorDashboard
       # Higher score = more stable (fewer errors, faster resolution)
       # @return [Hash] Platform => stability score
       def platform_stability_scores
-        platforms = ErrorLog.distinct.pluck(:platform).compact
+        platforms = base_scope.distinct.pluck(:platform).compact
         error_rates = error_rate_by_platform
         resolution_times = resolution_time_by_platform
 
@@ -131,7 +145,7 @@ module RailsErrorDashboard
       # @return [Array<Hash>] Errors with their platforms
       def cross_platform_errors
         # Get error types that appear on 2+ platforms
-        error_types_with_platforms = ErrorLog
+        error_types_with_platforms = base_scope
           .where("occurred_at >= ?", @start_date)
           .group(:error_type, :platform)
           .select(:error_type, :platform)
@@ -145,7 +159,7 @@ module RailsErrorDashboard
           .select { |_, platforms| platforms.map(&:last).uniq.count > 1 }
           .map do |error_type, platform_pairs|
             platforms = platform_pairs.map(&:last).uniq
-            total_count = ErrorLog
+            total_count = base_scope
               .where(error_type: error_type, platform: platforms)
               .where("occurred_at >= ?", @start_date)
               .sum(:occurrence_count)
@@ -155,7 +169,7 @@ module RailsErrorDashboard
               platforms: platforms.sort,
               total_occurrences: total_count,
               platform_breakdown: platforms.each_with_object({}) do |platform, breakdown|
-                breakdown[platform] = ErrorLog
+                breakdown[platform] = base_scope
                   .where(error_type: error_type, platform: platform)
                   .where("occurred_at >= ?", @start_date)
                   .sum(:occurrence_count)
@@ -168,10 +182,10 @@ module RailsErrorDashboard
       # Get daily error trend by platform
       # @return [Hash] Platform => { date => count }
       def daily_trend_by_platform
-        platforms = ErrorLog.distinct.pluck(:platform).compact
+        platforms = base_scope.distinct.pluck(:platform).compact
 
         platforms.each_with_object({}) do |platform, result|
-          result[platform] = ErrorLog
+          result[platform] = base_scope
             .where(platform: platform)
             .where("occurred_at >= ?", @start_date)
             .group_by_day(:occurred_at, range: @start_date..Time.current)
@@ -182,7 +196,7 @@ module RailsErrorDashboard
       # Get platform health summary
       # @return [Hash] Platform => health metrics
       def platform_health_summary
-        platforms = ErrorLog.distinct.pluck(:platform).compact
+        platforms = base_scope.distinct.pluck(:platform).compact
         error_rates = error_rate_by_platform
         stability_scores = platform_stability_scores
 
@@ -190,18 +204,18 @@ module RailsErrorDashboard
           total_errors = error_rates[platform] || 0
 
           # Count critical errors by checking severity method
-          critical_errors = ErrorLog
+          critical_errors = base_scope
             .where(platform: platform)
             .where("occurred_at >= ?", @start_date)
             .select { |error| error.severity == :critical }
             .count
 
-          unresolved_errors = ErrorLog
+          unresolved_errors = base_scope
             .where(platform: platform, resolved_at: nil)
             .where("occurred_at >= ?", @start_date)
             .count
 
-          resolved_errors = ErrorLog
+          resolved_errors = base_scope
             .where(platform: platform)
             .where.not(resolved_at: nil)
             .where("occurred_at >= ?", @start_date)
@@ -210,12 +224,12 @@ module RailsErrorDashboard
           resolution_rate = total_errors.positive? ? ((resolved_errors.to_f / total_errors) * 100).round(1) : 0.0
 
           # Calculate error velocity (increasing or decreasing)
-          first_half = ErrorLog
+          first_half = base_scope
             .where(platform: platform)
             .where("occurred_at >= ? AND occurred_at < ?", @start_date, @start_date + (@days / 2.0).days)
             .count
 
-          second_half = ErrorLog
+          second_half = base_scope
             .where(platform: platform)
             .where("occurred_at >= ?", @start_date + (@days / 2.0).days)
             .count

data/lib/rails_error_dashboard/queries/recurring_issues.rb

@@ -5,12 +5,13 @@ module RailsErrorDashboard
     # Query: Analyze recurring and persistent errors
     # Returns data about high-frequency errors, persistent issues, and cyclical patterns
     class RecurringIssues
-      def self.call(days = 30)
-        new(days).call
+      def self.call(days = 30, application_id: nil)
+        new(days, application_id: application_id).call
       end
 
-      def initialize(days = 30)
+      def initialize(days = 30, application_id: nil)
         @days = days
+        @application_id = application_id
         @start_date = days.days.ago
       end
 
@@ -25,7 +26,9 @@ module RailsErrorDashboard
       private
 
       def base_query
-        ErrorLog.where("occurred_at >= ?", @start_date)
+        scope = ErrorLog.where("occurred_at >= ?", @start_date)
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
       end
 
       def high_frequency_errors

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.1.23"
+  VERSION = "0.1.25"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.1.23
+  version: 0.1.25
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -83,16 +83,16 @@ dependencies:
   name: httparty
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: 0.24.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: 0.24.0
 - !ruby/object:Gem::Dependency
   name: turbo-rails
   requirement: !ruby/object:Gem::Requirement
@@ -386,7 +386,7 @@ metadata:
   source_code_uri: https://github.com/AnjanJ/rails_error_dashboard
   changelog_uri: https://github.com/AnjanJ/rails_error_dashboard/blob/main/CHANGELOG.md
 post_install_message: "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n
-  \ Rails Error Dashboard v0.1.23\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n\U0001F195
+  \ Rails Error Dashboard v0.1.25\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n\U0001F195
   First time? Quick start:\n   rails generate rails_error_dashboard:install\n   rails
   db:migrate\n   # Add to config/routes.rb:\n   mount RailsErrorDashboard::Engine
   => '/error_dashboard'\n\n\U0001F504 Upgrading from v0.1.x?\n   rails db:migrate\n