Monitorování aplikací .NET a Node.js pomocí Application Insights (Classic API 2.x)

Upozornění

Důležité

Pro nové aplikace použijte distro OpenTelemetry služby Azure Monitor.

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

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

Podporované scénáře

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

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

Poznámka:

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

Přidání Application Insights

V této části

Předpoklady

Instrumentace aplikace pomocí sady Application Insights SDK

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

ASP.NET

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

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

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

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


    Rozbalením zobrazíte konfiguraci. 
    <?xml version="1.0" encoding="utf-8"?>
<ApplicationInsights xmlns="http://schemas.microsoft.com/ApplicationInsights/2013/Settings">
  <TelemetryInitializers>
    <Add Type="Microsoft.ApplicationInsights.DependencyCollector.HttpDependenciesParsingTelemetryInitializer, Microsoft.AI.DependencyCollector" />
    <Add Type="Microsoft.ApplicationInsights.WindowsServer.AzureRoleEnvironmentTelemetryInitializer, Microsoft.AI.WindowsServer" />
    <Add Type="Microsoft.ApplicationInsights.WindowsServer.BuildInfoConfigComponentVersionTelemetryInitializer, Microsoft.AI.WindowsServer" />
    <Add Type="Microsoft.ApplicationInsights.Web.WebTestTelemetryInitializer, Microsoft.AI.Web" />
    <Add Type="Microsoft.ApplicationInsights.Web.SyntheticUserAgentTelemetryInitializer, Microsoft.AI.Web">
      <!-- Extended list of bots:
            search|spider|crawl|Bot|Monitor|BrowserMob|BingPreview|PagePeeker|WebThumb|URL2PNG|ZooShot|GomezA|Google SketchUp|Read Later|KTXN|KHTE|Keynote|Pingdom|AlwaysOn|zao|borg|oegp|silk|Xenu|zeal|NING|htdig|lycos|slurp|teoma|voila|yahoo|Sogou|CiBra|Nutch|Java|JNLP|Daumoa|Genieo|ichiro|larbin|pompos|Scrapy|snappy|speedy|vortex|favicon|indexer|Riddler|scooter|scraper|scrubby|WhatWeb|WinHTTP|voyager|archiver|Icarus6j|mogimogi|Netvibes|altavista|charlotte|findlinks|Retreiver|TLSProber|WordPress|wsr-agent|http client|Python-urllib|AppEngine-Google|semanticdiscovery|facebookexternalhit|web/snippet|Google-HTTP-Java-Client-->
      <Filters>search|spider|crawl|Bot|Monitor|AlwaysOn</Filters>
    </Add>
    <Add Type="Microsoft.ApplicationInsights.Web.ClientIpHeaderTelemetryInitializer, Microsoft.AI.Web" />
    <Add Type="Microsoft.ApplicationInsights.Web.AzureAppServiceRoleNameFromHostNameHeaderInitializer, Microsoft.AI.Web" />
    <Add Type="Microsoft.ApplicationInsights.Web.OperationNameTelemetryInitializer, Microsoft.AI.Web" />
    <Add Type="Microsoft.ApplicationInsights.Web.OperationCorrelationTelemetryInitializer, Microsoft.AI.Web" />
    <Add Type="Microsoft.ApplicationInsights.Web.UserTelemetryInitializer, Microsoft.AI.Web" />
    <Add Type="Microsoft.ApplicationInsights.Web.AuthenticatedUserIdTelemetryInitializer, Microsoft.AI.Web" />
    <Add Type="Microsoft.ApplicationInsights.Web.AccountIdTelemetryInitializer, Microsoft.AI.Web" />
    <Add Type="Microsoft.ApplicationInsights.Web.SessionTelemetryInitializer, Microsoft.AI.Web" />
  </TelemetryInitializers>
  <TelemetryModules>
    <Add Type="Microsoft.ApplicationInsights.DependencyCollector.DependencyTrackingTelemetryModule, Microsoft.AI.DependencyCollector">
      <ExcludeComponentCorrelationHttpHeadersOnDomains>
        <!--
        Requests to the following hostnames will not be modified by adding correlation headers.
        Add entries here to exclude additional hostnames.
        NOTE: this configuration will be lost upon NuGet upgrade.
        -->
        <Add>core.windows.net</Add>
        <Add>core.chinacloudapi.cn</Add>
        <Add>core.cloudapi.de</Add>
        <Add>core.usgovcloudapi.net</Add>
      </ExcludeComponentCorrelationHttpHeadersOnDomains>
      <IncludeDiagnosticSourceActivities>
        <Add>Microsoft.Azure.EventHubs</Add>
        <Add>Azure.Messaging.ServiceBus</Add>
      </IncludeDiagnosticSourceActivities>
    </Add>
    <Add Type="Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.PerformanceCollectorModule, Microsoft.AI.PerfCounterCollector">
      <!--
      Use the following syntax here to collect additional performance counters:

      <Counters>
        <Add PerformanceCounter="\Process(??APP_WIN32_PROC??)\Handle Count" ReportAs="Process handle count" />
        ...
      </Counters>

      PerformanceCounter must be either \CategoryName(InstanceName)\CounterName or \CategoryName\CounterName

      NOTE: performance counters configuration will be lost upon NuGet upgrade.

      The following placeholders are supported as InstanceName:
        ??APP_WIN32_PROC?? - instance name of the application process for Win32 counters.
        ??APP_W3SVC_PROC?? - instance name of the application IIS worker process for IIS/ASP.NET counters.
        ??APP_CLR_PROC?? - instance name of the application CLR process for .NET counters.
      -->
    </Add>
    <Add Type="Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse.QuickPulseTelemetryModule, Microsoft.AI.PerfCounterCollector" />
    <Add Type="Microsoft.ApplicationInsights.WindowsServer.AppServicesHeartbeatTelemetryModule, Microsoft.AI.WindowsServer" />
    <Add Type="Microsoft.ApplicationInsights.WindowsServer.AzureInstanceMetadataTelemetryModule, Microsoft.AI.WindowsServer">
      <!--
      Remove individual fields collected here by adding them to the ApplicationInsighs.HeartbeatProvider
      with the following syntax:

      <Add Type="Microsoft.ApplicationInsights.Extensibility.Implementation.Tracing.DiagnosticsTelemetryModule, Microsoft.ApplicationInsights">
        <ExcludedHeartbeatProperties>
          <Add>osType</Add>
          <Add>location</Add>
          <Add>name</Add>
          <Add>offer</Add>
          <Add>platformFaultDomain</Add>
          <Add>platformUpdateDomain</Add>
          <Add>publisher</Add>
          <Add>sku</Add>
          <Add>version</Add>
          <Add>vmId</Add>
          <Add>vmSize</Add>
          <Add>subscriptionId</Add>
          <Add>resourceGroupName</Add>
          <Add>placementGroupId</Add>
          <Add>tags</Add>
          <Add>vmScaleSetName</Add>
        </ExcludedHeartbeatProperties>
      </Add>

      NOTE: exclusions will be lost upon upgrade.
      -->
    </Add>
    <Add Type="Microsoft.ApplicationInsights.WindowsServer.DeveloperModeWithDebuggerAttachedTelemetryModule, Microsoft.AI.WindowsServer" />
    <Add Type="Microsoft.ApplicationInsights.WindowsServer.UnhandledExceptionTelemetryModule, Microsoft.AI.WindowsServer" />
    <Add Type="Microsoft.ApplicationInsights.WindowsServer.UnobservedExceptionTelemetryModule, Microsoft.AI.WindowsServer">
      <!--</Add>
    <Add Type="Microsoft.ApplicationInsights.WindowsServer.FirstChanceExceptionStatisticsTelemetryModule, Microsoft.AI.WindowsServer">-->
    </Add>
    <Add Type="Microsoft.ApplicationInsights.Web.RequestTrackingTelemetryModule, Microsoft.AI.Web">
      <Handlers>
        <!--
        Add entries here to filter out additional handlers:

        NOTE: handler configuration will be lost upon NuGet upgrade.
        -->
        <Add>Microsoft.VisualStudio.Web.PageInspector.Runtime.Tracing.RequestDataHttpHandler</Add>
        <Add>System.Web.StaticFileHandler</Add>
        <Add>System.Web.Handlers.AssemblyResourceLoader</Add>
        <Add>System.Web.Optimization.BundleHandler</Add>
        <Add>System.Web.Script.Services.ScriptHandlerFactory</Add>
        <Add>System.Web.Handlers.TraceHandler</Add>
        <Add>System.Web.Services.Discovery.DiscoveryRequestHandler</Add>
        <Add>System.Web.HttpDebugHandler</Add>
      </Handlers>
    </Add>
    <Add Type="Microsoft.ApplicationInsights.Web.ExceptionTrackingTelemetryModule, Microsoft.AI.Web" />
    <Add Type="Microsoft.ApplicationInsights.Web.AspNetDiagnosticTelemetryModule, Microsoft.AI.Web" />
  </TelemetryModules>
  <ApplicationIdProvider Type="Microsoft.ApplicationInsights.Extensibility.Implementation.ApplicationId.ApplicationInsightsApplicationIdProvider, Microsoft.ApplicationInsights" />
  <TelemetrySinks>
    <Add Name="default">
      <TelemetryProcessors>
        <Add Type="Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse.QuickPulseTelemetryProcessor, Microsoft.AI.PerfCounterCollector" />
        <Add Type="Microsoft.ApplicationInsights.Extensibility.AutocollectedMetricsExtractor, Microsoft.ApplicationInsights" />
        <Add Type="Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel.AdaptiveSamplingTelemetryProcessor, Microsoft.AI.ServerTelemetryChannel">
          <MaxTelemetryItemsPerSecond>5</MaxTelemetryItemsPerSecond>
          <ExcludedTypes>Event</ExcludedTypes>
        </Add>
        <Add Type="Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel.AdaptiveSamplingTelemetryProcessor, Microsoft.AI.ServerTelemetryChannel">
          <MaxTelemetryItemsPerSecond>5</MaxTelemetryItemsPerSecond>
          <IncludedTypes>Event</IncludedTypes>
        </Add>
        <!--
          Adjust the include and exclude examples to specify the desired semicolon-delimited types. (Dependency, Event, Exception, PageView, Request, Trace)
        -->
      </TelemetryProcessors>
      <TelemetryChannel Type="Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel.ServerTelemetryChannel, Microsoft.AI.ServerTelemetryChannel" />
    </Add>
  </TelemetrySinks>
  <!--
    Learn more about Application Insights configuration with ApplicationInsights.config here:
    http://go.microsoft.com/fwlink/?LinkID=513840
  -->
  <ConnectionString>Copy the connection string from your Application Insights resource</ConnectionString>
</ApplicationInsights>

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

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

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

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

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

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

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

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

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

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

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

    using System.Web;
using System.Web.Mvc;

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

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


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

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

ASP.NET Core

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

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

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

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

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

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

    // This method gets called by the runtime. Use this method to add services to the container.
var builder = WebApplication.CreateBuilder(args);

// The following line enables Application Insights telemetry collection.
builder.Services.AddApplicationInsightsTelemetry();

// This code adds other services for your application.
builder.Services.AddMvc();

var app = builder.Build();

  3. Přidejte připojovací řetězec, který lze nastavit třemi způsoby:

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

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

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

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

      Například:

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

      Poznámka:

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

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

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

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

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

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

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

Pracovní služba

V této části
Použití sady Application Insights SDK pro pracovní službu

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

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

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

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

    Snímek obrazovky zobrazující přehled Application Insights a připojovací řetězec

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

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

aplikace .NET Core Worker Service

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

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

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

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

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

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

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

        using Microsoft.ApplicationInsights;
    using Microsoft.ApplicationInsights.DataContracts;

    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;
        private TelemetryClient _telemetryClient;
        private static HttpClient _httpClient = new HttpClient();

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

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);

                using (_telemetryClient.StartOperation<RequestTelemetry>("operation"))
                {
                    _logger.LogWarning("A sample warning message. By default, logs with severity Warning or higher is captured by Application Insights");
                    _logger.LogInformation("Calling bing.com");
                    var res = await _httpClient.GetAsync("https://bing.com");
                    _logger.LogInformation("Calling bing completed with status:" + res.StatusCode);
                    _telemetryClient.TrackEvent("Bing call event completed");
                }

                await Task.Delay(1000, stoppingToken);
            }
        }
    }

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

    Snímek obrazovky znázorňující přehled Application Insights a připojovací řetězec

    Poznámka:

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

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

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

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

Poznámka:

Connection string zadaný v kódu má přednost před proměnnou prostředí APPLICATIONINSIGHTS_CONNECTION_STRING, která má přednost před jinými možnostmi.

Zadání úloh na pozadí v ASP.NET Core pomocí hostovaných služeb

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

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

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

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

        public static async Task Main(string[] args)
    {
        var host = new HostBuilder()
            .ConfigureAppConfiguration((hostContext, config) =>
            {
                config.AddJsonFile("appsettings.json", optional: true);
            })
            .ConfigureServices((hostContext, services) =>
            {
                services.AddLogging();
                services.AddHostedService<TimedHostedService>();

                // connection string is read automatically from appsettings.json
                services.AddApplicationInsightsTelemetryWorkerService();
            })
            .UseConsoleLifetime()
            .Build();

        using (host)
        {
            // Start the host
            await host.StartAsync();

            // Wait for the host to shutdown
            await host.WaitForShutdownAsync();
        }
    }

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

        using Microsoft.ApplicationInsights;
    using Microsoft.ApplicationInsights.DataContracts;

    public class TimedHostedService : IHostedService, IDisposable
    {
        private readonly ILogger _logger;
        private Timer _timer;
        private TelemetryClient _telemetryClient;
        private static HttpClient httpClient = new HttpClient();

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

        public Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("Timed Background Service is starting.");

            _timer = new Timer(DoWork, null, TimeSpan.Zero,
                TimeSpan.FromSeconds(1));

            return Task.CompletedTask;
        }

        private void DoWork(object state)
        {
            _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);

            using (_telemetryClient.StartOperation<RequestTelemetry>("operation"))
            {
                _logger.LogWarning("A sample warning message. By default, logs with severity Warning or higher is captured by Application Insights");
                _logger.LogInformation("Calling bing.com");
                var res = httpClient.GetAsync("https://bing.com").GetAwaiter().GetResult();
                _logger.LogInformation("Calling bing completed with status:" + res.StatusCode);
                _telemetryClient.TrackEvent("Bing call event completed");
            }
        }
    }

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

Konzolová aplikace .NET Core/.NET Framework

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

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

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

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

        using Microsoft.ApplicationInsights;
    using Microsoft.ApplicationInsights.DataContracts;
    using Microsoft.ApplicationInsights.WorkerService;
    using Microsoft.Extensions.DependencyInjection;
    using Microsoft.Extensions.Logging;
    using System;
    using System.Net.Http;
    using System.Threading.Tasks;

    namespace WorkerSDKOnConsole
    {
        class Program
        {
            static async Task Main(string[] args)
            {
                // Create the DI container.
                IServiceCollection services = new ServiceCollection();

                // Being a regular console app, there is no appsettings.json or configuration providers enabled by default.
                // Hence connection string and any changes to default logging level must be specified here.
                services.AddLogging(loggingBuilder => loggingBuilder.AddFilter<Microsoft.Extensions.Logging.ApplicationInsights.ApplicationInsightsLoggerProvider>("Category", LogLevel.Information));
                services.AddApplicationInsightsTelemetryWorkerService((ApplicationInsightsServiceOptions options) => options.ConnectionString = "<YOUR-CONNECTION-STRING>");

                // To pass a connection string
                // - aiserviceoptions must be created
                // - set connectionstring on it
                // - pass it to AddApplicationInsightsTelemetryWorkerService()

                // Build ServiceProvider.
                IServiceProvider serviceProvider = services.BuildServiceProvider();

                // Obtain logger instance from DI.
                ILogger<Program> logger = serviceProvider.GetRequiredService<ILogger<Program>>();

                // Obtain TelemetryClient instance from DI, for additional manual tracking or to flush.
                var telemetryClient = serviceProvider.GetRequiredService<TelemetryClient>();

                var httpClient = new HttpClient();

                while (true) // This app runs indefinitely. Replace with actual application termination logic.
                {
                    logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);

                    // Replace with a name which makes sense for this operation.
                    using (telemetryClient.StartOperation<RequestTelemetry>("operation"))
                    {
                        logger.LogWarning("A sample warning message. By default, logs with severity Warning or higher is captured by Application Insights");
                        logger.LogInformation("Calling bing.com");
                        var res = await httpClient.GetAsync("https://bing.com");
                        logger.LogInformation("Calling bing completed with status:" + res.StatusCode);
                        telemetryClient.TrackEvent("Bing call event completed");
                    }

                    await Task.Delay(1000);
                }

                // Explicitly call Flush() followed by sleep is required in console apps.
                // This is to ensure that even if application terminates, telemetry is sent to the back-end.
                telemetryClient.Flush();
                Task.Delay(5000).Wait();
            }
        }
    }

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

Nasazení agenta Application Insights pro místní servery

V této části

Agent Application Insights je modul PowerShellu publikovaný na Galerie prostředí PowerShell. Nahrazuje monitorování stavu. Telemetrie se odesílá na portál Azure, kde můžete monitorovat vaši aplikaci.

Pro úplný seznam podporovaných scénářů autoinstrumentace se podívejte na Podporovaná prostředí, jazyky a poskytovatele zdrojů.

Poznámka:

Modul v současné době podporuje bezkódovou instrumentaci webových aplikací ASP.NET a ASP.NET Core hostovaných pomocí Internet Information Services (IIS). K instrumentaci Java a Node.js aplikací použijte sadu SDK.

Poznámka:

Monitorování na straně klienta je ve výchozím nastavení povolené pro aplikace ASP.NET Core. Pokud chcete zakázat monitorování na straně klienta, definujte na serveru proměnnou prostředí s následujícími informacemi:

  • Jméno:APPINSIGHTS_JAVASCRIPT_ENABLED
  • Hodnota:false

Začínáme

Tato část obsahuje příkazy pro rychlý start, u které se očekává, že budou fungovat pro většinu prostředí. Pokyny závisí na Galerie prostředí PowerShell k distribuci aktualizací. Tyto příkazy podporují parametr PowerShellu -Proxy .

Vysvětlení těchto příkazů, pokynů k přizpůsobení a informací o řešení potíží najdete v podrobných pokynech.

Pokud nemáte předplatné Azure, vytvořte si bezplatný účet před zahájením.

Poznámka:

Potřebné požadavky najdete v tématu Podpora protokolu TLS (Transport Layer Security) Galerie PowerShell.

  1. Nainstalujte modul (spusťte ho jako správce):

    Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process -Force
Install-PackageProvider -Name NuGet -MinimumVersion 2.8.5.201 -Force
Set-PSRepository -Name "PSGallery" -InstallationPolicy Trusted
Install-Module -Name PowerShellGet -Force

  2. Instalace agenta Application Insights (spustit jako správce):

    Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process -Force
Install-Module -Name Az.ApplicationMonitor -AllowPrerelease -AcceptLicense

    Poznámka:

    Přepínač AllowPrerelease v rutině Install-Module umožňuje instalaci beta verze.

    Další informace viz Install-Module.

  3. Povolit monitorování:

    Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process -Force
Enable-ApplicationInsightsMonitoring -ConnectionString 'InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://xxxx.applicationinsights.azure.com/'
Možnost 2: Ruční stažení a instalace agenta Application Insights (offline možnost)

  1. Nejnovější verzi modulu si můžete stáhnout ručně z Galerie prostředí PowerShell.

  2. Rozbalte a nainstalujte agenta Application Insights:

    $pathToNupkg = "C:\Users\t\Desktop\Az.ApplicationMonitor.0.3.0-alpha.nupkg"
$pathToZip = ([io.path]::ChangeExtension($pathToNupkg, "zip"))
$pathToNupkg | rename-item -newname $pathToZip
$pathInstalledModule = "$Env:ProgramFiles\WindowsPowerShell\Modules\Az.ApplicationMonitor"
Expand-Archive -LiteralPath $pathToZip -DestinationPath $pathInstalledModule

  3. Povolit monitorování:

    Enable-ApplicationInsightsMonitoring -ConnectionString 'InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://xxxx.applicationinsights.azure.com/'

Podrobné pokyny

Tato část popisuje, jak se připojit do Galerie prostředí PowerShell a stáhnout modul ApplicationMonitor. Zahrnuté jsou nejběžnější parametry, které potřebujete k tomu, abyste mohli začít. Poskytujeme také pokyny pro ruční stažení pro případ, že nemáte přístup k internetu.

Spuštění PowerShellu jako správce pomocí zásad spouštění se zvýšenými oprávněními

Důležité

PowerShell potřebuje oprávnění na úrovni správce k provádění změn v počítači.

Zásady spouštění

  • Popis: Ve výchozím nastavení je spouštění skriptů PowerShellu zakázané. Doporučujeme povolit skripty RemoteSigned pouze pro aktuální rozsah.
  • Referenční informace: O zásadách spouštění a Set-ExecutionPolicy.
  • Příkaz: Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process.
  • Volitelný parametr:
    • -Force. Přeskočí výzvu k potvrzení.

Ukázkové chyby

Install-Module : The 'Install-Module' command was found in the module 'PowerShellGet', but the module could not be
loaded. For more information, run 'Import-Module PowerShellGet'.

Import-Module : File C:\Program Files\WindowsPowerShell\Modules\PackageManagement\1.3.1\PackageManagement.psm1 cannot
be loaded because running scripts is disabled on this system. For more information, see about_Execution_Policies at https://go.microsoft.com/fwlink/?LinkID=135170.
Předpoklady pro PowerShell

Auditujte instanci PowerShellu spuštěním příkazu $PSVersionTable. Tento příkaz vytvoří následující výstup:

Name                           Value
----                           -----
PSVersion                      5.1.17763.316
PSEdition                      Desktop
PSCompatibleVersions           {1.0, 2.0, 3.0, 4.0...}
BuildVersion                   10.0.17763.316
CLRVersion                     4.0.30319.42000
WSManStackVersion              3.0
PSRemotingProtocolVersion      2.3
SerializationVersion           1.1.0.1

Tyto pokyny byly napsány a testovány na počítači s Windows 10 a následujícími verzemi.

Tento postup připraví server na stahování modulů z Galerie prostředí PowerShell.

Poznámka:

Galerie prostředí PowerShell podporuje Windows 10, Windows Server 2016 a PowerShell 6 nebo novější. Informace o starších verzích najdete v tématu Instalace modulu PowerShellGet.

  1. Spusťte PowerShell jako správce se zvýšenou oprávnění pro spouštění.

  2. Nainstalujte zprostředkovatele balíčku NuGet.

    • Popis: K interakci s úložišti založenými na NuGetu, jako je Galerie prostředí PowerShell, potřebujete tohoto poskytovatele.
    • Referenční informace: Install-PackageProvider.
    • Příkaz: Install-PackageProvider -Name NuGet -MinimumVersion 2.8.5.201.
    • Volitelné parametry:
      • -Proxy. Určuje proxy server pro požadavek.
      • -Force. Přeskočí výzvu k potvrzení.

    Pokud nuGet není nastavený, zobrazí se tato výzva:

    NuGet provider is required to continue
PowerShellGet requires NuGet provider version '2.8.5.201' or newer to interact with NuGet-based repositories.
The NuGet provider must be available in 'C:\Program Files\PackageManagement\ProviderAssemblies' or
'C:\Users\t\AppData\Local\PackageManagement\ProviderAssemblies'. You can also install the NuGet provider by running
'Install-PackageProvider -Name NuGet -MinimumVersion 2.8.5.201 -Force'. Do you want PowerShellGet to install and import
the NuGet provider now?
[Y] Yes  [N] No  [S] Suspend  [?] Help (default is "Y"):

  3. Nakonfigurujte Galerie prostředí PowerShell jako důvěryhodné úložiště.

    • Popis: Ve výchozím nastavení je Galerie prostředí PowerShell nedůvěryhodné úložiště.
    • Referenční informace: Set-PSRepository.
    • Příkaz: Set-PSRepository -Name "PSGallery" -InstallationPolicy Trusted.
    • Volitelný parametr:
      • -Proxy. Určuje proxy server pro požadavek.

    Pokud Galerie prostředí PowerShell není důvěryhodná, zobrazí se tato výzva:

    Untrusted repository
You are installing the modules from an untrusted repository.
If you trust this repository, change its InstallationPolicy value
by running the Set-PSRepository cmdlet. Are you sure you want to
install the modules from 'PSGallery'?
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "N"):

    Tuto změnu můžete potvrdit a auditovat vše PSRepositories spuštěním Get-PSRepository příkazu.

  4. Nainstalujte nejnovější verzi modulu PowerShellGet.

    • Popis: Tento modul obsahuje nástroje používané k získání dalších modulů z Galerie prostředí PowerShell. Verze 1.0.0.1 se dodává s Windows 10 a Windows Serverem. Vyžaduje se verze 1.6.0 nebo vyšší. Pokud chcete zjistit, která verze je nainstalovaná, spusťte Get-Command -Module PowerShellGet příkaz.
    • Referenční informace: Instalace modulu PowerShellGet.
    • Příkaz: Install-Module -Name PowerShellGet.
    • Volitelné parametry:
      • -Proxy. Určuje proxy server pro požadavek.
      • -Force. Obchází upozornění "již nainstalované" a nainstaluje nejnovější verzi.

    Tato chyba se zobrazí, pokud nepoužíváte nejnovější verzi modulu PowerShellGet:

    Install-Module : A parameter cannot be found that matches parameter name 'AllowPrerelease'.
At line:1 char:20
Install-Module abc -AllowPrerelease
               ~~~~~~~~~~~~~~~~
CategoryInfo          : InvalidArgument: (:) [Install-Module], ParameterBindingException
FullyQualifiedErrorId : NamedParameterNotFound,Install-Module

  5. Restartujte PowerShell. V aktuální relaci nemůžete načíst novou verzi. Nové relace PowerShellu načítají nejnovější verzi modulu PowerShellGet.

Provedením těchto kroků stáhnete modul Az.ApplicationMonitor z Galerie prostředí PowerShell.

  1. Ujistěte se, že jsou splněny všechny požadavky Galerie prostředí PowerShell.
  2. Spusťte PowerShell jako správce se zvýšenou oprávnění pro spouštění.
  3. Nainstalujte modul Az.ApplicationMonitor.
    • Referenční informace: Install-Module.
    • Příkaz: Install-Module -Name Az.ApplicationMonitor.
    • Volitelné parametry:
      • -Proxy. Určuje proxy server pro požadavek.
      • -AllowPrerelease. Umožňuje instalaci alfa a beta verzí.
      • -AcceptLicense. Obchází výzvu Přijmout licenci.
      • -Force. Obchází upozornění "Nedůvěryhodné úložiště".
Možnost 2: Ruční stažení a instalace modulu (offline možnost)

Pokud se z nějakého důvodu nemůžete připojit k modulu PowerShellu, můžete modul Az.ApplicationMonitor stáhnout a nainstalovat ručně.

Ruční stažení nejnovějšího souboru nupkg
  1. Přejděte na https://www.powershellgallery.com/packages/Az.ApplicationMonitor .
  2. V tabulce Historie verzí vyberte nejnovější verzi souboru.
  3. V části Možnosti instalace vyberte Ruční stažení.
Možnost 2.1: Instalace do adresáře modulů PowerShellu

Nainstalujte ručně stažený modul PowerShellu do adresáře PowerShellu, aby bylo možné ho zjistit pomocí relací PowerShellu. Další informace najdete v tématu Instalace modulu PowerShellu.

Rozbalte nupkg jako soubor ZIP pomocí Expand-Archive (v1.0.1.0)

  • Popis: Základní verze Microsoft.PowerShell.Archive (v1.0.1.0) nemůže rozbalit soubory nupkg. Přejmenujte soubor s příponou .zip.

  • Referenční informace: Rozbalit archiv.

  • Příkaz:

    $pathToNupkg = "C:\az.applicationmonitor.0.3.0-alpha.nupkg"
$pathToZip = ([io.path]::ChangeExtension($pathToNupkg, "zip"))
$pathToNupkg | rename-item -newname $pathToZip
$pathInstalledModule = "$Env:ProgramFiles\WindowsPowerShell\Modules\az.applicationmonitor"
Expand-Archive -LiteralPath $pathToZip -DestinationPath $pathInstalledModule

Rozbalte nupkg pomocí Expand-Archive (v1.1.0.0)

  • Popis: K rozbalení souborů nupkg beze změny přípony použijte aktuální verzi expand-Archive.

  • Referenční informace: Rozbalit archiv a Microsoft.PowerShell.Archive.

  • Příkaz:

    $pathToNupkg = "C:\az.applicationmonitor.0.2.1-alpha.nupkg"
$pathInstalledModule = "$Env:ProgramFiles\WindowsPowerShell\Modules\az.applicationmonitor"
Expand-Archive -LiteralPath $pathToNupkg -DestinationPath $pathInstalledModule
Možnost 2.2: Ruční rozbalení a import nupkg

Nainstalujte ručně stažený modul PowerShellu do adresáře PowerShellu, aby bylo možné ho zjistit pomocí relací PowerShellu. Další informace najdete v tématu Instalace modulu PowerShellu.

Pokud modul instalujete do jakéhokoli jiného adresáře, importujte ho ručně pomocí modulu Import-Module.

Důležité

Knihovny dynamického propojení (DLL) se instalují prostřednictvím relativních cest. Uložte obsah balíčku do zamýšleného adresáře modulu runtime a ověřte, že přístupová oprávnění umožňují čtení, ale ne zápis.

  1. Změňte rozšíření na .zip a extrahujte obsah balíčku do zamýšleného instalačního adresáře.
  2. Vyhledejte cestu k souboru Az.ApplicationMonitor.psd1.
  3. Spusťte PowerShell jako správce se zvýšenou oprávnění pro spouštění.
  4. Načtěte modul pomocí Import-Module Az.ApplicationMonitor.psd1 příkazu.
Směrování provozu přes proxy server

Když monitorujete počítač v privátním intranetu, musíte směrovat provoz HTTP přes proxy server.

Příkazy PowerShellu pro stažení a instalaci Az.ApplicationMonitor z Galerie prostředí PowerShell podporují parametr -Proxy. Při psaní instalačních skriptů si projděte předchozí pokyny.

Sada Application Insights SDK musí odesílat telemetrii vaší aplikace do Microsoftu. Doporučujeme nakonfigurovat nastavení proxy serveru pro vaši aplikaci v souboru web.config. Další informace najdete v tématu Návody dosažení průchodu proxy serverem?.

Povolení monitorování

Enable-ApplicationInsightsMonitoring Pomocí příkazu povolte monitorování.

Podrobný popis použití této rutiny najdete v referenčních informacích k rozhraní API.

Referenční informace k rozhraní API

Důležité

  • Následující cmdlety vyžadují relaci PowerShellu s oprávněními správce a zvýšenými zásadami provádění. Další informace najdete v tématu Spuštění PowerShellu jako správce s rozšířenými právy spuštění.
  • Následující rutiny vyžadují, abyste zkontrolovali a přijali naše licenční prohlášení a prohlášení o zásadách ochrany osobních údajů.
  • Instrumentační modul zvyšuje režii a ve výchozím nastavení je vypnutý.

Tato část popisuje následující rutiny, které jsou členy modulu Az.ApplicationMonitor PowerShell:

Poznámka:

Rozbalte některou z níže uvedených částí, kde najdete další informace, včetně příkladů, parametrů a výstupu.

Enable-InstrumentationEngine

Povolí instrumentační stroj nastavením některých klíčů registru. Restartujte službu IIS, aby se změny projevily.

Instrumentační modul může doplnit data shromážděná sadami SDK (.NET Software Development Kit). Shromažďuje události a zprávy, které popisují spuštění spravovaného procesu. Tyto události a zprávy zahrnují kódy výsledků závislostí, příkazy HTTP a text příkazu SQL.

Povolte instrumentační modul, pokud:

  • Monitorování pomocí rutiny Enable jste už povolili, ale nepovolili jste instrumentační modul.
  • Aplikaci jste pomocí SDK pro .NET instrumentovali ručně a chcete shromažďovat další telemetrii.
Příklady
Enable-InstrumentationEngine
Parametry
Parameter Description
-PřijmoutLicenci Optional. Tento přepínač použijte k přijetí licence a prohlášení o zásadách ochrany osobních údajů v bezobsadových instalacích.
-Užvaněný Společný parametr. Tento přepínač slouží k výstupu podrobných protokolů.
Výstup

Příklad výstupu úspěšného povolení instrumentačního stroje:

Configuring IIS Environment for instrumentation engine...
Configuring registry for instrumentation engine...
Enable-ApplicationInsightsMonitoring (Povolit monitorování Application Insights)

Umožňuje monitorování připojení bez kódu aplikací IIS na cílovém počítači.

Tato rutina upraví soubor applicationHost.config služby IIS a nastaví některé klíče registru. Vytvoří soubor applicationinsights.ikey.config, který definuje instrumentační klíč používaný jednotlivými aplikacemi. Služba IIS načte při spuštění modul RedfieldModule, který při spuštění aplikací vloží sadu Application Insights SDK do aplikací. Restartujte službu IIS, aby se změny projevily.

Po povolení monitorování doporučujeme pomocí živých metrik rychle zkontrolovat, jestli vaše aplikace odesílá telemetrii.

Příklady
Příklad s jedním připojovacím řetězcem

V tomto příkladu všechny aplikace na aktuálním počítači používají jeden řetězec připojení.

Enable-ApplicationInsightsMonitoring -ConnectionString 'InstrumentationKey=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx;IngestionEndpoint=https://xxxx.applicationinsights.azure.com/'
Příklad s jedním instrumentačním klíčem

V tomto příkladu jsou všechny aplikace v aktuálním počítači k dispozici s jedním instrumentačním klíčem.

Enable-ApplicationInsightsMonitoring -InstrumentationKey xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
Příklad s mapou instrumentačního klíče

V tomto příkladu:

  • MachineFilter odpovídá aktuálnímu počítači pomocí zástupného znaku '.*'.
  • AppFilter='WebAppExclude' null poskytuje instrumentační klíč. Zadaná aplikace není instrumentovaná.
  • AppFilter='WebAppOne' přiřadí zadané aplikaci jedinečný instrumentační klíč.
  • AppFilter='WebAppTwo' přiřadí zadané aplikaci jedinečný instrumentační klíč.
  • AppFilter používá zástupný znak '.*' k tomu, aby odpovídal všem webovým aplikacím, které ještě nesplňuje, a přiřadí výchozí instrumentační klíč.
  • Pro čitelnost se přidají mezery.
Enable-ApplicationInsightsMonitoring -InstrumentationKeyMap `
    ` @(@{MachineFilter='.*';AppFilter='WebAppExclude'},
        ` @{MachineFilter='.*';AppFilter='WebAppOne';InstrumentationSettings=@{InstrumentationKey='xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx1'}},
        ` @{MachineFilter='.*';AppFilter='WebAppTwo';InstrumentationSettings=@{InstrumentationKey='xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx2'}},
        ` @{MachineFilter='.*';AppFilter='.*';InstrumentationSettings=@{InstrumentationKey='xxxxxxxx-xxxx-xxxx-xxxx-xxxxxdefault'}})
  • MachineFilter je regulární výraz C# vyžadovaný pro název počítače nebo virtuálního počítače.
    • '.*' odpovídá libovolnému znaku
    • Počítačové jméno (ComputerName) odpovídá pouze počítačům s přesně zadaným názvem.
  • AppFilter je povinný regulární výraz v C# pro název webu služby IIS. Seznam webů na serveru můžete získat spuštěním příkazu get-iissite.
    • '.*' odpovídá libovolnému znaku
    • "SiteName odpovídá pouze IIS webu s přesně zadaným názvem."
  • InstrumentationKey se vyžaduje k povolení monitorování aplikací, které odpovídají předchozím dvěma filtrům.
    • Pokud chcete definovat pravidla pro vyloučení monitorování, ponechte tuto hodnotu null.
Parametry
Parameter Description
-PovolitNástrojovýMotor Optional. Pomocí tohoto přepínače můžete nástroji povolit shromažďování událostí a zpráv o tom, co se děje během provádění spravovaného procesu. Tyto události a zprávy zahrnují kódy výsledků závislostí, příkazy HTTP a text příkazu SQL.

Instrumentační modul přidává režii a ve výchozím nastavení je vypnutý.
-PřijmoutLicenci Optional. Tento přepínač použijte k přijetí licence a prohlášení o zásadách ochrany osobních údajů v bezobsadových instalacích.
-IgnoreSharedConfig Pokud máte cluster webových serverů, možná používáte sdílenou konfiguraci. Do této sdílené konfigurace nelze vložit modul HttpModule. Tento skript selže se zprávou, že jsou vyžadovány další kroky instalace. Tento přepínač použijte k ignorování této kontroly a pokračování v instalaci požadavků.

Další informace naleznete v tématu konflikt s konfigurací sdílenou IIS
-Užvaněný Společný parametr. Pomocí tohoto přepínače zobrazíte podrobné protokoly.
-WhatIf Společný parametr. Tento přepínač použijte k otestování a ověření vstupních parametrů bez skutečného povolení monitorování.
Výstup
Příklad výstupu z úspěšné aktivace
Initiating Disable Process
Applying transformation to 'C:\Windows\System32\inetsrv\config\applicationHost.config'
'C:\Windows\System32\inetsrv\config\applicationHost.config' backed up to 'C:\Windows\System32\inetsrv\config\applicationHost.config.backup-2019-03-26_08-59-52z'
in :1,237
No element in the source document matches '/configuration/location[@path='']/system.webServer/modules/add[@name='ManagedHttpModuleHelper']'
Not executing RemoveAll (transform line 1, 546)
Transformation to 'C:\Windows\System32\inetsrv\config\applicationHost.config' was successfully applied. Operation: 'disable'
GAC Module will not be removed, since this operation might cause IIS instabilities
Configuring IIS Environment for codeless attach...
Registry: skipping non-existent 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\IISADMIN[Environment]
Registry: skipping non-existent 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W3SVC[Environment]
Registry: skipping non-existent 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WAS[Environment]
Configuring IIS Environment for instrumentation engine...
Registry: skipping non-existent 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\IISADMIN[Environment]
Registry: skipping non-existent 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W3SVC[Environment]
Registry: skipping non-existent 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WAS[Environment]
Configuring registry for instrumentation engine...
Successfully disabled Application Insights Agent
Installing GAC module 'C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\0.2.0\content\Runtime\Microsoft.AppInsights.IIS.ManagedHttpModuleHelper.dll'
Applying transformation to 'C:\Windows\System32\inetsrv\config\applicationHost.config'
Found GAC module Microsoft.AppInsights.IIS.ManagedHttpModuleHelper.ManagedHttpModuleHelper, Microsoft.AppInsights.IIS.ManagedHttpModuleHelper, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35
'C:\Windows\System32\inetsrv\config\applicationHost.config' backed up to 'C:\Windows\System32\inetsrv\config\applicationHost.config.backup-2019-03-26_08-59-52z_1'
Transformation to 'C:\Windows\System32\inetsrv\config\applicationHost.config' was successfully applied. Operation: 'enable'
Configuring IIS Environment for codeless attach...
Configuring IIS Environment for instrumentation engine...
Configuring registry for instrumentation engine...
Updating app pool permissions...
Successfully enabled Application Insights Agent
Disable-InstrumentationEngine

Zakáže instrumentační modul odebráním některých klíčů registru. Restartujte službu IIS, aby se změny projevily.

Příklady
Disable-InstrumentationEngine
Parametry
Parameter Description
-Užvaněný Společný parametr. Tento přepínač slouží k výstupu podrobných protokolů.
Výstup
Příklad výstupu z úspěšného zakázání instrumentačního stroje
Configuring IIS Environment for instrumentation engine...
Registry: removing 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\IISADMIN[Environment]'
Registry: removing 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W3SVC[Environment]'
Registry: removing 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WAS[Environment]'
Configuring registry for instrumentation engine...
Disable-ApplicationInsightsMonitoring

Zakáže monitorování v cílovém počítači. Tato rutina odebere úpravy souboru IIS applicationHost.config a odebere klíče registru.

Příklady
Disable-ApplicationInsightsMonitoring
Parametry
Parameter Description
-Užvaněný Společný parametr. Pomocí tohoto přepínače zobrazíte podrobné protokoly.
Výstup
Příklad výstupu z úspěšného zakázání monitorování
Initiating Disable Process
Applying transformation to 'C:\Windows\System32\inetsrv\config\applicationHost.config'
'C:\Windows\System32\inetsrv\config\applicationHost.config' backed up to 'C:\Windows\System32\inetsrv\config\applicationHost.config.backup-2019-03-26_08-59-00z'
in :1,237
No element in the source document matches '/configuration/location[@path='']/system.webServer/modules/add[@name='ManagedHttpModuleHelper']'
Not executing RemoveAll (transform line 1, 546)
Transformation to 'C:\Windows\System32\inetsrv\config\applicationHost.config' was successfully applied. Operation: 'disable'
GAC Module will not be removed, since this operation might cause IIS instabilities
Configuring IIS Environment for codeless attach...
Registry: skipping non-existent 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\IISADMIN[Environment]
Registry: skipping non-existent 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W3SVC[Environment]
Registry: skipping non-existent 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WAS[Environment]
Configuring IIS Environment for instrumentation engine...
Registry: skipping non-existent 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\IISADMIN[Environment]
Registry: skipping non-existent 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W3SVC[Environment]
Registry: skipping non-existent 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WAS[Environment]
Configuring registry for instrumentation engine...
Successfully disabled Application Insights Agent
Get-ApplicationInsightsMonitoringConfig

Získá konfigurační soubor a vytiskne hodnoty do konzoly.

Příklady
Get-ApplicationInsightsMonitoringConfig
Parametry

Nejsou vyžadovány žádné parametry.

Výstup
Příklad výstupu ze čtení konfiguračního souboru
RedfieldConfiguration:
Filters:
0)InstrumentationKey: AppFilter: WebAppExclude MachineFilter: .*
1)InstrumentationKey: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx2 AppFilter: WebAppTwo MachineFilter: .*
2)InstrumentationKey: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxdefault AppFilter: .* MachineFilter: .*
Get-ApplicationInsightsMonitoringStatus

Tento cmdlet poskytuje informace o řešení potíží s agentem Application Insights. Pomocí této rutiny můžete prozkoumat stav monitorování, verzi modulu PowerShellu a zkontrolovat spuštěný proces. Tato rutina hlásí informace o verzi a klíčových souborech potřebných k monitorování.

Příklady
Příklad: Stav aplikace

Spuštěním příkazu Get-ApplicationInsightsMonitoringStatus zobrazte stav monitorování webů.

Get-ApplicationInsightsMonitoringStatus

IIS Websites:

SiteName               : Default Web Site
ApplicationPoolName    : DefaultAppPool
SiteId                 : 1
SiteState              : Stopped

SiteName               : DemoWebApp111
ApplicationPoolName    : DemoWebApp111
SiteId                 : 2
SiteState              : Started
ProcessId              : not found

SiteName               : DemoWebApp222
ApplicationPoolName    : DemoWebApp222
SiteId                 : 3
SiteState              : Started
ProcessId              : 2024
Instrumented           : true
InstrumentationKey     : xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxx123

SiteName               : DemoWebApp333
ApplicationPoolName    : DemoWebApp333
SiteId                 : 4
SiteState              : Started
ProcessId              : 5184
AppAlreadyInstrumented : true

V tomto příkladu:

  • Identifikátor počítače je anonymní ID sloužící k jednoznačné identifikaci serveru. Pokud vytvoříte žádost o podporu, potřebujeme toto ID k vyhledání protokolů pro váš server.

  • Výchozí web je v IIS zastavený

  • Služba IIS zobrazuje DemoWebApp111 jako spuštěnou, ale aplikace nedostává žádné požadavky. Sestava nezobrazuje žádný spuštěný proces (ProcessId: nenalezena).

  • DemoWebApp222 je spuštěna a je monitorována (instrumentováno: true). Na základě konfigurace uživatele byl pro toto místo identifikován klíč instrumentace xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxx123.

  • DemoWebApp333 se ručně instrumentuje pomocí sady Application Insights SDK. Agent Application Insights detekuje sadu SDK a nemonitoruje tento web.

  • Přítomnost AppAlreadyInstrumented : true znamená, že agent Application Insights identifikoval konfliktní knihovnu DLL načtenou do webové aplikace a předpokládá, že webová aplikace je ručně instrumentovaná. Agent ustoupil a neinstrumentuje tento proces.

  • Instrumented : true označuje, že agent Application Insights úspěšně instrumentoval webovou aplikaci spuštěnou v zadaném procesu w3wp.exe.

Příklad: Informace o modulu PowerShellu

Spuštěním příkazu Get-ApplicationInsightsMonitoringStatus -PowerShellModule zobrazte informace o aktuálním modulu:

Get-ApplicationInsightsMonitoringStatus -PowerShellModule

PowerShell Module version:
0.4.0-alpha

Application Insights SDK version:
2.9.0.3872

Executing PowerShell Module Assembly:
Microsoft.ApplicationInsights.Redfield.Configurator.PowerShell, Version=2.8.14.11432, Culture=neutral, PublicKeyToken=31bf3856ad364e35

PowerShell Module Directory:
C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\0.2.2\content\PowerShell

Runtime Paths:
ParentDirectory (Exists: True)
C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content

ConfigurationPath (Exists: True)
C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\applicationInsights.ikey.config

ManagedHttpModuleHelperPath (Exists: True)
C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Runtime\Microsoft.AppInsights.IIS.ManagedHttpModuleHelper.dll

RedfieldIISModulePath (Exists: True)
C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Runtime\Microsoft.ApplicationInsights.RedfieldIISModule.dll

InstrumentationEngine86Path (Exists: True)
C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Instrumentation32\MicrosoftInstrumentationEngine_x86.dll

InstrumentationEngine64Path (Exists: True)
C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Instrumentation64\MicrosoftInstrumentationEngine_x64.dll

InstrumentationEngineExtensionHost86Path (Exists: True)
C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Instrumentation32\Microsoft.ApplicationInsights.ExtensionsHost_x86.dll

InstrumentationEngineExtensionHost64Path (Exists: True)
C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Instrumentation64\Microsoft.ApplicationInsights.ExtensionsHost_x64.dll

InstrumentationEngineExtensionConfig86Path (Exists: True)
C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Instrumentation32\Microsoft.InstrumentationEngine.Extensions.config

InstrumentationEngineExtensionConfig64Path (Exists: True)
C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Instrumentation64\Microsoft.InstrumentationEngine.Extensions.config

ApplicationInsightsSdkPath (Exists: True)
C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Runtime\Microsoft.ApplicationInsights.dll
Příklad: Stav modulu runtime

Proces v instrumentovaném počítači můžete zkontrolovat a zjistit, jestli jsou načteny všechny knihovny DLL. Pokud monitorování funguje, musí být načteno alespoň 12 knihoven DLL.

Spusťte příkaz Get-ApplicationInsightsMonitoringStatus -InspectProcess:

Get-ApplicationInsightsMonitoringStatus -InspectProcess

iisreset.exe /status
Status for IIS Admin Service ( IISADMIN ) : Running
Status for Windows Process Activation Service ( WAS ) : Running
Status for Net.Msmq Listener Adapter ( NetMsmqActivator ) : Running
Status for Net.Pipe Listener Adapter ( NetPipeActivator ) : Running
Status for Net.Tcp Listener Adapter ( NetTcpActivator ) : Running
Status for World Wide Web Publishing Service ( W3SVC ) : Running

handle64.exe -accepteula -p w3wp
BF0: File  (R-D)   C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Runtime\Microsoft.AI.ServerTelemetryChannel.dll
C58: File  (R-D)   C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Runtime\Microsoft.AI.AzureAppServices.dll
C68: File  (R-D)   C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Runtime\Microsoft.AI.DependencyCollector.dll
C78: File  (R-D)   C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Runtime\Microsoft.AI.WindowsServer.dll
C98: File  (R-D)   C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Runtime\Microsoft.AI.Web.dll
CBC: File  (R-D)   C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Runtime\Microsoft.AI.PerfCounterCollector.dll
DB0: File  (R-D)   C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Runtime\Microsoft.AI.Agent.Intercept.dll
B98: File  (R-D)   C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Runtime\Microsoft.ApplicationInsights.RedfieldIISModule.dll
BB4: File  (R-D)   C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Runtime\Microsoft.ApplicationInsights.RedfieldIISModule.Contracts.dll
BCC: File  (R-D)   C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Runtime\Microsoft.ApplicationInsights.Redfield.Lightup.dll
BE0: File  (R-D)   C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Runtime\Microsoft.ApplicationInsights.dll

listdlls64.exe -accepteula w3wp
0x0000000019ac0000  0x127000  C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Instrumentation64\MicrosoftInstrumentationEngine_x64.dll
0x00000000198b0000  0x4f000   C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Instrumentation64\Microsoft.ApplicationInsights.ExtensionsHost_x64.dll
0x000000000c460000  0xb2000   C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Instrumentation64\Microsoft.ApplicationInsights.Extensions.Base_x64.dll
0x000000000ad60000  0x108000  C:\Windows\TEMP\2.4.0.0.Microsoft.ApplicationInsights.Extensions.Intercept_x64.dll
Parametry

Ve výchozím nastavení tato rutina hlásí stav monitorování webových aplikací. Pomocí této možnosti zkontrolujte, jestli byla vaše aplikace úspěšně instrumentovaná. Můžete také zkontrolovat, který identifikátor nástrojů byl přiřazen vašemu webu.

Parameter Description
-PowerShellModule Volitelné. Pomocí tohoto přepínače můžete hlásit čísla verzí a cesty knihoven DLL vyžadovaných pro monitorování. Tuto možnost použijte, pokud potřebujete identifikovat verzi jakékoli knihovny DLL, včetně sady Application Insights SDK.
-InspectProcess Volitelné. Pomocí tohoto přepínače můžete hlásit, jestli je spuštěná služba IIS. Stáhne externí nástroje, které určí, jestli jsou nezbytné knihovny DLL načtené do modulu runtime služby IIS. Pokud tento proces z nějakého důvodu selže, můžete tyto příkazy spustit ručně:

* iisreset.exe /status
* \[handle64.exe\](/sysinternals/downloads/handle) -p w3wp \| findstr /I "InstrumentationEngine AI. ApplicationInsights"
* \[listdlls64.exe\](/sysinternals/downloads/listdlls) w3wp \| findstr /I "InstrumentationEngine AI ApplicationInsights"
-Force Volitelné. Používá se pouze u inspectProcess. Pomocí tohoto přepínače můžete přeskočit výzvu uživatele, která se zobrazí před stažením dalších nástrojů.
Set-ApplicationInsightsMonitoringConfig

Nastaví konfigurační soubor bez úplné přeinstalace. Restartujte službu IIS, aby se změny projevily.

Důležité

Tato cmdlet vyžaduje relaci PowerShellu s oprávněními správce.

Příklady
Příklad s jedním instrumentačním klíčem

V tomto příkladu jsou všechny aplikace v aktuálním počítači k dispozici s jedním instrumentačním klíčem.

Enable-ApplicationInsightsMonitoring -InstrumentationKey xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
Příklad s mapou instrumentačního klíče

V tomto příkladu:

  • MachineFilter odpovídá aktuálnímu počítači pomocí zástupného znaku '.*'.
  • AppFilter='WebAppExclude' null poskytuje instrumentační klíč. Zadaná aplikace není instrumentovaná.
  • AppFilter='WebAppOne' přiřadí zadané aplikaci jedinečný instrumentační klíč.
  • AppFilter='WebAppTwo' přiřadí zadané aplikaci jedinečný instrumentační klíč.
  • AppFilter používá '.*' jako zástupný znak pro shodu s webovými aplikacemi, které ještě nejsou přiřazeny, a přiděluje výchozí instrumentační klíč.
  • Pro čitelnost se přidají mezery.
Enable-ApplicationInsightsMonitoring -InstrumentationKeyMap `
    ` @(@{MachineFilter='.*';AppFilter='WebAppExclude'},
      ` @{MachineFilter='.*';AppFilter='WebAppOne';InstrumentationSettings=@{InstrumentationKey='xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx1'}},
      ` @{MachineFilter='.*';AppFilter='WebAppTwo';InstrumentationSettings=@{InstrumentationKey='xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx2'}},
      ` @{MachineFilter='.*';AppFilter='.*';InstrumentationSettings=@{InstrumentationKey='xxxxxxxx-xxxx-xxxx-xxxx-xxxxxdefault'}})
Parametry
Parameter Description
-Klíč pro Instrumentaci Povinné. Tento parametr použijte k zadání jednoho instrumentačního klíče pro použití všemi aplikacemi na cílovém počítači.
-MapaKlíčůKInstalaci Povinné. Pomocí tohoto parametru můžete zadat více instrumentačních klíčů a mapování instrumentačních klíčů používaných jednotlivými aplikacemi.

Můžete vytvořit jeden instalační skript pro několik počítačů nastavením MachineFilter.

Důležité

Aplikace odpovídají pravidlu v pořadí, v jakém je zadáte. Nejprve zadejte nejpřesnější pravidla a poslední obecná pravidla.

Důležité

InstrumentationKeyMap je pokročilá funkce směrování, která propojuje aplikace Internetové Informační Služby (IIS) na stejném počítači s prostředky Application Insights. Tato funkce se vztahuje na aplikace ASP.NET a ASP.NET Core hostované na IIS, které agent Application Insights automaticky instrumentuje.

Jak funguje porovnávání

  • Mapa definuje uspořádaný seznam pravidel s názvem filters. První odpovídající pravidlo vstoupí v platnost. Nejprve umístěte konkrétní pravidla a zakončete obecně použitelným pravidlem.
  • Každé pravidlo může přiřadit k odpovídajícím aplikacím jiný prostředek Application Insights. Upřednostněte připojovací řetězce v podporovaných scénářích, protože klíče instrumentace jsou zastaralé.

Dostupné filtry

  • MachineFilter nebo machineFilter: Regulární výraz jazyka C#, který odpovídá názvu počítače nebo virtuálního počítače. .* odpovídá všem názvům.
  • AppFilter nebo appFilter: Regulární výraz jazyka C#, který odpovídá názvu webu služby IIS (HostingEnvironment.SiteName). Tento filtr je nutný, pokud není k dispozici VirtualPathFilter nebo virtualPathFilter.
  • VirtualPathFilter nebo virtualPathFilter: Regulární výraz jazyka C#, který odpovídá virtuální cestě služby IIS (HostingEnvironment.ApplicationVirtualPath). Pomocí tohoto filtru můžete cílit na jednu aplikaci na webu.

Mapování terminologie

  • PowerShell cmdlety používají MachineFilter, AppFilter, a VirtualPathFilter.
  • Azure VM a rozšíření JSON pro Virtual Machine Scale Sets používají machineFilter, appFilter a virtualPathFilter a nastavují prostředek pomocí instrumentationSettings.

Návod

Zahrňte konečné pravidlo, které odpovídá všem aplikacím, například .*, a použijte výchozí prostředek, aby bylo chování explicitní.

Tvar mapy tohoto příkazu cmdletu

  • Zadejte -InstrumentationKeyMap jako pole hashovatelných tabulek PowerShellu.
  • Pro tento cmdlet nastavte cílový prostředek pro každé pravidlo pomocí InstrumentationSettings=@{ InstrumentationKey = '<ikey>' }.
  • Pokud chcete jeden prostředek pro všechny aplikace na počítači, použijte -ConnectionString nebo -InstrumentationKey místo toho.
Start-ApplicationInsightsMonitoringTrace

Shromažďuje události trasování událostí pro Windows (ETW), které generuje modul runtime bez kódu. Tuto rutinu použijte jako jednodušší alternativu ke spuštění perfView.

Události se vytisknou v konzole v reálném čase a zapisují se také do .etl souboru. Soubor můžete otevřít .etl pomocí nástroje PerfView pro hlubší analýzu.

Tato rutina se spustí, dokud nedosáhne časového limitu, výchozí hodnota je 5 minut nebo dokud ji ručně Ctrl + Cnezastavíte .

Příklady
Jak sbírat události

Tento postup použijte, když potřebujete zjistit, proč aplikace IIS není monitorována.

Modul runtime pro připojení bez kódu emituje události ETW při spuštění IIS a vaší aplikace.

  1. Na příkazovém řádku pro správu spusťte iisreset /stop k zastavení služby IIS a všech webových aplikací.
  2. Začněte trasovat spuštěním tohoto cmdletu.
  3. Na příkazovém řádku pro správu spusťte iisreset /start službu IIS.
  4. Spuštění aplikace vyvoláte tak, že ji zobrazíte v prohlížeči.
  5. Jakmile se aplikace dokončí načítání, stisknutím Ctrl + C ji zastavte, nebo počkejte na vypršení časového limitu pro ukončení relace.
Jaké události shromažďovat

Můžete zvolit, které zdroje událostí se mají zahrnout:

  1. -CollectSdkEvents shromažďuje události ze sady Application Insights SDK.
  2. -CollectRedfieldEvents shromažďuje události z agenta Application Insights a modulu runtime Redfield, což je užitečné pro diagnostiku spuštění služby IIS a aplikace.
  3. Shromážděte obě sady zadáním obou přepínačů.
  4. Pokud nezadáte přepínač, obě sady se ve výchozím nastavení shromažďují.
Parametry
Parameter Description
-MaxTrváníVMinutách Optional. Nastaví dobu sběru dat před vypršením časového limitu. Výchozí hodnota je 5 minut.
-LogDirectory Optional. Adresář, do kterého se má soubor .etl zapsat. Ve výchozím nastavení se soubor vytvoří v adresáři PowerShellu modulu. Úplná cesta se zobrazí při spuštění relace.
-SbíratUdálostiSdk Optional. Zahrnout události sady Application Insights SDK.
-CollectRedfieldEvents Optional. Zahrňte události z agenta Application Insights a modulu runtime Redfield.
-Užvaněný Společný parametr. Vypíše podrobné protokoly.

Výstup

Příklad spouštěcích protokolů aplikace
Start-ApplicationInsightsMonitoringTrace -CollectRedfieldEvents
Starting...
Log File: C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\logs\20190627_144217_ApplicationInsights_ETW_Trace.etl
Tracing enabled, waiting for events.
Tracing will timeout in 5 minutes. Press CTRL+C to cancel.
2:42:31 PM EVENT: Microsoft-ApplicationInsights-IIS-ManagedHttpModuleHelper Trace Resolved variables to: MicrosoftAppInsights_ManagedHttpModulePath='C:\Program Files\WindowsPowerShell\Modules\Az.ApplicationMonitor\content\Runtime\Microsoft.ApplicationInsights.RedfieldIISModule.dll', MicrosoftAppInsights_ManagedHttpModuleType='Microsoft.ApplicationInsights.RedfieldIISModule.RedfieldIISModule'
2:42:31 PM EVENT: Microsoft-ApplicationInsights-IIS-ManagedHttpModuleHelper Trace Resolved variables to: MicrosoftDiagnosticServices_ManagedHttpModulePath2='', MicrosoftDiagnosticServices_ManagedHttpModuleType2=''
2:42:31 PM EVENT: Microsoft-ApplicationInsights-IIS-ManagedHttpModuleHelper Trace Environment variable 'MicrosoftDiagnosticServices_ManagedHttpModulePath2' or 'MicrosoftDiagnosticServices_ManagedHttpModuleType2' is null, skipping managed dll loading

Nasazení agenta Application Insights pro virtuální počítače a škálovací sady virtuálních počítačů

V této části

Povolte monitorování Azure MonitorApplication Insights prostřednictvím autoinstrumentace pro ASP.NET a ASP.NET Core aplikace hostované na Internet Information Server (IIS) na Azure Virtual Machines a Škálovací sady virtuálních počítačů Azure.

Nasaďte agenta Application Insights s rozšířením virtuálního počítače. Agent automaticky zakóduje stejné signály závislostí jako sada SDK. Pomocí PowerShellu můžete automatizovat rozsáhlá nasazení.

Poznámka:

Pro úplný seznam podporovaných scénářů autoinstrumentace, viz Podporovaná prostředí, jazyky a poskytovatelé zdrojů.

Povolení monitorování pro virtuální počítače

K povolení monitorování virtuálních počítačů můžete použít portál Azure nebo PowerShell.

Možnost 1: portál Azure

  1. Na portálu Azure přejděte k prostředku Application Insights. Zkopírujte připojovací řetězec do schránky.

    Snímek obrazovky, která zobrazuje připojovací řetězec.

  2. Přejděte na virtuální počítač. V části Nastavení v nabídce na levé straně vyberte Rozšíření a aplikace>Přidat.

    Snímek obrazovky s podoknem Rozšíření a aplikace s tlačítkem Přidat

  3. Vyberte Application Insights Agent>Další.

    Snímek obrazovky znázorňující podokno Instalace rozšíření s tlačítkem Další

  4. Vložte připojovací řetězec, které jste zkopírovali v kroku 1, a vyberte Review + create.

    Snímek obrazovky, který ukazuje kartu Vytvořit s tlačítkem Zkontrolovat + vytvořit.

Možnost 2: PowerShell

Poznámka:

Začínáte s PowerShellem? Podívejte se na příručku Začínáme.

Nainstalujte nebo aktualizujte agenta Application Insights jako rozšíření pro virtuální počítače Azure:

# define variables to match your environment before running
$ResourceGroup = "<myVmResourceGroup>"
$VMName = "<myVmName>"
$Location = "<myVmLocation>"
$ConnectionString = "<myAppInsightsResourceConnectionString>"

$publicCfgJsonString = @"
{
    "redfieldConfiguration": {
        "instrumentationKeyMap": {
        "filters": [
            {
            "appFilter": ".*",
            "machineFilter": ".*",
            "virtualPathFilter": ".*",
            "instrumentationSettings" : {
                "connectionString": "$ConnectionString"
            }
            }
        ]
        }
    }
    }
"@

$privateCfgJsonString = '{}'

Set-AzVMExtension -ResourceGroupName $ResourceGroup -VMName $VMName -Location $Location -Name "ApplicationMonitoringWindows" -Publisher "Microsoft.Azure.Diagnostics" -Type "ApplicationMonitoringWindows" -Version "2.8" -SettingString $publicCfgJsonString -ProtectedSettingString $privateCfgJsonString

Poznámka:

V případě složitějších nasazení ve velkém měřítku můžete pomocí smyčky PowerShellu nainstalovat nebo aktualizovat rozšíření agenta Application Insights napříč několika virtuálními počítači.

Zadejte dotaz na stav rozšíření agenta Application Insights pro virtuální počítače Azure:

Get-AzVMExtension -ResourceGroupName "<myVmResourceGroup>" -VMName "<myVmName>" -Name ApplicationMonitoringWindows -Status

Získejte seznam nainstalovaných rozšíření pro virtuální počítače Azure:

Get-AzResource -ResourceId "/subscriptions/<mySubscriptionId>/resourceGroups/<myVmResourceGroup>/providers/Microsoft.Compute/virtualMachines/<myVmName>/extensions"

Odinstalujte rozšíření agenta Application Insights z virtuálních počítačů Azure:

Remove-AzVMExtension -ResourceGroupName "<myVmResourceGroup>" -VMName "<myVmName>" -Name "ApplicationMonitoring"

Poznámka:

Ověřte instalaci tak, že vyberete Live Metrics Stream v rámci prostředku Application Insights přidruženého ke spojovacímu řetězci, který jste použili k nasazení rozšíření agenta Application Insights. Pokud odesíláte data z více virtuálních počítačů, vyberte cílové virtuální počítače Azure v části Název serveru. Zahájení toku dat může trvat až minutu.

instrumentationKeyMap (nastavení rozšíření)

Důležité

InstrumentationKeyMap je pokročilá funkce směrování, která propojuje aplikace Internetové Informační Služby (IIS) na stejném počítači s prostředky Application Insights. Tato funkce se vztahuje na aplikace ASP.NET a ASP.NET Core hostované na IIS, které agent Application Insights automaticky instrumentuje.

Jak funguje porovnávání

  • Mapa definuje uspořádaný seznam pravidel s názvem filters. První odpovídající pravidlo vstoupí v platnost. Nejprve umístěte konkrétní pravidla a zakončete obecně použitelným pravidlem.
  • Každé pravidlo může přiřadit k odpovídajícím aplikacím jiný prostředek Application Insights. Upřednostněte připojovací řetězce v podporovaných scénářích, protože klíče instrumentace jsou zastaralé.

Dostupné filtry

  • MachineFilter nebo machineFilter: Regulární výraz jazyka C#, který odpovídá názvu počítače nebo virtuálního počítače. .* odpovídá všem názvům.
  • AppFilter nebo appFilter: Regulární výraz jazyka C#, který odpovídá názvu webu služby IIS (HostingEnvironment.SiteName). Tento filtr je nutný, pokud není k dispozici VirtualPathFilter nebo virtualPathFilter.
  • VirtualPathFilter nebo virtualPathFilter: Regulární výraz jazyka C#, který odpovídá virtuální cestě služby IIS (HostingEnvironment.ApplicationVirtualPath). Pomocí tohoto filtru můžete cílit na jednu aplikaci na webu.

Mapování terminologie

  • PowerShell cmdlety používají MachineFilter, AppFilter, a VirtualPathFilter.
  • Azure VM a rozšíření JSON pro Virtual Machine Scale Sets používají machineFilter, appFilter a virtualPathFilter a nastavují prostředek pomocí instrumentationSettings.

Návod

Zahrňte konečné pravidlo, které odpovídá všem aplikacím, například .*, a použijte výchozí prostředek, aby bylo chování explicitní.

Kde se uplatňuje rozšíření pro virtuální stroj a sady škálování virtuálních strojů

Umístěte mapu pod redfieldConfiguration.instrumentationKeyMap.filters ve veřejném nastavení rozšíření (-SettingString pro virtuální počítače, -Setting pro sady pro škálování virtuálních počítačů). Názvy vlastností jsou malá velbloudí písmena. Nastavte cílový prostředek pro každé pravidlo pomocí instrumentationSettings.connectionString.

{
  "redfieldConfiguration": {
    "instrumentationKeyMap": {
      "filters": [
        {
          "machineFilter": ".*",
          "appFilter": ".*",
          "instrumentationSettings": {
            "connectionString": "<your-APPLICATIONINSIGHTS_CONNECTION_STRING>"
          }
        }
      ]
    }
  }
}

Povolení monitorování pro škálovací sady virtuálních počítačů

K povolení monitorování škálovacích sad virtuálních počítačů můžete použít portál Azure nebo PowerShell.

Možnost 1: portál Azure

Postupujte podle předchozích kroků pro virtuální počítače, ale přejděte na škálovací sady virtuálních počítačů místo virtuálního počítače.

Možnost 2: PowerShell

Nainstalujte nebo aktualizujte agenta Application Insights jako rozšíření pro škálovací sady virtuálních počítačů:

# Set resource group, vmss name, and connection string to reflect your environment
$ResourceGroup = "<myVmResourceGroup>"
$VMSSName = "<myVmName>"
$ConnectionString = "<myAppInsightsResourceConnectionString>"
$publicCfgHashtable =
@{
  "redfieldConfiguration"= @{
    "instrumentationKeyMap"= @{
      "filters"= @(
        @{
          "appFilter"= ".*";
          "machineFilter"= ".*";
          "virtualPathFilter"= ".*";
          "instrumentationSettings" = @{
            "connectionString"= "$ConnectionString"
          }
        }
      )
    }
  }
};
$privateCfgHashtable = @{};
$vmss = Get-AzVmss -ResourceGroupName $ResourceGroup -VMScaleSetName $VMSSName
Add-AzVmssExtension -VirtualMachineScaleSet $vmss -Name "ApplicationMonitoringWindows" -Publisher "Microsoft.Azure.Diagnostics" -Type "ApplicationMonitoringWindows" -TypeHandlerVersion "2.8" -Setting $publicCfgHashtable -ProtectedSetting $privateCfgHashtable
Update-AzVmss -ResourceGroupName $vmss.ResourceGroupName -Name $vmss
# Note: Depending on your update policy, you might need to run Update-AzVmssInstance for each instance

Získejte seznam nainstalovaných rozšíření pro škálovací sady virtuálních počítačů:

Get-AzResource -ResourceId "/subscriptions/<mySubscriptionId>/resourceGroups/<myResourceGroup>/providers/Microsoft.Compute/virtualMachineScaleSets/<myVmssName>/extensions"

Odinstalujte rozšíření monitorování aplikací ze škálovacích sad virtuálních počítačů:

# set resource group and vmss name to reflect your environment
$vmss = Get-AzVmss -ResourceGroupName "<myResourceGroup>" -VMScaleSetName "<myVmssName>"
Remove-AzVmssExtension -VirtualMachineScaleSet $vmss -Name "ApplicationMonitoringWindows"
Update-AzVmss -ResourceGroupName $vmss.ResourceGroupName -Name $vmss.Name -VirtualMachineScaleSet $vmss
# Note: Depending on your update policy, you might need to run Update-AzVmssInstance for each instance

Troubleshooting

Vyhrazený postup řešení potíží najdete v tématu Řešení potíží s nasazením rozšíření Application Insights Monitoring Agent pro virtuální počítače a škálovací sady virtuálních počítačů.

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

ASP.NET a ASP.NET Core

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

Pracovní služba

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

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

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

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

Shromažďování telemetrických dat

V této části

Živé metriky

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

Poznámka:

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

Začínáme

  1. Povolte živé metriky pomocí sad Application Insights SDK podle pokynů pro konkrétní programovací jazyk:

    • ASP.NET: Ve výchozím nastavení je povoleno, ale můžete ho také povolit ručně pomocí kódu.
    • ASP.NET Core: Ve výchozím nastavení je povoleno, ale můžete ho také povolit ručně pomocí kódu.
    • Konzola /Pracovní proces .NET/.NET Core: Ve výchozím nastavení je povoleno.

  2. Na webu Azure Portal otevřete prostředek Application Insights pro vaši aplikaci. Vyberte Živé metriky, které jsou uvedené v části Prošetření v nabídce vlevo.

  3. Zabezpečte řídicí kanál povolením ověřování Microsoft Entra, pokud používáte vlastní filtry.

Podporované funkce
Jazyk Základní metriky Metriky výkonu Vlastní filtrování Ukázková telemetrie Rozdělení procesoru podle procesu
.NET Framework Podporováno (LTS) Podporováno (LTS) Podporováno (LTS) Podporováno (LTS) Podporováno (LTS)
.NET Core (cíl=.NET Framework) Podporováno (LTS) Podporováno (LTS) Podporováno (LTS) Podporováno (LTS) Podporováno (LTS)
.NET Core (cílová platforma=.NET Core) Podporováno (LTS) Supported* Podporováno (LTS) Podporováno (LTS) Nepodporováno

Mezi základní metriky patří požadavek, závislost a míra výjimek. Metriky výkonu (čítače výkonu) zahrnují paměť a procesor. Ukázková telemetrie zobrazuje datový proud s podrobnými informacemi o neúspěšných požadavcích a závislostech, výjimkách, událostech a trasování.

Podpora perfCounters se mírně liší v různých verzích .NET Core, které necílí na .NET Framework:

  • Metriky perfCounters se podporují při spuštění v Azure App Service pro Windows (ASP.NET Core SDK verze 2.4.1 nebo vyšší).
  • Podpora PerfCounters je zajištěna, když je aplikace spuštěná na jakémkoliv počítači se systémem Windows pro aplikace cílící na .NET Core LTS nebo vyšší.
  • Podpora funkce PerfCounters je dostupná, když je aplikace spuštěná kdekoli (například v Linuxu, Windows, App Service pro Linux nebo v kontejnerech) v nejnovějších verzích, ale pouze pro aplikace, které cílí na .NET Core LTS nebo vyšší.

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

ASP.NET

Ruční konfigurace živých metrik:

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

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

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

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

            var quickPulseModule = new QuickPulseTelemetryModule();

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

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

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

Ruční konfigurace živých metrik:

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

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

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

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

var quickPulseModule = new QuickPulseTelemetryModule();

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

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

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

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

Důležité

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

Poznámka:

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

Pracovní služba

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

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

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

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

Poznámka:

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

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

Trasování (protokoly)

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

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

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

Poznámka:

  • Ve výchozím nastavení poskytovatel Application Insights odesílá protokoly pouze se závažností Warning nebo vyšší. Chcete-li zahrnout Information či protokoly nižší úrovně, aktualizujte nastavení úrovně záznamu v souboru appsettings.json.

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

  • Nejčastější dotazy najdete v části Nejčastější dotazy o logování s .NET.

Instalace protokolování do aplikace

ASP.NET

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

V případě klasických aplikací ASP.NET, které používají trasování System.Diagnostics, nakonfigurujte Application Insights TraceListener.

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

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

Poznámka:

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

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

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

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

Poznámka:

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

ASP.NET Core

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

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

Ruční instalace

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

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

  2. Vyhledejte Application Insights.

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

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

Pokyny k instalaci:

Poznámka:

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


ILogger

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

  2. Přidat ApplicationInsightsLoggerProvider:

using Microsoft.Extensions.Logging.ApplicationInsights;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

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

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

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

var app = builder.Build();

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

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

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

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

public class ValuesController : ControllerBase
{
    private readonly ILogger _logger;

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

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

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

cs-CZ: Další informace najdete v tématu Logging v ASP.NET Core a Jaký typ telemetrie Application Insights je vytvořen z protokolů ILoggeru? Kde mohu vidět protokoly ILoggeru v Application Insights?.

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

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

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

Pokud chcete log4net , nebo NLogpoužijte:

    logger.Warn("Slow response - database01");
Použijte události EventSource

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

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

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

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

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

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

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

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

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

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

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

Použijte události ETW

Události trasování Windows (ETW) můžete nakonfigurovat tak, aby byly odesílány do Application Insights jako záznamy trasování.

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

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

Poznámka:

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

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

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

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

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

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

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

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

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

Nyní můžete snadno ve vyhledávání vyfiltrovat všechny zprávy určité úrovně závažnosti, které souvisejí s konkrétní databází.

Konzolová aplikace

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

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

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

using var channel = new InMemoryChannel();

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

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

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

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

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

Rozsahy protokolování

Poznámka:

Následující pokyny platí pro scénáře ILoggeru (pouze ASP.NET Core a konzoly). To se nevztahuje na klasický ASP.NET.

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

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

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

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

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

Vyhledání protokolů

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

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

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

Poznámka:

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

Prozkoumání v protokolech Azure Monitor

Protokoly ILogger se zobrazují jako trasovací telemetrie (tabulka traces v Application Insights a AppTraces v Log Analytics).

Příklad

Na portálu Azure přejděte do Application Insights a spusťte:

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

Distribuované trasování

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

Azure Monitor poskytuje dvě prostředí pro využívání distribuovaných dat trasování: diagnostiku transakcí pro jednu transakci/požadavek a mapu aplikací, která zobrazuje, jak systémy interagují.

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

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

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

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

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

Datový model pro korelaci telemetrie

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

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

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

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

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

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

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

Příklad

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

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

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

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

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

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

Hlavičky korelace pomocí W3C TraceContext

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

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

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

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

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

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

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

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

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

Povolení podpory distribuovaného trasování W3C

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

Korelace telemetrie

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

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

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

Závislosti

Automaticky sledované závislosti

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

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

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

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

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

Jak funguje automatické monitorování závislostí?

  • Instrumentace bajtového kódu se používá u vybraných metod pomocí InstrumentationEngine a je aktivována pomocí StatusMonitor nebo rozšíření Application Insights pro Azure App Service.

  • EventSource zpětná volání se používají k zachycení telemetrie z knihoven .NET, které generují strukturované události.

  • DiagnosticSource zpětná volání se používají v novějších .NET a .NET Core SDK ke sběru telemetrie z knihoven, které podporují distribuované trasování.

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

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

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

Poznámka:

V případě konzolových aplikací .NET Core je TelemetryConfiguration.Active zastaralé.

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

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

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

Pokud sada SDK automaticky nezachytí některé závislosti, můžete je sledovat ručně pomocí TrackDependency API, které používají standardní moduly pro automatické shromažďování.

Příklad

Pokud svůj kód sestavíte pomocí sestavení, které jste sami nenapsali, můžete načasovat všechna jeho volání. Tento scénář vám umožní zjistit, jaký příspěvek má na vaše doby odezvy.

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


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

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

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

Další informace najdete v modulech telemetrie.

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

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

Poznámka:

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

ASP.NET

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

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

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

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

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

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

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

Výjimky

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

Nastavení hlášení výjimek

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

Server-side

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

Client-side

JavaScript SDK poskytuje možnost klientského hlášení výjimek ve webových prohlížečích. Pokud chcete nastavit generování sestav výjimek v klientovi, přečtěte si téma Application Insights pro webové stránky.

Aplikační architektury

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

Důležité

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

Diagnostikujte selhání a výjimky

Azure Portal

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

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

Visual Studio

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

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

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

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

    Snímek obrazovky s oznámením CodeLens o výjimkách

Vlastní trasování a záznamová data

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

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

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

Snímek obrazovky znázorňující obrazovku Hledat

Poznámka:

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

Zobrazit data POST požadavku

Podrobnosti požadavku nezahrnují data odesílaná do vaší aplikace v rámci volání POST. Aby byla tato data hlášena:

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

Můžete:

  • Explicitně zaznamujte výjimky vložením kódu do obslužných rutin výjimek, které oznamují výjimky.
  • Automaticky zachycovat výjimky pomocí konfigurace rámce ASP.NET. Nezbytné doplňky se liší pro různé typy rozhraní.
Výjimky hlaste explicitně

Nejjednodušší způsob, jak vytvořit zprávu, je vložit volání do trackException() v obsluze výjimek.

jazyk C#
var telemetry = new TelemetryClient();

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

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

    // Send the exception telemetry:
    telemetry.TrackException(ex, properties, measurements);
}
JavaScript
try
{
    // ...
}
catch (ex)
{
    appInsights.trackException(ex, "handler loc",
    {
        Game: currentGame.Name,
        State: currentGame.State.ToString()
    });
}

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

Výjimky prohlížeče

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

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

Znovu použijte svého telemetrického klienta

Poznámka:

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

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

public class ExampleController : ApiController
{
    private readonly TelemetryClient _telemetryClient;

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

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

Webové formuláře

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

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

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

MVC

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

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

  • Od konstruktorů řadiče
  • Z obslužných rutin zpráv
  • Během směrování
  • Během serializace obsahu odpovědi
  • Během spuštění aplikace
  • Úlohy na pozadí

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

Podpora předchozích verzí

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


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

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

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

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

MVC 2

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

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

Ukázka

MVC 3

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

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

Ukázka

MVC 4, MVC 5

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

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

Ukázka

Webové rozhraní API

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

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

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

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

Podpora předchozích verzí

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


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

Webové rozhraní API 1.x

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

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

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

Tento přepsaný atribut můžete přidat do konkrétních kontrolérů nebo ho přidat do konfigurace filtru v globálním nastavení ve třídě 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());
        }
    }
}

Ukázka

Webové rozhraní API 2.x

Přidejte implementaci IExceptionLogger:

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

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

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

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

namespace WebApi2WithMVC
{
    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services

            // Web API routes
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional });

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

Ukázka

Jako alternativy můžete:

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

WCF

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

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

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

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

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

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

            ai.TrackException(error);
            return false;
        }

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

Přidejte atribut do implementací služby:

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

Ukázka

Čítače výkonu výjimek

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

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

Rozhraní .NET Framework vypočítá míru počítáním počtu výjimek v intervalu a vydělením tohoto počtu délkou intervalu.

Tento počet se liší od počtu výjimek vypočítávaných portálem Application Insights, který zahrnuje zprávy TrackException. Intervaly vzorkování se liší a sada SDK neodesílá TrackException sestavy pro všechny zpracovávané a neošetřené výjimky.

Vlastní kolekce metrik

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

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

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


Rozbalením získáte další informace o předagregování versus bezpředagregační rozhraní API.

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

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

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

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

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

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

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

Začínáme s GetMetric

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

Odesílání metrik

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

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

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

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

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

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

Při spuštění ukázkového kódu vidíte, že se smyčka while opakovaně spouští, aniž by do okna výstupu Visual Studio byla odesílána jakákoli telemetrie. Během našeho testu se přibližně v čase 60 sekund odešle jedna položka telemetrie, která vypadá takto:

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

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

Poznámka:

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

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

Snímek obrazovky znázorňující zobrazení dotazu Log Analytics

Poznámka:

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

K vlastní telemetrii metrik můžete na portálu přistupovat také v části Metriky, a to jak jako metrika založená na protokolech, tak jako vlastní metrika. Následující snímek obrazovky je příkladem metriky založené na protokolu.

Snímek obrazovky znázorňující zobrazení Průzkumníka metrik

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

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

Například předchozí příklad provedl vyhledávání popisovače metriky ComputersSold a pak sledoval pozorovanou hodnotu 42. Místo toho může být datový popisovač uložen v mezipaměti pro opakované spuštění úloh:

//...

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

                computersSold.TrackValue(42);

                computersSold.TrackValue(142);

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

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

Multidimenzionální metriky

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

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

//...

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

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


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

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

Snímek obrazovky znázorňující zobrazení Log Analytics pro multidimenzionální metriku

V Průzkumníku metrik:

Snímek obrazovky znázorňující vlastní metriky

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

Snímek obrazovky, který ukazuje podporu dělení

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

Povolení multidimenzionálních metrik

Pokud chcete povolit multidimenzionální metriky pro prostředek Application Insights, vyberte Využití a odhadované náklady>Vlastní metriky>Povolte upozorňování na vlastní dimenze metrik>OK. Další informace najdete v tématu Vlastní dimenze metrik a předagregace.

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

Poznámka:

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

Snímek obrazovky znázorňující použití rozdělení

Zobrazte agregace metrik pro každou FormFactor dimenzi.

Snímek obrazovky znázorňující faktory formulářů

Použijte MetricIdentifier, pokud jsou více než tří dimenzí

V současné době se podporuje 10 dimenzí. Použití více než tří dimenzí vyžaduje použití MetricIdentifier:

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

Vlastní konfigurace metriky

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

Speciální názvy dimenzí

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

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

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

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

        }

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

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

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

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

_telemetryClient.GetMetric("Request Size", "Operation Name", MetricDimensionNames.TelemetryContext.Operation.Name).TrackValue(requestSize, "Special Operation", "Special Operation");
Omezení dimenzí a časových řad

Pokud chcete, aby telemetrický subsystém omylem nevyužíval vaše zdroje, můžete řídit maximální počet datových řad na jednu metrickou jednotku. Výchozí limity nejsou větší než 1 000 celkových datových řad na metriku a ne více než 100 různých hodnot na dimenzi.

Důležité

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

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

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

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

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

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

// The following call gives 3rd unique value for dimension2, which is above the limit of 2.
computersSold.TrackValue(100, "Dim1Value1", "Dim2Value3");
// The above call doesn't track the metric, and returns false.
  • seriesCountLimit je maximální počet datových časových řad, které může metrika obsahovat. Jakmile dosáhnete tohoto limitu, volání TrackValue(), která by normálně způsobila vznik nové řady, vrátí false.
  • valuesPerDimensionLimit omezuje počet jedinečných hodnot na dimenzi podobným způsobem.
  • restrictToUInt32Values určuje, zda mají být sledovány pouze nezáporné celočíselné hodnoty.

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

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

Sledování vlastních operací

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

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

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

Přehled

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

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

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

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

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

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

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

Požadavek HTTP v samostatně hostované aplikaci Owin

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


Rozbalit pro zobrazení kódu 
public class ApplicationInsightsMiddleware : OwinMiddleware
{
    // You may create a new TelemetryConfiguration instance, reuse one you already have,
    // or fetch the instance created by Application Insights SDK.
    private readonly TelemetryConfiguration telemetryConfiguration = TelemetryConfiguration.CreateDefault();
    private readonly TelemetryClient telemetryClient = new TelemetryClient(telemetryConfiguration);

    public ApplicationInsightsMiddleware(OwinMiddleware next) : base(next) {}

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

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

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

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

            // Now it's time to stop the operation (and track telemetry).
            telemetryClient.StopOperation(operation);
        }
    }

    public static string GetOperationId(string id)
    {
        // Returns the root ID from the '|' to the first '.' if any.
        int rootEnd = id.IndexOf('.');
        if (rootEnd < 0)
            rootEnd = id.Length;

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

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

Instrumentace front

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

Poznámka:

Křížové trasování mezi komponentami není zatím pro fronty podporováno.

Pokud váš producent a příjemce posílají telemetrii do různých prostředků Application Insights, diagnostika transakcí a Mapa aplikací zobrazují transakce a mapování od začátku do konce. U front se tato funkce zatím nepodporuje.

Fronta služby Service Bus

Další informace o sledování najdete v tématu Distribuované sledování a korelace pomocí zasílání zpráv prostřednictvím Azure Service Bus.

Fronta služby Azure Storage

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

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

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

Zařadit do fronty

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

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

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

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

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

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

    CloudQueueMessage queueMessage = new CloudQueueMessage(jsonPayload);

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

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

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

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

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

Operace Dequeue je složitá. Sada Application Insights SDK automaticky sleduje požadavky HTTP. Ale nezná kontext korelace, dokud se zpráva neanalyzuje. Není možné korelovat požadavek HTTP se žádostí o zprávu k ostatním údajům telemetrie, zejména pokud přijmeme více než jednu zprávu.

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

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

    return null;
}
Proces

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

public async Task Process(MessagePayload message)
{
    // After the message is dequeued from the queue, create RequestTelemetry to track its processing.
    RequestTelemetry requestTelemetry = new RequestTelemetry { Name = "process " + queueName };

    // It might also make sense to get the name from the message.
    requestTelemetry.Context.Operation.Id = message.RootId;
    requestTelemetry.Context.Operation.ParentId = message.ParentId;

    var operation = telemetryClient.StartOperation(requestTelemetry);

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

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

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

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

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

  • Azure queue pro fronty Azure Storage
  • Azure Event Hubs pro Azure Event Hubs
  • Azure Service Bus pro Azure Service Bus
Dávkové zpracování

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

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

Dlouhotrvající úlohy na pozadí

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

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

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

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

Sledování odchozích závislostí

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

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

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

  • Zavolejte metodu TelemetryClient.StartOperation (extension), která vyplní DependencyTelemetry vlastnosti potřebné pro korelaci a některé další vlastnosti, jako je začátek, časové razítko a doba trvání.
  • Nastavte další vlastní vlastnosti v objektu DependencyTelemetry, například název a jakýkoli jiný kontext, který potřebujete.
  • Proveďte volání závislosti a počkejte na něj.
  • Operaci s StopOperation zastavte po jejím dokončení.
  • Zpracujte výjimky
public async Task RunMyTaskAsync()
{
    using (var operation = telemetryClient.StartOperation<DependencyTelemetry>("task 1"))
    {
        try
        {
            var myTask = await StartMyTaskAsync();
            // Update status code and success as appropriate.
        }
        catch(...)
        {
            // Update status code and success as appropriate.
        }
    }
}

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

Výstraha

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

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

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

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

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

await firstTask;

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

await secondTask;

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

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

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

    await Task.WhenAll(task1, task2);
}

Operace ApplicationInsights vs. System.Diagnostics.Activity

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

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

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

Counters

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

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

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

Čítače výkonu

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

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

Návod

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

Předpoklady

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

net localgroup "Performance Monitor Users" /add "IIS APPPOOL\NameOfYourPool"
Zobrazení čítačů

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

ASP.NET

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

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

Výchozí čítače pro webové aplikace ASP.NET Core:

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

Poznámka:

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

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

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

ASP.NET

Možnost 1: Konfigurace v ApplicationInsights.config

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

    Get-Counter -ListSet *

    Další informace najdete na webu Get-Counter.

  2. Otevřít ApplicationInsights.config.

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

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

  3. Upravte direktivu kolektoru výkonu:

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

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

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

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

Pokud zadáte instanci, stane se dimenzí CounterInstanceName reportované metriky.

Možnost 2: Konfigurace v kódu

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

ASP.NET Core

Nakonfigurujte PerformanceCollectorModule po metodě WebApplication.CreateBuilder() v Program.cs:

using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddApplicationInsightsTelemetry();

// The following configures PerformanceCollectorModule.

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

var app = builder.Build();
Shromažďování čítačů výkonu v kódu pro webové aplikace ASP.NET nebo konzolové aplikace .NET/.NET Core

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

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

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

    var perfCollectorModule = new PerformanceCollectorModule();
    perfCollectorModule.Counters.Add(new PerformanceCounterCollectionRequest(
      @"\Sales(photo)\# Items Sold", "Photo sales"));
    perfCollectorModule.Initialize(TelemetryConfiguration.Active);
Čítače výkonu pro aplikace spuštěné v kontejnerech Azure Web Apps a Windows na Azure App Service

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

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

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

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

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

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

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

Instance Tady odkazuje na instanci čítače výkonu, nikoli roli nebo instanci serveru. Název instance čítače výkonu obvykle segmentuje položky čítače, jako je čas procesoru, podle názvu procesu nebo aplikace.

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

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

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

performanceCounters | where counter == "% Processor Time" and instance == "SendMetrics" | summarize avg(value) by cloud_RoleInstance, bin(timestamp, 1d)
Nejčastější dotazy k čítačům výkonu

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

Počítadla událostí

EventCounter je mechanismus .NET/.NET Core pro publikování a využívání čítačů nebo statistik. EventCounters se podporují ve všech platformách operačního systému – Windows, Linuxu a macOS. Můžete si to představit jako ekvivalent PerformanceCounters, který je k dispozici na různých platformách, přičemž je podporován pouze v systémech Windows.

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

Návod

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

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

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

dotnet add package Microsoft.ApplicationInsights.EventCounterCollector
dotnet add package Microsoft.ApplicationInsights.AspNetCore
Shromažďované výchozí čítače

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

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

Přizpůsobení čítačů určených ke shromažďování

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

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

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

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

            // Adds the system counter "gen-0-size" from "System.Runtime"
            module.Counters.Add(
                new EventCounterCollectionRequest("System.Runtime", "gen-0-size"));
        }
    );
Zakázání modulu kolekce EventCounter

EventCounterCollectionModule lze zakázat pomocí ApplicationInsightsServiceOptions.

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

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

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

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

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

var applicationInsightsServiceOptions = new ApplicationInsightsServiceOptions();
applicationInsightsServiceOptions.EnableEventCounterCollectionModule = false;
builder.Services.AddApplicationInsightsTelemetry(applicationInsightsServiceOptions);
Dotazy v Log Analytics na čítače událostí

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

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

customMetrics | summarize avg(value) by name

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

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

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

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

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

Kolekce snímků

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

Zpracování a filtrování telemetrie

V této části

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

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

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

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

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

Poznámka:

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

Filtrování

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

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

Výstraha

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

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

ITelemetryProcessor a ITelemetryInitializer

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

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

Přidání nebo úprava vlastností

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

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

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

Inicializátory telemetrie

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

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

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

Inicializátor Description
AccountIdTelemetryInitializer Nastaví vlastnost AccountId.
AuthenticatedUserIdTelemetryInitializer AuthenticatedUserId Nastaví vlastnost nastavenou sadou JavaScript SDK.
AzureRoleEnvironmentTelemetryInitializer Aktualizuje vlastnosti RoleName a RoleInstance kontextu Device pro všechny položky telemetrie s informacemi extrahovanými z prostředí Azure runtime.
BuildInfoConfigComponentVersionTelemetryInitializer Version Aktualizuje vlastnost Component kontextu pro všechny položky telemetrie s hodnotou extrahovaná ze souboru vytvořeného BuildInfo.config nástrojem MS Build.
ClientIpHeaderTelemetryInitializer Aktualizuje vlastnost Ip v kontextu Location u všech položek telemetrie na základě X-Forwarded-For hlavičky HTTP požadavku.
DeviceTelemetryInitializer Aktualizuje následující vlastnosti Device kontextu pro všechny položky telemetrie:

• Type je nastaveno na PC.
• Id je nastaven na název domény počítače, na kterém je webová aplikace spuštěná.
• OemName je nastavena na hodnotu extrahovaná z Win32_ComputerSystem.Manufacturer pole pomocí rozhraní WMI.
• Model je nastavena na hodnotu extrahovaná z Win32_ComputerSystem.Model pole pomocí rozhraní WMI.
• NetworkType je nastavena na hodnotu extrahovaná z NetworkInterface vlastnosti.
• Language je nastaven na název CurrentCulture vlastnosti.
DomainNameRoleInstanceTelemetryInitializer RoleInstance Aktualizuje vlastnost Device kontextu pro všechny položky telemetrie názvem domény počítače, na kterém je webová aplikace spuštěná.
OperationNameTelemetryInitializer Aktualizuje vlastnost NameRequestTelemetry a vlastnost Name kontextu Operation všech položek telemetrie na základě metody HTTP a názvy kontroleru ASP.NET MVC a akce vyvolané ke zpracování požadavku.
OperationIdTelemetryInitializer nebo OperationCorrelationTelemetryInitializer Aktualizuje vlastnost kontextové Operation.Id u všech položek telemetrie sledovaných během zpracování požadavku pomocí automaticky vygenerovaného RequestTelemetry.Id.
SessionTelemetryInitializer Aktualizuje vlastnost Id kontextu Session pro všechny položky telemetrie s hodnotou extrahovanou ze ai_session souboru cookie vygenerovaného instrumentačním JavaScriptovým kódem ApplicationInsights spuštěným v prohlížeči uživatele.
SyntheticTelemetryInitializer nebo SyntheticUserAgentTelemetryInitializer Aktualizuje User, Session a Operation kontextové vlastnosti všech položek telemetrie sledovaných při zpracování požadavku ze syntetického zdroje, jako je test dostupnosti nebo robot vyhledávače. Průzkumník metrik ve výchozím nastavení nezobrazuje syntetickou telemetrii.

Sada <Filters> identifikující vlastnosti požadavků.
UserTelemetryInitializer Aktualizuje vlastnosti Id a AcquisitionDate kontextu User pro všechny položky telemetrie s hodnotami extrahovanými ze souboru cookie ai_user, který byl vygenerován instrumentačním kódem JavaScriptu Application Insights spuštěným v prohlížeči uživatele.
WebTestTelemetryInitializer Nastaví ID uživatele, ID relace a syntetické vlastnosti zdroje pro požadavky HTTP, které pocházejí z testů dostupnosti.

Sada <Filters> identifikující vlastnosti požadavků.

Poznámka:

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

Přidání ITelemetryInitializer

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

  1. Definování inicializátoru

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

namespace MvcWebRole.Telemetry
{
  /*
   * Custom TelemetryInitializer that overrides the default SDK
   * behavior of treating response codes >= 400 as failed requests
   *
   */
    public class MyTelemetryInitializer : ITelemetryInitializer
    {
        public void Initialize(ITelemetry telemetry)
        {
            var requestTelemetry = telemetry as RequestTelemetry;
            // Is this a TrackRequest() ?
            if (requestTelemetry == null) return;
            int code;
            bool parsed = Int32.TryParse(requestTelemetry.ResponseCode, out code);
            if (!parsed) return;
            if (code >= 400 && code < 500)
            {
                // If we set the Success property, the SDK won't change it:
                requestTelemetry.Success = true;

                // Allow us to filter these requests in the portal:
                requestTelemetry.Properties["Overridden400s"] = "true";
            }
            // else leave the SDK to set the Success property
        }
    }
}

  2. Načtení inicializátoru

ASP.NET

Možnost 1: Konfigurace v kódu

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

Možnost 2: Konfigurace v ApplicationInsights.config

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

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

Poznámka:

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

ASP.NET Core

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

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

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

Poznámka:

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

Odebrání inicializátorů telemetrie

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

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddApplicationInsightsTelemetry();

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

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

var app = builder.Build();
Pracovní služba

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

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

    using Microsoft.ApplicationInsights.Extensibility;

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddSingleton<ITelemetryInitializer, MyCustomTelemetryInitializer>();
        services.AddApplicationInsightsTelemetryWorkerService();
    }
Odebrání inicializátorů telemetrie

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

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

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

Příklady ITelemetryInitializers

Přidejte vlastní vlastnost

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

public void Initialize(ITelemetry item)
{
    var itemProperties = item as ISupportProperties;
    if(itemProperties != null && !itemProperties.Properties.ContainsKey("customProp"))
    {
        itemProperties.Properties["customProp"] = "customValue";
    }
}
Přidání názvu cloudové role a instance cloudové role

Krok 1: Napsat vlastní TelemetryInitializer

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

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

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

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

ASP.NET

V souboru ApplicationInsights.config :

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

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

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

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

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

 using Microsoft.ApplicationInsights.Extensibility;
 using CustomInitializer.Telemetry;
 public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<ITelemetryInitializer, MyTelemetryInitializer>();
}
Řízení IP adresy klienta používané pro mapování geografické polohy

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

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

Procesory telemetrie

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

Implementovat ITelemetryProcessor

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

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

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

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

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

        this.Next.Process(item);
    }

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

        return dependency.Success != true;
    }
}

Přidání procesoru

ASP.NET

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

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

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

Výstraha

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

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

Poznámka:

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

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

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

builder.Build();

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

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

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


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

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

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

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

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

    <TelemetryProcessors>
        <Add Type="Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel.SamplingTelemetryProcessor, Microsoft.AI.ServerTelemetryChannel">

        <!-- Set a percentage close to 100/N where N is an integer. -->
        <!-- E.g. 50 (=100/2), 33.33 (=100/3), 25 (=100/4), 20, 1 (=100/100), 0.1 (=100/1000) -->
        <SamplingPercentage>10</SamplingPercentage>
        </Add>
    </TelemetryProcessors>
ASP.NET Core

Poznámka:

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

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

var builder = WebApplication.CreateBuilder(args);

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

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

var app = builder.Build();

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

Pracovní služba

Poznámka:

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

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

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

Ukázkové filtry

Syntetické požadavky

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

public void Process(ITelemetry item)
{
    if (!string.IsNullOrEmpty(item.Context.Operation.SyntheticSource)) {return;}

    // Send everything else:
    this.Next.Process(item);
}
Neúspěšné ověřování

Vyfiltrujte požadavky s odpovědí 401.

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

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

    // Send everything else
    this.Next.Process(item);
}
Filtrujte rychlá volání vzdálených závislostí

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

Poznámka:

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

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

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

Vzorkování

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

Pracovní služba

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

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

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

var builder = WebApplication.CreateBuilder(args);

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

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

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

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

var app = builder.Build();

Obohacení dat prostřednictvím protokolu HTTP

ASP.NET

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

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

ASP.NET Core

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

Konfigurace sady SDK

V této části

Sadu Application Insights SDK můžete přizpůsobit pro ASP.NET, ASP.NET Core a Worker Service a změnit výchozí konfiguraci.

ASP.NET

Sada Application Insights .NET SDK se skládá z mnoha balíčků NuGet. Základní balíček poskytuje rozhraní API pro odesílání telemetrie do Application Insights. Další balíčky poskytují moduly telemetrie a inicializátory pro automatické sledování telemetrie z vaší aplikace a jejího kontextu. Úpravou konfiguračního souboru můžete povolit nebo zakázat moduly telemetrie a inicializátory. Můžete také nastavit parametry pro některé z nich.

Konfigurační soubor má název ApplicationInsights.config nebo ApplicationInsights.xml. Název závisí na typu vaší aplikace. Při instalaci většiny verzí sady SDK se do projektu automaticky přidá.

Ve výchozím nastavení, když použijete automatizované prostředí z projektů šablon Visual Studio, které podporují Add>Application Insights Telemetry, je soubor ApplicationInsights.config vytvořen v kořenovém adresáři projektu. Po kompilaci se zkopíruje do složky bin. Přidá se také do webové aplikace agentem Application Insights na serveru IIS.

Důležité

Konfigurační soubor se ignoruje, pokud je použito rozšíření pro weby Azure nebo rozšíření pro virtuální stroje Azure a škálovací sady virtuálních strojů Azure.

Neexistuje ekvivalentní soubor pro řízení sady SDK na webové stránce.

ASP.NET Core

V aplikacích ASP.NET Core jsou všechny změny konfigurace provedeny v ConfigureServices() metodě vaší třídy Startup.cs , pokud není směrováno jinak.

Poznámka:

V ASP.NET Core aplikacích se změna konfigurace úpravou TelemetryConfiguration.Active nepodporuje.

Pracovní služba

Výchozí TelemetryConfiguration používaná sadou SDK pracovních služeb je podobná automatické konfiguraci používané v aplikaci ASP.NET nebo ASP.NET Core, bez inicializátorů telemetrie, které by obohacovaly telemetrii z HttpContext.

SDK Application Insights for Worker Service můžete přizpůsobit ke změně výchozí konfigurace. Uživatelé sady Application Insights ASP.NET Core SDK mohou být obeznámeni se změnou konfigurace pomocí integrovaného vkládání závislostí v ASP.NET Core. Sada SDK pracovních služeb je také založena na podobných principech. Proveďte téměř všechny změny konfigurace v oddílu ConfigureServices() voláním vhodných metod IServiceCollection, jak je podrobně popsáno v další části.

Poznámka:

Pokud používáte sadu SDK pracovní služby, změna konfigurace úpravou TelemetryConfiguration.Active se nepodporuje a změny se neprojeví.

Kanály telemetrie

Telemetrické kanály jsou nedílnou součástí SDK sady Application Insights. Spravují ukládání do vyrovnávací paměti a přenos telemetrie do služby Application Insights. Verze sad SDK .NET a .NET Core mají dva integrované kanály telemetrie: InMemoryChannel a ServerTelemetryChannel. Tato část popisuje jednotlivé kanály a ukazuje, jak přizpůsobit chování kanálu.

Poznámka:

Chcete-li si prohlédnout nejčastější dotazy (FAQ), podívejte se na nejčastější dotazy ke kanálům telemetrie.

Co jsou kanály telemetrie?

Kanály telemetrie zodpovídají za ukládání položek telemetrie do vyrovnávací paměti a jejich odesílání do služby Application Insights, kde jsou uložené pro dotazování a analýzu. Kanál telemetrie je libovolná třída, která implementuje Microsoft.ApplicationInsights.ITelemetryChannel rozhraní.

Metoda Send(ITelemetry item) kanálu telemetrie se volá po zavolání všech inicializátorů telemetrie a procesorů telemetrie. Všechny položky vyřazené procesorem telemetrie se proto nedostanou do kanálu. Metoda Send() obvykle neodesílá položky do back-endu okamžitě. Obvykle je ukládá do vyrovnávací paměti a odesílá je v dávkách pro efektivní přenos.

Vyhněte se volání Flush(), pokud není důležité okamžitě odeslat telemetrická data z vyrovnávací paměti. Používejte ho jenom ve scénářích, jako je vypnutí aplikace, zpracování výjimek nebo použití krátkodobých procesů, jako jsou úlohy na pozadí nebo nástroje příkazového řádku. Ve webových aplikacích nebo dlouhotrvajících službách sada SDK zpracovává automatické odesílání telemetrie. Zbytečné volání Flush() může způsobit problémy s výkonem.

Live Metrics Stream má také vlastní kanál, který využívá živé streamování telemetrie. Tento kanál je nezávislý na běžném kanálu telemetrie a tento dokument se na něj nevztahuje.

Integrované kanály telemetrie

Sady SDK pro .NET a .NET Core od Application Insights se dodávají s dvěma vestavěnými kanály.

  • InMemoryChannel: Lehký kanál, který ukládá položky do paměti jako vyrovnávací paměť, dokud se neodesílají. Položky se ukládají do vyrovnávací paměti a vyprázdní se jednou za 30 sekund nebo kdykoli je vyrovnáno 500 položek. Tento kanál nabízí minimální záruky spolehlivosti, protože se po selhání nebude opakovat odesílání telemetrie. Tento kanál také neuchová položky na disku. Všechny neodeslané položky se proto při vypnutí aplikace trvale ztratí, bez ohledu na to, zda je vypnutí hladké, či nikoli. Tento kanál implementuje metodu Flush() , která se dá použít k synchronnímu vyprázdnění všech položek telemetrie v paměti. Tento kanál je vhodný pro krátkoběžné aplikace, kde je ideální synchronní pročištění.

    Tento kanál je součástí většího balíčku NuGet Microsoft.ApplicationInsights a je výchozím kanálem, který sada SDK používá, když není nakonfigurováno nic jiného.

  • ServerTelemetryChannel: Pokročilejší kanál, který má zásady opakování a schopnost ukládat data na místní disk. Tento kanál opakuje odesílání telemetrie, pokud dojde k přechodným chybám. Tento kanál také používá místní diskové úložiště k uchovávání položek na disku během výpadků sítě nebo velkých svazků telemetrie. Vzhledem k těmto mechanismům opakování a úložišti místních disků se tento kanál považuje za spolehlivější. Doporučujeme ho pro všechny produkční scénáře. Tento kanál je výchozí pro aplikace ASP.NET a ASP.NET Core nakonfigurované podle oficiální dokumentace. Tento kanál je optimalizovaný pro scénáře serveru s dlouhotrvajícími procesy. Metoda Flush() implementovaná tímto kanálem není synchronní.

    Tento kanál se odešle jako balíček NuGet Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel a získá se automaticky při použití balíčku NuGet Microsoft.ApplicationInsights.Web nebo Microsoft.ApplicationInsights.AspNetCore NuGet.

Konfigurace kanálu telemetrie

Kanál telemetrie nakonfigurujete tak, že ho nastavíte na aktivní konfiguraci telemetrie. Pro ASP.NET aplikace zahrnuje konfigurace nastavení instance kanálu telemetrie na TelemetryConfiguration.Active nebo úpravu ApplicationInsights.config. U aplikací ASP.NET Core spočívá konfigurace v přidání kanálu do kontejneru pro injektáž závislostí.

Následující části ukazují příklady konfigurace StorageFolder nastavení kanálu v různých typech aplikací. StorageFolder je pouze jedním z konfigurovatelných nastavení. Úplný seznam nastavení konfigurace najdete v části Konfigurovatelná nastavení v části Kanály dále v tomto článku.

ASP.NET

Možnost 1: Konfigurace v kódu

Následující kód nastaví instanci ServerTelemetryChannel s StorageFolder nastavenou na přizpůsobené umístění. Přidejte tento kód na začátek aplikace, obvykle v Application_Start() metodě v Global.aspx.cs.

using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel;
protected void Application_Start()
{
    var serverTelemetryChannel = new ServerTelemetryChannel();
serverTelemetryChannel.StorageFolder = @"d:\temp\applicationinsights";
    serverTelemetryChannel.Initialize(TelemetryConfiguration.Active);
    TelemetryConfiguration.Active.TelemetryChannel = serverTelemetryChannel;
}

Možnost 2: Konfigurace v ApplicationInsights.config

Následující část z ApplicationInsights.config ukazuje ServerTelemetryChannel kanál nakonfigurovaný na StorageFolder vlastní umístění:

    <TelemetrySinks>
        <Add Name="default">
            <TelemetryProcessors>
                <!-- Telemetry processors omitted for brevity -->
            </TelemetryProcessors>
            <TelemetryChannel Type="Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel.ServerTelemetryChannel, Microsoft.AI.ServerTelemetryChannel">
                <StorageFolder>d:\temp\applicationinsights</StorageFolder>
            </TelemetryChannel>
        </Add>
    </TelemetrySinks>
ASP.NET Core

ConfigureServices Upravte metodu Startup.cs třídy, jak je znázorněno zde:

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

public void ConfigureServices(IServiceCollection services)
{
    // This sets up ServerTelemetryChannel with StorageFolder set to a custom location.
    services.AddSingleton(typeof(ITelemetryChannel), new ServerTelemetryChannel() {StorageFolder = @"d:\temp\applicationinsights" });

    services.AddApplicationInsightsTelemetry();
}

Důležité

Konfigurace kanálu pomocí TelemetryConfiguration.Active není podporovaná pro aplikace ASP.NET Core.

Přepsání ServeruTelemetryChannel

Výchozí kanál telemetrie je ServerTelemetryChannel. Následující příklad ukazuje, jak to přepsat.

using Microsoft.ApplicationInsights.Channel;

var builder = WebApplication.CreateBuilder(args);

// Use the following to replace the default channel with InMemoryChannel.
// This can also be applied to ServerTelemetryChannel.
builder.Services.AddSingleton(typeof(ITelemetryChannel), new InMemoryChannel() {MaxTelemetryBufferCapacity = 19898 });

builder.Services.AddApplicationInsightsTelemetry();

var app = builder.Build();

Poznámka:

Pokud chcete vyrovnávací paměť vyprázdnit, viz Vyprazdňování dat. Pokud například používáte sadu SDK v aplikaci, která se vypne, možná budete muset vyrovnávací paměť vyprázdnit.

Pracovní služba

Výchozí kanál je ServerTelemetryChannel. Můžete jej přepsat, jak ukazuje následující příklad:

using Microsoft.ApplicationInsights.Channel;

    public void ConfigureServices(IServiceCollection services)
    {
        // Use the following to replace the default channel with InMemoryChannel.
        // This can also be applied to ServerTelemetryChannel.
        services.AddSingleton(typeof(ITelemetryChannel), new InMemoryChannel() {MaxTelemetryBufferCapacity = 19898 });

        services.AddApplicationInsightsTelemetryWorkerService();
    }

Konfigurace v kódu pro konzolové aplikace

Pro konzolové aplikace je kód stejný pro .NET i .NET Core:

var serverTelemetryChannel = new ServerTelemetryChannel();
serverTelemetryChannel.StorageFolder = @"d:\temp\applicationinsights";
serverTelemetryChannel.Initialize(TelemetryConfiguration.Active);
TelemetryConfiguration.Active.TelemetryChannel = serverTelemetryChannel;

Provozní podrobnosti ServerTelemetryChannel

ServerTelemetryChannel ukládá příchozí položky do vyrovnávací paměti. Položky jsou serializovány, komprimovány a uloženy do Transmission instance jednou za 30 sekund nebo při uložení 500 položek do vyrovnávací paměti. Jedna Transmission instance obsahuje až 500 položek a představuje dávku telemetrie, která se odesílá přes jedno volání HTTPS do služby Application Insights.

Ve výchozím nastavení je možné paralelně odesílat maximálně 10 Transmission instancí. Pokud telemetrie přichází rychleji, nebo je-li síť nebo back-end systému Application Insights pomalý, instance Transmission se ukládají do paměti. Výchozí kapacita této paměťové Transmission vyrovnávací paměti (buffer) je 5 MB. Při překročení Transmission kapacity v paměti se instance ukládají na místní disk až do limitu 50 MB.

Transmission Instance jsou uloženy na místním disku také v případě, že dochází k problémům se sítí. Pouze ty položky, které jsou uložené na místním disku, přežijí chybové ukončení aplikace. Posílají se pokaždé, když se aplikace znovu spustí. Pokud problémy se sítí potrvají, ServerTelemetryChannel použije exponenciální strategii odloženého opakování, které se pohybuje od 10 sekund do 1 hodiny, před opětovným pokusem o odeslání telemetrie.

Konfigurovatelná nastavení v kanálech

Úplný seznam konfigurovatelných nastavení pro každý kanál najdete tady:

Tady jsou nejčastěji používaná nastavení pro ServerTelemetryChannel:

  • MaxTransmissionBufferCapacity: Maximální velikost paměti v bajtech, kterou kanál používá k ukládání přenosů do vyrovnávací paměti. Po dosažení této kapacity se nové položky ukládají přímo na místní disk. Výchozí hodnota je 5 MB. Nastavení vyšší hodnoty vede k menšímu využití disku, ale mějte na paměti, že pokud dojde k chybovému ukončení aplikace, dojde ke ztrátě položek v paměti.

  • MaxTransmissionSenderCapacity: Maximální počet Transmission instancí odesílaných do Application Insights najednou. Výchozí hodnota je 10. Toto nastavení je možné nakonfigurovat na vyšší číslo, které doporučujeme, když se vygeneruje velký objem telemetrie. K vysokému objemu obvykle dochází během zátěžového testování nebo při vypnutí vzorkování.

  • StorageFolder: Složka, kterou kanál používá k ukládání položek na disk podle potřeby. Ve Windows se %LOCALAPPDATA% nebo %TEMP% používá, pokud není explicitně zadána žádná jiná cesta. V jiných prostředích než Windows se ve výchozím nastavení používají následující umístění (v pořadí): %TMPDIR%, /var/tmp/ nebo /tmp/.

Jaký kanál mám použít?

Doporučujeme ServerTelemetryChannel pro většinu produkčních scénářů, které zahrnují dlouhotrvající aplikace. Více informací o vyprázdnění telemetrie naleznete v části použití Flush().

Kdy použít Flush()

Metoda Flush() okamžitě odešle jakoukoli telemetrii, která byla dočasně uložena do vyrovnávací paměti. Měl by se ale používat pouze v konkrétních scénářích.

Použít Flush() když:

  • Aplikace se chystá vypnout a chcete před ukončením zajistit odesílání telemetrie.
  • Jste v obslužné rutině výjimky a potřebujete zaručit doručení telemetrie.
  • Píšete krátkodobý proces, jako je úloha na pozadí nebo nástroj rozhraní příkazového řádku, který se rychle ukončí.

Vyhněte se používání Flush() v dlouhotrvajících aplikacích, jako jsou webové služby. Sada SDK automaticky spravuje ukládání do vyrovnávací paměti a přenos. Zbytečné volání Flush() může způsobit problémy s výkonem a nezaručuje odeslání všech dat, zejména při použití ServerTelemetryChannel, který neprovádí vyprázdnění synchronně.

Moduly telemetrie

Application Insights automaticky shromažďuje telemetrii o konkrétních úlohách bez nutnosti ručního sledování uživatelem.

Ve výchozím nastavení jsou povoleny následující moduly automatické kolekce. Můžete je zakázat nebo nakonfigurovat tak, aby měnily výchozí chování.

ASP.NET

Každý modul telemetrie shromažďuje konkrétní typ dat a k odesílání dat používá základní rozhraní API. Moduly jsou nainstalovány různými balíčky NuGet, které také přidávají požadované řádky do .config souboru.

Area Description
Sledování požadavků Shromažďuje telemetrii požadavků (doba odezvy, kód výsledku) pro příchozí webové požadavky.

Modul:Microsoft.ApplicationInsights.Web.RequestTrackingTelemetryModule
NuGet:Microsoft.ApplicationInsights.Web
Sledování závislostí Shromažďuje telemetrii o odchozích závislostech (volání HTTP, volání SQL). Pokud chcete pracovat se službou IIS, nainstalujte agenta Application Insights. Můžete také napsat vlastní sledování závislostí pomocí TrackDependency API. Podporuje autoinstrumentaci pomocí App Service a monitorování virtuálních počítačů a jejich škálovacích sad.

Modul:Microsoft.ApplicationInsights.DependencyCollector.DependencyTrackingTelemetryModule
NuGet:Microsoft.ApplicationInsights.DependencyCollector
Čítače výkonu Shromažďuje čítače výkonu Windows (procesor, paměť, zatížení sítě z instalací IIS). Určete, které čítače (včetně vlastních čítačů). Další informace naleznete v tématu Shromažďování čítačů výkonu systému.

Modul:Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.PerformanceCollectorModule
NuGet:Microsoft.ApplicationInsights.PerfCounterCollector
Čítače událostí Shromažďuje .NET EventCounters. Doporučuje se pro ASP.NET Core a použití napříč platformami namísto čítačů výkonu Windows.

Modul:EventCounterCollectionModule (SDK ≥ 2.8.0)
Živé metriky (QuickPulse) Shromažďuje telemetrii pro panel Živé metriky.

Modul:QuickPulseTelemetryModule
Taktovací signály (App Service) Odesílá heartbeat signály a vlastní metriky pro prostředí služby App Service.

Modul:AppServicesHeartbeatTelemetryModule
Sledovací signály (virtuální počítače a škálovací sady virtuálních počítačů) Odesílá srdcově signály a vlastní metriky pro prostředí virtuálních počítačů Azure.

Modul:AzureInstanceMetadataTelemetryModule
Telemetrie diagnostiky Hlásí chyby v instrumentačním kódu Application Insights (například chybějící čítače, ITelemetryInitializer výjimky). Telemetrie trasování se zobrazí v Diagnostickém hledání.

Modul:Microsoft.ApplicationInsights.Extensibility.Implementation.Tracing.DiagnosticsTelemetryModule
NuGet:Microsoft.ApplicationInsights

Poznámka: Pokud instalujete pouze tento balíček, soubor ApplicationInsights.config se automaticky nevytvořil.
Vývojářský režim (ladicí program připojen) Vynutí TelemetryChannel okamžité odeslání položek, když je připojen debugger. Snižuje latenci, ale zvyšuje režii procesoru nebo sítě.

Modul:Microsoft.ApplicationInsights.WindowsServer.DeveloperModeWithDebuggerAttachedTelemetryModule
NuGet:Application Insights Windows Server
Sledování výjimek (web) Sleduje neošetřené výjimky ve webových aplikacích. Viz Chyby a výjimky.

Modul:Microsoft.ApplicationInsights.Web.ExceptionTrackingTelemetryModule
NuGet:Microsoft.ApplicationInsights.Web
Sledování výjimek (nezpozorované/neošetřené) Sleduje nepozorované výjimky úloh a neošetřené výjimky pro role pracovníků, služby Windows a konzolové aplikace.

Moduly:
 • Microsoft.ApplicationInsights.WindowsServer.UnobservedExceptionTelemetryModule
 • Microsoft.ApplicationInsights.WindowsServer.UnhandledExceptionTelemetryModule
NuGet:Microsoft.ApplicationInsights.WindowsServer
Sledování zdroje událostí Odesílá nakonfigurované události EventSource do Application Insights jako stopy.

Modul:Microsoft.ApplicationInsights.EventSourceListener.EventSourceTelemetryModule
NuGet:Microsoft.ApplicationInsights.EventSourceListener
ETW kolektor Odesílá nakonfigurované události ETW poskytovatele do Application Insights jako stopy.

Modul:Microsoft.ApplicationInsights.EtwCollector.EtwCollectorTelemetryModule
NuGet:Microsoft.ApplicationInsights.EtwCollector
Základní rozhraní API (ne modul) Základní rozhraní API používané jinými komponentami telemetrie a pro vlastní telemetrii

Modul:Microsoft.ApplicationInsights package
NuGet:Microsoft.ApplicationInsights
Poznámka: Pokud instalujete pouze tento balíček, soubor ApplicationInsights.config se automaticky nevytvořil.
ASP.NET Core
Area Description
Sledování požadavků Integrované sledování požadavků prostřednictvím integrace ASP.NET Core Application Insights.

Modul:Žádná samostatná třída modulu.
NuGet:Microsoft.ApplicationInsights.AspNetCore
Sledování závislostí Prostřednictvím kolektoru závislostí.

NuGet:Microsoft.ApplicationInsights.DependencyCollector
Čítače výkonu Jen pro Windows! Na různých platformách použijte EventCounterCollectionModule (viz další řádek).

NuGet:Microsoft.ApplicationInsights.PerfCounterCollector
Čítače událostí Shromažďuje .NET EventCounters. Doporučuje se pro ASP.NET Core a použití napříč platformami namísto čítačů výkonu Windows.

Modul:EventCounterCollectionModule (SDK 2.8.0 a vyšší)
NuGet:Microsoft.ApplicationInsights.EventCounterCollector
Živé metriky (QuickPulse) Živé metriky povoleny v integraci nástroje Application Insights pro ASP.NET Core.

Modul:Žádná samostatná třída modulu.
NuGet:Microsoft.ApplicationInsights.AspNetCore
Kolektor prezenčních signálů (App Service) Odesílá heartbeat signály (jako vlastní metriky) s podrobnostmi o prostředí služby App Service. Integrovaná prostřednictvím základní sady SDK, když je hostovaná ve službě App Service.

Modul:Žádná samostatná třída modulu.
NuGet:Microsoft.ApplicationInsights.AspNetCore
Kolektor prezenčních signálů (virtuální počítače a škálovací sady virtuálních počítačů) Odesílá heartbeatů (jako vlastní metriky) s podrobnostmi o prostředí Azure virtuálního počítače. Integrované díky základnímu SDK při provozu na virtuálních počítačích Azure a škálovacích sadách virtuálních počítačů Azure.

Modul:Žádná samostatná třída modulu.
NuGet:Microsoft.ApplicationInsights.AspNetCore
Telemetrie diagnostiky Hlásí chyby v samotném kódu instrumentace Application Insights (například nemůže získat přístup k čítačům výkonu, ITelemetryInitializer vyvolá výjimku). Telemetrie trasování se zobrazí v Diagnostickém hledání.

Modul:Microsoft.ApplicationInsights.Extensibility.Implementation.Tracing.DiagnosticsTelemetryModule
NuGet:Microsoft.ApplicationInsights
Vývojářský režim (ladicí program připojen) Stejné chování je k dispozici; třída je součástí balíčku Windows Server.

Modul:Microsoft.ApplicationInsights.WindowsServer.DeveloperModeWithDebuggerAttachedTelemetryModule
NuGet:Microsoft.ApplicationInsights.WindowsServer
Sledování výjimek (web) Automatické sledování výjimek v integraci ASP.NET Core Application Insights

Modul:Žádná samostatná třída modulu.
NuGet:Microsoft.ApplicationInsights.AspNetCore
Sledování výjimek (nezpozorované/neošetřené) Podobné chování pomocí běhového prostředí/integrace ASP.NET Core; názvy tříd jsou Windows Server-specifické.

NuGet:Microsoft.ApplicationInsights.WindowsServer
Sledování zdroje událostí Odesílá nakonfigurované události EventSource do Application Insights jako záznamy.

Modul:Microsoft.ApplicationInsights.EventSourceListener.EventSourceTelemetryModule
NuGet:Microsoft.ApplicationInsights.EventSourceListener
ETW kolektor pouze Windows (ETW). Odesílá nakonfigurované události ETW poskytovatele do Application Insights jako stopy.

Modul:Microsoft.ApplicationInsights.EtwCollector.EtwCollectorTelemetryModule
NuGet:Microsoft.ApplicationInsights.EtwCollector
Základní rozhraní API (ne modul) Základní rozhraní API používané jinými komponentami telemetrie a pro vlastní telemetrii

Modul:Microsoft.ApplicationInsights package
NuGet:Microsoft.ApplicationInsights

Konfigurace modulů telemetrie

ASP.NET

Pomocí oddílu TelemetryModules v ApplicationInsights.config nakonfigurujte, přidejte nebo odeberte moduly. Následující příklady:

  • Nastavit DependencyTrackingTelemetryModule (povolit vložení hlaviček W3C).
  • Nakonfigurujte EventCounterCollectionModule (zrušte výchozí nastavení a přidejte jeden čítač).
  • Zakázání kolekce perf-counter odebráním PerformanceCollectorModule.
<ApplicationInsights>
  <TelemetryModules>

    <!-- Dependency tracking -->
    <Add Type="Microsoft.ApplicationInsights.DependencyCollector.DependencyTrackingTelemetryModule, Microsoft.AI.DependencyCollector">
      <!-- Match Core example: enable W3C header injection -->
      <EnableW3CHeadersInjection>true</EnableW3CHeadersInjection>
    </Add>

    <!-- EventCounterCollectionModule: add a single counter (if you use event counters) -->
    <Add Type="Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.EventCounterCollectionModule, Microsoft.AI.PerfCounterCollector">
      <Counters>
        <!-- Mirrors Core example: only collect 'gen-0-size' from System.Runtime -->
        <Add ProviderName="System.Runtime" CounterName="gen-0-size" />
      </Counters>
    </Add>

    <!-- PerformanceCollectorModule (classic Windows performance counters).
         To DISABLE perf-counter collection, do NOT include this module.
         If it already exists in your file, remove or comment it out.
         Example of the line you would remove:
    <Add Type="Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.PerformanceCollectorModule, Microsoft.AI.PerfCounterCollector" />
    -->

  </TelemetryModules>
</ApplicationInsights>

Poznámka:

Přesná sada modulů, které jsou přítomné ve vaší ApplicationInsights.config sadě SDK, závisí na tom, které balíčky SDK jste nainstalovali.

ASP.NET Core

Možnost 1: Konfigurace modulů telemetrie pomocí modulu ConfigureTelemetryModule

Pokud chcete nakonfigurovat jakékoli výchozí TelemetryModule, použijte metodu rozšíření ConfigureTelemetryModule<T> na IServiceCollection, jak je znázorněno v následujícím příkladu:

using Microsoft.ApplicationInsights.DependencyCollector;
using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddApplicationInsightsTelemetry();

// The following configures DependencyTrackingTelemetryModule.
// Similarly, any other default modules can be configured.
builder.Services.ConfigureTelemetryModule<DependencyTrackingTelemetryModule>((module, o) =>
        {
            module.EnableW3CHeadersInjection = true;
        });

// The following removes all default counters from EventCounterCollectionModule, and adds a single one.
builder.Services.ConfigureTelemetryModule<EventCounterCollectionModule>((module, o) =>
        {
            module.Counters.Add(new EventCounterCollectionRequest("System.Runtime", "gen-0-size"));
        });

// The following removes PerformanceCollectorModule to disable perf-counter collection.
// Similarly, any other default modules can be removed.
var performanceCounterService = builder.Services.FirstOrDefault<ServiceDescriptor>(t => t.ImplementationType == typeof(PerformanceCollectorModule));
if (performanceCounterService != null)
{
    builder.Services.Remove(performanceCounterService);
}

var app = builder.Build();

Možnost 2: Konfigurace modulů telemetrie pomocí ApplicationInsightsServiceOptions

Ve verzích SDK 2.12.2 a novějších můžete upravit několik běžných nastavení předáním ApplicationInsightsServiceOptions do AddApplicationInsightsTelemetry, jak je uvedeno v tomto příkladu:

var builder = WebApplication.CreateBuilder(args);

var aiOptions = new Microsoft.ApplicationInsights.AspNetCore.Extensions.ApplicationInsightsServiceOptions();

// Disables adaptive sampling.
aiOptions.EnableAdaptiveSampling = false;

// Disables live metrics (also known as QuickPulse).
aiOptions.EnableQuickPulseMetricStream = false;

builder.Services.AddApplicationInsightsTelemetry(aiOptions);
var app = builder.Build();

Tato tabulka obsahuje úplný seznam ApplicationInsightsServiceOptions nastavení:

Setting Description Výchozí
PovolitModuleProSběrVýkonovýchPočítadel Povolit nebo zakázat PerformanceCounterCollectionModule. Pravdivé
Modul pro povolení sledování požadavků pomocí telemetrie Povolit nebo zakázat RequestTrackingTelemetryModule. Pravdivé
EnableEventCounterCollectionModule Povolit nebo zakázat EventCounterCollectionModule. Pravdivé
Modul pro umožnění sledování závislostí telemetrie Povolit nebo zakázat DependencyTrackingTelemetryModule. Pravdivé
Modul telemetrie srdečního tepu služby App Services Povolit nebo zakázat AppServicesHeartbeatTelemetryModule. Pravdivé
PovolitAzureInstanceMetadataTelemetrickýModul Povolit nebo zakázat AzureInstanceMetadataTelemetryModule. Pravdivé
PovolitRychlýPulzMetrickýTok Povolení nebo zakázání funkce LiveMetrics Pravdivé
PovolitAdaptivníVzorkování Povolení nebo zakázání adaptivního vzorkování Pravdivé
Povolit srdeční tep Povolit nebo zakázat funkci heartbeat signálu. Pravidelně (ve výchozím nastavení každých 15 minut) odesílá vlastní metriku s názvem HeartbeatState s informacemi o modulu runtime, jako je verze .NET a informace o prostředí Azure, pokud je to relevantní. Pravdivé
PřidatExtraktorAutomatickyShromažďovanýchMetrik Povolte nebo zakažte funkci AutoCollectedMetrics extractor. Tento procesor telemetrie odesílá předem agregované metriky o požadavcích a závislostech před vzorkováním. Pravdivé
MožnostiSběruŽádostí.SledovatVýjimky Povolte nebo zakažte hlášení o neošetřených výjimkách modulem pro shromažďování požadavků. Hodnota False v netstandard2.0 (protože výjimky jsou sledovány pomocí ApplicationInsightsLoggerProvider). Jinak platí.
Povolit Modul Diagnostické Telemetrie Povolit nebo zakázat DiagnosticsTelemetryModule. Zakázání způsobí ignorování následujících nastavení: EnableHeartbeat, EnableAzureInstanceMetadataTelemetryModulea EnableAppServicesHeartbeatTelemetryModule. Pravdivé

Nejnovější seznam najdete v konfigurovatelném nastavení v ApplicationInsightsServiceOptions.

Doporučení konfigurace pro Microsoft.ApplicationInsights.AspNetCore SDK 2.15.0 a novější

V sadě SDK Microsoft.ApplicationInsights.AspNetCore verze 2.15.0 a novější můžete nakonfigurovat všechna nastavení, která jsou k dispozici, včetně ApplicationInsightsServiceOptions. Použijte instanci aplikace IConfiguration . Nastavení musí být pod částí ApplicationInsights, jak je znázorněno v následujícím příkladu. Následující část z appsettings.json nakonfiguruje připojovací řetězec a zakáže adaptivní vzorkování a shromažďování čítačů výkonu.

{
    "ApplicationInsights": {
    "ConnectionString": "<YOUR-CONNECTION-STRING>",
    "EnableAdaptiveSampling": false,
    "EnablePerformanceCounterCollectionModule": false
    }
}

Pokud se používá buď builder.Services.AddApplicationInsightsTelemetry(aiOptions) pro ASP.NET Core 6.0, nebo services.AddApplicationInsightsTelemetry(aiOptions) pro ASP.NET Core 3.1 a starší, přepíše to nastavení z Microsoft.Extensions.Configuration.IConfiguration.

Pracovní služba

Možnost 1: Konfigurace modulů telemetrie pomocí modulu ConfigureTelemetryModule

Application Insights používá moduly telemetrie k automatickému shromažďování telemetrických dat o konkrétních úlohách bez nutnosti ručního sledování.

Ve výchozím nastavení jsou povoleny následující moduly autocollection. Tyto moduly zodpovídají za automatické shromažďování telemetrie. Můžete je zakázat nebo nakonfigurovat tak, aby měnily výchozí chování.

  • DependencyTrackingTelemetryModule
  • PerformanceCollectorModule
  • QuickPulseTelemetryModule
  • AppServicesHeartbeatTelemetryModule (V současné době došlo k problému souvisejícímu s tímto modulem telemetrie. Dočasné alternativní řešení najdete v tématu Problém GitHubu 1689.)
  • AzureInstanceMetadataTelemetryModule

Pokud chcete nakonfigurovat jakýkoliv výchozí modul telemetrie, použijte metodu rozšíření ConfigureTelemetryModule na IServiceCollection, jak je znázorněno v následujícím příkladu:

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

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddApplicationInsightsTelemetryWorkerService();

            // The following configures QuickPulseTelemetryModule.
            // Similarly, any other default modules can be configured.
            services.ConfigureTelemetryModule<QuickPulseTelemetryModule>((module, o) =>
            {
                module.AuthenticationApiKey = "<YOUR-API-KEY-HERE>";
            });

            // The following removes PerformanceCollectorModule to disable perf-counter collection.
            // Similarly, any other default modules can be removed.
            var performanceCounterService = services.FirstOrDefault<ServiceDescriptor>
                                        (t => t.ImplementationType == typeof(PerformanceCollectorModule));
            if (performanceCounterService != null)
            {
                services.Remove(performanceCounterService);
            }
    }

Možnost 2: Konfigurace modulů telemetrie pomocí ApplicationInsightsServiceOptions

Můžete upravit několik běžných nastavení předáním ApplicationInsightsServiceOptions do AddApplicationInsightsTelemetryWorkerService, jak je vidět v tomto příkladu:

using Microsoft.ApplicationInsights.WorkerService;

public void ConfigureServices(IServiceCollection services)
{
    var aiOptions = new ApplicationInsightsServiceOptions();
    // Disables adaptive sampling.
    aiOptions.EnableAdaptiveSampling = false;

    // Disables live metrics (also known as QuickPulse).
    aiOptions.EnableQuickPulseMetricStream = false;
    services.AddApplicationInsightsTelemetryWorkerService(aiOptions);
}

ApplicationInsightsServiceOptions v této sadě SDK je v jmenném prostoru Microsoft.ApplicationInsights.WorkerService na rozdíl od Microsoft.ApplicationInsights.AspNetCore.Extensions v ASP.NET Core SDK.

Následující tabulka uvádí běžně používaná nastavení v ApplicationInsightsServiceOptions.

Setting Description Výchozí
PovolitRychlýPulzMetrickýTok Povolte nebo zakažte funkci živých metrik. Pravdivé
PovolitAdaptivníVzorkování Povolení nebo zakázání adaptivního vzorkování Pravdivé
Povolit srdeční tep Povolte nebo zakažte funkci Heartbeats, která pravidelně (15 minut jako výchozí) odesílá vlastní metriku s názvem HeartBeatState s informacemi o prostředí runtime, jako je verze .NET a prostředí Azure, pokud je relevantní. Pravdivé
PřidatExtraktorAutomatickyShromažďovanýchMetrik Povolte nebo zakažte extraktor AutoCollectedMetrics, což je procesor telemetrie, který před vzorkováním odesílá předem agregované metriky o požadavcích a závislostech. Pravdivé
Povolit Modul Diagnostické Telemetrie Povolit nebo zakázat DiagnosticsTelemetryModule. Zakázání tohoto nastavení způsobí ignorování následujících nastavení: EnableHeartbeat, EnableAzureInstanceMetadataTelemetryModulea EnableAppServicesHeartbeatTelemetryModule. Pravdivé

Nejaktuálnější seznam najdete v konfigurovatelných nastaveních v ApplicationInsightsServiceOptions.

Zakázání telemetrie

ASP.NET

V konfiguračním souboru pro každý modul je uzel. Pokud chcete modul zakázat, odstraňte uzel nebo ho okomentujte.

ASP.NET Core

Pokud chcete telemetrii podmíněně a dynamicky zakázat, můžete kdekoli ve vašem kódu vyřešit instanci TelemetryConfiguration pomocí kontejneru pro vkládání závislostí ASP.NET Core a nastavit na ní příznak DisableTelemetry.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddApplicationInsightsTelemetry();

// any custom configuration can be done here:
builder.Services.Configure<TelemetryConfiguration>(x => x.DisableTelemetry = true);

var app = builder.Build();

Předchozí ukázka kódu brání odesílání telemetrie do Application Insights. Nezabrání automatickým sběrným modulům ve shromažďování telemetrie. Pokud chcete odebrat konkrétní modul automatického sběru, podívejte se na moduly telemetrie.

Pracovní služba

Pokud chcete telemetrii podmíněně a dynamicky zakázat, můžete kdekoli ve vašem kódu vyřešit instanci TelemetryConfiguration pomocí kontejneru pro vkládání závislostí ASP.NET Core a nastavit na ní příznak DisableTelemetry.

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddApplicationInsightsTelemetryWorkerService();
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, TelemetryConfiguration configuration)
    {
        configuration.DisableTelemetry = true;
        ...
    }

Připojovací řetězec

Toto nastavení určuje prostředek Application Insights, ve kterém se vaše data zobrazují. Obvykle vytvoříte samostatný prostředek se samostatným připojovacím řetězcem pro každou aplikaci.

Ukázky kódu najdete v tématu Připojovací řetězce v Application Insights.

Pokud chcete připojovací řetězec nastavit dynamicky, například pro odesílání výsledků z vaší aplikace do různých prostředků, můžete vynechat připojovací řetězec z konfiguračního souboru a místo toho ho nastavit v kódu.

ASP.NET

Pokud chcete nastavit připojovací řetězec pro všechny instance TelemetryClient, včetně standardních modulů telemetrie, proveďte tento krok v inicializační metodě, například global.aspx.cs ve službě ASP.NET:

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

    protected void Application_Start()
    {
        TelemetryConfiguration configuration = TelemetryConfiguration.CreateDefault();
        configuration.ConnectionString = "<YOUR-CONNECTION-STRING>";
        var telemetryClient = new TelemetryClient(configuration);

Pokud chcete odeslat konkrétní sadu událostí do jiného prostředku, můžete klíč pro konkrétního klienta telemetrie nastavit:


    var tc = new TelemetryClient();
    tc.Context.ConnectionString = "<YOUR-CONNECTION-STRING>";
    tc.TrackEvent("myEvent");
    // ...

Pokud chcete získat nový připojovací řetězec, vytvořte nový prostředek na portálu Application Insights.

ASP.NET Core

V ASP.NET Core nakonfigurujte připojovací řetězec v Program.cs při spuštění aplikace pomocí kontejneru injektáže závislostí (DI) TelemetryConfiguration:

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

var builder = WebApplication.CreateBuilder(args);

// Add Application Insights
builder.Services.AddApplicationInsightsTelemetry();

var app = builder.Build();

// Resolve TelemetryConfiguration from DI and set the connection string
var config = app.Services.GetRequiredService<TelemetryConfiguration>();
config.ConnectionString = "<YOUR-CONNECTION-STRING>";

app.Run();

Pokud chcete odeslat konkrétní sadu událostí do jiného prostředku, můžete vytvořit novou TelemetryClient instanci a explicitně nastavit její připojovací řetězec:

using Microsoft.ApplicationInsights;

var tc = new TelemetryClient();
tc.Context.ConnectionString = "<YOUR-CONNECTION-STRING>";
tc.TrackEvent("myEvent");
// ...

Poskytovatel ID aplikace

Poznámka:

Pro ASP.NET je tento poskytovatel dostupný od sady SDK verze 2.6.0*.

Účelem tohoto poskytovatele je vyhledat ID aplikace na základě připojovacího řetězce. ID aplikace je součástí RequestTelemetry a DependencyTelemetry slouží k určení korelace na portálu.

Tato funkce je dostupná nastavením TelemetryConfiguration.ApplicationIdProvider.

Rozhraní: IApplicationIdProvider

public interface IApplicationIdProvider
{
    bool TryGetApplicationId(string connectionString, out string applicationId);
}

Poskytujeme dvě implementace v sadě Microsoft.ApplicationInsights SDK: ApplicationInsightsApplicationIdProvider a DictionaryApplicationIdProvider.

ApplicationInsightsApplicationIdProvider

Tato obálka je určená pro rozhraní profilu API. Omezuje požadavky a ukládá výsledky do mezipaměti. Tento zprostředkovatel se automaticky zahrne při instalaci Microsoft.ApplicationInsights.DependencyCollector nebo Microsoft.ApplicationInsights.Web.

Třída zveřejňuje volitelnou vlastnost s názvem ProfileQueryEndpoint. Ve výchozím nastavení je nastavená na https://dc.services.visualstudio.com/api/profiles/{0}/appIdhodnotu .

Pokud potřebujete nakonfigurovat proxy server, doporučujeme základní adresu proxyovat a zajistit, aby cesta zahrnovala /api/profiles/{0}/appId. Během běhu se {0} nahradí připojovacím řetězcem pro každý požadavek.

ASP.NET

Příklad konfigurace prostřednictvím ApplicationInsights.config

<ApplicationInsights>
    ...
    <ApplicationIdProvider Type="Microsoft.ApplicationInsights.Extensibility.Implementation.ApplicationId.ApplicationInsightsApplicationIdProvider, Microsoft.ApplicationInsights">
        <ProfileQueryEndpoint>https://dc.services.visualstudio.com/api/profiles/{0}/appId</ProfileQueryEndpoint>
    </ApplicationIdProvider>
    ...
</ApplicationInsights>

Příklad konfigurace prostřednictvím kódu

TelemetryConfiguration.Active.ApplicationIdProvider = new ApplicationInsightsApplicationIdProvider();
ASP.NET Core

Poznámka:

V ASP.NET Core neexistuje žádný soubor ApplicationInsights.config. Konfigurace se provádí prostřednictvím injektáže závislostí (DI) v Program.cs nebo Startup.cs.

Můžete přepsat výchozího poskytovatele nebo přizpůsobit jeho ProfileQueryEndpoint.

using Microsoft.ApplicationInsights.Extensibility.Implementation.ApplicationId;

var builder = WebApplication.CreateBuilder(args);

// Add Application Insights
builder.Services.AddApplicationInsightsTelemetry();

// Replace default provider with custom configuration
builder.Services.AddSingleton<IApplicationIdProvider>(sp =>
    new ApplicationInsightsApplicationIdProvider
    {
        ProfileQueryEndpoint = "https://custom-proxy/api/profiles/{0}/appId"
    });

var app = builder.Build();
app.Run();

DictionaryApplicationIdProvider

Tento statický zprostředkovatel spoléhá na nakonfigurované páry připojovacího řetězce nebo ID aplikace.

Tato třída má vlastnost Defined, což je Dictionary<string,string> dvojic připojovací řetězeců a ID aplikací.

Tato třída má volitelnou vlastnost Next, kterou lze použít ke konfiguraci jiného zprostředkovatele, který se má použít, když je požadován připojovací řetězec, který v konfiguraci neexistuje.

ASP.NET

Příklad konfigurace prostřednictvím ApplicationInsights.config

<ApplicationInsights>
    ...
    <ApplicationIdProvider Type="Microsoft.ApplicationInsights.Extensibility.Implementation.ApplicationId.DictionaryApplicationIdProvider, Microsoft.ApplicationInsights">
        <Defined>
            <Type key="ConnectionString_1" value="ApplicationId_1"/>
            <Type key="ConnectionString_2" value="ApplicationId_2"/>
        </Defined>
        <Next Type="Microsoft.ApplicationInsights.Extensibility.Implementation.ApplicationId.ApplicationInsightsApplicationIdProvider, Microsoft.ApplicationInsights" />
    </ApplicationIdProvider>
    ...
</ApplicationInsights>

Příklad konfigurace prostřednictvím kódu

TelemetryConfiguration.Active.ApplicationIdProvider = new DictionaryApplicationIdProvider{
 Defined = new Dictionary<string, string>
    {
        {"ConnectionString_1", "ApplicationId_1"},
        {"ConnectionString_2", "ApplicationId_2"}
    }
};
ASP.NET Core
using Microsoft.ApplicationInsights.Extensibility.Implementation.ApplicationId;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddApplicationInsightsTelemetry();

// Register DictionaryApplicationIdProvider
builder.Services.AddSingleton<IApplicationIdProvider>(sp =>
    new DictionaryApplicationIdProvider
    {
        Defined = new Dictionary<string, string>
        {
            { "ConnectionString_1", "ApplicationId_1" },
            { "ConnectionString_2", "ApplicationId_2" }
        },
        Next = new ApplicationInsightsApplicationIdProvider() // optional fallback
    });

var app = builder.Build();
app.Run();

Přidat monitorování na straně klienta

Předchozí části obsahují pokyny k automatické a ruční konfiguraci monitorování na straně serveru. Pokud chcete přidat monitorování na straně klienta, použijte sadu JavaScript SDK na straně klienta. Transakce na straně klienta libovolné webové stránky můžete monitorovat přidáním JavaScript (Web) SDK zavaděcího skriptu před koncovou </head> značku HTML stránky.

I když je možné ručně přidat JavaScript (Web) SDK Loader Script do záhlaví každé stránky HTML, doporučujeme místo toho přidat JavaScript (Web) SDK Loader Script na hlavní stránku. Tato akce vloží skript zavaděče sady JavaScript (Web) SDK na všechny stránky webu.

ASP.NET

Pro aplikaci založenou na šabloně ASP.NET MVC z tohoto článku je soubor, který potřebujete upravit, _Layout.cshtml. Najdete to pod Zobrazení>Sdílené. Pokud chcete přidat monitorování na straně klienta, otevřete soubor _Layout.cshtml a postupujte podle pokynů pro nastavení JavaScript (Web) SDK založeného na skriptech z článku o konfiguraci této sady na straně klienta.

ASP.NET Core

Pokud má vaše aplikace komponenty na straně klienta, postupujte podle dalších kroků a začněte shromažďovat telemetrické údaje o využití pomocí vložení skriptu zavaděče sady JavaScript (Web) SDK dle konfigurace.

  1. Do souboru _ViewImports.cshtml přidejte injektáž:

    @inject Microsoft.ApplicationInsights.AspNetCore.JavaScriptSnippet JavaScriptSnippet

  2. V souboru _Layout.cshtml vložte HtmlHelper na konec sekce <head>, ale před jakýkoli jiný skript. Pokud chcete nahlásit vlastní telemetrii JavaScriptu ze stránky, zadejte ji za tento fragment kódu:

        @Html.Raw(JavaScriptSnippet.FullScript)
</head>

Jako alternativu k použití FullScript je k dispozici ScriptBody počínaje sadou Application Insights SDK pro ASP.NET Core verze 2.14. Použijte ScriptBody , pokud potřebujete řídit <script> značku pro nastavení zásad zabezpečení obsahu:

<script> // apply custom changes to this script tag.
    @Html.Raw(JavaScriptSnippet.ScriptBody)
</script>

Názvy souborů .cshtml odkazované dříve pocházejí z výchozí šablony aplikace MVC. Pokud chcete pro svou aplikaci správně povolit monitorování na straně klienta, musí se skript zavaděče sady JavaScript (Web) SDK zobrazit v <head> části každé stránky aplikace, kterou chcete monitorovat. Přidejte skript zavaděče sady JavaScript (Web) SDK do souboru _Layout.cshtml v šabloně aplikace pro povolení monitorování na straně klienta.

Pokud váš projekt neobsahuje _Layout.cshtml, můžete monitorování na straně klienta přidat přidáním skriptu zavaděče sady JavaScript (Web) SDK do ekvivalentního souboru, který řídí <head> všechny stránky v aplikaci. Případně můžete přidat skript JavaScript (Web) SDK Loader Script na více stránek, ale toto použití nedoporučujeme.

Poznámka:

Injektáž JavaScriptu poskytuje výchozí prostředí konfigurace. Pokud vyžadujete konfiguraci nad rámec nastavení připojovacího řetězce, musíte autoinjection odebrat podle popisu a ručně přidat javascriptovou sadu SDK.

Základní rozhraní API pro vlastní události a metriky

Vložte do aplikace několik řádků kódu, abyste zjistili, co s ním uživatelé dělají, nebo abyste mohli diagnostikovat problémy. Můžete odesílat telemetrii ze zařízení a desktopových aplikací, webových klientů a webových serverů. Pomocí základního rozhraní API telemetrie Application Insights můžete odesílat vlastní události a metriky a vlastní verze standardní telemetrie. Toto rozhraní API je to samé, které používají standardní kolektory dat Application Insights.

Souhrn rozhraní API

Základní rozhraní API je jednotné na všech platformách, kromě několika odchylek, jako je GetMetric (pouze pro .NET).

Metoda Používá se pro
TrackPageView Stránky, obrazovky, podokna nebo formuláře
TrackEvent Akce uživatelů a další události Používá se ke sledování chování uživatelů nebo ke sledování výkonu.
GetMetric Nulové a multidimenzionální metriky, centrálně nakonfigurované agregace, pouze C#.
TrackMetric Měření výkonu, jako jsou délky front, nesouvisely s konkrétními událostmi.
TrackException Protokolování výjimek pro diagnostiku Sledovat, kde se vyskytují ve vztahu k jiným událostem, a zkoumat trasování zásobníku.
TrackRequest Protokolování frekvence a doby trvání požadavků serveru pro analýzu výkonu
TrackTrace Zprávy logu diagnostiky prostředků Můžete také zaznamenávat protokoly třetích stran.
TrackDependency Protokolování doby trvání a frekvence volání externích komponent, na které vaše aplikace závisí.

K většině těchto volání telemetrie můžete připojit vlastnosti a metriky .

Předpoklady

Pokud zatím nemáte referenci na Application Insights SDK:

  1. Přidejte do projektu sadu Application Insights SDK.

  2. Zahrňte do kódu vašeho zařízení nebo webového serveru:

    using Microsoft.ApplicationInsights;

Získání instance TelemetryClient

Získání instance TelemetryClient:

Poznámka:

Pokud používáte Azure Functions v2 nebo Azure WebJobs v3+, přečtěte si Monitor Azure Functions.

Poznámka:

V případě aplikací ASP.NET Core a jiných než HTTP/Worker pro aplikace .NET/.NET Core získejte instanci TelemetryClient z kontejneru injektáže závislostí, jak je vysvětleno v příslušné dokumentaci.

private TelemetryClient telemetry = new TelemetryClient();

Pokud se zobrazí zpráva s informací, že tato metoda je zastaralá, další informace najdete v tématu microsoft/ApplicationInsights-dotnet#1152 .

Příchozí požadavky HTTP se zaznamenávají automaticky. Možná budete chtít vytvořit další instance pro další moduly TelemetryClient vaší aplikace. Můžete mít například v middlewarové třídě jednu TelemetryClient instanci pro hlášení událostí obchodní logiky. Můžete nastavit vlastnosti, například UserId a DeviceId identifikovat počítač. Tyto informace jsou připojeny ke všem událostem, které instance odesílá.

TelemetryClient.Context.User.Id = "...";
TelemetryClient.Context.Device.Id = "...";

Poznámka:

TelemetryClient je vláknově bezpečné.

TrackEvent

Ve službě Application Insights je vlastní událost datovým bodem, který můžete v Průzkumníku metrik zobrazit jako agregovaný počet a ve službě Search jako jednotlivé výskyty. (Nesouvisí s MVC ani s jinými "frameworkovými událostmi".)

Vložte volání TrackEvent do kódu pro počítání různých událostí. Můžete například chtít sledovat, jak často si uživatelé vyberou konkrétní funkci. Nebo můžete chtít vědět, jak často dosahují určitých cílů nebo dělají určité typy chyb.

Například v aplikaci hry odešlete událost pokaždé, když uživatel vyhraje hru:

telemetry.TrackEvent("WinGame");

Vlastní události v Log Analytics

Telemetrie je dostupná v customEvents tabulce na kartě Protokoly Application Insights nebo v prostředí využití. Události můžou pocházet z trackEvent(..) nebo z modulu plug-in Click Analytics Autocollection.

Pokud je vzorkování v provozu, itemCount vlastnost zobrazuje hodnotu větší než 1. Například itemCount==10 znamená, že z 10 volání na trackEvent() proces vzorkování přenesl pouze jedno. Pokud chcete získat správný počet vlastních událostí, použijte kód, například customEvents | summarize sum(itemCount).

Poznámka:

itemCount má minimální hodnotu jedné; samotný záznam představuje položku.

GetMetric

Jak se naučit efektivně využívat volání GetMetric() pro zachytávání místně předem agregovaných metrik v aplikacích .NET a .NET Core, naleznete v části Vlastní sběr metrik v .NET a .NET Core.

TrackMetric

Poznámka:

Microsoft.ApplicationInsights.TelemetryClient.TrackMetric není upřednostňovanou metodou odesílání metrik. Metriky by se měly před odesláním vždy předem agregovat napříč časovým obdobím. Pomocí jednoho z přetížených objektů GetMetric(..) můžete získat metrický objekt pro přístup k funkcím preagregace v sadě SDK.

Pokud implementujete vlastní logiku před agregací, můžete použít metodu TrackMetric() k odeslání výsledných agregací. Pokud vaše aplikace vyžaduje odesílání samostatné položky telemetrie při každé příležitosti bez agregace v čase, pravděpodobně máte případ použití pro telemetrii událostí. Viz TelemetryClient.TrackEvent(Microsoft.ApplicationInsights.DataContracts.EventTelemetry).

Application Insights může grafovat metriky, které nejsou připojené k určitým událostem. Můžete například monitorovat délku fronty v pravidelných intervalech. U metrik jsou jednotlivá měření méně zajímavá než variace a trendy, takže statistické grafy jsou užitečné.

K odesílání metrik do Application Insights můžete použít TrackMetric(..) rozhraní API. Metriku můžete odeslat dvěma způsoby:

  • Jedna hodnota. Pokaždé, když v aplikaci provedete měření, odešlete odpovídající hodnotu do Application Insights.

    Předpokládejme například, že máte metriku, která popisuje počet položek v kontejneru. Během určitého časového období nejprve vložíte do kontejneru tři položky a pak odeberete dvě položky. Proto byste volali TrackMetric dvakrát. Nejprve byste předali hodnotu 3 a pak předali hodnotu -2. Application Insights ukládá obě hodnoty za vás.

  • Agregace. Při práci s metrikami je každé měření zřídka zajímavé. Místo toho je důležité shrnutí toho, co se stalo během určitého časového období. Takový souhrn se nazývá agregace.

    V předchozím příkladu je 1 agregační součet metrik pro dané časové období a počet hodnot metriky .2 Při použití přístupu k agregaci vyvoláte TrackMetric pouze jednou za časové období a odešlete agregované hodnoty. Tento přístup doporučujeme, protože může výrazně snížit náklady a výkon tím, že do Application Insights odesílá méně datových bodů, zatímco stále shromažďuje všechny relevantní informace.

Příklady s jednou hodnotou

Odeslání jedné hodnoty metriky:

var sample = new MetricTelemetry();
sample.Name = "queueLength";
sample.Sum = 42.3;
telemetryClient.TrackMetric(sample);

Vlastní metriky v Log Analytics

Telemetrie je dostupná v tabulce v customMetricsAnalýzách Application Insights. Každý řádek představuje volání trackMetric(..) v aplikaci.

  • valueSum: Součet měření. Chcete-li získat střední hodnotu, vydělte hodnotou valueCount.
  • valueCount: Počet měření, které byly agregovány do tohoto trackMetric(..) volání.

Poznámka:

valueCount má minimální hodnotu jedné; samotný záznam představuje položku.

Zobrazení stránek

V zařízení nebo webové aplikaci se při načtení každé obrazovky nebo stránky automaticky odesílají data o zobrazení stránek. Výchozí nastavení ale můžete změnit tak, aby sledovala zobrazení stránek ve více nebo různých časech. Například v aplikaci, která zobrazuje karty nebo podokna, můžete chtít sledovat stránku pokaždé, když uživatel otevře nové podokno.

Data uživatelů a relací se odesílají jako vlastnosti spolu se zobrazeními stránek, takže grafy uživatelů a relací ožijí, když dojde k telemetrii zobrazení stránky.

Vlastní zobrazení stránek

telemetry.TrackPageView("GameReviewPage");

Telemetrie stránek v Log Analytics

V Log Analytics zobrazují dvě tabulky data z operací prohlížeče:

  • pageViews: Obsahuje data o adrese URL a názvu stránky.
  • browserTimings: Obsahuje data o výkonu klienta, jako je doba potřebná ke zpracování příchozích dat.

Zjistěte, jak dlouho prohlížeči trvá zpracování různých stránek:

browserTimings
| summarize avg(networkDuration), avg(processingDuration), avg(totalDuration) by name

Pokud chcete zjistit popularitu různých prohlížečů:

pageViews
| summarize count() by client_Browser

Chcete-li přidružit zobrazení stránek k voláním AJAX, spojte je se závislostmi:

pageViews
| join (dependencies) on operation_Id

TrackRequest

Serverová sada SDK používá TrackRequest k protokolování požadavků HTTP.

Můžete ho také volat sami, pokud chcete simulovat požadavky v kontextu, kde nemáte spuštěný modul webové služby.

Doporučeným způsobem odesílání telemetrie požadavků je místo, kde požadavek funguje jako kontext operace.

Kontext operace

Položky telemetrie můžete vzájemně korelovat tím, že je přidružíte k kontextu operace. Standardní modul pro sledování požadavků zpracovává výjimky a jiné události, které jsou odesílány během zpracování požadavku HTTP. Ve službě Search a Analytics můžete snadno najít všechny události přidružené k požadavku pomocí ID operace.

Pokud telemetrii sledujete ručně, nejjednodušší způsob, jak zajistit korelaci telemetrie pomocí tohoto vzoru:

// Establish an operation context and associated telemetry item:
using (var operation = telemetryClient.StartOperation<RequestTelemetry>("operationName"))
{
    // Telemetry sent in here uses the same operation ID.
    ...
    telemetryClient.TrackTrace(...); // or other Track* calls
    ...

    // Set properties of containing telemetry item--for example:
    operation.Telemetry.ResponseCode = "200";

    // Optional: explicitly send telemetry item:
    telemetryClient.StopOperation(operation);

} // When operation is disposed, telemetry item is sent.

Další informace o korelaci najdete v tématu Korelace telemetrie v Application Insights.

Spolu s nastavením kontextu StartOperation operace vytvoří položku telemetrie zadaného typu. Odesílá položku telemetrie, když odstraníte operaci nebo pokud explicitně zavoláte StopOperation. Pokud jako typ telemetrie použijete RequestTelemetry , jeho doba trvání se nastaví na časový interval mezi spuštěním a zastavením.

Položky telemetrie hlášené v rámci operace se stanou podřízenými položkami takové operace. Kontexty operací můžou být vnořené.

Při hledání se kontext operace používá k vytvoření seznamu Souvisejících položek .

Snímek obrazovky se seznamem Souvisejících položek

Další informace o sledování vlastních operací najdete v Track custom operations with Application Insights .NET SDK.

Žádosti v Log Analytics

V Application Insights Analytics se požadavky zobrazí v requests tabulce.

Pokud je vzorkování v provozu, itemCount vlastnost zobrazuje hodnotu větší než 1. Například itemCount==10 znamená, že z 10 volání na trackRequest() proces vzorkování přenesl pouze jedno. Pokud chcete získat správný počet požadavků a průměrnou dobu trvání segmentovanou podle názvů požadavků, použijte kód, například:

requests
| summarize count = sum(itemCount), avgduration = avg(duration) by name

TrackException

Odesílání výjimek do Application Insights:

Hlášení zahrnují zásobníkové trasování.

try
{
    ...
}
catch (Exception ex)
{
    telemetry.TrackException(ex);
}

SDK automaticky zachytává mnoho výjimek, takže ne vždy musíte volat TrackException explicitně.

Výjimky v Log Analytics

V Application Insights Analytics se výjimky zobrazují v exceptions tabulce.

Pokud je vzorkování v provozu, itemCount vlastnost zobrazuje hodnotu větší než 1. Například itemCount==10 znamená, že z 10 volání na trackException() proces vzorkování přenesl pouze jedno. Pokud chcete získat správný počet výjimek segmentovaných podle typu výjimky, použijte kód, například:

exceptions
| summarize sum(itemCount) by type

Většina důležitých informací o zásobníku je již extrahována do samostatných proměnných, ale můžete strukturu details rozdělit pro získání dalších informací. Vzhledem k tomu, že je tato struktura dynamická, měli byste výsledek přetypovat na očekávaný typ. Například:

exceptions
| extend method2 = tostring(details[0].parsedStack[1].method)

Pokud chcete přidružit výjimky k souvisejícím požadavkům, použijte připojení:

exceptions
| join (requests) on operation_Id

TrackTrace

Použijte TrackTrace k diagnostice problémů odesláním "stopy drobečků" do Application Insights. Můžete odesílat bloky diagnostických dat a kontrolovat je ve vyhledávání.

V .NET adaptérech protokolu použijte toto rozhraní API k odesílání protokolů třetích stran na portál.

telemetry.TrackTrace(message, SeverityLevel.Warning, properties);

Zaznamená diagnostickou událost, jako je zadání nebo opuštění metody.

Parameter Description
message Diagnostická data. Může být mnohem delší než název.
properties Mapa od řetězce k řetězci Další data se používají k filtrování výjimek na portálu. Výchozí hodnota je prázdná.
severityLevel Podporované hodnoty: SeverityLevel.ts.

Obsah zprávy můžete prohledávat, ale na rozdíl od hodnot vlastností na něm nemůžete filtrovat.

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

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

var telemetry = new Microsoft.ApplicationInsights.TelemetryClient();
telemetry.TrackTrace("Slow database response",
                SeverityLevel.Warning,
                new Dictionary<string,string> { {"database", db.ID} });

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

Trasování v Log Analytics

V Application Insights Analytics se volání do TrackTrace zobrazují v tabulce traces.

Pokud je vzorkování v provozu, itemCount vlastnost zobrazuje hodnotu větší než 1. Například itemCount==10 znamená, že z 10 volání na trackTrace() proces vzorkování přenesl pouze jedno. Chcete-li získat správný počet volání trasování, použijte například tento kód: traces | summarize sum(itemCount).

TrackDependency

TrackDependency Volání slouží ke sledování doby odezvy a míry úspěšnosti při volání externí části kódu. Výsledky se zobrazí v grafech závislostí na portálu. Následující fragment kódu se musí přidat všude, kde se provádí volání závislostí.

Poznámka:

Pro .NET a .NET Core můžete alternativně použít metodu TelemetryClient.StartOperation (extension), která vyplní vlastnosti DependencyTelemetry potřebné pro korelaci a některé další vlastnosti, jako je počáteční čas a doba trvání, takže nemusíte vytvářet vlastní časovač jako v následujících příkladech. Pro více informací viz část o sledování odchozích závislostí v Sledování vlastních operací pomocí sady Application Insights .NET SDK.

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

Nezapomeňte, že sady SDK serveru zahrnují modul závislostí , který zjišťuje a sleduje určitá volání závislostí automaticky, například databázím a rozhraním REST API. Abyste mohli modul fungovat, musíte na server nainstalovat agenta.

Toto volání použijete, pokud chcete sledovat volání, která automatizované sledování nezachytí.

Pokud chcete vypnout standardní modul sledování závislostí v jazyce C#, upravte ApplicationInsights.config a odstraňte odkaz na DependencyCollector.DependencyTrackingTelemetryModule.

Závislosti v Log Analytics

V Application Insights Analytics se trackDependency volání zobrazí v dependencies tabulce.

Pokud je vzorkování v provozu, vlastnost itemCount zobrazuje hodnotu větší než 1. Například itemCount==10 znamená, že z 10 volání na trackDependency() proces vzorkování přenesl pouze jedno. Pokud chcete získat správný počet závislostí segmentovaných podle cílové komponenty, použijte kód, například:

dependencies
| summarize sum(itemCount) by target

Pokud chcete přidružit závislosti k souvisejícím požadavkům, použijte spojení:

dependencies
| join (requests) on operation_Id

Vyčištění dat

Sada SDK obvykle odesílá data v pevných intervalech, obvykle 30 sekund nebo kdykoli je vyrovnávací paměť plná, což je obvykle 500 položek. V některých případech můžete chtít vyrovnávací paměť vyprázdnit. Příkladem je, že používáte sadu SDK v aplikaci, která se vypne.

Při použití Flush()doporučujeme tento vzor:

telemetry.Flush();
// Allow some time for flushing before shutdown.
System.Threading.Thread.Sleep(5000);

Při použití FlushAsync()doporučujeme tento vzor:

await telemetryClient.FlushAsync()
// No need to sleep

Doporučujeme vždy vyprázdnit v rámci vypnutí aplikace, aby se zajistilo, že se telemetrie neztratí.

Poznámka:

Zkontrolujte konfiguraci Autoflush: Povolení autoflush ve vašem web.config souboru může vést ke snížení výkonu v aplikacích .NET instrumentovaných pomocí Application Insights. Když je povolená funkce autoflush, každé vyvolání metod vede k odesílání jednotlivých položek telemetrie jako samostatných webových System.Diagnostics.Trace.Trace* požadavků do služby příjmu dat. To může potenciálně způsobit vyčerpání sítě a úložiště na webových serverech. Pro zvýšení výkonu se doporučuje zakázat autoflush a také využít ServerTelemetryChannel, který je navržený pro efektivnější přenos telemetrických dat.

Funkce je asynchronní pro kanál telemetrie serveru.

Ověření uživatelé

Ve webové aplikaci jsou uživatelé ve výchozím nastavení identifikováni soubory cookie . Pokud uživatel přistupuje k aplikaci z jiného počítače nebo prohlížeče, nebo pokud odstraní soubory cookie, může se počítat více než jednou.

Pokud se uživatelé přihlásí k aplikaci, můžete získat přesnější počet nastavením ověřeného ID uživatele v kódu prohlížeče. Není nutné použít skutečné přihlašovací jméno uživatele. Musí to být jenom ID, které je pro daného uživatele jedinečné. Nesmí obsahovat mezery ani žádný z znaků ,;=|.

ID uživatele je také nastaveno v relačním souboru cookie a odesláno na server. Pokud je sada SDK serveru nainstalovaná, ověřené ID uživatele se odešle jako součást kontextových vlastností telemetrie klienta i serveru. Můžete ho pak filtrovat a vyhledávat.

Pokud vaše aplikace seskupí uživatele do účtů, můžete mu také předat identifikátor. Platí stejná omezení znaků.

V Průzkumníku metrik můžete vytvořit graf, který počítá uživatele, ověřené a uživatelské účty.

Můžete také vyhledat klientské datové body s konkrétními uživatelskými jmény a účty.

Poznámka:

Vlastnost EnableAuthenticationTrackingJavaScript ve třídě ApplicationInsightsServiceOptions v sadě .NET Core SDK zjednodušuje konfiguraci JavaScriptu potřebnou k vložení uživatelského jména jako ID ověřování pro každé trasování odeslané sadou Application Insights JavaScript SDK.

Pokud je tato vlastnost nastavena na true, uživatelské jméno od uživatele v ASP.NET Core se vytiskne spolu s telemetrií na straně klienta. Z tohoto důvodu už není potřeba přidávat appInsights.setAuthenticatedUserContext ručně, protože už je vložený sadou SDK pro ASP.NET Core. Auth ID se také odešle na server, kde ho sada SDK v .NET Core identifikuje a používá pro jakoukoli telemetrii na straně serveru, jak je popsáno v referenčních informacích Rozhraní JavaScript API.

Pro javascriptové aplikace, které nefungují stejným způsobem jako ASP.NET Core MVC, jako jsou webové aplikace SPA, musíte přidat appInsights.setAuthenticatedUserContext ručně.

Filtrování, vyhledávání a segmentace dat pomocí vlastností

Vlastnosti a měření můžete připojit k událostem, metrikám, zobrazením stránek, výjimkám a dalším telemetrickým datům.

Vlastnosti jsou řetězcové hodnoty, které můžete použít k filtrování telemetrie přímo v přehledech o využití. Pokud například vaše aplikace poskytuje několik her, můžete ke každé události připojit název hry, abyste viděli, které hry jsou oblíbenější.

Délka řetězce je omezena na 8 192. Pokud chcete odesílat velké bloky dat, použijte parametr TrackTrace zprávy.

Metriky jsou číselné hodnoty, které lze graficky prezentovat. Například můžete chtít zjistit, zda dochází k postupnému zvyšování skóre, kterého vaši hráči dosahují. Grafy je možné segmentovat podle vlastností odesílaných s událostí, abyste mohli získat samostatné nebo skládané grafy pro různé hry.

Hodnoty metrik by měly být větší nebo rovny 0, aby se správně zobrazily.

Existuje několik omezení počtu vlastností, hodnot vlastností a metrik, které můžete použít.

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

Důležité

Ujistěte se, že ve vlastnostech nezapíšete identifikovatelné osobní údaje.

Alternativní způsob nastavení vlastností a metrik

Pokud je to pohodlnější, můžete shromažďovat parametry události v samostatném objektu:

var event = new EventTelemetry();

event.Name = "WinGame";
event.Metrics["processingTime"] = stopwatch.Elapsed.TotalMilliseconds;
event.Properties["game"] = currentGame.Name;
event.Properties["difficulty"] = currentGame.Difficulty;
event.Metrics["Score"] = currentGame.Score;
event.Metrics["Opponents"] = currentGame.Opponents.Length;

telemetry.TrackEvent(event);

Výstraha

Nepoužívejte opakovaně stejnou instanci položky telemetrie (event v tomto příkladu) k opakovanému volání Track*() . Tento postup může způsobit odesílání telemetrie s nesprávnou konfigurací.

Vlastní měření a vlastnosti v Log Analytics

V Log Analytics se vlastní metriky a vlastnosti zobrazují v atributech customMeasurements a customDimensions každého záznamu telemetrie.

Pokud například do telemetrie požadavku přidáte vlastnost s názvem "game", tento dotaz spočítá výskyty různých hodnot "hry" a zobrazí průměr vlastní metriky "score":

requests
| summarize sum(itemCount), avg(todouble(customMeasurements.score)) by tostring(customDimensions.game)

Všimněte si, že:

  • Když extrahujete hodnotu z objektu customDimensions NEBO customMeasurements JSON, má dynamický typ, takže ji musíte přetypovat tostring nebo todouble.
  • Při zohlednění možnosti odběru vzorků nepoužívejte sum(itemCount)count().

Události synchronizace

Někdy chcete zobrazit graf, jak dlouho trvá provedení akce. Můžete například chtít vědět, jak dlouho uživatelé berou v úvahu volby ve hře. K získání těchto informací použijte parametr měření.

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

Výchozí vlastnosti pro vlastní telemetrii

Pokud chcete nastavit výchozí hodnoty vlastností pro některé vlastní události, které napíšete, nastavte je v TelemetryClient instanci. Jsou připojené ke každé položce telemetrie odeslané z daného klienta.

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

Jednotlivá volání telemetrie mohou změnit výchozí hodnoty ve svých slovnících vlastností.

Pokud chcete přidat vlastnosti do všech telemetrických dat, včetně dat ze standardních modulů kolekce, implementujte ITelemetryInitializer.

Zakázání telemetrie

Dynamické zastavení a spuštění shromažďování a přenosu telemetrie:

using  Microsoft.ApplicationInsights.Extensibility;

TelemetryConfiguration.Active.DisableTelemetry = true;

Vývojářský režim

Během ladění je užitečné urychlit telemetrii prostřednictvím datového kanálu, abyste mohli okamžitě vidět výsledky. Získáte také další zprávy, které vám pomůžou trasovat všechny problémy s telemetrií. Vypněte ho v produkčním prostředí, protože může zpomalit vaši aplikaci.

TelemetryConfiguration.Active.TelemetryChannel.DeveloperMode = true;

Nastavení instrumentačního klíče pro vybranou vlastní telemetrii

var telemetry = new TelemetryClient();
telemetry.InstrumentationKey = "---my key---";
// ...

Dynamický připojovací řetězec

Abyste se vyhnuli kombinování telemetrie z vývojových, testovacích a produkčních prostředí, můžete vytvořit samostatné prostředky Application Insights a změnit jejich klíče v závislosti na prostředí.

Místo získání instrumentačního klíče z konfiguračního souboru ho můžete nastavit ve svém kódu. Nastavte klíč v inicializační metodě, například global.aspx.cs ve službě ASP.NET:

protected void Application_Start()
{
    Microsoft.ApplicationInsights.Extensibility.
    TelemetryConfiguration.Active.InstrumentationKey =
        // - for example -
        WebConfigurationManager.Settings["ikey"];
    ...
}

TelemetryContext

TelemetryClient má vlastnost Context, která obsahuje hodnoty, které se odesílají spolu se všemi telemetrickými daty. Obvykle jsou nastavené standardními moduly telemetrie, ale můžete je také nastavit sami. Například:

telemetry.Context.Operation.Name = "MyOperationName";

Pokud některou z těchto hodnot nastavíte sami, zvažte odebrání příslušného řádku z ApplicationInsights.config , aby se hodnoty a standardní hodnoty nezaměňily.

  • Komponenta: Aplikace a její verze.
  • Zařízení: Data o zařízení, na kterém je aplikace spuštěná. Ve webových aplikacích se jedná o server nebo klientské zařízení, ze kterého se telemetrie odesílá.
  • InstrumentationKey: Prostředek Application Insights v Azure, kde se telemetrie zobrazuje. Obvykle je načteno ze souboru ApplicationInsights.config.
  • Umístění: Zeměpisné umístění zařízení.
  • Operace: Ve webových aplikacích aktuální požadavek HTTP. V jiných typech aplikací můžete tuto hodnotu nastavit tak, aby seskupily události dohromady.
    • ID: Vygenerovaná hodnota, která koreluje různé události, takže při kontrole jakékoli události v diagnostickém vyhledávání můžete najít související položky.
    • Název: Identifikátor, obvykle adresa URL požadavku HTTP.
    • SyntheticSource: Pokud není null nebo prázdný, řetězec, který označuje, že zdroj požadavku byl identifikován jako robot nebo webový test. Ve výchozím nastavení je vyloučena z výpočtů v Průzkumníku metrik.
  • Session: Session uživatele. ID je nastavené na vygenerovanou hodnotu, která se změní, když uživatel nějakou dobu nebyl aktivní.
  • Uživatel: Informace o uživateli.

Omezení

Existuje několik omezení počtu metrik a událostí na aplikaci, tj. na připojovací řetězec. Limity závisí na zvoleném cenovém plánu .

zdroj Výchozí omezení Maximální limit Poznámky
Celkem dat za den 100 GB Obraťte se na podporu. Můžete nastavit limit pro omezení dat. Pokud potřebujete více dat, můžete limit na portálu zvýšit až o 1 000 GB. U kapacit větších než 1 000 GB odešlete e-mail na AIDataCap@microsoft.comadresu .
Throttling 32 000 událostí za sekundu Obraťte se na podporu. Limit je měřen během jedné minuty.
Protokoly uchovávání dat 30 až 730 dní 730 dní Tento zdroj je pro protokoly.
Metriky uchovávání dat 90 dní 90 dní Tento prostředek je určený pro Průzkumníka metrik.
Uchovávání podrobných výsledků vícekrokového testu dostupnosti 90 dní 90 dní Tento prostředek poskytuje podrobné výsledky každého kroku.
Maximální velikost položky telemetrie 64 kB 64 kB
Maximální počet položek telemetrie na dávku 64,000 64,000
Délka názvu vlastnosti a metriky sto padesát sto padesát Viz schémata typů.
Délka řetězce hodnoty vlastnosti 8,192 8,192 Viz schémata typů.
Délka zprávy sledování a výjimky 32,768 32,768 Viz schémata typů.
Počet testů dostupnosti na prostředek Application Insights 100 100
Počet testů dostupnosti na skupinu prostředků 800 800 Podívejte se na Azure Resource Manager
Maximální počet přesměrování v testech dostupnosti na jeden test 10 10
Minimální frekvence testů dostupnosti 300 sekund Vlastní frekvence testů nebo frekvence kratší než 5 minut vyžadují speciální implementace TrackAvailability.
Uchovávání dat v .NET Profileru a Snapshot Debuggeru Dva týdny Obraťte se na podporu. Maximální limit uchovávání je šest měsíců.
Data odeslaná profilerem .NET za den Bez omezení Žádný limit.
Odeslaná data nástroje Snapshot Debugger za den 30 snímků za den na monitorovanou aplikaci Žádný limit. Počet snímků shromážděných pro každou aplikaci je možné upravit prostřednictvím konfigurace.

Další informace o cenách a kvótách najdete v tématu Fakturace Application Insights.

Pokud se chcete vyhnout dosažení limitu rychlosti dat, použijte vzorkování.

Informace o tom, jak dlouho se data uchovávají, najdete v tématu Uchovávání a ochrana osobních údajů.

Vlastní testy dostupnosti s TrackAvailability

Následující archivované doprovodné materiály ukazují, jak vytvořit výsledky vlastního testu dostupnosti pomocí klasického rozhraní API Application Insights.

Důležité

TrackAvailability() vyžaduje, aby vývojář investoval do psaní a udržování potenciálně složitého vlastního kódu.

Standardní testy by se měly vždy používat, pokud je to možné, protože vyžadují malou investici, bez údržby a mají několik požadavků.

Tento příklad je navržený tak, aby vám ukázal mechaniku fungování volání rozhraní API TrackAvailability() v aplikaci Azure Functions. Nezobrazuje, jak napsat základní testovací kód HTTP nebo obchodní logiku potřebnou k převodu tohoto příkladu na plně funkční test dostupnosti.

Předpoklady

Začínáme

Poznámka:

Pokud chcete postupovat podle těchto pokynů, musíte použít plán služby App Service nebo plán Functions Premium, abyste povolili úpravy kódu v Editoru služby App Service. Musíte také zvolit verzi modulu runtime, která podporuje model v procesu.

Pokud testujete virtuální síť nebo testujete nepublikované koncové body, musíte použít plán Functions Premium.

Vytvořte funkci triggeru časovače

  1. Vytvořte službu Azure Functions s následujícím zohledněním:

    • Pokud ještě nemáte prostředek Application Insights pro funkci aktivovanou časovačem, je vytvořen automaticky při vytvoření aplikace Azure Functions.

    • Pokud už máte prostředek Application Insights, přejděte na kartu Monitoring při vytváření aplikace Azure Functions a v rozevíracím seznamu Application Insights vyberte nebo zadejte název existujícího prostředku:

      Snímek obrazovky znázorňující výběr existujícího prostředku Application Insights na kartě Monitorování

  2. Podle pokynů vytvořte funkci aktivovanou časovačem.

Přidání a úprava kódu v Editoru služby App Service

Přejděte do nasazené aplikace Azure Functions a v části Vývojové nástroje vyberte kartu Editor služby App Service.

Pokud chcete vytvořit nový soubor, klikněte pravým tlačítkem na funkci triggeru časovače (například TimerTrigger1) a vyberte Nový soubor. Pak zadejte název souboru a vyberte Enter.

  1. Vytvořte nový soubor s názvem function.proj a vložte následující kód:

    <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <TargetFramework>netstandard2.0</TargetFramework>
    </PropertyGroup>
    <ItemGroup>
        <PackageReference Include="Microsoft.ApplicationInsights" Version="2.15.0" /> <!-- Ensure you're using the latest version -->
    </ItemGroup>
</Project>

    Snímek obrazovky zobrazující function.proj v Editoru služby App Service

  2. Vytvořte nový soubor s názvem runAvailabilityTest.csx a vložte následující kód:

    using System.Net.Http;

public async static Task RunAvailabilityTestAsync(ILogger log)
{
    using (var httpClient = new HttpClient())
    {
        // TODO: Replace with your business logic
        await httpClient.GetStringAsync("https://www.bing.com/");
    }
}

  3. Nahraďte existující kód v souboru run.csx následujícím kódem:

    #load "runAvailabilityTest.csx"

using System;

using System.Diagnostics;

using Microsoft.ApplicationInsights;

using Microsoft.ApplicationInsights.Channel;

using Microsoft.ApplicationInsights.DataContracts;

using Microsoft.ApplicationInsights.Extensibility;

private static TelemetryClient telemetryClient;

// =============================================================

// ****************** DO NOT MODIFY THIS FILE ******************

// Business logic must be implemented in RunAvailabilityTestAsync function in runAvailabilityTest.csx

// If this file does not exist, add it first

// =============================================================

public async static Task Run(TimerInfo myTimer, ILogger log, ExecutionContext executionContext)

{
    if (telemetryClient == null)
    {
        // Initializing a telemetry configuration for Application Insights based on connection string

        var telemetryConfiguration = new TelemetryConfiguration();
        telemetryConfiguration.ConnectionString = Environment.GetEnvironmentVariable("APPLICATIONINSIGHTS_CONNECTION_STRING");
        telemetryConfiguration.TelemetryChannel = new InMemoryChannel();
        telemetryClient = new TelemetryClient(telemetryConfiguration);
    }

    string testName = executionContext.FunctionName;
    string location = Environment.GetEnvironmentVariable("REGION_NAME");
    var availability = new AvailabilityTelemetry
    {
        Name = testName,

        RunLocation = location,

        Success = false,
    };

    availability.Context.Operation.ParentId = Activity.Current.SpanId.ToString();
    availability.Context.Operation.Id = Activity.Current.RootId;
    var stopwatch = new Stopwatch();
    stopwatch.Start();

    try
    {
        using (var activity = new Activity("AvailabilityContext"))
        {
            activity.Start();
            availability.Id = Activity.Current.SpanId.ToString();
            // Run business logic
            await RunAvailabilityTestAsync(log);
        }
        availability.Success = true;
    }

    catch (Exception ex)
    {
        availability.Message = ex.Message;
        throw;
    }

    finally
    {
        stopwatch.Stop();
        availability.Duration = stopwatch.Elapsed;
        availability.Timestamp = DateTimeOffset.UtcNow;
        telemetryClient.TrackAvailability(availability);
        telemetryClient.Flush();
    }
}

Poznámka:

Testy vytvořené se TrackAvailability() se zobrazí s CUSTOM vedle názvu testu.

Snímek obrazovky znázorňující prostředí dostupnosti se dvěma různými testy

Microsoft Entra ověřeného vložení s klasickým rozhraním API

Následující archivované příklady ukazují, jak nakonfigurovat příjem dat ověřený pomocí Microsoft Entra s klasickým rozhraním API.

ASP.NET Core

Následující příklad ukazuje, jak nakonfigurovat TelemetryConfiguration pomocí .NET Core:

services.Configure<TelemetryConfiguration>(config =>
{
    var credential = new DefaultAzureCredential();
    config.SetAzureTokenCredential(credential);
});
services.AddApplicationInsightsTelemetry(new ApplicationInsightsServiceOptions
{
    ConnectionString = "InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://xxxx.applicationinsights.azure.com/"
});

platforma .NET

Následující příklad ukazuje, jak nakonfigurovat TelemetryConfiguration pomocí .NET Core:

services.Configure<TelemetryConfiguration>(config =>
{
    var credential = new DefaultAzureCredential();
    config.SetAzureTokenCredential(credential);
});
services.AddApplicationInsightsTelemetry(new ApplicationInsightsServiceOptions
{
    ConnectionString = "InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://xxxx.applicationinsights.azure.com/"
});

Poznámka:

  • Doporučujeme DefaultAzureCredential pro místní vývoj.
  • Přihlaste se do sady Visual Studio pomocí očekávaného uživatelského účtu Azure. Další informace najdete v tématu Ověřování prostřednictvím sady Visual Studio.
  • Doporučujeme ManagedIdentityCredential pro spravované identity přiřazené systémem i uživatelem.
    • Při systémovém přiřazení použijte výchozí konstruktor bez parametrů.
    • Pro uživatelem přiřazenou identitu zadejte ID klienta do konstruktoru.

  1. Nainstalujte nejnovější balíček Azure.Identity :

    dotnet add package Azure.Identity

  2. Zadejte požadovanou třídu přihlašovacích údajů:

    // Create a DefaultAzureCredential.
var credential = new DefaultAzureCredential();

// Create a new OpenTelemetry tracer provider and set the credential.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddAzureMonitorTraceExporter(options =>
    {
        options.Credential = credential;
    })
    .Build();

// Create a new OpenTelemetry meter provider and set the credential.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
    .AddAzureMonitorMetricExporter(options =>
    {
        options.Credential = credential;
    })
    .Build();

// Create a new logger factory and add the OpenTelemetry logger provider with the credential.
// It is important to keep the LoggerFactory instance active throughout the process lifetime.
var loggerFactory = LoggerFactory.Create(builder =>
{
    builder.AddOpenTelemetry(logging =>
    {
        logging.AddAzureMonitorLogExporter(options =>
        {
            options.Credential = credential;
        });
    });
});

Konfigurace proměnných prostředí

Pomocí proměnné prostředí APPLICATIONINSIGHTS_AUTHENTICATION_STRING umožníte službě Application Insights ověřit Microsoft Entra ID a odesílat telemetrii při použití Azure App Service autoinstrumentace.

  • Pro identitu přiřazenou systémem:
Nastavení aplikace Value
APPLICATIONINSIGHTS_AUTHENTICATION_STRING Authorization=AAD
  • Pro identitu přiřazenou uživatelem:
Nastavení aplikace Value
APPLICATIONINSIGHTS_AUTHENTICATION_STRING Authorization=AAD;ClientId={Client id of the User-Assigned Identity}

Klasické rozhraní API

Následující příklad ukazuje, jak ručně vytvořit a nakonfigurovat TelemetryConfiguration pomocí .NET:

TelemetryConfiguration.Active.ConnectionString = "InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://xxxx.applicationinsights.azure.com/";
var credential = new DefaultAzureCredential();
TelemetryConfiguration.Active.SetAzureTokenCredential(credential);

Nejčastější dotazy

Rozhraní API Application Insights pro vlastní události a metriky

Proč chybí telemetrická data?

Oba kanály TelemetryChannels ztratí telemetrii, pokud není vyrovnávací paměť vyprázdněna před vypnutím aplikace.

Aby nedošlo ke ztrátě dat, vyprázdněte TelemetryClient při vypnutí aplikace.

Další informace najdete v tématu Vyprázdnění dat.

Jaké výjimky mohou vyvolat volání Track_()?

Žádné. Nemusíte je zabalit do klauzulí try-catch. Pokud sada SDK narazí na problémy, zapíše zprávy do výstupu konzoly ladění a, pokud se zprávy objeví, také do diagnostického vyhledávání.

Existuje rozhraní REST API pro získání dat z portálu?

Ano, rozhraní API pro přístup k datům. Další způsoby extrakce dat zahrnují Power BI na prostředku založeném na pracovním prostoru.

Proč jsou moje volání vlastních událostí a API pro metriky ignorována?

Sada Application Insights SDK není kompatibilní s automatickou instrumentací. Pokud je povolena automatická instrumentace, budou ignorována volání Track() a dalších rozhraní API pro vlastní události a metriky.

Vypněte autoinstrumentaci v Azure Portalu na kartě Application Insights na stránce App Service nebo nastavte ApplicationInsightsAgent_EXTENSION_VERSION na disabled.

Proč jsou počty v grafech vyhledávání a metrik nerovné?

Vzorkování snižuje počet položek telemetrie (jako jsou požadavky a vlastní události), které se odesílají z vaší aplikace na portál. Ve vyhledávání se zobrazí počet přijatých položek. V grafech metrik, které zobrazují počet událostí, se zobrazí počet původních událostí, ke kterým došlo.

Každá přenášená položka nese itemCount vlastnost, která ukazuje, kolik původních událostí tato položka představuje. Pokud chcete sledovat provoz vzorkování, můžete tento dotaz spustit v Log Analytics:

requests | summarize original_events = sum(itemCount), transmitted_events = count()

Jak můžu nastavit upozornění na událost?

Upozornění Azure jsou zaměřená pouze na metriky. Vytvořte vlastní metriku, která při výskytu události překročí prahovou hodnotu hodnoty. Pak nastavte upozornění na metriku. Oznámení dostanete pokaždé, když metrika překročí prahovou hodnotu v obou směrech. Nebudete dostávat oznámení, dokud nenastane první přechod, bez ohledu na to, jestli je počáteční hodnota vysoká nebo nízká. Vždy je latence několik minut.

Kde získám další informace o rozhraní API Application Insights pro vlastní události a metriky?

Další informace najdete v tématu Základní rozhraní API pro vlastní události a metriky.

Nasazení agenta Application Insights pro místní servery

Podporuje agent Application Insights instalace proxy serveru?

Yes. Agenta Application Insights si můžete stáhnout několika způsoby:

  • Pokud má váš počítač přístup k internetu, můžete se připojit ke Galerie prostředí PowerShell pomocí parametrů -Proxy.
  • Modul si také můžete stáhnout ručně a buď ho nainstalovat do počítače, nebo ho použít přímo.

Každá z těchto možností je popsaná v podrobných pokynech.

Podporuje agent Application Insights ASP.NET Core aplikace?

Yes. V agentu Application Insights 2.0.0 a novějších se podporují aplikace ASP.NET Core hostované ve službě IIS.

Jak mohu ověřit, zda aktivace proběhla úspěšně?

  • K ověření úspěšného povolení můžete použít rutinu Get-ApplicationInsightsMonitoringStatus .

  • Pomocí živých metrik můžete rychle zjistit, jestli vaše aplikace odesílá telemetrii.

  • Pomocí Log Analytics můžete také zobrazit seznam všech cloudových rolí, které aktuálně odesílají telemetrii:

    union * | summarize count() by cloud_RoleName, cloud_RoleInstance

Kde najdu další informace o nasazení agenta Application Insights pro místní servery?

Další informace najdete v tématu Nasazení agenta Application Insights pro místní servery.

ASP.NET

Jak můžu odinstalovat sadu SDK?

Pokud chcete odebrat Application Insights, musíte odebrat balíčky NuGet a odkazy z rozhraní API ve vaší aplikaci. Balíčky NuGet můžete odinstalovat pomocí Správce balíčků NuGet v Visual Studio.

  1. Pokud je povolený sběr trasování, nejprve odinstalujte balíček Microsoft.ApplicationInsights.TraceListener pomocí NuGet Správce balíčků, ale neodstraňujte žádné závislosti.
  2. Odinstalujte balíček Microsoft.ApplicationInsights.Web a odeberte jeho závislosti pomocí NuGet Správce balíčků a možností Odinstalace v rámci ovládacího prvku NuGet Správce balíčků Options.
  3. Pokud chcete úplně odebrat Application Insights, zkontrolujte a ručně odstraňte přidaný kód nebo soubory spolu s libovolnými voláními rozhraní API, která jste přidali do projektu. Další informace najdete v tématu Co se automaticky vytvoří při přidání sady Application Insights SDK?.

Co se automaticky vytvoří při přidání sady Application Insights SDK?

Když do projektu přidáte Application Insights, automaticky vytvoří soubory a přidá do některých souborů kód. Pouze odinstalace balíčků NuGet ne vždy zahodí soubory a kód. Pokud chcete úplně odebrat Application Insights, měli byste zkontrolovat a ručně odstranit přidaný kód nebo soubory spolu s případnými voláními rozhraní API, která jste přidali do projektu.

Když přidáte telemetrii Application Insights do projektu Visual Studio ASP.NET, přidají se následující soubory:

  • ApplicationInsights.config
  • AiHandleErrorAttribute.cs

Automaticky se přidají následující části kódu:

  • [Název projektu].csproj

      <ApplicationInsightsResourceId>/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/Default-ApplicationInsights-EastUS/providers/microsoft.insights/components/WebApplication4</ApplicationInsightsResourceId>

  • Packages.config

    <packages>
...

   <package id="Microsoft.ApplicationInsights" version="2.12.0" targetFramework="net472" />
   <package id="Microsoft.ApplicationInsights.Agent.Intercept" version="2.4.0" targetFramework="net472" />
   <package id="Microsoft.ApplicationInsights.DependencyCollector" version="2.12.0" targetFramework="net472" />
   <package id="Microsoft.ApplicationInsights.PerfCounterCollector" version="2.12.0" targetFramework="net472" />
   <package id="Microsoft.ApplicationInsights.Web" version="2.12.0" targetFramework="net472" />
   <package id="Microsoft.ApplicationInsights.WindowsServer" version="2.12.0" targetFramework="net472" />
   <package id="Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel" version="2.12.0" targetFramework="net472" />

   <package id="Microsoft.AspNet.TelemetryCorrelation" version="1.0.7" targetFramework="net472" />

   <package id="System.Buffers" version="4.4.0" targetFramework="net472" />
   <package id="System.Diagnostics.DiagnosticSource" version="4.6.0" targetFramework="net472" />
   <package id="System.Memory" version="4.5.3" targetFramework="net472" />
   <package id="System.Numerics.Vectors" version="4.4.0" targetFramework="net472" />
   <package id="System.Runtime.CompilerServices.Unsafe" version="4.5.2" targetFramework="net472" />
...
</packages>

  • Layout.cshtml

    Pokud má váš project soubor Layout.cshtml, přidá se následující kód.

    <head>
...
     <script type = 'text/javascript' >
         var appInsights=window.appInsights||function(config)
         {
             function r(config){ t[config] = function(){ var i = arguments; t.queue.push(function(){ t[config].apply(t, i)})} }
             var t = { config:config},u=document,e=window,o='script',s=u.createElement(o),i,f;for(s.src=config.url||'//az416426.vo.msecnd.net/scripts/a/ai.0.js',u.getElementsByTagName(o)[0].parentNode.appendChild(s),t.cookie=u.cookie,t.queue=[],i=['Event','Exception','Metric','PageView','Trace','Ajax'];i.length;)r('track'+i.pop());return r('setAuthenticatedUserContext'),r('clearAuthenticatedUserContext'),config.disableExceptionTracking||(i='onerror',r('_'+i),f=e[i],e[i]=function(config, r, u, e, o) { var s = f && f(config, r, u, e, o); return s !== !0 && t['_' + i](config, r, u, e, o),s}),t
         }({
             connectionString:'<YOUR-CONNECTION-STRING>'
         });

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

  • ConnectedService.json

    {
   "ProviderId": "Microsoft.ApplicationInsights.ConnectedService.ConnectedServiceProvider",
   "Version": "16.0.0.0",
   "GettingStartedDocument": {
     "Uri": "https://go.microsoft.com/fwlink/?LinkID=613413"
  }
}

  • FilterConfig.cs

             public static void RegisterGlobalFilters(GlobalFilterCollection filters)
         {
             filters.Add(new ErrorHandler.AiHandleErrorAttribute());// This line was added
         }

Jak můžu zakázat korelaci telemetrie?

Pokud chcete zakázat korelaci telemetrie v konfiguraci, přečtěte si téma <ExcludeComponentCorrelationHttpHeadersOnDomains> v Application Insights pro konzolové aplikace.

Kde získám další informace o používání Application Insights s ASP.NET?

Další informace najdete v tématu Konfigurace Application Insights pro váš ASP.NET web.

vlastní telemetrie služby ASP.NET Core a pracovní služby

Jak můžu sledovat telemetrii, která se neshromažďuje automaticky?

Získejte instanci TelemetryClient vložením konstruktoru a zavolejte na ni potřebnou metodu TrackXXX(). Nedoporučujeme vytvářet nové instance TelemetryClient nebo TelemetryConfiguration v aplikaci ASP.NET Core. V kontejneru pro injektáž závislostí je již zaregistrovaná singletonová instance třídy TelemetryClient, která sdílí TelemetryConfiguration se zbytkem telemetrie. Vytvořte novou instanci TelemetryClient jenom v případě, že potřebuje konfiguraci, která je oddělená od zbytku telemetrie.

U aplikací pracovních služeb platí stejný vzor při použití balíčku ASP.NET Core s hostovanými službami. Konfigurace se sdílí se zbytkem aplikace.

Můžu povolit monitorování Application Insights pomocí agenta Application Insights nebo monitorování stavu v2?

Pro ASP.NET Core aplikace hostované ve službě IIS podporují monitorování agenta Application Insights 2.0.0 a novější. U aplikací služby Worker Service agent Application Insights podporuje pouze .NET a nejedná se o doporučenou cestu onboardingu pro nové aplikace.

Ukázkové aplikace

Konzolová aplikace .NET Core: Tuto ukázku použijte, pokud používáte konzolovou aplikaci napsanou v .NET Core (2.0 nebo vyšší) nebo .NET Framework (4.7.2 nebo vyšší).

ASP.NET Core úlohy na pozadí s HostedServices: Tuto ukázku použijte, pokud jste v ASP.NET Core a vytváříte úlohy na pozadí v souladu s oficiálními pokyny.

.NET Core Worker Service: Tuto ukázku použijte, pokud máte aplikaci .NET Worker Service v souladu s oficiálními pokyny.

Troubleshooting

Podívejte se na vyhrazené články o řešení potíží pro .NET a Node.js.

Testování připojení mezi hostitelem vaší aplikace a službou příjmu dat

SDK a agenti Application Insights odesílají telemetrii, aby se ingestovala jako volání REST na naše koncové body pro příjem dat. Připojení z webového serveru nebo hostitelského počítače aplikace ke koncovým bodům služby pro příjem dat můžete otestovat pomocí nezpracovaných klientů REST z příkazů PowerShellu nebo curl. Viz Řešení potíží s chybějící telemetrií aplikací ve službě Azure Monitor Application Insights.

Otevřené SDK

Přečtěte si a přispějte do kódu pro .NET a Node.js.

Poznámky k vydání

Aktualizace služeb také shrnují hlavní vylepšení Application Insights.

Další kroky

  • Last updated on