rails_error_dashboard 0.1.29 → 0.1.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c2f62f1af545cfebb6eb7356950d1ef5044ca767f7f0d0f8d048b9f8cedc16f
-  data.tar.gz: 95239d1ecadcf74c334b6af8269b3e2fbf2fc27f8b679a91f537f9c81d2ab363
+  metadata.gz: d9a0ec7ce2177fab0bbbd7103440111b9d737add4281bd85e651e219b032242a
+  data.tar.gz: c7edac468fff5d5318d78f384b460b1b9cf1ddbc50373ad71764c5675e33c67e
 SHA512:
-  metadata.gz: 867adf79f0eebb0dd5ab6f4ecc417546af088a5ececc76595326a8d1970b1593e2eaca52023c48f5441ebd788daad167d577223500b0f5adbb07b24ef6d0e581
-  data.tar.gz: f626ae8fb589b8ddf4a48385c910e52de87d17218f18b62fdf4f29837a37651b8eb103839a8e4a548b6ed1df0ea773e0870ede59550f8ee1b9cf0dfdce958559
+  metadata.gz: 166ed8da84a2ef05fc69b1e4352e4f108300b34ec78b75b7685d41622a07e1dfe45113556f27f55756002d0af93d2ae6fd165683fcef9393562ab117fe02aa0d
+  data.tar.gz: 79f5193644e2754c9f4f49e6d8f03edd463d91a7e021d23f9b02a02f8e412d748666a9b2cc3e8ff843b821f926f781a4e60887cce5d01b6f9b96c597cea6d317

data/README.md

@@ -143,6 +143,32 @@ Detect cyclical patterns (business hours, nighttime, weekend rhythms) and error
 **Plus: Developer Insights Dashboard** 💡
 Built-in analytics dashboard with severity detection, platform stability scoring, actionable recommendations, and recent error activity summaries (always available, no configuration needed).
 
+#### 🔍 Source Code Integration (NEW!)
+
+**View actual source code directly in error backtraces** - no need to switch to your editor or GitHub.
+
+- **Inline Source Code Viewer** - Click "View Source" on any error frame to see the actual code with ±7 lines of context
+- **Git Blame Integration** - See who last modified the code, when, and the commit message
+- **Repository Links** - Jump directly to GitHub/GitLab/Bitbucket at the exact error line
+- **Smart Caching** - Fast performance with 1-hour cache (configurable)
+- **Security Controls** - Only shows your app code by default (not gems/frameworks)
+
+**Perfect for debugging:**
+- Understand the code context without leaving the dashboard
+- Identify code ownership with git blame
+- Quick navigation to your repository
+- See recent changes that might have caused the error
+
+```ruby
+# Enable in config/initializers/rails_error_dashboard.rb
+config.enable_source_code_integration = true
+config.source_code_context_lines = 7
+config.enable_git_blame = true
+config.git_repository_url = "https://github.com/user/repo"
+```
+
+**📖 [Complete documentation →](docs/SOURCE_CODE_INTEGRATION.md)**
+
 #### 🔌 Plugin System
 Extensible architecture with event hooks (`on_error_logged`, `on_error_resolved`, `on_threshold_exceeded`). Built-in examples for Jira integration, metrics tracking, audit logging. Easy to create custom plugins - just drop a file in `config/initializers/error_dashboard_plugins/`.
 
@@ -763,15 +789,17 @@ See [Customization Guide](docs/CUSTOMIZATION.md).
 <details>
 <summary><strong>How long are errors stored?</strong></summary>
 
-Forever by default. Configure retention policy:
+Forever by default (no automatic deletion). Manual cleanup with rake task:
 
-```ruby
-RailsErrorDashboard.configure do |config|
-  config.retention_days = 90  # Auto-delete after 90 days
-end
+```bash
+# Delete resolved errors older than 90 days
+rails error_dashboard:cleanup_resolved DAYS=90
+
+# Filter by application name
+rails error_dashboard:cleanup_resolved DAYS=30 APP_NAME="My App"
 ```
 
-Or clean up manually with rake tasks. See [Database Optimization](docs/guides/DATABASE_OPTIMIZATION.md).
+Or schedule with cron/whenever. See [Database Optimization](docs/guides/DATABASE_OPTIMIZATION.md).
 </details>
 
 <details>

data/app/controllers/rails_error_dashboard/errors_controller.rb

@@ -18,6 +18,7 @@ module RailsErrorDashboard
       frequency
       status
       assigned_to
+      assignee_name
       priority_level
       hide_snoozed
       sort_by
@@ -38,6 +39,18 @@ module RailsErrorDashboard
         @platform_scores = {}
       end
 
+      # Get correlation summary (if enabled, pass application filter)
+      if RailsErrorDashboard.configuration.enable_error_correlation
+        correlation = Queries::ErrorCorrelation.new(days: 7, application_id: @current_application_id)
+        @problematic_releases = correlation.problematic_releases.first(3)
+        @time_correlated_errors = correlation.time_correlated_errors.first(3)
+        @multi_error_users = correlation.multi_error_users(min_error_types: 2).first(5)
+      else
+        @problematic_releases = []
+        @time_correlated_errors = []
+        @multi_error_users = []
+      end
+
       # Get critical alerts (critical/high severity errors from last hour)
       # Filter by priority_level in database instead of loading all records into memory
       @critical_alerts = ErrorLog
@@ -62,6 +75,15 @@ module RailsErrorDashboard
       filter_options = Queries::FilterOptions.call(application_id: @current_application_id)
       @error_types = filter_options[:error_types]
       @platforms = filter_options[:platforms]
+
+      # Get all distinct assignees for the assignee filter dropdown
+      assignee_query = ErrorLog.where.not(assigned_to: nil)
+      # Filter by application if specified
+      assignee_query = assignee_query.where(application_id: @current_application_id) if @current_application_id.present?
+      @assignees = assignee_query.select(:assigned_to)
+                                 .distinct
+                                 .pluck(:assigned_to)
+                                 .sort
     end
 
     def show

data/app/helpers/rails_error_dashboard/application_helper.rb

@@ -74,13 +74,6 @@ module RailsErrorDashboard
       end
     end
 
-    # Returns the current user name for filtering "My Errors"
-    # Uses configured dashboard username or system username
-    # @return [String] Current user identifier
-    def current_user_name
-      RailsErrorDashboard.configuration.dashboard_username || ENV["USER"] || "unknown"
-    end
-
     # Returns a sanitized hash of filter params safe for query links
     # @param extra_keys [Array<Symbol>] Additional permitted keys for specific contexts
     # @return [Hash] Whitelisted params for building URLs
@@ -202,5 +195,84 @@ module RailsErrorDashboard
         }
       )
     end
+
+    # Automatically converts URLs in text to clickable links that open in new window
+    # Also highlights inline code wrapped in backticks with syntax highlighting
+    # Also converts file paths to GitHub links if repository URL is configured
+    # Supports http://, https://, and common patterns like github.com/user/repo
+    # @param text [String] The text containing URLs, file paths, and inline code
+    # @param error [RailsErrorDashboard::ErrorLog, nil] The error for context (to get repo URL)
+    # @return [String] HTML safe text with clickable links and styled code
+    def auto_link_urls(text, error: nil)
+      return "" if text.blank?
+
+      # Get repository URL from error's application or global config
+      repo_url = if error&.application&.repository_url.present?
+        error.application.repository_url
+      elsif RailsErrorDashboard.configuration.git_repository_url.present?
+        RailsErrorDashboard.configuration.git_repository_url
+      end
+
+      # First, protect inline code with backticks by replacing with placeholders
+      code_blocks = []
+      file_paths = []
+      text_with_placeholders = text.gsub(/`([^`]+)`/) do |match|
+        code_content = Regexp.last_match(1)
+
+        # Check if the code block contains a file path pattern
+        if repo_url && code_content =~ %r{^(app|lib|config|db|spec|test)/[^\s]+\.(rb|js|jsx|ts|tsx|erb|yml|yaml|json|css|scss)$}
+          # It's a file path - save it and mark for GitHub linking
+          file_paths << code_content
+          "###FILE_PATH_#{file_paths.length - 1}###"
+        else
+          # Regular code block
+          code_blocks << code_content
+          "###CODE_BLOCK_#{code_blocks.length - 1}###"
+        end
+      end
+
+      # Regex to match URLs (http://, https://, www., and common domains)
+      url_regex = %r{
+        (
+          (?:https?://|www\.)           # http://, https://, or www.
+          (?:[^\s<>"]+)                 # Domain and path (no spaces, <, >, or ")
+          |
+          (?:^|\s)                      # Start of string or whitespace
+          (?:github\.com|gitlab\.com|bitbucket\.org|jira\.[^\s]+)
+          /[^\s<>"]+                    # Path after domain
+        )
+      }xi
+
+      # Replace URLs with clickable links
+      linked_text = text_with_placeholders.gsub(url_regex) do |url|
+        # Clean up the URL
+        clean_url = url.strip
+
+        # Add protocol if missing
+        href = clean_url.start_with?("http://", "https://") ? clean_url : "https://#{clean_url}"
+
+        # Truncate display text for very long URLs
+        display_text = clean_url.length > 60 ? "#{clean_url[0..57]}..." : clean_url
+
+        "<a href=\"#{ERB::Util.html_escape(href)}\" target=\"_blank\" rel=\"noopener noreferrer\" class=\"text-primary text-decoration-underline\">#{ERB::Util.html_escape(display_text)}</a>"
+      end
+
+      # Restore file paths with GitHub links (elvish magic! 🧝‍♀️)
+      linked_text.gsub!(/###FILE_PATH_(\d+)###/) do
+        file_path = file_paths[Regexp.last_match(1).to_i]
+        github_url = "#{repo_url.chomp('/')}/blob/main/#{file_path}"
+        "<a href=\"#{ERB::Util.html_escape(github_url)}\" target=\"_blank\" rel=\"noopener noreferrer\" class=\"text-decoration-none\" title=\"View on GitHub\">" \
+        "<code class=\"inline-code-highlight file-path-link\">#{ERB::Util.html_escape(file_path)}</code></a>"
+      end
+
+      # Restore code blocks with styling
+      linked_text.gsub!(/###CODE_BLOCK_(\d+)###/) do
+        code_content = code_blocks[Regexp.last_match(1).to_i]
+        "<code class=\"inline-code-highlight\">#{ERB::Util.html_escape(code_content)}</code>"
+      end
+
+      # Preserve line breaks and return as HTML safe
+      simple_format(linked_text, {}, sanitize: false)
+    end
   end
 end

data/app/helpers/rails_error_dashboard/backtrace_helper.rb

@@ -2,11 +2,60 @@
 
 module RailsErrorDashboard
   module BacktraceHelper
+    # Language mapping for syntax highlighting
+    LANGUAGE_MAP = {
+      ".rb" => "ruby",
+      ".js" => "javascript",
+      ".jsx" => "javascript",
+      ".ts" => "typescript",
+      ".tsx" => "typescript",
+      ".erb" => "erb",
+      ".html" => "html",
+      ".htm" => "html",
+      ".css" => "css",
+      ".scss" => "scss",
+      ".sass" => "scss",
+      ".yml" => "yaml",
+      ".yaml" => "yaml",
+      ".json" => "json",
+      ".sql" => "sql",
+      ".xml" => "xml",
+      ".py" => "python",
+      ".go" => "go",
+      ".java" => "java",
+      ".c" => "c",
+      ".cpp" => "cpp",
+      ".h" => "c",
+      ".hpp" => "cpp",
+      ".sh" => "bash",
+      ".bash" => "bash",
+      ".zsh" => "bash",
+      ".php" => "php",
+      ".pl" => "perl",
+      ".r" => "r",
+      ".rs" => "rust",
+      ".swift" => "swift",
+      ".kt" => "kotlin",
+      ".scala" => "scala",
+      ".clj" => "clojure",
+      ".ex" => "elixir",
+      ".exs" => "elixir"
+    }.freeze
+
     # Parse backtrace string into structured frames
     def parse_backtrace(backtrace_string)
       Services::BacktraceParser.parse(backtrace_string)
     end
 
+    # Detect programming language from file path
+    # Returns Highlight.js language identifier
+    def detect_language_from_path(file_path)
+      return "plaintext" unless file_path
+
+      ext = File.extname(file_path).downcase
+      LANGUAGE_MAP[ext] || "plaintext"
+    end
+
     # Filter to show only application code
     def filter_app_code(frames)
       frames.select { |f| f[:category] == :app }
@@ -87,5 +136,105 @@ module RailsErrorDashboard
       frames.group_by { |f| f[:category] }
             .transform_values(&:count)
     end
+
+    # Read source code for a backtrace frame
+    # Returns hash with { lines:, error: } or nil
+    def read_source_code(frame, context: 5)
+      return nil unless RailsErrorDashboard.configuration.enable_source_code_integration
+      return nil unless frame[:file_path] && frame[:line_number]
+
+      # Cache key includes file path, line number, and git SHA if available
+      cache_key = "source_code/#{frame[:file_path]}/#{frame[:line_number]}"
+      cache_ttl = RailsErrorDashboard.configuration.source_code_cache_ttl || 3600
+
+      Rails.cache.fetch(cache_key, expires_in: cache_ttl) do
+        context_lines = RailsErrorDashboard.configuration.source_code_context_lines || 5
+        reader = Services::SourceCodeReader.new(frame[:file_path], frame[:line_number])
+        lines = reader.read_lines(context: context_lines)
+
+        if lines
+          {
+            lines: lines,
+            language: detect_language_from_path(frame[:file_path]),
+            error: nil
+          }
+        else
+          {
+            lines: nil,
+            language: nil,
+            error: reader.error
+          }
+        end
+      end
+    end
+
+    # Read git blame for a backtrace frame
+    # Returns blame data hash or nil
+    def read_git_blame(frame)
+      return nil unless RailsErrorDashboard.configuration.enable_source_code_integration
+      return nil unless RailsErrorDashboard.configuration.enable_git_blame
+      return nil unless frame[:file_path] && frame[:line_number]
+
+      # Cache key includes file path and line number
+      cache_key = "git_blame/#{frame[:file_path]}/#{frame[:line_number]}"
+      cache_ttl = RailsErrorDashboard.configuration.source_code_cache_ttl || 3600
+
+      Rails.cache.fetch(cache_key, expires_in: cache_ttl) do
+        reader = Services::GitBlameReader.new(frame[:file_path], frame[:line_number])
+        reader.read_blame
+      end
+    end
+
+    # Generate GitHub/GitLab/Bitbucket link for a frame
+    # Returns URL string or nil
+    def generate_repository_link(frame, error_log)
+      return nil unless RailsErrorDashboard.configuration.enable_source_code_integration
+      return nil unless RailsErrorDashboard.configuration.git_repository_url.present?
+      return nil unless frame[:file_path] && frame[:line_number]
+
+      repo_url = RailsErrorDashboard.configuration.git_repository_url
+      commit_sha = determine_commit_sha(error_log)
+
+      generator = Services::GithubLinkGenerator.new(
+        repository_url: repo_url,
+        file_path: frame[:file_path],
+        line_number: frame[:line_number],
+        commit_sha: commit_sha
+      )
+
+      generator.generate_link
+    end
+
+    private
+
+    # Determine which commit SHA to use based on strategy
+    def determine_commit_sha(error_log)
+      strategy = RailsErrorDashboard.configuration.git_branch_strategy || :commit_sha
+
+      case strategy
+      when :commit_sha
+        # Use the SHA from when the error occurred (most accurate)
+        error_log.respond_to?(:git_sha) ? error_log.git_sha : nil
+      when :current_branch
+        # Use current branch HEAD
+        get_current_git_sha
+      when :main
+        # Use main/master branch
+        nil # Will default to "main" in GithubLinkGenerator
+      else
+        nil
+      end
+    end
+
+    # Get current git SHA from repository
+    def get_current_git_sha
+      return @current_git_sha if defined?(@current_git_sha)
+
+      @current_git_sha = begin
+        `git rev-parse HEAD 2>/dev/null`.strip.presence
+      rescue StandardError
+        nil
+      end
+    end
   end
 end

data/app/models/rails_error_dashboard/application.rb

@@ -1,5 +1,5 @@
 module RailsErrorDashboard
-  class Application < ActiveRecord::Base
+  class Application < ErrorLogsRecord
     self.table_name = "rails_error_dashboard_applications"
 
     # Associations

data/app/models/rails_error_dashboard/error_log.rb

@@ -4,6 +4,15 @@ module RailsErrorDashboard
   class ErrorLog < ErrorLogsRecord
     self.table_name = "rails_error_dashboard_error_logs"
 
+    # Priority level constants
+    # Using industry standard: P0 = Critical (highest), P3 = Low (lowest)
+    PRIORITY_LEVELS = {
+      3 => { label: "Critical", short_label: "P0", color: "danger", emoji: "🔴" },
+      2 => { label: "High", short_label: "P1", color: "warning", emoji: "🟠" },
+      1 => { label: "Medium", short_label: "P2", color: "info", emoji: "🟡" },
+      0 => { label: "Low", short_label: "P3", color: "secondary", emoji: "⚪" }
+    }.freeze
+
     # Application association
     belongs_to :application, optional: false
 
@@ -94,11 +103,17 @@ module RailsErrorDashboard
     # Includes controller/action/application for better context-aware grouping
     # Per-app deduplication: same error in App A vs App B creates separate records
     def generate_error_hash
-      # Hash based on error class, normalized message, first stack frame, controller, action, and application
+      # Use smart normalization to improve error grouping accuracy
+      normalized_message = Services::ErrorNormalizer.normalize(message)
+
+      # Extract significant backtrace frames (skips gem/vendor code)
+      significant_frames = Services::ErrorNormalizer.extract_significant_frames(backtrace, count: 3)
+
+      # Hash based on error class, normalized message, significant frames, controller, action, and application
       digest_input = [
         error_type,
-        message&.gsub(/\d+/, "N")&.gsub(/"[^"]*"/, '""'), # Normalize numbers and strings
-        backtrace&.lines&.first&.split(":")&.first, # Just the file, not line number
+        normalized_message,
+        significant_frames,
         controller_name,  # Controller context
         action_name,      # Action context
         application_id.to_s  # Application context (for per-app deduplication)
@@ -283,22 +298,35 @@ module RailsErrorDashboard
 
     # Priority methods
     def priority_label
-      case priority_level
-      when 3 then "Critical"
-      when 2 then "High"
-      when 1 then "Medium"
-      when 0 then "Low"
-      else "Unset"
-      end
+      priority_data = PRIORITY_LEVELS[priority_level]
+      return "Unset" unless priority_data
+
+      "#{priority_data[:label]} (#{priority_data[:short_label]})"
     end
 
     def priority_color
-      case priority_level
-      when 3 then "danger"    # Critical = red
-      when 2 then "warning"   # High = orange
-      when 1 then "info"      # Medium = blue
-      when 0 then "secondary" # Low = gray
-      else "light"
+      priority_data = PRIORITY_LEVELS[priority_level]
+      return "light" unless priority_data
+
+      priority_data[:color]
+    end
+
+    def priority_emoji
+      priority_data = PRIORITY_LEVELS[priority_level]
+      return "" unless priority_data
+
+      priority_data[:emoji]
+    end
+
+    # Class method to get priority options for select dropdowns
+    def self.priority_options(include_emoji: false)
+      PRIORITY_LEVELS.sort_by { |level, _| -level }.map do |level, data|
+        label = if include_emoji
+          "#{data[:emoji]} #{data[:label]} (#{data[:short_label]})"
+        else
+          "#{data[:label]} (#{data[:short_label]})"
+        end
+        [ label, level ]
       end
     end