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

# Signaler les déploiements pour suivre les améliorations

Le fonctionnement de votre application peut évoluer à chaque nouveau déploiement. En suivant vos déploiements avec AppSignal, les incidents d'erreurs et les mesures de performance sont regroupés par déploiement, vous permettant de voir facilement quel impact vos déploiements ont eu sur les performances et le taux d'erreurs de votre application. AppSignal peut vous amener d'un [backtrace d'erreur][error backtrace links] à la ligne de code d'où provient une erreur spécifique, et cela aide

Ce guide vous montrera comment suivre les déploiements dans AppSignal à l'aide de marqueurs de déploiement.

<Tip>
  Lisez des informations plus détaillées sur les [marqueurs de déploiement][deploy markers] et leur utilité.
</Tip>

## Configurer AppSignal

Ce guide utilisera la méthode de l'option de configuration `revision` pour signaler les marqueurs de déploiement. Vous pouvez en savoir plus sur les approches alternatives dans notre documentation [Marqueurs de déploiement][deploy markers].

L'option de configuration `revision` est configurée différemment selon le langage de l'intégration. Consultez la liste des intégrations ci-dessous pour celle que votre application utilise.

Notez qu'AppSignal [signalera automatiquement un déploiement][automatic report] lors de l'utilisation de plateformes telles que Heroku ou Render, ou d'orchestrateurs de déploiement tels que Kamal.

### Mettre à jour automatiquement la révision

Nous vous recommandons de récupérer dynamiquement la valeur de l'option de configuration revision depuis le système de gestion de code source utilisé pour votre projet (comme Git ou SVN) au démarrage ou au déploiement. De cette façon, la valeur n'a pas besoin d'être mise à jour manuellement à chaque déploiement. Si un hash de commit Git est utilisé, il sera également compatible avec les [liens vers les backtraces d'erreurs][error backtrace links].

Voici un exemple de la façon de procéder avec Git :

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

Nous continuerons à utiliser Git pour tous les exemples d'intégration dans cette documentation.

## Configurations par langage

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

### Ruby

Pour les applications Ruby, nous chargerons la révision Git depuis le fichier de configuration.

La commande shell que nous exécutons dans l'option de configuration `revision` est la même commande que nous avons utilisée [précédemment](#automatically-update-the-revision) pour récupérer le hash du commit actuel. Nous appelons la commande `git rev-parse` et définissons la sortie comme valeur de l'option de configuration `revision`, comme dans l'exemple ci-dessous :

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

#### Utilisation des gems de déploiement Ruby

Si vous utilisez un outil de déploiement comme [Capistrano](https://github.com/capistrano/capistrano) ou [Hatchbox](https://www.hatchbox.io/) qui exclut le dossier `.git` du déploiement :

* Modifiez le processus de déploiement pour exécuter une commande qui crée un fichier `REVISION` dans le dossier `current` contenant le hash Git : `git rev-parse --short HEAD > REVISION`

Lorsque vous utilisez un fournisseur Platform-as-a-Service, le fournisseur peut créer ce fichier pour vous ou exposer la révision en tant que variable d'environnement que vous pouvez lire depuis le fichier de configuration. Si vous n'êtes pas sûr que cela s'applique à vous, vérifiez avec votre fournisseur ou [contactez-nous](/support), nous connaissons peut-être la réponse.

Voici un exemple de la façon de lire le hash Git depuis un fichier `REVISION` lors de l'utilisation de `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>

[Lire plus sur les détails de l'option de configuration `revision` de Ruby](/ruby/configuration/options#option-revision)

### Elixir

Pour les applications Elixir, nous chargerons la révision Git dans le fichier de configuration `config/appsignal.exs` (l'emplacement de votre fichier peut différer).

Dans l'exemple de fichier `config/appsignal.exs` ci-dessous, nous appelons la commande `git rev-parse` avec Elixir et définissons la sortie comme valeur de l'option de configuration `revision`.

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

[Lire plus sur les détails de l'option de configuration `revision` d'Elixir](/elixir/configuration/options#option-revision)

### Node.js

Pour les applications Node.js, la révision Git est chargée dans le fichier de configuration de l'application.

Dans l'extrait `.js` ci-dessous, nous appelons la commande `git rev-parse` avec Node.js et définissons la sortie comme valeur de l'option de configuration `revision`.

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

[Lire plus sur les détails de l'option de configuration `revision` de Node.js](/nodejs/3.x/configuration/options#option-revision)

### Python

Pour les applications Python, la révision Git est chargée dans le fichier de configuration `__appsignal__.py` de l'application.

Dans l'exemple ci-dessous, nous appelons la commande `git rev-parse` avec Python et définissons la sortie comme valeur de l'option de configuration `revision`. La commande shell que nous exécutons est la même commande que nous avons utilisée [précédemment](#automatically-update-the-revision) pour récupérer le hash du commit actuel.

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

[Lire plus sur les détails de l'option de configuration `revision` de Python](/python/configuration/options#option-revision)

### JavaScript front-end

Comme les applications JavaScript front-end s'exécutent dans le navigateur, il n'est pas possible d'appeler la commande exécutable `git` depuis votre application front-end pour obtenir la `revision` actuelle. Il existe deux approches courantes pour transmettre la valeur de la révision à votre application front-end :

#### Utiliser les variables d'environnement au moment du build (recommandé pour les front-ends découplés)

Les outils de build front-end modernes intègrent les variables d'environnement dans votre bundle au moment du build. Vous pouvez transmettre la révision Git via l'une de ces variables et la référencer dans votre configuration AppSignal.

Le préfixe de la variable et le modèle d'accès dépendent de votre outil de build. L'exemple ci-dessous utilise **Vite**, qui expose les variables d'environnement préfixées par `VITE_` via l'objet `import.meta.env`. Définissez la variable avant de construire :

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

Lisez-la ensuite dans le fichier où vous configurez AppSignal :

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

Importez l'instance `appsignal` configurée à l'endroit où vous initialisez votre application. Par exemple, dans le `main.js` d'une application Vue :

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

#### Utiliser un attribut HTML rendu côté back-end

Si votre front-end est rendu par une application back-end (telle qu'une application Ruby ou Elixir), vous pouvez définir la valeur de `revision` dans le corps HTML en tant qu'attribut data :

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

Récupérez ensuite cette valeur dans votre 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>

[Lire plus sur les détails de l'option de configuration `revision` de JavaScript](/front-end/configuration#option-revision)

### Go

Pour les applications Go, la révision est définie sur un attribut de ressource OpenTelemetry lors de l'initialisation d'OpenTelemetry.

Dans l'exemple ci-dessous, nous appelons la commande `git rev-parse` et définissons la sortie comme attribut de ressource `appsignal.config.revision`. La commande shell que nous exécutons est la même commande que nous avons utilisée [précédemment](#automatically-update-the-revision) pour récupérer le hash du commit actuel.

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

Pour les applications Go, l'[option de configuration `appsignal.config.revision`][go revision option] est une configuration obligatoire, elle devrait donc déjà être définie. Veuillez consulter l'[option de configuration `appsignal.config.revision`][go revision option] pour plus d'informations.

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

### Java

Pour les applications Java, définissez la révision à l'aide de la variable d'environnement `OTEL_RESOURCE_ATTRIBUTES`. Nous utiliserons la même commande Git que celle indiquée [précédemment](#automatically-update-the-revision).

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

Pour les applications Java, l'[option de configuration `appsignal.config.revision`][java revision option] est une configuration obligatoire, elle devrait donc déjà être définie. Veuillez consulter l'[option de configuration `appsignal.config.revision`][java revision option] pour plus d'informations.

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

### PHP

Pour les applications PHP, définissez la révision dans votre configuration pour remplacer la valeur par défaut. Par défaut, AppSignal définit la révision en utilisant la même commande Git que celle présentée dans [Mettre à jour automatiquement la révision](#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>

Veuillez consulter l'[option de configuration `appsignal.config.revision`][php revision option] pour plus d'informations.

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

## Déployer

Une fois la configuration de l'option `revision` terminée, validez vos modifications et déployez votre application. Au démarrage/redémarrage de l'application, AppSignal créera un déploiement dans la [section déploiements] pour votre application.

C'est tout ! Vous avez configuré avec succès votre application pour notifier AppSignal des déploiements ! Les données de votre application seront suivies aux côtés du déploiement approprié, vous aidant à mieux analyser les performances de votre application.

Les déploiements ne sont pas signalés ou le sont de manière incorrecte ? [Contactez-nous][contact] et nous vous aiderons !

[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

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

[contact]: mailto:support@appsignal.com