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 tillämpa dessa instruktioner på 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 ditt program körs och har nätverksanslutning till Azure kan telemetri samlas in. Övervakning Insights program stöds överallt där .NET Core stöds. Supporten omfattar följande:

  • Operativsystem: Windows, Linux eller Mac
  • Värdmetod: Bearbetas eller är inte processad
  • 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

Anteckning

ASP.NET Core 3.1 kräver Application Insights 2.8.0 eller senare.

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 självstudien.
  • En giltig Application Insights instrumentationsnyckel. 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 instrumenteringsnyckel kan du gå till Skapa en Program Insights-resurs.

Viktigt

Anslutningssträngar rekommenderas framför instrumentationsnycklar. Nya Azure-regioner kräver att anslutningssträngar används i stället för instrumentationsnycklar. Anslutningssträngen identifierar den resurs som du vill associera dina telemetridata med. Du kan också ändra de slutpunkter som din resurs ska använda som mål för din telemetri. Du måste kopiera anslutningssträngen och lägga till den i programmets kod eller i en miljövariabel.

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 Arkiv Lägg till > i källkontroll.

  2. Välj Project > Lägg till 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 > Resursregistrera.

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

    Skärmbild som visar var du väljer Insights programpaketet för uppdatering

  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 för att se en diff-vy över de ändringar som gjorts av Application Insights telemetri.

Aktivera Insights telemetri på serversidan (inga 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 på lagringsplatsen med GitHub öppen källkod.

    Följande kodexempel visar 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 metoden i klassen , som i det här ConfigureServices() Startup 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 vanligtvis APPINSIGHTS_INSTRUMENTATIONKEY i Azure Web Apps, men det kan också användas på alla platser där detta SDK stöds. (Om du övervakar kodlös webbapp 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 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 services.AddApplicationInsightsTelemetry() automatiskt 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 Insights programövervakning har konfigurerats korrekt. Det kan ta några minuter innan telemetri visas i portalen och analyser, men Live Metrics visar CPU-användningen 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

Beroendeinsamling är aktiverat som standard. Den här artikeln förklarar de beroenden som samlas in automatiskt och innehåller även steg för 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 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 har stöd för cpu/minnesräknare i Linux. Inga andra 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 tillräckliga 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
  1. I _Layout.cshtml infogar HtmlHelper du i slutet av avsnittet men före andra <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 för 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.

Anteckning

JavaScript- injection ger en standardkonfigurationsupplevelse. Om du behöver konfiguration utöver att ange instrumenteringsnyckeln måste du ta bort automatisk injection enligt beskrivningen ovan och manuellt lägga till JavaScript SDK.

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.

Anteckning

I ASP.NET Core-program stöds inte ändring av TelemetryConfiguration.Active konfiguration genom att ändra.

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:

Inställning Beskrivning Standardvärde
EnablePerformanceCounterCollectionModule Aktivera/inaktivera PerformanceCounterCollectionModule true
EnableRequestTrackingTelemetryModule Aktivera/inaktivera RequestTrackingTelemetryModule true
EnableEventCounterCollectionModule Aktivera/inaktivera EventCounterCollectionModule true
EnableDependencyTrackingTelemetryModule Aktivera/inaktivera DependencyTrackingTelemetryModule true
EnableAppServicesServicesServicebeatTelemetryModule Aktivera/inaktivera AppServicesHeartbeatTelemetryModule true
AktiveraAzureInstanceMetadataTelemetryModule Aktivera/inaktivera AzureInstanceMetadataTelemetryModule true
EnableQuickPulseMetricStream Funktionen Aktivera/inaktivera LiveMetrics true
EnableAdaptiveSampling Aktivera/inaktivera anpassningsbar sampling true
EnableVbeat Funktionen Aktivera/inaktivera pulsslag, som regelbundet (15 min standard) skickar ett anpassat mått med namnet HeartbeatState med information om körningen, t.ex. .NET-version, Azure Environment-information, om tillämpligt osv. true
AddAutoCollectedMetricExtractor Enable/Disable AutoCollectedMetrics extractor, som är en TelemetryProcessor som skickar föraggregeringsmått om begäranden/beroenden innan samplingen äger rum. true
RequestCollectionOptions.TrackExceptions Aktivera/inaktivera rapportering av ohanterad undantagsspårning av modulen Begärandesamling. false i NETSTANDARD2.0 (eftersom undantag spåras med ApplicationInsightsLoggerProvider), sant annars.
EnableDiagnosticsTelemetryModule Aktivera/inaktivera DiagnosticsTelemetryModule . Om du inaktiverar detta ignoreras följande inställningar: EnableHeartbeat, EnableAzureInstanceMetadataTelemetryModule, EnableAppServicesHeartbeatTelemetryModule true

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. I följande avsnitt appsettings.jspå 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 i DependencyInjection 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>();
}

Anteckning

services.AddSingleton<ITelemetryInitializer, MyCustomTelemetryInitializer>(); fungerar för enkla initierare. För andra krävs följande: services.AddSingleton(new MyCustomTelemetryInitializer() { fieldName = "myfieldName" });

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 och ä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 matcha instansen med en container för ASP.NET Core-beroendeinjektion var som helst i koden och TelemetryConfiguration 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 för 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 dessutom aktiverar telemetri på serversidanbaserat på Visual Studio uppdaterar du till den senaste versionen av Visual Studio 2019 (16.3.0) att publicera. Tidigare versioner av Visual Studio stöder inte automatisk registrering för ASP.NET Core 3.X-appar.

Hur spårar jag 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 insamling av 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. Med följande konfiguration kan ApplicationInsights 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 aktivera 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 använder AddApplicationInsightsTelemetry() eftersom det tillhandahåller överlagringar för att kontrollera viss konfiguration. I 3.X ASP.NET Core appar är det services.AddApplicationInsightsTelemetry() enda sättet att aktivera Application Insights.

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

Om SDK:n installeras vid byggtiden som visas i den här artikeln behöver du inte aktivera application Insights-tillägget 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 Insights Application Insights 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 fristående 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 programövervakning med verktyg som Azure Monitor Application Insights Agent (tidigare Statusövervakare v2)?

Nej, Azure Monitor Application Insights Agent stöder för närvarande endast ASP.NET 4.x.

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, skapar inte kanalen automatiskt en lokal lagringsmapp för att tillfälligt behålla telemetri om det finns nätverksproblem om programmet körs i Linux eller ServerTelemetryChannel macOS. På grund av den här begränsningen går telemetri förlorad om det finns tillfälliga problem med nätverk eller servrar. 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 den nyligen utgivna Sdk:n Microsoft.ApplicationInsights.WorkerService finns i Application Insights for Worker Service applications (non-HTTP applications) (Program Insights for Worker Service-program (icke-HTTP-program).

SDK med öppen källkod

De senaste uppdateringarna och felkorrigeringarna finns i den viktiga informationen.

Nästa steg