Ruby on Rails Monitoring Guide: Metrics, APM & Production Observability (2026)

# Gemfile
gem "yabeda-rails"
gem "yabeda-prometheus"
gem "yabeda-sidekiq"  # if using Sidekiq

# config/application.rb — expose /metrics for Prometheus scraping
module MyApp
  class Application < Rails::Application
    config.middleware.use Yabeda::Prometheus::Exporter, path: "/metrics"
  end
end

# This auto-creates:
# rails_requests_total{controller, action, status} — Counter
# rails_request_duration_seconds{controller, action, status} — Histogram
# sidekiq_jobs_executed_total{queue, worker, status} — Counter
# sidekiq_queue_size{queue} — Gauge
# sidekiq_job_runtime{queue, worker} — Histogram

# Custom business metrics
Yabeda.configure do
  group :orders do
    counter :total,
      comment: "Total orders placed",
      tags: [:payment_method, :plan_tier]

    histogram :amount_dollars,
      comment: "Order value in dollars",
      buckets: [10, 50, 100, 500, 1000],
      tags: [:payment_method]
  end
end

# In your controller/service
class OrdersController < ApplicationController
  def create
    order = Order.create!(order_params)
    Yabeda.orders.total.increment(
      tags: { payment_method: order.payment_method, plan_tier: current_user.plan }
    )
    Yabeda.orders.amount_dollars.measure(
      tags: { payment_method: order.payment_method }
    ) { order.amount_cents / 100.0 }
  end
end

# Prometheus alert rules
# High error rate:
# rate(rails_requests_total{status=~"5.."}[5m])
#   / rate(rails_requests_total[5m]) > 0.01

# Slow requests:
# histogram_quantile(0.95, rate(rails_request_duration_seconds_bucket[5m])) > 1

# Sidekiq backlog:
# sidekiq_queue_size{queue="critical"} > 100

# Gemfile
gem "opentelemetry-sdk"
gem "opentelemetry-instrumentation-rails"
gem "opentelemetry-instrumentation-active_record"
gem "opentelemetry-instrumentation-sidekiq"
gem "opentelemetry-instrumentation-net_http"
gem "opentelemetry-exporter-otlp"

# config/initializers/opentelemetry.rb
require "opentelemetry/sdk"
require "opentelemetry/exporter/otlp"
require "opentelemetry/instrumentation/all"

OpenTelemetry::SDK.configure do |c|
  c.service_name = "my-rails-app"
  c.service_version = ENV.fetch("APP_VERSION", "unknown")

  c.use_all()  # Auto-instruments Rails, AR, Sidekiq, Net::HTTP, Faraday, Redis

  c.add_span_exporter(
    OpenTelemetry::Exporter::OTLP::Exporter.new(
      endpoint: ENV.fetch("OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4318")
    )
  )
end

# Manual spans for business logic
class PaymentService
  def charge(order)
    tracer = OpenTelemetry.tracer_provider.tracer("PaymentService")
    tracer.in_span("PaymentService.charge") do |span|
      span.set_attribute("order.id", order.id)
      span.set_attribute("order.amount_cents", order.amount_cents)
      span.set_attribute("payment.provider", "stripe")

      begin
        result = Stripe::PaymentIntent.create(amount: order.amount_cents)
        span.set_attribute("stripe.payment_intent_id", result.id)
        result
      rescue Stripe::CardError => e
        span.record_exception(e)
        span.status = OpenTelemetry::Trace::Status.error("Card declined")
        raise
      end
    end
  end
end

# config/routes.rb — Mount Sidekiq web UI (protect with Devise/HTTP auth)
require "sidekiq/web"

authenticate :user, ->(u) { u.admin? } do
  mount Sidekiq::Web, at: "/sidekiq"
end

# Custom health check for Sidekiq queue depth
class SidekiqHealthCheck
  def self.healthy?
    stats = Sidekiq::Stats.new
    queues = Sidekiq::Queue.all

    # Alert thresholds
    return false if stats.dead_size > 100           # Dead queue filling up
    return false if stats.failed > 1000             # High failure count
    return false if queues.any? { |q| q.name == "critical" && q.size > 50 }

    true
  end

  def self.stats_summary
    stats = Sidekiq::Stats.new
    {
      enqueued: stats.enqueued,
      processed: stats.processed,
      failed: stats.failed,
      dead: stats.dead_size,
      queues: Sidekiq::Queue.all.map { |q| { name: q.name, size: q.size, latency: q.latency } }
    }
  end
end

# Key Sidekiq Prometheus metrics via yabeda-sidekiq:
# sidekiq_queue_size{queue}           — jobs waiting
# sidekiq_queue_latency{queue}        — seconds oldest job has waited
# sidekiq_jobs_executed_total{queue, worker, status}
# sidekiq_job_runtime{queue, worker}  — histogram (seconds)

# Alert rules:
# sidekiq_queue_latency{queue="critical"} > 60  # job waiting >60s
# sidekiq_queue_size{queue="default"} > 5000
# rate(sidekiq_jobs_executed_total{status="failed"}[5m]) > 0