eussiror 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e721e700a3b37ec73117c35b65774e66c1f9274d249b12b16ea331c62bf34ef9
+  data.tar.gz: 20ddffdf0b98103b3777544046a271100383bf4720a7cf0d6a66e9075c2ecf1d
+SHA512:
+  metadata.gz: 72534f05812764111a22210f39521833ba30651347e1e68cd335f673c2e832258489f742c417191643a1a1e3cb29cd0d0ceb71d1695679c07ca6ce97e84627b1
+  data.tar.gz: 59b04321d5af06bbcd215290b26f2665ac6b3751bec5d76208041c28358e5a456da6c9be475cbe4bb6b696606fe0062b944561d9d74a277ee88de2bbac261ece

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-02-26
+
+### Added
+- Initial release.
+- Rack middleware that detects 500 responses and reads `env["action_dispatch.exception"]`.
+- SHA256-based fingerprinting to deduplicate errors across occurrences.
+- GitHub REST API v3 client (zero runtime dependencies, uses `Net::HTTP`).
+- Automatic issue creation on first occurrence of a given error.
+- Automatic comment on existing open issue for repeat occurrences.
+- `Eussiror.configure` block with support for token, repository, environments, labels, assignees, ignored exceptions, and async mode.
+- Rails install generator (`rails generate eussiror:install`).
+- RuboCop configuration.
+- GitHub Actions CI matrix: Ruby 3.1–3.4 × Rails 7.2–8.1.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Equipe Technique
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,314 @@
+# Eussiror
+
+**Maintainer:** [@tracyloisel](https://github.com/tracyloisel)
+
+[![Gem Version](https://badge.fury.io/rb/eussiror.svg)](https://badge.fury.io/rb/eussiror)
+[![CI](https://github.com/tracyloisel/eussiror/actions/workflows/ci.yml/badge.svg)](https://github.com/tracyloisel/eussiror/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+**Eussiror** automatically creates GitHub issues when your Rails application returns a 500 error in production. If the same error already has an open issue, it adds a comment with the new occurrence timestamp instead — keeping your issue tracker clean and deduplicated.
+
+---
+
+## Table of Contents
+
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Configuration](#configuration)
+- [How it works](#how-it-works)
+- [GitHub token setup](#github-token-setup)
+- [Architecture (for contributors)](#architecture-for-contributors)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
+## Requirements
+
+| Dependency | Minimum version |
+|---|---|
+| Ruby | 3.1 |
+| Rails | 7.2 |
+
+> **Note:** No additional runtime gems are required. Eussiror uses Ruby's built-in `Net::HTTP` to call the GitHub API.
+
+---
+
+## Installation
+
+Add the gem to your application's `Gemfile`:
+
+```ruby
+gem "eussiror"
+```
+
+Then run:
+
+```bash
+bundle install
+rails generate eussiror:install
+```
+
+The generator creates `config/initializers/eussiror.rb` with all available options commented out. To undo the installation:
+
+```bash
+rails destroy eussiror:install
+```
+
+---
+
+## Configuration
+
+Edit the generated initializer:
+
+```ruby
+# config/initializers/eussiror.rb
+Eussiror.configure do |config|
+  # Required: GitHub personal access token with "repo" scope
+  config.github_token = ENV["GITHUB_TOKEN"]
+
+  # Required: target repository in "owner/repository" format
+  config.github_repository = "your-org/your-repo"
+
+  # Environments where 500 errors will be reported (default: ["production"])
+  config.environments = %w[production]
+
+  # Labels applied to every new issue (optional)
+  config.labels = %w[bug automated]
+
+  # GitHub logins to assign to new issues (optional)
+  config.assignees = []
+
+  # Exception classes that should NOT trigger issue creation (optional)
+  config.ignored_exceptions = %w[ActionController::RoutingError]
+
+  # Set to false to report synchronously — recommended in test environments
+  config.async = false
+end
+```
+
+### Configuration options
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `github_token` | String | `nil` | GitHub token with `repo` (or Issues write) permission |
+| `github_repository` | String | `nil` | Target repo in `owner/repo` format |
+| `environments` | Array | `["production"]` | Environments where reporting is active |
+| `labels` | Array | `[]` | Labels applied to created issues |
+| `assignees` | Array | `[]` | GitHub logins assigned to created issues |
+| `ignored_exceptions` | Array | `[]` | Exception class names (strings) to skip |
+| `async` | Boolean | `true` | Report in a background thread (set `false` in tests) |
+
+---
+
+## How it works
+
+When a 500 error occurs:
+
+1. The Rack middleware catches the rendered 500 response.
+2. A **fingerprint** is computed from the exception class, message, and first application backtrace line.
+3. The GitHub API is searched for an open issue containing that fingerprint.
+4. If **no issue exists** → a new issue is created with the exception details.
+5. If **an issue exists** → a comment with the current timestamp is added.
+
+### Example GitHub issue
+
+**Title:** `[500] RuntimeError: something went wrong`
+
+**Body:**
+```
+## Error Details
+
+**Exception:** `RuntimeError`
+**Message:** something went wrong
+**First occurrence:** 2026-02-26 10:30:00 UTC
+**Request:** `GET /dashboard`
+**Remote IP:** 1.2.3.4
+
+## Backtrace
+
+app/controllers/dashboard_controller.rb:42:in 'index'
+...
+```
+
+### Example occurrence comment
+
+```
+**New occurrence:** 2026-02-26 14:55:02 UTC
+```
+
+---
+
+## GitHub token setup
+
+Eussiror needs a GitHub token with permission to read and create issues on your target repository.
+
+**Option A — Classic personal access token:**
+Generate at `Settings → Developer settings → Personal access tokens → Tokens (classic)` and select the `repo` scope.
+
+**Option B — Fine-grained personal access token:**
+Generate at `Settings → Developer settings → Personal access tokens → Fine-grained tokens`. Grant **Issues → Read and write** on the target repository only.
+
+Store the token in an environment variable (never hard-code it):
+
+```bash
+# .env or your secrets manager
+GITHUB_TOKEN=ghp_xxxxxxxxxxxx
+```
+
+---
+
+## Architecture (for contributors)
+
+This section describes the internal design of Eussiror to help contributors understand where everything lives and how the pieces connect.
+
+### File map
+
+```
+lib/
+├── eussiror.rb                         # Public API: .configure / .configuration / .reset_configuration!
+└── eussiror/
+    ├── version.rb                      # Gem version constant
+    ├── configuration.rb                # Configuration value object + guards
+    ├── railtie.rb                      # Rails integration: inserts Middleware into the stack
+    ├── middleware.rb                   # Rack middleware: detects 500s and calls ErrorReporter
+    ├── fingerprint.rb                  # Computes a stable SHA256 fingerprint per exception type
+    ├── github_client.rb                # GitHub REST API v3 calls via Net::HTTP
+    └── error_reporter.rb               # Orchestrator: fingerprint → search → create or comment
+
+lib/generators/eussiror/install/
+├── install_generator.rb                # `rails generate eussiror:install`
+└── templates/initializer.rb.tt         # Template for config/initializers/eussiror.rb
+```
+
+### Request / error flow
+
+```
+HTTP Request
+    │
+    ▼
+Eussiror::Middleware          (outermost Rack middleware)
+    │
+    ▼
+ActionDispatch::ShowExceptions (catches Rails exceptions, stores them in env)
+    │
+    ▼
+[... rest of Rails stack ...]
+    │
+    ▼  (response travels back up)
+ActionDispatch::ShowExceptions → sets env["action_dispatch.exception"]
+                                 returns HTTP 500 response
+    │
+    ▼
+Eussiror::Middleware
+    ├── status == 500 AND env["action_dispatch.exception"] present?
+    │     YES → ErrorReporter.report(exception, env)
+    │     NO  → pass response through unchanged
+    │
+    ▼
+HTTP Response returned to client
+```
+
+### Component responsibilities
+
+#### `Eussiror` (lib/eussiror.rb)
+Top-level module. Holds the singleton `configuration` object and exposes `.configure { |c| }`. All other components read `Eussiror.configuration`.
+
+#### `Eussiror::Configuration`
+Plain Ruby value object with attr_accessors for every option. Contains the two guard predicates used by `ErrorReporter`:
+- `#valid?` — both token and repository are present
+- `#reporting_enabled?` — valid config AND current Rails env is in `environments`
+
+#### `Eussiror::Railtie`
+Rails `Railtie` that runs one initializer: it inserts `Eussiror::Middleware` **before** `ActionDispatch::ShowExceptions` in the middleware stack. This positions our middleware as the outermost wrapper, so it sees the fully rendered 500 response on the way back out.
+
+#### `Eussiror::Middleware`
+Rack middleware with a standard `#call(env)` interface.
+- On a normal response: passes through.
+- On a 500 response with `env["action_dispatch.exception"]`: calls `ErrorReporter.report`.
+- On a re-raised exception (non-standard setups): calls `ErrorReporter.report` before re-raising.
+
+#### `Eussiror::Fingerprint`
+Stateless module with a single public method: `.compute(exception) → String`.
+
+The fingerprint is a 12-character hex prefix of a SHA256 digest computed from:
+```
+"#{exception.class.name}|#{exception.message[0,200]}|#{first_app_backtrace_line}"
+```
+Gem and stdlib lines are excluded when looking for the "first app line". This makes the fingerprint stable across deployments while being unique per error location.
+
+The fingerprint is embedded as an HTML comment in the issue body:
+```
+<!-- eussiror:fingerprint:a1b2c3d4e5f6 -->
+```
+
+#### `Eussiror::GithubClient`
+Thin HTTP client wrapping three GitHub REST API v3 endpoints. Uses only `Net::HTTP` (stdlib). Requires a `token:` and `repository:` at construction time.
+
+| Method | Endpoint | Purpose |
+|---|---|---|
+| `#find_issue(fingerprint)` | `GET /search/issues` | Returns issue number or `nil` |
+| `#create_issue(title:, body:, ...)` | `POST /repos/{owner}/{repo}/issues` | Returns new issue number |
+| `#add_comment(issue_number, body:)` | `POST /repos/{owner}/{repo}/issues/{n}/comments` | Returns comment id |
+
+#### `Eussiror::ErrorReporter`
+Stateless module that orchestrates the full reporting flow. Called by the middleware.
+
+1. Checks `Eussiror.configuration.reporting_enabled?` — returns early if not.
+2. Checks `ignored_exceptions` — returns early if matched.
+3. Dispatches in a `Thread.new` when `config.async` is `true` (default), or inline otherwise.
+4. Computes fingerprint → searches GitHub → creates issue or adds comment.
+5. All GitHub errors are rescued and emitted as `warn` messages — the gem **never crashes your app**.
+
+#### `Eussiror::Generators::InstallGenerator`
+Standard `Rails::Generators::Base` subclass. Copies `templates/initializer.rb.tt` to `config/initializers/eussiror.rb` using Thor's `template` method. Supports `rails destroy eussiror:install` for clean uninstallation.
+
+### Testing approach
+
+- **Unit specs**: each component is tested in isolation. `GithubClient` uses `WebMock` to stub HTTP calls. `ErrorReporter` uses RSpec doubles for `GithubClient`.
+- **Generator spec**: uses Rails generator test helpers (`prepare_destination`, `run_generator`).
+- **Appraisals**: the `Appraisals` file defines three gemfiles (`rails-7.2`, `rails-8.0`, `rails-8.1`) so the full test suite runs against each supported Rails version.
+
+---
+
+## Development
+
+```bash
+# Clone and install
+git clone https://github.com/tracyloisel/eussiror.git
+cd eussiror
+bundle install
+
+# Run tests against all Rails versions
+bundle exec appraisal install
+bundle exec appraisal rspec
+
+# Run tests against a specific Rails version
+bundle exec appraisal rails-8.0 rspec
+
+# Run the linter
+bundle exec rubocop
+
+# Run the linter with auto-correct
+bundle exec rubocop -A
+```
+
+---
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/my-feature`
+3. Write tests for your change
+4. Make the tests pass: `bundle exec appraisal rspec`
+5. Make the linter pass: `bundle exec rubocop`
+6. Open a pull request against `main`
+
+Please follow the existing code style. All public behaviour must be covered by specs.
+
+---
+
+## License
+
+The gem is available as open source under the [MIT License](LICENSE).

data/lib/eussiror/configuration.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Eussiror
+  class Configuration
+    # Required settings
+    attr_accessor :github_token, :github_repository
+
+    # Environments where issue reporting is active (default: production only)
+    attr_accessor :environments
+
+    # Optional GitHub issue metadata
+    attr_accessor :labels, :assignees
+
+    # Exception classes to ignore (array of strings)
+    attr_accessor :ignored_exceptions
+
+    # Set to false to report synchronously (useful in tests)
+    attr_accessor :async
+
+    def initialize
+      @environments       = %w[production]
+      @labels             = []
+      @assignees          = []
+      @ignored_exceptions = []
+      @async              = true
+    end
+
+    def valid?
+      github_token.to_s.strip.length.positive? &&
+        github_repository.to_s.strip.length.positive?
+    end
+
+    def reporting_enabled?
+      valid? && environments.include?(current_environment)
+    end
+
+    private
+
+    def current_environment
+      defined?(Rails) ? Rails.env.to_s : ENV.fetch("RAILS_ENV", "development")
+    end
+  end
+end

data/lib/eussiror/error_reporter.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Eussiror
+  module ErrorReporter
+    # Maximum number of backtrace lines included in an issue body.
+    MAX_BACKTRACE_LINES = 20
+
+    class << self
+      # Entry point called by the middleware.
+      # Checks configuration guards, then dispatches async or sync.
+      def report(exception, env = {})
+        config = Eussiror.configuration
+
+        return unless config.reporting_enabled?
+        return if ignored?(exception, config)
+
+        if config.async
+          Thread.new { process(exception, env, config) }
+        else
+          process(exception, env, config)
+        end
+      rescue StandardError => e
+        warn "[Eussiror] ErrorReporter.report raised an unexpected error: #{e.class}: #{e.message}"
+      end
+
+      private
+
+      def ignored?(exception, config)
+        config.ignored_exceptions.any? do |klass_name|
+          exception.is_a?(Object.const_get(klass_name))
+        rescue NameError
+          false
+        end
+      end
+
+      def process(exception, env, config)
+        fingerprint = Fingerprint.compute(exception)
+        client      = GithubClient.new(
+          token:      config.github_token,
+          repository: config.github_repository
+        )
+
+        existing_issue = client.find_issue(fingerprint)
+
+        if existing_issue
+          client.add_comment(existing_issue, body: occurrence_comment)
+        else
+          client.create_issue(
+            title:     issue_title(exception),
+            body:      issue_body(exception, env, fingerprint),
+            labels:    config.labels,
+            assignees: config.assignees
+          )
+        end
+      rescue StandardError => e
+        warn "[Eussiror] Failed to report exception to GitHub: #{e.class}: #{e.message}"
+      end
+
+      def issue_title(exception)
+        message = exception.message.to_s.lines.first.to_s.strip[0, 120]
+        "[500] #{exception.class}: #{message}"
+      end
+
+      def issue_body(exception, env, fingerprint)
+        request_info = build_request_info(env)
+        backtrace    = format_backtrace(exception)
+
+        <<~BODY
+          ## Error Details
+
+          **Exception:** `#{exception.class}`
+          **Message:** #{exception.message}
+          **First occurrence:** #{current_timestamp}
+          #{request_info}
+
+          ## Backtrace
+
+          ```
+          #{backtrace}
+          ```
+
+          <!-- #{GithubClient::FINGERPRINT_MARKER}:#{fingerprint} -->
+        BODY
+      end
+
+      def occurrence_comment
+        "**New occurrence:** #{current_timestamp}"
+      end
+
+      def current_timestamp
+        Time.now.utc.strftime("%Y-%m-%d %H:%M:%S UTC")
+      end
+
+      def build_request_info(env)
+        return "" if env.nil? || env.empty?
+
+        method      = env["REQUEST_METHOD"]
+        path        = env["PATH_INFO"]
+        remote_addr = env["REMOTE_ADDR"]
+
+        return "" unless method && path
+
+        parts = ["**Request:** `#{method} #{path}`"]
+        parts << "**Remote IP:** #{remote_addr}" if remote_addr
+
+        "\n#{parts.join("\n")}"
+      end
+
+      def format_backtrace(exception)
+        (exception.backtrace || [])
+          .first(MAX_BACKTRACE_LINES)
+          .join("\n")
+      end
+    end
+  end
+end

data/lib/eussiror/fingerprint.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Eussiror
+  module Fingerprint
+    # Number of hex characters kept from the SHA256 digest.
+    DIGEST_LENGTH = 12
+
+    # Lines from these path fragments are excluded when looking for the
+    # "first application line" in a backtrace.
+    GEM_PATH_PATTERNS = %w[/gems/ /ruby/ /rubygems vendor/bundle].freeze
+
+    # Computes a stable, short fingerprint for a given exception.
+    #
+    # The fingerprint is based on:
+    #   - The exception class name
+    #   - The first 200 characters of the message
+    #   - The first backtrace line that belongs to the application (not a gem)
+    #
+    # Returns a 12-character lowercase hex string.
+    def self.compute(exception)
+      parts = [
+        exception.class.name,
+        exception.message.to_s[0, 200],
+        first_app_backtrace_line(exception)
+      ]
+
+      Digest::SHA256.hexdigest(parts.join("|"))[0, DIGEST_LENGTH]
+    end
+
+    def self.first_app_backtrace_line(exception)
+      backtrace = exception.backtrace || []
+      backtrace.find { |line| GEM_PATH_PATTERNS.none? { |pattern| line.include?(pattern) } } || backtrace.first.to_s
+    end
+    private_class_method :first_app_backtrace_line
+  end
+end

data/lib/eussiror/github_client.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module Eussiror
+  class GithubClient
+    GITHUB_API_BASE = "https://api.github.com"
+    # Marker embedded as an HTML comment in every issue body for searching.
+    FINGERPRINT_MARKER = "eussiror:fingerprint"
+
+    def initialize(token:, repository:)
+      @token      = token
+      @repository = repository
+    end
+
+    # Searches for an open issue whose body contains the given fingerprint.
+    # Returns the issue number (Integer) or nil when none is found.
+    def find_issue(fingerprint)
+      query  = "repo:#{@repository} is:issue is:open \"#{FINGERPRINT_MARKER}:#{fingerprint}\" in:body"
+      params = URI.encode_www_form(q: query, per_page: 1)
+      uri    = URI("#{GITHUB_API_BASE}/search/issues?#{params}")
+
+      response = get(uri)
+      data     = JSON.parse(response.body)
+
+      return nil unless response.is_a?(Net::HTTPSuccess)
+      return nil if data["items"].nil? || data["items"].empty?
+
+      data["items"].first["number"]
+    end
+
+    # Creates a new GitHub issue and returns the issue number.
+    def create_issue(title:, body:, labels: [], assignees: [])
+      uri     = URI("#{GITHUB_API_BASE}/repos/#{@repository}/issues")
+      payload = { title: title, body: body }
+      payload[:labels]    = labels    if labels.any?
+      payload[:assignees] = assignees if assignees.any?
+
+      response = post(uri, payload)
+      data     = JSON.parse(response.body)
+
+      raise_api_error!(response, "create issue") unless response.is_a?(Net::HTTPSuccess)
+
+      data["number"]
+    end
+
+    # Adds a comment to an existing issue. Returns the comment id.
+    def add_comment(issue_number, body:)
+      uri = URI("#{GITHUB_API_BASE}/repos/#{@repository}/issues/#{issue_number}/comments")
+
+      response = post(uri, { body: body })
+      data     = JSON.parse(response.body)
+
+      raise_api_error!(response, "add comment") unless response.is_a?(Net::HTTPSuccess)
+
+      data["id"]
+    end
+
+    private
+
+    def get(uri)
+      request = Net::HTTP::Get.new(uri)
+      apply_headers!(request)
+      execute(uri, request)
+    end
+
+    def post(uri, payload)
+      request = Net::HTTP::Post.new(uri)
+      apply_headers!(request)
+      request.body = JSON.generate(payload)
+      execute(uri, request)
+    end
+
+    def execute(uri, request)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        http.request(request)
+      end
+    end
+
+    def apply_headers!(request)
+      request["Authorization"]        = "Bearer #{@token}"
+      request["Accept"]               = "application/vnd.github+json"
+      request["X-GitHub-Api-Version"] = "2022-11-28"
+      request["Content-Type"]         = "application/json"
+      request["User-Agent"]           = "eussiror/#{Eussiror::VERSION}"
+    end
+
+    def raise_api_error!(response, action)
+      raise "Eussiror: GitHub API failed to #{action} " \
+            "(HTTP #{response.code}): #{response.body}"
+    end
+  end
+end

data/lib/eussiror/middleware.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Eussiror
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+
+      if status == 500
+        exception = env["action_dispatch.exception"]
+        ErrorReporter.report(exception, env) if exception
+      end
+
+      [status, headers, body]
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      # The Rails stack re-raises after ShowExceptions in non-standard setups.
+      # We still want to capture the exception before propagating it.
+      ErrorReporter.report(e, env)
+      raise
+    end
+  end
+end

data/lib/eussiror/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module Eussiror
+  class Railtie < Rails::Railtie
+    # Insert before ShowExceptions so we wrap the full Rails error rendering.
+    # On the way back out, we inspect the rendered response and env to detect 500s.
+    initializer "eussiror.insert_middleware" do |app|
+      app.middleware.insert_before ActionDispatch::ShowExceptions, Eussiror::Middleware
+    end
+  end
+end

data/lib/eussiror/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Eussiror
+  VERSION = "0.1.0"
+end

data/lib/eussiror.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "eussiror/version"
+require "eussiror/configuration"
+require "eussiror/fingerprint"
+require "eussiror/github_client"
+require "eussiror/error_reporter"
+require "eussiror/middleware"
+require "eussiror/railtie" if defined?(Rails::Railtie)
+
+module Eussiror
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/generators/eussiror/install/install_generator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Eussiror
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates an Eussiror initializer in config/initializers."
+
+      def create_initializer_file
+        template "initializer.rb.tt", "config/initializers/eussiror.rb"
+      end
+    end
+  end
+end

data/lib/generators/eussiror/install/templates/initializer.rb.tt

@@ -0,0 +1,25 @@
+Eussiror.configure do |config|
+  # Required: GitHub personal access token with "repo" scope (or a fine-grained
+  # token with Issues read/write permission on the target repository).
+  config.github_token = ENV["GITHUB_TOKEN"]
+
+  # Required: target GitHub repository in "owner/repository" format.
+  config.github_repository = "your-org/your-repo"
+
+  # Environments where 500 errors will be reported to GitHub.
+  # Default: ["production"]
+  config.environments = %w[production]
+
+  # Labels applied to every new issue created by Eussiror (optional).
+  # config.labels = %w[bug automated]
+
+  # GitHub login(s) to assign to new issues (optional).
+  # config.assignees = []
+
+  # Exception classes that should NOT trigger issue creation (optional).
+  # config.ignored_exceptions = %w[ActionController::RoutingError]
+
+  # Set to false to report synchronously instead of in a background thread.
+  # Recommended for test environments or when using a job queue.
+  # config.async = false
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: eussiror
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Equipe Technique
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+description: |
+  Eussiror hooks into your Rails app and automatically creates GitHub issues
+  when unhandled exceptions produce 500 responses in configured environments.
+  If an issue already exists for the same error (identified by fingerprint),
+  it adds a comment with the new occurrence timestamp instead.
+email: []
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/eussiror.rb
+- lib/eussiror/configuration.rb
+- lib/eussiror/error_reporter.rb
+- lib/eussiror/fingerprint.rb
+- lib/eussiror/github_client.rb
+- lib/eussiror/middleware.rb
+- lib/eussiror/railtie.rb
+- lib/eussiror/version.rb
+- lib/generators/eussiror/install/install_generator.rb
+- lib/generators/eussiror/install/templates/initializer.rb.tt
+homepage: https://github.com/tracyloisel/eussiror
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/tracyloisel/eussiror
+  source_code_uri: https://github.com/tracyloisel/eussiror
+  changelog_uri: https://github.com/tracyloisel/eussiror/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Automatically create GitHub issues from Rails 500 errors
+test_files: []