Rails Sentry: Error Tracking in Productie met Source Maps, Performance Monitoring en PII Scrubbing
Rails Sentry vangt productiefouten voordat klanten klagen. Configureer sourcemaps, sample rates, performance traces en PII scrubbing op de juiste manier.
Een fintech-oprichter belde me op een vrijdagavond met de vraag waarom een klant een mailtje had gestuurd over een checkout-fout die zijn team nooit had gezien. De fout stond al elf dagen live. Sentry was technisch gezien geïnstalleerd, de gem stond in de Gemfile, de DSN was gezet, het dashboard stond open in iemand’s tab — maar elke exception uit de storefront-controller werd opgegeten door een rescue_from StandardError, with: :render_500 die netjes een 500-pagina renderde en de exception vervolgens stilletjes naar STDOUT logde. Sentry zag er nooit iets van. Rails Sentry is zo’n tool die geïnstalleerd lijkt terwijl hij niks vangt, en het gat tussen “we hebben Sentry” en “Sentry doet zijn werk” is groter dan de meeste teams beseffen.
Na negentien jaar Rails heb ik op honderden apps Sentry geconfigureerd, en in tien keer zoveel apps gezien waar de configuratie op een stille, dure manier verkeerd stond. Deze post is de productie-setup die ik standaard uitlever — de gem, de initializer, source maps voor JavaScript, performance traces die je begroting niet opvreten, en PII scrubbing die een security-audit overleeft.
Wat Rails Sentry Daadwerkelijk Doet
Rails Sentry is twee producten in één bundel. Het eerste is exception-capture: als je app een onafgevangen fout gooit, serialiseren de sentry-ruby- en sentry-rails-gems de exception, de request, de gebruiker en een stack trace, en sturen ze de payload via HTTPS naar sentry.io (of je self-hosted instance). Het tweede is performance monitoring: een instelbaar percentage requests krijgt een distributed trace met timings voor controller, view, ActiveRecord-queries en uitgaande HTTP, allemaal opgehangen aan dezelfde incident-view als de exceptions.
De valkuil is dat “we hebben Sentry geïnstalleerd” meestal betekent dat het eerste product half aanstaat en het tweede onzichtbaar is. De meeste teams lopen in één van drie fouten. Ze vangen exceptions in een base controller en re-raisen nooit naar Sentry. Ze zetten traces_sample_rate op 1.0 en branden hun quotum in acht dagen op, of negeren de resulterende ruis. Ze laten de standaard data-scrubbing staan en sturen klant-e-mails, sessiecookies en Stripe-tokens naar een in de VS gehoste SaaS zonder er ooit bij stil te staan. Elk van die drie is een fix van vijf minuten zodra je hem doorhebt.
Rails Sentry Correct Opzetten
Begin met de gems en een initializer. Kopieer niet zomaar de README in je config/initializers-directory — de standaard-config is prima voor een demo en verkeerd voor productie.
# Gemfile
gem "sentry-ruby"
gem "sentry-rails"
gem "sentry-sidekiq" # alleen als je Sidekiq gebruikt
gem "stackprof", require: false # voor profiling — optioneel
# config/initializers/sentry.rb
Sentry.init do |config|
config.dsn = ENV.fetch("SENTRY_DSN", nil)
config.breadcrumbs_logger = %i[active_support_logger http_logger]
config.enabled_environments = %w[production staging]
config.release = ENV.fetch("HEROKU_SLUG_COMMIT", `git rev-parse HEAD`.strip)
config.environment = Rails.env
config.traces_sample_rate = ENV.fetch("SENTRY_TRACES_RATE", "0.05").to_f
config.profiles_sample_rate = ENV.fetch("SENTRY_PROFILES_RATE", "0.05").to_f
config.send_default_pii = false
config.before_send = ->(event, _hint) { Sentry::Scrubber.call(event) }
config.excluded_exceptions += %w[
ActionController::RoutingError
ActiveRecord::RecordNotFound
ActionController::InvalidAuthenticityToken
]
end
Een paar niet-voor-de-hand-liggende keuzes hierin. De release-waarde is wat Sentry in staat stelt fouten per deploy te groeperen en je te vertellen “deze regressie is verschenen in abc1234”. Zonder die waarde lijkt elke fout er altijd al te zijn geweest. send_default_pii is standaard false in moderne sentry-ruby, maar ik zet ‘m expliciet zodat het bij code review opvalt — en omdat sommige oudere configs dit overschrijven. excluded_exceptions haalt de bulk-ruis weg die niet actionable is: een RecordNotFound van een bot die verwijderde URL’s scrapt is geen bug, dat is het internet.
Het stukje waar teams over struikelen is enabled_environments. Sentry stuurt stilletjes niks vanuit development als dit verkeerd staat, wat goed klinkt totdat je beseft dat je drie weken lang Sentry “getest” hebt in development en geen idee hebt of de integratie in productie werkt. De fix is een bewuste test-exception deployen naar staging, bevestigen dat hij binnenkomt, en de test daarna weer weghalen.
Rescue-Patronen Die Fouten Niet Verbergen
Rails Sentry haakt in op ActionDispatch::DebugExceptions, wat betekent dat alles wat je opslokt voordat de request bij die middleware aankomt, onzichtbaar blijft. De meest voorkomende dader is een defensieve base controller.
# Fout — Sentry ziet deze nooit.
class ApplicationController < ActionController::Base
rescue_from StandardError do |error|
Rails.logger.error(error)
render "errors/500", status: :internal_server_error
end
end
De fix is je custom errorpagina behouden én de exception expliciet opnieuw uitzenden.
# Goed — Sentry krijgt de exception, de gebruiker krijgt de vriendelijke pagina.
class ApplicationController < ActionController::Base
rescue_from StandardError do |error|
Sentry.capture_exception(error)
render "errors/500", status: :internal_server_error
end
end
Voor exceptions die je wel wilt tracken maar niet als rode alarm wilt zien — bijvoorbeeld een third-party API die wispelturig is en die je netjes afhandelt — gebruik je capture_exception met een tag, zodat je de ruis uit de hoofd-inbox kunt filteren.
Sentry.with_scope do |scope|
scope.set_tag(:expected, "true")
scope.set_level(:warning)
Sentry.capture_exception(error)
end
Een vergelijkbare valkuil zit in background jobs. Als je een job-body wikkelt in een begin/rescue en alleen logt, ziet Sentry de fout nooit. Wij hebben een langere post over Rails Active Job-retries met exponential backoff die behandelt wanneer je moet re-raisen en wanneer slikken — de korte versie is: als je slikt, capture dan expliciet.
Source Maps voor JavaScript-Fouten
Dit is het meest genegeerde onderdeel van een Rails Sentry-setup en de stap die zich het snelst terugbetaalt. Zonder source maps ziet een JavaScript-exception in je Sentry-dashboard eruit als TypeError at app-a1b2c3.js:1:84210, wat nutteloos is. Mét source maps wordt het TypeError at Checkout#submit (checkout_controller.js:42), wat een ticket is dat je kunt afsluiten.
Voor een Rails 8-app op importmaps is het verhaal simpel — je hebt geen source maps nodig omdat je JS niet geminified wordt. Voor elke app op esbuild, Bun of Vite (de meeste moderne Rails-apps met echte frontend) upload je source maps naar Sentry als onderdeel van je build.
# .github/workflows/deploy.yml — relevante deel
- name: Build assets
run: bin/rails assets:precompile
- name: Upload source maps to Sentry
env:
SENTRY_AUTH_TOKEN: $
SENTRY_ORG: ttb-software
SENTRY_PROJECT: storefront-web
SENTRY_RELEASE: $
run: |
npx @sentry/cli releases new "$SENTRY_RELEASE"
npx @sentry/cli releases files "$SENTRY_RELEASE" \
upload-sourcemaps ./app/assets/builds \
--url-prefix "~/assets" --rewrite
npx @sentry/cli releases finalize "$SENTRY_RELEASE"
De --url-prefix "~/assets" is het Rails-specifieke stukje. Sourcemaps worden gematcht op URL, en Rails serveert gecompileerde JS vanaf /assets/... met een digest. De tilde zegt tegen Sentry “elke host, dit pad” zodat het matchen werkt over staging en productie heen. Krijg dit verkeerd en je maps uploaden wel, maar worden nooit toegepast — wat er identiek uitziet aan helemaal geen maps uploaden.
Cruciaal: lever geen source maps mee naar je publieke CDN. Zet je asset-pipeline zo in dat .map-bestanden tijdens de build lokaal worden geschreven, upload ze naar Sentry, en doe rm voordat je naar S3 rsynct. Een gelekte source map is op zichzelf geen kwetsbaarheid, maar wel gratis reconnaissance voor iedereen die je frontend reverse-engineert.
Performance Monitoring Zonder Je Begroting Op Te Blazen
traces_sample_rate = 1.0 is de regel uit de README die meer startups meer geld heeft gekost dan welke andere ook. Op 1.0 traced Sentry elke request. Op een bescheiden app van 200 RPS zijn dat 17 miljoen traces per dag, wat op het Team-abonnement je maandquotum in twee dagen opblaast. Erger nog, het dashboard wordt onbruikbaar omdat elke endpoint verzuipt in ruis.
De verstandige setup is een lage default-rate met een dynamische sampler die de rate omhoog draait voor trage of fout-gevoelige endpoints.
config.traces_sampler = lambda do |sampling_context|
transaction_context = sampling_context[:transaction_context]
op = transaction_context[:op]
name = transaction_context[:name]
case
when op == "http.server" && name&.include?("/healthz")
0.0
when op == "http.server" && name&.include?("/checkout")
0.5
when op == "queue.sidekiq"
0.02
else
0.05
end
end
Dat geeft je 5 procent basisdekking, halve rate op de high-value checkoutflow, vrijwel niets op background jobs (waar het volume groot is en de waarde per trace laag), en nul op health checks. Een startup van 200 RPS op deze config ziet ruwweg 800.000 nuttige traces per maand in plaats van 500 miljoen nutteloze.
Om in die traces trage queries te vinden, combineer je Sentry performance met een van de in-process profilers — die workflow behandelen we in rack-mini-profiler voor Rails performance profiling en OpenTelemetry voor Rails 8 observability. Sentry vertelt je welke endpoints traag zijn; de profilers vertellen je waarom.
PII Scrubbing Die Een Audit Overleeft
De standaard Sentry-scrubbing dekt voor de hand liggende wachtwoorden en creditcardnummers, en mist vrijwel alles dat specifiek is voor jouw app. E-mailadressen, IP-adressen, klantnamen, interne ID’s die in je supporttool naar een klant verwijzen — die belanden allemaal standaard in stackframes, request bodies en breadcrumbs. Als je in de EU opereert, is dat een AVG-bevinding die staat te wachten.
Het juiste patroon is een expliciete before_send-hook die elk event door je eigen scrubber haalt.
# app/services/sentry/scrubber.rb
class Sentry::Scrubber
PII_FIELDS = %w[
email phone address ssn iban
api_key access_token refresh_token authorization
stripe_token card_number cvv
].freeze
def self.call(event)
return nil if drop?(event)
scrub_request(event)
scrub_extra(event)
scrub_breadcrumbs(event)
event
end
def self.drop?(event)
return true if event.tags&.dig(:expected) == "true" && Rails.env.staging?
false
end
def self.scrub_request(event)
return unless event.request
event.request.cookies = nil
event.request.headers&.transform_values! { |v| v.is_a?(String) ? scrub_string(v) : v }
event.request.data = scrub_hash(event.request.data) if event.request.data.is_a?(Hash)
end
def self.scrub_extra(event)
event.extra = scrub_hash(event.extra) if event.extra.is_a?(Hash)
end
def self.scrub_breadcrumbs(event)
event.breadcrumbs&.each do |b|
b.data = scrub_hash(b.data) if b.data.is_a?(Hash)
end
end
def self.scrub_hash(hash)
hash.transform_values.with_index do |value, _|
value
end.tap do
hash.each do |k, v|
hash[k] = "[FILTERED]" if PII_FIELDS.include?(k.to_s.downcase)
hash[k] = scrub_string(v) if v.is_a?(String)
end
end
end
def self.scrub_string(value)
value
.gsub(/[\w._%+-]+@[\w.-]+\.[A-Z]{2,}/i, "[email]")
.gsub(/\b\d{16}\b/, "[card]")
end
end
nil retourneren uit before_send laat het event helemaal vallen. Dat is het mechanisme waarmee je bekende-ruis-exceptions op staging onderdrukt zonder ze in productie uit te zetten. De scrubber draait op elk event, dus houd hem goedkoop — string-allocaties hier worden één keer per fout betaald, maar als je tijdens een incident 200 fouten per minuut stuurt, telt dat op.
Een tweede laag die de moeite waard is, zijn Rails’ eigen filter parameters. Alles in config.filter_parameters wordt vervangen door [FILTERED] voordat het de request body bereikt, wat betekent dat Sentry het sowieso nooit te zien krijgt. Dat is je verdediging in de diepte voor een verkeerd geconfigureerde scrubber.
# config/application.rb
config.filter_parameters += %i[
password password_confirmation
ssn iban card_number cvv stripe_token
access_token refresh_token api_key
email phone
]
Sentry Koppelen Aan Gebruikerscontext
De Sentry-config met de hoogste hefboomwerking is de user scope. Zonder die scope is elke fout anoniem en kun je niet zien of vijf fouten van vijf gebruikers komen of van één gebruiker die vijf keer opnieuw probeert. Mét die scope vertelt het dashboard je “deze fout raakte 312 gebruikers, hier is er één van.”
# app/controllers/application_controller.rb
before_action :set_sentry_context
def set_sentry_context
return unless current_user
Sentry.set_user(
id: current_user.id,
ip_address: request.remote_ip,
segment: current_user.plan
)
Sentry.set_tag(:account_id, current_user.account_id)
end
Ik stuur hier bewust niet current_user.email mee. De user-ID en het plan zijn genoeg om die persoon terug te vinden in je admin-tool; het e-mailadres is PII die je niet naar een derde partij hoeft te sturen. Als je werkt onder HIPAA, BAA-beperkingen of strikte EU-dataresidentie, is zelfs het IP-adres een probleem — zet ip_address op nil en vertrouw op alleen de user-ID.
Verifiëren Dat De Setup Echt Werkt
Elke Sentry-installatie verdient een smoke test in CI of staging. De kosten zijn twintig regels testcode en de payoff is een verkeerd geconfigureerde DSN vinden vóór een echt incident.
# test/integration/sentry_integration_test.rb
require "test_helper"
class SentryIntegrationTest < ActionDispatch::IntegrationTest
test "captures unhandled controller exceptions" do
captured = nil
Sentry.get_current_client.transport.stub :send_event, ->(event) { captured = event } do
get "/__sentry_test__"
assert captured
assert_equal "RuntimeError", captured.exception.values.first.type
end
end
end
Combineer dat met een tijdelijke /__sentry_test__-route op staging die een exception gooit, doe een hit na deploy, en bevestig dat het event in het dashboard binnenkomt, getagd met de huidige release SHA. Dat is de enige manier waarop je weet dat je volledige pipeline werkt — gem, initializer, DSN, netwerk, sourcemaps, scrubber, het hele zwikje.
FAQ
Wat kost Rails Sentry in productie?
Dat hangt volledig af van je traces sample rate en je foutvolume. Een typische Rails SaaS op 100 RPS met de dynamische sampler uit deze post en een paar duizend fouten per maand past comfortabel binnen het Team-abonnement. De cost-blowups die ik heb gezien komen allemaal van traces_sample_rate = 1.0, wat je rekening met twintig of meer kan vermenigvuldigen.
Moet ik Sentry, Honeybadger of Rollbar gebruiken voor Rails?
Alle drie doen het kernwerk goed. Sentry heeft de sterkste performance monitoring en de beste frontend-integratie. Honeybadger heeft de schoonste Ruby-only ervaring en uitstekende uptime monitoring. Rollbars grouping-algoritme is het meest agressief, wat helpt of pijn doet afhankelijk van of je team unieke fingerprints najaagt. Voor de meeste moderne Rails-apps met een JavaScript-frontend is Sentry de default die ik pak.
Vangt Rails Sentry Sidekiq-jobfouten automatisch op?
Alleen als je sentry-sidekiq installeert en in je Gemfile requirt. De basis-gem sentry-rails haakt in op web requests; de Sidekiq-integratie staat los en omsluit de middleware-stack. Als je jobs falen en Sentry stil blijft, is dit de eerste plek om te checken.
Hoe voorkom ik dat ik AVG-gevoelige data naar Sentry stuur?
Drie lagen. Zet send_default_pii = false. Voeg een before_send-scrubber toe zoals in deze post. Voeg de veldnamen toe aan config.filter_parameters zodat Rails ze strip voordat Sentry ze ooit ziet. Defence in depth wint van vertrouwen op één enkele laag.
Hulp nodig met productiewaardige observability op je Rails-app — error tracking, performance monitoring, audit-klare PII scrubbing? TTB Software is gespecialiseerd in Rails-infrastructuur en observability voor productteams die het in één keer goed willen hebben. We doen dit al negentien jaar.
Related Articles
Rails LLM Semantic Cache: AI API-kosten verlagen met pgvector
Rails LLM semantic cache met pgvector: AI-antwoorden cachen op query-gelijkenis, OpenAI/Claude-kosten 40-60% verlagen...
Rails PDF Genereren: Prawn, Grover en HTML-naar-PDF in Productie
Rails PDF genereren met Prawn, Grover en HTML-naar-PDF via headless Chrome — wanneer wat, productie-setup, achtergron...
Rails ActiveSupport::Notifications: Aangepaste Instrumentatie voor Metrics en Productie-monitoring
Rails ActiveSupport::Notifications vormt de basis voor aangepaste instrumentatie, metrics en APM-integratie. Abonneer...