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

# Custom metrics

Met custom metrics kunt u alles bijhouden wat zinvol is in uw applicatie — van het aantal actieve gebruikers op een bepaald moment, tot hoeveel facturen er in het afgelopen uur zijn gegenereerd, tot de huidige grootte van uw database. Door custom metrics naar AppSignal te sturen, kunt u grafieken in uw dashboards maken die deze gegevens relateren aan kritieke signalen zoals foutfrequenties en responstijden, waardoor u de context heeft om snel problemen te identificeren en op te lossen.

Bovendien helpen custom metrics u proactief te werken in plaats van reactief. Terwijl logging u helpt problemen te debuggen nadat ze zijn opgetreden, kunt u met custom metrics trends en potentiële problemen opmerken voordat uw klanten ze merken. U kunt zich concentreren op gegevens die belangrijk zijn voor uw business — zoals aantallen actieve gebruikers, KPI's of verkoopvolumes — zonder door logregels of incidentlijsten te hoeven spitten. U kunt ook triggers instellen op custom metrics om u te waarschuwen wanneer waarden buiten de verwachte bereiken vallen.

Custom metrics zijn geen vervanging voor [custom instrumentation](/ruby/instrumentation/instrumentation), maar een aanvullend hulpmiddel om specifieke applicatiegegevens zichtbaar en meetbaar te maken in de tijd.

AppSignal biedt drie typen custom metrics:

| Type                        | Het beste voor                             | Voorbeeld use case                                 |
| --------------------------- | ------------------------------------------ | -------------------------------------------------- |
| [Gauge](#gauge)             | Absolute waarden die in de tijd veranderen | Actieve gebruikers, databasegrootte, schijfgebruik |
| [Measurement](#measurement) | Bereiken en verdelingen van waarden        | Responstijden, taakduur, winkelwagenwaarden        |
| [Counter](#counter)         | Het tellen van gebeurtenissen in de tijd   | Aangemaakte facturen, logins, getriggerde fouten   |

U kunt custom metrics bijhouden in [grafieken](#graphing-custom-metrics) in uw AppSignal-dashboards.

### Gauge

Een gauge legt een waarde vast op een specifiek tijdstip. Als u meerdere gauges rapporteert met dezelfde sleutel binnen hetzelfde tijdsvenster, wordt alleen de laatste waarde bewaard.

**Gebruik gauges wanneer** u de huidige staat van iets wilt weten — het aantal items dat op dit moment bestaat, of de huidige grootte van een resource. Alle AppSignal [host metrics](/metrics/host-metrics) worden opgeslagen als gauges.

Gauges worden vaak gebruikt met [minutely probes](/ruby/instrumentation/minutely-probes) om periodiek een snapshotwaarde te rapporteren, zoals het elke minuut bevragen van het aantal recent actieve winkelwagens of open databaseconnecties.

**Voorbeelden:** aantal actieve gebruikers, databasegrootte, schijfgebruik, aantal open connecties.

<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>
  Vanaf versie 3.1.0 stelt de Node.js-integratie u in staat gauges en counters in te stellen met de OpenTelemetry metrics provider. U moet de OpenTelemetry HTTP-server van de agent inschakelen om deze metrics naar AppSignal te rapporteren; u kunt dit doen door de optie [enableOpentelemetryHttp](/nodejs/3.x/configuration/options#option-enable_opentelemetry_http) in te stellen op `true`.

  De Java- en Go-integraties gebruiken ook OpenTelemetry metrics om custom metrics naar AppSignal te rapporteren.

  U kunt meer lezen over OpenTelemetry metrics in de [OpenTelemetry metrics-documentatie](https://opentelemetry.io/docs/concepts/metrics/). Voor Node.js, zie de [OpenTelemetry JS metrics-documentatie](https://opentelemetry.io/docs/languages/js/instrumentation/#metrics) voor meer informatie.
</Tip>

### Measurement

Een measurement houdt een spreiding van waarden in de tijd bij. AppSignal slaat het gemiddelde en het aantal op voor elk tijdsvenster, waardoor u zaken zoals gemiddelde duur, 90e/95e percentiel en throughput kunt graphen.

**Gebruik measurements wanneer** u een waarde registreert die per gebeurtenis varieert en u de verdeling ervan wilt begrijpen — niet alleen de huidige waarde. U kunt bijvoorbeeld de duur van een kritieke achtergrondtaak (zoals bevestigings-e-mails voor bestellingen) bijhouden om vertragingen op te merken voordat deze uw gebruikers beïnvloeden.

Een measurement-metric maakt verschillende metric-velden aan:

* **Count:** hoe vaak de helper werd aangeroepen. Nuttig voor throughput-grafieken.
* **Mean:** de gemiddelde metric-waarde voor het punt in tijd.
* **90e percentiel:** het 90e percentiel van de metric-waarde voor het punt in tijd.
* **95e percentiel:** het 95e percentiel van de metric-waarde voor het punt in tijd.

**Voorbeelden:** HTTP-responstijden, durations van achtergrondtaken, gebruikers-winkelwagenwaarden, query-uitvoeringstijden.

<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

Een counter accumuleert een totaaltelling over een tijdsvenster. Counter-waarden worden gesommeerd voor elke resolutie — bij minutely resolutie toont het dus het totaal voor die minuut, en bij hourly resolutie toont het het totaal voor dat uur.

**Gebruik counters wanneer** u wilt bijhouden hoe vaak iets is gebeurd, niet welke waarde het had. Counters zijn vooral nuttig voor het monitoren van de frequentie van bedrijfskritieke gebeurtenissen. Bijvoorbeeld, door zowel geplaatste bestellingen als aangemaakte facturen bij te houden, kunt u verifiëren dat deze gerelateerde counters synchroon blijven en discrepanties vroegtijdig opvangen.

Wanneer de helper meerdere keren wordt aangeroepen, wordt het totaal/de som van alle aanroepen bewaard. Counters zijn niet-monotoon: zowel positieve als negatieve waarden worden ondersteund, zodat u dezelfde counter kunt verhogen en verlagen. Voor monotonische counters van andere systemen is er geen validatie dat counter-waarden alleen ooit toenemen.

**Voorbeelden:** geplaatste bestellingen, aangemaakte facturen, gebruikerslogins, in de wachtrij geplaatste achtergrondtaken, mislukte betalingspogingen.

<Tip>
  **Gauge vs. Counter:** Gebruik een gauge om bij te houden *hoeveel van iets er nu bestaan*
  (bijv. momenteel actieve gebruikers). Gebruik een counter om bij te houden *hoe vaak
  iets is gebeurd* in een bepaalde periode (bijv. nieuwe logins in de laatste minuut).
</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>
  **Let op**: In AppSignal zijn counters ontworpen om alleen integerwaarden op te slaan.
  Hoewel de API float-waarden accepteert om integratie te vergemakkelijken, worden deze waarden intern geconverteerd naar integers.

  Decimale waarden worden naar beneden afgerond op het dichtstbijzijnde gehele getal.
  De waarde 0,0001 wordt 0, en 1,2, 1,5 en 1,7 worden 1.
</Warning>

## Metric-naamgeving

We raden aan uw metrics een naam te geven die gemakkelijk herkenbaar is. Hoewel u delen van de metric-naam kunt wildcarden voor het aanmaken van dashboards, raden we aan dit alleen te gebruiken voor kleine groepering en geen ID's in metric-namen te gebruiken.

Metric-namen ondersteunen alleen cijfers, letters, punten en underscores (`[a-z0-9._]`) als geldige karakters. Andere karakters worden door onze processor vervangen door een underscore. U kunt de lijst met metrics zoals verwerkt vinden op ["Add Dashboard"](https://appsignal.com/redirect-to/app?to=dashboard\&overlay=dashboardForm).

Enkele voorbeelden van goede metric-namen zijn:

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

Standaard houdt AppSignal al metrics voor uw applicatie bij, zoals [host metrics](/metrics/host-metrics). Zie de metrics-lijst op de pagina ["Add Dashboard"](https://appsignal.com/redirect-to/app?to=dashboard\&overlay=dashboardForm) voor de metrics die al beschikbaar zijn voor uw app.

<Warning>
  **Let op**: We raden **af** om dynamische waarden toe te voegen aan uw metric-namen
  zoals: `eu.database_size`, `us.database_size` en `asia.database_size`. Dit
  creëert meerdere metrics die hetzelfde doel dienen. In plaats daarvan raden we
  aan om hiervoor [metric-tags](#metric-tags) te gebruiken.
</Warning>

## Metric-waarden

Metrics ondersteunen alleen getallen als geldige waarden. Elke andere waarde wordt stilzwijgend genegeerd of zal een fout veroorzaken die wordt getriggerd door de getalsparser van de implementatietaal. Voor Ruby en Elixir ondersteunen we een [double](https://en.wikipedia.org/wiki/Double-precision_floating-point_format) en [integer](https://en.wikipedia.org/wiki/Integer) als geldige waarden:

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

Let op: In Node.js is alleen het type `number` een geldige waarde.

### Waarde-opmaak {/* id: metric-values-value-formatting */}

AppSignal-grafieken hebben verschillende weergaveformaten, zoals getallen, bestandsgroottes, durations,
enz. Deze formaten helpen om de metric-waarden op een leesbare manier weer te geven.

Het selecteren van een waarde-formatter-input heeft geen invloed op de gegevens die in onze systemen worden opgeslagen, alleen op hoe deze worden weergegeven.

Om metric-waarden correct weer te geven met deze formatters, controleer dan de onderstaande tabel hoe de waarde moet worden gerapporteerd.

| Formatter  | Gerapporteerde waarde    | Beschrijving                                                                                                                                                                                                                                                                                                                                                    |
| ---------- | ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Number     | Weergavewaarde           | Een leesbaar geformatteerd getal. De waarden moeten worden gerapporteerd op dezelfde schaal als waarop ze worden weergegeven. De waarde `1` wordt weergegeven als "`1`", `10_000` als "`10 K`" en `1_000_000` wordt weergegeven als "`1 M`".                                                                                                                    |
| Percentage | Weergavewaarde           | Een metric-waarde geformatteerd als percentage. De waarden moeten worden gerapporteerd op dezelfde schaal als waarop ze worden weergegeven. De waarde `40` wordt weergegeven als "`40 %`".                                                                                                                                                                      |
| Throughput | Weergavewaarde           | Een metric-waarde geformatteerd als requests per minuut/uur. De waarden moeten worden gerapporteerd op dezelfde schaal als waarop ze worden weergegeven. Het toont de throughput geformatteerd als getal voor zowel de minuut als het uur. De waarde `10_000` wordt weergegeven als "`10k / hour 166 / min`". Vaak gebruikt voor [`counter`](#counter)-metrics. |
| Duration   | Milliseconden            | Een tijdsduur. De waarden moeten worden gerapporteerd als milliseconden. De waarde `100` wordt weergegeven als "`100 ms`" en 60\_000 als "`60 sec`". Vaak gebruikt voor [`measurement`](/metrics/custom#measurement)-metrics.                                                                                                                                   |
| File size  | [Aanpasbaar](#file-size) | Een bestandsgrootte standaard geformatteerd als megabytes. `1.0` megabytes wordt weergegeven als `1Mb`. Welke bestandsgrootte-eenheid de gerapporteerde metric-waarde wordt gelezen kan worden aangepast in de graph builder.                                                                                                                                   |

#### File size

Metric-waarden die een bestandsgrootte vertegenwoordigen kunnen de file size-formatter gebruiken. Om aan te geven welke grootte-eenheid de gerapporteerde waarde heeft, biedt de file size-formatter verschillende invoerwaarden.

De beschikbare opties zijn:

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

Bij het sturen van een metric met de volgende waarde:

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

De grafiek geeft de volgende weergavewaarde weer voor de opgegeven file size-formatter:

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

## Metric-tags

<Tip>
  Custom metric-tags vereisen de volgende AppSignal-pakket/gem-versie of
  hoger:

  <ul>
    <li>Ruby gem-versie `2.6.0`</li>
    <li>Elixir-pakket `1.6.0`</li>
    <li>Node.js-pakket `1.0.0`</li>
    <li>Python-pakket `0.3.0`</li>
  </ul>
</Tip>

Een enkele metric kan bestaan uit verschillende groepen gegevens; bijvoorbeeld kan een 'total\_orders' custom metric bestaan uit pending en processed orders.

U kunt meerdere tags toevoegen aan metrics voor diepere inzichten in de metric-gegevens die AppSignal rapporteert. Elke tag wordt weergegeven door zijn lijn op een AppSignal-grafiek.

Standaard stellen de AppSignal metric-helpers geen tags in op een custom metric.

Hoe u tags in AppSignal-grafieken kunt gebruiken:

Tags kunnen een lijn in de grafieklegenda "labelen", waardoor het gemakkelijker wordt om te zien wat elke lijn vertegenwoordigt wanneer u er met de muis overheen gaat.
Filteren met tags kan dezelfde metric tonen in verschillende contexten op verschillende grafieken.

Om het meeste uit metric-tags te halen, adviseren we het volgende:

* **Wees consistent met taggen:** Voor optimale tracking en grafiekleesbaarheid raden we af om een custom metric zowel met als zonder tags te rapporteren. Dezelfde metric op verschillende manieren rapporteren kan verwarring veroorzaken en het moeilijk maken om de gegevens nauwkeurig te interpreteren.

* **Gebruik altijd dezelfde metric-tags wanneer:** We raden aan om dezelfde combinatie van tags te gebruiken wanneer u een metric rapporteert. Bijvoorbeeld, als een metric tags A en B gebruikt in één gebied van uw app, moet deze ze in alle gebieden gebruiken. Vermijd het wijzigen van de tags, omdat consistente tagging het graphen gemakkelijker maakt.

* **Gebruik een beperkt waarde-bereik voor metric-tags:** Om overdreven complexe of onleesbare grafieken te voorkomen, raden we aan om een beperkt bereik van tags op uw custom metrics te gebruiken, zoals regio's (EU, US en Asia). U kunt een bredere analyse van de metric-gegevens van uw app uitvoeren wanneer u een beperkt en precies bereik van tags gebruikt voor al uw app-metric-gegevens.

In het algemeen, overweeg bij het implementeren van metric-tagging een robuuste tagging-strategie te ontwikkelen die consistent in uw applicatie kan worden toegepast en op de lange termijn weinig tot geen aanpassingen nodig zal hebben.

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

## Metrics renderen met en zonder tags

Als u een custom metric heeft aangemaakt en er meerdere tags aan zijn gekoppeld, kunt u de metric tegelijkertijd met en zonder de tag in een grafiek renderen.

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

## Custom metrics graphen

Zodra u bent begonnen met het registreren van custom metrics, kunt u deze bijhouden in aangepaste grafieken met behulp van de Graph Builder. Navigeer naar een bestaand dashboard of gebruik de knop "Add dashboard" in de Dashboard-navigatie om een nieuwe aan te maken, en klik vervolgens op "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" />

Bij het maken van een grafiek kunt u selecteren welke metrics en tags u wilt graphen en de legendas en labels van uw grafiek configureren. Eenmaal aangemaakt, wordt de grafiek toegevoegd aan het dashboard en worden alle geregistreerde custom metric-gegevens voor de opgegeven periode weergegeven.

U kunt meer lezen over dashboards en grafieken in onze [Dashboard-documentatie](/metrics/dashboards).