Rails Informant

Self-hosted error monitoring for Rails, built for AI agents

Quick Start ◆ Configuration ◆ Noise Suppression ◆ MCP Server ◆ Data and Privacy

Captures exceptions, stores them in your app's database with rich context (backtraces, breadcrumbs, request data), sends notifications, and exposes error data via a bundled MCP server -- so AI agents can query, triage, and fix production errors directly.

No dashboard. The agent is the interface.

• Agent-native -- 14 MCP tools let AI agents list, inspect, resolve, and fix errors without a browser.
• Self-hosted -- Errors stay in your database. No external service, no data leaving your infrastructure.
• Zero-config capture -- Automatic via Rails.error subscriber and Rack middleware. Breadcrumbs from ActiveSupport::Notifications provide structured debugging context.
• Lightweight -- Two database tables, no Redis, no background workers beyond ActiveJob.

Add to your Gemfile:

gem "rails-informant"

Install:

bundle install
bin/rails generate rails_informant:install
bin/rails db:migrate

Set an authentication token:

bin/rails credentials:edit

rails_informant:
  api_token: your-secret-token  # generate with: openssl rand -hex 32

Install Claude Code integration:

bin/rails generate rails_informant:skill

Errors are captured automatically. To capture manually:

RailsInformant.capture(exception, context: { order_id: 42 })

# config/initializers/rails_informant.rb
RailsInformant.configure do |config|
  config.capture_errors = !Rails.env.local?
  config.api_token = Rails.application.credentials.dig(:rails_informant, :api_token)
  config.slack_webhook_url = Rails.application.credentials.dig(:rails_informant, :slack_webhook_url)
  config.retention_days = 30
end

Every option can be set via an environment variable. The initializer takes precedence.

Connecting the tokens: The api_token in your Rails credentials and INFORMANT_PRODUCTION_TOKEN must be the same value. The first authenticates incoming requests to your app; the second tells the MCP server what token to send.

RailsInformant.silence do
  risky_operation_you_dont_care_about
end

Thread-safe via CurrentAttributes. Nesting is supported.

Hook into the recording pipeline to filter, modify fingerprints, or override severity:

config.before_record do |event|
  event.halt! if event.message.include?("timeout")
  event.fingerprint = "stripe-errors" if event.error_class.start_with?("Stripe::")
  event.severity = "warning" if event.error_class == "Net::ReadTimeout"
end

The event exposes: error, error_class, message, severity, controller_action, job_class, request_path, fingerprint. Callbacks that raise are logged and skipped.

Exceptions implementing to_informant_context have their context merged into occurrences automatically:

class PaymentError < StandardError
  def to_informant_context
    { payment_id:, gateway: }
  end
end

Notify Informant of a deploy to auto-resolve stale errors (not seen in the last hour):

curl -X POST https://myapp.com/informant/api/v1/deploy \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sha": "abc1234"}'

Resolved errors automatically reopen on regression. Also available as the notify_deploy MCP tool.

The bundled informant-mcp executable connects Claude Code to your error data via Model Context Protocol.

The rails_informant:skill generator creates .mcp.json automatically. Set INFORMANT_PRODUCTION_URL and INFORMANT_PRODUCTION_TOKEN as environment variables (e.g., via .envrc + direnv).

For multi-environment setups, add env vars for each environment:

export INFORMANT_PRODUCTION_URL=https://myapp.com
export INFORMANT_PRODUCTION_TOKEN=<token>
export INFORMANT_STAGING_URL=https://staging.myapp.com
export INFORMANT_STAGING_TOKEN=<token>

The MCP server enforces HTTPS by default. For local HTTP URLs, pass --allow-insecure:

{
  "mcpServers": {
    "informant": {
      "command": "informant-mcp",
      "args": ["--allow-insecure"]
    }
  }
}

Development Machine                    Remote Servers
+-----------------------+              +-----------------------+
|  Claude Code          |              |  Production           |
|        |              |              |  /informant           |
|        | stdio        |              +-----------------------+
|        v              |  HTTPS+Token
|  MCP Server           | -----------> +-----------------------+
|  (exe/informant-mcp)  |              |  Staging              |
|                       |              |  /informant           |
+-----------------------+              +-----------------------+

unresolved --> fix_pending --> resolved (auto, on deploy)
unresolved --> resolved (manual)
unresolved --> ignored
unresolved --> duplicate
resolved    --> unresolved [REGRESSION]

Occurrences store: user ID (always), email (opt-in via capture_user_email), IP address, and custom context. All context passes through ActiveSupport::ParameterFilter -- add keys to filter_parameters to suppress them.

RailsInformant::Current.user_context = { id: current_user.id }

• Token authentication (secure_compare), HTTPS enforced by default
• All context filtered through ActiveSupport::ParameterFilter
• Security headers: Cache-Control: no-store, X-Content-Type-Options: nosniff
• Error capture never breaks the host application
• No built-in rate limiting -- use Rack::Attack on /informant/

MIT License -- see LICENSE.