Rails Error Dashboard

Self-hosted Rails error monitoring — free, forever.

gem 'rails_error_dashboard'

5-minute setup · Works out-of-the-box · 100% Rails + Postgres · No vendor lock-in

Full Documentation · Live Demo · RubyGems

Try the Live Demo

rails-error-dashboard.anjan.dev — Username: gandalf · Password: youshallnotpass

Beta Software — Functional and tested (2,700+ tests passing), but the API may change before v1.0. Supports Rails 7.0-8.1 and Ruby 3.2-4.0.

Screenshots

Dashboard Overview — Real-time error stats, severity breakdown, and trend charts.

Dashboard Overview

Error Detail — Full stack trace, cause chain, enriched context, and workflow management.

Error Detail

Who This Is For

Solo bootstrappers who need professional error tracking without recurring costs
Indie SaaS founders building profitable apps on tight budgets
Small dev teams (2-5 people) who hate SaaS bloat
Privacy-conscious apps that need to keep error data on their own servers
Side projects that might become real businesses

What It Replaces

Before	After
$29-99/month for error monitoring	$0/month — runs on your existing Rails server
Sensitive error data sent to third parties	All data stays on your infrastructure
SaaS pricing tiers and usage limits	Unlimited errors, unlimited projects
Vendor lock-in with proprietary APIs	100% open source, fully portable
Complex SDK setup and external services	5-minute Rails Engine installation
Pay extra for local variable capture (Sentry)	Local + instance variables included free
No tool detects silently rescued exceptions	Swallowed exception detection built in

Features

Core (Always Enabled)

Error capture from controllers, jobs, and middleware. Beautiful Bootstrap 5 dashboard with dark/light mode, search, filtering, and real-time updates. Analytics with trend charts, severity breakdown, and spike detection. Workflow management with assignment, priority, snooze, mute/unmute (notification suppression), comments, and batch operations. Security via HTTP Basic Auth or custom lambda (Devise, Warden, session-based). Exception cause chains, enriched HTTP context, custom fingerprinting, CurrentAttributes integration, auto-reopen on recurrence, and sensitive data filtering — all built in.

Optional Features

Breadcrumbs — Request Activity Trail

See exactly what happened before the crash — SQL queries, controller actions, cache operations, job executions, and mailer deliveries captured automatically via `ActiveSupport::Notifications`. - Automatic capture — zero config beyond the enable flag - N+1 query detection with aggregate patterns page - Deprecation warnings with aggregate view - Custom breadcrumbs via `RailsErrorDashboard.add_breadcrumb("checkout started", { cart_id: 123 })` - Safe by design — fixed-size ring buffer, thread-local, every subscriber wrapped in rescue ```ruby config.enable_breadcrumbs = true ``` [Complete documentation →](docs/FEATURES.md#breadcrumbs--request-activity-trail-new)

System Health Snapshot

Know your app's runtime state at the moment of failure — GC stats, process memory, thread count, connection pool utilization, Puma thread stats, RubyVM cache health, YJIT compilation stats, and deep runtime insights captured automatically. - Sub-millisecond total snapshot, every metric individually rescue-wrapped - No ObjectSpace scanning, no Thread backtraces, no subprocess calls - RubyVM.stat: constant cache invalidations, shape cache stats - YJIT runtime stats: compiled iseqs, invalidation count, code region sizes - **v0.5.2** — File descriptor utilization, system load averages, system memory pressure, TCP connection states, GC context (trigger reason, last major/minor), process swap and peak RSS — all with color-coded danger indicators ```ruby config.enable_system_health = true ``` [Complete documentation →](docs/FEATURES.md#system-health-snapshot-new)

N+1 Detection + Deprecation Warnings

Cross-error N+1 detection grouped by SQL fingerprint, and aggregate deprecation warnings with occurrence counts. ![Deprecation Warnings](docs/images/deprecations.png) ![N+1 Query Patterns](docs/images/n-plus-one-queries.png) Requires breadcrumbs to be enabled. [Complete documentation →](docs/FEATURES.md#n1-query-detection)

Operational Health Panels — Jobs, Database, Cache, ActionCable

**Job Health** — Auto-detects Sidekiq, SolidQueue, or GoodJob. Per-error table with adapter badge, failed count (color-coded), sorted worst-first. ![Job Health](docs/images/job-health.png) **Database Health** — PgHero-style live PostgreSQL stats (table sizes, unused indexes, dead tuples, vacuum timestamps) plus historical connection pool data from error snapshots. ![Database Health](docs/images/database-health.png) **Cache Health** — Per-error cache performance sorted worst-first. ![Cache Health](docs/images/cache-health.png) **ActionCable Health** — Track WebSocket channel actions, transmissions, subscription confirmations, and rejections. Dashboard page at `/errors/actioncable_health_summary` with channel breakdown sorted by rejections. System health snapshot captures live connection count and adapter. ```ruby config.enable_actioncable_tracking = true # requires enable_breadcrumbs = true ``` **ActiveStorage Health** — Track file uploads, downloads, deletes, and existence checks across storage services (Disk, S3, GCS, Azure — any ActiveStorage backend). Dashboard page at `/errors/activestorage_health_summary` with per-service operation counts, average and slowest durations. Helps identify slow storage operations correlating with errors. ```ruby config.enable_activestorage_tracking = true # requires enable_breadcrumbs = true ``` [Complete documentation →](docs/FEATURES.md#job-health-page)

Issue Tracking — GitHub, GitLab, Codeberg

One switch connects errors to your issue tracker. Platform becomes the source of truth — status, assignees, labels, and comments are mirrored live in the dashboard. - **Create & link:** "Create Issue" button or paste an existing URL - **Auto-create:** New errors auto-create issues. Critical/high severity always creates - **Lifecycle sync:** Resolve → close, recur → reopen + comment, all via background jobs - **Platform mirror:** Issue state, assignees (with avatars), labels (with colors), and comments displayed in the dashboard. Workflow controls (Resolve, Assign, Priority) replaced by platform state - **Two-way webhooks:** Issue closed/reopened on platform syncs back to dashboard - **RED branding:** Issues show "Created by RED (Rails Error Dashboard)" ```ruby config.enable_issue_tracking = true config.issue_tracker_token = ENV["RED_BOT_TOKEN"] # That's it — provider and repo auto-detected from git_repository_url ``` [Complete documentation →](docs/guides/CONFIGURATION.md)

User Impact Scoring

Dedicated `/errors/user_impact` page ranking errors by unique users affected — not occurrence count. An error hitting 1000 users once ranks higher than hitting 1 user 1000 times. Shows impact percentage (when `total_users_for_impact` is configured or auto-detected), severity badges, and per-error drill-down links. No configuration needed — works automatically when errors have `user_id` (auto-detected via `CurrentAttributes` or `current_user`).

Scheduled Digests

Daily or weekly error summary emails — new errors, resolution rate, top errors by count, critical unresolved, and period-over-period comparison. HTML + text templates. Users schedule the job via SolidQueue, Sidekiq, or cron. ```ruby config.enable_scheduled_digests = true config.digest_frequency = :daily # or :weekly # config.digest_recipients = ["team@example.com"] # defaults to notification_email_recipients ``` Schedule: `rails error_dashboard:send_digest PERIOD=daily`

Release Tracking

Dedicated Releases page at `/errors/releases` shows a timeline of all deploys/versions with health stats. Answers: "Did this deploy introduce new errors?" and "Is this release stable?" - **Release timeline:** Every version seen, sorted newest-first, with error counts, unique types, and time range - **"New in this release":** Errors whose fingerprint first appeared in each version — flagged with a red badge - **Stability indicators:** Green (at or below average), yellow (1-2x), red (>2x average error rate) - **Release comparison:** Delta and percentage change vs the previous release - **Current release:** Highlighted card with live health stats - **Zero config:** Works automatically when `app_version` or `git_sha` is set (via config, `APP_VERSION`, `GIT_SHA`, `HEROKU_SLUG_COMMIT`, or `RENDER_GIT_COMMIT` env vars) ```ruby config.app_version = "1.2.0" # or set APP_VERSION env var config.git_sha = ENV["GIT_SHA"] # auto-detected on Heroku/Render config.git_repository_url = "https://github.com/user/repo" # enables SHA links ```

Source Code Integration + Git Blame

View actual source code directly in error backtraces with +/-7 lines of context. Git blame shows who last modified the code, when, and the commit message. Repository links jump to GitHub/GitLab/Bitbucket at the exact line. ```ruby config.enable_source_code_integration = true config.enable_git_blame = true ``` [Complete documentation →](docs/SOURCE_CODE_INTEGRATION.md)

Code Path Coverage (Diagnostic Mode)

Enable coverage via a dashboard button to see which production code paths were executed. Source code viewer overlays green checkmarks on executed lines and gray dots on unexecuted lines. Uses Ruby's `Coverage.setup(oneshot_lines: true)` — near-zero overhead, each line fires once. Zero overhead when off. ```ruby config.enable_coverage_tracking = true # shows Enable/Disable buttons on error detail page config.enable_source_code_integration = true # required for source code viewer ```

Error Replay — Copy as cURL / RSpec / LLM Markdown

Replay failing requests with one click. Copy the request as a cURL command, generate an RSpec test, or **copy all error details as clean Markdown** for pasting into an LLM session. The LLM export includes app backtrace, cause chain, local/instance variables, breadcrumbs, environment, system health, and related errors — with framework frames filtered and sensitive data preserved as `[FILTERED]`. [Complete documentation →](docs/FEATURES.md#error-details-page)

Notifications — Slack, Discord, PagerDuty, Email, Webhooks

Multi-channel alerting with severity filters, per-error cooldown, and milestone threshold alerts to prevent alert fatigue. ```ruby config.enable_slack_notifications = true config.slack_webhook_url = ENV['SLACK_WEBHOOK_URL'] ``` [Notification setup guide →](docs/guides/NOTIFICATIONS.md)

Advanced Analytics

![Analytics](docs/images/analytics.png) Seven analysis engines built in: 1. **Baseline Anomaly Alerts** — Statistical spike detection (mean + std dev) with intelligent cooldown 2. **Fuzzy Error Matching** — Jaccard similarity + Levenshtein distance to find related errors 3. **Co-occurring Errors** — Detect errors that happen together within configurable time windows 4. **Error Cascade Detection** — Identify chains (A causes B causes C) with probability and delays 5. **Error Correlation Analysis** — Correlate errors with app versions, git commits, and users 6. **Platform Comparison** — iOS vs Android vs Web health metrics side-by-side 7. **Occurrence Pattern Detection** — Cyclical patterns (business hours, weekends) and burst detection [Complete documentation →](docs/FEATURES.md#advanced-analytics-features)

Local Variable + Instance Variable Capture

See the exact values of local variables and instance variables at the moment an exception was raised — the most valuable debugging context possible. - TracePoint(`:raise`) captures locals and ivars before the stack unwinds - Configurable limits: max variable count, nesting depth, string truncation length - Sensitive data auto-filtered via Rails `filter_parameters` — passwords, tokens, and PII never stored - Never stores Binding objects — values extracted immediately, Binding is GC'd - Independent config flags: enable one or both ![Local Variables](docs/images/local-variables.png) ```ruby config.enable_local_variables = true config.enable_instance_variables = true ``` [Complete documentation →](docs/FEATURES.md)

Swallowed Exception Detection

Detect exceptions that are raised but silently rescued — the hardest bugs to find. No other error tracker does this. - Uses TracePoint(`:raise`) + TracePoint(`:rescue`) to track exception lifecycle - Identifies code paths where exceptions are caught but never logged or re-raised - Dashboard page at `/errors/swallowed_exceptions` shows detection counts, locations, and patterns - Memory-bounded aggregation with background flush - Requires Ruby 3.3+ ![Swallowed Exceptions](docs/images/swallowed-exceptions.png) ```ruby config.detect_swallowed_exceptions = true ``` [Complete documentation →](docs/FEATURES.md)

On-Demand Diagnostic Dump

Snapshot your app's entire system state on demand — environment, GC stats, threads, connection pool, memory, job queue health, and more. - Trigger via dashboard button or `rake rails_error_dashboard:diagnostic_dump` - Dashboard page at `/errors/diagnostic_dumps` with full history - Useful for debugging intermittent production issues without reproducing them ![Diagnostic Dumps](docs/images/diagnostic-dumps.png) ```ruby config.enable_diagnostic_dump = true ``` [Complete documentation →](docs/FEATURES.md)

Rack Attack Event Tracking

Track Rack Attack security events (throttles, blocklists, tracks) as breadcrumbs attached to errors, with a dedicated summary page. - Captures throttle, blocklist, and track events automatically - Dashboard page at `/errors/rack_attack_summary` with event breakdown - Requires breadcrumbs to be enabled ```ruby config.enable_rack_attack_tracking = true ``` [Complete documentation →](docs/FEATURES.md)

Process Crash Capture

Capture unhandled exceptions that crash the Ruby process via an `at_exit` hook — the last line of defense. - Disk-based fallback: writes crash data to disk because the database may be unavailable during shutdown - Imported automatically on next boot - Captures exception details, backtrace, uptime, GC stats, thread count, and cause chain - A self-hosted only feature — impossible for SaaS tools ```ruby config.enable_crash_capture = true ``` [Complete documentation →](docs/FEATURES.md)

Plugin System

Event-driven extensibility with hooks for `on_error_logged`, `on_error_resolved`, `on_threshold_exceeded`. Built-in examples for Jira integration, metrics tracking, and audit logging. ```ruby class MyPlugin < RailsErrorDashboard::Plugin def on_error_logged(error_log) # Your custom logic end end ``` [Plugin System guide →](docs/PLUGIN_SYSTEM.md)

Quick Start

1. Add to Gemfile

gem 'rails_error_dashboard'

2. Install with Interactive Setup

bundle install
rails generate rails_error_dashboard:install
rails db:migrate

The installer guides you through optional feature selection — notifications, performance optimizations, advanced analytics. All features are opt-in.

3. Visit your dashboard

http://localhost:3000/red

Default credentials: gandalf / youshallnotpass

Change these before production! Edit config/initializers/rails_error_dashboard.rb

4. Test it out

# In Rails console or any controller
raise "Test error from Rails Error Dashboard!"

Full installation guide →

Configuration

RailsErrorDashboard.configure do |config|
  # Authentication
  config.dashboard_username = ENV.fetch('ERROR_DASHBOARD_USER', 'gandalf')
  config.dashboard_password = ENV.fetch('ERROR_DASHBOARD_PASSWORD', 'youshallnotpass')

  # Or use your existing auth (Devise, Warden, etc.):
  # config.authenticate_with = -> { warden.authenticated? }

  # Optional features — enable as needed
  config.enable_slack_notifications = true
  config.slack_webhook_url = ENV['SLACK_WEBHOOK_URL']
  config.async_logging = true
  config.async_adapter = :sidekiq  # or :solid_queue, :async
end

Complete configuration guide →

Multi-App Support — Track errors from multiple Rails apps in a single shared database. Auto-detects app name, supports per-app filtering. Multi-App guide →

Documentation

Getting Started

Quickstart Guide — 5-minute setup
Configuration — All configuration options
Uninstalling — Clean removal

Features

Complete Feature List — Every feature explained
Notifications — Multi-channel alerting
Source Code Integration — Inline source + git blame
Batch Operations — Bulk resolve/delete
Real-Time Updates — Live dashboard
Error Trends — Charts and analytics

Advanced

Multi-App Support — Track multiple applications
Plugin System — Build custom integrations
API Reference — Complete API documentation
Customization — Customize everything
Database Options — Separate database setup
Database Optimization — Performance tuning
Mobile App Integration — React Native, Flutter, etc.
FAQ — Common questions answered

View all documentation →

Architecture

Built with CQRS (Command/Query Responsibility Segregation):

Commands — LogError, ResolveError, BatchOperations (writes)
Queries — ErrorsList, DashboardStats, Analytics (reads)
Services — PlatformDetector, SimilarityCalculator (business logic)
Plugins — Event-driven extensibility

Testing

2,600+ tests covering unit, integration, and browser-based system tests.

bundle exec rspec                              # Full suite
bundle exec rspec spec/system/                 # System tests (Capybara + Cuprite)
HEADLESS=false bundle exec rspec spec/system/  # Visible browser

Contributing

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Write tests, ensure all pass (bundle exec rspec)
Commit and push
Open a Pull Request

git clone https://github.com/AnjanJ/rails_error_dashboard.git
cd rails_error_dashboard
bin/setup  # Installs deps, hooks, runs tests

Development guide → · Testing guide →

License

Available as open source under the MIT License.

Acknowledgments

Built with Rails · UI by Bootstrap 5 · Charts by Chart.js · Pagination by Pagy · Docs theme by Jekyll VitePress Theme by @crmne

Contributors

Special thanks to @bonniesimon, @gundestrup, @midwire, @RafaelTurtle, and @j4rs. See CONTRIBUTORS.md for the full list.

Support

If this gem saves you some headaches (or some money on error tracking SaaS), consider sponsoring the project. It keeps RED going and lets me know people are finding it useful.

Made with ❤️ by Anjan

One Gem to rule them all, One Gem to find them, One Gem to bring them all, and in the dashboard bind them.