rails_error_dashboard 0.1.1 → 0.1.4

data/lib/generators/rails_error_dashboard/uninstall/uninstall_generator.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Generators
+    class UninstallGenerator < Rails::Generators::Base
+      desc "Uninstalls Rails Error Dashboard and removes all associated files and data"
+
+      class_option :keep_data, type: :boolean, default: false, desc: "Keep error data in database (don't drop tables)"
+      class_option :skip_confirmation, type: :boolean, default: false, desc: "Skip confirmation prompts"
+      class_option :manual_only, type: :boolean, default: false, desc: "Show manual instructions only, don't perform automated uninstall"
+
+      def welcome_message
+        say "\n"
+        say "=" * 80
+        say "  🗑️  Rails Error Dashboard - Uninstall", :red
+        say "=" * 80
+        say "\n"
+        say "This will remove Rails Error Dashboard from your application.", :yellow
+        say "\n"
+      end
+
+      def detect_installed_components
+        @components = {
+          initializer: File.exist?("config/initializers/rails_error_dashboard.rb"),
+          route: route_mounted?,
+          migrations: migrations_exist?,
+          tables: tables_exist?,
+          gemfile: gemfile_includes_gem?
+        }
+
+        say "Detected components:", :cyan
+        say "  #{status_icon(@components[:gemfile])} Gemfile entry"
+        say "  #{status_icon(@components[:initializer])} Initializer (config/initializers/rails_error_dashboard.rb)"
+        say "  #{status_icon(@components[:route])} Route (mount RailsErrorDashboard::Engine)"
+        say "  #{status_icon(@components[:migrations])} Migrations (#{migration_count} files)"
+        say "  #{status_icon(@components[:tables])} Database tables (#{table_count} tables)"
+        say "\n"
+      end
+
+      def show_manual_instructions
+        say "=" * 80
+        say "  📖 Manual Uninstall Instructions", :cyan
+        say "=" * 80
+        say "\n"
+
+        say "Step 1: Remove from Gemfile", :yellow
+        say "  Open: Gemfile"
+        say "  Remove: gem 'rails_error_dashboard'"
+        say "  Run: bundle install"
+        say "\n"
+
+        if @components[:initializer]
+          say "Step 2: Remove initializer", :yellow
+          say "  Delete: config/initializers/rails_error_dashboard.rb"
+          say "\n"
+        end
+
+        if @components[:route]
+          say "Step 3: Remove route", :yellow
+          say "  Open: config/routes.rb"
+          say "  Remove: mount RailsErrorDashboard::Engine => '/error_dashboard'"
+          say "\n"
+        end
+
+        if @components[:migrations]
+          say "Step 4: Remove migrations", :yellow
+          say "  Delete migration files from db/migrate/:"
+          migration_files.each do |file|
+            say "    - #{File.basename(file)}", :light_black
+          end
+          say "\n"
+        end
+
+        if @components[:tables]
+          say "Step 5: Drop database tables (⚠️  DESTRUCTIVE - will delete all error data)", :yellow
+          say "  Run: rails rails_error_dashboard:db:drop"
+          say "  Or manually in rails console:"
+          say "    ActiveRecord::Base.connection.execute('DROP TABLE rails_error_dashboard_error_logs')", :light_black
+          say "    ActiveRecord::Base.connection.execute('DROP TABLE rails_error_dashboard_error_occurrences')", :light_black
+          say "    ActiveRecord::Base.connection.execute('DROP TABLE rails_error_dashboard_cascade_patterns')", :light_black
+          say "    ActiveRecord::Base.connection.execute('DROP TABLE rails_error_dashboard_error_baselines')", :light_black
+          say "    ActiveRecord::Base.connection.execute('DROP TABLE rails_error_dashboard_error_comments')", :light_black
+          say "    ActiveRecord::Migration.drop_table(:rails_error_dashboard_error_logs) rescue nil", :light_black
+          say "\n"
+        end
+
+        say "Step 6: Clean up environment variables (optional)", :yellow
+        say "  Remove from .env or environment:"
+        say "    - ERROR_DASHBOARD_USER"
+        say "    - ERROR_DASHBOARD_PASSWORD"
+        say "    - SLACK_WEBHOOK_URL"
+        say "    - ERROR_NOTIFICATION_EMAILS"
+        say "    - DISCORD_WEBHOOK_URL"
+        say "    - PAGERDUTY_INTEGRATION_KEY"
+        say "    - WEBHOOK_URLS"
+        say "    - DASHBOARD_BASE_URL"
+        say "\n"
+
+        say "Step 7: Restart your application", :yellow
+        say "  Run: rails restart (or restart your server)"
+        say "\n"
+
+        say "=" * 80
+        say "\n"
+      end
+
+      def confirm_automated_uninstall
+        return if options[:manual_only]
+        return if options[:skip_confirmation]
+
+        say "Would you like to run the automated uninstall? (recommended)", :cyan
+        say "This will:", :yellow
+        say "  ✓ Remove initializer file"
+        say "  ✓ Remove route from config/routes.rb"
+        say "  ✓ Remove migration files"
+        if options[:keep_data]
+          say "  ✗ Keep database tables and data (--keep-data flag set)", :green
+        else
+          say "  ⚠️  Drop all database tables (deletes all error data!)", :red
+        end
+        say "\n"
+
+        response = ask("Proceed with automated uninstall? (yes/no):", :yellow, limited_to: [ "yes", "no", "y", "n" ])
+
+        if response.downcase == "no" || response.downcase == "n"
+          say "\n"
+          say "Automated uninstall cancelled.", :yellow
+          say "Follow the manual instructions above to uninstall.", :cyan
+          say "\n"
+          exit 0
+        end
+
+        say "\n"
+      end
+
+      def final_data_warning
+        return if options[:manual_only]
+        return if options[:keep_data]
+        return unless @components[:tables]
+
+        say "=" * 80
+        say "  ⚠️  FINAL WARNING - Data Deletion", :red
+        say "=" * 80
+        say "\n"
+        say "You are about to PERMANENTLY DELETE all error tracking data!", :red
+        say "\n"
+        say "Database tables to be dropped:", :yellow
+        table_names.each do |table|
+          say "  • #{table}", :light_black
+        end
+        say "\n"
+        say "This action CANNOT be undone!", :red
+        say "\n"
+
+        response = ask("Type 'DELETE ALL DATA' to confirm:", :red)
+
+        if response != "DELETE ALL DATA"
+          say "\n"
+          say "Data deletion cancelled. Database tables will be kept.", :green
+          say "Use --keep-data flag to skip this warning in the future.", :cyan
+          @components[:tables] = false  # Don't drop tables
+          say "\n"
+        end
+
+        say "\n"
+      end
+
+      def remove_initializer
+        return if options[:manual_only]
+        return unless @components[:initializer]
+
+        remove_file "config/initializers/rails_error_dashboard.rb"
+        say "  ✓ Removed initializer", :green
+      end
+
+      def remove_route
+        return if options[:manual_only]
+        return unless @components[:route]
+
+        begin
+          gsub_file "config/routes.rb", /mount RailsErrorDashboard::Engine.*\n/, ""
+          say "  ✓ Removed route", :green
+        rescue => e
+          say "  ⚠️  Could not automatically remove route: #{e.message}", :yellow
+          say "  Please manually remove: mount RailsErrorDashboard::Engine => '/error_dashboard'", :yellow
+        end
+      end
+
+      def remove_migrations
+        return if options[:manual_only]
+        return unless @components[:migrations]
+
+        migration_files.each do |file|
+          remove_file file
+        end
+        say "  ✓ Removed #{migration_count} migration file(s)", :green
+      end
+
+      def drop_database_tables
+        return if options[:manual_only]
+        return if options[:keep_data]
+        return unless @components[:tables]
+
+        say "  Dropping database tables...", :yellow
+
+        # Drop tables in reverse order (to respect foreign keys)
+        tables_to_drop = [
+          "rails_error_dashboard_error_comments",
+          "rails_error_dashboard_error_occurrences",
+          "rails_error_dashboard_cascade_patterns",
+          "rails_error_dashboard_error_baselines",
+          "rails_error_dashboard_error_logs"
+        ]
+
+        dropped_count = 0
+        tables_to_drop.each do |table|
+          if ActiveRecord::Base.connection.table_exists?(table)
+            ActiveRecord::Base.connection.drop_table(table, if_exists: true)
+            dropped_count += 1
+          end
+        rescue => e
+          say "  ⚠️  Could not drop table #{table}: #{e.message}", :yellow
+        end
+
+        say "  ✓ Dropped #{dropped_count} database table(s)", :green
+      end
+
+      def show_completion_message
+        return if options[:manual_only]
+
+        say "\n"
+        say "=" * 80
+        say "  ✅ Uninstall Complete!", :green
+        say "=" * 80
+        say "\n"
+
+        say "Remaining manual steps:", :cyan
+        say "\n"
+
+        say "1. Remove from Gemfile:", :yellow
+        say "   Open: Gemfile"
+        say "   Remove: gem 'rails_error_dashboard'"
+        say "   Run: bundle install"
+        say "\n"
+
+        say "2. Restart your application:", :yellow
+        say "   Run: rails restart"
+        say "   Or: kill and restart your server process"
+        say "\n"
+
+        if options[:keep_data]
+          say "3. Database tables were kept (--keep-data flag)", :green
+          say "   To remove data later, run:", :yellow
+          say "   rails generate rails_error_dashboard:uninstall", :yellow
+          say "\n"
+        end
+
+        say "Clean up environment variables (optional):", :yellow
+        say "  • ERROR_DASHBOARD_USER, ERROR_DASHBOARD_PASSWORD"
+        say "  • SLACK_WEBHOOK_URL, ERROR_NOTIFICATION_EMAILS"
+        say "  • DISCORD_WEBHOOK_URL, PAGERDUTY_INTEGRATION_KEY"
+        say "  • WEBHOOK_URLS, DASHBOARD_BASE_URL"
+        say "\n"
+
+        say "Thank you for using Rails Error Dashboard! 👋", :cyan
+        say "\n"
+      end
+
+      private
+
+      def status_icon(present)
+        present ? "✓" : "✗"
+      end
+
+      def route_mounted?
+        return false unless File.exist?("config/routes.rb")
+        File.read("config/routes.rb").include?("RailsErrorDashboard::Engine")
+      end
+
+      def migrations_exist?
+        migration_files.any?
+      end
+
+      def migration_files
+        Dir.glob("db/migrate/*rails_error_dashboard*.rb")
+      end
+
+      def migration_count
+        migration_files.count
+      end
+
+      def tables_exist?
+        return false unless defined?(ActiveRecord::Base)
+        table_names.any? { |table| ActiveRecord::Base.connection.table_exists?(table) rescue false }
+      end
+
+      def table_names
+        [
+          "rails_error_dashboard_error_logs",
+          "rails_error_dashboard_error_occurrences",
+          "rails_error_dashboard_cascade_patterns",
+          "rails_error_dashboard_error_baselines",
+          "rails_error_dashboard_error_comments"
+        ]
+      end
+
+      def table_count
+        table_names.count { |table| ActiveRecord::Base.connection.table_exists?(table) rescue false }
+      end
+
+      def gemfile_includes_gem?
+        return false unless File.exist?("Gemfile")
+        File.read("Gemfile").match?(/gem\s+['"]rails_error_dashboard['"]/)
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/commands/batch_delete_errors.rb

@@ -32,7 +32,7 @@ module RailsErrorDashboard
           errors: []
         }
       rescue => e
-        Rails.logger.error("Batch delete failed: #{e.message}")
+        RailsErrorDashboard::Logger.error("Batch delete failed: #{e.message}")
         { success: false, count: 0, total: @error_ids.size, errors: [ e.message ] }
       end
     end

data/lib/rails_error_dashboard/commands/batch_resolve_errors.rb

@@ -37,7 +37,7 @@ module RailsErrorDashboard
             resolved_errors << error
           rescue => e
             failed_ids << error.id
-            Rails.logger.error("Failed to resolve error #{error.id}: #{e.message}")
+            RailsErrorDashboard::Logger.error("Failed to resolve error #{error.id}: #{e.message}")
           end
         end
 
@@ -52,7 +52,7 @@ module RailsErrorDashboard
           errors: failed_ids.empty? ? [] : [ "Failed to resolve #{failed_ids.size} error(s)" ]
         }
       rescue => e
-        Rails.logger.error("Batch resolve failed: #{e.message}")
+        RailsErrorDashboard::Logger.error("Batch resolve failed: #{e.message}")
         { success: false, count: 0, total: @error_ids.size, errors: [ e.message ] }
       end
     end

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -71,6 +71,21 @@ module RailsErrorDashboard
           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))
@@ -86,7 +101,7 @@ module RailsErrorDashboard
               session_id: error_context.session_id
             )
           rescue => e
-            Rails.logger.error("Failed to create error occurrence: #{e.message}")
+            RailsErrorDashboard::Logger.error("Failed to create error occurrence: #{e.message}")
           end
         end
 
@@ -112,10 +127,14 @@ 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("Original exception: #{@exception.class} - #{@exception.message}") if @exception
-        Rails.logger.error("Context: #{@context.inspect}") if @context
-        Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
+        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
 
@@ -127,7 +146,7 @@ module RailsErrorDashboard
         RailsErrorDashboard.configuration.notification_callbacks[:error_logged].each do |callback|
           callback.call(error_log)
         rescue => e
-          Rails.logger.error("Error in error_logged callback: #{e.message}")
+          RailsErrorDashboard::Logger.error("Error in error_logged callback: #{e.message}")
         end
 
         # Trigger critical_error callbacks if this is a critical error
@@ -135,7 +154,7 @@ module RailsErrorDashboard
           RailsErrorDashboard.configuration.notification_callbacks[:critical_error].each do |callback|
             callback.call(error_log)
           rescue => e
-            Rails.logger.error("Error in critical_error callback: #{e.message}")
+            RailsErrorDashboard::Logger.error("Error in critical_error callback: #{e.message}")
           end
         end
       end
@@ -210,7 +229,7 @@ module RailsErrorDashboard
           end
         rescue NameError
           # Handle invalid class names in configuration
-          Rails.logger.warn("Invalid ignored exception class: #{ignored}")
+          RailsErrorDashboard::Logger.warn("Invalid ignored exception class: #{ignored}")
           false
         end
       end
@@ -348,13 +367,32 @@ module RailsErrorDashboard
         # Enqueue alert job (which will handle throttling)
         BaselineAlertJob.perform_later(error_log.id, anomaly)
 
-        Rails.logger.info(
+        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
-        Rails.logger.error("Failed to check baseline anomaly: #{e.message}")
+        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

data/lib/rails_error_dashboard/commands/resolve_error.rb

@@ -32,7 +32,7 @@ module RailsErrorDashboard
         RailsErrorDashboard.configuration.notification_callbacks[:error_resolved].each do |callback|
           callback.call(error)
         rescue => e
-          Rails.logger.error("Error in error_resolved callback: #{e.message}")
+          RailsErrorDashboard::Logger.error("Error in error_resolved callback: #{e.message}")
         end
 
         # Emit ActiveSupport::Notifications instrumentation event

data/lib/rails_error_dashboard/configuration.rb

@@ -82,6 +82,10 @@ module RailsErrorDashboard
     # 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", "gandalf")
@@ -145,6 +149,10 @@ module RailsErrorDashboard
       @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: [],

data/lib/rails_error_dashboard/error_reporter.rb

@@ -32,10 +32,10 @@ module RailsErrorDashboard
       rescue => e
         # Don't let error logging cause more errors - fail silently
         # Log failure for debugging but NEVER propagate exception
-        Rails.logger.error("[RailsErrorDashboard] ErrorReporter failed: #{e.class} - #{e.message}")
-        Rails.logger.error("Original error: #{error.class} - #{error.message}") if error
-        Rails.logger.error("Context: #{context.inspect}") if context
-        Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
+        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

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

@@ -36,8 +36,8 @@ module RailsErrorDashboard
           )
         rescue => e
           # If error reporting fails, log it but DON'T break the app
-          Rails.logger.error("[RailsErrorDashboard] Middleware error reporting failed: #{e.class} - #{e.message}")
-          Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
+          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 original exception to let Rails handle the response

data/lib/rails_error_dashboard/plugin.rb

@@ -92,9 +92,9 @@ module RailsErrorDashboard
       send(method_name, *args)
     rescue => e
       # Log plugin failures but never propagate - plugins must not break the app
-      Rails.logger.error("[RailsErrorDashboard] Plugin '#{name}' failed in #{method_name}: #{e.class} - #{e.message}")
-      Rails.logger.error("Plugin version: #{version}")
-      Rails.logger.error(e.backtrace&.first(10)&.join("\n")) if e.backtrace
+      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

data/lib/rails_error_dashboard/plugin_registry.rb

@@ -18,13 +18,13 @@ module RailsErrorDashboard
         end
 
         if plugins.any? { |p| p.name == plugin.name }
-          Rails.logger.warn("Plugin '#{plugin.name}' is already registered, skipping")
+          RailsErrorDashboard::Logger.warn("Plugin '#{plugin.name}' is already registered, skipping")
           return false
         end
 
         plugins << plugin
         plugin.on_register
-        Rails.logger.info("Registered plugin: #{plugin.name} (#{plugin.version})")
+        RailsErrorDashboard::Logger.info("Registered plugin: #{plugin.name} (#{plugin.version})")
         true
       end
 

data/lib/rails_error_dashboard/plugins/jira_integration_plugin.rb

@@ -62,7 +62,7 @@ module RailsErrorDashboard
           labels: [ "rails-error-dashboard", error_log.platform ].compact
         }
 
-        Rails.logger.info("Would create Jira ticket: #{ticket_data.to_json}")
+        RailsErrorDashboard::Logger.info("Would create Jira ticket: #{ticket_data.to_json}")
 
         # Actual implementation:
         # require 'httparty'

data/lib/rails_error_dashboard/plugins/metrics_plugin.rb

@@ -56,7 +56,7 @@ module RailsErrorDashboard
         # Datadog::Statsd.increment(metric_name, tags: metric_tags(data))
 
         # For demonstration, just log
-        Rails.logger.info("Metrics: #{metric_name} - #{data.is_a?(Hash) ? data : data.class.name}")
+        RailsErrorDashboard::Logger.info("Metrics: #{metric_name} - #{data.is_a?(Hash) ? data : data.class.name}")
       end
 
       def metric_tags(data)