> ## 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 Ruby-Konfiguration

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

Konfiguration. Wichtig, denn ohne sie weiß das AppSignal Ruby-Gem nicht,
welche Anwendung es instrumentiert oder in welcher Umgebung.

In diesem Thema erklären wir, wie Sie AppSignal konfigurieren, was im
Ruby-Gem konfiguriert werden kann, was die minimal benötigte Konfiguration ist und wie die
Konfiguration geladen wird.

## Minimal erforderliche Konfiguration

Damit Anwendungen Daten an AppSignal melden, ist die folgende Konfiguration erforderlich. Alle weiteren Konfigurationen sind optional.

* Anwendungsname - [name-Option](/ruby/configuration/options#option-name)
* Anwendungsumgebung - [environment](/ruby/configuration/options#option-appsignal_app_env) (automatisch erkannt oder mit einer Umgebungsvariable gesetzt)
* Push API-Schlüssel der Anwendung - [push\_api\_key-Option](/ruby/configuration/options#option-push_api_key)
* AppSignal muss aktiv sein - [active-Option](/ruby/configuration/options#option-active)

Für Rails-Apps müssen Sie Ihren Anwendungsnamen nicht konfigurieren; AppSignal verwendet standardmäßig den Namen Ihrer Anwendung.

Wenn Sie ein Framework verwenden, das Umgebungen kennt und [vom AppSignal-Gem unterstützt wird](/ruby/integrations), wird die Umgebung automatisch erkannt.

<CodeGroup>
  ```ruby Ruby theme={null}
  # config/appsignal.rb
  Appsignal.configure do |config|
    config.activate_if_environment(:development, :staging, :production)
    config.name = "My app"
    config.push_api_key = "1234-1234-1234"
  end
  ```

  ```bash Bash theme={null}
  # Environment variables
  export APPSIGNAL_APP_NAME="My app"
  export APPSIGNAL_APP_ENV="production"
  export APPSIGNAL_PUSH_API_KEY="1234-1234-1234"
  ```

  ```yaml YAML theme={null}
  # config/appsignal.yml
  # Legacy config method
  production:
    active: true
    name: "My app"
    push_api_key: "1234-1234-1234"
  ```
</CodeGroup>

## Konfigurationsmethoden

In unserem Ruby-Gem stehen mehrere unterschiedliche Konfigurationsmethoden zur Verfügung.
Um zu sehen, in welcher Reihenfolge sie geladen werden und welche Konfigurationsmethode Werte aus anderen Quellen überschreibt, lesen Sie unsere Seite zur [Ladereihenfolge der Konfiguration](/ruby/configuration/load-order).

### Ruby-Konfigurationsdatei

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

Das AppSignal Ruby-Gem kann mit einer Ruby-Konfigurationsdatei konfiguriert werden. Bei Auswahl erstellt der Installer automatisch eine `config/appsignal.rb`-Datei. Diese Datei enthält Standard-Konfigurationseinstellungen, die an die spezifischen Bedürfnisse Ihrer Anwendung angepasst werden können.

Diese Konfigurationsdatei wird gelesen, wenn `Appsignal.start` aufgerufen wird, was bei den meisten unserer [Integrationen](/ruby/integrations) automatisch geschieht. Bitte lesen Sie die [Anweisungen zur Integration von AppSignal](/ruby/instrumentation/integrating-appsignal), wenn `Appsignal.start` nicht automatisch aufgerufen wird.

Die Konfigurationsdatei konfiguriert unser Ruby-Gem mit [dem `Appsignal.configure`-Helper](#appsignalconfigure-helper). Lesen Sie den Abschnitt [Der `Appsignal.configure`-Helper](#appsignalconfigure-helper) für weitere Details zur Verwendung.

Die [YAML-Konfigurationsdatei](#yaml-configuration-file) wird nicht gelesen, wenn diese Datei vorhanden ist.

<CodeGroup>
  ```ruby Ruby theme={null}
  Appsignal.configure do |config|
    # Enable AppSignal for the following environments
    config.activate_if_environment(:development, :staging, :production)

    # Ignore this action for all environments
    config.ignore_actions << "My global action"

    # Ignore this action for only the production environment
    if config.env?(:production)
      config.ignore_actions << "My production action"
    end

    # Ignore this action for only the staging environment
    if config.env?(:staging)
      config.ignore_actions << "My staging action"
    end
  end
  ```
</CodeGroup>

### `Appsignal.configure`-Helper

Der `Appsignal.configure`-Helper kann verwendet werden, um AppSignal mit Ruby-Code zu konfigurieren. Die [Ruby-Konfigurationsdatei](#ruby-configuration-file) verwendet diesen Helper, und er kann auch direkt in Ihrer Anwendung verwendet werden.

Wenn Ihre App `Appsignal.configure` außerhalb der `config/appsignal.rb`-Datei verwendet, etwa in einem Rails-Initializer, lesen Sie bitte [diesen Abschnitt über die Unterschiede im Verhalten](#using-the-appsignalconfigure-helper-in-your-application).

Setzen Sie Konfigurationsoptionen innerhalb des `Appsignal.configure`-Blocks, indem Sie die Schreibmethoden auf dem `config`-Objekt aufrufen. [Konfigurationsoptionen](/ruby/configuration/options) können mit dem für die Konfigurationsoption aufgeführten "Config file key" gesetzt werden. Beispielsweise kann die [`send_params`-Option](/ruby/configuration/options#option-send_params) so gesetzt werden: `config.send_params = false`.

<CodeGroup>
  ```ruby Ruby theme={null}
  # Some examples on how to configure config options
  Appsignal.configure do |config|
    # Enable AppSignal for the following environments
    config.activate_if_environment(:development, :staging, :production)

    # Configure String config options
    config.name = "My app name"
    # Read a value from an environment variable
    config.hostname = ENV.fetch("HOSTNAME", "default hostname value")

    # Append values to Array config options
    config.ignore_actions += ["My ignored action", "My other ignored action"]
    config.request_headers << "MY_HTTP_HEADER"

    # Configure Boolean config options
    config.send_params = true
    config.enable_host_metrics = false
  end
  ```
</CodeGroup>

Lesen Sie den Rest dieses Abschnitts für weitere Details zur Funktionsweise des `Appsignal.configure`-Helpers und welche weiteren Helper er hat.

#### String-Konfigurationsoptionen

Konfigurationsoptionen vom Typ String können sowohl mit Strings als auch mit Symbols gesetzt werden. Beim Setzen wandeln wir Symbols in Strings um.

<CodeGroup>
  ```ruby Ruby theme={null}
  Appsignal.configure do |config|
    config.activejob_report_errors = :discard

    config.activejob_report_errors
    # => "discard"
  end
  ```
</CodeGroup>

#### Array-Konfigurationsoptionen

Konfigurationsoptionen vom Typ Array können wie ein normales Array modifiziert werden:

* Verwenden Sie eine Zuweisung, um Standardwerte und zuvor aus Umgebungsvariablen gelesene Werte zu überschreiben.
  * Beispiel: `config.array_option = ["value 1", "value 2"]`
  * Optionswert: `["value 1", "value 2"]`
* Verwenden Sie den *Additionsoperator* `+=`, um ein neues Array von Werten mit den Standardwerten und zuvor aus Umgebungsvariablen gelesenen Werten zusammenzuführen.
  * Beispiel: `config.array_option += ["value 1", "value 2"]`
  * Optionswert: `["DUMMY default value", "value 1", "value 2"]`
* Verwenden Sie den *Anhänge-Operator* `<<`, um einen einzelnen Wert an die Liste der Standardwerte und der zuvor aus Umgebungsvariablen gelesenen Werte anzuhängen.
  * Beispiel: `config.array_option << "value 1"`
  * Optionswert: `["DUMMY default value", "value 1"]`

#### Automatische Erkennung der Umgebung

Das AppSignal Ruby-Gem erkennt die Umgebung der Anwendung automatisch. Wir integrieren uns mit Gems wie Rails, Sinatra, Rack und anderen, um zu erkennen, in welcher Umgebung die Anwendung gestartet wurde. Aus diesem Grund sollte es nicht erforderlich sein, die Umgebung manuell zu konfigurieren.

Wenn Sie die Umgebung der Anwendung manuell konfigurieren müssen, übergeben Sie den Umgebungsnamen als erstes Argument an den `Appsignal.configure`-Helper. Dieses Argument überschreibt den Wert der [Umgebungsvariable `APPSIGNAL_APP_ENV`](/ruby/configuration/options#option-appsignal_app_env) und die automatische Umgebungserkennung.

<CodeGroup>
  ```ruby Ruby theme={null}
  # Configure the application environment explicitly to be "production"
  Appsignal.configure(:production) do |config|
    # Some config
  end
  ```
</CodeGroup>

#### `activate_if_environment`-Helper

Der `Appsignal.configure`-Helper hat einen Helper, mit dem Sie konfigurieren können, welche Umgebungen aktiv sein und Daten an AppSignal.com melden sollen.

Rufen Sie `activate_if_environment` mit einer Liste von Umgebungen auf (Strings und/oder Symbols).
AppSignal erkennt die Umgebung, wenn der `Appsignal.configure`-Helper ohne Umgebungsargument aufgerufen wird. Es prüft dann, ob die Umgebung mit einem der angegebenen Werte übereinstimmt, und setzt in diesem Fall die [active-Konfigurationsoption](/ruby/configuration/options#option-active) auf `true`.

<CodeGroup>
  ```ruby Ruby theme={null}
  Appsignal.configure do |config|
    # Enable AppSignal for the following environments
    config.activate_if_environment(:development, :staging, :production)
  end
  ```
</CodeGroup>

Der `activate_if_environment`-Helper ist ein Komfort-Helper, damit Anwendungen keine eigenen Prüfungen hinzufügen müssen, wann AppSignal aktiv sein soll, wie:

<CodeGroup>
  ```ruby Ruby theme={null}
  Appsignal.configure do |config|
    # Example of a manual check for which environments AppSignal should be active
    config.active = Rails.env.development? || Rails.env.staging? || Rails.env.production?
  end
  ```
</CodeGroup>

#### `env?`-Helper

Der `Appsignal.configure`-Helper hat einen Helper, um zu prüfen, welche Umgebung AppSignal erkannt hat. Verwenden Sie diesen Helper, um zu prüfen, welche Umgebung aktiv ist, und um Konfigurationsoptionen zu setzen, die nur für diese Umgebung gelten sollen.

Rufen Sie den `env?`-Helper mit einem Umgebungsnamen (String oder Symbol) auf, und er gibt `true` zurück, wenn der Umgebungsname mit der aktuell aktiven Umgebung übereinstimmt.

<CodeGroup>
  ```ruby Ruby theme={null}
  Appsignal.configure do |config|
    # Add this configuration only for the staging environment
    if config.env?(:staging)
      config.ignore_actions << "My staging action"
    end
  end
  ```
</CodeGroup>

#### Verwendung des `Appsignal.configure`-Helpers in Ihrer Anwendung

Wir empfehlen, das AppSignal Ruby-Gem mit der [Ruby-Konfigurationsdatei](#ruby-configuration-file) unter `config/appsignal.rb` zu konfigurieren. Falls ein Rails-Initializer oder eine Inline-Konfiguration bevorzugt wird, lesen Sie bitte diesen Abschnitt zu den daraus resultierenden Verhaltensänderungen.

Wenn der `Appsignal.configure`-Helper aufgerufen wird, bevor die `config/appsignal.rb` Ruby-Konfigurationsdatei beim Aufruf von `Appsignal.start` gelesen wird, wird die Ruby-Konfigurationsdatei nicht gelesen.

In Rails-Apps stellen Sie sicher, dass Sie [das AppSignal-Gem so konfigurieren, dass es nach der Initialisierung von Rails startet](/ruby/integrations/rails#configure-appsignal-in-an-initializer), da andernfalls die mit `Appsignal.configure` gesetzte Konfiguration ignoriert wird, wenn sie in einem Rails-Initializer wie `config/initializers/appsignal.rb` aufgerufen wird.

<Warning>
  In Ruby-Gem-Version 3.12 und neuer wird, wenn eine [YAML-Konfigurationsdatei](#yaml-configuration-file) vorhanden ist, diese gelesen, wenn `Appsignal.configure` in einem Rails-Initializer oder inline in einer Anwendung aufgerufen wird. Dies ist veraltetes Verhalten. Bitte verschieben Sie die gesamte Konfiguration in den `Appsignal.configure`-Helper.

  Wir werden dieses Verhalten in der nächsten Major-Version des Ruby-Gems entfernen.
</Warning>

Beispiel für einen Rails-Initializer:

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

  # WARNING: In this example the `config/appsignal.rb` config file is not read!
  Appsignal.configure do |config|
    # Set some config
  end
  ```
</CodeGroup>

Beispiel für eine Inline-Konfiguration:

<CodeGroup>
  ```ruby Ruby theme={null}
  # Example file: app.rb
  require "appsignal"
  require "web_framework"

  # WARNING: In this example the `config/appsignal.rb` config file is not read!
  Appsignal.configure do |config|
    # Set some config
  end
  Appsignal.start

  run WebFramework.app
  ```
</CodeGroup>

### System-Umgebungsvariablen

AppSignal kann auch mit System-Umgebungsvariablen auf dem Host konfiguriert werden, auf dem die von AppSignal überwachte Anwendung läuft. Dies ist auf Plattformen wie Heroku üblich.

Stellen Sie sicher, dass diese Umgebungsvariablen so konfiguriert sind, dass sie mit Ihrem Betriebssystem kompatibel sind, und dass die Werte geladen werden, bevor Ihre App mit AppSignal gestartet wird.

<CodeGroup>
  ```sh Shell theme={null}
  export APPSIGNAL_APP_NAME="My app"
  ```
</CodeGroup>

### YAML-Konfigurationsdatei

<Tip>
  Diese Konfigurationsmethode ist eine Legacy-Methode und wird in der nächsten Major-Version des Ruby-Gems entfernt.

  Bitte verwenden Sie stattdessen die [Ruby-Konfigurationsdatei](#ruby-configuration-file).
</Tip>

Das AppSignal Ruby-Gem kann mit einer YAML-Konfigurationsdatei konfiguriert werden. Während der Installation erstellt das Ruby-Gem (falls ausgewählt) eine `config/appsignal.yml`-Datei. In dieser Datei wird eine Standardkonfiguration bereitgestellt, die an die Bedürfnisse Ihrer Anwendung angepasst werden kann. Diese `config/appsignal.yml`-Datei unterstützt ERB-Tags, sodass auch System-Umgebungsvariablen in dieser Datei geladen werden können.

Die für Konfigurationsoptionen gezeigten `config/appsignal.yml`-Konfigurationsbeispiele verwenden den YAML-Anker `default`. Der AppSignal-Installer erstellt standardmäßig eine `config/appsignal.yml`-Datei mit diesem Anker. Falls nicht vorhanden, stellen Sie sicher, dass Sie die Konfigurationsoption zur korrekten Umgebung hinzufügen.

<CodeGroup>
  ```yaml YAML theme={null}
  # config/appsignal.yml
  # Define the "defaults" anchor
  default: &defaults
    name: "My app"
    # Supports ERB
    push_api_key: "<%= ENV['APPSIGNAL_PUSH_API_KEY'] %>"

  production:
    # Loads the defaults in the production environment by referencing the anchor
    <<: *defaults
    # production environment specific configuration
    active: true
  ```
</CodeGroup>

#### Mehrere App-Umgebungen

In dieser Datei können mehrere App-Umgebungen mit Schlüsseln auf Stammebene konfiguriert werden.

<CodeGroup>
  ```yaml YAML theme={null}
  # Example: config/appsignal.yml
  development: # Development app environment
    active: true

  production: # Production app environment
    active: true

  test: # Testing app environment
    active: false # Disabled for test environment
  ```
</CodeGroup>

Um die Konfiguration nicht für jede App-Umgebung wiederholen zu müssen, können wir YAML-Anker verwenden, um YAML-Objekte zu erweitern.

<CodeGroup>
  ```yaml YAML theme={null}
  # Example: config/appsignal.yml
  default: &defaults
    active: true

  development: # Development app environment
    <<: *defaults

  production: # Production app environment
    <<: *defaults

  test: # Testing app environment
    <<: *defaults
    active: false # Overwrites the inherited active config option from "defaults"
  ```
</CodeGroup>

Es ist nicht möglich, nur einen `defaults`-Anker zu konfigurieren und ihn automatisch auf alle Umgebungen anwenden zu lassen. Jede Umgebung muss in der YAML-Datei mit einem Schlüssel auf Stammebene konfiguriert werden und von diesem `defaults`-Anker erben.

#### Beispiel einer YAML-Konfigurationsdatei

Hier ist ein Beispiel für eine `appsignal.yml`-Konfigurationsdatei. Es wird empfohlen,
dass Sie nur die Konfiguration zu Ihrer Konfigurationsdatei hinzufügen, die Sie tatsächlich benötigen.

Die vollständige Liste der Optionen finden Sie auf der Seite [Konfigurationsoptionen](/ruby/configuration/options).

<CodeGroup>
  ```yaml YAML theme={null}
  # config/appsignal.yml
  default: &defaults
    # Your Push API Key, it is possible to set this dynamically using ERB. Required
    push_api_key: "<%= ENV['APPSIGNAL_PUSH_API_KEY'] %>"

    # Your app's name as reported on AppSignal.com. Required
    name: "My App"

    # Your server's hostname. Optional, auto detected
    hostname: "frontend1.myapp.com"

    # Add default instrumentation of net/http. Default: true
    instrument_net_http: true

    # Skip session data, if it contains private information. Default: false
    skip_session_data: true

    # Ignore these errors (Optional)
    ignore_errors:
      - SystemExit

    # Ignore these actions, used by our Loadbalancer. Optional
    ignore_actions:
      - IsUpController#index

    # Enable allocation tracking for memory metrics. Default: true
    enable_allocation_tracking: true

  # Configuration per environment, leave out an environment or set active
  # to false to not push metrics for that environment.
  development:
    <<: *defaults
    active: true
    # Set the severity level of AppSignal's internal logger. Optional
    # Supported values are error, warning, info, debug, trace
    log_level: debug

  staging:
    <<: *defaults
    # Configure AppSignal to be active for this environment. Required
    active: true

  production:
    <<: *defaults
    # Configure AppSignal to be active for this environment. Required
    active: true

    # Set different path for the log file. Optional, auto detected
    log_path: "/home/my_app/app/shared/log"

    # Set AppSignal working dir. Optional, auto detected
    working_directory_path: "/tmp/appsignal"

    # When it's not possible to connect to the outside world without a proxy.
    # Optional
    http_proxy: "proxy.mydomain.com:8080"
  ```
</CodeGroup>