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

# Reportando deploys para acompanhar melhorias

A forma como o seu aplicativo funciona pode mudar a cada novo deployment. Ao rastrear seus deploys com o AppSignal, os incidentes de erro e as medições de desempenho são agrupados por deployment, para que você possa ver facilmente quais impactos seu deployment teve no desempenho e na taxa de erros do seu aplicativo. O AppSignal pode levar você de um [backtrace de erro][error backtrace links] até a linha de código de onde um erro específico se originou, e isso ajuda

Este guia mostrará como rastrear deploys no AppSignal usando deploy markers.

<Tip>
  Leia mais informações detalhadas sobre [deploy markers][deploy markers] e para
  que servem.
</Tip>

## Configurando o AppSignal

Este guia usará o método de opção de configuração `revision` para reportar deploy markers. Você pode ler sobre abordagens alternativas a isso em nossa documentação de [Deploy Markers].

A opção de configuração `revision` é configurada de forma diferente por linguagem de integração. Veja a lista de integrações abaixo para a que seu app usa.

Observe que o AppSignal [reportará automaticamente um deploy][automatic report] ao usar plataformas como Heroku ou Render, ou orquestradores de deployment como o Kamal.

### Atualizar a revisão automaticamente

Recomendamos buscar dinamicamente o valor da opção de configuração revision do gerenciamento de controle de versão usado para o seu projeto (como Git ou SVN) na inicialização ou no deploy. Dessa forma, o valor não precisa ser atualizado manualmente por deploy. Se um hash de commit do Git for usado, ele também será compatível com [error backtrace links].

Abaixo está um exemplo de como você faria isso usando o Git:

<CodeGroup>
  ```bash Bash theme={null}
  git rev-parse --short HEAD
  # Irá produzir o SHA curto do commit atual
  ```
</CodeGroup>

Continuaremos a usar o Git para todos os exemplos de integração nesta documentação.

## Configurações por linguagem

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

### Ruby

Para aplicativos Ruby, carregaremos a revisão Git do arquivo de configuração.

O comando shell que executamos na opção de configuração `revision` é o mesmo comando que usamos [anteriormente](#automatically-update-the-revision) para recuperar o hash do commit atual. Chamamos o comando `git rev-parse` e definimos a saída como a opção de configuração `revision`, como mostrado no exemplo abaixo:

<CodeGroup>
  ```ruby Ruby theme={null}
  Appsignal.configure do |config|
    config.revision = `git rev-parse --short HEAD`.strip
  end
  ```

  ```yaml YAML theme={null}
  production:
    revision: "<%= `git rev-parse --short HEAD`.strip %>"
    # Outras opções de configuração
  ```
</CodeGroup>

#### Usando gems de deploy Ruby

Se você usa uma ferramenta de deployment como [Capistrano](https://github.com/capistrano/capistrano) ou [Hatchbox](https://www.hatchbox.io/) que exclui a pasta `.git` do deploy:

* Modifique o processo de deploy para executar um comando que crie um arquivo `REVISION` na pasta `current`, contendo o hash do Git: `git rev-parse --short HEAD > REVISION`

Ao usar um provedor Platform-as-a-Service, o provedor pode criar este arquivo para você ou expor a revisão como uma variável de ambiente que você pode ler no arquivo de configuração. Se você não tiver certeza se isso se aplica a você, verifique com seu provedor ou [entre em contato](/support), podemos saber a resposta.

Abaixo está um exemplo de como ler o hash do Git de um arquivo `REVISION` ao usar o `Rails`:

<CodeGroup>
  ```ruby Ruby theme={null}
  Appsignal.configure do |config|
    revision = Rails.root.join("REVISION") if defined?(Rails)
    config.revision = revision.read.strip[0, 7] if revision&.exist?
  end
  ```

  ```yaml YAML theme={null}
  production:
    <% revision = if (defined?(Rails)); Rails.root.join('REVISION'); end %>
    <% if revision&.exist? %>
    revision: "<%= revision.read.strip[0, 7] %>"
    <% end %>
  ```
</CodeGroup>

[Leia mais sobre os detalhes da opção de configuração `revision` para Ruby](/ruby/configuration/options#option-revision)

### Elixir

Para aplicativos Elixir, carregaremos a revisão Git no arquivo de configuração `config/appsignal.exs` (a localização do seu arquivo pode ser diferente).

No exemplo de arquivo `config/appsignal.exs` abaixo, chamamos o comando `git rev-parse` com Elixir e definimos a saída como a opção de configuração `revision`.

<CodeGroup>
  ```elixir Elixir theme={null}
  # Exemplo: config/appsignal.exs
  {revision, _exitcode} = System.cmd("git", ["log", "--pretty=format:%h", "-n 1"])
  config :appsignal, :config,
    revision: revision
    # Outras opções de configuração
  ```
</CodeGroup>

[Leia mais sobre os detalhes da opção de configuração `revision` para Elixir](/elixir/configuration/options#option-revision)

### Node.js

Para aplicativos Node.js, a revisão Git é carregada no arquivo de configuração do app.

No snippet `.js` abaixo, chamamos o comando `git rev-parse` com Node.js e definimos a saída como a opção de configuração `revision`.

<CodeGroup>
  ```javascript Node.js theme={null}
  // Exemplo: appsignal.js
  const childProcess = require("child_process");
  const REVISION = childProcess.execSync("git rev-parse --short HEAD").toString();
  const appsignal = new Appsignal({
    revision: REVISION,
    // Outras configurações
  });

  module.exports = { appsignal };
  ```
</CodeGroup>

[Leia mais sobre os detalhes da opção de configuração `revision` para Node.js](/nodejs/3.x/configuration/options#option-revision)

### Python

Para aplicativos Python, a revisão Git é carregada no arquivo de configuração `__appsignal__.py` do aplicativo.

No exemplo abaixo, chamamos o comando `git rev-parse` com Python e definimos a saída como a opção de configuração `revision`. O comando shell que executamos é o mesmo comando que usamos [anteriormente](#automatically-update-the-revision) para recuperar o hash do commit atual.

<CodeGroup>
  ```python Python theme={null}
  # Exemplo: __appsignal__.py
  import subprocess
  from appsignal import Appsignal

  revision = subprocess.check_output(
      "git rev-parse --short HEAD", shell=True, text=True
  ).strip()

  appsignal = Appsignal(
      # Outras configurações
      revision=revision
  )
  ```
</CodeGroup>

[Leia mais sobre os detalhes da opção de configuração `revision` para Python](/python/configuration/options#option-revision)

### JavaScript de front-end

Como os aplicativos JavaScript de front-end são executados no navegador, não é possível chamar o comando executável `git` do seu aplicativo de front-end para obter a `revision` atual. Existem duas abordagens comuns para passar o valor da revisão ao seu aplicativo de front-end:

#### Usando variáveis de ambiente em tempo de build (recomendado para front-ends desacoplados)

Ferramentas modernas de build de front-end incorporam variáveis de ambiente ao seu bundle em tempo de build. Você pode passar a revisão Git por meio de uma dessas variáveis e referenciá-la na sua configuração do AppSignal.

O prefixo da variável e o padrão de acesso dependem da ferramenta de build. O exemplo abaixo usa o **Vite**, que expõe variáveis de ambiente prefixadas com `VITE_` através do objeto `import.meta.env`. Defina a variável antes do build:

<CodeGroup>
  ```bash Bash theme={null}
  export VITE_REVISION=$(git rev-parse --short HEAD)
  npm run build
  ```
</CodeGroup>

Em seguida, leia-a no arquivo onde você configura o AppSignal:

<CodeGroup>
  ```javascript JavaScript theme={null}
  // Exemplo: appsignal.js
  export const appsignal = new Appsignal({
    revision: import.meta.env.VITE_REVISION,
    // Outras configurações
  });
  ```
</CodeGroup>

Importe a instância `appsignal` configurada onde você inicializa seu app. Por exemplo, em um `main.js` de uma aplicação Vue:

<CodeGroup>
  ```javascript JavaScript theme={null}
  // Exemplo: main.js
  import { createApp } from "vue";
  import App from "./App.vue";
  import { appsignal } from "./appsignal";
  import { errorHandler } from "@appsignal/vue";

  const app = createApp(App);
  app.config.errorHandler = errorHandler(appsignal, app);

  app.mount("#app");
  ```
</CodeGroup>

#### Usando um atributo HTML renderizado pelo back-end

Se o seu front-end for renderizado por uma aplicação de back-end (como uma aplicação Ruby ou Elixir), você pode definir o valor da `revision` no corpo HTML como um atributo data:

<CodeGroup>
  ```html HTML theme={null}
  <body data-app-revision="REVISION VALUE">
    <!-- Restante do HTML -->
  </body>
  ```
</CodeGroup>

Em seguida, recupere este valor no seu JavaScript:

<CodeGroup>
  ```javascript JavaScript theme={null}
  // Exemplo: appsignal.js
  const body = document.body;
  export const appsignal = new Appsignal({
    revision: body.dataset.appRevision,
    // Outras configurações
  });
  ```
</CodeGroup>

[Leia mais sobre os detalhes da opção de configuração `revision` para JavaScript](/front-end/configuration#option-revision)

### Go

Para aplicativos Go, a revisão é definida em um atributo de recurso OpenTelemetry quando o OpenTelemetry é inicializado.

No exemplo abaixo, chamamos o comando `git rev-parse` e definimos a saída como o atributo de recurso `appsignal.config.revision`. O comando shell que executamos é o mesmo comando que usamos [anteriormente](#automatically-update-the-revision) para recuperar o hash do commit atual.

<CodeGroup>
  ```go Go theme={null}
  import (
  	"os/exec"

  	// E outras importações
  )

  var revision string
  cmd := exec.Command("git", "rev-parse", "--short", "HEAD")
  output, err := cmd.Output()
  if err != nil {
  	revision = "unknown"
  } else {
  	revision = strings.TrimSpace(string(output))
  }

  res := resource.NewWithAttributes(
  	resource.WithAttributes(attribute.String("appsignal.config.revision", revision)),
  	// E outros atributos de recurso
  )
  ```
</CodeGroup>

Para aplicativos Go, a [opção de configuração `appsignal.config.revision`][go revision option] é uma configuração obrigatória, portanto, ela já deve estar definida. Consulte a [opção de configuração `appsignal.config.revision`][go revision option] para mais informações.

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

### Java

Para aplicativos Java, defina a revisão usando a variável de ambiente `OTEL_RESOURCE_ATTRIBUTES`. Usaremos o mesmo comando Git mostrado [anteriormente](#automatically-update-the-revision).

<CodeGroup>
  ```bash Bash theme={null}
  export OTEL_RESOURCE_ATTRIBUTES="\
    appsignal.config.revision=$(git rev-parse --short HEAD),\
    ..."
  ```
</CodeGroup>

Para aplicativos Java, a [opção de configuração `appsignal.config.revision`][java revision option] é uma configuração obrigatória, portanto, ela já deve estar definida. Consulte a [opção de configuração `appsignal.config.revision`][java revision option] para mais informações.

[java revision option]: /java/configuration/options.html#option-revision

### PHP

Para aplicativos PHP, defina a revisão na sua configuração para sobrescrever o padrão. Por padrão, o AppSignal define a revisão usando o mesmo comando Git mostrado em [Atualizar a revisão automaticamente](#automatically-update-the-revision).

<CodeGroup>
  ```php PHP theme={null}
  $revision = trim(shell_exec('git rev-parse --short HEAD 2>/dev/null')) ?: 'unknown';

  return [
      'revision' => $revision,
      // ... outras opções
  ];
  ```
</CodeGroup>

Consulte a [opção de configuração `appsignal.config.revision`][php revision option] para mais informações.

[php revision option]: /php/configuration/options.html#option-revision

## Deploy

Quando terminar de configurar a opção `revision`, faça o commit das suas alterações e o deploy do seu aplicativo. Quando o app iniciar/reiniciar, o AppSignal criará um deploy na [seção de deploys] do seu app.

É isso! Você configurou com sucesso seu aplicativo para notificar o AppSignal sobre deploys! Os dados do seu aplicativo serão rastreados juntamente com o deployment apropriado, ajudando a aprimorar sua capacidade de analisar o desempenho do seu aplicativo.

Os deploys não estão sendo reportados ou estão sendo reportados incorretamente? [Entre em contato conosco][contact] e nós o ajudaremos!

[deploy markers]: /application/markers/deploy-markers.html

[automatic report]: /application/markers/deploy-markers.html#revision-config-option

[error backtrace links]: /application/backtrace-links.html

[seção de deploys]: https://appsignal.com/redirect-to/app?to=markers

[contact]: mailto:support@appsignal.com