eussiror 0.2.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54a8483b3b8378abea17e270fa6ed1f70316caaa5409ad8302bc9ed34e61a4c8
-  data.tar.gz: ab05adc5d9249b40d0cdc5086c950939422b20be14d1984133da111a068f9a6f
+  metadata.gz: c4476191c4d0ae4fb165cb1542996388759025d3edc3948d9f2089bd79c1ff55
+  data.tar.gz: 041de6349fae9a39222aeba2991cb1ba5ca379b264fefd9ac49e35c0458eaf81
 SHA512:
-  metadata.gz: d71a26061ddea12db66a67febb49d80c43e44b99f76565f02cd37a3d404b3e034eba7285b8d8fc89b2f0ecb4106e23e7f3ce03f3967a55459fad5e24a6671a04
-  data.tar.gz: '06915b0ab2745c2e35a5631b111b3e38d3d543917effdeb2f1d6a0873d67ab20b551fbc559a86f1d5a7d6b5945503d8dbe99805344c642c196d1c4c999e86172'
+  metadata.gz: 1ac670063fc01936242fa48834725077733094df0c9e9dc3bbdc71e6dc3069558bcb0a6872f3ccbd7881723173b588c31f272da4b62d00cca201f48e87dd90dc
+  data.tar.gz: a239a33a76c34dedf39667ad4a642b31132ed63ca73789ef422d0f51199ae7102a136223bb8fd6fdbc5212dd7bbc9282f010f595288e38b1bcad53e7fc8e67f3

data/CHANGELOG.md

@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-04-02
+
+### Changed
+- **Breaking:** Replace Rack middleware with `Rails.error.subscribe` (`ActiveSupport::ErrorReporter`). Eussiror now catches **all** unhandled exceptions (HTTP requests, ActiveJob, Action Cable, Rake, etc.), not just HTTP 500s.
+- Issue titles use source-aware tags (`[request]`, `[job]`, `[cable]`, `[error]`) instead of `[500]`.
+- `Eussiror::Middleware` has been removed; `Eussiror::ErrorSubscriber` replaces it.
+- Source classification is now hybrid (strict mapping + heuristics on source strings) to reduce false `[error]` tags across Rails/runtime variants.
+
+### Added
+- `Eussiror::ErrorSubscriber` — `Rails.error` subscriber registered via the Railtie.
+- `Configuration#report_handled_errors` (default `false`) to optionally report errors caught by `Rails.error.handle`.
+- **Source** line in issue Context section for non-default sources (e.g. `job`, `request`).
+- Additional release environment variables (`SOURCE_VERSION`, `RAILWAY_GIT_COMMIT_SHA`, `RENDER_GIT_COMMIT`, `CI_COMMIT_SHA`, `GITHUB_SHA`) alongside existing keys.
+- `Eussiror::ContextExtractor` to normalize heterogeneous Rails.error context payloads (string/symbol keys, nested env/request/headers, request objects).
+
+## [0.3.0] - 2026-04-02
+
+### Added
+- `Configuration#issue_privacy` (`:minimal`, `:standard`, `:full`) and `Configuration#environment_name`.
+- `Eussiror::IssueFormatting` for structured GitHub issue bodies and repeat-occurrence comments.
+- Post-install notice after `rails generate eussiror:install`.
+
+### Changed
+- Issue and comment content use the new formatting; optional release from `RELEASE`, `HEROKU_SLUG_COMMIT`, `REVISION`, or `GIT_COMMIT`.
+
 ## [0.2.2] - 2026-02-26
 
 ### Fixed

data/README.md

@@ -6,7 +6,7 @@
 [![CI](https://github.com/EquipeTechnique/eussiror/actions/workflows/ci.yml/badge.svg)](https://github.com/EquipeTechnique/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.
+**Eussiror** automatically creates GitHub issues when your Rails application raises an unhandled exception — whether from an HTTP request, an ActiveJob, Action Cable, or any other Rails execution context. If the same error already has an open issue, it adds a comment with the new occurrence instead — keeping your issue tracker clean and deduplicated.
 
 ---
 
@@ -50,7 +50,9 @@ bundle install
 rails generate eussiror:install
 ```
 
-The generator creates `config/initializers/eussiror.rb` with all available options commented out. To undo the installation:
+The generator creates `config/initializers/eussiror.rb` with all available options commented out and prints a short **post-install notice** in the terminal (next steps, token safety, `issue_privacy`).
+
+To undo the installation:
 
 ```bash
 rails destroy eussiror:install
@@ -60,61 +62,112 @@ rails destroy eussiror:install
 
 ## Configuration
 
-Edit the generated initializer:
+Edit the generated initializer (`config/initializers/eussiror.rb`). Every assignable option is listed below.
 
 ```ruby
 # config/initializers/eussiror.rb
 Eussiror.configure do |config|
-  # Required: GitHub personal access token with "repo" scope
+  # --- GitHub (required for reporting) ---
   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"])
+  # --- Where and how to report ---
   config.environments = %w[production]
+  # config.issue_privacy = :minimal   # :minimal | :standard | :full — see "Issue privacy"
+  config.async = true                 # false = synchronous (e.g. tests)
 
-  # Labels applied to every new issue (optional)
-  config.labels = %w[bug automated]
-
-  # GitHub logins to assign to new issues (optional)
-  config.assignees = []
+  # Also report errors caught by Rails.error.handle (default: false — only unhandled)
+  # config.report_handled_errors = false
 
-  # Exception classes that should NOT trigger issue creation (optional)
-  config.ignored_exceptions = %w[ActionController::RoutingError]
+  # --- Issue metadata (optional) ---
+  # config.labels = %w[bug automated]
+  # config.assignees = []             # GitHub usernames (logins), not display names
 
-  # Set to false to report synchronously — recommended in test environments
-  config.async = false
+  # --- Filtering (optional) ---
+  # config.ignored_exceptions = %w[ActionController::RoutingError]
 end
 ```
 
-### Configuration options
+### Assignable options (`Eussiror.configure`)
 
 | 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) |
+|--------|------|---------|-------------|
+| `github_token` | String | `nil` | Personal access token (classic `repo`, or fine-grained with Issues read/write on the target repo). **Required for any GitHub activity:** if blank, reporting is disabled. |
+| `github_repository` | String | `nil` | Repository in `owner/repo` form. **Required with `github_token`** for reporting. |
+| `environments` | Array of String | `["production"]` | Rails/Rack env names where reporting runs. Current env comes from `Rails.env` (Rails) or `ENV["RAILS_ENV"]` (default `"development"`). |
+| `issue_privacy` | Symbol or String | `:minimal` | How much request/user context is copied into issue bodies and occurrence comments. Must be `minimal`, `standard`, or `full` (setter raises `ArgumentError` otherwise). See **Issue privacy** below. |
+| `async` | Boolean | `true` | If `true`, `ErrorReporter` runs in a `Thread`; if `false`, reporting is synchronous (useful in tests or strict ordering). |
+| `report_handled_errors` | Boolean | `false` | When `true`, errors caught by `Rails.error.handle` are also reported (by default only unhandled errors trigger a GitHub issue). |
+| `labels` | Array of String | `[]` | Labels applied to **new** issues created by Eussiror (must exist on the repo). |
+| `assignees` | Array of String | `[]` | GitHub **login** usernames assigned to new issues (empty = none). |
+| `ignored_exceptions` | Array of String | `[]` | Exception **class names** to never report (e.g. `"ActionController::RoutingError"`). Unknown class names are ignored safely. |
+
+Reporting runs only when **`#reporting_enabled?`** is true: configuration is **`#valid?`** (both `github_token` and `github_repository` non-blank after strip) **and** the current environment is listed in `environments`.
+
+### Read-only and predicates (`Eussiror.configuration`)
+
+These are not set in the initializer; they are useful for debugging or tests.
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `#environment_name` | String | Label for the current environment (same source as the env guard: `Rails.env` or `ENV["RAILS_ENV"]`). Shown in GitHub issue **Context**. |
+| `#issue_privacy` | Symbol | Current privacy level after assignment (`:minimal`, `:standard`, or `:full`). |
+| `#valid?` | Boolean | `true` if `github_token` and `github_repository` are both non-blank. |
+| `#reporting_enabled?` | Boolean | `true` if `#valid?` and the current env is in `environments`. |
+
+### Issue privacy
+
+GitHub issues may be visible to people outside your core team (public repo, or future collaborators). **`issue_privacy`** controls how much context is copied into each issue:
+
+| Value | Request in issue | User in issue | Typical use |
+|-------|------------------|---------------|-------------|
+| `:minimal` | HTTP method + path only | Never | Public repos, OSS, minimal footprint (default) |
+| `:standard` | Also Remote IP and `User-Agent` when present in the Rack `env` | Never | Private repo, ops-friendly debugging |
+| `:full` | Same as `:standard` | **User** section if you set Rack keys below | Private repo, team accepts user context in issues |
+
+### Optional user context (Rack `env`)
+
+When `issue_privacy` is `:full`, set these from your middleware (after authentication):
+
+| Key | Meaning |
+|-----|---------|
+| `env["eussiror.user_id"]` | Stable user identifier (e.g. database id) |
+| `env["eussiror.user_label"]` | Optional human-readable label (e.g. email or login) — only if your policy allows it |
+
+### Context normalization
+
+`Rails.error` can provide context in multiple shapes (flat hash, symbol keys, nested env/request, request object). Eussiror normalizes this before formatting issues/comments.
+
+Recognized families of keys (first non-empty wins):
+- **Request method/path:** `REQUEST_METHOD` / `PATH_INFO` (string or symbol), nested `env`/`rack`, request object (`request_method`, `fullpath`, `path`)
+- **IP/user-agent:** `REMOTE_ADDR` / `HTTP_USER_AGENT`, nested `headers["User-Agent"]`, request object (`remote_ip`, `user_agent`, `ip`)
+- **User fields:** `eussiror.user_id`, `eussiror.user_label`, plus `user_id` / `user_label` fallbacks
+
+Explicit top-level keys win over nested values when both are present.
+
+**Release** in the issue **Context** section is taken from the first non-empty environment variable among: `RELEASE` (recommended explicit override), then `SOURCE_VERSION` (Scalingo and others), `HEROKU_SLUG_COMMIT`, `RAILWAY_GIT_COMMIT_SHA`, `RENDER_GIT_COMMIT`, `REVISION`, `GIT_COMMIT`, `CI_COMMIT_SHA` (GitLab CI, etc.), `GITHUB_SHA` (GitHub Actions).
 
 ---
 
 ## How it works
 
-When a 500 error occurs:
+Eussiror subscribes to **`Rails.error`** (`ActiveSupport::ErrorReporter`, available since Rails 7.1). Rails wraps every execution context — HTTP requests, ActiveJob, Action Cable, etc. — in this reporter, so Eussiror catches exceptions regardless of origin.
 
-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.
+1. An unhandled exception (or a handled one if `report_handled_errors` is enabled) reaches `Rails.error`.
+2. `Eussiror::ErrorSubscriber` receives the exception with its `severity`, `source`, and `context`.
+3. A **fingerprint** is computed from the exception class, message, and first application backtrace line.
+4. The GitHub API is searched for an open issue containing that fingerprint.
+5. If **no issue exists** → a new issue is created with structured details.
+6. If **an issue exists** → a comment with the new occurrence is added.
+
+The issue title includes a **source tag** (`[request]`, `[job]`, `[cable]`, or `[error]`) so you can tell at a glance where the exception came from. Source classification uses a hybrid strategy:
+- strict mapping for known Rails sources,
+- heuristic fallback using source prefixes/contains (`ActiveJob`, `ActionCable`, `ActionDispatch`/`Rack`),
+- final fallback to `[error]`.
 
 ### Example GitHub issue
 
-**Title:** `[500] RuntimeError: something went wrong`
+**Title:** `[request] RuntimeError: something went wrong`
 
 **Body:**
 ```
@@ -123,8 +176,22 @@ When a 500 error occurs:
 **Exception:** `RuntimeError`
 **Message:** something went wrong
 **First occurrence:** 2026-02-26 10:30:00 UTC
+
+## Context
+
+**Environment:** `production`
+**Source:** `request` (omitted when the source is the default "error")
+**Release:** `abc123` (when a release env var from the list in **Optional user context** is set)
+
+## User
+
+(Only when issue_privacy is :full and eussiror.user_* keys are set.)
+
+## Request
+
 **Request:** `GET /dashboard`
-**Remote IP:** 1.2.3.4
+**Remote IP:** 1.2.3.4 (only when issue_privacy is :standard or :full)
+**User-Agent:** … (same)
 
 ## Backtrace
 
@@ -134,10 +201,16 @@ app/controllers/dashboard_controller.rb:42:in 'index'
 
 ### Example occurrence comment
 
+With `:minimal` (default):
+
 ```
 **New occurrence:** 2026-02-26 14:55:02 UTC
+
+**Request:** `GET /dashboard`
 ```
 
+With `:standard` or `:full`, Remote IP and User-Agent are included when present; with `:full`, **User id** appears when `env["eussiror.user_id"]` is set.
+
 ---
 
 ## GitHub token setup
@@ -208,10 +281,12 @@ lib/
 └── 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
+    ├── railtie.rb                      # Rails integration: subscribes to Rails.error
+    ├── error_subscriber.rb             # ActiveSupport::ErrorReporter subscriber
     ├── fingerprint.rb                  # Computes a stable SHA256 fingerprint per exception type
     ├── github_client.rb                # GitHub REST API v3 calls via Net::HTTP
+    ├── issue_formatting.rb             # Issue body and occurrence comment text
+    ├── release_env.rb                  # Optional release label from ENV (PaaS/CI keys)
     └── error_reporter.rb               # Orchestrator: fingerprint → search → create or comment
 
 lib/generators/eussiror/install/
@@ -219,32 +294,28 @@ lib/generators/eussiror/install/
 └── templates/initializer.rb.tt         # Template for config/initializers/eussiror.rb
 ```
 
-### Request / error flow
+### Error flow
 
 ```
-HTTP Request
-    │
-    ▼
-Eussiror::Middleware          (outermost Rack middleware)
+Any Rails execution context
+(HTTP request, ActiveJob, Action Cable, Rake, etc.)
     │
-    ▼
-ActionDispatch::ShowExceptions (catches Rails exceptions, stores them in env)
+    ▼  unhandled exception
+Rails.error (ActiveSupport::ErrorReporter)
     │
+    ▼  report(error, handled:, severity:, context:, source:)
+Eussiror::ErrorSubscriber
+    │  filters: handled? severity == :error?
     ▼
-[... rest of Rails stack ...]
-    │
-    ▼  (response travels back up)
-ActionDispatch::ShowExceptions → sets env["action_dispatch.exception"]
-                                 returns HTTP 500 response
+Eussiror::ErrorReporter.report(exception, context, source:)
     │
-    ▼
-Eussiror::Middleware
-    ├── status == 500 AND env["action_dispatch.exception"] present?
-    │     YES → ErrorReporter.report(exception, env)
-    │     NO  → pass response through unchanged
+    ├── Fingerprint.compute(exception)
+    ├── GithubClient.find_issue(fingerprint)
+    │     found  → GithubClient.add_comment (occurrence)
+    │     absent → GithubClient.create_issue (structured body)
     │
     ▼
-HTTP Response returned to client
+GitHub Issues
 ```
 
 ### Component responsibilities
@@ -253,18 +324,17 @@ HTTP Response returned to client
 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`:
+Plain Ruby value object with attr_accessors for every option. Exposes `#environment_name` for issue bodies. 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`
 
+`#issue_privacy` must be `:minimal`, `:standard`, or `:full` (setter raises `ArgumentError` otherwise).
+
 #### `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.
+Rails `Railtie` that runs one initializer: it registers `Eussiror::ErrorSubscriber` with `Rails.error.subscribe`, hooking into every execution context Rails wraps (requests, jobs, channels, etc.).
 
-#### `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::ErrorSubscriber`
+Implements the `ActiveSupport::ErrorReporter` subscriber interface (`#report(error, handled:, severity:, context:, source:)`). Filters out handled errors (unless `report_handled_errors` is enabled) and non-`:error` severities, then delegates to `ErrorReporter`.
 
 #### `Eussiror::Fingerprint`
 Stateless module with a single public method: `.compute(exception) → String`.
@@ -290,21 +360,22 @@ Thin HTTP client wrapping three GitHub REST API v3 endpoints. Uses only `Net::HT
 | `#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.
+Stateless module that orchestrates the full reporting flow. Called by `ErrorSubscriber`.
 
 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**.
+3. Maps the `source` string to a human-readable tag (`[request]`, `[job]`, `[cable]`, or `[error]`).
+4. Dispatches in a `Thread.new` when `config.async` is `true` (default), or inline otherwise.
+5. Computes fingerprint → searches GitHub → creates issue (structured body: Error Details, Context, optional User, Request, Backtrace) or adds an occurrence comment.
+6. 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.
+Standard `Rails::Generators::Base` subclass. Copies `templates/initializer.rb.tt` to `config/initializers/eussiror.rb` using Thor's `template` method, then prints a **post-install notice** (`show_post_install_notice`). 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`).
+- **Unit specs**: each component is tested in isolation. `GithubClient` uses `WebMock` to stub HTTP calls. `ErrorReporter` and `ErrorSubscriber` use RSpec doubles.
+- **Generator spec**: uses Rails generator test helpers (`prepare_destination`, `invoke_all`) and asserts post-install output.
 - **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.
 
 ---

data/lib/eussiror/configuration.rb

@@ -2,6 +2,9 @@
 
 module Eussiror
   class Configuration
+    # Allowed values for #issue_privacy: :minimal (default), :standard, :full
+    ISSUE_PRIVACY_LEVELS = %i[minimal standard full].freeze
+
     # Required settings
     attr_accessor :github_token, :github_repository
 
@@ -17,12 +20,25 @@ module Eussiror
     # Set to false to report synchronously (useful in tests)
     attr_accessor :async
 
+    # When true, errors caught by Rails.error.handle are also reported (default: false).
+    attr_accessor :report_handled_errors
+
+    # Controls how much request/user context is included in GitHub issue bodies and
+    # occurrence comments. :minimal is safest for public repos; :full for trusted private teams.
+    attr_reader :issue_privacy
+
     def initialize
-      @environments       = %w[production]
-      @labels             = []
-      @assignees          = []
-      @ignored_exceptions = []
-      @async              = true
+      @environments           = %w[production]
+      @labels                 = []
+      @assignees              = []
+      @ignored_exceptions     = []
+      @async                  = true
+      @report_handled_errors  = false
+      @issue_privacy          = :minimal
+    end
+
+    def issue_privacy=(value)
+      @issue_privacy = normalize_issue_privacy(value)
     end
 
     def valid?
@@ -34,8 +50,25 @@ module Eussiror
       valid? && environments.include?(current_environment)
     end
 
+    # Current Rails / Rack environment name (for display in issue bodies).
+    #
+    # @return [String]
+    def environment_name
+      current_environment
+    end
+
     private
 
+    def normalize_issue_privacy(value)
+      return :minimal if value.nil?
+
+      sym = value.respond_to?(:to_sym) ? value.to_sym : value.to_s.to_sym
+      return sym if ISSUE_PRIVACY_LEVELS.include?(sym)
+
+      raise ArgumentError,
+            "issue_privacy must be one of #{ISSUE_PRIVACY_LEVELS.join(', ')}, got #{value.inspect}"
+    end
+
     def current_environment
       return ENV.fetch("RAILS_ENV", "development") unless defined?(Rails)
       return Rails.env.to_s if Rails.respond_to?(:env)

data/lib/eussiror/context_extractor.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Eussiror
+  # Normalizes heterogeneous Rails.error context payloads into a stable structure
+  # consumed by issue formatting.
+  module ContextExtractor
+    class << self
+      def normalize(context)
+        ctx = context.is_a?(Hash) ? context : {}
+        req = request_object(ctx)
+        env = nested_hash(ctx, :env) || nested_hash(ctx, :rack)
+        headers = nested_hash(ctx, :headers)
+
+        {
+          request_method: request_method(ctx, env, req),
+          path: request_path(ctx, env, req),
+          remote_ip: remote_ip(ctx, env, req),
+          user_agent: user_agent(ctx, env, headers, req),
+          user_id: user_id(ctx, env),
+          user_label: user_label(ctx, env)
+        }
+      end
+
+      private
+
+      def request_method(ctx, env, req)
+        resolve_field(
+          [ctx, "REQUEST_METHOD"],
+          [env, "REQUEST_METHOD"],
+          [req, :request_method]
+        )
+      end
+
+      def request_path(ctx, env, req)
+        resolve_field(
+          [ctx, "PATH_INFO"],
+          [env, "PATH_INFO"],
+          [ctx, "path"],
+          [req, :fullpath],
+          [req, :path]
+        )
+      end
+
+      def remote_ip(ctx, env, req)
+        resolve_field(
+          [ctx, "REMOTE_ADDR"],
+          [env, "REMOTE_ADDR"],
+          [ctx, "remote_ip"],
+          [req, :remote_ip],
+          [ctx, "ip"],
+          [req, :ip]
+        )
+      end
+
+      def user_agent(ctx, env, headers, req)
+        resolve_field(
+          [ctx, "HTTP_USER_AGENT"],
+          [env, "HTTP_USER_AGENT"],
+          [headers, "User-Agent"],
+          [headers, "HTTP_USER_AGENT"],
+          [req, :user_agent]
+        )
+      end
+
+      def user_id(ctx, env)
+        resolve_field(
+          [ctx, IssueFormatting::USER_ID_KEY],
+          [env, IssueFormatting::USER_ID_KEY],
+          [ctx, "user_id"]
+        )
+      end
+
+      def user_label(ctx, env)
+        resolve_field(
+          [ctx, IssueFormatting::USER_LABEL_KEY],
+          [env, IssueFormatting::USER_LABEL_KEY],
+          [ctx, "user_label"]
+        )
+      end
+
+      def request_object(context)
+        fetch_key(context, "request") ||
+          fetch_key(context, "request_object") ||
+          fetch_key(context, "action_dispatch.request")
+      end
+
+      def nested_hash(context, key)
+        val = fetch_key(context, key)
+        val.is_a?(Hash) ? val : nil
+      end
+
+      def from_hash(container, key)
+        return nil unless container
+
+        if container.is_a?(Hash)
+          fetch_key(container, key)
+        elsif container.respond_to?(key)
+          container.public_send(key)
+        end
+      rescue NoMethodError
+        nil
+      end
+
+      def fetch_key(hash, key)
+        return nil unless hash.is_a?(Hash)
+
+        str_key = key.to_s
+        hash[str_key] || hash[str_key.to_sym]
+      end
+
+      def resolve_field(*lookups)
+        values = lookups.map { |(container, key)| from_hash(container, key) }
+        first_present(*values)
+      end
+
+      def first_present(*values)
+        values.find { |v| present_string?(v) }
+      end
+
+      def present_string?(value)
+        !value.nil? && !value.to_s.strip.empty?
+      end
+    end
+  end
+end

data/lib/eussiror/error_reporter.rb

@@ -2,22 +2,31 @@
 
 module Eussiror
   module ErrorReporter
-    # Maximum number of backtrace lines included in an issue body.
     MAX_BACKTRACE_LINES = 20
 
+    USER_ID_KEY    = IssueFormatting::USER_ID_KEY
+    USER_LABEL_KEY = IssueFormatting::USER_LABEL_KEY
+
+    # Maps Rails.error source strings to short tags for issue titles.
+    SOURCE_TAGS = {
+      "application" => "error",
+      "ActionDispatch::Executor" => "request",
+      "ActiveJob" => "job",
+      "ActionCable::Connection" => "cable"
+    }.freeze
+
     class << self
-      # Entry point called by the middleware.
-      # Checks configuration guards, then dispatches async or sync.
-      def report(exception, env = {})
+      def report(exception, context = {}, source: "application")
         config = Eussiror.configuration
 
         return unless config.reporting_enabled?
         return if ignored?(exception, config)
 
+        tag = source_tag_for(source)
         if config.async
-          Thread.new { process(exception, env, config) }
+          Thread.new { process(exception, context, config, tag) }
         else
-          process(exception, env, config)
+          process(exception, context, config, tag)
         end
       rescue StandardError => e
         warn "[Eussiror] ErrorReporter.report raised an unexpected error: #{e.class}: #{e.message}"
@@ -33,7 +42,19 @@ module Eussiror
         end
       end
 
-      def process(exception, env, config)
+      def source_tag_for(source)
+        src = source.to_s
+        return SOURCE_TAGS[src] if SOURCE_TAGS.key?(src)
+
+        down = src.downcase
+        return "job" if down.include?("activejob")
+        return "cable" if down.include?("actioncable")
+        return "request" if down.include?("actiondispatch") || down.include?("rack")
+
+        "error"
+      end
+
+      def process(exception, context, config, tag)
         fingerprint = Fingerprint.compute(exception)
         client = GithubClient.new(
           token: config.github_token,
@@ -43,11 +64,13 @@ module Eussiror
         existing_issue = client.find_issue(fingerprint)
 
         if existing_issue
-          client.add_comment(existing_issue, body: occurrence_comment)
+          client.add_comment(existing_issue, body: IssueFormatting.occurrence_comment(context, config))
         else
           client.create_issue(
-            title: issue_title(exception),
-            body: issue_body(exception, env, fingerprint),
+            title: issue_title(exception, tag),
+            body: IssueFormatting.issue_body(
+              exception, context, fingerprint, config, MAX_BACKTRACE_LINES, source_tag: tag
+            ),
             labels: config.labels,
             assignees: config.assignees
           )
@@ -56,60 +79,9 @@ module Eussiror
         warn "[Eussiror] Failed to report exception to GitHub: #{e.class}: #{e.message}"
       end
 
-      def issue_title(exception)
+      def issue_title(exception, tag)
         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.blank?
-
-        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")
+        "[#{tag}] #{exception.class}: #{message}"
       end
     end
   end

data/lib/eussiror/error_subscriber.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Eussiror
+  # Rails.error subscriber (ActiveSupport::ErrorReporter).
+  # Registered via Railtie so that Eussiror receives every unhandled exception
+  # regardless of origin (HTTP request, ActiveJob, Action Cable, Rake, etc.).
+  class ErrorSubscriber
+    def report(error, handled:, severity:, context:, source: "application")
+      return if handled && !Eussiror.configuration.report_handled_errors
+      return unless severity == :error
+
+      ErrorReporter.report(error, context, source: source)
+    end
+  end
+end

data/lib/eussiror/issue_formatting.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Eussiror
+  # Builds GitHub issue bodies and occurrence comments.
+  # Accepts either a Rack env hash or a plain Rails.error context hash.
+  module IssueFormatting
+    USER_ID_KEY    = "eussiror.user_id"
+    USER_LABEL_KEY = "eussiror.user_label"
+
+    class << self
+      def issue_body(exception, context, fingerprint, config, max_backtrace_lines, source_tag: "error")
+        normalized = ContextExtractor.normalize(context)
+        <<~BODY
+          #{error_details_section(exception)}
+          #{context_section(config, source_tag)}
+          #{user_section(normalized, config)}
+          #{request_section(normalized, config)}
+          ## Backtrace
+
+          ```
+          #{format_backtrace(exception, max_backtrace_lines)}
+          ```
+
+          <!-- #{GithubClient::FINGERPRINT_MARKER}:#{fingerprint} -->
+        BODY
+      end
+
+      def occurrence_comment(context, config)
+        normalized = ContextExtractor.normalize(context)
+        occurrence_lines(normalized, config).join("\n\n")
+      end
+
+      private
+
+      def format_backtrace(exception, max_lines)
+        (exception.backtrace || []).first(max_lines).join("\n")
+      end
+
+      def error_details_section(exception)
+        ts = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S UTC")
+        <<~SECTION
+          ## Error Details
+
+          **Exception:** `#{exception.class}`
+          **Message:** #{exception.message}
+          **First occurrence:** #{ts}
+        SECTION
+      end
+
+      def context_section(config, source_tag)
+        lines = ["**Environment:** `#{config.environment_name}`"]
+        lines << "**Source:** `#{source_tag}`" unless source_tag == "error"
+        rel = ReleaseEnv.label
+        lines << "**Release:** `#{rel}`" if rel
+
+        <<~SECTION
+
+          ## Context
+
+          #{lines.join("\n")}
+        SECTION
+      end
+
+      def user_section(normalized, config)
+        return "" unless config.issue_privacy == :full
+
+        uid   = normalized[:user_id]
+        label = normalized[:user_label]
+        return "" if string_blank?(uid) && string_blank?(label)
+
+        parts = []
+        parts << "**User id:** `#{uid}`" unless string_blank?(uid)
+        parts << "**User label:** #{label}" unless string_blank?(label)
+
+        <<~SECTION
+
+          ## User
+
+          #{parts.join("\n")}
+        SECTION
+      end
+
+      def request_section(normalized, config)
+        fragment = build_request_fragment(normalized, config)
+        return "" if string_blank?(fragment)
+
+        <<~SECTION
+
+          ## Request
+
+          #{fragment.strip}
+        SECTION
+      end
+
+      def build_request_fragment(normalized, config)
+        method = normalized[:request_method]
+        path   = normalized[:path]
+        return "" unless method && path
+
+        lines = ["**Request:** `#{method} #{path}`"]
+        return lines.join("\n") if config.issue_privacy == :minimal
+
+        append_ip_and_agent(lines, normalized)
+        lines.join("\n")
+      end
+
+      def append_ip_and_agent(lines, normalized)
+        ra = normalized[:remote_ip]
+        lines << "**Remote IP:** #{ra}" unless string_blank?(ra)
+        ua = normalized[:user_agent]
+        lines << "**User-Agent:** #{ua}" unless string_blank?(ua)
+      end
+
+      def occurrence_lines(normalized, config)
+        ts = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S UTC")
+        lines = ["**New occurrence:** #{ts}"]
+        req = request_summary_line(normalized)
+        lines << "**Request:** `#{req}`" if req
+        append_occurrence_privacy(lines, normalized, config)
+        lines
+      end
+
+      def append_occurrence_privacy(lines, normalized, config)
+        case config.issue_privacy
+        when :standard, :full
+          ra = normalized[:remote_ip]
+          lines << "**Remote IP:** #{ra}" unless string_blank?(ra)
+          ua = normalized[:user_agent]
+          lines << "**User-Agent:** #{ua}" unless string_blank?(ua)
+        end
+        return unless config.issue_privacy == :full
+
+        uid = normalized[:user_id]
+        lines << "**User id:** `#{uid}`" unless string_blank?(uid)
+      end
+
+      def request_summary_line(normalized)
+        method = normalized[:request_method]
+        path   = normalized[:path]
+        return nil unless method && path
+
+        "#{method} #{path}"
+      end
+
+      def string_blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+    end
+  end
+end

data/lib/eussiror/railtie.rb

@@ -4,10 +4,8 @@ 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
+    initializer "eussiror.subscribe_error_reporter" do
+      Rails.error.subscribe(Eussiror::ErrorSubscriber.new)
     end
   end
 end

data/lib/eussiror/release_env.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Eussiror
+  # First non-empty value wins. `RELEASE` is the explicit override; others are common PaaS/CI conventions.
+  module ReleaseEnv
+    KEYS = %w[
+      RELEASE
+      SOURCE_VERSION
+      HEROKU_SLUG_COMMIT
+      RAILWAY_GIT_COMMIT_SHA
+      RENDER_GIT_COMMIT
+      REVISION
+      GIT_COMMIT
+      CI_COMMIT_SHA
+      GITHUB_SHA
+    ].freeze
+
+    def self.label
+      KEYS.lazy.map { |k| ENV.fetch(k, nil) }.find { |v| v.to_s.strip.length.positive? }
+    end
+  end
+end

data/lib/eussiror/version.rb

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

data/lib/eussiror.rb

@@ -4,8 +4,11 @@ require "eussiror/version"
 require "eussiror/configuration"
 require "eussiror/fingerprint"
 require "eussiror/github_client"
+require "eussiror/release_env"
+require "eussiror/context_extractor"
+require "eussiror/issue_formatting"
 require "eussiror/error_reporter"
-require "eussiror/middleware"
+require "eussiror/error_subscriber"
 require "eussiror/railtie" if defined?(Rails::Railtie)
 
 module Eussiror

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

@@ -12,6 +12,25 @@ module Eussiror
       def create_initializer_file
         template "initializer.rb.tt", "config/initializers/eussiror.rb"
       end
+
+      def show_post_install_notice
+        say <<~NOTICE, :green
+
+          ================================================================================
+          Eussiror has been installed.
+          ================================================================================
+
+          Next steps:
+            1. Set GITHUB_TOKEN in your environment (never commit it to git).
+            2. Set config.github_repository to your target repo (owner/repo).
+            3. Adjust config.environments if needed (default: production only).
+            4. Review config.issue_privacy — :minimal is safest for public GitHub repos;
+               use :standard or :full only when issues are private to your team and you
+               accept request / user context in issue bodies.
+
+          See README.md for GitHub token setup, issue_privacy, and Rack env keys (eussiror.user_id).
+        NOTICE
+      end
     end
   end
 end

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

@@ -6,10 +6,19 @@ Eussiror.configure do |config|
   # Required: target GitHub repository in "owner/repository" format.
   config.github_repository = "your-org/your-repo"
 
-  # Environments where 500 errors will be reported to GitHub.
+  # Environments where errors will be reported to GitHub.
   # Default: ["production"]
   config.environments = %w[production]
 
+  # How much request/user context to include in issue bodies and occurrence comments.
+  # :minimal (default) — method + path only; safest for public repos.
+  # :standard — also Remote IP and User-Agent when present.
+  # :full — standard + User section from env["eussiror.user_id"] / ["eussiror.user_label"].
+  # config.issue_privacy = :minimal
+
+  # Also report errors caught by Rails.error.handle (default: false — only unhandled).
+  # config.report_handled_errors = false
+
   # Labels applied to every new issue created by Eussiror (optional).
   # config.labels = %w[bug automated]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eussiror
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Equipe Technique
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-26 00:00:00.000000000 Z
+date: 2026-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -25,10 +25,11 @@ dependencies:
       - !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.
+  Eussiror subscribes to Rails.error and automatically creates GitHub issues
+  when unhandled exceptions occur — whether in HTTP requests, ActiveJob,
+  Action Cable, or any other Rails execution context.
   If an issue already exists for the same error (identified by fingerprint),
-  it adds a comment with the new occurrence timestamp instead.
+  it adds a comment with the new occurrence instead.
 email: []
 executables: []
 extensions: []
@@ -39,11 +40,14 @@ files:
 - README.md
 - lib/eussiror.rb
 - lib/eussiror/configuration.rb
+- lib/eussiror/context_extractor.rb
 - lib/eussiror/error_reporter.rb
+- lib/eussiror/error_subscriber.rb
 - lib/eussiror/fingerprint.rb
 - lib/eussiror/github_client.rb
-- lib/eussiror/middleware.rb
+- lib/eussiror/issue_formatting.rb
 - lib/eussiror/railtie.rb
+- lib/eussiror/release_env.rb
 - lib/eussiror/version.rb
 - lib/generators/eussiror/install/install_generator.rb
 - lib/generators/eussiror/install/templates/initializer.rb.tt
@@ -73,5 +77,5 @@ requirements: []
 rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: Automatically create GitHub issues from Rails 500 errors
+summary: Automatically create GitHub issues from Rails exceptions
 test_files: []

data/lib/eussiror/middleware.rb

@@ -1,25 +0,0 @@
-# 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