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

# Python-Ausnahmebehandlung

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

AppSignal versucht, so viele Python-Ausnahmen wie möglich zu erfassen. AppSignal kann Ausnahmen in Ihrer gesamten Anwendung mit [unseren Instrumentierungen](/python/instrumentations) erfassen, die unsere Unterstützung auf viele beliebte Frameworks und Hintergrundjob-Pakete erweitern.

Es kann jedoch Szenarien geben, in denen Ausnahmen ausgelöst werden, die nicht mit potenziellen Problemen in Ihrer Python-Anwendung zusammenhängen, beispielsweise Bots, die versuchen, automatisch Formulare zu posten, oder veraltete Links, die Besucher zu Inhalten leiten, die nicht mehr existieren.

Um zu vermeiden, dass diese Fehler als Probleme in AppSignal gemeldet werden, können Sie Ausnahmebehandlung zu Ihrem Code hinzufügen oder AppSignal bestimmte Fehler vollständig ignorieren lassen.

## Fehler ignorieren

Die AppSignal-Konfiguration ermöglicht es, [Fehler zu ignorieren](/guides/filter-data/ignore-errors). Durch Angabe einer Liste bestimmter Fehler sendet AppSignal keine Benachrichtigungen, wenn diese Fehler ausgelöst werden.

## Ausnahmebehandlung

Das bloße Ignorieren eines Fehlers schaltet Benachrichtigungen stumm, könnte aber potenziell ein größeres Problem verbergen. Aus diesem Grund empfehlen wir, Ausnahmebehandlung mit `try ... except`-Anweisungen in Ihre Anwendung einzubauen.

Mit `try ... except` können Sie bestimmte Ausnahmen abfangen und einen alternativen Code-Pfad hinzufügen, wenn eine Ausnahme auftritt, z. B. das Rendern von 404-Seiten oder das Anzeigen detaillierterer Fehlermeldungen für den Benutzer darüber, was schiefgelaufen ist.

In einer Django-View-Datei können wir zum Beispiel Folgendes tun:

<CodeGroup>
  ```python Python theme={null}
  def show(request):
     try:
          user = Post.find(1)
      except RecordNotFound:
          return render(request, "not_found.html")
  ```
</CodeGroup>

Es gibt einige Szenarien, etwa wenn Ressourcen nicht existieren oder eine Formularübermittlung fehlschlägt, die auf diese Weise behandelt werden sollten, um dem Endbenutzer korrekte HTTP-Antworten zu liefern.

Wenn Sie diese abgefangenen Fehler an AppSignal melden möchten, verwenden Sie die Helper [`set_error`](#set_error) oder [`send_error`](#send_error).

## set\_error

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

Melden Sie Fehler, ohne dass Ihre Anwendung dabei abstürzt. Mit dem Helper `set_error` wird der angegebene Fehler an den AppSignal-Trace gehängt, wodurch der Fehler für den Trace (Request / Hintergrundjob) an AppSignal gemeldet wird.

Wenn Sie den Fehler weiterhin verfolgen möchten, während Sie ihn abfangen, können Sie den Helper `set_error` verwenden, um die Ausnahme dem aktuellen AppSignal-Trace hinzuzufügen. Der Fehler wird in AppSignal aufgezeichnet, Ihr Prozess stürzt jedoch nicht ab.

In einer Django-View-Datei können wir zum Beispiel Folgendes tun:

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

  # In a Django view file
  def show(request):
      try:
          user = Post.find(1)
      except Post.DoesNotExist as error:
          set_error(error)
          return render(request, "not_found.html")
  ```
</CodeGroup>

Die Ausnahme wird von AppSignal wie jeder andere Fehler verfolgt, und es ermöglicht Ihnen, benutzerdefinierte Fehlerbehandlung und Fallbacks bereitzustellen.

<Tip>
  **Hinweis:** Diese Methode funktioniert nur, wenn bereits ein AppSignal-Trace
  aktiv ist. Andernfalls wird der Fehler ignoriert. Dies ist in den meisten
  automatisch unterstützten [Instrumentierungen](/python/instrumentations) oder
  bei der Verwendung [benutzerdefinierter Instrumentierung](/python/instrumentation)
  der Fall. Siehe [`send_error`](#send_error) zum Senden von Fehlern ohne
  aktiven AppSignal-Trace.
</Tip>

## send\_error

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

AppSignal bietet einen Mechanismus, um Fehler an AppSignal zu senden, ohne einen Trace starten zu müssen. Dies ist nützlich, um Fehler zu verfolgen, die in Code auftreten, der sich nicht im Kontext eines Webrequests oder Hintergrundjobs befindet, z. B. einmalige Skripte oder Cronjobs.

Dies ist nützlich für Anwendungen, die unsere [Instrumentierungen](/python/instrumentations) für den Teil der App, in dem der Fehler ausgelöst wird, nicht verwenden.

Sie können die Methode `send_error` verwenden, um eine Ausnahme direkt aus einer beliebigen Stelle in Ihrem Code an AppSignal zu senden, ohne zuvor einen Trace zu starten.

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

  # In a script
  def perform():
      try:
          user = Post.find(1)
      except Post.DoesNotExist as error:
          send_error(error)
          print("No post found!")
  ```
</CodeGroup>

### Zusätzliche Metadaten

Um Metadaten zu dem gesendeten Fehler hinzuzufügen, verwenden Sie die Methode `send_error_with_context`. [Tags](/guides/tagging) und [andere Arten der Datenanpassung](/guides/custom-data) können auf diese Weise zum Fehler hinzugefügt werden.

<CodeGroup>
  ```python Python theme={null}
  from appsignal import send_error_with_context, set_params

  # In a script
  def perform():
      try:
          user = Post.find(1)
      except Post.DoesNotExist as error:
          # Using implicit current span
          with send_error_with_context(error):
              set_params({"abc": "def"})

          # Using explicit `with` block span
          with send_error_with_context(error) as current_span:
              set_params({"abc": "def"}, current_span)

          print("No post found!")
  ```
</CodeGroup>