RUBY ON RAILS · 17 MIN READ ·

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.

Rails Sentry: Error Tracking in Productie met Source Maps, Performance Monitoring en PII Scrubbing

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.

#rails-sentry #sentry-ruby #rails-error-tracking #sentry-performance-monitoring #rails-observability #sentry-pii-scrubbing #rails-production-monitoring

Related Articles

Laatste sectie. Bel dan alsjeblieft.

Het is een telefoongesprek. Erger dan dat kan het niet worden.

Geen discovery-deck. Geen 45-minuten "kwalificatiegesprek." 30 minuten, jouw probleem, mijn mening. Als we een fit zijn weet je dat in minuut 12.

Directe lijn — Roger neemt zelf op
+31 6 5123 6132
Ma–vr, 09:00–18:00 CET · Nu beschikbaar

OF
info@ttb.software