> ## 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/) wird von AppSignal out-of-the-box unterstützt. Folgen Sie zur Installation den Installationsschritten in AppSignal, beginnend mit einem Klick auf „Add app" auf dem [Accounts-Bildschirm](https://appsignal.com/accounts).

Die AppSignal-Integration für Rails funktioniert, indem sie Ausnahmen und Performance in Anfragen erfasst. Wenn während einer Anfrage in einem Controller ein Fehler auftritt, meldet AppSignal ihn. Performance-Probleme basieren auf der Dauer einer Anfrage und erzeugen eine Zeitleiste von Events, die zeigt, welche Teile der Anwendung am längsten gedauert haben.

## Active Job

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

Weitere Informationen zur Funktionsweise unserer Active-Job-Instrumentation finden Sie auf unserer [Active-Job-Seite](/ruby/integrations/active-job).

## Action Cable

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

Weitere Informationen zur Funktionsweise unserer Action-Cable-Instrumentation finden Sie auf unserer [Action-Cable-Seite](/ruby/integrations/action-cable).

## AppSignal in einem Initializer konfigurieren

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

Wir empfehlen die Verwendung unserer [`config/appsignal.rb`-Konfigurationsdatei](/ruby/configuration/load-order#appsignal-rb-config-file) oder von [Umgebungsvariablen](/ruby/configuration/load-order#5-environment-variables), um [AppSignal zu konfigurieren](/ruby/configuration).
Standardmäßig ist es nicht möglich, AppSignal aus einem Rails-Initializer heraus zu konfigurieren, da AppSignal vor den Initializern Ihrer Anwendung geladen wird, um Fehler melden zu können, die während der Initialisierung auftreten.

Um AppSignal in einem Rails-Initializer zu konfigurieren, konfigurieren Sie zunächst Rails so, dass AppSignal nach dem Ausführen der App-Initializer gestartet wird.

<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>

Dann im Initializer:

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

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

Rufen Sie `Appsignal.start` nicht in den Initializern auf. Das Ruby-Gem startet AppSignal automatisch, wenn Rails alle Initializer ausgeführt hat.

Wenn eine Rails-App so konfiguriert ist, dass AppSignal nach dem Laden der Initializer gestartet wird, ist es nicht mehr möglich, [Fehler aus Initializern beim Booten der Rails-App zu melden](#error-reporting-from-initializers).

## Fehlerberichterstattung aus Initializern

Standardmäßig meldet AppSignal Fehler, die in Controllern, Rake-Tasks und Active-Job-Jobs auftreten. Es meldet keine Fehler, die beim Starten der Anwendung auftreten, also vor den Rails-Initializern. Um auch über solche Fehler benachrichtigt zu werden, fügen Sie Folgendes zu Ihrer `config.ru`-Datei hinzu, in der Nähe der Zeile, die die `environment.rb`-Datei anfordert.

<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>

Die hier auftretenden Fehler werden nicht unter einem Incident mit einem Action-Namen gruppiert.

## Backtrace-Cleaner

Mit der Rails-Integration lässt AppSignal den Backtrace jeder Ausnahme durch den [Rails Backtrace-Cleaner][backtrace cleaner docs] laufen. Dieser Cleaner gibt Ihnen die Möglichkeit, unerwünschte Backtrace-Zeilen zu modifizieren oder herauszufiltern, um Unordnung und Rauschen aus dem Backtrace zu entfernen.

Sie können Filter und Silencer zur Standardkonfiguration hinzufügen oder entfernen.

**Filter** ändern die gegebene Zeile. Ein Beispiel wäre das Entfernen des `Rails.root`-Präfixes.

**Silencer** entfernen die Zeile aus dem Backtrace, wenn der gegebene Ausdruck `true` zurückgibt. Sie können diese zusätzlichen Backtrace-Cleaner-Regeln in einem Initializer hinzufügen.

Zum Beispiel:

<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>

Weitere Informationen zum Backtrace-Cleaner finden Sie in der [Dokumentation zum Rails BacktraceCleaner][backtrace cleaner docs].

## Error Reporter

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

AppSignal meldet standardmäßig Fehler, die über `ActiveSupport::ErrorReporter` ausgelöst werden. `ActiveSupport::ErrorReporter` wurde in Rails 7.0 eingeführt, um die benutzerdefinierte Fehlerberichterstattung zu standardisieren.

Sie können diese Funktionalität mit der Konfigurationsoption [`enable_rails_error_reporter`](/ruby/configuration/options#option-enable_rails_error_reporter) deaktivieren.

Wenn in dem Kontext, in dem ein Fehler über den Rails Error Reporter gemeldet wird, eine Transaktion aktiv ist, enthält dieser dieselben Metadaten und Sample-Daten wie die aktive Transaktion: Namespace, Action-Name, Tags, Custom Data, Parameter usw.

<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 für Ruby Gem Version 3 war einiges Verhalten anders. Bitte
  konsultieren Sie den Abschnitt [Legacy-Verhalten Ruby Gem 3](#ruby-gem-3-legacy-behavior)
  für weitere Informationen zu den Unterschieden.
</Warning>

### Namespace und Action aus der aktuellen Transaktion

Beim Melden von Fehlern bestimmen wir den Namespace und den Action-Namen, in dem der Fehler auftritt, wie z. B. einen Controller oder einen Background-Job, nach bestem Wissen. Der Incident-Namespace und der Action-Name werden nicht immer gesetzt oder sind genau.

Wenn eine AppSignal-Transaktion aktiv ist (etwa bei einer Web-Anfrage oder einem Background-Job), hat der mit `Rails.error.handle/record` gemeldete Fehler denselben Namespace, Action-Namen, dieselben Tags, Parameter, Custom Data usw. wie die aktive Transaktion. Wenn keine AppSignal-Transaktion aktiv ist, werden standardmäßig kein Namespace, Action-Name, keine Tags usw. gesetzt.

### Namespace und Action aus dem Kontext

Wenn Sie den Namespace und den Action-Namen des gemeldeten Fehlers ändern möchten, ohne sie in der bereits aktiven AppSignal-Transaktion zu ändern, können Sie dies beim Aufruf des Error Reporters anpassen.

<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 aus der aktiven Transaktion

Standardmäßig werden die Tags der Request-/Job-Transaktion aus der Request-/Job-Transaktion auf die AppSignal-Transaktion des Fehlers im Error Reporter kopiert.

<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 aus dem Kontext

Sie können einem gemeldeten Fehler Tags hinzufügen, indem Sie `context` im Aufruf von `Rails.error.handle/record` verwenden. Diese Tags werden nur für den mit den Methoden `Rails.error.handle/record` gemeldeten Fehler gesetzt.

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

Es gelten dieselben Einschränkungen für das Tagging wie bei der Verwendung von [`Appsignal.add_tags`](/guides/tagging#ruby).

### Legacy-Verhalten Ruby Gem 3

In AppSignal für Ruby Gem Version 3 ist das Verhalten der Fehlerberichterstattung anders.

* Mit der Methode `Rails.error.handle` gemeldete Fehler werden an AppSignal gemeldet.
* Mit `Rails.error.record` gemeldete Fehler werden nicht an AppSignal gemeldet, um zu vermeiden, dass der Fehler zweimal gemeldet wird, wenn er von unserer Rails-Fehlerberichterstattungs-Middleware gemeldet wird.

Alle mit dem Rails Error Reporter gemeldeten Fehler werden als separate Fehler gemeldet. Sie enthalten nicht immer dieselben Metadaten und Sample-Daten aus einer aktiven AppSignal-Transaktion. Weitere Informationen finden Sie im Abschnitt zu [Einschränkungen bei der Kontextvererbung](#context-inheritance-limitations).

<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>

#### Einschränkungen bei der Kontextvererbung

In Ruby Gem 3 ist die Kontextvererbung aus der aktiven Transaktion eingeschränkt. Die Metadaten und einige der Sample-Daten werden nur dann kopiert, wenn sie zum Zeitpunkt des Aufrufs von `Rails.error.handle/record` gesetzt sind.

In der Praxis bedeutet dies, dass Rails-Controller und Active-Job-Jobs korrekt gemeldet werden. Für andere Bibliotheken wie Sidekiq-Jobs wird beim Melden von Fehlern mit `Rails.error.handle` kein Action-Name gesetzt.

Tags, die nach dem Aufruf von `Rails.error.handle/record` gesetzt werden, werden für den über diesen Helper gemeldeten Fehler nicht gemeldet.

## Runners

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

AppSignal meldet automatisch Fehler innerhalb von [Rails-Runners](https://guides.rubyonrails.org/command_line.html#bin-rails-runner). Für die Instrumentation der Runner-Performance ist außerdem manuelles Setup erforderlich.

Wir empfehlen, den Code des Runners in eine separate Datei zu schreiben und ihn mit dem Helper [`Appsignal.monitor`](/ruby/instrumentation/background-jobs) zu umschließen, wie im folgenden Beispiel gezeigt.

```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>

Wenn Ihr Rails-Runner auf einem Container läuft, der nur gestartet wird, um diesen Task auszuführen, stellen Sie sicher, dass die [Option `enable_at_exit_hook`](/ruby/configuration/options#option-enable_at_exit_hook) auf `true` gesetzt ist (was auf Containern der Standardwert sein sollte). Dadurch wird sichergestellt, dass die Daten an den AppSignal-Agent gesendet werden, bevor der Runner beendet wird.

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

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