> ## 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.
# Configurer des applications
Bienvenue dans notre guide de configuration. Ce guide vous apprendra à ajouter et modifier les configurations de votre intégration AppSignal.
Lisez plus d'informations sur la configuration de l'intégration AppSignal
dans votre application dans notre [section configuration][config topic].
## Choisir une option de configuration
Ce guide vous accompagne dans les étapes nécessaires pour configurer votre application afin qu'elle réponde au mieux à vos besoins. Il existe bien sûr plusieurs options de configuration pour votre application, mais comme la méthode d'implémentation est identique pour toutes les options, dans ce guide, nous nous concentrerons sur les configurations suivantes :
Nous utiliserons l'option `log_level` comme exemple pour les applications [Ruby](/ruby/configuration/options#option-log_level), [Elixir](/elixir/configuration/options#option-log_level), [Node.js](/nodejs/3.x/configuration/options#option-loglevel) et [Python](/python/configuration/options#option-log_level).
Nous utiliserons l'option `namespace` comme exemple pour les [applications JavaScript front-end](/front-end/configuration).
## Méthodes de configuration
Il existe plusieurs façons de configurer votre intégration AppSignal, et les intégrations peuvent varier en fonction du langage de votre application, mais elles disposent toutes des méthodes de configuration suivantes :
* [Configuration par fichier :](#file-based-configuration)
Un fichier de configuration depuis lequel l'intégration AppSignal lit la
configuration AppSignal.
* [Configuration par variables d'environnement système :][env]
Les variables d'environnement sont définies sur le système hôte (serveur) sur le
processus parent qui démarre votre application.
**Remarque** : cette méthode n'est pas disponible pour le JavaScript front-end.
## Configuration par fichier
La configuration par fichier est le moyen le plus simple de configurer votre intégration.
Certaines intégrations créent un fichier de configuration lors de l'installation d'AppSignal dans l'application. Dans ces fichiers de configuration, vous pouvez configurer de manière unique un ou plusieurs environnements d'application.
Veillez à utiliser la valeur « Config file key » du tableau des options de
configuration comme clé de configuration. Cette clé est soit une chaîne en
snake\_case (Ruby, Elixir, Python), soit en camelCase (Node, JavaScript
front-end).
Options de configuration pour :
* [Ruby](/ruby/configuration/options)
* [Elixir](/elixir/configuration/options)
* [Node.js](/nodejs/3.x/configuration/options)
* [Python](/python/configuration/options)
* [JavaScript front-end](/front-end/configuration/)
* [Go](/go/configuration/options)
Veillez à ne pas enregistrer de valeurs de configuration sensibles, telles
que la clé API Push, dans un système de gestion de code source comme Git,
sauf si elles sont chiffrées.
### Ruby
Lorsque vous utilisez le gem d'intégration Ruby, il créera le fichier `config/appsignal.yml` à la racine du dossier de votre application, avec des paramètres de configuration de base lors de l'installation. Si votre application rapporte des données à AppSignal sans fichier `appsignal.yml`, votre application utilise très probablement des [variables d'environnement système][env].
Le fichier `config/appsignal.yml` est un fichier YAML (Yet Another Markup
Language) et est interprété comme un template ERB (Embedded Ruby). Veuillez
consulter la documentation [Configuration Ruby][ruby config] pour plus de
détails sur le fonctionnement de la configuration YAML.
Dans l'exemple de fichier de configuration ci-dessous, deux environnements sont définis, `development` et `production` — chacun a des options de configuration spécifiques à son environnement imbriquées en dessous. Tout ce qui est défini et imbriqué dans `default` s'applique à tous les environnements, à condition que default soit inclus dans le mappage d'environnement.
Nous voulons définir le log\_level sur debug exclusivement dans notre environnement `development` ; pour ce faire, nous avons ajouté `log_level: "debug"` dans la configuration de l'environnement de développement (ligne 10).
```yaml YAML theme={null}
# Example: config/appsignal.yml
default: &defaults # Shared configuration options for all environments
active: true
name: "My awesome app"
push_api_key: ""
development: # Development environment
<<: *defaults
log_level: "debug" # This enables debug mode for only the development environment
production: # Production environment
<<: *defaults
```
Rappelez-vous, tout ce qui est imbriqué dans `default` s'applique à tous les environnements, donc pour définir le log\_level sur debug dans tous les environnements, nous pouvons à la place imbriquer la configuration sous default, comme dans la ligne 6 de l'exemple de code ci-dessous :
```yaml YAML theme={null}
# Example: config/appsignal.yml
default: &defaults
active: true
name: "My awesome app"
push_api_key: ""
log_level: "debug" # This enables debug mode for all environments
# Other AppSignal config...
development: # Development environment
<<: *defaults
# Other AppSignal config...
production: # Production environment
<<: *defaults
# Other AppSignal config...
```
Super, vous avez maintenant appris à configurer AppSignal dans votre application Ruby !
#### En savoir plus :
* [Rubrique Configuration de l'intégration Ruby][ruby config]
* [Détails sur l'ordre de chargement de la configuration de l'intégration Ruby](/ruby/configuration/load-order)
### Elixir
Lors de l'installation, l'intégration Elixir crée un fichier `config/appsignal.exs` (emplacement par défaut) avec des configurations de base. Si ce fichier n'est pas présent mais que votre application rapporte des données à AppSignal, vérifiez l'un des autres fichiers `.exs` du répertoire `config/` de votre application Elixir. Si aucune configuration AppSignal n'est présente dans aucun des fichiers, votre application utilise probablement les [variables d'environnement système][env] comme méthode de configuration à la place.
Pour ajouter une option de configuration et l'appliquer à tous les environnements de votre application, ajoutez l'option de configuration au fichier `config/appsignal.exs`, comme à la ligne 7 de l'exemple ci-dessous :
```elixir Elixir theme={null}
# Example: config/config.exs
config :appsignal, :config,
active: true,
name: "My awesome app",
push_api_key: "",
env: Mix.env,
log_level: "debug" # This sets the log_level to debug for all environments
```
Pour appliquer l'option de configuration uniquement à un seul environnement, ajoutez la configuration AppSignal au fichier de configuration de l'environnement, situé dans le répertoire `config/`.
Dans l'exemple ci-dessous, l'option log\_level a été ajoutée à la ligne 3 de l'environnement de développement (ou « dev ») :
```elixir Elixir theme={null}
# Example: config/dev.exs
config :appsignal, :config,
log_level: "debug" # This only sets the log_level to debug for the "dev" environment
```
Super, vous avez maintenant appris à configurer AppSignal dans votre application Elixir !
#### En savoir plus
* [Rubrique Configuration de l'intégration Elixir](/elixir/configuration/)
* [Détails sur l'ordre de chargement de la configuration de l'intégration Elixir](/elixir/configuration/load-order)
### Node.js
Après l'installation, vous devez créer un fichier de configuration AppSignal pour configurer votre application. Si aucun fichier avec la configuration AppSignal n'est présent, elle utilise très probablement les [variables d'environnement système][env] comme méthode de configuration à la place.
Pour configurer AppSignal pour les applications Node.js, nous vous recommandons de créer un fichier `appsignal.js` avec la configuration AppSignal à la racine de votre application ou dans le répertoire `src`. Ensuite, importez-le ou requérez-le depuis le code de l'application avant que d'autres packages ne soient requis ou importés.
Dans l'exemple ci-dessous, il y a un fichier `appsignal.js` à la racine du répertoire de l'application. Dans ce fichier, nous ajouterons l'option de configuration `logLevel`.
```javascript Node.js theme={null}
// appsignal.js
const { Appsignal } = require("@appsignal/nodejs");
const appsignal = new Appsignal({
active: true,
name: "",
pushApiKey: "",
logLevel: "debug", // Sets logLevel to debug for the Node.js environment
});
module.exports = { appsignal };
```
La configuration dans l'exemple ci-dessus s'applique à l'environnement dans lequel Node.js s'exécute (`NODE_ENV`, par défaut « development »).
Dans Node.js, il existe de nombreuses façons de créer des configurations spécifiques à un environnement pour AppSignal. Si vous ne savez pas comment procéder dans votre propre application, une méthode que nous recommandons consiste à utiliser des conditionnelles dans votre `appsignal.js`, comme dans l'exemple ci-dessous où nous spécifions debug pour l'environnement de production.
1. À la ligne 4 — nous activons l'intégration AppSignal uniquement si l'environnement est production.
2. À la ligne 8 — comme dans notre exemple de code précédent, nous définissons `logLevel` sur `debug`
```javascript Node.js theme={null}
// appsignal.js
const appsignal = new Appsignal({
active: process.env.NODE_ENV === "production"
name: "",
pushApiKey: "",
logLevel: "debug" // Sets logLevel to debug for the Node.js environment
});
```
Une fois votre configuration terminée, vous devez requérir `appsignal.js` tout en haut du fichier principal de votre application. Le nom du fichier principal de votre application peut varier en fonction de la structure de votre application. Il s'agit du fichier que vous utilisez pour démarrer votre application Node et il est généralement nommé `index.js` ou `app.js`. Assurez-vous qu'AppSignal est requis tout en haut du fichier comme dans l'exemple ci-dessous :
```javascript Node.js theme={null}
// index.js
// Place this at the top
const { appsignal } = require("./appsignal"); // Update to the location used in the previous step
// Place your app code below this
```
Super, vous avez maintenant appris à configurer AppSignal dans votre application Node.js !
#### En savoir plus
* [Configuration de l'intégration Node.js][nodejs config]
* [Ordre de chargement de la configuration de l'intégration Node.js](/nodejs/3.x/configuration/load-order)
### Python
Lorsque vous utilisez l'installateur de l'intégration Python, celui-ci créera le fichier `__appsignal__.py` à la racine du dossier de votre application, avec des paramètres de configuration de base. Votre application peut également être configurée à l'aide de [variables d'environnement système][env].
Pour ajouter une option de configuration et l'appliquer à l'environnement de développement de votre application, ajoutez l'option de configuration au fichier `__appsignal__.py`, comme dans l'exemple ci-dessous.
```python Python theme={null}
# __appsignal__.py
from appsignal import Appsignal
appsignal = Appsignal(
active=True,
name="My awesome app",
push_api_key="",
environment="development",
log_level="debug",
)
```
Pour configurer AppSignal pour Python pour un autre environnement, ou appliquer la configuration à tous les environnements, configurez l'option `environment` de la même manière que votre application détermine son environnement (development/staging/production). Cela peut se faire à l'aide d'une variable d'environnement système ou d'une autre méthode propre à l'application. Dans l'exemple ci-dessous, nous utiliserons une variable d'environnement système `MY_APP_ENV` à la fois pour définir l'environnement de l'application et n'activer que pour l'environnement de production.
```python Python theme={null}
# __appsignal__.py
import os
from appsignal import Appsignal
app_env = os.environ.get("MY_APP_ENV")
appsignal = Appsignal(
active=app_env == "production",
name="My awesome app",
push_api_key="",
environment=app_env,
)
```
Si vous souhaitez que certaines options de configuration ne s'appliquent qu'à certains environnements, créez des conditionnelles adaptées à vos besoins.
```python Python theme={null}
# __appsignal__.py
import os
from appsignal import Appsignal
app_env = os.environ.get("MY_APP_ENV")
options = {
"active": app_env == "development",
"name": "python/django4-celery",
"environment": app_env,
}
if app_env == "development":
options["log_level"] = "debug"
appsignal = Appsignal(**options)
```
Super, vous avez maintenant appris à configurer AppSignal dans votre application Python !
#### En savoir plus :
* [Rubrique Configuration de l'intégration Python][python config]
* [Détails sur l'ordre de chargement de la configuration de l'intégration Python](/python/configuration/load-order)
### JavaScript front-end
Pour configurer AppSignal pour le JavaScript front-end, nous vous recommandons de créer un fichier `appsignal.js` avec la configuration AppSignal à la racine de votre projet ou dans le répertoire `src`. Ensuite, requérez-le ou importez-le depuis le code de l'application avant que d'autres packages ne soient requis ou importés.
Dans l'exemple ci-dessous, il y a un fichier `appsignal.js` à la racine du répertoire de l'application. À la ligne 8, nous avons ajouté l'option de configuration `namespace`.
```javascript JavaScript theme={null}
// appsignal.js
import Appsignal from "@appsignal/javascript"; // For ES Module
const Appsignal = require("@appsignal/javascript").default; // For CommonJS module
const appsignal = new Appsignal({
key: "",
namespace: "frontend", // Configure the AppSignal namespace for front-end errors in this app
});
module.exports = { appsignal };
```
Une fois la configuration de votre application terminée, vous devez requérir `appsignal.js` tout en haut du fichier principal de votre application, comme dans l'exemple ci-dessous :
```javascript JavaScript theme={null}
// index.js
// Place this at the top
const { appsignal } = require("./appsignal"); // Update to the location used in the previous step
// Place your app code below this
```
Et voilà — vous êtes prêt ! Suivez ces étapes simples pour toutes les modifications futures d'options de configuration.
#### En savoir plus
* [Configuration de l'intégration JavaScript front-end](/front-end/configuration/)
## Configuration par variables d'environnement système
Cette méthode de configuration n'est pas disponible pour le JavaScript front-end.
Les variables d'environnement système, ou « variables d'environnement » en abrégé, sont des variables accessibles par les processus, et qui sont héritées du processus parent qui les démarre. Au lieu d'utiliser un [fichier de configuration][file] pour la configuration, il est possible de configurer AppSignal en utilisant uniquement des variables d'environnement. Il est également possible de stocker des clés de configuration contenant des données sensibles, telles que la clé API Push, dans une variable d'environnement, et d'utiliser des [fichiers de configuration][file] pour le reste de la configuration.
Cette méthode de configuration est compatible avec les applications Ruby, Elixir et Node.js.
Avant de passer à l'exemple suivant de définition de variables d'environnement via un shell, expliquons comment fonctionnent les variables d'environnement concernant les shells et les processus.
Les variables d'environnement peuvent appartenir à un processus tel qu'un shell ou votre application. La commande `export FOO=BAR`, par exemple, définirait la variable d'environnement `FOO` de votre shell sur `BAR`. Les variables d'environnement sont héritées entre les processus, donc lorsque ce shell démarre un nouveau processus, ce processus aura également les variables d'environnement du shell.
Lorsque vous lancez un processus dans le shell (par exemple, npm start), vous pouvez également fournir plus de variables d'environnement uniquement pour ce processus en assignant les variables comme ceci : `FOO=BAR npm start`
Pour plus de commodité, vous pouvez configurer votre shell pour définir certaines variables d'environnement à son démarrage, afin que tout processus démarré depuis ce shell hérite de ces variables d'environnement. Si vous utilisez le shell `bash`, les commandes du fichier `.bash_profile` dans votre répertoire personnel sont exécutées au démarrage du shell. Si vous utilisez `zsh`, qui est le shell par défaut dans macOS, le fichier `.zshenv` serait utilisé à la place pour configurer les variables d'environnement.
Dans l'exemple de fichier ci-dessous, nous exportons les variables d'environnement qui configurent la clé API Push d'AppSignal et le niveau de journalisation, afin que lorsqu'un nouveau shell est démarré, les bonnes variables d'environnement soient accessibles à votre application, lui permettant de communiquer avec AppSignal.
Les options de configuration définies via les variables d'environnement s'appliquent à tous les environnements d'application, cependant certaines options de configuration sont spécifiques au langage. Par exemple, l'option de configuration `instrument_sequel` n'existe que dans l'intégration Ruby, car Sequel est un gem Ruby, et donc définir la variable d'environnement `APPSIGNAL_INSTRUMENT_SEQUEL` n'a aucun effet pour les autres intégrations.
```sh Shell theme={null}
# Bash shell example
export APPSIGNAL_PUSH_API_KEY=
export APPSIGNAL_LOG_LEVEL=debug # Sets log_level to debug for all environments.
```
Il existe plusieurs emplacements possibles pour les fichiers contenant la configuration des variables d'environnement. Veuillez choisir la meilleure option qui convient à votre application, et assurez-vous de recharger votre shell de terminal après avoir effectué des modifications pour qu'il ait accès à vos variables mises à jour.
* `~/.profile` ou `~/.bash_profile` — Paramètres spécifiques à l'utilisateur. Utilisez cet emplacement pour configurer les variables d'environnement par utilisateur.
* `/etc/profile` — Paramètres à l'échelle du système. Si plusieurs utilisateurs ou applications utilisent la même machine hôte, n'utilisez pas cet emplacement.
Les fournisseurs d'hébergement Platform As A Service (PaaS) comme Heroku ne fournissent pas de système pour configurer directement les variables d'environnement dans le shell. Vous pouvez à la place utiliser leur interface web ou CLI pour configurer ces variables d'environnement.
Lors de l'utilisation de la configuration basée sur les variables d'environnement
système, veillez à utiliser la valeur « System environment key » du tableau
des options de configuration comme clé de configuration. Cette clé est
toujours en snake case capitalisé\*, comme ceci :
`EXAMPLE_OF_A_CONFIG_KEY`
***Fait amusant :** ceci est également connu sous le nom de SCREAMING\_SNAKE\_CASE 🐍*
## Finaliser la configuration
Après avoir modifié votre configuration AppSignal, votre application doit être redémarrée ou déployée pour que les modifications de configuration soient détectées par AppSignal.
Les modifications de configuration ne sont pas détectées ? [Contactez-nous][contact], et nous vous aiderons ! Pour nous aider à déboguer votre problème plus rapidement, nous vous recommandons de nous envoyer un [rapport de diagnostic](/support/debugging#diagnose) depuis l'hôte de votre application.
## Pour aller plus loin
En savoir plus sur la configuration dans notre documentation [Configuration des applications][config topic].
[config topic]: /application/configuration.html
[contact]: mailto:support@appsignal.com
[env]: #system-environment-variable-configuration
[file]: #file-based-configuration
[nodejs config]: /nodejs/3.x/configuration/
[ruby config]: /ruby/configuration/
[python config]: /python/configuration/