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

# Anwendungen konfigurieren

Willkommen zu unserem Konfigurationsleitfaden. Dieser Leitfaden zeigt Ihnen, wie Sie Konfigurationen für Ihre AppSignal-Integration hinzufügen und ändern.

<Tip>
  Lesen Sie weitere Informationen über die AppSignal-Integrationskonfiguration in Ihrer App in
  unserem [Konfigurationsbereich][config topic].
</Tip>

## Wählen Sie eine Konfigurationsoption

Dieser Leitfaden führt Sie durch die Schritte, die erforderlich sind, um Ihre Anwendung optimal auf Ihre Bedürfnisse abzustimmen. Es gibt natürlich mehrere Konfigurationsoptionen für Ihre Anwendung, aber da die Implementierungsmethode für alle Optionen identisch ist, konzentrieren wir uns in diesem Leitfaden auf die folgenden Konfigurationen:

Wir verwenden die Option `log_level` als Beispiel für [Ruby](/ruby/configuration/options#option-log_level)-, [Elixir](/elixir/configuration/options#option-log_level)-, [Node.js](/nodejs/3.x/configuration/options#option-loglevel)- und [Python](/python/configuration/options#option-log_level)-Anwendungen.

Wir verwenden die Option `namespace` als Beispiel für [Front-end-JavaScript-Anwendungen](/front-end/configuration).

## Konfigurationsmethoden

Es gibt mehrere Möglichkeiten, Ihre AppSignal-Integration zu konfigurieren, und Integrationen können je nach Sprache Ihrer Anwendung variieren, aber sie alle haben die folgenden Konfigurationsmethoden:

* [Dateibasierte Konfiguration:](#file-based-configuration)
  <br />Eine Konfigurationsdatei, aus der die AppSignal-Integration die
  AppSignal-Konfiguration liest.
* [System-Umgebungsvariablen-Konfiguration:][env]
  <br />
  Umgebungsvariablen werden auf dem Host-System (Server) auf dem
  übergeordneten Prozess gesetzt, der Ihre Anwendung startet.
  <br /> **Hinweis**: Diese Methode ist nicht für Front-end-JavaScript verfügbar.

## Dateibasierte Konfiguration

Die dateibasierte Konfiguration ist die einfachste Möglichkeit, Ihre Integration zu konfigurieren.

Einige Integrationen erstellen während der Installation von AppSignal in der App eine Konfigurationsdatei. In diesen Konfigurationsdateien können Sie eine oder mehrere Anwendungsumgebungen individuell konfigurieren.

<Tip>
  Stellen Sie sicher, dass Sie den Wert "Config file key" aus der Konfigurationsoptionen-Tabelle als
  Konfigurationsschlüssel verwenden. Dieser Schlüssel ist entweder eine snake\_cased (Ruby, Elixir, Python) oder
  eine camelCased Zeichenkette (Node, Front-End JavaScript).
</Tip>

Konfigurationsoptionen für:

* [Ruby](/ruby/configuration/options)
* [Elixir](/elixir/configuration/options)
* [Node.js](/nodejs/3.x/configuration/options)
* [Python](/python/configuration/options)
* [Front-end Javascript](/front-end/configuration/)
* [Go](/go/configuration/options)

<Warning>
  Stellen Sie sicher, dass Sie keine sensiblen Konfigurationswerte, wie den Push-API-Schlüssel,
  in ein Versionskontrollsystem wie Git einchecken, es sei denn, sie sind verschlüsselt.
</Warning>

### Ruby

Bei Verwendung des Ruby-Integrations-Gems wird bei der Installation `config/appsignal.yml` im Stammverzeichnis Ihrer Anwendung mit grundlegenden Konfigurationseinstellungen erstellt. Wenn Ihre Anwendung Daten an AppSignal meldet, ohne dass eine `appsignal.yml`-Datei vorhanden ist, verwendet Ihre Anwendung höchstwahrscheinlich [System-Umgebungsvariablen][env].

<Tip>
  Die Datei `config/appsignal.yml` ist eine YAML-Datei (Yet Another Markup Language).
  und wird als ERB-Template (Embedded Ruby) interpretiert. Weitere Details, wie die YAML-Konfiguration funktioniert,
  finden Sie in der [Ruby-Konfigurations][ruby config]-Dokumentation.
</Tip>

Im untenstehenden Beispiel-Konfigurationsdatei werden zwei Umgebungen definiert, `development` und `production` – jede hat umgebungsspezifische Konfigurationsoptionen, die darunter verschachtelt sind. Alles, was unter `default` definiert und verschachtelt ist, gilt für alle Umgebungen, solange default in der Umgebungszuordnung enthalten ist.

Wir möchten das log\_level ausschließlich in unserer `development`-Umgebung auf debug setzen; dazu haben wir `log_level: "debug"` in die development-Umgebungs-Konfiguration eingefügt (Zeile 10).

<CodeGroup>
  ```yaml YAML theme={null}
  # Beispiel: config/appsignal.yml
  default: &defaults # Gemeinsame Konfigurationsoptionen für alle Umgebungen
    active: true
    name: "My awesome app"
    push_api_key: "<YOUR PUSH API KEY>"

  development: # Development-Umgebung
    <<: *defaults
    log_level: "debug" # Dies aktiviert den Debug-Modus nur für die Development-Umgebung

  production: # Production-Umgebung
    <<: *defaults
  ```
</CodeGroup>

Denken Sie daran, alles, was unter `default` verschachtelt ist, wird auf alle Umgebungen angewendet. Um also das log\_level in allen Umgebungen auf debug zu setzen, können wir die Konfiguration stattdessen unter default verschachteln, wie in Zeile 6 des untenstehenden Beispielcodes:

<CodeGroup>
  ```yaml YAML theme={null}
  # Beispiel: config/appsignal.yml
  default: &defaults
    active: true
    name: "My awesome app"
    push_api_key: "<YOUR PUSH API KEY>"
    log_level: "debug" # Dies aktiviert den Debug-Modus für alle Umgebungen
    # Weitere AppSignal-Konfiguration...

  development: # Development-Umgebung
    <<: *defaults
    # Weitere AppSignal-Konfiguration...

  production: # Production-Umgebung
    <<: *defaults
    # Weitere AppSignal-Konfiguration...
  ```
</CodeGroup>

Großartig, jetzt haben Sie gelernt, wie Sie AppSignal in Ihrer Ruby-Anwendung konfigurieren!

#### Mehr lesen:

* [Thema Ruby-Integrations-Konfiguration][ruby config]
* [Details zur Ladereihenfolge der Ruby-Integrations-Konfiguration](/ruby/configuration/load-order)

### Elixir

Bei der Installation erstellt die Elixir-Integration eine `config/appsignal.exs`-Datei (Standardspeicherort) mit grundlegenden Konfigurationen. Wenn diese Datei nicht vorhanden ist, Ihre Anwendung aber Daten an AppSignal meldet, prüfen Sie eine der anderen `.exs`-Dateien im Verzeichnis `config/` Ihrer Elixir-App. Wenn in keiner der Dateien eine AppSignal-Konfiguration vorhanden ist, verwendet Ihre Anwendung wahrscheinlich [System-Umgebungsvariablen][env] als Konfigurationsmethode.

Um eine Konfigurationsoption hinzuzufügen und sie auf alle Umgebungen Ihrer Anwendung anzuwenden, fügen Sie die Konfigurationsoption der Datei `config/appsignal.exs` hinzu, wie in Zeile 7 des Beispiels unten:

<CodeGroup>
  ```elixir Elixir theme={null}
  # Beispiel: config/config.exs
  config :appsignal, :config,
    active: true,
    name: "My awesome app",
    push_api_key: "<YOUR PUSH API KEY>",
    env: Mix.env,
    log_level: "debug" # Dies setzt das log_level für alle Umgebungen auf debug
  ```
</CodeGroup>

Um die Konfigurationsoption nur auf eine einzelne Umgebung anzuwenden, fügen Sie die AppSignal-Konfiguration der Konfigurationsdatei der Umgebung hinzu, die sich im Verzeichnis `config/` befindet.

Im Beispiel unten wurde die Option log\_level in Zeile 3 der Entwicklungsumgebung (oder "dev") hinzugefügt:

<CodeGroup>
  ```elixir Elixir theme={null}
  # Beispiel: config/dev.exs
  config :appsignal, :config,
    log_level: "debug" # Dies setzt das log_level nur für die "dev"-Umgebung auf debug
  ```
</CodeGroup>

Großartig, jetzt haben Sie gelernt, wie Sie AppSignal in Ihrer Elixir-Anwendung konfigurieren!

#### Mehr lesen

* [Thema Elixir-Integrations-Konfiguration](/elixir/configuration/)
* [Details zur Ladereihenfolge der Elixir-Integrations-Konfiguration](/elixir/configuration/load-order)

### Node.js

Nach der Installation müssen Sie eine AppSignal-Konfigurationsdatei erstellen, um Ihre Anwendung zu konfigurieren. Wenn keine Datei mit AppSignal-Konfiguration vorhanden ist, verwendet sie höchstwahrscheinlich [System-Umgebungsvariablen][env] als Konfigurationsmethode.

Um AppSignal für Node.js-Apps zu konfigurieren, empfehlen wir, eine `appsignal.js`-Datei mit der AppSignal-Konfiguration im Stamm- oder `src`-Verzeichnis Ihrer Anwendung zu erstellen. Dann fordern/importieren Sie sie aus dem Code der App, bevor andere Pakete angefordert oder importiert werden.

Im Beispiel unten befindet sich eine `appsignal.js`-Datei im Stammverzeichnis der App. In dieser Datei fügen wir die Konfigurationsoption `logLevel` hinzu.

<CodeGroup>
  ```javascript Node.js theme={null}
  // appsignal.js
  const { Appsignal } = require("@appsignal/nodejs");

  const appsignal = new Appsignal({
    active: true,
    name: "<YOUR APPLICATION NAME>",
    pushApiKey: "<YOUR API KEY>",
    logLevel: "debug", // Setzt logLevel für die Node.js-Umgebung auf debug
  });

  module.exports = { appsignal };
  ```
</CodeGroup>

Die Konfiguration im obigen Beispiel gilt für die Umgebung, in der Node.js läuft (`NODE_ENV`, Standard ist "development").

In Node.js gibt es viele Möglichkeiten, umgebungsspezifische Konfigurationen für AppSignal zu erstellen. Wenn Sie unsicher sind, wie Sie dies in Ihrer eigenen Anwendung tun sollen, ist eine Methode, die wir empfehlen, die Verwendung von Bedingungen in Ihrer `appsignal.js`, wie im Beispiel unten, in dem wir debug für die Produktionsumgebung angeben.

1. In Zeile 4 – aktivieren wir die AppSignal-Integration nur, wenn die Umgebung production ist.
2. In Zeile 8 – wie in unserem vorherigen Codebeispiel setzen wir das `logLevel` auf `debug`

<CodeGroup>
  ```javascript Node.js theme={null}
  // appsignal.js

  const appsignal = new Appsignal({
    active: process.env.NODE_ENV === "production"
    name: "<YOUR APPLICATION NAME>",
    pushApiKey: "<YOUR API KEY>",
    logLevel: "debug" // Setzt logLevel für die Node.js-Umgebung auf debug
  });
  ```
</CodeGroup>

Sobald Ihre Konfiguration abgeschlossen ist, müssen Sie `appsignal.js` ganz oben in der Hauptdatei Ihrer App anfordern. Der Name der Hauptdatei Ihrer Anwendung kann je nach Struktur Ihrer Anwendung variieren. Es ist die Datei, mit der Sie Ihre Node-Anwendung starten und wird normalerweise als `index.js` oder `app.js` bezeichnet. Stellen Sie sicher, dass AppSignal ganz oben in der Datei angefordert wird, wie im Beispiel unten:

<CodeGroup>
  ```javascript Node.js theme={null}
  // index.js
  // Platzieren Sie dies ganz oben
  const { appsignal } = require("./appsignal"); // Auf den im vorherigen Schritt verwendeten Speicherort aktualisieren

  // Platzieren Sie Ihren App-Code darunter
  ```
</CodeGroup>

Großartig, jetzt haben Sie gelernt, wie Sie AppSignal in Ihrer Node.js-Anwendung konfigurieren!

#### Mehr lesen

* [Node.js-Integrations-Konfiguration][nodejs config]
* [Ladereihenfolge der Node.js-Integrations-Konfiguration](/nodejs/3.x/configuration/load-order)

### Python

Bei Verwendung des Python-Integrations-Installers wird `__appsignal__.py` im Stammverzeichnis Ihrer Anwendung mit grundlegenden Konfigurationseinstellungen erstellt. Ihre Anwendung kann auch über [System-Umgebungsvariablen][env] konfiguriert werden.

Um eine Konfigurationsoption hinzuzufügen und sie auf Ihre Entwicklungs-Anwendungsumgebung anzuwenden, fügen Sie die Konfigurationsoption der `__appsignal__.py`-Datei hinzu, wie im Beispiel unten.

<CodeGroup>
  ```python Python theme={null}
  # __appsignal__.py
  from appsignal import Appsignal

  appsignal = Appsignal(
      active=True,
      name="My awesome app",
      push_api_key="<YOUR PUSH API KEY>",
      environment="development",
      log_level="debug",
  )
  ```
</CodeGroup>

Um AppSignal für Python für eine andere Umgebung zu konfigurieren oder die Konfiguration auf alle Umgebungen anzuwenden, konfigurieren Sie die Konfigurationsoption `environment` auf die gleiche Weise, wie Ihre App ihre Umgebung bestimmt (development/staging/production). Dies kann über eine System-Umgebungsvariable oder eine andere anwendungsspezifische Methode geschehen. Im Beispiel unten verwenden wir eine System-Umgebungsvariable `MY_APP_ENV`, um sowohl die App-Umgebung festzulegen als auch nur für die Produktionsumgebung zu aktivieren.

<CodeGroup>
  ```python Python theme={null}
  # __appsignal__.py
  import os
  from appsignal import Appsignal

  app_env = os.environ.get("MY_APP_ENV")

  appsignal = Appsignal(
      active=app_env == "production",
      name="My awesome app",
      push_api_key="<YOUR PUSH API KEY>",
      environment=app_env,
  )
  ```
</CodeGroup>

Wenn Sie möchten, dass einige Konfigurationsoptionen nur auf bestimmte Umgebungen angewendet werden, erstellen Sie Bedingungen, die Ihren Bedürfnissen entsprechen.

<CodeGroup>
  ```python Python theme={null}
  # __appsignal__.py
  import os
  from appsignal import Appsignal

  app_env = os.environ.get("MY_APP_ENV")

  options = {
      "active": app_env == "development",
      "name": "python/django4-celery",
      "environment": app_env,
  }
  if app_env == "development":
      options["log_level"] = "debug"

  appsignal = Appsignal(**options)
  ```
</CodeGroup>

Großartig, jetzt haben Sie gelernt, wie Sie AppSignal in Ihrer Python-Anwendung konfigurieren!

#### Mehr lesen:

* [Thema Python-Integrations-Konfiguration][python config]
* [Details zur Ladereihenfolge der Python-Integrations-Konfiguration](/python/configuration/load-order)

### Front-end JavaScript

Um AppSignal für Front-end-JavaScript zu konfigurieren, empfehlen wir, eine `appsignal.js`-Datei mit der AppSignal-Konfiguration im Stamm- oder `src`-Verzeichnis Ihres Projekts zu erstellen. Dann fordern oder importieren Sie sie aus dem Code der App, bevor andere Pakete angefordert oder importiert werden.

Im Beispiel unten befindet sich eine `appsignal.js`-Datei im Stammverzeichnis der Anwendung. In Zeile 8 haben wir die Konfigurationsoption `namespace` hinzugefügt.

<CodeGroup>
  ```javascript JavaScript theme={null}
  // appsignal.js
  import Appsignal from "@appsignal/javascript"; // Für ES Module
  const Appsignal = require("@appsignal/javascript").default; // Für CommonJS-Module

  const appsignal = new Appsignal({
    key: "<YOUR FRONTEND API KEY>",
    namespace: "frontend", // Konfiguriert den AppSignal-Namespace für Front-end-Fehler in dieser App
  });

  module.exports = { appsignal };
  ```
</CodeGroup>

Sobald Sie mit der Konfiguration Ihrer Anwendung fertig sind, müssen Sie `appsignal.js` ganz oben in der Hauptdatei Ihrer Anwendung anfordern, wie im Beispiel unten:

<CodeGroup>
  ```javascript JavaScript theme={null}
  // index.js
  // Platzieren Sie dies ganz oben
  const { appsignal } = require("./appsignal"); // Auf den im vorherigen Schritt verwendeten Speicherort aktualisieren

  // Platzieren Sie Ihren App-Code darunter
  ```
</CodeGroup>

Und das war's – Sie können loslegen! Befolgen Sie diese einfachen Schritte für alle zukünftigen Änderungen an Konfigurationsoptionen.

#### Mehr lesen

* [Front-end-JavaScript-Integrations-Konfiguration](/front-end/configuration/)

## System-Umgebungsvariablen-Konfiguration

<Warning>
  Diese Konfigurationsmethode ist nicht für Front-end-JavaScript verfügbar.
</Warning>

System-Umgebungsvariablen oder kurz "Umgebungsvariablen" sind Variablen, die für Prozesse zugänglich sind und vom übergeordneten Prozess, der sie startet, vererbt werden. Anstatt eine [Konfigurationsdatei][file] für die Konfiguration zu verwenden, ist es möglich, AppSignal nur über Umgebungsvariablen zu konfigurieren. Es ist auch möglich, Konfigurationsschlüssel, die sensible Daten enthalten, wie den Push-API-Schlüssel, in einer Umgebungsvariablen zu speichern und [Konfigurationsdateien][file] für den Rest der Konfiguration zu verwenden.

Diese Konfigurationsmethode ist kompatibel mit Ruby-, Elixir- und Node.js-Anwendungen.

Bevor wir mit dem folgenden Beispiel zum Setzen von Umgebungsvariablen über eine Shell fortfahren, erklären wir, wie Umgebungsvariablen in Bezug auf Shells und Prozesse funktionieren.

Umgebungsvariablen können zu einem Prozess wie einer Shell oder Ihrer Anwendung gehören. Der Befehl `export FOO=BAR` würde beispielsweise die `FOO`-Umgebungsvariable Ihrer Shell auf `BAR` setzen. Umgebungsvariablen werden zwischen Prozessen vererbt, sodass, wenn diese Shell einen neuen Prozess startet, dieser Prozess ebenfalls alle Umgebungsvariablen der Shell hat.

Wenn Sie einen Prozess in der Shell starten (d. h. npm start), können Sie auch mehr Umgebungsvariablen nur für diesen Prozess bereitstellen, indem Sie die Variablen wie folgt zuweisen: `FOO=BAR npm start`

Aus Bequemlichkeit möchten Sie möglicherweise Ihre Shell so konfigurieren, dass bestimmte Umgebungsvariablen beim Start gesetzt werden, sodass alle aus dieser Shell gestarteten Prozesse diese Umgebungsvariablen erben. Wenn Sie die Shell `bash` verwenden, werden die Befehle in der Datei `.bash_profile` in Ihrem Home-Verzeichnis beim Start der Shell ausgeführt. Bei Verwendung von `zsh`, der Standard-Shell in macOS, würde stattdessen die Datei `.zshenv` zur Konfiguration der Umgebungsvariablen verwendet.

In der untenstehenden Beispieldatei exportieren wir die Umgebungsvariablen, die den Push-API-Schlüssel und das Log-Level von AppSignal konfigurieren, sodass beim Start einer neuen Shell die korrekten Umgebungsvariablen für Ihre Anwendung zugänglich sind und sie mit AppSignal kommunizieren kann.

Konfigurationsoptionen, die über Umgebungsvariablen gesetzt werden, gelten für alle Anwendungsumgebungen, einige Konfigurationsoptionen sind jedoch sprachspezifisch. Zum Beispiel existiert die Konfigurationsoption `instrument_sequel` nur in der Ruby-Integration, da Sequel ein Ruby-Gem ist, und daher hat das Setzen der Umgebungsvariable `APPSIGNAL_INSTRUMENT_SEQUEL` keine Auswirkung auf andere Integrationen.

<CodeGroup>
  ```sh Shell theme={null}
  # Bash-Shell-Beispiel
  export APPSIGNAL_PUSH_API_KEY=<YOUR PUSH API KEY>
  export APPSIGNAL_LOG_LEVEL=debug # Setzt log_level für alle Umgebungen auf debug.
  ```
</CodeGroup>

Es gibt mehrere mögliche Speicherorte für Dateien mit Umgebungsvariablen-Konfiguration. Bitte wählen Sie die beste Option, die zu Ihrer Anwendung passt, und stellen Sie sicher, dass Sie Ihre Terminal-Shell nach Änderungen neu laden, damit sie auf Ihre aktualisierten Variablen zugreifen kann.

* `~/.profile` oder `~/.bash_profile` - Benutzerspezifische Einstellungen. Verwenden Sie diesen Speicherort, um Umgebungsvariablen pro Benutzer zu konfigurieren.
* `/etc/profile` - Systemweite Einstellungen. Wenn mehrere Benutzer oder Apps dieselbe Host-Maschine verwenden, verwenden Sie diesen Speicherort nicht.

Platform-As-A-Service (PaaS)-Hosting-Anbieter wie Heroku bieten kein System zur direkten Konfiguration von Umgebungsvariablen in der Shell. Sie können stattdessen ihre Weboberfläche oder CLI verwenden, um diese Umgebungsvariablen zu konfigurieren.

<Note>
  Stellen Sie bei Verwendung der konfigurationsbasierten System-Umgebungsvariablen sicher, dass Sie
  den Wert "System environment key" aus der Tabelle der Konfigurationsoptionen als Konfigurationsschlüssel
  verwenden. Dieser Schlüssel ist immer in großem\* snake case, wie folgt:
  `EXAMPLE_OF_A_CONFIG_KEY`

  <br />

  ***Fun Fact:** Dies wird auch als SCREAMING\_SNAKE\_CASE 🐍 bezeichnet*
</Note>

## Abschluss der Konfiguration

Nach der Änderung Ihrer AppSignal-Konfiguration muss Ihre Anwendung neu gestartet oder deployt werden, damit die Konfigurationsänderungen von AppSignal erkannt werden.

Werden Konfigurationsänderungen nicht erkannt? [Setzen Sie sich mit uns in Verbindung][contact], und wir helfen Ihnen weiter! Um uns die Fehlersuche zu erleichtern, empfehlen wir Ihnen, uns einen [Diagnosebericht](/support/debugging#diagnose) vom Host Ihrer Anwendung zu senden.

## Weiterführende Literatur

Lesen Sie mehr über Konfiguration in unserer [Anwendungskonfigurations][config topic]-Dokumentation.

[config topic]: /application/configuration.html

[contact]: mailto:support@appsignal.com

[env]: #system-environment-variable-configuration

[file]: #file-based-configuration

[nodejs config]: /nodejs/3.x/configuration/

[ruby config]: /ruby/configuration/

[python config]: /python/configuration/