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

# Métriques personnalisées

Les métriques personnalisées vous permettent de suivre tout ce qui est important dans votre application — du nombre d'utilisateurs actifs à un moment donné, au nombre de factures générées au cours de la dernière heure, en passant par la taille actuelle de votre base de données. En envoyant des métriques personnalisées à AppSignal, vous pouvez créer des graphiques dans vos tableaux de bord qui mettent ces données en relation avec des signaux critiques tels que les taux d'erreur et les temps de réponse, vous donnant le contexte nécessaire pour identifier et résoudre rapidement les problèmes.

De plus, les métriques personnalisées vous aident à travailler de manière proactive plutôt que réactive. Tandis que la journalisation vous aide à déboguer les problèmes après leur survenue, les métriques personnalisées vous permettent de repérer les tendances et les problèmes potentiels avant que vos clients ne les remarquent. Vous pouvez vous concentrer sur les données qui comptent pour votre activité — comme le nombre d'utilisateurs actifs, les KPI ou les volumes de ventes — sans avoir à parcourir des lignes de logs ou des listes d'incidents. Vous pouvez également définir des triggers sur les métriques personnalisées pour vous avertir lorsque les valeurs sortent des plages attendues.

Les métriques personnalisées ne remplacent pas l'[instrumentation personnalisée](/ruby/instrumentation/instrumentation), mais sont un outil complémentaire pour rendre des données d'application spécifiques visibles et mesurables dans le temps.

AppSignal propose trois types de métriques personnalisées :

| Type                        | Idéal pour                                    | Exemple d'utilisation                                      |
| --------------------------- | --------------------------------------------- | ---------------------------------------------------------- |
| [Gauge](#gauge)             | Valeurs absolues qui changent au fil du temps | Utilisateurs actifs, taille de la base, utilisation disque |
| [Measurement](#measurement) | Plages et distributions de valeurs            | Temps de réponse, durée de jobs, valeurs de panier         |
| [Counter](#counter)         | Comptage des occurrences au fil du temps      | Factures créées, connexions, erreurs déclenchées           |

Vous pouvez suivre les métriques personnalisées dans des [graphiques](#graphing-custom-metrics) dans vos tableaux de bord AppSignal.

### Gauge

Une gauge enregistre une valeur à un point précis dans le temps. Si vous rapportez plusieurs gauges avec la même clé dans la même fenêtre de temps, seule la dernière valeur est conservée.

**Utilisez les gauges lorsque** vous souhaitez connaître l'état actuel de quelque chose — le nombre d'éléments qui existent en ce moment, ou la taille actuelle d'une ressource. Toutes les [métriques d'hôte](/metrics/host-metrics) d'AppSignal sont stockées sous forme de gauges.

Les gauges sont souvent utilisées avec des [minutely probes](/ruby/instrumentation/minutely-probes) pour rapporter périodiquement une valeur instantanée, telle que le nombre de paniers d'achat récemment actifs ou les connexions ouvertes à la base de données chaque minute.

**Exemples :** nombre d'utilisateurs actifs, taille de la base de données, utilisation du disque, nombre de connexions ouvertes.

<CodeGroup>
  ```ruby Ruby theme={null}
  # The first argument is a string, the second argument a number
  # Appsignal.set_gauge(metric_name, value)
  Appsignal.set_gauge("database_size", 100)
  Appsignal.set_gauge("database_size", 10)

  # Will create the metric "database_size" with the value 10
  ```

  ```elixir Elixir theme={null}
  # The first argument is a string, the second argument a number
  # Appsignal.set_gauge(metric_name, value)
  Appsignal.set_gauge("database_size", 100)
  Appsignal.set_gauge("database_size", 10)

  # Will create the metric "database_size" with the value 10
  ```

  ```javascript Node.js theme={null}
  const meter = Appsignal.client.metrics();

  // The first argument is a string, the second argument a number
  // meter.setGauge(metric_name, value)
  meter.setGauge("database_size", 100);
  meter.setGauge("database_size", 10);

  // Will create the metric "database_size" with the value 10
  ```

  ```python Python theme={null}
  # Import the AppSignal metric helper
  from appsignal import set_gauge

  # The first argument is a string, the second argument a number (int/float)
  # set_gauge(metric_name, value)
  set_gauge("database_size", 100)
  set_gauge("database_size", 10)

  # Will create the metric named "database_size" with the value 10
  ```

  ```php PHP theme={null}
  <?php
  use Appsignal\Appsignal;

  // Record gauge values
  Appsignal::setGauge('database_size', 100);
  Appsignal::setGauge('database_size', 10);

  // Will create the metric "database_size" with the value 10
  ```

  ```java Java theme={null}
  import io.opentelemetry.api.GlobalOpenTelemetry;
  import io.opentelemetry.api.metrics.DoubleGauge;
  import io.opentelemetry.api.metrics.Meter;

  public void recordMetrics() {
      // Get the meter from the global meter provider
      Meter meter = GlobalOpenTelemetry.getMeter("my-app");

      // Create a gauge instrument
      DoubleGauge gauge = meter.gaugeBuilder("database_size").build();

      // Record gauge values
      gauge.set(100);
      gauge.set(10);

      // Will create the metric "database_size" with the value 10
  }
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"go.opentelemetry.io/otel"
  	"go.opentelemetry.io/otel/metric"
  )

  func recordMetrics() {
  	// Get the meter from the global meter provider
  	meter := otel.Meter("my-app")

  	// Create a gauge instrument
  	gauge, _ := meter.Float64Gauge("database_size")

  	// Record gauge values
  	gauge.Record(context.Background(), 100)
  	gauge.Record(context.Background(), 10)

  	// Will create the metric "database_size" with the value 10
  }
  ```
</CodeGroup>

<Tip>
  Depuis la version 3.1.0, l'intégration Node.js vous permet de définir des gauges et des counters à l'aide du fournisseur de métriques OpenTelemetry. Vous devez activer le serveur HTTP OpenTelemetry de l'agent pour rapporter ces métriques à AppSignal ; vous pouvez le faire en définissant l'option [enableOpentelemetryHttp](/nodejs/3.x/configuration/options#option-enable_opentelemetry_http) sur `true`.

  Les intégrations Java et Go utilisent également les métriques OpenTelemetry pour rapporter les métriques personnalisées à AppSignal.

  Vous pouvez en savoir plus sur les métriques OpenTelemetry dans la [documentation des métriques OpenTelemetry](https://opentelemetry.io/docs/concepts/metrics/). Pour Node.js, consultez la [documentation des métriques OpenTelemetry JS](https://opentelemetry.io/docs/languages/js/instrumentation/#metrics) pour plus d'informations.
</Tip>

### Measurement

Une measurement suit une plage de valeurs dans le temps. AppSignal stocke la moyenne et le compte pour chaque fenêtre de temps, vous permettant de représenter graphiquement des éléments tels que la durée moyenne, les 90e/95e percentiles et le throughput.

**Utilisez les measurements lorsque** vous enregistrez une valeur qui varie d'un événement individuel à l'autre et que vous souhaitez comprendre sa distribution — pas seulement sa valeur actuelle. Par exemple, vous pouvez suivre la durée d'un job en arrière-plan critique (comme les e-mails de confirmation de commande) pour repérer les ralentissements avant qu'ils n'affectent vos utilisateurs.

Une métrique de measurement crée plusieurs champs de métriques :

* **Count :** combien de fois le helper a été appelé. Utile pour les graphiques de throughput.
* **Mean :** la valeur moyenne de la métrique pour le point dans le temps.
* **90e percentile :** le 90e percentile de la valeur de la métrique pour le point dans le temps.
* **95e percentile :** le 95e percentile de la valeur de la métrique pour le point dans le temps.

**Exemples :** temps de réponse HTTP, durées des jobs en arrière-plan, valeurs des paniers utilisateurs, temps d'exécution des requêtes.

<CodeGroup>
  ```ruby Ruby theme={null}
  # The first argument is a string, the second argument a number
  # Appsignal.add_distribution_value(metric_name, value)
  Appsignal.add_distribution_value("memory_usage", 100)
  Appsignal.add_distribution_value("memory_usage", 110)

  # Will create a metric "memory_usage" with the mean field value 105
  # Will create a metric "memory_usage" with the count field value 2
  ```

  ```elixir Elixir theme={null}
  # The first argument is a string, the second argument a number
  # Appsignal.add_distribution_value(metric_name, value)
  Appsignal.add_distribution_value("memory_usage", 100)
  Appsignal.add_distribution_value("memory_usage", 110)

  # Will create a metric "memory_usage" with the mean field value 105
  # Will create a metric "memory_usage" with the count field value 2
  ```

  ```javascript JavaScript theme={null}
  const meter = Appsignal.client.metrics();

  // The first argument is a string, the second argument a number
  // meter.addDistributionValue(metric_name, value)
  meter.addDistributionValue("memory_usage", 100);
  meter.addDistributionValue("memory_usage", 110);

  // Will create a metric "memory_usage" with the mean field value 105
  // Will create a metric "memory_usage" with the count field value 2
  ```

  ```python Python theme={null}
  # Import the AppSignal metric helper
  from appsignal import add_distribution_value

  # The first argument is a string, the second argument a number (int/float)
  # add_distribution_value(metric_name, value)
  add_distribution_value("memory_usage", 100)
  add_distribution_value("memory_usage", 110)

  # Will create a metric "memory_usage" with the mean field value 105
  # Will create a metric "memory_usage" with the count field value 2
  ```

  ```php PHP theme={null}
  <?php
  use Appsignal\Appsignal;

  // Record distribution values
  Appsignal::addDistributionValue('memory_usage', 100);
  Appsignal::addDistributionValue('memory_usage', 110);

  // Will create a metric "memory_usage" with the mean field value 105
  // Will create a metric "memory_usage" with the count field value 2
  ```

  ```java Java theme={null}
  import io.opentelemetry.api.GlobalOpenTelemetry;
  import io.opentelemetry.api.metrics.DoubleHistogram;
  import io.opentelemetry.api.metrics.Meter;

  public void recordDistributions() {
      // Get the meter from the global meter provider
      Meter meter = GlobalOpenTelemetry.getMeter("my-app");

      // Create a histogram instrument for distributions
      DoubleHistogram histogram = meter.histogramBuilder("memory_usage").build();

      // Record distribution values
      histogram.record(100);
      histogram.record(110);

      // Will create a metric "memory_usage" with the mean field value 105
      // Will create a metric "memory_usage" with the count field value 2
  }
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"go.opentelemetry.io/otel"
  	"go.opentelemetry.io/otel/metric"
  )

  func recordDistributions() {
  	// Get the meter from the global meter provider
  	meter := otel.Meter("my-app")

  	// Create a histogram instrument for distributions
  	histogram, _ := meter.Float64Histogram("memory_usage")

  	// Record distribution values
  	histogram.Record(context.Background(), 100)
  	histogram.Record(context.Background(), 110)

  	// Will create a metric "memory_usage" with the mean field value 105
  	// Will create a metric "memory_usage" with the count field value 2
  }
  ```
</CodeGroup>

### Counter

Un counter accumule un compte total sur une fenêtre de temps. Les valeurs des counters sont additionnées pour chaque résolution — ainsi, à la résolution minutely, il affiche le total pour cette minute, et à la résolution hourly, il affiche le total pour cette heure.

**Utilisez les counters lorsque** vous souhaitez suivre le nombre de fois où quelque chose s'est produit, et non la valeur qu'il avait. Les counters sont particulièrement utiles pour surveiller la fréquence d'événements critiques pour l'activité. Par exemple, en suivant à la fois les commandes passées et les factures créées, vous pouvez vérifier que ces counters liés restent synchronisés et détecter les écarts rapidement.

Lorsque le helper est appelé plusieurs fois, le total/la somme de tous les appels est conservé. Les counters sont non-monotones : les valeurs positives et négatives sont supportées, vous pouvez donc incrémenter et décrémenter le même counter. Pour les counters monotones provenant d'autres systèmes, il n'y a aucune validation que les valeurs des counters n'augmentent toujours.

**Exemples :** commandes passées, factures créées, connexions utilisateurs, jobs en arrière-plan mis en file, tentatives de paiement échouées.

<Tip>
  **Gauge vs Counter :** Utilisez une gauge pour suivre *combien d'éléments
  existent en ce moment* (par exemple, les utilisateurs actuellement actifs).
  Utilisez un counter pour suivre *combien de fois quelque chose s'est produit*
  dans une période donnée (par exemple, les nouvelles connexions dans la
  dernière minute).
</Tip>

<CodeGroup>
  ```ruby Ruby theme={null}
  # The first argument is a string, the second argument a number
  # Appsignal.increment_counter(metric_name, value)
  Appsignal.increment_counter("login_count", 1)
  Appsignal.increment_counter("login_count", 1)

  # Will create the metric "login_count" with the value 2 for a point in the minutely/hourly resolution
  ```

  ```elixir Elixir theme={null}
  # The first argument is a string, the second argument a number
  # Appsignal.increment_counter(metric_name, value)
  Appsignal.increment_counter("login_count", 1)
  Appsignal.increment_counter("login_count", 1)

  # Will create the metric "login_count" with the value 2 for a point in the minutely/hourly resolution
  ```

  ```javascript JavaScript theme={null}
  const meter = Appsignal.client.metrics();

  // The first argument is a string, the second argument a number
  // meter.incrementCounter(metric_name, value)
  meter.incrementCounter("login_count", 1);
  meter.incrementCounter("login_count", 1);

  // Will create the metric "login_count" with the value 2 for a point in the minutely/hourly resolution
  ```

  ```python Python theme={null}
  # Import the AppSignal metric helper
  from appsignal import increment_counter

  # The first argument is a string, the second argument a number (int/float)
  # increment_counter(metric_name, value)
  increment_counter("metric_name", 1)  # Increase the value by one
  increment_counter("metric_name", 1)
  increment_counter("metric_name", -1) # Decrease the value by one

  # Will create the metric named "metric_name" with the value 2 for a point in the minutely/hourly resolution
  ```

  ```php PHP theme={null}
  <?php
  use Appsignal\Appsignal;

  // Record counter values
  Appsignal::incrementCounter('login_count', 1);
  Appsignal::incrementCounter('login_count', 1);

  // Will create the metric "login_count" with the value 2 for a point in the minutely/hourly resolution
  ```

  ```java Java theme={null}
  import io.opentelemetry.api.GlobalOpenTelemetry;
  import io.opentelemetry.api.metrics.LongCounter;
  import io.opentelemetry.api.metrics.Meter;

  public void recordCounters() {
      // Get the meter from the global meter provider
      Meter meter = GlobalOpenTelemetry.getMeter("my-app");

      // Create a counter instrument
      LongCounter counter = meter.counterBuilder("login_count").build();

      // Record counter values
      counter.add(1);
      counter.add(1);

      // Will create the metric "login_count" with the value 2 for a point in the minutely/hourly resolution
  }
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"go.opentelemetry.io/otel"
  	"go.opentelemetry.io/otel/metric"
  )

  func recordCounters() {
  	// Get the meter from the global meter provider
  	meter := otel.Meter("my-app")

  	// Create a counter instrument
  	counter, _ := meter.Int64Counter("login_count")

  	// Record counter values
  	counter.Add(context.Background(), 1)
  	counter.Add(context.Background(), 1)

  	// Will create the metric "login_count" with the value 2 for a point in the minutely/hourly resolution
  }
  ```
</CodeGroup>

<Warning>
  **Note** : Dans AppSignal, les counters sont conçus pour stocker uniquement des valeurs entières.
  Bien que l'API accepte des valeurs flottantes pour faciliter l'intégration, ces valeurs sont converties en entiers en interne.

  Les valeurs décimales sont arrondies à l'entier inférieur le plus proche.
  La valeur 0,0001 devient 0, et 1,2, 1,5 et 1,7 deviennent 1.
</Warning>

## Dénomination des métriques

Nous vous recommandons de nommer vos métriques de manière facilement reconnaissable. Bien que vous puissiez utiliser des wildcards dans certaines parties du nom de la métrique pour créer des tableaux de bord, nous vous recommandons de ne l'utiliser que pour de petits regroupements et de ne pas utiliser d'identifiants dans les noms de métriques.

Les noms de métriques ne prennent en charge que les chiffres, lettres, points et underscores (`[a-z0-9._]`) comme caractères valides. Tout autre caractère sera remplacé par un underscore par notre processeur. Vous trouverez la liste des métriques telles qu'elles sont traitées sur la page ["Add Dashboard"](https://appsignal.com/redirect-to/app?to=dashboard\&overlay=dashboardForm).

Voici quelques exemples de bons noms de métriques :

* `database_size`
* `account_count`
* `users.count`
* `notifier.failed`
* `notifier.perform`
* `notifier.success`

Par défaut, AppSignal suit déjà des métriques pour votre application, telles que les [métriques d'hôte](/metrics/host-metrics). Consultez la liste des métriques sur la page ["Add Dashboard"](https://appsignal.com/redirect-to/app?to=dashboard\&overlay=dashboardForm) pour les métriques déjà disponibles pour votre app.

<Warning>
  **Note** : Nous **ne** recommandons **pas** d'ajouter des valeurs dynamiques
  aux noms de vos métriques, comme ceci : `eu.database_size`, `us.database_size`
  et `asia.database_size`. Cela crée plusieurs métriques qui servent le même
  objectif. À la place, nous recommandons d'utiliser des [tags de
  métriques](#metric-tags) pour cela.
</Warning>

## Valeurs des métriques

Les métriques ne prennent en charge que les nombres comme valeurs valides. Toute autre valeur sera ignorée silencieusement ou déclenchera une erreur selon le parser de nombres du langage d'implémentation. Pour Ruby et Elixir, nous prenons en charge un [double](https://en.wikipedia.org/wiki/Double-precision_floating-point_format) et un [integer](https://en.wikipedia.org/wiki/Integer) comme valeurs valides :

<CodeGroup>
  ```ruby Ruby theme={null}
  # Integer
  Appsignal.increment_counter("login_count", 1)
  # Double
  Appsignal.increment_counter("assignment_completed", 0.12)
  ```

  ```elixir Elixir theme={null}
  # Integer
  Appsignal.increment_counter("login_count", 1)
  # Double
  Appsignal.increment_counter("assignment_completed", 0.12)
  ```

  ```javascript JavaScript theme={null}
  const meter = Appsignal.client.metrics();

  // Integer
  meter.incrementCounter("login_count", 1);
  // Double
  meter.incrementCounter("assignment_completed", 0.12);
  ```

  ```python Python theme={null}
  from appsignal import increment_counter

  # Integer
  increment_counter("login_count", 1)
  # Double
  increment_counter("assignment_completed", 0.12)
  ```

  ```php PHP theme={null}
  <?php
  use Appsignal\Appsignal;

  // Integer
  Appsignal::incrementCounter('login_count', 1);
  // Double
  Appsignal::incrementCounter('login_count', 0.12);
  ```

  ```java Java theme={null}
  import io.opentelemetry.api.GlobalOpenTelemetry;
  import io.opentelemetry.api.metrics.DoubleCounter;
  import io.opentelemetry.api.metrics.LongCounter;
  import io.opentelemetry.api.metrics.Meter;

  public void recordValues() {
      Meter meter = GlobalOpenTelemetry.getMeter("my-app");

      // Integer counter
      LongCounter longCounter = meter.counterBuilder("login_count").build();
      longCounter.add(1);

      // Double counter
      DoubleCounter doubleCounter = meter.counterBuilder("assignment_completed")
          .ofDoubles()
          .build();
      doubleCounter.add(0.12);
  }
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"go.opentelemetry.io/otel"
  	"go.opentelemetry.io/otel/metric"
  )

  func recordValues() {
  	meter := otel.Meter("my-app")

  	// Integer counter
  	intCounter, _ := meter.Int64Counter("login_count")
  	intCounter.Add(context.Background(), 1)

  	// Float counter
  	floatCounter, _ := meter.Float64Counter("assignment_completed")
  	floatCounter.Add(context.Background(), 0.12)
  }
  ```
</CodeGroup>

Note : En Node.js, seul le type `number` est une valeur valide.

### Formatage des valeurs {/* id: metric-values-value-formatting */}

Les graphiques AppSignal proposent plusieurs formats d'affichage, tels que les nombres, les tailles de fichiers, les durées,
etc. Ces formats aident à présenter les valeurs des métriques de manière lisible par l'humain.

La sélection d'un formateur de valeur d'entrée n'affecte pas les données stockées dans nos systèmes, mais uniquement la façon dont elles sont affichées.

Pour afficher correctement les valeurs des métriques à l'aide de ces formateurs, veuillez consulter le tableau ci-dessous pour savoir comment la valeur doit être rapportée.

| Formateur  | Valeur rapportée              | Description                                                                                                                                                                                                                                                                                                                                                 |
| ---------- | ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Number     | Valeur affichée               | Un nombre formaté lisible par l'humain. Les valeurs doivent être rapportées à la même échelle que celle à laquelle elles sont affichées. La valeur `1` est affichée comme "`1`", `10_000` comme "`10 K`" et `1_000_000` est affichée comme "`1 M`".                                                                                                         |
| Percentage | Valeur affichée               | Une valeur de métrique formatée en pourcentage. Les valeurs doivent être rapportées à la même échelle que celle à laquelle elles sont affichées. La valeur `40` est affichée comme "`40 %`".                                                                                                                                                                |
| Throughput | Valeur affichée               | Une valeur de métrique formatée en requêtes par minute/heure. Les valeurs doivent être rapportées à la même échelle que celle à laquelle elles sont affichées. Affichera le throughput formaté en nombre pour la minute et l'heure. La valeur `10_000` est affichée "`10k / hour 166 / min`". Couramment utilisée pour les métriques [`counter`](#counter). |
| Duration   | Millisecondes                 | Une durée. Les valeurs doivent être rapportées en millisecondes. La valeur `100` est affichée comme "`100 ms`" et 60\_000 comme "`60 sec`". Couramment utilisée pour la métrique [`measurement`](/metrics/custom#measurement).                                                                                                                              |
| File size  | [Personnalisable](#file-size) | Une taille de fichier formatée en mégaoctets par défaut. `1.0` mégaoctet est affiché comme `1Mb`. L'unité de taille de fichier dans laquelle la valeur de métrique rapportée est lue peut être personnalisée dans le constructeur de graphiques.                                                                                                            |

#### File size

Les valeurs de métriques qui représentent une taille de fichier peuvent utiliser le formateur de taille de fichier. Pour spécifier dans quelle unité de taille la valeur rapportée est exprimée, le formateur de taille de fichier propose plusieurs valeurs d'entrée.

Les options disponibles sont :

* `Size in Bit`
* `Size in Bytes`
* `Size in Kilobits`
* `Size in Kilobytes`
* `Size in Megabytes`

Lors de l'envoi d'une métrique avec la valeur suivante :

<CodeGroup>
  ```ruby Ruby theme={null}
  Appsignal.set_gauge("database_size", 1024)
  ```

  ```elixir Elixir theme={null}
  Appsignal.set_gauge("database_size", 1024)
  ```

  ```javascript JavaScript theme={null}
  const meter = Appsignal.client.metrics();

  meter.setGauge("database_size", 1024);
  ```

  ```python Python theme={null}
  # Import the AppSignal metric helper
  from appsignal import set_gauge

  set_gauge("database_size", 1024)
  ```

  ```php PHP theme={null}
  <?php
  use Appsignal\Appsignal;

  Appsignal::setGauge('database_size', 1024);
  ```

  ```java Java theme={null}
  import io.opentelemetry.api.GlobalOpenTelemetry;
  import io.opentelemetry.api.metrics.DoubleGauge;
  import io.opentelemetry.api.metrics.Meter;

  public void recordFileSize() {
      Meter meter = GlobalOpenTelemetry.getMeter("my-app");
      DoubleGauge gauge = meter.gaugeBuilder("database_size").build();

      gauge.set(1024);
  }
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"go.opentelemetry.io/otel"
  	"go.opentelemetry.io/otel/metric"
  )

  func recordFileSize() {
  	meter := otel.Meter("my-app")
  	gauge, _ := meter.Float64Gauge("database_size")

  	gauge.Record(context.Background(), 1024)
  }
  ```
</CodeGroup>

Le graphique affichera la valeur suivante pour le formateur de taille de fichier spécifié :

* `Size in Bit` affichera "128 Bytes"
* `Size in Bytes` affichera "1 KB"
* `Size in Kilobits` affichera "128 KB"
* `Size in Kilobytes` affichera "1 MB"
* `Size in Megabytes` affichera "1 GB"

## Tags de métriques

<Tip>
  Les tags de métriques personnalisés nécessitent les versions de package/gem
  AppSignal suivantes ou ultérieures :

  <ul>
    <li>Version du gem Ruby `2.6.0`</li>
    <li>Package Elixir `1.6.0`</li>
    <li>Package Node.js `1.0.0`</li>
    <li>Package Python `0.3.0`</li>
  </ul>
</Tip>

Une seule métrique peut être composée de différents groupes de données ; par exemple, une métrique personnalisée 'total\_orders' pourrait être composée de commandes en attente et de commandes traitées.

Vous pouvez ajouter plusieurs tags aux métriques pour obtenir des informations plus approfondies sur les données de métriques rapportées par AppSignal. Chaque tag sera représenté par sa propre ligne sur un graphique AppSignal.

Par défaut, les helpers de métriques AppSignal ne définissent pas de tags sur une métrique personnalisée.

Comment utiliser les tags dans les graphiques AppSignal :

Les tags peuvent "étiqueter" une ligne dans la légende du graphique, facilitant ainsi l'identification de ce que représente chaque ligne lorsque vous survolez avec la souris.
Le filtrage avec des tags peut afficher la même métrique dans différents contextes sur différents graphiques.

Pour tirer le meilleur parti des tags de métriques, nous vous conseillons ce qui suit :

* **Soyez cohérent dans l'utilisation des tags :** Pour un suivi optimal et une bonne lisibilité des graphiques, nous déconseillons de rapporter une métrique personnalisée à la fois avec et sans tags. Rapporter la même métrique de différentes manières peut créer de la confusion et rendre l'interprétation des données plus difficile.

* **Utilisez toujours les mêmes tags de métriques :** Nous recommandons d'utiliser la même combinaison de tags chaque fois que vous rapportez une métrique. Par exemple, si une métrique utilise les tags A et B dans une zone de votre app, elle doit les utiliser dans toutes les zones. Évitez de changer les tags, car une étiquetage cohérent facilitera la création de graphiques.

* **Utilisez une plage limitée de valeurs pour les tags de métriques :** Pour éviter des graphiques trop complexes ou illisibles, nous recommandons d'utiliser une plage limitée de tags sur vos métriques personnalisées, telles que les régions (EU, US et Asie). Vous pouvez effectuer une analyse plus large des données de métriques de votre app en utilisant une plage de tags limitée et précise pour toutes les données de métriques de votre app.

En général, lors de la mise en œuvre de l'étiquetage des métriques, envisagez d'élaborer une stratégie de tagging robuste qui peut être appliquée de manière cohérente dans toute votre application et qui nécessitera peu ou pas d'ajustements à long terme.

<CodeGroup>
  ```ruby Ruby theme={null}
  Appsignal.set_gauge("database_size", 100, :region => "eu")
  Appsignal.set_gauge("database_size",  50, :region => "us")
  Appsignal.set_gauge("database_size", 200, :region => "asia")

  # Multiple tags per metric
  Appsignal.set_gauge("my_metric_name", 100, :tag_a => "a", :tag_b => "b")
  Appsignal.set_gauge("my_metric_name", 10, :tag_a => "a", :tag_b => "b")
  Appsignal.set_gauge("my_metric_name", 200, :tag_a => "b", :tag_b => "c")
  ```

  ```elixir Elixir theme={null}
  Appsignal.set_gauge("database_size", 100, %{region: "eu"})
  Appsignal.set_gauge("database_size",  50, %{region: "us"})
  Appsignal.set_gauge("database_size", 200, %{region: "asia"})

  # Multiple tags per metric
  Appsignal.set_gauge("my_metric_name", 100, %{tag_a: "a", tag_b: "b"})
  Appsignal.set_gauge("my_metric_name", 10, %{tag_a: "a", tag_b: "b"})
  Appsignal.set_gauge("my_metric_name", 200, %{tag_a: "b", tag_b: "c"})
  ```

  ```javascript JavaScript theme={null}
  const meter = Appsignal.client.metrics();

  meter.setGauge("database_size", 100, { region: "eu" });
  meter.setGauge("database_size", 50, { region: "us" });
  meter.setGauge("database_size", 200, { region: "asia" });

  // Multiple tags per metric
  meter.setGauge("my_metric_name", 100, { tag_a: "a", tag_b: "b" });
  meter.setGauge("my_metric_name", 10, { tag_a: "a", tag_b: "b" });
  meter.setGauge("my_metric_name", 200, { tag_a: "b", tag_b: "c" });
  ```

  ```python Python theme={null}
  from appsignal import set_gauge

  set_gauge("database_size", 100, {"region": "eu"})
  set_gauge("database_size",  50, {"region": "us"})
  set_gauge("database_size", 200, {"region": "asia"})

  # Multiple tags per metric
  set_gauge("my_metric_name", 100, {"tag_a": "a", "tag_b": "b"})
  set_gauge("my_metric_name",  10, {"tag_a": "a", "tag_b": "b"})
  set_gauge("my_metric_name", 200, {"tag_a": "b", "tag_b": "c"})
  ```

  ```php PHP theme={null}
  <?php
  use Appsignal\Appsignal;

  // Record gauge values with attributes (tags)
  Appsignal::setGauge('database_size', 100, ['region' => 'eu']);
  Appsignal::setGauge('database_size', 50, ['region' => 'us']);
  Appsignal::setGauge('database_size', 200, ['region' => 'asia']);

  // Multiple tags per metric
  Appsignal::setGauge('my_metric_name', 100, ['tag_a' => 'a', 'tag_b' => 'b']);
  Appsignal::setGauge('my_metric_name', 10, ['tag_a' => 'a', 'tag_b' => 'b']);
  Appsignal::setGauge('my_metric_name', 200, ['tag_a' => 'b', 'tag_b' => 'c']);
  ```

  ```java Java theme={null}
  import io.opentelemetry.api.GlobalOpenTelemetry;
  import io.opentelemetry.api.common.AttributeKey;
  import io.opentelemetry.api.common.Attributes;
  import io.opentelemetry.api.metrics.DoubleGauge;
  import io.opentelemetry.api.metrics.Meter;

  public void recordTaggedMetrics() {
      Meter meter = GlobalOpenTelemetry.getMeter("my-app");
      DoubleGauge gauge = meter.gaugeBuilder("database_size").build();

      // Record gauge values with attributes (tags)
      gauge.set(100, Attributes.of(
          AttributeKey.stringKey("region"), "eu"
      ));
      gauge.set(50, Attributes.of(
          AttributeKey.stringKey("region"), "us"
      ));
      gauge.set(200, Attributes.of(
          AttributeKey.stringKey("region"), "asia"
      ));

      // Multiple tags per metric
      DoubleGauge myGauge = meter.gaugeBuilder("my_metric_name").build();
      myGauge.set(100, Attributes.of(
          AttributeKey.stringKey("tag_a"), "a",
          AttributeKey.stringKey("tag_b"), "b"
      ));
      myGauge.set(10, Attributes.of(
          AttributeKey.stringKey("tag_a"), "a",
          AttributeKey.stringKey("tag_b"), "b"
      ));
      myGauge.set(200, Attributes.of(
          AttributeKey.stringKey("tag_a"), "b",
          AttributeKey.stringKey("tag_b"), "c"
      ));
  }
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"go.opentelemetry.io/otel"
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/metric"
  )

  func recordTaggedMetrics() {
  	meter := otel.Meter("my-app")
  	gauge, _ := meter.Float64Gauge("database_size")

  	// Record gauge values with attributes (tags)
  	gauge.Record(context.Background(), 100, metric.WithAttributes(
  		attribute.String("region", "eu"),
  	))
  	gauge.Record(context.Background(), 50, metric.WithAttributes(
  		attribute.String("region", "us"),
  	))
  	gauge.Record(context.Background(), 200, metric.WithAttributes(
  		attribute.String("region", "asia"),
  	))

  	// Multiple tags per metric
  	myGauge, _ := meter.Float64Gauge("my_metric_name")
  	myGauge.Record(context.Background(), 100, metric.WithAttributes(
  		attribute.String("tag_a", "a"),
  		attribute.String("tag_b", "b"),
  	))
  	myGauge.Record(context.Background(), 10, metric.WithAttributes(
  		attribute.String("tag_a", "a"),
  		attribute.String("tag_b", "b"),
  	))
  	myGauge.Record(context.Background(), 200, metric.WithAttributes(
  		attribute.String("tag_a", "b"),
  		attribute.String("tag_b", "c"),
  	))
  }
  ```
</CodeGroup>

## Afficher une métrique avec et sans tags

Si vous avez créé une métrique personnalisée à laquelle plusieurs tags sont associés, vous pouvez afficher la métrique avec et sans le tag en même temps dans un graphique.

<CodeGroup>
  ```ruby Ruby theme={null}
  Appsignal.increment_counter("sign_ups", 1, region: "eu")
  Appsignal.increment_counter("sign_ups", 1)
  ```

  ```elixir Elixir theme={null}
  Appsignal.increment_counter("sign_ups", 1, %{region: "eu"})
  Appsignal.increment_counter("sign_ups", 1)
  ```

  ```javascript JavaScript theme={null}
  const meter = Appsignal.client.metrics();

  meter.incrementCounter("sign_ups", 1, { region: "eu" });
  meter.incrementCounter("sign_ups", 1);
  ```

  ```python Python theme={null}
  from appsignal import increment_counter

  increment_counter("sign_ups", 1, {"region": "eu"})
  increment_counter("sign_ups", 1)
  ```

  ```php PHP theme={null}
  <?php
  use Appsignal\Appsignal;

  Appsignal::incrementCounter('sign_ups', 1, ['region' => 'eu']);
  Appsignal::incrementCounter('sign_ups', 1);
  ```

  ```java Java theme={null}
  import io.opentelemetry.api.GlobalOpenTelemetry;
  import io.opentelemetry.api.common.AttributeKey;
  import io.opentelemetry.api.common.Attributes;
  import io.opentelemetry.api.metrics.LongCounter;
  import io.opentelemetry.api.metrics.Meter;

  public void recordMixedMetrics() {
      Meter meter = GlobalOpenTelemetry.getMeter("my-app");
      LongCounter counter = meter.counterBuilder("sign_ups").build();

      counter.add(1, Attributes.of(
          AttributeKey.stringKey("region"), "eu"
      ));
      counter.add(1);
  }
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"go.opentelemetry.io/otel"
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/metric"
  )

  func recordMixedMetrics() {
  	meter := otel.Meter("my-app")
  	counter, _ := meter.Int64Counter("sign_ups")

  	counter.Add(context.Background(), 1, metric.WithAttributes(
  		attribute.String("region", "eu"),
  	))
  	counter.Add(context.Background(), 1)
  }
  ```
</CodeGroup>

## Représenter graphiquement les métriques personnalisées

Une fois que vous avez commencé à enregistrer des métriques personnalisées, vous pouvez les suivre dans des graphiques personnalisés à l'aide du Graph Builder. Naviguez vers un tableau de bord existant ou utilisez le bouton "Add dashboard" dans la navigation des tableaux de bord pour en créer un nouveau, puis cliquez sur "Add graph".

<img src="https://mintcdn.com/appsignal-715f5a51/4TRZP0Sq9Zq7PAPW/assets/images/screenshots/metrics/custom/graph-builder.png?fit=max&auto=format&n=4TRZP0Sq9Zq7PAPW&q=85&s=095f9711aa9531e138596c955b6a81c2" alt="Graph Builder" width="2304" height="1720" data-path="assets/images/screenshots/metrics/custom/graph-builder.png" />

Lors de la création d'un graphique, vous pouvez sélectionner les métriques et les tags que vous souhaitez représenter et configurer les légendes et étiquettes de votre graphique. Une fois créé, le graphique sera ajouté au tableau de bord et affichera toutes les données de métriques personnalisées enregistrées pour la période spécifiée.

Vous pouvez en savoir plus sur les tableaux de bord et les graphiques dans notre [documentation Dashboard](/metrics/dashboards).