Dela via

Sampling i Application Insights

  • Artikel

Sampling är en funktion i Application Insights. Det är det rekommenderade sättet att minska telemetritrafik, datakostnader och lagringskostnader, samtidigt som en statistiskt korrekt analys av programdata bevaras. Sampling hjälper dig också att undvika att Application Insights begränsar telemetrin. Samplingsfiltret väljer objekt som är relaterade, så att du kan navigera mellan objekt när du utför diagnostikundersökningar.

När måttantal visas i portalen är de renormaliserade för att ta hänsyn till sampling. Om du gör det minimeras all effekt på statistiken.

Kommentar

  • Om du har antagit vår OpenTelemetry Distro och letar efter konfigurationsalternativ kan du läsa Aktivera sampling.

Kommentar

Följande dokumentation förlitar sig på det klassiska API:et Application Insights. Den långsiktiga planen för Application Insights är att samla in data med OpenTelemetry. Mer information finns i Aktivera Azure Monitor OpenTelemetry för .NET-, Node.js-, Python- och Java-program och vår OpenTelemetry-översikt. Migreringsvägledning är tillgänglig för .NET, Node.js och Python.

En skärmbild av konfigurationsalternativ för sampling.

Kort sammanfattning

  • Det finns tre olika typer av sampling: adaptiv sampling, sampling med fast frekvens och inmatningssampling.
  • Anpassningsbar sampling är aktiverat som standard i alla de senaste versionerna av Application Insights ASP.NET och ASP.NET Core Software Development Kits (SDK:er) och Azure Functions.
  • Sampling med fast hastighet är tillgängligt i de senaste versionerna av Application Insights SDK:er för ASP.NET, ASP.NET Core, Java (både agenten och SDK), JavaScript och Python.
  • I Java är samplings åsidosättningar tillgängliga och är användbara när du behöver tillämpa olika samplingsfrekvenser på valda beroenden, begäranden och hälsokontroller. Använd samplings åsidosättningar för att finjustera vissa brusberoenden, medan till exempel alla viktiga fel sparas på 100 %. Det här beteendet är en form av fast sampling som ger dig en detaljerad kontrollnivå över telemetrin.
  • Inmatningssampling fungerar på Application Insights-tjänstens slutpunkt. Den tillämpas bara när ingen annan sampling är aktiv. Om SDK:t tar exempel på telemetrin inaktiveras inmatningssampling.
  • För webbprogram måste händelserna ha samma OperationId värde om du loggar anpassade händelser och behöver se till att en uppsättning händelser bevaras eller ignoreras tillsammans.
  • Om du skriver Analytics-frågor bör du ta hänsyn till sampling. I stället för att bara räkna poster bör du använda summarize sum(itemCount).
  • Vissa telemetrityper, inklusive prestandamått och anpassade mått, behålls alltid oavsett om sampling är aktiverat eller inte.

I följande tabell sammanfattas de samplingstyper som är tillgängliga för varje SDK och typ av program:

Application Insights SDK Anpassningsbar sampling stöds Fast sampling stöds Inmatningssampling stöds
ASP.NET Ja (på som standard) Ja Endast om ingen annan sampling är i kraft
ASP.NET Core Ja (på som standard) Ja Endast om ingen annan sampling är i kraft
Azure Functions Ja (på som standard) Nej Endast om ingen annan sampling är i kraft
Java Nej Ja Endast om ingen annan sampling är i kraft
JavaScript Nej Ja Endast om ingen annan sampling är i kraft
Node.JS Nej Ja Endast om ingen annan sampling är i kraft
Python Nej Ja Endast om ingen annan sampling är i kraft
Alla andra Nej Nej Ja

Kommentar

  • Java Application Agent 3.4.0 och senare använder hastighetsbegränsad sampling som standard när telemetri skickas till Application Insights. Mer information finns i Frekvensbegränsad sampling.
  • Informationen på det mesta av den här sidan gäller för de aktuella versionerna av Application Insights SDK:er. Information om äldre versioner av SDK:er finns i äldre SDK-versioner.

När du ska använda sampling

I allmänhet behöver du inte sampling för de flesta små och medelstora program. Den mest användbara diagnostikinformationen och den mest exakta statistiken erhålls genom att samla in data om alla dina användaraktiviteter.

De största fördelarna med sampling är:

  • Application Insights-tjänsten släpper datapunkter ("begränsningar") när din app skickar en hög telemetrifrekvens på kort tid. Sampling minskar sannolikheten för att programmet ser begränsningar.
  • För att hålla dig inom kvoten för datapunkter för din prisnivå.
  • För att minska nätverkstrafiken från insamlingen av telemetri.

Så här fungerar sampling

Samplingsalgoritmen bestämmer vilka telemetriobjekt den behåller eller släpper, oavsett om SDK eller Application Insights-tjänsten utför samplingen. Den följer reglerna för att hålla alla relaterade datapunkter intakta, vilket säkerställer att Application Insights ger en användbar och tillförlitlig diagnostikupplevelse, även med mindre data. Om ett exempel till exempel innehåller en misslyckad begäran behåller den alla relaterade telemetriobjekt som undantag och spårningar. På så sätt ser du alltid begäran och tillhörande telemetri när du visar information om begäran i Application Insights.

Samplingsbeslutet baseras på begärans åtgärds-ID, vilket innebär att alla telemetriobjekt som hör till en viss åtgärd antingen bevaras eller tas bort. För telemetriobjekt som inte har en åtgärds-ID-uppsättning (till exempel telemetriobjekt som rapporteras från asynkrona trådar utan HTTP-kontext) fångar samplingen bara en procentandel telemetriobjekt av varje typ.

När telemetri presenteras för dig justerar Application Insights-tjänsten måtten med samma samplingsprocent som användes vid tidpunkten för insamlingen, för att kompensera för de saknade datapunkterna. När man tittar på telemetrin i Application Insights ser användarna därför statistiskt korrekta approximationer som ligger nära de verkliga talen.

Noggrannheten i uppskattningen beror till stor del på den konfigurerade samplingsprocenten. Dessutom ökar noggrannheten för program som hanterar en stor mängd liknande begäranden från många användare. Å andra sidan behövs inte sampling för program som inte fungerar med en betydande belastning eftersom dessa program vanligtvis kan skicka all sin telemetri medan de håller sig inom kvoten, utan att orsaka dataförlust från begränsning.

Typer av sampling

Det finns tre olika samplingsmetoder:

  • Anpassningsbar sampling justerar automatiskt mängden telemetri som skickas från SDK:t i din ASP.NET/ASP.NET Core-app och från Azure Functions. Det är standardsampling när du använder ASP.NET eller ASP.NET Core SDK. Anpassningsbar sampling är för närvarande endast tillgängligt för ASP.NET/ASP.NET Core-telemetri på serversidan och för Azure Functions.

  • Sampling med fast hastighet minskar mängden telemetri som skickas från både din ASP.NET- eller ASP.NET Core- eller Java-server och från användarnas webbläsare. Du anger priset. Klienten och servern synkroniserar samplingen så att du i Sök kan navigera mellan relaterade sidvisningar och begäranden.

  • Inmatningssampling sker på Application Insights-tjänstens slutpunkt. Den tar bort en del av telemetrin som kommer från din app, med en samplingsfrekvens som du anger. Den minskar inte telemetritrafiken som skickas från din app, utan hjälper dig att hålla dig inom din månatliga kvot. Den största fördelen med inmatningssampling är att du kan ange samplingsfrekvensen utan att distribuera om appen. Inmatningssampling fungerar enhetligt för alla servrar och klienter, men det gäller inte när andra typer av sampling används.

Viktigt!

Om anpassningsbara eller fasta samplingsmetoder är aktiverade för en telemetrityp inaktiveras inmatningssampling för den telemetrin. Telemetrityper som undantas från sampling på SDK-nivå kommer dock fortfarande att omfattas av inmatningssampling med den hastighet som anges i portalen.

Adaptiv sampling

Anpassningsbar sampling påverkar mängden telemetri som skickas från webbserverappen till Application Insights-tjänstens slutpunkt.

Dricks

Anpassningsbar sampling är aktiverat som standard när du använder ASP.NET SDK eller ASP.NET Core SDK, och är också aktiverat som standard för Azure Functions.

Volymen justeras automatiskt för att hålla sig inom hastighetsgränsen MaxTelemetryItemsPerSecond . Om programmet genererar låg telemetri, till exempel under felsökning eller låg användning, släpper det inte objekt så länge volymen ligger under MaxTelemetryItemsPerSecond. När telemetrivolymen ökar justeras samplingsfrekvensen så att den når målvolymen. Den här justeringen, som beräknas om med jämna mellanrum, baseras på det glidande medelvärdet för den utgående överföringshastigheten.

För att uppnå målvolymen ignoreras en del av den genererade telemetrin. Men precis som andra typer av sampling behåller algoritmen relaterade telemetriobjekt. När du till exempel inspekterar telemetrin i Sök kan du hitta begäran som är relaterad till ett visst undantag.

Måttantal som begärandefrekvens och undantagsfrekvens justeras för att kompensera för samplingsfrekvensen, så att de visar ungefärliga värden i Metric Explorer.

Konfigurera anpassningsbar sampling för ASP.NET program

Kommentar

Det här avsnittet gäller för ASP.NET program, inte för ASP.NET Core-program. Lär dig mer om att konfigurera anpassningsbar sampling för ASP.NET Core-program senare i det här dokumentet.

I ApplicationInsights.configkan du justera flera parametrar i AdaptiveSamplingTelemetryProcessor noden. De siffror som visas är standardvärdena:

  • <MaxTelemetryItemsPerSecond>5</MaxTelemetryItemsPerSecond>

    Målfrekvensen för logiska åtgärder som den anpassningsbara algoritmen syftar till att samla in på varje servervärd. Om webbappen körs på många värdar kan du minska det här värdet för att hålla dig inom målfrekvensen för trafik på Application Insights-portalen.

  • <EvaluationInterval>00:00:15</EvaluationInterval>

    Det intervall med vilket den aktuella telemetrihastigheten omvärderas. Utvärderingen utförs som ett glidande medelvärde. Du kanske vill förkorta det här intervallet om telemetrin kan leda till plötsliga toppar.

  • <SamplingPercentageDecreaseTimeout>00:02:00</SamplingPercentageDecreaseTimeout>

    När samplingsprocentvärdet ändras avgörs hur snabbt vi kan minska samplingsprocenten igen för att samla in färre data.

  • <SamplingPercentageIncreaseTimeout>00:15:00</SamplingPercentageIncreaseTimeout>

    När samplingsprocentvärdet ändras avgörs hur snart vi kan öka samplingsprocenten igen för att samla in mer data.

  • <MinSamplingPercentage>0.1</MinSamplingPercentage>

    När samplingsprocenten varierar, vilket är det lägsta värde som vi får ange?

  • <MaxSamplingPercentage>100.0</MaxSamplingPercentage>

    När samplingsprocenten varierar, vilket är det högsta värde som vi får ange?

  • <MovingAverageRatio>0.25</MovingAverageRatio>

    I beräkningen av glidande medelvärde anger det här värdet den vikt som ska tilldelas till det senaste värdet. Använd ett värde som är lika med eller mindre än 1. Mindre värden gör algoritmen mindre reaktiv för plötsliga ändringar.

  • <InitialSamplingPercentage>100</InitialSamplingPercentage>

    Mängden telemetri som ska samplas när appen startas. Minska inte det här värdet när du felsöker.

  • <ExcludedTypes>type;type</ExcludedTypes>

    En semikolonavgränsad lista över typer som du inte vill ska omfattas av sampling. Identifierade typer är: Dependency, Event, Exception, PageView, Request, . Trace All telemetri av de angivna typerna överförs. de typer som inte har angetts samplas.

  • <IncludedTypes>type;type</IncludedTypes>

    En semikolonavgränsad lista över typer som du vill omfattas av sampling. Identifierade typer är: Dependency, Event, Exception, PageView, Request, . Trace De angivna typerna samplas. all telemetri av de andra typerna överförs alltid.

Om du vill stänga av anpassningsbar sampling tar du bort noderna AdaptiveSamplingTelemetryProcessor från ApplicationInsights.config.

Alternativ: Konfigurera anpassningsbar sampling i kod

I stället för att ange samplingsparametern .config i filen kan du programmatiskt ange dessa värden.

  1. Ta bort alla AdaptiveSamplingTelemetryProcessor noder från .config filen.

  2. Använd följande kodfragment för att konfigurera anpassningsbar sampling:

    using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.WindowsServer.Channel.Implementation;
using Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel;

// ...

var builder = TelemetryConfiguration.Active.DefaultTelemetrySink.TelemetryProcessorChainBuilder;
// For older versions of the Application Insights SDK, use the following line instead:
// var builder = TelemetryConfiguration.Active.TelemetryProcessorChainBuilder;

// Enable AdaptiveSampling so as to keep overall telemetry volume to 5 items per second.
builder.UseAdaptiveSampling(maxTelemetryItemsPerSecond:5);

// If you have other telemetry processors:
builder.Use((next) => new AnotherProcessor(next));

builder.Build();

    (Läs mer om telemetriprocessorer.)

Du kan också justera samplingsfrekvensen för varje telemetrityp individuellt, eller till och med undanta vissa typer från att samplas alls:

// The following configures adaptive sampling with 5 items per second, and also excludes Dependency telemetry from being subjected to sampling.
builder.UseAdaptiveSampling(maxTelemetryItemsPerSecond:5, excludedTypes: "Dependency");

Konfigurera anpassningsbar sampling för ASP.NET Core-program

ASP.NET Core-program kan konfigureras i kod eller via appsettings.json filen. Mer information finns i Konfiguration i ASP.NET Core.

Anpassningsbar sampling är aktiverat som standard för alla ASP.NET Core-program. Du kan inaktivera eller anpassa samplingsbeteendet.

Stänga av anpassningsbar sampling

Standardsamplingsfunktionen kan inaktiveras när du lägger till Application Insights-tjänsten.

Lägg till ApplicationInsightsServiceOptions efter WebApplication.CreateBuilder() -metoden i Program.cs filen:

var builder = WebApplication.CreateBuilder(args);

var aiOptions = new Microsoft.ApplicationInsights.AspNetCore.Extensions.ApplicationInsightsServiceOptions();
aiOptions.EnableAdaptiveSampling = false;
builder.Services.AddApplicationInsightsTelemetry(aiOptions);

var app = builder.Build();

Koden ovan inaktiverar anpassningsbar sampling. Följ följande steg för att lägga till sampling med fler anpassningsalternativ.

Konfigurera samplingsinställningar

Använd följande tilläggsmetoder TelemetryProcessorChainBuilder för för att anpassa samplingsbeteendet.

Viktigt!

Om du använder den här metoden för att konfigurera sampling måste du ange aiOptions.EnableAdaptiveSampling egenskapen till false när du anropar AddApplicationInsightsTelemetry(). När du har gjort den här ändringen måste du följa anvisningarna i följande kodblock exakt för att återaktivera anpassningsbar sampling med dina anpassningar på plats. Om du inte gör det kan det leda till för hög datainmatning. Testa alltid efter ändring av samplingsinställningar och ange ett lämpligt dagligt datatak för att kontrollera dina kostnader.

using Microsoft.ApplicationInsights.AspNetCore.Extensions;
using Microsoft.ApplicationInsights.Extensibility;

var builder = WebApplication.CreateBuilder(args);

builder.Services.Configure<TelemetryConfiguration>(telemetryConfiguration =>
{
   var telemetryProcessorChainBuilder = telemetryConfiguration.DefaultTelemetrySink.TelemetryProcessorChainBuilder;

   // Using adaptive sampling
   telemetryProcessorChainBuilder.UseAdaptiveSampling(maxTelemetryItemsPerSecond: 5);

   // Alternately, the following configures adaptive sampling with 5 items per second, and also excludes DependencyTelemetry from being subject to sampling:
   // telemetryProcessorChainBuilder.UseAdaptiveSampling(maxTelemetryItemsPerSecond:5, excludedTypes: "Dependency");

   telemetryProcessorChainBuilder.Build();
});

builder.Services.AddApplicationInsightsTelemetry(new ApplicationInsightsServiceOptions
{
   EnableAdaptiveSampling = false,
});

var app = builder.Build();

Du kan anpassa andra samplingsinställningar med hjälp av klassen SamplingPercentageEstimatorSettings :

using Microsoft.ApplicationInsights.WindowsServer.Channel.Implementation;

telemetryProcessorChainBuilder.UseAdaptiveSampling(new SamplingPercentageEstimatorSettings
{
     MinSamplingPercentage = 0.01,
     MaxSamplingPercentage = 100,
     MaxTelemetryItemsPerSecond = 5
 }, null, excludedTypes: "Dependency");

Konfigurera anpassningsbar sampling för Azure Functions

Följ anvisningarna från den här sidan för att konfigurera anpassningsbar sampling för appar som körs i Azure Functions.

Sampling med fast frekvens

Sampling med fast hastighet minskar trafiken som skickas från webbservern och webbläsaren. Till skillnad från adaptiv sampling minskar telemetrin med en fast hastighet som bestäms av dig. Sampling med fast hastighet är tillgängligt för ASP.NET,ASP.NET Core-, Java- och Python-program.

Precis som andra tekniker behåller den även relaterade objekt. Den synkroniserar även klient- och serversampling så att relaterade objekt behålls. När du till exempel tittar på en sidvy i Sök kan du hitta dess relaterade serverbegäranden.

I Metrics Explorer multipliceras priser som antal förfrågningar och undantag med en faktor för att kompensera för samplingsfrekvensen, så att de är så exakta som möjligt.

Konfigurera fast sampling för ASP.NET program

  1. Inaktivera anpassningsbar sampling: I ApplicationInsights.configtar du bort eller kommenterar ut AdaptiveSamplingTelemetryProcessor noden.

    <TelemetryProcessors>
    <!-- Disabled adaptive sampling:
    <Add Type="Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel.AdaptiveSamplingTelemetryProcessor, Microsoft.AI.ServerTelemetryChannel">
        <MaxTelemetryItemsPerSecond>5</MaxTelemetryItemsPerSecond>
    </Add>
    -->

  2. Aktivera modulen för fast sampling. Lägg till det här kodfragmentet i ApplicationInsights.config:

    I det här exemplet är SamplingPercentage 20, så 20 % av alla objekt samplas. Värden i Metrics Explorer multipliceras med (100/20) = 5 för att kompensera.

    <TelemetryProcessors>
    <Add Type="Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel.SamplingTelemetryProcessor, Microsoft.AI.ServerTelemetryChannel">
        <!-- Set a percentage close to 100/N where N is an integer. -->
        <!-- E.g. 50 (=100/2), 33.33 (=100/3), 25 (=100/4), 20, 1 (=100/100), 0.1 (=100/1000) -->
        <SamplingPercentage>20</SamplingPercentage>
    </Add>
</TelemetryProcessors>

    I stället för att ange samplingsparametern i ApplicationInsights.config filen kan du också programmatiskt ange följande värden:

    using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel;

// ...

var builder = TelemetryConfiguration.Active.DefaultTelemetrySink.TelemetryProcessorChainBuilder;
// For older versions of the Application Insights SDK, use the following line instead:
// var builder = TelemetryConfiguration.Active.TelemetryProcessorChainBuilder;

builder.UseSampling(10.0); // percentage

// If you have other telemetry processors:
builder.Use((next) => new AnotherProcessor(next));

builder.Build();

    (Läs mer om telemetriprocessorer.)

Konfigurera sampling med fast hastighet för ASP.NET Core-program

  1. Inaktivera anpassningsbar sampling

    Ändringar kan göras efter WebApplication.CreateBuilder() metoden med hjälp av ApplicationInsightsServiceOptions:

    var builder = WebApplication.CreateBuilder(args);

var aiOptions = new Microsoft.ApplicationInsights.AspNetCore.Extensions.ApplicationInsightsServiceOptions();
aiOptions.EnableAdaptiveSampling = false;
builder.Services.AddApplicationInsightsTelemetry(aiOptions);

var app = builder.Build();

  2. Aktivera modulen för fast sampling

    Ändringar kan göras efter WebApplication.CreateBuilder() metoden:

    var builder = WebApplication.CreateBuilder(args);

builder.Services.Configure<TelemetryConfiguration>(telemetryConfiguration =>
{
    var builder = telemetryConfiguration.DefaultTelemetrySink.TelemetryProcessorChainBuilder;

    // Using fixed rate sampling
    double fixedSamplingPercentage = 10;
    builder.UseSampling(fixedSamplingPercentage);
    builder.Build();
});

builder.Services.AddApplicationInsightsTelemetry(new ApplicationInsightsServiceOptions
{
    EnableAdaptiveSampling = false,
});

var app = builder.Build();

Konfigurera åsidosättningar för sampling och fast sampling för Java-program

Som standard är ingen sampling aktiverad i Java autoinstrumentation och SDK. För närvarande stöds Java-autoinstrumentation, samplings åsidosättningar och sampling med fast hastighet. Anpassningsbar sampling stöds inte i Java.

Konfigurera java-autoinstrumentation

  • Om du vill konfigurera samplings åsidosättningar som åsidosätter standardsamplingsfrekvensen och tillämpar olika samplingsfrekvenser på valda begäranden och beroenden använder du guiden för åsidosättning av sampling.
  • Om du vill konfigurera sampling med fast hastighet som gäller för all telemetri använder du samplingsguiden för fast hastighet.

Kommentar

För samplingsprocenten väljer du en procentandel som är nära 100/N där N är ett heltal. För närvarande stöder sampling inte andra värden.

Konfigurera fast sampling för OpenCensus Python-program

Instrumentera ditt program med de senaste OpenCensus Azure Monitor-exportörerna.

Kommentar

Sampling med fast hastighet är inte tillgängligt för måttexportören. Det innebär att anpassade mått är de enda typerna av telemetri där sampling INTE kan konfigureras. Måttexportören skickar all telemetri som den spårar.

Sampling med fast hastighet för spårning

Du kan ange en som en sampler del av konfigurationen Tracer . Om ingen explicit sampler tillhandahålls används den ProbabilitySampler som standard. Skulle ProbabilitySampler använda en hastighet på 1/10000 som standard, vilket innebär att en av 10 000 begäranden skickas till Application Insights. Om du vill ange en samplingsfrekvens kan du läsa följande information.

Om du vill ange samplingsfrekvensen kontrollerar du att din Tracer anger en provtagare med en samplingsfrekvens mellan 0,0 och 1,0 inklusive. En samplingsfrekvens på 1,0 representerar 100 %, vilket innebär att alla dina begäranden skickas som telemetri till Application Insights.

tracer = Tracer(
    exporter=AzureExporter(
        instrumentation_key='00000000-0000-0000-0000-000000000000',
    ),
    sampler=ProbabilitySampler(1.0),
)

Sampling med fast hastighet för loggar

Du kan konfigurera sampling med fast hastighet för AzureLogHandler genom att ändra det logging_sampling_rate valfria argumentet. Om inget argument anges används en samplingsfrekvens på 1,0. En samplingsfrekvens på 1,0 representerar 100 %, vilket innebär att alla dina begäranden skickas som telemetri till Application Insights.

handler = AzureLogHandler(
    instrumentation_key='00000000-0000-0000-0000-000000000000',
    logging_sampling_rate=0.5,
)

Konfigurera sampling med fast hastighet för webbsidor med JavaScript

JavaScript-baserade webbsidor kan konfigureras att använda Application Insights. Telemetri skickas från klientprogrammet som körs i användarens webbläsare och sidorna kan hanteras från valfri server.

När du konfigurerar dina JavaScript-baserade webbsidor för Application Insights ändrar du det JavaScript-kodfragment som du får från Application Insights-portalen.

Dricks

I ASP.NET appar med JavaScript ingår, går kodfragmentet vanligtvis i _Layout.cshtml.

Infoga en linje som samplingPercentage: 10, före instrumentationsnyckeln:

<script>
    var appInsights = // ... 
    ({ 
      // Value must be 100/N where N is an integer.
      // Valid examples: 50, 25, 20, 10, 5, 1, 0.1, ...
      samplingPercentage: 10, 

      instrumentationKey: ...
    }); 

    window.appInsights = appInsights; 
    appInsights.trackPageView(); 
</script>

Kommentar

Stödet för inmatning av instrumentationsnycklar upphör den 31 mars 2025. Inmatningen av instrumenteringsnyckeln fortsätter att fungera, men vi kommer inte längre att tillhandahålla uppdateringar eller stöd för funktionen. Övergå till anslutningssträng för att dra nytta av nya funktioner.

För samplingsprocenten väljer du en procentandel som är nära 100/N där N är ett heltal. För närvarande stöder sampling inte andra värden.

Samordna sampling på serversidan och på klientsidan

JavaScript SDK på klientsidan deltar i fast sampling med SDK på serversidan. Instrumenterade sidor skickar endast telemetri på klientsidan från samma användare som SDK på serversidan tog sitt beslut att ta med i samplingen. Den här logiken är utformad för att upprätthålla integriteten för användarsessioner i klient- och serverprogram. Därför kan du från ett visst telemetriobjekt i Application Insights hitta alla andra telemetriobjekt för den här användaren eller sessionen och i Sök kan du navigera mellan relaterade sidvyer och begäranden.

Om telemetrin på klient- och serversidan inte visar koordinerade exempel:

  • Kontrollera att du har aktiverat sampling både på servern och klienten.
  • Kontrollera att du anger samma samplingsprocent i både klienten och servern.
  • Kontrollera att SDK-versionen är 2.0 eller senare.

Inmatningssampling

Inmatningssampling fungerar på den punkt där telemetrin från webbservern, webbläsare och enheter når Application Insights-tjänstens slutpunkt. Även om den inte minskar telemetritrafiken som skickas från din app, minskar den mängden som bearbetas och behålls (och debiteras för) av Application Insights.

Använd den här typen av sampling om din app ofta överskrider sin månatliga kvot och du inte har möjlighet att använda någon av de SDK-baserade typerna av sampling.

Ange samplingsfrekvensen på sidan Användning och uppskattade kostnader:

I programmets översiktsfönster väljer du Inställningar, Kvot, Exempel och sedan en samplingsfrekvens och väljer Uppdatera.

Precis som andra typer av sampling behåller algoritmen relaterade telemetriobjekt. När du till exempel inspekterar telemetrin i Sök kan du hitta begäran som är relaterad till ett visst undantag. Måttantal som begärandefrekvens och undantagsfrekvens behålls korrekt.

Sampling tar bort vissa datapunkter, vilket gör dem otillgängliga i alla Application Insights-funktioner, till exempel Kontinuerlig export.

Inmatningssampling fungerar inte tillsammans med anpassningsbar eller fast sampling. Anpassningsbar sampling aktiveras automatiskt med ASP.NET SDK, ASP.NET Core SDK, i Azure App Service eller med Application Insights-agenten. När Application Insights-tjänstslutpunkten tar emot telemetri och identifierar en samplingsfrekvens under 100 % (som anger aktiv sampling) ignorerar den alla angivna samplingsfrekvenser för inmatning.

Varning

Värdet som visas på portalpanelen anger det värde som du angav för inmatningssampling. Den representerar inte den faktiska samplingsfrekvensen om någon form av SDK-sampling (adaptiv eller fast sampling) är i drift.

Vilken typ av sampling ska jag använda?

Använd inmatningssampling om:

  • Du använder ofta din månatliga telemetrikvot.
  • Du får för mycket telemetri från användarnas webbläsare.
  • Du använder en version av SDK som inte stöder sampling – till exempel ASP.NET tidigare versioner än 2.0.

Använd sampling med fast hastighet om:

  • Du behöver synkroniserad sampling mellan klient och server för att navigera mellan relaterade händelser. Till exempel sidvisningar och HTTP-begäranden i Sök när du undersöker händelser.
  • Du är säker på lämplig samplingsprocent för din app. Den bör vara tillräckligt hög för att få korrekta mått, men under den hastighet som överskrider din priskvot och begränsningsgränserna.

Använd anpassningsbar sampling:

Om villkoren för att använda de andra formerna av sampling inte gäller rekommenderar vi anpassningsbar sampling. Den här inställningen är aktiverad som standard i ASP.NET/ASP.NET Core SDK. Det minskar inte trafiken förrän en viss minimifrekvens har nåtts, och därför samplas förmodligen inte webbplatser med låg användning alls.

Kontrollera om sampling är aktiverat

Använd en Analysfråga för att hitta samplingsfrekvensen.

union requests,dependencies,pageViews,browserTimings,exceptions,traces
| where timestamp > ago(1d)
| summarize RetainedPercentage = 100/avg(itemCount) by bin(timestamp, 1h), itemType

Om du ser att RetainedPercentage för någon typ är mindre än 100 innebär det att den typen av telemetri samplas.

Viktigt!

Application Insights samplar inte sessioner, mått (inklusive anpassade mått) eller telemetrityper för prestandaräknare i någon av samplingsteknikerna. Dessa typer undantas alltid från sampling eftersom en minskning av precisionen kan vara mycket oönskad för dessa telemetrityper.

Noggrannhet för loggfrågor och hög samplingsfrekvens

När programmet skalas upp kan det bearbeta dussintals, hundratals eller tusentals arbetsobjekt per sekund. Loggning av en händelse för var och en av dem är inte resurs- eller kostnadseffektiv. Application Insights använder sampling för att anpassa sig till att öka telemetrivolymen på ett flexibelt sätt och för att styra resursanvändning och kostnader.

Varning

En distribuerad åtgärds vyintegritet från slutpunkt till slutpunkt kan påverkas om något program i den distribuerade åtgärden har aktiverat sampling. Olika samplingsbeslut fattas av varje program i en distribuerad åtgärd, så telemetri för ett åtgärds-ID kan sparas av ett program medan andra program kan besluta att inte sampla telemetrin för samma åtgärds-ID.

När samplingsfrekvensen ökar minskar loggbaserade frågors noggrannhet och är uppblåsta. Det påverkar bara noggrannheten för loggbaserade frågor när sampling är aktiverat och exempelfrekvenserna ligger inom ett högre intervall (~ 60 %). Effekten varierar beroende på telemetrityper, telemetriantal per åtgärd och andra faktorer.

SDK:er använder föraggregerade mått för att lösa problem som orsakas av sampling. Mer information om dessa mått finns i Azure Application Insights – Azure Monitor | Microsoft Docs. SDK:erna identifierar relevanta egenskaper för loggade data och extraherar statistik före sampling. För att minimera resursanvändning och kostnader aggregeras mått. Den här processen resulterar i några måtttelemetriobjekt per minut i stället för tusentals händelsetelemetriobjekt. Dessa mått kan till exempel rapportera "den här webbappen bearbetade 25 begäranden" till MDM-kontot, med itemCount 100 i den skickade telemetriposten för begäranden. Dessa föraggregerade mått ger korrekta tal och är tillförlitliga även när sampling påverkar loggbaserade frågeresultat. Du kan visa dem i fönstret Mått i Application Insights-portalen.

Vanliga frågor och svar

Påverkar sampling av aviseringsprecision?

  • Ja. Aviseringar kan bara utlösas vid exempeldata. Aggressiv filtrering kan leda till att aviseringar inte utlöss som förväntat.

Kommentar

Sampling tillämpas inte på mått, men mått kan härledas från exempeldata. På så sätt kan sampling indirekt påverka aviseringsprecisionen.

Vad är standardbeteendet för sampling i ASP.NET och ASP.NET Core SDK:er?

  • Om du använder en av de senaste versionerna av ovanstående SDK aktiveras adaptiv sampling som standard med fem telemetriobjekt per sekund. Systemet lägger som standard till två AdaptiveSamplingTelemetryProcessor noder: den ena innehåller Event typen i sampling, medan den andra exkluderar den. Den här konfigurationen begränsar telemetri till fem Event typobjekt och fem objekt av alla andra typer tillsammans, vilket säkerställer att Events samplas separat från andra telemetrityper.

Använd exemplen i det tidigare avsnittet på den här sidan för att ändra det här standardbeteendet.

Kan telemetri samplas mer än en gång?

  • Nej. SamplingTelemetryProcessors ignorerar objekt från samplingsöverväganden om objektet redan har samplats. Detsamma gäller även för inmatningssampling, som inte tillämpar sampling på de objekt som redan har samplats i själva SDK:n.

Varför samplas inte en enkel "samla in X procent av varje telemetrityp"?

  • Även om den här samplingsmetoden ger hög precision i måttimimeringar, skulle det bryta möjligheten att korrelera diagnostikdata per användare, session och begäran, vilket är viktigt för diagnostiken. Därför fungerar sampling bättre med principer som "samla in alla telemetriobjekt för X procent av appanvändare" eller "samla in all telemetri för X procent av appbegäranden". För de telemetriobjekt som inte är associerade med begäranden (till exempel asynkron bakgrundsbearbetning) är återställningen att "samla in X procent av alla objekt för varje telemetrityp".

Kan samplingsprocenten ändras över tid?

  • Ja, anpassningsbar sampling ändrar gradvis samplingsprocenten, baserat på telemetrins aktuella observerade volym.

Hur vet jag vilken samplingsprocent som passar bäst för min app om jag använder fast sampling?

  • Ett sätt är att börja med anpassningsbar sampling, ta reda på vilken hastighet den sätter på (se ovanstående fråga) och sedan byta till sampling med fast hastighet med hjälp av den frekvensen.

    Annars måste du gissa. Analysera din aktuella telemetrianvändning i Application Insights, observera eventuella begränsningar som inträffar och uppskatta volymen för den insamlade telemetrin. Dessa tre indata, tillsammans med den valda prisnivån, tyder på hur mycket du kanske vill minska volymen för den insamlade telemetrin. En ökning av antalet användare eller något annat skifte i telemetrivolymen kan dock göra uppskattningen ogiltig.

Vad händer om jag konfigurerar samplingsprocenten till för låg?

  • Överdrivet låga samplingsprocenttal orsakar överaggressiv sampling och minskar noggrannheten för approximeringarna när Application Insights försöker kompensera visualiseringen av data för minskning av datavolymer. Diagnostikupplevelsen kan också påverkas negativt eftersom vissa av de sällan misslyckade eller långsamma begäranden kan samplas ut.

Vad händer om jag konfigurerar samplingsprocenten så att den är för hög?

  • Att konfigurera en för hög samplingsprocent (inte tillräckligt aggressiv) resulterar i en otillräcklig minskning av volymen av den insamlade telemetrin. Du kan fortfarande uppleva telemetridataförluster relaterade till begränsning, och kostnaden för att använda Application Insights kan vara högre än du planerade på grund av överförbrukningsavgifter.

Vad händer om jag konfigurerar både inställningarna IncludedTypes och ExcludedTypes?

  • Det är bäst att inte ange både ExcludedTypes och IncludedTypes i konfigurationen för att förhindra konflikter och säkerställa tydliga inställningar för telemetrisamling.
  • Telemetrityper som anges i ExcludedTypes utesluts även om de också anges i IncludedTypes inställningarna. ExcludedTypes har företräde framför IncludedTypes.

På vilka plattformar kan jag använda sampling?

  • Inmatningssampling kan ske automatiskt för telemetri över en viss volym, om SDK:t inte utför sampling. Den här konfigurationen skulle till exempel fungera om du använder en äldre version av ASP.NET SDK eller Java SDK.
  • Om du använder den aktuella ASP.NET eller ASP.NET Core SDK:er (som finns antingen i Azure eller på din egen server) får du anpassningsbar sampling som standard, men du kan växla till fast ränta enligt tidigare beskrivning. Med fast sampling synkroniserar webbläsarens SDK automatiskt med exempelrelaterade händelser.
  • Om du använder den aktuella Java-agenten kan du konfigurera applicationinsights.json (för Java SDK, konfigurera ApplicationInsights.xml) för att aktivera fast sampling. Sampling är inaktiverat som standard. Med fast sampling synkroniserar webbläsarens SDK och servern automatiskt med exempelrelaterade händelser.

Det finns vissa sällsynta händelser jag alltid vill se. Hur får jag dem förbi samplingsmodulen?

  • Det bästa sättet att alltid se vissa händelser är att skriva en anpassad TelemetryInitializer, som anger SamplingPercentage till 100 på telemetriobjektet som du vill behålla, som du ser i följande exempel. Initierare kommer garanterat att köras före telemetriprocessorer (inklusive sampling), så det säkerställer att alla samplingstekniker ignorerar det här objektet från eventuella samplingsöverväganden. Anpassade telemetriinitierare är tillgängliga i ASP.NET SDK, ASP.NET Core SDK, JavaScript SDK och Java SDK. Du kan till exempel konfigurera en telemetriinitierare med hjälp av ASP.NET SDK:

    public class MyTelemetryInitializer : ITelemetryInitializer
{
    public void Initialize(ITelemetry telemetry)
    {
        if(somecondition)
        {
            ((ISupportSampling)telemetry).SamplingPercentage = 100;
        }
    }
}

Äldre SDK-versioner

Anpassningsbar sampling är tillgängligt för Application Insights SDK för ASP.NET v2.0.0-beta3 och senare, Microsoft.ApplicationInsights.AspNetCore SDK v2.2.0-beta1 och senare, och är aktiverat som standard.

Sampling med fast hastighet är en funktion i SDK:t i ASP.NET versioner från 2.0.0 och Java SDK version 2.0.1 och senare.

Före v2.5.0-beta2 av ASP.NET SDK och v2.2.0-beta3 av ASP.NET Core SDK förlitade sig samplingsbeslut för program som definierar "användare" (som de flesta webbprogram) på användar-ID:ts hash. För program som inte definierar användare (till exempel webbtjänster) baserades beslutet på begärans åtgärds-ID. De senaste versionerna av både ASP.NET och ASP.NET Core SDK:er använder nu åtgärds-ID:t för samplingsbeslut.

Nästa steg