Program Insights för ASP.NET Core program

Den här artikeln beskriver hur du aktiverar Application Insights för ett ASP.NET Core program. När du slutför anvisningarna i den här artikeln samlar Application Insights in begäranden, beroenden, undantag, prestandaräknare, pulsslag och loggar från ditt ASP.NET Core program.

Exemplet vi använder här är ett MVC-program som riktar sig mot netcoreapp3.0 . Du kan använda dessa instruktioner för alla ASP.NET Core program. Om du använder Worker-tjänstenföljer du anvisningarna här.

Scenarier som stöds

Application Insights SDK för ASP.NET Core kan övervaka dina program oavsett var eller hur de körs. Om programmet körs och har nätverksanslutning till Azure kan telemetri samlas in. Program Insights övervakning stöds överallt där .NET Core stöds. Supporten omfattar följande:

• Operativsystem: Windows, Linux eller Mac
• Värdmetod: Pågår eller är ur process
• Distributionsmetod: Ramverksberoende eller fristående
• Webbserver: IIS (Internet Information Server) eller Kestrel
• Värdplattform: Web Apps i Azure App Service, virtuell Azure-dator, Docker, Azure Kubernetes Service (AKS) och så vidare
• .NET Core-version: Alla .NET Core-versioner som stöds officiellt och som inte är i förhandsversion
• IDE: Visual Studio, Visual Studio Code eller kommandorad

Förutsättningar

• Ett fungerande ASP.NET Core program. Om du behöver skapa ett program ASP.NET Core du den här självstudien ASP.NET Core .
• En giltig Application Insights-instrumenteringsnyckel. Den här nyckeln krävs för att skicka telemetri till Application Insights. Om du behöver skapa en ny Application Insights-resurs för att hämta en instrumentationsnyckel kan du gå till Skapa en Program Insights resurs.

Aktivera Insights telemetri på serversidan (Visual Studio)

Använd Visual Studio för Mac manuella vägledningen för att få hjälp. Endast den Windows versionen av Visual Studio stöder den här proceduren.

1. Öppna ditt projekt i Visual Studio.

   Tips

   Om du vill spåra alla ändringar som Insights gör kan du konfigurera källkontroll för ditt projekt. Om du vill konfigurera det väljer du Fil lägg till > i källkontroll.

2. Välj Project > Lägg till program Insights Telemetri.

3. Välj Kom igång. Beroende på vilken version Visual Studio kan namnet på den här knappen variera. I vissa tidigare versioner heter den knappen Starta kostnadsfritt.

4. Välj din prenumeration och välj sedan Resource Register (Registrera > resurs).

5. När du har lagt Insights program i projektet kontrollerar du att du använder den senaste stabila versionen av SDK:n. Gå till Project > Hantera NuGet-paket > Microsoft.ApplicationInsights.AspNetCore. Om du behöver väljer du Uppdatera.

   

6. Om du har lagt till projektet i källkontrollen går du till Visa > Ändringar i Team Explorer. > Du kan välja varje fil om du vill se en diff-vy över de ändringar som gjorts av Insights telemetri.

Aktivera Insights telemetri på serversidan (ingen Visual Studio)

1. Installera Application Insights SDK NuGet-paketet för ASP.NET Core. Vi rekommenderar att du alltid använder den senaste stabila versionen. Hitta fullständig viktig information för SDK:n på lagringsplatsen med GitHub öppen källkod.

   I följande kodexempel visas de ändringar som ska läggas till i projektets .csproj -fil.

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

2. Lägg services.AddApplicationInsightsTelemetry(); till i ConfigureServices() -metoden i Startup klassen, som i det här exemplet:

       // This method gets called by the runtime. Use this method to add services to the container.
       public void ConfigureServices(IServiceCollection services)
       {
           // The following line enables Application Insights telemetry collection.
           services.AddApplicationInsightsTelemetry();
   
           // This code adds other services for your application.
           services.AddMvc();
       }
   

3. Konfigurera instrumenteringsnyckeln.

   Även om du kan ange instrumenteringsnyckeln som ett argument AddApplicationInsightsTelemetry till rekommenderar vi att du anger instrumenteringsnyckeln i konfigurationen. Följande kodexempel visar hur du anger en instrumentationsnyckel i appsettings.json . Se till appsettings.json att kopieras till programmets rotmapp under publiceringen.

       {
         "ApplicationInsights": {
           "InstrumentationKey": "putinstrumentationkeyhere"
         },
         "Logging": {
           "LogLevel": {
             "Default": "Warning"
           }
         }
       }
   

   Du kan också ange instrumenteringsnyckeln i någon av följande miljövariabler:

   • APPINSIGHTS_INSTRUMENTATIONKEY

   • ApplicationInsights:InstrumentationKey

   Exempel:

   • SET ApplicationInsights:InstrumentationKey=putinstrumentationkeyhere

   • SET APPINSIGHTS_INSTRUMENTATIONKEY=putinstrumentationkeyhere

   • Används APPINSIGHTS_INSTRUMENTATIONKEY vanligtvis i Azure Web Apps, men det kan också användas på alla platser där detta SDK stöds. (Om du övervakar kodlösa webbapper krävs det här formatet om du inte använder anslutningssträngar.)

   I stället för att ange instrumentationsnycklar kan du nu också använda anslutningssträngar.

   Anteckning

   En instrumentationsnyckel som anges i koden vinner över miljövariabeln APPINSIGHTS_INSTRUMENTATIONKEY , som vinner över andra alternativ.

Användarhemligheter och andra konfigurationsproviders

Om du vill lagra instrumenteringsnyckeln i ASP.NET Core användarhemligheter eller hämta den från en annan konfigurationsprovider kan du använda överlagringen med en Microsoft.Extensions.Configuration.IConfiguration parameter. Till exempel services.AddApplicationInsightsTelemetry(Configuration);. Från och med Microsoft.ApplicationInsights.AspNetCore version 2.15.0läser anropet automatiskt services.AddApplicationInsightsTelemetry() instrumenteringsnyckeln Microsoft.Extensions.Configuration.IConfiguration från programmet. Du behöver inte uttryckligen ange IConfiguration .

Köra ditt program

Kör ditt program och skicka begäranden till det. Telemetri bör nu flöda till Application Insights. Application Insights SDK samlar automatiskt in inkommande webbförfrågningar till ditt program, tillsammans med följande telemetri.

Live Metrics

Live Metrics kan användas för att snabbt kontrollera om programövervakning Insights är korrekt konfigurerad. Det kan ta några minuter innan telemetri visas i portalen och analys, men Live Metrics visar CPU-användning av den process som körs nästan i realtid. Den kan också visa annan telemetri som begäranden, beroenden och spårningar.

ILogger-loggar

Standardkonfigurationen samlar in ILogger Warning loggar och allvarligare loggar. Du kan anpassa den här konfigurationen.

Beroenden

Beroendesamling är aktiverat som standard. Den här artikeln förklarar de beroenden som samlas in automatiskt och innehåller även steg för att göra manuell spårning.

Prestandaräknare

Stöd för prestandaräknare i ASP.NET Core är begränsat:

• SDK-version 2.4.1 och senare samlar in prestandaräknare om programmet körs i Azure Web Apps (Windows).
• SDK-version 2.7.1 och senare samlar in prestandaräknare om programmet körs i Windows och mål NETSTANDARD2.0 eller senare.
• För program som riktar .NET Framework stöder alla versioner av SDK prestandaräknare.
• SDK-versionerna 2.8.0 och senare stöder cpu/minnesräknare i Linux. Ingen annan räknare stöds i Linux. Det rekommenderade sättet att hämta systemräknare i Linux (och andra icke-Windows miljöer) är att använda EventCounters.

EventCounter

Är aktiverat EventCounterCollectionModule som standard. Information om hur du konfigurerar listan över räknare som ska samlas in finns i Introduktion till EventCounters.

Aktivera telemetri på klientsidan för webbprogram

Föregående steg räcker för att hjälpa dig att börja samla in telemetri på serversidan. Om programmet har komponenter på klientsidan följer du nästa steg för att börja samla in användningstelemetri.

1. I _ViewImports.cshtml lägger du till injection:

    @inject Microsoft.ApplicationInsights.AspNetCore.JavaScriptSnippet JavaScriptSnippet

2. I _Layout.cshtml infogar HtmlHelper du i slutet av avsnittet men före något annat <head> skript. Om du vill rapportera anpassad JavaScript-telemetri från sidan matar du in den efter det här kodfragmentet:

    @Html.Raw(JavaScriptSnippet.FullScript)
    </head>

Som ett alternativ till att använda är tillgänglig från och med FullScript Application Insights SDK för ASP.NET Core version ScriptBody 2.14. Använd det här om du behöver kontrollera <script> taggen för att ange en innehållssäkerhetsprincip:

 <script> // apply custom changes to this script tag.
     @Html.Raw(JavaScriptSnippet.ScriptBody)
 </script>

Filnamnen .cshtml som refererades tidigare kommer från en standardmall för MVC-program. Om du vill aktivera övervakning på klientsidan för ditt program korrekt måste JavaScript-kodfragmentet visas i avsnittet på varje sida i programmet som <head> du vill övervaka. Det gör du i den här programmallen genom att lägga till JavaScript-kodfragmentet i _Layout.cshtml .

Om projektet inte innehåller kan du _Layout.cshtml fortfarande lägga till övervakning på klientsidan. Det gör du genom att lägga till JavaScript-kodfragmentet i en motsvarande fil som <head> styr alla sidor i din app. Eller så kan du lägga till kodfragmentet på flera sidor, men den här lösningen är svår att underhålla och vi rekommenderar den vanligtvis inte.

Konfigurera Application Insights SDK

Du kan anpassa Application Insights SDK för ASP.NET Core ändra standardkonfigurationen. Användare av Application Insights ASP.NET SDK kanske känner till att ändra konfigurationen med hjälp ApplicationInsights.config av eller genom att ändra TelemetryConfiguration.Active . Du ASP.NET Core att göra nästan alla konfigurationsändringar i metoden ConfigureServices() i Startup.cs klassen, om du inte har dirigerat något annat. Följande avsnitt innehåller mer information.

Använda ApplicationInsightsServiceOptions

Du kan ändra några vanliga inställningar genom att skicka ApplicationInsightsServiceOptions till , som i det här AddApplicationInsightsTelemetry exemplet:

public void ConfigureServices(IServiceCollection services)
{
    Microsoft.ApplicationInsights.AspNetCore.Extensions.ApplicationInsightsServiceOptions aiOptions
                = new Microsoft.ApplicationInsights.AspNetCore.Extensions.ApplicationInsightsServiceOptions();
    // Disables adaptive sampling.
    aiOptions.EnableAdaptiveSampling = false;

    // Disables QuickPulse (Live Metrics stream).
    aiOptions.EnableQuickPulseMetricStream = false;
    services.AddApplicationInsightsTelemetry(aiOptions);
}

Den här tabellen innehåller en fullständig lista över ApplicationInsightsServiceOptions inställningar:

Den senaste listan finns i de konfigurerbara ApplicationInsightsServiceOptions inställningarna i .

Konfigurationsrekommendation för Microsoft.ApplicationInsights.AspNetCore SDK 2.15.0 och senare

I Microsoft.ApplicationInsights.AspNetCore SDK version 2.15.0 och senare rekommenderar vi att du konfigurerar alla inställningar som är tillgängliga i , inklusive ApplicationInsightsServiceOptions InstrumentationKey med programmets IConfiguration instans. Inställningarna måste finnas under avsnittet "ApplicationInsights", som du ser i följande exempel. Följande avsnitt från appsettings.json konfigurerar instrumenteringsnyckeln och inaktiverar insamling av anpassningsbar sampling och prestandaräknare.

{
    "ApplicationInsights": {
    "InstrumentationKey": "putinstrumentationkeyhere",
    "EnableAdaptiveSampling": false,
    "EnablePerformanceCounterCollectionModule": false
    }
}

Om services.AddApplicationInsightsTelemetry(aiOptions) används åsidosätts inställningarna från Microsoft.Extensions.Configuration.IConfiguration .

Samling

Application Insights SDK för ASP.NET Core stöder både fast och anpassningsbar sampling. Anpassningsbar sampling är aktiverat som standard.

Mer information finns i Konfigurera anpassningsbar sampling för ASP.NET Core program.

Lägga till TelemetryInitializers

När du vill utöka telemetrin med ytterligare information använder du telemetriinitierare.

Lägg till alla TelemetryInitializer nya DependencyInjection i containern enligt följande kod. SDK:n hämtar automatiskt alla TelemetryInitializer som läggs till i DependencyInjection containern.

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

Ta bort TelemetryInitializers

Som standard finns telemetriinitierare. Om du vill ta bort alla eller specifika telemetriinitierare använder du följande exempelkod när du har anropat AddApplicationInsightsTelemetry() .

public void ConfigureServices(IServiceCollection services)
{
    services.AddApplicationInsightsTelemetry();

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

Lägga till telemetriprocessorer

Du kan lägga till anpassade telemetriprocessorer TelemetryConfiguration till med hjälp av tilläggsmetoden på AddApplicationInsightsTelemetryProcessor IServiceCollection . Du använder telemetriprocessorer i avancerade filtreringsscenarier. Använd följande exempel.

public void ConfigureServices(IServiceCollection services)
{
    // ...
    services.AddApplicationInsightsTelemetry();
    services.AddApplicationInsightsTelemetryProcessor<MyFirstCustomTelemetryProcessor>();

    // If you have more processors:
    services.AddApplicationInsightsTelemetryProcessor<MySecondCustomTelemetryProcessor>();
}

Konfigurera eller ta bort standardtelemetrimoduler

Program Insights använder telemetrimoduler för att automatiskt samla in användbar telemetri om specifika arbetsbelastningar utan manuell spårning av användaren.

Som standard är följande moduler för automatisk insamling aktiverade. Dessa moduler ansvarar för att automatiskt samla in telemetri. Du kan inaktivera eller konfigurera dem för att ändra deras standardbeteende.

• RequestTrackingTelemetryModule – Samlar in RequestTelemetry från inkommande webbförfrågningar
• DependencyTrackingTelemetryModule – Samlar in DependencyTelemetry från utgående HTTP-anrop och SQL-anrop
• PerformanceCollectorModule– Samlar Windows PerformanceCounters
• QuickPulseTelemetryModule – Samlar in telemetri för visning i Live Metrics-portalen
• AppServicesHeartbeatTelemetryModule – Samlar in pulsslag (som skickas som anpassade mått) om Azure App Service miljö där programmet finns
• AzureInstanceMetadataTelemetryModule – Samlar in pulsslag (som skickas som anpassade mått) om den virtuella Azure-datormiljön där programmet finns
• EventCounterCollectionModule - Samlar in EventCounters; den här modulen är en ny funktion som är tillgänglig i SDK version 2.8.0 och senare

Om du vill konfigurera TelemetryModule en standard använder du ConfigureTelemetryModule<T> tilläggsmetoden på , som du ser IServiceCollection i följande exempel.

using Microsoft.ApplicationInsights.DependencyCollector;
using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector;

public void ConfigureServices(IServiceCollection services)
{
    services.AddApplicationInsightsTelemetry();

    // The following configures DependencyTrackingTelemetryModule.
    // Similarly, any other default modules can be configured.
    services.ConfigureTelemetryModule<DependencyTrackingTelemetryModule>((module, o) =>
            {
                module.EnableW3CHeadersInjection = true;
            });

    // The following removes all default counters from EventCounterCollectionModule, and adds a single one.
    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 = services.FirstOrDefault<ServiceDescriptor>(t => t.ImplementationType == typeof(PerformanceCollectorModule));
    if (performanceCounterService != null)
    {
        services.Remove(performanceCounterService);
    }
}

I version 2.12.2 och senare finns ett ApplicationInsightsServiceOptions enkelt alternativ för att inaktivera någon av standardmodulerna.

Konfigurera en telemetrikanal

Standardkanalen för telemetri är ServerTelemetryChannel . I följande exempel visas hur du åsidosätter den.

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

Inaktivera telemetri dynamiskt

Om du vill inaktivera telemetri villkorligt och dynamiskt kan du lösa instansen med en TelemetryConfiguration ASP.NET Core-beroendeinjektionscontainer var som helst i koden och DisableTelemetry ange flaggan för den.

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddApplicationInsightsTelemetry();
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, TelemetryConfiguration configuration)
    {
        configuration.DisableTelemetry = true;
        ...
    }

Föregående kodexempel förhindrar att telemetri skickas till Application Insights. Det förhindrar inte att automatiska insamlingsmoduler samlar in telemetri. Om du vill ta bort en viss modul för automatisk insamling kan du se ta bort telemetrimodulen.

Vanliga frågor och svar

Har Application Insights stöd ASP.NET Core 3.X?

Ja. Uppdatera till Application Insights SDK för ASP.NET Core version 2.8.0 eller senare. Tidigare versioner av SDK stöder inte ASP.NET Core 3.X.

Om du aktiverar telemetripå serversidan baserat på Visual Studio uppdaterar du till den senaste versionen av Visual Studio 2019 (16.3.0) som ska publiceras. Tidigare versioner av Visual Studio stöder inte automatisk registrering för ASP.NET Core 3.X-appar.

Hur kan jag spåra telemetri som inte samlas in automatiskt?

Hämta en instans av TelemetryClient med hjälp av konstruktorinjektion och anropa den TrackXXX() nödvändiga metoden på den. Vi rekommenderar inte att du skapar nya TelemetryClient instanser eller instanser i ett ASP.NET Core TelemetryConfiguration program. En singleton-instans TelemetryClient av har redan registrerats i DependencyInjection containern, som TelemetryConfiguration delar med resten av telemetrin. Vi rekommenderar bara att du skapar en ny instans om den behöver en konfiguration som är separat TelemetryClient från resten av telemetrin.

I följande exempel visas hur du spårar ytterligare telemetri från en kontrollant.

using Microsoft.ApplicationInsights;

public class HomeController : Controller
{
    private TelemetryClient telemetry;

    // Use constructor injection to get a TelemetryClient instance.
    public HomeController(TelemetryClient telemetry)
    {
        this.telemetry = telemetry;
    }

    public IActionResult Index()
    {
        // Call the required TrackXXX method.
        this.telemetry.TrackEvent("HomePageRequested");
        return View();
    }

Mer information om anpassad datarapportering i Application Insights finns i API-referens för Insights mått för Application Insights. En liknande metod kan användas för att skicka anpassade mått till Application Insights med hjälp av GetMetric-API:et.

Hur gör jag för att anpassa samlingen med ILogger-loggar?

Som standard Warning avbildas endast loggar och allvarligare loggar automatiskt. Om du vill ändra det här beteendet åsidosätter du uttryckligen loggningskonfigurationen för ApplicationInsights providern enligt nedan. Följande konfiguration gör att ApplicationInsights kan samla in alla Information loggar och allvarligare loggar.

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

Observera att följande inte gör att ApplicationInsights-providern samlar in Information loggar. Den samlar inte in den eftersom SDK lägger till ett standardloggningsfilter som instruerar att endast samla in ApplicationInsights Warning loggar och allvarligare loggar. ApplicationInsights kräver en explicit åsidosättning.

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

Mer information finns i ILogger-konfiguration.

Vissa Visual Studio-mallar använde tilläggsmetoden UseApplicationInsights() på IWebHostBuilder för att Insights. Är den här användningen fortfarande giltig?

Tilläggsmetoden stöds fortfarande, men den markeras som föråldrad i UseApplicationInsights() Application Insights SDK version 2.8.0 och senare. Den tas bort i nästa huvudversion av SDK: n. Om du vill Insights programtelemetri rekommenderar vi att du AddApplicationInsightsTelemetry() använder eftersom det ger överlagringar för att styra viss konfiguration. I 3.X ASP.NET Core appar är det enda sättet services.AddApplicationInsightsTelemetry() att aktivera Application Insights.

Jag distribuerar mitt ASP.NET Core till Web Apps. Bör jag fortfarande aktivera Insights programtillägget från Web Apps?

Om SDK:n installeras vid byggtiden som visas i den här artikeln behöver du inte aktivera tillägget Application Insights från App Service portalen. Även om tillägget har installerats backar det när det upptäcker att SDK redan har lagts till i programmet. Om du aktiverar Insights program från tillägget behöver du inte installera och uppdatera SDK:n. Men om du aktiverar Application Insights genom att följa anvisningarna i den här artikeln får du större flexibilitet eftersom:

• Program Insights telemetri fortsätter att fungera i:
  • Alla operativsystem, inklusive Windows, Linux och Mac.
  • Alla publiceringslägen, inklusive oberoende läge eller ramverksberoende.
  • Alla målramverk, inklusive fullständiga .NET Framework.
  • Alla värdalternativ, inklusive Web Apps, virtuella datorer, Linux, containrar, Azure Kubernetes Service och icke-Azure-värd.
  • Alla .NET Core-versioner, inklusive förhandsversioner.
• Du kan se telemetri lokalt när du felsöker från Visual Studio.
• Du kan spåra ytterligare anpassad telemetri med hjälp av TrackXXX() API:et.
• Du har fullständig kontroll över konfigurationen.

Kan jag aktivera övervakning Insights programhantering med verktyg som Azure Monitor Application Insights Agent (tidigare Statusövervakare v2)?

Ja. Från och med Application Insights Agent 2.0.0-beta1stöds ASP.NET Core program som finns i IIS.

Stöds alla funktioner om jag kör mitt program i Linux?

Ja. Funktionsstöd för SDK är detsamma på alla plattformar, med följande undantag:

• SDK samlar in händelseräknare i Linux eftersom prestandaräknare endast stöds i Windows. De flesta mått är desamma.
• Även om är aktiverat som standard, om programmet körs i Linux eller macOS, skapar kanalen inte automatiskt en lokal lagringsmapp för att tillfälligt behålla telemetri om det ServerTelemetryChannel finns nätverksproblem. På grund av den här begränsningen går telemetri förlorad när det finns tillfälliga nätverk- eller serverproblem. Du kan komma runt det här problemet genom att konfigurera en lokal mapp för kanalen:

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

    public void ConfigureServices(IServiceCollection services)
    {
        // The following will configure the channel to use the given folder to temporarily
        // store telemetry items during network or Application Insights server issues.
        // User should ensure that the given folder already exists
        // and that the application has read/write permissions.
        services.AddSingleton(typeof(ITelemetryChannel),
                                new ServerTelemetryChannel () {StorageFolder = "/tmp/myfolder"});
        services.AddApplicationInsightsTelemetry();
    }

Den här begränsningen gäller inte från version 2.15.0 och senare.

Stöds detta SDK för de nya mallprogrammen för .NET Core 3.X Worker-tjänsten?

Detta SDK kräver . Därför fungerar det inte i några HttpContext icke-HTTP-program, inklusive .NET Core 3.X Worker Service-program. Information om hur du aktiverar Application Insights i sådana program med hjälp av nyligen utgivna Microsoft.ApplicationInsights.WorkerService SDK finns i Application Insights for Worker Service applications (non-HTTP applications) (Program Insights for Worker Service applications (icke-HTTP-program).

SDK med öppen källkod

• Läs och bidra till koden.

De senaste uppdateringarna och felkorrigeringarna finns i den viktiga informationen.

Nästa steg

• Utforska användarflöden för att förstå hur användare navigerar i din app.
• Konfigurera en ögonblicksbildssamling för att se tillståndet för källkoden och variablerna när ett undantag inlöstes.
• Använd API:et för att skicka dina egna händelser och mått för en detaljerad vy av appens prestanda och användning.
• Använd tillgänglighetstester för att ständigt kontrollera din app från hela världen.
• Beroendeinmatning i ASP.NET Core