Benutzerdefinierte Metriken - AppSignal Documentation

Mit benutzerdefinierten Metriken können Sie alles erfassen, was in Ihrer Anwendung von Bedeutung ist – von der Anzahl der aktiven Nutzer zu einem bestimmten Zeitpunkt über die Anzahl der in der letzten Stunde erstellten Rechnungen bis hin zur aktuellen Größe Ihrer Datenbank. Indem Sie benutzerdefinierte Metriken an AppSignal senden, können Sie in Ihren Dashboards Diagramme erstellen, die diese Daten mit wichtigen Signalen wie Fehlerraten und Antwortzeiten in Beziehung setzen – so erhalten Sie den Kontext, um Probleme schnell zu erkennen und zu beheben. Darüber hinaus helfen benutzerdefinierte Metriken Ihnen, proaktiv statt reaktiv zu arbeiten. Während Logging Ihnen hilft, Probleme nach ihrem Auftreten zu debuggen, ermöglichen Ihnen benutzerdefinierte Metriken, Trends und potenzielle Probleme zu erkennen, bevor Ihre Kunden sie bemerken. Sie können sich auf Daten konzentrieren, die für Ihr Geschäft wichtig sind – wie etwa die Anzahl aktiver Nutzer, KPIs oder Verkaufsmengen –, ohne Logzeilen oder Vorfallslisten zu durchsuchen. Sie können auch Trigger auf benutzerdefinierte Metriken setzen, die Sie warnen, wenn Werte außerhalb der erwarteten Bereiche liegen. Benutzerdefinierte Metriken sind kein Ersatz für benutzerdefinierte Instrumentierung, sondern ein ergänzendes Werkzeug, um spezifische Anwendungsdaten über die Zeit hinweg sichtbar und messbar zu machen. AppSignal bietet drei Arten von benutzerdefinierten Metriken:

Typ	Am besten geeignet für	Beispiel-Anwendungsfall
Gauge	Absolute Werte, die sich über die Zeit ändern	Aktive Nutzer, Datenbankgröße, Speicherplatznutzung
Measurement	Bereiche und Verteilungen von Werten	Antwortzeiten, Job-Dauern, Warenkorbwerte
Counter	Vorkommen über die Zeit zählen	Erstellte Rechnungen, Logins, ausgelöste Fehler

Sie können benutzerdefinierte Metriken in Diagrammen in Ihren AppSignal-Dashboards verfolgen.

Gauge

Ein Gauge zeichnet einen Wert zu einem bestimmten Zeitpunkt auf. Wenn Sie mehrere Gauges mit demselben Schlüssel innerhalb desselben Zeitfensters melden, wird nur der letzte Wert gespeichert. Verwenden Sie Gauges, wenn Sie den aktuellen Zustand von etwas wissen möchten – die Anzahl der gerade existierenden Elemente oder die aktuelle Größe einer Ressource. Alle AppSignal-Host-Metriken werden als Gauges gespeichert. Gauges werden häufig mit minütlichen Probes verwendet, um regelmäßig einen Snapshot-Wert zu melden, etwa um jede Minute die Anzahl der kürzlich aktiven Warenkörbe oder offenen Datenbankverbindungen abzufragen. Beispiele: Anzahl aktiver Nutzer, Datenbankgröße, Speicherplatznutzung, Anzahl offener Verbindungen.

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

Ab Version 3.1.0 ermöglicht es die Node.js-Integration, Gauges und Counter über den OpenTelemetry-Metrics-Provider zu setzen. Sie müssen den OpenTelemetry-HTTP-Server des Agents aktivieren, um diese Metriken an AppSignal zu melden; dies können Sie tun, indem Sie die Option enableOpentelemetryHttp auf true setzen.Auch die Java- und Go-Integrationen verwenden OpenTelemetry-Metriken, um benutzerdefinierte Metriken an AppSignal zu melden.Mehr zu OpenTelemetry-Metriken erfahren Sie in der OpenTelemetry-Metrics-Dokumentation. Für Node.js finden Sie weitere Informationen in der OpenTelemetry JS Metrics-Dokumentation.

Measurement

Ein Measurement verfolgt eine Verteilung von Werten über die Zeit. AppSignal speichert für jedes Zeitfenster den Durchschnitt und die Anzahl, sodass Sie Dinge wie durchschnittliche Dauer, 90. / 95. Perzentil und Durchsatz grafisch darstellen können. Verwenden Sie Measurements, wenn Sie einen Wert aufzeichnen, der über einzelne Ereignisse hinweg variiert, und Sie dessen Verteilung verstehen möchten – nicht nur seinen aktuellen Wert. Beispielsweise können Sie die Dauer eines kritischen Hintergrund-Jobs (etwa Bestellbestätigungs-E-Mails) verfolgen, um Verlangsamungen zu erkennen, bevor sie Ihre Nutzer beeinträchtigen. Eine Measurement-Metrik erstellt mehrere Metrik-Felder:

Count: wie oft der Helper aufgerufen wurde. Nützlich für Durchsatz-Diagramme.
Mean: der durchschnittliche Metrik-Wert für den Zeitpunkt.
90. Perzentil: das 90. Perzentil des Metrik-Werts für den Zeitpunkt.
95. Perzentil: das 95. Perzentil des Metrik-Werts für den Zeitpunkt.

Beispiele: HTTP-Antwortzeiten, Hintergrund-Job-Dauern, Werte von Nutzer-Warenkörben, Ausführungszeiten von Abfragen.

# 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

Ein Counter akkumuliert eine Gesamtsumme über ein Zeitfenster. Counter-Werte werden für jede Auflösung summiert – bei minütlicher Auflösung zeigt er also die Summe für diese Minute, und bei stündlicher Auflösung die Summe für diese Stunde. Verwenden Sie Counter, wenn Sie verfolgen möchten, wie oft etwas passiert ist, nicht welchen Wert es hatte. Counter sind besonders nützlich, um die Häufigkeit geschäftskritischer Ereignisse zu überwachen. Indem Sie beispielsweise sowohl aufgegebene Bestellungen als auch erstellte Rechnungen verfolgen, können Sie sicherstellen, dass diese zusammenhängenden Counter synchron bleiben, und Abweichungen frühzeitig erkennen. Wenn der Helper mehrfach aufgerufen wird, wird die Summe aller Aufrufe gespeichert. Counter sind nicht monoton: Sowohl positive als auch negative Werte werden unterstützt, sodass Sie denselben Counter erhöhen und verringern können. Für monotone Counter aus anderen Systemen gibt es keine Validierung, dass die Counter-Werte nur jemals steigen. Beispiele: aufgegebene Bestellungen, erstellte Rechnungen, Nutzer-Logins, in die Warteschlange gestellte Hintergrund-Jobs, fehlgeschlagene Zahlungsversuche.

Gauge vs. Counter: Verwenden Sie einen Gauge, um zu verfolgen, wie viele Elemente von etwas gerade existieren (z. B. derzeit aktive Nutzer). Verwenden Sie einen Counter, um zu verfolgen, wie oft etwas passiert ist in einem bestimmten Zeitraum (z. B. neue Logins in der letzten Minute).

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

Hinweis: In AppSignal sind Counter so konzipiert, dass sie ausschließlich Integer-Werte speichern. Obwohl die API zur Erleichterung der Integration Float-Werte akzeptiert, werden diese intern in Integer umgewandelt.Dezimalwerte werden auf den nächstkleineren Integer abgerundet. Der Wert 0,0001 wird zu 0, und 1,2, 1,5 sowie 1,7 werden zu 1.

Benennung von Metriken

Wir empfehlen, Ihre Metriken so zu benennen, dass sie leicht erkennbar sind. Obwohl Sie Teile des Metrik-Namens für die Dashboard-Erstellung mit Wildcards versehen können, empfehlen wir, dies nur für kleine Gruppierungen zu verwenden und keine IDs in Metrik-Namen einzubauen. Metrik-Namen unterstützen nur Zahlen, Buchstaben, Punkte und Unterstriche ([a-z0-9._]) als gültige Zeichen. Alle anderen Zeichen werden von unserem Prozessor durch einen Unterstrich ersetzt. Die Liste der verarbeiteten Metriken finden Sie auf der Seite „Add Dashboard”. Einige Beispiele für gute Metrik-Namen sind:

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

Standardmäßig verfolgt AppSignal bereits Metriken für Ihre Anwendung, etwa Host-Metriken. Sehen Sie sich die Metrik-Liste auf der Seite „Add Dashboard” an, um die Metriken zu sehen, die bereits für Ihre App verfügbar sind.

Hinweis: Wir empfehlen nicht, dynamische Werte in Ihre Metrik-Namen einzufügen, wie etwa: eu.database_size, us.database_size und asia.database_size. Dadurch entstehen mehrere Metriken, die denselben Zweck erfüllen. Stattdessen empfehlen wir, dafür Metrik-Tags zu verwenden.

Metrik-Werte

Metriken unterstützen nur Zahlen als gültige Werte. Jeder andere Wert wird stillschweigend ignoriert oder löst einen Fehler aus, wie er vom Zahlen-Parser der jeweiligen Implementierungssprache erzeugt wird. Für Ruby und Elixir unterstützen wir Double und Integer als gültige Werte:

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

Hinweis: In Node.js ist nur der Typ number ein gültiger Wert.

Wertformatierung

AppSignal-Diagramme bieten verschiedene Anzeigeformate, etwa Zahlen, Dateigrößen, Dauern usw. Diese Formate helfen dabei, die Metrik-Werte in einer lesbaren Form darzustellen. Die Auswahl eines Wert-Formatierers wirkt sich nicht auf die in unseren Systemen gespeicherten Daten aus, sondern nur auf deren Anzeige. Um Metrik-Werte mit diesen Formatierern korrekt anzuzeigen, prüfen Sie bitte in der Tabelle unten, wie der Wert gemeldet werden sollte.

Formatierer	Gemeldeter Wert	Beschreibung
Number	Anzeige-Wert	Eine menschenlesbar formatierte Zahl. Die Werte sollten auf derselben Skala gemeldet werden, wie sie angezeigt werden. Der Wert `1` wird als „`1`” angezeigt, `10_000` als „`10 K`” und `1_000_000` wird als „`1 M`” angezeigt.
Percentage	Anzeige-Wert	Ein Metrik-Wert, der als Prozentsatz formatiert ist. Die Werte sollten auf derselben Skala gemeldet werden, wie sie angezeigt werden. Der Wert `40` wird als „`40 %`” angezeigt.
Throughput	Anzeige-Wert	Ein Metrik-Wert, der als Anfragen pro Minute/Stunde formatiert ist. Die Werte sollten auf derselben Skala gemeldet werden, wie sie angezeigt werden. Der Durchsatz wird sowohl für die Minute als auch für die Stunde als Zahl formatiert angezeigt. Der Wert `10_000` wird als „`10k / hour 166 / min`” angezeigt. Üblicherweise verwendet für `counter`-Metriken.
Duration	Millisekunden	Eine Zeitdauer. Die Werte sollten als Millisekunden gemeldet werden. Der Wert `100` wird als „`100 ms`” und `60_000` als „`60 sec`” angezeigt. Üblicherweise verwendet für `measurement`-Metriken.
File size	Anpassbar	Eine Dateigröße, die standardmäßig als Megabyte formatiert ist. `1.0` Megabyte wird als `1Mb` angezeigt. Welche Dateigrößen-Einheit der gemeldete Metrik-Wert hat, kann im Diagramm-Builder angepasst werden.

Dateigröße

Metrik-Werte, die eine Dateigröße darstellen, können den Dateigrößen-Formatierer verwenden. Um anzugeben, in welcher Größeneinheit der gemeldete Wert vorliegt, erlaubt der Dateigrößen-Formatierer mehrere Eingabewerte. Die verfügbaren Optionen sind:

Size in Bit
Size in Bytes
Size in Kilobits
Size in Kilobytes
Size in Megabytes

Wenn eine Metrik mit dem folgenden Wert gesendet wird:

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

Das Diagramm rendert den folgenden Anzeige-Wert für den angegebenen Dateigrößen-Formatierer:

Size in Bit rendert „128 Bytes”
Size in Bytes rendert „1 KB”
Size in Kilobits rendert „128 KB”
Size in Kilobytes rendert „1 MB”
Size in Megabytes rendert „1 GB”

Metrik-Tags

Benutzerdefinierte Metrik-Tags erfordern die folgende AppSignal-Paket-/Gem-Version oder höher:

Ruby Gem Version 2.6.0
Elixir-Paket 1.6.0
Node.js-Paket 1.0.0
Python-Paket 0.3.0

Eine einzelne Metrik kann aus verschiedenen Datengruppen bestehen; beispielsweise könnte eine benutzerdefinierte Metrik „total_orders” aus offenen und verarbeiteten Bestellungen bestehen. Sie können einer Metrik mehrere Tags hinzufügen, um tiefere Einblicke in die von AppSignal gemeldeten Metrik-Daten zu erhalten. Jeder Tag wird durch eine eigene Linie in einem AppSignal-Diagramm dargestellt. Standardmäßig setzen die AppSignal-Metrik-Helper keine Tags auf benutzerdefinierte Metriken. So können Sie Tags in AppSignal-Diagrammen verwenden: Tags können eine Linie in der Diagramm-Legende „beschriften”, sodass leichter erkennbar ist, was jede Linie darstellt, wenn Sie mit der Maus darüberfahren. Das Filtern nach Tags kann dieselbe Metrik in verschiedenen Kontexten in verschiedenen Diagrammen darstellen. Um das Beste aus Metrik-Tags herauszuholen, empfehlen wir Folgendes:

Seien Sie konsistent beim Tagging: Für eine optimale Nachverfolgung und Lesbarkeit der Diagramme raten wir davon ab, eine benutzerdefinierte Metrik sowohl mit als auch ohne Tags zu melden. Das Melden derselben Metrik auf verschiedene Arten kann zu Verwirrung führen und die genaue Interpretation der Daten erschweren.
Verwenden Sie immer dieselben Metrik-Tags: Wir empfehlen, immer dieselbe Tag-Kombination zu verwenden, wenn Sie eine Metrik melden. Wenn eine Metrik beispielsweise in einem Bereich Ihrer App die Tags A und B verwendet, sollte sie diese in allen Bereichen verwenden. Vermeiden Sie es, die Tags zu ändern, da konsistentes Tagging das Erstellen von Diagrammen erleichtert.
Verwenden Sie einen begrenzten Wertebereich für Metrik-Tags: Um übermäßig komplexe oder unleserliche Diagramme zu vermeiden, empfehlen wir, für Ihre benutzerdefinierten Metriken einen begrenzten Bereich von Tags zu verwenden, etwa Regionen (EU, US und Asien). Sie können eine umfassendere Analyse der Metrik-Daten Ihrer App durchführen, wenn Sie für alle Metrik-Daten Ihrer App einen begrenzten und präzisen Bereich von Tags verwenden.

Beim Implementieren von Metrik-Tagging sollten Sie generell eine robuste Tagging-Strategie entwickeln, die konsistent in Ihrer Anwendung angewendet werden kann und langfristig wenig bis keine Anpassungen erfordert.

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

Metrik mit und ohne Tags rendern

Wenn Sie eine benutzerdefinierte Metrik erstellt haben und ihr mehrere Tags zugeordnet sind, können Sie die Metrik gleichzeitig mit und ohne den Tag in einem Diagramm rendern.

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

Grafische Darstellung benutzerdefinierter Metriken

Sobald Sie mit dem Aufzeichnen benutzerdefinierter Metriken begonnen haben, können Sie sie mit dem Graph Builder in benutzerdefinierten Diagrammen verfolgen. Navigieren Sie zu einem bestehenden Dashboard oder verwenden Sie die Schaltfläche „Add dashboard” in der Dashboard-Navigation, um ein neues zu erstellen, und klicken Sie dann auf „Add graph”.

Beim Erstellen eines Diagramms können Sie auswählen, welche Metriken und Tags Sie darstellen möchten, und die Legenden und Beschriftungen Ihres Diagramms konfigurieren. Nach der Erstellung wird das Diagramm dem Dashboard hinzugefügt und zeigt alle aufgezeichneten benutzerdefinierten Metrik-Daten für den angegebenen Zeitraum an. Weitere Informationen zu Dashboards und Diagrammen finden Sie in unserer Dashboard-Dokumentation.

​Gauge

​Measurement

​Counter

​Benennung von Metriken

​Metrik-Werte

​Wertformatierung

​Dateigröße

​Metrik-Tags

​Metrik mit und ohne Tags rendern

​Grafische Darstellung benutzerdefinierter Metriken

Gauge

Measurement

Counter

Benennung von Metriken

Metrik-Werte

Wertformatierung

Dateigröße

Metrik-Tags

Metrik mit und ohne Tags rendern

Grafische Darstellung benutzerdefinierter Metriken