rails_error_dashboard 0.1.29 → 0.1.30

data/lib/rails_error_dashboard/services/git_blame_reader.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+
+module RailsErrorDashboard
+  module Services
+    # Reads git blame information for specific file lines
+    # Executes git blame command and parses porcelain output
+    #
+    # @example
+    #   reader = GitBlameReader.new("/path/to/file.rb", 42)
+    #   blame = reader.read_blame
+    #   # => { author: "John Doe", email: "john@example.com", date: Time, sha: "abc123", line: "code" }
+    class GitBlameReader
+      COMMAND_TIMEOUT = 5 # seconds
+      PORCELAIN_FIELDS = %w[
+        author
+        author-mail
+        author-time
+        author-tz
+        committer
+        committer-mail
+        committer-time
+        committer-tz
+        summary
+        filename
+      ].freeze
+
+      attr_reader :file_path, :line_number, :error
+
+      # Initialize a new git blame reader
+      #
+      # @param file_path [String] Path to the source file
+      # @param line_number [Integer] Target line number
+      def initialize(file_path, line_number)
+        @file_path = file_path
+        @line_number = line_number.to_i
+        @error = nil
+      end
+
+      # Read git blame information for the target line
+      #
+      # @return [Hash, nil] Blame data hash or nil if unavailable
+      def read_blame
+        unless git_available?
+          @error = "Git not available"
+          return nil
+        end
+
+        unless File.exist?(file_path)
+          @error = "File not found"
+          return nil
+        end
+
+        # Execute git blame command
+        output = execute_git_blame
+        return nil unless output
+
+        # Parse porcelain format output
+        parse_blame_output(output)
+      rescue StandardError => e
+        @error = "Error reading git blame: #{e.message}"
+        RailsErrorDashboard::Logger.error("GitBlameReader error for #{file_path}:#{line_number} - #{e.message}")
+        nil
+      end
+
+      # Check if git is available on the system
+      #
+      # @return [Boolean]
+      def git_available?
+        @git_available ||= begin
+          _stdout, _stderr, status = Open3.capture3("git", "--version")
+          status.success?
+        rescue StandardError
+          false
+        end
+      end
+
+      private
+
+      # Execute git blame command for the specific line
+      #
+      # @return [String, nil] Command output or nil if failed
+      def execute_git_blame
+        # Build command array (prevents command injection)
+        cmd = [
+          "git",
+          "blame",
+          "-L", "#{line_number},#{line_number}",
+          "--porcelain",
+          "--", # Separator
+          file_path
+        ]
+
+        # Execute with timeout
+        stdout, stderr, status = Timeout.timeout(COMMAND_TIMEOUT) do
+          Open3.capture3(*cmd, chdir: Rails.root)
+        end
+
+        unless status.success?
+          @error = "Git blame failed: #{stderr}"
+          RailsErrorDashboard::Logger.debug("Git blame failed for #{file_path}:#{line_number} - #{stderr}")
+          return nil
+        end
+
+        stdout
+      rescue Timeout::Error
+        @error = "Git blame timeout"
+        RailsErrorDashboard::Logger.warn("Git blame timeout for #{file_path}:#{line_number}")
+        nil
+      rescue StandardError => e
+        @error = "Git blame execution error: #{e.message}"
+        RailsErrorDashboard::Logger.error("Git blame execution error for #{file_path}:#{line_number} - #{e.message}")
+        nil
+      end
+
+      # Parse git blame porcelain format output
+      #
+      # Git blame --porcelain format:
+      # <sha> <line_number> <final_line_number> <num_lines>
+      # author <author_name>
+      # author-mail <<author_email>>
+      # author-time <unix_timestamp>
+      # author-tz <timezone>
+      # committer <committer_name>
+      # committer-mail <<committer_email>>
+      # committer-time <unix_timestamp>
+      # committer-tz <timezone>
+      # summary <commit_message_summary>
+      # filename <filename>
+      # <TAB><line_content>
+      #
+      # @param output [String] Git blame porcelain output
+      # @return [Hash, nil] Parsed blame data
+      def parse_blame_output(output)
+        return nil if output.blank?
+
+        lines = output.split("\n")
+        return nil if lines.empty?
+
+        # First line contains commit SHA and line info
+        first_line = lines[0]
+        match = first_line.match(/^([0-9a-f]+)\s+(\d+)\s+(\d+)/)
+        unless match
+          @error = "Incomplete git blame data"
+          return nil
+        end
+
+        sha = match[1]
+        data = { sha: sha }
+
+        # Parse subsequent lines
+        lines[1..].each do |line|
+          # Check for field: value lines
+          PORCELAIN_FIELDS.each do |field|
+            if line.start_with?("#{field} ")
+              value = line.sub("#{field} ", "")
+
+              case field
+              when "author"
+                data[:author] = value
+              when "author-mail"
+                # Remove < and > brackets
+                data[:email] = value.gsub(/[<>]/, "")
+              when "author-time"
+                # Convert Unix timestamp to Time object
+                data[:date] = Time.at(value.to_i)
+              when "summary"
+                data[:commit_message] = value
+              end
+            end
+          end
+
+          # Line content starts with tab
+          if line.start_with?("\t")
+            data[:line] = line.sub("\t", "")
+          end
+        end
+
+        # Validate required fields
+        if data[:author].present? && data[:sha].present?
+          data
+        else
+          @error = "Incomplete git blame data"
+          nil
+        end
+      rescue StandardError => e
+        @error = "Error parsing git blame output: #{e.message}"
+        RailsErrorDashboard::Logger.error("Git blame parsing error: #{e.message}")
+        nil
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/github_link_generator.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Generates links to source code on GitHub, GitLab, or Bitbucket
+    # Supports commit SHA, branch, and tag references
+    #
+    # @example
+    #   generator = GithubLinkGenerator.new(
+    #     repository_url: "https://github.com/user/repo",
+    #     file_path: "app/models/user.rb",
+    #     line_number: 42,
+    #     commit_sha: "abc123def456"
+    #   )
+    #   generator.generate_link
+    #   # => "https://github.com/user/repo/blob/abc123def456/app/models/user.rb#L42"
+    class GithubLinkGenerator
+      attr_reader :repository_url, :file_path, :line_number, :commit_sha, :branch, :error
+
+      # Initialize a new link generator
+      #
+      # @param repository_url [String] Base repository URL (GitHub, GitLab, Bitbucket)
+      # @param file_path [String] Relative path to file from repository root
+      # @param line_number [Integer] Line number to link to
+      # @param commit_sha [String, nil] Git commit SHA (recommended for accuracy)
+      # @param branch [String, nil] Branch name (fallback if no commit SHA)
+      def initialize(repository_url:, file_path:, line_number:, commit_sha: nil, branch: nil)
+        @repository_url = repository_url
+        @file_path = file_path
+        @line_number = line_number.to_i
+        @commit_sha = commit_sha
+        @branch = branch || "main"
+        @error = nil
+      end
+
+      # Generate a link to the source file on the repository host
+      #
+      # @return [String, nil] URL to the source file or nil if invalid
+      def generate_link
+        return nil if repository_url.blank? || file_path.blank?
+
+        # Normalize repository URL
+        normalized_repo = normalize_repository_url
+
+        # Determine reference (commit SHA or branch)
+        reference = determine_reference
+
+        # Generate link based on repository type
+        case detect_repository_type
+        when :github
+          generate_github_link(normalized_repo, reference)
+        when :gitlab
+          generate_gitlab_link(normalized_repo, reference)
+        when :bitbucket
+          generate_bitbucket_link(normalized_repo, reference)
+        else
+          @error = "Unsupported repository type"
+          nil
+        end
+      rescue StandardError => e
+        @error = "Error generating link: #{e.message}"
+        RailsErrorDashboard::Logger.error("GithubLinkGenerator error for #{repository_url} - #{e.message}")
+        nil
+      end
+
+      private
+
+      # Normalize repository URL (remove .git suffix, trailing slashes, etc.)
+      #
+      # @return [String]
+      def normalize_repository_url
+        url = repository_url.strip
+        url = url.chomp(".git")
+        url = url.chomp("/")
+        url
+      end
+
+      # Detect repository type from URL
+      #
+      # @return [Symbol] :github, :gitlab, :bitbucket, or :unknown
+      def detect_repository_type
+        normalized = normalize_repository_url.downcase
+
+        return :github if normalized.include?("github.com")
+        return :gitlab if normalized.include?("gitlab.com") || normalized.include?("gitlab.")
+        return :bitbucket if normalized.include?("bitbucket.org") || normalized.include?("bitbucket.")
+
+        :unknown
+      end
+
+      # Determine which reference to use (commit SHA or branch)
+      #
+      # @return [String]
+      def determine_reference
+        if commit_sha.present?
+          commit_sha
+        else
+          branch
+        end
+      end
+
+      # Normalize file path (remove leading slashes, Rails.root prefix, etc.)
+      #
+      # @return [String]
+      def normalize_file_path
+        path = file_path.strip
+
+        # Remove leading slash
+        path = path.sub(%r{^/}, "")
+
+        # Remove Rails.root or app root prefix if present
+        # Handles paths like "/Users/foo/myapp/app/models/user.rb" -> "app/models/user.rb"
+        # Match pattern: look for one of the standard Rails directories
+        match = path.match(%r{.*/?((?:app|lib|config|db|spec|test)/.*)$})
+        if match
+          path = match[1]
+        end
+
+        path
+      end
+
+      # Generate GitHub link
+      #
+      # Format: https://github.com/user/repo/blob/{ref}/path/to/file.rb#L42
+      #
+      # @param repo_url [String] Normalized repository URL
+      # @param ref [String] Commit SHA or branch name
+      # @return [String]
+      def generate_github_link(repo_url, ref)
+        normalized_path = normalize_file_path
+        "#{repo_url}/blob/#{ref}/#{normalized_path}#L#{line_number}"
+      end
+
+      # Generate GitLab link
+      #
+      # Format: https://gitlab.com/user/repo/-/blob/{ref}/path/to/file.rb#L42
+      #
+      # @param repo_url [String] Normalized repository URL
+      # @param ref [String] Commit SHA or branch name
+      # @return [String]
+      def generate_gitlab_link(repo_url, ref)
+        normalized_path = normalize_file_path
+        "#{repo_url}/-/blob/#{ref}/#{normalized_path}#L#{line_number}"
+      end
+
+      # Generate Bitbucket link
+      #
+      # Format: https://bitbucket.org/user/repo/src/{ref}/path/to/file.rb#lines-42
+      #
+      # @param repo_url [String] Normalized repository URL
+      # @param ref [String] Commit SHA or branch name
+      # @return [String]
+      def generate_bitbucket_link(repo_url, ref)
+        normalized_path = normalize_file_path
+        "#{repo_url}/src/#{ref}/#{normalized_path}#lines-#{line_number}"
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/source_code_reader.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Reads source code files from disk with security validation
+    # and context lines around a target line number
+    #
+    # @example
+    #   reader = SourceCodeReader.new("/path/to/app/models/user.rb", 42)
+    #   lines = reader.read_lines(context: 5)
+    #   # Returns array of hashes with line numbers and content
+    class SourceCodeReader
+      MAX_FILE_SIZE = 10 * 1024 * 1024 # 10 MB
+      MAX_CONTEXT_LINES = 50
+
+      attr_reader :file_path, :line_number, :error
+
+      # Initialize a new source code reader
+      #
+      # @param file_path [String] Path to the source file
+      # @param line_number [Integer] Target line number
+      def initialize(file_path, line_number)
+        @file_path = file_path
+        @line_number = line_number.to_i
+        @error = nil
+      end
+
+      # Read source code lines with context around the target line
+      #
+      # @param context [Integer] Number of lines before and after target line
+      # @return [Array<Hash>, nil] Array of line data hashes or nil if unavailable
+      def read_lines(context: 5)
+        context = [ [ context, MAX_CONTEXT_LINES ].min, 1 ].max
+
+        # Validate and resolve path
+        absolute_path = resolve_absolute_path
+        return nil unless absolute_path
+
+        # Validate path is safe
+        unless validate_path!(absolute_path)
+          @error = "Invalid or unsafe file path"
+          return nil
+        end
+
+        # Check file exists and is readable
+        unless File.exist?(absolute_path) && File.readable?(absolute_path)
+          @error = "File not found or not readable"
+          return nil
+        end
+
+        # Check file size
+        file_size = File.size(absolute_path)
+        if file_size > MAX_FILE_SIZE
+          @error = "File too large (#{file_size} bytes, max #{MAX_FILE_SIZE})"
+          return nil
+        end
+
+        # Check if file is binary
+        if binary_file?(absolute_path)
+          @error = "Binary file cannot be displayed"
+          return nil
+        end
+
+        # Read the specific lines
+        read_specific_lines(absolute_path, line_number - context, line_number + context)
+      rescue StandardError => e
+        @error = "Error reading file: #{e.message}"
+        RailsErrorDashboard::Logger.error("SourceCodeReader error for #{file_path}:#{line_number} - #{e.message}")
+        nil
+      end
+
+      # Check if file exists on disk
+      #
+      # @return [Boolean]
+      def file_exists?
+        absolute_path = resolve_absolute_path
+        return false unless absolute_path
+
+        File.exist?(absolute_path) && File.readable?(absolute_path)
+      rescue StandardError
+        false
+      end
+
+      private
+
+      # Resolve file path to absolute path within Rails.root
+      #
+      # @return [String, nil] Absolute path or nil if invalid
+      def resolve_absolute_path
+        return nil if file_path.blank?
+
+        # Handle relative paths from backtrace
+        if file_path.start_with?(Rails.root.to_s)
+          # Already absolute
+          file_path
+        elsif file_path.start_with?("/")
+          # Absolute but might be from different root (deployed location)
+          # Try to find relative to Rails.root
+          relative = file_path.sub(%r{^.*/}, "")
+          File.join(Rails.root, relative)
+        else
+          # Relative path
+          File.join(Rails.root, file_path)
+        end
+      end
+
+      # Validate path is safe to read (security check)
+      #
+      # @param path [String] Absolute path to validate
+      # @return [Boolean]
+      # @raise [SecurityError] if path is unsafe
+      def validate_path!(path)
+        # Normalize path
+        normalized = File.expand_path(path)
+        rails_root = File.expand_path(Rails.root)
+
+        # Must be within Rails.root
+        unless normalized.start_with?(rails_root)
+          RailsErrorDashboard::Logger.warn("Path outside Rails.root: #{normalized}")
+          return false
+        end
+
+        # Prevent directory traversal
+        if path.include?("..") || normalized.include?("..")
+          RailsErrorDashboard::Logger.warn("Directory traversal attempt: #{path}")
+          return false
+        end
+
+        # Check against sensitive file patterns
+        sensitive_patterns = [
+          /\.env/i,
+          /secrets\.yml$/i,
+          /credentials\.yml/i,
+          /database\.yml$/i,
+          /master\.key$/i,
+          /private_key/i,
+          /\.pem$/i,
+          /\.key$/i
+        ]
+
+        if sensitive_patterns.any? { |pattern| normalized.match?(pattern) }
+          RailsErrorDashboard::Logger.warn("Attempt to read sensitive file: #{normalized}")
+          return false
+        end
+
+        # Only show app code if configured
+        if RailsErrorDashboard.configuration.only_show_app_code_source
+          # Block gem/vendor code
+          blocked_patterns = [
+            %r{/gems/},
+            %r{/vendor/bundle/},
+            %r{/vendor/ruby/},
+            %r{/.bundle/}
+          ]
+
+          if blocked_patterns.any? { |pattern| normalized.match?(pattern) }
+            RailsErrorDashboard::Logger.debug("Skipping gem/vendor code: #{normalized}")
+            return false
+          end
+        end
+
+        true
+      end
+
+      # Read specific lines from file
+      #
+      # @param file_path [String] Path to file
+      # @param start_line [Integer] First line to read (1-indexed)
+      # @param end_line [Integer] Last line to read (1-indexed)
+      # @return [Array<Hash>] Array of line data
+      def read_specific_lines(file_path, start_line, end_line)
+        start_line = [ start_line, 1 ].max
+        lines = []
+
+        File.open(file_path, "r") do |file|
+          file.each_line.with_index(1) do |line, line_num|
+            break if line_num > end_line
+
+            next if line_num < start_line
+
+            lines << {
+              number: line_num,
+              content: line.chomp,
+              highlight: line_num == @line_number
+            }
+          end
+        end
+
+        lines
+      rescue StandardError => e
+        RailsErrorDashboard::Logger.error("Error reading specific lines from #{file_path}: #{e.message}")
+        []
+      end
+
+      # Check if file is binary
+      #
+      # @param file_path [String] Path to file
+      # @return [Boolean]
+      def binary_file?(file_path)
+        # Read first 8KB to check for null bytes
+        sample_size = 8192
+        File.open(file_path, "rb") do |file|
+          sample = file.read(sample_size)
+          return false if sample.nil? || sample.empty?
+
+          # Binary files typically contain null bytes
+          sample.include?("\x00")
+        end
+      rescue StandardError
+        false # If we can't determine, assume text
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.1.29"
+  VERSION = "0.1.30"
 end

data/lib/rails_error_dashboard.rb

@@ -1,5 +1,6 @@
 require "rails_error_dashboard/version"
 require "rails_error_dashboard/engine"
+require "rails_error_dashboard/configuration_error"
 require "rails_error_dashboard/configuration"
 require "rails_error_dashboard/logger"
 require "rails_error_dashboard/manual_error_reporter"
@@ -16,6 +17,7 @@ require "turbo-rails"
 
 # Core library files
 require "rails_error_dashboard/value_objects/error_context"
+require "rails_error_dashboard/helpers/user_model_detector"
 require "rails_error_dashboard/services/platform_detector"
 require "rails_error_dashboard/services/backtrace_parser"
 require "rails_error_dashboard/services/similarity_calculator"
@@ -23,6 +25,10 @@ require "rails_error_dashboard/services/cascade_detector"
 require "rails_error_dashboard/services/baseline_calculator"
 require "rails_error_dashboard/services/baseline_alert_throttler"
 require "rails_error_dashboard/services/pattern_detector"
+require "rails_error_dashboard/services/error_normalizer"
+require "rails_error_dashboard/services/source_code_reader"
+require "rails_error_dashboard/services/git_blame_reader"
+require "rails_error_dashboard/services/github_link_generator"
 require "rails_error_dashboard/queries/co_occurring_errors"
 require "rails_error_dashboard/queries/error_cascades"
 require "rails_error_dashboard/queries/baseline_stats"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.1.29
+  version: 0.1.30
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -267,13 +267,6 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- app/assets/stylesheets/rails_error_dashboard/_catppuccin_mocha.scss
-- app/assets/stylesheets/rails_error_dashboard/_components.scss
-- app/assets/stylesheets/rails_error_dashboard/_layout.scss
-- app/assets/stylesheets/rails_error_dashboard/_theme_variables.scss
-- app/assets/stylesheets/rails_error_dashboard/application.css
-- app/assets/stylesheets/rails_error_dashboard/application.css.map
-- app/assets/stylesheets/rails_error_dashboard/application.scss
 - app/controllers/rails_error_dashboard/application_controller.rb
 - app/controllers/rails_error_dashboard/errors_controller.rb
 - app/helpers/rails_error_dashboard/application_helper.rb
@@ -298,11 +291,11 @@ files:
 - app/models/rails_error_dashboard/error_logs_record.rb
 - app/models/rails_error_dashboard/error_occurrence.rb
 - app/views/layouts/rails_error_dashboard.html.erb
-- app/views/layouts/rails_error_dashboard/application.html.erb
 - app/views/rails_error_dashboard/error_notification_mailer/error_alert.html.erb
 - app/views/rails_error_dashboard/error_notification_mailer/error_alert.text.erb
 - app/views/rails_error_dashboard/errors/_error_row.html.erb
 - app/views/rails_error_dashboard/errors/_pattern_insights.html.erb
+- app/views/rails_error_dashboard/errors/_source_code.html.erb
 - app/views/rails_error_dashboard/errors/_stats.html.erb
 - app/views/rails_error_dashboard/errors/_timeline.html.erb
 - app/views/rails_error_dashboard/errors/_user_errors_table.html.erb
@@ -312,9 +305,11 @@ files:
 - app/views/rails_error_dashboard/errors/overview.html.erb
 - app/views/rails_error_dashboard/errors/platform_comparison.html.erb
 - app/views/rails_error_dashboard/errors/settings.html.erb
+- app/views/rails_error_dashboard/errors/settings/_value_badge.html.erb
 - app/views/rails_error_dashboard/errors/show.html.erb
 - config/routes.rb
 - db/development.sqlite3
+- db/migrate/20251223000000_create_rails_error_dashboard_complete_schema.rb
 - db/migrate/20251224000001_create_rails_error_dashboard_error_logs.rb
 - db/migrate/20251224081522_add_better_tracking_to_error_logs.rb
 - db/migrate/20251224101217_add_controller_action_to_error_logs.rb
@@ -345,8 +340,10 @@ files:
 - lib/rails_error_dashboard/commands/log_error.rb
 - lib/rails_error_dashboard/commands/resolve_error.rb
 - lib/rails_error_dashboard/configuration.rb
+- lib/rails_error_dashboard/configuration_error.rb
 - lib/rails_error_dashboard/engine.rb
 - lib/rails_error_dashboard/error_reporter.rb
+- lib/rails_error_dashboard/helpers/user_model_detector.rb
 - lib/rails_error_dashboard/logger.rb
 - lib/rails_error_dashboard/manual_error_reporter.rb
 - lib/rails_error_dashboard/middleware/error_catcher.rb
@@ -372,9 +369,13 @@ files:
 - lib/rails_error_dashboard/services/baseline_alert_throttler.rb
 - lib/rails_error_dashboard/services/baseline_calculator.rb
 - lib/rails_error_dashboard/services/cascade_detector.rb
+- lib/rails_error_dashboard/services/error_normalizer.rb
+- lib/rails_error_dashboard/services/git_blame_reader.rb
+- lib/rails_error_dashboard/services/github_link_generator.rb
 - lib/rails_error_dashboard/services/pattern_detector.rb
 - lib/rails_error_dashboard/services/platform_detector.rb
 - lib/rails_error_dashboard/services/similarity_calculator.rb
+- lib/rails_error_dashboard/services/source_code_reader.rb
 - lib/rails_error_dashboard/value_objects/error_context.rb
 - lib/rails_error_dashboard/version.rb
 - lib/tasks/error_dashboard.rake
@@ -386,8 +387,10 @@ metadata:
   homepage_uri: https://github.com/AnjanJ/rails_error_dashboard
   source_code_uri: https://github.com/AnjanJ/rails_error_dashboard
   changelog_uri: https://github.com/AnjanJ/rails_error_dashboard/blob/main/CHANGELOG.md
+  documentation_uri: https://rails-error-dashboard.anjan.dev
+  demo_uri: https://rails-error-dashboard.anjan.dev
 post_install_message: "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n
-  \ Rails Error Dashboard v0.1.29\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n\U0001F195
+  \ Rails Error Dashboard v0.1.30\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n\U0001F195
   First time? Quick start:\n   rails generate rails_error_dashboard:install\n   rails
   db:migrate\n   # Add to config/routes.rb:\n   mount RailsErrorDashboard::Engine
   => '/error_dashboard'\n\n\U0001F504 Upgrading from v0.1.x?\n   rails db:migrate\n