rails_error_dashboard 0.5.9 → 0.5.11

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

@@ -444,10 +444,40 @@ RailsErrorDashboard.configure do |config|
   config.git_sha = ENV["GIT_SHA"]
   # config.total_users_for_impact = 10000  # For user impact % calculation
 
-  # Git repository URL for clickable commit links
+  # Git repository URL for clickable commit links and issue tracking
   # Examples:
   #   GitHub: "https://github.com/username/repo"
   #   GitLab: "https://gitlab.com/username/repo"
-  #   Bitbucket: "https://bitbucket.org/username/repo"
+  #   Codeberg: "https://codeberg.org/username/repo"
   # config.git_repository_url = ENV["GIT_REPOSITORY_URL"]
+
+  # ============================================================================
+  # ISSUE TRACKING (GitHub / GitLab / Codeberg)
+  # ============================================================================
+  #
+  # One switch enables everything: issue creation, auto-create on first
+  # occurrence, lifecycle sync (resolve → close, reopen → reopen), platform
+  # state mirroring (status, assignees, labels), and comment display.
+  #
+  # IMPORTANT: When enabled, the dashboard shows platform state instead of
+  # internal workflow controls:
+  #   - "Mark as Resolved" → replaced by issue open/closed from platform
+  #   - Workflow Status → issue state from platform
+  #   - Assigned To → assignees from platform (with avatars)
+  #   - Priority → labels from platform (with colors)
+  #   - Snooze and Mute remain (no platform equivalent)
+  #
+  # Setup:
+  #   1. Create a RED bot account on GitHub/GitLab/Codeberg
+  #   2. Generate a token and set RED_BOT_TOKEN env var
+  #   3. Set git_repository_url above (already used for source code linking)
+  #   4. Enable:
+  #
+  # config.enable_issue_tracking = true
+  # config.issue_tracker_token = ENV["RED_BOT_TOKEN"]
+  #
+  # Optional overrides:
+  # config.issue_tracker_labels = ["bug"]                          # Labels added to new issues
+  # config.issue_tracker_auto_create_severities = [:critical, :high]  # Auto-create threshold
+  # config.issue_webhook_secret = ENV["ISSUE_WEBHOOK_SECRET"]      # Enables two-way webhook sync
 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
 
@@ -82,17 +87,17 @@ module RailsErrorDashboard
     attr_accessor :git_repository_url
 
     # Issue tracker integration (GitHub, GitLab, Codeberg/Gitea/Forgejo)
-    attr_accessor :enable_issue_tracking         # Master switch (default: false)
-    attr_accessor :issue_tracker_provider         # :github, :gitlab, :codeberg (auto-detected from git_repository_url)
+    # One switch enables everything: issue creation, auto-create, lifecycle sync,
+    # platform state mirroring, and comment display. Webhooks activate when
+    # issue_webhook_secret is set.
+    attr_accessor :enable_issue_tracking         # Master switch (default: false) — enables all platform integration
     attr_accessor :issue_tracker_token            # String or lambda/proc for Rails credentials
+    attr_accessor :issue_tracker_provider         # :github, :gitlab, :codeberg (auto-detected from git_repository_url)
     attr_accessor :issue_tracker_repo             # "owner/repo" (auto-extracted from git_repository_url)
     attr_accessor :issue_tracker_labels           # Array of label strings (default: ["bug"])
     attr_accessor :issue_tracker_api_url          # Custom API base URL for self-hosted instances
-    attr_accessor :auto_create_issues              # Boolean (default: false) — auto-create issues for new errors
-    attr_accessor :auto_create_issues_on_first_occurrence  # Boolean (default: true) — create on first occurrence
-    attr_accessor :auto_create_issues_for_severities       # Array of symbols (default: [:critical, :high])
-    attr_accessor :enable_issue_webhooks            # Boolean (default: false) — receive webhooks for two-way sync
-    attr_accessor :issue_webhook_secret             # String — HMAC secret for webhook signature verification
+    attr_accessor :issue_tracker_auto_create_severities  # Auto-create for these severities (default: [:critical, :high])
+    attr_accessor :issue_webhook_secret           # HMAC secret — webhooks activate when this is set
 
     # Advanced error analysis features
     attr_accessor :enable_similar_errors          # Fuzzy error matching
@@ -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)
@@ -244,17 +257,14 @@ module RailsErrorDashboard
       @total_users_for_impact = nil # Auto-detect if not set
       @git_repository_url = ENV["GIT_REPOSITORY_URL"]
 
-      # Issue tracker integration defaults — OFF by default
+      # Issue tracker integration defaults — OFF by default, one switch enables all
       @enable_issue_tracking = false
+      @issue_tracker_token = ENV["RED_BOT_TOKEN"] || ENV["ISSUE_TRACKER_TOKEN"]
       @issue_tracker_provider = nil    # Auto-detect from git_repository_url
-      @issue_tracker_token = ENV["ISSUE_TRACKER_TOKEN"]
       @issue_tracker_repo = nil        # Auto-extract from git_repository_url
       @issue_tracker_labels = [ "bug" ]
       @issue_tracker_api_url = nil     # For self-hosted instances
-      @auto_create_issues = false
-      @auto_create_issues_on_first_occurrence = true
-      @auto_create_issues_for_severities = [ :critical, :high ]
-      @enable_issue_webhooks = false
+      @issue_tracker_auto_create_severities = [ :critical, :high ]
       @issue_webhook_secret = ENV["ISSUE_WEBHOOK_SECRET"]
 
       # Advanced error analysis features (all OFF by default - opt-in)
@@ -328,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
 
@@ -655,6 +668,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
@@ -692,5 +713,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/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/release_timeline.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Build a release timeline from error data, showing per-version health stats,
+    # "new in this release" error detection, stability indicators, and release-over-release deltas.
+    # Uses existing app_version and git_sha columns on error_logs — no new migration needed.
+    class ReleaseTimeline
+      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
+        return empty_result unless has_version_column?
+
+        releases = build_releases
+        {
+          releases: releases,
+          summary: build_summary(releases)
+        }
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] ReleaseTimeline failed: #{e.class}: #{e.message}")
+        empty_result
+      end
+
+      private
+
+      def base_scope
+        scope = ErrorLog.where("occurred_at >= ?", @start_date)
+                        .where.not(app_version: [ nil, "" ])
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
+      end
+
+      def build_releases
+        version_stats = aggregate_version_stats
+        return [] if version_stats.empty?
+
+        new_errors = new_errors_per_version
+        avg_errors = version_stats.sum { |_v, s| s[:total_errors] }.to_f / version_stats.size
+
+        # Sort chronologically by first_seen (oldest first) for delta calculation
+        sorted_chrono = version_stats.sort_by { |_v, s| s[:first_seen] }
+
+        releases = []
+        sorted_chrono.each_with_index do |(version, stats), idx|
+          previous_count = idx > 0 ? sorted_chrono[idx - 1][1][:total_errors] : nil
+
+          releases << {
+            version: version,
+            git_shas: stats[:git_shas],
+            first_seen: stats[:first_seen],
+            last_seen: stats[:last_seen],
+            current: false, # set below
+            total_errors: stats[:total_errors],
+            unique_error_types: stats[:unique_error_types],
+            new_error_count: new_errors[version] || 0,
+            stability: stability_indicator(stats[:total_errors], avg_errors),
+            problematic: stats[:total_errors] > (avg_errors * 2),
+            delta_from_previous: previous_count ? (stats[:total_errors] - previous_count) : nil,
+            delta_percentage: previous_count && previous_count > 0 ? ((stats[:total_errors] - previous_count).to_f / previous_count * 100).round(1) : nil
+          }
+        end
+
+        # Mark the most recent release as current
+        releases.last[:current] = true if releases.any?
+
+        # Return in reverse chronological order (newest first)
+        releases.reverse
+      end
+
+      # Single GROUP BY query for per-version aggregates
+      def aggregate_version_stats
+        rows = base_scope
+          .group(:app_version)
+          .select(
+            :app_version,
+            "COUNT(*) AS total_count",
+            "COUNT(DISTINCT error_type) AS unique_types",
+            "MIN(occurred_at) AS first_seen_at",
+            "MAX(occurred_at) AS last_seen_at"
+          )
+
+        # Collect git_shas per version in a second lightweight query
+        sha_map = {}
+        if has_git_sha_column?
+          base_scope.where.not(git_sha: [ nil, "" ])
+                    .group(:app_version, :git_sha)
+                    .pluck(:app_version, :git_sha)
+                    .each do |version, sha|
+                      (sha_map[version] ||= []) << sha
+                    end
+          sha_map.each_value(&:uniq!)
+        end
+
+        rows.each_with_object({}) do |row, result|
+          version = row.app_version
+          first_seen = row.first_seen_at
+          last_seen = row.last_seen_at
+          first_seen = Time.zone.parse(first_seen) if first_seen.is_a?(String)
+          last_seen = Time.zone.parse(last_seen) if last_seen.is_a?(String)
+
+          result[version] = {
+            total_errors: row.total_count.to_i,
+            unique_error_types: row.unique_types.to_i,
+            first_seen: first_seen,
+            last_seen: last_seen,
+            git_shas: sha_map[version] || []
+          }
+        end
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] ReleaseTimeline aggregate failed: #{e.class}: #{e.message}")
+        {}
+      end
+
+      # For each error_hash in the window, find which app_version it first appeared in.
+      # Count per version to get "new errors introduced in this release".
+      def new_errors_per_version
+        return {} unless has_error_hash_column?
+
+        # Get the earliest occurrence per error_hash, with its app_version
+        # We need (error_hash, app_version) at MIN(occurred_at)
+        earliest = {}
+        base_scope.select(:error_hash, :app_version, :occurred_at)
+                  .where.not(error_hash: [ nil, "" ])
+                  .order(:occurred_at)
+                  .each do |row|
+                    earliest[row.error_hash] ||= row.app_version
+                  end
+
+        # Count how many error_hashes have each version as their earliest
+        earliest.values.tally
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] ReleaseTimeline new_errors failed: #{e.class}: #{e.message}")
+        {}
+      end
+
+      def stability_indicator(count, avg)
+        return :green if avg <= 0
+        ratio = count.to_f / avg
+        if ratio <= 1.0
+          :green
+        elsif ratio <= 2.0
+          :yellow
+        else
+          :red
+        end
+      end
+
+      def build_summary(releases)
+        {
+          total_releases: releases.size,
+          current_version: releases.first&.dig(:version),
+          avg_errors_per_release: releases.any? ? (releases.sum { |r| r[:total_errors] }.to_f / releases.size).round(1) : 0
+        }
+      end
+
+      def empty_result
+        { releases: [], summary: { total_releases: 0, current_version: nil, avg_errors_per_release: 0 } }
+      end
+
+      def has_version_column?
+        ErrorLog.column_names.include?("app_version")
+      end
+
+      def has_git_sha_column?
+        ErrorLog.column_names.include?("git_sha")
+      end
+
+      def has_error_hash_column?
+        ErrorLog.column_names.include?("error_hash")
+      end
+    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