rails_error_dashboard 0.5.10 → 0.5.12

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

@@ -138,17 +138,19 @@ RailsErrorDashboard.configure do |config|
 
 <% if @enable_async_logging -%>
   # Async Error Logging - ENABLED
-  # Errors will be logged in background jobs for better performance
+  # Errors are logged in background jobs — zero impact on request response time.
+  # Default adapter is :async (Rails built-in, no extra infrastructure needed).
+  # Swap to :sidekiq or :solid_queue when you have a background worker running.
   config.async_logging = true
-  config.async_adapter = :sidekiq  # Options: :sidekiq, :solid_queue, :async
+  config.async_adapter = :async  # Options: :async (built-in), :sidekiq, :solid_queue
   # To disable: Set config.async_logging = false
 
 <% else -%>
   # Async Error Logging - DISABLED
-  # Errors are logged synchronously (blocking)
-  # To enable: Set config.async_logging = true and configure adapter
+  # Errors are logged synchronously (adds ~1-5ms to requests that trigger errors)
+  # To enable: Set config.async_logging = true
   config.async_logging = false
-  # config.async_adapter = :sidekiq  # Options: :sidekiq, :solid_queue, :async
+  # config.async_adapter = :async  # Options: :async (built-in), :sidekiq, :solid_queue
 
 <% end -%>
   # Backtrace size limiting (100 lines is industry standard: Rollbar, Airbrake, Bugsnag)
@@ -156,15 +158,18 @@ RailsErrorDashboard.configure do |config|
 
 <% if @enable_error_sampling -%>
   # Error Sampling - ENABLED
-  # Reduce volume by logging only a percentage of non-critical errors
-  # Critical errors are ALWAYS logged regardless of sampling rate
-  config.sampling_rate = 0.1  # 10% - Adjust as needed (0.0 to 1.0)
+  # Samples non-critical errors to reduce storage volume.
+  # Critical and high severity errors are ALWAYS logged at 100% regardless of this setting.
+  # 0.5 = log 50% of non-critical occurrences — halves storage while keeping
+  # occurrence counts meaningful and error patterns visible.
+  # Tune lower (e.g. 0.1) if one error is flooding the DB; set to 1.0 to log everything.
+  config.sampling_rate = 0.5  # 50% of non-critical errors
   # To disable: Set config.sampling_rate = 1.0 (100%)
 
 <% else -%>
   # Error Sampling - DISABLED
-  # All errors are logged (100% sampling rate)
-  # To enable: Set config.sampling_rate < 1.0 (e.g., 0.1 for 10%)
+  # All errors are logged (100% sampling rate).
+  # To enable: Set config.sampling_rate < 1.0 (e.g., 0.5 for 50%, 0.1 for 10%)
   config.sampling_rate = 1.0
 
 <% end -%>

data/lib/rails_error_dashboard/configuration.rb

@@ -34,6 +34,11 @@ module RailsErrorDashboard
     attr_accessor :webhook_urls
     attr_accessor :enable_webhook_notifications
 
+    # Scheduled digests (daily/weekly summary emails)
+    attr_accessor :enable_scheduled_digests         # Master switch (default: false)
+    attr_accessor :digest_frequency                 # :daily or :weekly (default: :daily)
+    attr_accessor :digest_recipients                # Array of emails (default: notification_email_recipients)
+
     # Separate database configuration
     attr_accessor :use_separate_database
 
@@ -168,6 +173,9 @@ module RailsErrorDashboard
     # On-demand diagnostic dump (rake task + dashboard endpoint)
     attr_accessor :enable_diagnostic_dump               # Master switch (default: false)
 
+    # Code path coverage (diagnostic mode — Ruby 3.2+)
+    attr_accessor :enable_coverage_tracking             # Master switch (default: false)
+
     # Rack Attack event tracking (requires enable_breadcrumbs = true)
     attr_accessor :enable_rack_attack_tracking          # Master switch (default: false)
 
@@ -215,6 +223,11 @@ module RailsErrorDashboard
       @webhook_urls = ENV.fetch("WEBHOOK_URLS", "").split(",").map(&:strip).reject(&:empty?)
       @enable_webhook_notifications = false
 
+      # Scheduled digest defaults - OFF by default (opt-in)
+      @enable_scheduled_digests = false
+      @digest_frequency = :daily
+      @digest_recipients = nil  # falls back to notification_email_recipients
+
       @use_separate_database = ENV.fetch("USE_SEPARATE_ERROR_DB", "false") == "true"
 
       # Retention policy - days to keep errors before automatic deletion (default: 90)
@@ -325,6 +338,9 @@ module RailsErrorDashboard
       # Diagnostic dump defaults - OFF by default (opt-in)
       @enable_diagnostic_dump = false   # On-demand system state snapshot
 
+      # Code path coverage defaults - OFF by default (opt-in, Ruby 3.2+)
+      @enable_coverage_tracking = false
+
       # Rack Attack event tracking defaults - OFF by default (opt-in, requires breadcrumbs)
       @enable_rack_attack_tracking = false
 
@@ -495,44 +511,56 @@ module RailsErrorDashboard
         @enable_activestorage_tracking = false
       end
 
+      # Skip credential/service-dependent validations during Docker builds.
+      # SECRET_KEY_BASE_DUMMY=1 means no credentials or external services available.
+      build_env = ENV["SECRET_KEY_BASE_DUMMY"].present?
+
       # Validate issue tracking configuration
-      if enable_issue_tracking && effective_issue_tracker_token.blank?
-        warnings << "enable_issue_tracking is true but no token configured. " \
-                    "Set issue_tracker_token or RED_BOT_TOKEN env var. " \
-                    "Tip: Create a dedicated RED (Rails Error Dashboard) bot account on your platform."
-      end
+      unless build_env
+        if enable_issue_tracking && effective_issue_tracker_token.blank?
+          warnings << "enable_issue_tracking is true but no token configured. " \
+                      "Set issue_tracker_token or RED_BOT_TOKEN env var. " \
+                      "Tip: Create a dedicated RED (Rails Error Dashboard) bot account on your platform."
+        end
 
-      if enable_issue_tracking && effective_issue_tracker_provider.nil?
-        warnings << "enable_issue_tracking is true but provider could not be detected. " \
-                    "Set issue_tracker_provider or git_repository_url."
+        if enable_issue_tracking && effective_issue_tracker_provider.nil?
+          warnings << "enable_issue_tracking is true but provider could not be detected. " \
+                      "Set issue_tracker_provider or git_repository_url."
+        end
       end
 
-      # Validate crash capture path (must exist if custom path specified)
-      if enable_crash_capture && crash_capture_path
+      # Validate crash capture path — auto-create if missing
+      if enable_crash_capture && crash_capture_path && !build_env
         unless Dir.exist?(crash_capture_path)
-          errors << "crash_capture_path '#{crash_capture_path}' does not exist"
+          begin
+            FileUtils.mkdir_p(crash_capture_path)
+          rescue => e
+            errors << "crash_capture_path '#{crash_capture_path}' could not be created: #{e.message}"
+          end
         end
       end
 
-      # Validate notification dependencies
-      if enable_slack_notifications && (slack_webhook_url.nil? || slack_webhook_url.strip.empty?)
-        errors << "slack_webhook_url is required when enable_slack_notifications is true"
-      end
+      # Validate notification dependencies (skip during builds — credentials unavailable)
+      unless build_env
+        if enable_slack_notifications && (slack_webhook_url.nil? || slack_webhook_url.strip.empty?)
+          errors << "slack_webhook_url is required when enable_slack_notifications is true"
+        end
 
-      if enable_email_notifications && notification_email_recipients.empty?
-        errors << "notification_email_recipients is required when enable_email_notifications is true"
-      end
+        if enable_email_notifications && notification_email_recipients.empty?
+          errors << "notification_email_recipients is required when enable_email_notifications is true"
+        end
 
-      if enable_discord_notifications && (discord_webhook_url.nil? || discord_webhook_url.strip.empty?)
-        errors << "discord_webhook_url is required when enable_discord_notifications is true"
-      end
+        if enable_discord_notifications && (discord_webhook_url.nil? || discord_webhook_url.strip.empty?)
+          errors << "discord_webhook_url is required when enable_discord_notifications is true"
+        end
 
-      if enable_pagerduty_notifications && (pagerduty_integration_key.nil? || pagerduty_integration_key.strip.empty?)
-        errors << "pagerduty_integration_key is required when enable_pagerduty_notifications is true"
-      end
+        if enable_pagerduty_notifications && (pagerduty_integration_key.nil? || pagerduty_integration_key.strip.empty?)
+          errors << "pagerduty_integration_key is required when enable_pagerduty_notifications is true"
+        end
 
-      if enable_webhook_notifications && webhook_urls.empty?
-        errors << "webhook_urls is required when enable_webhook_notifications is true"
+        if enable_webhook_notifications && webhook_urls.empty?
+          errors << "webhook_urls is required when enable_webhook_notifications is true"
+        end
       end
 
       # Validate separate database configuration
@@ -652,6 +680,14 @@ module RailsErrorDashboard
       end
     end
 
+    # Detect the engine's mount path from the host app routes.
+    # Falls back to "/red" if detection fails.
+    #
+    # @return [String] The mount path (e.g. "/red", "/admin/red", "/error_dashboard")
+    def engine_mount_path
+      @engine_mount_path ||= detect_engine_mount_path
+    end
+
     # Get the effective user model (auto-detected if not configured)
     #
     # @return [String, nil] User model class name
@@ -689,5 +725,26 @@ module RailsErrorDashboard
     def clear_total_users_cache!
       @total_users_cache = {}
     end
+
+    # Detect where the engine is mounted in the host app's routes.
+    # @return [String] mount path (default: "/red")
+    def detect_engine_mount_path
+      return "/red" unless defined?(Rails) && Rails.application
+
+      Rails.application.routes.routes.each do |route|
+        app = route.app
+        app = app.app if app.respond_to?(:app)
+        if app == RailsErrorDashboard::Engine || (app.is_a?(Class) && app <= RailsErrorDashboard::Engine)
+          path = route.path.spec.to_s.sub("(.:format)", "").chomp("/")
+          return path if path.present?
+        end
+      rescue => e
+        next
+      end
+
+      "/red"
+    rescue => e
+      "/red"
+    end
   end
 end

data/lib/rails_error_dashboard/engine.rb

@@ -61,6 +61,16 @@ module RailsErrorDashboard
 
     # Subscribe to Rails error reporter
     config.after_initialize do
+      # Skip all runtime features during Docker asset precompilation.
+      # SECRET_KEY_BASE_DUMMY=1 signals a build environment — no database,
+      # no credentials, no external services are available. Activating
+      # TracePoint hooks, error subscribers, or background jobs here causes
+      # infinite retry loops and connection failures (issues #1-5).
+      if ENV["SECRET_KEY_BASE_DUMMY"].present?
+        Rails.logger.info "[Rails Error Dashboard] Build environment detected (SECRET_KEY_BASE_DUMMY) — skipping runtime features."
+        next
+      end
+
       if RailsErrorDashboard.configuration.enable_error_subscriber
         Rails.error.subscribe(RailsErrorDashboard::ErrorReporter.new)
       end

data/lib/rails_error_dashboard/error_reporter.rb

@@ -24,6 +24,32 @@ module RailsErrorDashboard
 
       # CRITICAL: Wrap entire process in rescue to ensure failures don't break the app
       begin
+        # Enrich context with request data from Thread.current when available.
+        # Rails internals (ActionDispatch::Executor) report errors with
+        # source: "application.action_dispatch" but pass NO request object,
+        # resulting in placeholder values ("Rails Application", "{}", etc.).
+        # Our middleware stores the Rack env in Thread.current so we can
+        # build a proper request here — fixing issue #106.
+        if context[:request].nil? && Thread.current[:rails_error_dashboard_request_env]
+          env = Thread.current[:rails_error_dashboard_request_env]
+          context = context.merge(request: ActionDispatch::Request.new(env))
+        end
+
+        # Skip duplicate reports from our own middleware when the subscriber
+        # already captured this error with full request context above.
+        # Without this, async logging enqueues two jobs for one exception —
+        # and non-deterministic job ordering can overwrite good data.
+        if source == "rack.middleware" &&
+           Thread.current[:rails_error_dashboard_reported_errors]&.include?(error.object_id)
+          return
+        end
+
+        # Track that we've reported this error (for dedup with middleware)
+        if Thread.current[:rails_error_dashboard_request_env]
+          Thread.current[:rails_error_dashboard_reported_errors] ||= Set.new
+          Thread.current[:rails_error_dashboard_reported_errors].add(error.object_id)
+        end
+
         # Extract context information
         error_context = ValueObjects::ErrorContext.new(context, source)
 

data/lib/rails_error_dashboard/middleware/error_catcher.rb

@@ -23,6 +23,11 @@ module RailsErrorDashboard
         # Record request start time for duration calculation
         env["rails_error_dashboard.request_start"] = Time.now.to_f
 
+        # Store request env in thread-local so the ErrorReporter subscriber
+        # can access request context when Rails.error.report fires from
+        # Rails internals (e.g., ActionDispatch::ShowExceptions)
+        Thread.current[:rails_error_dashboard_request_env] = env
+
         # Initialize breadcrumb buffer for this request
         if RailsErrorDashboard.configuration.enable_breadcrumbs
           RailsErrorDashboard::Services::BreadcrumbCollector.init_buffer
@@ -52,6 +57,8 @@ module RailsErrorDashboard
         raise exception
       ensure
         # CRITICAL: Always clean up thread-local storage (Puma reuses threads)
+        Thread.current[:rails_error_dashboard_request_env] = nil
+        Thread.current[:rails_error_dashboard_reported_errors] = nil
         RailsErrorDashboard::Services::BreadcrumbCollector.clear_buffer
       end
     end

data/lib/rails_error_dashboard/middleware/rate_limiter.rb

@@ -5,14 +5,9 @@ module RailsErrorDashboard
     # Rate limiting middleware for Rails Error Dashboard routes
     # Protects both dashboard UI and API endpoints from abuse
     class RateLimiter
-      # Rate limits by endpoint type
-      LIMITS = {
-        # API endpoints (mobile/frontend) - stricter limits
-        "/error_dashboard/api" => { limit: 100, period: 60 }, # 100 req/min
-
-        # Dashboard pages (human users) - more lenient
-        "/error_dashboard" => { limit: 300, period: 60 } # 300 req/min
-      }.freeze
+      # Rate limits by endpoint type (relative to engine mount path)
+      API_LIMIT = { limit: 100, period: 60 }.freeze   # 100 req/min
+      DASHBOARD_LIMIT = { limit: 300, period: 60 }.freeze # 300 req/min
 
       def initialize(app)
         @app = app
@@ -51,13 +46,22 @@ module RailsErrorDashboard
         RailsErrorDashboard.configuration.enable_rate_limiting
       end
 
+      def engine_mount_path
+        @engine_mount_path ||= RailsErrorDashboard.configuration.engine_mount_path
+      rescue
+        "/red"
+      end
+
       def error_dashboard_route?(path)
-        path.start_with?("/error_dashboard")
+        path.start_with?(engine_mount_path)
       end
 
       def find_limit_config(path)
-        # Match most specific route first (API before dashboard)
-        LIMITS.find { |pattern, _| path.start_with?(pattern) }&.last
+        if path.start_with?("#{engine_mount_path}/api")
+          API_LIMIT
+        else
+          DASHBOARD_LIMIT
+        end
       end
 
       def rate_limit_key(request)
@@ -71,7 +75,7 @@ module RailsErrorDashboard
 
       def rate_limit_response(request, limit_config)
         # Return JSON for API requests, HTML for dashboard
-        if request.path.start_with?("/error_dashboard/api")
+        if request.path.start_with?("#{engine_mount_path}/api")
           json_rate_limit_response(limit_config)
         else
           html_rate_limit_response(limit_config)

data/lib/rails_error_dashboard/plugins/jira_integration_plugin.rb

@@ -114,7 +114,8 @@ module RailsErrorDashboard
 
       def dashboard_url(error_log)
         base_url = RailsErrorDashboard.configuration.dashboard_base_url || "http://localhost:3000"
-        "#{base_url}/error_dashboard/errors/#{error_log.id}"
+        mount_path = RailsErrorDashboard.configuration.engine_mount_path
+        "#{base_url}#{mount_path}/errors/#{error_log.id}"
       end
     end
   end

data/lib/rails_error_dashboard/queries/user_impact_summary.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Rank errors by unique user impact — how many distinct users each error type affects.
+    # Surfaces "this error affected 847 unique users" prominently.
+    # An error hitting 1 user 1000 times is different from an error hitting 1000 users once.
+    class UserImpactSummary
+      def self.call(days = 30, application_id: nil)
+        new(days, application_id: application_id).call
+      end
+
+      def initialize(days = 30, application_id: nil)
+        @days = days
+        @application_id = application_id
+        @start_date = days.days.ago
+      end
+
+      def call
+        all_entries = build_entries
+        {
+          entries: all_entries,
+          summary: build_summary(all_entries)
+        }
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] UserImpactSummary failed: #{e.class}: #{e.message}")
+        empty_result
+      end
+
+      private
+
+      def base_scope
+        scope = ErrorLog.where("occurred_at >= ?", @start_date)
+                        .where.not(user_id: nil)
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
+      end
+
+      def build_entries
+        # Group by error_type, count distinct users and total occurrences
+        user_counts = base_scope
+          .group(:error_type)
+          .distinct
+          .count(:user_id)
+
+        occurrence_counts = base_scope
+          .group(:error_type)
+          .count
+
+        total_users = effective_total_users
+
+        user_counts.map do |error_type, unique_users|
+          occurrences = occurrence_counts[error_type] || 0
+          sample = base_scope.where(error_type: error_type).order(occurred_at: :desc).first
+          impact_pct = total_users && total_users > 0 ? (unique_users.to_f / total_users * 100).round(1) : nil
+
+          {
+            error_type: error_type,
+            message: sample&.message.to_s.truncate(120),
+            unique_users: unique_users,
+            total_occurrences: occurrences,
+            impact_percentage: impact_pct,
+            severity: sample&.severity,
+            last_seen: sample&.occurred_at,
+            id: sample&.id
+          }
+        end.sort_by { |e| -e[:unique_users] }
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] UserImpactSummary.build_entries failed: #{e.class}: #{e.message}")
+        []
+      end
+
+      def build_summary(entries)
+        {
+          total_error_types_with_users: entries.size,
+          total_unique_users_affected: entries.sum { |e| e[:unique_users] },
+          most_impactful: entries.first&.dig(:error_type),
+          total_users: effective_total_users
+        }
+      end
+
+      def effective_total_users
+        RailsErrorDashboard.configuration.effective_total_users
+      rescue => e
+        nil
+      end
+
+      def empty_result
+        { entries: [], summary: { total_error_types_with_users: 0, total_unique_users_affected: 0, most_impactful: nil, total_users: nil } }
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/coverage_tracker.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "coverage"
+
+module RailsErrorDashboard
+  module Services
+    # Diagnostic-mode code path coverage using Ruby's Coverage API.
+    #
+    # Operator enables coverage via dashboard button, reproduces the error,
+    # views source code with executed-line overlay, then disables.
+    # Zero overhead when off. Uses oneshot_lines mode (each line fires once).
+    #
+    # SAFETY:
+    # - Coverage is process-global (not thread-local) — data blends across threads
+    # - oneshot_lines mode has near-zero ongoing overhead
+    # - peek_result is read-only, does not mutate state
+    # - Every method rescue-wrapped (never raises)
+    # - Ruby 3.2+ required for Coverage.setup with oneshot_lines
+    class CoverageTracker
+      @active = false
+      @we_started = false
+      @mutex = Mutex.new
+
+      class << self
+        # Check if the current Ruby version supports Coverage with oneshot_lines
+        def supported?
+          RUBY_VERSION >= "3.2"
+        end
+
+        # Start coverage collection in oneshot_lines mode
+        # @return [Boolean] true if successfully enabled
+        def enable!
+          return false unless supported?
+          return true if @active
+
+          @mutex.synchronize do
+            return true if @active
+
+            Coverage.setup(oneshot_lines: true)
+            Coverage.resume
+            @we_started = true
+            @active = true
+          end
+
+          true
+        rescue => e
+          # Coverage.setup raises RuntimeError if another session is active (e.g. SimpleCov).
+          # In that case, we piggyback on the existing session for peek_result.
+          if e.is_a?(RuntimeError) && coverage_running?
+            @mutex.synchronize do
+              @we_started = false
+              @active = true
+            end
+            true
+          else
+            Rails.logger.error("[RailsErrorDashboard] CoverageTracker.enable! failed: #{e.class}: #{e.message}")
+            @active = false
+            false
+          end
+        end
+
+        # Stop coverage collection and clear all data
+        def disable!
+          return unless @active
+
+          @mutex.synchronize do
+            return unless @active
+            # Only call Coverage.result if WE started the session
+            # Don't kill another tool's coverage (e.g. SimpleCov)
+            if @we_started
+              begin
+                Coverage.result
+              rescue RuntimeError
+                # Already stopped
+              end
+            end
+            @active = false
+            @we_started = false
+          end
+        rescue => e
+          Rails.logger.error("[RailsErrorDashboard] CoverageTracker.disable! failed: #{e.class}: #{e.message}")
+          @active = false
+          @we_started = false
+        end
+
+        # Whether coverage is currently being collected
+        def active?
+          @active
+        end
+
+        # Get executed line numbers for a specific file
+        # @param file_path [String] absolute path to the source file
+        # @return [Hash{Integer => Boolean}] line_number => executed?, or nil if inactive
+        def peek(file_path)
+          return nil if file_path.nil?
+          return nil unless @active
+
+          result = Coverage.peek_result
+          file_data = result[file_path]
+          return {} unless file_data
+
+          # Coverage result format varies by mode:
+          # - oneshot_lines: { oneshot_lines: [nil, 0, nil, 1, ...] }
+          # - lines (SimpleCov): { lines: [0, 1, nil, 2, ...] } or just [0, 1, nil, 2, ...]
+          # where index = line_number - 1, nil = not executable, 0 = not hit, N>0 = hit
+          lines_data = if file_data.is_a?(Hash)
+            file_data[:oneshot_lines] || file_data[:lines]
+          elsif file_data.is_a?(Array)
+            file_data
+          end
+          return {} unless lines_data.is_a?(Array)
+
+          executed = {}
+          lines_data.each_with_index do |val, idx|
+            next if val.nil? # not an executable line
+
+            line_number = idx + 1
+            executed[line_number] = val > 0
+          end
+
+          executed
+        rescue => e
+          Rails.logger.error("[RailsErrorDashboard] CoverageTracker.peek failed: #{e.class}: #{e.message}")
+          {}
+        end
+
+        private
+
+        # Check if Coverage is currently running (e.g. via SimpleCov)
+        def coverage_running?
+          Coverage.peek_result
+          true
+        rescue RuntimeError
+          false
+        end
+      end
+    end
+  end
+end