Egyéni metrikagyűjtemény a .NET-ben és a .NET Core-ban

Az Azure Monitor Application Insights .NET és a .NET Core SDK-k két különböző módszerrel gyűjtenek egyéni metrikákat: TrackMetric() és GetMetric(). A két módszer közötti fő különbség a helyi összesítés. A TrackMetric() metódus nem tartalmaz előaggregációt. A GetMetric() metódus előaggregációval rendelkezik. Javasoljuk, hogy aggregációt használjon, így TrackMetric() már nem az egyéni metrikák gyűjtésének előnyben részesített módszere. Ez a cikk végigvezeti a GetMetric() módszer használatán és a működés hátterében álló néhány okon.

Preaggregating vs. non-preaggregating API

A TrackMetric() metódus nyers telemetriát küld, amely egy metrikát jelöl. Nem hatékony egyetlen telemetriai elemet küldeni minden értékhez. A TrackMetric() módszer teljesítmény szempontjából is nem hatékony, mert mindegyik TrackMetric(item) a telemetriai inicializálók és processzorok teljes SDK-folyamatán megy keresztül.

Ellentétben a TrackMetric()GetMetric() helyi preaggregációval, és csak egy perc rögzített időközzel küldi el az összesített összegző metrikát. Ha a második vagy akár ezredmásodperc szintjén is szigorúan figyelnie kell néhány egyéni metrikát, ezt megteheti, miközben csak a percenkénti monitorozás tárolási és hálózati forgalmának költségeit tapasztalja. Ez a viselkedés jelentősen csökkenti a szabályozás kockázatát is, mivel az összesített metrikához küldendő telemetriai elemek teljes száma jelentősen csökken.

Az Application Insightsban a mintavételezésen keresztül TrackMetric() gyűjtött és GetMetric() nem mintavételezett egyéni metrikák. A fontos metrikák mintavételezése olyan forgatókönyvekhez vezethet, amelyekben a metrikák köré épített riasztások megbízhatatlanná válhatnak. Ha soha nem mintavételezi az egyéni metrikákat, általában biztos lehet abban, hogy a riasztási küszöbértékek átlépésekor riasztás aktiválódik. Mivel az egyéni metrikák nem mintavételezettek, lehetséges problémák merülnek fel.

A trendkövetés egy metrika minden másodpercében vagy még részletesebb időközönként a következőt eredményezheti:

• Megnövekedett adattárolási költségek. A költségek az Azure Monitorba küldött adatok összegével kapcsolatosak. Minél több adatot küld, annál nagyobb a figyelés általános költsége.
• Nagyobb hálózati forgalom vagy teljesítményterhelés. Bizonyos esetekben ennek a többletterhelésnek pénzbeli és alkalmazásteljesítményi költsége is lehet.
• A betöltés szabályozásának kockázata. Az Azure Monitor elveti a ("szabályozások") adatpontokat, amikor az alkalmazás rövid időintervallumban nagy mennyiségű telemetriát küld.

A szabályozás aggodalomra ad okot, mert a riasztások kimaradásához vezethet. A riasztás aktiválásának feltétele helyileg is előfordulhat, majd a túl sok adat elküldése miatt a betöltési végponton el lehet dobni. A .NET és a .NET Core használatát TrackMetric() csak akkor javasoljuk, ha saját helyi összesítési logikát implementált. Ha egy adott időszak alatt minden eseményt nyomon szeretne követni, akkor ez jobb választás lehet TrackEvent() . Ne feledje, hogy az egyéni metrikákkal ellentétben az egyéni események mintavételezés tárgyát képezik. Továbbra is használhatja TrackMetric() a saját helyi előaggregáció írása nélkül is. De ha így tesz, vegye figyelembe a buktatókat.

Összefoglalva azt javasoljuk GetMetric() , hogy mivel előaggregációt végez, az összes Track() hívásból gyűjt értékeket, és percenként egy összegzést/összesítést küld. A GetMetric() módszer jelentősen csökkentheti a költség- és teljesítményterhelést azáltal, hogy kevesebb adatpontot küld, miközben továbbra is összegyűjti az összes releváns információt.

A GetMetric használatának első lépései

Példáinkban egy alapszintű .NET Core 3.1 feldolgozói szolgáltatásalkalmazást fogunk használni. Ha a példában használt tesztkörnyezetet szeretné replikálni, kövesse az 1–6. lépést a Monitorozási feldolgozó szolgáltatás cikkben. Ezek a lépések hozzáadják az Application Insightst egy alapszintű feldolgozói szolgáltatási projektsablonhoz. A fogalmak minden olyan általános alkalmazásra vonatkoznak, ahol az SDK használható, beleértve a webalkalmazásokat és a konzolalkalmazásokat is.

Metrikák küldése

Cserélje le a worker.cs fájl tartalmát a következő kódra:

using System;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.ApplicationInsights;

namespace WorkerService3
{
    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;
        private TelemetryClient _telemetryClient;

        public Worker(ILogger<Worker> logger, TelemetryClient tc)
        {
            _logger = logger;
            _telemetryClient = tc;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {   // The following line demonstrates usages of GetMetric API.
            // Here "computersSold", a custom metric name, is being tracked with a value of 42 every second.
            while (!stoppingToken.IsCancellationRequested)
            {
                _telemetryClient.GetMetric("ComputersSold").TrackValue(42);

                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
                await Task.Delay(1000, stoppingToken);
            }
        }
    }
}

A mintakód futtatásakor a while ciklus ismétlődően fut, és nem küld telemetriát a Visual Studio kimeneti ablakában. A rendszer egyetlen telemetriai elemet küld a 60 másodperces jel körül, amely a tesztünkben a következőképpen néz ki:

Application Insights Telemetry: {"name":"Microsoft.ApplicationInsights.Dev.00000000-0000-0000-0000-000000000000.Metric", "time":"2019-12-28T00:54:19.0000000Z",
"ikey":"00000000-0000-0000-0000-000000000000",
"tags":{"ai.application.ver":"1.0.0.0",
"ai.cloud.roleInstance":"Test-Computer-Name",
"ai.internal.sdkVersion":"m-agg2c:2.12.0-21496",
"ai.internal.nodeName":"Test-Computer-Name"},
"data":{"baseType":"MetricData",
"baseData":{"ver":2,"metrics":[{"name":"ComputersSold",
"kind":"Aggregation",
"value":1722,
"count":41,
"min":42,
"max":42,
"stdDev":0}],
"properties":{"_MS.AggregationIntervalMs":"42000",
"DeveloperMode":"true"}}}}

Ez az egyetlen telemetriai elem 41 különböző metrikamérés összesítését jelöli. Mivel ugyanazt az értéket küldtük újra és újra, a szórás (stDev) 0 azonos maximális (max) és minimális (min) értékkel rendelkezik. A value tulajdonság az összes összesített egyedi érték összegét jelöli.

Ha az Application Insights-erőforrást a Naplók (Elemzések) felületen vizsgáljuk meg, az egyes telemetriai elem az alábbi képernyőképhez hasonlóan fog kinézni.

Az egyéni metrikatelemetria a portál Metrikák szakaszában is elérhető naplóalapú és egyéni metrikaként is. Az alábbi képernyőkép egy naplóalapú metrikára mutat be példát.

Gyorsítótár metrikahivatkozása a nagy átviteli sebességű használathoz

Bizonyos esetekben gyakran figyelhetők meg metrikaértékek. Például egy magas átviteli sebességű szolgáltatás, amely másodpercenként 500 kérést dolgoz fel, 20 telemetriai metrikát szeretne kibocsátani minden kéréshez. Az eredmény 10 000 érték másodpercenkénti nyomon követését jelenti. Ilyen nagy átviteli sebességű forgatókönyvek esetén előfordulhat, hogy a felhasználóknak segítségre van szükségük az SDK-ban bizonyos keresések elkerülésével.

Az előző példa például megkereste a metrika ComputersSold egyik leíróját 42, majd nyomon követte a megfigyelt értéket. Ehelyett előfordulhat, hogy a leíró több nyomkövetési híváshoz is gyorsítótárazva van:

//...

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            // This is where the cache is stored to handle faster lookup
            Metric computersSold = _telemetryClient.GetMetric("ComputersSold");
            while (!stoppingToken.IsCancellationRequested)
            {

                computersSold.TrackValue(42);

                computersSold.TrackValue(142);

                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
                await Task.Delay(50, stoppingToken);
            }
        }

A metrikafogópont gyorsítótárazása mellett az előző példa 50 ezredmásodpercre is csökkent Task.Delay , hogy a hurok gyakrabban futjon. Az eredmény 772 TrackValue() meghívás.

Többdimenziós metrikák

Az előző szakaszban szereplő példák zéró dimenziójú metrikákat mutatnak. A metrikák többdimenziósak is lehetnek. Jelenleg legfeljebb 10 dimenziót támogatunk.

Íme egy példa egydimenziós metrikák létrehozására:

//...

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            // This is an example of a metric with a single dimension.
            // FormFactor is the name of the dimension.
            Metric computersSold= _telemetryClient.GetMetric("ComputersSold", "FormFactor");

            while (!stoppingToken.IsCancellationRequested)
            {
                // The number of arguments (dimension values)
                // must match the number of dimensions specified while GetMetric.
                // Laptop, Tablet, etc are values for the dimension "FormFactor"
                computersSold.TrackValue(42, "Laptop");
                computersSold.TrackValue(20, "Tablet");
                computersSold.TrackValue(126, "Desktop");


                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
                await Task.Delay(50, stoppingToken);
            }
        }

A mintakód legalább 60 másodpercen át történő futtatása három különböző telemetriai elemet eredményez, amelyeket az Azure-ba küld. Minden elem a három űrlaptényező egyikének összesítését jelöli. A korábbiakhoz hasonlóan a Naplók (Elemzések) nézetben is megvizsgálhatja.

A metrikák kezelőjében:

Figyelje meg, hogy nem oszthatja fel a metrikát az új egyéni dimenzióval, és nem tekintheti meg az egyéni dimenziót a metrikák nézettel.

Alapértelmezés szerint a metrikakezelőben lévő többdimenziós metrikák nincsenek bekapcsolva az Application Insights-erőforrásokban.

Többdimenziós metrikák engedélyezése

Ha többdimenziós metrikákat szeretne engedélyezni egy Application Insights-erőforráshoz, válassza a Használati és becsült költségek>egyéni metrikák>Az egyéni metrikák riasztásának engedélyezése az egyéni metrikadimenziókon>OK lehetőséget. További információ: Egyéni metrikák dimenziói és előaggregációja.

Miután végrehajtotta ezt a módosítást, és új többdimenziós telemetriát küldött, kiválaszthatja a Felosztás alkalmazása lehetőséget.

Tekintse meg az egyes FormFactor dimenziók metrika-összesítéseit.

A MetricIdentifier használata háromnál több dimenzió esetén

Jelenleg 10 dimenzió támogatott. Háromnál több dimenzió használatához a következőt kell használni MetricIdentifier:

// Add "using Microsoft.ApplicationInsights.Metrics;" to use MetricIdentifier
// MetricIdentifier id = new MetricIdentifier("[metricNamespace]","[metricId],"[dim1]","[dim2]","[dim3]","[dim4]","[dim5]");
MetricIdentifier id = new MetricIdentifier("CustomMetricNamespace","ComputerSold", "FormFactor", "GraphicsCard", "MemorySpeed", "BatteryCapacity", "StorageCapacity");
Metric computersSold  = _telemetryClient.GetMetric(id);
computersSold.TrackValue(110,"Laptop", "Nvidia", "DDR4", "39Wh", "1TB");

Egyéni metrikakonfiguráció

Ha módosítani szeretné a metrika konfigurációját, módosítania kell a metrika inicializálásának helyét.

Speciális dimenziónevek

A metrikák nem használják a használt telemetriai környezetet a TelemetryClient hozzáférésükhöz. Ennek a korlátozásnak a legjobb kerülő megoldása az, ha az osztályban MetricDimensionNames konstansként elérhető speciális dimenzióneveket használ.

A következő Special Operation Request Size metrika által küldött metrika-összesítések nem lesznek Context.Operation.Name beállítva.Special Operation A TrackMetric() metódus vagy bármely más TrackXXX() metódus helyesen Special Operationlett OperationName beállítva.

        //...
        TelemetryClient specialClient;
        private static int GetCurrentRequestSize()
        {
            // Do stuff
            return 1100;
        }
        int requestSize = GetCurrentRequestSize()

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                //...
                specialClient.Context.Operation.Name = "Special Operation";
                specialClient.GetMetric("Special Operation Request Size").TrackValue(requestSize);
                //...
            }
                   
        }

Ebben a helyzetben az osztályban MetricDimensionNames felsorolt speciális dimenziónevekkel adja meg az TelemetryContext értékeket.

Ha például a következő utasításból származó metrika-aggregátumot elküldi az Application Insights felhővégpontnak, az adatmezője Context.Operation.Name a következőre Special Operationlesz állítva:

_telemetryClient.GetMetric("Request Size", MetricDimensionNames.TelemetryContext.Operation.Name).TrackValue(requestSize, "Special Operation");

A speciális dimenzió értékeit a rendszer átmásoljaTelemetryContext, és nem használja normál dimenzióként. Ha egy műveleti dimenziót is meg szeretne tartani a normál metrikafeltáráshoz, ehhez külön dimenziót kell létrehoznia:

_telemetryClient.GetMetric("Request Size", "Operation Name", MetricDimensionNames.TelemetryContext.Operation.Name).TrackValue(requestSize, "Special Operation", "Special Operation");

Dimenzió- és idősorkorlát-meghatározás

Ha meg szeretné akadályozni, hogy a telemetriai alrendszer véletlenül használja fel az erőforrásokat, szabályozhatja a mérőszámonkénti adatsorok maximális számát. Az alapértelmezett korlátok metrikánként legfeljebb 1000 adatsort tartalmaznak, dimenziónként pedig legfeljebb 100 különböző értéket.

A dimenzió- és idősorkorlátok korlátozásának kontextusában biztosítjuk Metric.TrackValue(..) a korlátok betartását. Ha már elérte a korlátokat, Metric.TrackValue(..) visszaadja False , és az érték nem lesz nyomon követve. Ellenkező esetben a visszaadott Trueérték. Ez a viselkedés akkor hasznos, ha egy metrika adatai felhasználói bemenetből származnak.

A MetricConfiguration konstruktor a megfelelő metrikán belüli különböző adatsorok és a metrikák egyes sorozatai összesítési viselkedését meghatározó osztály implementálási IMetricSeriesConfiguration objektumának kezelésére kínál lehetőséget:

var metConfig = new MetricConfiguration(seriesCountLimit: 100, valuesPerDimensionLimit:2,
                new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: false));

Metric computersSold = _telemetryClient.GetMetric("ComputersSold", "Dimension1", "Dimension2", metConfig);

// Start tracking.
computersSold.TrackValue(100, "Dim1Value1", "Dim2Value1");
computersSold.TrackValue(100, "Dim1Value1", "Dim2Value2");

// The following call gives 3rd unique value for dimension2, which is above the limit of 2.
computersSold.TrackValue(100, "Dim1Value1", "Dim2Value3");
// The above call does not track the metric, and returns false.

• seriesCountLimit A metrikák által tartalmazhatnak adat-idősorok maximális száma. Ha eléri ezt a korlátot, az erre irányuló TrackValue() hívások általában egy új sorozat visszatérését falseeredményezik.
• valuesPerDimensionLimit a dimenziónkénti különböző értékek számát hasonló módon korlátozza.
• restrictToUInt32Values meghatározza, hogy csak a nem negatív egész számértékeket kell-e nyomon követni.

Íme egy példa arra, hogyan küldhet üzenetet, amelyből megtudhatja, hogy túllépték-e a korlátot:

if (! computersSold.TrackValue(100, "Dim1Value1", "Dim2Value3"))
{
// Add "using Microsoft.ApplicationInsights.DataContract;" to use SeverityLevel.Error
_telemetryClient.TrackTrace("Metric value not tracked as value of one of the dimension exceeded the cap. Revisit the dimensions to ensure they are within the limits",
SeverityLevel.Error);
}

Következő lépések

• Metrikák – Lekérés – REST API
• Application Insights API egyéni eseményekhez és metrikákhoz
• További információ a feldolgozói szolgáltatásalkalmazások monitorozásáról.
• Naplóalapú és előre összesített metrikákat használjon.
• Metrikák elemzése a Metrics Explorerrel.
• Megtudhatja, hogyan engedélyezheti az Application Insightst ASP.NET Core-alkalmazásokhoz.
• Megtudhatja, hogyan engedélyezheti az Application Insightst ASP.NET alkalmazásokhoz.