rails_error_dashboard 0.1.21 → 0.1.22

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

@@ -2,20 +2,15 @@
 
 RailsErrorDashboard.configure do |config|
   # ============================================================================
-  # AUTHENTICATION (Always Required)
+  # AUTHENTICATION (Always Required - Cannot Be Disabled)
   # ============================================================================
 
   # Dashboard authentication credentials
   # ⚠️ CHANGE THESE BEFORE PRODUCTION! ⚠️
+  # Authentication is ALWAYS enforced in ALL environments (production, development, test)
   config.dashboard_username = ENV.fetch("ERROR_DASHBOARD_USER", "gandalf")
   config.dashboard_password = ENV.fetch("ERROR_DASHBOARD_PASSWORD", "youshallnotpass")
 
-  # Require authentication for dashboard access
-  config.require_authentication = true
-
-  # Require authentication even in development mode
-  config.require_authentication_in_development = false
-
   # ============================================================================
   # CORE FEATURES (Always Enabled)
   # ============================================================================

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -46,9 +46,13 @@ module RailsErrorDashboard
 
         error_context = ValueObjects::ErrorContext.new(@context, @context[:source])
 
+        # Find or create application (cached lookup)
+        application = find_or_create_application
+
         # Build error attributes
         truncated_backtrace = truncate_backtrace(@exception.backtrace)
         attributes = {
+          application_id: application.id,
           error_type: @exception.class.name,
           message: @exception.message,
           backtrace: truncated_backtrace,
@@ -63,8 +67,8 @@ module RailsErrorDashboard
           occurred_at: Time.current
         }
 
-        # Generate error hash for deduplication (including controller/action context)
-        error_hash = generate_error_hash(@exception, error_context.controller_name, error_context.action_name)
+        # Generate error hash for deduplication (including controller/action context and application)
+        error_hash = generate_error_hash(@exception, error_context.controller_name, error_context.action_name, application.id)
 
         #  Calculate backtrace signature for fuzzy matching (if column exists)
         if ErrorLog.column_names.include?("backtrace_signature")
@@ -127,10 +131,6 @@ module RailsErrorDashboard
       rescue => e
         # Don't let error logging cause more errors - fail silently
         # CRITICAL: Log but never propagate exception
-        # Log to Rails logger for visibility during development
-        Rails.logger.error("[RailsErrorDashboard] LogError command failed: #{e.class} - #{e.message}")
-        Rails.logger.error("Backtrace: #{e.backtrace&.first(10)&.join("\n")}")
-
         RailsErrorDashboard::Logger.error("[RailsErrorDashboard] LogError command failed: #{e.class} - #{e.message}")
         RailsErrorDashboard::Logger.error("Original exception: #{@exception.class} - #{@exception.message}") if @exception
         RailsErrorDashboard::Logger.error("Context: #{@context.inspect}") if @context
@@ -140,6 +140,20 @@ module RailsErrorDashboard
 
       private
 
+      # Find or create application for multi-app support
+      def find_or_create_application
+        app_name = RailsErrorDashboard.configuration.application_name ||
+                   ENV['APPLICATION_NAME'] ||
+                   (defined?(Rails) && Rails.application.class.module_parent_name) ||
+                   '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')
+      end
+
       # Trigger notification callbacks for error logging
       def trigger_callbacks(error_log)
         # Trigger general error_logged callbacks
@@ -237,13 +251,14 @@ module RailsErrorDashboard
       # Generate consistent hash for error deduplication
       # Same hash = same error type
       # Note: This is also defined in ErrorLog model for backward compatibility
-      def generate_error_hash(exception, controller_name = nil, action_name = nil)
+      def generate_error_hash(exception, controller_name = nil, action_name = nil, application_id = nil)
         # Hash components:
         # 1. Error class (NoMethodError, ArgumentError, etc.)
         # 2. Normalized message (replace numbers, quoted strings)
         # 3. First stack frame file (ignore line numbers)
         # 4. Controller name (for context-aware grouping)
         # 5. Action name (for context-aware grouping)
+        # 6. Application ID (for per-app deduplication)
 
         normalized_message = exception.message
           &.gsub(/\d+/, "N")                    # Replace numbers: "User 123" -> "User N"
@@ -261,13 +276,14 @@ module RailsErrorDashboard
         # Extract just the file path, not line number
         file_path = first_app_frame&.split(":")&.first
 
-        # Generate hash including controller/action for better grouping
+        # Generate hash including controller/action/application for better grouping
         digest_input = [
           exception.class.name,
           normalized_message,
           file_path,
-          controller_name, # Context: which controller
-          action_name      # Context: which action
+          controller_name,      # Context: which controller
+          action_name,          # Context: which action
+          application_id.to_s   # Context: which application (for per-app deduplication)
         ].compact.join("|")
 
         Digest::SHA256.hexdigest(digest_input)[0..15]

data/lib/rails_error_dashboard/configuration.rb

@@ -2,15 +2,17 @@
 
 module RailsErrorDashboard
   class Configuration
-    # Dashboard authentication
+    # Dashboard authentication (always required)
     attr_accessor :dashboard_username
     attr_accessor :dashboard_password
-    attr_accessor :require_authentication
-    attr_accessor :require_authentication_in_development
 
     # User model (for associations)
     attr_accessor :user_model
 
+    # Multi-app support - Application name
+    attr_accessor :application_name
+    attr_accessor :database  # Database connection name for shared error dashboard DB
+
     # Notifications
     attr_accessor :slack_webhook_url
     attr_accessor :notification_email_recipients
@@ -94,14 +96,16 @@ module RailsErrorDashboard
     attr_accessor :log_level
 
     def initialize
-      # Default values
+      # Default values - Authentication is ALWAYS required
       @dashboard_username = ENV.fetch("ERROR_DASHBOARD_USER", "gandalf")
       @dashboard_password = ENV.fetch("ERROR_DASHBOARD_PASSWORD", "youshallnotpass")
-      @require_authentication = true
-      @require_authentication_in_development = false
 
       @user_model = "User"
 
+      # Multi-app support defaults
+      @application_name = ENV["APPLICATION_NAME"]  # Auto-detected if not set
+      @database = nil  # Use primary database by default
+
       # Notification settings (disabled by default - enable during installation or in initializer)
       @slack_webhook_url = ENV["SLACK_WEBHOOK_URL"]
       @notification_email_recipients = ENV.fetch("ERROR_NOTIFICATION_EMAILS", "").split(",").map(&:strip)

data/lib/rails_error_dashboard/queries/analytics_stats.rb

@@ -5,15 +5,16 @@ module RailsErrorDashboard
     # Query: Fetch analytics statistics for charts and trends
     # This is a read operation that aggregates error data over time
     class AnalyticsStats
-      def self.call(days = 30)
-        new(days).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
 
+      def self.call(days = 30, application_id: nil)
+        new(days, application_id: application_id).call
+      end
+
       def call
         # Cache analytics data for 5 minutes to reduce database load
         # Cache key includes days parameter and last error update timestamp
@@ -38,20 +39,28 @@ module RailsErrorDashboard
         # Cache key includes:
         # - Query class name
         # - Days parameter (different time ranges = different caches)
+        # - Application ID (per-app caching)
         # - Last error update timestamp (auto-invalidates when errors change)
         # - Start date (ensures correct time window)
         [
           "analytics_stats",
           @days,
-          ErrorLog.maximum(:updated_at)&.to_i || 0,
+          @application_id || "all",
+          base_scope.maximum(:updated_at)&.to_i || 0,
           @start_date.to_date.to_s
         ].join("/")
       end
 
       private
 
+      def base_scope
+        scope = ErrorLog.all
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
+      end
+
       def base_query
-        ErrorLog.where("occurred_at >= ?", @start_date)
+        base_scope.where("occurred_at >= ?", @start_date)
       end
 
       def error_statistics

data/lib/rails_error_dashboard/queries/dashboard_stats.rb

@@ -5,8 +5,12 @@ module RailsErrorDashboard
     # Query: Fetch dashboard statistics
     # This is a read operation that aggregates error data for the dashboard
     class DashboardStats
-      def self.call
-        new.call
+      def initialize(application_id: nil)
+        @application_id = application_id
+      end
+
+      def self.call(application_id: nil)
+        new(application_id: application_id).call
       end
 
       def call
@@ -15,12 +19,12 @@ module RailsErrorDashboard
         begin
           Rails.cache.fetch(cache_key, expires_in: 1.minute) do
             {
-              total_today: ErrorLog.where("occurred_at >= ?", Time.current.beginning_of_day).count,
-              total_week: ErrorLog.where("occurred_at >= ?", 7.days.ago).count,
-              total_month: ErrorLog.where("occurred_at >= ?", 30.days.ago).count,
-              unresolved: ErrorLog.unresolved.count,
-              resolved: ErrorLog.resolved.count,
-              by_platform: ErrorLog.group(:platform).count,
+              total_today: base_scope.where("occurred_at >= ?", Time.current.beginning_of_day).count,
+              total_week: base_scope.where("occurred_at >= ?", 7.days.ago).count,
+              total_month: base_scope.where("occurred_at >= ?", 30.days.ago).count,
+              unresolved: base_scope.unresolved.count,
+              resolved: base_scope.resolved.count,
+              by_platform: base_scope.group(:platform).count,
               top_errors: top_errors,
               #  Trend visualizations
               errors_trend_7d: errors_trend_7d,
@@ -40,8 +44,8 @@ module RailsErrorDashboard
         rescue => e
           # If Rails.cache or any stats query fails, return empty stats hash
           # This prevents broadcast failures in API-only mode or when cache is unavailable
-          Rails.logger.error("[RailsErrorDashboard] DashboardStats failed: #{e.class} - #{e.message}")
-          Rails.logger.debug("[RailsErrorDashboard] Backtrace: #{e.backtrace&.first(3)&.join("\n")}")
+          RailsErrorDashboard::Logger.error("[RailsErrorDashboard] DashboardStats failed: #{e.class} - #{e.message}")
+          RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Backtrace: #{e.backtrace&.first(3)&.join("\n")}")
 
           # Return minimal stats hash to prevent nil errors in views
           {
@@ -70,41 +74,49 @@ module RailsErrorDashboard
       def cache_key
         # Cache key includes last error update timestamp for auto-invalidation
         # Also includes current hour to ensure fresh data
+        # Uses base_scope to respect application_id filter for proper cache isolation
         [
           "dashboard_stats",
-          ErrorLog.maximum(:updated_at)&.to_i || 0,
+          @application_id || "all",
+          base_scope.maximum(:updated_at)&.to_i || 0,
           Time.current.hour
         ].join("/")
       end
 
       private
 
+      def base_scope
+        scope = ErrorLog.all
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
+      end
+
       def top_errors
-        ErrorLog.where("occurred_at >= ?", 7.days.ago)
-                .group(:error_type)
-                .count
-                .sort_by { |_, count| -count }
-                .first(10)
-                .to_h
+        base_scope.where("occurred_at >= ?", 7.days.ago)
+                  .group(:error_type)
+                  .count
+                  .sort_by { |_, count| -count }
+                  .first(10)
+                  .to_h
       end
 
       # Get 7-day error trend (daily counts)
       def errors_trend_7d
-        ErrorLog.where("occurred_at >= ?", 7.days.ago)
-                .group_by_day(:occurred_at, range: 7.days.ago.to_date..Date.current, default_value: 0)
-                .count
+        base_scope.where("occurred_at >= ?", 7.days.ago)
+                  .group_by_day(:occurred_at, range: 7.days.ago.to_date..Date.current, default_value: 0)
+                  .count
       end
 
       # Get error counts by severity for last 7 days
       # OPTIMIZED: Use database filtering instead of loading all records into Ruby
       def errors_by_severity_7d
-        base_scope = ErrorLog.where("occurred_at >= ?", 7.days.ago)
+        scoped_errors = base_scope.where("occurred_at >= ?", 7.days.ago)
 
         {
-          critical: base_scope.where(error_type: ErrorLog::CRITICAL_ERROR_TYPES).count,
-          high: base_scope.where(error_type: ErrorLog::HIGH_SEVERITY_ERROR_TYPES).count,
-          medium: base_scope.where(error_type: ErrorLog::MEDIUM_SEVERITY_ERROR_TYPES).count,
-          low: base_scope.where.not(
+          critical: scoped_errors.where(error_type: ErrorLog::CRITICAL_ERROR_TYPES).count,
+          high: scoped_errors.where(error_type: ErrorLog::HIGH_SEVERITY_ERROR_TYPES).count,
+          medium: scoped_errors.where(error_type: ErrorLog::MEDIUM_SEVERITY_ERROR_TYPES).count,
+          low: scoped_errors.where.not(
             error_type: ErrorLog::CRITICAL_ERROR_TYPES +
                        ErrorLog::HIGH_SEVERITY_ERROR_TYPES +
                        ErrorLog::MEDIUM_SEVERITY_ERROR_TYPES
@@ -117,7 +129,7 @@ module RailsErrorDashboard
       def spike_detected?
         return false if errors_trend_7d.empty?
 
-        today_count = ErrorLog.where("occurred_at >= ?", Time.current.beginning_of_day).count
+        today_count = base_scope.where("occurred_at >= ?", Time.current.beginning_of_day).count
 
         # Try baseline-based detection first
         if baseline_anomaly_detected?(today_count)
@@ -136,7 +148,7 @@ module RailsErrorDashboard
       def spike_info
         return nil unless spike_detected?
 
-        today_count = ErrorLog.where("occurred_at >= ?", Time.current.beginning_of_day).count
+        today_count = base_scope.where("occurred_at >= ?", Time.current.beginning_of_day).count
         avg_count = (errors_trend_7d.values.sum / 7.0).round(1)
 
         info = {
@@ -158,9 +170,9 @@ module RailsErrorDashboard
         return false unless defined?(Queries::BaselineStats)
 
         # Check most common error types for anomalies
-        ErrorLog.distinct.pluck(:error_type, :platform).compact.any? do |(error_type, platform)|
+        base_scope.distinct.pluck(:error_type, :platform).compact.any? do |(error_type, platform)|
           stats = Queries::BaselineStats.new(error_type, platform)
-          error_count = ErrorLog.where(
+          error_count = base_scope.where(
             error_type: error_type,
             platform: platform
           ).where("occurred_at >= ?", Time.current.beginning_of_day).count
@@ -175,9 +187,9 @@ module RailsErrorDashboard
         return nil unless defined?(Queries::BaselineStats)
 
         # Find the most anomalous error type
-        anomalies = ErrorLog.distinct.pluck(:error_type, :platform).compact.map do |(error_type, platform)|
+        anomalies = base_scope.distinct.pluck(:error_type, :platform).compact.map do |(error_type, platform)|
           stats = Queries::BaselineStats.new(error_type, platform)
-          error_count = ErrorLog.where(
+          error_count = base_scope.where(
             error_type: error_type,
             platform: platform
           ).where("occurred_at >= ?", Time.current.beginning_of_day).count
@@ -225,7 +237,7 @@ module RailsErrorDashboard
       # Since we don't track total requests, we'll use error count as proxy
       # In the future, this could be: (errors / total_requests) * 100
       def error_rate
-        today_errors = ErrorLog.where("occurred_at >= ?", Time.current.beginning_of_day).count
+        today_errors = base_scope.where("occurred_at >= ?", Time.current.beginning_of_day).count
         return 0.0 if today_errors.zero?
 
         # For now, use a simple heuristic: errors per hour today
@@ -243,20 +255,20 @@ module RailsErrorDashboard
 
       # Count distinct users affected by errors today
       def affected_users_today
-        ErrorLog.where("occurred_at >= ?", Time.current.beginning_of_day)
-                .where.not(user_id: nil)
-                .distinct
-                .count(:user_id)
+        base_scope.where("occurred_at >= ?", Time.current.beginning_of_day)
+                  .where.not(user_id: nil)
+                  .distinct
+                  .count(:user_id)
       end
 
       # Count distinct users affected by errors yesterday
       def affected_users_yesterday
-        ErrorLog.where("occurred_at >= ? AND occurred_at < ?",
-                      1.day.ago.beginning_of_day,
-                      Time.current.beginning_of_day)
-                .where.not(user_id: nil)
-                .distinct
-                .count(:user_id)
+        base_scope.where("occurred_at >= ? AND occurred_at < ?",
+                        1.day.ago.beginning_of_day,
+                        Time.current.beginning_of_day)
+                  .where.not(user_id: nil)
+                  .distinct
+                  .count(:user_id)
       end
 
       # Calculate change in affected users (today vs yesterday)
@@ -272,10 +284,10 @@ module RailsErrorDashboard
 
       # Calculate percentage change in errors (today vs yesterday)
       def trend_percentage
-        today = ErrorLog.where("occurred_at >= ?", Time.current.beginning_of_day).count
-        yesterday = ErrorLog.where("occurred_at >= ? AND occurred_at < ?",
-                                  1.day.ago.beginning_of_day,
-                                  Time.current.beginning_of_day).count
+        today = base_scope.where("occurred_at >= ?", Time.current.beginning_of_day).count
+        yesterday = base_scope.where("occurred_at >= ? AND occurred_at < ?",
+                                     1.day.ago.beginning_of_day,
+                                     Time.current.beginning_of_day).count
 
         return 0.0 if today.zero? && yesterday.zero?
         return 100.0 if yesterday.zero? && today.positive?
@@ -299,7 +311,7 @@ module RailsErrorDashboard
       # Get top 5 errors ranked by impact score
       # Impact = affected_users_count × occurrence_count
       def top_errors_by_impact
-        ErrorLog.where("occurred_at >= ?", 7.days.ago)
+        base_scope.where("occurred_at >= ?", 7.days.ago)
                 .group(:error_type, :id)
                 .select("error_type, id, occurrence_count,
                         COUNT(DISTINCT user_id) as affected_users,

data/lib/rails_error_dashboard/queries/errors_list.rb

@@ -28,6 +28,7 @@ module RailsErrorDashboard
         query = filter_by_error_type(query)
         query = filter_by_resolved(query)
         query = filter_by_platform(query)
+        query = filter_by_application(query)
         query = filter_by_search(query)
         query = filter_by_severity(query)
         query = filter_by_timeframe(query)
@@ -74,6 +75,13 @@ module RailsErrorDashboard
         query.where(platform: @filters[:platform])
       end
 
+      def filter_by_application(query)
+        return query unless @filters[:application_id].present?
+
+        # ActiveRecord handles both single values and arrays automatically
+        query.where(application_id: @filters[:application_id])
+      end
+
       def filter_by_search(query)
         return query unless @filters[:search].present?
 

data/lib/rails_error_dashboard/queries/filter_options.rb

@@ -12,7 +12,8 @@ module RailsErrorDashboard
       def call
         {
           error_types: ErrorLog.distinct.pluck(:error_type).compact.sort,
-          platforms: ErrorLog.distinct.pluck(:platform).compact
+          platforms: ErrorLog.distinct.pluck(:platform).compact,
+          applications: Application.ordered_by_name.pluck(:name, :id)
         }
       end
     end

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.1.21"
+  VERSION = "0.1.22"
 end