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

# Fehler ignorieren

Fehler (oder Exceptions), die von Ihrer Anwendung ausgelöst werden, sind in der [Fehlervorfallsliste][error incident list] sichtbar.
Möglicherweise stellen Sie fest, dass AppSignal Sie über Fehler benachrichtigt, die Sie nicht für wichtig halten. Um dies zu verhindern, können Sie eine Liste von Fehlern zu einer Ignore-Liste in der Konfiguration Ihrer Anwendung hinzufügen. AppSignal benachrichtigt Sie dann nur über Fehler, die nicht auf der Ignore-Liste stehen.

<Note>
  🔕 Wenn Sie möchten, dass AppSignal Fehlerbenachrichtigungen stummschaltet, anstatt sie zu ignorieren,
  [lesen Sie unsere Benachrichtigungseinstellungen][notifications]-Dokumentation, um zu erfahren, wie Sie
  die Benachrichtigungseinstellungen Ihrer Anwendung anpassen können.
</Note>

## Fehler ignorieren

Um Fehler zu ignorieren, können Sie eine "Fehler ignorieren"-*Denylist* in Ihrer AppSignal-Integrations-Konfiguration konfigurieren. Durch das Hinzufügen von Fehlernamen zu dieser Liste filtern die Integrationen ignorierte Fehler aus den an AppSignal gesendeten Daten heraus.

Dieser Leitfaden zeigt Ihnen, wie Sie Ihre Denylist zum Ignorieren von Fehlern basierend auf der von Ihrer Anwendung verwendeten Sprache konfigurieren:

* [Ruby](#ruby)
* [Elixir](#elixir)
* [Node.js](#nodejs)
* [Python](#python)
* [Front-end JavaScript](#front-end-javascript)
* [Go](#go)
* [Java](#java)
* [PHP](#php)

<Tip>
  Es ist nicht möglich, alle Fehler zu ignorieren oder die Fehlermeldung vollständig zu deaktivieren.
  Es ist möglich, [Benachrichtigungen für Fehler zu deaktivieren][notifications].
</Tip>

## Ruby

Um Fehler in Ruby zu ignorieren, fügen Sie Folgendes zu Ihrer AppSignal-Konfigurationsdatei hinzu. Der [`ignore_errors`][ruby ignore_errors]-Wert ist ein Array von Strings.

<CodeGroup>
  ```ruby Ruby theme={null}
  Appsignal.configure do |config|
    config.ignore_errors += ["ActiveRecord::RecordNotFound", "ActionController::RoutingError"]
  end
  ```

  ```yaml YAML theme={null}
  production:
    ignore_errors:
      - ActiveRecord::RecordNotFound
      - ActionController::RoutingError
  ```
</CodeGroup>

<Warning>
  In [`ignore_errors`][ruby ignore_errors] gesetzte Namen werden anhand des Klassennamens
  abgeglichen, nicht anhand der Klassenvererbung. Wenn Sie alle Unterklassen einer
  bestimmten Exception abgleichen möchten, müssen alle Unterklassen separat aufgeführt werden.
</Warning>

### Mehr lesen {/* id: ruby-read-more */}

* Mehr über die [Ruby-`ignore_errors`-Konfigurationsoption][ruby ignore_errors] lesen.
* [Exception-Handling mit AppSignal in Ruby](/ruby/instrumentation/exception-handling).

## Elixir

Um Fehler in Elixir zu ignorieren, fügen Sie Folgendes zu Ihrer AppSignal-Konfigurationsdatei hinzu. Der [`ignore_errors`][elixir ignore_errors]-Wert ist eine Liste von Strings.

<CodeGroup>
  ```elixir Elixir theme={null}
  config :appsignal, :config,
    ignore_errors: ["SpecificError", "AnotherError"]
  ```
</CodeGroup>

<Warning>
  In [`ignore_errors`][elixir ignore_errors] gesetzte Namen werden anhand des Modulnamens abgeglichen.
</Warning>

### Mehr lesen {/* id: elixir-read-more */}

* Mehr über die [Elixir-`ignore_errors`-Konfigurationsoption][elixir ignore_errors] lesen.
* [Exception-Handling mit AppSignal in Elixir](/elixir/instrumentation/exception-handling).

## Node.js

Um Fehler in Node.js zu ignorieren, fügen Sie Folgendes zu Ihrer AppSignal-Konfigurationsdatei hinzu. Der [`ignoreErrors`][nodejs ignore_errors]-Wert ist ein Array von Strings.

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

  new Appsignal({
    // Andere Konfiguration
    ignoreErrors: ["SpecificError", "AnotherError"],
  });
  ```
</CodeGroup>

<Warning>
  In [`ignoreErrors`][nodejs ignore_errors] gesetzte Namen werden nur anhand der
  `name`-Eigenschaft der `Error`-Objekte abgeglichen und berücksichtigen keine
  Klassenvererbung. Wenn Sie Unterklassen von `Error` abgleichen möchten, muss
  jede Unterklasse separat aufgeführt werden.
</Warning>

### Mehr lesen {/* id: nodejs-read-more */}

* Mehr über die [Node.js-`ignoreErrors`-Konfigurationsoption][nodejs ignore_errors] lesen.
* [Exception-Handling mit AppSignal in Node.js](/nodejs/3.x/instrumentation/exception-handling).

## Python

Um Fehler in Python zu ignorieren, fügen Sie Folgendes zu Ihrer AppSignal-Konfigurationsdatei hinzu. Der [`ignore_errors`][python ignore_errors]-Wert ist eine Liste von Strings.

<CodeGroup>
  ```python Python theme={null}
  from appsignal import Appsignal

  appsignal = Appsignal(
      # Andere Konfiguration
      ignore_errors: ["SpecificError", "AnotherError"],
  )
  ```
</CodeGroup>

<Warning>
  In [`ignore_errors`][python ignore_errors] gesetzte Namen werden nur anhand des
  Exception-Klassennamens abgeglichen und berücksichtigen keine Klassenvererbung. Wenn
  Sie Unterklassen von `Exception` abgleichen möchten, muss jede Unterklasse separat
  aufgeführt werden.
</Warning>

### Mehr lesen {/* id: python-read-more */}

* Mehr über die [Python-`ignore_errors`-Konfigurationsoption][python ignore_errors] lesen.
* [Exception-Handling mit AppSignal in Python](/python/instrumentation/exception-handling).

## Front-end JavaScript

Um Fehler in Front-end-JavaScript zu ignorieren, fügen Sie Folgendes zu Ihrer AppSignal-Konfigurationsdatei hinzu. Der [`ignoreErrors`][js ignore_errors]-Wert ist ein Array von regulären Ausdrücken.

<CodeGroup>
  ```javascript JavaScript theme={null}
  import Appsignal from "@appsignal/javascript";

  export const appsignal = new Appsignal({
    // Andere Konfiguration
    ignoreErrors: [/a specific error message/, /another error message/],
  });
  ```
</CodeGroup>

<Warning>
  In [`ignoreErrors`][js ignore_errors] gesetzte Namen werden anhand eines regulären
  Ausdrucks abgeglichen. Der reguläre Ausdruck wird mit der `message`-Eigenschaft eines
  gegebenen `Error` abgeglichen.
</Warning>

### Mehr lesen {/* id: javascript-read-more */}

* Mehr über die [Front-end-JavaScript-`ignoreErrors`-Konfigurationsoption][js ignore_errors] lesen.
* [Exception-Handling mit AppSignal in Front-end-JavaScript](/front-end/error-handling).

## Go

Um Fehler in Go-Anwendungen zu ignorieren, konfigurieren Sie die [`ignore_errors`-Konfigurationsoption][go ignore_errors].

Fehlernamen werden exakt anhand ihres Namens abgeglichen, nicht anhand der Vererbung. Sie können eine Liste der Fehler in der Spalte "Action and error type" der *Issue list* unter [Errors](https://appsignal.com/redirect-to/app?to=exceptions) in der Seitenleiste sehen. Um einen bestimmten Fehler zu ignorieren, kopieren Sie den Namen, wie er in der Benutzeroberfläche erscheint, und fügen Sie ihn zur `ignore_errors`-Option hinzu.

Weitere Informationen zur Konfiguration von OpenTelemetry für Go-Apps finden Sie auf der [Go-Konfigurationsseite](/go/configuration/options).

<CodeGroup>
  ```go Go theme={null}
  res := resource.NewWithAttributes(
  	attribute.StringSlice("appsignal.config.ignore_errors", []string{"MyCustomError", "ExpectedError"}),
  	// Und andere Ressourcenattribute
  )
  ```
</CodeGroup>

### Mehr lesen {/* id: go-read-more */}

* Mehr über die [Go-`ignore_errors`-Konfigurationsoption][go ignore_errors] lesen.

## Java

Um Fehler in Java-Anwendungen zu ignorieren, konfigurieren Sie die [`ignore_errors`-Konfigurationsoption](/java/configuration/options#option-ignore_errors) über die Umgebungsvariable `OTEL_RESOURCE_ATTRIBUTES`.

Fehlernamen werden exakt anhand ihres Namens abgeglichen, nicht anhand der Vererbung. Sie können eine Liste der Fehler in der Spalte "Action and error type" der *Issue list* unter [Errors](https://appsignal.com/redirect-to/app?to=exceptions) in der Seitenleiste sehen. Um einen bestimmten Fehler zu ignorieren, kopieren Sie den Namen, wie er in der Benutzeroberfläche erscheint, und fügen Sie ihn zur `ignore_errors`-Option hinzu.

Weitere Informationen zur Konfiguration von OpenTelemetry für Java-Apps finden Sie auf der [Java-Konfigurationsseite](/java/configuration/options).

<CodeGroup>
  ```bash Bash theme={null}
  function encode() {
    echo -n "$@" | sed 's/,/%2C/g'
  }

  export OTEL_RESOURCE_ATTRIBUTES="\
    appsignal.config.ignore_errors=$(encode "MyCustomError,ExpectedError"),\
    ..."
  ```
</CodeGroup>

<Warning>
  In [`ignore_errors`](/java/configuration/options#option-ignore_errors) gesetzte
  Namen werden nur anhand des Exception-Klassennamens abgeglichen und berücksichtigen
  keine Klassenvererbung. Wenn Sie Unterklassen von `Exception` abgleichen möchten,
  muss jede Unterklasse separat aufgeführt werden.
</Warning>

### Mehr lesen {/* id: java-read-more */}

* Mehr über die [Java-`ignore_errors`-Konfigurationsoption](/java/configuration/options#option-ignore_errors) lesen.

## PHP

Um Fehler in PHP-Anwendungen zu ignorieren, konfigurieren Sie die [`ignore_errors`-Konfigurationsoption](/php/configuration/options#option-ignore_errors).

<CodeGroup>
  ```php PHP theme={null}
  return [
      'ignore_errors' => ['SpecificError', 'AnotherError'],
      // ... andere Optionen
  ];
  ```
</CodeGroup>

<Warning>
  In [`ignore_errors`](/php/configuration/options#option-ignore_errors) gesetzte
  Namen werden nur anhand des Exception-Klassennamens abgeglichen und berücksichtigen
  keine Klassenvererbung. Wenn Sie Unterklassen von `Exception` abgleichen möchten,
  muss jede Unterklasse separat aufgeführt werden.
</Warning>

### Mehr lesen {/* id: php-read-more */}

* Mehr über die [PHP-`ignore_errors`-Konfigurationsoption](/php/configuration/options#option-ignore_errors) lesen.

[elixir ignore_errors]: /elixir/configuration/options.html#option-ignore_errors

[error incident list]: https://appsignal.com/redirect-to/app?to=exceptions

[js ignore_errors]: /front-end/configuration/

[nodejs ignore_errors]: /nodejs/3.x/configuration/options.html#option-ignoreerrors

[notifications]: /application/notification-settings.html

[ruby ignore_errors]: /ruby/configuration/options.html#option-ignore_errors

[python ignore_errors]: /python/configuration/options.html#option-ignore_errors

[go ignore_errors]: /go/configuration/options.html#option-ignore_errors