Gyors útmutató a mikrométerhez

1. Bemutatkozás

Mikrométer egyszerű homlokzatot biztosít a műszer kliensek felett számos népszerű felügyeleti rendszer számára. Jelenleg a következő megfigyelő rendszereket támogatja: Atlas, Datadog, Graphite, Ganglia, Influx, JMX és Prometheus.

Ebben a cikkben bemutatjuk a mikrométer alapvető használatát és annak Springbe történő integrációját.

Az egyszerűség kedvéért a Micrometer Atlas-t vesszük példaként, hogy bemutassuk a legtöbb felhasználási esetünket.

2. Maven-függőség

Először tegyük a következő függőséget a pom.xml:

 io.micrometer micrometer-registry-atlas 0.12.0.FELHASZNÁLÁS 

A legújabb verzió itt található.

3. MeterRegistry

A Mikrométerben a MeterRegistry a mérőórák regisztrálásához használt alapkomponens. Iterálhatunk a nyilvántartáson és továbbíthatjuk az egyes mérők mutatóit, hogy idősorokat állítsunk elő a háttérrendszerben a mutatók és azok dimenzióértékeinek kombinációival.

A nyilvántartás legegyszerűbb formája a SimpleMeterRegistry. De a legtöbb esetben a MeterRegistry kifejezetten a monitoring rendszerünkhöz tervezték; az Atlas számára az AtlasMeterRegistry.

CompositeMeterRegistry lehetővé teszi több regiszter hozzáadását. Megoldást kínál az alkalmazás metrikáinak közzétételére különféle támogatott felügyeleti rendszerekben egyszerre.

Bármelyiket felvehetjük MeterRegistry szükséges az adatok több platformra történő feltöltéséhez:

CompositeMeterRegistry compositeRegistry = új CompositeMeterRegistry (); SimpleMeterRegistry oneSimpleMeter = új SimpleMeterRegistry (); AtlasMeterRegistry atlasMeterRegistry = új AtlasMeterRegistry (atlasConfig, Clock.SYSTEM); compositeRegistry.add (oneSimpleMeter); compositeRegistry.add (atlasMeterRegistry);

A Micrometer statikus globális nyilvántartási támogatást nyújt: Metrics.globalRegistry. Ezen a globális nyilvántartáson alapuló statikus építőkészlet is rendelkezésre áll a mérők előállításához Metrikák:

@Test public void givenGlobalRegistry_whenIncrementAnywhere_thenCounted () {class CountedObject {private CountedObject () {Metrics.counter ("object.instance"). Increment (1.0); }} Metrics.addRegistry (új SimpleMeterRegistry ()); Metrics.counter ("tárgyak.instance"). Növekmény (); új CountedObject (); Opcionális számlálóOptional = Metrics.globalRegistry .find ("object.instance"). Counter (); assertTrue (counterOptional.isPresent ()); assertTrue (counterOptional.get (). count () == 2.0); }

4. Címkék és Mérők

4.1. Címkék

A. Azonosítója Méter névből és címkékből áll. Javasoljuk, hogy kövessünk egy elnevezési megállapodást, amely elválasztja a szavakat egy ponttal, hogy garantáljuk a metrikus nevek hordozhatóságát több megfigyelő rendszerben.

Számláló számláló = registry.counter ("oldal.látogatók", "életkor", "20-as évek");

Címkék használható a metrika szeletelésére az értékekkel kapcsolatos érveléshez. A fenti kódban oldal.látogatók a mérő neve, a életkor = 20 év mint a címkéje. Ebben az esetben a számláló célja az oldal látogatóinak megszámlálása 20 és 30 év között.

Nagy rendszer esetén közös címkéket csatolhatunk egy nyilvántartáshoz, mondjuk, hogy a mutatók egy adott régióból származnak:

register.config (). commonTags ("régió", "ua-kelet");

4.2. Számláló

A Számláló csupán az alkalmazás egy adott tulajdonságának számlálását jelenti. Készíthetünk egyedi számlálót a folyékony készítővel vagy bármelyik segítő módszerével MetricRegistry:

Számláló számláló = Számláló .builder ("példány") .description ("az objektum példányszámát jelzi") .tags ("dev", "teljesítmény") .register (regisztráció); számláló.növekedés (2.0); assertTrue (számláló.szám () == 2); számlálónövekedés (-1); assertTrue (számláló.szám () == 2);

Amint a fenti részletből látható, megpróbáltuk eggyel csökkenteni a számlálót a számlálót csak rögzített pozitív összeggel növelhetjük monoton módon.

4.3. Időzítők

Használhatjuk a rendszer késleltetésének vagy eseményeinek gyakoriságának mérését Időzítők. A Időzítő legalább az adott idősorok teljes idejét és eseményszámát jelenti.

Például rögzíthetünk olyan alkalmazáseseményeket, amelyek több másodpercig is eltarthatnak:

SimpleMeterRegistry registry = új SimpleMeterRegistry (); Időzítő időzítő = register.timer ("app.event"); timer.record (() -> {próbálkozzon {TimeUnit.MILLISECONDS.sleep (1500);} catch (InterruptedException ignored) {}}); időzítő.rekord (3000, MILLISECONDS); assertTrue (2 == időzítő.szám ()); assertTrue (4510> timer.totalTime (MILLISECONDS) && 4500 <= timer.totalTime (MILLISECONDS));

Hosszú ideje futó események rögzítéséhez használjuk LongTaskTimer:

SimpleMeterRegistry registry = új SimpleMeterRegistry (); LongTaskTimer longTaskTimer = LongTaskTimer .builder ("3rdPartyService") .register (nyilvántartás); hosszú currentTaskId = longTaskTimer.start (); próbáld meg a {TimeUnit.SECONDS.sleep (2); } catch (InterruptedException ignored) {} ​​long timeElapsed = longTaskTimer.stop (currentTaskId); assertTrue (timeElapsed / (int) 1e9 == 2);

4.4. Nyomtáv

A mérőeszköz a méter aktuális értékét mutatja.

Különbözik a többi mérőtől, Mérők csak megfigyeléskor kell jelentést adnia. Mérők hasznos lehet a gyorsítótár, a gyűjtemények stb. statisztikáinak figyelemmel kísérésekor:

SimpleMeterRegistry registry = új SimpleMeterRegistry (); Lista lista = new ArrayList (4); Gauge gauge = Gauge .builder ("cache.size", list, List :: size) .register (nyilvántartás); assertTrue (gauge.value () == 0,0); list.add ("1"); assertTrue (gauge.value () == 1,0);

4.5. DistributionSummary

Az események elosztását és egy egyszerű összefoglalót a DistributionSummary:

SimpleMeterRegistry registry = új SimpleMeterRegistry (); DistributionSummary distributionSummary = DistributionSummary .builder ("request.size") .baseUnit ("bytes") .register (register); distributionSummary.record (3); distributionSummary.record (4); distributionSummary.record (5); assertTrue (3 == distributionSummary.count ()); assertTrue (12 == distributionSummary.totalAmount ());

Ráadásul, DistributionSummary és Időzítők kvantilisokkal gazdagodhat:

SimpleMeterRegistry registry = új SimpleMeterRegistry (); Időzítő időzítő = Timer.builder ("test.timer") .quantiles (WindowSketchQuantiles .quantiles (0,3, 0,5, 0,95) .create ()) .regiszter (regisztráció);

A fenti részletben három mérőműszer címkékkel kvantilis = 0,3, kvantilis = 0,5 és kvantilis = 0,95 elérhetővé válik a nyilvántartásban, megjelölve azokat az értékeket, amelyek alatt a megfigyelések 95, 50 és 30% -a alá esik.

Ahhoz, hogy ezeket a kvantilokat működés közben láthassuk, adjuk hozzá a következő rekordokat:

timer.record (2, TimeUnit.SECONDS); timer.record (2, TimeUnit.SECONDS); timer.record (3, TimeUnit.SECONDS); timer.record (4, TimeUnit.SECONDS); timer.record (8, TimeUnit.SECONDS); timer.record (13, TimeUnit.SECONDS);

Ezután ellenőrizhetjük az értékek kivonásával ebben a három kvantilisben Mérők:

List quantileGauges = register.getMeters (). Stream () .filter (m -> m.getType (). Name (). Egyenlő ("Gauge")) .map (meter -> (Gauge) meter) .collect (Collectors .toList ()); assertTrue (3 == quantileGauges.size ()); Térkép quantileMap = extractTagValueMap (nyilvántartás, Type.Gauge, 1e9); assertThat (quantileMap, allOf (hasEntry ("quantile = 0.3", 2), hasEntry ("quantile = 0.5", 3), hasEntry ("quantile = 0.95", 8));

A Micrometer emellett támogatja a hisztogramokat is:

DistributionSummary hist = DistributionSummary .builder ("summary") .histogram (Histogram.linear (0, 10, 5)) .register (register);

A kvantilisekhez hasonlóan több rekord csatolása után láthatjuk, hogy a hisztogram elég jól kezeli a számítást:

Térkép hisztogramjai = extractTagValueMap (nyilvántartás, Type.Counter, 1.0); assertThat (hisztogramok, allOf (hasEntry ("vödör = 0.0", 0), hasEntry ("vödör = 10.0", 2), hasEntry ("vödör = 20.0", 2), hasEntry ("vödör = 30.0", 1), hasEntry ("vödör = 40.0", 1), hasEntry ("vödör = Végtelen", 0)));

Általában a hisztogramok segíthetnek szemléltetni a közvetlen összehasonlítást külön vödrökben. A hisztogramok időskálázhatók is, ami nagyon hasznos a háttérszolgáltatás válaszidejének elemzéséhez:

SimpleMeterRegistry registry = új SimpleMeterRegistry (); Időzítő időzítő = Időzítő .builder ("időzítő") .histogram (Histogram.linearTime (TimeUnit.MILLISECONDS, 0, 200, 3)) .regiszter (nyilvántartás); // ... assertThat (hisztogramok, allOf (hasEntry ("bucket = 0.0", 0), hasEntry ("bucket = 2.0E8", 1), hasEntry ("bucket = 4.0E8", 1), hasEntry ("bucket = Végtelen ", 3)));

5. Kötőanyagok

A mikrométer több beépített kötővel rendelkezik a JVM, a gyorsítótárak, ExecutorService és fakitermelési szolgáltatások.

Ami a JVM-et és a rendszerfigyelést illeti, figyelemmel kísérhetjük az osztálybetöltők mutatóit (ClassLoaderMetrics), JVM memóriakészlet (JvmMemoryMetrics) és a GC mérőszámai (JvmGcMetrics), a szál és a CPU kihasználtsága (JvmThreadMetrics, ProcessorMetrics).

A gyorsítótár-figyelés (jelenleg csak a Guava, EhCache, Hazelcast és a Caffeine támogatott) a GuavaCacheMetrics, EhCache2Metrics, HazelcastCacheMetrics, és CaffeineCacheMetrics. A naplózási szolgáltatás figyelemmel kísérésére pedig köthetünk LogbackMetrics bármely érvényes nyilvántartásba:

új LogbackMetrics (). bind (nyilvántartás);

A fenti kötőanyagok használata meglehetősen hasonló LogbackMetrics és mind meglehetősen egyszerűek, ezért itt nem részletezzük a részleteket.

6. Tavaszi integráció

A Spring Boot Actuator függőségkezelést és automatikus konfigurációt biztosít a mikrométer számára. Most a Spring Boot 2.0 / 1.x és a Spring Framework 5.0 / 4.x támogatja.

A következő függőségre lesz szükségünk (a legújabb verzió itt található):

 io.mikrométer mikrométer-rugó-örökség 0.12.0.FELHASZNÁLÁS 

A meglévő kód további változtatása nélkül engedélyeztük a tavaszi támogatást a mikrométerrel. Tavaszi alkalmazásunk JVM memória mutatói automatikusan regisztrálásra kerülnek a globális nyilvántartásban, és közzéteszik az alapértelmezett atlas végponton: // localhost: 7101 / api / v1 / publish.

Számos konfigurálható tulajdonság áll rendelkezésre a metrikák exportálására a viselkedés kezdetétől kezdve tavasz.metrika.attlas. *. Jelölje be AtlasConfig az Atlas közzététel konfigurációs tulajdonságainak teljes listájának megtekintéséhez.

Ha további mutatókat kell kötnünk, akkor csak ezeket adja hozzá @Bab az alkalmazás kontextusához.

Mondja, hogy szükségünk van a JvmThreadMetrics:

@Bean JvmThreadMetrics threadMetrics () {return new JvmThreadMetrics (); }

Ami a webes megfigyelést illeti, az alkalmazásunk minden végpontjához automatikusan konfigurálva van, ugyanakkor egy konfigurációs tulajdonságon keresztül kezelhető: spring.metrics.web.autoTimeServerRequests.

Az alapértelmezett megvalósítás a metrikák négy dimenzióját biztosítja a végpontok számára: HTTP kérési módszer, HTTP válaszkód, végpont URI és kivétel információk.

Amikor válaszol a megkeresésekre, a kérési módszerre vonatkozó mutatók (KAP, POSTstb.) az Atlas-ban fognak megjelenni.

Az Atlas Graph API segítségével grafikont készíthetünk a különböző módszerek válaszidejének összehasonlítására:

Alapértelmezés szerint a 20x, 30x, 40x, 50x szintén beszámolnak:

Összehasonlíthatjuk a különböző URI-kat is:

vagy ellenőrizze a kivétel metrikáit:

Vegye figyelembe, hogy mi is használhatjuk @ Időzített a vezérlő osztályról vagy a metrikák címkék, hosszú feladat, kvantilisek és percentilisek testreszabására szolgáló specifikus végpont-módszerekről:

@RestController @Timed ("people") public class PeopleController {@GetMapping ("/ people") @Timed (value = "people.all", longTask = true) public List listPeople () {// ...}}

A fenti kód alapján a következő címkéket láthatjuk az Atlas végpont ellenőrzésével // localhost: 7101 / api / v1 / tags / name:

["emberek", "people.all", "jvmBufferCount", ...]

A mikrométer a Spring Boot 2.0-ban bevezetett funkció webes keretrendszerben is működik. A metrikák engedélyezhetők a RouterFunction:

RouterFunctionMetrics metrics = új RouterFunctionMetrics (nyilvántartás); RouterFunctions.route (...) .filter (metrics.timer ("server.requests"));

Az adatforrásból származó mutatók és az ütemezett feladatok is összegyűjthetők. További részletekért ellenőrizze a hivatalos dokumentációt.

7. Következtetés

Ebben a cikkben bemutattuk a metrikus homlokzati mikrométert. Azáltal, hogy elvonatkoztat és több szemantikában támogat több megfigyelő rendszert, az eszköz meglehetősen megkönnyíti a váltást a különböző megfigyelő platformok között.

Mint mindig, a cikk teljes implementációs kódja megtalálható a Github oldalon.