Introduksjon til Dropwizard-beregninger
1. Introduksjon
Metrics er et Java-bibliotek som gir måleinstrumenter for Java-applikasjoner.
Den har flere moduler, og i denne artikkelen vil vi utdype metrics-core module, metrics-healthchecks module, metrics-servlets module og metrics-servlet module, og skissere resten, for din referanse.
2. Modul beregninger-kjerne
2.1. Maven avhengigheter
For å bruke beregninger-kjerne modul, er det bare en avhengighet som kreves som må legges til pom.xml fil:
io.dropwizard.metrics metrics-core 3.1.2 Og du kan finne den nyeste versjonen her.
2.2. MetricRegistry
Enkelt sagt, vi bruker MetricRegistry klasse for å registrere en eller flere beregninger.
Vi kan bruke ett beregningsregister for alle beregningene våre, men hvis vi vil bruke forskjellige rapporteringsmetoder for forskjellige beregninger, kan vi også dele beregningene våre i grupper og bruke forskjellige beregningsregistre for hver gruppe.
La oss lage en MetricRegistry nå:
MetricRegistry metricRegistry = ny MetricRegistry ();Og så kan vi registrere noen beregninger med dette MetricRegistry:
Meter meter1 = ny Meter (); metricRegistry.register ("meter1", meter1); Meter meter2 = metricRegistry.meter ("meter2"); Det er to grunnleggende måter å opprette en ny beregning på: sette en i gang selv eller få en fra beregningsregisteret. Som du kan se, brukte vi begge i eksemplet ovenfor, vi instantierer Måler objekt “meter1” og vi får en til Måler objektet "meter2" som er opprettet av metricRegistry.
I et beregningsregister har hver beregning et unikt navn, ettersom vi brukte "meter1" og "meter2" som beregningsnavn ovenfor. MetricRegistry gir også et sett med statiske hjelpermetoder som hjelper oss med å lage riktige beregningsnavn:
String name1 = MetricRegistry.name (Filter.class, "request", "count"); String name2 = MetricRegistry.name ("CustomFilter", "response", "count"); Hvis vi trenger å administrere et sett metriske registre, kan vi bruke det SharedMetricRegistries klasse, som er en singleton og trådsikker. Vi kan legge til et beregningsregister i det, hente dette beregningsregisteret fra det og fjerne det:
SharedMetricRegistries.add ("standard", metricRegistry); MetricRegistry retrievedMetricRegistry = SharedMetricRegistries.getOrCreate ("standard"); SharedMetricRegistries.remove ("standard"); 3. Metrics Concepts
Metrics-core-modulen inneholder flere vanlige metrityper: Måler, Måler, Disk, Histogram og Timer, og Journalist for å vise verdiene for beregninger.
3.1. Måler
EN Måler måler antall hendelser teller og rangerer:
Meter meter = ny Meter (); lang initCount = meter.getCount (); assertThat (initCount, equalTo (0L)); meter.mark (); assertThat (meter.getCount (), equalTo (1L)); meter.mark (20); assertThat (meter.getCount (), equalTo (21L)); dobbelt gjennomsnittRate = meter.getMeanRate (); dobbel oneMinRate = meter.getOneMinuteRate (); dobbel fiveMinRate = meter.getFiveMinuteRate (); dobbel fifteenMinRate = meter.getFifteenMinuteRate (); De getCount () metoden returnerer antall hendelser, og merke() metoden legger til 1 eller n til antall hendelser. De Måler objektet gir fire priser som representerer gjennomsnittspriser for helheten Måler levetid, for det siste ett minutt, for de siste fem minuttene og for det siste kvartalet, henholdsvis.
3.2. Måler
Måler er et grensesnitt som bare brukes til å returnere en bestemt verdi. Metrics-core-modulen gir flere implementeringer av den: RatioGauge, CachedGauge, DerivativeGauge og JmxAttributeGauge.
RatioGauge er en abstrakt klasse og den måler forholdet mellom en verdi og en annen.
La oss se hvordan du bruker den. Først implementerer vi en klasse AttendanceRatioGauge:
offentlig klasse AttendanceRatioGauge utvider RatioGauge {private int attendanceCount; privat int kursCount; @ Override-beskyttet forhold getRatio () {return Ratio.of (attendanceCount, courseCount); } // standardkonstruktører} Og så tester vi det:
RatioGauge ratioGauge = new AttendanceRatioGauge (15, 20); assertThat (ratioGauge.getValue (), equalTo (0,75)); CachedGauge er en annen abstrakt klasse som kan cache verdi, derfor er det ganske nyttig når verdiene er dyre å beregne. For å bruke den, må vi implementere en klasse ActiveUsersGauge:
offentlig klasse ActiveUsersGauge utvider CachedGauge {@Override-beskyttet liste loadValue () {return getActiveUserCount (); } privat liste getActiveUserCount () {Listresultat = ny ArrayList (); result.add (12L); returresultat; } // standardkonstruktører}
Så tester vi det for å se om det fungerer som forventet:
Måler activeUsersGauge = ny ActiveUsersGauge (15, TimeUnit.MINUTES); Liste forventet = ny ArrayList (); forventet. legg til (12L); assertThat (activeUsersGauge.getValue (), equalTo (forventet));
Vi setter hurtigbufferens utløpstid til 15 minutter når vi starter ActiveUsersGauge.
DerivativeGauge er også en abstrakt klasse, og den lar deg utlede en verdi fra andre Måler som sin verdi.
La oss se på et eksempel:
offentlig klasse ActiveUserCountGauge utvider DerivativeGauge {@ Override-beskyttet heltalstransformasjon (listeverdi) {returverdi.størrelse (); } // standardkonstruktører} Dette Måler henter verdien fra en ActiveUsersGauge, så vi forventer at det skal være verdien fra baselistens størrelse:
Måler activeUsersGauge = ny ActiveUsersGauge (15, TimeUnit.MINUTES); Gauge activeUserCountGauge = ny ActiveUserCountGauge (activeUsersGauge); assertThat (activeUserCountGauge.getValue (), equalTo (1));
JmxAttributeGauge brukes når vi trenger tilgang til andre bibliotekers beregninger eksponert via JMX.
3.3. Disk
De Disk brukes til å registrere inkrementasjoner og dekrementeringer:
Counter counter = new Counter (); lang initCount = counter.getCount (); assertThat (initCount, equalTo (0L)); counter.inc (); assertThat (counter.getCount (), equalTo (1L)); counter.inc (11); assertThat (counter.getCount (), equalTo (12L)); counter.dec (); assertThat (counter.getCount (), equalTo (11L)); counter.dec (6); assertThat (counter.getCount (), equalTo (5L));3.4. Histogram
Histogram brukes til å holde oversikt over en strøm av Lang verdier og den analyserer deres statistiske egenskaper som maks, min, gjennomsnitt, median, standardavvik, 75. persentil og så videre:
Histogram histogram = nytt Histogram (nytt UniformReservoir ()); histogram. oppdatering (5); lang count1 = histogram.getCount (); assertThat (count1, equalTo (1L)); Øyeblikksbilde øyeblikksbilde1 = histogram.getSnapshot (); assertThat (snapshot1.getValues (). length, equalTo (1)); assertThat (snapshot1.getValues () [0], equalTo (5L)); histogram. oppdatering (20); lang count2 = histogram.getCount (); assertThat (count2, equalTo (2L)); Øyeblikksbilde øyeblikksbilde2 = histogram.getSnapshot (); assertThat (snapshot2.getValues (). length, equalTo (2)); assertThat (snapshot2.getValues () [1], equalTo (20L)); assertThat (snapshot2.getMax (), equalTo (20L)); assertThat (snapshot2.getMean (), equalTo (12.5)); assertEquals (10.6, snapshot2.getStdDev (), 0.1); assertThat (snapshot2.get75thPercentile (), equalTo (20.0)); assertThat (snapshot2.get999thPercentile (), equalTo (20.0)); Histogram sampler dataene ved å bruke reservoarprøvetaking, og når vi instantierer a Histogram objekt, må vi sette reservoaret eksplisitt.
Reservoar er et grensesnitt og metrics-core gir fire implementeringer av dem: Eksponentielt forfallReservoir, UniformReservoir, SlidingTimeWindowReservoir, SlidingWindowReservoir.
I delen ovenfor nevnte vi at en beregning også kan opprettes av Metrisk register, i tillegg til å bruke en konstruktør. Når vi bruker metricRegistry.histogram (), det returnerer a Histogram eksempel med Eksponentielt forfallReservoir gjennomføring.
3.5. Timer
Timer brukes til å holde oversikt over flere timingvarigheter som er representert av Kontekst objekter, og det gir også deres statistiske data:
Timer timer = new Timer (); Timer.Context context1 = timer.time (); TimeUnit.SECONDS.sleep (5); lang forløpt1 = kontekst1.stop (); assertEquals (5000000000L, forløpt1, 1000000); assertThat (timer.getCount (), equalTo (1L)); assertEquals (0.2, timer.getMeanRate (), 0.1); Timer.Context context2 = timer.time (); TimeUnit.SECONDS.sleep (2); context2.close (); assertThat (timer.getCount (), equalTo (2L)); assertEquals (0,3, timer.getMeanRate (), 0,1); 3.6. Journalist
Når vi trenger å sende målingene våre, kan vi bruke det Journalist. Dette er et grensesnitt, og metrics-core-modulen gir flere implementeringer av den, for eksempel ConsoleReporter, CsvReporter, Slf4jRapporter, JmxReporter og så videre.
Her bruker vi ConsoleReporter som et eksempel:
MetricRegistry metricRegistry = ny MetricRegistry (); Meter meter = metricRegistry.meter ("meter"); meter.mark (); meter.mark (200); Histogram histogram = metriskRegistry.histogram ("histogram"); histogram. oppdatering (12); histogram. oppdatering (17); Counter counter = metricRegistry.counter ("counter"); counter.inc (); counter.dec (); ConsoleReporter reporter = ConsoleReporter.forRegistry (metricRegistry) .build (); reporter.start (5, TimeUnit.MICROSECONDS); reporter.report (); Her er prøveutgangen til ConsoleReporter:
- Histogrammer ------------------------------------------------------- ------------------- histogramantall = 2 min = 12 maks = 17 middel = 14,50 stddev = 2,50 median = 17,00 75% <= 17,00 95% <= 17,00 98% <= 17,00 99% <= 17,00 99,9% <= 17,00 - Meter ---------------------------------- ------------------------------------ meterantall = 201 middelhastighet = 1756,87 hendelser / sekund 1 minutt rate = 0,00 hendelser / sekund 5-minutters hastighet = 0,00 hendelser / sekund 15-minutters hastighet = 0,00 hendelser / sekund 4. Modul beregninger-helsekontroller
Metrics har en utvidelse metrics-healthchecks-modul for å håndtere helsekontroller.
4.1. Maven avhengigheter
For å bruke metrics-healthchecks modulen, må vi legge til denne avhengigheten til pom.xml fil:
io.dropwizard.metrics metrics-healthchecks 3.1.2 Og du kan finne den nyeste versjonen her.
4.2. Bruk
For det første trenger vi flere klasser som har ansvar for spesifikke helsesjekkoperasjoner, og disse klassene må implementeres Helsesjekk.
For eksempel bruker vi DatabaseHealthCheck og UserCenterHealthCheck:
offentlig klasse DatabaseHealthCheck utvider HealthCheck {@Override-beskyttet Resultatkontroll () kaster Unntak {return Result.healthy (); }} offentlig klasse UserCenterHealthCheck utvider HealthCheck {@Override-beskyttet Resultatkontroll () kaster Unntak {return Result.healthy (); }} Da trenger vi en HealthCheckRegistry (som er akkurat som MetricRegistry), og registrer DatabaseHealthCheck og UserCenterHealthCheck med det:
HealthCheckRegistry healthCheckRegistry = ny HealthCheckRegistry (); healthCheckRegistry.register ("db", ny DatabaseHealthCheck ()); healthCheckRegistry.register ("uc", ny UserCenterHealthCheck ()); assertThat (healthCheckRegistry.getNames (). størrelse (), equalTo (2)); Vi kan også avregistrere Helsesjekk:
healthCheckRegistry.unregister ("uc"); assertThat (healthCheckRegistry.getNames (). størrelse (), equalTo (1)); Vi kan kjøre alle Helsesjekk forekomster:
Kartresultater = healthCheckRegistry.runHealthChecks (); for (Map.Entry entry: results.entrySet ()) {assertThat (entry.getValue (). isHealthy (), equalTo (true)); } Endelig kan vi kjøre en spesifikk Helsesjekk forekomst:
healthCheckRegistry.runHealthCheck ("db"); 5. Modul metrics-servlets
Metrics gir oss en håndfull nyttige servlets som lar oss få tilgang til beregningsrelaterte data gjennom HTTP-forespørsler.
5.1. Maven avhengigheter
For å bruke metrics-servlets modulen, må vi legge til denne avhengigheten til pom.xml fil:
io.dropwizard.metrics metrics-servlets 3.1.2 Og du kan finne den nyeste versjonen her.
5.2. HealthCheckServlet Bruk
HealthCheckServlet gir helsekontrollresultater. Først må vi lage en ServletContextListener som avslører vår HealthCheckRegistry:
offentlig klasse MyHealthCheckServletContextListener utvider HealthCheckServlet.ContextListener {public static HealthCheckRegistry HEALTH_CHECK_REGISTRY = new HealthCheckRegistry (); statisk {HEALTH_CHECK_REGISTRY.register ("db", ny DatabaseHealthCheck ()); } @ Override-beskyttet HealthCheckRegistry getHealthCheckRegistry () {return HEALTH_CHECK_REGISTRY; }} Deretter legger vi til både denne lytteren og HealthCheckServlet inn i det web.xml fil:
com.baeldung.metrics.servlets.MyHealthCheckServletContextListener healthCheck com.codahale.metrics.servlets.HealthCheckServlet healthCheck / healthcheck Nå kan vi starte webapplikasjonen, og sende en GET-forespørsel til “// localhost: 8080 / healthcheck” for å få helsekontrollresultater. Svaret skal være slik:
{"db": {"sunn": sann}}5.3. ThreadDumpServlet Bruk
ThreadDumpServlet gir informasjon om alle live-tråder i JVM, deres stater, deres stack-spor og tilstanden til eventuelle låser de måtte vente på.
Hvis vi vil bruke det, trenger vi bare å legge disse til i web.xml fil:
threadDump com.codahale.metrics.servlets.ThreadDumpServlet threadDump / threaddump Tråddumpdata vil være tilgjengelig på “// localhost: 8080 / threaddump”.
5.4. PingServlet Bruk
PingServlet kan brukes til å teste om applikasjonen kjører. Vi legger til disse i web.xml fil:
ping com.codahale.metrics.servlets.PingServlet ping / ping Og send deretter en GET-forespørsel til “// localhost: 8080 / ping”. Svarets statuskode er 200 og innholdet er "pong".
5.5. MetricsServlet Bruk
MetricsServlet gir beregningsdata. Først må vi lage en ServletContextListener som avslører vår MetricRegistry:
offentlig klasse MyMetricsServletContextListener utvider MetricsServlet.ContextListener {privat statisk MetricRegistry METRIC_REGISTRY = ny MetricRegistry (); statisk {Counter counter = METRIC_REGISTRY.counter ("m01-counter"); counter.inc (); Histogram histogram = METRIC_REGISTRY.histogram ("m02-histogram"); histogram. oppdatering (5); histogram. oppdatering (20); histogram. oppdatering (100); } @ Override-beskyttet MetricRegistry getMetricRegistry () {return METRIC_REGISTRY; }} Både denne lytteren og MetricsServlet må legges inn i web.xml:
com.codahale.metrics.servlets.MyMetricsServletContextListener metrics com.codahale.metrics.servlets.MetricsServlet metrics / metrics Dette vil bli eksponert i webapplikasjonen vår på “// localhost: 8080 / metrics”. Svaret skal inneholde ulike beregningsdata:
{"version": "3.0.0", "gauges": {}, "counters": {"m01-counter": {"count": 1}}, "histograms": {"m02-histogram": { "count": 3, "max": 100, "mean": 41.66666666666666, "min": 5, "p50": 20, "p75": 100, "p95": 100, "p98": 100, "p99 ": 100," p999 ": 100," stddev ": 41.69998667732268}}," meter ": {}," timers ": {}} 5.6. AdminServlet Bruk
AdminServlet aggregater HealthCheckServlet, ThreadDumpServlet, MetricsServlet, og PingServlet.
La oss legge disse til i web.xml:
admin com.codahale.metrics.servlets.AdminServlet admin / admin / * Den er nå tilgjengelig på “// localhost: 8080 / admin”. Vi får en side som inneholder fire lenker, en for hver av disse fire servlets.
Merk at hvis vi ønsker å gjøre helsesjekk og få tilgang til beregningsdata, er det fortsatt behov for disse to lytterne.
6. Modul metrics-servlet
De metrics-servlet modul gir en Filter som har flere beregninger: målere for statuskoder, en teller for antall aktive forespørsler og en tidtaker for forespørselens varighet.
6.1. Maven avhengigheter
For å bruke denne modulen, la oss først legge til avhengighet i pom.xml:
io.dropwizard.metrics metrics-servlet 3.1.2 Og du kan finne den nyeste versjonen her.
6.2. Bruk
For å bruke den, må vi lage en ServletContextListener som avslører vår MetricRegistry til InstrumentedFilter:
offentlig klasse MyInstrumentedFilterContextListener utvider InstrumentedFilterContextListener {public static MetricRegistry REGISTRY = new MetricRegistry (); @ Override beskyttet MetricRegistry getMetricRegistry () {return REGISTRY; }} Deretter legger vi disse inn i web.xml:
com.baeldung.metrics.servlet.MyInstrumentedFilterContextListener instrumentFilter com.codahale.metrics.servlet.InstrumentedFilter instrumentFilter / * Nå er det InstrumentedFilter kan jobbe. Hvis vi ønsker å få tilgang til beregningsdataene, kan vi gjøre det gjennom det MetricRegistryREGISTRERING.
7. Andre moduler
Med unntak av modulene vi introduserte ovenfor, har Metrics noen andre moduler for forskjellige formål:
- beregninger-jvm: gir flere nyttige beregninger for å instrumentere JVM internals
- beregninger-ehcache: gir InstrumentedEcache, en dekoratør for Ehcache-cacher
- beregninger-httpclient: gir klasser for å instrumentere Apache HttpClient (4.x versjon)
- beregninger-log4j: gir InstrumentedAppender, en Log4j Appender implementering for log4j 1.x som registrerer frekvensen av loggede hendelser etter deres loggningsnivå
- metrics-log4j2: ligner på metrics-log4j, bare for log4j 2.x
- metrics-logback: gir InstrumentedAppender, en Logback Appender implementering som registrerer frekvensen av loggede hendelser etter loggningsnivå
- metrics-json: gir HealthCheckModule og MetricsModule for Jackson
I tillegg til disse hovedprosjektmodulene, gir noen andre tredjepartsbiblioteker integrasjon med andre biblioteker og rammer.
8. Konklusjon
Instrumentering av applikasjoner er et vanlig krav, så i denne artikkelen introduserte vi Metrics, i håp om at det kan hjelpe deg med å løse problemet ditt.
Som alltid er den komplette kildekoden for eksemplet tilgjengelig på GitHub.
