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

# Tratamento de exceções em Python

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

O AppSignal tenta registrar o maior número possível de exceções Python. O AppSignal consegue capturar exceções em toda a sua aplicação com [nossas instrumentações](/python/instrumentations) que estendem nosso suporte a muitos frameworks e pacotes populares de jobs em background.

No entanto, pode haver cenários em que exceções são levantadas que não estão relacionadas a problemas potenciais na sua aplicação Python, como bots tentando postar formulários automaticamente ou links desatualizados que podem direcionar visitantes para conteúdo que não existe mais.

Para evitar que esses erros sejam levantados como problemas no AppSignal, é possível adicionar tratamento de exceções ao seu código ou até mesmo permitir que o AppSignal ignore completamente certos erros.

## Ignorar erros

A configuração do AppSignal permite [ignorar erros](/guides/filter-data/ignore-errors). Fornecendo uma lista de erros específicos, o AppSignal não enviará alertas quando esses erros forem levantados.

## Tratamento de exceções

Simplesmente ignorar um erro silenciará as notificações, mas pode potencialmente esconder um problema maior. Por essa razão, recomendamos que você adicione tratamento de exceções com instruções `try ... except` à sua aplicação.

Usando `try ... except`, você pode capturar exceções específicas e adicionar um caminho de código alternativo para quando uma exceção ocorre, como renderizar páginas 404 ou fornecer ao usuário mensagens de erro mais detalhadas sobre o que deu errado.

Por exemplo, em um arquivo de view do Django podemos fazer o seguinte:

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

Existem alguns cenários, como quando recursos não existem ou quando o envio de um formulário falha, que devem ser tratados dessa forma para fornecer respostas HTTP adequadas ao usuário final.

Se você quiser reportar esses erros capturados ao AppSignal, use os helpers [`set_error`](#set_error) ou [`send_error`](#send_error).

## set\_error

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

Reporta erros sem que eles causem o crash da sua aplicação. Usando o helper `set_error`, o erro fornecido é definido no trace do AppSignal, que reporta o erro no trace (requisição / job em background) ao AppSignal.

Se você ainda quiser rastrear o erro enquanto o captura, pode usar o helper `set_error` para adicionar a exceção ao trace atual do AppSignal. O erro será registrado no AppSignal, mas seu processo não irá travar.

Por exemplo, em um arquivo de view do Django podemos fazer o seguinte:

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

A exceção será rastreada pelo AppSignal como qualquer outro erro, e permite que você forneça tratamento de erros personalizado e fallbacks.

<Tip>
  **Nota:** Este método só funciona quando já existe um trace do AppSignal
  ativo. Caso contrário, o erro será ignorado. Isso é verdade na maioria das
  [instrumentações](/python/instrumentations) suportadas automaticamente ou ao
  usar [instrumentação personalizada](/python/instrumentation). Consulte
  [`send_error`](#send_error) para enviar erros sem um trace do AppSignal ativo.
</Tip>

## send\_error

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

O AppSignal fornece um mecanismo para enviar erros ao AppSignal sem precisar iniciar um trace. Isso é útil para rastrear erros que ocorrem em código que não está em um contexto de requisição web ou job em background, como scripts pontuais ou cron jobs.

Isso é útil para apps que não usam nossas [instrumentações](/python/instrumentations) para esta parte do app onde o erro é levantado.

Você pode usar o método `send_error` para enviar diretamente uma exceção ao AppSignal de qualquer lugar do seu código sem precisar iniciar um trace primeiro.

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

### Metadados adicionais

Para adicionar metadados ao erro enviado, use o método `send_error_with_context`. [Tags](/guides/tagging) e [outros tipos de personalização de dados](/guides/custom-data) podem ser adicionados ao erro dessa forma.

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