rails_error_dashboard 0.1.28 → 0.1.30

data/lib/rails_error_dashboard/services/error_normalizer.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Smart error message normalization for better error grouping
+    #
+    # Replaces dynamic values (IDs, UUIDs, timestamps, etc.) with placeholders
+    # while preserving semantic meaning. This improves error deduplication accuracy
+    # compared to naive "replace all numbers" approach.
+    #
+    # @example
+    #   ErrorNormalizer.normalize("User 123 not found")
+    #   # => "User :id not found"
+    #
+    #   ErrorNormalizer.normalize("Expected 2 arguments, got 5")
+    #   # => "Expected 2 arguments, got 5" (preserves meaningful numbers)
+    #
+    class ErrorNormalizer
+      # Patterns for smart normalization
+      # Order matters: more specific patterns should come first
+      PATTERNS = {
+        # UUIDs (e.g., "550e8400-e29b-41d4-a716-446655440000")
+        uuid: /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i,
+
+        # Memory addresses (e.g., "<User:0x00007f8b1a2b3c4d>", "0x00007f8b1a2b3c4d")
+        # MUST come before hash_id to match memory addresses first
+        memory_address: /#?<[^>]+:0x[0-9a-f]+>/i,
+        hex_address: /\b0x[0-9a-f]{8,16}\b/i,
+
+        # Timestamps (ISO8601 and common formats)
+        # Remove timezone offset separately to avoid leaving it behind
+        timestamp_iso: /\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?/,
+        timestamp_unix: /\btimestamp[:\s]+\d{10,13}\b/i,
+
+        # Tokens and API keys (long alphanumeric strings)
+        # MUST come before large_number to match long tokens first
+        token: /\b[a-z0-9]{32,}\b/i,
+
+        # Object IDs and database IDs (e.g., "User #123", "id: 456", "ID=789")
+        # MUST come before hash_id to match specific ID patterns first
+        object_id: /(?:#|(?:id|ID)(?:\s*[=:#]\s*|\s+))\d+\b/,
+        # Ruby-style object references (e.g., "User:123", "#<User:123>")
+        hash_id: /#?<?[A-Z]\w*:\d+>?/,
+
+        # File paths with dynamic components (but check for UUIDs in path first)
+        # More specific pattern: match /tmp/ followed by UUID-like or hash-like segment
+        temp_path: %r{/(?:tmp|var/tmp|private/tmp)/(?:[a-z0-9_-]+/)*[a-z0-9_-]+(?:\.[a-z0-9]+)?},
+
+        # Numbered URL paths - MUST come before large_number
+        # Capture the leading slash with the number, and optional trailing slash
+        numbered_path: %r{/\d+(?=/|$)}, # e.g., "/api/users/123/posts" → "/api/users:numbered_path/posts"
+
+        # Email addresses (preserve domain, replace local part)
+        email: /\b[\w.+-]+@[\w.-]+\.[a-z]{2,}\b/i,
+
+        # IP addresses
+        ipv4: /\b(?:\d{1,3}\.){3}\d{1,3}\b/,
+        ipv6: /\b(?:[0-9a-f]{1,4}:){7}[0-9a-f]{1,4}\b/i,
+
+        # Hexadecimal values (but not in memory addresses - already handled)
+        hex_value: /\b0x[0-9a-f]+\b/i,
+
+        # Standalone large numbers (likely IDs, but preserve small numbers < 1000)
+        # MUST come last to avoid matching parts of other patterns
+        large_number: /\b\d{4,}\b/
+      }.freeze
+
+      class << self
+        # Normalize an error message by replacing dynamic values with placeholders
+        #
+        # @param message [String] the error message to normalize
+        # @return [String] the normalized message
+        def normalize(message)
+          return "" if message.nil?
+          return message if message.strip.empty? # Preserve whitespace-only strings
+
+          normalized = message.dup
+
+          # Apply each pattern in order
+          PATTERNS.each do |type, pattern|
+            normalized.gsub!(pattern, ":#{type}")
+          end
+
+          # Clean up leftover timezone offsets that weren't caught by timestamp pattern
+          normalized.gsub!(/\s+[+-]\d{2}:\d{2}$/, "")
+
+          normalized
+        end
+
+        # Extract significant backtrace frames, skipping gem/vendor code
+        #
+        # @param backtrace [String] the full backtrace string
+        # @param count [Integer] number of frames to extract (default: 3)
+        # @return [String, nil] the significant frames joined with "|"
+        def extract_significant_frames(backtrace, count: 3)
+          return nil if backtrace.blank?
+
+          frames = backtrace.split("\n")
+            .map(&:strip)
+            .reject { |line| gem_or_vendor_code?(line) }
+            .reject { |line| ruby_stdlib_code?(line) }
+            .first(count)
+            .map { |line| extract_file_and_method(line) }
+            .compact
+
+          frames.empty? ? nil : frames.join("|")
+        end
+
+        private
+
+        # Check if a backtrace line is from gem/vendor code
+        def gem_or_vendor_code?(line)
+          line.include?("vendor/bundle") ||
+            line.include?("gems/") ||
+            line.include?(".gem/ruby")
+        end
+
+        # Check if a backtrace line is from Ruby standard library
+        def ruby_stdlib_code?(line)
+          line.include?("/ruby/") ||
+            line.include?("/lib/ruby/") ||
+            line.match?(%r{ruby-\d+\.\d+\.\d+/lib})
+        end
+
+        # Extract file path and method name from a backtrace line
+        # Example: "/app/models/user.rb:10:in `name'" => "/app/models/user.rb:name"
+        def extract_file_and_method(line)
+          # Match pattern: file.rb:line:in `method'
+          match = line.match(%r{^(.+\.rb):(\d+)(?::in `(.+)')?})
+          return nil unless match
+
+          file = match[1]
+          method = match[3]
+
+          # Remove absolute path prefix for consistency
+          file = file.sub(%r{.*/(?=app/)}, "")
+
+          method ? "#{file}:#{method}" : file
+        end
+      end
+    end
+  end
+end

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