Skip to main content
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, maar een aanvullend hulpmiddel om specifieke applicatiegegevens zichtbaar en meetbaar te maken in de tijd. AppSignal biedt drie typen custom metrics:
TypeHet beste voorVoorbeeld use case
GaugeAbsolute waarden die in de tijd veranderenActieve gebruikers, databasegrootte, schijfgebruik
MeasurementBereiken en verdelingen van waardenResponstijden, taakduur, winkelwagenwaarden
CounterHet tellen van gebeurtenissen in de tijdAangemaakte facturen, logins, getriggerde fouten
U kunt custom metrics bijhouden in grafieken 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 worden opgeslagen als gauges. Gauges worden vaak gebruikt met 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. 
# 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

# 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

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

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

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
}

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
}
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 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. Voor Node.js, zie de OpenTelemetry JS metrics-documentatie voor meer informatie.

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

# 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

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

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

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
}

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
}

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

# 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

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

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

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
}

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

​
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”. 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. Zie de metrics-lijst op de pagina “Add Dashboard” voor de metrics die al beschikbaar zijn voor uw app.
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 te gebruiken.

​
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 en integer als geldige waarden: 
# Integer
Appsignal.increment_counter("login_count", 1)
# Double
Appsignal.increment_counter("assignment_completed", 0.12)

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

const meter = Appsignal.client.metrics();

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

from appsignal import increment_counter

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

<?php
use Appsignal\Appsignal;

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

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);
}

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)
}
Let op: In Node.js is alleen het type number een geldige waarde.

​
Waarde-opmaak

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.
FormatterGerapporteerde waardeBeschrijving
NumberWeergavewaardeEen 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”.
PercentageWeergavewaardeEen 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 %”.
ThroughputWeergavewaardeEen 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-metrics.
DurationMillisecondenEen 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.
File sizeAanpasbaarEen 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: 
Appsignal.set_gauge("database_size", 1024)

Appsignal.set_gauge("database_size", 1024)

const meter = Appsignal.client.metrics();

meter.setGauge("database_size", 1024);

# Import the AppSignal metric helper
from appsignal import set_gauge

set_gauge("database_size", 1024)

<?php
use Appsignal\Appsignal;

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

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);
}

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

Custom metric-tags vereisen de volgende AppSignal-pakket/gem-versie of hoger:
  • Ruby gem-versie 2.6.0
  • Elixir-pakket 1.6.0
  • Node.js-pakket 1.0.0
  • Python-pakket 0.3.0
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. 
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")

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"})

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" });

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
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']);

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"
    ));
}

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"),
	))
}

​
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. 
Appsignal.increment_counter("sign_ups", 1, region: "eu")
Appsignal.increment_counter("sign_ups", 1)

Appsignal.increment_counter("sign_ups", 1, %{region: "eu"})
Appsignal.increment_counter("sign_ups", 1)

const meter = Appsignal.client.metrics();

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

from appsignal import increment_counter

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

<?php
use Appsignal\Appsignal;

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

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);
}

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

​
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”. Graph Builder 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.