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

# Deployments melden, um Verbesserungen zu verfolgen

Die Funktionsweise Ihrer Anwendung kann sich mit jedem neuen Deployment ändern. Wenn Sie Ihre Deployments mit AppSignal verfolgen, werden Fehlervorfälle und Performance-Messungen pro Deployment gruppiert, sodass Sie leicht sehen können, welche Auswirkungen Ihre Deployments auf die Performance und Fehlerrate Ihrer Anwendung hatten. AppSignal kann Sie von einem [Fehler-Backtrace][error backtrace links] zur Codezeile führen, aus der ein bestimmter Fehler stammt, und dies hilft

Dieser Leitfaden zeigt Ihnen, wie Sie Deployments in AppSignal mit Deploy-Markern verfolgen.

<Tip>
  Lesen Sie ausführlichere Informationen über [Deploy-Marker][deploy markers] und wofür
  sie verwendet werden.
</Tip>

## AppSignal konfigurieren

Dieser Leitfaden verwendet die Methode der Konfigurationsoption `revision` zum Melden von Deploy-Markern. Über alternative Ansätze hierzu können Sie in unserer \[Deploy-Marker]-Dokumentation lesen.

Die Konfigurationsoption `revision` wird je nach Integrationssprache unterschiedlich konfiguriert. Sehen Sie sich die Liste der Integrationen unten an für diejenige, die Ihre App verwendet.

Beachten Sie, dass AppSignal [automatisch ein Deployment meldet][automatic report] bei Verwendung von Plattformen wie Heroku oder Render oder Deployment-Orchestratoren wie Kamal.

### Revision automatisch aktualisieren

Wir empfehlen, den Wert der Konfigurationsoption `revision` beim Start oder Deployment dynamisch aus dem für Ihr Projekt verwendeten Versionskontrollsystem (wie Git oder SVN) abzurufen. Auf diese Weise muss der Wert nicht manuell pro Deployment aktualisiert werden. Bei Verwendung eines Git-Commit-Hashs ist er auch kompatibel mit [Fehler-Backtrace-Links][error backtrace links].

Unten finden Sie ein Beispiel, wie Sie dies mit Git tun würden:

<CodeGroup>
  ```bash Bash theme={null}
  git rev-parse --short HEAD
  # Gibt den kurzen SHA des aktuellen Commits aus
  ```
</CodeGroup>

Wir werden in dieser Dokumentation für alle Integrationsbeispiele weiterhin Git verwenden.

## Konfigurationen pro Sprache

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

### Ruby

Für Ruby-Anwendungen laden wir die Git-Revision aus der Konfigurationsdatei.

Der Shell-Befehl, den wir in der Konfigurationsoption `revision` ausführen, ist derselbe Befehl, den wir [zuvor](#automatically-update-the-revision) verwendet haben, um den Hash des aktuellen Commits abzurufen. Wir rufen den Befehl `git rev-parse` auf und setzen die Ausgabe als Konfigurationsoption `revision`, wie im Beispiel unten gezeigt:

<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 %>"
    # Andere Konfigurationsoptionen
  ```
</CodeGroup>

#### Verwendung von Ruby-Deploy-Gems

Wenn Sie ein Deployment-Tool wie [Capistrano](https://github.com/capistrano/capistrano) oder [Hatchbox](https://www.hatchbox.io/) verwenden, das den Ordner `.git` vom Deployment ausschließt:

* Ändern Sie den Deployment-Prozess so, dass er einen Befehl ausführt, der eine `REVISION`-Datei im `current`-Ordner erstellt, die den Git-Hash enthält: `git rev-parse --short HEAD > REVISION`

Bei Verwendung eines Platform-as-a-Service-Anbieters erstellt der Anbieter möglicherweise diese Datei für Sie oder stellt die Revision als Umgebungsvariable zur Verfügung, die Sie aus der Konfigurationsdatei lesen können. Wenn Sie sich nicht sicher sind, ob dies auf Sie zutrifft, fragen Sie bei Ihrem Anbieter nach oder [setzen Sie sich mit uns in Verbindung](/support), wir kennen möglicherweise die Antwort.

Unten finden Sie ein Beispiel, wie der Git-Hash aus einer `REVISION`-Datei bei Verwendung von `Rails` gelesen wird:

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

[Mehr über die Details der Ruby-Konfigurationsoption `revision` lesen](/ruby/configuration/options#option-revision)

### Elixir

Für Elixir-Anwendungen laden wir die Git-Revision in der Konfigurationsdatei `config/appsignal.exs` (Ihr Dateispeicherort kann abweichen).

In der untenstehenden Beispiel-Datei `config/appsignal.exs` rufen wir den Befehl `git rev-parse` mit Elixir auf und setzen die Ausgabe als Konfigurationsoption `revision`.

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

[Mehr über die Details der Elixir-Konfigurationsoption `revision` lesen](/elixir/configuration/options#option-revision)

### Node.js

Für Node.js-Anwendungen wird die Git-Revision in der Konfigurationsdatei der App geladen.

Im untenstehenden `.js`-Snippet rufen wir den Befehl `git rev-parse` mit Node.js auf und setzen die Ausgabe als Konfigurationsoption `revision`.

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

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

[Mehr über die Details der Node.js-Konfigurationsoption `revision` lesen](/nodejs/3.x/configuration/options#option-revision)

### Python

Für Python-Anwendungen wird die Git-Revision in der Konfigurationsdatei `__appsignal__.py` der Anwendung geladen.

Im Beispiel unten rufen wir den Befehl `git rev-parse` mit Python auf und setzen die Ausgabe als Konfigurationsoption `revision`. Der ausgeführte Shell-Befehl ist derselbe Befehl, den wir [zuvor](#automatically-update-the-revision) verwendet haben, um den Hash des aktuellen Commits abzurufen.

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

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

  appsignal = Appsignal(
      # Andere Konfiguration
      revision=revision
  )
  ```
</CodeGroup>

[Mehr über die Details der Python-Konfigurationsoption `revision` lesen](/python/configuration/options#option-revision)

### Front-end JavaScript

Da Front-end-JavaScript-Anwendungen im Browser laufen, ist es nicht möglich, den `git`-Befehl von Ihrer Front-end-Anwendung aus aufzurufen, um die aktuelle `revision` zu erhalten. Es gibt zwei gängige Ansätze, um den Revision-Wert an Ihre Front-end-Anwendung weiterzugeben:

#### Verwendung von Build-Zeit-Umgebungsvariablen (empfohlen für entkoppelte Front-ends)

Moderne Front-end-Build-Tools betten Umgebungsvariablen zur Build-Zeit in Ihr Bundle ein. Sie können die Git-Revision über eine dieser Variablen übergeben und in Ihrer AppSignal-Konfiguration referenzieren.

Das Variablenpräfix und das Zugriffsmuster hängen von Ihrem Build-Tool ab. Das untenstehende Beispiel verwendet **Vite**, das Umgebungsvariablen mit dem Präfix `VITE_` über das Objekt `import.meta.env` verfügbar macht. Setzen Sie die Variable vor dem Build:

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

Lesen Sie sie dann in der Datei, in der Sie AppSignal konfigurieren:

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

Importieren Sie die konfigurierte `appsignal`-Instanz, wo immer Sie Ihre App initialisieren. Zum Beispiel in der `main.js`-Datei einer Vue-Anwendung:

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

#### Verwendung eines vom Back-end gerenderten HTML-Attributs

Wenn Ihr Front-end von einer Back-end-Anwendung (wie einer Ruby- oder Elixir-Anwendung) gerendert wird, können Sie den `revision`-Wert im HTML-Body als Datenattribut definieren:

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

Rufen Sie diesen Wert dann in Ihrem JavaScript ab:

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

[Mehr über die Details der JavaScript-Konfigurationsoption `revision` lesen](/front-end/configuration#option-revision)

### Go

Für Go-Anwendungen wird die Revision auf ein OpenTelemetry-Ressourcenattribut gesetzt, wenn OpenTelemetry initialisiert wird.

Im Beispiel unten rufen wir den Befehl `git rev-parse` auf und setzen die Ausgabe als Ressourcenattribut `appsignal.config.revision`. Der ausgeführte Shell-Befehl ist derselbe Befehl, den wir [zuvor](#automatically-update-the-revision) verwendet haben, um den Hash des aktuellen Commits abzurufen.

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

  	// Und andere 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)),
  	// Und andere Ressourcenattribute
  )
  ```
</CodeGroup>

Für Go-Anwendungen ist die [`appsignal.config.revision`-Konfigurationsoption][go revision option] erforderliche Konfiguration, sodass sie bereits gesetzt sein sollte. Bitte konsultieren Sie die [`appsignal.config.revision`-Konfigurationsoption][go revision option] für weitere Informationen.

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

### Java

Für Java-Anwendungen setzen Sie die Revision über die Umgebungsvariable `OTEL_RESOURCE_ATTRIBUTES`. Wir verwenden denselben Git-Befehl, der [zuvor](#automatically-update-the-revision) gezeigt wurde.

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

Für Java-Anwendungen ist die [`appsignal.config.revision`-Konfigurationsoption][java revision option] erforderliche Konfiguration, sodass sie bereits gesetzt sein sollte. Bitte konsultieren Sie die [`appsignal.config.revision`-Konfigurationsoption][java revision option] für weitere Informationen.

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

### PHP

Für PHP-Anwendungen setzen Sie die Revision in Ihrer Konfiguration, um den Standardwert zu überschreiben. Standardmäßig setzt AppSignal die Revision mit demselben Git-Befehl, der in [Revision automatisch aktualisieren](#automatically-update-the-revision) gezeigt wird.

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

  return [
      'revision' => $revision,
      // ... andere Optionen
  ];
  ```
</CodeGroup>

Bitte konsultieren Sie die [`appsignal.config.revision`-Konfigurationsoption][php revision option] für weitere Informationen.

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

## Deployment

Wenn Sie mit der Konfiguration der Option `revision` fertig sind, committen Sie Ihre Änderungen und deployen Sie Ihre Anwendung. Wenn die App startet/neu startet, erstellt AppSignal ein Deployment im [Deployment-Bereich] für Ihre App.

Das war's! Sie haben Ihre Anwendung erfolgreich konfiguriert, AppSignal über Deployments zu benachrichtigen! Die Daten Ihrer Anwendung werden zusammen mit dem entsprechenden Deployment verfolgt, was Ihre Fähigkeit, die Performance Ihrer Anwendung zu analysieren, verbessert.

Werden Deployments nicht oder falsch gemeldet? [Kontaktieren Sie uns][contact] und wir helfen Ihnen weiter!

[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

[Deployment-Bereich]: https://appsignal.com/redirect-to/app?to=markers

[contact]: mailto:support@appsignal.com