rails_error_dashboard 0.5.7 → 0.5.8

data/lib/rails_error_dashboard/configuration.rb

@@ -81,6 +81,19 @@ module RailsErrorDashboard
     # Git repository URL for linking commits (e.g., "https://github.com/user/repo")
     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)
+    attr_accessor :issue_tracker_token            # String or lambda/proc for Rails credentials
+    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
+
     # Advanced error analysis features
     attr_accessor :enable_similar_errors          # Fuzzy error matching
     attr_accessor :enable_co_occurring_errors     # Detect errors happening together
@@ -160,6 +173,8 @@ module RailsErrorDashboard
 
     # ActionCable event tracking (requires enable_breadcrumbs = true)
     attr_accessor :enable_actioncable_tracking          # Master switch (default: false)
+    # ActiveStorage event tracking (requires enable_breadcrumbs = true)
+    attr_accessor :enable_activestorage_tracking        # Master switch (default: false)
 
     # Notification callbacks (managed via helper methods, not set directly)
     attr_reader :notification_callbacks
@@ -229,6 +244,19 @@ 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
+      @enable_issue_tracking = false
+      @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_webhook_secret = ENV["ISSUE_WEBHOOK_SECRET"]
+
       # Advanced error analysis features (all OFF by default - opt-in)
       @enable_similar_errors = false        # Fuzzy error matching
       @enable_co_occurring_errors = false   # Co-occurring error detection
@@ -305,6 +333,8 @@ module RailsErrorDashboard
 
       # ActionCable event tracking defaults - OFF by default (opt-in, requires breadcrumbs)
       @enable_actioncable_tracking = false
+      # ActiveStorage event tracking defaults - OFF by default (opt-in, requires breadcrumbs)
+      @enable_activestorage_tracking = false
 
       # Internal logging defaults - SILENT by default
       @enable_internal_logging = false  # Opt-in for debugging
@@ -461,6 +491,25 @@ module RailsErrorDashboard
         @enable_actioncable_tracking = false
       end
 
+      # Validate activestorage tracking requires breadcrumbs
+      if enable_activestorage_tracking && !enable_breadcrumbs
+        warnings << "enable_activestorage_tracking requires enable_breadcrumbs = true. " \
+                    "ActiveStorage tracking has been auto-disabled."
+        @enable_activestorage_tracking = false
+      end
+
+      # Validate issue tracking configuration
+      if enable_issue_tracking && effective_issue_tracker_token.blank?
+        warnings << "enable_issue_tracking is true but no token configured. " \
+                    "Set issue_tracker_token or RED_BOT_TOKEN env var. " \
+                    "Tip: Create a dedicated RED (Rails Error Dashboard) bot account on your platform."
+      end
+
+      if enable_issue_tracking && effective_issue_tracker_provider.nil?
+        warnings << "enable_issue_tracking is true but provider could not be detected. " \
+                    "Set issue_tracker_provider or git_repository_url."
+      end
+
       # Validate crash capture path (must exist if custom path specified)
       if enable_crash_capture && crash_capture_path
         unless Dir.exist?(crash_capture_path)
@@ -556,6 +605,56 @@ module RailsErrorDashboard
       default || blank
     end
 
+    # Resolve the effective issue tracker provider (auto-detect from git_repository_url)
+    #
+    # @return [Symbol, nil] :github, :gitlab, :codeberg, or nil
+    def effective_issue_tracker_provider
+      return issue_tracker_provider&.to_sym if issue_tracker_provider.present?
+      return nil if git_repository_url.blank?
+
+      case git_repository_url
+      when /github\.com/i then :github
+      when /gitlab\.com/i then :gitlab
+      when /codeberg\.org/i then :codeberg
+      when /gitea\./i, /forgejo\./i then :codeberg # Gitea/Forgejo instances use same API
+      end
+    end
+
+    # Resolve the effective issue tracker repository ("owner/repo")
+    #
+    # @return [String, nil] "owner/repo" or nil
+    def effective_issue_tracker_repo
+      return issue_tracker_repo if issue_tracker_repo.present?
+      return nil if git_repository_url.blank?
+
+      # Extract owner/repo from URL: https://github.com/owner/repo(.git)
+      match = git_repository_url.match(%r{[:/]([^/]+/[^/]+?)(?:\.git)?$})
+      match&.[](1)
+    end
+
+    # Resolve the issue tracker API token (supports string or lambda)
+    #
+    # @return [String, nil] The resolved token value
+    def effective_issue_tracker_token
+      return nil if issue_tracker_token.nil?
+      issue_tracker_token.respond_to?(:call) ? issue_tracker_token.call : issue_tracker_token
+    rescue => e
+      nil
+    end
+
+    # Resolve the effective API base URL for the issue tracker
+    #
+    # @return [String] API base URL
+    def effective_issue_tracker_api_url
+      return issue_tracker_api_url if issue_tracker_api_url.present?
+
+      case effective_issue_tracker_provider
+      when :github then "https://api.github.com"
+      when :gitlab then "https://gitlab.com/api/v4"
+      when :codeberg then "https://codeberg.org/api/v1"
+      end
+    end
+
     # Get the effective user model (auto-detected if not configured)
     #
     # @return [String, nil] User model class name

data/lib/rails_error_dashboard/engine.rb

@@ -84,6 +84,13 @@ module RailsErrorDashboard
         RailsErrorDashboard::Subscribers::ActionCableSubscriber.subscribe!
       end
 
+      # Subscribe to ActiveStorage AS::Notifications events (requires breadcrumbs + ActiveStorage)
+      if RailsErrorDashboard.configuration.enable_activestorage_tracking &&
+         RailsErrorDashboard.configuration.enable_breadcrumbs &&
+         defined?(ActiveStorage)
+        RailsErrorDashboard::Subscribers::ActiveStorageSubscriber.subscribe!
+      end
+
       # Enable TracePoint(:raise) for local variable and/or instance variable capture
       if RailsErrorDashboard.configuration.enable_local_variables ||
          RailsErrorDashboard.configuration.enable_instance_variables
@@ -100,6 +107,38 @@ module RailsErrorDashboard
         RailsErrorDashboard::Services::CrashCapture.import!
         RailsErrorDashboard::Services::CrashCapture.enable!
       end
+
+      # Wire issue tracker lifecycle hooks (auto-create, close on resolve, reopen on recur)
+      if RailsErrorDashboard.configuration.enable_issue_tracking
+        config = RailsErrorDashboard.configuration
+        config.notification_callbacks[:error_logged] ||= []
+        config.notification_callbacks[:error_resolved] ||= []
+
+        # Ensure notification_callbacks entries are arrays (may be lambda from user config)
+        unless config.notification_callbacks[:error_logged].is_a?(Array)
+          existing = config.notification_callbacks[:error_logged]
+          config.notification_callbacks[:error_logged] = [ existing ].compact
+        end
+        unless config.notification_callbacks[:error_resolved].is_a?(Array)
+          existing = config.notification_callbacks[:error_resolved]
+          config.notification_callbacks[:error_resolved] = [ existing ].compact
+        end
+
+        config.notification_callbacks[:error_logged] << ->(error_log) {
+          # Dispatch to appropriate handler based on error state
+          if error_log.occurrence_count == 1
+            RailsErrorDashboard::Subscribers::IssueTrackerSubscriber.on_error_logged(error_log)
+          elsif error_log.respond_to?(:just_reopened) && error_log.just_reopened
+            RailsErrorDashboard::Subscribers::IssueTrackerSubscriber.on_error_reopened(error_log)
+          else
+            RailsErrorDashboard::Subscribers::IssueTrackerSubscriber.on_error_recurred(error_log)
+          end
+        }
+
+        config.notification_callbacks[:error_resolved] << ->(error_log) {
+          RailsErrorDashboard::Subscribers::IssueTrackerSubscriber.on_error_resolved(error_log)
+        }
+      end
     end
   end
 end

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,99 @@
+# 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
+
+      private
+
+      def auth_headers
+        { "Authorization" => "token #{@token}" }
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/github_issue_client.rb

@@ -0,0 +1,94 @@
+# 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
+
+      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,98 @@
+# 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
+
+      private
+
+      def auth_headers
+        { "PRIVATE-TOKEN" => @token }
+      end
+    end
+  end
+end