error_track 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b0aafcfb135d31aacec7b653a3f5a05862c08a3d7340ed2bcf23280943cabc8f
+  data.tar.gz: 613a310ad2fb7b96521225806fa9dc9a2703607823f1f182b51236e7e736eb1a
+SHA512:
+  metadata.gz: c3346b12cd38a25d6006098646a1d27182986d3895fe5e289874c5b1a0975a519ad850fd9966a8133fedf1cec9302a2ecd23b0a036d8b1b634d4f5742f8726d2
+  data.tar.gz: 9ba6cbf434e9d11d1b26129de45156b630301578fd766eabbd0b156fa3bc127020dab56b890b79726b84dd630ebd1fdf281a1dba92389a1e41d29bdbec1a3986

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2026
+
+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,141 @@
+# ErrorTrack
+
+A self-hosted, Sentry/Honeybadger-style error tracker for Rails — except
+errors are logged to **your own app's database**, and shown at **`/errors`**.
+No external service, no API keys, no extra infrastructure.
+
+## Features
+
+- Automatically captures unhandled exceptions (Rack middleware) and errors
+  reported via Rails' built-in `Rails.error` reporter (retries, background
+  rescues, etc.)
+- Manual reporting API: `ErrorTrack.notify(exception, context: {...})`
+- Groups repeated occurrences of the same error together (like Sentry
+  "issues"), with a count, first-seen/last-seen timestamps
+- Stores backtrace + request context (URL, method, params, user) per
+  occurrence
+- `/errors` dashboard — a single self-contained page, hand-rolled with
+  vanilla JS and a Radix/Tailwind-inspired utility CSS. No Hotwire, no
+  React, no npm, no CDN, no build step. It talks to plain JSON endpoints
+  and polls lightly for live updates.
+- **Works the same in full-stack Rails apps and API-only Rails apps**
+  (`--api`), and on older Rails versions that don't have Hotwire installed.
+  CSRF/session usage is auto-detected and skipped entirely when there's no
+  session store in the middleware stack, so it never blows up in an
+  API-only app.
+- Zero required external services — just your existing database
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "error_track"
+```
+
+Then:
+
+```bash
+bundle install
+rails generate error_track:install
+rails db:migrate
+```
+
+This will:
+1. Add a migration creating `error_track_error_events` and `error_track_occurrences`
+2. Add `config/initializers/error_track.rb`
+3. Mount the engine at `/errors` in `config/routes.rb`
+
+Visit `/errors` in your running app — works identically whether your app
+is a normal Rails app or `config.api_only = true`.
+
+### API-only apps + a separate frontend (e.g. Next.js)
+
+If your Rails app is a pure JSON API and your actual product frontend
+lives elsewhere (Next.js, etc.), `/errors` still works out of the box: it's
+just an extra HTML route your Rails app happens to serve, independent of
+your API routes and independent of your Next.js app. Nothing about your
+API surface changes, and you don't need to build any dashboard UI into
+your Next.js app - just visit `yourapi.example.com/errors` directly (behind
+your own auth/VPN, see below).
+
+If you'd rather it live *inside* your Next.js app instead, the JSON
+endpoints (`GET /errors.json`, `GET /errors/:id.json`, etc. - see below)
+are plain JSON and CORS-friendly, so you could point a custom Next.js page
+at them instead of using the bundled HTML dashboard. That's more work than
+just visiting `/errors` though, and isn't required.
+
+## Securing the dashboard
+
+**This is important** — by default `/errors` has no auth and will show
+backtraces, params, and any user info you configure. Restrict it in
+`config/initializers/error_track.rb`, e.g.:
+
+```ruby
+Rails.application.config.to_prepare do
+  ErrorTrack::ErrorsController.class_eval do
+    before_action :authenticate_admin!   # your existing auth method
+  end
+end
+```
+
+or gate the route itself in `config/routes.rb`:
+
+```ruby
+authenticate :user, ->(u) { u.admin? } do
+  mount ErrorTrack::Engine => "/errors"
+end
+```
+
+For an API-only app with no session-based auth at all, HTTP basic auth is
+often simplest:
+
+```ruby
+Rails.application.config.to_prepare do
+  ErrorTrack::ErrorsController.class_eval do
+    http_basic_authenticate_with name: Rails.application.credentials.dig(:error_track, :user),
+                                  password: Rails.application.credentials.dig(:error_track, :password)
+  end
+end
+```
+
+## Manual reporting
+
+```ruby
+begin
+  risky_call
+rescue => e
+  ErrorTrack.notify(e, context: { user_id: current_user&.id, order_id: order.id })
+  # handle/re-raise as needed
+end
+```
+
+## JSON API
+
+The dashboard is powered by these endpoints (mounted relative to wherever
+you mount the engine, e.g. `/errors`):
+
+| Method | Path                    | Description                        |
+|--------|-------------------------|-------------------------------------|
+| GET    | `/errors.json`          | List, supports `?filter=unresolved\|resolved\|all` and `?page=` |
+| GET    | `/errors/:id.json`      | Single error group + recent occurrences |
+| POST   | `/errors/:id/resolve`   | Mark resolved                       |
+| POST   | `/errors/:id/reopen`    | Reopen                              |
+| DELETE | `/errors/:id`           | Delete an error group and its occurrences |
+
+## Configuration
+
+See the generated `config/initializers/error_track.rb` for all options:
+enabling/disabling capture per environment, ignored exception classes,
+a `current_user_resolver` for attaching user info to occurrences, and
+retention settings.
+
+## How grouping works
+
+Errors are fingerprinted from the exception class + the first backtrace
+line inside your app (with line numbers normalized out), so the same bug
+firing 500 times shows up as one row with a count of 500 — not 500 rows.
+
+## License
+
+MIT

data/app/controllers/error_track/errors_controller.rb

@@ -0,0 +1,118 @@
+module ErrorTrack
+  class ErrorsController < ActionController::Base
+    layout false
+
+    # CSRF protection (and the CSRF token/meta tags themselves) only work
+    # when a session store is actually in the middleware stack. API-only
+    # Rails apps strip out ActionDispatch::Session/Flash/Cookies by default,
+    # and touching the session without it raises. So we detect this once and
+    # skip CSRF entirely when there's no session backing it - this lets the
+    # same controller work in a full Rails app *and* an `--api` app with zero
+    # configuration.
+    SESSION_AVAILABLE = begin
+      Rails.application.middleware.any? { |m| m.klass.name.to_s.include?("Session") }
+    rescue
+      false
+    end
+
+    protect_from_forgery with: :exception if SESSION_AVAILABLE
+    helper_method :session_available? if respond_to?(:helper_method)
+
+    rescue_from ActiveRecord::RecordNotFound do
+      render json: { error: "not found" }, status: :not_found
+    end
+
+    # GET /errors            (HTML shell)
+    # GET /errors.json       (JSON list)
+    def index
+      scope = ErrorTrack::ErrorEvent.recent
+      scope = case params[:filter]
+              when "resolved" then scope.resolved
+              when "all" then scope
+              else scope.unresolved
+              end
+
+      page = [params[:page].to_i, 1].max
+      per_page = 25
+      total = scope.count
+      events = scope.offset((page - 1) * per_page).limit(per_page)
+
+      respond_to do |format|
+        format.html { render "error_track/errors/index" }
+        format.json do
+          render json: {
+            errors: events.map { |e| serialize_event(e) },
+            meta: {
+              page: page,
+              per_page: per_page,
+              total: total,
+              total_pages: (total.to_f / per_page).ceil
+            }
+          }
+        end
+      end
+    end
+
+    # GET /errors/:id.json
+    def show
+      event = ErrorTrack::ErrorEvent.find(params[:id])
+      occurrences = event.occurrences.recent.limit(20)
+
+      render json: serialize_event(event).merge(
+        occurrences: occurrences.map { |o| serialize_occurrence(o) }
+      )
+    end
+
+    # POST /errors/:id/resolve
+    def resolve
+      event = ErrorTrack::ErrorEvent.find(params[:id])
+      event.resolve!
+      render json: serialize_event(event)
+    end
+
+    # POST /errors/:id/reopen
+    def reopen
+      event = ErrorTrack::ErrorEvent.find(params[:id])
+      event.reopen!
+      render json: serialize_event(event)
+    end
+
+    # DELETE /errors/:id
+    def destroy
+      event = ErrorTrack::ErrorEvent.find(params[:id])
+      event.destroy
+      head :no_content
+    end
+
+    private
+
+    def session_available?
+      SESSION_AVAILABLE
+    end
+
+    def serialize_event(event)
+      {
+        id: event.id,
+        klass: event.klass,
+        message: event.message,
+        occurrences_count: event.occurrences_count,
+        resolved: event.resolved,
+        first_seen_at: event.first_seen_at,
+        last_seen_at: event.last_seen_at
+      }
+    end
+
+    def serialize_occurrence(occurrence)
+      {
+        id: occurrence.id,
+        occurred_at: occurrence.occurred_at,
+        backtrace: occurrence.backtrace,
+        environment: occurrence.environment,
+        url: occurrence.request_url,
+        method: occurrence.request_method,
+        params: occurrence.request_params,
+        user: occurrence.user_info
+      }
+    end
+  end
+end

data/app/models/error_track/application_record.rb

@@ -0,0 +1,5 @@
+module ErrorTrack
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/error_track/error_event.rb

@@ -0,0 +1,26 @@
+module ErrorTrack
+  class ErrorEvent < ApplicationRecord
+    self.table_name = "error_track_error_events"
+
+    has_many :occurrences, class_name: "ErrorTrack::Occurrence", dependent: :destroy, inverse_of: :error_event
+
+    validates :fingerprint, presence: true, uniqueness: true
+    validates :klass, presence: true
+
+    scope :unresolved, -> { where(resolved: false) }
+    scope :resolved, -> { where(resolved: true) }
+    scope :recent, -> { order(last_seen_at: :desc) }
+
+    def resolve!
+      update!(resolved: true)
+    end
+
+    def reopen!
+      update!(resolved: false)
+    end
+
+    def latest_occurrence
+      occurrences.order(occurred_at: :desc).first
+    end
+  end
+end

data/app/models/error_track/occurrence.rb

@@ -0,0 +1,28 @@
+module ErrorTrack
+  class Occurrence < ApplicationRecord
+    self.table_name = "error_track_occurrences"
+
+    belongs_to :error_event, class_name: "ErrorTrack::ErrorEvent", inverse_of: :occurrences
+
+    # `context` is a native :json column (see install generator migration),
+    # so Rails handles serialization automatically - no `serialize` needed.
+
+    scope :recent, -> { order(occurred_at: :desc) }
+
+    def request_url
+      context["url"] || context[:url]
+    end
+
+    def request_method
+      context["method"] || context[:method]
+    end
+
+    def request_params
+      context["params"] || context[:params]
+    end
+
+    def user_info
+      context["user"] || context[:user]
+    end
+  end
+end

data/app/views/error_track/errors/index.html.erb

@@ -0,0 +1,414 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <title>Errors</title>
+  <% if session_available? %>
+    <%= csrf_meta_tags %>
+  <% end %>
+  <style>
+    :root {
+      --gray-1:#fcfcfd; --gray-2:#f9f9fb; --gray-3:#f0f0f3; --gray-4:#e8e8ec;
+      --gray-5:#e0e1e6; --gray-6:#d9d9e0; --gray-7:#cdced6; --gray-8:#b9bbc6;
+      --gray-9:#8b8d98; --gray-10:#80828d; --gray-11:#60646c; --gray-12:#1c1f26;
+      --red-3:#feebec; --red-9:#e5484d; --red-11:#ce2c31;
+      --amber-3:#fff7d6; --amber-11:#a35200;
+      --green-3:#e6f6eb; --green-9:#30a46c; --green-11:#207c4f;
+      --accent-9:#3e63dd;
+      --radius-2:6px; --radius-3:10px;
+      --shadow-1:0 1px 2px rgba(0,0,0,.06);
+      --shadow-3:0 4px 16px rgba(0,0,0,.08),0 1px 3px rgba(0,0,0,.06);
+      --shadow-5:0 12px 36px rgba(0,0,0,.14),0 2px 6px rgba(0,0,0,.08);
+      --font: -apple-system,BlinkMacSystemFont,"Segoe UI",Inter,Helvetica,Arial,sans-serif;
+      --mono: ui-monospace,SFMono-Regular,Menlo,Consolas,"Liberation Mono",monospace;
+    }
+    * { box-sizing: border-box; }
+    html,body { margin:0; padding:0; }
+    body {
+      font-family: var(--font);
+      background: var(--gray-2);
+      color: var(--gray-12);
+      font-size: 14px;
+      line-height: 1.5;
+      -webkit-font-smoothing: antialiased;
+    }
+    a { color: inherit; }
+    button { font-family: inherit; font-size: inherit; }
+
+    .app { max-width: 880px; margin: 0 auto; padding: 0 20px 80px; }
+
+    .topbar {
+      display:flex; align-items:center; justify-content:space-between;
+      padding: 18px 0 16px; border-bottom: 1px solid var(--gray-5); margin-bottom: 20px;
+      position: sticky; top: 0; background: var(--gray-2); z-index: 10;
+    }
+    .brand { display:flex; align-items:center; gap:8px; font-weight:600; font-size:15px; }
+    .brand-dot { width:8px; height:8px; border-radius:50%; background: var(--accent-9); }
+    .status-line { color: var(--gray-10); font-size: 12.5px; display:flex; align-items:center; gap:6px; }
+    .pulse { width:6px; height:6px; border-radius:50%; background: var(--green-9); animation: pulse 2s infinite; }
+    @keyframes pulse { 0%,100%{opacity:1} 50%{opacity:.35} }
+
+    .tabs { display:flex; gap:4px; background: var(--gray-3); padding:3px; border-radius: var(--radius-3); width: fit-content; margin-bottom:16px; }
+    .tab {
+      border:none; background:transparent; padding:6px 14px; border-radius: var(--radius-2);
+      cursor:pointer; color: var(--gray-11); font-weight:500;
+    }
+    .tab[aria-selected="true"] { background:#fff; color: var(--gray-12); box-shadow: var(--shadow-1); }
+
+    .list { list-style:none; margin:0; padding:0; display:flex; flex-direction:column; gap:8px; }
+    .row {
+      background:#fff; border:1px solid var(--gray-5); border-radius: var(--radius-3);
+      padding: 14px 16px; cursor:pointer; transition: box-shadow .12s, border-color .12s;
+      display:flex; justify-content:space-between; align-items:center; gap:12px;
+    }
+    .row:hover { box-shadow: var(--shadow-3); border-color: var(--gray-7); }
+    .row.resolved { opacity:.55; }
+    .row-main { min-width:0; }
+    .klass { font-family: var(--mono); font-size:12px; color: var(--red-11); background: var(--red-3); padding:1px 7px; border-radius:999px; display:inline-block; margin-bottom:5px; }
+    .msg { font-weight:500; color: var(--gray-12); white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
+    .meta { color: var(--gray-9); font-size:12px; margin-top:3px; }
+    .row-side { display:flex; align-items:center; gap:8px; flex-shrink:0; }
+    .badge { font-size:11.5px; font-weight:600; padding:2px 9px; border-radius:999px; background: var(--amber-3); color: var(--amber-11); }
+    .badge.resolved { background: var(--green-3); color: var(--green-11); }
+
+    .empty { text-align:center; color: var(--gray-9); padding: 80px 20px; }
+    .empty-emoji { font-size:32px; margin-bottom:10px; }
+
+    .pager { display:flex; justify-content:center; gap:10px; align-items:center; margin-top:20px; color: var(--gray-10); font-size:13px; }
+    .pager button { border:1px solid var(--gray-6); background:#fff; border-radius: var(--radius-2); padding:5px 10px; cursor:pointer; }
+    .pager button:disabled { opacity:.4; cursor:default; }
+
+    .skeleton { background: linear-gradient(90deg,var(--gray-4) 25%,var(--gray-3) 37%,var(--gray-4) 63%); background-size:400% 100%; animation: sk 1.4s ease infinite; border-radius: var(--radius-3); height:58px; }
+    @keyframes sk { 0%{background-position:100% 50%} 100%{background-position:0 50%} }
+
+    .overlay { position:fixed; inset:0; background: rgba(20,20,25,.35); opacity:0; pointer-events:none; transition:opacity .15s; z-index:20; }
+    .overlay.open { opacity:1; pointer-events:auto; }
+
+    .panel {
+      position:fixed; top:0; right:0; bottom:0; width:100%; max-width:560px;
+      background:#fff; box-shadow: var(--shadow-5); transform: translateX(100%);
+      transition: transform .18s ease; z-index:21; display:flex; flex-direction:column;
+    }
+    .panel.open { transform: translateX(0); }
+    .panel-head { padding:18px 20px; border-bottom:1px solid var(--gray-5); display:flex; justify-content:space-between; align-items:flex-start; gap:12px; }
+    .panel-body { padding:20px; overflow-y:auto; flex:1; }
+    .panel-close { border:none; background: var(--gray-3); width:28px; height:28px; border-radius:50%; cursor:pointer; font-size:15px; color: var(--gray-11); flex-shrink:0; }
+    .panel-close:hover { background: var(--gray-4); }
+
+    .section-title { font-size:11.5px; font-weight:700; text-transform:uppercase; letter-spacing:.04em; color: var(--gray-9); margin: 20px 0 8px; }
+    .section-title:first-child { margin-top:0; }
+    .code {
+      background: var(--gray-12); color: #e5e7eb; font-family: var(--mono); font-size:12px;
+      padding:14px; border-radius: var(--radius-3); overflow-x:auto; white-space:pre; line-height:1.6;
+    }
+    .kv { display:grid; grid-template-columns:90px 1fr; gap:6px 10px; font-size:13px; }
+    .kv dt { color: var(--gray-9); }
+    .kv dd { margin:0; word-break:break-word; }
+
+    .btn { border:1px solid var(--gray-6); background:#fff; border-radius: var(--radius-2); padding:7px 13px; cursor:pointer; font-weight:500; }
+    .btn:hover { background: var(--gray-3); }
+    .btn.primary { background: var(--gray-12); border-color: var(--gray-12); color:#fff; }
+    .btn.primary:hover { background:#333; }
+    .btn.danger { color: var(--red-11); border-color: var(--red-9); }
+    .btn.danger:hover { background: var(--red-3); }
+    .actions { display:flex; gap:8px; margin-top:16px; }
+
+    table.occ { width:100%; border-collapse:collapse; font-size:12.5px; }
+    table.occ th { text-align:left; color: var(--gray-9); font-weight:600; padding:6px 8px; border-bottom:1px solid var(--gray-5); }
+    table.occ td { padding:6px 8px; border-bottom:1px solid var(--gray-4); font-family: var(--mono); }
+
+    .toast {
+      position:fixed; bottom:20px; left:50%; transform:translateX(-50%) translateY(10px);
+      background: var(--gray-12); color:#fff; padding:9px 16px; border-radius: var(--radius-3);
+      font-size:13px; opacity:0; pointer-events:none; transition:.15s; z-index:30; box-shadow: var(--shadow-3);
+    }
+    .toast.show { opacity:1; transform:translateX(-50%) translateY(0); }
+  </style>
+</head>
+<body>
+  <div class="app">
+    <div class="topbar">
+      <div class="brand"><span class="brand-dot"></span> Errors</div>
+      <div class="status-line"><span class="pulse"></span> <span id="last-refreshed">loading&hellip;</span></div>
+    </div>
+
+    <div class="tabs" role="tablist">
+      <button class="tab" data-filter="unresolved" role="tab">Unresolved</button>
+      <button class="tab" data-filter="resolved" role="tab">Resolved</button>
+      <button class="tab" data-filter="all" role="tab">All</button>
+    </div>
+
+    <ul class="list" id="list"></ul>
+    <div class="pager" id="pager" style="display:none"></div>
+  </div>
+
+  <div class="overlay" id="overlay"></div>
+  <aside class="panel" id="panel" aria-hidden="true">
+    <div class="panel-head">
+      <div>
+        <div class="klass" id="p-klass"></div>
+        <div style="font-weight:600; margin-top:6px;" id="p-message"></div>
+        <div class="meta" id="p-meta"></div>
+      </div>
+      <button class="panel-close" id="p-close" aria-label="Close">&times;</button>
+    </div>
+    <div class="panel-body">
+      <div class="actions" id="p-actions"></div>
+
+      <div class="section-title">Latest backtrace</div>
+      <div class="code" id="p-backtrace"></div>
+
+      <div id="p-request-wrap" style="display:none">
+        <div class="section-title">Request</div>
+        <dl class="kv" id="p-request"></dl>
+      </div>
+
+      <div class="section-title">Recent occurrences</div>
+      <table class="occ">
+        <thead><tr><th>When</th><th>Method</th><th>URL</th></tr></thead>
+        <tbody id="p-occurrences"></tbody>
+      </table>
+    </div>
+  </aside>
+
+  <div class="toast" id="toast"></div>
+
+  <script>
+  (function () {
+    "use strict";
+
+    var base = window.location.pathname.replace(/\/+$/, "");
+    var csrfToken = (document.querySelector('meta[name="csrf-token"]') || {}).content;
+
+    var state = { filter: "unresolved", page: 1, pollTimer: null, panelOpen: false };
+
+    var els = {
+      list: document.getElementById("list"),
+      pager: document.getElementById("pager"),
+      tabs: document.querySelectorAll(".tab"),
+      lastRefreshed: document.getElementById("last-refreshed"),
+      overlay: document.getElementById("overlay"),
+      panel: document.getElementById("panel"),
+      pClose: document.getElementById("p-close"),
+      pKlass: document.getElementById("p-klass"),
+      pMessage: document.getElementById("p-message"),
+      pMeta: document.getElementById("p-meta"),
+      pActions: document.getElementById("p-actions"),
+      pBacktrace: document.getElementById("p-backtrace"),
+      pRequestWrap: document.getElementById("p-request-wrap"),
+      pRequest: document.getElementById("p-request"),
+      pOccurrences: document.getElementById("p-occurrences"),
+      toast: document.getElementById("toast")
+    };
+
+    function api(path, opts) {
+      opts = opts || {};
+      var headers = Object.assign({ "Accept": "application/json" }, opts.headers || {});
+      if (opts.method && opts.method !== "GET" && csrfToken) {
+        headers["X-CSRF-Token"] = csrfToken;
+      }
+      return fetch(base + path, Object.assign({}, opts, { headers: headers }))
+        .then(function (res) {
+          if (!res.ok && res.status !== 204) throw new Error("Request failed: " + res.status);
+          if (res.status === 204) return null;
+          return res.json();
+        });
+    }
+
+    function escapeHtml(str) {
+      var div = document.createElement("div");
+      div.textContent = str == null ? "" : String(str);
+      return div.innerHTML;
+    }
+
+    function timeAgo(iso) {
+      if (!iso) return "\u2014";
+      var diff = (Date.now() - new Date(iso).getTime()) / 1000;
+      if (diff < 60) return Math.max(1, Math.floor(diff)) + "s ago";
+      if (diff < 3600) return Math.floor(diff / 60) + "m ago";
+      if (diff < 86400) return Math.floor(diff / 3600) + "h ago";
+      return Math.floor(diff / 86400) + "d ago";
+    }
+
+    function showToast(msg) {
+      els.toast.textContent = msg;
+      els.toast.classList.add("show");
+      setTimeout(function () { els.toast.classList.remove("show"); }, 1800);
+    }
+
+    function renderTabs() {
+      els.tabs.forEach(function (tab) {
+        tab.setAttribute("aria-selected", tab.dataset.filter === state.filter ? "true" : "false");
+      });
+    }
+
+    function renderSkeleton() {
+      els.list.innerHTML = "";
+      for (var i = 0; i < 4; i++) {
+        var li = document.createElement("li");
+        li.className = "skeleton";
+        els.list.appendChild(li);
+      }
+    }
+
+    function renderList(data) {
+      els.list.innerHTML = "";
+
+      if (!data.errors.length) {
+        els.list.innerHTML =
+          '<div class="empty"><div class="empty-emoji">&#127881;</div>No ' +
+          (state.filter === "all" ? "" : escapeHtml(state.filter) + " ") +
+          "errors.</div>";
+        els.pager.style.display = "none";
+        return;
+      }
+
+      data.errors.forEach(function (e) {
+        var li = document.createElement("li");
+        li.className = "row" + (e.resolved ? " resolved" : "");
+        li.dataset.id = e.id;
+        li.innerHTML =
+          '<div class="row-main">' +
+            '<div class="klass">' + escapeHtml(e.klass) + "</div>" +
+            '<div class="msg">' + escapeHtml(e.message || "(no message)") + "</div>" +
+            '<div class="meta">last seen ' + timeAgo(e.last_seen_at) + " &middot; first seen " + timeAgo(e.first_seen_at) + "</div>" +
+          "</div>" +
+          '<div class="row-side">' +
+            (e.resolved ? '<span class="badge resolved">resolved</span>' : "") +
+            '<span class="badge">' + e.occurrences_count + "&times;</span>" +
+          "</div>";
+        li.addEventListener("click", function () { openPanel(e.id); });
+        els.list.appendChild(li);
+      });
+
+      renderPager(data.meta);
+    }
+
+    function renderPager(meta) {
+      if (meta.total_pages <= 1) { els.pager.style.display = "none"; return; }
+      els.pager.style.display = "flex";
+      els.pager.innerHTML =
+        '<button id="prev" ' + (meta.page <= 1 ? "disabled" : "") + ">&larr; Prev</button>" +
+        "<span>Page " + meta.page + " of " + meta.total_pages + "</span>" +
+        '<button id="next" ' + (meta.page >= meta.total_pages ? "disabled" : "") + ">Next &rarr;</button>";
+      var prev = document.getElementById("prev"), next = document.getElementById("next");
+      if (prev) prev.addEventListener("click", function () { state.page--; load(); });
+      if (next) next.addEventListener("click", function () { state.page++; load(); });
+    }
+
+    function load(opts) {
+      opts = opts || {};
+      if (!opts.silent) renderSkeleton();
+      return api("?filter=" + encodeURIComponent(state.filter) + "&page=" + state.page)
+        .then(function (data) {
+          renderList(data);
+          els.lastRefreshed.textContent = "updated " + new Date().toLocaleTimeString();
+        })
+        .catch(function () {
+          els.lastRefreshed.textContent = "couldn't refresh";
+        });
+    }
+
+    function openPanel(id) {
+      state.panelOpen = true;
+      els.overlay.classList.add("open");
+      els.panel.classList.add("open");
+      els.panel.setAttribute("aria-hidden", "false");
+      els.pBacktrace.textContent = "Loading\u2026";
+      els.pOccurrences.innerHTML = "";
+      els.pRequestWrap.style.display = "none";
+
+      api("/" + id).then(function (e) {
+        els.pKlass.textContent = e.klass;
+        els.pMessage.textContent = e.message || "(no message)";
+        els.pMeta.textContent = e.occurrences_count + " occurrences \u00b7 first seen " +
+          timeAgo(e.first_seen_at) + " \u00b7 last seen " + timeAgo(e.last_seen_at);
+
+        els.pActions.innerHTML = e.resolved
+          ? '<button class="btn primary" id="reopen-btn">Reopen</button>'
+          : '<button class="btn primary" id="resolve-btn">Resolve</button>';
+        els.pActions.innerHTML += '<button class="btn danger" id="delete-btn">Delete</button>';
+
+        var resolveBtn = document.getElementById("resolve-btn");
+        var reopenBtn = document.getElementById("reopen-btn");
+        var deleteBtn = document.getElementById("delete-btn");
+        if (resolveBtn) resolveBtn.addEventListener("click", function () { mutate(id, "resolve"); });
+        if (reopenBtn) reopenBtn.addEventListener("click", function () { mutate(id, "reopen"); });
+        if (deleteBtn) deleteBtn.addEventListener("click", function () { destroyError(id); });
+
+        var latest = e.occurrences[0];
+        els.pBacktrace.textContent = latest ? latest.backtrace : "(no occurrences recorded)";
+
+        if (latest && latest.url) {
+          els.pRequestWrap.style.display = "block";
+          els.pRequest.innerHTML =
+            "<dt>URL</dt><dd>" + escapeHtml(latest.url) + "</dd>" +
+            "<dt>Method</dt><dd>" + escapeHtml(latest.method) + "</dd>" +
+            (latest.user ? "<dt>User</dt><dd>" + escapeHtml(JSON.stringify(latest.user)) + "</dd>" : "");
+        }
+
+        els.pOccurrences.innerHTML = e.occurrences.map(function (o) {
+          return "<tr><td>" + escapeHtml(o.occurred_at) + "</td><td>" + escapeHtml(o.method) +
+            "</td><td>" + escapeHtml(o.url) + "</td></tr>";
+        }).join("");
+      });
+    }
+
+    function closePanel() {
+      state.panelOpen = false;
+      els.overlay.classList.remove("open");
+      els.panel.classList.remove("open");
+      els.panel.setAttribute("aria-hidden", "true");
+    }
+
+    function mutate(id, action) {
+      api("/" + id + "/" + action, { method: "POST" }).then(function () {
+        showToast(action === "resolve" ? "Marked as resolved" : "Reopened");
+        closePanel();
+        load({ silent: true });
+      });
+    }
+
+    function destroyError(id) {
+      if (!window.confirm("Delete this error and all its occurrences?")) return;
+      api("/" + id, { method: "DELETE" }).then(function () {
+        showToast("Deleted");
+        closePanel();
+        load({ silent: true });
+      });
+    }
+
+    els.tabs.forEach(function (tab) {
+      tab.addEventListener("click", function () {
+        state.filter = tab.dataset.filter;
+        state.page = 1;
+        renderTabs();
+        load();
+      });
+    });
+
+    els.pClose.addEventListener("click", closePanel);
+    els.overlay.addEventListener("click", closePanel);
+    document.addEventListener("keydown", function (ev) {
+      if (ev.key === "Escape" && state.panelOpen) closePanel();
+    });
+
+    // Lightweight polling instead of Hotwire/ActionCable - keeps this
+    // dependency-free and works the same for API-only Rails apps.
+    function startPolling() {
+      if (state.pollTimer) clearInterval(state.pollTimer);
+      state.pollTimer = setInterval(function () {
+        if (document.visibilityState === "visible" && !state.panelOpen) {
+          load({ silent: true });
+        }
+      }, 10000);
+    }
+
+    renderTabs();
+    load();
+    startPolling();
+  })();
+  </script>
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,15 @@
+ErrorTrack::Engine.routes.draw do
+  # Mounted with path: "" so the engine's own root becomes the index,
+  # e.g. `mount ErrorTrack::Engine => "/errors"` gives you:
+  #   GET    /errors            -> index (HTML shell, or JSON with .json / Accept: json)
+  #   GET    /errors/:id        -> show  (JSON)
+  #   POST   /errors/:id/resolve -> resolve (JSON)
+  #   POST   /errors/:id/reopen  -> reopen  (JSON)
+  #   DELETE /errors/:id        -> destroy (JSON)
+  resources :errors, only: [:index, :show, :destroy], path: "" do
+    member do
+      post :resolve
+      post :reopen
+    end
+  end
+end

data/lib/error_track/configuration.rb

@@ -0,0 +1,39 @@
+module ErrorTrack
+  class Configuration
+    # Toggle capturing on/off (e.g. disable in test env)
+    attr_accessor :enabled
+
+    # Exception classes that should never be recorded
+    attr_accessor :ignored_exceptions
+
+    # Request param keys to scrub before storing (e.g. :password, :token)
+    attr_accessor :filtered_params
+
+    # Proc called with (record) -> current user info hash, e.g.
+    #   config.current_user_resolver = ->(request) {
+    #     user = request.env["warden"]&.user
+    #     { id: user&.id, email: user&.email }
+    #   }
+    attr_accessor :current_user_resolver
+
+    # How many days to keep resolved errors before they can be purged
+    # (purging itself is left to the host app via a rake task, this is just config)
+    attr_accessor :retention_days
+
+    def initialize
+      @enabled = true
+      @ignored_exceptions = [
+        "ActionController::RoutingError",
+        "ActiveRecord::RecordNotFound",
+        "ActionController::InvalidAuthenticityToken"
+      ]
+      @filtered_params = %w[password password_confirmation token secret api_key]
+      @current_user_resolver = nil
+      @retention_days = 30
+    end
+
+    def ignored?(exception)
+      ignored_exceptions.include?(exception.class.name)
+    end
+  end
+end

data/lib/error_track/engine.rb

@@ -0,0 +1,33 @@
+require "rails/engine"
+
+module ErrorTrack
+  class Engine < ::Rails::Engine
+    isolate_namespace ErrorTrack
+
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+    # Catch anything that bubbles all the way up unhandled.
+    initializer "error_track.middleware" do |app|
+      app.middleware.insert_after ActionDispatch::ShowExceptions, ErrorTrack::Middleware
+    end
+
+    # Also subscribe to Rails' built-in error reporter (Rails 7+), so
+    # errors reported via `Rails.error.handle` / `Rails.error.record`
+    # (e.g. from ActiveJob retries, background rescues, etc.) get logged too.
+    initializer "error_track.rails_error_subscriber" do
+      ActiveSupport.on_load(:action_controller) do
+        if defined?(Rails.error) && Rails.error.respond_to?(:subscribe)
+          Rails.error.subscribe(ErrorTrack::RailsErrorSubscriber.new)
+        end
+      end
+    end
+  end
+
+  class RailsErrorSubscriber
+    def report(error, handled:, severity:, context:, source: nil)
+      ErrorTrack.notify(error, context: context.merge(handled: handled, severity: severity, source: source))
+    end
+  end
+end

data/lib/error_track/middleware.rb

@@ -0,0 +1,46 @@
+module ErrorTrack
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => e
+      request = ActionDispatch::Request.new(env)
+      ErrorTrack.notify(e, context: request_context(request))
+      raise
+    end
+
+    private
+
+    def request_context(request)
+      {
+        url: request.original_url,
+        method: request.request_method,
+        params: filtered_params(request),
+        user_agent: request.user_agent,
+        remote_ip: (request.remote_ip rescue nil),
+        user: current_user_info(request)
+      }
+    rescue
+      {}
+    end
+
+    def filtered_params(request)
+      params = request.filtered_parameters
+      params
+    rescue
+      {}
+    end
+
+    def current_user_info(request)
+      resolver = ErrorTrack.configuration.current_user_resolver
+      return nil unless resolver
+
+      resolver.call(request)
+    rescue
+      nil
+    end
+  end
+end

data/lib/error_track/notifier.rb

@@ -0,0 +1,47 @@
+require "digest"
+
+module ErrorTrack
+  class Notifier
+    def call(exception, context: {})
+      return unless ErrorTrack.configuration.enabled
+      return if ErrorTrack.configuration.ignored?(exception)
+
+      fingerprint = generate_fingerprint(exception)
+
+      event = ErrorTrack::ErrorEvent.transaction do
+        e = ErrorTrack::ErrorEvent.lock.find_or_initialize_by(fingerprint: fingerprint)
+        e.klass ||= exception.class.name
+        e.message = exception.message.to_s.truncate(1000)
+        e.first_seen_at ||= Time.current
+        e.last_seen_at = Time.current
+        e.occurrences_count = e.occurrences_count.to_i + 1
+        e.resolved = false if e.resolved?
+        e.save!
+        e
+      end
+
+      event.occurrences.create!(
+        backtrace: Array(exception.backtrace).first(50).join("\n"),
+        context: context.presence || {},
+        environment: defined?(Rails) ? Rails.env.to_s : nil,
+        occurred_at: Time.current
+      )
+
+      event
+    rescue => e
+      # Never let error tracking itself break the host app.
+      Rails.logger&.error("[ErrorTrack] failed to record exception: #{e.class} #{e.message}") if defined?(Rails)
+      nil
+    end
+
+    private
+
+    # Group by exception class + the first "in-app-ish" backtrace line,
+    # normalized so line numbers don't fragment identical errors.
+    def generate_fingerprint(exception)
+      top_line = Array(exception.backtrace).first(5).find { |l| l.include?("/app/") } || Array(exception.backtrace).first
+      normalized_line = top_line.to_s.gsub(/:\d+:in/, ":in").gsub(/:\d+\z/, "")
+      Digest::SHA256.hexdigest("#{exception.class.name}|#{normalized_line}")
+    end
+  end
+end

data/lib/error_track/version.rb

@@ -0,0 +1,3 @@
+module ErrorTrack
+  VERSION = "0.1.0"
+end

data/lib/error_track.rb

@@ -0,0 +1,28 @@
+require "error_track/version"
+require "error_track/configuration"
+require "error_track/notifier"
+require "error_track/middleware"
+require "error_track/engine"
+
+module ErrorTrack
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    # Public API for manually reporting a rescued exception.
+    #
+    #   begin
+    #     risky_call
+    #   rescue => e
+    #     ErrorTrack.notify(e, context: { user_id: current_user.id })
+    #   end
+    def notify(exception, context: {})
+      Notifier.new.call(exception, context: context)
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require "rails/generators"
+require "rails/generators/migration"
+
+module ErrorTrack
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      include ::Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Installs ErrorTrack: copies the migration, initializer, and mounts the engine."
+
+      def self.next_migration_number(dirname)
+        ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def copy_migration
+        migration_template "create_error_track_tables.rb.erb",
+                            "db/migrate/create_error_track_tables.rb"
+      end
+
+      def copy_initializer
+        template "error_track.rb", "config/initializers/error_track.rb"
+      end
+
+      def mount_engine
+        route 'mount ErrorTrack::Engine => "/errors"'
+      end
+
+      def show_readme
+        say ""
+        say "ErrorTrack installed! Next steps:", :green
+        say "  1. rails db:migrate"
+        say "  2. Visit /errors in your app"
+        say "  3. (Recommended) Restrict access in config/initializers/error_track.rb"
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/error_track/install/templates/create_error_track_tables.rb.erb

@@ -0,0 +1,29 @@
+class CreateErrorTrackTables < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :error_track_error_events do |t|
+      t.string   :fingerprint, null: false
+      t.string   :klass, null: false
+      t.text     :message
+      t.integer  :occurrences_count, null: false, default: 0
+      t.boolean  :resolved, null: false, default: false
+      t.datetime :first_seen_at
+      t.datetime :last_seen_at
+
+      t.timestamps
+    end
+    add_index :error_track_error_events, :fingerprint, unique: true
+    add_index :error_track_error_events, :last_seen_at
+    add_index :error_track_error_events, :resolved
+
+    create_table :error_track_occurrences do |t|
+      t.references :error_event, null: false, foreign_key: { to_table: :error_track_error_events }
+      t.text     :backtrace
+      t.json     :context
+      t.string   :environment
+      t.datetime :occurred_at
+
+      t.timestamps
+    end
+    add_index :error_track_occurrences, :occurred_at
+  end
+end

data/lib/generators/error_track/install/templates/error_track.rb

@@ -0,0 +1,36 @@
+ErrorTrack.configure do |config|
+  # Turn capturing off entirely (e.g. in test env)
+  # config.enabled = !Rails.env.test?
+
+  # Exception classes to never record
+  # config.ignored_exceptions += ["MyApp::ExpectedError"]
+
+  # Resolve the current user for context on each occurrence.
+  # Called with the ActionDispatch::Request.
+  # config.current_user_resolver = ->(request) {
+  #   user = request.env["warden"]&.user
+  #   { id: user&.id, email: user&.email } if user
+  # }
+
+  # Days to retain resolved errors (informational; wire up your own
+  # cleanup rake task/cron using this if desired)
+  # config.retention_days = 30
+end
+
+# Restrict access to the /errors dashboard - IMPORTANT for anything
+# beyond local development. Example using an admin auth method:
+#
+# Rails.application.config.to_prepare do
+#   ErrorTrack::ErrorsController.class_eval do
+#     before_action :authenticate_admin!
+#   end
+# end
+#
+# Or with HTTP basic auth:
+#
+# Rails.application.config.to_prepare do
+#   ErrorTrack::ErrorsController.class_eval do
+#     http_basic_authenticate_with name: Rails.application.credentials.dig(:error_track, :user),
+#                                   password: Rails.application.credentials.dig(:error_track, :password)
+#   end
+# end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: error_track
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aditya Pandit
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A mountable Rails engine that captures unhandled and manually-reported
+  exceptions, groups them like Sentry/Honeybadger, stores them in your app's own database,
+  and gives you a dependency-free dashboard at /errors (vanilla JS, no Hotwire/React/build
+  step required). Works in full-stack Rails apps and API-only apps alike.
+email:
+- adityapandit38@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- app/controllers/error_track/errors_controller.rb
+- app/models/error_track/application_record.rb
+- app/models/error_track/error_event.rb
+- app/models/error_track/occurrence.rb
+- app/views/error_track/errors/index.html.erb
+- config/routes.rb
+- lib/error_track.rb
+- lib/error_track/configuration.rb
+- lib/error_track/engine.rb
+- lib/error_track/middleware.rb
+- lib/error_track/notifier.rb
+- lib/error_track/version.rb
+- lib/generators/error_track/install/install_generator.rb
+- lib/generators/error_track/install/templates/create_error_track_tables.rb.erb
+- lib/generators/error_track/install/templates/error_track.rb
+homepage: https://github.com/adityapandit17/error_track
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/adityapandit17/error_track
+  source_code_uri: https://github.com/adityapandit17/error_track
+  allowed_push_host: https://rubygems.org
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.17
+specification_version: 4
+summary: 'Self-hosted error tracking for Rails: logs exceptions to your own DB and
+  shows them at /errors.'
+test_files: []