[17.0.0.3 und höher]

MicroProfile-Metrics-Instrumentierungs-API

Sie können die MicroProfile-Metrics-API verwenden, um Ihren Anwendungen Metriken hinzuzufügen. Die MicroProfile-Metrics-API ähnelt der Dropwizard-Metrics-API.

Architektur von MicroProfile Metrics

Die Features mpMetrics-1.0 und mpMetrics-1.1 stellen drei Metrikregistrys bereit, in denen Metriken gespeichert werden.
Basis
Die Basisregistry wird für Servermetriken gemäß der MicroProfile-Metrics-Spezifikation verwendet.
Anbieter
Die Anbieterregistry wird für Metriken verwendet, die vom Produktanbieter, in diesem Fall von Liberty, hinzugefügt werden.
Anwendung
Die Anwendungsregistry wird für Metriken verwendet, die von Ihren Anwendungen hinzugefügt werden. Die Anwendungsregistry ist die Standard-MetricRegistry.

Die Features mpMetrics-1.0 und mpMetrics-1.1 enthalten außerdem einen /metrics-Endpunkt, der die HTTP-Schnittstelle für Browser und Überwachungstools für die Interaktion bereitstellt.

Metrikwerte überprüfen

MicroProfile Metrics stellt einen /metrics-Endpunkt bereit, auf den Sie mit HTTP zugreifen können. Nachdem der Liberty-Server mit der ordnungsgemäßen Konfiguration gestartet wurde, können Sie Ihre Metriken in einem beliebigen Browser anzeigen.

Das folgende Beispiel für ein URL-Format stellt eine Adresse dar, an der Sie Ihre Metriken anzeigen können:
https://localhost:9443/metrics

In der Regel können Operationsteams Tools zur Überwachung und Aufzeichnung der Metrikwerte im Zeitverlauf konfigurieren.

Ihren Anwendungen Metriken hinzufügen

Wenn Sie Ihren Anwendungen Metriken hinzufügen möchten, müssen Sie Metriken mit der Anwendungsregistry erstellen und registrieren, damit sie im System bekannt sind und am /metrics-Endpunkt berichtet werden können. Sie können Metriken auf folgende Art und Weise erstellen und registrieren:
  • Sie verwenden die MetricRegistry direkt. Wenn Sie diese Methode verwenden, werden die Metriken explizit von Ihrem Anwendungscode erstellt und registriert.
  • Sie verwenden CDI, um Metriken einzufügen. Wenn Sie diese Methode verwenden, werden Metriken implizit mit CDI erstellt und bei der MetricRegistry für Anwendungen registriert.
  • Sie verwenden Metrikannotationen. Wenn Sie diese Methode verwenden, werden Metriken implizit mit CDI erstellt und bei der MetricRegistry für Anwendungen registriert.

MetricRegistry direkt verwalten

In der MetricRegistry werden alle Metriken mit den zugehörigen Metadaten gespeichert. Metriken und Metadaten können mithilfe der bereitgestellten Methoden registriert und abgerufen werden. Standardmäßig werden alle anwendungsbezogenen Metriken einer MetricRegistry hinzugefügt, deren Geltungsbereich eine einzigen Anwendung ist.

Die MetricRegistry für die Anwendung kann mithilfe der CDI-Injektion abgerufen werden.
@Inject
MetricRegistry registry;

Metriken registrieren

Die MetricRegistry-Klasse enthält Methoden, die Zähler, Messungen, Histogramme und Zeitgeber abrufen und erstellen können.

Die Registry überprüft, ob eine Metrik mit demselben Namen vorhanden ist. Wenn die Metrik vorhanden ist, wird sie zurückgegeben.
Metadata counterMetadata = new Metadata(…);
…
 
// Metrik mit Metadata.getName() erstellen oder abrufen
Counter counterMetric = registry.counter(counterMetadata);
Timer timerMetric =  registry.timer(timerMetadata);
Histogram histogramMetric =  registry.histogram(histogramMetadata);
Meter meterMetric =  registry.meter(meterMetadata);
 
// Messwertgeberdaten mit Metadata.getName() registrieren
registry.register("gaugeMetric", gaugeMetric, gaugeMetadata);

Metriken mit Metadaten beschreiben

Metadaten sind Datensätze, die Angaben zu Metriken beschreiben und zusammenfassen und mit deren Hilfe die Suche nach und die Arbeit mit Metriken unterschiedlicher Typen vereinfacht werden kann. Metadaten sind differenziert genug, um Informationen auf Attributebene zu definieren.

Metrikmetadaten bestehen aus den folgenden Attributen:

Mithilfe von Metadaten können Sie den Zweck einer Metrik genauer beschreiben. Diese Informationen sind hilfreich, wenn Sie auf die Metriken über die REST-API zugreifen.
Einheit
Ein fester Satz von Zeichenfolgeeinheiten.
Typ
Gauge, counter, meter, histogram oder timer.
Beschreibung
Eine lesbare Beschreibung der Metrik.
Anzeigename
Ein lesbarer Name der Metrik für die Anzeige, wenn der Metrikname kein lesbarer Name ist, z. B. wenn der Metrikname eine UUID ist.
Tags
Eine Liste von Schlüssel- und Wertpaaren (Schlüssel=Wert), die durch Kommas voneinander getrennt sind.
[18.0.0.1 und höher]Reusable (Wiederverwendbar)
[18.0.0.1 und höher]In MicroProfile Metrics Version 1.1 und höher ist "reusable" ein boolescher Wert, um anzugeben, dass der Metrikname wiederverwendbar ist. Zum Beispiel, wenn Sie eine einzelnen Metrik bei der Annotation mehrerer Methoden wiederverwenden möchten.
Globale oder anwendungsweite Tags, die durch Übergeben einer durch Kommas getrennten Liste von Name=Wert-Paaren über die Umgebungsvariable MP_METRICS_TAGS festgelegt werden.
export MP_METRICS_TAGS=app=shop,node=2932

[18.0.0.1 und höher]Sie können auch MicroProfile Config für die Konfiguration von MP_METRICS_TAGS verwenden. Weitere Informationen zur Konfiguration von MP_METRICS_TAGS finden Sie unter Gültige Positionen für Konfigurationswerte in der Liberty-Laufzeitumgebung.

Metadaten können sich nicht während der Laufzeit eines Prozesses ändern. Es ist beispielsweise nicht möglich, Einheiten bei einer Abfrage in Sekunden und bei einer anderen Abfrage in Stunden zurückzugeben.
Anmerkung: Wenn kein Anzeigenamen angegeben wird, ist der Standardname der Metrik der Name des Objekts.

Counters

Counters sind eine Metrik, die verwendet wird, um eine inkrementelle oder eine dekrementelle Zählung zu erhalten. Der Anfangswert des Counters ist auf 0 gesetzt und kann mit inc() bzw. inc(long n) erhöht und mit dec() bzw. dec(long n) verringert werden.

Sie können einen Counter zum Zählen der Gesamtzahl von Anforderungen, die empfangen werden, oder zum Zählen der Gesamtzahl gleichzeitig aktiver HTTP-Sitzungen verwenden.

Im folgenden Beispiel wird ein Counter verwendet, um die Anzahl der Treffer der /donations-REST-Endpunkte zu messen.
Metadata statsHitsCounterMetadata = new Metadata(
    "statsHits",                                // Name
    "Stats Hits",                               // Anzeigename
    "Number of hits on the /stats endpoint",    // Beschreibung
    MetricType.COUNTER,                         // Typ
    MetricUnits.NONE);                          // Einheiten
 
Counter statsHitsCounter = registry.counter(statsHitsCounterMetadata);
@GET
@Path("/donations")
public String getTotalDonations() {
    statsHitsCounter.inc();
    return "$" + donationManager.getTotalDonations();
}
Das folgende Ergebnis wird über die REST-Endpunkte generiert.
curl -k -u user:password https://localhost:9443/metrics/application/statsHits
# TYPE application:stats_hits counter
# HELP application:stats_hits Number of hits on the /stats endpoint
application:stats_hits 213

curl -k -u user:password -H “Accept: application/json” https://localhost:9443/metrics/application/statsHits
{"statsHits":213}

Gauges

Gauges (Messwertgeber) stellen Metriken dar, für die Stichproben zum Abrufen der zugehörigen Werte genommen werden.

Ein Gauge ist eine Schnittstelle, die vom Entwickler implementiert werden muss. Da die Implementierung eines Gauge nicht definiert ist, muss er manuell bei der MetricRegistry mithilfe der MetricRegistry-Methode .register() registriert werden. Stellen Sie sicher, dass die Methode register() nur ein einziges Mal pro Metrik verwendet wird. Sie können nicht zwei Metriken mit demselben Namen registrieren. Sie verwenden einen Gauge zum Messen der CPU-Temperatur oder zum Messen der Plattenbelegung.

Das folgende Beispiel veranschaulicht einen Gauge, der verwendet wird, um den aktuellen Fortschritt in Prozent bis zum Erreichen eines Ziels anzugeben.
Gauge<Double> progressGauge = new Gauge<Double>() {
    public Double getValue() {
        return (double) getTotalDonations()
             / (double) getGoal() * 100.0;
    }
};
 
// Gauge (Messwertgeber)
Metadata progressMetadata = new Metadata(
    "progress",                                     // Name
    "Donation Progress",                            // Anzeigename
    "The percentage of the goal achieved so far",   // Beschreibung
    MetricType.GAUGE,                               // Typ
    MetricUnits.PERCENT);                           // Einheiten
 
registry.register(progressMetadata.getName(), progressGauge, progressMetadata);
Das folgende Ergebnis wird über die REST-Endpunkte generiert.
curl -k -u user:password https://localhost:9443/metrics/application/progress
# TYPE application:progress_percent gauge
# HELP application:progress_percent The percentage of the goal achieved so far
application:progress_percent 4.472

curl -k -u user:password -H "Accept: application/json" https://localhost:9443/metrics/application/progress
{"progress":4.472}

Meters

Meters (Zähler) werden zur Überwachung von Durchsatz verwendet.

Wenn Sie einen Meter verwenden möchten, müssen Sie die Methode meter.mark() aufrufen, um ein Ereignis zu markieren. Bei mehreren Ereignissen können Sie auch die Methode mark(long n) verwenden, um mehrere Vorkommen von Ereignissen zur selben Zeit zu markieren. Ein Meter enthält die folgenden Informationen:
  • Durchschnittlicher Durchsatz.
  • Eine/fünf/fünfzehn Minuten exponentiell gewichteter gleitender Durchschnittsdurchsatz.
  • Die Anzahl der Messungen.

Sie können einen Meter (Zähler) verwenden, um die Geschwindigkeit, mit der Transaktionen von einer Anwendung verarbeitet werden, zu berechnen.

Im folgenden Beispiel wird ein Meter verwendet, um diese Geschwindigkeit zu ermitteln. Hierzu wird die Methode getProcess() aufgerufen. Eine hohe Geschwindigkeit bedeutet möglicherweise, dass das Ergebnis im Cache gespeichert werden muss oder eine Begrenzung für die Geschwindigkeit festgelegt werden muss.
Metadata getProgressMeterMetadata = new Metadata(
    "getProgressMeter",                             // Name
    "getProgress Call Rate",                        // Anzeigename
    "The rate of getProgress calls",                // Beschreibung
    MetricType.METERED,                             // Typ
    MetricUnits.SECONDS);                           // Einheiten
Meter getProgressMeter = registry.meter(getProgressMeterMetadata);
public Double getProgress() {
    getProgressMeter.mark();
    return (double) getTotalDonations()/(double) getGoal() * 100.0;
}
Das folgende Ergebnis wird über die REST-Endpunkte generiert.
curl -k -u user:password https://localhost:9443/metrics/application/getProgressMeter1
# TYPE application:get_progress_meter_total counter
# HELP application:get_progress_meter_total The rate of getProgress calls
application:get_progress_meter_total 78
# TYPE application:get_progress_meter_rate_per_second gauge
application:get_progress_meter_rate_per_second 0.6584919803150174
# TYPE application:get_progress_meter_one_min_rate_per_second gauge
application:get_progress_meter_one_min_rate_per_second 0.5851884005757912
# TYPE application:get_progress_meter_five_min_rate_per_second gauge
application:get_progress_meter_five_min_rate_per_second 1.4218610926179416
# TYPE application:get_progress_meter_fifteen_min_rate_per_second gauge
application:get_progress_meter_fifteen_min_rate_per_second 1.6627979138032118

curl -k -u user:password -H "Accept: application/json" https://localhost:9443/metrics/application/getProgressMeter
	{
   "getProgressMeter": {
       "count": 78,
       "fifteenMinRate": 1.6627979138032118,
       "fiveMinRate": 1.4218610926179416,
       "meanRate": 0.6584919803150174,
       "oneMinRate": 0.5851884005757912
   }
}

Histograms

Histogramme (Histogram) werden verwendet, um die Verteilung von Werten zu speichern.

Wenn Sie einen Wert im Histogramm aufzeichnen möchten, müssen Sie die Methode histogram.update(long value) mit dem Wert aufrufen, den Sie aufzeichnen möchten. Der aktuelle Status (bzw. der Screenshot) des Histogramms kann mit der Methode getSnapshot() abgerufen werden. Histogramme MicroProfile Metrics unterstützen nur ganze Zahlen oder lange Werte.

Ein Histogramm enthält die folgenden Informationen:
  • Höchstwert/Mindestwert/Durchschnittswert
  • Der Wert für das 50.-, 75.-, 95.-, 98.-, 99.-, 99.9.-Perzentil.
  • Die Anzahl der Werte.

Beispiele für Histogramme sind z. B. die Verteilung von Nutzdatengrößen, die abgerufen werden, oder Daten für eine Onboarding-Umfrage, die die Verteilung von Haushaltseinkommen erfasst.

Das folgende Beispiel veranschaulicht ein Histogramm, das zum Speichern des Spendenergebnisses verwendet werden soll. Ein solches Beispiel gibt dem Administrator einen Überblick darüber, wie sich die Spendenbeträge verteilen.
Metadata donationDistributionMetadata = new Metadata(
    "donationDistribution",                      // Name
    "Donation Distribution",                     // Anzeigename
    "The distribution of the donation amounts ", // Beschreibung
    MetricType.HISTOGRAM,                        // Typ
    “dollars”);                                  // Einheiten
Histogram donationDistribution = registry.histogram(donationDistributionMetadata);
public void addDonation(Long amount) {
    totalDonations += amount;
    donations.add(amount);
    donationDistribution.update(amount);
}
Das folgende Ergebnis wird über die REST-Endpunkte generiert:
curl -k -u user:password https://localhost:9443/metrics/application/com.example.samples.donationapp.DonationManager.donationDistribution

# TYPE application:com_example_samples_donationapp_donation_manager_donation_distribution_mean_dollars gauge
application:com_example_samples_donationapp_donation_manager_donation_distribution_mean_dollars 19.300015535407777
# TYPE application:com_example_samples_donationapp_donation_manager_donation_distribution_max_dollars gauge
application:com_example_samples_donationapp_donation_manager_donation_distribution_max_dollars 102.0
# TYPE application:com_example_samples_donationapp_donation_manager_donation_distribution_min_dollars gauge
application:com_example_samples_donationapp_donation_manager_donation_distribution_min_dollars 3.0
# TYPE application:com_example_samples_donationapp_donation_manager_donation_distribution_stddev_dollars gauge
application:com_example_samples_donationapp_donation_manager_donation_distribution_stddev_dollars 26.35464238355834
# TYPE application:com_example_samples_donationapp_donation_manager_donation_distribution_dollars summary
# HELP application:com_example_samples_donationapp_donation_manager_donation_distribution_dollars The distribution of the donation amounts
application:com_example_samples_donationapp_donation_manager_donation_distribution_dollars_count 203
application:com_example_samples_donationapp_donation_manager_donation_distribution_dollars{quantile="0.5"} 5.0
application:com_example_samples_donationapp_donation_manager_donation_distribution_dollars{quantile="0.75"} 24.0
application:com_example_samples_donationapp_donation_manager_donation_distribution_dollars{quantile="0.95"} 83.0
application:com_example_samples_donationapp_donation_manager_donation_distribution_dollars{quantile="0.98"} 93.0
application:com_example_samples_donationapp_donation_manager_donation_distribution_dollars{quantile="0.99"} 101.0
application:com_example_samples_donationapp_donation_manager_donation_distribution_dollars{quantile="0.999"} 102.0

curl -k -u user:password -H "Accept: application/json" https://localhost:9443/metrics/application/com.example.samples.donationapp.DonationManager.donationDistribution
	{
    "com.example.samples.donationapp.DonationManager.donationDistribution": {
        "count": 203,
        "max": 102,
        "mean": 19.300015535407777,
        "min": 3,
        "p50": 5.0,
        "p75": 24.0,
        "p95": 83.0,
        "p98": 93.0,
        "p99": 101.0,
        "p999": 102.0,
        "stddev": 26.35464238355834
    }
}

Timer

Timer (Zeitgeber) werden verwendet, um Timing-Zeiträume (in Nanosekunden) zu aggregieren, und Statistikdaten zur Dauer und zum Durchsatz bereitzustellen.

Wenn Sie die Zeit für einen Teil des Codes erfassen möchten, können Sie die Methode timer.time() aufrufen, die ein Objekt timer.context zurückgibt. Dieser Kontext wird verwendet, um den Zeitgeber durch Aufrufen der Methode context.close() zu stoppen. Die Informationen, die vom Zeitgeber abgerufen werden, sind eine Kombination aus Zähler und Histogramm der erfassten Zeitdauer.

Ein Zeitgeber enthält die folgenden Informationen:
  • Maximale Zeit/minimale Zeit/Durchschnittszeit.
  • Den Zeitwert für das 50.-, 75.-, 95.-, 98.-, 99.-, 99.9.-Perzentil.
  • Durchschnittlicher Durchsatz.
  • Eine/fünf/fünfzehn Minuten exponentiell gewichteter gleitender Durchschnittsdurchsatz.
  • Die Anzahl der zeitlich erfassten Ereignisse.

Zu den Beispielen für die Verwendungsmöglichkeiten eines Zeitgebers gehört die Messung von Antwortzeiten und die Messung von Verarbeitungszeiten für komplexe Logik.

Das folgende Beispiel veranschaulicht einen Zeitgeber, der verwendet wird, um die Laufzeit bei einer linearen Suche über die Spenden zu messen:
Metadata topDonationCalcTimerMetadata = new Metadata(
    "topDonationCalcTimer",                             // Name
    "Top Donation Calculation Time",                    // Anzeigename
    "Processing time to find the top donation",         // Beschreibung
    MetricType.TIMER,                                   // Typ
    MetricUnits.NANOSECONDS);                           // Einheiten
Timer topDonationCalcTimer = registry.timer(topDonationCalcTimerMetadata);
public Long getTopDonation() {
 
    // Hier mit Timing beginnen
    Timer.Context context = topDonationCalcTimer.time();
 
    Long max = 0L;
    for (Long amount : donationManager.getDonationsList()) {
        max = amount > max ? amount : max;
    }
 
    // Timing stoppen
    context.close();
    return max;
}
Das folgende Ergebnis wird über die REST-Endpunkte generiert:
curl -k -u user:password https://localhost:9443/metrics/application/topDonationCalcTimer

# TYPE application:top_donation_calc_timer_rate_per_second gauge
application:top_donation_calc_timer_rate_per_second 0.19107302754898328
# TYPE application:top_donation_calc_timer_one_min_rate_per_second gauge
application:top_donation_calc_timer_one_min_rate_per_second 0.013233974568205872
# TYPE application:top_donation_calc_timer_five_min_rate_per_second gauge
application:top_donation_calc_timer_five_min_rate_per_second 0.4845914744130395
# TYPE application:top_donation_calc_timer_fifteen_min_rate_per_second gauge
application:top_donation_calc_timer_fifteen_min_rate_per_second 0.8866728789348088
# TYPE application:top_donation_calc_timer_mean_seconds gauge
application:top_donation_calc_timer_mean_seconds 9.37780684853573E-5
# TYPE application:top_donation_calc_timer_max_seconds gauge
application:top_donation_calc_timer_max_seconds 1.97197E-4
# TYPE application:top_donation_calc_timer_min_seconds gauge
application:top_donation_calc_timer_min_seconds 4.9630000000000004E-5
# TYPE application:top_donation_calc_timer_stddev_seconds gauge
application:top_donation_calc_timer_stddev_seconds 3.082659934664267E-5
# TYPE application:top_donation_calc_timer_seconds summary
# HELP application:top_donation_calc_timer_seconds Processing time to find the top donation
application:top_donation_calc_timer_seconds_count 63
application:top_donation_calc_timer_seconds{quantile="0.5"} 8.6069E-5
application:top_donation_calc_timer_seconds{quantile="0.75"} 1.0372E-4
application:top_donation_calc_timer_seconds{quantile="0.95"} 1.53694E-4
application:top_donation_calc_timer_seconds{quantile="0.98"} 1.96615E-4
application:top_donation_calc_timer_seconds{quantile="0.99"} 1.97197E-4
application:top_donation_calc_timer_seconds{quantile="0.999"} 1.97197E-4

curl -k -u user:password -H "Accept: application/json" https://localhost:9443/metrics/application/topDonationCalcTimer
{
   "topDonationCalcTimer": {
       "count": 63,
       "fifteenMinRate": 0.8866728789348088,
       "fiveMinRate": 0.4845914744130395,
       "max": 197197,
       "mean": 93778.06848535729,
       "meanRate": 0.19107302754898328,
       "min": 49630,
       "oneMinRate": 0.013233974568205872,
       "p50": 86069.0,
       "p75": 103720.0,
       "p95": 153694.0,
       "p98": 196615.0,
       "p99": 197197.0,
       "p999": 197197.0,
       "stddev": 30826.599346642666
   }
}

Metriken mit CDI einfügen

CDI-Injektion bietet eine einfache Möglichkeit, Metriken zu erstellen und bei der MetricRegistry zu registrieren. Statt ein Metadatenobjekt zu erstellen, können die Parameter der Annotation @Metric verwendet werden, um Metrikmetadaten zuzuordnen.
  • @Metric: Eine Annotation, die die Metrik beschreibt, die eingefügt wird. Diese Annotation kann für die Felder des Typs Meter, Timer, Counter und Histogram verwendet werden.
  • @Metric-Parameter: name, displayname, units, tags, description, absolute.
    Die Parameter für die Annotation @Metric gleichen dem entsprechenden Metadatenfeld mit Ausnahme der folgenden Unterschiede.
    • tags: Ein Array von key=value-Tagzeichenfolgen.
    • absolute: Setzen Sie bei der Angabe von true den Metriknamen auf den exakten Namen, der über den Parameter name angegeben ist. Verwenden Sie bei der Angabe von false den vollständig qualifizierten Namen, indem Sie der Paketklasse und dem Namen ein Präfix hinzufügen.
    @Inject
    @Metric(name="statsHits", displayName="Stats Hits", description="Number of hits on the /stats endpoint", absolute=true)
    Counter statsHitsCounter;
    Der Server erstellt und registriert einen Zähler in der MetricRegistry und stellt ihn der Anwendung zur Verfügung. Das Zählerbeispiel ist äquivalent zum statsHitsCounter-Beispiel. Die Angabe absolute=true bedeutet, dass der angegebene Name wie angegeben verwendet wird. Der Parameter units wird nicht verwendet und nimmt standardmäßig den Wert MetricUnits.NONE an.
    @Inject
    @Metric(name= "topDonationCalcTimer", unit = MetricUnits.NANOSECONDS, description="Processing time to find the top donation")
    Timer topDonationCalcTimer;
    
    @Inject
    @Metric(absolute = true, tags=["appName=DonationApp"])
    Counter counted;
Die zwei Beispiele veranschaulichen, wie eine Metrik mit unterschiedlichen Parametern eingefügt wird.

Annotationen für Metriken

MicroProfile Metrics enthält eine Reihe von Interceptors für die Verarbeitung der Annotationen @Counted, @Timed, @Metered und @Gauge.

Analog zur Annotation @Metric können Sie die Metadatenparameter für jede dieser Annotation festlegen, indem Sie die Annotation direkt verwenden. Jede Annotation kann auf Klassen, Methoden oder Typen angewendet werden. Wenn der Name nicht angegeben wird, wird der Name aus dem Methoden-/Konstruktornamen abgerufen.
@Counted
Eine Annotation zum Kennzeichnen einer Methode, eines Konstruktors oder Typs als Counter (Zähler). Zusammen mit den Metadatenfeldern hat ein Counter auch ein zusätzliches Feld "monotonic". Wenn der Wert für monotonic auf false gesetzt wird, wird der Counter erhöht, wenn die mit Annotationen versehene Methode aufgerufen wird und verringert, wenn die mit Annotationen versehene Methode zurückgegeben wird, sodass aktuelle Aufrufe der mit Annotationen versehene Methode gezählt werden. Wenn der Wert für monotonic auf true gesetzt wird, wird der Counter monoton erhöht, sodass die Gesamtzahl der Aufrufe der mit Annotationen versehenen Methode gezählt werden.
Anmerkung: Standardmäßig ist monotonic auf false gesetzt.
@GET
@Path("/no")
@Counted(name="no", displayName="No donation count", description="Number of people that declined to donate.", monotonic=true)
public String noDonation() {
    return "Maybe next time!";
}
@Timed
Eine Annotation zum Kennzeichnen eines Konstruktors oder einer Methode eines Objekts, das als zeitgesteuert annotiert wurde. Die Zeitgebermetrik überwacht, wie oft das annotierte Objekt gestartet wurde, und wie lange es gedauert hat, bis der Aufruf ausgeführt wurde.
@POST
@Path("/creditcard")
@Timed(
    name="donateAmountViaCreditCard.timer",
    displayName="Donations Via Credit Cards",
    description = "Donations that were made using a credit card")
public String donateAmountViaCreditCard(@FormParam("amount") Long amount, @FormParam("card") String card) {
 
    if (processCard(card, amount))
        return "Thanks for donating!";
 
    return "Sorry, please try again.";
 
}
@Metered
Eine Annotation zum Kennzeichnen eines Konstruktors oder einer Methode als Teil einer Messung. Bei der Messung wird die Anzahl der Aufrufe des Konstruktors oder der Methode erfasst und überwacht, wie oft die Aufrufe erfolgen.
@Metered(displayName="Rate of donations", description="Rate of incoming donations (the instances not the amount)")
public void addDonation(Long amount) {
    totalDonations += amount;
    donations.add(amount);
    donationDistribution.update(amount);
}
@Gauge
Eine Annotation zum Kennzeichnen einer Methode als Gauge (Messwertgeber).
@Gauge(
    name="donations",
    displayName="Total Donations",
    description="Total amount of money raised for charity!",
    unit = "dollars",
    absolute=true)
public Long getTotalDonations(){
    return totalDonations;
}
[18.0.0.1 und höher]
Metriken wiederverwenden
Wenn Sie MicroProfile Metrics Version 1.1 und höher verwenden, können Sie Metriken wiederverwenden. Die Annotationen @Counted, @Metered und @Timed haben ein Flag, um anzugeben, dass die Metrik von anderen Annotationen wiederverwendet werden kann. Ihre Anwendung hat zum Beispiel möglicherweise mehrere Endpunkte für unterschiedliche Zahlungsmethoden. Wenn Sie die Anzahl der Zahlungen für alle Zahlungsmethoden verfolgen möchten, können Sie denselben Metriknamen verwenden, indem Sie die Einstellung reusable=true festlegen. Sehen Sie sich hierzu zur Veranschaulichung die Verwendung im folgenden Beispiel an.
@POST
@Path("/creditcard")
@Counted(
    name="donation.counter",
    displayName="Number of donations",
    description = "Donations that were made using any method",
    monotonic=true,
    reusable=true)
public String donateAmountViaCreditCard(@FormParam("amount") Long amount, @FormParam("card") String card) {
 
    if (processCard(card, amount))
        return "Thanks for donating!";
 
    return "Sorry, please try again.";
 
}
@POST
@Path("/debitcard")
@Counted(
    name="donations.counter",
    displayName="Number of donations",
    description = "Donations that were made using any method",
    monotonic=true,
    reusable=true)
public String donateAmountViaDebitCard(@FormParam("amount") Long amount, @FormParam("card") String card) {
 
    if (processDebitCard(card, amount))
        return "Thanks for donating!";
 
    return "Sorry, please try again.";
 
}

CDI-Tipps

Das Feature mpMetrics-1.0 basiert auf CDI. Die CDI-Injektion wird immer dann verwendet, wenn Sie eine MetricRegistry oder einen der Metriktypen in ein Feld einfügen möchten. CDI-Interceptors werden verwendet, um die Metriken @Timed, @Counted, @Metered und @Gauge auf Typen, Konstruktoren oder Methoden anzuwenden.

Explizite Bean-Archive verwenden
Stellen Sie für einen effizienten Anwendungsstart sicher, dass Ihre Bean-Archive eine Datei beans.xml enthalten. Wenn Sie eine Webanwendung erstellen, muss sich Ihre beans.xml-Datei im Verzeichnis WEB-INF befinden. Wenn Sie ein EJB-Modul oder eine JAR-Datei erstellen, muss sich Ihre beans.xml-Datei im Verzeichnis META-INF befinden. Wenn Sie die CDI-Funktion für implizite Bean-Archive in Ihren Anwendungen vermeiden, können Sie Ihren Liberty-Server so optimieren, dass das Scannen nach Bean-Archiven beim Start vermieden wird.
Einschränkungen für die Interceptors @Timed, @Counted, @Metered, @Gauge
CDI benötigt Java-Interceptors, die in Liberty als Interceptors implementiert sind, für Metrikannotationen. Die Annotationen @Timed, @Counted, @Metered und @Gauge werden mithilfe von Interceptors implementiert. Interceptors müssen einen Proxy starten können, der mit dem Codepfad gestartet werden kann, bevor Konstruktoren oder Methoden mit Interceptorannotationen aufgerufen werden können. Der Interceptor-Code befindet sich an der Position, an der Metriken aktualisiert werden. Es gibt Einschränkungen im Hinblick darauf, welcher Codetyp weitergleitet und wo Interceptorannotationen verwendet werden können. Nur MBeans gemäß der Definition von CDI können weitergeleitet und mit Interceptors verwendet werden. Proxys werden als Unterklasse der Bean implementiert, die sie weiterleiten. Wenn Sie sicherstellen möchten, dass eine Klasse weitergeleitet werden kann, darf die Klasse nicht als final markiert sein und muss ein nicht privater Konstruktor ohne Argumente sein.
Einschränkungen für die Injektion
Wenn Sie mit @Inject Typen, wie z. B. eine MetricRegistry, in eine Klasse einfügen möchten, muss diese Klasse von CDI verwaltet werden. Das folgende JAX-RS-Beispiel veranschaulicht, wie die someclass.setMetricsRegistry automatisch von CDI aufgerufen wird.
@Path("/myPath")
public class MyService {
    // Lebenszyklus von Someclass wird von CDI verwaltet
    @Inject
    Someclass someclass;
 
    ...
}
 
public class Someclass {
    // Someclass wurde eingefügt und wird von CDI verwaltet und kann daher @Inject verwenden
    // setMetricRegistry wird vor dem ersten Methodenaufruf für Someclass aufgerufen
    @Inject
    public void setMetricRegistry(final MetricRegistry metrics) {
    }
}
Die Klasse wird im folgenden Beispiel nicht aufgerufen:
@Path("/myPath")
public class MyService {
    // CDI verwaltet nicht den Lebenszyklus von Someclass
    Someclass someclass = new Someclass();
 
    ...
}
 
public class Someclass {
    // Diese Methode wird nie von CDI aufgerufen, da Someclass nicht mit CDI erstellt wurde
    @Inject
    public void setMetricRegistry(MetricRegistry metrics) {
    }
}

Symbol das den Typ des Artikels anzeigt. Konzeptartikel

Dateiname: cwlp_mp_metrics_api.html