.NET- és Node.js-alkalmazások monitorozása az Application Insights (klasszikus API) használatával

Megjegyzés:

Tekintse át az Application Insights SDK támogatási útmutatóját a klasszikus API SDK támogatási szabályzathoz.

Caution

Javasoljuk az Azure Monitor OpenTelemetry Distro használatát az új alkalmazások vagy ügyfelek számára az Azure Monitor Application Insights használatához. Az Azure Monitor OpenTelemetry Distro az Application Insights SDK-hoz hasonló funkciókat és élményt nyújt. Az Application Insights SDK-ból a .NET, a Node.js és a Python áttelepítési útmutatóival migrálható, de még dolgozunk néhány további funkció hozzáadásán a visszamenőleges kompatibilitás érdekében.

Ez a cikk bemutatja, hogyan engedélyezheti és konfigurálhatja az Application Insightst a .NET-hez (ASP.NET, ASP.NET Core és Worker Service) és Node.js alkalmazásokhoz. Az Application Insights a következő telemetriát gyűjtheti az alkalmazásokból:

• Requests
• Függőségek
• Exceptions
• Teljesítmény számlálók
• Nyomkövetések (naplók)
• Szívdobbanás
• Egyéni események > metrikák (manuális rendszerezést igényel)
• Oldalmegtekintések (a weblapokhoz JavaScript SDK szükséges)
• Rendelkezésre állási tesztek ( a rendelkezésre állási tesztek manuális beállítását igényli)

Támogatott forgatókönyvek

.NET

Támogatott	ASP.NET	ASP.NET Core	Feldolgozói szolgáltatás
Operációs rendszer	Windows	Windows, Linux vagy macOS	Windows, Linux vagy macOS
Üzemeltetési módszer	Folyamatban (IIS vagy IIS Express)	Folyamatban lévő vagy folyamaton kívüli	Konzol- vagy háttérszolgáltatás (folyamatként fut, általában dotnet parancssori felületen vagy Windows-szolgáltatásként/Linux-démonként)
Üzembe helyezési módszer	Webes üzembe helyezés, MSI vagy manuális fájlmásolás	Keretrendszerfüggő vagy önálló	Keretrendszerfüggő vagy önálló
Webkiszolgáló	Internetes információs szolgáltatások (IIS)	Internet Information Server (IIS) vagy Kestrel	Nem alkalmazható (nincs webkiszolgáló, nem HTTP-alapú számítási feladatokhoz, például üzenetküldéshez, háttérfeladatokhoz és konzolalkalmazásokhoz tervezve)
Üzemeltetési platform	Azure App Service (Windows), Azure Virtual Machines vagy helyszíni kiszolgálók	Az Azure App Service, az Azure Virtual Machines, a Docker és az Azure Kubernetes Service (AKS) Web Apps szolgáltatása	Azure Virtual Machines, Azure Kubernetes Service (AKS), tárolók vagy bármely olyan környezet, ahol a .NET Core támogatott
.NET-verzió	.NET Framework 4.6.1 és újabb verziók	Az előzetes verzióban nem szereplő összes hivatalosan támogatott .NET-verzió	Az előzetes verzióban nem szereplő összes hivatalosan támogatott .NET-verzió
IDE	Visual Studio	Visual Studio, Visual Studio Code vagy parancssor	Visual Studio, Visual Studio Code vagy parancssor

A Worker Service SDK önmagában nem végez telemetriai gyűjtést. Ehelyett más jól ismert Application Insights-automatikus gyűjtőket hoz létre, például a DependencyCollectort, a PerfCounterCollectort és az ApplicationInsightsLoggingProvidert. Ez az SDK bővítménymódszereket tesz elérhetővé IServiceCollection a telemetriagyűjtés engedélyezéséhez és konfigurálásához.

Megjegyzés:

A feldolgozó szolgáltatás egy hosszan futó háttéralkalmazás, amely HTTP-kérés-/válaszfolyamaton kívüli feladatokat hajt végre. Az Application Insights SDK for Worker Service az újonnan bevezetett .NET Core feldolgozói szolgáltatásban, a ASP.NET Core háttérfeladataiban, valamint a konzolalkalmazásokban, például a .NET Core-ban és a .NET-keretrendszerben használható.

Node.js

Támogatott	Node.js
Operációs rendszer	Windows, Linux vagy macOS
Üzemeltetési módszer	Konzol- vagy háttérszolgáltatás (folyamatként fut csomópontparancson vagy npm-szkripteken keresztül)
Üzembe helyezési módszer	Keretrendszerfüggő (Node.js futtatókörnyezetet igényel az npm-csomagon keresztül)
Webkiszolgáló	Beépített HTTP-modul vagy webes keretrendszerek (Express, Fastify stb.), vagy nem http-alapú számítási feladatokhoz nem alkalmazhatók
Üzemeltetési platform	Azure App Service, Azure Virtual Machines, Azure Kubernetes Service (AKS), Docker, helyszíni vagy bármely olyan környezet, ahol Node.js támogatott
Node.js verzió	Minden hivatalosan támogatott Node.js LTS-verzió (jelenleg 18.19.0+ vagy 20.6.0+ SDK 3.X esetén)
IDE	Visual Studio Code, Visual Studio vagy parancssor

A Node.js ügyfélkódtár automatikusan monitorozza a bejövő és kimenő HTTP-kéréseket, kivételeket és néhány rendszermetrikát. A 0.20-es verziótól kezdődően az ügyféloldali kódtár figyelhet néhány gyakori külső csomagot is, például a MongoDB-t, a MySQL-t és a Redist.

Az egyes bejövő HTTP-kérésekhez kapcsolódó összes eseményt összekapcsolja a gyorsabb hibaelhárítás érdekében.

A TelemetryClient API-val manuálisan instrumentálhatja és monitorozhatja az alkalmazás és a rendszer több aspektusát. A TelemetryClient API-t a jelen cikk egy későbbi részében részletesebben ismertetjük.

Application Insights hozzáadása

.NET

Előfeltételek

• Egy Azure-előfizetés. Ha még nem rendelkezik ilyen fiókkal, hozzon létre egy ingyenes Azure-fiókot.
• Application Insights-munkaterület-alapú erőforrás.
• Egy működő alkalmazás. Ha még nem rendelkezik ilyen alkalmazással, olvassa el az Alapszintű webalkalmazás létrehozása című témakört.
• A Visual Studio legújabb verziója a következő számítási feladatokkal:
  • ASP.NET és webfejlesztés
  • Azure-fejlesztés

Alapszintű webalkalmazás létrehozása

Ha még nem rendelkezik működő webalkalmazással, az alábbi útmutató segítségével hozhat létre egyet.

ASP.NET

1. Nyissa meg a Visual Studiót.
2. Válassza az Új projekt létrehozása lehetőséget.
3. Válassza ASP.NET webalkalmazást (.NET-keretrendszer)a C# használatával, majd válassza a Tovább gombot.
4. Adjon meg egy projektnevet, majd válassza a Létrehozás lehetőséget.
5. Válassza az MVC, majd a Létrehozás.

ASP.NET Core

1. Nyissa meg a Visual Studiót.
2. Válassza az Új projekt létrehozása lehetőséget.
3. Válassza a ASP.NET Core Web App (Razor Pages)és a C# lehetőséget, majd válassza a Tovább gombot.
4. Adjon meg egy projektnevet, majd válassza a Létrehozás lehetőséget.
5. Válasszon egy keretrendszert (LTS vagy STS), majd válassza a Létrehozás lehetőséget.

Application Insights automatikus hozzáadása (Visual Studio)

Ez a szakasz végigvezeti az Application Insights sablonalapú webalkalmazáshoz való automatikus hozzáadásán.

ASP.NET

Megjegyzés:

A Visual Studio 2019-ben ismert probléma merült fel: a rendszerállapot-kulcs vagy kapcsolati sztring egy felhasználói titkos kódban való tárolása megszakadt .NET-keretrendszer-alapú alkalmazások esetében. A hiba elhárításához a kulcsot végül a Applicationinsights.config fájlba kell kódolni.

A ASP.NET webalkalmazás-projektből a Visual Studióban:

1. Válassza a >> lehetőséget.

2. Nyissa meg az ApplicationInsights.config fájlt.

3. A záró </ApplicationInsights> címke előtt adjon hozzá egy sort, amely tartalmazza az Application Insights-erőforrás kapcsolati sztring. Keresse meg a kapcsolati sztring az újonnan létrehozott Application Insights-erőforrás áttekintő ablaktábláján.

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

4. Válassza a Project Manage NuGet Packages Updates (NuGet-csomagok frissítéseinek Ezután frissítse az egyes Microsoft.ApplicationInsights NuGet-csomagokat a legújabb stabil kiadásra.

5. Futtassa az alkalmazást az IIS Express kiválasztásával. Megnyílik egy egyszerű ASP.NET alkalmazás. Amikor végigböngészi a webhely lapjait, a rendszer telemetriát küld az Application Insightsnak.

ASP.NET Core

Megjegyzés:

Ha a különálló ILogger-szolgáltatót szeretné használni a ASP.NET alkalmazáshoz, használja a Microsoft.Extensions.Logging.ApplicationInsight parancsot.

Fontos

MacOS-hez készült Visual Studio esetén használja a manuális útmutatót. Ezt az eljárást csak a Visual Studio Windows-verziója támogatja.

A ASP.NET webalkalmazás-projektből a Visual Studióban:

1. Lépjen a Project>Add Application Insights Telemetria hozzáadása lehetőségre.

2. Válassza az Azure Application Insights>Tovább lehetőséget.

3. Válassza ki az előfizetést és az Application Insights-példányt. Vagy létrehozhat egy új példányt a Új létrehozása lehetőséggel. Válassza a Következőlehetőséget.

4. Adja hozzá vagy erősítse meg az Application Insights kapcsolati karakterláncot. Az előző lépésben megadott beállítás alapján előre fel kell tölteni. Válassza ki a Befejezésopciót.

5. Miután hozzáadta az Application Insightst a projekthez, ellenőrizze, hogy az SDK legújabb stabil kiadását használja-e. Nyissa meg a >Microsoft.ApplicationInsights.AspNetCore webhelyet. Ha szükséges, válassza a Frissítés lehetőséget.

   

Application Insights manuális hozzáadása (nincs Visual Studio)

Ez a szakasz végigvezeti az Application Insights sablonalapú webalkalmazáshoz való manuális hozzáadásán.

ASP.NET

1. Adja hozzá a következő NuGet-csomagokat és azok függőségeit a projekthez:

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

2. Bizonyos esetekben a rendszer automatikusan létrehozza az ApplicationInsights.config fájlt. Ha a fájl már jelen van, ugorjon a 4. lépésre.

   Hozza létre saját maga, ha hiányzik. Egy ASP.NET-alkalmazás gyökérkönyvtárában hozzon létre egy új fájlt ApplicationInsights.config néven.

3. Másolja a következő XML-konfigurációt az újonnan létrehozott fájlba:

   
   
   Kibontás a konfiguráció megtekintéséhez

   <?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. Adja hozzá a kapcsolati sztring, amely kétféleképpen végezhető el:

   • (Ajánlott) Állítsa be a kapcsolati sztring konfigurációban.

     Az ApplicationInsights.config záró </ApplicationInsights> címkéje előtt adja hozzá az Application Insights-erőforrás kapcsolati sztring. A kapcsolati sztring az újonnan létrehozott Application Insights-erőforrás áttekintő ablaktábláján találja.

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

   • Állítsa be a kapcsolati sztring a kódban.

     Adjon meg egy kapcsolati sztring a program.cs osztályban.

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

5. Az ApplicationInsights.config fájllal megegyező szinten hozzon létre egy ErrorHandler nevű mappát egy AiHandleErrorAttribute.cs nevű új C#-fájllal. A fájl tartalma a következőképpen néz ki:

   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. A App_Start mappában nyissa meg a FilterConfig.cs fájlt, és módosítsa úgy, hogy megfeleljen a mintának:

   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. Ha a Web.config már frissült, hagyja ki ezt a lépést. Ellenkező esetben frissítse a fájlt az alábbiak szerint:

   
   
   Kibontás a konfiguráció megtekintéséhez

   <?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>
   

Ezen a ponton sikeresen konfigurálta a kiszolgálóoldali alkalmazásfigyelést. A webalkalmazás futtatásakor a telemetriai adatok megjelennek az Application Insightsban.

ASP.NET Core

1. Telepítse az Application Insights SDK NuGet-csomagot ASP.NET Core-hoz.

   Javasoljuk, hogy mindig a legújabb stabil verziót használja. Az SDK teljes kibocsátási megjegyzéseit megtalálhatja a nyílt forráskódú GitHub-adattárban.

   Az alábbi kódminta a projekt .csproj fájljához hozzáadandó módosításokat mutatja be:

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

2. Adja hozzá AddApplicationInsightsTelemetry() a program.cs osztályhoz.

   Adja hozzá builder.Services.AddApplicationInsightsTelemetry(); a WebApplication.CreateBuilder() metódus után, ahogy ebben a példában is látható:

   // 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. Adja meg a kapcsolati karakterláncot, amit háromféleképpen lehet elvégezni:

   • (Ajánlott) Állítsa be a kapcsolati sztring konfigurációban.

     Állítsa be a kapcsolati sztringet az appsettings.json fájlban, és győződjön meg arról, hogy a konfigurációs fájl a közzététel során át lesz másolva az alkalmazás gyökérkönyvtárába.

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

   • Állítsa be a kapcsolati láncot a APPLICATIONINSIGHTS_CONNECTION_STRING környezeti változóban vagy a ApplicationInsights:ConnectionString JSON konfigurációs fájlban.

     Például:

     • SET ApplicationInsights:ConnectionString = <Copy connection string from Application Insights Resource Overview>
     • SET APPLICATIONINSIGHTS_CONNECTION_STRING = <Copy connection string from Application Insights Resource Overview>
     • Általában APPLICATIONINSIGHTS_CONNECTION_STRING a Web Appsben használják. Minden olyan helyen használható, ahol ez az SDK támogatott.

     Megjegyzés:

     A kódban megadott kapcsolati sztring felülírja a környezeti változót APPLICATIONINSIGHTS_CONNECTION_STRING, amely pedig felülír más lehetőségeket.

   • Állítsa be a kapcsolati sztring a kódban.

     Adjon meg a kapcsolati karakterláncot a ApplicationInsightsServiceOptions argumentum részeként a AddApplicationInsightsTelemetryprogram.cs osztályban.

Felhasználói titkos kódok és egyéb konfigurációs szolgáltatók

Ha a kapcsolati sztring a ASP.NET Core felhasználói titkos kulcsaiban szeretné tárolni, vagy egy másik konfigurációszolgáltatótól szeretné lekérni, a túlterhelést paraméterrel Microsoft.Extensions.Configuration.IConfiguration is használhatja. Példaparaméter: services.AddApplicationInsightsTelemetry(Configuration);.

A Microsoft.ApplicationInsights.AspNetCore 2.15.0 verziótól kezdve és az újabb verziókban a hívás automatikusan beolvassa a kapcsolati sztringet az alkalmazás services.AddApplicationInsightsTelemetry() részéből. Nincs szükség explicit módon megadni IConfiguration.

Ha IConfiguration több szolgáltatótól tölt be konfigurációt, akkor services.AddApplicationInsightsTelemetry rangsorolja a appsettings.jsonkonfigurációját, függetlenül a szolgáltatók hozzáadásának sorrendjétől. Használja a módszert a services.AddApplicationInsightsTelemetry(IConfiguration) konfiguráció IConfiguration olvasására anélkül, hogy ez a kedvezményes elbánás appsettings.json.

Feldolgozói szolgáltatás

Ebben a szakaszban

• Az Application Insights SDK használata munkavállalói szolgáltatáshoz
• .NET Core Worker Service-alkalmazás
• ASP.NET Alapvető háttérfeladatok üzemeltetett szolgáltatásokkal
• .NET Core/.NET-keretrendszer konzolalkalmazás

Az Application Insights SDK használata munkaszolgáltatáshoz

1. Telepítse a Microsoft.ApplicationInsights.WorkerService csomagot az alkalmazásra.

   Az alábbi kódrészlet azokat a módosításokat mutatja be, amelyeket hozzá kell adni a projekt fájljához .csproj :

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

2. Konfigurálja a kapcsolati sztringet a APPLICATIONINSIGHTS_CONNECTION_STRING környezeti változóban vagy a konfigurációban (appsettings.json).

   

3. Hívjon meg egy ILogger példányt, vagy használjon egy TelemetryClient példányt a Függőséginjektálás (DI) tárolóból, a serviceProvider.GetRequiredService<TelemetryClient>(); vagy a konstruktorinjektálás használatával. Ez a lépés aktiválja a TelemetryConfiguration és az automatikus gyűjtés modulok konfigurációját.

Az egyes alkalmazástípusokra vonatkozó konkrét utasításokat a következő szakaszok ismertetik.

.NET Core Worker Service-alkalmazás

A teljes példa meg van osztva a NuGet webhelyén.

1. Töltse le és telepítse a .NET SDK-t.

2. Hozzon létre egy új Worker Service-projektet egy Új Visual Studio-projektsablon vagy a parancssor dotnet new workerhasználatával.

3. Adja hozzá a Microsoft.ApplicationInsights.WorkerService csomagot az alkalmazáshoz.

4. Adja hozzá services.AddApplicationInsightsTelemetryWorkerService(); a CreateHostBuilder() metódushoz az Program.cs osztályban, ahogy ebben a példában is látható:

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

5. Módosítsa a Worker.cs következő példában leírtak szerint:

       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. Állítsa be a kapcsolati sztringet.

   

   Megjegyzés:

   Javasoljuk, hogy adja meg a kapcsolati sztringet a konfigurációban. Az alábbi kódminta bemutatja, hogyan adhatja meg a kapcsolati sztringet a következőben appsettings.json: A közzététel során győződjön meg arról, hogy appsettings.json az alkalmazás gyökérmappájába van másolva.

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

Másik lehetőségként adja meg a kapcsolati sztringet a APPLICATIONINSIGHTS_CONNECTION_STRING környezeti változóban.

APPLICATIONINSIGHTS_CONNECTION_STRING Általában webfeladatként adja meg a webalkalmazásokban üzembe helyezett alkalmazások kapcsolati sztringét.

Megjegyzés:

A kódban megadott kapcsolati sztring elsőbbséget élvez a környezeti változóval APPLICATIONINSIGHTS_CONNECTION_STRINGszemben, amely elsőbbséget élvez más beállításokkal szemben.

ASP.NET Alapvető háttérfeladatok üzemeltetett szolgáltatásokkal

Ez a dokumentum azt ismerteti, hogyan hozhat létre háttérfeladatokat egy ASP.NET Core-alkalmazásban.

A teljes példa ezen a GitHub-oldalon van megosztva.

1. Telepítse a Microsoft.ApplicationInsights.WorkerService csomagot az alkalmazásra.

2. Adja hozzá services.AddApplicationInsightsTelemetryWorkerService(); a ConfigureServices() metódushoz, ahogy ebben a példában is látható:

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

   A következő kód a TimedHostedServiceháttérfeladat logikájának helyéhez tartozik:

       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. Állítsa be a kapcsolati sztringet. Használja ugyanezt appsettings.json az előző .NET worker service-példában is.

.NET Core/.NET-keretrendszer konzolalkalmazás

Ahogy a cikk elején említettük, az új csomag az Application Insights telemetriai adatainak engedélyezésére használható még egy normál konzolalkalmazásból is. Ez a csomag a célokat célozza netstandard2.0meg, így a .NET Core vagy újabb konzolalkalmazásokhoz és a .NET-keretrendszerhez vagy újabb verziókhoz is használható.

A teljes példa ezen a GitHub-oldalon van megosztva.

1. Telepítse a Microsoft.ApplicationInsights.WorkerService csomagot az alkalmazásra.

2. Módosítsa a Program.cs az alábbi példában látható módon:

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

Ez a konzolalkalmazás is ugyanazt az alapértelmezettet TelemetryConfigurationhasználja. Ugyanúgy testre szabható, mint a korábbi szakaszokban szereplő példák.

Node.js

Előfeltételek

• Egy Azure-előfizetés. Ha még nem rendelkezik ilyen fiókkal, hozzon létre egy ingyenes Azure-fiókot.
• Application Insights-munkaterület-alapú erőforrás.
• Egy működő alkalmazás. Ha még nem rendelkezik ilyen alkalmazással, olvassa el az Alapszintű webalkalmazás létrehozása című témakört.

A Node.js ügyfélkódtár beállítása

Vegye fel az SDK-t az alkalmazásba, hogy adatokat gyűjtsön.

1. Másolja ki az új erőforrásból az erőforrás kapcsolati sztringjét. Az Application Insights a kapcsolati sztringet használja az adatok az Azure-erőforráshoz való leképezéséhez. Ahhoz, hogy az SDK használni tudja a kapcsolati sztringet, meg kell adnia azt egy környezeti változóban vagy a kódban.

   

2. Adja hozzá az Node.js ügyfélkódtárat az alkalmazás függőségeihez a következőn keresztül package.json: Az alkalmazás gyökérkönyvtárából hajtsa végre az alábbi parancsot:

   npm install applicationinsights --save
   

   Megjegyzés:

   TypeScript használata esetén ne telepítsen külön "gépelési" csomagokat. Ez az NPM-csomag beépített tipizálásokat tartalmaz.

3. Kifejezetten töltse be a könyvtárat a programjában. Mivel az SDK sok más könyvtárhoz injektál instrumentációt, a könyvtárat a lehető leghamarabb be kell tölteni, akár más require-utasítások előtt.

   let appInsights = require('applicationinsights');
   

4. A környezeti változón APPLICATIONINSIGHTS_CONNECTION_STRING keresztül is megadhat kapcsolati sztringet, ahelyett, hogy manuálisan átadná azt setup()-nek vagy new appInsights.TelemetryClient()-nek. Ez a gyakorlat lehetővé teszi, hogy a kapcsolati sztringek ne legyenek beküldött forráskódban, és különböző kapcsolati sztringeket adhat meg a különböző környezetekhez. A manuális konfiguráláshoz hívja meg a appInsights.setup('[your connection string]'); elemet.

   További konfigurációs beállításokért tekintse meg a következő szakaszokat.

   Az SDK-t telemetria küldése nélkül is kipróbálhatja az appInsights.defaultClient.config.disableAppInsights = true beállításával.

5. Indítsa el az adatok automatikus gyűjtését és küldését a hívással appInsights.start();.

Megjegyzés:

Az Application Insights rendszerállapotának részeként diagnosztikai adatokat gyűjtünk és küldünk a Microsoftnak. Ezek az adatok segítenek az Application Insights futtatásában és fejlesztésében. Lehetősége van letiltani a nem alapvető adatgyűjtést. További információ.

Alapszintű használat

A HTTP-kérések, a népszerű külső könyvtári események, a kezeletlen kivételek és a rendszermetrikák alapértelmezett gyűjtéséhez:

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

Megjegyzés:

Ha a kapcsolati sztring a környezeti változóban APPLICATIONINSIGHTS_CONNECTION_STRINGvan beállítva, .setup() argumentumok nélkül hívható meg. Ez megkönnyíti, hogy különböző környezetekben különböző kapcsolati karakterláncokat használjunk.

Az Application Insights-kódtárat require("applicationinsights") a lehető leghamarabb töltse be a szkriptekbe, mielőtt más csomagokat tölt be. Erre a lépésre azért van szükség, hogy az Application Insights-kódtár előkészíthesse a későbbi csomagokat a nyomon követéshez. Ha ütközések merülnek fel más, hasonló előkészítést végző kódtárakkal, próbálja meg később betölteni az Application Insights-tárat.

Mivel a JavaScript kezeli a visszahívásokat, több munkára van szükség a külső függőségek és későbbi visszahívások közötti kérések nyomon követéséhez. Alapértelmezés szerint ez az extra nyomon követés engedélyezve van. Tiltsa le azzal, hogy meghívja a setAutoDependencyCorrelation(false) az SDK konfiguráció szakaszában leírtak szerint.

Migrálás a 0.22 előtti verziókból

A 0.22-es verzió előtti és utáni kiadások között megtalálhatók a kompatibilitástörő változások. Ezek a módosítások úgy lettek kialakítva, hogy konzisztenciát teremtsen más Application Insights SDK-kkal, és lehetővé tegye a jövőbeli bővíthetőséget.

A migrálás általában a következő műveletekkel végezhető el:

• Cserélje le a appInsights.client hivatkozásokat appInsights.defaultClient-re.
• Cserélje le a appInsights.getClient() hivatkozásokat new appInsights.TelemetryClient()-re.
• Cserélje le az összes argumentumot a client.track* metódusokra egyetlen objektumra, amely argumentumként megnevezett tulajdonságokat tartalmaz. Tekintse meg az IDE beépített típusmegjegyzését vagy TelemetryTypes elemet, hogy megtalálja az elvárt objektumot az egyes telemetriatípusokhoz.

Ha láncolás nélkül fér hozzá az SDK konfigurációs függvényeihez a appInsights.setup()-hoz, akkor ezeket a függvényeket a következő helyen találja: appInsights.Configurations. Például: appInsights.Configuration.setAutoCollectDependencies(true). Tekintse át az alapértelmezett konfiguráció módosításait a következő szakaszban.

Annak ellenőrzése, hogy az Application Insights telemetriát fogad-e

.NET

ASP.NET &ASP.NET Core

Futtassa az alkalmazást, és küldjön neki kéréseket. A telemetriának most át kell haladnia az Application Insightsba. Az Application Insights SDK automatikusan gyűjti az alkalmazáshoz érkező bejövő webes kéréseket, valamint az alábbi telemetriát.

Feldolgozói szolgáltatás

Futtassa alkalmazását. A munkások az összes előző példában másodpercenként HTTP-hívást kezdeményeznek a bing.com címre, és néhány napló bejegyzést is kibocsátanak a ILogger használatával. Ezek a sorok a StartOperation művelet létrehozásához használt hívásba TelemetryClientvannak csomagolva. Ebben a példában RequestTelemetry a neve "művelet".

Az Application Insights ezeket az ILogger-naplókat gyűjti össze alapértelmezés szerint figyelmeztetési vagy magasabb súlyossággal, valamint függőségekkel. Egy szülő-gyermek kapcsolattal vannak összefüggésben RequestTelemetry . A korreláció folyamat-/hálózathatárokon is működik. Ha például a hívás egy másik figyelt összetevőhöz lett intézve, az is ehhez a szülőhöz van összefüggésben.

Ez az RequestTelemetry egyéni művelet úgy tekinthető, mint egy tipikus webalkalmazás bejövő webes kérésének megfelelője. Nem szükséges műveletet használni, de a legjobban megfelel az Application Insights korrelációs adatmodelljének. RequestTelemetry szülőműveletként működik, és a munkavégző iterációban generált összes telemetria logikailag ugyanahhoz a művelethez tartozik.

Ez a megközelítés azt is biztosítja, hogy a létrehozott telemetriai adatok automatikusan és manuálisan is megegyeznek operation_id. Mivel a mintavételezés alapja operation_id, a mintavételezési algoritmus egyetlen iterációból vagy megtartja, vagy elveti az összes telemetriai adatot.

Node.js

Az SDK automatikusan telemetriát gyűjt a Node.js futtatókörnyezetről és néhány gyakori külső modulról. Az alkalmazás használatával gyűjtsön össze néhányat ezekből az adatokból.

Ezután az Azure Portalon lépjen a korábban létrehozott Application Insights-erőforráshoz. Az Áttekintő idővonalon tekintse meg az első néhány adatpontot. Részletesebb adatokért válasszon a diagramok különböző összetevői közül.

Az alkalmazáshoz felderített topológiát az Alkalmazástérkép használatával tekintheti meg.

Nincs adat

Mivel az SDK beküldésre köti az adatokat, előfordulhat, hogy késéssel jelennek meg az elemek a portálon. Ha nem lát adatokat az erőforrásában, próbálja elvégezni valamelyik javítást az alábbiak közül:

• Folytassa az alkalmazás használatát. Végezzen el több műveletet, hogy több telemetria jöjjön létre.
• Válassza a Frissítés lehetőséget a portál erőforrásnézetben. A diagramok adott időközönként maguktól frissülnek, de manuálisan azonnal is frissíthetők.
• Ellenőrizze, hogy a szükséges kimenő portok nyitva vannak-e.
• Keressen bizonyos eseményekre.
• Tekintse meg a gyakori kérdésekkel foglalkozó részt.

Telemetriai adatok gyűjtése

.NET

Ebben a szakaszban

• Élő metrikák
• Nyomkövetések (naplók)
• Elosztott nyomkövetés
• Függőségek
• Kivételek
• Egyéni metrikák
• Egyéni műveletek
• Számlálók
• Pillanatkép-gyűjtemény

Élő metrikák

Az élő metrikák segítségével gyorsan ellenőrizheti, hogy az Application Insights alkalmazásmonitorozása megfelelően van-e konfigurálva. A telemetriai adatok megjelenése eltarthat néhány percig az Azure Portalon, de az élő metrikák panelen a futó folyamat processzorhasználata közel valós időben jelenik meg. Más telemetriákat is megjeleníthet, például kéréseket, függőségeket és nyomkövetéseket.

Megjegyzés:

Az élő metrikák alapértelmezés szerint engedélyezve vannak, amikor a .NET-alkalmazásokhoz ajánlott utasításokat követve készíti el azokat.

Élő metrikák engedélyezése kód használatával bármely .NET-alkalmazáshoz

ASP.NET

Élő metrikák manuális konfigurálása:

1. Telepítse a NuGet-csomagot : Microsoft.ApplicationInsights.PerfCounterCollector.

2. Az alábbi minta konzolalkalmazás-kód az élő metrikák beállítását mutatja be:

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

Élő metrikák manuális konfigurálása:

1. Telepítse a NuGet-csomagot : Microsoft.ApplicationInsights.PerfCounterCollector.

2. Az alábbi minta konzolalkalmazás-kód az élő metrikák beállítását mutatja be:

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

Az előző minta egy konzolalkalmazáshoz készült, de ugyanez a kód bármely .NET-alkalmazásban használható.

Fontos

Ha bármely más telemetriai modul engedélyezve van a telemetriai adatok automatikus gyűjtéséhez, győződjön meg arról, hogy a modul inicializálásához használt konfigurációt használja az élő metrikák modulhoz.

Megjegyzés:

Az alapértelmezett konfiguráció összegyűjti a ILoggerWarning naplókat és a komolyabb naplókat. További információért lásd: Hogyan testreszabható az ILogger-naplók gyűjteménye?.

Feldolgozói szolgáltatás

A figyelmeztetés súlyosságú vagy annál nagyobb súlyosságú naplók, amelyeket ILogger keresztül bocsátanak ki, automatikusan rögzítésre kerülnek. A viselkedés módosításához explicit módon bírálja felül a szolgáltató ApplicationInsightsnaplózási konfigurációját az alábbi kódban látható módon. Az alábbi konfiguráció lehetővé teszi az Application Insights számára az összes Information napló és súlyosabb napló rögzítését.

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

Fontos megjegyezni, hogy az alábbi példa nem eredményezi, hogy az Application Insights-szolgáltató rögzítse a naplókat Information. Nem rögzíti, mert az SDK hozzáad egy alapértelmezett naplózási szűrőt, amely arra utasítja ApplicationInsights , hogy csak Warning a naplókat és a súlyosabb naplókat rögzítse. Az Application Insightshez egyértelmű felülbírálás szükséges.

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

Megjegyzés:

Az Application Insights tiszteletben tartja a ConfigureLogging(...) használatával konfigurált naplószinteket a kódban. Ha csak az appsettings.json fájlt használja, és a ConfigureLogging nincs explicit módon felülírva, az alapértelmezett naplószint a Figyelmeztetés.

További információkért kövesse az ILogger-dokumentumokat az Application Insights által rögzített naplószintek testreszabásához.

Nyomkövetések (naplók)

Ez a szakasz bemutatja, hogyan küldhet diagnosztikai nyomkövetési naplókat ASP.NET vagy ASP.NET Core-alkalmazásokból az Application Insightsnak, majd hogyan vizsgálhatja meg és keresheti meg ezeket a naplókat a portálon.

A nyomkövetési naplók segítségével azonosíthatja az egyes felhasználói kérésekhez társított nyomkövetéseket, és korrelálhatja őket más eseményekkel és kivételjelentésekkel.

Az Application Insights naplókat rögzít ASP.NET Core- és más .NET-alkalmazásokból az ILoggeren keresztül, valamint a klasszikus ASP.NET (.NET-keretrendszer) a klasszikus SDK-n és adaptereken keresztül.

Megjegyzés:

• Alapértelmezés szerint az Application Insights-szolgáltató csak olyan naplókat küld, amelyek súlyossága vagy súlyossága Warning magasabb. A naplók belefoglalásához Information vagy az alacsonyabb szintű naplókhoz frissítse a naplószint beállításait a következőben appsettings.json: .

• Az Microsoft.ApplicationInsights.WorkerService Application Insights háttérszolgáltatásokhoz való engedélyezéséhez használt NuGet-csomag hatókörén kívül esik.

• A gyakori kérdések (GYIK) áttekintéséhez tekintse át a naplózást a .NET-gyikkel.

Naplózás telepítése az alkalmazásra

ASP.NET

Válasszon egy naplózási módszert az Application Insights által gyűjthető diagnosztikai naplók kibocsátásához.

A System.Diagnostics nyomkövetést használó klasszikus ASP.NET alkalmazásokhoz konfiguráljon egy Application Insights TraceListenert konfigurációban.

Figyelő hozzáadása a web.config vagy app.config elemhez:

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

Megjegyzés:

A naplórögzítési modul hasznos adapter külső adatgyűjtők számára. Ha azonban még nem használja az NLogot, a log4Netet vagy System.Diagnostics.Trace, fontolja meg az Application Insights TrackTrace() közvetlen meghívását.

Az Application Insights konfigurálása naplók gyűjtésére

1. lehetőség: Ha még nem tette meg, adja hozzá az Application Insightst a projekthez. Az Application Insights Visual Studióban való hozzáadásakor lehetőség van a naplógyűjtő hozzáadására.

2. lehetőség: Kattintson a jobb gombbal a projektre a Megoldáskezelőben az Application Insights konfigurálásához. Válassza a Nyomkövetési gyűjtemény konfigurálása lehetőséget.

Megjegyzés:

Ha hiányzik az Application Insights menü vagy a naplógyűjtő lehetőség, tekintse meg a dedikált hibaelhárítási cikket.

ASP.NET Core

A ASP.NET Core-hoz készült Application Insights SDK alapértelmezés szerint már gyűjtI az ILogger-naplókat. Ha az SDK-t használja, általában nem kell meghívnia builder.Logging.AddApplicationInsights() , és figyelmen kívül hagyhatja az alábbi ILogger telepítési utasításokat.

Ha csak naplótovábbításra van szüksége, és nem a teljes telemetriai veremre, a szolgáltatói csomag használatával rögzítheti a Microsoft.Extensions.Logging.ApplicationInsights naplókat.

Manuális telepítés

Ezt a módszert akkor használja, ha az Application Insights telepítője nem támogatja a projekttípust (például néhány asztali/konzolos forgatókönyvet), vagy ha explicit csomagszintű vezérlést szeretne.

1. A Megoldáskezelőben kattintson a jobb gombbal a projektre, és válassza a NuGet-csomagok kezelése lehetőséget.

2. Keresse meg az Application Insightst.

3. Válassza ki az alábbi csomagok egyikét:

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

A NuGet-csomag telepíti a szükséges összeállításokat, és szükség esetén módosítja a web.config vagy app.config fájlt.

Telepítési utasítások:

Megjegyzés:

Bontsa ki az alábbi szakaszok bármelyikét a csomagspecifikus telepítési utasításokért.

ILogger

1. Telepítse a Microsoft.Extensions.Logging.ApplicationInsights.

2. Adja hozzá 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();

Ha telepítve van a NuGet-csomag, és a szolgáltató regisztrálva van a függőséginjektálással, az alkalmazás készen áll a naplózásra. Konstruktorinjektálás esetén vagy ILogger az általános típusú alternatíva ILogger<TCategoryName> szükséges. Ha ezek a megvalósítások megoldódnak, ApplicationInsightsLoggerProvider adja meg őket. A rendszer naplózott üzeneteket vagy kivételeket küld az Application Insightsnak.

Vegye figyelembe a következő példavezérlőt:

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

További információ: Naplózás az ASP.NET Core-ban és milyen Application Insights-telemetriatípus jön létre az ILogger-naplókból? Hol láthatom az ILogger-naplókat az Application Insightsban?

Diagnosztikai naplóhívások beszúrása (System.Diagnostics.Trace / log4net / NLog)

Ha használja System.Diagnostics.Trace, általában a következő hívásokat kell használnia:

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

Ha inkább a log4net vagy a NLog lehetőséget részesíti előnyben, használja a következőt:

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

EventSource-események használata

Konfigurálhatja a System.Diagnostics.Tracing.EventSource eseményeket úgy, hogy nyomkövetésként küldhetők el az Application Insightsnak.

1. Telepítse a Microsoft.ApplicationInsights.EventSourceListener NuGet-csomagot.

2. Szerkessze a TelemetryModulesApplicationInsights.config fájl szakaszát:

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

Minden forráshoz a következő paramétereket állíthatja be:

• A név a gyűjtendő EventSource nevét adja meg.
• A Szint a gyűjtendő naplózási szintet adja meg: Kritikus, Hiba, Információ, LogAlways, Részletes vagy Figyelmeztetés.
• A kulcsszavak (nem kötelező) a használni kívánt kulcsszókombinációk egész számát adják meg.

DiagnosticSource-események használata

Konfigurálhatja a System.Diagnostics.DiagnosticSource-eseményeket úgy, hogy nyomkövetésként küldhetők el az Application Insightsnak.

1. Telepítse a Microsoft.ApplicationInsights.DiagnosticSourceListener NuGet-csomagot.

2. Szerkessze a TelemetryModulesApplicationInsights.config fájl szakaszát:

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

Minden nyomon követni kívánt diagnosztikai forráshoz adjon hozzá egy bejegyzést, amelynek Name attribútuma a diagnosztikai forrás nevéhez van állítva.

ETW-események használata

Konfigurálhatja az Event Tracing for Windows (ETW) eseményeit úgy, hogy nyomkövetésként küldhetők el az Application Insightsnak.

1. Telepítse a Microsoft.ApplicationInsights.EtwCollector NuGet-csomagot.

2. Szerkessze a ApplicationInsights.config fájl "TelemetryModules" szakaszát:

Megjegyzés:

Az ETW-események csak akkor gyűjthetők össze, ha az SDK-t üzemeltető folyamat olyan identitás alatt fut, amely tagja a teljesítménynapló felhasználóinak vagy rendszergazdáinak.

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

Minden forráshoz a következő paramétereket állíthatja be:

• A ProviderName a gyűjtendő ETW-szolgáltató neve.
• A ProviderGuid a gyűjtendő ETW-szolgáltató GUID azonosítóját adja meg. Használható a(z) ProviderName helyett.
• A szint beállítja a gyűjtendő naplózási szintet. Lehet kritikus, hiba, információs, LogAlways, részletes, vagy figyelmeztetés.
• A kulcsszavak (nem kötelező) a használni kívánt kulcsszókombinációk egész számértékét állítják be.

A Trace API közvetlen használata

Közvetlenül meghívhatja az Application Insights nyomkövetési API-t. A naplózási adapterek ezt az API-t használják. Például:

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

Ennek az az előnye TrackTrace , hogy viszonylag hosszú adatokat helyezhet el az üzenetben. Itt például a POST-adatokat kódolhatja.

Súlyossági szintet is hozzáadhat az üzenethez. A többi telemetriához hasonlóan tulajdonságértékeket is hozzáadhat a különböző nyomkövetési csoportok szűréséhez vagy kereséséhez. Például:

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

Mostantól egyszerűen kiszűrheti az adott adatbázishoz kapcsolódó, adott súlyossági szintű üzeneteket a Keresés alkalmazásban.

Konzolalkalmazás

Az Application Insights-naplózás konzolalkalmazásokhoz való hozzáadásához először telepítse a következő NuGet-csomagokat:

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

Az alábbi példa a Microsoft.Extensions.Logging.ApplicationInsights csomagot használja, és bemutatja a konzolalkalmazások alapértelmezett viselkedését. A Microsoft.Extensions.Logging.ApplicationInsights csomagot egy konzolalkalmazásban kell használni, vagy amikor az Application Insights minimális implementációját szeretné elérni a teljes funkciókészlet nélkül, például metrikák, elosztott nyomkövetés, mintavételezés és telemetriai inicializálók nélkül.

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

További információ: Milyen Application Insights-telemetriatípus jön létre az ILogger-naplókból? Hol láthatom az ILogger-naplókat az Application Insightsban?

Naplózási hatókörök

Megjegyzés:

Az alábbi útmutató az ILogger-forgatókönyvekre vonatkozik (csak ASP.NET Core-ra és konzolra). Ez nem vonatkozik a klasszikus ASP.NET.

ApplicationInsightsLoggingProvider támogatja az alapértelmezés szerint engedélyezett naplóhatóköröket.

Ha a hatókör típusa IReadOnlyCollection<KeyValuePair<string,object>>, akkor a gyűjteményben lévő kulcs-érték párok egyéni tulajdonságokként lesznek hozzáadva az Application Insights telemetriai adataihoz. Az alábbi példában a naplókat a rendszer a tulajdonságok szerint rögzíti TraceTelemetry és tartalmazza ("MyKey", "MyValue") .

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

Ha bármilyen más típust használ hatókörként, a rendszer az Application Insights telemetriai tulajdonsága Scope alatt tárolja. Az alábbi példában van egy olyan tulajdonság neveTraceTelemetry, Scope amely tartalmazza a hatókört.

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

A naplók megkeresése

Futtassa az alkalmazást hibakeresési módban, vagy telepítse élőben.

Felfedezés a Keresésben

Az alkalmazás áttekintő ablaktábláján az Application Insights portálon válassza a Keresés lehetőséget, ahol megteheti:

• Szűrjön naplónyomokra vagy adott tulajdonságokkal rendelkező elemekre.
• Egy adott elem részletes vizsgálata.
• Keressen más rendszernapló-adatokat, amelyek ugyanahhoz a felhasználói kéréshez kapcsolódnak (ugyanazzal a műveletazonosítóval rendelkezik).
• Mentse a lap konfigurációját kedvencként.

Megjegyzés:

Ha az alkalmazás nagy mennyiségű adatot küld, és az Application Insights SDK-t használja ASP.NET 2.0.0-béta3-es vagy újabb verzióhoz, az adaptív mintavételezési funkció a telemetria csak egy részét használhatja és küldheti el. További információ a mintavételezésről.

Felfedezés az Azure Monitor-naplókban

Az ILogger-naplók nyomkövetési telemetriaként jelennek meg (tábla traces az Application Insightsban és AppTraces a Log Analyticsben).

Example

Az Azure Portalon nyissa meg az Application Insightst, és futtassa a következőt:

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

Elosztott nyomkövetés

A modern felhő- és mikroszolgáltatás-architektúrák egyszerű, egymástól függetlenül üzembe helyezhető szolgáltatásokat tettek lehetővé, amelyek csökkentik a költségeket, miközben növelik a rendelkezésre állást és az átviteli sebességet. Ez azonban megnehezítette az általános rendszerek érvelését és hibakeresését. Az elosztott nyomkövetés egy olyan teljesítményprofilozóval oldja meg ezt a problémát, amely a felhő- és mikroszolgáltatás-architektúrák hívásveremeihez hasonlóan működik.

Az Azure Monitor két szolgáltatást biztosít az elosztott nyomkövetési adatok használatához: az egyetlen tranzakció/kérelem tranzakciódiagnosztikai nézetét és az alkalmazástérkép nézetet, amely a rendszerek interakcióit mutatja be.

Az Application Insights külön monitorozza az egyes összetevőket, és elosztott telemetriai korreláció használatával észleli, hogy melyik összetevő felelős a hibákért vagy a teljesítménycsökkenésért. Ez a cikk az Application Insights által használt különböző nyelvek és platformok korrelációs taktikáinak adatmodellét, környezetpropagálási technikáit, protokolljait és implementálását ismerteti.

Elosztott nyomkövetés engedélyezése az Application Insightson keresztül autoinstrumentációval vagy SDK-kkal

A .NET, a .NET Core, a Java, a Node.jsés a JavaScript alkalmazáshoz készült Application Insights-ügynökök és SDK-k mind támogatják az elosztott nyomkövetést natív módon.

A megfelelő Application Insights SDK telepítésével és konfigurálásával a rendszer automatikusan gyűjti a nyomkövetési információkat a népszerű keretrendszerekhez, kódtárakhoz és technológiákhoz az SDK függőségi autoklektorai által. A támogatott technológiák teljes listája elérhető a Dependency autocollection dokumentációjában.

Bármely technológia manuálisan is nyomon követhető a TelemetryClient TrackDependency hívásával.

Adatmodell telemetriai korrelációhoz

Az Application Insights egy adatmodellt határoz meg az elosztott telemetriai korrelációhoz. Ha a telemetriát logikai művelethez szeretné társítani, minden telemetriai elemhez tartozik egy környezetmező.operation_Id Az elosztott nyomkövetés minden telemetriai eleme megosztja ezt az azonosítót. Így akkor is társíthat más összetevők által jelentett telemetriát, ha egyetlen rétegből veszíti el a telemetriát.

Az elosztott logikai műveletek általában kisebb műveletekből állnak, amelyeket az egyik összetevő feldolgoz. A kérelemtelemetria határozza meg ezeket a műveleteket. Minden kérelemtelemetriaelem saját id , amely egyedileg és globálisan azonosítja azt. A kérelemhez társított összes telemetriai elemnek (mint például a nyomkövetések és kivételek) a operation_parentId értékét a kérelem id értékére kell beállítania.

A függőségi telemetria minden kimenő műveletet jelöl, például egy másik összetevőhöz irányuló HTTP-hívást. Meghatározza a saját id-ját is, amely globálisan egyedi. A függőségi hívás által kezdeményezett telemetriai kérések ezt id használják operation_parentId-ként.

Az elosztott logikai művelet nézetét az operation_Id, operation_parentId, request.id és dependency.id használatával hozhatja létre. Ezek a mezők a telemetriai hívások oksági sorrendjét is meghatározzák.

Mikroszolgáltatási környezetben az összetevőkből származó nyomkövetések különböző tárolóelemekre is áttérhetnek. Minden összetevő rendelkezhet saját kapcsolati sztringgel az Application Insightsban. A logikai művelet telemetriájának lekéréséhez az Application Insights minden tárolóelemből lekérdezi az adatokat.

Ha a tárelemek száma nagy, szüksége van útmutatásra arról, hogy hol keresse a következőt. Az Application Insights adatmodell két mezőt határoz meg a probléma megoldásához: request.source és dependency.target. Az első mező azonosítja a függőségi kérelmet kezdeményező összetevőt. A második mező azonosítja, hogy melyik összetevő válaszolt a függőségi hívásra.

További információ a több különálló példányból történő lekérdezésről: Adatok lekérdezése Log Analytics-munkaterületeken, -alkalmazásokon és -erőforrásokon az Azure Monitorban.

Example

Lássunk egy példát. A Stock Prices nevű alkalmazás egy részvény aktuális piaci árát jeleníti meg egy Stock nevű külső API használatával. A Tőzsdei árak alkalmazásnak van egy Stock lap nevű oldala, amelyet az ügyfél webböngészője a segítségével GET /Home/Stocknyit meg. Az alkalmazás HTTP-hívással GET /api/stock/valuelekérdezi a Stock API-t.

Az eredményként kapott telemetriát egy lekérdezés futtatásával elemezheti:

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

Az eredményekben az összes telemetriaelem osztozik a gyökérben operation_Id. Amikor Ajax-hívást kezdeményez a lapról, a rendszer egy új egyedi azonosítót (qJSXU) rendel a függőségi telemetriahoz, és a pageView azonosítóját operation_ParentIdhasználja a rendszer. A kiszolgálókérés ezután az Ajax-azonosítót használja a következőként operation_ParentId: .

elemTípus	név	azonosító	operation_ParentId	művelet_Azonosító
pageView	Készletek oldal	STYz		STYz
függőség	GET /Home/Stock	qJSXU	STYz	STYz
kérelem	GET Kezdőlap/Készlet	KqKwlrSt9PA=	qJSXU	STYz
függőség	GET /api/stock/value	bBrf2L7mm2g=	KqKwlrSt9PA=	STYz

Amikor a hívást GET /api/stock/value egy külső szolgáltatáshoz intézik, ismernie kell a kiszolgáló identitását, hogy megfelelően be tudja állítani a dependency.target mezőt. Ha a külső szolgáltatás nem támogatja a figyelést, target a szolgáltatás állomásnevére van állítva. Például: stock-prices-api.com. Ha azonban a szolgáltatás egy előre definiált HTTP-fejléc visszaadásával azonosítja magát, tartalmazza azt a szolgáltatásidentitást, target amely lehetővé teszi az Application Insights számára, hogy elosztott nyomkövetést hozzon létre a szolgáltatásból származó telemetriai adatok lekérdezésével.

Korrelációs fejlécek a W3C TraceContext használatával

Az Application Insights a W3C Trace-Contextre vált, amely a következőket határozza meg:

• traceparent: A globálisan egyedi műveleti azonosítót és a hívás egyedi azonosítóját hordozza.
• tracestate: Rendszerspecifikus nyomkövetési környezetet hordoz.

Az Application Insights SDK legújabb verziója támogatja a Trace-Context protokollt, de előfordulhat, hogy be kell jelentkeznie. (Az Application Insights SDK által támogatott korábbi korrelációs protokolllal való visszamenőleges kompatibilitás megmarad.)

A korrelációs HTTP protokoll, más néven Request-Id elavult. Ez a protokoll két fejlécet határoz meg:

• Request-Id: A hívás globálisan egyedi azonosítóját hordozza.
• Correlation-Context: Az elosztott nyomkövetési tulajdonságok név-érték párok gyűjteményét hordozza.

Az Application Insights a korrelációs HTTP protokoll bővítményét is meghatározza. Azonnali hívó vagy hívott fél által használt tulajdonságok gyűjteményét név-érték párok Request-Context használatával propagálja. Az Application Insights SDK ezzel a fejléccel állítja be a dependency.target és a request.source mezőket.

A W3C Trace-Context és az Application Insights adatmodelljei a következő módon illeszkednek:

Application Insights	W3C TraceContext (nyomkövetési környezet)
Id és RequestDependency	parent-id
Operation_Id	nyomkövetési azonosító
Operation_ParentId	e span szülő spanjának azonosítója. Ennek a mezőnek üresnek kell lennie, ha gyökérszakaszról van szó.

További információ: Application Insights telemetriai adatmodell.

W3C elosztott nyomkövetés támogatásának engedélyezése

A W3C TraceContext-alapú elosztott nyomkövetés alapértelmezés szerint engedélyezve van az összes legutóbbi .NET-keretrendszerben/.NET Core SDK-ban, valamint az örökölt Request-Id protokolllal való visszamenőleges kompatibilitással.

Telemetriai korreláció

Az alkalmazás előkészítésekor a korreláció alapértelmezés szerint kezelhető. Nincs szükség speciális műveletekre.

A .NET-futtatókörnyezet az Activity és a DiagnosticSource segítségével támogatja az elosztott terjesztést

Az Application Insights .NET SDK a telemetria gyűjtésére és korrelálására használja a(z) DiagnosticSource és Activity elemeket.

Függőségek

Automatikusan nyomon követett függőségek

A .NET-hez és a .NET Core-hoz készült Application Insights SDK-k egy telemetriai modullal DependencyTrackingTelemetryModule, amely automatikusan gyűjti a függőségeket. A modul DependencyTrackingTelemetryModule a Microsoft.ApplicationInsights.DependencyCollector NuGet csomagként lesz szállítva, és automatikusan el lesz állítva, amikor a NuGet-csomagot vagy a Microsoft.ApplicationInsights.WebMicrosoft.ApplicationInsights.AspNetCore NuGet-csomagot használja.

DependencyTrackingTelemetryModule Jelenleg a következő függőségeket követi nyomon automatikusan:

Függőségek	Részletek
HTTP/HTTPS	Helyi vagy távoli HTTP/HTTPS-hívások.
WCF-hívások	Csak HTTP-alapú kötések használata esetén lesz automatikusan nyomon követve.
SQL	A SqlClient-val indított hívások. Az SQL-lekérdezések rögzítésére szolgáló teljes SQL-lekérdezés lekéréséhez tekintse meg a Speciális SQL-nyomkövetés című szakaszt.
Azure Blob-tároló, Táblázat-tároló vagy Sor-tároló	Az Azure Storage-ügyféllel indított hívások.
Azure Event Hubs ügyféloldali SDK	Használja a legújabb csomagot: https://nuget.org/packages/Azure.Messaging.EventHubs.
Azure Service Bus-ügyfél SDK	Használja a legújabb csomagot: https://nuget.org/packages/Azure.Messaging.ServiceBus.
Azure Cosmos DB	HTTP/HTTPS használata esetén a rendszer automatikusan nyomon követi. A TCP-vel történő közvetlen módban végzett műveletek nyomkövetése automatikusan rögzítésre kerül az előnézeti csomag >= 3.33.0-előnézet használatával. További részletekért tekintse meg a dokumentációt.

Ha a függőség nincs automatikusan összegyűjtve, manuálisan is nyomon követheti egy függőség nyomon követése hívással.

A függőségkövetés működésével kapcsolatos további információkért lásd: Függőségkövetés az Application Insightsban.

Automatikus függőségkövetés beállítása konzolalkalmazásokban

A .NET-konzolalkalmazásoktól származó függőségek automatikus nyomon követéséhez telepítse a NuGet-csomagot Microsoft.ApplicationInsights.DependencyCollector , és inicializálja a következőt DependencyTrackingTelemetryModule:

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

Megjegyzés:

A .NET Core-konzolalkalmazások TelemetryConfiguration.Active elavultak.

Függőségek manuális nyomon követése

A következő, nem automatikusan gyűjtött függőségekre vonatkozó példák manuális nyomkövetést igényelnek:

• Az Azure Cosmos DB csak HTTP/HTTPS használata esetén lesz automatikusan nyomon követve. A TCP-módot az Application Insights nem rögzíti automatikusan a korábbi SDK-verziókhoz 2.22.0-Beta1.
• Redis

Az SDK által nem automatikusan gyűjtött függőségek esetében manuálisan is nyomon követheti őket a standard autocollection-modulok által használt TrackDependency API használatával.

Example

Ha a kódját egy olyan szerelvénnyel állítja össze, amelyet nem Ön írt, az összes hívást időzítheti. Ez a forgatókönyv lehetővé teszi, hogy megtudja, milyen mértékben járul hozzá a válaszidőkhöz.

Ha meg szeretné jeleníteni ezeket az adatokat az Application Insights függőségi diagramjaiban, küldje el a következővel 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);
    }

Alternatív megoldásként a TelemetryClient kiterjesztési metódusokat, StartOperation és StopOperation, használhatjuk a függőségek manuális nyomon követésére, ahogyan azt a kimenő függőségek nyomon követése rész mutatja.

A standard függőségkövetési modul letiltása

További információkért tekintse meg a telemetriai modulokat.

Speciális SQL-nyomkövetés a teljes SQL-lekérdezés lekéréséhez

SQL-hívások esetén a rendszer mindig a kiszolgáló és az adatbázis nevét gyűjti és tárolja az összegyűjtött DependencyTelemetrynévként. Egy másik mező, az úgynevezett adatok a teljes SQL-lekérdezésszöveget tartalmazhatják.

Megjegyzés:

Az Azure Functions külön beállításokat igényel az SQL-szöveggyűjtemény engedélyezéséhez. További információ: SQL-lekérdezésgyűjtemény engedélyezése.

ASP.NET

ASP.NET alkalmazások esetén a rendszer a teljes SQL-lekérdezési szöveget bájtkód-rendszerezés segítségével gyűjti össze, amelyhez a rendszerállapot-kezelő motor vagy a System.Data.SqlClient-kódtár helyett a Microsoft.Data.SqlClient NuGet-csomag használata szükséges. A teljes SQL Query-gyűjtemény engedélyezésének platformspecifikus lépéseit az alábbi táblázat ismerteti.

Plattform	A teljes SQL-lekérdezés lekéréséhez szükséges lépések
Web Apps a Azure-alkalmazás Szolgáltatásban	A webalkalmazás vezérlőpultján nyissa meg az Application Insights panelt, és engedélyezze az SQL-parancsokat a .NET alatt.
IIS-kiszolgáló (Azure Virtual Machines, helyszíni stb.)	Használja a Microsoft.Data.SqlClient NuGet-csomagot, vagy használja az Application Insights Agent PowerShell-modult a rendszerállapot-kezelő motor telepítéséhez és az IIS újraindításához.
Azure Cloud Services	Adjon hozzá egy indítási feladatot a StatusMonitor telepítéséhez. Az alkalmazást a buildeléskor az ApplicationInsights SDK-ba kell előkészíteni, ha nuGet-csomagokat telepít ASP.NET vagy ASP.NET Core-alkalmazásokhoz.
IIS Express	Használja a Microsoft.Data.SqlClient NuGet-csomagot.
WebJobs a Azure-alkalmazás szolgáltatásban	Használja a Microsoft.Data.SqlClient NuGet-csomagot.

Az előző platformspecifikus lépések mellett explicit módon engedélyeznie kell az SQL-parancsgyűjtést is a ApplicationInsights.config fájl alábbi kóddal történő módosításával:

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

ASP.NET Core

Az ASP.NET Core-alkalmazások esetében az SQL Text-gyűjteményt a következő használatával kell választania:

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

A korábbi esetekben az instrumentációs motor megfelelő telepítésének helyes módja az ellenőrzés, hogy az összegyűjtött DependencyTelemetry SDK verziója rddp. rdddsd A függőségek használatát vagy rddf jelzését a rendszer visszahívásokkal DiagnosticSource vagy EventSource visszahívásokkal gyűjti, így a rendszer nem rögzíti a teljes SQL-lekérdezést.

Exceptions

A webalkalmazások kivételei az Application Insights használatával jelenthetők. A sikertelen kérelmeket az ügyfél és a kiszolgáló kivételeivel és egyéb eseményeivel korrelálhatja, így gyorsan diagnosztizálhatja az okokat. Ebben a szakaszban megtudhatja, hogyan állíthat be kivételjelentést, hogyan jelentheti ki explicit módon a kivételeket, diagnosztizálhatja a hibákat stb.

Kivételjelentés beállítása

Beállíthatja az Application Insightst a kiszolgálón vagy az ügyfélen előforduló kivételek jelentésére. Attól függően, hogy az alkalmazás melyik platformtól függ, a megfelelő bővítményre vagy SDK-ra van szüksége.

Server-side

Ha a kiszolgálóoldali alkalmazás kivételeit szeretné jelenteni, vegye figyelembe a következő forgatókönyveket:

• Adja hozzá az Azure-webalkalmazásokhoz készült Application Insights-bővítményt .
• Adja hozzá az Alkalmazásfigyelési bővítményt az Azure-beli virtuális gépekhez és Azure-beli virtuálisgép-méretezési csoportokhoz, amelyek IIS által üzemeltetett alkalmazásokat futtatnak.
• Adja hozzá az Application Insights SDK-t az alkalmazáskódhoz, futtassa az Application Insights Agent for IIS-webkiszolgálókat, vagy engedélyezze a Java-webalkalmazásokhoz készült Java-ügynököt .

Client-side

A JavaScript SDK lehetővé teszi a webböngészőkben előforduló kivételek ügyféloldali jelentéskészítését. A kivételjelentések ügyfélen való beállításához tekintse meg az Application Insights weblapokhoz készült jelentéseit.

Alkalmazás-keretrendszerek

Egyes alkalmazás-keretrendszerek esetén további konfigurációra van szükség. Vegye figyelembe a következő technológiákat:

• Webes űrlapok
• MVC
• Webes API 1.*
• Web API 2.*
• WCF

Fontos

Ez a szakasz a .NET-keretrendszer-alkalmazásokra összpontosít egy példakód szempontjából. A .NET-keretrendszerhez használt módszerek némelyike elavult a .NET Core SDK-ban.

Hibák és kivételek diagnosztizálása

Azure Portal

Az Application Insights egy válogatott alkalmazásteljesítmény-kezelési felülettel rendelkezik, amely segít diagnosztizálni a megfigyelt alkalmazások hibáit.

Részletes útmutatást az Application Insights hibáinak, teljesítményének és tranzakcióinak vizsgálata című témakörben talál.

Visual Studio

1. Nyissa meg az alkalmazásmegoldást a Visual Studióban. Futtassa az alkalmazást a kiszolgálón vagy a fejlesztőgépen az F5 használatával. Hozza létre újra a kivételt.

2. Nyissa meg az Application Insights Search telemetriai ablakát a Visual Studióban. A hibakeresés során válassza az Application Insights legördülő menüt.

3. Válasszon ki egy kivételjelentést a verem nyomkövetésének megjelenítéséhez. A megfelelő kódfájl megnyitásához válasszon egy sorhivatkozást a verem nyomkövetésében.

   Ha a CodeLens engedélyezve van, a kivételekre vonatkozó adatok láthatók:

   

Egyéni nyomkövetési és naplóadatok

Az alkalmazásra vonatkozó diagnosztikai adatok lekéréséhez beszúrhat kódot a saját telemetriai adatok küldéséhez. Az egyéni telemetriai vagy naplóadatok a kérés, az oldalnézet és az egyéb automatikusan gyűjtött adatok mellett megjelennek a diagnosztikai keresésben.

Microsoft.VisualStudio.ApplicationInsights.TelemetryClientA használatával számos API érhető el:

• TelemetryClient.TrackEvent általában a használati minták monitorozására használják, de az általa küldött adatok az egyéni események alatt is megjelennek a diagnosztikai keresésben. Az események elnevezése sztringtulajdonságokat és numerikus metrikákat tartalmazhat, amelyek alapján szűrheti a diagnosztikai kereséseket.
• TelemetryClient.TrackTrace lehetővé teszi hosszabb adatok, például POST-adatok küldését.
• TelemetryClient.TrackException kivételadatokat, például veremköveteket küld az Application Insightsnak.

Az események megtekintéséhez a bal oldali menüben nyissa meg a Keresés elemet. Válassza ki a legördülő menü eseménytípusait, majd válassza az Egyéni esemény, nyomkövetés vagy kivétel lehetőséget.

Megjegyzés:

Ha az alkalmazás nagy mennyiségű telemetriát hoz létre, az adaptív mintavételezési modul automatikusan csökkenti a portálra küldött kötetet úgy, hogy csak az események egy reprezentatív részét küldi el. Az ugyanahhoz a művelethez tartozó események csoportként vannak kijelölve vagy törölve, így navigálhat a kapcsolódó események között. További információ: Mintavételezés az Application Insightsban.

Kérelem POST-adatainak megtekintése

A kérés részletei nem tartalmazzák az alkalmazásnak post-hívásban küldött adatokat. Az adatok jelentése:

• Adja hozzá az Application Insights SDK-t az alkalmazáskódhoz.
• Kód beszúrása az alkalmazásba a Microsoft.ApplicationInsights.TrackTrace() meghívásához. Küldje el a POST-adatokat az üzenetparaméterben. A megengedett méret korlátozott, ezért csak a lényeges adatokat kell elküldenie.
• Sikertelen kérés vizsgálatakor keresse meg a kapcsolódó nyomkövetéseket.

Kivételek és kapcsolódó diagnosztikai adatok rögzítése

Alapértelmezés szerint nem minden olyan kivétel jelenik meg a portálon, amely hibákat okoz az alkalmazásban. Ha a JavaScript SDK-t használja a weblapokon, böngészőkivételek láthatók. A legtöbb kiszolgálóoldali kivételt azonban az IIS elfogja, ezért hozzá kell adnia néhány kódot a rögzítésükhöz és jelentésükhöz.

Ön megteheti:

• A kivételeket explicit módon naplózza , ha kódot szúr be a kivételkezelőkbe a kivételek jelentéséhez.
• A kivételek automatikus rögzítése a ASP.NET-keretrendszer konfigurálásával. A szükséges kiegészítések különböző típusú keretrendszerekhez eltérőek.

Jelentéskivételek explicit módon

A jelentés legegyszerűbb módja, ha beszúr egy hívást trackException() egy kivételkezelőbe.

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

A tulajdonságok és a mérési paraméterek nem kötelezőek, de hasznosak a szűréshez és a további információk hozzáadásához. Ha például van egy alkalmazás, amely több játékot is futtathat, megtalálhatja az adott játékhoz kapcsolódó kivételjelentéseket. Tetszőleges számú elemet adhat hozzá az egyes szótárakhoz.

Böngészők kivételei

A legtöbb böngésző-kivételt a rendszer jelenti.

Ha a weblap tartalomkézbesítési hálózatokból vagy más tartományokból származó szkriptfájlokat tartalmaz, győződjön meg arról, hogy a szkriptcímke rendelkezik az attribútummal crossorigin="anonymous" , és hogy a kiszolgáló CORS-fejléceket küld. Ez a viselkedés lehetővé teszi, hogy lekérje a verem nyomkövetését és részleteit az erőforrásokból származó nem kezelt JavaScript-kivételekhez.

A telemetriai ügyfél újbóli használata

Megjegyzés:

Javasoljuk, hogy példányosítsd az TelemetryClient egyszer, és használd újra az alkalmazás teljes élettartama alatt.

A függőséginjektálás (DI) a .NET-ben, a megfelelő .NET SDK-ban és az Application Insights di-hez való helyes konfigurálásával konstruktorparaméterként megkövetelhető TelemetryClient .

public class ExampleController : ApiController
{
    private readonly TelemetryClient _telemetryClient;

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

Az előző példában a TelemetryClient beszúrt érték be lesz szúrva az ExampleController osztályba.

Webes űrlapok

Webes űrlapok esetén a HTTP-modul képes összegyűjteni a kivételeket, ha nincsenek konfigurálva CustomErrorsátirányítások. Ha azonban aktív átirányításokkal rendelkezik, adja hozzá a következő sorokat a Application_Error a Global.asax.cs.

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

Az előző példában a _telemetryClient típus osztályhatókörű változója TelemetryClient.

MVC

Az Application Insights Web SDK 2.6-os verziójától kezdve (3. bétaverzió és újabb verziók) az Application Insights automatikusan összegyűjti az MVC 5+ vezérlők metódusaiba beszedett kezeletlen kivételeket. Ha korábban hozzáadott egy egyéni kezelőt az ilyen kivételek nyomon követéséhez, eltávolíthatja, hogy megakadályozza a kivételek kettős nyomon követését.

Több olyan eset is van, amikor egy kivételszűrő nem tudja megfelelően kezelni a kivételekkel kapcsolatos hibákat:

• Vezérlőkonstruktorokból
• Üzenetkezelőktől
• Útválasztás során
• Választartalmak szerializálása során
• Az alkalmazás indításakor
• Háttérfeladatokban

Az alkalmazás által kezelt kivételeket továbbra is manuálisan kell nyomon követni. A vezérlőkből származó kezeletlen kivételek általában 500 "belső kiszolgálói hiba" választ eredményeznek. Ha az ilyen válasz manuálisan, egy kezelt kivétel eredményeként jön létre, vagy egyáltalán nincs kivétel, akkor a rendszer a megfelelő 500-as ResultCode kérelemtelemetria alapján követi nyomon. Az Application Insights SDK azonban nem tudja nyomon követni a megfelelő kivételt.

Korábbi verziók támogatása

Ha az Application Insights Web SDK 2.5 -ös (és korábbi) MVC 4-et (és korábbit) használja, a kivételek nyomon követéséhez tekintse meg az alábbi példákat.

Kibontás a korábbi verziókra vonatkozó utasítások megtekintéséhez

Ha a CustomErrors konfigurációja van Off, a HTTP-modul számára kivételeket lehet gyűjteni. Ha azonban (alapértelmezett) vagy RemoteOnly(alapértelmezett) értékre On van állítva, a kivétel törlődik, és nem érhető el az Application Insights számára az automatikus adatgyűjtéshez. Ezt a viselkedést a System.Web.Mvc.HandleErrorAttribute osztály felülbírálásával és a felülbírált osztály alkalmazásával javíthatja, ahogyan az itt látható különböző MVC-verziók esetében is látható (lásd a GitHub forrását):

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

Cserélje le a HandleError attribútumot az új attribútumra a vezérlőkben:

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

Minta

MVC 3

Regisztráljon AiHandleErrorAttribute globális szűrőként a Global.asax.cs:

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

Minta

MVC 4, MVC 5

Regisztráljon AiHandleErrorAttribute globális szűrőként a FilterConfig.cs:

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

Minta

Webes API

Az Application Insights Web SDK 2.6-os verziójától kezdve (3. bétaverzió és újabb verziók) az Application Insights a Web API 2+-hoz automatikusan gyűjti a vezérlő metódusaiba beszedett kezeletlen kivételeket. Ha korábban hozzáadott egy egyéni kezelőt az ilyen kivételek nyomon követéséhez, az alábbi példákban leírtak szerint eltávolíthatja, hogy megakadályozza a kivételek kettős nyomon követését.

A kivételszűrők számos esetben nem kezelhetők. Például:

• A vezérlők konstruktoraitól származó kivételek.
• Az üzenetkezelőktől származó kivételek.
• Az útválasztás során felmerülő kivételek.
• A választartalmak szerializálása során felmerülő kivételek.
• Az alkalmazás indításakor kidobott kivétel.
• A háttérfeladatok kivétele.

Az alkalmazás által kezelt kivételeket továbbra is manuálisan kell nyomon követni. A vezérlőkből származó kezeletlen kivételek általában 500 "belső kiszolgálói hiba" választ eredményeznek. Ha egy ilyen válasz manuálisan, egy kezelt kivétel eredményeként jön létre, vagy egyáltalán nincs kivétel, akkor a rendszer egy 500-as ResultCode megfelelő kérelemtelemetria alapján követi nyomon. Az Application Insights SDK azonban nem tudja nyomon követni a megfelelő kivételt.

Korábbi verziók támogatása

Ha az Application Insights Web SDK 2.5(és korábbi) 1. (és korábbi) Webes API-t használja, a kivételek nyomon követéséhez tekintse meg az alábbi példákat.

Kibontás a korábbi verziókra vonatkozó utasítások megtekintéséhez

Webes API 1.x

Felülbírálás 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);
    }
    }
}

Ezt a felülírt attribútumot hozzáadhatja adott vezérlőkhöz, vagy felveheti az osztály globális szűrőkonfigurációjába WebApiConfig :

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

Minta

Webes API 2.x

A következő implementáció IExceptionLoggerhozzáadása:

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

Adja hozzá ezt a kódrészletet a következő szolgáltatásokhoz 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());
        }
    }
}

Minta

Alternatív megoldásként a következőkre van lehetősége:

• Cserélje le az egyetlen ExceptionHandler példányt egy egyéni implementációra IExceptionHandler. Ezt a kivételkezelőt csak akkor hívja meg a rendszer, ha a keretrendszer továbbra is meg tudja választani, hogy melyik válaszüzenetet küldje el, például a kapcsolat megszakadásakor nem.
• Használjon kivételszűrőket a Web API 1.x vezérlők előző szakaszában leírtak szerint, amelyeket nem minden esetben hívunk meg.

WCF

Adjon hozzá egy olyan osztályt, amely kiterjeszti Attribute és megvalósítja IErrorHandler a elemet.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)
        {
        }
      }
    }

Adja hozzá az attribútumot a szolgáltatás implementációihoz:

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

Minta

Kivételteljesítmény-számlálók

Ha telepítette az Azure Monitor Application Insights-ügynököt a kiszolgálón, lekérheti a .NET által mért kivételek arányát ábrázoló diagramot. Mind a kezelt, mind a kezeletlen .NET-kivételeket tartalmazza a rendszer.

Nyisson meg egy metrikakezelő lapot, és adjon hozzá egy új diagramot. A Teljesítményszámlálók területen válassza a Kivételi arány lehetőséget.

A .NET-keretrendszer úgy számítja ki a mértéket, hogy megszámolja a kivételek számát egy intervallumban, és elosztja az intervallum hosszával.

Ez a szám eltér az Application Insights portál által kiszámított kivételek számától, amely a jelentéseket számolja TrackException . A mintavételezési időközök eltérőek, és az SDK nem küld TrackException jelentéseket az összes kezelt és kezeletlen kivételről.

Egyéni metrikagyűjtemény

Az Azure Monitor Application Insights .NET és a .NET Core SDK-k két különböző módszerrel gyűjtenek egyéni metrikákat:

• A TrackMetric() módszer, amely nem rendelkezik előaggregációval.
• A GetMetric() metódus, amely előaggregációval rendelkezik.

Javasoljuk az összesítés használatát, így TrackMetric()már nem az egyéni metrikák gyűjtésének előnyben részesített módszere. Ez a cikk végigvezeti a GetMetric() módszer használatán és a működés hátterében álló néhány okon.

További információ a preaggregating és a nem preaggregating API-ról

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

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

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

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

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

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

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

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

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

Metrikák küldése

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

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

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

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

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

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

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

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

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

Megjegyzés:

A GetMetric metódus nem támogatja az utolsó érték nyomon követését (például gauge) vagy hisztogramok vagy eloszlások nyomon követését.

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

Megjegyzés:

Bár a nyers telemetriaelem nem tartalmazott explicit összegtulajdonságot/mezőt a betöltés után, létrehozunk egyet Önnek. Ebben az esetben mind a valuevalueSum tulajdonság, mind a tulajdonság ugyanazt képviseli.

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

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

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

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

//...

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

                computersSold.TrackValue(42);

                computersSold.TrackValue(142);

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

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

Többdimenziós metrikák

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

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

//...

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

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


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

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

A metrikák kezelőjében:

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

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

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

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

Miután elvégezte a módosítást, és új többdimenziós telemetriát küldött, kiválaszthatja az Alkalmaz felosztás lehetőséget.

Megjegyzés:

Csak az újonnan küldött metrikák vannak tárolva a portálon a funkció bekapcsolása után.

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

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

Jelenleg 10 dimenzió támogatott. Háromnál több dimenzió használata esetén a következőt kell használni MetricIdentifier:

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

Egyéni metrikakonfiguráció

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

Speciális dimenziónevek

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

A következő Special Operation Request Size metrika által küldött metrika-összesítések nem lettek Context.Operation.Name beállítva.Special Operation A TrackMetric() metódus vagy bármely más TrackXXX() metódus helyesen lett OperationName beállítva.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);
                //...
            }
                   
        }

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

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

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

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

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

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

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

Fontos

A szabályozás elkerülése érdekében használjon alacsony számosságú értékeket a dimenziókhoz.

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

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

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

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

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

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

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

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

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

Egyéni műveletek nyomon követése

Az Application Insights SDK-k automatikusan nyomon követik a függő szolgáltatásokhoz érkező HTTP-kéréseket és hívásokat, például HTTP-kéréseket és SQL-lekérdezéseket. A kérelmek és függőségek nyomon követése és korrelációja lehetővé teszi az alkalmazás válaszkészségének és megbízhatóságának áttekintését az alkalmazás összes olyan mikroszolgáltatásában, amely kombinálja ezt az alkalmazást.

Vannak olyan alkalmazásminták, amelyek általánosan nem támogatottak. Az ilyen minták megfelelő monitorozása manuális kódrendszerezést igényel. Ez a szakasz néhány olyan mintát mutat be, amelyek manuális rendszerezést igényelhetnek, például egyéni üzenetsor-feldolgozást és hosszú ideig futó háttérfeladatok futtatását.

Ez a szakasz útmutatást nyújt az Egyéni műveletek nyomon követéséhez az Application Insights SDK-val.

Áttekintés

A művelet egy alkalmazás által futtatott logikai munkadarab. Neve, kezdési időpontja, időtartama, eredménye és a végrehajtás környezete, például felhasználónév, tulajdonságok és eredmény. Ha az A műveletet a B művelet kezdeményezte, akkor a B művelet az A szülőjeként van beállítva. Egy műveletnek csak egy szülője lehet, de számos gyermekművelettel rendelkezhet. További információ a műveletekről és a telemetriai korrelációról: Application Insights telemetriai korreláció.

Az Application Insights .NET SDK-ban a műveletet az OperationTelemetry absztrakt osztály és annak leszármazottai , a RequestTelemetry és a DependencyTelemetry írja le.

Bejövő műveletek nyomon követése

Az Application Insights webes SDK automatikusan http-kéréseket gyűjt az IIS-folyamatban futó ASP.NET alkalmazásokhoz és az összes ASP.NET Core-alkalmazáshoz. Más platformokhoz és keretrendszerekhez is léteznek közösség által támogatott megoldások. Ha az alkalmazást egyik standard vagy közösség által támogatott megoldás sem támogatja, manuálisan is rendszerezheti.

Egy másik példa, amely egyéni nyomon követést igényel, az a feldolgozó, amely elemeket fogad az üzenetsorból. Egyes üzenetsorok esetében az üzenetsorhoz üzenet hozzáadására irányuló hívás függőségként van nyomon követve. A rendszer nem gyűjti automatikusan az üzenetfeldolgozást leíró magas szintű műveletet.

Lássuk, hogyan követhetők nyomon az ilyen műveletek.

Magas szinten a feladat az ismert tulajdonságok létrehozása RequestTelemetry és beállítása. A művelet befejezése után nyomon követheti a telemetriát. Az alábbi példa ezt a feladatot mutatja be.

HTTP-kérés az Owin saját üzemeltetésű alkalmazásában

Ebben a példában a nyomkövetési környezet propagálása a http protokollnak megfelelően történik a korrelációhoz. Az itt leírt fejléceket várhatóan megkapja.

Kibontás a kód megtekintéséhez

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

A http protokoll a korrelációhoz is deklarálja a fejlécet Correlation-Context . Itt hiányzik az egyszerűség kedvéért.

Üzenetsor-kialakítás

A W3C trace context és a HTTP Protocol for Correlation pass korrelációs adatokat ad át a HTTP-kérésekkel, de minden üzenetsor-protokollnak meg kell határoznia, hogy a rendszer hogyan továbbítja ugyanazokat a részleteket az üzenetsor-üzenetben. Egyes üzenetsor-protokollok, például az AMQP lehetővé teszik további metaadatok átadását. Más protokollok, például az Azure Storage Queue megkövetelik, hogy a környezet az üzenet hasznos adataiba legyen kódolva.

Megjegyzés:

Az üzenetsorok még nem támogatják az összetevők közötti nyomkövetést.

A HTTP használatával, ha a gyártó és a fogyasztó telemetriát küld különböző Application Insights-erőforrásokba, a tranzakciódiagnosztikai élmény és az Alkalmazástérkép a tranzakciókat és a végpontok közötti leképezést jeleníti meg. Az üzenetsorok esetében ez a képesség még nem támogatott.

Service Bus-üzenetsor

A nyomkövetési információkért lásd: Elosztott nyomkövetés és korreláció az Azure Service Bus-üzenetkezelésen keresztül.

Azure Storage-üzenetsor

Az alábbi példa bemutatja, hogyan követheti nyomon az Azure Storage-üzenetsor műveleteit, és hogyan korrelálhatja a telemetriát a gyártó, a fogyasztó és az Azure Storage között.

A Storage-üzenetsor http API-val rendelkezik. Az üzenetsorra irányuló összes hívást az Application Insights függőséggyűjtője követi nyomon a HTTP-kérésekhez. Alapértelmezés szerint ASP.NET és ASP.NET Core-alkalmazásokban van konfigurálva. Más típusú alkalmazásokkal kapcsolatban tekintse meg a konzolalkalmazások dokumentációját.

Érdemes lehet korrelálni az Application Insights-művelet azonosítóját a Storage-kérelem azonosítójával. A Storage-kérelemügyfél és a kiszolgálókérés azonosítójának beállításáról és lekéréséről további információt az Azure Storage monitorozása, diagnosztizálása és hibaelhárítása című témakörben talál.

Enqueue

Mivel a tárolási üzenetsorok támogatják a HTTP API-t, az Application Insights automatikusan nyomon követi az üzenetsor összes műveletét. Sok esetben ennek a rendszerezésnek elégnek kell lennie. Ha a fogyasztói oldalon lévő nyomkövetéseket a gyártói nyomkövetésekkel szeretné korrelálni, a korreláció http protokolljában használthoz hasonlóan át kell adnia néhány korrelációs összefüggést.

Ez a példa bemutatja, hogyan követheti nyomon a Enqueue műveletet. Ön megteheti:

• Újrapróbálkozási újrapróbálkozások korrelálása (ha van ilyen):: Mindegyiknek van egy közös szülője, amely a Enqueue művelet. Ellenkező esetben a bejövő kérés gyermekeiként lesznek nyomon követve. Ha több logikai kérés is van az üzenetsorhoz, előfordulhat, hogy nehéz megtalálni, hogy melyik hívás eredményezett újrapróbálkozásokat.
• Tárnaplók korrelálása (ha és ha szükséges): Az Application Insights telemetriai adataival vannak korrelálva.

A Enqueue művelet egy szülőművelet gyermeke. Ilyen például egy bejövő HTTP-kérés. A HTTP-függőségi hívás a művelet gyermeke Enqueue és a bejövő kérés unokája.

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

Ha csökkenteni szeretné az alkalmazásjelentések telemetriai adatait, vagy ha más okból nem szeretné nyomon követni a Enqueue műveletet, használja közvetlenül az Activity API-t:

• Hozzon létre (és kezdjen el) egy újat Activity az Application Insights-művelet indítása helyett. A művelet neve kivételével nincs szükség tulajdonságok hozzárendelésére.
• Szerializálja yourActivity.Id az üzenet hasznos adatait ahelyett, hogy operation.Telemetry.Id. A Activity.Current.Idis használható.

Kivétel a sorból

Ehhez hasonlóan Enqueueaz Application Insights automatikusan nyomon követi a Storage-üzenetsorra irányuló tényleges HTTP-kéréseket. A Enqueue művelet feltehetően a szülőkörnyezetben történik, például egy bejövő kérelemkörnyezetben. Az Application Insights SDK-k automatikusan korrelálnak egy ilyen műveletet és annak HTTP-részét a szülőkérelmével és az ugyanabban a hatókörben jelentett egyéb telemetriával.

A Dequeue művelet trükkös. Az Application Insights SDK automatikusan nyomon követi a HTTP-kéréseket. Az üzenet elemzéséig azonban nem ismeri a korrelációs környezetet. Nem lehet korrelálni a HTTP-kérést az üzenet lekéréséhez a többi telemetriával, különösen akkor, ha egynél több üzenet érkezik.

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

Folyamat

Az alábbi példában a bejövő üzenetek a bejövő HTTP-kérésekhez hasonló módon lesznek nyomon követve:

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

Hasonlóképpen más üzenetsor-műveletek is rendszerezhetők. A betekintő műveletet a dequeue művelethez hasonlóan kell végrehajtani. A rendszerállapot-kezelési műveletek nem szükségesek. Az Application Insights nyomon követi az olyan műveleteket, mint a HTTP, és a legtöbb esetben elegendő.

Az eszközüzenetek törlésekor győződjön meg arról, hogy beállítja a művelet (korreláció) azonosítóit. Másik lehetőségként használhatja az Activity API-t. Ezután nem kell műveleti azonosítókat beállítania a telemetriai elemeken, mert az Application Insights SDK elvégzi Önnek:

• Hozzon létre egy újat Activity , miután már kapott egy elemet az üzenetsorból.
• A Activity.SetParentId(message.ParentId) fogyasztói és a termelői naplók korrelációja.
• Indítsa el a Activity.
• Nyomon követheti a lekérési, feldolgozási és törlési műveleteket segítők használatával Start/StopOperation . Végezze el ugyanabból az aszinkron vezérlési folyamatból (végrehajtási környezetből). Ily módon megfelelően vannak korrelálva.
• Állítsa le a Activity.
• Telemetria manuális használata Start/StopOperation vagy meghívása Track .

Függőségtípusok

Az Application Insights függőségtípussal szabja testre a felhasználói felületi szolgáltatásokat. Az üzenetsorok esetében a DependencyTelemetry ismeri fel:

• Azure queue Azure Storage-üzenetsorokhoz
• Azure Event Hubs Az Azure Event Hubshoz
• Azure Service Bus Az Azure Service Bushoz

Kötegelt feldolgozás

Egyes üzenetsorokkal több üzenetet is lekérhet egyetlen kéréssel. Az ilyen üzenetek feldolgozása feltehetően független, és a különböző logikai műveletekhez tartozik. A művelet nem kapcsolható össze Dequeue egy feldolgozandó üzenettel.

Minden üzenetet a saját aszinkron vezérlőfolyamatában kell feldolgozni. További információ: Kimenő függőségek nyomon követése szakasz.

Hosszan futó háttérfeladatok

Egyes alkalmazások hosszú ideig futó műveleteket indítanak el, amelyeket felhasználói kérések okozhatnak. A nyomkövetés/rendszerállapot szempontjából ez nem különbözik a kéréstől vagy a függőségi rendszerállapottól:

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

Ebben a példában telemetryClient.StartOperation létrehozza DependencyTelemetry és kitölti a korrelációs környezetet. Tegyük fel, hogy van egy szülőművelete, amelyet a műveletet ütemező bejövő kérések hoztak létre. Mindaddig, amíg BackgroundTask ugyanabban az aszinkron vezérlőfolyamatban indul el, mint egy bejövő kérés, a szülőművelettel van összefüggésben. BackgroundTask és az összes beágyazott telemetriai elem automatikusan korrelál az azt okozó kéréssel, még a kérés befejeződése után is.

Ha a feladat olyan háttérszálból indul, amelyhez nincs társítva semmilyen művelet (Activity) , BackgroundTask nincs szülője. Azonban beágyazott műveleteket is tartalmazhat. A tevékenységből jelentett összes telemetriai elem korrelációban van a DependencyTelemetry létrehozott BackgroundTaskelemekkel.

Kimenő függőségek nyomon követése

Nyomon követheti a saját függőségi típusát vagy az Application Insights által nem támogatott műveletet.

A Enqueue Service Bus-üzenetsor vagy a Storage-üzenetsor metódusa példaként szolgálhat az ilyen egyéni nyomon követéshez.

Az egyéni függőségek nyomon követésének általános megközelítése a következő:

• Hívja meg a TelemetryClient.StartOperation (bővítmény) metódust, amely kitölti a korrelációhoz szükséges tulajdonságokat és más tulajdonságokat, például a kezdést, az időbélyeget és az DependencyTelemetry időtartamot.
• Adja meg a többi egyéni tulajdonságot, DependencyTelemetrypéldául a nevet és a szükséges egyéb környezeteket.
• Hozzon létre egy függőségi hívást, és várja meg.
• Állítsa le a műveletet StopOperation , ha befejeződött.
• Kivételek kezelése.

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

A művelet letiltása leállítja a műveletet, ezért a hívás StopOperationhelyett ezt is megteheti.

Figyelmeztetés

Bizonyos esetekben előfordulhat, hogy a nem kezelt kivétel nemfinally hívható meg, ezért előfordulhat, hogy a műveletek nem lesznek nyomon követve.

Párhuzamos műveletek feldolgozása és nyomon követése

A hívás StopOperation csak az elindított műveletet állítja le. Ha az aktuális futó művelet nem egyezik meg a leállítani kívánt művelettel, StopOperation semmit sem tesz. Ez a helyzet akkor fordulhat elő, ha egyszerre több műveletet is elindít ugyanabban a végrehajtási környezetben.

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;

Győződjön meg arról, hogy a műveletet mindig ugyanabban az StartOperation metódusban hívja meg és dolgozza fel, hogy elkülönítse a párhuzamosan futó műveleteket. Ha a művelet szinkron (vagy nem aszinkron), csomagolja be a folyamatot, és kövesse a következőt 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);
}

ApplicationInsights-műveletek és System.Diagnostics.Activity

System.Diagnostics.Activity az elosztott nyomkövetési környezetet jelöli, és keretrendszerek és kódtárak használják a környezet létrehozásának és propagálásának folyamaton belüli és kívüli létrehozására és propagálására, valamint a telemetriai elemek korrelációjára. Activity együttműködik a keretrendszer/tár közötti értesítési mechanizmussal System.Diagnostics.DiagnosticSource , hogy értesítést küldjön az olyan érdekes eseményekről, mint a bejövő vagy kimenő kérések és kivételek.

A tevékenységek az Application Insights legfelső szintű funkciói. Az automatikus függőségek és kérések gyűjtése nagyban támaszkodik rájuk az események mellett DiagnosticSource . Ha az alkalmazásban hozta létre Activity , az nem eredményezne Application Insights-telemetriát. Az Application Insightsnak eseményeket kell fogadnia DiagnosticSource, valamint ismernie kell az eseményneveket és a hasznos adatokat, hogy ezeket Activity telemetriai adatokra lehessen fordítani.

Minden Application Insights-művelet (kérelem vagy függőség) magában foglalja a Activitykövetkezőket: . Amikor StartOperation meghívják, az alatta jön létre Activity . StartOperation A kérések vagy függőségi telemetriák manuális nyomon követésének és annak ellenőrzésének ajánlott módja, hogy minden összefüggésben legyen.

Counters

Az Application Insights támogatja a teljesítményszámlálókat és az eseményszámlálókat. Ez az útmutató áttekintést nyújt mindkettőről, beleértve azok célját, konfigurációját és használatát a .NET-alkalmazásokban.

• A teljesítményszámlálók a Windows operációs rendszerbe vannak beépítve, és előre meghatározott metrikákat kínálnak, például a processzorhasználatot, a memóriahasználatot és a lemeztevékenységet. Ezek a számlálók ideálisak a standard teljesítménymetrikák minimális beállítással történő monitorozásához. Segítenek nyomon követni az erőforrások kihasználtságát, vagy elhárítják a Windows-alapú alkalmazások rendszerszintű szűk keresztmetszeteit, de nem támogatják az egyéni alkalmazásspecifikus metrikákat.

• Az eseményszámlálók több platformon is működnek, beleértve a Windowst, a Linuxot és a macOS-t is. Lehetővé teszik a fejlesztők számára, hogy egyszerű, testre szabható alkalmazásspecifikus metrikákat definiáljanak és monitorozzanak, nagyobb rugalmasságot biztosítva, mint a teljesítményszámlálók. Az eseményszámlálók akkor hasznosak, ha a rendszermetrikák nem elegendőek, vagy ha részletes telemetriára van szükség a platformfüggetlen alkalmazásokban. Explicit megvalósítást és konfigurálást igényelnek, ami nagyobb erőfeszítést igényel.

Teljesítmény számlálók

A Windows különböző teljesítményszámlálókat biztosít, például a processzor-, memória- és lemezhasználati statisztikák gyűjtéséhez használtakat. Saját teljesítményszámlálókat is definiálhat.

Az alkalmazás támogatja a teljesítményszámláló gyűjtését, ha az Internet Information Server (IIS) alatt fut egy helyszíni gazdagépen vagy rendszergazdai hozzáféréssel rendelkező virtuális gépen. Az Azure Web Apps-ként futó alkalmazások nem férhetnek hozzá közvetlenül a teljesítményszámlálókhoz, de az Application Insights összegyűjti az elérhető számlálók egy részét.

Jótanács

Más metrikákhoz hasonlóan riasztást is beállíthat , amely figyelmezteti, ha egy számláló túllép egy megadott korlátot. Riasztás beállításához nyissa meg a Riasztások panelt , és válassza a Riasztás hozzáadása lehetőséget.

Előfeltételek

Adjon engedélyt az alkalmazáskészlet szolgáltatásfiókjának a teljesítményszámlálók figyelésére a Teljesítményfigyelő felhasználók csoportjához való hozzáadásával.

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

Számlálók megtekintése

A Metrikák panelen a teljesítményszámlálók alapértelmezett készlete látható.

ASP.NET

Alapértelmezett számlálók ASP.NET webalkalmazásokhoz:

• % folyamat\processzoridő
• % folyamat\Processzoridő normalizált
• Memória\Rendelkezésre álló bájtok
• ASP.NET kérések/mp
• .NET Common Language Runtime (CLR) – Kivételek másodpercenként
• ASP.NET ApplicationsRequest végrehajtási ideje
• Folyamat\Privát Bájtok
• Folyamat\IO Adat Bájt/mp
• ASP.NET Alkalmazások\Kérelmek az alkalmazássorban
• Processzor(_Total)\% processzoridő

ASP.NET Core

Alapértelmezett számlálók ASP.NET Core-webalkalmazásokhoz:

• % folyamat\processzoridő
• % folyamat\Processzoridő normalizált
• Memória\Rendelkezésre álló bájtok
• Folyamat\Privát Bájtok
• Folyamat\IO Adat Bájt/mp
• Processzor(_Total)\% processzoridő

Megjegyzés:

A ASP.NET Core teljesítményszámlálóinak támogatása korlátozott:

• A 2.4.1-s és újabb SDK-verziók teljesítményszámlálókat gyűjtenek, ha az alkalmazás az Azure Web Appsben (Windows) fut.
• A 2.7.1-s és újabb SDK-verziók teljesítményszámlálókat gyűjtenek, ha az alkalmazás Windows rendszerben és célokban vagy újabb verziókban NETSTANDARD2.0 fut.
• A .NET-keretrendszert célzó alkalmazások esetében az SDK minden verziója támogatja a teljesítményszámlálókat.
• Az SDK 2.8.0-s és újabb verziói támogatják a Cpu/Memória számlálót Linuxon. A Linux nem támogat más számlálót. Ha rendszerszámlálókat szeretne lekérni Linuxon (és más nem Windows-környezetekben), használjon eseményszámlálókat.

Számlálók hozzáadása

Ha a kívánt teljesítményszámláló nem szerepel a metrikák listájában, felveheti.

ASP.NET

1. lehetőség: Konfiguráció a ApplicationInsights.config

1. A helyi kiszolgálón található PowerShell-paranccsal megtudhatja, hogy mely számlálók érhetők el a kiszolgálón:

   Get-Counter -ListSet *
   

   További információért lásd Get-Counter.

2. Nyissa meg ApplicationInsights.config.

   Ha a fejlesztés során hozzáadta az Application Insightst az alkalmazáshoz:

   1. Szerkesztés ApplicationInsights.config a projektben.
   2. Helyezze újra üzembe a kiszolgálókon.

3. A teljesítménygyűjtő irányelvének szerkesztése:

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

A saját maga által implementálva használt standard számlálókat és számlálókat is rögzítheti. \Objects\Processes Egy példa egy szabványos számlálóra, amely minden Windows rendszeren elérhető. \Sales(photo)\# Items Sold Egy példa egy webszolgáltatásban implementálható egyéni számlálóra.

A formátum , \Category(instance)\Countervagy olyan kategóriák esetén, amelyek nem rendelkeznek példányokkal, csak \Category\Counter.

A ReportAs paraméter olyan számlálónevekhez szükséges, amelyek nem egyeznek [a-zA-Z()/-_ \.]+.

Ha megad egy példányt, az a jelentett metrika dimenziójává CounterInstanceName válik.

2. lehetőség: Konfiguráció a kódban

Lásd a következő szakaszt.

ASP.NET Core

Konfigurálás PerformanceCollectorModule a metódus után a WebApplication.CreateBuilder() következőben 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();

Teljesítményszámlálók gyűjtése ASP.NET webalkalmazások vagy .NET/.NET Core-konzolalkalmazások kódjában

A rendszerteljesítmény-számlálók gyűjtéséhez és az Application Insightsba való elküldéséhez a következő kódrészletet módosíthatja:

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

Vagy ugyanezt megteheti a létrehozott egyéni metrikákkal is:

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

Teljesítményszámlálók az Azure Web Appsben és a Windows-tárolókban futó alkalmazásokhoz az Azure App Service-ben

Az Azure Web Appsben üzembe helyezett ASP.NET és ASP.NET Core-alkalmazások speciális tesztkörnyezetben futnak. Az Azure App Service-ben üzembe helyezett alkalmazások windowsos tárolót használhatnak, vagy tesztkörnyezetben üzemeltethetők. Ha az alkalmazás windowsos tárolóban van üzembe helyezve, a tároló lemezképében minden standard teljesítményszámláló elérhető.

A tesztkörnyezet nem teszi lehetővé a rendszerteljesítmény-számlálók közvetlen elérését. A számlálók korlátozott részhalmaza azonban környezeti változóként jelenik meg a környezeti változóként közzétett Perf Számlálókban leírtak szerint. Ebben a környezetben csak a számlálók egy részhalmaza érhető el. A teljes listát a környezeti változókként közzétett perf számlálókban találja.

A ASP.NET és ASP.NET Core-hoz készült Application Insights SDK észleli, hogy a kód webalkalmazásban vagy nem Windows-tárolóban van-e üzembe helyezve. Az észlelés meghatározza, hogy a tesztkörnyezetben gyűjti-e a teljesítményszámlálókat, vagy windowsos tárolón vagy virtuális gépen üzemeltetve használja-e a standard gyűjtési mechanizmust.

Log Analytics-lekérdezések teljesítményszámlálókhoz

A Log Analyticsben teljesítményszámláló jelentéseket kereshet és jeleníthet meg.

A performanceCounters séma az egyes teljesítményszámlálók categorynevét counter és instance nevét teszi elérhetővé. Az egyes alkalmazások telemetriai adataiban csak az adott alkalmazás számlálói láthatók. Például a rendelkezésre álló számlálók megtekintéséhez:

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

Instance Itt a teljesítményszámláló példányra hivatkozik, nem a szerepkörre vagy a kiszolgálógép-példányra. A teljesítményszámláló-példány neve általában a folyamat vagy az alkalmazás neve alapján szegmentálta a számlálókat, például a processzoridőt.

Az elmúlt időszakban rendelkezésre álló memória diagramjának lekérése:

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

A többi telemetriához hasonlóan a PerformanceCounters is rendelkezik egy oszlopmal cloud_RoleInstance , amely annak a gazdagépkiszolgáló-példánynak az identitását jelzi, amelyen az alkalmazás fut. Például az alkalmazás teljesítményének összehasonlítása a különböző gépeken:

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

Teljesítményszámlálók – gyakori kérdések

A gyakori kérdések (GYIK) áttekintéséhez tekintse meg a Teljesítményszámlálók gyakori kérdéseket.

Eseményszámlálók

EventCounter .NET/.NET Core-mechanizmus számlálók vagy statisztikák közzétételére és felhasználására. Az EventCounters minden operációsrendszer-platformon támogatott – Windows, Linux és macOS. Platformokon átívelő egyenértékként tekinthetünk rá a PerformanceCounters-hoz, amit kizárólag Windows rendszerek támogatnak.

Bár a felhasználók bármilyen egyéni eseményszámlálót közzétehetnek az igényeiknek megfelelően, a .NET alapértelmezés szerint közzéteszi ezeket a számlálókat. Ez a dokumentum végigvezeti az Azure Application Insights eseményszámlálóinak (rendszer által definiált vagy felhasználó által definiált) gyűjtéséhez és megtekintéséhez szükséges lépéseket.

Jótanács

Más metrikákhoz hasonlóan riasztást is beállíthat , amely figyelmezteti, ha egy számláló túllép egy megadott korlátot. Riasztás beállításához nyissa meg a Riasztások panelt , és válassza a Riasztás hozzáadása lehetőséget.

Az Application Insights használata az EventCounters gyűjtéséhez

Az Application Insights támogatja a gyűjtést EventCounters az EventCounterCollectionModuleújonnan kiadott Microsoft.ApplicationInsights.EventCounterCollector NuGet-csomag részeként. EventCounterCollectionModule A automatikusan engedélyezve van az AspNetCore vagy a WorkerService használatakor. EventCounterCollectionModule 60 másodperces nem konfigurálható gyűjtési gyakorisággal gyűjti a számlálókat. Az EventCounters gyűjtéséhez nincs szükség különleges engedélyekre. Az ASP.NET Core-alkalmazásokhoz a Microsoft.ApplicationInsights.AspNetCore csomagot is hozzá kell adnia.

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

Összegyűjtött alapértelmezett számlálók

Az AspNetCore SDK vagy a WorkerService SDK 2.15.0-s verziójától kezdve alapértelmezés szerint nem gyűjt számlálókat. Maga a modul engedélyezve van, így a felhasználók hozzáadhatják a kívánt számlálókat az adatgyűjtéshez.

A .NET-futtatókörnyezet által közzétett jól ismert számlálók listájának lekéréséhez tekintse meg az Elérhető számlálók dokumentumot.

Gyűjtendő számlálók testreszabása

Az alábbi példa a számlálók hozzáadását/eltávolítását mutatja be. Ezt a testreszabást az alkalmazásszolgáltatás konfigurációjának részeként kell elvégezni, miután az Application Insights telemetriai gyűjtemény engedélyezve lett az AddApplicationInsightsTelemetry() egyik vagy AddApplicationInsightsWorkerService()a . Az alábbi példakód egy ASP.NET Core-alkalmazásból származik. Egyéb típusú alkalmazások esetén tekintse meg a telemetriai modulok konfigurálását.

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

Az EventCounter gyűjteménymodul letiltása

EventCounterCollectionModule funkcióval ApplicationInsightsServiceOptionsle lehet tiltani.

Az alábbi példa a ASP.NET Core SDK-t használja.

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

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

Hasonló megközelítés használható a Worker Service SDK-hoz is, de a névteret módosítani kell az alábbi példában látható módon.

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

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

Log Analytics-lekérdezések eseményszámlálókhoz

Az eseményszámláló-jelentések a Log Analyticsben, a customMetrics táblában kereshetők és jeleníthetők meg.

Futtassa például a következő lekérdezést, hogy lássa, milyen számlálók vannak összegyűjtve és elérhetők a lekérdezéshez:

customMetrics | summarize avg(value) by name

Ha egy adott számláló diagramját (például: ThreadPool Completed Work Item Count) szeretné lekérni az elmúlt időszakban, futtassa az alábbi lekérdezést.

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

A többi telemetriához hasonlóan a customMetrics is rendelkezik egy oszloppal cloud_RoleInstance , amely annak a gazdagépkiszolgáló-példánynak az identitását jelzi, amelyen az alkalmazás fut. Az előző lekérdezés a példányonkénti számlálóértéket jeleníti meg, és a különböző kiszolgálópéldányok teljesítményének összehasonlítására használható.

Eseményszámlálók – gyakori kérdések

A gyakori kérdések (GYIK) áttekintéséhez tekintse meg az Eseményszámlálók gyik című témakört.

Pillanatkép-gyűjtemény

Ha tudni szeretné, hogyan konfigurálhatja a pillanatkép-gyűjteményt ASP.NET és ASP.NET Core-alkalmazásokhoz, olvassa el a Pillanatkép-hibakereső engedélyezése .NET-alkalmazásokhoz az Azure Service Fabricben, a Cloud Servicesben és a virtuális gépeken című témakört.

Node.js

Ebben a szakaszban

• Élő metrikák
• Elosztott nyomkövetés
• Kiterjesztett metrikák
• TelemetryClient API

Élő metrikák

Ha engedélyezni szeretné az élő metrikák küldését az alkalmazásból az Azure-ba, használja setSendLiveMetrics(true). Az élő metrikák szűrése jelenleg nem támogatott a portálon.

Elosztott nyomkövetés

A modern felhő- és mikroszolgáltatás-architektúrák egyszerű, egymástól függetlenül üzembe helyezhető szolgáltatásokat tettek lehetővé, amelyek csökkentik a költségeket, miközben növelik a rendelkezésre állást és az átviteli sebességet. Ez azonban megnehezítette az általános rendszerek érvelését és hibakeresését. Az elosztott nyomkövetés egy olyan teljesítményprofilozóval oldja meg ezt a problémát, amely a felhő- és mikroszolgáltatás-architektúrák hívásveremeihez hasonlóan működik.

Az Azure Monitor két szolgáltatást biztosít az elosztott nyomkövetési adatok használatához: az egyetlen tranzakció/kérelem tranzakciódiagnosztikai nézetét és az alkalmazástérkép nézetet, amely a rendszerek interakcióit mutatja be.

Az Application Insights külön monitorozza az egyes összetevőket, és elosztott telemetriai korreláció használatával észleli, hogy melyik összetevő felelős a hibákért vagy a teljesítménycsökkenésért. Ez a cikk az Application Insights által használt különböző nyelvek és platformok korrelációs taktikáinak adatmodellét, környezetpropagálási technikáit, protokolljait és implementálását ismerteti.

Elosztott nyomkövetés engedélyezése az Application Insightson keresztül autoinstrumentációval vagy SDK-kkal

A .NET, a .NET Core, a Java, a Node.jsés a JavaScript alkalmazáshoz készült Application Insights-ügynökök és SDK-k mind támogatják az elosztott nyomkövetést natív módon.

A megfelelő Application Insights SDK telepítésével és konfigurálásával a rendszer automatikusan gyűjti a nyomkövetési információkat a népszerű keretrendszerekhez, kódtárakhoz és technológiákhoz az SDK függőségi autoklektorai által. A támogatott technológiák teljes listája elérhető a Dependency autocollection dokumentációjában.

Bármely technológia manuálisan is nyomon követhető a TelemetryClient TrackDependency hívásával.

Adatmodell telemetriai korrelációhoz

Az Application Insights egy adatmodellt határoz meg az elosztott telemetriai korrelációhoz. Ha a telemetriát logikai művelethez szeretné társítani, minden telemetriai elemhez tartozik egy környezetmező.operation_Id Az elosztott nyomkövetés minden telemetriai eleme megosztja ezt az azonosítót. Így akkor is társíthat más összetevők által jelentett telemetriát, ha egyetlen rétegből veszíti el a telemetriát.

Az elosztott logikai műveletek általában kisebb műveletekből állnak, amelyeket az egyik összetevő feldolgoz. A kérelemtelemetria határozza meg ezeket a műveleteket. Minden kérelemtelemetriaelem saját id , amely egyedileg és globálisan azonosítja azt. A kérelemhez társított összes telemetriai elemnek (mint például a nyomkövetések és kivételek) a operation_parentId értékét a kérelem id értékére kell beállítania.

A függőségi telemetria minden kimenő műveletet jelöl, például egy másik összetevőhöz irányuló HTTP-hívást. Meghatározza a saját id-ját is, amely globálisan egyedi. A függőségi hívás által kezdeményezett telemetriai kérések ezt id használják operation_parentId-ként.

Az elosztott logikai művelet nézetét az operation_Id, operation_parentId, request.id és dependency.id használatával hozhatja létre. Ezek a mezők a telemetriai hívások oksági sorrendjét is meghatározzák.

Mikroszolgáltatási környezetben az összetevőkből származó nyomkövetések különböző tárolóelemekre is áttérhetnek. Minden összetevő rendelkezhet saját kapcsolati sztringgel az Application Insightsban. A logikai művelet telemetriájának lekéréséhez az Application Insights minden tárolóelemből lekérdezi az adatokat.

Ha a tárelemek száma nagy, szüksége van útmutatásra arról, hogy hol keresse a következőt. Az Application Insights adatmodell két mezőt határoz meg a probléma megoldásához: request.source és dependency.target. Az első mező azonosítja a függőségi kérelmet kezdeményező összetevőt. A második mező azonosítja, hogy melyik összetevő válaszolt a függőségi hívásra.

További információ a több különálló példányból történő lekérdezésről: Adatok lekérdezése Log Analytics-munkaterületeken, -alkalmazásokon és -erőforrásokon az Azure Monitorban.

Example

Lássunk egy példát. A Stock Prices nevű alkalmazás egy részvény aktuális piaci árát jeleníti meg egy Stock nevű külső API használatával. A Tőzsdei árak alkalmazásnak van egy Stock lap nevű oldala, amelyet az ügyfél webböngészője a segítségével GET /Home/Stocknyit meg. Az alkalmazás HTTP-hívással GET /api/stock/valuelekérdezi a Stock API-t.

Az eredményként kapott telemetriát egy lekérdezés futtatásával elemezheti:

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

Az eredményekben az összes telemetriaelem osztozik a gyökérben operation_Id. Amikor Ajax-hívást kezdeményez a lapról, a rendszer egy új egyedi azonosítót (qJSXU) rendel a függőségi telemetriahoz, és a pageView azonosítóját operation_ParentIdhasználja a rendszer. A kiszolgálókérés ezután az Ajax-azonosítót használja a következőként operation_ParentId: .

elemTípus	név	azonosító	operation_ParentId	művelet_Azonosító
pageView	Készletek oldal	STYz		STYz
függőség	GET /Home/Stock	qJSXU	STYz	STYz
kérelem	GET Kezdőlap/Készlet	KqKwlrSt9PA=	qJSXU	STYz
függőség	GET /api/stock/value	bBrf2L7mm2g=	KqKwlrSt9PA=	STYz

Amikor a hívást GET /api/stock/value egy külső szolgáltatáshoz intézik, ismernie kell a kiszolgáló identitását, hogy megfelelően be tudja állítani a dependency.target mezőt. Ha a külső szolgáltatás nem támogatja a figyelést, target a szolgáltatás állomásnevére van állítva. Például: stock-prices-api.com. Ha azonban a szolgáltatás egy előre definiált HTTP-fejléc visszaadásával azonosítja magát, tartalmazza azt a szolgáltatásidentitást, target amely lehetővé teszi az Application Insights számára, hogy elosztott nyomkövetést hozzon létre a szolgáltatásból származó telemetriai adatok lekérdezésével.

Korrelációs fejlécek a W3C TraceContext használatával

Az Application Insights a W3C Trace-Contextre vált, amely a következőket határozza meg:

• traceparent: A globálisan egyedi műveleti azonosítót és a hívás egyedi azonosítóját hordozza.
• tracestate: Rendszerspecifikus nyomkövetési környezetet hordoz.

Az Application Insights SDK legújabb verziója támogatja a Trace-Context protokollt, de előfordulhat, hogy be kell jelentkeznie. (Az Application Insights SDK által támogatott korábbi korrelációs protokolllal való visszamenőleges kompatibilitás megmarad.)

A korrelációs HTTP protokoll, más néven Request-Id elavult. Ez a protokoll két fejlécet határoz meg:

• Request-Id: A hívás globálisan egyedi azonosítóját hordozza.
• Correlation-Context: Az elosztott nyomkövetési tulajdonságok név-érték párok gyűjteményét hordozza.

Az Application Insights a korrelációs HTTP protokoll bővítményét is meghatározza. Azonnali hívó vagy hívott fél által használt tulajdonságok gyűjteményét név-érték párok Request-Context használatával propagálja. Az Application Insights SDK ezzel a fejléccel állítja be a dependency.target és a request.source mezőket.

A W3C Trace-Context és az Application Insights adatmodelljei a következő módon illeszkednek:

Application Insights	W3C TraceContext (nyomkövetési környezet)
Id és RequestDependency	parent-id
Operation_Id	nyomkövetési azonosító
Operation_ParentId	e span szülő spanjának azonosítója. Ennek a mezőnek üresnek kell lennie, ha gyökérszakaszról van szó.

További információ: Application Insights telemetriai adatmodell.

W3C elosztott nyomkövetés támogatásának engedélyezése

Alapértelmezés szerint az SDK az Application Insights SDK-val létrehozott más alkalmazások vagy szolgáltatások által értelmezett fejléceket küld. A W3C Trace Context fejlécek küldését és fogadását a meglévő AI-fejléceken kívül is engedélyezheti. Ily módon nem szakítja meg a meglévő örökölt szolgáltatásokkal való korrelációt.

A W3C-fejlécek engedélyezése lehetővé teszi az alkalmazás számára, hogy korreláljon más, az Application Insightsban nem használt szolgáltatásokkal, de a W3C-szabványt alkalmazza.

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

Kiterjesztett metrikák

Megjegyzés:

A kiterjesztett natív metrikák küldésének lehetősége az 1.4.0-s verzióban lett hozzáadva.

Ha engedélyezni szeretné a kiterjesztett natív metrikák küldését az alkalmazásból az Azure-ba, telepítse a külön natív metrikák csomagját. Az SDK automatikusan betöltődik, amikor telepítve van, és megkezdi Node.js natív metrikák gyűjtését.

npm install applicationinsights-native-metrics

A natív metrikák csomagja jelenleg automatikusan elvégzi a szemétgyűjtés processzoridejének, az eseményhurok iterációinak és a halomhasználatnak az automatikus gyűjtését.

• Szemétgyűjtés: Az egyes szemétgyűjtési típusokra fordított processzoridő és az egyes típusúak előfordulásainak száma.
• Eseményhurok: Hány léptetés zajlott le, és mennyi CPU-időt használtak fel összesen.
• Halom vs. nonheap: Az alkalmazás memóriahasználatának mennyisége a halomban vagy a nem halomban van.

TelemetryClient API

A TelemetryClient API részletes leírásával kapcsolatban lásd az egyéni eseményekhez és a mérőszámokhoz rendelkezésre álló Application Insights API-t.

Bármilyen kérést, eseményt, metrikát vagy kivételt nyomon követhet az Application Insights ügyfélkódtárával Node.js. Az alábbi példakód a használható API-k közül mutat be néhányat.

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

Függőségek követése

A következő kóddal követheti a függőségeket:

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

Egy példa arra a segédeszközre, amely trackMetric segítségével méri, mennyi ideig tart az eseményhurok ütemezése.

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

Egyéni tulajdonság hozzáadása eseményekhez

A következő kóddal adhat hozzá egyéni tulajdonságot minden eseményhez:

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

HTTP GET-kérések követése

A HTTP GET-kérések manuális nyomon követéséhez használja az alábbi kódot:

Megjegyzés:

• A rendszer alapértelmezés szerint minden kérést nyomon követ. Az automatikus adatgyűjtés letiltásához hívja meg a .setAutoCollectRequests(false)-t, mielőtt meghívná a start()-t.
• A natív beolvasási API-kéréseket a klasszikus Application Insights nem követi automatikusan; manuális függőségkövetésre van szükség.

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

Másik lehetőségként a következő módszerrel követheti nyomon a trackNodeHttpRequest kéréseket:

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

Kiszolgáló indítási idejének követése

A következő kóddal követheti a kiszolgáló indítási idejét:

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

Öblít

Alapértelmezés szerint a telemetriát a rendszer 15 másodpercig puffereli, mielőtt elküldené a betöltési kiszolgálónak. Ha az alkalmazás rövid időtartamú, mint például egy parancssori eszköz, előfordulhat, hogy manuálisan kell ürítenie a pufferelt telemetriát, amikor az alkalmazás leáll appInsights.defaultClient.flush() használatával.

Ha az SDK azt észleli, hogy az alkalmazás összeomlik, az automatikusan meghívja a flush parancsot a(z) appInsights.defaultClient.flush({ isAppCrashing: true }) használatával. Ha a kiürítési opció isAppCrashing van beállítva, az alkalmazásról feltételezhető, hogy rendellenes állapotban van, és nem alkalmas telemetriai adatok küldésére. Ehelyett az SDK az összes pufferelt telemetriát az állandó tárolóba menti, és lehetővé teszi az alkalmazás leállítását. Amikor az alkalmazás újra elindul, megpróbálja elküldeni az állandó tárolóba mentett telemetriát.

Telemetriai adatok feldolgozása és szűrése

.NET

Ebben a szakaszban

• Telemetria szűrése és előfeldolgozása
• Telemetriai inicializálók
• Telemetriai processzor
• Mintavétel
• Adatok bővítése HTTP-ben

Telemetria szűrése és előfeldolgozása

Az SDK-ból való küldés előtt kódot írhat a telemetriai adatok szűréséhez, módosításához vagy bővítéséhez. A feldolgozás a szabványos telemetriai modulokból, például a HTTP-kérések gyűjtéséből és a függőséggyűjtésből küldött adatokat tartalmazza.

• A szűrés módosíthatja vagy elvetheti a telemetriát, mielőtt továbbítanák az SDK-ból, az ITelemetryProcessor implementálása által. Csökkentheti például a telemetriai adatok mennyiségét a robotok kéréseinek kizárásával. A mintavételezéssel ellentétben Ön teljes mértékben szabályozhatja az elküldött vagy elvetett adatokat, de ez az összesített naplókon alapuló metrikákra is hatással van. Az elemek elvetésének módjától függően előfordulhat, hogy elveszíti a kapcsolódó elemek közötti navigálás lehetőségét is.

• Adjon hozzá vagy módosítson tulajdonságokat az alkalmazásából küldött telemetriai adatokhoz egy ITelemetryInitializer megvalósításával. Hozzáadhat például számított értékeket vagy verziószámokat, amelyekkel szűrheti az adatokat a portálon.

• A mintavételezés a statisztikák befolyásolása nélkül csökkenti a telemetriai adatok mennyiségét. Összetartja a kapcsolódó adatpontokat, így a probléma diagnosztizálásakor navigálhat közöttük. A portálon a mintavételezés kompenzálása érdekében megszorozzák az összes értéket.

Megjegyzés:

Az SDK API egyéni események és metrikák küldéséhez használható.

Filtering

Ezzel a technikával közvetlenül szabályozhatja, hogy mi szerepel a telemetriai adatfolyamban, vagy mit zár ki belőle. A szűrés segítségével eltávolíthatja a telemetriai elemeket az Application Insightsba küldött adatokból. A szűrést mintavételezéssel vagy külön is használhatja.

A telemetria szűréséhez írjon egy telemetriai processzort, és regisztrálja azt a TelemetryConfiguration. Minden telemetria a processzoron megy keresztül. Dönthet úgy, hogy elveti a streamből, vagy átadja a lánc következő processzorának. A standard modulokból, például a HTTP-kérelemgyűjtőből és a függőséggyűjtőből származó telemetriai adatok, valamint a saját maga által nyomon követett telemetriai adatok is szerepelnek. Szűrheti például a robotok kéréseivel vagy a sikeres függőségi hívásokkal kapcsolatos telemetriát.

Figyelmeztetés

Az SDK-ból a processzorok használatával küldött telemetriai adatok szűrésével megszűrheti a portálon látható statisztikákat, és megnehezítheti a kapcsolódó elemek követését.

Ehelyett fontolja meg a mintavételezést.

ITelemetryProcessor és ITelemetryInitializer

Mi a különbség a telemetriai processzorok és a telemetriai inicializálók között?

• Vannak átfedések a velük elvégezhető műveletekben. Mindkettő használható a telemetria tulajdonságainak hozzáadására vagy módosítására, bár javasoljuk, hogy inicializálókat használjon erre a célra.
• A telemetriai inicializálók mindig a telemetriai processzorok előtt futnak.
• A telemetriai inicializálók több alkalommal is meghívhatók. Konvenció szerint nem állítottak be olyan tulajdonságot, amely már be lett állítva.
• A telemetriai processzorokkal teljes mértékben lecserélhet vagy elvethet egy telemetriai elemet.
• A rendszer minden regisztrált telemetriai inicializálót meghív minden telemetriai elemhez. A telemetriai processzorok esetében az SDK garantálja az első telemetriai processzor meghívását. Az előző telemetriai processzorok határozzák meg, hogy a többi processzort meghívják-e.
• Telemetriai inicializálókkal bővítheti a telemetriát több tulajdonsággal, vagy felülbírálhat egy meglévőt. Telemetria-feldolgozóval szűrheti ki a telemetriát.

Tulajdonságok hozzáadása/módosítása

Telemetriai inicializálókkal bővítheti a telemetriát további információkkal, vagy felülbírálhatja a standard telemetriai modulok által beállított telemetriai tulajdonságokat.

A webes Application Insights például telemetriát gyűjt a HTTP-kérelmekről. Alapértelmezés szerint az =400 válaszkódú >kéréseket sikertelenként jelöli meg. Ha ehelyett a 400-at szeretné sikeresnek tekinteni, megadhat egy telemetriai inicializálót, amely beállítja a siker tulajdonságot.

Ha telemetriai inicializálót ad meg, a rendszer akkor hívja meg, amikor a Track*() metódusok bármelyikét meghívja. Ez az inicializáló a standard telemetriai modulok által meghívott metódusokat tartalmazza Track() . Ezek a modulok konvenció szerint nem állítottak be olyan tulajdonságot, amelyet egy inicializáló már beállított. A telemetriai inicializálók hívása a telemetriai processzorok meghívása előtt történik, így az inicializálók által végzett összes bővítés látható a processzorok számára.

Telemetriai inicializálók

Ha további információkkal szeretné bővíteni a telemetriát, vagy felül szeretné bírálni a standard telemetriai modulok által beállított telemetriai tulajdonságokat, használjon telemetriai inicializálókat.

A telemetriai inicializálók a telemetria minden elemével együtt elküldik a környezeti tulajdonságokat. A környezettulajdonságok beállításához saját inicializálókat is írhat.

A standard inicializálókat a webes vagy a WindowsServer NuGet-csomagok állítják be:

Inicializáló	Description
AccountIdTelemetryInitializer	Beállítja a tulajdonságot AccountId .
AuthenticatedUserIdTelemetryInitializer	Beállítja a AuthenticatedUserId tulajdonságot a JavaScript SDK által beállított módon.
AzureRoleEnvironmentTelemetryInitializer	RoleName RoleInstance Az Azure futtatókörnyezetből kinyert információkkal frissíti az Device összes telemetriai elem környezetének és tulajdonságainak tulajdonságait.
BuildInfoConfigComponentVersionTelemetryInitializer	Frissíti a Version környezet tulajdonságát az Component összes telemetriai elemhez az MS Build által létrehozott fájlból BuildInfo.config kinyert értékkel.
ClientIpHeaderTelemetryInitializer	Frissíti az IpLocation összes telemetriai elem környezetének tulajdonságát a X-Forwarded-For kérelem HTTP-fejléce alapján.
DeviceTelemetryInitializer	Frissíti a környezet alábbi tulajdonságait az Device összes telemetriai elem esetében: • Type értékre PCvan állítva. • Id annak a számítógépnek a tartományneve, amelyen a webalkalmazás fut. • OemName a WMI használatával a Win32_ComputerSystem.Manufacturer mezőből kinyert értékre van állítva. • Model a WMI használatával a Win32_ComputerSystem.Model mezőből kinyert értékre van állítva. • NetworkType a tulajdonságból NetworkInterface kinyert értékre van állítva. • Language a tulajdonság nevére CurrentCulture van állítva.
DomainNameRoleInstanceTelemetryInitializer	Frissíti a RoleInstance környezet tulajdonságát az Device összes telemetriai elemhez annak a számítógépnek a tartománynevével, amelyen a webalkalmazás fut.
OperationNameTelemetryInitializer	Frissíti az Name összes telemetriai elem tulajdonságát RequestTelemetry és Name tulajdonságát Operation a HTTP-metódus alapján, valamint a kérés feldolgozásához meghívott ASP.NET MVC-vezérlő és művelet nevét.
OperationIdTelemetryInitializer vagy OperationCorrelationTelemetryInitializer	Frissíti az Operation.Id összes nyomon követett telemetriai elem környezeti tulajdonságát, miközben az automatikusan létrehozott RequestTelemetry.Idkéréseket kezeli.
SessionTelemetryInitializer	Frissíti a Id környezet tulajdonságát az Session összes telemetriai elemhez a felhasználó böngészőjében futó JavaScript-rendszerállapot-kód által létrehozott cookie-ból ai_sessionApplicationInsights kinyert értékkel.
SyntheticTelemetryInitializer vagy SyntheticUserAgentTelemetryInitializer	Frissíti az Userösszes követett telemetriai elem, Sessionpéldául a rendelkezésre állási teszt vagy Operation a keresőmotor-robot kéréseinek kezelésekor nyomon követett telemetriai elemek tulajdonságait. Alapértelmezés szerint a Metrikák kezelője nem jelenít meg szintetikus telemetriát. A <Filters> kérések tulajdonságait azonosító készlet.
UserTelemetryInitializer	Frissíti az IdAcquisitionDate összes telemetriai elem környezetét és User tulajdonságait a ai_user felhasználó böngészőjében futó Application Insights JavaScript-eszközkód által létrehozott cookie-ból kinyert értékekkel.
WebTestTelemetryInitializer	Beállítja a rendelkezésre állási tesztekből származó HTTP-kérelmek felhasználói azonosítóját, munkamenet-azonosítóját és szintetikus forrástulajdonságait. A <Filters> kérések tulajdonságait azonosító készlet.

Megjegyzés:

Az Azure Service Fabricben futó .NET-alkalmazásokhoz a NuGet-csomagot is belefoglalhatja Microsoft.ApplicationInsights.ServiceFabric . Ez a csomag tartalmaz egy tulajdonságot FabricTelemetryInitializer , amely Service Fabric-tulajdonságokat ad hozzá a telemetriai elemekhez. További információt a NuGet-csomag által hozzáadott tulajdonságokról a GitHub oldalán talál .

ITelemetryInitializer hozzáadása

Ez a blog egy olyan projektet ír le, amely a függőségekkel kapcsolatos problémákat diagnosztizálja azáltal, hogy automatikusan küld rendszeres pingeket a függőségeknek.

1. Az inicializáló definiálása

   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. Töltse be az inicializálót

ASP.NET

1. lehetőség: Konfiguráció a kódban

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

2. lehetőség: Konfiguráció a ApplicationInsights.config

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

Tekintse meg ezt a mintát részletesebben.

Megjegyzés:

Győződjön meg arról, hogy a applicationinsights.config fájl a kimeneti könyvtárban van, és tartalmazza a legutóbbi módosításokat.

ASP.NET Core

Inicializáló hozzáadása ApplicationInsights.config vagy TelemetryConfiguration.Active használatával nem érvényes ASP.NET Core-alkalmazások esetében.

A ASP.NET Core használatával írt alkalmazások esetében az új telemetriai inicializáló hozzáadása a DependencyInjection tárolóhoz való hozzáadásával történik, ahogy az látható. Végezze el ezt a lépést a Startup.ConfigureServices metódusban.

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

Megjegyzés:

builder.Services.AddSingleton<ITelemetryInitializer, MyCustomTelemetryInitializer>(); egyszerű inicializálókhoz használható. Mások builder.Services.AddSingleton(new MyCustomTelemetryInitializer() { fieldName = "myfieldName" }); számára kötelező.

Telemetriai inicializálók eltávolítása

Alapértelmezés szerint telemetriai inicializálók vannak jelen. Az összes vagy adott telemetriai inicializáló eltávolításához használja a következő mintakódot .

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

Feldolgozói szolgáltatás

Inicializáló hozzáadása ApplicationInsights.config vagy TelemetryConfiguration.Active használatával nem érvényes a Worker Service SDK esetén.

A Worker Service használatával írt alkalmazásokhoz új telemetriai inicializálót úgy adhatunk hozzá, hogy beillesztjük a DependencyInjection tárolóba, ahogyan az látható. Végezze el ezt a lépést a Startup.ConfigureServices metódusban.

    using Microsoft.ApplicationInsights.Extensibility;

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

Telemetriai inicializálók eltávolítása

Alapértelmezés szerint telemetriai inicializálók vannak jelen. Az összes vagy adott telemetriai inicializáló eltávolításához használja a következő mintakódot .

   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élda ITelemetryInitializers (telemetria inicializáló)

Egyéni tulajdonság hozzáadása

Az alábbi példa inicializáló minden nyomon követett telemetriaadathoz hozzáad egy egyéni tulajdonságot.

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

Felhőbeli szerepkörnév és felhőbeli szerepkörpéldány hozzáadása

1. lépés: Egyéni TelemetryInitializer írása

Az alábbi inicializáló minden nyomon követett telemetriára beállítja a felhőbeli szerepkör nevét.

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

2. lépés: Inicializáló betöltése a TelemetryConfiguration szolgáltatásba

ASP.NET

A ApplicationInsights.config fájlban:

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

A ASP.NET webalkalmazások másik módszere az inicializáló példányosítása a kódban. Az alábbi példa a Global.aspx.cs fájlban lévő kódot mutatja be:

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

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

ASP.NET Core

Új TelemetryInitializer példány hozzáadásához tegye be a Dependency Injection konténerbe. Az alábbi példa ezt a megközelítést mutatja be. Adja hozzá ezt a kódot a ConfigureServices metódusának az Startup.cs osztályban.

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

A földrajzi helyleképezésekhez használt ügyfél IP-címének szabályozása

Az alábbi minta inicializáló beállítja az ügyfél IP-címét, amelyet az ügyfélcsatorna IP-címe helyett geolokációs leképezéshez használnak a telemetriai betöltés során.

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

Telemetriai feldolgozók

A telemetriai processzorok szűrhetik és módosíthatják az egyes telemetriai elemeket, mielőtt az SDK-ból a portálra küldené őket.

Megvalósít ITelemetryProcessor

A telemetriai processzorok feldolgozási láncot hoznak létre. Amikor létrehoz egy telemetriai processzort, a lánc következő processzorára fog hivatkozni. Amikor egy telemetriai adatpontot átad a folyamatmetódusnak, elvégzi a munkáját, majd meghívja (vagy nem hívja meg) a lánc következő telemetriai feldolgozóját.

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

Add hozzá a processzorod

ASP.NET

Szúrja be ezt a kódrészletet aApplicationInsights.config:

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

A .config fájlból sztringértékeket adhat át úgy, hogy nyilvánosan elnevezett tulajdonságokat ad meg az osztályban.

Figyelmeztetés

Ügyeljen arra, hogy a .config fájlban szereplő típusnév és tulajdonságnevek megegyeznek a kód osztály- és tulajdonságnevével. Ha a .config fájl nem létező típusra vagy tulajdonságra hivatkozik, előfordulhat, hogy az SDK nem küld telemetriai adatokat.

Másik lehetőségként inicializálhatja a szűrőt a kódban. Egy megfelelő inicializálási osztályban, például az AppStart osztályban, Global.asax.cs helyezze be a processzort a láncba:

Megjegyzés:

Az alábbi kódminta elavult, de az utókor számára itt érhető el. Fontolja meg az OpenTelemetria használatának első lépéseit , vagy az OpenTelemetryre való migrálást.

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

Az ezt követően létrehozott telemetriai kliensek a processzoraidat használják.

Adaptív mintavételezési telemetriafeldolgozó (2.0.0-béta3-tól)

Ez a funkció alapértelmezés szerint engedélyezve van. Ha az alkalmazás jelentős telemetriát küld, ez a processzor eltávolít belőle néhányat.

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

A paraméter megadja az algoritmus által elérni kívánt célt. Az SDK minden példánya egymástól függetlenül működik. Ha tehát a kiszolgáló több gépből álló fürt, a rendszer ennek megfelelően megszorozza a telemetriai adatok tényleges mennyiségét.

További információ a mintavételezésről.

Rögzített sebességű mintavételezési telemetriafeldolgozó (2.0.0-béta1-től)

Van egy szabványos mintavételezési telemetriai processzor is (2.0.1-től):

    <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

Megjegyzés:

Nem érvényes a processzor ApplicationInsights.config vagy TelemetryConfiguration.Active alkalmazása ASP.NET Core-alkalmazásokban, vagy ha a Microsoft.ApplicationInsights.WorkerService SDK-t használja.

A ASP.NET Core esetében egy új telemetriai processzor hozzáadása a bővítménymetódus AddApplicationInsightsTelemetryProcessorhasználatával történik, IServiceCollection ahogy az látható. Ezt a metódust a ConfigureServices metódusban hívja meg a Startup.cs osztály.

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

Az ASP.NET Core-ban paramétereket igénylő telemetriai processzorok regisztrálásához hozzon létre egy egyéni osztályt, amely implementálja az ITelemetryProcessorFactoryt. Hívja meg a konstruktort a kívánt paraméterekkel a Létrehozás metódusban, majd használja az AddSingleton<ITelemetryProcessorFactory, MyTelemetryProcessorFactory>() parancsot.

Feldolgozói szolgáltatás

Megjegyzés:

Nem érvényes a processzor ApplicationInsights.config vagy TelemetryConfiguration.Active alkalmazása ASP.NET Core-alkalmazásokban, vagy ha a Microsoft.ApplicationInsights.WorkerService SDK-t használja.

A Worker Service esetében egy új telemetriai processzor hozzáadása a bővítménymetódus AddApplicationInsightsTelemetryProcessorhasználatával történik, IServiceCollection ahogy az látható. Ezt a metódust a ConfigureServices metódusban hívja meg a Startup.cs osztály.

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

Példaszűrők

Szintetikus kérések

Szűrje ki a robotokat és a webes teszteket. Bár a Metrics Explorer lehetővé teszi a szintetikus források szűrését, ez a lehetőség csökkenti a forgalmat és a betöltési méretet azáltal, hogy magát az SDK-t szűri.

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

Sikertelen hitelesítés

Szűrje ki azokat a kéréseket, amelyek "401" válaszokat kapnak.

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

Gyors távoli függőségi hívások kiszűrése

Ha csak lassú hívásokat szeretne diagnosztizálni, szűrje ki a gyors hívásokat.

Megjegyzés:

Ez a szűrés torzítja a portálon látható statisztikákat.

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

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

Mintavételezés

Ha szeretné megtudni, hogyan konfigurálhatja a mintavételezést ASP.NET és ASP.NET Core-alkalmazásokhoz, olvassa el a Mintavételezés az Application Insightsban című témakört.

Feldolgozói szolgáltatás

Az Application Insights SDK for Worker Service támogatja a rögzített sebességű mintavételezést és az adaptív mintavételezést is. Az adaptív mintavételezés alapértelmezés szerint engedélyezve van. A mintavételezés az EnableAdaptiveSampling beállításával tiltható le.

Más mintavételezési beállítások konfigurálásához használja az alábbi példát:

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

Adatok bővítése HTTP-ben

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

Ebben a szakaszban

• Telemetria szűrése és előfeldolgozása
• Telemetriai inicializálók
• Telemetriai processzor
• Mintavétel
• Több szerepkör többkomponensű alkalmazásokhoz

Telemetria szűrése és előfeldolgozása

Az SDK-ból való küldés előtt kódot írhat a telemetriai adatok szűréséhez, módosításához vagy bővítéséhez. A feldolgozás a szabványos telemetriai modulokból, például a HTTP-kérések gyűjtéséből és a függőséggyűjtésből küldött adatokat tartalmazza.

• A szűrés módosíthatja vagy elvetheti a telemetriát, mielőtt továbbítanák az SDK-ból, az ITelemetryProcessor implementálása által. Csökkentheti például a telemetriai adatok mennyiségét a robotok kéréseinek kizárásával. A mintavételezéssel ellentétben Ön teljes mértékben szabályozhatja az elküldött vagy elvetett adatokat, de ez az összesített naplókon alapuló metrikákra is hatással van. Az elemek elvetésének módjától függően előfordulhat, hogy elveszíti a kapcsolódó elemek közötti navigálás lehetőségét is.

• Adjon hozzá vagy módosítson tulajdonságokat az alkalmazásából küldött telemetriai adatokhoz egy ITelemetryInitializer megvalósításával. Hozzáadhat például számított értékeket vagy verziószámokat, amelyekkel szűrheti az adatokat a portálon.

• A mintavételezés a statisztikák befolyásolása nélkül csökkenti a telemetriai adatok mennyiségét. Összetartja a kapcsolódó adatpontokat, így a probléma diagnosztizálásakor navigálhat közöttük. A portálon a mintavételezés kompenzálása érdekében megszorozzák az összes értéket.

Megjegyzés:

Az SDK API egyéni események és metrikák küldéséhez használható.

Filtering

Ezzel a technikával közvetlenül szabályozhatja, hogy mi szerepel a telemetriai adatfolyamban, vagy mit zár ki belőle. A szűrés segítségével eltávolíthatja a telemetriai elemeket az Application Insightsba küldött adatokból. A szűrést mintavételezéssel vagy külön is használhatja.

A telemetria szűréséhez írjon egy telemetriai processzort, és regisztrálja azt a TelemetryConfiguration. Minden telemetria a processzoron megy keresztül. Dönthet úgy, hogy elveti a streamből, vagy átadja a lánc következő processzorának. A standard modulokból, például a HTTP-kérelemgyűjtőből és a függőséggyűjtőből származó telemetriai adatok, valamint a saját maga által nyomon követett telemetriai adatok is szerepelnek. Szűrheti például a robotok kéréseivel vagy a sikeres függőségi hívásokkal kapcsolatos telemetriát.

Figyelmeztetés

Az SDK-ból a processzorok használatával küldött telemetriai adatok szűrésével megszűrheti a portálon látható statisztikákat, és megnehezítheti a kapcsolódó elemek követését.

Ehelyett fontolja meg a mintavételezést.

ITelemetryProcessor és ITelemetryInitializer

Mi a különbség a telemetriai processzorok és a telemetriai inicializálók között?

• Vannak átfedések a velük elvégezhető műveletekben. Mindkettő használható a telemetria tulajdonságainak hozzáadására vagy módosítására, bár javasoljuk, hogy inicializálókat használjon erre a célra.
• A telemetriai inicializálók mindig a telemetriai processzorok előtt futnak.
• A telemetriai inicializálók több alkalommal is meghívhatók. Konvenció szerint nem állítottak be olyan tulajdonságot, amely már be lett állítva.
• A telemetriai processzorokkal teljes mértékben lecserélhet vagy elvethet egy telemetriai elemet.
• A rendszer minden regisztrált telemetriai inicializálót meghív minden telemetriai elemhez. A telemetriai processzorok esetében az SDK garantálja az első telemetriai processzor meghívását. Az előző telemetriai processzorok határozzák meg, hogy a többi processzort meghívják-e.
• Telemetriai inicializálókkal bővítheti a telemetriát több tulajdonsággal, vagy felülbírálhat egy meglévőt. Telemetria-feldolgozóval szűrheti ki a telemetriát.

Tulajdonságok hozzáadása/módosítása

Telemetriai inicializálókkal bővítheti a telemetriát további információkkal, vagy felülbírálhatja a standard telemetriai modulok által beállított telemetriai tulajdonságokat.

A webes Application Insights például telemetriát gyűjt a HTTP-kérelmekről. Alapértelmezés szerint az =400 válaszkódú >kéréseket sikertelenként jelöli meg. Ha ehelyett a 400-at szeretné sikeresnek tekinteni, megadhat egy telemetriai inicializálót, amely beállítja a siker tulajdonságot.

Ha telemetriai inicializálót ad meg, a rendszer akkor hívja meg, amikor a Track*() metódusok bármelyikét meghívja. Ez az inicializáló a standard telemetriai modulok által meghívott metódusokat tartalmazza Track() . Ezek a modulok konvenció szerint nem állítottak be olyan tulajdonságot, amelyet egy inicializáló már beállított. A telemetriai inicializálók hívása a telemetriai processzorok meghívása előtt történik, így az inicializálók által végzett összes bővítés látható a processzorok számára.

Telemetriai feldolgozók

Az összegyűjtött adatokat a telemetriai processzorok használatával feldolgozhatja és szűrheti, mielőtt azokat megőrzésre küldené. A telemetriai processzorokat egyenként, a hozzáadásuk sorrendjében hívják meg, mielőtt a telemetriai elemet elküldik a felhőbe.

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

Ha egy telemetriafeldolgozó visszaadja false, a rendszer nem küldi el a telemetriai elemet.

Minden telemetriai processzor megkapja a telemetriai adatokat és annak borítékját a vizsgálathoz és a módosításhoz. Környezeti objektumot is kapnak. Ennek az objektumnak a tartalmát a paraméter határozza meg, contextObjects amikor manuálisan nyomon követett telemetriai nyomkövetési metódust hív meg. Az automatikusan gyűjtött telemetriai adatok esetében ez az objektum a rendelkezésre álló kérelemadatokkal és a kérések által appInsights.getCorrelationContext() biztosított állandó tartalommal van kitöltve (ha engedélyezve van az automatikus függőségi korreláció).

A telemetriai processzor TypeScript típusa a következő:

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

Például az alábbiak szerint írható és adható hozzá egy processzor, amely eltávolítja a veremkövetési adatokat a kivételekből.

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

Felhőbeli szerepkörnév és felhőbeli szerepkörpéldány hozzáadása

Felhőbeli szerepkör nevének beállítása közvetlen környezetcímkék használatával:

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

Felhőbeli szerepkör nevének beállítása telemetriai processzorral:

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

Mintavételezés

Alapértelmezés szerint az SDK az összes összegyűjtött adatot elküldi az Application Insights szolgáltatásnak. Ha engedélyezni szeretné a mintavételezést az adatok mennyiségének csökkentése érdekében, állítsa be az samplingPercentageconfig ügyfél objektumának mezőjét. A 100-ra (az alapértelmezett értékre) való beállítás samplingPercentage azt jelenti, hogy minden adat el lesz küldve, a 0 pedig azt jelenti, hogy semmi sem lesz elküldve.

Ha automatikus korrelációt használ, a rendszer az egyetlen kérelemhez társított összes adatot egységként tartalmazza vagy kizárja.

A mintavételezés engedélyezéséhez adja hozzá a következőhöz hasonló kódot:

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

Több szerepkör többkomponensű alkalmazásokhoz

Bizonyos esetekben előfordulhat, hogy az alkalmazás több összetevőből áll, amelyeket ugyanazzal a kapcsolati sztringgel szeretne konfigurálni. Ezeket az összetevőket továbbra is különálló egységekként szeretné látni a portálon, úgy, mintha külön kapcsolati karaktersort használnának. Példaként külön csomópontokat láthat az Alkalmazástérképen. Manuálisan kell konfigurálnia a mezőt, RoleName hogy megkülönböztesse az egyik összetevő telemetriáját a többi összetevőtől, amelyek adatokat küldenek az Application Insights-erőforrásnak.

A mező beállításához használja a RoleName következő kódot:

const appInsights = require("applicationinsights");
appInsights.setup("<connection_string>");
appInsights.defaultClient.context.tags[appInsights.defaultClient.context.keys.cloudRole] = "MyRoleName";
appInsights.start();

SDK konfigurálása

.NET

Ebben a szakaszban

• Telemetriai csatornák
• Telemetriai modulok
• Telemetriai adatok letiltása
• Kapcsolati karakterlánc
• ApplicationId-szolgáltató

Az Alapértelmezett konfiguráció módosításához testre szabhatja az Application Insights SDK-t ASP.NET, ASP.NET Core és Worker Service szolgáltatáshoz.

ASP.NET

Az Application Insights .NET SDK számos NuGet-csomagból áll. Az alapcsomag biztosítja az API-t, amely telemetriát küld az Application Insightsnak. További csomagok telemetriai modulokat és inicializálókat biztosítanak az alkalmazásból és környezetéből származó telemetriai adatok automatikus nyomon követéséhez. A konfigurációs fájl módosításával engedélyezheti vagy letilthatja a telemetriai modulokat és inicializálókat. Néhány paramétert is beállíthat.

A konfigurációs fájl neve vagy ApplicationInsights.configneve ApplicationInsights.xml . A név az alkalmazás típusától függ. A rendszer automatikusan hozzáadja a projekthez az SDK legtöbb verziójának telepítésekor.

Alapértelmezés szerint ha azApplication Insights telemetriát> Visual Studio-sablonprojektek automatizált felületét használja, a ApplicationInsights.config fájl a projekt gyökérmappájában jön létre. A fordítás után a rendszer átmásolja a tárolómappába. Az Application Insights-ügynök egy IIS-kiszolgálón is hozzáadja egy webalkalmazáshoz.

Fontos

A konfigurációs fájl figyelmen kívül lesz hagyva, ha az Azure-webhelyek bővítményét vagy az Azure-beli virtuális gépek és az Azure virtuálisgép-méretezési csoportok bővítményét használja.

A weblap SDK-jának szabályozásához nincs megfelelő fájl.

ASP.NET Core

Az ASP.NET Core-alkalmazásokban az összes konfigurációs módosítás a ConfigureServices()Startup.cs osztály metódusában történik, kivéve, ha másként van irányítva.

Megjegyzés:

Az ASP.NET Core-alkalmazásokban a konfiguráció módosítással történő módosítása TelemetryConfiguration.Active nem támogatott.

Feldolgozói szolgáltatás

A Worker Service SDK által használt alapértelmezett TelemetryConfiguration beállítás hasonló az ASP.NET vagy ASP.NET Core alkalmazásokban használt automatikus konfigurációhoz, a telemetriai HttpContextadatok dúsításához használt telemetriai inicializálók nélkül.

Az Application Insights SDK for Worker Service testreszabásával módosíthatja az alapértelmezett konfigurációt. Az Application Insights ASP.NET Core SDK felhasználói valószínűleg ismerik, hogyan lehet módosítani a konfigurációt az ASP.NET Core beépített függőséginjektálásával. A Worker Service SDK is hasonló elveken alapul. Végezze el a szakasz szinte összes konfigurációs módosítását a ConfigureServices() megfelelő metódusok IServiceCollectionmeghívásával a következő szakaszban leírtak szerint.

Megjegyzés:

A Worker Service SDK használatakor a konfiguráció módosítással TelemetryConfiguration.Active történő módosítása nem támogatott, és a módosítások nem jelennek meg.

Telemetriai csatornák

A telemetriai csatornák az Application Insights SDK-k szerves részét képezik. Kezelik a telemetria pufferelését és átvitelét az Application Insights szolgáltatásba. Az SDK-k .NET és .NET Core verziói két beépített telemetriai csatornával rendelkeznek: InMemoryChannel és ServerTelemetryChannel. Ez a szakasz ismerteti az egyes csatornákat, és bemutatja, hogyan szabhatja testre a csatorna viselkedését.

Megjegyzés:

A gyakori kérdések (GYIK) áttekintéséhez tekintse meg a telemetriai csatornák gyakori kérdéseit

Mik azok a telemetriai csatornák?

A telemetriai csatornák feladata a telemetriai elemek pufferelése és elküldése az Application Insights szolgáltatásba, ahol a rendszer lekérdezésre és elemzésre tárolja őket. A telemetriacsatorna bármely olyan osztály, amely megvalósítja az interfészt Microsoft.ApplicationInsights.ITelemetryChannel .

A Send(ITelemetry item) telemetriai csatorna metódusának meghívása az összes telemetriai inicializáló és telemetriafeldolgozó meghívása után történik. A telemetriai processzor által elvetett elemek tehát nem érik el a csatornát. A Send() metódus általában nem küldi el az elemeket a háttérbe azonnal. Általában puffereli őket a memóriában, és kötegekben küldi őket a hatékony átvitel érdekében.

Kerülje a hívásokat Flush() , kivéve, ha kritikus fontosságú a pufferelt telemetriai adatok azonnali elküldése. Csak olyan helyzetekben használja, mint az alkalmazások leállítása, a kivételkezelés, vagy rövid élettartamú folyamatok, például háttérfeladatok vagy parancssori eszközök használata esetén. Webalkalmazásokban vagy hosszan futó szolgáltatásokban az SDK automatikusan kezeli a telemetriai küldést. A szükségtelen hívás Flush() teljesítményproblémát okozhat.

Az élő metrikák streamje egy egyéni csatornával is rendelkezik, amely a telemetriai adatok élő streamelésének a szabályozását biztosítja. Ez a csatorna független a normál telemetriai csatornától, és ez a dokumentum nem vonatkozik rá.

Beépített telemetriai csatornák

Az Application Insights .NET és a .NET Core SDK-k két beépített csatornával szállnak le:

• InMemoryChannel: Egy egyszerűsített csatorna, amely puffereli a memóriában lévő elemeket, amíg el nem küldi őket. A rendszer az elemeket a memóriában puffereli, és 30 másodpercenként egyszer üríti ki, vagy amikor 500 elemet pufferel. Ez a csatorna minimális megbízhatósági garanciát nyújt, mert nem próbál újra telemetriát küldeni meghibásodás után. Ez a csatorna a lemezen lévő elemeket sem tárolja. Az alkalmazás leállítása után tehát a nem elküldött elemek végleg elvesznek, akár kecses, akár nem. Ez a csatorna egy Flush() metódust implementál, amellyel a memóriában lévő telemetriai elemeket szinkron módon kényszerítheti ki. Ez a csatorna kiválóan alkalmas rövid ideig futó alkalmazásokhoz, ahol a szinkron öblítés ideális.

  Ez a csatorna a nagyobb Microsoft.ApplicationInsights NuGet-csomag része, és ez az alapértelmezett csatorna, amelyet az SDK akkor használ, ha nincs más konfigurálva.

• ServerTelemetryChannel: Egy fejlettebb csatorna, amely újrapróbálkozési szabályzatokkal rendelkezik, és képes adatokat tárolni egy helyi lemezen. Ez a csatorna újrapróbálkozza a telemetriai adatok küldését átmeneti hibák esetén. Ez a csatorna helyi lemeztárolót is használ a lemezen lévő elemek hálózati kimaradások vagy magas telemetriai kötetek során történő tárolásához. Az újrapróbálkozások és a helyi lemeztárolás miatt ez a csatorna megbízhatóbbnak minősül. Minden éles forgatókönyvhöz ajánljuk. Ez a csatorna a hivatalos dokumentációnak megfelelően konfigurált ASP.NET és ASP.NET Core-alkalmazások alapértelmezett csatornája. Ez a csatorna hosszú ideig futó folyamatokkal rendelkező kiszolgálói forgatókönyvekhez van optimalizálva. A Flush() csatorna által implementált metódus nem szinkron.

  Ez a csatorna a Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel NuGet csomagként lesz szállítva, és automatikusan be lesz szerezve a Microsoft.ApplicationInsights.Web vagy a Microsoft.ApplicationInsights.AspNetCore NuGet csomag használatakor.

Telemetriacsatorna konfigurálása

A telemetriai csatornát úgy konfigurálhatja, hogy az aktív telemetriai konfigurációra állítja. Az ASP.NET alkalmazások esetében a konfiguráció magában foglalja a telemetriai csatornapéldány TelemetryConfiguration.Active beállítását vagy módosítását ApplicationInsights.config. Az ASP.NET Core-alkalmazások esetében a konfiguráció magában foglalja a csatorna hozzáadását a függőséginjektálási tárolóhoz.

Az alábbi szakaszok példákat mutatnak be a csatorna beállításának StorageFolder konfigurálására különböző alkalmazástípusokban. StorageFolder csak az egyik konfigurálható beállítás. A konfigurációs beállítások teljes listájáért tekintse meg a cikk későbbi, Csatornák konfigurálható beállításai szakaszát.

ASP.NET

1. lehetőség: Konfiguráció a kódban

Az alábbi kód egy ServerTelemetryChannel egyéni helyre beállított példányt StorageFolder állít be. Adja hozzá ezt a kódot az alkalmazás elején, általában a Application_Start() Global.aspx.cs metódusában.

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

2. lehetőség: Konfiguráció a ApplicationInsights.config

A ApplicationInsights.config következő szakasza az ServerTelemetryChannel egyéni helyre beállított csatornát StorageFolder mutatja be:

    <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

Módosítsa az ConfigureServices osztály metódusát az Startup.cs itt látható módon:

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

Fontos

A csatorna használata TelemetryConfiguration.Active nem támogatott ASP.NET Core-alkalmazások esetében.

A ServerTelemetryChannel felülírása

Az alapértelmezett telemetriai csatorna a .ServerTelemetryChannel Az alábbi példa bemutatja, hogyan bírálhatja felül.

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

Megjegyzés:

Ha ki szeretné üríteni a puffert, tekintse meg az adatok kiürítését. Előfordulhat például, hogy ki kell ürítenie a puffert, ha az SDK-t egy leállított alkalmazásban használja.

Feldolgozói szolgáltatás

Az alapértelmezett csatorna a következő ServerTelemetryChannel: . A következő példa szerint felülbírálhatja:

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

Konfiguráció a konzolalkalmazások kódjában

Konzolalkalmazások esetén a kód a .NET és a .NET Core esetében is ugyanaz:

var serverTelemetryChannel = new ServerTelemetryChannel();
serverTelemetryChannel.StorageFolder = @"d:\temp\applicationinsights";
serverTelemetryChannel.Initialize(TelemetryConfiguration.Active);
TelemetryConfiguration.Active.TelemetryChannel = serverTelemetryChannel;

A ServerTelemetryChannel működési adatai

ServerTelemetryChannel tárolja az érkező elemeket egy memóriabeli pufferben. Az elemek szerializálva, tömörítve és tárolva vannak egy Transmission példányban 30 másodpercenként, vagy 500 elem pufferelésekor. Egyetlen Transmission példány legfeljebb 500 elemet tartalmaz, és olyan telemetriai kötegeket jelöl, amelyeket egyetlen HTTPS-híváson keresztül küldenek az Application Insights szolgáltatásnak.

Alapértelmezés szerint legfeljebb 10 Transmission példány küldhető párhuzamosan. Ha a telemetria gyorsabb ütemben érkezik, vagy ha a hálózat vagy az Application Insights háttérrendszere lassú, Transmission a példányok a memóriában vannak tárolva. A memóriabeli Transmission puffer alapértelmezett kapacitása 5 MB. A memóriabeli kapacitás túllépésekor Transmission a rendszer a példányokat legfeljebb 50 MB-os korlátig tárolja a helyi lemezen.

Transmission a példányok a helyi lemezen is tárolódnak, ha hálózati problémák merülnek fel. Csak a helyi lemezen tárolt elemek maradnak túl egy alkalmazás összeomlásán. A rendszer minden alkalommal elküldi őket, amikor az alkalmazás újra elindul. Ha a hálózati problémák továbbra is fennállnak, ServerTelemetryChannel egy exponenciális, 10 másodperc és 1 óra közötti visszalépési logikát használ, mielőtt újrapróbálkozna a telemetriai adatok küldésére.

Konfigurálható beállítások a csatornákban

Az egyes csatornák konfigurálható beállításainak teljes listáját a következő témakörben találja:

• InMemoryChannel
• ServerTelemetryChannel

Az alábbiakban a leggyakrabban használt beállításokat ServerTelemetryChannelhasználjuk:

• MaxTransmissionBufferCapacity: A csatorna által a memóriában lévő átvitelek pufferelésére használt maximális memóriamennyiség bájtban. A kapacitás elérésekor a rendszer közvetlenül a helyi lemezen tárolja az új elemeket. Az alapértelmezett érték 5 MB. A magasabb érték beállítása kevesebb lemezhasználatot eredményez, de ne feledje, hogy a memóriában lévő elemek elvesznek, ha az alkalmazás összeomlik.

• MaxTransmissionSenderCapacity: Az Application Insightsba egyszerre küldött példányok maximális száma Transmission . Az alapértelmezett érték 10. Ez a beállítás magasabb számra konfigurálható, amelyet nagy mennyiségű telemetriai adat létrehozásakor javasoljuk. A nagy mennyiség általában terhelésteszteléskor vagy a mintavétel kikapcsolásakor fordul elő.

• StorageFolder: A csatorna által az elemek lemezre való tárolására használt mappa, szükség szerint. Windows rendszerben %LOCALAPPDATA% vagy %TEMP% használható, ha nincs más elérési út explicit módon megadva. A Windowstól eltérő környezetekben alapértelmezés szerint a következő helyek vannak használatban (sorrendben): %TMPDIR%, /var/tmp/ vagy /tmp/.

Melyik csatornát érdemes használni?

A legtöbb olyan éles forgatókönyvhöz ajánljuk ServerTelemetryChannel , amelyek hosszú ideig futó alkalmazásokat is érintenek. A telemetriai adatok kiürítésével kapcsolatos további információkért olvassa el a használatával Flush()kapcsolatos tudnivalókat.

Mikor érdemes a Flush() et használni?

A Flush() metódus azonnal elküldi a pufferelt telemetriát. Ezt azonban csak bizonyos helyzetekben szabad használni.

Használja a Flush()-t, amikor:

• Az alkalmazás leáll, és meg szeretné győződni arról, hogy a telemetriát a rendszer a kilépés előtt elküldi.
• Kivételkezelőben van, és garantálnia kell a telemetriai adatok kézbesítését.
• Egy rövid életű folyamatot ír, például egy háttérfeladatot vagy egy parancssori felületi eszközt, amely gyorsan kilép.

Kerülje a hosszú ideig futó alkalmazások, például a webszolgáltatások használatát Flush() . Az SDK automatikusan kezeli a pufferelést és az átvitelt. A szükségtelen hívás Flush() teljesítményproblémákhoz vezethet, és nem garantálja az összes adat küldését, különösen akkor, ha a használat ServerTelemetryChannelsorán nem öblítik szinkronban.

Telemetriai modulok

Az Application Insights automatikusan gyűjti az adott számítási feladatok telemetriáját anélkül, hogy manuális nyomon követést kellene megkövetelnie a felhasználótól.

Alapértelmezés szerint a következő automatikus gyűjteménymodulok vannak engedélyezve. Letilthatja vagy konfigurálhatja őket, hogy módosítsák az alapértelmezett viselkedésüket.

ASP.NET

Minden telemetriai modul egy adott adattípust gyűjt, és az alapvető API használatával küldi el az adatokat. A modulokat különböző NuGet-csomagok telepítik, amelyek a szükséges sorokat is hozzáadják a .config fájlhoz.

Area	Description
Kérések nyomon követése	A bejövő webes kérések kéréstelemetria (válaszidő, eredménykód) gyűjtése. Modul:Microsoft.ApplicationInsights.Web.RequestTrackingTelemetryModule NuGet:Microsoft.ApplicationInsights.Web
Függőségek nyomon követése	Telemetriát gyűjt a kimenő függőségekről (HTTP-hívások, SQL-hívások). Az IIS használatához telepítse az Application Insights-ügynököt. Egyéni függőségkövetést is írhat a TrackDependency API használatával. Támogatja az autoinstrumentációt az App Service és a virtuális gépek és a virtuális gép-méretezési csoportok felügyeletével. Modul:Microsoft.ApplicationInsights.DependencyCollector.DependencyTrackingTelemetryModule NuGet:Microsoft.ApplicationInsights.DependencyCollector
Teljesítményszámlálók	Összegyűjti a Windows teljesítményszámlálóit (CPU, memória, hálózati terhelés az IIS-telepítésekből). Adja meg, hogy mely számlálók (beleértve az egyéni számlálókat is). További információ: Rendszerteljesítmény-számlálók gyűjtése. Modul:Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.PerformanceCollectorModule NuGet:Microsoft.ApplicationInsights.PerfCounterCollector
Eseményszámlálók	Gyűjti a .NET EventCounterst. Ajánlott ASP.NET Core és platformfüggetlen windowsos perf számlálók helyett. Modul:EventCounterCollectionModule (SDK ≥ 2.8.0)
Élő metrikák (QuickPulse)	Telemetriát gyűjt az Élő metrikák panelhez. Modul:QuickPulseTelemetryModule
Szívverések (App Service)	Szívveréseket és egyéni metrikákat küld az App Service-környezethez. Modul:AppServicesHeartbeatTelemetryModule
Szívverések (virtuális gépek és virtuálisgép-méretezési csoportok)	Szívveréseket és egyéni metrikákat küld az Azure-beli virtuálisgép-környezethez. Modul:AzureInstanceMetadataTelemetryModule
Diagnosztikai telemetria	Hibajelentések az Application Insights rendszerállapotkódjában (például hiányzó számlálók, ITelemetryInitializer kivételek). A nyomkövetési telemetria megjelenik a Diagnosztikai keresésben. Modul:Microsoft.ApplicationInsights.Extensibility.Implementation.Tracing.DiagnosticsTelemetryModule NuGet:Microsoft.ApplicationInsights Jegyzet: Ha csak ezt a csomagot telepíti, a ApplicationInsights.config fájl nem jön létre automatikusan.
Fejlesztői mód (hibakereső csatolva)	Kényszeríti TelemetryChannel az elemek azonnali küldését, amikor a hibakereső csatlakoztatva van. Csökkenti a késést, de növeli a processzor-/hálózati terhelést. Modul:Microsoft.ApplicationInsights.WindowsServer.DeveloperModeWithDebuggerAttachedTelemetryModule NuGet:Application Insights Windows Server
Kivételkövetés (web)	Nyomon követi a nem kezelt kivételeket a webalkalmazásokban. Lásd : Hibák és kivételek. Modul:Microsoft.ApplicationInsights.Web.ExceptionTrackingTelemetryModule NuGet:Microsoft.ApplicationInsights.Web
Kivételkövetés (Nem figyelt/Kezeletlen)	Nyomon követi a munkavégző szerepkörök, a Windows-szolgáltatások és a konzolalkalmazások nem figyelt tevékenység-kivételeket és kezeletlen kivételeket. Modulok:  • Microsoft.ApplicationInsights.WindowsServer.UnobservedExceptionTelemetryModule  • Microsoft.ApplicationInsights.WindowsServer.UnhandledExceptionTelemetryModule NuGet:Microsoft.ApplicationInsights.WindowsServer
EventSource-nyomkövetés	Konfigurált EventSource-eseményeket küld az Application Insightsnak nyomkövetésként. Modul:Microsoft.ApplicationInsights.EventSourceListener.EventSourceTelemetryModule NuGet:Microsoft.ApplicationInsights.EventSourceListener
ETW gyűjtő	Konfigurált ETW-szolgáltatói eseményeket küld az Application Insightsnak nyomkövetésként. Modul:Microsoft.ApplicationInsights.EtwCollector.EtwCollectorTelemetryModule NuGet:Microsoft.ApplicationInsights.EtwCollector
Core API (nem modul)	Az egyéb telemetriai összetevők és az egyéni telemetriai adatok által használt core API. Modul:Microsoft.ApplicationInsights package NuGet:Microsoft.ApplicationInsights Jegyzet: Ha csak ezt a csomagot telepíti, a ApplicationInsights.config fájl nem jön létre automatikusan.

ASP.NET Core

Area	Description
Kérések nyomon követése	Beépített kéréskövetés ASP.NET Core Application Insights-integrációval. Modul:Nincs külön modulosztály. NuGet:Microsoft.ApplicationInsights.AspNetCore
Függőségek nyomon követése	Függőséggyűjtőn keresztül. NuGet:Microsoft.ApplicationInsights.DependencyCollector
Teljesítményszámlálók	Csak Windows rendszeren! Platformfüggetlen használat EventCounterCollectionModule esetén (lásd a következő sort). NuGet:Microsoft.ApplicationInsights.PerfCounterCollector
Eseményszámlálók	Gyűjti a .NET EventCounterst. Ajánlott ASP.NET Core és platformfüggetlen windowsos perf számlálók helyett. Modul:EventCounterCollectionModule (SDK 2.8.0 és újabb) NuGet:Microsoft.ApplicationInsights.EventCounterCollector
Élő metrikák (QuickPulse)	Az ASP.NET Core Application Insights-integrációban engedélyezett élő metrikák. Modul:Nincs külön modulosztály. NuGet:Microsoft.ApplicationInsights.AspNetCore
Szívverések gyűjtője (App Service)	Szívveréseket küld (egyéni metrikákként) az App Service-környezet részleteivel. Beépített alap SDK-val az App Service-ben üzemeltetve. Modul:Nincs külön modulosztály. NuGet:Microsoft.ApplicationInsights.AspNetCore
Szívverés gyűjtő (virtuális gépek és virtuális gép méretezési készletek)	Szívveréseket küld (egyéni metrikákként) az Azure-beli virtuálisgép-környezet részleteivel. Azure-beli virtuális gépeken és Azure-beli virtuálisgép-méretezési csoportokon üzemeltetett alap SDK-n keresztül beépített. Modul:Nincs külön modulosztály. NuGet:Microsoft.ApplicationInsights.AspNetCore
Diagnosztikai telemetria	Az Application Insights-rendszerállapotkód hibáit jelenti (például nem tud hozzáférni a teljesítményszámlálókhoz, ITelemetryInitializer kivételt okoz). A nyomkövetési telemetria megjelenik a Diagnosztikai keresésben. Modul:Microsoft.ApplicationInsights.Extensibility.Implementation.Tracing.DiagnosticsTelemetryModule NuGet:Microsoft.ApplicationInsights
Fejlesztői mód (hibakereső csatolva)	Ugyanaz a viselkedés érhető el; osztály a Windows Server-csomag része. Modul:Microsoft.ApplicationInsights.WindowsServer.DeveloperModeWithDebuggerAttachedTelemetryModule NuGet:Microsoft.ApplicationInsights.WindowsServer
Kivételkövetés (web)	Automatikus kivételkövetés ASP.NET Core Application Insights-integrációban Modul:Nincs külön modulosztály. NuGet:Microsoft.ApplicationInsights.AspNetCore
Kivételkövetés (Nem figyelt/Kezeletlen)	Hasonló viselkedés ASP.NET Core-futtatókörnyezeten/integráción keresztül; az osztálynevek Windows Server-specifikusak. NuGet:Microsoft.ApplicationInsights.WindowsServer
EventSource-nyomkövetés	Konfigurált EventSource-eseményeket küld az Application Insightsnak nyomkövetésként. Modul:Microsoft.ApplicationInsights.EventSourceListener.EventSourceTelemetryModule NuGet:Microsoft.ApplicationInsights.EventSourceListener
ETW gyűjtő	Csak Windows rendszerű (ETW). Konfigurált ETW-szolgáltatói eseményeket küld az Application Insightsnak nyomkövetésként. Modul:Microsoft.ApplicationInsights.EtwCollector.EtwCollectorTelemetryModule NuGet:Microsoft.ApplicationInsights.EtwCollector
Core API (nem modul)	Az egyéb telemetriai összetevők és az egyéni telemetriai adatok által használt core API. Modul:Microsoft.ApplicationInsights package NuGet:Microsoft.ApplicationInsights

Telemetriai modulok konfigurálása

ASP.NET

TelemetryModules A ApplicationInsights.config szakaszában konfigurálhatja, hozzáadhatja vagy eltávolíthatja a modulokat. Az alábbi példák:

• Konfigurálás DependencyTrackingTelemetryModule (W3C-fejlécinjektálás engedélyezése).
• Konfigurálás EventCounterCollectionModule (az alapértelmezett értékek törlése és egyetlen számláló hozzáadása).
• Tiltsa le a perf-counter gyűjteményt az eltávolítással 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>

Megjegyzés:

A modulok pontos készlete attól függ, ApplicationInsights.config hogy mely SDK-csomagokat telepítette.

ASP.NET Core

1. lehetőség: Telemetriai modulok konfigurálása a ConfigureTelemetryModule használatával

Az alapértelmezett TelemetryModulebeállítások konfigurálásához használja a bővítménymetódust ConfigureTelemetryModule<T>IServiceCollectiona következő példában látható módon:

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

2. lehetőség: Telemetriai modulok konfigurálása az ApplicationInsightsServiceOptions használatával

Az SDK 2.12.2-s és újabb verzióiban az alábbi példához hasonlóan módosíthatja a gyakori beállításokat ApplicationInsightsServiceOptionsAddApplicationInsightsTelemetry:

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

Ez a táblázat tartalmazza a beállítások teljes listáját ApplicationInsightsServiceOptions :

Setting	Description	Alapértelmezett
Teljesítményszámláló-gyűjtőmodul bekapcsolása	Engedélyezés/letiltás PerformanceCounterCollectionModule.	True
Engedélyezze a Kérések Nyomonkövetési Telemetriai Modul használatát	Engedélyezés/letiltás RequestTrackingTelemetryModule.	True
Engedélyezze az Eseményszámláló Gyűjtőmodult	Engedélyezés/letiltás EventCounterCollectionModule.	True
FüggetlenségKövetésTelemetriaModulEngedélyezése	Engedélyezés/letiltás DependencyTrackingTelemetryModule.	True
AppSzolgáltatásokSzívverésTelemetriaModul Engedélyezése	Engedélyezés/letiltás AppServicesHeartbeatTelemetryModule.	True
Engedélyezze az AzureInstanceMetadataTelemetryModule-t	Engedélyezés/letiltás AzureInstanceMetadataTelemetryModule.	True
GyorsimpulzusMetriStreamEngedélyezése	A LiveMetrics funkció engedélyezése/letiltása.	True
Adaptív mintavételezés engedélyezése	Adaptív mintavételezés engedélyezése/letiltása.	True
Szívverés engedélyezése	A szívverések funkció engedélyezése/letiltása. Rendszeres időközönként (alapértelmezés szerint 15 perc) küld egy egyéni metrikát, amely a futtatókörnyezettel kapcsolatos információkat tartalmazza HeartbeatState , például a .NET-verziót és az Azure környezeti adatait, ha vannak ilyenek.	True
Automatikusan Gyűjtött Metrikai Kivonatoló Hozzáadása	Engedélyezze/tiltsa le a AutoCollectedMetrics extractor. Ez a telemetriai feldolgozó előre összesített metrikákat küld a kérelmekről/függőségekről a mintavételezés előtt.	True
A kérésgyűjtési beállítások követése hibák nélkül	A kérésgyűjtési modul által nem kezelt kivételkövetés jelentésének engedélyezése/letiltása.	False in netstandard2.0 (mert a kivételeket a rendszer nyomon követi ApplicationInsightsLoggerProvider). Ellenkező esetben igaz.
DiagnosztikaiTelemetriaModulEngedélyezése	Engedélyezés/letiltás DiagnosticsTelemetryModule. A letiltás miatt a következő beállítások figyelmen kívül lesznek hagyva: EnableHeartbeat, EnableAzureInstanceMetadataTelemetryModuleés EnableAppServicesHeartbeatTelemetryModule.	True

A legfrissebb lista megtekintéséhez lásd a konfigurálható beállításokat. ApplicationInsightsServiceOptions

Konfigurációs javaslat a Microsoft.ApplicationInsights.AspNetCore SDK 2.15.0-s és újabb verzióihoz

A Microsoft.ApplicationInsights.AspNetCore SDK 2.15.0-s és újabb verziójában ApplicationInsightsServiceOptionskonfiguráljon minden elérhető beállítást, beleértve a következőket: ConnectionString. Használja az alkalmazás példányát IConfiguration. A beállításoknak a szakasz ApplicationInsightsalatt kell lenniük, ahogyan az az alábbi példában is látható. Az appsettings.json alábbi szakasza konfigurálja a kapcsolati stringet, és letiltja az adaptív mintavételezést és a teljesítmény-számlálók gyűjtését.

{
    "ApplicationInsights": {
    "ConnectionString": "<YOUR-CONNECTION-STRING>",
    "EnableAdaptiveSampling": false,
    "EnablePerformanceCounterCollectionModule": false
    }
}

Ha builder.Services.AddApplicationInsightsTelemetry(aiOptions) ASP.NET Core 6.0-s vagy services.AddApplicationInsightsTelemetry(aiOptions) ASP.NET Core 3.1-et vagy korábbi verziót használ, az felülírja a beállításokat Microsoft.Extensions.Configuration.IConfiguration.

Feldolgozói szolgáltatás

1. lehetőség: Telemetriai modulok konfigurálása a ConfigureTelemetryModule használatával

Az Application Insights telemetriai modulokkal automatikusan gyűjt telemetriát adott számítási feladatokról manuális nyomon követés nélkül.

Alapértelmezés szerint az alábbi autocollection-modulok vannak engedélyezve. Ezek a modulok felelősek a telemetriai adatok automatikus gyűjtéséért. Letilthatja vagy konfigurálhatja őket, hogy módosítsák az alapértelmezett viselkedésüket.

• DependencyTrackingTelemetryModule
• PerformanceCollectorModule
• QuickPulseTelemetryModule
• AppServicesHeartbeatTelemetryModule (Jelenleg ez a telemetriai modullal kapcsolatos probléma merült fel. Ideiglenes kerülő megoldásért tekintse meg a GitHub 1689-es problémáját.)
• AzureInstanceMetadataTelemetryModule

Az alapértelmezett telemetriai modul konfigurálásához használja a bővítménymetódust ConfigureTelemetryModuleIServiceCollectiona következő példában látható módon:

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

2. lehetőség: Telemetriai modulok konfigurálása az ApplicationInsightsServiceOptions használatával

Néhány gyakori beállítás módosításához adja át ApplicationInsightsServiceOptions-t a AddApplicationInsightsTelemetryWorkerService-nek, mint ebben a példában:

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

Ebben ApplicationInsightsServiceOptions az SDK-ban a névtérben Microsoft.ApplicationInsights.WorkerService van, szemben Microsoft.ApplicationInsights.AspNetCore.Extensions az ASP.NET Core SDK-val.

Az alábbi táblázat a gyakran használt beállításokat sorolja fel.ApplicationInsightsServiceOptions

Setting	Description	Alapértelmezett
GyorsimpulzusMetriStreamEngedélyezése	Az élő metrikák funkció engedélyezése/letiltása.	True
Adaptív mintavételezés engedélyezése	Adaptív mintavételezés engedélyezése/letiltása.	True
Szívverés engedélyezése	Engedélyezze/tiltsa le a Szívverés funkciót, amely rendszeres időközönként (alapértelmezés szerint 15 perc) küld egy "HeartBeatState" nevű egyéni metrikát, amely információkat tartalmaz a futtatókörnyezetről, például a .NET-verzióról és az Azure-környezetről, ha van ilyen.	True
Automatikusan Gyűjtött Metrikai Kivonatoló Hozzáadása	Engedélyezze/tiltsa le az AutoCollectedMetrics-kinyerőt, amely egy telemetriai feldolgozó, amely előre összesített metrikákat küld a kérelmekről/függőségekről a mintavételezés előtt.	True
DiagnosztikaiTelemetriaModulEngedélyezése	Engedélyezés/letiltás DiagnosticsTelemetryModule. Ha letiltja ezt a beállítást, a rendszer figyelmen kívül hagyja a következő beállításokat: EnableHeartbeat, EnableAzureInstanceMetadataTelemetryModuleés EnableAppServicesHeartbeatTelemetryModule.	True

A legfrissebb listáért tekintse meg a konfigurálható beállításokat ApplicationInsightsServiceOptions.

Telemetriai adatok letiltása

ASP.NET

Minden modulhoz tartozik egy csomópont a konfigurációs fájlban. Egy modul letiltásához törölje a csomópontot, vagy fűzzön hozzá megjegyzést.

ASP.NET Core

Ha feltételesen és dinamikusan szeretné letiltani a telemetriát, feloldhatja a TelemetryConfiguration példányt egy ASP.NET Core függőséginjektáló tárolóval a kód bármely pontján, és beállíthatja rajta a DisableTelemetry jelzőt.

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

Az előző kódminta megakadályozza, hogy telemetriát küldjön az Application Insightsnak. Ez nem akadályozza meg, hogy az automatikus gyűjtési modulok telemetriát gyűjtsenek. Ha el szeretne távolítani egy adott autocollection modult, tekintse meg a telemetriai modulokat.

Feldolgozói szolgáltatás

Ha feltételesen és dinamikusan szeretné letiltani a telemetriát, feloldhatja a TelemetryConfiguration példányt egy ASP.NET Core függőséginjektáló tárolóval a kód bármely pontján, és beállíthatja rajta a DisableTelemetry jelzőt.

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddApplicationInsightsTelemetryWorkerService();
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, TelemetryConfiguration configuration)
    {
        configuration.DisableTelemetry = true;
        ...
    }

Csatlakozási karakterlánc

Ez a beállítás határozza meg azt az Application Insights-erőforrást, amelyben az adatok megjelennek. Általában minden alkalmazáshoz külön erőforrást hoz létre, külön kapcsolati sztringgel.

A kódmintákat az Application Insights kapcsolati sztringjeiben tekinti meg.

Ha például dinamikusan szeretné beállítani a kapcsolati sztringet, hogy az eredményeket az alkalmazásból különböző erőforrásokba küldje, kihagyhatja a kapcsolati sztringet a konfigurációs fájlból, és ehelyett kódban állíthatja be.

ASP.NET

Ha a kapcsolati sztringet az összes példányhoz TelemetryClient( beleértve a standard telemetriai modulokat is) be szeretné állítani, ezt a lépést inicializálási módszerben kell elvégeznie, például global.aspx.cs egy ASP.NET szolgáltatásban:

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

Ha egy adott eseménykészletet szeretne elküldeni egy másik erőforrásnak, beállíthatja egy adott telemetriai ügyfél kulcsát:

    var tc = new TelemetryClient();
    tc.Context.ConnectionString = "<YOUR-CONNECTION-STRING>";
    tc.TrackEvent("myEvent");
    // ...

Új kapcsolati sztring beszerzéséhez hozzon létre egy új erőforrást az Application Insights portálon.

ASP.NET Core

A ASP.NET Core-ban Program.cs konfigurálja a kapcsolati sztringet az alkalmazás indítása során a TelemetryConfiguration függőséginjektálási (DI) tároló használatával:

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

Ha egy adott eseménykészletet szeretne elküldeni egy másik erőforrásnak, létrehozhat egy új TelemetryClient példányt, és explicit módon beállíthatja annak kapcsolati sztringjét:

using Microsoft.ApplicationInsights;

var tc = new TelemetryClient();
tc.Context.ConnectionString = "<YOUR-CONNECTION-STRING>";
tc.TrackEvent("myEvent");
// ...

ApplicationId-szolgáltató

Megjegyzés:

A ASP.NET esetében ez a szolgáltató az SDK 2.6.0*-os verziótól kezdve érhető el.

Ennek a szolgáltatónak az a célja, hogy megkeressen egy alkalmazásazonosítót egy kapcsolati sztring alapján. Az alkalmazásazonosító szerepel a RequestTelemetry portálon, és DependencyTelemetry a korreláció meghatározására szolgál.

Ez a funkció a beállítással TelemetryConfiguration.ApplicationIdProviderérhető el.

Interfész: IApplicationIdProvider

public interface IApplicationIdProvider
{
    bool TryGetApplicationId(string connectionString, out string applicationId);
}

Két implementációt biztosítunk a Microsoft.ApplicationInsights SDK-ban: ApplicationInsightsApplicationIdProvider és DictionaryApplicationIdProvider.

ApplicationInsightsApplicationIdProvider

Ez a burkoló a Profil API-hoz készült. Szabályozza a kéréseket és a gyorsítótár eredményeit. Ez a szolgáltató automatikusan megjelenik a Microsoft.ApplicationInsights.DependencyCollector vagy a Microsoft.ApplicationInsights.Web telepítésekor.

Az osztály egy választható tulajdonságot ProfileQueryEndpointtesz elérhetővé. Alapértelmezés szerint a következőre https://dc.services.visualstudio.com/api/profiles/{0}/appIdvan állítva: .

Ha proxyt kell konfigurálnia, javasoljuk, hogy proxyt adjon meg az alapcímhez, és gondoskodjon arról, hogy az elérési út tartalmazza./api/profiles/{0}/appId Futásidőben az egyes kérésekhez szükséges kapcsolati lánccal {0} helyettesítve van.

ASP.NET

Példakonfiguráció 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élda a kódon keresztüli konfigurációra

TelemetryConfiguration.Active.ApplicationIdProvider = new ApplicationInsightsApplicationIdProvider();

ASP.NET Core

Megjegyzés:

A ASP.NET Core-ban nincs ApplicationInsights.config fájl. A konfiguráció függőséginjektálással (DI) történik Program.cs vagy Startup.cs.

Felülbírálhatja az alapértelmezett szolgáltatót, vagy testre szabhatja annak .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

Ez a statikus szolgáltató a konfigurált kapcsolati sztring-/alkalmazásazonosító-párokra támaszkodik.

Ez az osztály rendelkezik a Defined tulajdonsággal, amely Dictionary<string,string> kapcsolati sztring/alkalmazásazonosító párokból áll.

Ez az osztály rendelkezik az opcionális tulajdonságtal Next, amely egy másik szolgáltató konfigurálására használható, ha olyan kapcsolati sztringet kérnek, amely nem létezik a konfigurációban.

ASP.NET

Példakonfiguráció 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élda a kódon keresztüli konfigurációra

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

Ebben a szakaszban

• Kapcsolati karakterlánc
• Speciális konfigurációs beállítás
• Automatikus harmadik fél általi műszerezés

Az appInsights objektum számos konfigurációs módszert biztosít. Ezek az alábbi kódrészletben jelennek meg az alapértelmezett értékekkel.

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

Ahhoz, hogy teljes körűen megállapíthassa egy szolgáltatás eseményeinek korrelációját, mindenképpen be kell állítania a .setAutoDependencyCorrelation(true) értéket. E beállítás lehetővé teszi, hogy a Node.js-ben az SDK kövesse a kontextust az aszinkron visszahívások során.

Részletes információkért és opcionális másodlagos argumentumokért tekintse át a leírásukat az IDE beépített típusleírásában vagy applicationinsights.ts .

Megjegyzés:

Alapértelmezés szerint a setAutoCollectConsole úgy van konfigurálva, hogy kizárja a és más konzolmódszerek hívásait. Csak a támogatott külső naplózók (például Winston és Bunyan) hívásait gyűjtjük össze. A viselkedést úgy módosíthatja, hogy a console metódusokra irányuló hívásokat is tartalmazza a setAutoCollectConsole(true, true) használatával.

Csatlakozási karakterlánc

Ez a beállítás határozza meg azt az Application Insights-erőforrást, amelyben az adatok megjelennek. Általában minden alkalmazáshoz külön erőforrást hoz létre, külön kapcsolati sztringgel.

A kódmintákat az Application Insights kapcsolati sztringjeiben tekinti meg.

Ha például dinamikusan szeretné beállítani a kapcsolati sztringet, hogy az eredményeket az alkalmazásból különböző erőforrásokba küldje, kihagyhatja a kapcsolati sztringet a konfigurációs fájlból, és ehelyett kódban állíthatja be.

Több kapcsolati sztring használata

Több Application Insights-erőforrást is létrehozhat, és különböző adatokat küldhet mindegyiknek a megfelelő kapcsolati sztring használatával.

Például:

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

Speciális konfigurációs beállítások

Az ügyfélobjektum olyan tulajdonságot config tartalmaz, amely számos választható beállítással rendelkezik a speciális forgatókönyvekhez. A beállításukhoz használja a következőt:

client.config.PROPERTYNAME = VALUE;

Ezek a tulajdonságok ügyfélspecifikusak, így a appInsights.defaultClient külön konfigurálható a new appInsights.TelemetryClient()-tel létrehozott ügyfelektől.

Ingatlan	Description
connectionString	Az Application Insights-erőforrás azonosítója.
endpointUrl	A telemetriai adatok küldésére használt adatfogadó végpont.
quickPulseHost	Az élő metrikák stream-gazdagépe, amely élő metrikák telemetriáját küldi el.
proxyHttpUrl	Proxykiszolgáló az SDK HTTP-forgalmához. (Nem kötelező. Az alapértelmezett érték a környezeti változóból származik http_proxy .)
proxyHttpsUrl	Proxykiszolgáló SDK HTTPS-forgalomhoz. (Nem kötelező. Az alapértelmezett érték a környezeti változóból származik https_proxy .)
HTTP ügynök	Egy http.Agent az SDK HTTP-forgalomhoz használandó. (Nem kötelező. Az alapértelmezett érték nincs definiálva.)
httpsAgent	Egy HTTPS-ügynök, amely az SDK HTTPS-forgalmának kezelésére szolgál. (Nem kötelező. Az alapértelmezett érték nincs definiálva.)
maxBatchSize	Az adatbevitel végpontra küldendő hasznos adatba tartozó telemetriai elemek maximális száma. (Az alapértelmezett érték a 250.)
maxBatchIntervalMs (maximális csoportintervallum ms-ben)	A maximális időtartam, amely alatt várakozunk, hogy a hasznos adatcsomag elérje a maxBatchSize méretet. (Az alapértelmezett érték a 15000.)
Az AppInsights letiltása	Egy jelző, amely jelzi, hogy a telemetriai átvitel le van-e tiltva. (Az alapértelmezett érték a false.)
mintavételi százalék	A követett telemetriai elemek azon százalékos aránya, amelyet továbbítani kell. (Az alapértelmezett érték a 100.)
korrelációAzonosítóÚjrapróbálkozásiIdőtartamMs	A keresztösszetevők közötti korreláció azonosítójának lekéréséhez szükséges várakozási idő. (Az alapértelmezett érték a 30000.)
korelációsFejlécKizártTartományok	Az összetevők közötti korrelációs fejlécinjektálásból kizárandó tartományok listája. (Alapértelmezett. Lásd: Config.ts.)

Automatikus harmadik fél műszerezés

Az aszinkron hívások kontextusának nyomon követéséhez bizonyos változtatásokra van szükség a külső kódtárakban, például a MongoDB-ben és a Redisben. Alapértelmezés szerint az Application Insights diagnostic-channel-publishers használja néhány ilyen könyvtár ideiglenes módosítására. Ez a funkció a környezeti változó beállításával APPLICATION_INSIGHTS_NO_DIAGNOSTIC_CHANNEL letiltható.

Megjegyzés:

A környezeti változó beállításával előfordulhat, hogy az események nem lesznek megfelelően társítva a megfelelő művelettel.

Az egyes monkey patch-ek letilthatók úgy, hogy a APPLICATION_INSIGHTS_NO_PATCH_MODULES környezeti változót a kikapcsolandó csomagok vesszővel tagolt listájára állítja. Például használja a APPLICATION_INSIGHTS_NO_PATCH_MODULES=console,redis a console és redis csomagok javításának elkerülése érdekében.

Jelenleg kilenc csomag van kialakítva: bunyan,console,,mongodb,mongodb-core,mysqlredis,,winston,pg és pg-pool. A csomagok pontosan melyik verzióját javították, arról a diagnostic-channel-publishers README fájlban találhatók információk.

A bunyan, winstonés console a javítások az Application Insights nyomkövetési eseményeit generálják attól függően, hogy engedélyezve van-e setAutoCollectConsole . A többi az Application Insights függőségi eseményeit hozza létre attól függően, hogy engedélyezve van-e setAutoCollectDependencies .

Ügyféloldali megfigyelés hozzáadása

.NET

Az előző szakaszok útmutatást adtak a kiszolgálóoldali monitorozás automatikus és manuális konfigurálásához használható módszerekről. Ügyféloldali monitorozás hozzáadásához használja az ügyféloldali JavaScript SDK-t. Bármely weblap ügyféloldali tranzakcióit figyelheti úgy, hogy a lap HTML-jének záró címkéje elé egy </head> ad hozzá.

Bár manuálisan is hozzáadhatja a JavaScript (Webes) SDK Loader-szkriptet az egyes HTML-lapok fejlécéhez, javasoljuk, hogy ehelyett adja hozzá a JavaScript (webes) SDK loader szkriptet egy elsődleges laphoz. Ez a művelet a JavaScript (webes) SDK loader szkriptet a webhely összes lapjára injektálja.

ASP.NET

A cikkben szereplő sablonalapú ASP.NET MVC-alkalmazás esetében a szerkeszteni kívánt fájl a _Layout.cshtml. A nézetet a Megosztotttalálja. Ügyféloldali monitorozás hozzáadásához nyissa meg a _Layout.cshtml fájlt, és kövesse a JavaScript (webes) SDK Loader szkriptalapú beállítási utasításait az ügyféloldali JavaScript SDK-konfigurációról szóló cikkben.

ASP.NET Core

Ha az alkalmazás ügyféloldali összetevőkkel rendelkezik, a következő lépéseket követve megkezdheti a használati telemetria gyűjtését a JavaScript (Webes) SDK Loader Script injektálásával, konfiguráció alapján.

1. A _ViewImports.cshtml-ben adja hozzá az injekciót:

   @inject Microsoft.ApplicationInsights.AspNetCore.JavaScriptSnippet JavaScriptSnippet
   

2. A _Layout.cshtml fájlban szúrja be HtmlHelper a <head> szakasz végén, de bármely más szkript előtt. Ha egyéni JavaScript-telemetriát szeretne jelenteni a lapról, szúrja be a kódrészlet után:

       @Html.Raw(JavaScriptSnippet.FullScript)
   </head>
   

A FullScript alternatívájaként a ScriptBody elérhető az Application Insights SDK ASP.NET Core 2.14-es verziójától kezdve. A ScriptBody használatával vezérelheti a <script> címkét a tartalombiztonsági szabályzat beállításához.

<script> // apply custom changes to this script tag.
    @Html.Raw(JavaScriptSnippet.ScriptBody)
</script>

A korábban hivatkozott .cshtml fájlnevek egy alapértelmezett MVC-alkalmazássablonból származnak. Végső soron, ha megfelelően szeretné engedélyezni az ügyféloldali monitorozást az alkalmazáshoz, a JavaScript (webes) SDK loader szkriptnek meg kell jelennie az <head> alkalmazás minden figyelni kívánt oldalának szakaszában. Az ügyféloldali monitorozás engedélyezéséhez adja hozzá a JavaScript (webes) SDK loader szkriptet a _Layout.cshtml fájlhoz egy alkalmazássablonban.

Ha a projekt nem tartalmazza a _Layout.cshtml fájlt, akkor is hozzáadhat ügyféloldali monitorozást úgy, hogy a JavaScript (webes) SDK loader szkriptet hozzáadja egy egyenértékű fájlhoz, amely az <head> alkalmazás összes lapját vezérli. Másik lehetőségként hozzáadhatja a JavaScript (webes) SDK loader szkriptet több laphoz, de nem javasoljuk.

Megjegyzés:

A JavaScript-injektálás alapértelmezett konfigurációs felületet biztosít. Ha a kapcsolati sztring beállításán túl konfigurálásra van szüksége, el kell távolítania az autoinjekciót a leírt módon, és manuálisan kell hozzáadnia a JavaScript SDK-t.

Node.js

Megjegyzés:

Nyilvános előzetes verzióként érhető el. A Microsoft Azure előzetes verziójú termékekre vonatkozó kiegészítő feltételek

Az automatikus webes instrumentáció engedélyezhető a node szerveren a JavaScript (Web) SDK Loader Script konfiguráció szerinti injektálásával.

let appInsights = require("applicationinsights");
appInsights.setup("<connection_string>")
    .enableWebInstrumentation(true)
    .start();

vagy a környezeti változó APPLICATIONINSIGHTS_WEB_INSTRUMENTATION_ENABLED = truebeállításával.

A Web Instrumentation akkor engedélyezve van a csomópontkiszolgálói válaszokon, ha az alábbi követelmények teljesülnek:

• A válasz állapotkóddal 200rendelkezik.
• A válaszadási módszer: GET.
• A kiszolgáló válasza Content-Type html-t tartalmaz.
• A kiszolgáló válasza mindkettőt <head> és </head> címkéket is tartalmaz.
• Ha a válasz tömörítve van, annak csak egy Content-Encoding típussal kell rendelkeznie, és a kódolási típusnak az egyiknek gzip vagy braz egyiknek deflatekell lennie.
• A válasz nem tartalmaz aktuális /backup web Instrumentation CDN-végpontokat. (a Web Instrumentation CDN-végpontok aktuális és biztonsági mentése itt)

A Web Instrumentation CDN-végpont a környezeti változó APPLICATIONINSIGHTS_WEB_INSTRUMENTATION_SOURCE = "web Instrumentation CDN endpoints"beállításával módosítható. A Web Instrumentation kapcsolati sztringje módosítható a környezeti változó beállításával APPLICATIONINSIGHTS_WEB_INSTRUMENTATION_CONNECTION_STRING = "web Instrumentation connection string"

Megjegyzés:

A Web Instrumentation lelassíthatja a kiszolgáló válaszidejének idejét, különösen akkor, ha a válasz mérete nagy, vagy a válasz tömörítve van. Abban az esetben, ha bizonyos közbenső rétegeket alkalmaznak, előfordulhat, hogy a webes műszeres felügyelet nem működik, és az eredeti válasz kerül visszaadásra.

Alapvető API egyéni eseményekhez és metrikákhoz

Szúrjon be néhány sornyi kódot az alkalmazásba, hogy megtudja, mit csinálnak vele a felhasználók, vagy segítsen a problémák diagnosztizálásában. Telemetriát küldhet eszköz- és asztali alkalmazásokból, webes ügyfelekről és webkiszolgálókról. Az Application Insights alapvető telemetriai API-jának használatával egyéni eseményeket és metrikákat küldhet, valamint a standard telemetriai adatok saját verzióit. Ez az API ugyanaz az API, amelyet a standard Application Insights-adatgyűjtők használnak.

API-összefoglalás

Az alapvető API minden platformon egységes, néhány változattól eltekintve, például GetMetric (csak.NET).

Metódus	A következőhöz használatos:
TrackPageView	Lapok, képernyők, panelek vagy űrlapok.
TrackEvent	Felhasználói műveletek és egyéb események. A felhasználói viselkedés nyomon követésére vagy a teljesítmény figyelésére szolgál.
GetMetric	Nulla és többdimenziós metrikák, központilag konfigurált összesítés, csak C#.
TrackMetric	Teljesítménymérések, mint például az üzenetsorok hossza, amelyek nem kapcsolódnak adott eseményekhez.
TrackException	Naplózási kivételek a diagnózishoz. Kövesse nyomon, hogy hol fordulnak elő más eseményekhez képest, és vizsgálja meg a verem nyomkövetéseket.
TrackRequest	A kiszolgálói teljesítményelemzési kérelmek gyakoriságának és időtartamának naplózása.
TrackTrace	Erőforrás-diagnosztikai naplóüzenetek. Külső naplókat is rögzíthet.
TrackDependency	Az alkalmazás által használt külső összetevőkre irányuló hívások időtartamának és gyakoriságának naplózása.

A legtöbb telemetriai híváshoz tulajdonságokat és metrikákat csatolhat .

Előfeltételek

Ha még nem rendelkezik hivatkozással az Application Insights SDK-ra:

1. Adja hozzá az Application Insights SDK-t a projekthez.

2. Az eszköz vagy a webkiszolgáló kódja tartalmazza a következőket:

   .NET

   using Microsoft.ApplicationInsights;
   

   Node.js

   var applicationInsights = require("applicationinsights");
   

TelemetryClient-példány lekérése

A következő példány lekérése TelemetryClient:

Megjegyzés:

Ha az Azure Functions v2+ vagy az Azure WebJobs v3+-ot használja, tekintse meg az Azure Functions monitorozását.

.NET

Megjegyzés:

A .NET/.NET Core-alkalmazásokhoz készült ASP.NET Core és nem HTTP/Worker esetén szerezze be a függőséginjektálási tároló egy példányát TelemetryClient a vonatkozó dokumentációjukban leírtak szerint.

private TelemetryClient telemetry = new TelemetryClient();

Ha egy üzenet jelzi, hogy ez a módszer elavult, további információt a microsoft/ApplicationInsights-dotnet#1152 című témakörben talál.

A rendszer automatikusan rögzíti a bejövő HTTP-kéréseket. Lehetséges, hogy több TelemetryClient példányt szeretne létrehozni az alkalmazásod más moduljaihoz. Előfordulhat például, hogy a köztes szoftverosztályban van egy TelemetryClient példány az üzleti logikai események jelentéséhez. Beállíthat olyan tulajdonságokat, mint például UserIdDeviceId a gép azonosítása. Ez az információ a példány által küldött összes eseményhez csatolva van.

TelemetryClient.Context.User.Id = "...";
TelemetryClient.Context.Device.Id = "...";

Node.js

var telemetry = applicationInsights.defaultClient;

Létrehozhat új példányt new applicationInsights.TelemetryClient(instrumentationKey?) segítségével. Ezt a megközelítést csak olyan forgatókönyvek esetén javasoljuk, amelyek elszigetelt konfigurációt igényelnek a singletontól defaultClient.

Megjegyzés:

TelemetryClient szálbiztos.

TrackEvent

Az Application Insightsban az egyéni esemény egy adatpont, amelyet összesített számként és a Keresésben egyéni előfordulásként jeleníthet meg a Metrics Explorerben. (Nem kapcsolódik az MVC-hez vagy más keretrendszer "eseményeihez".)

A különböző események megszámlálásához szúrjon be TrackEvent hívásokat a kódba. Előfordulhat például, hogy nyomon szeretné követni, hogy a felhasználók milyen gyakran választanak ki egy adott funkciót. Vagy érdemes lehet tudni, hogy milyen gyakran érnek el bizonyos célokat, vagy követnek el bizonyos típusú hibákat.

Egy játékalkalmazásban például minden alkalommal küldjön eseményt, amikor egy felhasználó megnyeri a játékot:

.NET

telemetry.TrackEvent("WinGame");

Node.js

telemetry.trackEvent({name: "WinGame"});

Egyéni események a Log Analyticsben

A telemetria az customEventsApplication Insights Naplók lapján vagy a használati felületen található táblázatban érhető el. Események érkezhetnek a trackEvent(..) vagy a Click Analytics Autocollection bővítményből.

Ha a mintavételezés folyamatban van, a itemCount tulajdonság értéke nagyobb, mint 1. Ez azt jelenti például, itemCount==10 hogy 10 hívásból trackEvent()csak egyet továbbított a mintavételezési folyamat. Az egyéni események helyes számának lekéréséhez használja a customEvents | summarize sum(itemCount)következő kódot: .

Megjegyzés:

Az itemCount értéke legalább egy; maga a rekord egy bejegyzést jelöl.

GetMetric

Ha tudni szeretné, hogyan használhatja hatékonyan a hívást a GetMetric() .NET- és .NET Core-alkalmazások helyileg előre összeállított metrikáinak rögzítésére, tekintse meg az egyéni metrikák gyűjteményét a .NET-ben és a .NET Core-ban.

TrackMetric

Megjegyzés:

Microsoft.ApplicationInsights.TelemetryClient.TrackMetric nem a metrikák küldésének előnyben részesített módszere. A metrikákat mindig előre kell összesíteni egy adott időszakban, mielőtt elküldené őket. Használja az egyik túlterhelést egy GetMetric(..) metrikaobjektum lekérésére az SDK előaggregációs funkcióinak kihasználásához.

Ha saját előaggregációs logikát implementál, a TrackMetric() metódussal elküldheti az eredményül kapott összesítéseket. Ha az alkalmazásnak minden alkalommal külön telemetriai elemet kell küldenie összesítés nélkül, akkor valószínűleg van egy használati esete az eseménytelemetria esetében. Lásd a(z) TelemetryClient.TrackEvent(Microsoft.ApplicationInsights.DataContracts.EventTelemetry).

Az Application Insights képes olyan metrikákat ábrázolni, amelyek nincsenek adott eseményekhez csatolva. Monitorozhat például egy üzenetsor hosszát rendszeres időközönként. A metrikáknál az egyes mérések kevésbé érdekesek, mint a variációk és trendek, ezért a statisztikai diagramok hasznosak.

Metrikák Application Insightsba való küldéséhez használhatja az TrackMetric(..) API-t. A metrikák küldésének két módja van:

• Egyetlen érték. Minden alkalommal, amikor mérést végez az alkalmazásban, elküldi a megfelelő értéket az Application Insightsnak.

  Tegyük fel például, hogy rendelkezik egy olyan metrikával, amely egy tároló elemeinek számát írja le. Egy adott időszakban először három elemet helyez a tárolóba, majd eltávolít két elemet. Ennek megfelelően Ön kétszer hívná fel TrackMetric. Először adja át az értéket 3 , majd adja át az értéket -2. Az Application Insights mindkét értéket tárolja.

• Összesítés. Ha metrikákkal dolgozik, minden egyes mérés ritkán érdekes. Ehelyett fontos összefoglalni, hogy mi történt egy adott időszakban. Az ilyen összegzést összesítésnek nevezzük.

  Az előző példában az adott időszak összesített metrikaösszege 1, és a metrikaértékek száma 2. Az összesítési módszer használata esetén időszakonként csak egyszer hív meg TrackMetric , és elküldi az összesített értékeket. Ezt a megközelítést azért javasoljuk, mert jelentősen csökkentheti a költségeket és a teljesítményterhelést azáltal, hogy kevesebb adatpontot küld az Application Insightsnak, miközben továbbra is összegyűjti az összes releváns információt.

Példák egyetlen értékre

Egyetlen metrikaérték küldése:

.NET

var sample = new MetricTelemetry();
sample.Name = "queueLength";
sample.Sum = 42.3;
telemetryClient.TrackMetric(sample);

Node.js

telemetry.trackMetric({name: "queueLength", value: 42.0});

Egyéni metrikák a Log Analyticsben

A telemetria az customMetricsApplication Insights Analytics táblájában érhető el. Minden sor egy hívást jelent a(z) trackMetric(..) alkalmazásban.

• valueSum: A mérések összege. A középérték lekéréséhez ossza el a következővel valueCount: .
• valueCount: Az trackMetric(..) hívásba összesített mérések száma.

Megjegyzés:

a valueCount értéke legalább egy; maga a rekord egy bejegyzést jelöl.

Oldalmegtekintések

Egy eszköz- vagy weblapalkalmazásban a rendszer alapértelmezés szerint elküldi a lapnézet telemetriáját az egyes képernyők vagy lapok betöltésekor. Az alapértelmezett beállítást azonban módosíthatja úgy, hogy több vagy több időpontban is nyomon kövesse az oldalmegtekintéseket. Egy lapokat vagy paneleket megjelenítő alkalmazásban például érdemes lehet nyomon követni egy lapot, amikor a felhasználó új panelt nyit meg.

A rendszer tulajdonságokként és oldalnézetekként küldi el a felhasználói és munkamenet-adatokat, így a felhasználói és a munkamenet-diagramok életre kelnek, amikor oldalnézeti telemetria van.

Egyéni oldalmegtekintések

.NET

telemetry.TrackPageView("GameReviewPage");

Node.js

Nem alkalmazható.

Laptelemetria a Log Analyticsben

A Log Analyticsben két tábla jeleníti meg a böngészőműveletek adatait:

• pageViews: Adatokat tartalmaz az URL-címről és a lap címéről.
• browserTimings: Olyan adatokat tartalmaz az ügyfél teljesítményéről, mint a bejövő adatok feldolgozásához szükséges idő.

Annak megkeresése, hogy a böngésző mennyi ideig tart a különböző oldalak feldolgozásához:

browserTimings
| summarize avg(networkDuration), avg(processingDuration), avg(totalDuration) by name

A különböző böngészők népszerűségének felfedezése:

pageViews
| summarize count() by client_Browser

Ha oldalmegtekintéseket szeretne társítani az AJAX-hívásokhoz, csatlakozzon a függőségekhez:

pageViews
| join (dependencies) on operation_Id

TrackRequest

A kiszolgáló SDK a HTTP-kérések naplózására használja a TrackRequest jelölőt.

Akkor is meghívhatja, ha olyan környezetben szeretné szimulálni a kéréseket, ahol nem fut a webszolgáltatás-modul.

A kérelemtelemetria küldésének ajánlott módja, ha a kérés műveleti környezetként működik.

Műveleti környezet

A telemetriai elemeket összekapcsolhatja a műveleti környezettel való társítással. A szabványos kéréskövetési modul a HTTP-kérés feldolgozása során küldött kivételekre és egyéb eseményekre vonatkozik. A Keresés és elemzés területen egyszerűen megtalálhatja a kérelemhez társított eseményeket a műveletazonosító használatával.

Ha manuálisan követi nyomon a telemetriát, a telemetria korrelációjának legegyszerűbb módja az alábbi minta használata:

.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.

A korrelációról további információt az Application Insights telemetriai korrelációjában talál.

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.

A műveleti környezet StartOperation beállításával együtt létrehoz egy megadott típusú telemetriai elemet. A telemetria elemet akkor küldi el, amikor befejezi a műveletet, vagy ha explicit módon meghívja a StopOperation. Ha telemetriatípusként használja RequestTelemetry , annak időtartama a kezdés és a leállítás közötti időintervallumra van állítva.

A művelet hatókörében jelentett telemetriai elemek egy ilyen művelet gyermekévé válnak. A műveleti környezetek beágyazhatók.

A Keresésben a műveletkörnyezetet használja a kapcsolódó elemek listájának létrehozásához.

Az egyéni műveletek nyomon követésével kapcsolatos további információkért lásd: Egyéni műveletek nyomon követése az Application Insights .NET SDK-val.

Kérelmek a Log Analyticsben

Az Application Insights Analyticsben a kérelmek megjelennek a requests táblázatban.

Ha a mintavételezés folyamatban van, a itemCount tulajdonság értéke nagyobb, mint 1. Ez azt jelenti például, itemCount==10 hogy 10 hívásból trackRequest()csak egyet továbbított a mintavételezési folyamat. A kérések helyes számának és a kérelmek neve szerint szegmentált átlagos időtartamának lekéréséhez használja a következő kódot:

requests
| summarize count = sum(itemCount), avgduration = avg(duration) by name

TrackException

Kivételek küldése az Application Insights szolgáltatásba:

• Azok megszámlálása a probléma gyakoriságának jelzéseként.
• Az egyes előfordulások vizsgálata.

A jelentések tartalmazzák a veremkivonatot.

.NET

try
{
    ...
}
catch (Exception ex)
{
    telemetry.TrackException(ex);
}

Node.js

try
{
    ...
}
catch (ex)
{
    telemetry.trackException({exception: ex});
}

Az SDK-k számos kivételt automatikusan elkapnak, így nem mindig kell explicit módon hívnia a TrackException.

Kivételek a Log Analyticsben

Az Application Insights Analyticsben kivételek jelennek meg a exceptions táblázatban.

Ha a mintavételezés folyamatban van, a itemCount tulajdonság értéke nagyobb, mint 1. Ez azt jelenti például, itemCount==10 hogy 10 hívásból trackException()csak egyet továbbított a mintavételezési folyamat. A kivételtípusok szerint szegmentált kivételek helyes számának lekéréséhez használja a következő kódokat:

exceptions
| summarize sum(itemCount) by type

A legfontosabb veremadatok többsége már külön változókba van kinyerve, de a details szerkezetet szétszedve még több információhoz juthat. Mivel ez a struktúra dinamikus, az eredményt a várt típusra kell átalakítania. Például:

exceptions
| extend method2 = tostring(details[0].parsedStack[1].method)

Ha kivételeket szeretne társítani a kapcsolódó kérésekhez, használjon illesztést:

exceptions
| join (requests) on operation_Id

TrackTrace

Használja a TrackTrace elemet a problémák diagnosztizálásához, és küldjön „nyomvonalat” az Application Insightsnak. A diagnosztikai adatok darabjait elküldheti, és megvizsgálhatja őket a Keresésben.

.NET

A .NET naplóadapterekben ezzel az API-val küldhet harmadik féltől származó naplókat a portálra.

telemetry.TrackTrace(message, SeverityLevel.Warning, properties);

Node.js

telemetry.trackTrace({
    message: message,
    severity: applicationInsights.Contracts.SeverityLevel.Warning,
    properties: properties
});

Naplózhat egy diagnosztikai eseményt, például beírhat vagy elhagyhat egy metódust.

Paraméter	Description
message	Diagnosztikai adatok. Sokkal hosszabb lehet, mint egy név.
properties	Sztringről sztringre történő leképezés. További adatokkal szűrheti a kivételeket a portálon. Alapértelmezés szerint üres.
severityLevel	Támogatott értékek: SeverityLevel.ts.

Kereshet az üzenet tartalmában, de a tulajdonságértékekkel ellentétben nem szűrhet rá.

A méretkorlát message sokkal magasabb, mint a tulajdonságokra vonatkozó korlát. Ennek az az előnye TrackTrace , hogy viszonylag hosszú adatokat helyezhet el az üzenetben. Itt például a POST-adatokat kódolhatja.

Súlyossági szintet is hozzáadhat az üzenethez. A többi telemetriához hasonlóan tulajdonságértékeket is hozzáadhat a különböző nyomkövetési csoportok szűréséhez vagy kereséséhez. Például:

.NET

var telemetry = new Microsoft.ApplicationInsights.TelemetryClient();
telemetry.TrackTrace("Slow database response",
                SeverityLevel.Warning,
                new Dictionary<string,string> { {"database", db.ID} });

Node.js

Nem alkalmazható.

A Keresésben ezután egyszerűen kiszűrheti egy adott súlyossági szint összes üzenetét, amely egy adott adatbázishoz kapcsolódik.

Nyomkövetések a Log Analyticsben

Az Application Insights Analyticsben megjelennek a TrackTrace hívások a traces táblázatban.

Ha a mintavételezés folyamatban van, a itemCount tulajdonság értéke nagyobb, mint 1. Ez azt jelenti például, itemCount==10 hogy 10 hívásból trackTrace()csak egyet továbbított a mintavételezési folyamat. A nyomkövetési hívások helyes számának lekéréséhez használjon olyan kódot, mint a traces | summarize sum(itemCount).

TrackDependency

A hívással TrackDependency nyomon követheti a külső kódhoz intézett hívások válaszidejének és sikerességi arányának mértékét. Az eredmények a portál függőségi diagramjaiban jelennek meg. A következő kódrészletet mindenhol hozzá kell adni, ahol függőségi hívást kezdeményeznek.

Megjegyzés:

A .NET és a .NET Core esetében alternatív megoldásként használhatja a TelemetryClient.StartOperation (bővítmény) metódust, amely kitölti a DependencyTelemetry korrelációhoz szükséges tulajdonságokat és néhány egyéb tulajdonságot, például a kezdési időpontot és az időtartamot, így nem kell egyéni időzítőt létrehoznia az alábbi példákhoz hasonlóan. További információ: A kimenő függőségek nyomon követése az Egyéni műveletek követése az Application Insights .NET SDK-val című szakaszában.

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

Ne feledje, hogy a kiszolgáló SDK-jai tartalmaznak egy függőségi modult , amely automatikusan felderít és nyomon követ bizonyos függőségi hívásokat, például az adatbázisokat és a REST API-kat. A modul működéséhez telepítenie kell egy ügynököt a kiszolgálóra.

Ezt a hívást akkor használja, ha olyan hívásokat szeretne nyomon követni, amelyeket az automatikus nyomkövetés nem fog el.

Ha ki szeretné kapcsolni a standard függőségkövetési modult a C#-ban, szerkessze ApplicationInsights.config , és törölje a hivatkozását DependencyCollector.DependencyTrackingTelemetryModule.

Függőségek a Log Analyticsben

Az Application Insights AnalyticsbentrackDependency a hívások megjelennek a dependencies táblázatban.

Ha a mintavételezés működik, a itemCount tulajdonság értéke 1-nél nagyobb. Ez azt jelenti például, itemCount==10 hogy 10 hívásból trackDependency()csak egyet továbbított a mintavételezési folyamat. A célösszetevő szerint szegmentált függőségek helyes számának lekéréséhez használja a következő kódokat:

dependencies
| summarize sum(itemCount) by target

Ha függőségeket szeretne társítani a kapcsolódó kéréseikkel, használjon egy illesztést:

dependencies
| join (requests) on operation_Id

Adatok törlése

Az SDK általában rögzített időközönként, általában 30 másodperccel vagy a puffer megtelt állapotában küld adatokat, ami általában 500 elem. Bizonyos esetekben érdemes lehet kiüríteni a puffert. Ilyen például, ha az SDK-t egy leállított alkalmazásban használja.

.NET

Amikor a(z) Flush()-t használja, ezt mintát ajánljuk:

telemetry.Flush();
// Allow some time for flushing before shutdown.
System.Threading.Thread.Sleep(5000);

A FlushAsync() használata során a következő mintát javasoljuk:

await telemetryClient.FlushAsync()
// No need to sleep

Javasoljuk, hogy az alkalmazásleállítás részeként mindig ürítsen, hogy a telemetriai adatok ne vesszenek el.

Megjegyzés:

Tekintse át az Automatikus adatáramlás konfigurációját: Az automatikus adatbetöltés engedélyezése a web.config fájlban teljesítménycsökkenéshez vezethet az Application Insights használatával létrehozott .NET-alkalmazásokban. Ha az automatikus adatbetöltés engedélyezve van, a metódusok minden meghívása System.Diagnostics.Trace.Trace* azt eredményezi, hogy az egyes telemetriai elemek külön külön webes kérésként lesznek elküldve a betöltési szolgáltatásnak. Ez hálózati és tárolási kimerültséget okozhat a webkiszolgálókon. A nagyobb teljesítmény érdekében ajánlott letiltani az automatikus adatáramlást, és a Hatékonyabb telemetriai adatátvitelhez tervezett ServerTelemetryChannelt is használni.

A függvény aszinkron a kiszolgálói telemetriai csatornához.

Node.js

telemetry.flush();

Hitelesített felhasználók

Egy webalkalmazásban a felhasználókat alapértelmezés szerint cookie-k azonosítják . Előfordulhat, hogy egy felhasználót többször is meg kell számolni, ha egy másik gépről vagy böngészőből fér hozzá az alkalmazáshoz, vagy törli a cookie-kat.

Ha a felhasználók bejelentkeznek az alkalmazásba, pontosabb számot kaphat a hitelesített felhasználói azonosító böngészőkódban való beállításával. Nem szükséges a felhasználó tényleges bejelentkezési nevét használni. Csak az adott felhasználóra jellemző azonosítónak kell lennie. Nem tartalmazhat szóközöket vagy karaktereket ,;=|.

A felhasználói azonosító egy munkamenet-cookie-ban is be van állítva, és elküldi a kiszolgálónak. Ha a kiszolgáló SDK telepítve van, a hitelesített felhasználói azonosító az ügyfél- és kiszolgálótelemetria környezeti tulajdonságainak részeként lesz elküldve. Ezután szűrheti és kereshet rajta.

Ha az alkalmazás fiókba csoportosítja a felhasználókat, a fiók azonosítóját is átadhatja. Ugyanezek a karakterkorlátozások érvényesek.

A Metrics Explorerben létrehozhat egy diagramot, amely megszámlálja a felhasználókat, a hitelesített és a felhasználói fiókokat.

Adott felhasználónevekkel és fiókokkal rendelkező ügyféladat-pontokat is kereshet .

Megjegyzés:

A .NET Core SDK ApplicationInsightsServiceOptions osztályában található EnableAuthenticationTrackingJavaScript tulajdonság leegyszerűsíti az Application Insights JavaScript SDK által küldött nyomkövetések hitelesítésazonosítójaként a felhasználónév injektálásához szükséges JavaScript-konfigurációt.

Ha ez a tulajdonság be van állítva true, a rendszer az ASP.NET Core-ban lévő felhasználó felhasználónevet nyomtatja ki az ügyféloldali telemetriával együtt. Emiatt a appInsights.setAuthenticatedUserContext manuális hozzáadására már nincs szükség, mert az SDK már beilleszti az ASP.NET Core-hoz tartozó SDK-ba. A hitelesítési azonosítót a rendszer arra a kiszolgálóra is elküldi, ahol a .NET Core SDK azonosítja és használja a kiszolgálóoldali telemetriához a JavaScript API-referencia alapján.

Az olyan JavaScript-alkalmazások esetében, amelyek nem ugyanúgy működnek, mint ASP.NET Core MVC, például SPA-webalkalmazások, manuálisan kell hozzáadni appInsights.setAuthenticatedUserContext .

Adatok szűrése, keresése és szegmentálása tulajdonságok használatával

Tulajdonságokat és méréseket csatolhat az eseményekhez, metrikákhoz, oldalnézetekhez, kivételekhez és egyéb telemetriai adatokhoz.

A tulajdonságok olyan sztringértékek, amelyekkel szűrheti a telemetriát a használati jelentésekben. Ha például az alkalmazás több játékot is kínál, minden eseményhez csatolhatja a játék nevét, így láthatja, hogy mely játékok népszerűbbek.

A karakterlánc hossza legfeljebb 8 192 lehet. Ha nagy adattömböket szeretne küldeni, használja a következő üzenetparamétert TrackTrace: .

A metrikák grafikusan ábrázolható numerikus értékek. Érdemes lehet például megnézni, hogy a játékosok által elért pontszámok fokozatosan növekednek-e. A grafikonok szegmentáltak lehetnek az eseményhez küldött tulajdonságok alapján, így különálló vagy halmozott gráfokat kaphat a különböző játékokhoz.

A metrikaértékek helyes megjelenítéséhez a metrikaértéknek 0-nál nagyobbnak vagy egyenlőnek kell lennie.

A használható tulajdonságok, tulajdonságértékek és metrikák száma korlátozott.

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

Fontos

Győződjön meg arról, hogy nem naplózza a személyazonosításra alkalmas adatokat a tulajdonságokban.

Tulajdonságok és metrikák beállításának alternatív módja

Ha kényelmesebb, egy esemény paramétereit külön objektumban gyűjtheti össze:

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

Figyelmeztetés

Ne használja újra ugyanazt a telemetriai elempéldányt (event ebben a példában) többszöri híváshoz Track*() . Ez a gyakorlat azt okozhatja, hogy a telemetriai adatok helytelen konfigurációval lesznek elküldve.

Egyéni mérések és tulajdonságok a Log Analyticsben

A Log Analyticsben az egyéni metrikák és tulajdonságok az customMeasurements egyes telemetriai rekordokban és customDimensions attribútumokban jelennek meg.

Ha például hozzáad egy "game" nevű tulajdonságot a kérelem telemetriai adataihoz, ez a lekérdezés megszámolja a "játék" különböző értékeinek előfordulását, és megjeleníti az egyéni metrika "pontszámának" átlagát:

requests
| summarize sum(itemCount), avg(todouble(customMeasurements.score)) by tostring(customDimensions.game)

Figyelje meg az alábbiakat:

• Ha kivon egy értéket a customDimensions vagy customMeasurements JSON-ból, annak dinamikus típusa van, ezért azt tostring vagy todouble típussá kell alakítania.
• A mintavétel lehetőségének figyelembevétele érdekében használja sum(itemCount)-t, ne pedig count()-t.

Időzítési események

Néha érdemes diagramot készíteni, hogy mennyi ideig tart egy művelet végrehajtása. Érdemes lehet például tudnia, hogy a felhasználók mennyi ideig tartanak, amíg megfontolják a választásokat egy játékban. Az információk beszerzéséhez használja a mérési paramétert.

.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

Az egyéni telemetriai adatok alapértelmezett tulajdonságai

Ha meg szeretné adni az alapértelmezett tulajdonságértékeket az ön által írt egyéni események némelyikéhez, állítsa be őket egy TelemetryClient példányban. Ezek az ügyféltől küldött összes telemetriai elemhez vannak csatolva.

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

Az egyes telemetriai hívások felülírhatják a tulajdonságszótárak alapértelmezett értékeit.

Ha tulajdonságokat szeretne hozzáadni az összes telemetriához, beleértve a standard gyűjteménymodulokból származó adatokat is, implementálja a elemet ITelemetryInitializer.

Telemetriai adatok letiltása

A telemetriai adatok gyűjtésének és átvitelének dinamikus leállítása és elindítása :

.NET

using  Microsoft.ApplicationInsights.Extensibility;

TelemetryConfiguration.Active.DisableTelemetry = true;

Node.js

telemetry.config.disableAppInsights = true;

A kiválasztott standard gyűjtők( például teljesítményszámlálók, HTTP-kérések vagy függőségek) inicializáláskor történő letiltásához lánckonfigurációs módszereket kell az SDK inicializálási kódjához kapcsolni.

applicationInsights.setup()
    .setAutoCollectRequests(false)
    .setAutoCollectPerformance(false)
    .setAutoCollectExceptions(false)
    .setAutoCollectDependencies(false)
    .setAutoCollectConsole(false)
    .start();

Ha le szeretné tiltani ezeket a gyűjtőket az inicializálás után, használja a Konfiguráció objektumot: applicationInsights.Configuration.setAutoCollectRequests(false).

Fejlesztői mód

Hibakeresés során hasznos, ha a telemetria felgyorsítva haladjon a csatornán keresztül, hogy azonnal láthassa az eredményeket. Más üzeneteket is kap, amelyek segítenek a telemetriával kapcsolatos problémák nyomon követésében. Kapcsolja ki éles környezetben, mert lelassíthatja az alkalmazást.

.NET

TelemetryConfiguration.Active.TelemetryChannel.DeveloperMode = true;

Node.js

Node.js esetében engedélyezheti a fejlesztői módot a belső naplózás setInternalLogging bekapcsolásával, és maxBatchSize értékét 0-re állítva, ami miatt a telemetriát az adatgyűjtés után azonnal továbbítja.

applicationInsights.setup("ikey")
  .setInternalLogging(true, true)
  .start()
applicationInsights.defaultClient.config.maxBatchSize = 0;

A kiválasztott egyedi telemetria instrumentációs kulcsának beállítása

.NET

var telemetry = new TelemetryClient();
telemetry.InstrumentationKey = "---my key---";
// ...

Node.js

Dinamikus kapcsolati sztring

A fejlesztési, tesztelési és éles környezetekből származó telemetriai adatok keveredésének elkerülése érdekében létrehozhat külön Application Insights-erőforrásokat , és a környezettől függően módosíthatja a kulcsokat.

Ahelyett, hogy a konfigurációs fájlból kérné le az instrumentációs kulcsot, beállíthatja a kódban. Állítsa be a kulcsot inicializálási módszerben, például global.aspx.cs egy ASP.NET szolgáltatásban:

.NET

protected void Application_Start()
{
    Microsoft.ApplicationInsights.Extensibility.
    TelemetryConfiguration.Active.InstrumentationKey =
        // - for example -
        WebConfigurationManager.Settings["ikey"];
    ...
}

Node.js

Nem alkalmazható.

TelemetryContext

TelemetryClient Egy Környezeti tulajdonsággal rendelkezik, amely az összes telemetriai adattal együtt elküldött értékeket tartalmazza. Ezeket általában a standard telemetriai modulok állítják be, de ön is beállíthatja őket. Például:

telemetry.Context.Operation.Name = "MyOperationName";

Ha ezeket az értékeket saját maga állítja be, vegye fontolóra a megfelelő sor eltávolítását aApplicationInsights.config , hogy az értékek és a standard értékek ne keveredhessenek össze.

• Összetevő: Az alkalmazás és annak verziója.
• Eszköz: Adatok arról az eszközről, amelyen az alkalmazás fut. A webalkalmazásokban az a kiszolgáló vagy ügyféleszköz, amelyről a telemetriát elküldi a rendszer.
• InstrumentationKey: Az Application Insights-erőforrás az Azure-ban, ahol megjelenik a telemetria. Általában az ApplicationInsights.config-ból veszik.
• Hely: Az eszköz földrajzi helye.
• Művelet: Webalkalmazásokban az aktuális HTTP-kérés. Más alkalmazástípusokban ezt az értéket úgy állíthatja be, hogy csoportosítsa az eseményeket.
  • Azonosító: Olyan generált érték, amely különböző eseményeket korrelál, így amikor bármilyen eseményt megvizsgál a Diagnosztikai keresésben, megkeresheti a kapcsolódó elemeket.
  • Név: Egy azonosító, általában a HTTP-kérés URL-címe.
  • Szintetikusforrás: Ha nem null értékű vagy üres, egy sztring, amely azt jelzi, hogy a kérés forrása robotként vagy webes tesztként lett azonosítva. Alapértelmezés szerint ki van zárva a Metrics Explorer számításaiból.
• Munkamenet: A felhasználó munkamenete. Az azonosító egy generált értékre van állítva, amely akkor változik, ha a felhasználó egy ideje nem aktív.
• Felhasználó: Felhasználói adatok.

Limits

Az alkalmazásonkénti metrikák és események, azaz a kapcsolati sztringek száma korlátozott. A korlátozások a választott díjszabási csomagtól függően változnak.

Resource	Alapértelmezett korlát	Maximális határ	Jegyzetek
Napi teljes adatmennyiség	100 GB	Kapcsolatfelvétel az ügyfélszolgálattal.	Az adatok csökkentéséhez beállíthat egy korlátot. Ha több adatra van szüksége, a portálon akár 1000 GB-ra is növelheti a korlátot. Az 1000 GB-nál nagyobb kapacitások esetén küldjön e-mailt a következő címre AIDataCap@microsoft.com: .
Fojtás	32 000 esemény/másodperc	Kapcsolatfelvétel az ügyfélszolgálattal.	A korlát megállapítása egy percnyi mérés alapján történik.
Adatmegőrzési naplók	30–730 nap	730 nap	Ez az erőforrás a naplók számára készült .
Adatmegőrzési metrikák	90 nap	90 nap	Ez az erőforrás a Metrics Explorerhez készült.
Rendelkezésre állási többlépéses teszt részletes eredményeinek tárolása	90 nap	90 nap	Ez az erőforrás minden lépésről részletes eredményeket biztosít.
Telemetriai elemek maximális mérete	64 KB	64 KB
Telemetriaelemek maximális száma kötegenként	64,000	64,000
Tulajdonság- és metrikanév hossza	150	150	Lásd a típussémákat.
Tulajdonságérték-karakterlánc hossza	8,192	8,192	Lásd a típussémákat.
Nyomkövetési és kivételüzenet hossza	32,768	32,768	Lásd a típussémákat.
A rendelkezésre állási tesztek száma Application Insights-erőforrásonként	100	100
Rendelkezésre állási tesztek száma erőforráscsoportonként	800	800	Lásd: Azure Resource Manager
A rendelkezésre állási tesztek maximális átirányítása tesztenként	10	10
Rendelkezésre állási tesztek minimális tesztelési gyakorisága	300 másodperc		Az 5 percnél rövidebb egyéni tesztelési gyakoriságok vagy frekvenciák egyéni TrackAvailability implementációt igényelnek.
.NET Profiler és Snapshot Debugger adatmegőrzés	Két hét	Kapcsolatfelvétel az ügyfélszolgálattal. A maximális megőrzési korlát hat hónap.
Naponta küldött .NET Profiler-adatok	Nincs korlát	Nincs korlát.
Pillanatkép-hibakereső által küldött adatok naponta	Naponta 30 pillanatkép figyelt alkalmazásonként	Nincs korlát.	Az alkalmazásonként gyűjtött pillanatképek száma konfigurációval módosítható.

A díjszabásról és a kvótákról további információt az Application Insights számlázásában talál.

Az adatsebesség-korlát elérésének elkerülése érdekében használjon mintavételezést.

Az adatok megőrzésének időtartamáról további információt az adatmegőrzés és az adatvédelem című témakörben talál.

Mintaalkalmazások

.NET Core-konzolalkalmazás: Ezt a mintát akkor használja, ha .NET Core (2.0 vagy újabb) vagy .NET-keretrendszerben (4.7.2 vagy újabb) írt konzolalkalmazást használ.

ASP.NET Alapvető háttérfeladatok a HostedServices szolgáltatással: Ezt a mintát akkor használja, ha ASP.NET Core-ban van, és a hivatalos útmutatásnak megfelelően hozza létre a háttérfeladatokat.

.NET Core Worker Service: Ezt a mintát akkor használja, ha a hivatalos útmutatásnak megfelelően .NET Worker Service-alkalmazással rendelkezik.

Hibaelhárítás

A .NET-hez és aNode.jskapcsolódó hibaelhárítási cikkeket itt találja.

Az alkalmazásgazda és a betöltési szolgáltatás közötti kapcsolat tesztelése

Az Application Insights SDK-k és ügynökök telemetria adatokat küldenek, hogy azok REST-hívásokként feldolgozásra kerüljenek az adatgyűjtési végpontjainkon. A webkiszolgálóról vagy az alkalmazásgazdagépről a betöltési szolgáltatás végpontjaihoz való kapcsolódást a PowerShellből vagy curl parancsokból származó nyers REST-ügyfelek használatával tesztelheti. Tekintse meg a hiányzó alkalmazástelemetria hibaelhárítását az Azure Monitor Application Insightsban.

Nyílt forráskódú SDK

Olvassa el és járuljon hozzá a .NET és Node.jskódhoz.

Kibocsátási megjegyzések

• Az Application Insights kibocsátási megjegyzései
• .NET SDK-kiadások a GitHubon
• Node.js SDK-kiadások a GitHubon

A szolgáltatásfrissítések az Application Insights főbb fejlesztéseit is összefoglalják.

Következő lépések

• Ellenőrizze, hogy az Application Insights SDK támogatott verzióját futtatja-e .
• Az Application Insights-típusok és adatmodellek adatmodelljének megtekintése.
• Tekintse meg a System.Diagnostics.Activity felhasználói útmutatót , amelyből megtudhatja, hogyan korreláljuk a telemetriát.
• A gyakori kérdések (GYIK) áttekintéséhez lásd:
  • ASP.NET gyakori kérdések
  • ASP.NET alapvető gyakori kérdések
  • Feldolgozói szolgáltatás – gyakori kérdések
  • Node.js gyakori kérdések
  • API egyéni eseményekhez és metrikákhoz – gyakori kérdések