rails_error_dashboard 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 002c2e5d338c585425599802271a90c5bac425dc86867da1aa10a0c7a478d1e8
-  data.tar.gz: 077d7d7a7f957bee799cf39c96632532e3c74259e83310605c6068d57436aec3
+  metadata.gz: 532921b0ba2ccb40a532a66e5e3c7b1fcf17fc56e53cb5b0ed3772648644f0c0
+  data.tar.gz: 282169f161d90326aaebce5933521cd54c8bb373611e9002b447f114b6654204
 SHA512:
-  metadata.gz: 8e6ef9f87aae8c200e997bf761184eb37c86d0637dfdd383fd6cc003f3c3b9fa30b7906fbaf6377670d932a60da5a9046202d4a48ab63264ce916c861ac20b91
-  data.tar.gz: 67858acc12ad29cb412b0c049b776b7193c9ce8d45febfa4bc23e079a1afd7ff64a2a85bd81516c999cc57861631ed3f89ea62bc36544370811e8cff858c8678
+  metadata.gz: 63c2ba5ef4319eaff8450837fec526135e37865ea0d2c72c30b7010ff6e86c03e49f728172d032bec6ad626f8dba39d00841300839fee9b8a493caa912669559
+  data.tar.gz: c84238b00e2f6959fd1e4ac5a1c9ff2d696a0d28379a102e99d761585caf4c24a4f6446f4d303d69c933e5135b31e7c3ef1d0a6b7464376e88ad25b14068c75a

data/README.md

@@ -233,7 +233,7 @@ Payload contract matches the `LlmCallEvent` value object — see [`docs/LLM_OBSE
 </details>
 
 <details>
-<summary><strong>Issue Tracking — GitHub, GitLab, Codeberg</strong></summary>
+<summary><strong>Issue Tracking — GitHub, GitLab, Codeberg, Linear</strong></summary>
 
 One switch connects errors to your issue tracker. Platform becomes the source of truth — status, assignees, labels, and comments are mirrored live in the dashboard.
 
@@ -250,6 +250,17 @@ config.issue_tracker_token = ENV["RED_BOT_TOKEN"]
 # That's it — provider and repo auto-detected from git_repository_url
 ```
 
+Linear works too — it's not a git forge, so set the provider and team key explicitly:
+
+```ruby
+config.enable_issue_tracking = true
+config.issue_tracker_provider = :linear
+config.issue_tracker_repo = "ENG"  # Linear team key (issues land as ENG-123)
+config.issue_tracker_token = ENV["RED_BOT_TOKEN"]  # lin_api_... personal API key
+```
+
+Closing maps to the team's first `completed` workflow state, reopening to `unstarted`/`backlog`. Two-way sync uses Linear webhooks (`Linear-Signature` HMAC verification).
+
 [Complete documentation →](docs/guides/CONFIGURATION.md)
 </details>
 

data/app/controllers/rails_error_dashboard/webhooks_controller.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module RailsErrorDashboard
-  # Receives webhooks from GitHub/GitLab/Codeberg for two-way issue sync.
+  # Receives webhooks from GitHub/GitLab/Codeberg/Linear for two-way issue sync.
   #
   # When an issue is closed/reopened on the platform, the corresponding
   # error in the dashboard is resolved/reopened to match.
@@ -10,6 +10,7 @@ module RailsErrorDashboard
   # - GitHub:   X-Hub-Signature-256 (HMAC-SHA256)
   # - GitLab:   X-Gitlab-Token (shared secret)
   # - Codeberg: X-Gitea-Signature (HMAC-SHA256)
+  # - Linear:   Linear-Signature (HMAC-SHA256)
   class WebhooksController < ActionController::Base
     skip_before_action :verify_authenticity_token
 
@@ -29,6 +30,8 @@ module RailsErrorDashboard
         handle_gitlab(payload)
       when "codeberg"
         handle_codeberg(payload)
+      when "linear"
+        handle_linear(payload)
       else
         head :not_found
         return
@@ -69,6 +72,8 @@ module RailsErrorDashboard
         verify_gitlab_token(secret)
       when "codeberg"
         verify_codeberg_signature(body, secret)
+      when "linear"
+        verify_linear_signature(body, secret)
       else
         false
       end
@@ -99,6 +104,14 @@ module RailsErrorDashboard
       ActiveSupport::SecurityUtils.secure_compare(expected, signature)
     end
 
+    def verify_linear_signature(body, secret)
+      signature = request.headers["Linear-Signature"]
+      return false unless signature
+
+      expected = OpenSSL::HMAC.hexdigest("SHA256", secret, body)
+      ActiveSupport::SecurityUtils.secure_compare(expected, signature)
+    end
+
     def parse_payload
       JSON.parse(request.body.read)
     rescue JSON::ParserError
@@ -162,6 +175,27 @@ module RailsErrorDashboard
       end
     end
 
+    # Linear: Issue webhook fires with action create/update/remove. State changes
+    # arrive as updates with the old stateId in updatedFrom. Linear has no
+    # open/closed binary — completed/canceled state types map to resolved.
+    def handle_linear(payload)
+      return unless payload["type"] == "Issue" && payload["action"] == "update"
+      return unless payload["updatedFrom"]&.key?("stateId")
+
+      issue_number = payload.dig("data", "number")
+      return unless issue_number
+
+      error = find_error_by_issue(issue_number, "linear")
+      return unless error
+
+      state_type = payload.dig("data", "state", "type")
+      if state_type.in?(%w[completed canceled])
+        resolve_error(error, "Completed on Linear by #{payload.dig("actor", "name")}")
+      elsif state_type.in?(%w[triage backlog unstarted started])
+        reopen_error(error)
+      end
+    end
+
     def find_error_by_issue(issue_number, provider)
       ErrorLog.find_by(
         external_issue_number: issue_number,

data/app/views/rails_error_dashboard/errors/_issue_section.html.erb

@@ -18,6 +18,7 @@
                    when "github" then "bi-github"
                    when "gitlab" then "bi-gitlab"
                    when "codeberg" then "bi-git"
+                   when "linear" then "bi-kanban"
                    else "bi-link-45deg"
                    end %>
         <% issue = @platform_issue %>

data/lib/generators/rails_error_dashboard/install/templates/initializer.rb

@@ -519,7 +519,7 @@ RailsErrorDashboard.configure do |config|
   # Safe to enable on production OTel pipelines.
 
   # ============================================================================
-  # ISSUE TRACKING (GitHub / GitLab / Codeberg)
+  # ISSUE TRACKING (GitHub / GitLab / Codeberg / Linear)
   # ============================================================================
   #
   # One switch enables everything: issue creation, auto-create on first
@@ -534,7 +534,7 @@ RailsErrorDashboard.configure do |config|
   #   - Priority → labels from platform (with colors)
   #   - Snooze and Mute remain (no platform equivalent)
   #
-  # Setup:
+  # Setup (GitHub/GitLab/Codeberg):
   #   1. Create a RED bot account on GitHub/GitLab/Codeberg
   #   2. Generate a token and set RED_BOT_TOKEN env var
   #   3. Set git_repository_url above (already used for source code linking)
@@ -543,6 +543,17 @@ RailsErrorDashboard.configure do |config|
   # config.enable_issue_tracking = true
   # config.issue_tracker_token = ENV["RED_BOT_TOKEN"]
   #
+  # Setup (Linear):
+  #   Linear is not a git forge, so it cannot be auto-detected from
+  #   git_repository_url — set provider and team key explicitly. Issues are
+  #   created in the team matching the key (e.g. "ENG" for ENG-123 issues).
+  #   Generate a personal API key under Settings > Security & access.
+  #
+  # config.enable_issue_tracking = true
+  # config.issue_tracker_provider = :linear
+  # config.issue_tracker_repo = "ENG"                              # Linear team key
+  # config.issue_tracker_token = ENV["RED_BOT_TOKEN"]              # lin_api_... key
+  #
   # Optional overrides:
   # config.issue_tracker_labels = ["bug"]                          # Labels added to new issues
   # config.issue_tracker_auto_create_severities = [:critical, :high]  # Auto-create threshold

data/lib/rails_error_dashboard/commands/create_issue.rb

@@ -2,7 +2,7 @@
 
 module RailsErrorDashboard
   module Commands
-    # Command: Create an issue on the configured issue tracker (GitHub/GitLab/Codeberg)
+    # Command: Create an issue on the configured issue tracker (GitHub/GitLab/Codeberg/Linear)
     #
     # Creates the issue via the provider API, then stores the issue URL, number,
     # and provider on the error record for linking.

data/lib/rails_error_dashboard/commands/link_existing_issue.rb

@@ -14,7 +14,9 @@ module RailsErrorDashboard
       PROVIDER_PATTERNS = {
         github: %r{github\.com/([^/]+/[^/]+)/issues/(\d+)}i,
         gitlab: %r{gitlab\.com/([^/]+/[^/]+)/-/issues/(\d+)}i,
-        codeberg: %r{codeberg\.org/([^/]+/[^/]+)/issues/(\d+)}i
+        codeberg: %r{codeberg\.org/([^/]+/[^/]+)/issues/(\d+)}i,
+        # https://linear.app/<workspace>/issue/ENG-123/<slug> — capture team key + number
+        linear: %r{linear\.app/[^/]+/issue/([A-Za-z][A-Za-z0-9]*)-(\d+)}i
       }.freeze
 
       def self.call(error_id, issue_url:)

data/lib/rails_error_dashboard/configuration.rb

@@ -92,8 +92,8 @@ module RailsErrorDashboard
     # issue_webhook_secret is set.
     attr_accessor :enable_issue_tracking         # Master switch (default: false) — enables all platform integration
     attr_accessor :issue_tracker_token            # String or lambda/proc for Rails credentials
-    attr_accessor :issue_tracker_provider         # :github, :gitlab, :codeberg (auto-detected from git_repository_url)
-    attr_accessor :issue_tracker_repo             # "owner/repo" (auto-extracted from git_repository_url)
+    attr_accessor :issue_tracker_provider         # :github, :gitlab, :codeberg (auto-detected from git_repository_url), or :linear (explicit only)
+    attr_accessor :issue_tracker_repo             # "owner/repo" (auto-extracted from git_repository_url), or Linear team key like "ENG"
     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 :issue_tracker_auto_create_severities  # Auto-create for these severities (default: [:critical, :high])
@@ -604,7 +604,8 @@ module RailsErrorDashboard
 
         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."
+                      "Set issue_tracker_provider (:github, :gitlab, :codeberg, :linear) or git_repository_url. " \
+                      "Note: :linear is never auto-detected — set it explicitly with issue_tracker_repo as the team key."
         end
       end
 
@@ -736,9 +737,11 @@ module RailsErrorDashboard
       default || blank
     end
 
-    # Resolve the effective issue tracker provider (auto-detect from git_repository_url)
+    # Resolve the effective issue tracker provider (auto-detect from git_repository_url).
+    # Linear is never auto-detected (it is not a git forge) — set issue_tracker_provider
+    # explicitly.
     #
-    # @return [Symbol, nil] :github, :gitlab, :codeberg, or nil
+    # @return [Symbol, nil] :github, :gitlab, :codeberg, :linear, 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?
@@ -751,11 +754,13 @@ module RailsErrorDashboard
       end
     end
 
-    # Resolve the effective issue tracker repository ("owner/repo")
+    # Resolve the effective issue tracker repository ("owner/repo", or Linear team key)
     #
-    # @return [String, nil] "owner/repo" or nil
+    # @return [String, nil] "owner/repo", Linear team key, or nil
     def effective_issue_tracker_repo
       return issue_tracker_repo if issue_tracker_repo.present?
+      # A git URL can never yield a Linear team key — require explicit config
+      return nil if effective_issue_tracker_provider == :linear
       return nil if git_repository_url.blank?
 
       # Extract owner/repo from URL: https://github.com/owner/repo(.git)
@@ -783,6 +788,7 @@ module RailsErrorDashboard
       when :github then "https://api.github.com"
       when :gitlab then "https://gitlab.com/api/v4"
       when :codeberg then "https://codeberg.org/api/v1"
+      when :linear then "https://api.linear.app/graphql"
       end
     end
 

data/lib/rails_error_dashboard/services/issue_tracker_client.rb

@@ -8,8 +8,9 @@ module RailsErrorDashboard
   module Services
     # Base class and factory for issue tracker API clients.
     #
-    # Supports GitHub, GitLab, and Codeberg/Gitea/Forgejo via a unified interface.
-    # Each provider implements the same methods with provider-specific API calls.
+    # Supports GitHub, GitLab, Codeberg/Gitea/Forgejo, and Linear via a unified
+    # interface. Each provider implements the same methods with provider-specific
+    # API calls.
     #
     # @example
     #   client = IssueTrackerClient.for(:github, token: "ghp_xxx", repo: "user/repo")
@@ -23,9 +24,9 @@ module RailsErrorDashboard
 
       # Factory method — returns the correct client for the provider
       #
-      # @param provider [Symbol] :github, :gitlab, or :codeberg
+      # @param provider [Symbol] :github, :gitlab, :codeberg, or :linear
       # @param token [String] API authentication token
-      # @param repo [String] Repository identifier ("owner/repo")
+      # @param repo [String] Repository identifier ("owner/repo"), or Linear team key ("ENG")
       # @param api_url [String, nil] Custom API base URL (for self-hosted)
       # @return [IssueTrackerClient] Provider-specific client instance
       def self.for(provider, token:, repo:, api_url: nil)
@@ -36,8 +37,10 @@ module RailsErrorDashboard
           GitLabIssueClient.new(token: token, repo: repo, api_url: api_url)
         when :codeberg
           CodebergIssueClient.new(token: token, repo: repo, api_url: api_url)
+        when :linear
+          LinearIssueClient.new(token: token, repo: repo, api_url: api_url)
         else
-          raise ArgumentError, "Unknown issue tracker provider: #{provider}. Supported: :github, :gitlab, :codeberg"
+          raise ArgumentError, "Unknown issue tracker provider: #{provider}. Supported: :github, :gitlab, :codeberg, :linear"
         end
       end
 

data/lib/rails_error_dashboard/services/linear_issue_client.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Linear GraphQL API client for issue management.
+    #
+    # API Docs: https://developers.linear.app/docs/graphql/working-with-the-graphql-api
+    # Auth: Personal API key (Settings > Security & access > Personal API keys)
+    # Rate limit: 1,500 requests/hour per API key
+    #
+    # Unlike the git forges, Linear has no "owner/repo" — issues belong to a
+    # team. The `repo` argument holds the team key (e.g. "ENG"), and issues
+    # are addressed by their human identifier ("ENG-123"), reconstructed from
+    # the team key plus the team-scoped issue number we store.
+    #
+    # Linear also has no open/closed binary — issues move between typed
+    # workflow states. Closing maps to the team's first `completed`-type
+    # state, reopening to the first `unstarted` (or `backlog`) state.
+    class LinearIssueClient < IssueTrackerClient
+      REOPEN_STATE_TYPES = [ "unstarted", "backlog", "triage" ].freeze
+
+      def initialize(token:, repo:, api_url: nil)
+        super
+        @api_url = api_url || "https://api.linear.app/graphql"
+      end
+
+      def create_issue(title:, body:, labels: [])
+        return error_response(@last_error || "Linear team '#{@repo}' not found") unless team_id
+
+        input = { teamId: team_id, title: title, description: truncate_body(body) }
+        label_ids = resolve_label_ids(labels)
+        input[:labelIds] = label_ids if label_ids.any?
+
+        data = graphql(<<~GRAPHQL, input: input)
+          mutation($input: IssueCreateInput!) {
+            issueCreate(input: $input) { success issue { identifier number url } }
+          }
+        GRAPHQL
+
+        issue = data&.dig("issueCreate", "issue")
+        if issue
+          success_response(url: issue["url"], number: issue["number"])
+        else
+          error_response(@last_error || "Linear API error: issue creation failed")
+        end
+      end
+
+      def close_issue(number:)
+        update_issue_state(number, "completed")
+      end
+
+      def reopen_issue(number:)
+        update_issue_state(number, REOPEN_STATE_TYPES)
+      end
+
+      def add_comment(number:, body:)
+        issue_id = find_issue_id(number)
+        return error_response(@last_error || "Linear issue #{identifier_for(number)} not found") unless issue_id
+
+        data = graphql(<<~GRAPHQL, input: { issueId: issue_id, body: truncate_body(body) })
+          mutation($input: CommentCreateInput!) {
+            commentCreate(input: $input) { success comment { url } }
+          }
+        GRAPHQL
+
+        comment = data&.dig("commentCreate", "comment")
+        comment ? success_response(url: comment["url"]) : error_response(@last_error || "Linear API error: comment failed")
+      end
+
+      def fetch_comments(number:, per_page: 10)
+        data = graphql(<<~GRAPHQL, id: identifier_for(number), first: per_page)
+          query($id: String!, $first: Int!) {
+            issue(id: $id) {
+              comments(first: $first) {
+                nodes { body createdAt url user { name avatarUrl } }
+              }
+            }
+          }
+        GRAPHQL
+
+        nodes = data&.dig("issue", "comments", "nodes")
+        return error_response(@last_error || "Linear API error: could not fetch comments") unless nodes
+
+        comments = nodes.map { |c|
+          {
+            author: c.dig("user", "name"),
+            avatar_url: c.dig("user", "avatarUrl"),
+            body: c["body"],
+            created_at: c["createdAt"],
+            url: c["url"]
+          }
+        }
+        success_response(comments: comments)
+      end
+
+      def fetch_issue(number:)
+        data = graphql(<<~GRAPHQL, id: identifier_for(number))
+          query($id: String!) {
+            issue(id: $id) {
+              title
+              state { name type }
+              assignee { name avatarUrl }
+              labels { nodes { name color } }
+            }
+          }
+        GRAPHQL
+
+        issue = data&.dig("issue")
+        return error_response(@last_error || "Linear API error: could not fetch issue") unless issue
+
+        assignee = issue["assignee"]
+        success_response(
+          state: closed_state_type?(issue.dig("state", "type")) ? "closed" : "open",
+          title: issue["title"],
+          assignees: assignee ? [ { login: assignee["name"], avatar_url: assignee["avatarUrl"] } ] : [],
+          labels: (issue.dig("labels", "nodes") || []).map { |l|
+            { name: l["name"], color: l["color"]&.delete("#") }
+          }
+        )
+      end
+
+      private
+
+      # Linear issues are addressed by "TEAM-123" — team key + stored number
+      def identifier_for(number)
+        "#{@repo}-#{number}"
+      end
+
+      def closed_state_type?(state_type)
+        [ "completed", "canceled" ].include?(state_type)
+      end
+
+      def update_issue_state(number, state_types)
+        issue_id = find_issue_id(number)
+        return error_response(@last_error || "Linear issue #{identifier_for(number)} not found") unless issue_id
+
+        state_id = workflow_state_id(Array(state_types))
+        return error_response(@last_error || "No matching workflow state for #{Array(state_types).join('/')}") unless state_id
+
+        data = graphql(<<~GRAPHQL, id: issue_id, input: { stateId: state_id })
+          mutation($id: String!, $input: IssueUpdateInput!) {
+            issueUpdate(id: $id, input: $input) { success }
+          }
+        GRAPHQL
+
+        data&.dig("issueUpdate", "success") ? success_response({}) : error_response(@last_error || "Linear API error: state update failed")
+      end
+
+      def find_issue_id(number)
+        data = graphql("query($id: String!) { issue(id: $id) { id } }", id: identifier_for(number))
+        data&.dig("issue", "id")
+      end
+
+      def team_id
+        @team_id ||= begin
+          data = graphql(<<~GRAPHQL, key: @repo)
+            query($key: String!) {
+              teams(filter: { key: { eq: $key } }) { nodes { id } }
+            }
+          GRAPHQL
+          data&.dig("teams", "nodes", 0, "id")
+        end
+      end
+
+      # Pick the first workflow state whose type matches, in preference order
+      def workflow_state_id(preferred_types)
+        states = workflow_states
+        return nil unless states
+
+        preferred_types.each do |type|
+          match = states.find { |s| s["type"] == type }
+          return match["id"] if match
+        end
+        nil
+      end
+
+      def workflow_states
+        @workflow_states ||= begin
+          data = graphql(<<~GRAPHQL, key: @repo)
+            query($key: String!) {
+              workflowStates(filter: { team: { key: { eq: $key } } }) {
+                nodes { id name type position }
+              }
+            }
+          GRAPHQL
+          data&.dig("workflowStates", "nodes")&.sort_by { |s| s["position"].to_f }
+        end
+      end
+
+      # Best-effort: resolve label names to UUIDs, creating missing ones.
+      # Label failures must never block issue creation.
+      def resolve_label_ids(names)
+        names = Array(names).map(&:to_s).reject(&:empty?)
+        return [] if names.empty?
+
+        data = graphql(<<~GRAPHQL, names: names)
+          query($names: [String!]) {
+            issueLabels(filter: { name: { in: $names } }) { nodes { id name } }
+          }
+        GRAPHQL
+        existing = data&.dig("issueLabels", "nodes") || []
+        ids = existing.map { |l| l["id"] }
+
+        missing = names - existing.map { |l| l["name"] }
+        missing.each do |name|
+          created = graphql(<<~GRAPHQL, input: { name: name, teamId: team_id })
+            mutation($input: IssueLabelCreateInput!) {
+              issueLabelCreate(input: $input) { issueLabel { id } }
+            }
+          GRAPHQL
+          id = created&.dig("issueLabelCreate", "issueLabel", "id")
+          ids << id if id
+        end
+
+        ids
+      rescue
+        []
+      end
+
+      # Execute a GraphQL request. Returns the "data" hash, or nil on any
+      # error (with the message stashed in @last_error for the caller).
+      def graphql(query, variables = {})
+        @last_error = nil
+        response = http_post(@api_url, { query: query, variables: variables }, auth_headers)
+
+        if response[:status] != 200
+          message = response.dig(:body, "errors", 0, "message") || response[:error]
+          @last_error = "Linear API error (#{response[:status]}): #{message}"
+          return nil
+        end
+
+        errors = response.dig(:body, "errors")
+        if errors.present?
+          @last_error = "Linear API error: #{errors.first["message"]}"
+          return nil
+        end
+
+        response.dig(:body, "data")
+      end
+
+      def auth_headers
+        # Personal API keys are passed bare; OAuth tokens need a Bearer prefix
+        value = @token.to_s.start_with?("lin_api_") ? @token : "Bearer #{@token}"
+        { "Authorization" => value }
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.8.0"
+  VERSION = "0.8.1"
 end

data/lib/rails_error_dashboard.rb

@@ -68,6 +68,7 @@ require "rails_error_dashboard/services/issue_tracker_client"
 require "rails_error_dashboard/services/github_issue_client"
 require "rails_error_dashboard/services/gitlab_issue_client"
 require "rails_error_dashboard/services/codeberg_issue_client"
+require "rails_error_dashboard/services/linear_issue_client"
 require "rails_error_dashboard/services/database_health_inspector"
 require "rails_error_dashboard/services/cache_analyzer"
 require "rails_error_dashboard/services/llm_summary"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -463,6 +463,7 @@ files:
 - lib/rails_error_dashboard/services/gitlab_issue_client.rb
 - lib/rails_error_dashboard/services/issue_body_formatter.rb
 - lib/rails_error_dashboard/services/issue_tracker_client.rb
+- lib/rails_error_dashboard/services/linear_issue_client.rb
 - lib/rails_error_dashboard/services/llm_client.rb
 - lib/rails_error_dashboard/services/llm_cost_estimator.rb
 - lib/rails_error_dashboard/services/llm_summary.rb
@@ -511,7 +512,7 @@ metadata:
   funding_uri: https://github.com/sponsors/AnjanJ
 post_install_message: |
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    RED (Rails Error Dashboard) v0.8.0
+    RED (Rails Error Dashboard) v0.8.1
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   First install:
@@ -547,7 +548,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Self-hosted error tracking and exception monitoring for Rails. Free, forever.
 test_files: []