Monitorování aplikací .NET a Node.js pomocí Application Insights (klasické rozhraní API)

Poznámka:

Projděte si doprovodné materiály k sadě Application Insights SDK pro naše zásady podpory klasické sady API SDK.

Upozornění

Pro nové aplikace nebo zákazníky doporučujeme použít distribuci Azure Monitor OpenTelemetry k podpoře Azure Monitor Application Insights. Distribuce OpenTelemetry služby Azure Monitor poskytuje podobné funkce a prostředí jako sada Application Insights SDK. Ze sady Application Insights SDK je možné migrovat pomocí průvodců migrací pro .NET, Node.js a Python, ale stále pracujeme na přidání několika dalších funkcí pro zpětnou kompatibilitu.

Tento článek vysvětluje, jak povolit a nakonfigurovat Application Insights pro .NET (ASP.NET, ASP.NET Core a pracovní službu) a aplikace Node.js. Application Insights může shromažďovat následující telemetrická data z vašich aplikací:

• Requests
• Závislosti
• Exceptions
• Čítače výkonu
• Trasování (protokoly)
• Tlukot srdce
• Vlastní události a metriky (vyžaduje ruční instrumentaci)
• Zobrazení stránek (vyžaduje javascriptovou sadu SDK pro webové stránky)
• Testy dostupnosti (vyžaduje ruční nastavení testů dostupnosti)

Podporované scénáře

.NET

Podporováno	ASP.NET	ASP.NET Core	Pracovní služba
Operační systém	Windows	Windows, Linux nebo macOS	Windows, Linux nebo macOS
Metoda hostování	In-process (IIS nebo IIS Express)	V rámci procesu nebo mimo proces	Konzola nebo služba na pozadí (spouští se jako proces, obvykle přes dotnet CLI nebo jako Windows služba nebo linuxový démon)
Metoda nasazení	Nasazení webu, MSI nebo ruční kopírování souborů	Závislé na frameworku nebo samostatné	Závislé na frameworku nebo samostatné
Webový server	IIS (Internetová informační služba)	Internetový informační server (IIS) nebo Kestrel	Nejde použít (žádný webový server, navržený pro úlohy mimo PROTOKOL HTTP, jako jsou zasílání zpráv, úlohy na pozadí a konzolové aplikace)
Platforma pro hostování	Azure App Service (Windows), Azure Virtual Machines nebo místní servery	Funkce Web Apps pro Azure App Service, Azure Virtual Machines, Docker a Azure Kubernetes Service (AKS)	Azure Virtual Machines, Azure Kubernetes Service (AKS), kontejnery nebo jakékoli prostředí, ve kterém se podporuje .NET Core
Verze .NET	.NET Framework 4.6.1 a novější	Všechny oficiálně podporované verze .NET , které nejsou ve verzi Preview	Všechny oficiálně podporované verze .NET , které nejsou ve verzi Preview
IDE	Visual Studio	Visual Studio, Visual Studio Code nebo příkazový řádek	Visual Studio, Visual Studio Code nebo příkazový řádek

SDK pro pracovní služby nesbírá žádná data telemetrie samostatně. Místo toho přináší další dobře známé automatické kolektory Application Insights, jako je DependencyCollector, PerfCounterCollector a ApplicationInsightsLoggingProvider. Tento SDK zveřejňuje rozšiřující metody na IServiceCollection pro povolení a konfiguraci shromažďování telemetrie.

Poznámka:

Pracovní služba je dlouhotrvající aplikace na pozadí, která spouští úlohy mimo kanál požadavku/odpovědi HTTP. Application Insights SDK pro Worker Service je možné použít v nově zavedené .NET Core Worker Service, úlohách na pozadí v ASP.NET Core a konzolových aplikacích, například .NET Core a .NET Framework.

Node.js

Podporováno	Node.js
Operační systém	Windows, Linux nebo macOS
Metoda hostování	Konzola nebo služba na pozadí (spouští se jako proces prostřednictvím příkazů uzlu nebo skriptů npm)
Metoda nasazení	Závislý na architektuře (vyžaduje Node.js runtime nainstalované prostřednictvím balíčku npm)
Webový server	Integrované moduly HTTP nebo webové architektury (Express, Fastify atd.) nebo nejsou použitelné pro úlohy mimo PROTOKOL HTTP
Platforma pro hostování	Azure App Service, Azure Virtual Machines, Azure Kubernetes Service (AKS), Docker, místní prostředí nebo jakékoli prostředí, ve kterém se Node.js podporuje
Node.js verze	Všechny oficiálně podporované verze Node.js LTS (aktuálně 18.19.0 nebo 20.6.0 nebo novější pro SDK 3.X)
IDE	Visual Studio Code, Visual Studio nebo příkazový řádek

Klientská knihovna Node.js může automaticky monitorovat příchozí a odchozí požadavky HTTP, výjimky a některé systémové metriky. Od verze 0.20 může klientská knihovna také monitorovat některé běžné balíčky třetích stran, jako jsou MongoDB, MySQL a Redis.

Všechny události související s příchozím požadavkem HTTP se korelují za účelem rychlejšího řešení potíží.

Pomocí rozhraní API TelemetryClient můžete ručně instrumentovat a monitorovat další aspekty vaší aplikace a systému. Rozhraní TelemetryClient API popisujeme podrobněji dále v tomto článku.

Přidání Application Insights

.NET

Požadavky

• Předplatné služby Azure. Pokud ho ještě nemáte, vytvořte si bezplatný účet Azure.
• Prostředek založený na pracovním prostoru Application Insights
• Funkční aplikace. Pokud ho ještě nemáte, přečtěte si téma Vytvoření základní webové aplikace.
• Nejnovější verze sady Visual Studio s následujícími pracovními zátěžemi:
  • vývoj pro ASP.NET a web
  • Vývoj pro Azure

Vytvoření základní webové aplikace

Pokud ještě nemáte funkční webovou aplikaci, můžete ji vytvořit pomocí následujících doprovodných materiálů.

ASP.NET

1. Otevřete Visual Studio.
2. Vyberte Vytvořit nový projekt.
3. Zvolte ASP.NET webovou aplikaci (.NET Framework) s jazykem C# a vyberte Další.
4. Zadejte název projektu a pak vyberte Vytvořit.
5. Zvolte MVC a pak vyberte Vytvořit.

ASP.NET Core

1. Otevřete Visual Studio.
2. Vyberte Vytvořit nový projekt.
3. V jazyce C# zvolte ASP.NET Základní webová aplikace (Razor Pages) a vyberte Další.
4. Zadejte název projektu a pak vyberte Vytvořit.
5. Zvolte architekturu (LTS nebo STS) a pak vyberte Vytvořit.

Automatické přidání Application Insights (Visual Studio)

Tato část vás provede automatickým přidáním Application Insights do webové aplikace založené na šablonách.

ASP.NET

Poznámka:

V sadě Visual Studio 2019 je známý problém: ukládání instrumentačního klíče nebo připojovacích řetězců v uživatelském tajném klíči nefunguje pro aplikace založené na rozhraní .NET Framework. Klíč musí být nakonec pevně zakódován do souboru Applicationinsights.config , aby se tato chyba vyřešila.

V rámci projektu webové aplikace v ASP.NET v sadě Visual Studio:

1. Vyberte Projekt>Přidat telemetrii Application Insights>Application Insights SDK (lokální)>Další>Dokončit>Zavřít

2. Otevřete soubor ApplicationInsights.config.

3. Před koncovou </ApplicationInsights> značku přidejte řádek, který obsahuje připojovací řetězec prostředku Application Insights. Vyhledejte připojovací řetězec na podokně přehledu nově vytvořeného prostředku Application Insights.

   <ConnectionString>Copy connection string from Application Insights Resource Overview</ConnectionString>
   

4. Vyberte Projekt>Spravovat balíčky NuGet>Aktualizace. Pak aktualizujte každý Microsoft.ApplicationInsights balíček NuGet na nejnovější stabilní verzi.

5. Spusťte aplikaci výběrem služby IIS Express. Otevře se základní ASP.NET aplikace. Při procházení stránek na webu se telemetrie odesílá do Application Insights.

ASP.NET Core

Poznámka:

Pokud chcete pro ASP.NET aplikaci použít samostatného zprostředkovatele ILogger, použijte Microsoft.Extensions.Logging.ApplicationInsight.

Důležité

Pro Visual Studio pro macOS použijte ruční pokyny. Tento postup podporuje pouze verze windows sady Visual Studio.

V rámci projektu webové aplikace v ASP.NET v sadě Visual Studio:

1. Přejděte na Project>Add Application Insights Telemetry.

2. Vyberte Azure Application Insights>Další.

3. Zvolte své předplatné a instanci Application Insights. Nebo můžete vytvořit novou instanci pomocí příkazu Vytvořit novou. Vyberte Další.

4. Přidejte nebo potvrďte připojovací řetězec Application Insights. Měla by být předem vyplněna na základě vašeho výběru v předchozím kroku. Vyberte Dokončit.

5. Po přidání Application Insights do projektu zkontrolujte, jestli používáte nejnovější stabilní verzi sady SDK. Přejděte do Projekt>Spravovat balíčky NuGet>Microsoft.ApplicationInsights.AspNetCore. Pokud potřebujete, vyberte Aktualizovat.

   

Ruční přidání nástroje Application Insights (bez použití sady Visual Studio)

Tato část vás provede ručním přidáním Application Insights do webové aplikace založené na šablonách.

ASP.NET

1. Do projektu přidejte následující balíčky NuGet a jejich závislosti:

   • Microsoft.ApplicationInsights.WindowsServer
   • Microsoft.ApplicationInsights.Web
   • Microsoft.AspNet.TelemetryCorrelation

2. V některých případech se automaticky vytvoří soubor ApplicationInsights.config . Pokud už soubor existuje, přejděte ke kroku 4.

   Pokud chybí, vytvořte si ho sami. V kořenovém adresáři ASP.NET aplikace vytvořte nový soubor s názvem ApplicationInsights.config.

3. Do nově vytvořeného souboru zkopírujte následující konfiguraci XML:

   
   
   Rozbalením zobrazíte konfiguraci.

   <?xml version="1.0" encoding="utf-8"?>
   <ApplicationInsights xmlns="http://schemas.microsoft.com/ApplicationInsights/2013/Settings">
     <TelemetryInitializers>
       <Add Type="Microsoft.ApplicationInsights.DependencyCollector.HttpDependenciesParsingTelemetryInitializer, Microsoft.AI.DependencyCollector" />
       <Add Type="Microsoft.ApplicationInsights.WindowsServer.AzureRoleEnvironmentTelemetryInitializer, Microsoft.AI.WindowsServer" />
       <Add Type="Microsoft.ApplicationInsights.WindowsServer.BuildInfoConfigComponentVersionTelemetryInitializer, Microsoft.AI.WindowsServer" />
       <Add Type="Microsoft.ApplicationInsights.Web.WebTestTelemetryInitializer, Microsoft.AI.Web" />
       <Add Type="Microsoft.ApplicationInsights.Web.SyntheticUserAgentTelemetryInitializer, Microsoft.AI.Web">
         <!-- Extended list of bots:
               search|spider|crawl|Bot|Monitor|BrowserMob|BingPreview|PagePeeker|WebThumb|URL2PNG|ZooShot|GomezA|Google SketchUp|Read Later|KTXN|KHTE|Keynote|Pingdom|AlwaysOn|zao|borg|oegp|silk|Xenu|zeal|NING|htdig|lycos|slurp|teoma|voila|yahoo|Sogou|CiBra|Nutch|Java|JNLP|Daumoa|Genieo|ichiro|larbin|pompos|Scrapy|snappy|speedy|vortex|favicon|indexer|Riddler|scooter|scraper|scrubby|WhatWeb|WinHTTP|voyager|archiver|Icarus6j|mogimogi|Netvibes|altavista|charlotte|findlinks|Retreiver|TLSProber|WordPress|wsr-agent|http client|Python-urllib|AppEngine-Google|semanticdiscovery|facebookexternalhit|web/snippet|Google-HTTP-Java-Client-->
         <Filters>search|spider|crawl|Bot|Monitor|AlwaysOn</Filters>
       </Add>
       <Add Type="Microsoft.ApplicationInsights.Web.ClientIpHeaderTelemetryInitializer, Microsoft.AI.Web" />
       <Add Type="Microsoft.ApplicationInsights.Web.AzureAppServiceRoleNameFromHostNameHeaderInitializer, Microsoft.AI.Web" />
       <Add Type="Microsoft.ApplicationInsights.Web.OperationNameTelemetryInitializer, Microsoft.AI.Web" />
       <Add Type="Microsoft.ApplicationInsights.Web.OperationCorrelationTelemetryInitializer, Microsoft.AI.Web" />
       <Add Type="Microsoft.ApplicationInsights.Web.UserTelemetryInitializer, Microsoft.AI.Web" />
       <Add Type="Microsoft.ApplicationInsights.Web.AuthenticatedUserIdTelemetryInitializer, Microsoft.AI.Web" />
       <Add Type="Microsoft.ApplicationInsights.Web.AccountIdTelemetryInitializer, Microsoft.AI.Web" />
       <Add Type="Microsoft.ApplicationInsights.Web.SessionTelemetryInitializer, Microsoft.AI.Web" />
     </TelemetryInitializers>
     <TelemetryModules>
       <Add Type="Microsoft.ApplicationInsights.DependencyCollector.DependencyTrackingTelemetryModule, Microsoft.AI.DependencyCollector">
         <ExcludeComponentCorrelationHttpHeadersOnDomains>
           <!-- 
           Requests to the following hostnames will not be modified by adding correlation headers.
           Add entries here to exclude additional hostnames.
           NOTE: this configuration will be lost upon NuGet upgrade.
           -->
           <Add>core.windows.net</Add>
           <Add>core.chinacloudapi.cn</Add>
           <Add>core.cloudapi.de</Add>
           <Add>core.usgovcloudapi.net</Add>
         </ExcludeComponentCorrelationHttpHeadersOnDomains>
         <IncludeDiagnosticSourceActivities>
           <Add>Microsoft.Azure.EventHubs</Add>
           <Add>Azure.Messaging.ServiceBus</Add>
         </IncludeDiagnosticSourceActivities>
       </Add>
       <Add Type="Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.PerformanceCollectorModule, Microsoft.AI.PerfCounterCollector">
         <!--
         Use the following syntax here to collect additional performance counters:
   
         <Counters>
           <Add PerformanceCounter="\Process(??APP_WIN32_PROC??)\Handle Count" ReportAs="Process handle count" />
           ...
         </Counters>
   
         PerformanceCounter must be either \CategoryName(InstanceName)\CounterName or \CategoryName\CounterName
   
         NOTE: performance counters configuration will be lost upon NuGet upgrade.
   
         The following placeholders are supported as InstanceName:
           ??APP_WIN32_PROC?? - instance name of the application process for Win32 counters.
           ??APP_W3SVC_PROC?? - instance name of the application IIS worker process for IIS/ASP.NET counters.
           ??APP_CLR_PROC?? - instance name of the application CLR process for .NET counters.
         -->
       </Add>
       <Add Type="Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse.QuickPulseTelemetryModule, Microsoft.AI.PerfCounterCollector" />
       <Add Type="Microsoft.ApplicationInsights.WindowsServer.AppServicesHeartbeatTelemetryModule, Microsoft.AI.WindowsServer" />
       <Add Type="Microsoft.ApplicationInsights.WindowsServer.AzureInstanceMetadataTelemetryModule, Microsoft.AI.WindowsServer">
         <!--
         Remove individual fields collected here by adding them to the ApplicationInsighs.HeartbeatProvider
         with the following syntax:
   
         <Add Type="Microsoft.ApplicationInsights.Extensibility.Implementation.Tracing.DiagnosticsTelemetryModule, Microsoft.ApplicationInsights">
           <ExcludedHeartbeatProperties>
             <Add>osType</Add>
             <Add>location</Add>
             <Add>name</Add>
             <Add>offer</Add>
             <Add>platformFaultDomain</Add>
             <Add>platformUpdateDomain</Add>
             <Add>publisher</Add>
             <Add>sku</Add>
             <Add>version</Add>
             <Add>vmId</Add>
             <Add>vmSize</Add>
             <Add>subscriptionId</Add>
             <Add>resourceGroupName</Add>
             <Add>placementGroupId</Add>
             <Add>tags</Add>
             <Add>vmScaleSetName</Add>
           </ExcludedHeartbeatProperties>
         </Add>
   
         NOTE: exclusions will be lost upon upgrade.
         -->
       </Add>
       <Add Type="Microsoft.ApplicationInsights.WindowsServer.DeveloperModeWithDebuggerAttachedTelemetryModule, Microsoft.AI.WindowsServer" />
       <Add Type="Microsoft.ApplicationInsights.WindowsServer.UnhandledExceptionTelemetryModule, Microsoft.AI.WindowsServer" />
       <Add Type="Microsoft.ApplicationInsights.WindowsServer.UnobservedExceptionTelemetryModule, Microsoft.AI.WindowsServer">
         <!--</Add>
       <Add Type="Microsoft.ApplicationInsights.WindowsServer.FirstChanceExceptionStatisticsTelemetryModule, Microsoft.AI.WindowsServer">-->
       </Add>
       <Add Type="Microsoft.ApplicationInsights.Web.RequestTrackingTelemetryModule, Microsoft.AI.Web">
         <Handlers>
           <!-- 
           Add entries here to filter out additional handlers:
   
           NOTE: handler configuration will be lost upon NuGet upgrade.
           -->
           <Add>Microsoft.VisualStudio.Web.PageInspector.Runtime.Tracing.RequestDataHttpHandler</Add>
           <Add>System.Web.StaticFileHandler</Add>
           <Add>System.Web.Handlers.AssemblyResourceLoader</Add>
           <Add>System.Web.Optimization.BundleHandler</Add>
           <Add>System.Web.Script.Services.ScriptHandlerFactory</Add>
           <Add>System.Web.Handlers.TraceHandler</Add>
           <Add>System.Web.Services.Discovery.DiscoveryRequestHandler</Add>
           <Add>System.Web.HttpDebugHandler</Add>
         </Handlers>
       </Add>
       <Add Type="Microsoft.ApplicationInsights.Web.ExceptionTrackingTelemetryModule, Microsoft.AI.Web" />
       <Add Type="Microsoft.ApplicationInsights.Web.AspNetDiagnosticTelemetryModule, Microsoft.AI.Web" />
     </TelemetryModules>
     <ApplicationIdProvider Type="Microsoft.ApplicationInsights.Extensibility.Implementation.ApplicationId.ApplicationInsightsApplicationIdProvider, Microsoft.ApplicationInsights" />
     <TelemetrySinks>
       <Add Name="default">
         <TelemetryProcessors>
           <Add Type="Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse.QuickPulseTelemetryProcessor, Microsoft.AI.PerfCounterCollector" />
           <Add Type="Microsoft.ApplicationInsights.Extensibility.AutocollectedMetricsExtractor, Microsoft.ApplicationInsights" />
           <Add Type="Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel.AdaptiveSamplingTelemetryProcessor, Microsoft.AI.ServerTelemetryChannel">
             <MaxTelemetryItemsPerSecond>5</MaxTelemetryItemsPerSecond>
             <ExcludedTypes>Event</ExcludedTypes>
           </Add>
           <Add Type="Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel.AdaptiveSamplingTelemetryProcessor, Microsoft.AI.ServerTelemetryChannel">
             <MaxTelemetryItemsPerSecond>5</MaxTelemetryItemsPerSecond>
             <IncludedTypes>Event</IncludedTypes>
           </Add>
           <!--
             Adjust the include and exclude examples to specify the desired semicolon-delimited types. (Dependency, Event, Exception, PageView, Request, Trace)
           -->
         </TelemetryProcessors>
         <TelemetryChannel Type="Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel.ServerTelemetryChannel, Microsoft.AI.ServerTelemetryChannel" />
       </Add>
     </TelemetrySinks>
     <!-- 
       Learn more about Application Insights configuration with ApplicationInsights.config here:
       http://go.microsoft.com/fwlink/?LinkID=513840
     -->
     <ConnectionString>Copy the connection string from your Application Insights resource</ConnectionString>
   </ApplicationInsights>
   

4. Přidejte připojovací řetězec, který lze provést dvěma způsoby:

   • (Doporučeno) Nastavte připojovací řetězec v konfiguraci.

     Před koncovou značku </ApplicationInsights> v ApplicationInsights.config přidejte řetězec připojení k prostředku Application Insights. Své připojovací řetězce najdete na panelu přehledu nově vytvořeného prostředku Application Insights.

     <ConnectionString>Copy the connection string from your Application Insights resource</ConnectionString>
     

   • Nastavte připojovací řetězec v kódu.

     Do třídy program.cs zadejte připojovací řetězec.

     var configuration = new TelemetryConfiguration
     {
         ConnectionString = "Copy the connection string from your Application Insights resource"
     };
     

5. Na stejné úrovni projektu jako soubor ApplicationInsights.config vytvořte složku s názvem ErrorHandler s novým souborem C# s názvem AiHandleErrorAttribute.cs. Obsah souboru vypadá takto:

   using System;
   using System.Web.Mvc;
   using Microsoft.ApplicationInsights;
   
   namespace WebApplication10.ErrorHandler //namespace will vary based on your project name
   {
       [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)] 
       public class AiHandleErrorAttribute : HandleErrorAttribute
       {
           public override void OnException(ExceptionContext filterContext)
           {
               if (filterContext != null && filterContext.HttpContext != null && filterContext.Exception != null)
               {
                   //If customError is Off, then AI HTTPModule will report the exception
                   if (filterContext.HttpContext.IsCustomErrorEnabled)
                   {   
                       var ai = new TelemetryClient();
                       ai.TrackException(filterContext.Exception);
                   } 
               }
               base.OnException(filterContext);
           }
       }
   }
   

6. Ve složce App_Start otevřete soubor FilterConfig.cs a změňte ho tak, aby odpovídal ukázce:

   using System.Web;
   using System.Web.Mvc;
   
   namespace WebApplication10 //Namespace will vary based on project name
   {
       public class FilterConfig
       {
           public static void RegisterGlobalFilters(GlobalFilterCollection filters)
           {
               filters.Add(new ErrorHandler.AiHandleErrorAttribute());
           }
       }
   }
   

7. Pokud je soubor Web.config již aktualizován, tento krok přeskočte. V opačném případě aktualizujte soubor následujícím způsobem:

   
   
   Rozbalením zobrazíte konfiguraci.

   <?xml version="1.0" encoding="utf-8"?>
   <!--
     For more information on how to configure your ASP.NET application, please visit
     https://go.microsoft.com/fwlink/?LinkId=301880
     -->
   <configuration>
     <appSettings>
       <add key="webpages:Version" value="3.0.0.0" />
       <add key="webpages:Enabled" value="false" />
       <add key="ClientValidationEnabled" value="true" />
       <add key="UnobtrusiveJavaScriptEnabled" value="true" />
     </appSettings>
     <system.web>
       <compilation debug="true" targetFramework="4.7.2" />
       <httpRuntime targetFramework="4.7.2" />
       <!-- Code added for Application Insights start -->
       <httpModules>
         <add name="TelemetryCorrelationHttpModule" type="Microsoft.AspNet.TelemetryCorrelation.TelemetryCorrelationHttpModule, Microsoft.AspNet.TelemetryCorrelation" />
         <add name="ApplicationInsightsWebTracking" type="Microsoft.ApplicationInsights.Web.ApplicationInsightsHttpModule, Microsoft.AI.Web" />
       </httpModules>
       <!-- Code added for Application Insights end -->
     </system.web>
     <runtime>
       <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
         <dependentAssembly>
           <assemblyIdentity name="Antlr3.Runtime" publicKeyToken="eb42632606e9261f" />
           <bindingRedirect oldVersion="0.0.0.0-3.5.0.2" newVersion="3.5.0.2" />
         </dependentAssembly>
         <dependentAssembly>
           <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" />
           <bindingRedirect oldVersion="0.0.0.0-12.0.0.0" newVersion="12.0.0.0" />
         </dependentAssembly>
         <dependentAssembly>
           <assemblyIdentity name="System.Web.Optimization" publicKeyToken="31bf3856ad364e35" />
           <bindingRedirect oldVersion="1.0.0.0-1.1.0.0" newVersion="1.1.0.0" />
         </dependentAssembly>
         <dependentAssembly>
           <assemblyIdentity name="WebGrease" publicKeyToken="31bf3856ad364e35" />
           <bindingRedirect oldVersion="0.0.0.0-1.6.5135.21930" newVersion="1.6.5135.21930" />
         </dependentAssembly>
         <dependentAssembly>
           <assemblyIdentity name="System.Web.Helpers" publicKeyToken="31bf3856ad364e35" />
           <bindingRedirect oldVersion="1.0.0.0-3.0.0.0" newVersion="3.0.0.0" />
         </dependentAssembly>
         <dependentAssembly>
           <assemblyIdentity name="System.Web.WebPages" publicKeyToken="31bf3856ad364e35" />
           <bindingRedirect oldVersion="1.0.0.0-3.0.0.0" newVersion="3.0.0.0" />
         </dependentAssembly>
         <dependentAssembly>
           <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" />
           <bindingRedirect oldVersion="1.0.0.0-5.2.7.0" newVersion="5.2.7.0" />
         </dependentAssembly>
         <!-- Code added for Application Insights start -->
         <dependentAssembly>
           <assemblyIdentity name="System.Memory" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
           <bindingRedirect oldVersion="0.0.0.0-4.0.1.1" newVersion="4.0.1.1" />
         </dependentAssembly>
         <!-- Code added for Application Insights end -->
       </assemblyBinding>
     </runtime>
     <system.codedom>
       <compilers>
         <compiler language="c#;cs;csharp" extension=".cs" type="Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider, Microsoft.CodeDom.Providers.DotNetCompilerPlatform, Version=2.0.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" warningLevel="4" compilerOptions="/langversion:default /nowarn:1659;1699;1701" />
         <compiler language="vb;vbs;visualbasic;vbscript" extension=".vb" type="Microsoft.CodeDom.Providers.DotNetCompilerPlatform.VBCodeProvider, Microsoft.CodeDom.Providers.DotNetCompilerPlatform, Version=2.0.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" warningLevel="4" compilerOptions="/langversion:default /nowarn:41008 /define:_MYTYPE=\&quot;Web\&quot; /optionInfer+" />
       </compilers>
     </system.codedom>
     <system.webServer>
       <validation validateIntegratedModeConfiguration="false" />
       <!-- Code added for Application Insights start -->
       <modules>
         <remove name="TelemetryCorrelationHttpModule" />
         <add name="TelemetryCorrelationHttpModule" type="Microsoft.AspNet.TelemetryCorrelation.TelemetryCorrelationHttpModule, Microsoft.AspNet.TelemetryCorrelation" preCondition="managedHandler" />
         <remove name="ApplicationInsightsWebTracking" />
         <add name="ApplicationInsightsWebTracking" type="Microsoft.ApplicationInsights.Web.ApplicationInsightsHttpModule, Microsoft.AI.Web" preCondition="managedHandler" />
       </modules>
       <!-- Code added for Application Insights end -->
     </system.webServer>
   </configuration>
   

V tomto okamžiku jste úspěšně nakonfigurovali monitorování aplikací na straně serveru. Pokud spustíte webovou aplikaci, uvidíte, že se v Application Insights začnou zobrazovat telemetrie.

ASP.NET Core

1. Nainstalujte balíček NuGet sady Application Insights SDK pro ASP.NET Core.

   Doporučujeme vždy používat nejnovější stabilní verzi. Úplné poznámky k verzi sady SDK najdete v opensourcovém úložišti GitHubu.

   Následující ukázka kódu ukazuje změny, které se mají přidat do souboru .csproj projektu:

   <ItemGroup>
       <PackageReference Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.21.0" />
   </ItemGroup>
   

2. Přidejte AddApplicationInsightsTelemetry() do program.cs třídy.

   Přidejte builder.Services.AddApplicationInsightsTelemetry(); za metodu WebApplication.CreateBuilder(), jak je znázorněno v tomto příkladu:

   // This method gets called by the runtime. Use this method to add services to the container.
   var builder = WebApplication.CreateBuilder(args);
   
   // The following line enables Application Insights telemetry collection.
   builder.Services.AddApplicationInsightsTelemetry();
   
   // This code adds other services for your application.
   builder.Services.AddMvc();
   
   var app = builder.Build();
   

3. Přidejte připojovací řetězec, což lze provést třemi způsoby:

   • (Doporučeno) Nastavte připojovací řetězec v konfiguraci.

     Nastavte připojovací řetězec v appsettings.json a ujistěte se, že se konfigurační soubor během publikování zkopíruje do kořenové složky aplikace.

     {
         "Logging": {
             "LogLevel": {
                 "Default": "Information",
                 "Microsoft.AspNetCore": "Warning"
             }
         },
         "AllowedHosts": "*",
         "ApplicationInsights": {
             "ConnectionString": "<YOUR-CONNECTION-STRING>"
         }
     }
     

   • Nastavte připojovací řetězec buď v proměnné prostředí APPLICATIONINSIGHTS_CONNECTION_STRING, nebo v konfiguračním souboru JSON ApplicationInsights:ConnectionString.

     Například:

     • SET ApplicationInsights:ConnectionString = <Copy connection string from Application Insights Resource Overview>
     • SET APPLICATIONINSIGHTS_CONNECTION_STRING = <Copy connection string from Application Insights Resource Overview>
     • Obvykle se používá ve službě APPLICATIONINSIGHTS_CONNECTION_STRING Web Apps. Dá se použít také na všech místech, kde je tato sada SDK podporovaná.

     Poznámka:

     Připojovací řetězec zadaný v kódu má přednost před proměnnou APPLICATIONINSIGHTS_CONNECTION_STRING prostředí, která má přednost před dalšími možnostmi.

   • Nastavte připojovací řetězec v kódu.

     Ve třídě ApplicationInsightsServiceOptions zadejte připojovací řetězec jako součást argumentu AddApplicationInsightsTelemetry pro .

Tajné kódy uživatelů a další poskytovatelé konfigurace

Pokud chcete uložit připojovací řetězec do uživatelských tajemství ASP.NET Core nebo ho načíst z jiného poskytovatele konfigurace, můžete použít přetížení s parametrem Microsoft.Extensions.Configuration.IConfiguration. Příkladem parametru je services.AddApplicationInsightsTelemetry(Configuration);.

Ve verzi Microsoft.ApplicationInsights.AspNetCore, počínaje verzí 2.15.0, volání services.AddApplicationInsightsTelemetry() automaticky přečte připojovací řetězec z Microsoft.Extensions.Configuration.IConfiguration aplikace. Není nutné explicitně zadávat IConfiguration.

Pokud IConfiguration se načte konfigurace od více poskytovatelů, určuje services.AddApplicationInsightsTelemetry prioritu konfigurace z appsettings.jsonbez ohledu na pořadí, ve kterém jsou zprostředkovatelé přidáni. Použijte metodu services.AddApplicationInsightsTelemetry(IConfiguration) ke čtení konfigurace z IConfiguration, aniž by bylo zvýhodněno zacházení s appsettings.json.

Pracovní služba

V této části

• Použití sady Application Insights SDK pro pracovní službu
• Aplikace .NET Core Worker Service
• ASP.NET úlohy na pozadí jádra s hostovanými službami
• Konzolová aplikace .NET Core/.NET Framework

Použití sady Application Insights SDK pro pracovní službu

1. Nainstalujte do aplikace balíček Microsoft.ApplicationInsights.WorkerService .

   Následující fragment kódu ukazuje změny, které je potřeba přidat do souboru projektu .csproj :

       <ItemGroup>
           <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.22.0" />
       </ItemGroup>
   

2. Nakonfigurujte připojovací řetězec v proměnné prostředí APPLICATIONINSIGHTS_CONNECTION_STRING nebo v konfiguračním souboru appsettings.json.

   

3. Načtěte instanci ILogger nebo instanci TelemetryClient z kontejneru injekce závislostí (DI) pomocí volání serviceProvider.GetRequiredService<TelemetryClient>(); nebo použitím injekce konstruktoru. Tento krok aktivuje nastavení modulů TelemetryConfiguration a automatického sběru dat.

Konkrétní pokyny pro každý typ aplikace jsou popsány v následujících částech.

Aplikace .NET Core Worker Service

Úplný příklad se sdílí na webu NuGet.

1. Stáhněte a nainstalujte sadu .NET SDK.

2. Vytvořte nový projekt Služby pracovních procesů pomocí nové šablony projektu sady Visual Studio nebo příkazového řádku dotnet new worker.

3. Přidejte do aplikace balíček Microsoft.ApplicationInsights.WorkerService .

4. Přidejte services.AddApplicationInsightsTelemetryWorkerService(); do metody CreateHostBuilder() ve třídě Program.cs, jak je znázorněno v tomto příkladu:

       public static IHostBuilder CreateHostBuilder(string[] args) =>
           Host.CreateDefaultBuilder(args)
               .ConfigureServices((hostContext, services) =>
               {
                   services.AddHostedService<Worker>();
                   services.AddApplicationInsightsTelemetryWorkerService();
               });
   

5. Upravte vaše Worker.cs podle následujícího příkladu:

       using Microsoft.ApplicationInsights;
       using Microsoft.ApplicationInsights.DataContracts;
   
       public class Worker : BackgroundService
       {
           private readonly ILogger<Worker> _logger;
           private TelemetryClient _telemetryClient;
           private static HttpClient _httpClient = new HttpClient();
   
           public Worker(ILogger<Worker> logger, TelemetryClient tc)
           {
               _logger = logger;
               _telemetryClient = tc;
           }
   
           protected override async Task ExecuteAsync(CancellationToken stoppingToken)
           {
               while (!stoppingToken.IsCancellationRequested)
               {
                   _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
   
                   using (_telemetryClient.StartOperation<RequestTelemetry>("operation"))
                   {
                       _logger.LogWarning("A sample warning message. By default, logs with severity Warning or higher is captured by Application Insights");
                       _logger.LogInformation("Calling bing.com");
                       var res = await _httpClient.GetAsync("https://bing.com");
                       _logger.LogInformation("Calling bing completed with status:" + res.StatusCode);
                       _telemetryClient.TrackEvent("Bing call event completed");
                   }
   
                   await Task.Delay(1000, stoppingToken);
               }
           }
       }
   

6. Nastavte připojovací řetězec.

   

   Poznámka:

   Doporučujeme zadat připojovací řetězec v konfiguraci. Následující ukázka kódu ukazuje, jak zadat připojovací řetězec v appsettings.jsonsouboru . Během publikování se ujistěte, že appsettings.json se zkopíruje do kořenové složky aplikace.

       {
           "ApplicationInsights":
           {
               "ConnectionString" : "<YOUR-CONNECTION-STRING>"
           },
           "Logging":
           {
               "LogLevel":
               {
                   "Default": "Warning"
               }
           }
       }
   

Případně zadejte připojovací řetězec v proměnné prostředí APPLICATIONINSIGHTS_CONNECTION_STRING.

APPLICATIONINSIGHTS_CONNECTION_STRING Obvykle určuje připojovací řetězec pro aplikace nasazené do webových aplikací jako webové úlohy.

Poznámka:

Připojovací řetězec zadaný v kódu má přednost před proměnnou APPLICATIONINSIGHTS_CONNECTION_STRINGprostředí, která má přednost před jinými možnostmi.

ASP.NET úlohy na pozadí jádra s hostovanými službami

Tento dokument popisuje, jak vytvořit úlohy na pozadí v aplikaci ASP.NET Core.

Úplný příklad se sdílí na této stránce GitHubu.

1. Nainstalujte do aplikace balíček Microsoft.ApplicationInsights.WorkerService .

2. Přidejte services.AddApplicationInsightsTelemetryWorkerService(); do metody, jak je znázorněno v tomto příkladu ConfigureServices() :

       public static async Task Main(string[] args)
       {
           var host = new HostBuilder()
               .ConfigureAppConfiguration((hostContext, config) =>
               {
                   config.AddJsonFile("appsettings.json", optional: true);
               })
               .ConfigureServices((hostContext, services) =>
               {
                   services.AddLogging();
                   services.AddHostedService<TimedHostedService>();
   
                   // connection string is read automatically from appsettings.json
                   services.AddApplicationInsightsTelemetryWorkerService();
               })
               .UseConsoleLifetime()
               .Build();
   
           using (host)
           {
               // Start the host
               await host.StartAsync();
   
               // Wait for the host to shutdown
               await host.WaitForShutdownAsync();
           }
       }
   

   Následující kód je určený pro TimedHostedService, kde se nachází logika úlohy na pozadí:

       using Microsoft.ApplicationInsights;
       using Microsoft.ApplicationInsights.DataContracts;
   
       public class TimedHostedService : IHostedService, IDisposable
       {
           private readonly ILogger _logger;
           private Timer _timer;
           private TelemetryClient _telemetryClient;
           private static HttpClient httpClient = new HttpClient();
   
           public TimedHostedService(ILogger<TimedHostedService> logger, TelemetryClient tc)
           {
               _logger = logger;
               this._telemetryClient = tc;
           }
   
           public Task StartAsync(CancellationToken cancellationToken)
           {
               _logger.LogInformation("Timed Background Service is starting.");
   
               _timer = new Timer(DoWork, null, TimeSpan.Zero,
                   TimeSpan.FromSeconds(1));
   
               return Task.CompletedTask;
           }
   
           private void DoWork(object state)
           {
               _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
   
               using (_telemetryClient.StartOperation<RequestTelemetry>("operation"))
               {
                   _logger.LogWarning("A sample warning message. By default, logs with severity Warning or higher is captured by Application Insights");
                   _logger.LogInformation("Calling bing.com");
                   var res = httpClient.GetAsync("https://bing.com").GetAwaiter().GetResult();
                   _logger.LogInformation("Calling bing completed with status:" + res.StatusCode);
                   _telemetryClient.TrackEvent("Bing call event completed");
               }
           }
       }
   

3. Nastavte připojovací řetězec. Použijte totéž appsettings.json z předchozího příkladu pracovní služby .NET .

Konzolová aplikace .NET Core/.NET Framework

Jak je uvedeno na začátku tohoto článku, nový balíček se dá použít k povolení telemetrie Application Insights i z běžné konzolové aplikace. Tento balíček je určen netstandard2.0, aby se mohl používat pro konzolové aplikace v .NET Core nebo novější a .NET Framework nebo novější.

Úplný příklad se sdílí na této stránce GitHubu.

1. Nainstalujte do aplikace balíček Microsoft.ApplicationInsights.WorkerService .

2. Upravte Program.cs , jak je znázorněno v následujícím příkladu:

       using Microsoft.ApplicationInsights;
       using Microsoft.ApplicationInsights.DataContracts;
       using Microsoft.ApplicationInsights.WorkerService;
       using Microsoft.Extensions.DependencyInjection;
       using Microsoft.Extensions.Logging;
       using System;
       using System.Net.Http;
       using System.Threading.Tasks;
   
       namespace WorkerSDKOnConsole
       {
           class Program
           {
               static async Task Main(string[] args)
               {
                   // Create the DI container.
                   IServiceCollection services = new ServiceCollection();
   
                   // Being a regular console app, there is no appsettings.json or configuration providers enabled by default.
                   // Hence connection string and any changes to default logging level must be specified here.
                   services.AddLogging(loggingBuilder => loggingBuilder.AddFilter<Microsoft.Extensions.Logging.ApplicationInsights.ApplicationInsightsLoggerProvider>("Category", LogLevel.Information));
                   services.AddApplicationInsightsTelemetryWorkerService((ApplicationInsightsServiceOptions options) => options.ConnectionString = "<YOUR-CONNECTION-STRING>");
   
                   // To pass a connection string
                   // - aiserviceoptions must be created
                   // - set connectionstring on it
                   // - pass it to AddApplicationInsightsTelemetryWorkerService()
   
                   // Build ServiceProvider.
                   IServiceProvider serviceProvider = services.BuildServiceProvider();
   
                   // Obtain logger instance from DI.
                   ILogger<Program> logger = serviceProvider.GetRequiredService<ILogger<Program>>();
   
                   // Obtain TelemetryClient instance from DI, for additional manual tracking or to flush.
                   var telemetryClient = serviceProvider.GetRequiredService<TelemetryClient>();
   
                   var httpClient = new HttpClient();
   
                   while (true) // This app runs indefinitely. Replace with actual application termination logic.
                   {
                       logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
   
                       // Replace with a name which makes sense for this operation.
                       using (telemetryClient.StartOperation<RequestTelemetry>("operation"))
                       {
                           logger.LogWarning("A sample warning message. By default, logs with severity Warning or higher is captured by Application Insights");
                           logger.LogInformation("Calling bing.com");                    
                           var res = await httpClient.GetAsync("https://bing.com");
                           logger.LogInformation("Calling bing completed with status:" + res.StatusCode);
                           telemetryClient.TrackEvent("Bing call event completed");
                       }
   
                       await Task.Delay(1000);
                   }
   
                   // Explicitly call Flush() followed by sleep is required in console apps.
                   // This is to ensure that even if application terminates, telemetry is sent to the back-end.
                   telemetryClient.Flush();
                   Task.Delay(5000).Wait();
               }
           }
       }
   

Tato konzolová aplikace také používá stejnou výchozí hodnotu TelemetryConfiguration. Dá se přizpůsobit stejným způsobem jako příklady v předchozích částech.

Node.js

Požadavky

• Předplatné služby Azure. Pokud ho ještě nemáte, vytvořte si bezplatný účet Azure.
• Prostředek založený na pracovním prostoru Application Insights
• Funkční aplikace. Pokud ho ještě nemáte, přečtěte si téma Vytvoření základní webové aplikace.

Nastavení klientské knihovny Node.js

Zahrňte do aplikace sadu SDK, aby mohl shromažďovat data.

1. Zkopírujte připojovací řetězec vašeho prostředku z nového prostředku. Application Insights používá připojovací řetězec k mapování dat na váš prostředek Azure. Než SDK může použít připojovací řetězec, musíte zadat připojovací řetězec v proměnné prostředí nebo ve vašem kódu.

   

2. Přidejte klientskou knihovnu Node.js do závislostí aplikace prostřednictvím package.json. Z kořenové složky aplikace spusťte:

   npm install applicationinsights --save
   

   Poznámka:

   Pokud používáte TypeScript, není třeba instalovat samostatné balíčky typů. Tento balíček npm obsahuje vestavěné typové definice.

3. Explicitně načtěte knihovnu ve vašem kódu. Vzhledem k tomu, že sada SDK vkládá instrumentaci do mnoha dalších knihoven, knihovna by měla být načtena co nejdříve, ještě před ostatními příkazy require.

   let appInsights = require('applicationinsights');
   

4. Můžete také poskytnout připojovací řetězec prostřednictvím proměnné prostředí APPLICATIONINSIGHTS_CONNECTION_STRING místo jeho předání do setup() nebo new appInsights.TelemetryClient(). Tento postup vám umožní ponechat připojovací řetězec mimo potvrzený zdrojový kód a můžete zadat různé připojovací řetězec pro různá prostředí. Pokud chcete ručně nakonfigurovat, zavolejte appInsights.setup('[your connection string]');.

   Další možnosti konfigurace najdete v následujících částech.

   Sadu SDK můžete vyzkoušet bez odesílání telemetrie nastavením appInsights.defaultClient.config.disableAppInsights = true.

5. Začněte automaticky shromažďovat a odesílat data voláním appInsights.start();.

Poznámka:

V rámci instrumentace Application Insights shromažďujeme a odesíláme diagnostická data do Microsoftu. Tato data nám pomáhají spouštět a vylepšovat Application Insights. Máte možnost zakázat shromažďování dat, která nejsou zásadní. Další informace.

Základní použití

Pro předem nastavenou kolekci požadavků HTTP, událostí z knihoven třetích stran, neošetřených výjimek a systémových metrik:

let appInsights = require("applicationinsights");
appInsights.setup("[your connection string]").start();

Poznámka:

Pokud je připojovací řetězec nastaven v proměnné prostředí APPLICATIONINSIGHTS_CONNECTION_STRING, .setup() lze volat bez argumentů. To usnadňuje použití různých připojovací řetězec pro různá prostředí.

Než načtete další balíčky, načtěte knihovnu require("applicationinsights") Application Insights co nejdříve do skriptů. Tento krok je potřeba, aby knihovna Application Insights mohla připravit pozdější balíčky pro sledování. Pokud narazíte na konflikty s jinými knihovnami, které provádějí podobnou přípravu, zkuste načíst knihovnu Application Insights až po nich.

Vzhledem ke způsobu, jakým JavaScript zpracovává zpětná volání, je potřeba více práce sledovat požadavek napříč externími závislostmi a pozdějšími zpětnými voláními. Ve výchozím nastavení je toto dodatečné sledování povolené. Zakažte ho voláním setAutoDependencyCorrelation(false) podle popisu v části konfigurace sady SDK.

Migrace z verzí starších než 0.22

Mezi verzemi staršími než 0.22 a novějšími verzemi došlo k zásadním změnám. Tyto změny jsou navržené tak, aby přinesly konzistenci s jinými sadami Application Insights SDK a umožnily budoucí rozšiřitelnost.

Obecně platí, že migraci můžete provést pomocí následujících akcí:

• Nahraďte odkazy na appInsights.client s appInsights.defaultClient.
• Nahraďte odkazy na appInsights.getClient() s new appInsights.TelemetryClient().
• Nahraďte všechny argumenty metod client.track* jedním objektem, který obsahuje pojmenované vlastnosti jako argumenty. Podívejte se na předdefinované typy integrovaného vývojového prostředí (IDE) nebo TelemetryTypes pro výjimkou objektu pro každý typ telemetrie.

Pokud přistupujete ke konfiguračním funkcím sady SDK, aniž byste je zřetězovali appInsights.setup(), můžete tyto funkce najít na adrese appInsights.Configurations. Příklad: appInsights.Configuration.setAutoCollectDependencies(true). Zkontrolujte změny výchozí konfigurace v další části.

Ověření, že Application Insights přijímá telemetrii

.NET

ASP.NET a ASP.NET Core

Spusťte aplikaci a odešlete jí požadavky. Telemetrie by teď měla proudit do Application Insights. Sada Application Insights SDK automaticky shromažďuje příchozí webové požadavky do vaší aplikace spolu s následující telemetrií.

Pracovní služba

Spusťte aplikaci. Pracovníci ze všech předchozích příkladů každou sekundu provádějí HTTP volání na bing.com a také zapisují několik protokolů pomocí ILogger. Tyto řádky jsou zahrnuty uvnitř volání StartOperation funkce TelemetryClient, které se používá k vytvoření operace. V tomto příkladu RequestTelemetry má název "operation" (operace).

Application Insights shromažďuje tyto protokoly ILoggeru s úrovní závažnosti upozornění nebo vyšší, ve výchozím nastavení, a také jejich závislosti. Korelují se RequestTelemetry vztahem nadřazenosti a podřízenosti. Korelace také funguje napříč hranicemi procesů a sítí. Pokud se například volání provedlo na jinou monitorovanou komponentu, je také přiřazena k tomuto nadřazenému prvku.

Tuto vlastní operaci RequestTelemetry si můžete představit jako ekvivalent příchozího webového požadavku v typické webové aplikaci. Není nutné použít operaci, ale nejlépe vyhovuje datovému modelu korelace Application Insights. RequestTelemetry funguje jako nadřazená operace a každá telemetrie vygenerovaná uvnitř iterace pracovního procesu je považována za logicky patřící stejné operaci.

Tento přístup také zajišťuje, že telemetrie vygenerovaná automaticky i ručně má stejnou operation_idhodnotu . Vzhledem k tomu, že vzorkování je založené na operation_id, algoritmus vzorkování buď uchovává, nebo zahodí veškerou telemetrii z jedné iterace.

Node.js

Sada SDK automaticky shromažďuje telemetrii o modulu runtime Node.js a některých běžných modulech třetích stran. Použijte svou aplikaci k vygenerování nějakých dat.

Potom na webu Azure Portal přejděte k prostředku Application Insights, který jste vytvořili dříve. V části Časová osa přehledu vyhledejte své první datové body. Pokud chcete zobrazit podrobnější data, vyberte v grafech různé komponenty.

Pokud chcete zobrazit topologii zjištěnou pro vaši aplikaci, můžete použít mapu aplikace.

Žádná data

Vzhledem k tomu, že SDK zpracovává data dávkově k odeslání, může chvíli trvat, než se položky zobrazí na portálu. Pokud ve svém prostředku nevidíte data, vyzkoušejte některé z následujících oprav:

• Pokračujte v používání aplikace. Proveďte více akcí pro vygenerování další telemetrie.
• V zobrazení prostředků portálu vyberte Aktualizovat . Grafy se samy pravidelně aktualizují, ale ruční aktualizace vynutí jejich okamžitou aktualizaci.
• Ověřte, že jsou otevřené požadované výchozí porty.
• Pomocí Vyhledávání vyhledejte konkrétní události.
• Přečtěte si Nejčastější dotazy.

Shromažďování telemetrických dat

.NET

V této části

• Živé metriky
• Trasování (protokoly)
• Distribuované trasování
• Závislosti
• Exceptions
• Vlastní metriky
• Vlastní operace
• Čítače
• Kolekce snímků

Živé metriky

Živé metriky se dají použít k rychlému ověření, jestli je správně nakonfigurované monitorování aplikací pomocí Application Insights. Zobrazení telemetrie na webu Azure Portal může trvat několik minut, ale v podokně živých metrik se zobrazuje využití procesoru spuštěného procesu téměř v reálném čase. Může také zobrazovat další telemetrii, jako jsou požadavky, závislosti a trasovací data.

Poznámka:

Živé metriky jsou ve výchozím nastavení povolené při jeho onboardingu pomocí doporučených pokynů pro aplikace .NET.

Povolení živých metrik pomocí kódu pro libovolnou aplikaci .NET

ASP.NET

Ruční konfigurace živých metrik:

1. Nainstalujte balíček NuGet Microsoft.ApplicationInsights.PerfCounterCollector.

2. Následující ukázkový kód konzolové aplikace ukazuje nastavení živých metrik:

using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse;
using System;
using System.Threading.Tasks;

namespace LiveMetricsDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a TelemetryConfiguration instance.
            TelemetryConfiguration config = TelemetryConfiguration.CreateDefault();
            config.ConnectionString = "<YOUR-CONNECTION-STRING>";
            QuickPulseTelemetryProcessor quickPulseProcessor = null;
            config.DefaultTelemetrySink.TelemetryProcessorChainBuilder
                .Use((next) =>
                {
                    quickPulseProcessor = new QuickPulseTelemetryProcessor(next);
                    return quickPulseProcessor;
                })
                .Build();

            var quickPulseModule = new QuickPulseTelemetryModule();

            // Secure the control channel.
            // This is optional, but recommended.
            quickPulseModule.AuthenticationApiKey = "<YOUR-API-KEY>";
            quickPulseModule.Initialize(config);
            quickPulseModule.RegisterTelemetryProcessor(quickPulseProcessor);

            // Create a TelemetryClient instance. It is important
            // to use the same TelemetryConfiguration here as the one
            // used to set up live metrics.
            TelemetryClient client = new TelemetryClient(config);

            // This sample runs indefinitely. Replace with actual application logic.
            while (true)
            {
                // Send dependency and request telemetry.
                // These will be shown in live metrics.
                // CPU/Memory Performance counter is also shown
                // automatically without any additional steps.
                client.TrackDependency("My dependency", "target", "http://sample",
                    DateTimeOffset.Now, TimeSpan.FromMilliseconds(300), true);
                client.TrackRequest("My Request", DateTimeOffset.Now,
                    TimeSpan.FromMilliseconds(230), "200", true);
                Task.Delay(1000).Wait();
            }
        }
    }
}

ASP.NET Core

Ruční konfigurace živých metrik:

1. Nainstalujte balíček NuGet Microsoft.ApplicationInsights.PerfCounterCollector.

2. Následující ukázkový kód konzolové aplikace ukazuje nastavení živých metrik:

using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse;

// Create a TelemetryConfiguration instance.
TelemetryConfiguration config = TelemetryConfiguration.CreateDefault();
config.ConnectionString = "<YOUR-CONNECTION-STRING>";
QuickPulseTelemetryProcessor quickPulseProcessor = null;
config.DefaultTelemetrySink.TelemetryProcessorChainBuilder
    .Use((next) =>
    {
        quickPulseProcessor = new QuickPulseTelemetryProcessor(next);
        return quickPulseProcessor;
    })
    .Build();

var quickPulseModule = new QuickPulseTelemetryModule();

// Secure the control channel.
// This is optional, but recommended.
quickPulseModule.AuthenticationApiKey = "<YOUR-API-KEY>";
quickPulseModule.Initialize(config);
quickPulseModule.RegisterTelemetryProcessor(quickPulseProcessor);

// Create a TelemetryClient instance. It is important
// to use the same TelemetryConfiguration here as the one
// used to set up live metrics.
TelemetryClient client = new TelemetryClient(config);

// This sample runs indefinitely. Replace with actual application logic.
while (true)
{
    // Send dependency and request telemetry.
    // These will be shown in live metrics.
    // CPU/Memory Performance counter is also shown
    // automatically without any additional steps.
    client.TrackDependency("My dependency", "target", "http://sample",
        DateTimeOffset.Now, TimeSpan.FromMilliseconds(300), true);
    client.TrackRequest("My Request", DateTimeOffset.Now,
        TimeSpan.FromMilliseconds(230), "200", true);
    Task.Delay(1000).Wait();
}

Předchozí ukázka je určená pro konzolovou aplikaci, ale stejný kód lze použít v libovolné aplikaci .NET.

Důležité

Pokud jsou povoleny nějaké jiné moduly telemetrie pro automatické protokolování telemetrie, ujistěte se, že se pro modul živých metrik používá stejná konfigurace, která se používá k inicializaci těchto modulů.

Poznámka:

Výchozí konfigurace shromažďuje záznamy ILoggerWarning a závažnější záznamy. Další informace najdete v tématu Jak přizpůsobit shromažďování protokolů ILogger?.

Pracovní služba

Protokoly generované ILogger se závažností Varování nebo vyšší se automaticky zaznamenávají. Chcete-li toto chování změnit, explicitně přepište konfiguraci protokolování pro zprostředkovatele ApplicationInsights, jak je znázorněno v následujícím kódu. Následující konfigurace umožňuje Application Insights zaznamenávat všechny Information protokoly a logy s vyšší závažností.

{
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    },
    "ApplicationInsights": {
      "LogLevel": {
        "Default": "Information"
      }
    }
  }
}

Je důležité si uvědomit, že následující příklad nezpůsobí, že poskytovatel Application Insights zachytává Information protokoly. Nezachytí to, protože sada SDK přidá výchozí filtr protokolování, který instruuje ApplicationInsights k zachycení pouze Warning protokolů a závažnějších protokolů. Application Insights vyžaduje explicitní překonfigurování.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information"
    }
  }
}

Poznámka:

Application Insights respektuje úrovně záznamů nakonfigurované prostřednictvím ConfigureLogging(...) v kódu. Pokud se použije jenom appsettings.json a konfigurace logování se explicitně nepřepíše, výchozí úroveň záznamu je Upozornění.

Další informace najdete v dokumentaci ILoggeru a přizpůsobte si, které úrovně protokolů zachytává Application Insights.

Trasování (protokoly)

Tato část vysvětluje, jak odesílat diagnostické protokoly trasování z aplikací ASP.NET nebo ASP.NET Core do Application Insights a pak tyto protokoly prozkoumávat a prohledávat na portálu.

Protokoly trasování můžete použít k identifikaci trasování přidružených k jednotlivým požadavkům uživatelů a jejich korelaci s jinými událostmi a zprávami o výjimkách.

Application Insights zaznamenává protokoly z ASP.NET Core a dalších aplikací .NET prostřednictvím ILoggeru a z klasických ASP.NET (.NET Framework) prostřednictvím klasické sady SDK a adaptérů.

Poznámka:

• Ve výchozím nastavení poskytovatel Application Insights odesílá protokoly pouze se závažností Warning nebo vyšší. Chcete-li zahrnout Information nebo nižší úroveň protokolů, aktualizujte nastavení na úrovni protokolu v appsettings.jsonsouboru .

• Balíček Microsoft.ApplicationInsights.WorkerService NuGet, který se používá k povolení Application Insights pro služby na pozadí, je mimo rozsah.

• Nejčastější dotazy najdete v tématu Protokolování pomocí nejčastějších dotazů k .NET.

Instalace protokolování do aplikace

ASP.NET

Zvolte přístup k protokolování pro odesílání diagnostických protokolů, které může Application Insights shromažďovat.

Pro klasické ASP.NET aplikace, které používají trasování System.Diagnostics nakonfigurujte Application Insights TraceListener v konfiguraci.

Přidání naslouchacího procesu do web.config nebo app.config:

<configuration>
  <system.diagnostics>
    <trace>
      <listeners>
        <add name="myAppInsightsListener"
             type="Microsoft.ApplicationInsights.TraceListener.ApplicationInsightsTraceListener, Microsoft.ApplicationInsights.TraceListener" />
      </listeners>
    </trace>
  </system.diagnostics>
</configuration>

Poznámka:

Modul pro zachytávání protokolů je užitečný adaptér pro protokolovací nástroje třetích stran. Pokud ale ještě nepoužíváte NLog, log4Net nebo System.Diagnostics.Trace, zvažte přímé volání TrackTrace() Application Insights .

Konfigurujte Application Insights pro shromažďování protokolů

Možnost 1: Pokud jste to ještě neudělali, přidejte do projektu Application Insights. Při přidání Application Insights v prostředí Visual Studio je k dispozici možnost zahrnout kolektor protokolů.

Možnost 2: Klikněte pravým tlačítkem na projekt v Průzkumníku řešení a nakonfigurujte Application Insights. Vyberte možnost Konfigurovat kolekci trasování .

Poznámka:

Pokud vám chybí nabídka Application Insights nebo možnost kolektoru protokolů, přečtěte si vyhrazený článek o řešení potíží.

ASP.NET Core

Sada Application Insights SDK pro ASP.NET Core už ve výchozím nastavení shromažďuje protokoly ILoggeru. Pokud používáte sadu SDK, obvykle nemusíte volat builder.Logging.AddApplicationInsights(). V takovém případě můžete nebrat v úvahu následující pokyny k instalaci ILogger.

Pokud potřebujete pouze předávání protokolů, a ne úplný zásobník telemetrie, můžete k zaznamenání protokolů použít Microsoft.Extensions.Logging.ApplicationInsights balíček zprostředkovatele.

Ruční instalace

Tuto metodu použijte, pokud instalační program Application Insights nepodporuje váš typ projektu (například některé scénáře desktopové/konzoly) nebo pokud dáváte přednost explicitnímu řízení na úrovni balíčku.

1. V Průzkumníku řešení klikněte pravým tlačítkem na projekt a vyberte Spravovat balíčky NuGet.

2. Vyhledejte Application Insights.

3. Vyberte jeden z následujících balíčků:

   • ILogger: Microsoft.Extensions.Logging.ApplicationInsights
   • System.Diagnostics: Microsoft.ApplicationInsights.TraceListener
   • log4net: Microsoft.ApplicationInsights.Log4NetAppender Banner
   • NLog: Microsoft.ApplicationInsights.NLogTarget
   • Microsoft.ApplicationInsights.EventSourceListener
   • Microsoft.ApplicationInsights.DiagnosticSourceListener
   • Microsoft.ApplicationInsights.EtwCollector

Balíček NuGet nainstaluje potřebná sestavení a upraví web.config nebo app.config, pokud je to možné.

Pokyny k instalaci:

Poznámka:

Rozbalte některou z níže uvedených částí, kde najdete pokyny k instalaci pro konkrétní balíček.

ILogger

1. Nainstalujte soubor Microsoft.Extensions.Logging.ApplicationInsights.

2. Přidat ApplicationInsightsLoggerProvider:

using Microsoft.Extensions.Logging.ApplicationInsights;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

builder.Logging.AddApplicationInsights(
        configureTelemetryConfiguration: (config) => 
            config.ConnectionString = builder.Configuration.GetConnectionString("APPLICATIONINSIGHTS_CONNECTION_STRING"),
            configureApplicationInsightsLoggerOptions: (options) => { }
    );

builder.Logging.AddFilter<ApplicationInsightsLoggerProvider>("your-category", LogLevel.Trace);

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

S nainstalovaným balíčkem NuGet a zaregistrovaným poskytovatelem injektáže závislostí je aplikace připravená k protokolování. Při injektáži ILogger konstruktoru je vyžadována alternativa ILogger<TCategoryName> obecného typu. Když jsou tyto implementace vyřešeny, ApplicationInsightsLoggerProvider poskytuje je. Protokolované zprávy nebo výjimky se odesílají do Application Insights.

Představte si následující příklad kontroleru:

public class ValuesController : ControllerBase
{
    private readonly ILogger _logger;

    public ValuesController(ILogger<ValuesController> logger)
    {
        _logger = logger;
    }

    [HttpGet]
    public ActionResult<IEnumerable<string>> Get()
    {
        _logger.LogWarning("An example of a Warning trace..");
        _logger.LogError("An example of an Error level message");

        return new string[] { "value1", "value2" };
    }
}

Další informace najdete v tématu Protokolování v ASP.NET Core a jaký typ telemetrie Application Insights se vytváří z protokolů ILoggeru? Kde se v Application Insights zobrazují protokoly ILoggeru?

Vložení volání diagnostického protokolu (System.Diagnostics.Trace / log4net / NLog)

Pokud použijete System.Diagnostics.Trace, typický hovor by byl:

System.Diagnostics.Trace.TraceWarning("Slow response - database01");

Pokud chcete log4net , nebo NLogpoužijte:

    logger.Warn("Slow response - database01");

Použijte události EventSource

Události System.Diagnostics.Tracing.EventSource můžete nakonfigurovat k odesílání do Application Insights jako sledování.

1. Microsoft.ApplicationInsights.EventSourceListener Nainstalujte balíček NuGet.

2. TelemetryModules Upravte část souboru ApplicationInsights.config:

       <Add Type="Microsoft.ApplicationInsights.EventSourceListener.EventSourceTelemetryModule, Microsoft.ApplicationInsights.EventSourceListener">
         <Sources>
           <Add Name="MyCompany" Level="Verbose" />
         </Sources>
       </Add>
   

Pro každý zdroj můžete nastavit následující parametry:

• Název určuje název EventSource, který se má sbírat.
• Úroveň určuje úroveň protokolování, která se má shromažďovat: Critical, Error, Informational, LogAlways, podrobné nebo Warning.
• Klíčová slova (volitelné) určují celočíselnou hodnotu kombinací klíčových slov, která se mají použít.

Použijte události z DiagnosticSource

Události System.Diagnostics.DiagnosticSource můžete nakonfigurovat tak, aby se odesílaly do Application Insights jako trasování.

1. Microsoft.ApplicationInsights.DiagnosticSourceListener Nainstalujte balíček NuGet.

2. TelemetryModules Upravte část souboru ApplicationInsights.config:

       <Add Type="Microsoft.ApplicationInsights.DiagnosticSourceListener.DiagnosticSourceTelemetryModule, Microsoft.ApplicationInsights.DiagnosticSourceListener">
         <Sources>
           <Add Name="MyDiagnosticSourceName" />
         </Sources>
       </Add>
   

Pro každý zdroj diagnostiky, který chcete sledovat, přidejte položku s atributem Name nastaveným na název vašeho diagnostického zdroje.

Použijte události ETW

Trasování událostí pro Windows (ETW) můžete nakonfigurovat tak, aby se odesílaly do Application Insights jako trasování.

1. Microsoft.ApplicationInsights.EtwCollector Nainstalujte balíček NuGet.

2. Upravte část TelemetryModules souboru ApplicationInsights.config :

Poznámka:

ETW události je možné shromažďovat pouze v případě, že proces, který hostuje sadu SDK, běží pod identitou, která je členem skupiny uživatelů protokolu výkonu nebo Administrátoři.

    <Add Type="Microsoft.ApplicationInsights.EtwCollector.EtwCollectorTelemetryModule, Microsoft.ApplicationInsights.EtwCollector">
      <Sources>
        <Add ProviderName="MyCompanyEventSourceName" Level="Verbose" />
      </Sources>
    </Add>

Pro každý zdroj můžete nastavit následující parametry:

• ProviderName je název zprostředkovatele ETW, který se má sbírat.
• ProviderGuid určuje identifikátor GUID zprostředkovatele Trasování událostí pro Windows, který se má shromáždit. Lze jej použít místo ProviderName.
• Úroveň nastaví úroveň protokolování, která se má shromažďovat. Může to být kritické, chybové, informační, LogAlways, podrobné nebo upozornění.
• Klíčová slova (volitelné) nastavují celočíselnou hodnotu kombinací klíčových slov, která se mají použít.

Přímé použití rozhraní API trasování

Rozhraní trasovacího API Application Insights můžete volat přímo. Adaptéry protokolování používají toto rozhraní API. Například:

TelemetryConfiguration configuration = TelemetryConfiguration.CreateDefault();
var telemetryClient = new TelemetryClient(configuration);
telemetryClient.TrackTrace("Slow response - database01");

Výhodou TrackTrace je, že do zprávy můžete vložit relativně dlouhá data. Můžete tam například zakódovat data POST.

Ke zprávě můžete také přidat úroveň závažnosti. A stejně jako u jiné telemetrie můžete přidat hodnoty vlastností, které pomáhají filtrovat nebo vyhledávat různé soubory tras. Například:

TelemetryConfiguration configuration = TelemetryConfiguration.CreateDefault();
var telemetryClient = new TelemetryClient(configuration);
telemetryClient.TrackTrace("Slow database response",
                            SeverityLevel.Warning,
                            new Dictionary<string, string> { { "database", "db.ID" } });

Nyní můžete snadno vyfiltrovat ve službě Transaction Search všechny zprávy konkrétní úrovně závažnosti, které souvisejí s konkrétní databází.

Konzolová aplikace

Pokud chcete přidat protokolování Application Insights do konzolových aplikací, nejprve nainstalujte následující balíčky NuGet:

• Microsoft.Extensions.Logging.ApplicationInsights
• Microsoft.Extensions.DependencyInjection

Následující příklad používá Microsoft.Extensions.Logging.ApplicationInsights balíček a ukazuje výchozí chování konzolové aplikace. Balíček Microsoft.Extensions.Logging.ApplicationInsights by se měl používat v konzolové aplikaci nebo kdykoli chcete použít minimální implementaci Application Insights bez úplné sady funkcí, jako jsou metriky, distribuované trasování, vzorkování a inicializátory telemetrie.

using Microsoft.ApplicationInsights.Channel;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

using var channel = new InMemoryChannel();

try
{
    IServiceCollection services = new ServiceCollection();
    services.Configure<TelemetryConfiguration>(config => config.TelemetryChannel = channel);
    services.AddLogging(builder =>
    {
        // Only Application Insights is registered as a logger provider
        builder.AddApplicationInsights(
            configureTelemetryConfiguration: (config) => config.ConnectionString = "<YourConnectionString>",
            configureApplicationInsightsLoggerOptions: (options) => { }
        );
    });

    IServiceProvider serviceProvider = services.BuildServiceProvider();
    ILogger<Program> logger = serviceProvider.GetRequiredService<ILogger<Program>>();

    logger.LogInformation("Logger is working...");
}
finally
{
    // Explicitly call Flush() followed by Delay, as required in console apps.
    // This ensures that even if the application terminates, telemetry is sent to the back end.
    channel.Flush();

    await Task.Delay(TimeSpan.FromMilliseconds(1000));
}

Další informace najdete v tématu Jaký typ telemetrie Application Insights se vytváří z protokolů ILoggeru? Kde se v Application Insights zobrazují protokoly ILoggeru?

Obory protokolování

Poznámka:

Následující pokyny platí pro scénáře ILoggeru (jenom ASP.NET Core a konzolu). Nevztahuje se na klasické ASP.NET.

ApplicationInsightsLoggingProvider podporuje obory protokolů, které jsou ve výchozím nastavení povolené.

Pokud je obor typu IReadOnlyCollection<KeyValuePair<string,object>>, pak se každý pár klíč/hodnota v kolekci přidá do telemetrie Application Insights jako vlastní vlastnosti. V následujícím příkladu se protokoly zaznamenávají jako TraceTelemetry a mají ("MyKey", "MyValue") ve vlastnostech.

using (_logger.BeginScope(new Dictionary<string, object> { ["MyKey"] = "MyValue" }))
{
    _logger.LogError("An example of an Error level message");
}

Pokud se jako obor použije jakýkoli jiný typ, uloží se pod vlastnost Scope v telemetrii Application Insights. V následujícím příkladu TraceTelemetry má vlastnost s názvem Scope , která obsahuje obor.

using (_logger.BeginScope("hello scope"))
{
    _logger.LogError("An example of an Error level message");
}

Vyhledání protokolů

Spusťte aplikaci v režimu ladění nebo ji nasaďte živě.

Prozkoumat ve vyhledávání transakcí

V podokně přehledu vaší aplikace na portálu Application Insights vyberte vyhledávání transakcí , kde můžete:

• Filtrování trasování protokolu nebo položek s konkrétními vlastnostmi
• Podrobně zkontrolujte konkrétní položku.
• Vyhledejte další data systémového protokolu, která se vztahují ke stejnému požadavku uživatele (má stejné ID operace).
• Uložte konfiguraci stránky jako oblíbené položky.

Poznámka:

Pokud vaše aplikace odesílá velké objemy dat a používáte sadu Application Insights SDK pro ASP.NET verze 2.0.0-beta3 nebo novější, může funkce adaptivního vzorkování fungovat a odesílat jenom část telemetrie. Přečtěte si další informace o vzorkování.

Prozkoumání v protokolech služby Azure Monitor

Protokoly ILoggeru se zobrazují jako telemetrie trasování (tabulka traces v Application Insights a AppTraces v Log Analytics).

Příklad

Na webu Azure Portal přejděte do Application Insights a spusťte:

traces
| where severityLevel >= 2 // 2=Warning, 1=Information, 0=Verbose
| take 50

Distribuované trasování

Moderní architektury cloudových a mikroslužeb umožňují jednoduché a nezávisle nasaditelné služby, které snižují náklady a zvyšují dostupnost a propustnost. Celkově to ale ztěžuje pochopení a ladění systémů. Distribuované trasování tento problém řeší tím, že poskytuje nástroj pro profilování výkonu, který funguje jako zásobníky volání v architekturách cloudu a mikroslužeb.

Azure Monitor poskytuje dvě prostředí pro využívání distribuovaných dat trasování: zobrazení diagnostiky transakcí pro jednu transakci nebo požadavek a zobrazení mapy aplikace , které ukazuje, jak systémy komunikují.

Application Insights může monitorovat jednotlivé komponenty samostatně a zjišťovat, která komponenta zodpovídá za selhání nebo snížení výkonu pomocí distribuované korelace telemetrie. Tento článek vysvětluje datový model, techniky šíření kontextu, protokoly a implementaci taktik korelace na různých jazycích a platformách používaných application Insights.

Povolte distribuované trasování pomocí Application Insights buď prostřednictvím automatické instrumentace, nebo pomocí SDK.

Agenti a sady SDK Application Insights pro .NET, .NET Core, Java, Node.jsa JavaScript podporují distribuované trasování nativně.

Při správné instalaci a konfiguraci sady Application Insights SDK se informace o sledování automaticky shromažďují pro oblíbené rámce, knihovny a technologie automatickými sběrači závislostí SDK. Úplný seznam podporovaných technologií je k dispozici v dokumentaci k automatickému sběru závislostí.

Libovolnou technologii lze také sledovat ručně pomocí volání TrackDependency v TelemetryClient.

Datový model pro korelaci telemetrie

Application Insights definuje datový model pro distribuovanou korelaci telemetrie. Chcete-li přidružit telemetrii k logické operaci, má každá položka telemetrie kontextové pole s názvem operation_Id. Každý telemetrický údaj v distribuovaném trasování sdílí tento identifikátor. I když tedy ztratíte telemetrii z jedné vrstvy, můžete i nadále přidružit telemetrii hlášenou jinými komponentami.

Distribuovaná logická operace se obvykle skládá ze sady menších operací, které jsou požadavky zpracovávané jednou z komponent. Žádost o telemetrii definuje tyto operace. Každá položka telemetrie požadavku má vlastní id , která ji jednoznačně a globálně identifikuje. A všechny položky telemetrie (například trasování a výjimky), které jsou přidružené k požadavku, by měly nastavit operation_parentId na hodnotu požadavku id.

Telemetrie závislostí představuje každou odchozí operaci, například volání HTTP do jiné komponenty. Definuje také vlastní id, který je globálně jedinečný. Žádost o telemetrii, iniciovaná tímto voláním závislosti, používá id jako operation_parentId.

Můžete vytvořit zobrazení distribuované logické operace pomocí operation_Id, operation_parentId a request.id s dependency.id. Tato pole také definují kauzální pořadí volání telemetrie.

V prostředí mikroslužeb mohou stopy ze součástí přecházet do různých úložných jednotek. Každá komponenta může mít v Application Insights vlastní připojovací řetězec. Pokud chcete získat telemetrii pro logickou operaci, Application Insights dotazuje data z každé položky úložiště.

Pokud je počet položek úložiště velký, potřebujete nápovědu, kde hledat příště. Datový model Application Insights definuje dvě pole pro vyřešení tohoto problému: request.source a dependency.target. První pole identifikuje komponentu, která iniciovala požadavek na závislost. Druhé pole určuje, která komponenta vrátila odpověď volání závislosti.

Informace o dotazování z několika různorodých instancí najdete v tématu Dotazování dat v pracovních prostorech, aplikacích a prostředcích služby Log Analytics ve službě Azure Monitor.

Example

Podívejme se na příklad. Aplikace s názvem Stock Prices (Ceny akcií) zobrazuje aktuální tržní cenu akcií pomocí externího rozhraní API s názvem Akcie. Aplikace Stock Prices má stránku s názvem Stock page, kterou klient webový prohlížeč otevře pomocí GET /Home/Stock. Aplikace odesílá dotaz na rozhraní API akcií pomocí volání HTTP GET /api/stock/value.

Výslednou telemetrii můžete analyzovat spuštěním dotazu:

(requests | union dependencies | union pageViews)
| where operation_Id == "STYz"
| project timestamp, itemType, name, id, operation_ParentId, operation_Id

Ve výsledcích všechny položky telemetrie sdílejí kořen operation_Id. Při volání Ajax ze stránky se k telemetrii závislostí přiřadí nové jedinečné ID (qJSXU) a ID objektu pageView se použije jako operation_ParentId. Požadavek serveru pak použije ID Ajax jako operation_ParentId.

Typ položky	název	ID	operation_ParentId	operation_Id
pageView	Stránka akcií	STYz		STYz
závislost	GET /Home/Stock	qJSXU	STYz	STYz
žádost	Dostaňte se do Domů/Zásoby	KqKwlrSt9PA=	qJSXU	STYz
závislost	GET /api/stock/value	bBrf2L7mm2g=	KqKwlrSt9PA=	STYz

Při volání GET /api/stock/value do externí služby potřebujete znát identitu tohoto serveru, abyste mohli pole správně nastavit dependency.target . Pokud externí služba nepodporuje monitorování, target nastaví se na název hostitele služby. Příklad: stock-prices-api.com. Pokud se ale služba identifikuje vrácením předdefinované hlavičky HTTP, obsahuje identitu služby, target která službě Application Insights umožňuje sestavit distribuované trasování dotazováním telemetrie z této služby.

Hlavičky korelace pomocí W3C TraceContext

Application Insights přechází na W3C Trace-Context, který definuje:

• traceparent: Nese globálně jedinečné ID operace a jedinečný identifikátor volání.
• tracestate: Přenáší trasovací kontext specifický pro systém.

Nejnovější verze sady Application Insights SDK podporuje protokol Trace-Context, ale možná se k němu budete muset přihlásit. (Zpětnou kompatibilitu s předchozím korelačním protokolem podporovaným sadou Application Insights SDK se udržuje.)

Protokol HTTP korelace, označovaný také jako ID požadavku, je zastaralý. Tento protokol definuje dvě hlavičky:

• Request-Id: Přenáší globálně jedinečné ID volání.
• Correlation-Context: Nese kolekci párů klíč-hodnota vlastností distribuovaného trasování.

Application Insights také definuje rozšíření pro protokol HTTP korelace. Používá páry název-hodnota Request-Context k přenosu kolekce vlastností používaných bezprostředním volajícím nebo volaným. Sada Application Insights SDK používá tuto hlavičku ke nastavení polí dependency.target a request.source.

Datové modely W3C Trace-Context a Application Insights se mapují následujícím způsobem:

Application Insights	W3C TraceContext
Id z Request a Dependency	parent-id
Operation_Id	trace-id
Operation_ParentId	parent-id nadřazeného rozsahu tohoto úseku. Toto pole musí být prázdné, pokud se jedná o kořenové rozpětí.

Další informace najdete v datovém modelu telemetrie Application Insights.

Povolení podpory distribuovaného trasování W3C

Distribuované trasování založené na W3C TraceContext je ve výchozím nastavení povolené ve všech nedávných sadách .NET Framework/.NET Core SDK spolu s zpětnou kompatibilitou se starší Request-Id verzí protokolu.

Korelace telemetrie

Korelace se ve výchozím nastavení zpracovává při onboardingu aplikace. Nejsou vyžadovány žádné zvláštní akce.

Modul runtime .NET podporuje distribuované systémy pomocí Activity a DiagnosticSource.

Sada Application Insights .NET SDK používá DiagnosticSource a Activity ke shromažďování a korelování telemetrie.

Závislosti

Automaticky sledované závislosti

Sady Application Insights SDK pro .NET a .NET Core se dodávají s modulem DependencyTrackingTelemetryModuletelemetrie, který automaticky shromažďuje závislosti. DependencyTrackingTelemetryModule Modul se odešle jako balíček NuGet Microsoft.ApplicationInsights.DependencyCollector a automaticky se přenese při použití Microsoft.ApplicationInsights.Web balíčku NuGet nebo Microsoft.ApplicationInsights.AspNetCore balíčku NuGet.

DependencyTrackingTelemetryModule V současné době sleduje následující závislosti automaticky:

Závislosti	Podrobnosti
HTTP/HTTPS	Místní nebo vzdálené volání HTTP/HTTPS.
Volání WCF	Automaticky sledováno pouze v případě, že se používají vazby založené na protokolu HTTP.
SQL	Hovory s .SqlClient Úplný dotaz SQL pro zachytávání dotazů SQL najdete v části Pokročilé sledování SQL.
Azure Blob Storage, Table Storage nebo Queue Storage	Volání provedená pomocí klienta služby Azure Storage
Klientská sada SDK služby Azure Event Hubs	Použijte nejnovější balíček: https://nuget.org/packages/Azure.Messaging.EventHubs.
Klientská sada SDK služby Azure Service Bus	Použijte nejnovější balíček: https://nuget.org/packages/Azure.Messaging.ServiceBus.
Azure Cosmos DB	Sleduje se automaticky, pokud se používá HTTP/HTTPS. Trasování operací v přímém režimu s protokolem TCP se zaznamenává automaticky pomocí balíčku >preview = 3.33.0-preview. Další podrobnosti najdete v dokumentaci.

Pokud závislost není automatickycollectována, můžete ji sledovat ručně pomocí volání sledování závislostí.

Další informace o tom, jak sledování závislostí funguje, najdete v tématu Sledování závislostí v Application Insights.

Nastavení automatického sledování závislostí v konzolových aplikacích

Pokud chcete automaticky sledovat závislosti z konzolových aplikací .NET, nainstalujte balíček Microsoft.ApplicationInsights.DependencyCollector NuGet a inicializujte DependencyTrackingTelemetryModule:

    DependencyTrackingTelemetryModule depModule = new DependencyTrackingTelemetryModule();
    depModule.Initialize(TelemetryConfiguration.Active);

Poznámka:

Pro konzolové aplikace TelemetryConfiguration.Active .NET Core je zastaralé.

Ruční sledování závislostí

Následující příklady závislostí, které se neshromažďuje automaticky, vyžadují ruční sledování:

• Azure Cosmos DB se sleduje automaticky jenom v případě, že se používá HTTP/HTTPS . Režim TCP není automaticky zachycen službou Application Insights pro verze sady SDK starší než 2.22.0-Beta1.
• Redis

U těchto závislostí, které sada SDK automaticky neshromažďuje, je můžete sledovat ručně pomocí rozhraní API trackDependency, které používá standardní moduly autocollection.

Příklad

Pokud kód sestavíte sestavením, které jste sami nenapsali, můžete všechna volání do něj zavolat. Tento scénář vám umožní zjistit, jaký příspěvek přispívá k době odezvy.

Pokud chcete, aby se tato data zobrazovala v grafech závislostí v Application Insights, odešlete je pomocí TrackDependency:

    var startTime = DateTime.UtcNow;
    var timer = System.Diagnostics.Stopwatch.StartNew();
    try
    {
        // making dependency call
        success = dependency.Call();
    }
    finally
    {
        timer.Stop();
        telemetryClient.TrackDependency("myDependencyType", "myDependencyCall", "myDependencyData", startTime, timer.Elapsed, success);
    }

Alternativně TelemetryClient poskytuje rozšiřující metody StartOperation a StopOperation, které lze použít k ručnímu sledování závislostí, jak je znázorněno ve sledování odchozích závislostí.

Zakázání standardního modulu sledování závislostí

Další informace najdete v modulech telemetrie.

Pokročilé sledování SQL pro získání úplného dotazu SQL

Pro volání SQL se název serveru a databáze vždy shromažďuje a ukládá jako název shromážděného DependencyTelemetry. Další pole označované jako data může obsahovat celý text dotazu SQL.

Poznámka:

Azure Functions vyžaduje samostatná nastavení pro povolení shromažďování textu SQL. Další informace najdete v tématu Povolení shromažďování dotazů SQL.

ASP.NET

Pro ASP.NET aplikace se shromažďuje úplný text dotazu SQL pomocí instrumentace bajtů, který vyžaduje použití instrumentačního modulu nebo pomocí balíčku NuGet Microsoft.Data.SqlClient namísto knihovny System.Data.SqlClient. Kroky specifické pro platformu pro povolení úplné kolekce dotazů SQL jsou popsány v následující tabulce.

Platforma	Kroky potřebné k získání úplného dotazu SQL
Web Apps ve službě Aplikace Azure	V ovládacích panelech webové aplikace otevřete podokno Application Insights a povolte příkazy SQL v .NET.
Server SLUŽBY IIS (Virtuální počítače Azure, místní atd.)	Buď použijte balíček NuGet Microsoft.Data.SqlClient , nebo použijte modul PowerShellu agenta Application Insights k instalaci instrumentačního modulu a restartování služby IIS.
Azure Cloud Services	Přidejte spouštěcí úlohu pro instalaci StatusMonitor. Aplikace by se měla připojit k sadě ApplicationInsights SDK v době sestavení instalací balíčků NuGet pro aplikace ASP.NET nebo ASP.NET Core.
IIS Express	Použijte balíček NuGet Microsoft.Data.SqlClient.
Webové úlohy ve službě Aplikace Azure Service	Použijte balíček NuGet Microsoft.Data.SqlClient.

Kromě předchozích kroků specifických pro platformu musíte také explicitně vyjádřit výslovný souhlas s povolením shromažďování příkazů SQL úpravou souboru následujícím kódem ApplicationInsights.config :

<TelemetryModules>
  <Add Type="Microsoft.ApplicationInsights.DependencyCollector.DependencyTrackingTelemetryModule, Microsoft.AI.DependencyCollector">
    <EnableSqlCommandTextInstrumentation>true</EnableSqlCommandTextInstrumentation>
  </Add>

ASP.NET Core

Pro aplikace ASP.NET Core se vyžaduje, abyste se přihlásili ke kolekci SQL Text pomocí:

services.ConfigureTelemetryModule<DependencyTrackingTelemetryModule>((module, o) => { module. EnableSqlCommandTextInstrumentation = true; });

V předchozích případech je správný způsob ověření, že instrumentační modul je správně nainstalován, ověřením, že je shromážděná DependencyTelemetryrddpverze sady SDK . Použití nebo rdddsd označení závislostí se shromažďuje prostřednictvím rddf zpětného DiagnosticSource volání nebo EventSource zpětné volání, takže se nezachytí celý dotaz SQL.

Exceptions

Výjimky ve webových aplikacích je možné hlásit pomocí Application Insights. Neúspěšné požadavky můžete korelovat s výjimkami a dalšími událostmi na klientovi i na serveru, abyste mohli rychle diagnostikovat příčiny. V této části se dozvíte, jak nastavit generování sestav výjimek, explicitně hlásit výjimky, diagnostikovat selhání a další.

Nastavení generování sestav výjimek

Application Insights můžete nastavit tak, aby hlásila výjimky, ke kterým dochází na serveru nebo klientovi. V závislosti na platformě, na které je vaše aplikace závislá, potřebujete příslušné rozšíření nebo sadu SDK.

Server-side

Pokud chcete mít výjimky hlášené z aplikace na straně serveru, zvažte následující scénáře:

• Přidejte rozšíření Application Insights pro webové aplikace Azure.
• Přidejte rozšíření monitorování aplikací pro virtuální počítače Azure a škálovací sady virtuálních počítačů Azure s aplikacemi hostovanými službou IIS.
• Přidejte sadu Application Insights SDK do kódu aplikace, spusťte agenta Application Insights pro webové servery služby IIS nebo povolte agenta Java pro webové aplikace v Javě.

Client-side

Sada JavaScript SDK poskytuje možnost generování sestav výjimek na straně klienta, ke kterým dochází ve webových prohlížečích. Pokud chcete nastavit generování sestav výjimek v klientovi, přečtěte si téma Application Insights pro webové stránky.

Aplikační architektury

U některých aplikačních architektur se vyžaduje další konfigurace. Zvažte následující technologie:

• Webové formuláře
• MVC
• Webové rozhraní API 1.*
• Webové rozhraní API 2.*
• WCF

Důležité

Tato část se zaměřuje na aplikace rozhraní .NET Framework z pohledu příkladu kódu. Některé metody, které fungují pro rozhraní .NET Framework, jsou zastaralé v sadě .NET Core SDK.

Diagnostika selhání a výjimek

Azure Portal

Application Insights nabízí kurátorované prostředí správy výkonu aplikací, které vám pomůže diagnostikovat selhání v monitorovaných aplikacích.

Podrobné pokyny najdete v tématu Zkoumání selhání, výkonu a transakcí pomocí Application Insights.

Visual Studio

1. Otevřete řešení aplikace v sadě Visual Studio. Spusťte aplikaci buď na serveru, nebo na vývojovém počítači pomocí klávesy F5. Znovu vytvořte výjimku.

2. Otevřete okno telemetrie Application Insights Search v sadě Visual Studio. Při ladění vyberte rozevírací seznam Application Insights .

3. Vyberte sestavu výjimek, aby se zobrazilo trasování zásobníku. Pokud chcete otevřít příslušný soubor kódu, vyberte odkaz na řádek v trasování zásobníku.

   Pokud je Povolená služba CodeLens, zobrazí se data o výjimkách:

   

Vlastní trasování a data protokolu

Pokud chcete získat diagnostická data specifická pro vaši aplikaci, můžete vložit kód pro odesílání vlastních telemetrických dat. Vaše vlastní telemetrická data nebo data protokolu se zobrazují v diagnostickém vyhledávání společně s požadavkem, zobrazením stránky a dalšími automaticky shromážděnými daty.

Pomocí rozhraní Microsoft.VisualStudio.ApplicationInsights.TelemetryClientAPI máte k dispozici několik rozhraní API:

• TelemetryClient.TrackEvent se obvykle používá pro monitorování vzorů využití, ale data, která odesílá, se zobrazují také v části Vlastní události v diagnostickém vyhledávání. Události jsou pojmenované a mohou obsahovat vlastnosti řetězců a číselné metriky, na kterých můžete filtrovat diagnostická hledání.
• TelemetryClient.TrackTrace umožňuje odesílat delší data, například informace POST.
• TelemetryClient.TrackException odesílá podrobnosti o výjimce, jako jsou trasování zásobníku do Application Insights.

Pokud chcete tyto události zobrazit, otevřete v nabídce vlevo hledání. Vyberte rozevírací nabídku Typy událostí a pak zvolte Vlastní událost, Trasování nebo Výjimka.

Poznámka:

Pokud vaše aplikace generuje velké objemy telemetrie, modul adaptivního vzorkování automaticky sníží objem odesílaný na portál odesláním pouze reprezentativního zlomku událostí. Události, které jsou součástí stejné operace, jsou vybrány nebo zrušeny jako skupina, abyste mohli přecházet mezi souvisejícími událostmi. Další informace najdete v tématu Vzorkování v Application Insights.

Zobrazit data POST požadavku

Podrobnosti žádosti nezahrnují data odesílaná do vaší aplikace do volání POST. Chcete-li tato data hlásit:

• Přidejte do kódu aplikace sadu Application Insights SDK .
• Vložte do aplikace kód pro volání Microsoft.ApplicationInsights.TrackTrace(). Odešle data POST v parametru zprávy. Povolená velikost je omezena, takže byste se měli pokusit odeslat jenom důležitá data.
• Když prošetříte neúspěšný požadavek, vyhledejte přidružené trasování.

Zachycení výjimek a souvisejících diagnostických dat

Ve výchozím nastavení se na portálu nezobrazují všechny výjimky, které způsobují selhání ve vaší aplikaci. Pokud na webových stránkách používáte javascriptovou sadu SDK , zobrazí se výjimky prohlížeče. Služba IIS ale zachytí většinu výjimek na straně serveru, takže je potřeba přidat nějaký kód, který je zachytí a nahlásí.

Můžete:

• Explicitně zaznamujte výjimky vložením kódu do obslužných rutin výjimek, které oznamují výjimky.
• Zachytávání výjimek automaticky konfigurací architektury ASP.NET Nezbytné doplňky se liší pro různé typy rozhraní.

Explicitní výjimky sestav

Nejjednodušší způsob, jak vytvořit sestavu, je vložit volání do trackException() obslužné rutiny výjimky.

jazyk C#

var telemetry = new TelemetryClient();

try
{
    // ...
}
catch (Exception ex)
{
    var properties = new Dictionary<string, string>
    {
        ["Game"] = currentGame.Name
    };

    var measurements = new Dictionary<string, double>
    {
        ["Users"] = currentGame.Users.Count
    };

    // Send the exception telemetry:
    telemetry.TrackException(ex, properties, measurements);
}

JavaScript

try
{
    // ...
}
catch (ex)
{
    appInsights.trackException(ex, "handler loc",
    {
        Game: currentGame.Name,
        State: currentGame.State.ToString()
    });
}

Parametry vlastností a měření jsou volitelné, ale jsou užitečné pro filtrování a přidávání dalších informací. Pokud máte například aplikaci, která dokáže spouštět několik her, můžete najít výjimkové hlášení související s konkrétní hrou. Do každého slovníku můžete přidat libovolný počet položek.

Výjimky prohlížeče

Většina výjimek prohlížeče se hlásí.

Pokud webová stránka obsahuje soubory skriptů ze sítí pro doručování obsahu nebo jiných domén, ujistěte se, že značka skriptu má atribut crossorigin="anonymous" a že server odesílá hlavičky CORS. Toto chování umožňuje získat trasování zásobníku a podrobnosti o neošetřených výjimkách JavaScriptu z těchto prostředků.

Opakované použití klienta telemetrie

Poznámka:

Doporučujeme vytvořit instanci jednou a opakovaně ji používat po celou dobu životnosti TelemetryClient aplikace.

Pomocí injektáže závislostí (DI) v .NET, příslušné sadě .NET SDK a správné konfiguraci Application Insights pro DI můžete vyžadovat jako parametr konstruktoru TelemetryClient .

public class ExampleController : ApiController
{
    private readonly TelemetryClient _telemetryClient;

    public ExampleController(TelemetryClient telemetryClient)
    {
        _telemetryClient = telemetryClient;
    }
}

V předchozím příkladu se TelemetryClient vloží do ExampleController třídy.

Webové formuláře

U webových formulářů může modul HTTP shromažďovat výjimky, pokud nejsou nakonfigurované CustomErrorsžádné přesměrování . Pokud ale máte aktivní přesměrování, přidejte do Application_Error funkce v Global.asax.cs následující řádky.

void Application_Error(object sender, EventArgs e)
{
    if (HttpContext.Current.IsCustomErrorEnabled &&
        Server.GetLastError () != null)
    {
        _telemetryClient.TrackException(Server.GetLastError());
    }
}

V předchozím příkladu _telemetryClient je proměnná TelemetryClienttypu s oborem třídy .

MVC

Počínaje sadou Application Insights Web SDK verze 2.6 (beta 3 a novější) application Insights shromažďuje neošetřené výjimky vyvolané metodami kontrolerů MVC 5 nebo novější. Pokud jste dříve přidali vlastní obslužnou rutinu pro sledování těchto výjimek, můžete ji odebrat, abyste zabránili dvojitému sledování výjimek.

Existuje několik scénářů, kdy filtr výjimek nemůže správně zpracovat chyby při vyvolání výjimek:

• Z konstruktorů kontroleru
• Z obslužných rutin zpráv
• Během směrování
• Během serializace obsahu odpovědi
• Během spuštění aplikace
• Úkoly na pozadí

Všechny výjimky zpracovávané aplikací je stále potřeba sledovat ručně. Neošetřené výjimky pocházející z kontrolerů obvykle vedou k odpovědi 500 Vnitřní chyba serveru. Pokud je taková odpověď ručně vytvořena v důsledku zpracovávané výjimky nebo vůbec žádné výjimky, sleduje se v odpovídající telemetrii požadavku s ResultCode 500. Sada Application Insights SDK ale nemůže sledovat odpovídající výjimku.

Podpora předchozích verzí

Pokud používáte MVC 4 (a starší) sady Application Insights Web SDK 2.5 (a předchozí), projděte si následující příklady pro sledování výjimek.

Rozbalením zobrazíte pokyny pro předchozí verze.

Pokud je konfigurace Off , výjimky jsou k dispozici pro modul HTTP ke shromažďování. Pokud je ale nastavená na RemoteOnly (výchozí) nebo On, výjimka se vymaže a není k dispozici, aby Application Insights automaticky shromažďovala. Toto chování můžete opravit přepsáním třídy System.Web.Mvc.HandleErrorAttribute a použitím přepsáné třídy, jak je znázorněno pro různé verze MVC zde (viz zdroj GitHubu):

using System;
using System.Web.Mvc;
using Microsoft.ApplicationInsights;

namespace MVC2App.Controllers
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
    public class AiHandleErrorAttribute : HandleErrorAttribute
    {
        public override void OnException(ExceptionContext filterContext)
        {
            if (filterContext != null && filterContext.HttpContext != null && filterContext.Exception != null)
            {
                //The attribute should track exceptions only when CustomErrors setting is On
                //if CustomErrors is Off, exceptions will be caught by AI HTTP Module
                if (filterContext.HttpContext.IsCustomErrorEnabled)
                {   //Or reuse instance (recommended!). See note above.
                    var ai = new TelemetryClient();
                    ai.TrackException(filterContext.Exception);
                }
            }
            base.OnException(filterContext);
        }
    }
}

MVC 2

Nahraďte atribut HandleError novým atributem v řadičích:

    namespace MVC2App.Controllers
    {
        [AiHandleError]
        public class HomeController : Controller
        {
            // Omitted for brevity
        }
    }

Ukázka

MVC 3

Registrace AiHandleErrorAttribute jako globálního filtru v Global.asax.cs:

public class MyMvcApplication : System.Web.HttpApplication
{
    public static void RegisterGlobalFilters(GlobalFilterCollection filters)
    {
        filters.Add(new AiHandleErrorAttribute());
    }
}

Ukázka

MVC 4, MVC 5

Zaregistrujte AiHandleErrorAttribute se jako globální filtr v FilterConfig.cs:

public class FilterConfig
{
    public static void RegisterGlobalFilters(GlobalFilterCollection filters)
    {
        // Default replaced with the override to track unhandled exceptions
        filters.Add(new AiHandleErrorAttribute());
    }
}

Ukázka

Webové rozhraní API

Počínaje sadou Application Insights Web SDK verze 2.6 (beta 3 a novější), Application Insights shromažďuje neošetřené výjimky vyvolané metodami kontroleru automaticky pro webové rozhraní API 2 nebo novější. Pokud jste dříve přidali vlastní obslužnou rutinu pro sledování takových výjimek, jak je popsáno v následujících příkladech, můžete ji odebrat, abyste zabránili dvojitému sledování výjimek.

Existuje několik případů, kdy filtry výjimek nemůžou zpracovat. Například:

• Výjimky vyvolané konstruktory kontroleru
• Výjimky vyvolané obslužnou rutinou zpráv
• Výjimky vyvolané během směrování
• Výjimky vyvolané při serializaci obsahu odpovědi
• Při spuštění aplikace došlo k výjimce.
• V úlohách na pozadí došlo k výjimce.

Všechny výjimky zpracovávané aplikací je stále potřeba sledovat ručně. Neošetřené výjimky pocházející z kontrolerů obvykle vedou k odpovědi 500 Vnitřní chyba serveru. Pokud je taková odpověď ručně vytvořena v důsledku zpracovávané výjimky nebo vůbec žádné výjimky, sleduje se v odpovídající telemetrii požadavku s ResultCode 500. Sada Application Insights SDK ale nemůže sledovat odpovídající výjimku.

Podpora předchozích verzí

Pokud používáte webové rozhraní API 1 (a starší) sady Application Insights Web SDK 2.5 (a starší), projděte si následující příklady sledování výjimek.

Rozbalením zobrazíte pokyny pro předchozí verze.

Webové rozhraní API 1.x

Přepsání System.Web.Http.Filters.ExceptionFilterAttribute:

using System.Web.Http.Filters;
using Microsoft.ApplicationInsights;

namespace WebAPI.App_Start
{
    public class AiExceptionFilterAttribute : ExceptionFilterAttribute
    {
    public override void OnException(HttpActionExecutedContext actionExecutedContext)
    {
        if (actionExecutedContext != null && actionExecutedContext.Exception != null)
        {  //Or reuse instance (recommended!). See note above.
            var ai = new TelemetryClient();
            ai.TrackException(actionExecutedContext.Exception);
        }
        base.OnException(actionExecutedContext);
    }
    }
}

Tento přepsaný atribut můžete přidat do konkrétních kontrolerů nebo ho přidat do konfigurace globálního WebApiConfig filtru ve třídě:

using System.Web.Http;
using WebApi1.x.App_Start;

namespace WebApi1.x
{
    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional });
    
            // ...
            config.EnableSystemDiagnosticsTracing();
    
            // Capture exceptions for Application Insights:
            config.Filters.Add(new AiExceptionFilterAttribute());
        }
    }
}

Ukázka

Webové rozhraní API 2.x

Přidejte implementaci IExceptionLogger:

using System.Web.Http.ExceptionHandling;
using Microsoft.ApplicationInsights;

namespace ProductsAppPureWebAPI.App_Start
{
    public class AiExceptionLogger : ExceptionLogger
    {
        public override void Log(ExceptionLoggerContext context)
        {
            if (context != null && context.Exception != null)
            {
                //or reuse instance (recommended!). see note above
                var ai = new TelemetryClient();
                ai.TrackException(context.Exception);
            }
            base.Log(context);
        }
    }
}

Přidejte tento fragment kódu do služeb v WebApiConfig:

using System.Web.Http;
using System.Web.Http.ExceptionHandling;
using ProductsAppPureWebAPI.App_Start;

namespace WebApi2WithMVC
{
    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services
    
            // Web API routes
            config.MapHttpAttributeRoutes();
    
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional });

            config.Services.Add(typeof(IExceptionLogger), new AiExceptionLogger());
        }
    }
}

Ukázka

Jako alternativy můžete:

• Nahraďte jedinou ExceptionHandler instanci vlastní implementací IExceptionHandler. Tato obslužná rutina výjimky je volána pouze v případě, že architektura stále dokáže zvolit, která zpráva odpovědi se má odeslat, a ne při přerušení připojení, například.
• Použijte filtry výjimek, jak je popsáno v předchozí části kontrolerů webového rozhraní API 1.x, které nejsou volány ve všech případech.

WCF

Přidejte třídu, která rozšiřuje Attribute a implementuje IErrorHandler a IServiceBehavior.

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.ServiceModel.Description;
    using System.ServiceModel.Dispatcher;
    using System.Web;
    using Microsoft.ApplicationInsights;

    namespace WcfService4.ErrorHandling
    {
      public class AiLogExceptionAttribute : Attribute, IErrorHandler, IServiceBehavior
      {
        public void AddBindingParameters(ServiceDescription serviceDescription,
            System.ServiceModel.ServiceHostBase serviceHostBase,
            System.Collections.ObjectModel.Collection<ServiceEndpoint> endpoints,
            System.ServiceModel.Channels.BindingParameterCollection bindingParameters)
        {
        }

        public void ApplyDispatchBehavior(ServiceDescription serviceDescription,
            System.ServiceModel.ServiceHostBase serviceHostBase)
        {
            foreach (ChannelDispatcher disp in serviceHostBase.ChannelDispatchers)
            {
                disp.ErrorHandlers.Add(this);
            }
        }

        public void Validate(ServiceDescription serviceDescription,
            System.ServiceModel.ServiceHostBase serviceHostBase)
        {
        }

        bool IErrorHandler.HandleError(Exception error)
        {//or reuse instance (recommended!). see note above
            var ai = new TelemetryClient();

            ai.TrackException(error);
            return false;
        }

        void IErrorHandler.ProvideFault(Exception error,
            System.ServiceModel.Channels.MessageVersion version,
            ref System.ServiceModel.Channels.Message fault)
        {
        }
      }
    }

Přidejte atribut do implementací služby:

namespace WcfService4
{
    [AiLogException]
    public class Service1 : IService1
    {
        // Omitted for brevity
    }
}

Ukázka

Čítače výkonu výjimek

Pokud jste na svůj server nainstalovali agenta Application Insights pro Azure Monitor , můžete získat graf míry výjimek měřených rozhraním .NET. Zahrnuté jsou i nezpracované výjimky .NET.

Otevřete kartu Průzkumníka metrik a přidejte nový graf. V části Čítače výkonu vyberte Rychlost výjimek.

Rozhraní .NET Framework vypočítá rychlost počítá počet výjimek v intervalu a vydělí délkou intervalu.

Tento počet se liší od počtu výjimek počítaných sestavami portálu TrackException Application Insights. Intervaly vzorkování se liší a sada SDK neodesílá TrackException sestavy pro všechny zpracovávané a neošetřené výjimky.

Vlastní kolekce metrik

Sady Azure Monitor Application Insights .NET a .NET Core SDK mají dvě různé metody shromažďování vlastních metrik:

• Metoda TrackMetric() , která nemá preaggregaci.
• Metoda GetMetric() , která má preaggregaci.

Doporučujeme použít agregaci, takže TrackMetric()už není upřednostňovanou metodou shromažďování vlastních metrik. Tento článek vás provede použitím GetMetric() metody a některých důvodů, jak funguje.

Rozbalením získáte další informace o před agregaci vs. nespravujícím rozhraní API.

Metoda TrackMetric() odesílá nezpracovanou telemetrii označující metriku. Odeslání jedné položky telemetrie pro každou hodnotu je neefektivní. Metoda TrackMetric() je také neefektivní z hlediska výkonu, protože každá TrackMetric(item) prochází celým kanálem sady SDK inicializátorů telemetrie a procesorů.

Na rozdíl od TrackMetric(), GetMetric() zpracovává místní předagregace za vás a pak odešle agregovanou souhrnnou metriku pouze v pevném intervalu jedné minuty. Pokud potřebujete pečlivě monitorovat určitou vlastní metriku na druhé nebo dokonce milisekundové úrovni, můžete to udělat, zatímco náklady na úložiště a síťový provoz se budou monitorovat jenom každou minutu. Toto chování také výrazně snižuje riziko omezování, protože celkový počet položek telemetrie, které je potřeba odeslat pro agregovanou metriku, se výrazně sníží.

Ve službě Application Insights se na vlastní metriky shromážděné prostřednictvím TrackMetric()GetMetric() vzorkování neshromažďuje vzorkování. Vzorkování důležitých metrik může vést ke scénářům, kdy se upozornění založená na těchto metrikách stanou nespolehlivými. Díky tomu, že nikdy neodejdete vlastní metriky, můžete mít obecně jistotu, že když dojde k porušení prahových hodnot upozornění, aktivuje se upozornění. Vzhledem k tomu, že vlastní metriky nejsou vzorkovány, existuje několik potenciálních obav.

Sledování trendu v metrikách každou sekundu nebo v ještě podrobnějším intervalu může vést k:

• Zvýšení nákladů na úložiště dat Náklady jsou spojené s objemem dat, která odesíláte do služby Azure Monitor. Čím více dat odesíláte, tím větší jsou celkové náklady na monitorování.
• Zvýšení síťového provozu nebo režijního výkonu V některých scénářích by tato režie mohla mít peněžní i aplikační náklady na výkon.
• Riziko omezování příjmu dat Když vaše aplikace během krátkého časového intervalu odesílá vysokou míru telemetrie, azure Monitor zahodí datové body ("omezení").

Omezování je problém, protože může vést k zmeškaným výstrahám. Podmínka, která aktivuje výstrahu, může nastat místně a pak se v koncovém bodu příjmu dat zahodí kvůli příliš velkému množství dat. Nedoporučujeme používat TrackMetric() pro .NET a .NET Core, pokud jste neimplementovali vlastní místní agregační logiku. Pokud se pokoušíte sledovat každou instanci, ke které dojde v daném časovém období, můžete zjistit, že TrackEvent() je to vhodnější. Mějte na paměti, že na rozdíl od vlastních metrik podléhají vlastní události vzorkování. Stále můžete používat TrackMetric() i bez psaní vlastní místní preaggregace. Ale pokud to uděláte, mějte na paměti úskalí.

V souhrnu doporučujeme GetMetric() , protože provádí předběžné agregace, shromažďuje hodnoty ze všech Track() volání a odesílá souhrn/agregaci jednou za minutu. Metoda GetMetric() může výrazně snížit náklady a režijní náklady tím, že odesílá méně datových bodů a přitom shromažďuje všechny relevantní informace.

Začínáme s GetMetric

V našich příkladech použijeme základní aplikaci pracovních služeb .NET Core 3.1. Pokud chcete replikovat testovací prostředí použité s těmito příklady, postupujte podle kroků 1 až 6 v aplikaci .NET Core Worker Service. Tento postup přidá Application Insights do šablony projektu základní pracovní služby. Tyto koncepty platí pro jakoukoli obecnou aplikaci, ve které je možné sadu SDK použít, včetně webových aplikací a konzolových aplikací.

Odesílání metrik

Obsah souboru worker.cs nahraďte následujícím kódem:

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);
            }
        }
    }
}

Při spuštění ukázkového kódu se smyčka while opakovaně spouští bez odesílání telemetrie v okně výstupu sady Visual Studio. Jedna položka telemetrie se odešle kolem 60sekundové značky, která v našem testu vypadá takto:

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"}}}}

Tato jedna položka telemetrie představuje agregaci 41 různých měření metrik. Vzhledem k tomu, že jsme odeslali stejnou hodnotu znovu a znovu, máme směrodatnou odchylku (stDev) 0 s identickými maximálními (max) a minimálními (min) hodnotami. Vlastnost value představuje součet všech jednotlivých hodnot, které byly agregovány.

Poznámka:

Metoda GetMetric nepodporuje sledování poslední hodnoty (například gauge) nebo sledování histogramů nebo distribucí.

Pokud prozkoumáme prostředek Application Insights v prostředí protokolů (Analytics), jednotlivé položky telemetrie by vypadaly jako na následujícím snímku obrazovky.

Poznámka:

I když nezpracovaná položka telemetrie po ingestování neobsahovala explicitní vlastnost součtu nebo pole, vytvoříme ji pro vás. V tomto případě obě vlastnosti valuevalueSum představují stejnou věc.

Ke své vlastní telemetrii metrik můžete přistupovat také v části Metriky na portálu jako na základě protokolů i k vlastní metrice. Následující snímek obrazovky je příkladem metriky založené na protokolu.

Referenční informace o metrikách mezipaměti pro využití s vysokou propustností

Hodnoty metrik můžou být v některých případech často pozorovány. Například služba s vysokou propustností, která zpracovává 500 požadavků za sekundu, může pro každý požadavek generovat 20 metrik telemetrie. Výsledek znamená sledování 10 000 hodnot za sekundu. V takových scénářích s vysokou propustností můžou uživatelé potřebovat pomoct sadě SDK tím, že se vyhnete některým vyhledáváním.

Například předchozí příklad provedl vyhledávání popisovače metriky ComputersSold a pak sledoval pozorovanou hodnotu 42. Místo toho může být popisovač uložen v mezipaměti pro více volání sledování:

//...

        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);
            }
        }

Kromě ukládání popisovače metriky do mezipaměti se předchozí příklad snížil Task.Delay také na 50 milisekund, aby se smyčka spustila častěji. Výsledkem je 772 TrackValue() vyvolání.

Multidimenzionální metriky

Příklady v předchozí části zobrazují nulové metriky. Metriky můžou být také multidimenzionální. V současné době podporujeme až 10 dimenzí.

Tady je příklad vytvoření jednorozměrné metriky:

//...

        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);
            }
        }

Spuštění ukázkového kódu po dobu nejméně 60 sekund způsobí, že se do Azure odesílají tři různé položky telemetrie. Každá položka představuje agregaci jednoho ze tří faktorů formuláře. Stejně jako předtím můžete v zobrazení Protokolů (Analytics) podrobněji prozkoumat.

V Průzkumníku metrik:

Všimněte si, že metriku nemůžete rozdělit podle nové vlastní dimenze nebo zobrazit vlastní dimenzi pomocí zobrazení metrik.

Ve výchozím nastavení nejsou v prostředcích Application Insights zapnuté multidimenzionální metriky v průzkumníku metrik.

Povolení multidimenzionálních metrik

Pokud chcete povolit multidimenzionální metriky pro prostředek Application Insights, vyberte Možnost Využití a odhadované náklady>– Vlastní metriky>Umožňují upozorňovat na vlastní dimenze> metrikv pořádku. Další informace najdete v tématu Vlastní dimenze metrik a před agregace.

Po provedení této změny a odeslání nové multidimenzionální telemetrie můžete vybrat Použít rozdělení.

Poznámka:

Pouze nově odeslané metriky po zapnutí funkce na portálu mají uložené dimenze.

Zobrazte agregace metrik pro každou FormFactor dimenzi.

Použití MetricIdentifier, pokud je více než tři dimenze

V současné době se podporuje 10 dimenzí. Použití více než tří dimenzí vyžaduje použití 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");

Vlastní konfigurace metriky

Pokud chcete změnit konfiguraci metriky, musíte provést změny v místě, kde je metrika inicializována.

Speciální názvy dimenzí

Metriky nepoužívají kontext telemetrie použitého TelemetryClient pro přístup k nim. Použití speciálních názvů dimenzí dostupných jako konstant ve MetricDimensionNames třídě je nejlepším alternativním řešením pro toto omezení.

Metriky agregované podle následující Special Operation Request Size metriky nejsou nastaveny Context.Operation.Name na Special Operationhodnotu . Metoda TrackMetric() nebo jakákoli jiná TrackXXX() metoda je správně nastavena OperationName na Special Operation.

        //...
        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);
                //...
            }
                   
        }

V tomto případě použijte speciální názvy dimenzí uvedené ve MetricDimensionNames třídě k určení TelemetryContext hodnot.

Když se například do koncového bodu cloudu Application Insights odešle agregace metriky vyplývající z dalšího příkazu, nastaví se jeho Context.Operation.Name datové pole na Special Operation:

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

Hodnota této speciální dimenze se zkopíruje a TelemetryContext nepoužívá se jako normální dimenze. Pokud chcete zachovat také dimenzi operace pro normální zkoumání metrik, musíte pro tento účel vytvořit samostatnou dimenzi:

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

Omezení dimenzí a časových řad

Pokud chcete zabránit náhodnému používání telemetrického subsystému, můžete řídit maximální počet datových řad na metriku. Výchozí limity nejsou větší než 1 000 celkových datových řad na metriku a ne více než 100 různých hodnot na dimenzi.

Důležité

Pro dimenze používejte nízké hodnoty kardinality, abyste se vyhnuli omezování.

V kontextu omezování dimenzí a časových řad používáme Metric.TrackValue(..) k zajištění toho, aby se limity sledovaly. Pokud už jsou limity dosaženy, Metric.TrackValue(..) vrátí False hodnotu a hodnota se nesleduje. V opačném případě vrátí True. Toto chování je užitečné, pokud data metriky pocházejí ze vstupu uživatele.

Konstruktor MetricConfiguration má několik možností, jak spravovat různé řady v rámci příslušné metriky a objekt třídy implementuje IMetricSeriesConfiguration , který určuje chování agregace pro jednotlivé řady metriky:

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 doesn't track the metric, and returns false.

• seriesCountLimit je maximální počet datových časových řad, které může metrika obsahovat. Když dosáhnete tohoto limitu, volání TrackValue() , která by normálně způsobovala vrácení falsenové řady .
• valuesPerDimensionLimit omezuje počet jedinečných hodnot na dimenzi podobným způsobem.
• restrictToUInt32Values určuje, zda mají být sledovány pouze nezáporné celočíselné hodnoty.

Tady je příklad, jak odeslat zprávu s informacemi o překročení limitů limitu:

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);
}

Sledování vlastních operací

Sady Application Insights SDK automaticky sledují příchozí požadavky HTTP a volání závislých služeb, jako jsou požadavky HTTP a dotazy SQL. Sledování a korelace požadavků a závislostí poskytuje přehled o odezvě a spolehlivosti celé aplikace napříč všemi mikroslužbami, které tuto aplikaci kombinují.

Existuje třída vzorů aplikací, které není možné obecně podporovat. Správné monitorování takových vzorů vyžaduje ruční instrumentaci kódu. Tato část popisuje několik vzorů, které můžou vyžadovat ruční instrumentaci, například vlastní zpracování fronty a spouštění dlouhotrvajících úloh na pozadí.

Tato část obsahuje pokyny ke sledování vlastních operací pomocí sady Application Insights SDK.

Přehled

Operace je logická část práce spuštěná aplikací. Má název, počáteční čas, dobu trvání, výsledek a kontext spuštění, jako je uživatelské jméno, vlastnosti a výsledek. Pokud byla operace A inicializována operací B, operace B je nastavena jako nadřazená pro A. Operace může mít pouze jednu nadřazenou položku, ale může mít mnoho podřízených operací. Další informace o operacích a korelaci telemetrie najdete v tématu Korelace telemetrie Application Insights.

V sadě Application Insights .NET SDK je operace popsaná abstraktní třídou OperationTelemetry a jejími potomky RequestTelemetry a DependencyTelemetry.

Sledování příchozích operací

Webová sada SDK služby Application Insights automaticky shromažďuje požadavky HTTP pro ASP.NET aplikace, které běží v kanálu služby IIS, a všechny aplikace ASP.NET Core. Existují komunitní řešení pro jiné platformy a architektury. Pokud aplikace není podporována žádným ze standardních nebo komunitních řešení, můžete ji instrumentovat ručně.

Dalším příkladem, který vyžaduje vlastní sledování, je pracovní proces, který přijímá položky z fronty. U některých front se volání pro přidání zprávy do této fronty sleduje jako závislost. Operace vysoké úrovně, která popisuje zpracování zpráv, se neshromažďuje automaticky.

Pojďme se podívat, jak by mohly být tyto operace sledovány.

Na vysoké úrovni je úkolem vytvořit RequestTelemetry a nastavit známé vlastnosti. Po dokončení operace budete sledovat telemetrii. Následující příklad ukazuje tento úkol.

Požadavek HTTP v aplikaci V místním prostředí Owinu

V tomto příkladu se kontext trasování rozšíří podle protokolu HTTP pro korelaci. Měli byste očekávat, že dostanete hlavičky, které jsou tam popsané.

Rozbalení pro zobrazení kódu

public class ApplicationInsightsMiddleware : OwinMiddleware
{
    // You may create a new TelemetryConfiguration instance, reuse one you already have,
    // or fetch the instance created by Application Insights SDK.
    private readonly TelemetryConfiguration telemetryConfiguration = TelemetryConfiguration.CreateDefault();
    private readonly TelemetryClient telemetryClient = new TelemetryClient(telemetryConfiguration);
    
    public ApplicationInsightsMiddleware(OwinMiddleware next) : base(next) {}

    public override async Task Invoke(IOwinContext context)
    {
        // Let's create and start RequestTelemetry.
        var requestTelemetry = new RequestTelemetry
        {
            Name = $"{context.Request.Method} {context.Request.Uri.GetLeftPart(UriPartial.Path)}"
        };

        // If there is a Request-Id received from the upstream service, set the telemetry context accordingly.
        if (context.Request.Headers.ContainsKey("Request-Id"))
        {
            var requestId = context.Request.Headers.Get("Request-Id");
            // Get the operation ID from the Request-Id (if you follow the HTTP Protocol for Correlation).
            requestTelemetry.Context.Operation.Id = GetOperationId(requestId);
            requestTelemetry.Context.Operation.ParentId = requestId;
        }

        // StartOperation is a helper method that allows correlation of 
        // current operations with nested operations/telemetry
        // and initializes start time and duration on telemetry items.
        var operation = telemetryClient.StartOperation(requestTelemetry);

        // Process the request.
        try
        {
            await Next.Invoke(context);
        }
        catch (Exception e)
        {
            requestTelemetry.Success = false;
            requestTelemetry.ResponseCode;
            telemetryClient.TrackException(e);
            throw;
        }
        finally
        {
            // Update status code and success as appropriate.
            if (context.Response != null)
            {
                requestTelemetry.ResponseCode = context.Response.StatusCode.ToString();
                requestTelemetry.Success = context.Response.StatusCode >= 200 && context.Response.StatusCode <= 299;
            }
            else
            {
                requestTelemetry.Success = false;
            }

            // Now it's time to stop the operation (and track telemetry).
            telemetryClient.StopOperation(operation);
        }
    }
    
    public static string GetOperationId(string id)
    {
        // Returns the root ID from the '|' to the first '.' if any.
        int rootEnd = id.IndexOf('.');
        if (rootEnd < 0)
            rootEnd = id.Length;

        int rootStart = id[0] == '|' ? 1 : 0;
        return id.Substring(rootStart, rootEnd - rootStart);
    }
}

Protokol HTTP pro korelaci také deklaruje hlavičku Correlation-Context . Kvůli jednoduchosti je tu vynechán.

Instrumentace front

Kontext trasování W3C a protokol HTTP pro předávání korelačních podrobností s požadavky HTTP, ale každý protokol fronty musí definovat, jak se stejné podrobnosti předávají ve zprávě fronty. Některé protokoly front, jako je AMQP, umožňují předávání dalších metadat. Jiné protokoly, jako je fronta služby Azure Storage, vyžadují, aby byl kontext zakódován do datové části zprávy.

Poznámka:

Trasování mezi komponentami se zatím pro fronty nepodporuje.

Pokud váš producent a příjemce posílají telemetrii do různých prostředků Application Insights, prostředí diagnostiky transakcí a mapa aplikací zobrazují transakce a kompletní mapování. U front se tato funkce zatím nepodporuje.

Fronta služby Service Bus

Informace o trasování najdete v tématu Distribuované trasování a korelace prostřednictvím zasílání zpráv služby Azure Service Bus.

Fronta služby Azure Storage

Následující příklad ukazuje, jak sledovat operace fronty Azure Storage a korelovat telemetrii mezi producentem, příjemcem a Azure Storage.

Fronta úložiště má rozhraní HTTP API. Všechna volání do fronty jsou sledována kolektorem závislostí Application Insights pro požadavky HTTP. Ve výchozím nastavení je nakonfigurovaná pro aplikace ASP.NET a ASP.NET Core. Další typy aplikací najdete v dokumentaci ke konzolovým aplikacím.

Můžete také chtít korelovat ID operace Application Insights s ID požadavku úložiště. Informace o tom, jak nastavit a získat klienta žádosti o úložiště a ID požadavku serveru, najdete v tématu Monitorování, diagnostika a řešení potíží se službou Azure Storage.

Zařadit do fronty

Protože fronty služby Storage podporují rozhraní HTTP API, všechny operace s frontou se automaticky sledují službou Application Insights. V mnoha případech by tato instrumentace měla stačit. Pokud chcete korelovat trasování na straně příjemce s trasováními producenta, musíte předat kontext korelace podobně jako v protokolu HTTP pro korelaci.

Tento příklad ukazuje, jak sledovat Enqueue operaci. Můžete:

• Korelace opakovaných pokusů (pokud existuje):Všichni mají jeden společný nadřazený objekt, který je operací Enqueue . Jinak se sledují jako podřízené příchozí žádosti. Pokud fronta obsahuje více logických požadavků, může být obtížné zjistit, které volání vedlo k opakovaným pokusům.
• Korelace protokolů úložiště (pokud a v případě potřeby): Korelují se telemetrií Application Insights.

Operace Enqueue je podřízenou nadřazenou operací. Příkladem je příchozí požadavek HTTP. Volání závislostí HTTP je podřízeným objektem Enqueue operace a vnukem příchozího požadavku.

public async Task Enqueue(CloudQueue queue, string message)
{
    var operation = telemetryClient.StartOperation<DependencyTelemetry>("enqueue " + queue.Name);
    operation.Telemetry.Type = "Azure queue";
    operation.Telemetry.Data = "Enqueue " + queue.Name;

    // MessagePayload represents your custom message and also serializes correlation identifiers into payload.
    // For example, if you choose to pass payload serialized to JSON, it might look like
    // {'RootId' : 'some-id', 'ParentId' : '|some-id.1.2.3.', 'message' : 'your message to process'}
    var jsonPayload = JsonConvert.SerializeObject(new MessagePayload
    {
        RootId = operation.Telemetry.Context.Operation.Id,
        ParentId = operation.Telemetry.Id,
        Payload = message
    });
    
    CloudQueueMessage queueMessage = new CloudQueueMessage(jsonPayload);

    // Add operation.Telemetry.Id to the OperationContext to correlate Storage logs and Application Insights telemetry.
    OperationContext context = new OperationContext { ClientRequestID = operation.Telemetry.Id};

    try
    {
        await queue.AddMessageAsync(queueMessage, null, null, new QueueRequestOptions(), context);
    }
    catch (StorageException e)
    {
        operation.Telemetry.Properties.Add("AzureServiceRequestID", e.RequestInformation.ServiceRequestID);
        operation.Telemetry.Success = false;
        operation.Telemetry.ResultCode = e.RequestInformation.HttpStatusCode.ToString();
        telemetryClient.TrackException(e);
    }
    finally
    {
        // Update status code and success as appropriate.
        telemetryClient.StopOperation(operation);
    }
}  

Pokud chcete snížit množství telemetrických dat, které vaše aplikace hlásí, nebo pokud nechcete sledovat Enqueue operaci z jiných důvodů, použijte Activity rozhraní API přímo:

• Místo spuštění operace Application Insights vytvořte (a spusťte) novou Activity . Nemusíte v něm přiřazovat žádné vlastnosti s výjimkou názvu operace.
• Serializace yourActivity.Id do datové části zprávy místo operation.Telemetry.Id. Můžete také použít Activity.Current.Id.

Vyřadit z fronty

EnqueuePodobně jako skutečný požadavek HTTP na frontu služby Storage se automaticky sleduje službou Application Insights. Operace Enqueue se pravděpodobně provede v nadřazeného kontextu, například v kontextu příchozího požadavku. Sady Application Insights SDK automaticky korelují takovou operaci a její část HTTP s nadřazeným požadavkem a další telemetrií hlášenými ve stejném oboru.

Operace Dequeue je složitá. Sada Application Insights SDK automaticky sleduje požadavky HTTP. Ale nezná kontext korelace, dokud se zpráva neanalyzuje. Požadavek HTTP není možné korelovat, aby se zpráva dostala se zbytkem telemetrie, zejména pokud se přijme více než jedna zpráva.

public async Task<MessagePayload> Dequeue(CloudQueue queue)
{
    var operation = telemetryClient.StartOperation<DependencyTelemetry>("dequeue " + queue.Name);
    operation.Telemetry.Type = "Azure queue";
    operation.Telemetry.Data = "Dequeue " + queue.Name;

    try
    {
        var message = await queue.GetMessageAsync();
    }
    catch (StorageException e)
    {
        operation.telemetry.Properties.Add("AzureServiceRequestID", e.RequestInformation.ServiceRequestID);
        operation.telemetry.Success = false;
        operation.telemetry.ResultCode = e.RequestInformation.HttpStatusCode.ToString();
        telemetryClient.TrackException(e);
    }
    finally
    {
        // Update status code and success as appropriate.
        telemetryClient.StopOperation(operation);
    }

    return null;
}

Proces

V následujícím příkladu se příchozí zpráva sleduje podobným způsobem jako příchozí požadavek HTTP:

public async Task Process(MessagePayload message)
{
    // After the message is dequeued from the queue, create RequestTelemetry to track its processing.
    RequestTelemetry requestTelemetry = new RequestTelemetry { Name = "process " + queueName };
    
    // It might also make sense to get the name from the message.
    requestTelemetry.Context.Operation.Id = message.RootId;
    requestTelemetry.Context.Operation.ParentId = message.ParentId;

    var operation = telemetryClient.StartOperation(requestTelemetry);

    try
    {
        await ProcessMessage();
    }
    catch (Exception e)
    {
        telemetryClient.TrackException(e);
        throw;
    }
    finally
    {
        // Update status code and success as appropriate.
        telemetryClient.StopOperation(operation);
    }
}

Podobně lze instrumentovat i jiné operace fronty. Operace náhledu by měla být instrumentována podobným způsobem jako operace odstranění fronty. Instrumentace operací správy front není nutná. Application Insights sleduje operace, jako je HTTP, a ve většině případů stačí.

Při instrumentaci odstranění zprávy se ujistěte, že jste nastavili identifikátory operace (korelace). Alternativně můžete použít Activity rozhraní API. Pak nemusíte nastavovat identifikátory operací u položek telemetrie, protože ji sada Application Insights SDK dělá za vás:

• Po vytvoření položky z fronty vytvořte novou Activity položku.
• Slouží Activity.SetParentId(message.ParentId) ke korelaci protokolů příjemců a producentů.
• Spusťte tlačítko Activity.
• Sledujte operace vyřazení, zpracování a odstranění pomocí Start/StopOperation pomocných rutin. Proveďte to ze stejného asynchronního toku řízení (kontext spouštění). Tímto způsobem korelují správně.
• ActivityZastavte .
• Použijte Start/StopOperation nebo volejte Track telemetrii ručně.

Typy závislostí

Application Insights používá k přizpůsobení uživatelského rozhraní typ závislosti. Pro fronty rozpozná následující typy DependencyTelemetry , které zlepšují prostředí pro diagnostiku transakcí:

• Azure queue pro fronty Azure Storage
• Azure Event Hubs pro Azure Event Hubs
• Azure Service Bus pro Azure Service Bus

Dávkové zpracování

U některých front můžete s jedním požadavkem vyřadit z fronty více zpráv. Zpracování takových zpráv je pravděpodobně nezávislé a patří do různých logických operací. Operaci není možné korelovat Dequeue s konkrétní zpracovávanou zprávou.

Každá zpráva by měla být zpracována ve vlastním asynchronním toku řízení. Další informace najdete v části Sledování odchozích závislostí .

Dlouhotrvající úlohy na pozadí

Některé aplikace spouštějí dlouhotrvající operace, které můžou být způsobené požadavky uživatelů. Z hlediska trasování/instrumentace se neliší od instrumentace požadavků nebo závislostí:

async Task BackgroundTask()
{
    var operation = telemetryClient.StartOperation<DependencyTelemetry>(taskName);
    operation.Telemetry.Type = "Background";
    try
    {
        int progress = 0;
        while (progress < 100)
        {
            // Process the task.
            telemetryClient.TrackTrace($"done {progress++}%");
        }
        // Update status code and success as appropriate.
    }
    catch (Exception e)
    {
        telemetryClient.TrackException(e);
        // Update status code and success as appropriate.
        throw;
    }
    finally
    {
        telemetryClient.StopOperation(operation);
    }
}

V tomto příkladu telemetryClient.StartOperation vytvoří DependencyTelemetry a vyplní kontext korelace. Řekněme, že máte nadřazenou operaci vytvořenou příchozími požadavky, které operaci naplánovaly. BackgroundTask Pokud se spustí ve stejném asynchronním toku řízení jako příchozí požadavek, koreluje se s danou nadřazenou operací. BackgroundTask a všechny vnořené položky telemetrie se automaticky korelují s požadavkem, který ji způsobil, a to i po skončení požadavku.

Když úloha začíná z vlákna na pozadí, které nemá přidruženou Activity žádnou operaci (BackgroundTask) nemá žádnou nadřazenou položku. Může však obsahovat vnořené operace. Všechny položky telemetrie hlášené z úkolu jsou korelovány s vytvořeným DependencyTelemetry v BackgroundTask.

Sledování odchozích závislostí

Můžete sledovat vlastní druh závislosti nebo operaci, kterou Application Insights nepodporuje.

Metoda Enqueue ve frontě služby Service Bus nebo frontě služby Storage může sloužit jako příklady pro takové vlastní sledování.

Obecným přístupem ke sledování vlastních závislostí je:

• Zavolejte metodu TelemetryClient.StartOperation (extension), která vyplní DependencyTelemetry vlastnosti potřebné pro korelaci a některé další vlastnosti, jako je začátek, časové razítko a doba trvání.
• Nastavte další vlastní vlastnosti v objektu DependencyTelemetry, například název a jakýkoli jiný kontext, který potřebujete.
• Proveďte volání závislostí a počkejte na něj.
• Po dokončení operace StopOperation zastavte.
• Zpracování výjimek

public async Task RunMyTaskAsync()
{
    using (var operation = telemetryClient.StartOperation<DependencyTelemetry>("task 1"))
    {
        try 
        {
            var myTask = await StartMyTaskAsync();
            // Update status code and success as appropriate.
        }
        catch(...) 
        {
            // Update status code and success as appropriate.
        }
    }
}

Zrušení operace způsobí zastavení operace, takže ji můžete udělat místo volání StopOperation.

Výstraha

V některých případech může neošetřená výjimka bránitfinally v volání, takže operace nemusí být sledovány.

Paralelní zpracování a sledování operací

Volání StopOperation zastaví pouze spuštěnou operaci. Pokud aktuální spuštěná operace neodpovídá té, kterou chcete zastavit, StopOperation nic nedělá. K této situaci může dojít, pokud paralelně spustíte více operací ve stejném kontextu provádění.

var firstOperation = telemetryClient.StartOperation<DependencyTelemetry>("task 1");
var firstTask = RunMyTaskAsync();

var secondOperation = telemetryClient.StartOperation<DependencyTelemetry>("task 2");
var secondTask = RunMyTaskAsync();

await firstTask;

// FAILURE!!! This will do nothing and will not report telemetry for the first operation
// as currently secondOperation is active.
telemetryClient.StopOperation(firstOperation); 

await secondTask;

Ujistěte se, že vždy voláte StartOperation a zpracováváte operaci ve stejné asynchronní metodě, abyste izolovali operace spuštěné paralelně. Pokud je operace synchronní (nebo nesync), zabalte proces a sledujte pomocí Task.Run.

public void RunMyTask(string name)
{
    using (var operation = telemetryClient.StartOperation<DependencyTelemetry>(name))
    {
        Process();
        // Update status code and success as appropriate.
    }
}

public async Task RunAllTasks()
{
    var task1 = Task.Run(() => RunMyTask("task 1"));
    var task2 = Task.Run(() => RunMyTask("task 2"));
    
    await Task.WhenAll(task1, task2);
}

Operace ApplicationInsights vs. System.Diagnostics.Activity

System.Diagnostics.Activity představuje distribuovaný kontext trasování a je používán architekturami a knihovnami k vytvoření a šíření kontextu uvnitř procesu a mimo proces a korelaci položek telemetrie. Activity spolupracuje s mechanismem System.Diagnostics.DiagnosticSource oznámení mezi architekturou nebo knihovnou, aby upozorňovat na zajímavé události, jako jsou příchozí nebo odchozí požadavky a výjimky.

Aktivity jsou funkce nejvyšší úrovně v Application Insights. Automatické závislosti a shromažďování požadavků se na ně spoléhají společně s událostmi DiagnosticSource . Pokud jste vytvořili Activity ve své aplikaci, nemělo by to za následek vytvoření telemetrie Application Insights. Application Insights potřebuje přijímat DiagnosticSource události a znát názvy událostí a datové části pro překlad Activity do telemetrie.

Každá operace Application Insights (požadavek nebo závislost) zahrnuje Activity. Když StartOperation je volána, vytvoří Activity se pod ní. StartOperation je doporučený způsob ručního sledování telemetrie požadavků nebo závislostí a zajištění korelace všeho.

Counters

Application Insights podporuje čítače výkonu a čítače událostí. Tato příručka poskytuje přehled o obou případech, včetně jejich účelu, konfigurace a použití v aplikacích .NET.

• Čítače výkonu jsou integrované do operačního systému Windows a nabízejí předdefinované metriky, jako je využití procesoru, spotřeba paměti a aktivita disku. Tyto čítače jsou ideální pro monitorování standardních metrik výkonu s minimálním nastavením. Pomáhají sledovat využití prostředků nebo řešit kritické body na úrovni systému v aplikacích s Windows, ale nepodporují vlastní metriky specifické pro aplikace.

• Čítače událostí fungují na různých platformách, včetně Windows, Linuxu a macOS. Umožňují vývojářům definovat a monitorovat zjednodušené přizpůsobitelné metriky specifické pro aplikace a poskytují větší flexibilitu než čítače výkonu. Čítače událostí jsou užitečné, když systémové metriky nejsou dostatečné nebo když je potřeba podrobná telemetrie v multiplatformních aplikacích. Vyžadují explicitní implementaci a konfiguraci, což zvyšuje náročnost instalace.

Čítače výkonu

Systém Windows poskytuje různé čítače výkonu, například ty, které se používají ke shromažďování statistik využití procesoru, paměti a disku. Můžete také definovat vlastní čítače výkonu.

Vaše aplikace podporuje shromažďování čítačů výkonu, pokud běží v internetovém informačním serveru (IIS) na místním hostiteli nebo virtuálním počítači s přístupem pro správu. Aplikace spuštěné jako Azure Web Apps nemají přímý přístup k čítačům výkonu, ale Application Insights shromažďuje podmnožinu dostupných čítačů.

Návod

Stejně jako u jiných metrik můžete nastavit upozornění , které vás upozorní, pokud čítač překročí zadaný limit. Pokud chcete nastavit upozornění, otevřete podokno Upozornění a vyberte Přidat výstrahu.

Požadavky

Udělte účtu služby App Pool Service oprávnění k monitorování čítačů výkonu tak, že ho přidáte do skupiny Uživatelé sledování výkonu .

net localgroup "Performance Monitor Users" /add "IIS APPPOOL\NameOfYourPool"

Zobrazení čítačů

Podokno Metriky zobrazuje výchozí sadu čítačů výkonu.

ASP.NET

Výchozí čítače webových aplikací ASP.NET:

• proces %\doba procesoru
• % Proces\Čas procesoru Normalizován
• Paměť\Dostupné bajty
• požadavky ASP.NET za sekundu
• Výjimky modulu CLR (Common Language Runtime) .NET vyvolány za sekundu
• ASP.NET ApplicationsRequest – doba provádění
• Proces\Soukromé bajty
• Zpracování\Bajty vstupně-výstupních dat za sekundu
• ASP.NET aplikace\Žádosti ve frontě aplikace
• Processor(_Total)\ čas procesoru%

ASP.NET Core

Výchozí čítače webových aplikací ASP.NET Core:

• proces %\doba procesoru
• % Proces\Čas procesoru Normalizován
• Paměť\Dostupné bajty
• Proces\Soukromé bajty
• Zpracování\Bajty vstupně-výstupních dat za sekundu
• Processor(_Total)\ čas procesoru%

Poznámka:

Podpora čítačů výkonu v ASP.NET Core je omezená:

• Sada SDK verze 2.4.1 a novější shromažďuje čítače výkonu, pokud aplikace běží ve službě Azure Web Apps (Windows).
• Sada SDK verze 2.7.1 a novější shromažďuje čítače výkonu, pokud aplikace běží ve Windows a cílech NETSTANDARD2.0 nebo novějších verzích.
• U aplikací, které cílí na rozhraní .NET Framework, podporují všechny verze sady SDK čítače výkonu.
• Sada SDK verze 2.8.0 a novější podporuje čítač procesoru a paměti v Linuxu. Linux nepodporuje žádný jiný čítač. K získání čítačů systému v Linuxu (a dalších prostředích mimo Windows) použijte čítače událostí.

Přidání čítačů

Pokud požadovaný čítač výkonu není součástí seznamu metrik, můžete ho přidat.

ASP.NET

Možnost 1: Konfigurace v ApplicationInsights.config

1. Pomocí tohoto příkazu PowerShellu na místním serveru zjistěte, jaké čítače jsou na vašem serveru k dispozici:

   Get-Counter -ListSet *
   

   Další informace najdete v tématu Get-Counter.

2. Otevřít ApplicationInsights.config.

   Pokud jste do aplikace přidali Application Insights během vývoje:

   1. Upravte ApplicationInsights.config v projektu.
   2. Znovu ho nasaďte na servery.

3. Upravte direktivu kolektoru výkonu:

   
       <Add Type="Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.PerformanceCollectorModule, Microsoft.AI.PerfCounterCollector">
         <Counters>
           <Add PerformanceCounter="\Objects\Processes"/>
           <Add PerformanceCounter="\Sales(photo)\# Items Sold" ReportAs="Photo sales"/>
         </Counters>
       </Add>
   

Zaznamenáte standardní čítače i čítače, které implementujete sami. \Objects\Processes je příkladem standardního čítače, který je k dispozici ve všech systémech Windows. \Sales(photo)\# Items Sold je příkladem vlastního čítače, který může být implementován ve webové službě.

Formát je \Category(instance)\Counter, nebo pro kategorie, které nemají instance, pouze \Category\Counter.

Parametr ReportAs je povinný pro názvy čítačů, které neodpovídají [a-zA-Z()/-_ \.]+.

Pokud zadáte instanci, stane se dimenze CounterInstanceName hlášené metriky.

Možnost 2: Konfigurace v kódu

Podívejte se na následující část.

ASP.NET Core

Konfigurace PerformanceCollectorModule za metodou WebApplication.CreateBuilder() v Program.cs:

using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddApplicationInsightsTelemetry();

// The following configures PerformanceCollectorModule.

builder.Services.ConfigureTelemetryModule<PerformanceCollectorModule>((module, o) =>
    {
        // The application process name could be "dotnet" for ASP.NET Core self-hosted applications.
        module.Counters.Add(new PerformanceCounterCollectionRequest(@"\Process([replace-with-application-process-name])\Page Faults/sec", "DotnetPageFaultsPerfSec"));
    });

var app = builder.Build();

Shromažďování čítačů výkonu v kódu pro webové aplikace ASP.NET nebo konzolové aplikace .NET/.NET Core

Pokud chcete shromažďovat čítače výkonu systému a odesílat je do Application Insights, můžete přizpůsobit následující fragment kódu:

    var perfCollectorModule = new PerformanceCollectorModule();
    perfCollectorModule.Counters.Add(new PerformanceCounterCollectionRequest(
      @"\Process([replace-with-application-process-name])\Page Faults/sec", "PageFaultsPerfSec"));
    perfCollectorModule.Initialize(TelemetryConfiguration.Active);

Nebo můžete udělat totéž s vlastními metrikami, které jste vytvořili:

    var perfCollectorModule = new PerformanceCollectorModule();
    perfCollectorModule.Counters.Add(new PerformanceCounterCollectionRequest(
      @"\Sales(photo)\# Items Sold", "Photo sales"));
    perfCollectorModule.Initialize(TelemetryConfiguration.Active);

Čítače výkonu pro aplikace spuštěné ve službě Azure Web Apps a kontejnery Windows ve službě Azure App Service

Aplikace ASP.NET i ASP.NET Core nasazené do Azure Web Apps běží ve speciálním sandboxovém prostředí. Aplikace nasazené ve službě Azure App Service můžou využívat kontejner Windows nebo být hostované v sandboxovém prostředí. Pokud je aplikace nasazená v kontejneru Windows, jsou v imagi kontejneru k dispozici všechny standardní čítače výkonu.

Prostředí sandboxu neumožňuje přímý přístup k čítačům výkonu systému. Omezená podmnožina čítačů je však vystavena jako proměnné prostředí, jak je popsáno v čítačích výkonu vystavených jako proměnné prostředí. V tomto prostředí je k dispozici pouze podmnožina čítačů. Úplný seznam najdete v tématu Čítače výkonu vystavené jako proměnné prostředí.

Sada Application Insights SDK pro ASP.NET a ASP.NET Core zjistí, jestli je kód nasazený do webové aplikace nebo kontejneru mimo Windows. Detekce určuje, jestli shromažďuje čítače výkonu v prostředí sandboxu nebo využívá standardní mechanismus shromažďování při hostování na kontejneru nebo virtuálním počítači s Windows.

Dotazy Log Analytics na čítače výkonu

Sestavy čítačů výkonu můžete vyhledávat a zobrazovat v Log Analytics.

Schéma performanceCounters zveřejňuje category, counter název a instance název každého čítače výkonu. V telemetrii pro každou aplikaci uvidíte pouze čítače dané aplikace. Pokud například chcete zjistit, jaké čítače jsou k dispozici:

performanceCounters | summarize count(), avg(value) by category, instance, counter

Instance Tady odkazuje na instanci čítače výkonu, nikoli roli nebo instanci serveru. Název instance čítače výkonu obvykle segmentuje čítače, například čas procesoru, podle názvu procesu nebo aplikace.

Získání grafu dostupné paměti za poslední období:

performanceCounters | where counter == "Available Bytes" | summarize avg(value), min(value) by bin(timestamp, 1h) | render timechart

Stejně jako jiná telemetrie má performanceCounters také sloupec cloud_RoleInstance , který označuje identitu instance hostitelského serveru, na které je vaše aplikace spuštěná. Pokud chcete například porovnat výkon aplikace na různých počítačích:

performanceCounters | where counter == "% Processor Time" and instance == "SendMetrics" | summarize avg(value) by cloud_RoleInstance, bin(timestamp, 1d)

Nejčastější dotazy k čítačům výkonu

Nejčastější dotazy najdete v tématu Nejčastější dotazy k čítačům výkonu.

Počítadla událostí

EventCounter je mechanismus .NET/.NET Core pro publikování a využívání čítačů nebo statistik. Funkce EventCounters se podporují na všech platformách operačního systému – Windows, Linux a macOS. Může být považován za multiplatformní ekvivalent pro PerformanceCounters , které jsou podporovány pouze v systémech Windows.

I když uživatelé můžou publikovat libovolné vlastní čítače událostí tak, aby vyhovovaly jejich potřebám, .NET ve výchozím nastavení publikuje sadu těchto čítačů. Tento dokument vás provede kroky potřebnými ke shromažďování a zobrazení čítačů událostí (definovaných systémem nebo uživatelem) ve službě Azure Application Insights.

Návod

Stejně jako u jiných metrik můžete nastavit upozornění , které vás upozorní, pokud čítač překročí zadaný limit. Pokud chcete nastavit upozornění, otevřete podokno Upozornění a vyberte Přidat výstrahu.

Shromažďování objektů EventCounters pomocí Application Insights

Application Insights podporuje shromažďování EventCounters s jeho EventCounterCollectionModule, což je součást nově vydaného balíčku NuGet Microsoft.ApplicationInsights.EventCounterCollector. EventCounterCollectionModule je automaticky povolena při použití AspNetCore nebo WorkerService. EventCounterCollectionModule shromažďuje čítače s nekonfigurovatelnou frekvencí shromažďování 60 sekund. Ke shromažďování objektů EventCounters nejsou nutná žádná zvláštní oprávnění. Pro aplikace ASP.NET Core také chcete přidat balíček Microsoft.ApplicationInsights.AspNetCore .

dotnet add package Microsoft.ApplicationInsights.EventCounterCollector
dotnet add package Microsoft.ApplicationInsights.AspNetCore

Shromažďované výchozí čítače

Od verze 2.15.0 sady AspNetCore SDK nebo sady WorkerService SDK se ve výchozím nastavení neshromažďují žádné čítače. Samotný modul je povolený, takže uživatelé můžou přidat požadované čítače, které je budou shromažďovat.

Seznam známých čítačů publikovaných modulem runtime .NET získáte v dokumentu Dostupné čítače .

Přizpůsobení čítačů, které se mají shromažďovat

Následující příklad ukazuje, jak přidat nebo odebrat čítače. Toto přizpůsobení by bylo provedeno jako součást konfigurace aplikační služby po povolení shromažďování telemetrie Application Insights pomocí nebo AddApplicationInsightsTelemetry()AddApplicationInsightsWorkerService(). Následuje příklad kódu z aplikace ASP.NET Core. Další typy aplikací najdete v tématu konfigurace modulů telemetrie.

using Microsoft.ApplicationInsights.Extensibility.EventCounterCollector;
using Microsoft.Extensions.DependencyInjection;

builder.Services.ConfigureTelemetryModule<EventCounterCollectionModule>(
        (module, o) =>
        {
            // Removes all default counters, if any.
            module.Counters.Clear();

            // Adds a user defined counter "MyCounter" from EventSource named "MyEventSource"
            module.Counters.Add(
                new EventCounterCollectionRequest("MyEventSource", "MyCounter"));

            // Adds the system counter "gen-0-size" from "System.Runtime"
            module.Counters.Add(
                new EventCounterCollectionRequest("System.Runtime", "gen-0-size"));
        }
    );

Zakázání modulu kolekce EventCounter

EventCounterCollectionModulelze zakázat pomocí .ApplicationInsightsServiceOptions

Následující příklad používá sadu ASP.NET Core SDK.

using Microsoft.ApplicationInsights.AspNetCore.Extensions;
using Microsoft.Extensions.DependencyInjection;

var applicationInsightsServiceOptions = new ApplicationInsightsServiceOptions();
applicationInsightsServiceOptions.EnableEventCounterCollectionModule = false;
builder.Services.AddApplicationInsightsTelemetry(applicationInsightsServiceOptions);

Podobný přístup lze použít i pro sadu SDK pracovních služeb, ale obor názvů se musí změnit, jak je znázorněno v následujícím příkladu.

using Microsoft.ApplicationInsights.AspNetCore.Extensions;
using Microsoft.Extensions.DependencyInjection;

var applicationInsightsServiceOptions = new ApplicationInsightsServiceOptions();
applicationInsightsServiceOptions.EnableEventCounterCollectionModule = false;
builder.Services.AddApplicationInsightsTelemetry(applicationInsightsServiceOptions);

Dotazy Log Analytics na čítače událostí

Sestavy čítačů událostí můžete prohledávat a zobrazovat v Log Analytics v tabulce customMetrics .

Spuštěním následujícího dotazu můžete například zjistit, jaké čítače se shromažďují a k dispozici pro dotazování:

customMetrics | summarize avg(value) by name

Pokud chcete získat graf určitého čítače (například: ThreadPool Completed Work Item Count) za poslední období, spusťte následující dotaz.

customMetrics 
| where name contains "System.Runtime|ThreadPool Completed Work Item Count"
| where timestamp >= ago(1h)
| summarize avg(value) by cloud_RoleInstance, bin(timestamp, 1m)
| render timechart

Stejně jako jiná telemetrie má customMetrics také sloupec cloud_RoleInstance , který označuje identitu instance hostitelského serveru, na které je vaše aplikace spuštěná. Předchozí dotaz zobrazuje hodnotu čítače pro každou instanci a dá se použít k porovnání výkonu různých instancí serveru.

Nejčastější dotazy k čítačům událostí

Nejčastější dotazy najdete v nejčastějších dotazech k čítačům událostí.

Kolekce snímků

Informace o konfiguraci kolekce snímků pro aplikace ASP.NET a ASP.NET Core najdete v tématu Povolení nástroje Snapshot Debugger pro aplikace .NET v Azure Service Fabric, Cloud Services a Virtual Machines.

Node.js

V této části

• Živé metriky
• Distribuované trasování
• Rozšířené metriky
• TelemetryClient API

Živé metriky

Pokud chcete povolit odesílání živých metrik z vaší aplikace do Azure, použijte setSendLiveMetrics(true). Filtrování živých metrik na portálu se v současné době nepodporuje.

Distribuované trasování

Moderní architektury cloudových a mikroslužeb umožňují jednoduché a nezávisle nasaditelné služby, které snižují náklady a zvyšují dostupnost a propustnost. Celkově to ale ztěžuje pochopení a ladění systémů. Distribuované trasování tento problém řeší tím, že poskytuje nástroj pro profilování výkonu, který funguje jako zásobníky volání v architekturách cloudu a mikroslužeb.

Azure Monitor poskytuje dvě prostředí pro využívání distribuovaných dat trasování: zobrazení diagnostiky transakcí pro jednu transakci nebo požadavek a zobrazení mapy aplikace , které ukazuje, jak systémy komunikují.

Application Insights může monitorovat jednotlivé komponenty samostatně a zjišťovat, která komponenta zodpovídá za selhání nebo snížení výkonu pomocí distribuované korelace telemetrie. Tento článek vysvětluje datový model, techniky šíření kontextu, protokoly a implementaci taktik korelace na různých jazycích a platformách používaných application Insights.

Povolte distribuované trasování pomocí Application Insights buď prostřednictvím automatické instrumentace, nebo pomocí SDK.

Agenti a sady SDK Application Insights pro .NET, .NET Core, Java, Node.jsa JavaScript podporují distribuované trasování nativně.

Při správné instalaci a konfiguraci sady Application Insights SDK se informace o sledování automaticky shromažďují pro oblíbené rámce, knihovny a technologie automatickými sběrači závislostí SDK. Úplný seznam podporovaných technologií je k dispozici v dokumentaci k automatickému sběru závislostí.

Libovolnou technologii lze také sledovat ručně pomocí volání TrackDependency v TelemetryClient.

Datový model pro korelaci telemetrie

Application Insights definuje datový model pro distribuovanou korelaci telemetrie. Chcete-li přidružit telemetrii k logické operaci, má každá položka telemetrie kontextové pole s názvem operation_Id. Každý telemetrický údaj v distribuovaném trasování sdílí tento identifikátor. I když tedy ztratíte telemetrii z jedné vrstvy, můžete i nadále přidružit telemetrii hlášenou jinými komponentami.

Distribuovaná logická operace se obvykle skládá ze sady menších operací, které jsou požadavky zpracovávané jednou z komponent. Žádost o telemetrii definuje tyto operace. Každá položka telemetrie požadavku má vlastní id , která ji jednoznačně a globálně identifikuje. A všechny položky telemetrie (například trasování a výjimky), které jsou přidružené k požadavku, by měly nastavit operation_parentId na hodnotu požadavku id.

Telemetrie závislostí představuje každou odchozí operaci, například volání HTTP do jiné komponenty. Definuje také vlastní id, který je globálně jedinečný. Žádost o telemetrii, iniciovaná tímto voláním závislosti, používá id jako operation_parentId.

Můžete vytvořit zobrazení distribuované logické operace pomocí operation_Id, operation_parentId a request.id s dependency.id. Tato pole také definují kauzální pořadí volání telemetrie.

V prostředí mikroslužeb mohou stopy ze součástí přecházet do různých úložných jednotek. Každá komponenta může mít v Application Insights vlastní připojovací řetězec. Pokud chcete získat telemetrii pro logickou operaci, Application Insights dotazuje data z každé položky úložiště.

Pokud je počet položek úložiště velký, potřebujete nápovědu, kde hledat příště. Datový model Application Insights definuje dvě pole pro vyřešení tohoto problému: request.source a dependency.target. První pole identifikuje komponentu, která iniciovala požadavek na závislost. Druhé pole určuje, která komponenta vrátila odpověď volání závislosti.

Informace o dotazování z několika různorodých instancí najdete v tématu Dotazování dat v pracovních prostorech, aplikacích a prostředcích služby Log Analytics ve službě Azure Monitor.

Example

Podívejme se na příklad. Aplikace s názvem Stock Prices (Ceny akcií) zobrazuje aktuální tržní cenu akcií pomocí externího rozhraní API s názvem Akcie. Aplikace Stock Prices má stránku s názvem Stock page, kterou klient webový prohlížeč otevře pomocí GET /Home/Stock. Aplikace odesílá dotaz na rozhraní API akcií pomocí volání HTTP GET /api/stock/value.

Výslednou telemetrii můžete analyzovat spuštěním dotazu:

(requests | union dependencies | union pageViews)
| where operation_Id == "STYz"
| project timestamp, itemType, name, id, operation_ParentId, operation_Id

Ve výsledcích všechny položky telemetrie sdílejí kořen operation_Id. Při volání Ajax ze stránky se k telemetrii závislostí přiřadí nové jedinečné ID (qJSXU) a ID objektu pageView se použije jako operation_ParentId. Požadavek serveru pak použije ID Ajax jako operation_ParentId.

Typ položky	název	ID	operation_ParentId	operation_Id
pageView	Stránka akcií	STYz		STYz
závislost	GET /Home/Stock	qJSXU	STYz	STYz
žádost	Dostaňte se do Domů/Zásoby	KqKwlrSt9PA=	qJSXU	STYz
závislost	GET /api/stock/value	bBrf2L7mm2g=	KqKwlrSt9PA=	STYz

Při volání GET /api/stock/value do externí služby potřebujete znát identitu tohoto serveru, abyste mohli pole správně nastavit dependency.target . Pokud externí služba nepodporuje monitorování, target nastaví se na název hostitele služby. Příklad: stock-prices-api.com. Pokud se ale služba identifikuje vrácením předdefinované hlavičky HTTP, obsahuje identitu služby, target která službě Application Insights umožňuje sestavit distribuované trasování dotazováním telemetrie z této služby.

Hlavičky korelace pomocí W3C TraceContext

Application Insights přechází na W3C Trace-Context, který definuje:

• traceparent: Nese globálně jedinečné ID operace a jedinečný identifikátor volání.
• tracestate: Přenáší trasovací kontext specifický pro systém.

Nejnovější verze sady Application Insights SDK podporuje protokol Trace-Context, ale možná se k němu budete muset přihlásit. (Zpětnou kompatibilitu s předchozím korelačním protokolem podporovaným sadou Application Insights SDK se udržuje.)

Protokol HTTP korelace, označovaný také jako ID požadavku, je zastaralý. Tento protokol definuje dvě hlavičky:

• Request-Id: Přenáší globálně jedinečné ID volání.
• Correlation-Context: Nese kolekci párů klíč-hodnota vlastností distribuovaného trasování.

Application Insights také definuje rozšíření pro protokol HTTP korelace. Používá páry název-hodnota Request-Context k přenosu kolekce vlastností používaných bezprostředním volajícím nebo volaným. Sada Application Insights SDK používá tuto hlavičku ke nastavení polí dependency.target a request.source.

Datové modely W3C Trace-Context a Application Insights se mapují následujícím způsobem:

Application Insights	W3C TraceContext
Id z Request a Dependency	parent-id
Operation_Id	trace-id
Operation_ParentId	parent-id nadřazeného rozsahu tohoto úseku. Toto pole musí být prázdné, pokud se jedná o kořenové rozpětí.

Další informace najdete v datovém modelu telemetrie Application Insights.

Povolení podpory distribuovaného trasování W3C

Sada SDK ve výchozím nastavení odesílá hlavičky, kterým rozumí jiné aplikace nebo služby instrumentované pomocí sady Application Insights SDK. Kromě existujících hlaviček AI můžete povolit odesílání a příjem hlaviček kontextu trasování W3C. Tímto způsobem nebudete přerušovat korelaci s žádnou ze stávajících starších služeb.

Povolení hlaviček W3C umožňuje vaší aplikaci korelovat s jinými službami, které nejsou instrumentované pomocí Application Insights, ale přijímají tento standard W3C.

const appInsights = require("applicationinsights");
appInsights
  .setup("<your connection string>")
  .setDistributedTracingMode(appInsights.DistributedTracingModes.AI_AND_W3C)
  .start()

Rozšířené metriky

Poznámka:

Možnost odesílat rozšířené nativní metriky byla přidána ve verzi 1.4.0.

Pokud chcete povolit odesílání rozšířených nativních metrik z vaší aplikace do Azure, nainstalujte samostatný balíček nativních metrik. Sada SDK se automaticky načte, když je nainstalovaná, a začne shromažďovat Node.js nativní metriky.

npm install applicationinsights-native-metrics

V současné době balíček nativních metrik provádí automatické sbírání času CPU při uvolňování paměti, tiků smyčky událostí a využití haldy.

• Garbage Collection: Doba strávená na CPU pro každý typ Garbage Collection a počet výskytů jednotlivých typů.
• Smyčka událostí: Kolik cyklů proběhlo a kolik času procesoru bylo celkem použito.
• Halda vs. mimo haldu: Kolik paměti vašeho aplikace je využito v haldě nebo mimo haldu.

TelemetryClient API

Úplný popis rozhraní TelemetryClient API najdete v tématu Rozhraní API Application Insights pro vlastní události a metriky.

Všechny požadavky, události, metriky nebo výjimky můžete sledovat pomocí klientské knihovny Application Insights pro Node.js. Následující příklad kódu ukazuje některá z rozhraní API, která můžete použít:

let appInsights = require("applicationinsights");
appInsights.setup().start(); // assuming connection string in env var. start() can be omitted to disable any non-custom data
let client = appInsights.defaultClient;
client.trackEvent({name: "my custom event", properties: {customProperty: "custom property value"}});
client.trackException({exception: new Error("handled exceptions can be logged with this method")});
client.trackMetric({name: "custom metric", value: 3});
client.trackTrace({message: "trace message"});
client.trackDependency({target:"http://dbname", name:"select customers proc", data:"SELECT * FROM Customers", duration:231, resultCode:0, success: true, dependencyTypeName: "ZSQL"});
client.trackRequest({name:"GET /customers", url:"http://myserver/customers", duration:309, resultCode:200, success:true});

let http = require("http");
http.createServer( (req, res) => {
  client.trackNodeHttpRequest({request: req, response: res}); // Place at the beginning of your request handler
});

Sledování závislostí

Pomocí následujícího kódu můžete sledovat závislosti:

let appInsights = require("applicationinsights");
let client = new appInsights.TelemetryClient();

var success = false;
let startTime = Date.now();
// execute dependency call here....
let duration = Date.now() - startTime;
success = true;

client.trackDependency({target:"http://dbname", name:"select customers proc", data:"SELECT * FROM Customers", duration:duration, resultCode:0, success: true, dependencyTypeName: "ZSQL"});;

Příklad nástroje, který používá trackMetric k měření, jak dlouho trvá plánování smyčky událostí:

function startMeasuringEventLoop() {
  var startTime = process.hrtime();
  var sampleSum = 0;
  var sampleCount = 0;

  // Measure event loop scheduling delay
  setInterval(() => {
    var elapsed = process.hrtime(startTime);
    startTime = process.hrtime();
    sampleSum += elapsed[0] * 1e9 + elapsed[1];
    sampleCount++;
  }, 0);

  // Report custom metric every second
  setInterval(() => {
    var samples = sampleSum;
    var count = sampleCount;
    sampleSum = 0;
    sampleCount = 0;

    if (count > 0) {
      var avgNs = samples / count;
      var avgMs = Math.round(avgNs / 1e6);
      client.trackMetric({name: "Event Loop Delay", value: avgMs});
    }
  }, 1000);
}

Přidejte vlastní vlastnost ke všem událostem

Pomocí následující kód můžete do všech událostí přidat vlastní vlastnost:

appInsights.defaultClient.commonProperties = {
  environment: process.env.SOME_ENV_VARIABLE
};

Sledování požadavků HTTP GET

Pomocí následujícího kódu můžete ručně sledovat požadavky HTTP GET:

Poznámka:

• Všechny požadavky se ve výchozím nastavení sledují. Chcete-li zakázat automatické shromažďování, zavolejte .setAutoCollectRequests(false) před voláním start().
• Nativní požadavky rozhraní API pro načítání nejsou automaticky sledovány klasickými Application Insights; Vyžaduje se ruční sledování závislostí.

appInsights.defaultClient.trackRequest({name:"GET /customers", url:"http://myserver/customers", duration:309, resultCode:200, success:true});

Další možností je sledovat požadavky pomocí trackNodeHttpRequest metody:

var server = http.createServer((req, res) => {
  if ( req.method === "GET" ) {
      appInsights.defaultClient.trackNodeHttpRequest({request:req, response:res});
  }
  // other work here....
  res.end();
});

Sledování času spuštění serveru

Pomocí následujícího kódu můžete zaznamenat čas spuštění serveru:

let start = Date.now();
server.on("listening", () => {
  let duration = Date.now() - start;
  appInsights.defaultClient.trackMetric({name: "server startup time", value: duration});
});

Spláchnout

Ve výchozím nastavení se telemetrie uloží do vyrovnávací paměti po dobu 15 sekund před odesláním na server pro příjem dat. Pokud má vaše aplikace krátkou životnost, například nástroj rozhraní příkazového řádku, může být nutné ručně vyprázdnit vyrovnávací paměť telemetrie při ukončení aplikace pomocí appInsights.defaultClient.flush().

Pokud sada SDK zjistí, že vaše aplikace havaruje, vykoná za vás flush pomocí appInsights.defaultClient.flush({ isAppCrashing: true }). Možnost isAppCrashing vyprázdnění značí, že vaše aplikace se nachází v abnormálním stavu a není vhodná k odesílání telemetrie. Místo toho sada SDK ukládá veškerou telemetrii uloženou do vyrovnávací paměti do trvalého úložiště a umožňuje ukončení aplikace. Když se vaše aplikace znovu spustí, pokusí se odeslat veškerou telemetrii uloženou do trvalého úložiště.

Zpracování a filtrování telemetrie

.NET

V této části

• Filtrování a předběžné zpracování telemetrie
• Inicializátory telemetrie
• Procesor telemetrie
• Vzorkování
• Obohacení dat prostřednictvím protokolu HTTP

Filtrování a předběžné zpracování telemetrie

Před odesláním ze sady SDK můžete napsat kód pro filtrování, úpravu nebo rozšiřování telemetrie. Zpracování zahrnuje data odesílaná ze standardních modulů telemetrie, jako je například shromažďování požadavků HTTP a kolekce závislostí.

• Filtrování může upravit nebo zahodit telemetrii před jejím odesláním ze sady SDK pomocí implementace ITelemetryProcessor. Můžete například snížit objem telemetrie vyloučením požadavků z robotů. Na rozdíl od vzorkování máte úplnou kontrolu nad tím, co se odesílá nebo zahodí, ale ovlivňuje všechny metriky založené na agregovaných protokolech. V závislosti na tom, jak položky zahodíte, můžete také ztratit možnost přecházet mezi souvisejícími položkami.

• Přidejte nebo upravte vlastnosti do jakékoli telemetrie odeslané z vaší aplikace implementací ITelemetryInitializer. Můžete například přidat počítané hodnoty nebo čísla verzí, podle kterých chcete filtrovat data na portálu.

• Vzorkování snižuje objem telemetrie, aniž by to ovlivnilo vaše statistiky. Udržuje související datové body pohromadě, abyste mezi nimi mohli přecházet při diagnostice problému. V rámci portálu se celkové počty násobí, aby bylo kompenzováno odběr vzorků.

Poznámka:

Rozhraní API sady SDK slouží k odesílání vlastních událostí a metrik.

Filtering

Tato technika poskytuje přímou kontrolu nad tím, co je součástí nebo vyloučeno z datového proudu telemetrie. Filtrování je možné použít k vyřazení položek telemetrie odesílaných do Application Insights. Filtrování můžete použít s vzorkováním nebo samostatně.

Pokud chcete filtrovat telemetrii, napíšete procesor telemetrie a zaregistrujete ho v TelemetryConfiguration. Veškerá telemetrie prochází vaším procesorem. Můžete ho vypustit z datového proudu nebo ho předat dalšímu procesoru v řetězci. Zahrnuje se telemetrie ze standardních modulů, jako je kolektor požadavků HTTP a kolektor závislostí a telemetrie, kterou jste sledovali sami. Můžete například filtrovat telemetrii týkající se požadavků od robotů nebo úspěšných volání na závislosti.

Výstraha

Filtrování telemetrie odeslané ze sady SDK pomocí procesorů může zkosit statistiky, které vidíte na portálu, a ztížit sledování souvisejících položek.

Místo toho zvažte použití vzorkování.

ITelemetryProcessor a ITelemetryInitializer

Jaký je rozdíl mezi procesory telemetrie a inicializátory telemetrie?

• Existují určité společné rysy v tom, co s nimi můžete dělat. Obojí se dá použít k přidání nebo úpravě vlastností telemetrie, i když pro tento účel doporučujeme používat inicializátory.
• Inicializátory telemetrie se vždy spouštějí před procesory telemetrie.
• Inicializátory telemetrie mohou být volány více než jednou. Podle konvence nenastavují žádnou vlastnost, která už byla nastavena.
• Procesory telemetrie umožňují zcela nahradit nebo zahodit položku telemetrie.
• Pro každou položku telemetrie se volají všechny zaregistrované inicializátory telemetrie. V případě procesorů telemetrie sada SDK zaručuje volání prvního procesoru telemetrie. Zda je zbytek procesorů volán, je rozhodováno předchozími telemetrickými procesory.
• Pomocí inicializátorů telemetrie můžete rozšířit telemetrii o více vlastností nebo přepsat existující. Pomocí procesoru telemetrie můžete vyfiltrovat telemetrii.

Přidání nebo úprava vlastností

Inicializátory telemetrie slouží k obohacení telemetrie o další informace nebo k přepsání vlastností telemetrie nastavených standardními moduly telemetrie.

Application Insights pro webový balíček například shromažďuje telemetrická data o požadavcích HTTP. Ve výchozím nastavení označí všechny požadavky s kódem odpovědi >=400 jako neúspěšné. Pokud místo toho chcete zacházet s 400 jako s úspěchem, můžete poskytnout inicializátor telemetrie, který nastaví vlastnost úspěchu.

Pokud zadáte inicializátor telemetrie, volá se při každém zavolání jakékoli metody Track*(). Tento inicializátor zahrnuje Track() metody, které jsou volány standardními moduly telemetrie. Podle konvence tyto moduly nenastavují žádnou vlastnost, která byla již nastavena inicializátorem. Inicializátory telemetrie se volají před voláním procesorů telemetrie, takže všechny rozšiřování provedené inicializátory jsou viditelné pro procesory.

Inicializátory telemetrie

Pokud chcete rozšířit telemetrii o další informace nebo přepsat vlastnosti telemetrie nastavené standardními moduly telemetrie, použijte inicializátory telemetrie.

Inicializátory telemetrie nastavují kontextové vlastnosti, které se odesílají spolu s každou položkou telemetrie. Můžete napsat vlastní inicializátory pro nastavení kontextových vlastností.

Standardní inicializátory jsou nastaveny buď webovými nebo windowsserverovými balíčky NuGet:

Inicializátor	Description
AccountIdTelemetryInitializer	AccountId Nastaví vlastnost.
AuthenticatedUserIdTelemetryInitializer	AuthenticatedUserId Nastaví vlastnost nastavenou sadou JavaScript SDK.
AzureRoleEnvironmentTelemetryInitializer	RoleName Aktualizuje kontext a RoleInstance vlastnosti Device všech položek telemetrie s informacemi extrahovanými z prostředí modulu runtime Azure.
BuildInfoConfigComponentVersionTelemetryInitializer	Version Aktualizuje vlastnost Component kontextu pro všechny položky telemetrie s hodnotou extrahovaná ze souboru vytvořeného BuildInfo.config nástrojem MS Build.
ClientIpHeaderTelemetryInitializer	Ip Aktualizuje vlastnost Location kontextu všech položek telemetrie na X-Forwarded-For základě hlavičky HTTP požadavku.
DeviceTelemetryInitializer	Aktualizuje následující vlastnosti Device kontextu pro všechny položky telemetrie: • Type je nastavena na PChodnotu . • Id je nastaven na název domény počítače, na kterém je webová aplikace spuštěná. • OemName je nastavena na hodnotu extrahovaná z Win32_ComputerSystem.Manufacturer pole pomocí rozhraní WMI. • Model je nastavena na hodnotu extrahovaná z Win32_ComputerSystem.Model pole pomocí rozhraní WMI. • NetworkType je nastavena na hodnotu extrahovaná z NetworkInterface vlastnosti. • Language je nastaven na název CurrentCulture vlastnosti.
DomainNameRoleInstanceTelemetryInitializer	RoleInstance Aktualizuje vlastnost Device kontextu pro všechny položky telemetrie názvem domény počítače, na kterém je webová aplikace spuštěná.
OperationNameTelemetryInitializer	Name Aktualizuje vlastnost a RequestTelemetry vlastnost NameOperation kontextu všech položek telemetrie na základě metody HTTP a názvy kontroleru ASP.NET MVC a akce vyvolané ke zpracování požadavku.
OperationIdTelemetryInitializer nebo OperationCorrelationTelemetryInitializer	Aktualizuje kontextovou Operation.Id vlastnost všech položek telemetrie sledovaných při zpracování požadavku automaticky vygenerovaným RequestTelemetry.Id.
SessionTelemetryInitializer	Id Aktualizuje vlastnost Session kontextu pro všechny položky telemetrie s hodnotou extrahovaná ze ai_session souboru cookie vygenerovaného kódem ApplicationInsights instrumentace JavaScript spuštěným v prohlížeči uživatele.
SyntheticTelemetryInitializer nebo SyntheticUserAgentTelemetryInitializer	UserAktualizuje vlastnosti a SessionOperation kontext všech položek telemetrie sledovaných při zpracování požadavku ze syntetického zdroje, jako je test dostupnosti nebo robot vyhledávacího webu. Průzkumník metrik ve výchozím nastavení nezobrazuje syntetickou telemetrii. Sada <Filters> identifikující vlastnosti požadavků.
UserTelemetryInitializer	Id Aktualizuje a AcquisitionDate vlastnosti User kontextu pro všechny položky telemetrie s hodnotami extrahovanými ze ai_user souboru cookie vygenerovaného kódem instrumentace JavaScriptu Application Insights spuštěným v prohlížeči uživatele.
WebTestTelemetryInitializer	Nastaví ID uživatele, ID relace a syntetické vlastnosti zdroje pro požadavky HTTP, které pocházejí z testů dostupnosti. Sada <Filters> identifikující vlastnosti požadavků.

Poznámka:

Pro aplikace .NET spuštěné v Azure Service Fabric můžete zahrnout Microsoft.ApplicationInsights.ServiceFabric balíček NuGet. Tento balíček obsahuje FabricTelemetryInitializer vlastnost, která přidává vlastnosti Service Fabric k položkám telemetrie. Další informace najdete na stránce GitHubu o vlastnostech přidaných tímto balíčkem NuGet.

Přidání ITelemetryInitializer

Tento blog popisuje projekt pro diagnostiku problémů závislostí tím, že automaticky odesílá běžné příkazy ping do závislostí.

1. Definování inicializátoru

   using System;
   using Microsoft.ApplicationInsights.Channel;
   using Microsoft.ApplicationInsights.DataContracts;
   using Microsoft.ApplicationInsights.Extensibility;
   
   namespace MvcWebRole.Telemetry
   {
     /*
      * Custom TelemetryInitializer that overrides the default SDK
      * behavior of treating response codes >= 400 as failed requests
      *
      */
       public class MyTelemetryInitializer : ITelemetryInitializer
       {
           public void Initialize(ITelemetry telemetry)
           {
               var requestTelemetry = telemetry as RequestTelemetry;
               // Is this a TrackRequest() ?
               if (requestTelemetry == null) return;
               int code;
               bool parsed = Int32.TryParse(requestTelemetry.ResponseCode, out code);
               if (!parsed) return;
               if (code >= 400 && code < 500)
               {
                   // If we set the Success property, the SDK won't change it:
                   requestTelemetry.Success = true;
   
                   // Allow us to filter these requests in the portal:
                   requestTelemetry.Properties["Overridden400s"] = "true";
               }
               // else leave the SDK to set the Success property
           }
       }
   }
   

2. Načtení inicializátoru

ASP.NET

Možnost 1: Konfigurace v kódu

protected void Application_Start()
{
    // ...
    TelemetryConfiguration.Active.TelemetryInitializers.Add(new MyTelemetryInitializer());
}

Možnost 2: Konfigurace v ApplicationInsights.config

<ApplicationInsights>
    <TelemetryInitializers>
    <!-- Fully qualified type name, assembly name: -->
    <Add Type="MvcWebRole.Telemetry.MyTelemetryInitializer, MvcWebRole"/>
    ...
    </TelemetryInitializers>
</ApplicationInsights>

Podívejte se na další část této ukázky.

Poznámka:

Ujistěte se , že je souborapplicationinsights.configve výstupním adresáři a obsahuje všechny nedávné změny.

ASP.NET Core

Přidání inicializátoru pomocí použití ApplicationInsights.config nebo TelemetryConfiguration.Active není platné pro aplikace ASP.NET Core.

Pro aplikace napsané pomocí ASP.NET Core se přidání nového inicializátoru telemetrie provádí tak, že ho přidáte do kontejneru DependencyInjection , jak je znázorněno. Proveďte tento krok v Startup.ConfigureServices metodě.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSingleton<ITelemetryInitializer, MyCustomTelemetryInitializer>();

var app = builder.Build();

Poznámka:

builder.Services.AddSingleton<ITelemetryInitializer, MyCustomTelemetryInitializer>(); funguje pro jednoduché inicializátory. Pro ostatní se builder.Services.AddSingleton(new MyCustomTelemetryInitializer() { fieldName = "myfieldName" }); vyžaduje.

Odebrání inicializátorů telemetrie

Ve výchozím nastavení jsou k dispozici inicializátory telemetrie. Chcete-li odebrat všechny nebo konkrétní inicializátory telemetrie, použijte následující ukázkový kód po volání AddApplicationInsightsTelemetry().

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddApplicationInsightsTelemetry();

// Remove a specific built-in telemetry initializer
var tiToRemove = builder.Services.FirstOrDefault<ServiceDescriptor>
                    (t => t.ImplementationType == typeof(AspNetCoreEnvironmentTelemetryInitializer));
if (tiToRemove != null)
{
    builder.Services.Remove(tiToRemove);
}

// Remove all initializers
// This requires importing namespace by using Microsoft.Extensions.DependencyInjection.Extensions;
builder.Services.RemoveAll(typeof(ITelemetryInitializer));

var app = builder.Build();

Pracovní služba

Přidání inicializátoru pomocí ApplicationInsights.config nebo TelemetryConfiguration.Active není platné pro sadu SDK pracovních služeb.

Pro aplikace napsané pomocí služby Worker Service se přidání nového inicializátoru telemetrie provádí tak, že ho přidáte do kontejneru DependencyInjection , jak je znázorněno. Proveďte tento krok v Startup.ConfigureServices metodě.

    using Microsoft.ApplicationInsights.Extensibility;

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddSingleton<ITelemetryInitializer, MyCustomTelemetryInitializer>();
        services.AddApplicationInsightsTelemetryWorkerService();
    }

Odebrání inicializátorů telemetrie

Inicializátory telemetrie jsou ve výchozím nastavení k dispozici. Chcete-li odebrat všechny nebo konkrétní inicializátory telemetrie, použijte následující ukázkový kód po volání AddApplicationInsightsTelemetryWorkerService().

   public void ConfigureServices(IServiceCollection services)
   {
        services.AddApplicationInsightsTelemetryWorkerService();
        // Remove a specific built-in telemetry initializer.
        var tiToRemove = services.FirstOrDefault<ServiceDescriptor>
                            (t => t.ImplementationType == typeof(AspNetCoreEnvironmentTelemetryInitializer));
        if (tiToRemove != null)
        {
            services.Remove(tiToRemove);
        }

        // Remove all initializers.
        // This requires importing namespace by using Microsoft.Extensions.DependencyInjection.Extensions;
        services.RemoveAll(typeof(ITelemetryInitializer));
   }

Příklady ITelemetryInitializers

Přidejte vlastní vlastnost

Následující ukázkový inicializátor přidá vlastní vlastnost ke každé sledované telemetrii.

public void Initialize(ITelemetry item)
{
    var itemProperties = item as ISupportProperties;
    if(itemProperties != null && !itemProperties.Properties.ContainsKey("customProp"))
    {
        itemProperties.Properties["customProp"] = "customValue";
    }
}

Přidání názvu cloudové role a instance cloudové role

Krok 1: Napsat vlastní TelemetryInitializer

Následující ukázkový inicializátor nastaví název cloudové role na každou sledované telemetrii.

using Microsoft.ApplicationInsights.Channel;
using Microsoft.ApplicationInsights.Extensibility;

namespace CustomInitializer.Telemetry
{
    public class MyTelemetryInitializer : ITelemetryInitializer
    {
        public void Initialize(ITelemetry telemetry)
        {
            if (string.IsNullOrEmpty(telemetry.Context.Cloud.RoleName))
            {
                //set custom role name here
                telemetry.Context.Cloud.RoleName = "Custom RoleName";
                telemetry.Context.Cloud.RoleInstance = "Custom RoleInstance";
            }
        }
    }
}

Krok 2: Načtení inicializátoru do TelemetryConfiguration

ASP.NET

V souboru ApplicationInsights.config :

    <ApplicationInsights>
      <TelemetryInitializers>
        <!-- Fully qualified type name, assembly name: -->
        <Add Type="CustomInitializer.Telemetry.MyTelemetryInitializer, CustomInitializer"/>
        ...
      </TelemetryInitializers>
    </ApplicationInsights>

Alternativní metodou ASP.NET webových aplikací je vytvoření instance inicializátoru v kódu. Následující příklad ukazuje kód v souboru Global.aspx.cs :

 using Microsoft.ApplicationInsights.Extensibility;
 using CustomInitializer.Telemetry;

    protected void Application_Start()
    {
        // ...
        TelemetryConfiguration.Active.TelemetryInitializers.Add(new MyTelemetryInitializer());
    }

ASP.NET Core

Pro přidání nové TelemetryInitializer instance ji přidejte do kontejneru injektáže závislosti. Následující příklad ukazuje tento přístup. Přidejte tento kód do ConfigureServices metody třídy Startup.cs .

 using Microsoft.ApplicationInsights.Extensibility;
 using CustomInitializer.Telemetry;
 public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<ITelemetryInitializer, MyTelemetryInitializer>();
}

Řízení IP adresy klienta používané pro mapování geografické polohy

Následující ukázkový inicializátor nastaví IP adresu klienta, která se používá pro mapování geografické polohy místo IP adresy soketu klienta během příjmu telemetrie.

public void Initialize(ITelemetry telemetry)
{
    var request = telemetry as RequestTelemetry;
    if (request == null) return true;
    request.Context.Location.Ip = "{client ip address}"; // Could utilize System.Web.HttpContext.Current.Request.UserHostAddress;   
    return true;
}

Procesory telemetrie

Procesory telemetrie můžou filtrovat a upravovat jednotlivé položky telemetrie před odesláním ze sady SDK na portál.

Implementovat ITelemetryProcessor

Procesory telemetrie vytváří řetěz zpracování. Když vytvoříte instanci procesoru telemetrie, získáte odkaz na další procesor v řetězu. Když se do procesní metody předá datový bod telemetrie, vykoná svou funkci a pak zavolá (nebo nevolá) dalšího procesoru telemetrie v řetězu.

using Microsoft.ApplicationInsights.Channel;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.DataContracts;

public class SuccessfulDependencyFilter : ITelemetryProcessor
{
    private ITelemetryProcessor Next { get; set; }

    // next will point to the next TelemetryProcessor in the chain.
    public SuccessfulDependencyFilter(ITelemetryProcessor next)
    {
        this.Next = next;
    }

    public void Process(ITelemetry item)
    {
        // To filter out an item, return without calling the next processor.
        if (!OKtoSend(item)) { return; }

        this.Next.Process(item);
    }

    // Example: replace with your own criteria.
    private bool OKtoSend (ITelemetry item)
    {
        var dependency = item as DependencyTelemetry;
        if (dependency == null) return true;

        return dependency.Success != true;
    }
}

Přidání procesoru

ASP.NET

Vložte tento fragment kódu do ApplicationInsights.config:

<TelemetryProcessors>
    <Add Type="WebApplication9.SuccessfulDependencyFilter, WebApplication9">
    <!-- Set public property -->
    <MyParamFromConfigFile>2-beta</MyParamFromConfigFile>
    </Add>
</TelemetryProcessors>

Řetězcové hodnoty můžete předat ze souboru .config zadáním veřejných pojmenovaných vlastností ve vaší třídě.

Výstraha

Ujistěte se, že název typu a všechny názvy vlastností v souboru .config odpovídají názvům tříd a vlastností v kódu. Pokud soubor .config odkazuje na neexistující typ nebo vlastnost, může sada SDK tiše selhat a neposlat žádnou telemetrii.

Případně můžete inicializovat filtr v kódu. V vhodné inicializační třídě, například AppStart in Global.asax.cs, vložte procesor do řetězu:

Poznámka:

Následující ukázka kódu je zastaralá, ale je zde k dispozici pro budoucí generace. Zvažte zahájení práce s OpenTelemetry nebo migraci na OpenTelemetry.

var builder = TelemetryConfiguration.Active.DefaultTelemetrySink.TelemetryProcessorChainBuilder;
builder.Use((next) => new SuccessfulDependencyFilter(next));

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

builder.Build();

Klienti telemetrie vytvořená po tomto bodu používají vaše procesory.

Procesor telemetrie adaptivního vzorkování (od verze 2.0.0-beta3)

Tato funkce je ve výchozím nastavení povolená. Pokud vaše aplikace odesílá značnou telemetrii, tento procesor některé z nich odebere.

    <TelemetryProcessors>
        <Add Type="Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel.AdaptiveSamplingTelemetryProcessor, Microsoft.AI.ServerTelemetryChannel">
        <MaxTelemetryItemsPerSecond>5</MaxTelemetryItemsPerSecond>
        </Add>
    </TelemetryProcessors>

Parametr poskytuje cíl, kterého se algoritmus pokusí dosáhnout. Každá instance sady SDK funguje nezávisle. Takže pokud je váš server clusterem několika počítačů, skutečný objem telemetrie se odpovídajícím způsobem vynásobí.

Přečtěte si další informace o vzorkování.

Procesor telemetrie vzorkování s pevnou rychlostí (z verze 2.0.0-beta1)

K dispozici je také standardní procesor telemetrie vzorkování (od 2.0.1):

    <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>10</SamplingPercentage>
        </Add>
    </TelemetryProcessors>

ASP.NET Core

Poznámka:

Přidání procesoru pomocí ApplicationInsights.config nebo TelemetryConfiguration.Active není platné pro aplikace ASP.NET Core ani pokud používáte SDK Microsoft.ApplicationInsights.WorkerService.

Pro ASP.NET Core se nový procesor telemetrie přidává pomocí metody rozšíření AddApplicationInsightsTelemetryProcessor na IServiceCollection, jak je znázorněno. Tato metoda je volána v ConfigureServices metodě vaší Startup.cs třídy.

var builder = WebApplication.CreateBuilder(args);

// ...
builder.Services.AddApplicationInsightsTelemetry();
builder.Services.AddApplicationInsightsTelemetryProcessor<MyFirstCustomTelemetryProcessor>();

// If you have more processors:
builder.Services.AddApplicationInsightsTelemetryProcessor<MySecondCustomTelemetryProcessor>();

var app = builder.Build();

Pokud chcete zaregistrovat procesory telemetrie, které potřebují parametry v ASP.NET Core, vytvořte vlastní třídu implementující ITelemetryProcessorFactory. Zavolejte konstruktor s požadovanými parametry v metodě Create a pak použijte AddSingleton ITelemetryProcessorFactory<, MyTelemetryProcessorFactory>().

Pracovní služba

Poznámka:

Přidání procesoru pomocí ApplicationInsights.config nebo TelemetryConfiguration.Active není platné pro aplikace ASP.NET Core ani pokud používáte SDK Microsoft.ApplicationInsights.WorkerService.

Pro službu Worker Service se přidání nového procesoru telemetrie provádí pomocí metody rozšíření AddApplicationInsightsTelemetryProcessor na IServiceCollection, jak je znázorněno. Tato metoda je volána v ConfigureServices metodě vaší Startup.cs třídy.

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddApplicationInsightsTelemetryWorkerService();
        services.AddApplicationInsightsTelemetryProcessor<MyFirstCustomTelemetryProcessor>();
        // If you have more processors:
        services.AddApplicationInsightsTelemetryProcessor<MySecondCustomTelemetryProcessor>();
    }

Ukázkové filtry

Syntetické požadavky

Vyfiltrujte roboty a webové testy. I když Průzkumník metrik nabízí možnost odfiltrovat syntetické zdroje, tato možnost snižuje provoz a velikost příjmu tím, že je filtruje přímo v sadě SDK.

public void Process(ITelemetry item)
{
    if (!string.IsNullOrEmpty(item.Context.Operation.SyntheticSource)) {return;}
    
    // Send everything else:
    this.Next.Process(item);
}

Neúspěšné ověřování

Vyfiltrujte požadavky s odpovědí 401.

public void Process(ITelemetry item)
{
    var request = item as RequestTelemetry;

    if (request != null &&
    request.ResponseCode.Equals("401", StringComparison.OrdinalIgnoreCase))
    {
        // To filter out an item, return without calling the next processor.
        return;
    }

    // Send everything else
    this.Next.Process(item);
}

Filtrujte rychlá volání vzdálených závislostí

Pokud chcete diagnostikovat pouze volání, která jsou pomalá, vyfiltrujte rychlé volání.

Poznámka:

Toto filtrování zkosí statistiky, které vidíte na portálu.

public void Process(ITelemetry item)
{
    var request = item as DependencyTelemetry;

    if (request != null && request.Duration.TotalMilliseconds < 100)
    {
        return;
    }
    this.Next.Process(item);
}

Vzorkování

Informace o konfiguraci vzorkování pro aplikace ASP.NET a ASP.NET Core najdete v tématu Vzorkování v Application Insights.

Pracovní služba

Sada Application Insights SDK pro pracovní službu podporuje vzorkování s pevnou rychlostí i adaptivní vzorkování. Adaptivní vzorkování je ve výchozím nastavení povolené. Vzorkování je možné zakázat pomocí EnableAdaptiveSampling možnosti v ApplicationInsightsServiceOptions.

Pokud chcete nakonfigurovat další nastavení vzorkování, můžete použít následující příklad:

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");
});

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

var app = builder.Build();

Obohacení dat prostřednictvím protokolu HTTP

ASP.NET

var requestTelemetry = HttpContext.Current?.Items["Microsoft.ApplicationInsights.RequestTelemetry"] as RequestTelemetry;

if (requestTelemetry != null)
{
    requestTelemetry.Properties["myProp"] = "someData";
}

ASP.NET Core

HttpContext.Features.Get<RequestTelemetry>().Properties["myProp"] = someData

Node.js

V této části

• Filtrování a předběžné zpracování telemetrie
• Inicializátory telemetrie
• Procesor telemetrie
• Vzorkování
• Více rolí pro více komponentní aplikace

Filtrování a předběžné zpracování telemetrie

Před odesláním ze sady SDK můžete napsat kód pro filtrování, úpravu nebo rozšiřování telemetrie. Zpracování zahrnuje data odesílaná ze standardních modulů telemetrie, jako je například shromažďování požadavků HTTP a kolekce závislostí.

• Filtrování může upravit nebo zahodit telemetrii před jejím odesláním ze sady SDK pomocí implementace ITelemetryProcessor. Můžete například snížit objem telemetrie vyloučením požadavků z robotů. Na rozdíl od vzorkování máte úplnou kontrolu nad tím, co se odesílá nebo zahodí, ale ovlivňuje všechny metriky založené na agregovaných protokolech. V závislosti na tom, jak položky zahodíte, můžete také ztratit možnost přecházet mezi souvisejícími položkami.

• Přidejte nebo upravte vlastnosti do jakékoli telemetrie odeslané z vaší aplikace implementací ITelemetryInitializer. Můžete například přidat počítané hodnoty nebo čísla verzí, podle kterých chcete filtrovat data na portálu.

• Vzorkování snižuje objem telemetrie, aniž by to ovlivnilo vaše statistiky. Udržuje související datové body pohromadě, abyste mezi nimi mohli přecházet při diagnostice problému. V rámci portálu se celkové počty násobí, aby bylo kompenzováno odběr vzorků.

Poznámka:

Rozhraní API sady SDK slouží k odesílání vlastních událostí a metrik.

Filtering

Tato technika poskytuje přímou kontrolu nad tím, co je součástí nebo vyloučeno z datového proudu telemetrie. Filtrování je možné použít k vyřazení položek telemetrie odesílaných do Application Insights. Filtrování můžete použít s vzorkováním nebo samostatně.

Pokud chcete filtrovat telemetrii, napíšete procesor telemetrie a zaregistrujete ho v TelemetryConfiguration. Veškerá telemetrie prochází vaším procesorem. Můžete ho vypustit z datového proudu nebo ho předat dalšímu procesoru v řetězci. Zahrnuje se telemetrie ze standardních modulů, jako je kolektor požadavků HTTP a kolektor závislostí a telemetrie, kterou jste sledovali sami. Můžete například filtrovat telemetrii týkající se požadavků od robotů nebo úspěšných volání na závislosti.

Výstraha

Filtrování telemetrie odeslané ze sady SDK pomocí procesorů může zkosit statistiky, které vidíte na portálu, a ztížit sledování souvisejících položek.

Místo toho zvažte použití vzorkování.

ITelemetryProcessor a ITelemetryInitializer

Jaký je rozdíl mezi procesory telemetrie a inicializátory telemetrie?

• Existují určité společné rysy v tom, co s nimi můžete dělat. Obojí se dá použít k přidání nebo úpravě vlastností telemetrie, i když pro tento účel doporučujeme používat inicializátory.
• Inicializátory telemetrie se vždy spouštějí před procesory telemetrie.
• Inicializátory telemetrie mohou být volány více než jednou. Podle konvence nenastavují žádnou vlastnost, která už byla nastavena.
• Procesory telemetrie umožňují zcela nahradit nebo zahodit položku telemetrie.
• Pro každou položku telemetrie se volají všechny zaregistrované inicializátory telemetrie. V případě procesorů telemetrie sada SDK zaručuje volání prvního procesoru telemetrie. Zda je zbytek procesorů volán, je rozhodováno předchozími telemetrickými procesory.
• Pomocí inicializátorů telemetrie můžete rozšířit telemetrii o více vlastností nebo přepsat existující. Pomocí procesoru telemetrie můžete vyfiltrovat telemetrii.

Přidání nebo úprava vlastností

Inicializátory telemetrie slouží k obohacení telemetrie o další informace nebo k přepsání vlastností telemetrie nastavených standardními moduly telemetrie.

Application Insights pro webový balíček například shromažďuje telemetrická data o požadavcích HTTP. Ve výchozím nastavení označí všechny požadavky s kódem odpovědi >=400 jako neúspěšné. Pokud místo toho chcete zacházet s 400 jako s úspěchem, můžete poskytnout inicializátor telemetrie, který nastaví vlastnost úspěchu.

Pokud zadáte inicializátor telemetrie, volá se při každém zavolání jakékoli metody Track*(). Tento inicializátor zahrnuje Track() metody, které jsou volány standardními moduly telemetrie. Podle konvence tyto moduly nenastavují žádnou vlastnost, která byla již nastavena inicializátorem. Inicializátory telemetrie se volají před voláním procesorů telemetrie, takže všechny rozšiřování provedené inicializátory jsou viditelné pro procesory.

Procesory telemetrie

Shromážděná data můžete zpracovávat a filtrovat před jejich odesláním za účelem uchovávání pomocí procesorů telemetrie. Procesory telemetrie se nazývají jeden po druhém v pořadí, v jakém byly přidány před odesláním položky telemetrie do cloudu.

public addTelemetryProcessor(telemetryProcessor: (envelope: Contracts.Envelope, context: { http.RequestOptions, http.ClientRequest, http.ClientResponse, correlationContext }) => boolean)

Pokud procesor telemetrie vrátí false, tato položka telemetrie se neodesílá.

Všechny procesory telemetrie přijímají telemetrická data a jeho obálku pro kontrolu a úpravy. Obdrží také kontextový objekt. Obsah tohoto objektu contextObjects je definován parametrem při volání metody sledování pro ručně sledované telemetrie. Pro automaticky shromážděnou telemetrii se tento objekt vyplní dostupnými informacemi o požadavku a trvalým obsahem požadavku, který appInsights.getCorrelationContext() poskytuje (pokud je povolená automatická korelace závislostí).

Typ TypeScriptu pro procesor telemetrie je:

telemetryProcessor: (envelope: ContractsModule.Contracts.Envelope, context: { http.RequestOptions, http.ClientRequest, http.ClientResponse, correlationContext }) => boolean;

Například procesor, který odstraní informace o trasování zásobníků z výjimek, lze zapsat a přidat následujícím způsobem:

function removeStackTraces ( envelope, context ) {
  if (envelope.data.baseType === "Microsoft.ApplicationInsights.ExceptionData") {
    var data = envelope.data.baseData;
    if (data.exceptions && data.exceptions.length > 0) {
      for (var i = 0; i < data.exceptions.length; i++) {
        var exception = data.exceptions[i];
        exception.parsedStack = null;
        exception.hasFullStack = false;
      }
    }
  }
  return true;
}

appInsights.defaultClient.addTelemetryProcessor(removeStackTraces);

Přidání názvu cloudové role a instance cloudové role

Nastavte název cloudové role prostřednictvím přímých kontextových značek:

var appInsights = require("applicationinsights");
appInsights.setup('CONNECTION_STRING').start();
appInsights.defaultClient.context.tags["ai.cloud.role"] = "your role name";
appInsights.defaultClient.context.tags["ai.cloud.roleInstance"] = "your role instance";

Nastavení názvu cloudové role prostřednictvím procesoru telemetrie:

var appInsights = require("applicationinsights");
appInsights.setup('CONNECTION_STRING').start();

appInsights.defaultClient.addTelemetryProcessor(envelope => {
    envelope.tags["ai.cloud.role"] = "your role name";
    envelope.tags["ai.cloud.roleInstance"] = "your role instance"
});

Vzorkování

Sada SDK ve výchozím nastavení odesílá všechna shromážděná data do služby Application Insights. Pokud chcete povolit vzorkování, abyste snížili množství dat, nastavte samplingPercentage pole na config objektu klienta. Nastavení samplingPercentage na 100 (výchozí) znamená, že budou odeslána všechna data a 0 znamená, že se nic neposílají.

Pokud používáte automatickou korelaci, všechna data přidružená k jednomu požadavku se zahrnou nebo vyloučí jako jednotka.

Přidejte například následující kód, který povolí vzorkování:

const appInsights = require("applicationinsights");
appInsights.setup("<connection_string>");
appInsights.defaultClient.config.samplingPercentage = 33; // 33% of all telemetry will be sent to Application Insights
appInsights.start();

Více rolí pro více komponentní aplikace

V některých scénářích se vaše aplikace může skládat z několika komponentů, které chcete všechny instrumentovat stejným připojovacím řetězcem. Tyto komponenty chcete na portálu stále vidět jako samostatné jednotky, jako by používaly samostatné připojovací řetězec. Příkladem jsou samostatné uzly na mapě aplikace. Musíte ručně nakonfigurovat RoleName pole tak, aby odlišily telemetrii jedné komponenty od ostatních komponent, které odesílají data do prostředku Application Insights.

K nastavení RoleName pole použijte následující kód:

const appInsights = require("applicationinsights");
appInsights.setup("<connection_string>");
appInsights.defaultClient.context.tags[appInsights.defaultClient.context.keys.cloudRole] = "MyRoleName";
appInsights.start();

Konfigurace sady SDK

.NET

V této části

• Kanály telemetrie
• Moduly telemetrie
• Zakázání telemetrie
• Připojovací řetězec
• Zprostředkovatel ID aplikace

Sadu Application Insights SDK můžete přizpůsobit pro ASP.NET, ASP.NET Core a Worker Service a změnit výchozí konfiguraci.

ASP.NET

Sada Application Insights .NET SDK se skládá z mnoha balíčků NuGet. Základní balíček poskytuje rozhraní API pro odesílání telemetrie do Application Insights. Další balíčky poskytují moduly telemetrie a inicializátory pro automatické sledování telemetrie z vaší aplikace a jejího kontextu. Úpravou konfiguračního souboru můžete povolit nebo zakázat moduly telemetrie a inicializátory. Můžete také nastavit parametry pro některé z nich.

Konfigurační soubor má název ApplicationInsights.config nebo ApplicationInsights.xml. Název závisí na typu vaší aplikace. Při instalaci většiny verzí sady SDK se do projektu automaticky přidá.

Když ve výchozím nastavení použijete automatizované prostředí z projektů šablon sady Visual Studio, které podporují přidání>telemetrie Application Insights, ApplicationInsights.config soubor se vytvoří v kořenové složce projektu. Po kompilaci se zkopíruje do složky bin. Přidá se také do webové aplikace agentem Application Insights na serveru SLUŽBY IIS.

Důležité

Konfigurační soubor se ignoruje, pokud se použije rozšíření pro weby Azure nebo rozšíření pro virtuální počítače Azure a škálovací sady virtuálních počítačů Azure .

Neexistuje ekvivalentní soubor pro řízení sady SDK na webové stránce.

ASP.NET Core

V aplikacích ASP.NET Core jsou všechny změny konfigurace provedeny v ConfigureServices() metodě vaší třídy Startup.cs , pokud není směrováno jinak.

Poznámka:

V aplikacích ASP.NET Core se změna konfigurace úpravou TelemetryConfiguration.Active nepodporuje.

Pracovní služba

Výchozí TelemetryConfiguration používaná sadou SDK pracovní služby je podobná automatické konfiguraci používané v aplikaci ASP.NET nebo ASP.NET Core, bez inicializátorů telemetrie používaných ke zpracování telemetrie z HttpContext.

SDK Application Insights for Worker Service můžete přizpůsobit ke změně výchozí konfigurace. Uživatelé sady Application Insights ASP.NET Core SDK mohou být obeznámeni se změnou konfigurace pomocí integrovaného vkládání závislostí v ASP.NET Core. Sada SDK pracovních služeb je také založena na podobných principech. Proveďte téměř všechny změny konfigurace v oddílu ConfigureServices() voláním vhodných metod IServiceCollection, jak je podrobně popsáno v další části.

Poznámka:

Pokud používáte sadu SDK pracovní služby, změna konfigurace úpravou TelemetryConfiguration.Active se nepodporuje a změny se neprojeví.

Kanály telemetrie

Telemetrické kanály jsou nedílnou součástí sad SDK Application Insights. Spravují ukládání do vyrovnávací paměti a přenos telemetrie do služby Application Insights. Verze sad .NET a .NET Core sad SDK mají dva integrované kanály telemetrie: InMemoryChannel a ServerTelemetryChannel. Tato část popisuje jednotlivé kanály a ukazuje, jak přizpůsobit chování kanálu.

Poznámka:

Nejčastější dotazy k nejčastějším dotazům najdete v nejčastějších dotazech ke kanálům telemetrie.

Co jsou kanály telemetrie?

Kanály telemetrie zodpovídají za ukládání položek telemetrie do vyrovnávací paměti a jejich odesílání do služby Application Insights, kde jsou uložené pro dotazování a analýzu. Kanál telemetrie je libovolná třída, která implementuje Microsoft.ApplicationInsights.ITelemetryChannel rozhraní.

Metoda Send(ITelemetry item) kanálu telemetrie se volá po zavolání všech inicializátorů telemetrie a procesorů telemetrie. Všechny položky vyřazené procesorem telemetrie se proto nedostanou do kanálu. Metoda Send() obvykle neodesílá položky do back-endu okamžitě. Obvykle je ukládá do vyrovnávací paměti a odesílá je do dávek pro efektivní přenos.

Vyhněte se volání Flush() , pokud není důležité odesílat telemetrická data do vyrovnávací paměti okamžitě. Používejte ho jenom ve scénářích, jako je vypnutí aplikace, zpracování výjimek nebo použití krátkodobých procesů, jako jsou úlohy na pozadí nebo nástroje příkazového řádku. Ve webových aplikacích nebo dlouhotrvajících službách sada SDK zpracovává automatické odesílání telemetrie. Zbytečné volání Flush() může způsobit problémy s výkonem.

Live Metrics Stream má také vlastní kanál, který využívá živé streamování telemetrie. Tento kanál je nezávislý na běžném kanálu telemetrie a tento dokument se na něj nevztahuje.

Integrované kanály telemetrie

Sady Application Insights .NET a .NET Core SDK se dodávají se dvěma integrovanými kanály:

• InMemoryChannel: Jednoduchý kanál, který do vyrovnávací paměti ukládat položky do paměti, dokud se neposílají. Položky se ukládají do vyrovnávací paměti a vyprázdní se jednou za 30 sekund nebo každých 500 položek do vyrovnávací paměti. Tento kanál nabízí minimální záruky spolehlivosti, protože se po selhání nebude opakovat odesílání telemetrie. Tento kanál také neuchová položky na disku. Všechny neodehrané položky se proto při vypnutí aplikace trvale ztratí bez ohledu na to, jestli jsou elegantní, nebo ne. Tento kanál implementuje metodu Flush() , která se dá použít k synchronnímu vyprázdnění všech položek telemetrie v paměti. Tento kanál je vhodný pro krátkodobé aplikace, kde je ideální synchronní vyprázdnění.

  Tento kanál je součástí většího balíčku NuGet Microsoft.ApplicationInsights a je výchozím kanálem, který sada SDK používá, když není nakonfigurováno nic jiného.

• ServerTelemetryChannel: Pokročilejší kanál, který má zásady opakování a schopnost ukládat data na místní disk. Tento kanál opakuje odesílání telemetrie, pokud dojde k přechodným chybám. Tento kanál také používá místní diskové úložiště k uchovávání položek na disku během výpadků sítě nebo velkých svazků telemetrie. Vzhledem k těmto mechanismům opakování a úložišti místních disků se tento kanál považuje za spolehlivější. Doporučujeme ho pro všechny produkční scénáře. Tento kanál je výchozí pro aplikace ASP.NET a ASP.NET Core nakonfigurované podle oficiální dokumentace. Tento kanál je optimalizovaný pro scénáře serveru s dlouhotrvajícími procesy. Metoda Flush() implementovaná tímto kanálem není synchronní.

  Tento kanál se odešle jako balíček NuGet Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel a získá se automaticky při použití balíčku NuGet Microsoft.ApplicationInsights.Web nebo Microsoft.ApplicationInsights.AspNetCore NuGet.

Konfigurace kanálu telemetrie

Kanál telemetrie nakonfigurujete tak, že ho nastavíte na aktivní konfiguraci telemetrie. Pro ASP.NET aplikace zahrnuje konfigurace nastavení instance kanálu telemetrie nebo TelemetryConfiguration.Active úpravou ApplicationInsights.config. U aplikací ASP.NET Core zahrnuje konfigurace přidání kanálu do kontejneru injektáž závislostí.

Následující části ukazují příklady konfigurace StorageFolder nastavení kanálu v různých typech aplikací. StorageFolder je pouze jedním z konfigurovatelných nastavení. Úplný seznam nastavení konfigurace najdete v části Konfigurovatelná nastavení v části Kanály dále v tomto článku.

ASP.NET

Možnost 1: Konfigurace v kódu

Následující kód nastaví ServerTelemetryChannel instanci s StorageFolder nastavenou na vlastní umístění. Přidejte tento kód na začátek aplikace, obvykle v Application_Start() metodě v Global.aspx.cs.

using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel;
protected void Application_Start()
{
    var serverTelemetryChannel = new ServerTelemetryChannel();
serverTelemetryChannel.StorageFolder = @"d:\temp\applicationinsights";
    serverTelemetryChannel.Initialize(TelemetryConfiguration.Active);
    TelemetryConfiguration.Active.TelemetryChannel = serverTelemetryChannel;
}

Možnost 2: Konfigurace v ApplicationInsights.config

Následující část z ApplicationInsights.config ukazuje ServerTelemetryChannel kanál nakonfigurovaný na StorageFolder vlastní umístění:

    <TelemetrySinks>
        <Add Name="default">
            <TelemetryProcessors>
                <!-- Telemetry processors omitted for brevity -->
            </TelemetryProcessors>
            <TelemetryChannel Type="Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel.ServerTelemetryChannel, Microsoft.AI.ServerTelemetryChannel">
                <StorageFolder>d:\temp\applicationinsights</StorageFolder>
            </TelemetryChannel>
        </Add>
    </TelemetrySinks>

ASP.NET Core

ConfigureServices Upravte metodu Startup.cs třídy, jak je znázorněno zde:

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

public void ConfigureServices(IServiceCollection services)
{
    // This sets up ServerTelemetryChannel with StorageFolder set to a custom location.
    services.AddSingleton(typeof(ITelemetryChannel), new ServerTelemetryChannel() {StorageFolder = @"d:\temp\applicationinsights" });

    services.AddApplicationInsightsTelemetry();
}

Důležité

Konfigurace kanálu pomocí není TelemetryConfiguration.Active pro aplikace ASP.NET Core podporovaná.

Přepsání ServeruTelemetryChannel

Výchozí kanál telemetrie je ServerTelemetryChannel. Následující příklad ukazuje, jak to přepsat.

using Microsoft.ApplicationInsights.Channel;

var builder = WebApplication.CreateBuilder(args);

// Use the following to replace the default channel with InMemoryChannel.
// This can also be applied to ServerTelemetryChannel.
builder.Services.AddSingleton(typeof(ITelemetryChannel), new InMemoryChannel() {MaxTelemetryBufferCapacity = 19898 });

builder.Services.AddApplicationInsightsTelemetry();

var app = builder.Build();

Poznámka:

Pokud chcete vyrovnávací paměť vyprázdnit, viz Vyprazdňování dat. Pokud například používáte sadu SDK v aplikaci, která se vypne, možná budete muset vyrovnávací paměť vyprázdnit.

Pracovní služba

Výchozí kanál je ServerTelemetryChannel. Můžete jej přepsat, jak ukazuje následující příklad:

using Microsoft.ApplicationInsights.Channel;

    public void ConfigureServices(IServiceCollection services)
    {
        // Use the following to replace the default channel with InMemoryChannel.
        // This can also be applied to ServerTelemetryChannel.
        services.AddSingleton(typeof(ITelemetryChannel), new InMemoryChannel() {MaxTelemetryBufferCapacity = 19898 });

        services.AddApplicationInsightsTelemetryWorkerService();
    }

Konfigurace v kódu pro konzolové aplikace

Pro konzolové aplikace je kód stejný pro .NET i .NET Core:

var serverTelemetryChannel = new ServerTelemetryChannel();
serverTelemetryChannel.StorageFolder = @"d:\temp\applicationinsights";
serverTelemetryChannel.Initialize(TelemetryConfiguration.Active);
TelemetryConfiguration.Active.TelemetryChannel = serverTelemetryChannel;

Provozní podrobnosti o Nástroji ServerTelemetryChannel

ServerTelemetryChannel ukládá příchozí položky do vyrovnávací paměti. Položky jsou serializovány, komprimovány a uloženy do Transmission instance jednou za 30 sekund nebo při uložení 500 položek do vyrovnávací paměti. Jedna Transmission instance obsahuje až 500 položek a představuje dávku telemetrie, která se odesílá přes jedno volání HTTPS do služby Application Insights.

Ve výchozím nastavení je možné paralelně odesílat maximálně 10 Transmission instancí. Pokud telemetrie přichází rychleji nebo pokud je síť nebo back-end Application Insights pomalý, Transmission instance se ukládají do paměti. Výchozí kapacita této vyrovnávací paměti v paměti Transmission je 5 MB. Při překročení Transmission kapacity v paměti se instance ukládají na místní disk až do limitu 50 MB.

Transmission Instance jsou uloženy na místním disku také v případě, že dochází k problémům se sítí. Pouze ty položky, které jsou uložené na místním disku, přežijí chybové ukončení aplikace. Posílají se pokaždé, když se aplikace znovu spustí. Pokud problémy se sítí potrvají, ServerTelemetryChannel použije se před opakovaným pokusem o odeslání telemetrie exponenciální logika zpětného od 10 sekund do 1 hodiny.

Konfigurovatelná nastavení v kanálech

Úplný seznam konfigurovatelných nastavení pro každý kanál najdete tady:

• InMemoryChannel
• ServerTelemetryChannel

Tady jsou nejčastěji používaná nastavení pro ServerTelemetryChannel:

• MaxTransmissionBufferCapacity: Maximální velikost paměti v bajtech, kterou kanál používá k ukládání přenosů do vyrovnávací paměti. Po dosažení této kapacity se nové položky ukládají přímo na místní disk. Výchozí hodnota je 5 MB. Nastavení vyšší hodnoty vede k menšímu využití disku, ale mějte na paměti, že pokud dojde k chybovému ukončení aplikace, dojde ke ztrátě položek v paměti.

• MaxTransmissionSenderCapacity: Maximální počet Transmission instancí odesílaných do Application Insights najednou. Výchozí hodnota je 10. Toto nastavení je možné nakonfigurovat na vyšší číslo, které doporučujeme, když se vygeneruje velký objem telemetrie. K vysokému objemu obvykle dochází během zátěžového testování nebo při vypnutí vzorkování.

• StorageFolder: Složka, kterou kanál používá k ukládání položek na disk podle potřeby. Ve Windows se %LOCALAPPDATA% nebo %TEMP% používá, pokud není explicitně zadána žádná jiná cesta. V jiných prostředích než Windows se ve výchozím nastavení používají následující umístění (v pořadí): %TMPDIR%, /var/tmp/ nebo /tmp/.

Jaký kanál mám použít?

Doporučujeme ServerTelemetryChannel pro většinu produkčních scénářů, které zahrnují dlouhotrvající aplikace. Další informace o vyprázdnění telemetrie si přečtěte o použití Flush().

Kdy použít Flush()

Metoda Flush() okamžitě odešle veškerou telemetrii s vyrovnávací pamětí. Měl by se ale používat pouze v konkrétních scénářích.

Použít Flush() když:

• Aplikace se chystá vypnout a chcete před ukončením zajistit odesílání telemetrie.
• Jste v obslužné rutině výjimky a potřebujete zaručit doručení telemetrie.
• Píšete krátkodobý proces, jako je úloha na pozadí nebo nástroj rozhraní příkazového řádku, který se rychle ukončí.

Vyhněte se používání Flush() v dlouhotrvajících aplikacích, jako jsou webové služby. Sada SDK automaticky spravuje ukládání do vyrovnávací paměti a přenos. Zbytečné volání Flush() může způsobit problémy s výkonem a nezaručuje, že se všechna data odesílají, zejména při použití ServerTelemetryChannel, která neprázdní synchronně.

Moduly telemetrie

Application Insights automaticky shromažďuje telemetrii o konkrétních úlohách bez nutnosti ručního sledování uživatelem.

Ve výchozím nastavení jsou povoleny následující moduly automatické kolekce. Můžete je zakázat nebo nakonfigurovat tak, aby měnily výchozí chování.

ASP.NET

Každý modul telemetrie shromažďuje konkrétní typ dat a k odesílání dat používá základní rozhraní API. Moduly jsou nainstalovány různými balíčky NuGet, které také přidávají požadované řádky do .config souboru.

Area	Description
Sledování požadavků	Shromažďuje telemetrii požadavků (doba odezvy, kód výsledku) pro příchozí webové požadavky. Modul:Microsoft.ApplicationInsights.Web.RequestTrackingTelemetryModule NuGet:Microsoft.ApplicationInsights.Web
Sledování závislostí	Shromažďuje telemetrii o odchozích závislostech (volání HTTP, volání SQL). Pokud chcete pracovat se službou IIS, nainstalujte agenta Application Insights. Můžete také napsat vlastní sledování závislostí pomocí rozhraní TrackDependency API. Podporuje autoinstrumentaci pomocí App Service a monitorování virtuálních počítačů a jejich škálovacích sad. Modul:Microsoft.ApplicationInsights.DependencyCollector.DependencyTrackingTelemetryModule NuGet:Microsoft.ApplicationInsights.DependencyCollector
Čítače výkonu	Shromažďuje čítače výkonu Systému Windows (procesor, paměť, zatížení sítě z instalací služby IIS). Určete, které čítače (včetně vlastních čítačů). Další informace naleznete v tématu Shromažďování čítačů výkonu systému. Modul:Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.PerformanceCollectorModule NuGet:Microsoft.ApplicationInsights.PerfCounterCollector
Čítače událostí	Shromažďuje .NET EventCounters. Doporučuje se pro ASP.NET Core a multiplatformní místo čítačů výkonu Windows. Modul:EventCounterCollectionModule (SDK ≥ 2.8.0)
Živé metriky (QuickPulse)	Shromažďuje telemetrii pro podokno Živé metriky. Modul:QuickPulseTelemetryModule
Prezenčních signálů (App Service)	Odesílá prezenčních signálů a vlastní metriky pro službu App Service Environment. Modul:AppServicesHeartbeatTelemetryModule
Sledovací signály (virtuální počítače a škálovací sady virtuálních počítačů)	Odesílá prezenčních signálů a vlastní metriky pro prostředí virtuálních počítačů Azure. Modul:AzureInstanceMetadataTelemetryModule
Telemetrie diagnostiky	Hlásí chyby v instrumentačním kódu Application Insights (například chybějící čítače, ITelemetryInitializer výjimky). Telemetrie trasování se zobrazí ve vyhledávání diagnostiky. Modul:Microsoft.ApplicationInsights.Extensibility.Implementation.Tracing.DiagnosticsTelemetryModule NuGet:Microsoft.ApplicationInsights Poznámka: Pokud instalujete pouze tento balíček, soubor ApplicationInsights.config se automaticky nevytvořil.
Vývojářský režim (připojený ladicí program)	Vynutí TelemetryChannel okamžité odeslání položek při připojení ladicího programu. Snižuje latenci, ale zvyšuje režii procesoru nebo sítě. Modul:Microsoft.ApplicationInsights.WindowsServer.DeveloperModeWithDebuggerAttachedTelemetryModule NuGet:Application Insights Windows Server
Sledování výjimek (web)	Sleduje neošetřené výjimky ve webových aplikacích. Viz Chyby a výjimky. Modul:Microsoft.ApplicationInsights.Web.ExceptionTrackingTelemetryModule NuGet:Microsoft.ApplicationInsights.Web
Sledování výjimek (neošetřené nebo neošetřené)	Sleduje neošetřené výjimky úloh a neošetřené výjimky pro role pracovních procesů, služby Windows a konzolové aplikace. Moduly:  • Microsoft.ApplicationInsights.WindowsServer.UnobservedExceptionTelemetryModule  • Microsoft.ApplicationInsights.WindowsServer.UnhandledExceptionTelemetryModule NuGet:Microsoft.ApplicationInsights.WindowsServer
Sledování zdroje událostí	Odesílá nakonfigurované události EventSource do Application Insights jako trasování. Modul:Microsoft.ApplicationInsights.EventSourceListener.EventSourceTelemetryModule NuGet:Microsoft.ApplicationInsights.EventSourceListener
Kolektor Trasování událostí pro Windows	Odesílá nakonfigurované události zprostředkovatele Trasování událostí pro Windows do Application Insights jako trasování. Modul:Microsoft.ApplicationInsights.EtwCollector.EtwCollectorTelemetryModule NuGet:Microsoft.ApplicationInsights.EtwCollector
Základní rozhraní API (ne modul)	Základní rozhraní API používané jinými komponentami telemetrie a pro vlastní telemetrii Modul:Microsoft.ApplicationInsights package NuGet:Microsoft.ApplicationInsights Poznámka: Pokud instalujete pouze tento balíček, soubor ApplicationInsights.config se automaticky nevytvořil.

ASP.NET Core

Area	Description
Sledování požadavků	Integrované sledování požadavků prostřednictvím integrace ASP.NET Core Application Insights. Modul:Žádná samostatná třída modulu. NuGet:Microsoft.ApplicationInsights.AspNetCore
Sledování závislostí	Prostřednictvím kolektoru závislostí. NuGet:Microsoft.ApplicationInsights.DependencyCollector
Čítače výkonu	Jen pro Windows! Na různých platformách použijte EventCounterCollectionModule (viz další řádek). NuGet:Microsoft.ApplicationInsights.PerfCounterCollector
Čítače událostí	Shromažďuje .NET EventCounters. Doporučuje se pro ASP.NET Core a multiplatformní místo čítačů výkonu Windows. Modul:EventCounterCollectionModule (SDK 2.8.0 a vyšší) NuGet:Microsoft.ApplicationInsights.EventCounterCollector
Živé metriky (QuickPulse)	Živé metriky povoleny v integraci nástroje Application Insights pro ASP.NET Core. Modul:Žádná samostatná třída modulu. NuGet:Microsoft.ApplicationInsights.AspNetCore
Kolektor prezenčních signálů (App Service)	Odesílá prezenčních signálů (jako vlastní metriky) s podrobnostmi o službě App Service Environment. Integrovaná prostřednictvím základní sady SDK, když je hostovaná ve službě App Service. Modul:Žádná samostatná třída modulu. NuGet:Microsoft.ApplicationInsights.AspNetCore
Kolektor prezenčních signálů (virtuální počítače a škálovací sady virtuálních počítačů)	Odesílá prezenčních signálů (jako vlastní metriky) s podrobnostmi o prostředí virtuálního počítače Azure. Integrované prostřednictvím základní sady SDK, když jsou hostované na virtuálních počítačích Azure a škálovacích sadách virtuálních počítačů Azure. Modul:Žádná samostatná třída modulu. NuGet:Microsoft.ApplicationInsights.AspNetCore
Telemetrie diagnostiky	Hlásí chyby v samotném kódu instrumentace Application Insights (například nemůže získat přístup k čítačům výkonu, ITelemetryInitializer vyvolá výjimku). Telemetrie trasování se zobrazí ve vyhledávání diagnostiky. Modul:Microsoft.ApplicationInsights.Extensibility.Implementation.Tracing.DiagnosticsTelemetryModule NuGet:Microsoft.ApplicationInsights
Vývojářský režim (připojený ladicí program)	Stejné chování je k dispozici; třída je součástí balíčku Systému Windows Server. Modul:Microsoft.ApplicationInsights.WindowsServer.DeveloperModeWithDebuggerAttachedTelemetryModule NuGet:Microsoft.ApplicationInsights.WindowsServer
Sledování výjimek (web)	Automatické sledování výjimek v integraci ASP.NET Core Application Insights Modul:Žádná samostatná třída modulu. NuGet:Microsoft.ApplicationInsights.AspNetCore
Sledování výjimek (neošetřené nebo neošetřené)	Podobné chování prostřednictvím modulu ASP.NET Core Runtime/integrace; Názvy tříd jsou specifické pro Windows Server. NuGet:Microsoft.ApplicationInsights.WindowsServer
Sledování zdroje událostí	Odesílá nakonfigurované události EventSource do Application Insights jako trasování. Modul:Microsoft.ApplicationInsights.EventSourceListener.EventSourceTelemetryModule NuGet:Microsoft.ApplicationInsights.EventSourceListener
Kolektor Trasování událostí pro Windows	Windows-only (EtW). Odesílá nakonfigurované události zprostředkovatele Trasování událostí pro Windows do Application Insights jako trasování. Modul:Microsoft.ApplicationInsights.EtwCollector.EtwCollectorTelemetryModule NuGet:Microsoft.ApplicationInsights.EtwCollector
Základní rozhraní API (ne modul)	Základní rozhraní API používané jinými komponentami telemetrie a pro vlastní telemetrii Modul:Microsoft.ApplicationInsights package NuGet:Microsoft.ApplicationInsights

Konfigurace modulů telemetrie

ASP.NET

Pomocí oddílu TelemetryModules v ApplicationInsights.config nakonfigurujte, přidejte nebo odeberte moduly. Následující příklady:

• Konfigurace DependencyTrackingTelemetryModule (povolení injektáže hlaviček W3C)
• Nakonfigurujte EventCounterCollectionModule (zrušte výchozí nastavení a přidejte jeden čítač).
• Zakázání kolekce perf-counter odebráním PerformanceCollectorModule.

<ApplicationInsights>
  <TelemetryModules>

    <!-- Dependency tracking -->
    <Add Type="Microsoft.ApplicationInsights.DependencyCollector.DependencyTrackingTelemetryModule, Microsoft.AI.DependencyCollector">
      <!-- Match Core example: enable W3C header injection -->
      <EnableW3CHeadersInjection>true</EnableW3CHeadersInjection>
    </Add>

    <!-- EventCounterCollectionModule: add a single counter (if you use event counters) -->
    <Add Type="Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.EventCounterCollectionModule, Microsoft.AI.PerfCounterCollector">
      <Counters>
        <!-- Mirrors Core example: only collect 'gen-0-size' from System.Runtime -->
        <Add ProviderName="System.Runtime" CounterName="gen-0-size" />
      </Counters>
    </Add>

    <!-- PerformanceCollectorModule (classic Windows performance counters).
         To DISABLE perf-counter collection, do NOT include this module.
         If it already exists in your file, remove or comment it out.
         Example of the line you would remove:
    <Add Type="Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.PerformanceCollectorModule, Microsoft.AI.PerfCounterCollector" />
    -->

  </TelemetryModules>
</ApplicationInsights>

Poznámka:

Přesná sada modulů, které jsou přítomné ve vaší ApplicationInsights.config sadě SDK, závisí na tom, které balíčky SDK jste nainstalovali.

ASP.NET Core

Možnost 1: Konfigurace modulů telemetrie pomocí modulu ConfigureTelemetryModule

Pokud chcete nakonfigurovat jakékoli výchozí TelemetryModule, použijte metodu rozšíření ConfigureTelemetryModule<T> na IServiceCollection, jak je znázorněno v následujícím příkladu:

using Microsoft.ApplicationInsights.DependencyCollector;
using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddApplicationInsightsTelemetry();

// The following configures DependencyTrackingTelemetryModule.
// Similarly, any other default modules can be configured.
builder.Services.ConfigureTelemetryModule<DependencyTrackingTelemetryModule>((module, o) =>
        {
            module.EnableW3CHeadersInjection = true;
        });

// The following removes all default counters from EventCounterCollectionModule, and adds a single one.
builder.Services.ConfigureTelemetryModule<EventCounterCollectionModule>((module, o) =>
        {
            module.Counters.Add(new EventCounterCollectionRequest("System.Runtime", "gen-0-size"));
        });

// The following removes PerformanceCollectorModule to disable perf-counter collection.
// Similarly, any other default modules can be removed.
var performanceCounterService = builder.Services.FirstOrDefault<ServiceDescriptor>(t => t.ImplementationType == typeof(PerformanceCollectorModule));
if (performanceCounterService != null)
{
    builder.Services.Remove(performanceCounterService);
}

var app = builder.Build();

Možnost 2: Konfigurace modulů telemetrie pomocí ApplicationInsightsServiceOptions

V sadě SDK verze 2.12.2 a novějších můžete upravit několik běžných nastavení předáním ApplicationInsightsServiceOptionsAddApplicationInsightsTelemetrysouboru , například v tomto příkladu:

var builder = WebApplication.CreateBuilder(args);

var aiOptions = new Microsoft.ApplicationInsights.AspNetCore.Extensions.ApplicationInsightsServiceOptions();

// Disables adaptive sampling.
aiOptions.EnableAdaptiveSampling = false;

// Disables live metrics (also known as QuickPulse).
aiOptions.EnableQuickPulseMetricStream = false;

builder.Services.AddApplicationInsightsTelemetry(aiOptions);
var app = builder.Build();

Tato tabulka obsahuje úplný seznam ApplicationInsightsServiceOptions nastavení:

Setting	Description	Výchozí
PovolitModuleProSběrVýkonovýchPočítadel	Povolit nebo zakázat PerformanceCounterCollectionModule.	Pravdivé
Modul pro povolení sledování požadavků pomocí telemetrie	Povolit nebo zakázat RequestTrackingTelemetryModule.	Pravdivé
EnableEventCounterCollectionModule	Povolit nebo zakázat EventCounterCollectionModule.	Pravdivé
Modul pro umožnění sledování závislostí telemetrie	Povolit nebo zakázat DependencyTrackingTelemetryModule.	Pravdivé
Modul telemetrie srdečního tepu služby App Services	Povolit nebo zakázat AppServicesHeartbeatTelemetryModule.	Pravdivé
PovolitAzureInstanceMetadataTelemetrickýModul	Povolit nebo zakázat AzureInstanceMetadataTelemetryModule.	Pravdivé
PovolitRychlýPulzMetrickýTok	Povolení nebo zakázání funkce LiveMetrics	Pravdivé
PovolitAdaptivníVzorkování	Povolení nebo zakázání adaptivního vzorkování	Pravdivé
Povolit srdeční tep	Povolit nebo zakázat funkci heartbeat signálu. Pravidelně (15 min. výchozí) odesílá vlastní metriku s názvem HeartbeatState s informacemi o modulu runtime, jako je verze .NET a informace o prostředí Azure, pokud je to možné.	Pravdivé
PřidatExtraktorAutomatickyShromažďovanýchMetrik	Povolte nebo zakažte funkci AutoCollectedMetrics extractor. Tento procesor telemetrie odesílá předem agregované metriky o požadavcích a závislostech před vzorkováním.	Pravdivé
MožnostiSběruŽádostí.SledovatVýjimky	Povolte nebo zakažte hlášení o neošetřených výjimkách modulem pro shromažďování požadavků.	Hodnota False v netstandard2.0 (protože výjimky jsou sledovány pomocí ApplicationInsightsLoggerProvider). Jinak platí.
Povolit Modul Diagnostické Telemetrie	Povolit nebo zakázat DiagnosticsTelemetryModule. Zakázání způsobí ignorování následujících nastavení: EnableHeartbeat, EnableAzureInstanceMetadataTelemetryModulea EnableAppServicesHeartbeatTelemetryModule.	Pravdivé

Nejnovější seznam najdete v konfigurovatelném nastavení v ApplicationInsightsServiceOptions.

Doporučení konfigurace pro Microsoft.ApplicationInsights.AspNetCore SDK 2.15.0 a novější

V sadě SDK Microsoft.ApplicationInsights.AspNetCore verze 2.15.0 a novější můžete nakonfigurovat všechna nastavení, která jsou k dispozici, včetně ApplicationInsightsServiceOptions. Použijte instanci aplikace IConfiguration . Nastavení musí být pod částí ApplicationInsights, jak je znázorněno v následujícím příkladu. Následující část z appsettings.json nakonfiguruje připojovací řetězec a zakáže adaptivní vzorkování a shromažďování čítačů výkonu.

{
    "ApplicationInsights": {
    "ConnectionString": "<YOUR-CONNECTION-STRING>",
    "EnableAdaptiveSampling": false,
    "EnablePerformanceCounterCollectionModule": false
    }
}

Pokud se používá buď builder.Services.AddApplicationInsightsTelemetry(aiOptions) pro ASP.NET Core 6.0, nebo services.AddApplicationInsightsTelemetry(aiOptions) pro ASP.NET Core 3.1 a starší, přepíše to nastavení z Microsoft.Extensions.Configuration.IConfiguration.

Pracovní služba

Možnost 1: Konfigurace modulů telemetrie pomocí modulu ConfigureTelemetryModule

Application Insights používá moduly telemetrie k automatickému shromažďování telemetrických dat o konkrétních úlohách bez nutnosti ručního sledování.

Ve výchozím nastavení jsou povoleny následující moduly autocollection. Tyto moduly zodpovídají za automatické shromažďování telemetrie. Můžete je zakázat nebo nakonfigurovat tak, aby měnily výchozí chování.

• DependencyTrackingTelemetryModule
• PerformanceCollectorModule
• QuickPulseTelemetryModule
• AppServicesHeartbeatTelemetryModule (V současné době došlo k problému souvisejícímu s tímto modulem telemetrie. Dočasné alternativní řešení najdete v tématu Problém GitHubu 1689.)
• AzureInstanceMetadataTelemetryModule

Pokud chcete nakonfigurovat jakýkoliv výchozí modul telemetrie, použijte metodu rozšíření ConfigureTelemetryModule na IServiceCollection, jak je znázorněno v následujícím příkladu:

    using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse;
    using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector;

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddApplicationInsightsTelemetryWorkerService();

            // The following configures QuickPulseTelemetryModule.
            // Similarly, any other default modules can be configured.
            services.ConfigureTelemetryModule<QuickPulseTelemetryModule>((module, o) =>
            {
                module.AuthenticationApiKey = "<YOUR-API-KEY-HERE>";
            });

            // The following removes PerformanceCollectorModule to disable perf-counter collection.
            // Similarly, any other default modules can be removed.
            var performanceCounterService = services.FirstOrDefault<ServiceDescriptor>
                                        (t => t.ImplementationType == typeof(PerformanceCollectorModule));
            if (performanceCounterService != null)
            {
                services.Remove(performanceCounterService);
            }
    }

Možnost 2: Konfigurace modulů telemetrie pomocí ApplicationInsightsServiceOptions

Můžete upravit několik běžných nastavení předáním ApplicationInsightsServiceOptions do AddApplicationInsightsTelemetryWorkerService, jak je vidět v tomto příkladu:

using Microsoft.ApplicationInsights.WorkerService;

public void ConfigureServices(IServiceCollection services)
{
    var aiOptions = new ApplicationInsightsServiceOptions();
    // Disables adaptive sampling.
    aiOptions.EnableAdaptiveSampling = false;

    // Disables live metrics (also known as QuickPulse).
    aiOptions.EnableQuickPulseMetricStream = false;
    services.AddApplicationInsightsTelemetryWorkerService(aiOptions);
}

Tato ApplicationInsightsServiceOptions sada SDK je v oboru názvů Microsoft.ApplicationInsights.WorkerService, na rozdíl od Microsoft.ApplicationInsights.AspNetCore.Extensions v sadě SDK ASP.NET Core.

Následující tabulka uvádí běžně používaná nastavení v ApplicationInsightsServiceOptions.

Setting	Description	Výchozí
PovolitRychlýPulzMetrickýTok	Povolte nebo zakažte funkci živých metrik.	Pravdivé
PovolitAdaptivníVzorkování	Povolení nebo zakázání adaptivního vzorkování	Pravdivé
Povolit srdeční tep	Povolte nebo zakažte funkci Heartbeats, která pravidelně (15 minut, výchozí hodnota) odesílá metriku pojmenovanou "HeartBeatState" s informacemi o modulu runtime, jako je verze .NET a prostředí Azure, pokud je to možné.	Pravdivé
PřidatExtraktorAutomatickyShromažďovanýchMetrik	Povolte nebo zakažte extraktor AutoCollectedMetrics, což je procesor telemetrie, který před vzorkováním odesílá předem agregované metriky o požadavcích a závislostech.	Pravdivé
Povolit Modul Diagnostické Telemetrie	Povolit nebo zakázat DiagnosticsTelemetryModule. Zakázání tohoto nastavení způsobí ignorování následujících nastavení: EnableHeartbeat, EnableAzureInstanceMetadataTelemetryModulea EnableAppServicesHeartbeatTelemetryModule.	Pravdivé

Nejaktuálnější seznam najdete v konfigurovatelných nastaveních v ApplicationInsightsServiceOptions.

Zakázání telemetrie

ASP.NET

V konfiguračním souboru pro každý modul je uzel. Pokud chcete modul zakázat, odstraňte uzel nebo ho okomentujte.

ASP.NET Core

Pokud chcete telemetrii podmíněně a dynamicky zakázat, můžete instanci vyřešit pomocí kontejneru pro vkládání závislostí v ASP.NET Core kdekoliv ve svém kódu a nastavit na ní příznak TelemetryConfiguration.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddApplicationInsightsTelemetry();

// any custom configuration can be done here:
builder.Services.Configure<TelemetryConfiguration>(x => x.DisableTelemetry = true);

var app = builder.Build();

Předchozí ukázka kódu brání odesílání telemetrie do Application Insights. Nezabrání automatickým sběrným modulům ve shromažďování telemetrie. Pokud chcete odebrat konkrétní modul autocollection, podívejte se na moduly telemetrie.

Pracovní služba

Pokud chcete telemetrii podmíněně a dynamicky zakázat, můžete instanci vyřešit pomocí kontejneru pro vkládání závislostí v ASP.NET Core kdekoliv ve svém kódu a nastavit na ní příznak TelemetryConfiguration.

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddApplicationInsightsTelemetryWorkerService();
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, TelemetryConfiguration configuration)
    {
        configuration.DisableTelemetry = true;
        ...
    }

Připojovací řetězec

Toto nastavení určuje prostředek Application Insights, ve kterém se vaše data zobrazují. Obvykle vytvoříte samostatný prostředek se samostatným připojovacím řetězcem pro každou aplikaci.

Ukázky kódu najdete v tématu Připojovací řetězce v Application Insights.

Pokud chcete připojovací řetězec nastavit dynamicky, například pro odesílání výsledků z vaší aplikace do různých prostředků, můžete vynechat připojovací řetězec z konfiguračního souboru a místo toho ho nastavit v kódu.

ASP.NET

Pokud chcete nastavit připojovací řetězec pro všechny instance , včetně standardních TelemetryClienttelemetrických modulů, proveďte tento krok v inicializační metodě, například global.aspx.cs ve službě ASP.NET:

using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights;

    protected void Application_Start()
    {
        TelemetryConfiguration configuration = TelemetryConfiguration.CreateDefault();
        configuration.ConnectionString = "<YOUR-CONNECTION-STRING>";
        var telemetryClient = new TelemetryClient(configuration);

Pokud chcete odeslat konkrétní sadu událostí do jiného prostředku, můžete klíč pro konkrétního klienta telemetrie nastavit:

    var tc = new TelemetryClient();
    tc.Context.ConnectionString = "<YOUR-CONNECTION-STRING>";
    tc.TrackEvent("myEvent");
    // ...

Pokud chcete získat nový připojovací řetězec, vytvořte nový prostředek na portálu Application Insights.

ASP.NET Core

V ASP.NET Core nakonfigurujte připojovací řetězec během Program.cs spouštění aplikace pomocí TelemetryConfiguration kontejneru injektáže závislostí (DI):

using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights;

var builder = WebApplication.CreateBuilder(args);

// Add Application Insights
builder.Services.AddApplicationInsightsTelemetry();

var app = builder.Build();

// Resolve TelemetryConfiguration from DI and set the connection string
var config = app.Services.GetRequiredService<TelemetryConfiguration>();
config.ConnectionString = "<YOUR-CONNECTION-STRING>";

app.Run();

Pokud chcete odeslat konkrétní sadu událostí do jiného prostředku, můžete vytvořit novou TelemetryClient instanci a explicitně nastavit její připojovací řetězec:

using Microsoft.ApplicationInsights;

var tc = new TelemetryClient();
tc.Context.ConnectionString = "<YOUR-CONNECTION-STRING>";
tc.TrackEvent("myEvent");
// ...

Zprostředkovatel ID aplikace

Poznámka:

Pro ASP.NET je tento poskytovatel dostupný od sady SDK verze 2.6.0*.

Účelem tohoto poskytovatele je vyhledat ID aplikace na základě připojovacího řetězce. ID aplikace je součástí RequestTelemetry a DependencyTelemetry slouží k určení korelace na portálu.

Tato funkce je dostupná nastavením TelemetryConfiguration.ApplicationIdProvider.

Rozhraní: IApplicationIdProvider

public interface IApplicationIdProvider
{
    bool TryGetApplicationId(string connectionString, out string applicationId);
}

Poskytujeme dvě implementace v sadě Microsoft.ApplicationInsights SDK: ApplicationInsightsApplicationIdProvider a DictionaryApplicationIdProvider.

ApplicationInsightsApplicationIdProvider

Tento obálka je určená pro rozhraní API profilu. Omezuje požadavky a výsledky mezipaměti. Tento zprostředkovatel se automaticky zahrne při instalaci Microsoft.ApplicationInsights.DependencyCollector nebo Microsoft.ApplicationInsights.Web.

Třída zveřejňuje volitelnou vlastnost s názvem ProfileQueryEndpoint. Ve výchozím nastavení je nastavená na https://dc.services.visualstudio.com/api/profiles/{0}/appIdhodnotu .

Pokud potřebujete nakonfigurovat proxy server, doporučujeme proxy server základní adresu a zajistit, aby cesta zahrnovala /api/profiles/{0}/appId. Během běhu se {0} nahradí připojovacím řetězcem pro každý požadavek.

ASP.NET

Příklad konfigurace prostřednictvím ApplicationInsights.config

<ApplicationInsights>
    ...
    <ApplicationIdProvider Type="Microsoft.ApplicationInsights.Extensibility.Implementation.ApplicationId.ApplicationInsightsApplicationIdProvider, Microsoft.ApplicationInsights">
        <ProfileQueryEndpoint>https://dc.services.visualstudio.com/api/profiles/{0}/appId</ProfileQueryEndpoint>
    </ApplicationIdProvider>
    ...
</ApplicationInsights>

Příklad konfigurace prostřednictvím kódu

TelemetryConfiguration.Active.ApplicationIdProvider = new ApplicationInsightsApplicationIdProvider();

ASP.NET Core

Poznámka:

V ASP.NET Core neexistuje žádný souborApplicationInsights.config . Konfigurace se provádí prostřednictvím injektáže závislostí (DI) v Program.cs nebo Startup.cs.

Můžete přepsat výchozího poskytovatele nebo přizpůsobit jeho ProfileQueryEndpoint.

using Microsoft.ApplicationInsights.Extensibility.Implementation.ApplicationId;

var builder = WebApplication.CreateBuilder(args);

// Add Application Insights
builder.Services.AddApplicationInsightsTelemetry();

// Replace default provider with custom configuration
builder.Services.AddSingleton<IApplicationIdProvider>(sp =>
    new ApplicationInsightsApplicationIdProvider
    {
        ProfileQueryEndpoint = "https://custom-proxy/api/profiles/{0}/appId"
    });

var app = builder.Build();
app.Run();

DictionaryApplicationIdProvider

Tento statický zprostředkovatel spoléhá na nakonfigurované páry připojovacího řetězce nebo ID aplikace.

Tato třída má Defined vlastnost, což je Dictionary<string,string> dvojice ID připojovacího řetězce nebo aplikace.

Tato třída má volitelnou vlastnost Next, kterou lze použít ke konfiguraci jiného poskytovatele, který se má použít při vyžádání připojovacího řetězce, který v konfiguraci neexistuje.

ASP.NET

Příklad konfigurace prostřednictvím ApplicationInsights.config

<ApplicationInsights>
    ...
    <ApplicationIdProvider Type="Microsoft.ApplicationInsights.Extensibility.Implementation.ApplicationId.DictionaryApplicationIdProvider, Microsoft.ApplicationInsights">
        <Defined>
            <Type key="ConnectionString_1" value="ApplicationId_1"/>
            <Type key="ConnectionString_2" value="ApplicationId_2"/>
        </Defined>
        <Next Type="Microsoft.ApplicationInsights.Extensibility.Implementation.ApplicationId.ApplicationInsightsApplicationIdProvider, Microsoft.ApplicationInsights" />
    </ApplicationIdProvider>
    ...
</ApplicationInsights>

Příklad konfigurace prostřednictvím kódu

TelemetryConfiguration.Active.ApplicationIdProvider = new DictionaryApplicationIdProvider{
 Defined = new Dictionary<string, string>
    {
        {"ConnectionString_1", "ApplicationId_1"},
        {"ConnectionString_2", "ApplicationId_2"}
    }
};

ASP.NET Core

using Microsoft.ApplicationInsights.Extensibility.Implementation.ApplicationId;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddApplicationInsightsTelemetry();

// Register DictionaryApplicationIdProvider
builder.Services.AddSingleton<IApplicationIdProvider>(sp =>
    new DictionaryApplicationIdProvider
    {
        Defined = new Dictionary<string, string>
        {
            { "ConnectionString_1", "ApplicationId_1" },
            { "ConnectionString_2", "ApplicationId_2" }
        },
        Next = new ApplicationInsightsApplicationIdProvider() // optional fallback
    });

var app = builder.Build();
app.Run();

Node.js

V této části

• Připojovací řetězec
• Možnost rozšířené konfigurace
• Automatická instrumentace třetích stran

Objekt appInsights poskytuje mnoho metod konfigurace. Jsou uvedené v následujícím fragmentu kódu s výchozími hodnotami.

let appInsights = require("applicationinsights");
appInsights.setup("<connection_string>")
    .setAutoDependencyCorrelation(true)
    .setAutoCollectRequests(true)
    .setAutoCollectPerformance(true, true)
    .setAutoCollectExceptions(true)
    .setAutoCollectDependencies(true)
    .setAutoCollectConsole(true)
    .setUseDiskRetryCaching(true)
    .setSendLiveMetrics(false)
    .setDistributedTracingMode(appInsights.DistributedTracingModes.AI)
    .start();

Pro úplnou korelaci událostí ve službě nezapomeňte nastavit .setAutoDependencyCorrelation(true). Nastavení této možnosti umožní sadě SDK sledovat kontext napříč asynchronními zpětnými voláními v Node.js.

Projděte si jejich popisy ve vestavěné nápovědě k typům ve vašem IDE nebo v souboru applicationinsights.ts, kde najdete podrobné informace a volitelné sekundární argumenty.

Poznámka:

Ve výchozím nastavení je setAutoCollectConsole nakonfigurováno tak, aby vylučovalo volání na a další metody konzole. Budou shromažďována pouze volání na podporované protokolovače třetích stran (například winston a bunyan). Toto chování můžete změnit tak, aby zahrnovalo volání console metod pomocí .setAutoCollectConsole(true, true)

Připojovací řetězec

Toto nastavení určuje prostředek Application Insights, ve kterém se vaše data zobrazují. Obvykle vytvoříte samostatný prostředek se samostatným připojovacím řetězcem pro každou aplikaci.

Ukázky kódu najdete v tématu Připojovací řetězce v Application Insights.

Pokud chcete připojovací řetězec nastavit dynamicky, například pro odesílání výsledků z vaší aplikace do různých prostředků, můžete vynechat připojovací řetězec z konfiguračního souboru a místo toho ho nastavit v kódu.

Použití více připojovacích řetězců

Pomocí příslušných připojovací řetězec můžete vytvořit několik prostředků Application Insights a posílat jim různá data.

Například:

let appInsights = require("applicationinsights");

// configure auto-collection under one connection string
appInsights.setup("Connection String A").start();

// track some events manually under another connection string
let otherClient = new appInsights.TelemetryClient("Connection String B");
otherClient.trackEvent({name: "my custom event"});

Pokročilé možnosti konfigurace

Objekt klienta obsahuje config vlastnost s mnoha volitelnými nastaveními pro pokročilé scénáře. Pokud je chcete nastavit, použijte:

client.config.PROPERTYNAME = VALUE;

Tyto vlastnosti jsou specifické pro klienta, takže můžete nakonfigurovat appInsights.defaultClient odděleně od klientů vytvořených pomocí new appInsights.TelemetryClient().

Vlastnictví	Description
connectionString	Identifikátor prostředku Application Insights.
endpointUrl	Koncový bod příjmu pro odesílání telemetrických dat.
quickPulseHost	Hostitel streamu živých metrik pro odesílání telemetrie živých metrik.
proxyHttpUrl	Proxy server pro HTTP komunikaci SDK. (Volitelné. Výchozí hodnota se načítá z proměnné prostředí http_proxy.)
proxyHttpsUrl	Proxy server pro provoz HTTPS sady SDK. (Volitelné. Výchozí hodnota se načítá z proměnné prostředí https_proxy.)
httpAgent	HTTP agent, který se má použít pro HTTP provoz v rámci SDK. (Volitelné. Výchozí hodnota není definována.)
httpsAgent (zprostředkovatel HTTPS)	Agenta HTTPS pro provoz SDK. (Volitelné. Výchozí hodnota není definována.)
maxBatchSize	Maximální počet položek telemetrie, které se mají zahrnout do datové části na koncovém bodu příjmu dat. (Výchozí hodnota je 250.)
maxBatchIntervalMs	Maximální doba čekání, než uživatelská data dosáhnou velikosti maxBatchSize. (Výchozí hodnota je 15000.)
zakázat AppInsights	Příznak označující, jestli je zakázaný přenos telemetrie. (Výchozí hodnota je false.)
procento vzorkování	Procento sledovaných položek telemetrie, které by se měly přenášet. (Výchozí hodnota je 100.)
interval opakování pro korelační identifikátor (ms)	Doba čekání před opakovaným pokusem o načtení ID pro korelaci mezi součástmi (Výchozí hodnota je 30000.)
vyloučenéDoményKorelacíHlaviček	Seznam domén, které se mají vyloučit z injektáže hlaviček korelace mezi komponentami. (Výchozí. Viz Config.ts.)

Automatická instrumentace třetích stran

Ke sledování kontextu napříč asynchronními voláními se v knihovnách třetích stran, jako jsou MongoDB a Redis, vyžadují některé změny. Application Insights ve výchozím nastavení používá diagnostic-channel-publishers k úpravám za běhu některých z těchto knihoven. Tuto funkci lze zakázat nastavením APPLICATION_INSIGHTS_NO_DIAGNOSTIC_CHANNEL proměnné prostředí.

Poznámka:

Nastavením této proměnné prostředí nemusí být události správně přidruženy ke správné operaci.

Jednotlivé opičí záplaty lze zakázat nastavením proměnné prostředí APPLICATION_INSIGHTS_NO_PATCH_MODULES na seznam balíčků, které chcete zakázat, oddělených čárkami. Použijte například APPLICATION_INSIGHTS_NO_PATCH_MODULES=console,redis, abyste se vyhnuli opravám balíčků console a redis.

V současné době je instrumentováno devět balíčků: bunyan, console, mongodb, mongodb-core, mysql, redis, winston, pg a pg-pool. Informace o tom, která verze těchto balíčků je opravena, najdete v souboru README pro vydavatele diagnostických kanálů.

bunyan, winston a console záplaty generují události trasování Application Insights na základě toho, zda je setAutoCollectConsole povoleno. Zbytek generuje události závislostí Application Insights na základě toho, jestli setAutoCollectDependencies je povoleno.

Přidat monitorování na straně klienta

.NET

Předchozí části obsahují pokyny k automatické a ruční konfiguraci monitorování na straně serveru. Pokud chcete přidat monitorování na straně klienta, použijte sadu JavaScript SDK na straně klienta. Transakce na straně klienta libovolné webové stránky můžete monitorovat přidáním JavaScript (Web) SDK zavaděcího skriptu před koncovou </head> značku HTML stránky.

I když je možné ručně přidat JavaScript (Web) SDK Loader Script do záhlaví každé stránky HTML, doporučujeme místo toho přidat JavaScript (Web) SDK Loader Script na hlavní stránku. Tato akce vloží skript zavaděče sady JavaScript (Web) SDK na všechny stránky webu.

ASP.NET

Pro aplikaci ASP.NET MVC založenou na šabloně z tohoto článku je soubor, který potřebujete upravit, _Layout.cshtml. Najdete to pod Zobrazení>Sdílené. Pokud chcete přidat monitorování na straně klienta, otevřete soubor _Layout.cshtml a postupujte podle pokynů pro nastavení JavaScript (Web) SDK založeného na skriptech z článku o konfiguraci této sady na straně klienta.

ASP.NET Core

Pokud má vaše aplikace komponenty na straně klienta, postupujte podle dalších kroků a začněte shromažďovat telemetrické údaje o využití pomocí vložení skriptu zavaděče sady JavaScript (Web) SDK dle konfigurace.

1. Do souboru _ViewImports.cshtml přidejte injektáž:

   @inject Microsoft.ApplicationInsights.AspNetCore.JavaScriptSnippet JavaScriptSnippet
   

2. V souboru _Layout.cshtml vložte HtmlHelper na konec sekce <head>, ale před jakýkoli jiný skript. Pokud chcete nahlásit vlastní telemetrii JavaScriptu ze stránky, zadejte ji za tento fragment kódu:

       @Html.Raw(JavaScriptSnippet.FullScript)
   </head>
   

Jako alternativu k použití FullScript je ScriptBody dostupný počínaje sadou Application Insights SDK pro ASP.NET Core verze 2.14. Použijte ScriptBody , pokud potřebujete řídit <script> značku pro nastavení zásad zabezpečení obsahu:

<script> // apply custom changes to this script tag.
    @Html.Raw(JavaScriptSnippet.ScriptBody)
</script>

Názvy souborů .cshtml odkazované dříve pocházejí z výchozí šablony aplikace MVC. Pokud chcete pro svou aplikaci správně povolit monitorování na straně klienta, musí se skript zavaděče sady JavaScript (Web) SDK zobrazit v <head> části každé stránky aplikace, kterou chcete monitorovat. Přidejte skript zavaděče sady JavaScript (Web) SDK do souboru _Layout.cshtml v šabloně aplikace pro povolení monitorování na straně klienta.

Pokud váš projekt neobsahuje _Layout.cshtml, můžete monitorování na straně klienta přidat přidáním skriptu zavaděče sady JavaScript (Web) SDK do ekvivalentního souboru, který řídí <head> všechny stránky v aplikaci. Případně můžete přidat skript JavaScript (Web) SDK Loader Script na více stránek, ale toto použití nedoporučujeme.

Poznámka:

Injektáž JavaScriptu poskytuje výchozí prostředí konfigurace. Pokud vyžadujete konfiguraci nad rámec nastavení připojovacího řetězce, musíte autoinjection odebrat podle popisu a ručně přidat javascriptovou sadu SDK.

Node.js

Poznámka:

K dispozici jako veřejná ukázka. Dodatečné podmínky použití pro Microsoft Azure verze Preview

Automatickou webovou instrumentaci je možné povolit pro server Node.js prostřednictvím injekce loader skriptu JavaScriptového (webového) SDK pomocí konfigurace.

let appInsights = require("applicationinsights");
appInsights.setup("<connection_string>")
    .enableWebInstrumentation(true)
    .start();

nebo nastavením proměnné prostředí APPLICATIONINSIGHTS_WEB_INSTRUMENTATION_ENABLED = true.

Pokud jsou splněny všechny následující požadavky, je na serverech uzlů povolená webová instrumentace:

• Odpověď má stavový kód 200.
• Metoda odpovědi je GET.
• Odpověď serveru má Content-Type kód HTML.
• Odpověď serveru obsahuje obě <head> a </head> značky.
• Pokud je odpověď komprimovaná, musí mít pouze jeden Content-Encoding typ a typ kódování musí být jeden z gzip, br nebo deflate.
• Odpověď neobsahuje aktuální ani záložní webové koncové body CDN instrumentace. (aktuální a záložní CDN koncové body pro webovou instrumentaci zde)

Koncový bod CDN webové instrumentace lze změnit nastavením proměnné prostředí `APPLICATIONINSIGHTS_WEB_INSTRUMENTATION_SOURCE = "web Instrumentation CDN endpoints"`. Připojovací řetězec Web Instrumentation lze změnit nastavením proměnné prostředí APPLICATIONINSIGHTS_WEB_INSTRUMENTATION_CONNECTION_STRING = "web Instrumentation connection string".

Poznámka:

Webová instrumentace může zpomalit dobu odezvy serveru, zejména pokud je velikost odpovědi velká nebo je komprimovaná odpověď. V případě, že se použijí některé střední vrstvy systému, může způsobit, že webová instrumentace nefunguje a původní odpověď bude vrácena.

Základní rozhraní API pro vlastní události a metriky

Vložte do aplikace několik řádků kódu, abyste zjistili, co s ním uživatelé dělají, nebo abyste mohli diagnostikovat problémy. Můžete odesílat telemetrii ze zařízení a desktopových aplikací, webových klientů a webových serverů. Pomocí základního rozhraní API telemetrie Application Insights můžete odesílat vlastní události a metriky a vlastní verze standardní telemetrie. Toto rozhraní API je to samé, které používají standardní kolektory dat Application Insights.

Souhrn rozhraní API

Základní rozhraní API je jednotné na všech platformách, kromě několika odchylek, jako je GetMetric (pouze pro .NET).

Metoda	Používá se pro
TrackPageView	Stránky, obrazovky, podokna nebo formuláře
TrackEvent	Akce uživatelů a další události Používá se ke sledování chování uživatelů nebo ke sledování výkonu.
GetMetric	Nulové a multidimenzionální metriky, centrálně nakonfigurované agregace, pouze C#.
TrackMetric	Měření výkonu, jako jsou délky front, nesouvisely s konkrétními událostmi.
TrackException	Protokolování výjimek pro diagnostiku Sledovat, kde se vyskytují ve vztahu k jiným událostem, a zkoumat trasování zásobníku.
TrackRequest	Protokolování frekvence a doby trvání požadavků serveru pro analýzu výkonu
TrackTrace	Zprávy logu diagnostiky prostředků Můžete také zaznamenávat protokoly třetích stran.
TrackDependency	Protokolování doby trvání a frekvence volání externích komponent, na které vaše aplikace závisí.

K většině těchto volání telemetrie můžete připojit vlastnosti a metriky .

Požadavky

Pokud zatím nemáte referenci na Application Insights SDK:

1. Přidejte do projektu sadu Application Insights SDK.

2. Zahrňte do kódu vašeho zařízení nebo webového serveru:

   .NET

   using Microsoft.ApplicationInsights;
   

   Node.js

   var applicationInsights = require("applicationinsights");
   

Získání instance TelemetryClient

Získání instance TelemetryClient:

Poznámka:

Pokud používáte Azure Functions v2 nebo Azure WebJobs v3+, přečtěte si téma Monitorování Azure Functions.

.NET

Poznámka:

Pro aplikace ASP.NET Core a non-HTTP/Worker pro aplikace .NET/.NET Core získejte instanci TelemetryClient z kontejneru injektáže závislostí, jak je vysvětleno v příslušné dokumentaci.

private TelemetryClient telemetry = new TelemetryClient();

Pokud se zobrazí zpráva s informací, že tato metoda je zastaralá, další informace najdete v tématu microsoft/ApplicationInsights-dotnet#1152 .

Příchozí požadavky HTTP se zaznamenávají automaticky. Možná budete chtít vytvořit další instance pro další moduly TelemetryClient vaší aplikace. Můžete mít například v middlewarové třídě jednu TelemetryClient instanci pro hlášení událostí obchodní logiky. Můžete nastavit vlastnosti, například UserId a DeviceId identifikovat počítač. Tyto informace jsou připojeny ke všem událostem, které instance odesílá.

TelemetryClient.Context.User.Id = "...";
TelemetryClient.Context.Device.Id = "...";

Node.js

var telemetry = applicationInsights.defaultClient;

Můžete použít new applicationInsights.TelemetryClient(instrumentationKey?) k vytvoření nové instance. Tento přístup doporučujeme pouze pro scénáře, které vyžadují izolovanou konfiguraci od singletonu defaultClient.

Poznámka:

TelemetryClient je vláknově bezpečné.

TrackEvent

Ve službě Application Insights je vlastní událost datovým bodem, který můžete v Průzkumníku metrik zobrazit jako agregovaný počet a v diagnostickém vyhledávání jako jednotlivé výskyty. (Nesouvisí s MVC ani s jinými "frameworkovými událostmi".)

Vložte volání TrackEvent do kódu pro počítání různých událostí. Můžete například chtít sledovat, jak často si uživatelé vyberou konkrétní funkci. Nebo můžete chtít vědět, jak často dosahují určitých cílů nebo dělají určité typy chyb.

Například v aplikaci hry odešlete událost pokaždé, když uživatel vyhraje hru:

.NET

telemetry.TrackEvent("WinGame");

Node.js

telemetry.trackEvent({name: "WinGame"});

Vlastní události v Log Analytics

Telemetrie je dostupná v customEvents tabulce na kartě Protokoly Application Insights nebo v prostředí využití. Události můžou pocházet z trackEvent(..) nebo z modulu plug-in Click Analytics Autocollection.

Pokud je vzorkování v provozu, itemCount vlastnost zobrazuje hodnotu větší než 1. Například itemCount==10 znamená, že z 10 volání na trackEvent() proces vzorkování přenesl pouze jedno. Pokud chcete získat správný počet vlastních událostí, použijte kód, například customEvents | summarize sum(itemCount).

Poznámka:

itemCount má minimální hodnotu jedné; samotný záznam představuje položku.

GetMetric

Informace o efektivním využití GetMetric() volání k zachycení místně předem agregovaných metrik pro aplikace .NET a .NET Core najdete v tématu Vlastní kolekce metrik v .NET a .NET Core.

TrackMetric

Poznámka:

Microsoft.ApplicationInsights.TelemetryClient.TrackMetric není upřednostňovanou metodou odesílání metrik. Metriky by se měly před odesláním vždy předem agregovat napříč časovým obdobím. Pomocí jednoho z přetížených objektů GetMetric(..) můžete získat metrický objekt pro přístup k funkcím preagregace v sadě SDK.

Pokud implementujete vlastní logiku před agregací, můžete použít metodu TrackMetric() k odeslání výsledných agregací. Pokud vaše aplikace vyžaduje odesílání samostatné položky telemetrie při každé příležitosti bez agregace v čase, pravděpodobně máte případ použití pro telemetrii událostí. Viz TelemetryClient.TrackEvent(Microsoft.ApplicationInsights.DataContracts.EventTelemetry).

Application Insights může grafovat metriky, které nejsou připojené k určitým událostem. Můžete například monitorovat délku fronty v pravidelných intervalech. U metrik jsou jednotlivá měření méně zajímavá než variace a trendy, takže statistické grafy jsou užitečné.

K odesílání metrik do Application Insights můžete použít TrackMetric(..) rozhraní API. Metriku můžete odeslat dvěma způsoby:

• Jedna hodnota. Pokaždé, když v aplikaci provedete měření, odešlete odpovídající hodnotu do Application Insights.

  Předpokládejme například, že máte metriku, která popisuje počet položek v kontejneru. Během určitého časového období nejprve vložíte do kontejneru tři položky a pak odeberete dvě položky. Proto byste volali TrackMetric dvakrát. Nejprve byste předali hodnotu 3 a pak předali hodnotu -2. Application Insights ukládá obě hodnoty za vás.

• Agregace. Při práci s metrikami je každé měření zřídka zajímavé. Místo toho je důležité shrnutí toho, co se stalo během určitého časového období. Takový souhrn se nazývá agregace.

  V předchozím příkladu je 1 agregační součet metrik pro dané časové období a počet hodnot metriky .2 Při použití přístupu k agregaci vyvoláte TrackMetric pouze jednou za časové období a odešlete agregované hodnoty. Tento přístup doporučujeme, protože může výrazně snížit náklady a výkon tím, že do Application Insights odesílá méně datových bodů, zatímco stále shromažďuje všechny relevantní informace.

Příklady s jednou hodnotou

Odeslání jedné hodnoty metriky:

.NET

var sample = new MetricTelemetry();
sample.Name = "queueLength";
sample.Sum = 42.3;
telemetryClient.TrackMetric(sample);

Node.js

telemetry.trackMetric({name: "queueLength", value: 42.0});

Vlastní metriky v Log Analytics

Telemetrie je dostupná v tabulce v customMetricsAnalýzách Application Insights. Každý řádek představuje volání trackMetric(..) v aplikaci.

• valueSum: Součet měření. Chcete-li získat střední hodnotu, vydělte hodnotou valueCount.
• valueCount: Počet měření, které byly agregovány do tohoto trackMetric(..) volání.

Poznámka:

valueCount má minimální hodnotu jedné; samotný záznam představuje položku.

Zobrazení stránek

V zařízení nebo webové aplikaci se při načtení každé obrazovky nebo stránky automaticky odesílají data o zobrazení stránek. Výchozí nastavení ale můžete změnit tak, aby sledovala zobrazení stránek ve více nebo různých časech. Například v aplikaci, která zobrazuje karty nebo podokna, můžete chtít sledovat stránku pokaždé, když uživatel otevře nové podokno.

Data uživatelů a relací se odesílají jako vlastnosti spolu se zobrazeními stránek, takže grafy uživatelů a relací ožijí, když dojde k telemetrii zobrazení stránky.

Vlastní zobrazení stránek

.NET

telemetry.TrackPageView("GameReviewPage");

Node.js

Nelze použít.

Telemetrie stránek v Log Analytics

V Log Analytics zobrazují dvě tabulky data z operací prohlížeče:

• pageViews: Obsahuje data o adrese URL a názvu stránky.
• browserTimings: Obsahuje data o výkonu klienta, jako je doba potřebná ke zpracování příchozích dat.

Zjistěte, jak dlouho prohlížeči trvá zpracování různých stránek:

browserTimings
| summarize avg(networkDuration), avg(processingDuration), avg(totalDuration) by name

Pokud chcete zjistit popularitu různých prohlížečů:

pageViews
| summarize count() by client_Browser

Chcete-li přidružit zobrazení stránek k voláním AJAX, spojte je se závislostmi:

pageViews
| join (dependencies) on operation_Id

TrackRequest

Serverová sada SDK používá TrackRequest k protokolování požadavků HTTP.

Můžete ho také volat sami, pokud chcete simulovat požadavky v kontextu, kde nemáte spuštěný modul webové služby.

Doporučeným způsobem odesílání telemetrie požadavků je místo, kde požadavek funguje jako kontext operace.

Kontext operace

Položky telemetrie můžete vzájemně korelovat tím, že je přidružíte k kontextu operace. Standardní modul pro sledování požadavků zpracovává výjimky a jiné události, které jsou odesílány během zpracování požadavku HTTP. Ve službě Search a Analytics můžete snadno najít všechny události přidružené k požadavku pomocí ID operace.

Pokud telemetrii sledujete ručně, nejjednodušší způsob, jak zajistit korelaci telemetrie pomocí tohoto vzoru:

.NET

// Establish an operation context and associated telemetry item:
using (var operation = telemetryClient.StartOperation<RequestTelemetry>("operationName"))
{
    // Telemetry sent in here uses the same operation ID.
    ...
    telemetryClient.TrackTrace(...); // or other Track* calls
    ...

    // Set properties of containing telemetry item--for example:
    operation.Telemetry.ResponseCode = "200";

    // Optional: explicitly send telemetry item:
    telemetryClient.StopOperation(operation);

} // When operation is disposed, telemetry item is sent.

Další informace o korelaci najdete v tématu Korelace telemetrie v Application Insights.

Node.js

// Establish an operation context and associated telemetry item:
const operation = appInsights.startOperation(client, { name: "operationName" });

appInsights.wrapWithCorrelationContext(() => {
    // Telemetry sent in here uses the same operation ID.
    ...
    client.trackTrace({ message: "..." }); // or other track* calls
    ...

    // Set properties of containing telemetry item—for example:
    operation.telemetry.responseCode = "200";

    // Optional: explicitly send telemetry item:
    client.stopOperation(operation);

}, operation.context)(); // When callback completes, telemetry item is sent.

Spolu s nastavením kontextu StartOperation operace vytvoří položku telemetrie zadaného typu. Odesílá položku telemetrie, když odstraníte operaci nebo pokud explicitně zavoláte StopOperation. Pokud jako typ telemetrie použijete RequestTelemetry , jeho doba trvání se nastaví na časový interval mezi spuštěním a zastavením.

Položky telemetrie hlášené v rámci operace se stanou podřízenými položkami takové operace. Kontexty operací můžou být vnořené.

Při hledání se kontext operace používá k vytvoření seznamu Souvisejících položek .

Další informace o sledování vlastních operací najdete v Track custom operations with Application Insights .NET SDK.

Požadavky v Log Analytics

V Application Insights Analytics se požadavky zobrazí v requests tabulce.

Pokud je vzorkování v provozu, itemCount vlastnost zobrazuje hodnotu větší než 1. Například itemCount==10 znamená, že z 10 volání na trackRequest() proces vzorkování přenesl pouze jedno. Pokud chcete získat správný počet požadavků a průměrnou dobu trvání segmentovanou podle názvů požadavků, použijte kód, například:

requests
| summarize count = sum(itemCount), avgduration = avg(duration) by name

TrackException

Odesílání výjimek do Application Insights:

• Pokud je chcete spočítat, jako indikátor četnosti problému.
• Chcete-li prozkoumat jednotlivé výskyty.

Hlášení zahrnují zásobníkové trasování.

.NET

try
{
    ...
}
catch (Exception ex)
{
    telemetry.TrackException(ex);
}

Node.js

try
{
    ...
}
catch (ex)
{
    telemetry.trackException({exception: ex});
}

SDK automaticky zachytává mnoho výjimek, takže ne vždy musíte volat TrackException explicitně.

Výjimky v Log Analytics

V Application Insights Analytics se výjimky zobrazují v exceptions tabulce.

Pokud je vzorkování v provozu, itemCount vlastnost zobrazuje hodnotu větší než 1. Například itemCount==10 znamená, že z 10 volání na trackException() proces vzorkování přenesl pouze jedno. Pokud chcete získat správný počet výjimek segmentovaných podle typu výjimky, použijte kód, například:

exceptions
| summarize sum(itemCount) by type

Většina důležitých informací o zásobníku je již extrahována do samostatných proměnných, ale můžete strukturu details rozdělit pro získání dalších informací. Vzhledem k tomu, že je tato struktura dynamická, měli byste výsledek přetypovat na očekávaný typ. Například:

exceptions
| extend method2 = tostring(details[0].parsedStack[1].method)

Pokud chcete přidružit výjimky k souvisejícím požadavkům, použijte připojení:

exceptions
| join (requests) on operation_Id

TrackTrace

Použijte TrackTrace k diagnostice problémů odesláním "stopy drobečků" do Application Insights. Můžete odesílat bloky diagnostických dat a kontrolovat je v diagnostickém vyhledávání.

.NET

V .NET adaptérech protokolu použijte toto rozhraní API k odesílání protokolů třetích stran na portál.

telemetry.TrackTrace(message, SeverityLevel.Warning, properties);

Node.js

telemetry.trackTrace({
    message: message,
    severity: applicationInsights.Contracts.SeverityLevel.Warning,
    properties: properties
});

Zaznamená diagnostickou událost, jako je zadání nebo opuštění metody.

Parameter	Description
message	Diagnostická data. Může být mnohem delší než název.
properties	Mapa od řetězce k řetězci Další data se používají k filtrování výjimek na portálu. Výchozí hodnota je prázdná.
severityLevel	Podporované hodnoty: SeverityLevel.ts.

Obsah zprávy můžete prohledávat, ale na rozdíl od hodnot vlastností na něm nemůžete filtrovat.

Limit message velikosti je mnohem vyšší než limit vlastností. Výhodou TrackTrace je, že do zprávy můžete vložit relativně dlouhá data. Můžete tam například zakódovat data POST.

Ke zprávě můžete také přidat úroveň závažnosti. A stejně jako jiná telemetrie můžete přidat hodnoty vlastností, které vám pomůžou filtrovat nebo vyhledávat různé sady tras. Například:

.NET

var telemetry = new Microsoft.ApplicationInsights.TelemetryClient();
telemetry.TrackTrace("Slow database response",
                SeverityLevel.Warning,
                new Dictionary<string,string> { {"database", db.ID} });

Node.js

Nelze použít.

Ve službě Search pak můžete snadno vyfiltrovat všechny zprávy konkrétní úrovně závažnosti, které souvisejí s konkrétní databází.

Trasování v Log Analytics

V Application Insights Analytics se volání do TrackTrace zobrazují v tabulce traces.

Pokud je vzorkování v provozu, itemCount vlastnost zobrazuje hodnotu větší než 1. Například itemCount==10 znamená, že z 10 volání na trackTrace() proces vzorkování přenesl pouze jedno. Chcete-li získat správný počet volání trasování, použijte například tento kód: traces | summarize sum(itemCount).

TrackDependency

TrackDependency Volání slouží ke sledování doby odezvy a míry úspěšnosti při volání externí části kódu. Výsledky se zobrazí v grafech závislostí na portálu. Následující fragment kódu se musí přidat všude, kde se provádí volání závislostí.

Poznámka:

Pro .NET a .NET Core můžete alternativně použít metodu TelemetryClient.StartOperation (extension), která vyplní DependencyTelemetry vlastnosti potřebné pro korelaci a některé další vlastnosti, jako je počáteční čas a doba trvání, takže nemusíte vytvářet vlastní časovač jako v následujících příkladech. Další informace najdete v části sledování odchozích závislostí v tématu Sledování vlastních operací pomocí sady Application Insights .NET SDK.

.NET

var success = false;
var startTime = DateTime.UtcNow;
var timer = System.Diagnostics.Stopwatch.StartNew();
try
{
    success = dependency.Call();
}
catch(Exception ex)
{
    success = false;
    telemetry.TrackException(ex);
    throw new Exception("Operation went wrong", ex);
}
finally
{
    timer.Stop();
    telemetry.TrackDependency("DependencyType", "myDependency", "myCall", startTime, timer.Elapsed, success);
}

Node.js

var success = false;
var startTime = new Date().getTime();
try
{
    success = dependency.Call();
}
finally
{
    var elapsed = new Date() - startTime;
    telemetry.trackDependency({
        dependencyTypeName: "myDependency",
        name: "myCall",
        duration: elapsed,
        success: success
    });
}

Nezapomeňte, že sady SDK serveru zahrnují modul závislostí , který zjišťuje a sleduje určitá volání závislostí automaticky, například databázím a rozhraním REST API. Abyste mohli modul fungovat, musíte na server nainstalovat agenta.

Toto volání použijete, pokud chcete sledovat volání, která automatizované sledování nezachytí.

Pokud chcete vypnout standardní modul sledování závislostí v jazyce C#, upravte ApplicationInsights.config a odstraňte odkaz na DependencyCollector.DependencyTrackingTelemetryModule.

Závislosti v Log Analytics

V Application Insights Analytics se trackDependency volání zobrazí v dependencies tabulce.

Pokud je vzorkování v provozu, vlastnost itemCount zobrazuje hodnotu větší než 1. Například itemCount==10 znamená, že z 10 volání na trackDependency() proces vzorkování přenesl pouze jedno. Pokud chcete získat správný počet závislostí segmentovaných podle cílové komponenty, použijte kód, například:

dependencies
| summarize sum(itemCount) by target

Pokud chcete přidružit závislosti k souvisejícím požadavkům, použijte spojení:

dependencies
| join (requests) on operation_Id

Vyčištění dat

Sada SDK obvykle odesílá data v pevných intervalech, obvykle 30 sekund nebo kdykoli je vyrovnávací paměť plná, což je obvykle 500 položek. V některých případech můžete chtít vyrovnávací paměť vyprázdnit. Příkladem je, že používáte sadu SDK v aplikaci, která se vypne.

.NET

Při použití Flush()doporučujeme tento vzor:

telemetry.Flush();
// Allow some time for flushing before shutdown.
System.Threading.Thread.Sleep(5000);

Při použití FlushAsync()doporučujeme tento vzor:

await telemetryClient.FlushAsync()
// No need to sleep

Doporučujeme vždy vyprázdnit v rámci vypnutí aplikace, aby se zajistilo, že se telemetrie neztratí.

Poznámka:

Zkontrolujte konfiguraci Autoflush: Povolení autoflush ve vašem web.config souboru může vést ke snížení výkonu v aplikacích .NET instrumentovaných pomocí Application Insights. Když je povolená funkce autoflush, každé vyvolání metod vede k odesílání jednotlivých položek telemetrie jako samostatných webových System.Diagnostics.Trace.Trace* požadavků do služby příjmu dat. To může potenciálně způsobit vyčerpání sítě a úložiště na webových serverech. Pro zvýšení výkonu se doporučuje zakázat autoflush a také využít ServerTelemetryChannel, který je navržený pro efektivnější přenos telemetrických dat.

Funkce je asynchronní pro kanál telemetrie serveru.

Node.js

telemetry.flush();

Ověření uživatelé

Ve webové aplikaci jsou uživatelé ve výchozím nastavení identifikováni soubory cookie . Pokud uživatel přistupuje k aplikaci z jiného počítače nebo prohlížeče, nebo pokud odstraní soubory cookie, může se počítat více než jednou.

Pokud se uživatelé přihlásí k aplikaci, můžete získat přesnější počet nastavením ověřeného ID uživatele v kódu prohlížeče. Není nutné použít skutečné přihlašovací jméno uživatele. Musí to být jenom ID, které je pro daného uživatele jedinečné. Nesmí obsahovat mezery ani žádný z znaků ,;=|.

ID uživatele je také nastaveno v relačním souboru cookie a odesláno na server. Pokud je sada SDK serveru nainstalovaná, ověřené ID uživatele se odešle jako součást kontextových vlastností telemetrie klienta i serveru. Můžete ho pak filtrovat a vyhledávat.

Pokud vaše aplikace seskupí uživatele do účtů, můžete mu také předat identifikátor. Platí stejná omezení znaků.

V Průzkumníku metrik můžete vytvořit graf, který počítá uživatele, ověřené a uživatelské účty.

Můžete také vyhledat klientské datové body s konkrétními uživatelskými jmény a účty.

Poznámka:

Vlastnost EnableAuthenticationTrackingJavaScript ve třídě ApplicationInsightsServiceOptions v sadě .NET Core SDK zjednodušuje konfiguraci JavaScriptu potřebnou k vložení uživatelského jména jako ID ověřování pro každé trasování odeslané sadou Application Insights JavaScript SDK.

Pokud je tato vlastnost nastavena na true, uživatelské jméno od uživatele v ASP.NET Core se vytiskne spolu s telemetrií na straně klienta. Z tohoto důvodu už není potřeba přidávat appInsights.setAuthenticatedUserContext ručně, protože už je vložený sadou SDK pro ASP.NET Core. ID ověřování se také odešle na server, kde sada SDK v .NET Core identifikuje a používá ho pro veškerou telemetrii na straně serveru, jak je popsáno v referenčních informacích k rozhraní JAVAScript API.

Pro javascriptové aplikace, které nefungují stejným způsobem jako ASP.NET Core MVC, jako jsou webové aplikace SPA, musíte přidat appInsights.setAuthenticatedUserContext ručně.

Filtrování, vyhledávání a segmentace dat pomocí vlastností

Vlastnosti a měření můžete připojit k událostem, metrikám, zobrazením stránek, výjimkám a dalším telemetrickým datům.

Vlastnosti jsou řetězcové hodnoty, které můžete použít k filtrování telemetrie přímo v přehledech o využití. Pokud například vaše aplikace poskytuje několik her, můžete ke každé události připojit název hry, abyste viděli, které hry jsou oblíbenější.

Délka řetězce je omezena na 8 192. Pokud chcete odesílat velké bloky dat, použijte parametr TrackTrace zprávy.

Metriky jsou číselné hodnoty, které lze graficky prezentovat. Například můžete chtít zjistit, zda dochází k postupnému zvyšování skóre, kterého vaši hráči dosahují. Grafy je možné segmentovat podle vlastností odesílaných s událostí, abyste mohli získat samostatné nebo skládané grafy pro různé hry.

Hodnoty metrik by měly být větší nebo rovny 0, aby se správně zobrazily.

Existuje několik omezení počtu vlastností, hodnot vlastností a metrik, které můžete použít.

.NET

// Set up some properties and metrics:
var properties = new Dictionary <string, string>
    {{"game", currentGame.Name}, {"difficulty", currentGame.Difficulty}};
var metrics = new Dictionary <string, double>
    {{"Score", currentGame.Score}, {"Opponents", currentGame.OpponentCount}};

// Send the event:
telemetry.TrackEvent("WinGame", properties, metrics);

Node.js

// Set up some properties and metrics:
var properties = {"game": currentGame.Name, "difficulty": currentGame.Difficulty};
var metrics = {"Score": currentGame.Score, "Opponents": currentGame.OpponentCount};

// Send the event:
telemetry.trackEvent({name: "WinGame", properties: properties, measurements: metrics});

Důležité

Ujistěte se, že ve vlastnostech nezapíšete identifikovatelné osobní údaje.

Alternativní způsob nastavení vlastností a metrik

Pokud je to pohodlnější, můžete shromažďovat parametry události v samostatném objektu:

var event = new EventTelemetry();

event.Name = "WinGame";
event.Metrics["processingTime"] = stopwatch.Elapsed.TotalMilliseconds;
event.Properties["game"] = currentGame.Name;
event.Properties["difficulty"] = currentGame.Difficulty;
event.Metrics["Score"] = currentGame.Score;
event.Metrics["Opponents"] = currentGame.Opponents.Length;

telemetry.TrackEvent(event);

Výstraha

Nepoužívejte opakovaně stejnou instanci položky telemetrie (event v tomto příkladu) k opakovanému volání Track*() . Tento postup může způsobit odesílání telemetrie s nesprávnou konfigurací.

Vlastní měření a vlastnosti v Log Analytics

V Log Analytics se vlastní metriky a vlastnosti zobrazují v customMeasurements a v customDimensions atributech jednotlivých záznamů telemetrie.

Pokud například do telemetrie požadavku přidáte vlastnost s názvem "game", tento dotaz spočítá výskyty různých hodnot "hry" a zobrazí průměr vlastní metriky "score":

requests
| summarize sum(itemCount), avg(todouble(customMeasurements.score)) by tostring(customDimensions.game)

Všimněte si, že:

• Když extrahujete hodnotu z objektu customDimensions NEBO customMeasurements JSON, má dynamický typ, takže ji musíte přetypovat tostring nebo todouble.
• Při zohlednění možnosti odběru vzorků nepoužívejte sum(itemCount)count().

Události synchronizace

Někdy chcete zobrazit graf, jak dlouho trvá provedení akce. Můžete například chtít vědět, jak dlouho uživatelé berou v úvahu volby ve hře. K získání těchto informací použijte parametr měření.

.NET

var stopwatch = System.Diagnostics.Stopwatch.StartNew();

// ... perform the timed action ...

stopwatch.Stop();

var metrics = new Dictionary <string, double>
    {{"processingTime", stopwatch.Elapsed.TotalMilliseconds}};

// Set up some properties:
var properties = new Dictionary <string, string>
    {{"signalSource", currentSignalSource.Name}};

// Send the event:
telemetry.TrackEvent("SignalProcessed", properties, metrics);

Node.js

Výchozí vlastnosti pro vlastní telemetrii

Pokud chcete nastavit výchozí hodnoty vlastností pro některé vlastní události, které napíšete, nastavte je v TelemetryClient instanci. Jsou připojené ke každé položce telemetrie odeslané z daného klienta.

.NET

using Microsoft.ApplicationInsights.DataContracts;

var gameTelemetry = new TelemetryClient();
gameTelemetry.Context.GlobalProperties["Game"] = currentGame.Name;
// Now all telemetry is automatically sent with the context property:
gameTelemetry.TrackEvent("WinGame");

Node.js

var gameTelemetry = new applicationInsights.TelemetryClient();
gameTelemetry.commonProperties["Game"] = currentGame.Name;

gameTelemetry.TrackEvent({name: "WinGame"});

Jednotlivá volání telemetrie mohou změnit výchozí hodnoty ve svých slovnících vlastností.

Pokud chcete přidat vlastnosti do všech telemetrických dat, včetně dat ze standardních modulů kolekce, implementujte ITelemetryInitializer.

Zakázání telemetrie

Dynamické zastavení a spuštění shromažďování a přenosu telemetrie:

.NET

using  Microsoft.ApplicationInsights.Extensibility;

TelemetryConfiguration.Active.DisableTelemetry = true;

Node.js

telemetry.config.disableAppInsights = true;

Chcete-li při inicializaci zakázat vybrané standardní kolektory, jako jsou například čítače výkonu, požadavky HTTP či závislosti, propojte konfigurační metody s inicializačním kódem sady SDK.

applicationInsights.setup()
    .setAutoCollectRequests(false)
    .setAutoCollectPerformance(false)
    .setAutoCollectExceptions(false)
    .setAutoCollectDependencies(false)
    .setAutoCollectConsole(false)
    .start();

Chcete-li tyto kolektory po inicializaci zakázat, použijte objekt Konfigurace: applicationInsights.Configuration.setAutoCollectRequests(false).

Vývojářský režim

Během ladění je užitečné urychlit telemetrii prostřednictvím datového kanálu, abyste mohli okamžitě vidět výsledky. Získáte také další zprávy, které vám pomůžou trasovat všechny problémy s telemetrií. Vypněte ho v produkčním prostředí, protože může zpomalit vaši aplikaci.

.NET

TelemetryConfiguration.Active.TelemetryChannel.DeveloperMode = true;

Node.js

Pro Node.jsmůžete povolit vývojářský režim povolením interního protokolování prostřednictvím setInternalLogging a nastavením maxBatchSize0, což způsobí, že se vaše telemetrie odešle hned po shromáždění.

applicationInsights.setup("ikey")
  .setInternalLogging(true, true)
  .start()
applicationInsights.defaultClient.config.maxBatchSize = 0;

Nastavení instrumentačního klíče pro vybranou vlastní telemetrii

.NET

var telemetry = new TelemetryClient();
telemetry.InstrumentationKey = "---my key---";
// ...

Node.js

Dynamický připojovací řetězec

Abyste se vyhnuli kombinování telemetrie z vývojových, testovacích a produkčních prostředí, můžete vytvořit samostatné prostředky Application Insights a změnit jejich klíče v závislosti na prostředí.

Místo získání instrumentačního klíče z konfiguračního souboru ho můžete nastavit ve svém kódu. Nastavte klíč v inicializační metodě, například global.aspx.cs ve službě ASP.NET:

.NET

protected void Application_Start()
{
    Microsoft.ApplicationInsights.Extensibility.
    TelemetryConfiguration.Active.InstrumentationKey =
        // - for example -
        WebConfigurationManager.Settings["ikey"];
    ...
}

Node.js

Nelze použít.

TelemetryContext

TelemetryClient má vlastnost Context, která obsahuje hodnoty, které se odesílají spolu se všemi telemetrickými daty. Obvykle jsou nastavené standardními moduly telemetrie, ale můžete je také nastavit sami. Například:

telemetry.Context.Operation.Name = "MyOperationName";

Pokud některou z těchto hodnot nastavíte sami, zvažte odebrání příslušného řádku z ApplicationInsights.config , aby se hodnoty a standardní hodnoty nezaměňily.

• Komponenta: Aplikace a její verze.
• Zařízení: Data o zařízení, na kterém je aplikace spuštěná. Ve webových aplikacích se jedná o server nebo klientské zařízení, ze kterého se telemetrie odesílá.
• InstrumentationKey: Prostředek Application Insights v Azure, kde se telemetrie zobrazuje. Obvykle je načteno ze souboru ApplicationInsights.config.
• Umístění: Zeměpisné umístění zařízení.
• Operace: Ve webových aplikacích aktuální požadavek HTTP. V jiných typech aplikací můžete tuto hodnotu nastavit tak, aby seskupily události dohromady.
  • ID: Vygenerovaná hodnota, která koreluje různé události, takže při kontrole jakékoli události v diagnostickém vyhledávání můžete najít související položky.
  • Název: Identifikátor, obvykle adresa URL požadavku HTTP.
  • SyntheticSource: Pokud není null nebo prázdný, řetězec, který označuje, že zdroj požadavku byl identifikován jako robot nebo webový test. Ve výchozím nastavení je vyloučena z výpočtů v Průzkumníku metrik.
• Session: Session uživatele. ID je nastavené na vygenerovanou hodnotu, která se změní, když uživatel nějakou dobu nebyl aktivní.
• Uživatel: Informace o uživateli.

Limits

Existuje několik omezení počtu metrik a událostí na aplikaci, tj. na připojovací řetězec. Limity závisí na zvoleném cenovém plánu .

Resource	Výchozí omezení	Maximální limit	Poznámky
Celkem dat za den	100 GB	Obraťte se na podporu.	Můžete nastavit limit pro omezení dat. Pokud potřebujete více dat, můžete limit na portálu zvýšit až o 1 000 GB. U kapacit větších než 1 000 GB odešlete e-mail na AIDataCap@microsoft.comadresu .
Throttling	32 000 událostí za sekundu	Obraťte se na podporu.	Limit je měřen během jedné minuty.
Protokoly uchovávání dat	30 až 730 dní	730 dní	Tento zdroj je pro protokoly.
Metriky uchovávání dat	90 dní	90 dní	Tento prostředek je určený pro Průzkumníka metrik.
Uchovávání podrobných výsledků vícekrokového testu dostupnosti	90 dní	90 dní	Tento prostředek poskytuje podrobné výsledky každého kroku.
Maximální velikost položky telemetrie	64 kB	64 kB
Maximální počet položek telemetrie na dávku	64,000	64,000
Délka názvu vlastnosti a metriky	sto padesát	sto padesát	Viz schémata typů.
Délka řetězce hodnoty vlastnosti	8,192	8,192	Viz schémata typů.
Délka zprávy sledování a výjimky	32,768	32,768	Viz schémata typů.
Počet testů dostupnosti na prostředek Application Insights	100	100
Počet testů dostupnosti na skupinu prostředků	800	800	Podívejte se na Azure Resource Manager
Maximální počet přesměrování v testech dostupnosti na jeden test	10	10
Minimální frekvence testů dostupnosti	300 sekund		Vlastní frekvence testů nebo frekvence kratší než 5 minut vyžadují speciální implementace TrackAvailability.
Uchovávání dat v .NET Profileru a Snapshot Debuggeru	Dva týdny	Obraťte se na podporu. Maximální limit uchovávání je šest měsíců.
Data odeslaná profilerem .NET za den	Bez omezení	Žádný limit.
Odeslaná data nástroje Snapshot Debugger za den	30 snímků za den na monitorovanou aplikaci	Žádný limit.	Počet snímků shromážděných pro každou aplikaci je možné upravit prostřednictvím konfigurace.

Další informace o cenách a kvótách najdete v tématu Fakturace Application Insights.

Pokud se chcete vyhnout dosažení limitu rychlosti dat, použijte vzorkování.

Informace o tom, jak dlouho se data uchovávají, najdete v tématu Uchovávání a ochrana osobních údajů.

Ukázkové aplikace

Konzolová aplikace .NET Core: Tuto ukázku použijte, pokud používáte konzolovou aplikaci napsanou v .NET Core (2.0 nebo vyšší) nebo .NET Framework (4.7.2 nebo vyšší).

ASP.NET Core úlohy na pozadí s HostedServices: Tuto ukázku použijte, pokud jste v ASP.NET Core a vytváříte úlohy na pozadí v souladu s oficiálními pokyny.

.NET Core Worker Service: Tuto ukázku použijte, pokud máte aplikaci .NET Worker Service v souladu s oficiálními pokyny.

Řešení problémů

Podívejte se na vyhrazené články o řešení potíží pro .NET a Node.js.

Testování připojení mezi hostitelem vaší aplikace a službou příjmu dat

SDK a agenti Application Insights odesílají telemetrii, aby se ingestovala jako volání REST na naše koncové body pro příjem dat. Připojení z webového serveru nebo hostitelského počítače aplikace ke koncovým bodům služby pro příjem dat můžete otestovat pomocí nezpracovaných klientů REST z příkazů PowerShellu nebo curl. Viz Řešení potíží s chybějící telemetrií aplikací ve službě Azure Monitor Application Insights.

Otevřené SDK

Číst a přispívat do kódu pro .NET a Node.js.

Poznámky k vydání

• Poznámky k verzi Application Insights
• Vydání sady .NET SDK na GitHubu
• verze sady Node.js SDK na GitHubu

Aktualizace služeb také shrnují hlavní vylepšení Application Insights.

Další kroky

• Ověřte, že používáte podporovanou verzi sady Application Insights SDK.
• Podívejte se na datový model pro typy Application Insights a datový model.
• Projděte si uživatelskou příručku system.Diagnostics.Activity a zjistěte, jak korelujeme telemetrii.
• Pokud chcete zkontrolovat nejčastější dotazy, přečtěte si:
  • nejčastější dotazy k ASP.NET
  • Nejčastější dotazy k ASP.NET Core
  • Nejčastější dotazy ke službě Worker Service
  • nejčastější dotazy kNode.js
  • Nejčastější dotazy k rozhraní API pro vlastní události a metriky