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

# Deploys rapporteren om verbeteringen bij te houden

Hoe uw applicatie functioneert kan veranderen bij elke nieuwe deployment. Door uw deploys bij te houden met AppSignal worden foutincidenten en prestatiemetingen per deployment gegroepeerd, zodat u eenvoudig kunt zien welke impact uw deployment heeft gehad op de prestaties en het foutpercentage van uw applicatie. AppSignal kan u van een [foutbacktrace][error backtrace links] meenemen naar de regel code waar een specifieke fout vandaan kwam, en dit helpt

Deze gids laat u zien hoe u deploys bijhoudt in AppSignal met behulp van deploy markers.

<Tip>
  Lees meer diepgaande informatie over [deploy markers][deploy markers] en
  waar ze voor worden gebruikt.
</Tip>

## AppSignal configureren

Deze gids gebruikt de `revision` configuratieoptie-methode om deploy markers te rapporteren. U kunt lezen over alternatieve benaderingen hiervan in onze [Deploy Markers] documentatie.

De `revision` configuratieoptie wordt anders geconfigureerd per integratietaal. Zie de lijst met integraties hieronder voor de taal die uw app gebruikt.

Houd er rekening mee dat AppSignal [automatisch een deploy rapporteert][automatic report] bij gebruik van platforms zoals Heroku of Render, of deployment-orchestrators zoals Kamal.

### De revisie automatisch bijwerken

We raden aan om de waarde van de revision configuratieoptie dynamisch op te halen uit het source control management dat voor uw project wordt gebruikt (zoals Git of SVN) bij start of deploy. Op deze manier hoeft de waarde niet handmatig per deploy te worden bijgewerkt. Als een Git commit-hash wordt gebruikt, is deze ook compatibel met [foutbacktrace-links][error backtrace links].

Hieronder een voorbeeld van hoe u dit zou doen met Git:

<CodeGroup>
  ```bash Bash theme={null}
  git rev-parse --short HEAD
  # Will output the current commit's short SHA
  ```
</CodeGroup>

We blijven Git gebruiken voor alle integratievoorbeelden in deze documentatie.

## Configuraties per taal

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

### Ruby

Voor Ruby-applicaties laden we de Git-revisie uit het configuratiebestand.

Het shell-commando dat we uitvoeren in de `revision` configuratieoptie is hetzelfde commando dat we [eerder](#automatically-update-the-revision) gebruikten om de hash van de huidige commit op te halen. We roepen het `git rev-parse` commando aan en stellen de uitvoer in als de `revision` configuratieoptie, zoals in het onderstaande voorbeeld:

<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 %>"
    # Other config options
  ```
</CodeGroup>

#### Ruby deploy-gems gebruiken

Als u een deployment-tool gebruikt zoals [Capistrano](https://github.com/capistrano/capistrano) of [Hatchbox](https://www.hatchbox.io/) die de `.git`-map uitsluit van deployment:

* Pas het deploy-proces aan om een commando uit te voeren dat een `REVISION` bestand aanmaakt in de `current`-map dat de Git-hash bevat: `git rev-parse --short HEAD > REVISION`

Bij gebruik van een Platform-as-a-Service provider, kan de provider dit bestand voor u maken, of de revisie blootstellen als een omgevingsvariabele die u uit het configuratiebestand kunt lezen. Als u niet zeker weet of dit op u van toepassing is, neem dan contact op met uw provider of [neem contact op](/support), wij weten mogelijk het antwoord.

Hieronder een voorbeeld van hoe u de Git-hash uit een `REVISION` bestand kunt lezen bij gebruik van `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>

[Meer lezen over de details van de Ruby `revision` configuratieoptie](/ruby/configuration/options#option-revision)

### Elixir

Voor Elixir-applicaties laden we de Git-revisie in het `config/appsignal.exs` configuratiebestand (uw bestandslocatie kan verschillen).

In het onderstaande voorbeeld `config/appsignal.exs` bestand roepen we het `git rev-parse` commando aan met Elixir en stellen de uitvoer in als de `revision` configuratieoptie.

<CodeGroup>
  ```elixir Elixir theme={null}
  # Example: config/appsignal.exs
  {revision, _exitcode} = System.cmd("git", ["log", "--pretty=format:%h", "-n 1"])
  config :appsignal, :config,
    revision: revision
    # Other config options
  ```
</CodeGroup>

[Meer lezen over de details van de Elixir `revision` configuratieoptie](/elixir/configuration/options#option-revision)

### Node.js

Voor Node.js-applicaties wordt de Git-revisie geladen in het configuratiebestand van de app.

In de onderstaande `.js` snippet roepen we het `git rev-parse` commando aan met Node.js en stellen de uitvoer in als de `revision` configuratieoptie.

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

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

[Meer lezen over de details van de Node.js `revision` configuratieoptie](/nodejs/3.x/configuration/options#option-revision)

### Python

Voor Python-applicaties wordt de Git-revisie geladen in het `__appsignal__.py` configuratiebestand van de applicatie.

In het onderstaande voorbeeld roepen we het `git rev-parse` commando aan met Python en stellen de uitvoer in als de `revision` configuratieoptie. Het shell-commando dat we uitvoeren is hetzelfde commando dat we [eerder](#automatically-update-the-revision) gebruikten om de hash van de huidige commit op te halen.

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

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

  appsignal = Appsignal(
      # Other config
      revision=revision
  )
  ```
</CodeGroup>

[Meer lezen over de details van de Python `revision` configuratieoptie](/python/configuration/options#option-revision)

### Front-end JavaScript

Omdat front-end JavaScript-applicaties in de browser draaien, is het niet mogelijk om het `git` uitvoerbare commando aan te roepen vanuit uw front-end applicatie om de huidige `revision` op te halen. Er zijn twee veelvoorkomende benaderingen om de revisiewaarde door te geven aan uw front-end applicatie:

#### Omgevingsvariabelen tijdens build-tijd gebruiken (aanbevolen voor losgekoppelde front-ends)

Moderne front-end build-tools sluiten omgevingsvariabelen in uw bundle in tijdens de build-tijd. U kunt de Git-revisie via een van deze variabelen doorgeven en ernaar verwijzen in uw AppSignal-configuratie.

Het variabel-prefix en het toegangspatroon zijn afhankelijk van uw build-tool. Het onderstaande voorbeeld gebruikt **Vite**, dat omgevingsvariabelen met het prefix `VITE_` blootstelt via het `import.meta.env` object. Stel de variabele in voordat u bouwt:

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

Lees deze vervolgens in het bestand waar u AppSignal configureert:

<CodeGroup>
  ```javascript JavaScript theme={null}
  // Example: appsignal.js
  export const appsignal = new Appsignal({
    revision: import.meta.env.VITE_REVISION,
    // Other config
  });
  ```
</CodeGroup>

Importeer de geconfigureerde `appsignal` instance overal waar u uw app initialiseert. Bijvoorbeeld in de `main.js` van een Vue-applicatie:

<CodeGroup>
  ```javascript JavaScript theme={null}
  // Example: 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>

#### Een door de back-end gerenderd HTML-attribuut gebruiken

Als uw front-end wordt gerenderd door een back-end applicatie (zoals een Ruby- of Elixir-applicatie), kunt u de `revision` waarde definiëren in de HTML-body als een data-attribuut:

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

Haal deze waarde vervolgens op in uw JavaScript:

<CodeGroup>
  ```javascript JavaScript theme={null}
  // Example: appsignal.js
  const body = document.body;
  export const appsignal = new Appsignal({
    revision: body.dataset.appRevision,
    // Other config
  });
  ```
</CodeGroup>

[Meer lezen over de details van de JavaScript `revision` configuratieoptie](/front-end/configuration#option-revision)

### Go

Voor Go-applicaties wordt de revisie ingesteld op een OpenTelemetry resource-attribuut wanneer OpenTelemetry wordt geïnitialiseerd.

In het onderstaande voorbeeld roepen we het `git rev-parse` commando aan en stellen de uitvoer in als het `appsignal.config.revision` resource-attribuut. Het shell-commando dat we uitvoeren is hetzelfde commando dat we [eerder](#automatically-update-the-revision) gebruikten om de hash van de huidige commit op te halen.

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

  	// And other imports
  )

  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)),
  	// And other resource attributes
  )
  ```
</CodeGroup>

Voor Go-applicaties is de [`appsignal.config.revision` configuratieoptie][go revision option] een verplichte configuratie en moet deze dus al zijn ingesteld. Raadpleeg de [`appsignal.config.revision` configuratieoptie][go revision option] voor meer informatie.

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

### Java

Voor Java-applicaties stelt u de revisie in met behulp van de `OTEL_RESOURCE_ATTRIBUTES` omgevingsvariabele. We gebruiken hetzelfde Git-commando zoals [eerder](#automatically-update-the-revision) is getoond.

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

Voor Java-applicaties is de [`appsignal.config.revision` configuratieoptie][java revision option] een verplichte configuratie en moet deze dus al zijn ingesteld. Raadpleeg de [`appsignal.config.revision` configuratieoptie][java revision option] voor meer informatie.

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

### PHP

Voor PHP-applicaties stelt u de revisie in uw configuratie in om de standaardwaarde te overschrijven. Standaard stelt AppSignal de revisie in met hetzelfde Git-commando dat wordt getoond in [De revisie automatisch bijwerken](#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,
      // ... other options
  ];
  ```
</CodeGroup>

Raadpleeg de [`appsignal.config.revision` configuratieoptie][php revision option] voor meer informatie.

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

## Deploy

Wanneer u klaar bent met het configureren van de `revision` optie, commit uw wijzigingen en deploy uw applicatie. Wanneer de app start/herstart, maakt AppSignal een deploy aan in de [deploys-sectie][deploys section] voor uw app.

Dat is alles! U heeft uw applicatie met succes geconfigureerd om AppSignal op de hoogte te stellen van deploys! De gegevens van uw applicatie worden bijgehouden naast de bijbehorende deployment, wat u helpt om uw mogelijkheid om de prestaties van uw applicatie te analyseren te verbeteren.

Worden deploys niet of onjuist gerapporteerd? [Neem contact met ons op][contact] en wij helpen u verder!

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

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

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

[deploys section]: https://appsignal.com/redirect-to/app?to=markers

[contact]: mailto:support@appsignal.com