Stop guessing what's slow in your Rails app.
Rails Pulse is an open source Rails engine that monitors response times, SQL queries, background jobs, and unhandled exceptions, with opinionated defaults that tell you what to care about, without having to become a platform engineer. Your data stays in your own database.
Who is Rails Pulse for?
Rails Pulse is built for developers who want real visibility into their application's performance without the overhead of enterprise monitoring tooling.
Solo developers and small Rails teams
You're paying $300–400/month for Sentry or AppSignal and checking performance metrics once a month. Rails Pulse is built specifically for Rails. It tells you what's slow without requiring you to learn a querying language or configure dashboards.
Teams switching off generic APMs
New Relic and Datadog are built for ops teams with a dedicated platform engineer. If you're a Rails developer who wants answers, not dashboards, Rails Pulse is built for how you actually work.
Developers who own their data
You don't want request traces and query patterns sitting on someone else's servers, subject to their retention policies and their terms of service. With Rails Pulse, it stays in your database.
Let's be honest.
Something in your Rails app is slow. You just don't know exactly what, why, or for how long it's been happening. And when you go looking for a monitoring solution, the options aren't great.
Sentry or Honeybadger
Polished error tracking with alerting and integrations. But performance visibility is buried under a querying language most Rails developers don't have time to learn, the bill grows every time you turn on logs or spans, and your exception payloads live on someone else's servers. Easy to end up paying $300–400/month for features you check monthly.
New Relic or Datadog
Genuinely powerful tools built for ops teams with dedicated platform engineers. $300–$500/month for a typical Rails app, usage-based pricing that grows with traffic, and more dashboards than any one developer has time to configure.
Tailing Logs
Free, but you'll spend more time writing grep commands than writing features. No trend analysis. No SQL query breakdown. No way to correlate a slow request with the queries that caused it.
Rolling Your Own
A few days of instrumentation work, a charting library, a data model, a cleanup job... it's a project in itself. And you rebuild it from scratch every time you start a new app.
There's a better option. One that's built for Rails developers, not platform engineers, and tells you what to care about.
Four things that make Rails Pulse different.
Opinionated by default
Rails Pulse knows what matters for a Rails app. Route-level response times, slow queries, background job health, recurring exceptions, all surfaced automatically without configuring dashboards or learning a query language. Install it and it tells you what's slow and what's breaking.
Open Source
Rails Pulse is MIT licensed. Add it to your Gemfile and it works with no account required, no API keys, and no external services to configure.
Your Data Stays on Your Server
Every request, every SQL query, every job run, every exception, stored in your own database. Nothing is sent to an external service. No API keys. No outbound connections. Your performance data is as private as the rest of your application.
Direct Access to Your Data
Because Rails Pulse stores data in your database, you can query it directly with SQL. Write custom reports, join against your own tables, export to your BI tool, or build alerts on top. No API rate limits. No data export fees.
Everything you need to understand your app's performance.
From slow endpoints to N+1 queries, background job failures to unhandled exceptions, and which deploy made things worse. Rails Pulse gives you the full picture in one dashboard.
SQL Query Performance
Track SQL query performance with slow query identification, P95/P99 percentiles, and configurable SLO thresholds. Quickly identify database bottlenecks and optimize your most expensive queries.
Route-Specific Metrics
Get granular insights with route-specific metrics and configurable performance thresholds. See exactly which endpoints need optimization.
Exception Tracking
Unhandled exceptions from requests and jobs, grouped by class and location, with backtraces, source context, and filtered params. Messages are redacted with your own filter_parameters before they are stored. Mark them resolved, or copy an LLM-ready summary straight into your editor.
Deployments and What Changed
Record deploys from CI or a rake task and they appear as markers on every chart. Each route, query, and job is compared against its own history, so Rails Pulse tells you not just that something is slow, but that it got slower, and when.
Background Job Monitoring
Track job execution time, queue wait, failure rates, and retry counts across all ActiveJob adapters including Sidekiq, Solid Queue, Good Job, and more.
Zero Configuration
Start collecting performance data immediately after installation with sensible defaults. No complex setup required.
Smart Data Cleanup
Automatic data archiving prevents database bloat while preserving essential insights. A storage page shows how full every table is against its cap.
What you can see.
A full dashboard for every layer of your Rails stack: requests, queries, routes, background jobs, exceptions, and deployments, all in one place.
Dashboard
A system health bar across routes, queries, jobs, exceptions, and storage, plus response time percentiles, throughput, errors, recent deploys, and what needs attention right now.
SQL Query Performance
Every SQL query tracked and ranked by execution time, with P95/P99 percentiles and SLO threshold indicators.
Route Metrics
Per-endpoint performance data identified by controller action, with configurable thresholds and a comparison against each route's own history.
Background Jobs
Job execution times, failure rates, retry counts, and queue breakdowns across all your ActiveJob adapters.
Request Detail
Drill into any request to see every SQL query it triggered, execution time, route, response code, and a full operation timeline. Instantly understand what a slow request was actually doing.
Exception Detail
Every occurrence of an exception with its backtrace, source snippets for your app's frames, filtered request params, and the deploy that was live when it fired.
Storage
How full each Rails Pulse table is, disk usage, retention settings, and when cleanup last ran. No surprises about what monitoring costs you in database space.
Query Detail
See the full history of any SQL query — execution frequency, average and P95/P99 times, which requests triggered it, and a zoomable performance chart over time.
Works with your stack.
Rails Pulse integrates with the tools and databases you're already using.
Databases
SQLite, PostgreSQL, and MySQL. Store Rails Pulse data in your main application database or a dedicated separate database.
Job Adapters
Sidekiq, Solid Queue, Good Job, Delayed Job, Resque, and any other ActiveJob adapter, all supported out of the box.
Rails & Ruby
Rails 7.2+ and Ruby 3.1+. Tested across Rails 7.2, 8.0, and 8.1 on each release.
Built for Developers
Rails Pulse is designed with developer experience in mind. Everything you need to monitor, debug, and optimize your Rails application.
Quick Installation
Add Rails Pulse to your application in minutes. Simply add the gem, run the installer, and you're ready to start monitoring.
Get Started in Minutes
Add Rails Pulse to your Gemfile, run the installer, and mount the engine. That's it. Start monitoring your application's performance immediately with zero configuration.
# Gemfile
gem 'rails_pulse'
# Install
$ bundle install
$ rails generate rails_pulse:install
$ rails db:migrate
# config/routes.rb
Rails.application.routes.draw do
mount RailsPulse::Engine => "/rails_pulse"
endFrequently Asked Questions
Everything you need to know about Rails Pulse
How much does Rails Pulse cost?
Rails Pulse is open source and MIT licensed. Add it to your Gemfile and start using it with no account, no API keys, and no subscription required.
Where does my performance data get stored?
All data is stored in your own database, the same one your app uses, or a separate dedicated database if you prefer. Nothing is sent to any external service. Rails Pulse makes no outbound network connections. Your data is as private as the rest of your application.
Can I query the Rails Pulse data directly?
Yes. Because Rails Pulse stores data in your own database using standard ActiveRecord models, you can query it with SQL, join it against your own tables, export it to a BI tool, or build custom reports and alerts on top. You're not locked into the dashboard UI. The data is just tables in your database.
What Rails and Ruby versions are supported?
Rails Pulse supports Rails 7.2+ and Ruby 3.1+. It's built as a Rails Engine and follows Rails best practices, ensuring compatibility with the latest Rails versions.
Does Rails Pulse impact my application's performance?
Tracking data is written on a background thread after the response is sent, so the request thread pays well under a millisecond. The database writes themselves take a few milliseconds per request off the request path. For high-traffic applications you can reduce this further by filtering low-value routes (health checks, assets) or using a separate database.
Can I use a separate database for Rails Pulse?
Yes. Rails Pulse supports two database configurations:
- Single Database (default): Stores data in your main application database. Simple setup with zero additional configuration.
- Separate Database: Use a dedicated database for complete isolation. Supports SQLite, PostgreSQL, and MySQL.
Install with the --database=separate flag to use a separate database.
How does data cleanup work?
Rails Pulse offers automatic data archiving with two strategies: time-based cleanup (delete records older than a configured period) and count-based cleanup (enforce maximum record limits per table). Schedule RailsPulse::CleanupJob to run daily, or trigger it manually with rails rails_pulse:cleanup.
How do I secure the Rails Pulse dashboard?
Authentication is on by default outside development and test. Set config.authorize to a predicate such as ->(controller) { controller.current_user&.admin? } and anything that doesn't return true gets a 403. If you'd rather redirect to a login page, use authentication_method. It works with Devise, Rails 8 authentication, or anything else.
Does Rails Pulse track errors too?
Yes. Rails Pulse captures unhandled exceptions from requests and background jobs, groups them by class and location, and shows backtraces with source context and filtered request params. Messages are redacted using your app's filter_parameters before they're stored. There's no alerting or issue-tracker integration; what you get is recurring production errors alongside your performance data, in your own database. It's opt-in with config.track_exceptions = true.
From the blog
Practical writing on Rails performance, monitoring, and building in public.