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

# AppSignal für Rails installieren

> Folgen Sie Chris Oliver bei der Installation und Konfiguration von AppSignal in einer Rails-Anwendung.

export const YouTube = ({id, title, description, presenter, duration, republished}) => {
  const playlistId = "PLFHQSOKTqHXA";
  const playlistUrl = `https://www.youtube.com/playlist?list=${playlistId}`;
  if (!id || id === "YOUTUBE_ID") {
    return <div style={{
      border: "1px dashed currentColor",
      borderRadius: "0.5rem",
      opacity: 0.7,
      padding: "2rem 1.5rem",
      textAlign: "center",
      fontSize: "0.875rem"
    }}>
        <strong>Video not published yet.</strong>
        <br />
        {title ? `"${title}" has no YouTube id.` : "This tutorial has no YouTube id."}{" "}
        Replace <code>YOUTUBE_ID</code> in this page with the id from the
        video's URL, once it is in the{" "}
        <a href={playlistUrl}>GoRails x AppSignal playlist</a>.
      </div>;
  }
  const prettyDate = republished ? new Date(`${republished}T00:00:00Z`).toLocaleDateString("en-US", {
    year: "numeric",
    month: "long",
    day: "numeric",
    timeZone: "UTC"
  }) : null;
  const schema = {
    "@context": "https://schema.org",
    "@type": "VideoObject",
    name: title,
    embedUrl: `https://www.youtube-nocookie.com/embed/${id}`,
    contentUrl: `https://www.youtube.com/watch?v=${id}`,
    thumbnailUrl: [`https://i.ytimg.com/vi/${id}/maxresdefault.jpg`],
    creator: {
      "@type": "Organization",
      name: "GoRails",
      url: "https://gorails.com"
    },
    publisher: {
      "@type": "Organization",
      name: "AppSignal",
      url: "https://appsignal.com"
    }
  };
  if (description) schema.description = description;
  if (duration) schema.duration = duration;
  if (republished) schema.uploadDate = republished;
  if (presenter) schema.author = {
    "@type": "Person",
    name: presenter
  };
  return <div style={{
    marginBottom: "1.5rem"
  }}>
      <iframe width="100%" height="450" src={`https://www.youtube-nocookie.com/embed/${id}?list=${playlistId}`} title={title} style={{
    borderRadius: "0.5rem",
    border: 0,
    display: "block"
  }} allow="accelerometer; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerPolicy="strict-origin-when-cross-origin" allowFullScreen />
      <p style={{
    fontSize: "0.875rem",
    marginTop: "0.5rem"
  }}>
        <a href={`https://www.youtube.com/watch?v=${id}&list=${playlistId}`}>{`Watch "${title}" on YouTube`}</a>
      </p>
      <script type="application/ld+json" dangerouslySetInnerHTML={{
    __html: JSON.stringify(schema)
  }} />
    </div>;
};

<YouTube id="-QEw0DsvVw0" title="AppSignal für Rails installieren" description="Folgen Sie Chris Oliver bei der Installation und Konfiguration von AppSignal in einer Rails-Anwendung." presenter="Chris Oliver" duration="PT13M19S" republished="2026-09-25" />

Vorgestellt von Chris Oliver für [GoRails](https://gorails.com). Erneut veröffentlicht auf AppSignal am 25. September 2026.

Sie haben monatelang an Ihrer App-Idee gearbeitet. Sie bringen sie in Produktion und testen die Registrierung sowie die anderen Funktionen, um sicherzustellen, dass alles funktioniert. Dann veröffentlichen Sie Ihr Produkt. Menschen beginnen sich zu registrieren, was großartig ist. Doch dann tauchen in Ihrem Posteingang Nachrichten von Kunden mit Beschwerden auf:

* Seiten laden sehr langsam.
* Wenn ich versuche, mein Passwort zurückzusetzen, kommt die E-Mail zum Abschluss des Vorgangs nie an.
* Ist die App kaputt?

In diesem Moment merken Sie, dass Ihnen die Sichtbarkeit in die Produktion fehlt, und erkennen, dass Sie sich bei AppSignal anmelden müssen.

Chris installiert das `appsignal`-Gem in einer Ruby-on-Rails-Anwendung, die auf Hatchbox bereitgestellt ist. Er konfiguriert es von Hand, damit Sie sehen, was jede Option bewirkt. Anschließend deployt er sie und nutzt AppSignal, um einen Fehler zu finden, auf den seine Nutzer gestoßen sind.

<Tip>
  Möchten Sie die Einrichtung einem KI-Coding-Agenten überlassen? Folgen Sie [Eine neue Anwendung mit KI einrichten](/guides/install-with-agents).
</Tip>

<h2 id="what-this-covers">
  Was dieses Tutorial behandelt
</h2>

* Das AppSignal-Gem für Ruby hinzufügen und den Installationsbefehl ausführen.
* Festlegen, welche Umgebungen an AppSignal berichten.
* Ihren Push API key mit Rails' verschlüsselten Credentials aus Ihrem Repository heraushalten.
* Störende Aktionen und Namespaces ignorieren und bei jedem Deployment eine Revision melden.
* Bestätigen, dass Daten ankommen, und dann den ersten echten Fehler untersuchen, auf den Ihre Nutzer gestoßen sind.

<h2 id="requirements">
  Voraussetzungen
</h2>

| Was | Wert |
| - | - |
| Framework | Ruby on Rails |
| Gem | `appsignal` |
| Konto | Ein AppSignal-Konto, für dessen Push API key |

<h2 id="install-appsignal">
  AppSignal installieren
</h2>

Wählen Sie nach der Registrierung das Framework oder die Sprache, die Ihre App verwendet. In diesem Walkthrough ist das eine Ruby-on-Rails-App, die auf Hatchbox bereitgestellt ist. Der [KI-Setup-Flow von AppSignal](/guides/install-with-agents) kann das auch anhand der Umgebung Ihrer App erkennen und die Installation ausführen. Oder Sie gehen den klassischen Weg, wie in diesem Walkthrough, und installieren alles manuell über den UI-Flow von AppSignal:

1. Wählen Sie zunächst **Add app** und dann Ruby & Rails aus.

2. Fügen Sie das AppSignal-Ruby-Integrations-Gem wie folgt zu Ihrem Gemfile hinzu:

   ```rb theme={null}
   # Gemfile
   source "https://rubygems.org"
   gem "appsignal"
   ```

3. Führen Sie `bundle install` aus, um das AppSignal-Ruby-Gem herunterzuladen und zu installieren.

4. Konfigurieren Sie es abschließend mit dem [Push API key](https://appsignal.com/redirect-to/organization?to=admin/api_keys) Ihrer Organisation.

   ```bash theme={null}
   bundle exec appsignal install <YOUR_PUSH_API_KEY>
   ```

Der Installationsbefehl überprüft Ihren Push API key. Anschließend fragt er, ob Sie einen freundlicheren Namen für Ihre App möchten und welche Konfigurationsdatei Sie verwenden möchten. Dieser Walkthrough lehnt die Umbenennung ab und wählt die Ruby-Konfigurationsdatei, sodass `config.name` den vom Installer erkannten Namen behält. Der Assistent sendet anschließend einen Beispielfehler an AppSignal. Er prüft Ihre Installation, indem er wartet, bis dieser Fehler ankommt.

Die aktuellsten detaillierten Befehle und Anforderungen finden Sie in der Dokumentation zur [Installation von AppSignal für Ruby](/ruby/installation).

<h2 id="using-the-ruby-configuration-file">
  Die Ruby-Konfigurationsdatei verwenden
</h2>

Der Installationsbefehl schreibt Ihre Antworten in `config/appsignal.rb`. Da die Konfiguration eine Ruby-Datei ist, wird jede Änderung, die Sie vornehmen, in Ihrem Git-Repository gespeichert. Das hilft, falls Sie später Dinge ändern oder rückgängig machen möchten.

Standardmäßig aktiviert sich AppSignal nur in den Umgebungen `development` und `production`.

<Tip>
  Normalerweise dienen Entwicklungsumgebungen zum Testen, wobei auch mal etwas kaputtgehen darf. Sie könnten zum Beispiel die Standardumgebung `"development"` durch `"staging"` ersetzen. Dann können Sie Fehler abfangen und beheben, bevor sie in die Produktion gelangen.
</Tip>

```rb theme={null}
# Visit our documentation for a list of all available configuration options.
# https://docs.appsignal.com/ruby/configuration/options.html
   Appsignal.configure do |config|
      config.activate_if_environment("staging", "production")

      config.name = "AppsignalExample"
```

<h3 id="storing-credentials-safely">
  Credentials sicher speichern
</h3>

Führen Sie `rails credentials:edit` aus, um Ihren Editor zu öffnen, fügen Sie Ihren AppSignal Push API key ein und speichern Sie ihn als Secret.
Kopieren Sie anschließend den Inhalt von `config/master.key` in Ihre Zwischenablage. Führen Sie unter macOS `cat config/master.key | pbcopy` aus. Gehen Sie dann zu Ihrer Hosting-Umgebung, zum Beispiel Hatchbox, und legen Sie ihn als Umgebungsvariable `RAILS_MASTER_KEY` fest.

```yaml theme={null}
# smtp:
#   user_name: my-smtp-user
#   password: my-smtp-password
#
# aws:
#   access_key_id: 123
#   secret_access_key: 345

# Used as the base secret for all MessageVerifiers in Rails, including
# the one protecting cookies.
secret_key_base: <YOUR_SECRET_KEY_BASE>

appsignal:
  api_key: "<YOUR_PUSH_API_KEY>"
```

```rb theme={null}
  # Your application's Push API key
  # We recommend removing this line and setting this option with the
  # APPSIGNAL_PUSH_API_KEY environment variable instead
  # This will use Rails' encrypted credentials so you can manage them safely in your repository
  # https://docs.appsignal.com/ruby/configuration/options.html#option-push_api_key
      config.push_api_key = Rails.application.credentials.dig(:appsignal, :api_key)
```

<h3 id="ignoring-actions-namespaces-and-configuring-a-revision-file">
  Aktionen und Namespaces ignorieren und eine Revisionsdatei konfigurieren
</h3>

Neue Rails-Anwendungen haben eine Standardroute namens `/up`, die Sie in `config/routes.rb` sehen können. Sie ist in Rails eingebaut und gibt einen `200`- oder `500`-Status zurück, um zu zeigen, ob Ihre Anwendung läuft. Das ist nützlich für Uptime- und Health-Checks durch Ihren Load Balancer, um zu prüfen, ob Ihre App live ist. Ihr Load Balancer ruft diese Route alle paar Sekunden auf. Sie müssen diese Route – oder andere sehr stark frequentierte Routen – nicht immer an AppSignal melden.

Alternativ können Sie AppSignal Daten sammeln und Ihre App in den nächsten 24 Stunden überwachen lassen. Sehen Sie, was gemeldet wird, und stimmen Sie es später fein ab.

```rb theme={null}
  # Configure actions that should not be monitored by AppSignal.
  # For more information see our docs:
  # https://docs.appsignal.com/ruby/configuration/ignore-actions.html
      config.ignore_actions << "Rails::HealthController#show"
```

Ignorieren Sie alle Metriken und Action-Cable-Nachrichten, die zum Namespace `action_cable` gehören. Das kann sinnvoll sein, weil WebSockets in Rails Action Cable wahrscheinlich eine erhebliche Menge an Rauschen erzeugen. Nehmen wir an, Ihre Hatchbox-Anwendung sendet ständig Echtzeitereignisse und Log-Nachrichten an Browser. Das könnte Ihr AppSignal-Kontingent aufbrauchen, wenn dieser Namespace aktiviert ist.

Schließlich schreibt Ihr Hatchbox-Deployment eine Revisionsdatei, die Ihren Git-Commit-SHA enthält. `config.revision` liest diese Datei, sodass AppSignal alle Metriken, Fehler, Logs und alles andere, was gemeldet wird, mit diesem Deployment verknüpft.

Verwenden Sie diese Datei, um die Fehler nachzuverfolgen, die Sie beheben und für die Sie Änderungen deployen. Falls sie nach Ihrem Deployment zurückkehren, teilt Ihnen AppSignal mit, dass diese Fehler nicht wirklich behoben wurden.

```rb theme={null}
  # Configure errors that should not be recorded by AppSignal.
  # For more information see our docs:
  # https://docs.appsignal.com/ruby/configuration/ignore-errors.html
      config.ignore_errors << "MyCustomError"

      config.ignore_namespaces << "action_cable"

      config.revision = File.read("REVISION")
end
```

Hier ist die vollständige Datei aus unserem Walkthrough.

```rb theme={null}
# Visit our documentation for a list of all available configuration options.
# https://docs.appsignal.com/ruby/configuration/options.html
   Appsignal.configure do |config|
      config.activate_if_environment("staging", "production")

      config.name = "AppsignalExample"

  # Your application's Push API key
  # We recommend removing this line and setting this option with the
  # APPSIGNAL_PUSH_API_KEY environment variable instead
  # This will use Rails' encrypted credentials so you can manage them safely in your repository
  # https://docs.appsignal.com/ruby/configuration/options.html#option-push_api_key
      config.push_api_key = Rails.application.credentials.dig(:appsignal, :api_key)

  # Configure actions that should not be monitored by AppSignal.
  # For more information see our docs:
  # https://docs.appsignal.com/ruby/configuration/ignore-actions.html
      config.ignore_actions << "Rails::HealthController#show"

  # Configure errors that should not be recorded by AppSignal.
  # For more information see our docs:
  # https://docs.appsignal.com/ruby/configuration/ignore-errors.html
      config.ignore_errors << "MyCustomError"

      config.ignore_namespaces << "action_cable"
      config.revision = File.read("REVISION")
end
```

Committen Sie die Konfiguration und pushen Sie sie in Ihr Repository:

```bash theme={null}
git add .
git commit -m "Add appsignal"
git push
```

<h2 id="deploy-your-app">
  Ihre App deployen
</h2>

Nachdem Sie in Ihr Git-Repository gespeichert haben, wechseln Sie zu Ihrer Deployment- und Server-Management-Plattform, etwa Hatchbox. Stellen Sie sicher, dass Ihr Rails-Master-Key-Wert mit `config/master.key` übereinstimmt, und deployen Sie dann Ihre App.
Sie sollten sehen, wie eine `production`-Umgebung zu AppSignal hinzugefügt wird. Sie erscheint neben Ihrer `development`-Umgebung und dem Demo-Fehler, den Sie beim Installieren gesendet haben. Sobald Ihr Deployment bereit ist, zeigt AppSignal die Metriken und Requests Ihrer App auf den Dashboards an. Wechseln Sie zur `production`-Umgebung, um zu beobachten, wie Requests eintreffen.

<h2 id="find-the-error-your-users-reported">
  Den von Ihren Nutzern gemeldeten Fehler finden
</h2>

Anschließend können Sie versuchen, den Fehler nachzustellen, den Ihre Nutzer erhalten haben, etwa die nie angekommene Passwort-Reset-E-Mail:

1. Gehen Sie zu Ihren Dashboards und prüfen Sie das Diagramm „Error rate (%)". AppSignal trennt Web-Requests von Background-Jobs, etwa Solid Queue, in eigene Namespaces.

2. Wählen Sie Errors > Issue list aus und öffnen Sie den Fehler, den Sie genauer untersuchen möchten. Er zeigt die Fehlermeldung und den Backtrace, zum Beispiel „Make sure your API key is set".

3. Setzen Sie in Hatchbox den fehlenden Resend-API-Key in Ihren Environment Variables und speichern Sie ihn. Das behebt den Fehler, den Ihre Nutzer erhalten haben.

   In diesem Walkthrough gehört der fehlende Key zu Resend, dem Dienst, über den die App E-Mails versendet. Erstellen Sie in Resend einen API-Key mit Sendeberechtigung für alle Domains und legen Sie ihn dann in Hatchbox fest. Solange Sie keine Domain verifiziert haben, liefert ein Resend-Testkonto nur an seine eigene Testadresse aus. Senden Sie das Passwort-Reset an `delivered@resend.dev`, und prüfen Sie, ob die E-Mail in Ihrem Resend-Dashboard ankommt.

4. Gehen Sie zurück zu Errors > Issue list in AppSignal und markieren Sie in den Settings des Fehlers dessen Status als „Closed".

AppSignal-Dashboards zeigen außerdem für jedes Deployment und jede Revision, die Sie vornehmen, einen [Marker](/guides/deploy-markers) an. Sie können die Fehler zwischen den Deployments sehen. Der Throughput zeigt an, ob es nach dem Deployment einer neuen Funktion langsamer geworden ist. Es gibt noch viel mehr, was Sie mit AppSignal in Ihrer App tun und untersuchen können. [Intelligence dashboards](/metrics/intelligence-dashboards) werden außerdem automatisch für die Rails-Funktionen erzeugt, die AppSignal erkennt. In diesem Walkthrough erkannte es, dass Active Job E-Mails versendet, und erzeugte Dashboards für Action Mailer und Active Job. Jedes hat sein eigenes Dashboard, das zeigt, was in diesem Teil Ihrer Rails-Anwendung passiert. Um tiefer in Ihr bevorzugtes Framework und Ihre Sprache einzutauchen, lesen Sie die Dokumentation [AppSignal für Ruby](/ruby). Sie beschreibt, wie AppSignal sich in Ihre Anwendung integriert und Ihnen Sichtbarkeit dafür bietet.

<h2 id="transcript">
  Transkript
</h2>

Aus dem Video transkribiert und leicht bearbeitet. Die automatischen Untertitel haben mehrere Produkt- und API-Namen falsch verstanden, und diese wurden korrigiert.

<Accordion title="Transkript lesen">
  **0:00** Stellen Sie sich vor: Sie haben monatelang an Ihrer Produktidee gearbeitet, und sie ist endlich fertig. Sie haben sie in Produktion gebracht, sich registriert, alles getestet, und es sieht so aus, als würde es großartig funktionieren. Also schicken Sie es an Ihre Freunde, Ihre Familie, Ihren E-Mail-Newsletter, Ihre Social-Media-Accounts, um Nutzer zu gewinnen, und Menschen beginnen sich zu registrieren, was gut ist.

  **0:18** Bis Sie Nachrichten von Leuten bekommen, die sagen: „Hey, diese Seite lädt wirklich langsam", oder so etwas wie: „Hey, ich habe versucht, mein Passwort zurückzusetzen", und die E-Mail einfach nie ankam. „Ist es kaputt? Was ist da los?" Und Sie merken: „Ich habe überhaupt keine Sichtbarkeit in die Produktion. Was mache ich jetzt?" Nun, Sie registrieren sich bei AppSignal.

  **0:39** Also heute werden wir AppSignal auf unserer Procrastinate-App hier installieren, und wir werden gleich loslegen, indem wir uns natürlich zuerst bei AppSignal registrieren und es dann in unserer App installieren. Wenn Sie das tun, können Sie dem Framework oder der Sprache Ihrer Wahl folgen, bei uns ist es Ruby on Rails, aber ich würde einfach empfehlen, ihren KI-Prompt dafür zu verwenden.

  **1:00** Sie haben also Docs und einen Prompt und alles bereit, sodass Sie das einfach kopieren und einfügen können, in Claude Code oder Codex oder was auch immer Sie verwenden, und es wird die Installation für Sie erledigen. Natürlich kann es auch Dinge konfigurieren, sodass Sie es bitten können, Dinge feinabzustimmen, aber wir werden es auf die harte, altmodische Art manuell machen, damit Sie genau sehen können, was im Hintergrund passiert.

  **1:24** Alles, was wir tun müssen, ist die Bibliothek hinzuzufügen, also `bundle add appsignal` lädt das AppSignal-Ruby-Gem herunter und installiert es, damit wir es verwenden können, und dann müssen wir es natürlich so konfigurieren, dass es unseren API-Key verwendet. Und genau das wird dieser Installationsbefehl tun: Er wird unseren API-Key überprüfen, uns fragen, ob wir einen freundlicheren Namen für unsere App möchten, wir sagen nein, und dann, wie wir sie konfigurieren möchten.

  **1:47** Wir verwenden die Ruby-Konfigurationsdatei, sodass alles, was wir tun, in unserem Git-Repository gespeichert wird, was später praktisch ist, wenn wir das ändern, vielleicht wollen wir ein paar Dinge rückgängig machen oder so, und das wird einen Beispielfehler übermitteln. Lassen Sie uns also mit diesem Assistenten weitermachen, und Sie werden etwas mehr darüber lernen, wie AppSignal funktioniert, aber dann wird er die Installation überprüfen, er sucht nach diesem Beispielfehler, der bei unserer Installation übermittelt wurde.

  **2:13** Während das passiert, öffnen wir `config/appsignal.rb` und schauen uns die Standardkonfiguration an. Zunächst aktiviert sich das nur, wenn wir uns in einer dieser vorkonfigurierten Umgebungen befinden, also development und production. Natürlich sind wir auf unserer lokalen Maschine in development, aber in Produktion auf einem Server haben wir die production-Umgebung.

  **2:36** Nun, mir liegt nicht besonders viel daran, Fehler in development zu verfolgen, weil ich beim Entwickeln von Funktionen oft Dinge kaputt mache, und das würde Metriken und Fehler und alles Mögliche an AppSignal senden, und die brauche ich nicht, ich werde sie mir ohnehin nicht wirklich ansehen. Also entferne ich das, und ich könnte es zum Beispiel durch staging ersetzen, sodass meine staging-Umgebung Fehler und alles Weitere meldet, damit ich diese abfangen und beheben kann, bevor sie zum Beispiel in die Produktion gelangen.

  **3:03** Dann können Sie es hier natürlich auch umbenennen, und Ihr Push API key ist das, was Ihnen erlaubt, Daten an AppSignal zu senden. Das wollen wir jetzt eigentlich entfernen, wir wollen nicht, dass es hart codiert ist, also schreiben wir `Rails.application.credentials.dig(:appsignal, :api_key)`. Das wird Rails' verschlüsselte Credentials verwenden, sodass wir dieses Secret schön sicher in den verschlüsselten Credentials in unserem Git-Repository speichern können.

  **3:35** Also wechseln wir zu unserem anderen Tab hier und schreiben `rails credentials:edit`, das öffnet unseren Editor, wir gehen ganz nach unten und fügen die passenden Keys hinzu, AppSignal API key, und fügen das Secret ein. Wir speichern das, und dann müssen wir nur noch die Ausgabe von `config/master.key` nehmen, ich bin auf einem Mac, also kann ich `pbcopy` verwenden, um es in die Zwischenablage zu kopieren, und dann gehen Sie in Ihre Hosting-Umgebung.

  **4:07** Bei uns ist das Hatchbox, und Sie legen `RAILS_MASTER_KEY` als Umgebungsvariable mit diesem Wert fest. Machen Sie das also, ich habe meinen bereits eingerichtet, also muss ich das nicht tun, aber wir machen hier in der AppSignal-Konfiguration weiter.

  **4:23** Es gibt noch ein paar andere Dinge, die Sie beim Einrichten Ihrer AppSignal-Konfiguration beachten sollten. Eines davon ist, dass Sie wahrscheinlich so etwas wie den Health-Controller, die show-Action, ignorieren lassen möchten. Schauen wir uns dazu unsere Routes-Datei an, damit Sie genau sehen, was das macht.

  **4:44** In einer neuen Rails-Anwendung haben Sie seit dem Erscheinen von Kamal jetzt eine Standardroute namens `/up`, die zu einem in Rails eingebauten Controller führt, der einfach sagt: „Hey, deine Rails-Anwendung läuft." Das ist nützlich für Uptime-Checks oder Health-Checks durch Ihren Load Balancer oder was auch immer, und diese Route macht eigentlich nichts, ist aber nützlich. Sie ist also wichtig und wird oft aufgerufen, besonders wenn sie in einem Load Balancer eingesetzt wird, der aktive Health-Checks durchführt.

  **5:13** Diese Route wird einfach alle paar Sekunden aufgerufen und fragt: „Bist du noch am Leben? Bist du noch am Leben?" Ja, ich bin noch am Leben, aber wir brauchen diese Daten nicht wirklich an AppSignal zu melden, deshalb ignoriere ich das gerne. Andere Routen, die sehr stark frequentiert sind und die Sie ignorieren möchten, könnten Sie hier hinzufügen, aber ich würde sagen: Lassen Sie es erst mal in Ruhe und schauen Sie, was in Produktion passiert, welche Daten AppSignal in den nächsten vier Stunden oder 24 Stunden sammelt, was auch immer, und dann können Sie später feinabstimmen.

  **5:44** Und natürlich können Sie KI verwenden, um das zu analysieren und die Dinge entsprechend feinabzustimmen. Genauso beim Ignorieren von Fehlern: Normalerweise würde ich dieser Liste nichts hinzufügen, es sei denn, ich wüsste wirklich von etwas Bestimmtem, das wir ignorieren wollten, denn wir wollen offensichtlich Fehler verfolgen und beheben, also wollen wir so viel wie möglich sammeln, besonders bei Fehlern.

  **6:06** Eine Sache, die wir vielleicht nicht sammeln möchten, betrifft `ignore_namespaces`: Wir können sagen, dass wir alle Action-Cable-Nachrichten und -Metriken, die damit zusammenhängen, ignorieren möchten, sodass alles in diesem Namespace in AppSignal ignoriert wird. Und das ist wichtig, denn wenn Sie WebSockets in Rails Action Cable verwenden, dem Framework dafür, wird das wahrscheinlich sehr viel Rauschen erzeugen.

  **6:33** In unserer Hatchbox-Anwendung senden wir ständig Echtzeitereignisse und Log-Nachrichten an den Browser, und wenn wir AppSignal installieren und das nicht aktiviert haben, verbrauchen wir unser Kontingent wirklich sehr schnell. Sie möchten das wahrscheinlich bei der Erstinstallation weglassen und später, nach einer Stunde oder zwei oder einem Tag, zurückkommen und so etwas hinzufügen. Sobald Sie Zeit hatten zu sehen, was wir tatsächlich melden, was wirklich stark frequentiert ist, ob wir unser Kontingent und unseren AppSignal-Plan aufbrauchen, können wir feinabstimmen.

  **7:09** Gut, zu guter Letzt möchte ich `config.revision` erwähnen. So wie Hatchbox deployt, erstellen wir eine Revisionsdatei, die den Git-Commit-SHA anzeigt oder enthält, den Sie deployt haben. Es gibt viele Wege, darauf zuzugreifen. Jeder Hosting-Anbieter ist ein bisschen anders. Manche verwenden Umgebungsvariablen, wir auch. Aber Sie können das auch anpassen, etwa mit einem Datei-Read der Revisionsdatei, und das dann als das Deployment schreiben lassen, mit dem alle Metriken, Fehler oder alles andere, was an AppSignal zurückgemeldet wird, verknüpft sind.

  **7:45** Das ist sehr nützlich, denn wenn Sie einen Fehler beheben und ein Änderung deployen, die diesen Fehler beheben sollte, und der Fehler nach diesem Deployment doch wieder auftaucht, kann AppSignal Sie benachrichtigen und sagen: „Hey, das hast du eigentlich nicht behoben. Du dachtest, du hättest es getan, aber wir haben ihn wieder gesehen." Vielleicht ist es ein anderer Randfall oder so, aber es hilft Ihnen, den Überblick darüber zu behalten.

  **8:04** Sobald Sie also über einen Fehler benachrichtigt wurden, bekommen Sie nicht hundert Benachrichtigungen, wenn er hundertmal auftritt. Aber wenn Sie deployen und er kommt zurück, werden Sie erneut benachrichtigt. So wissen Sie: „Hey, das wurde eigentlich nicht behoben." Und das ist sehr, sehr hilfreich zu wissen.

  **8:20** Das sind also einige der Standardanpassungen, die ich gerne vornehme. Wir machen jetzt `git add` für all diese Änderungen und schreiben `git commit -m "Add appsignal"`. Und wir pushen das in unser Git-Repository, und wir können zu unserer Anwendung auf Hatchbox wechseln und diese Änderungen deployen.

  **8:40** In Ihrer Umgebung, denken Sie daran, ich habe erwähnt, dass Sie Ihren Rails-Master-Key gesetzt haben möchten, und wir wollen nur überprüfen, ob dieser Wert genau dem entspricht, was hier in unserer Zwischenablage war, mit `config/master.key`, und das ist genau dasselbe. Sobald dieses Deployment abgeschlossen und erfolgreich ist, können wir unsere Anwendung neu laden, sie wird natürlich automatisch neu starten, aber dann sollten wir sehen, wie eine production-Umgebung zu AppSignal hinzugefügt wird.

  **9:12** Schauen wir uns also an, was bisher erstellt wurde. Wir haben eine development-Umgebung für AppsignalExample, die Anwendung, an der wir arbeiten, und wir haben hier einen gemeldeten Fehler. Und wenn wir uns die Fehlerliste ansehen, sehen wir einen `Appsignal::Demo::TestError`. Das ist natürlich der Testfehler, den der Installationsbefehl übermittelt hat. Danach hat er gesucht, während er die Installation überprüft hat, und er hat ihn gefunden, also war alles in Ordnung.

  **9:40** Ausgezeichnet. Unser Deployment ist jetzt erfolgreich. Lassen Sie uns die Seite aktualisieren und sehen, ob Metriken an AppSignal übermittelt werden. Ich habe die development-Umgebung, aber jetzt sollten wir hier oben eine production-Umgebung sehen, und wir können dorthin wechseln und sollten sehen, dass jetzt Requests eintreffen. Ich habe hier zum Beispiel drei Requests pro Minute, was ein gutes Zeichen dafür ist, dass alles korrekt eingerichtet ist.

  **10:05** Versuchen wir jetzt, diesen Fehler nachzustellen, und sehen, ob er auch durchkommt. Wir gehen zu „Passwort vergessen", geben unsere E-Mail-Adresse ein und senden das ab. Kein 500er-Fehler, nichts dergleichen. Vielleicht passiert also etwas im Hintergrund, und dann können wir uns AppSignal ansehen und schauen, ob es etwas erfasst hat, das wir als Nutzer visuell nicht mitbekommen haben.

  **10:24** Und jetzt sehen wir, dass tatsächlich ein Fehler durchgekommen ist, und wir haben einen Fehler im Background-Namespace. Es hat also automatisch unseren Rails-Server von den Background-Jobs getrennt, in unserem Fall Solid Queue. Es hat diese getrennt, und Sie können sie hier auch in unterschiedlichen Farben sehen. Da das im Hintergrund passiert ist, ist es eine blaue Linie, und wir können auch zur Fehlerliste gehen und genau herausfinden, was falsch gelaufen ist.

  **10:50** Wir verwenden Resend für E-Mails, und es sieht so aus, als hätten wir einen Resend-Fehler. Klicken wir darauf und schauen wir uns die Fehlermeldung an. „Make sure your API key is set." Oh, ich habe total vergessen, das einzutragen. Also gehen wir zu Resend, erstellen einen API-Key, und wir werden ein AppSignal.

  **11:11** Example ist der Name. Wir geben ihm vollen Zugriff bzw. Sendeberechtigung für alle Domains, und dann kopieren wir das und fügen es in unsere Umgebung ein. Ich weiß, dass das ein Resend-API-Key sein soll, fügen das ein, speichern die Änderungen, und jetzt sollte alles bereit sein, und wir sollten diese E-Mail versenden und erfolgreich ausführen können.

  **11:35** Jetzt versuchen wir das noch einmal, und ich habe mich erinnert, dass ich für Resend eine spezielle E-Mail-Adresse zum Testen verwenden muss, solange ich noch keine gültige Domain habe, weil ich mich nur in deren Testkonto befinde. Wir senden also eine E-Mail an `delivered@resend.dev`. Und in deren Dashboard sollten wir jetzt sehen, dass „reset your password" gerade eben angekommen ist. Ich habe dieses Konto nur erstellt, damit wir damit testen können, aber wir können bestätigen, dass unsere Background-Jobs jetzt funktionieren und keine Fehler mehr senden, und dass sie tatsächlich meinen echten Resend-API-Key verwenden.

  **12:07** Dieser Fehler kann also als gelöst betrachtet werden, wir können hingehen und ihn selbst schließen, aber wir können auch sehen, dass wir bei einem weiteren Deployment hier unten einen weiteren Punkt bekommen, der jedes Deployment, das wir machen, mit Zeitpunkt und Git-Revision erfasst. Wir können diese also über die Zeit hinweg sehen und die Fehler zwischen den einzelnen Deployments betrachten, und wir können auch den Throughput sehen, sodass Sie erkennen können, dass die Dinge nach dem Deployment einer bestimmten Funktion vielleicht deutlich langsamer geworden sind.

  **12:38** Vielleicht müssten wir irgendein Performance-Problem beheben oder so. Natürlich ist das nur die Spitze des Eisbergs, AppSignal bietet noch viel mehr, was Sie damit machen können. Und wenn wir zum Beispiel die Seite aktualisieren, sehen wir bereits die neuen Dashboards für Action Mailer und Active Job, die automatisch für uns erstellt wurden, weil es erkannt hat, dass wir Active Job zum Versenden von E-Mails verwenden.

  **12:56** Beide Rails-Funktionen haben also ihre eigenen speziellen Dashboards, in denen Sie genau sehen können, was in diesen Teilen Ihrer Rails-Anwendungen passiert. Schauen Sie sich also die Dokumentation an, um tiefer in Ihr bevorzugtes Framework und Ihre Sprache einzutauchen, und sehen Sie, wie AppSignal sich besser integrieren und Ihnen Sichtbarkeit in Ihre Anwendungen geben kann.
</Accordion>

<h2 id="related-tutorials">
  Verwandte Tutorials
</h2>

* [Background Jobs mit Solid Queue ausführen](/tutorials/ruby/solid-queue)
* [Background Jobs mit Mission Control überprüfen](/tutorials/ruby/mission-control-jobs)

<h2 id="about-this-tutorial">
  Über dieses Tutorial
</h2>

Dieses Tutorial folgt Schritt für Schritt einem GoRails-Screencast von Chris Oliver zur Installation von AppSignal in einer auf Hatchbox bereitgestellten Rails-Anwendung. Der Screencast ist das Originalwerk. GoRails veröffentlicht ihn, zusammen mit dem Rest der Serie, auf [gorails.com](https://gorails.com).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.