rails_error_dashboard 0.5.7 → 0.5.9

data/lib/rails_error_dashboard/queries/active_storage_summary.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Aggregate ActiveStorage events from breadcrumbs across all errors
+    # Scans error_logs breadcrumbs JSON, filters for "active_storage" category crumbs,
+    # and groups by service name with counts by operation type.
+    class ActiveStorageSummary
+      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
+        {
+          services: aggregated_services
+        }
+      end
+
+      private
+
+      def base_query
+        scope = ErrorLog.where("occurred_at >= ?", @start_date)
+                        .where.not(breadcrumbs: nil)
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
+      end
+
+      def aggregated_services
+        results = {}
+
+        base_query.select(:id, :breadcrumbs, :occurred_at).find_each(batch_size: 500) do |error_log|
+          crumbs = parse_breadcrumbs(error_log.breadcrumbs)
+          next if crumbs.empty?
+
+          as_crumbs = crumbs.select { |c| c["c"] == "active_storage" }
+          next if as_crumbs.empty?
+
+          as_crumbs.each do |crumb|
+            meta = crumb["meta"] || {}
+            service = meta["service"].to_s.presence || "Unknown"
+            operation = meta["operation"].to_s
+
+            results[service] ||= {
+              service: service,
+              upload_count: 0,
+              download_count: 0,
+              delete_count: 0,
+              exist_count: 0,
+              error_ids: [],
+              durations: [],
+              last_seen: nil
+            }
+
+            entry = results[service]
+
+            case operation
+            when "upload"
+              entry[:upload_count] += 1
+            when "download", "streaming_download"
+              entry[:download_count] += 1
+            when "delete", "delete_prefixed"
+              entry[:delete_count] += 1
+            when "exist"
+              entry[:exist_count] += 1
+            end
+
+            entry[:durations] << crumb["d"] if crumb["d"].is_a?(Numeric) && crumb["d"] > 0
+            entry[:error_ids] << error_log.id
+            entry[:last_seen] = [ entry[:last_seen], error_log.occurred_at ].compact.max
+          end
+        end
+
+        results.values.each do |r|
+          r[:error_ids] = r[:error_ids].uniq
+          r[:error_count] = r[:error_ids].size
+          r[:total_operations] = r[:upload_count] + r[:download_count] + r[:delete_count] + r[:exist_count]
+          r[:avg_duration_ms] = r[:durations].any? ? (r[:durations].sum / r[:durations].size).round(2) : nil
+          r[:slowest_ms] = r[:durations].max
+          r.delete(:durations)
+        end
+        results.values.sort_by { |r| [ -r[:total_operations], -r[:error_count] ] }
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] ActiveStorageSummary query failed: #{e.class}: #{e.message}")
+        []
+      end
+
+      def parse_breadcrumbs(raw)
+        return [] if raw.blank?
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        []
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/codeberg_issue_client.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Codeberg/Gitea/Forgejo REST API client for issue management.
+    #
+    # Codeberg runs Forgejo (hard fork of Gitea). The API is compatible with
+    # Gitea's /api/v1/ endpoints. Works with any Gitea or Forgejo instance.
+    #
+    # API Docs: https://docs.gitea.com/development/api-usage
+    # Codeberg: https://codeberg.org/api/swagger
+    # Auth: Personal access token
+    class CodebergIssueClient < IssueTrackerClient
+      def initialize(token:, repo:, api_url: nil)
+        super
+        @api_url = api_url || "https://codeberg.org/api/v1"
+      end
+
+      def create_issue(title:, body:, labels: [])
+        response = http_post(
+          "#{@api_url}/repos/#{@repo}/issues",
+          { title: title, body: truncate_body(body) },
+          auth_headers
+        )
+        # Note: Gitea/Forgejo labels require label IDs, not names.
+        # We skip labels in the create call — users can add them on the platform.
+
+        if response[:status] == 201
+          data = response[:body]
+          success_response(url: data["html_url"], number: data["number"])
+        else
+          error_response("Codeberg API error (#{response[:status]}): #{response[:body]&.dig("message") || response[:error]}")
+        end
+      end
+
+      def close_issue(number:)
+        response = http_patch(
+          "#{@api_url}/repos/#{@repo}/issues/#{number}",
+          { state: "closed" },
+          auth_headers
+        )
+
+        response[:status] == 201 ? success_response({}) : error_response("Codeberg API error (#{response[:status]})")
+      end
+
+      def reopen_issue(number:)
+        response = http_patch(
+          "#{@api_url}/repos/#{@repo}/issues/#{number}",
+          { state: "open" },
+          auth_headers
+        )
+
+        response[:status] == 201 ? success_response({}) : error_response("Codeberg API error (#{response[:status]})")
+      end
+
+      def add_comment(number:, body:)
+        response = http_post(
+          "#{@api_url}/repos/#{@repo}/issues/#{number}/comments",
+          { body: truncate_body(body) },
+          auth_headers
+        )
+
+        if response[:status] == 201
+          success_response(url: response[:body]["html_url"])
+        else
+          error_response("Codeberg API error (#{response[:status]})")
+        end
+      end
+
+      def fetch_comments(number:, per_page: 10)
+        response = http_get(
+          "#{@api_url}/repos/#{@repo}/issues/#{number}/comments?limit=#{per_page}",
+          auth_headers
+        )
+
+        if response[:status] == 200
+          comments = (response[:body] || []).map { |c|
+            {
+              author: c.dig("user", "login"),
+              avatar_url: c.dig("user", "avatar_url"),
+              body: c["body"],
+              created_at: c["created_at"],
+              url: c["html_url"]
+            }
+          }
+          success_response(comments: comments)
+        else
+          error_response("Codeberg API error (#{response[:status]})")
+        end
+      end
+
+      def fetch_issue(number:)
+        response = http_get(
+          "#{@api_url}/repos/#{@repo}/issues/#{number}",
+          auth_headers
+        )
+
+        if response[:status] == 200
+          data = response[:body]
+          success_response(
+            state: data["state"],
+            title: data["title"],
+            assignees: (data["assignees"] || []).map { |a|
+              { login: a["login"], avatar_url: a["avatar_url"] }
+            },
+            labels: (data["labels"] || []).map { |l|
+              { name: l["name"], color: l["color"] }
+            }
+          )
+        else
+          error_response("Codeberg API error (#{response[:status]})")
+        end
+      end
+
+      private
+
+      def auth_headers
+        { "Authorization" => "token #{@token}" }
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/github_issue_client.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # GitHub REST API client for issue management.
+    #
+    # API Docs: https://docs.github.com/en/rest/issues/issues
+    # Auth: Personal access token with `repo` scope
+    # Rate limit: 5,000 requests/hour per authenticated user
+    class GitHubIssueClient < IssueTrackerClient
+      def initialize(token:, repo:, api_url: nil)
+        super
+        @api_url = api_url || "https://api.github.com"
+      end
+
+      def create_issue(title:, body:, labels: [])
+        response = http_post(
+          "#{@api_url}/repos/#{@repo}/issues",
+          { title: title, body: truncate_body(body), labels: labels },
+          auth_headers
+        )
+
+        if response[:status] == 201
+          data = response[:body]
+          success_response(url: data["html_url"], number: data["number"])
+        else
+          error_response("GitHub API error (#{response[:status]}): #{response[:body]&.dig("message") || response[:error]}")
+        end
+      end
+
+      def close_issue(number:)
+        response = http_patch(
+          "#{@api_url}/repos/#{@repo}/issues/#{number}",
+          { state: "closed" },
+          auth_headers
+        )
+
+        response[:status] == 200 ? success_response({}) : error_response("GitHub API error (#{response[:status]})")
+      end
+
+      def reopen_issue(number:)
+        response = http_patch(
+          "#{@api_url}/repos/#{@repo}/issues/#{number}",
+          { state: "open" },
+          auth_headers
+        )
+
+        response[:status] == 200 ? success_response({}) : error_response("GitHub API error (#{response[:status]})")
+      end
+
+      def add_comment(number:, body:)
+        response = http_post(
+          "#{@api_url}/repos/#{@repo}/issues/#{number}/comments",
+          { body: truncate_body(body) },
+          auth_headers
+        )
+
+        if response[:status] == 201
+          success_response(url: response[:body]["html_url"])
+        else
+          error_response("GitHub API error (#{response[:status]})")
+        end
+      end
+
+      def fetch_comments(number:, per_page: 10)
+        response = http_get(
+          "#{@api_url}/repos/#{@repo}/issues/#{number}/comments?per_page=#{per_page}&sort=created&direction=desc",
+          auth_headers
+        )
+
+        if response[:status] == 200
+          comments = (response[:body] || []).map { |c|
+            {
+              author: c.dig("user", "login"),
+              avatar_url: c.dig("user", "avatar_url"),
+              body: c["body"],
+              created_at: c["created_at"],
+              url: c["html_url"]
+            }
+          }
+          success_response(comments: comments)
+        else
+          error_response("GitHub API error (#{response[:status]})")
+        end
+      end
+
+      def fetch_issue(number:)
+        response = http_get(
+          "#{@api_url}/repos/#{@repo}/issues/#{number}",
+          auth_headers
+        )
+
+        if response[:status] == 200
+          data = response[:body]
+          success_response(
+            state: data["state"],
+            title: data["title"],
+            assignees: (data["assignees"] || []).map { |a|
+              { login: a["login"], avatar_url: a["avatar_url"] }
+            },
+            labels: (data["labels"] || []).map { |l|
+              { name: l["name"], color: l["color"] }
+            }
+          )
+        else
+          error_response("GitHub API error (#{response[:status]})")
+        end
+      end
+
+      private
+
+      def auth_headers
+        { "Authorization" => "Bearer #{@token}", "Accept" => "application/vnd.github+json" }
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/github_link_generator.rb

@@ -53,6 +53,8 @@ module RailsErrorDashboard
           generate_gitlab_link(normalized_repo, reference)
         when :bitbucket
           generate_bitbucket_link(normalized_repo, reference)
+        when :codeberg
+          generate_codeberg_link(normalized_repo, reference)
         else
           @error = "Unsupported repository type"
           nil
@@ -77,13 +79,14 @@ module RailsErrorDashboard
 
       # Detect repository type from URL
       #
-      # @return [Symbol] :github, :gitlab, :bitbucket, or :unknown
+      # @return [Symbol] :github, :gitlab, :bitbucket, :codeberg, 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.")
+        return :codeberg if normalized.include?("codeberg.org") || normalized.include?("gitea.") || normalized.include?("forgejo.")
 
         :unknown
       end
@@ -154,6 +157,21 @@ module RailsErrorDashboard
         normalized_path = normalize_file_path
         "#{repo_url}/src/#{ref}/#{normalized_path}#lines-#{line_number}"
       end
+
+      # Generate Codeberg/Gitea/Forgejo link
+      #
+      # Format: https://codeberg.org/user/repo/src/commit/{ref}/path/to/file.rb#L42
+      # Same as GitHub's /blob/ but Codeberg uses /src/commit/ or /src/branch/
+      #
+      # @param repo_url [String] Normalized repository URL
+      # @param ref [String] Commit SHA or branch name
+      # @return [String]
+      def generate_codeberg_link(repo_url, ref)
+        normalized_path = normalize_file_path
+        # Codeberg uses /src/commit/{sha} for commits and /src/branch/{name} for branches
+        ref_type = ref.match?(/\A[0-9a-f]{7,40}\z/i) ? "commit" : "branch"
+        "#{repo_url}/src/#{ref_type}/#{ref}/#{normalized_path}#L#{line_number}"
+      end
     end
   end
 end

data/lib/rails_error_dashboard/services/gitlab_issue_client.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # GitLab REST API client for issue management.
+    #
+    # API Docs: https://docs.gitlab.com/api/issues/
+    # Auth: Personal access token or project access token
+    # Project ID: URL-encoded path ("user%2Frepo") or numeric ID
+    class GitLabIssueClient < IssueTrackerClient
+      def initialize(token:, repo:, api_url: nil)
+        super
+        @api_url = api_url || "https://gitlab.com/api/v4"
+        @encoded_repo = URI.encode_www_form_component(@repo)
+      end
+
+      def create_issue(title:, body:, labels: [])
+        response = http_post(
+          "#{@api_url}/projects/#{@encoded_repo}/issues",
+          { title: title, description: truncate_body(body), labels: labels.join(",") },
+          auth_headers
+        )
+
+        if response[:status] == 201
+          data = response[:body]
+          success_response(url: data["web_url"], number: data["iid"])
+        else
+          error_response("GitLab API error (#{response[:status]}): #{response[:body]&.dig("message") || response[:error]}")
+        end
+      end
+
+      def close_issue(number:)
+        response = http_put(
+          "#{@api_url}/projects/#{@encoded_repo}/issues/#{number}",
+          { state_event: "close" },
+          auth_headers
+        )
+
+        response[:status] == 200 ? success_response({}) : error_response("GitLab API error (#{response[:status]})")
+      end
+
+      def reopen_issue(number:)
+        response = http_put(
+          "#{@api_url}/projects/#{@encoded_repo}/issues/#{number}",
+          { state_event: "reopen" },
+          auth_headers
+        )
+
+        response[:status] == 200 ? success_response({}) : error_response("GitLab API error (#{response[:status]})")
+      end
+
+      def add_comment(number:, body:)
+        response = http_post(
+          "#{@api_url}/projects/#{@encoded_repo}/issues/#{number}/notes",
+          { body: truncate_body(body) },
+          auth_headers
+        )
+
+        if response[:status] == 201
+          # GitLab notes don't have a direct URL — construct from issue URL + note anchor
+          note_id = response[:body]["id"]
+          issue_url = "#{@api_url.sub("/api/v4", "")}/#{@repo}/-/issues/#{number}#note_#{note_id}"
+          success_response(url: issue_url)
+        else
+          error_response("GitLab API error (#{response[:status]})")
+        end
+      end
+
+      def fetch_comments(number:, per_page: 10)
+        response = http_get(
+          "#{@api_url}/projects/#{@encoded_repo}/issues/#{number}/notes?per_page=#{per_page}&sort=desc",
+          auth_headers
+        )
+
+        if response[:status] == 200
+          comments = (response[:body] || []).reject { |n| n["system"] }.map { |n|
+            {
+              author: n.dig("author", "username"),
+              avatar_url: n.dig("author", "avatar_url"),
+              body: n["body"],
+              created_at: n["created_at"],
+              url: nil # GitLab notes don't have individual URLs in API response
+            }
+          }
+          success_response(comments: comments)
+        else
+          error_response("GitLab API error (#{response[:status]})")
+        end
+      end
+
+      def fetch_issue(number:)
+        response = http_get(
+          "#{@api_url}/projects/#{@encoded_repo}/issues/#{number}",
+          auth_headers
+        )
+
+        if response[:status] == 200
+          data = response[:body]
+          success_response(
+            state: data["state"],
+            title: data["title"],
+            assignees: (data["assignees"] || []).map { |a|
+              { login: a["username"], avatar_url: a["avatar_url"] }
+            },
+            labels: (data["labels"] || []).map { |l|
+              { name: l, color: nil }
+            }
+          )
+        else
+          error_response("GitLab API error (#{response[:status]})")
+        end
+      end
+
+      private
+
+      def auth_headers
+        { "PRIVATE-TOKEN" => @token }
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/issue_body_formatter.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Pure algorithm: Format error details as markdown for issue tracker body.
+    #
+    # Tailored for issue context — shorter than MarkdownErrorFormatter,
+    # includes a link back to the dashboard, and omits system health
+    # (not useful in a GitHub issue body).
+    #
+    # @example
+    #   IssueBodyFormatter.call(error)
+    #   # => "## NoMethodError\n\nundefined method 'foo'...\n\n[View in Dashboard](url)"
+    class IssueBodyFormatter
+      MAX_BACKTRACE_LINES = 20
+
+      def self.call(error, dashboard_url: nil)
+        new(error, dashboard_url).generate
+      rescue => e
+        "Error details could not be formatted: #{e.message}"
+      end
+
+      def initialize(error, dashboard_url)
+        @error = error
+        @dashboard_url = dashboard_url
+      end
+
+      def generate
+        sections = []
+
+        sections << heading_section
+        sections << backtrace_section
+        sections << cause_chain_section
+        sections << request_context_section
+        sections << environment_section
+        sections << metadata_section
+        sections << dashboard_link_section
+
+        sections.compact.join("\n\n")
+      rescue => e
+        "Error details could not be formatted."
+      end
+
+      private
+
+      def heading_section
+        "## #{@error.error_type}\n\n#{@error.message}"
+      end
+
+      def backtrace_section
+        raw = @error.backtrace
+        return nil if raw.blank?
+
+        lines = raw.split("\n")
+        app_lines = lines.reject { |l| l.include?("/gems/") || l.include?("/ruby/") || l.include?("/vendor/") }
+        app_lines = lines.first(MAX_BACKTRACE_LINES) if app_lines.empty?
+        app_lines = app_lines.first(MAX_BACKTRACE_LINES)
+
+        "### Backtrace\n\n```\n#{app_lines.join("\n")}\n```"
+      end
+
+      def cause_chain_section
+        raw = @error.exception_cause
+        return nil if raw.blank?
+
+        causes = parse_json(raw)
+        return nil unless causes.is_a?(Array) && causes.any?
+
+        items = causes.each_with_index.map { |cause, i|
+          "#{i + 1}. **#{cause["class_name"]}** — #{cause["message"]}"
+        }
+
+        "### Exception Cause Chain\n\n#{items.join("\n")}"
+      end
+
+      def request_context_section
+        return nil if @error.request_url.blank?
+
+        items = []
+        items << "- **Controller:** #{@error.controller_name}##{@error.action_name}" if @error.controller_name.present?
+        items << "- **Method:** #{@error.http_method}" if @error.http_method.present?
+        items << "- **URL:** #{@error.request_url}"
+        items << "- **Hostname:** #{@error.hostname}" if @error.hostname.present?
+
+        "### Request Context\n\n#{items.join("\n")}"
+      end
+
+      def environment_section
+        raw = @error.environment_info
+        return nil if raw.blank?
+
+        env = parse_json(raw)
+        return nil unless env.is_a?(Hash) && env.any?
+
+        items = []
+        items << "- **Ruby:** #{env["ruby_version"]}" if env["ruby_version"]
+        items << "- **Rails:** #{env["rails_version"]}" if env["rails_version"]
+        items << "- **Env:** #{env["rails_env"]}" if env["rails_env"]
+
+        return nil if items.empty?
+
+        "### Environment\n\n#{items.join("\n")}"
+      end
+
+      def metadata_section
+        items = []
+        items << "- **Platform:** #{@error.platform}" if @error.platform.present?
+        items << "- **First seen:** #{@error.first_seen_at&.utc&.strftime("%Y-%m-%d %H:%M:%S UTC")}" if @error.first_seen_at
+        items << "- **Occurrences:** #{@error.occurrence_count}" if @error.occurrence_count
+
+        return nil if items.empty?
+
+        "### Metadata\n\n#{items.join("\n")}"
+      end
+
+      def dashboard_link_section
+        parts = []
+        parts << "[View in Dashboard](#{@dashboard_url})" if @dashboard_url.present?
+        parts << "Created by [RED](https://github.com/AnjanJ/rails_error_dashboard) (Rails Error Dashboard)"
+
+        "---\n\n#{parts.join(" | ")}"
+      end
+
+      def parse_json(raw)
+        return nil if raw.blank?
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end