> ## 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 exception handling

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 probeert zoveel mogelijk Python-excepties te registreren. AppSignal kan excepties in uw hele applicatie vastleggen met [onze instrumentaties](/python/instrumentations) die onze ondersteuning uitbreiden naar vele populaire frameworks en background job-pakketten.

Er kunnen echter scenario's zijn waarin excepties worden opgeworpen die niet gerelateerd zijn aan potentiële problemen in uw Python-applicatie, zoals bots die automatisch formulieren proberen in te dienen of verouderde links die bezoekers naar inhoud kunnen leiden die niet meer bestaat.

Om te voorkomen dat deze fouten als problemen in AppSignal worden gemeld, is het mogelijk om exception handling aan uw code toe te voegen of AppSignal bepaalde fouten volledig te laten negeren.

## Fouten negeren

De AppSignal-configuratie maakt het mogelijk om [fouten te negeren](/guides/filter-data/ignore-errors). Door een lijst met specifieke fouten op te geven, zal AppSignal geen meldingen versturen wanneer deze fouten worden opgeworpen.

## Exception handling

Het simpelweg negeren van een fout zal meldingen onderdrukken, maar kan mogelijk een groter probleem verbergen. Om deze reden raden we u aan om exception handling toe te voegen met `try ... except`-statements in uw applicatie.

Met `try ... except` kunt u specifieke excepties opvangen en een alternatief codepad toevoegen voor wanneer een exceptie optreedt, zoals het renderen van 404-pagina's of het verstrekken van meer gedetailleerde foutmeldingen aan de gebruiker over wat er mis ging.

In een Django view-bestand kunnen we bijvoorbeeld het volgende doen:

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

Er zijn een aantal scenario's, zoals wanneer resources niet bestaan of wanneer een formulierinzending mislukt, die op deze manier moeten worden afgehandeld om correcte HTTP-responses aan de eindgebruiker te bieden.

Als u deze opgevangen fouten aan AppSignal wilt rapporteren, gebruikt u de [`set_error`](#set_error)- of [`send_error`](#send_error)-helpers.

## set\_error

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

Rapporteer fouten zonder dat ze uw applicatie laten crashen. Met behulp van de `set_error`-helper wordt de gegeven fout ingesteld op de AppSignal-trace, wat de fout op de trace (request / background job) naar AppSignal rapporteert.

Als u de fout nog steeds wilt volgen terwijl u deze opvangt, kunt u de `set_error`-helper gebruiken om de exceptie toe te voegen aan de huidige AppSignal-trace. De fout wordt vastgelegd in AppSignal, maar uw proces zal niet crashen.

In een Django view-bestand kunnen we bijvoorbeeld het volgende doen:

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

De exceptie wordt door AppSignal gevolgd zoals elke andere fout, en het stelt u in staat om aangepaste foutafhandeling en fallbacks te bieden.

<Tip>
  **Let op:** Deze methode werkt alleen wanneer er al een AppSignal-trace actief
  is. Anders wordt de fout genegeerd. Dit is het geval in de meeste
  automatisch ondersteunde [instrumentaties](/python/instrumentations) of bij
  het gebruik van [custom instrumentatie](/python/instrumentation). Zie
  [`send_error`](#send_error) voor het verzenden van fouten zonder een actieve AppSignal-
  trace.
</Tip>

## send\_error

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

AppSignal biedt een mechanisme om fouten naar AppSignal te verzenden zonder dat er een trace gestart hoeft te worden. Dit is handig voor het volgen van fouten die optreden in code die zich niet in de context van een webrequest of background job bevindt, zoals eenmalige scripts of cron jobs.

Dit is nuttig voor apps die onze [instrumentaties](/python/instrumentations) niet gebruiken voor dit deel van de app waarin de fout wordt opgeworpen.

U kunt de `send_error`-methode gebruiken om vanaf elke plek in uw code direct een exceptie naar AppSignal te verzenden zonder eerst een trace te 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>

### Aanvullende metadata

Om metadata toe te voegen aan de verzonden fout, gebruikt u de `send_error_with_context`-methode. [Tags](/guides/tagging) en [andere typen gegevensaanpassing](/guides/custom-data) kunnen op deze manier aan de fout worden toegevoegd.

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