> ## Documentation Index
> Fetch the complete documentation index at: https://docs.appsignal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Ruby on Rails

export const Compatibility = ({versions = [], label = "Available in"}) => {
  if (!Array.isArray(versions) || versions.length === 0) {
    return null;
  }
  const defaultPillStyle = {
    borderColor: "#d4d4d8",
    background: "#f4f4f5",
    color: "#3f3f46"
  };
  const pillStyles = {
    "AppSignal for Elixir": {
      background: "#f3e8ff",
      borderColor: "#d8b4fe",
      color: "#6b21a8"
    },
    "AppSignal for Front-end": {
      background: "#fef9c3",
      borderColor: "#fde047",
      color: "#854d0e"
    },
    "AppSignal for Go": {
      background: "#ccfbf1",
      borderColor: "#5eead4",
      color: "#115e59"
    },
    "AppSignal for JavaScript": {
      background: "#fef9c3",
      borderColor: "#fde047",
      color: "#854d0e"
    },
    "AppSignal for Node.js": {
      background: "#dcfce7",
      borderColor: "#86efac",
      color: "#166534"
    },
    "AppSignal for Python": {
      background: "#dbeafe",
      borderColor: "#93c5fd",
      color: "#1e40af"
    },
    "AppSignal for Ruby": {
      background: "#fee2e2",
      borderColor: "#fca5a5",
      color: "#991b1b"
    },
    "AppSignal for Rust": {
      background: "#ffedd5",
      borderColor: "#fdba74",
      color: "#9a3412"
    }
  };
  const getPillStyle = name => ({
    ...defaultPillStyle,
    ...pillStyles[name] || ({})
  });
  return <div className="not-prose my-4 rounded-lg border border-zinc-200 bg-zinc-50 px-4 py-3 text-sm dark:border-white/10 dark:bg-white/5">
      <div className="flex flex-wrap items-center gap-x-2 gap-y-1">
        <span className="font-semibold text-zinc-700 dark:text-zinc-200">
          {label}:
        </span>
        {versions.map((v, i) => <span key={`${v.name}-${v.version}-${i}`} className="inline-flex items-center gap-1 rounded-full border px-2 py-0.5 text-xs font-medium" style={getPillStyle(v.name)}>
            <span>{v.name}</span>
            <span className="opacity-70">
              {v.version}
              {v.exact ? "" : "+"}
            </span>
          </span>)}
      </div>
    </div>;
};

[Ruby on Rails](http://rubyonrails.org/) wordt direct ondersteund door AppSignal. Om te installeren, volgt u de installatiestappen in AppSignal, te beginnen met het klikken op 'Add app' op het [accountsscherm](https://appsignal.com/accounts).

De AppSignal-integratie voor Rails werkt door excepties en prestaties in requests te volgen. Wanneer er een fout optreedt in een controller tijdens een request, rapporteert AppSignal deze. Prestatieproblemen worden gebaseerd op de duur van een request en er wordt een tijdlijn met events aangemaakt waarin wordt aangegeven welke onderdelen van de applicatie het langst hebben geduurd.

## Active Job

<Compatibility versions={[{ name: "AppSignal for Ruby", version: "2.11.0" }]} />

Zie onze [Active Job-pagina](/ruby/integrations/active-job) voor meer informatie over hoe onze Active Job-instrumentatie werkt.

## Action Cable

<Compatibility versions={[{ name: "AppSignal for Ruby", version: "2.3.0" }]} />

Zie onze [Action Cable-pagina](/ruby/integrations/action-cable) voor meer informatie over hoe onze Action Cable-instrumentatie werkt.

## AppSignal configureren in een initializer

<Compatibility versions={[{ name: "AppSignal for Ruby", version: "3.12.0" }]} />

We raden aan ons [`config/appsignal.rb`-configuratiebestand](/ruby/configuration/load-order#appsignal-rb-config-file) of [omgevingsvariabelen](/ruby/configuration/load-order#5-environment-variables) te gebruiken om [AppSignal te configureren](/ruby/configuration).
Standaard is het niet mogelijk om AppSignal vanuit een Rails-initializer te configureren, omdat AppSignal wordt geladen vóór de initializers van uw applicatie, om fouten te kunnen rapporteren die tijdens de initialisatie optreden.

Om AppSignal in een Rails-initializer te configureren, configureer Rails dan eerst om AppSignal te starten nadat de initializers van de app zijn uitgevoerd.

<CodeGroup>
  ```ruby Ruby theme={null}
  # config/application.rb

  # ...

  module MyApp
    class Application < Rails::Application
      # Add this line
      config.appsignal.start_at = :after_initialize

      # Other config
    end
  end
  ```
</CodeGroup>

Dan, in de initializer:

<CodeGroup>
  ```ruby Ruby theme={null}
  # config/initializers/appsignal.rb

  Appsignal.configure do |config|
    config.ignore_actions = ["My action"]
  end
  ```
</CodeGroup>

Roep `Appsignal.start` niet aan in de initializers. De Ruby-gem start AppSignal automatisch wanneer Rails alle initializers heeft uitgevoerd.

Wanneer een Rails-app is geconfigureerd om AppSignal te starten nadat de initializers zijn geladen, is het niet langer mogelijk om [fouten uit initializers te rapporteren bij het opstarten van de Rails-app](#error-reporting-from-initializers).

## Foutrapportage vanuit initializers

Standaard rapporteert AppSignal fouten die optreden in controllers, Rake-taken en Active Job-jobs. Het rapporteert geen fouten die optreden wanneer de applicatie opstart, vóór de Rails-initializers. Om op de hoogte te worden gesteld wanneer deze fouten optreden, voegt u het volgende toe aan uw `config.ru`-bestand, rond de regel die het `environment.rb`-bestand requireert.

<CodeGroup>
  ```ruby Ruby theme={null}
  # config.ru
  begin
    require ::File.expand_path("../config/environment",  __FILE__)
  rescue Exception => error
    Appsignal.send_error(error)
    raise
  end
  ```
</CodeGroup>

De fouten die hier optreden, worden niet gegroepeerd onder een incident met een actienaam.

## Backtrace-cleaner

Met de Rails-integratie zal AppSignal de backtrace van elke exceptie door de [Rails backtrace-cleaner][backtrace cleaner docs] halen. Met deze cleaner kunt u ongewenste backtrace-regels wijzigen of uitfilteren, waarmee rommel en ruis uit de backtrace worden verwijderd.

U kunt filters en silencers toevoegen aan of verwijderen uit de standaardconfiguratie.

**Filters** wijzigen de gegeven regel. Een voorbeeld hiervan is het verwijderen van het `Rails.root`-prefix.

**Silencers** verwijderen de regel uit de backtrace, als de gegeven expressie `true` retourneert. U kunt deze extra backtrace-cleaner-regels toevoegen in een initializer.

Bijvoorbeeld:

<CodeGroup>
  ```ruby Ruby theme={null}
  # config/initializers/backtrace_cleaner.rb
  bc = Rails.backtrace_cleaner
  bc.add_filter { |line| line.gsub(Rails.root.to_s, '<root>') }
  bc.add_silencer { |line| line.index('<root>').nil? and line.index('/') == 0 }
  bc.add_silencer { |line| line.index('<root>/vendor/') == 0 }
  ```
</CodeGroup>

Zie de [Rails BacktraceCleaner-documentatie][backtrace cleaner docs] voor meer informatie over de backtrace-cleaner.

## Error reporter

<Compatibility versions={[{ name: "AppSignal for Ruby", version: "3.4.1" }]} />

AppSignal rapporteert standaard fouten die via `ActiveSupport::ErrorReporter` worden gemeld. `ActiveSupport::ErrorReporter` is geïntroduceerd in Rails 7.0 om aangepaste foutrapportage te standaardiseren.

U kunt deze functionaliteit uitschakelen met de configuratieoptie [`enable_rails_error_reporter`](/ruby/configuration/options#option-enable_rails_error_reporter).

Als er een transactie actief is in de context waarin een fout wordt gerapporteerd via de Rails-error-reporter, bevat deze dezelfde metadata en sample-gegevens als de actieve transactie: namespace, actienaam, tags, aangepaste gegevens, parameters, enz.

<CodeGroup>
  ```ruby Ruby theme={null}
  # In both scenarios, the error is reported by AppSignal
  Rails.error.handle do
    raise "some error"
  end

  Rails.error.record do
    raise "some error"
  end
  ```
</CodeGroup>

<Warning>
  In AppSignal voor Ruby-gem versie 3 was sommig gedrag anders. Raadpleeg de
  sectie [Ruby-gem 3 legacy-gedrag](#ruby-gem-3-legacy-behavior) voor meer
  informatie over de verschillen.
</Warning>

### Namespace en actie uit de huidige transactie

Bij het rapporteren van fouten bepalen we de namespace en actienaam waarin deze plaatsvindt, zoals een controller of background job, op basis van best effort. De incident-namespace en actienaam worden niet altijd ingesteld of zijn niet altijd accuraat.

Als een AppSignal-transactie actief is (zoals bij een web request of background job) zal de fout die wordt gerapporteerd met `Rails.error.handle/record` dezelfde namespace, actienaam, tags, parameters, aangepaste gegevens, enz. hebben als de actieve transactie. Als er geen AppSignal-transactie actief is, worden er standaard geen namespace, actienaam, tags, enz. ingesteld.

### Namespace en actie uit de context

Als u de namespace en actienaam van de gerapporteerde fout wilt wijzigen zonder deze op de reeds actieve AppSignal-transactie te wijzigen, kunt u dit aanpassen bij de aanroep van de error-reporter.

<CodeGroup>
  ```ruby Ruby theme={null}
  # The error reported here will have the "custom_namespace" namespace
  # and "CustomizedActionName#index" action name
  Rails.error.handle(:context => { :appsignal => { :namespace => "custom_namespace", :action => "CustomizedActionName#index" } }) do
    raise "some error"
  end
  ```
</CodeGroup>

### Tags uit de actieve transactie

Standaard worden de tags van de transactie van het request/de job gekopieerd naar de AppSignal-transactie van de fout van de error-reporter vanuit de transactie van het request/de job.

<CodeGroup>
  ```ruby Ruby theme={null}
  # Rails controller example using a before_action callback
  class ExamplesController < ApplicationController
    before_action do
      Appsignal.add_tags(:tag1 => "value1", :tag2 => "value2")
    end

    def index
      # The error reported here will have the same tags set
      # as in the `before_action` callback
      Rails.error.handle do
        raise "some error"
      end
    end
  end
  ```
</CodeGroup>

### Tags uit context

U kunt tags toevoegen aan een gerapporteerde fout door `context` te gebruiken in de aanroep van `Rails.error.handle/record`. Deze tags worden alleen ingesteld op de fout die wordt gerapporteerd met de methoden `Rails.error.handle/record`.

<CodeGroup>
  ```ruby Ruby theme={null}
  Rails.error.handle(:context => { :tag1 => "value1", :tag2 => "value2" }) do
    raise "some error"
  end
  ```
</CodeGroup>

Dezelfde tag-beperkingen gelden als voor het gebruik van [`Appsignal.add_tags`](/guides/tagging#ruby).

### Ruby-gem 3 legacy-gedrag

In AppSignal voor Ruby-gem versie 3 is het foutrapportagegedrag anders.

* Fouten die worden gerapporteerd met de methode `Rails.error.handle` worden gerapporteerd aan AppSignal.
* Fouten die worden gerapporteerd met `Rails.error.record` worden niet gerapporteerd aan AppSignal om te voorkomen dat de fout twee keer wordt gerapporteerd wanneer deze door onze Rails-error-reporting-middleware wordt gerapporteerd.

Alle fouten die met de Rails-error-reporter worden gerapporteerd, worden als afzonderlijke fouten gerapporteerd. Ze bevatten niet altijd dezelfde metadata en sample-gegevens uit een actieve AppSignal-transactie. Zie de sectie over [beperkingen van context-overerving](#context-inheritance-limitations) voor meer informatie.

<CodeGroup>
  ```ruby Ruby theme={null}
  # Reported by AppSignal
  Rails.error.handle do
    raise "some error"
  end

  # NOT reported by AppSignal
  Rails.error.record do
    raise "some error"
  end
  ```
</CodeGroup>

#### Beperkingen van context-overerving

In Ruby-gem 3 is de overerving van context uit de actieve transactie beperkt. De metadata en een deel van de sample-gegevens worden alleen gekopieerd als deze zijn ingesteld op het moment dat `Rails.error.handle/record` wordt aangeroepen.

In de praktijk betekent dit dat Rails-controllers en Active Job-jobs nauwkeurig worden gerapporteerd. Bij andere bibliotheken zoals Sidekiq-jobs wordt er geen actienaam ingesteld bij het rapporteren van fouten met `Rails.error.handle`.

Tags die worden ingesteld nadat `Rails.error.handle/record` is aangeroepen, worden niet gerapporteerd voor de fout die met deze helper wordt gerapporteerd.

## Runners

<Compatibility versions={[{ name: "AppSignal for Ruby", version: "4.0.0" }]} />

AppSignal rapporteert automatisch fouten binnen [Rails-runners](https://guides.rubyonrails.org/command_line.html#bin-rails-runner). Er is ook enige handmatige configuratie nodig om de prestaties van een runner te instrumenteren.

We raden aan om de code van de runner in een apart bestand te plaatsen en in te pakken in de [`Appsignal.monitor`-helper](/ruby/instrumentation/background-jobs), zoals in het onderstaande voorbeeld.

```bash Bash theme={null}
bin/rails runner path_to_file.rb
```

<CodeGroup>
  ```ruby Ruby theme={null}
  Appsignal.monitor(:namespace => :runner, :action => "Runner name") do
    # Some code
  end
  ```
</CodeGroup>

Als uw Rails-runner draait op een container die alleen wordt gestart om deze taak uit te voeren, zorg er dan voor dat [de optie `enable_at_exit_hook`](/ruby/configuration/options#option-enable_at_exit_hook) op `true` staat (wat de standaard zou moeten zijn op containers). Dit zorgt ervoor dat de gegevens worden doorgespoeld naar de AppSignal-agent voordat de runner wordt afgesloten.

[backtrace cleaner docs]: https://api.rubyonrails.org/classes/ActiveSupport/BacktraceCleaner.html

[error reporter]: https://guides.rubyonrails.org/error_reporting.html