rails_error_dashboard 0.1.0 → 0.1.3

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -6,7 +6,29 @@ module RailsErrorDashboard
     # This is a write operation that creates an ErrorLog record
     class LogError
       def self.call(exception, context = {})
-        new(exception, context).call
+        # Check if async logging is enabled
+        if RailsErrorDashboard.configuration.async_logging
+          # For async logging, just enqueue the job
+          # All filtering happens when the job runs
+          call_async(exception, context)
+        else
+          # For sync logging, execute immediately
+          new(exception, context).call
+        end
+      end
+
+      # Queue error logging as a background job
+      def self.call_async(exception, context = {})
+        # Serialize exception data for the job
+        exception_data = {
+          class_name: exception.class.name,
+          message: exception.message,
+          backtrace: exception.backtrace
+        }
+
+        # Enqueue the async job using ActiveJob
+        # The queue adapter (:sidekiq, :solid_queue, :async) is configured separately
+        AsyncErrorLoggingJob.perform_later(exception_data, context)
       end
 
       def initialize(exception, context = {})
@@ -15,19 +37,26 @@ module RailsErrorDashboard
       end
 
       def call
+        # Check if this exception should be ignored
+        return nil if should_ignore_exception?(@exception)
+
+        # Check sampling rate for non-critical errors
+        # Critical errors are ALWAYS logged regardless of sampling
+        return nil if should_skip_due_to_sampling?(@exception)
+
         error_context = ValueObjects::ErrorContext.new(@context, @context[:source])
 
         # Build error attributes
+        truncated_backtrace = truncate_backtrace(@exception.backtrace)
         attributes = {
           error_type: @exception.class.name,
           message: @exception.message,
-          backtrace: @exception.backtrace&.join("\n"),
+          backtrace: truncated_backtrace,
           user_id: error_context.user_id,
           request_url: error_context.request_url,
           request_params: error_context.request_params,
           user_agent: error_context.user_agent,
           ip_address: error_context.ip_address,
-          environment: Rails.env,
           platform: error_context.platform,
           controller_name: error_context.controller_name,
           action_name: error_context.action_name,
@@ -37,31 +66,174 @@ module RailsErrorDashboard
         # Generate error hash for deduplication (including controller/action context)
         error_hash = generate_error_hash(@exception, error_context.controller_name, error_context.action_name)
 
+        #  Calculate backtrace signature for fuzzy matching (if column exists)
+        if ErrorLog.column_names.include?("backtrace_signature")
+          attributes[:backtrace_signature] = calculate_backtrace_signature_from_backtrace(truncated_backtrace)
+        end
+
+        #  Add git/release info if columns exist
+        if ErrorLog.column_names.include?("git_sha")
+          attributes[:git_sha] = RailsErrorDashboard.configuration.git_sha ||
+                                  ENV["GIT_SHA"] ||
+                                  ENV["HEROKU_SLUG_COMMIT"] ||
+                                  ENV["RENDER_GIT_COMMIT"] ||
+                                  detect_git_sha_from_command
+        end
+
+        if ErrorLog.column_names.include?("app_version")
+          attributes[:app_version] = RailsErrorDashboard.configuration.app_version ||
+                                      ENV["APP_VERSION"] ||
+                                      detect_version_from_file
+        end
+
         # Find existing error or create new one
         # This ensures accurate occurrence tracking
         error_log = ErrorLog.find_or_increment_by_hash(error_hash, attributes.merge(error_hash: error_hash))
 
+        #  Track individual error occurrence for co-occurrence analysis (if table exists)
+        if defined?(ErrorOccurrence) && ErrorOccurrence.table_exists?
+          begin
+            ErrorOccurrence.create(
+              error_log: error_log,
+              occurred_at: attributes[:occurred_at],
+              user_id: attributes[:user_id],
+              request_id: error_context.request_id,
+              session_id: error_context.session_id
+            )
+          rescue => e
+            RailsErrorDashboard::Logger.error("Failed to create error occurrence: #{e.message}")
+          end
+        end
+
         # Send notifications only for new errors (not increments)
         # Check if this is first occurrence or error was just created
         if error_log.occurrence_count == 1
           send_notifications(error_log)
           # Dispatch plugin event for new error
           PluginRegistry.dispatch(:on_error_logged, error_log)
+          # Trigger notification callbacks
+          trigger_callbacks(error_log)
+          # Emit ActiveSupport::Notifications instrumentation events
+          emit_instrumentation_events(error_log)
         else
           # Dispatch plugin event for error recurrence
           PluginRegistry.dispatch(:on_error_recurred, error_log)
         end
 
+        #  Check for baseline anomalies
+        check_baseline_anomaly(error_log)
+
         error_log
       rescue => e
-        # Don't let error logging cause more errors
-        Rails.logger.error("Failed to log error: #{e.message}")
-        Rails.logger.error("Backtrace: #{e.backtrace&.first(5)&.join("\n")}")
-        nil
+        # 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
+        RailsErrorDashboard::Logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
+        nil # Explicitly return nil, never raise
       end
 
       private
 
+      # Trigger notification callbacks for error logging
+      def trigger_callbacks(error_log)
+        # Trigger general error_logged callbacks
+        RailsErrorDashboard.configuration.notification_callbacks[:error_logged].each do |callback|
+          callback.call(error_log)
+        rescue => e
+          RailsErrorDashboard::Logger.error("Error in error_logged callback: #{e.message}")
+        end
+
+        # Trigger critical_error callbacks if this is a critical error
+        if error_log.critical?
+          RailsErrorDashboard.configuration.notification_callbacks[:critical_error].each do |callback|
+            callback.call(error_log)
+          rescue => e
+            RailsErrorDashboard::Logger.error("Error in critical_error callback: #{e.message}")
+          end
+        end
+      end
+
+      # Emit ActiveSupport::Notifications instrumentation events
+      def emit_instrumentation_events(error_log)
+        # Payload for instrumentation subscribers
+        payload = {
+          error_log: error_log,
+          error_id: error_log.id,
+          error_type: error_log.error_type,
+          message: error_log.message,
+          severity: error_log.severity,
+          platform: error_log.platform,
+          occurred_at: error_log.occurred_at
+        }
+
+        # Emit general error_logged event
+        ActiveSupport::Notifications.instrument("error_logged.rails_error_dashboard", payload)
+
+        # Emit critical_error event if this is a critical error
+        if error_log.critical?
+          ActiveSupport::Notifications.instrument("critical_error.rails_error_dashboard", payload)
+        end
+      end
+
+      # Check if error should be skipped due to sampling rate
+      # Critical errors are ALWAYS logged, sampling only applies to non-critical errors
+      def should_skip_due_to_sampling?(exception)
+        sampling_rate = RailsErrorDashboard.configuration.sampling_rate
+
+        # If sampling is 100% (1.0) or higher, log everything
+        return false if sampling_rate >= 1.0
+
+        # Always log critical errors regardless of sampling rate
+        # Check this BEFORE checking for 0% sampling
+        return false if is_critical_error?(exception)
+
+        # If sampling is 0% or negative, skip all non-critical errors
+        return true if sampling_rate <= 0.0
+
+        # For non-critical errors, use probabilistic sampling
+        # rand returns 0.0 to 1.0, so if sampling_rate is 0.1 (10%),
+        # we skip 90% of errors (when rand > 0.1)
+        rand > sampling_rate
+      end
+
+      # Check if exception is a critical error type
+      def is_critical_error?(exception)
+        exception_class_name = exception.class.name
+        RailsErrorDashboard::ErrorLog::CRITICAL_ERROR_TYPES.include?(exception_class_name)
+      end
+
+      # Check if exception should be ignored based on configuration
+      # Supports both string class names and regex patterns
+      def should_ignore_exception?(exception)
+        ignored_exceptions = RailsErrorDashboard.configuration.ignored_exceptions
+        return false if ignored_exceptions.blank?
+
+        exception_class_name = exception.class.name
+
+        ignored_exceptions.any? do |ignored|
+          case ignored
+          when String
+            # Exact class name match (supports inheritance)
+            exception.is_a?(ignored.constantize)
+          when Regexp
+            # Regex pattern match on class name
+            exception_class_name.match?(ignored)
+          else
+            false
+          end
+        rescue NameError
+          # Handle invalid class names in configuration
+          RailsErrorDashboard::Logger.warn("Invalid ignored exception class: #{ignored}")
+          false
+        end
+      end
+
       # Generate consistent hash for error deduplication
       # Same hash = same error type
       # Note: This is also defined in ErrorLog model for backward compatibility
@@ -101,6 +273,28 @@ module RailsErrorDashboard
         Digest::SHA256.hexdigest(digest_input)[0..15]
       end
 
+      # Truncate backtrace to configured maximum lines
+      # This reduces database storage and improves performance
+      def truncate_backtrace(backtrace)
+        return nil if backtrace.nil?
+
+        max_lines = RailsErrorDashboard.configuration.max_backtrace_lines
+
+        # Limit backtrace to max_lines
+        limited_backtrace = backtrace.first(max_lines)
+
+        # Join into string
+        result = limited_backtrace.join("\n")
+
+        # Add truncation notice if we cut lines
+        if backtrace.length > max_lines
+          truncation_notice = "... (#{backtrace.length - max_lines} more lines truncated)"
+          result = result.empty? ? truncation_notice : result + "\n" + truncation_notice
+        end
+
+        result
+      end
+
       def send_notifications(error_log)
         config = RailsErrorDashboard.configuration
 
@@ -129,6 +323,77 @@ module RailsErrorDashboard
           WebhookErrorNotificationJob.perform_later(error_log.id)
         end
       end
+
+      #  Calculate backtrace signature from backtrace string/array
+      # This matches the algorithm in ErrorLog#calculate_backtrace_signature
+      def calculate_backtrace_signature_from_backtrace(backtrace)
+        return nil if backtrace.blank?
+
+        lines = backtrace.is_a?(String) ? backtrace.split("\n") : backtrace
+        frames = lines.first(20).map do |line|
+          # Extract file path and method name, ignore line numbers
+          if line =~ %r{([^/]+\.rb):.*?in `(.+)'$}
+            "#{Regexp.last_match(1)}:#{Regexp.last_match(2)}"
+          elsif line =~ %r{([^/]+\.rb)}
+            Regexp.last_match(1)
+          end
+        end.compact.uniq
+
+        return nil if frames.empty?
+
+        # Create signature from sorted file paths (order-independent)
+        file_paths = frames.map { |frame| frame.split(":").first }.sort
+        Digest::SHA256.hexdigest(file_paths.join("|"))[0..15]
+      end
+
+      #  Check if error exceeds baseline and send alert if needed
+      def check_baseline_anomaly(error_log)
+        config = RailsErrorDashboard.configuration
+
+        # Return early if baseline alerts are disabled
+        return unless config.enable_baseline_alerts
+        return unless defined?(Queries::BaselineStats)
+        return unless defined?(BaselineAlertJob)
+
+        # Get baseline anomaly info
+        anomaly = error_log.baseline_anomaly(sensitivity: config.baseline_alert_threshold_std_devs)
+
+        # Return if no anomaly detected
+        return unless anomaly[:anomaly]
+
+        # Check if severity level should trigger alert
+        return unless config.baseline_alert_severities.include?(anomaly[:level])
+
+        # Enqueue alert job (which will handle throttling)
+        BaselineAlertJob.perform_later(error_log.id, anomaly)
+
+        RailsErrorDashboard::Logger.info(
+          "Baseline alert queued for #{error_log.error_type} on #{error_log.platform}: " \
+          "#{anomaly[:level]} (#{anomaly[:std_devs_above]&.round(1)}σ above baseline)"
+        )
+      rescue => e
+        # Don't let baseline alerting cause errors
+        RailsErrorDashboard::Logger.error("Failed to check baseline anomaly: #{e.message}")
+      end
+
+      # Detect git SHA from git command (fallback)
+      def detect_git_sha_from_command
+        return nil unless File.exist?(Rails.root.join(".git"))
+        `git rev-parse --short HEAD 2>/dev/null`.strip.presence
+      rescue => e
+        RailsErrorDashboard::Logger.debug("Could not detect git SHA: #{e.message}")
+        nil
+      end
+
+      # Detect app version from VERSION file (fallback)
+      def detect_version_from_file
+        version_file = Rails.root.join("VERSION")
+        return File.read(version_file).strip if File.exist?(version_file)
+        nil
+      rescue => e
+        RailsErrorDashboard::Logger.debug("Could not detect version: #{e.message}")
+        nil
+      end
     end
   end
 end

data/lib/rails_error_dashboard/commands/resolve_error.rb

@@ -28,6 +28,22 @@ module RailsErrorDashboard
         # Dispatch plugin event for resolved error
         PluginRegistry.dispatch(:on_error_resolved, error)
 
+        # Trigger notification callbacks
+        RailsErrorDashboard.configuration.notification_callbacks[:error_resolved].each do |callback|
+          callback.call(error)
+        rescue => e
+          RailsErrorDashboard::Logger.error("Error in error_resolved callback: #{e.message}")
+        end
+
+        # Emit ActiveSupport::Notifications instrumentation event
+        ActiveSupport::Notifications.instrument("error_resolved.rails_error_dashboard", {
+          error_log: error,
+          error_id: error.id,
+          error_type: error.error_type,
+          resolved_by: @resolution_data[:resolved_by_name],
+          resolved_at: error.resolved_at
+        })
+
         error
       end
     end

data/lib/rails_error_dashboard/configuration.rb

@@ -43,22 +43,65 @@ module RailsErrorDashboard
     # Enable/disable Rails.error subscriber
     attr_accessor :enable_error_subscriber
 
+    # Advanced configuration options
+    # Custom severity classification rules (hash of error_type => severity)
+    attr_accessor :custom_severity_rules
+
+    # Exceptions to ignore (array of strings, regexes, or classes)
+    attr_accessor :ignored_exceptions
+
+    # Sampling rate for non-critical errors (0.0 to 1.0, default 1.0 = 100%)
+    attr_accessor :sampling_rate
+
+    # Async logging configuration
+    attr_accessor :async_logging
+    attr_accessor :async_adapter # :sidekiq, :solid_queue, or :async
+
+    # Backtrace configuration
+    attr_accessor :max_backtrace_lines
+
+    # Enhanced metrics
+    attr_accessor :app_version
+    attr_accessor :git_sha
+    attr_accessor :total_users_for_impact # For user impact % calculation
+
+    # Advanced error analysis features
+    attr_accessor :enable_similar_errors          # Fuzzy error matching
+    attr_accessor :enable_co_occurring_errors     # Detect errors happening together
+    attr_accessor :enable_error_cascades          # Parent→child error relationships
+    attr_accessor :enable_error_correlation       # Version/user/time correlation
+    attr_accessor :enable_platform_comparison     # iOS vs Android analytics
+    attr_accessor :enable_occurrence_patterns     # Cyclical/burst pattern detection
+
+    # Baseline alert configuration
+    attr_accessor :enable_baseline_alerts
+    attr_accessor :baseline_alert_threshold_std_devs # Number of std devs to trigger alert (default: 2.0)
+    attr_accessor :baseline_alert_severities # Array of severities to alert on (default: [:critical, :high])
+    attr_accessor :baseline_alert_cooldown_minutes # Minutes between alerts for same error type (default: 120)
+
+    # Notification callbacks (managed via helper methods, not set directly)
+    attr_reader :notification_callbacks
+
+    # Internal logging configuration
+    attr_accessor :enable_internal_logging
+    attr_accessor :log_level
+
     def initialize
       # Default values
-      @dashboard_username = ENV.fetch("ERROR_DASHBOARD_USER", "admin")
-      @dashboard_password = ENV.fetch("ERROR_DASHBOARD_PASSWORD", "password")
+      @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"
 
-      # Notification settings
+      # 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)
       @notification_email_from = ENV.fetch("ERROR_NOTIFICATION_FROM", "errors@example.com")
       @dashboard_base_url = ENV["DASHBOARD_BASE_URL"]
-      @enable_slack_notifications = true
-      @enable_email_notifications = true
+      @enable_slack_notifications = false
+      @enable_email_notifications = false
 
       # Discord notification settings
       @discord_webhook_url = ENV["DISCORD_WEBHOOK_URL"]
@@ -78,6 +121,48 @@ module RailsErrorDashboard
 
       @enable_middleware = true
       @enable_error_subscriber = true
+
+      # Advanced configuration defaults
+      @custom_severity_rules = {}
+      @ignored_exceptions = []
+      @sampling_rate = 1.0 # 100% by default
+      @async_logging = false
+      @async_adapter = :sidekiq # Battle-tested default
+      @max_backtrace_lines = 50
+
+      # Enhanced metrics defaults
+      @app_version = ENV["APP_VERSION"]
+      @git_sha = ENV["GIT_SHA"]
+      @total_users_for_impact = nil # Auto-detect if not set
+
+      # Advanced error analysis features (all OFF by default - opt-in)
+      @enable_similar_errors = false        # Fuzzy error matching
+      @enable_co_occurring_errors = false   # Co-occurring error detection
+      @enable_error_cascades = false        # Error cascade detection
+      @enable_error_correlation = false     # Version/user/time correlation
+      @enable_platform_comparison = false   # Platform health comparison
+      @enable_occurrence_patterns = false   # Pattern detection
+
+      # Baseline alert defaults
+      @enable_baseline_alerts = false  # OFF by default (opt-in)
+      @baseline_alert_threshold_std_devs = ENV.fetch("BASELINE_ALERT_THRESHOLD", "2.0").to_f
+      @baseline_alert_severities = [ :critical, :high ] # Alert on critical and high severity anomalies
+      @baseline_alert_cooldown_minutes = ENV.fetch("BASELINE_ALERT_COOLDOWN", "120").to_i
+
+      # Internal logging defaults - SILENT by default
+      @enable_internal_logging = false  # Opt-in for debugging
+      @log_level = :silent  # Silent by default, use :debug, :info, :warn, :error, or :silent
+
+      @notification_callbacks = {
+        error_logged: [],
+        critical_error: [],
+        error_resolved: []
+      }
+    end
+
+    # Reset configuration to defaults
+    def reset!
+      initialize
     end
   end
 end

data/lib/rails_error_dashboard/error_reporter.rb

@@ -22,14 +22,22 @@ module RailsErrorDashboard
       # Skip low-severity warnings
       return if handled && severity == :warning
 
-      # Extract context information
-      error_context = ValueObjects::ErrorContext.new(context, source)
+      # CRITICAL: Wrap entire process in rescue to ensure failures don't break the app
+      begin
+        # Extract context information
+        error_context = ValueObjects::ErrorContext.new(context, source)
 
-      # Log to our error dashboard using Command
-      Commands::LogError.call(error, error_context.to_h.merge(source: source))
-    rescue => e
-      # Don't let error logging cause more errors
-      Rails.logger.error("ErrorReporter failed: #{e.message}")
+        # Log to our error dashboard using Command
+        Commands::LogError.call(error, error_context.to_h.merge(source: source))
+      rescue => e
+        # Don't let error logging cause more errors - fail silently
+        # Log failure for debugging but NEVER propagate exception
+        RailsErrorDashboard::Logger.error("[RailsErrorDashboard] ErrorReporter failed: #{e.class} - #{e.message}")
+        RailsErrorDashboard::Logger.error("Original error: #{error.class} - #{error.message}") if error
+        RailsErrorDashboard::Logger.error("Context: #{context.inspect}") if context
+        RailsErrorDashboard::Logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
+        nil # Explicitly return nil, never raise
+      end
     end
   end
 end

data/lib/rails_error_dashboard/logger.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Internal logger wrapper for Rails Error Dashboard
+  #
+  # By default, all logging is SILENT to keep production logs clean.
+  # Users can opt-in to verbose logging for debugging.
+  #
+  # @example Enable logging for debugging
+  #   RailsErrorDashboard.configure do |config|
+  #     config.enable_internal_logging = true
+  #     config.log_level = :debug
+  #   end
+  #
+  # @example Production troubleshooting (errors only)
+  #   RailsErrorDashboard.configure do |config|
+  #     config.enable_internal_logging = true
+  #     config.log_level = :error
+  #   end
+  module Logger
+    LOG_LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3,
+      silent: 4
+    }.freeze
+
+    class << self
+      # Log debug message (only if internal logging enabled)
+      #
+      # @param message [String] The message to log
+      # @example
+      #   RailsErrorDashboard::Logger.debug("Processing error #123")
+      def debug(message)
+        return unless logging_enabled?
+        return unless log_level_enabled?(:debug)
+
+        Rails.logger.debug(formatted_message(message))
+      end
+
+      # Log info message (only if internal logging enabled)
+      #
+      # @param message [String] The message to log
+      # @example
+      #   RailsErrorDashboard::Logger.info("Registered plugin: MyPlugin")
+      def info(message)
+        return unless logging_enabled?
+        return unless log_level_enabled?(:info)
+
+        Rails.logger.info(formatted_message(message))
+      end
+
+      # Log warning message (only if internal logging enabled)
+      #
+      # @param message [String] The message to log
+      # @example
+      #   RailsErrorDashboard::Logger.warn("Plugin already registered")
+      def warn(message)
+        return unless logging_enabled?
+        return unless log_level_enabled?(:warn)
+
+        Rails.logger.warn(formatted_message(message))
+      end
+
+      # Log error message
+      # Errors are logged by default unless log_level is :silent
+      #
+      # @param message [String] The message to log
+      # @example
+      #   RailsErrorDashboard::Logger.error("Failed to save error log")
+      def error(message)
+        return unless log_level_enabled?(:error)
+
+        Rails.logger.error(formatted_message(message))
+      end
+
+      private
+
+      # Check if internal logging is enabled
+      #
+      # @return [Boolean]
+      def logging_enabled?
+        RailsErrorDashboard.configuration.enable_internal_logging
+      end
+
+      # Check if the given log level is enabled
+      #
+      # @param level [Symbol] The log level to check (:debug, :info, :warn, :error)
+      # @return [Boolean]
+      def log_level_enabled?(level)
+        config_level = RailsErrorDashboard.configuration.log_level || :silent
+        LOG_LEVELS[level] >= LOG_LEVELS[config_level]
+      end
+
+      # Format message with gem prefix
+      #
+      # @param message [String] The message to format
+      # @return [String] Formatted message with prefix
+      def formatted_message(message)
+        "[RailsErrorDashboard] #{message}"
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/middleware/error_catcher.rb

@@ -23,17 +23,24 @@ module RailsErrorDashboard
         @app.call(env)
       rescue => exception
         # Report to Rails.error (will be logged by our ErrorReporter)
-        Rails.error.report(exception,
-          handled: false,
-          severity: :error,
-          context: {
-            request: ActionDispatch::Request.new(env),
-            middleware: true
-          },
-          source: "rack.middleware"
-        )
+        # CRITICAL: Wrap in rescue to ensure gem failures don't break the app
+        begin
+          Rails.error.report(exception,
+            handled: false,
+            severity: :error,
+            context: {
+              request: ActionDispatch::Request.new(env),
+              middleware: true
+            },
+            source: "rack.middleware"
+          )
+        rescue => e
+          # If error reporting fails, log it but DON'T break the app
+          RailsErrorDashboard::Logger.error("[RailsErrorDashboard] Middleware error reporting failed: #{e.class} - #{e.message}")
+          RailsErrorDashboard::Logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
+        end
 
-        # Re-raise to let Rails handle the response
+        # Re-raise original exception to let Rails handle the response
         raise exception
       end
     end

data/lib/rails_error_dashboard/plugin.rb

@@ -85,14 +85,17 @@ module RailsErrorDashboard
     end
 
     # Helper method to safely execute plugin hooks
-    # Prevents plugin errors from breaking the main application
+    # CRITICAL: Prevents plugin errors from breaking the main application
     def safe_execute(method_name, *args)
       return unless enabled?
 
       send(method_name, *args)
     rescue => e
-      Rails.logger.error("Plugin '#{name}' failed in #{method_name}: #{e.message}")
-      Rails.logger.error(e.backtrace.first(5).join("\n"))
+      # Log plugin failures but never propagate - plugins must not break the app
+      RailsErrorDashboard::Logger.error("[RailsErrorDashboard] Plugin '#{name}' failed in #{method_name}: #{e.class} - #{e.message}")
+      RailsErrorDashboard::Logger.error("Plugin version: #{version}")
+      RailsErrorDashboard::Logger.error(e.backtrace&.first(10)&.join("\n")) if e.backtrace
+      nil # Explicitly return nil, never raise
     end
   end
 end