Application Insights för ASP.NET Core-program

Den här artikeln beskriver hur du aktiverar och konfigurerar Application Insights för ett ASP.NET Core-program .

Application Insights kan samla in följande telemetri från ditt ASP.NET Core-program:

Vi använder ett MVC-programexempel . Om du använder Arbetstjänsten använder du anvisningarna i Application Insights för Worker Service-program.

Ett OpenTelemetry-baserat .NET-erbjudande är tillgängligt. Mer information finns i Översikt över OpenTelemetry.

Stödda scenarier

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. Application Insights-övervakning stöds överallt där .NET Core stöds och omfattar följande scenarier:

• Operativsystem: Windows, Linux eller Mac
• Värdmetod: Process- eller out-of-process
• Distributionsmetod: Ramverksberoende eller fristående
• Webbserver: Internet Information Server (IIS) eller Kestrel
• Värdplattform: Funktionen Web Apps i Azure App Service, Azure Virtual Machines, Docker och Azure Kubernetes Service (AKS)
• .NET-version: Alla .NET-versioner som stöds officiellt och som inte finns i förhandsversionen
• IDE: Visual Studio, Visual Studio Code eller kommandorad

Förutsättningar

Du måste:

• Ett fungerande ASP.NET Core-program. Om du behöver skapa ett ASP.NET Core-program följer du den här självstudien om ASP.NET Core.
• En referens till en version som stöds av Application Insights NuGet-paketet.
• En giltig Application Insights-anslutningssträng. Den här strängen krävs för att skicka telemetri till Application Insights. Om du behöver skapa en ny Application Insights-resurs för att få en anslutningssträng kan du läsa Skapa en Application Insights-resurs.

Aktivera Application Insights-telemetri på serversidan (Visual Studio)

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

1. Öppna projektet i Visual Studio.

2. Gå till Project Add Application Insights Telemetry (Project>Add Application Insights Telemetry).

3. Välj Azure Application Insights>Nästa.

4. Välj din prenumeration och Application Insights-instans. Eller så kan du skapa en ny instans med Skapa ny. Välj Nästa.

5. Lägg till eller bekräfta din Application Insights-anslutningssträng. Den bör fyllas i i förväg baserat på ditt val i föregående steg. Välj Slutför.

6. När du har lagt till Application Insights i projektet kontrollerar du att du använder den senaste stabila versionen av SDK:et. Gå till Project>Manage NuGet Packages>Microsoft.ApplicationInsights.AspNetCore. Om du behöver det väljer du Uppdatera.

   

Aktivera Application 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ändiga viktig information för SDK:t på GitHub-lagringsplatsen med ö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.21.0" />
   </ItemGroup>
   

2. Lägg till AddApplicationInsightsTelemetry() i din startup.cs eller program.cs -klassen. Valet beror på din .NET Core-version.

   • ASP.NET Core 6 och senare
   • ASP.NET Core 5 och tidigare

   Lägg till builder.Services.AddApplicationInsightsTelemetry(); efter WebApplication.CreateBuilder() -metoden i klassen Program , som i det här exemplet:

   // 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. Konfigurera anslutningssträng.

   Även om du kan ange en anslutningssträng som en del av ApplicationInsightsServiceOptions argumentet till AddApplicationInsightsTelemetryrekommenderar vi att du anger anslutningssträng i konfigurationen. Följande kodexempel visar hur du anger en anslutningssträng i appsettings.json. Kontrollera att appsettings.json den kopieras till programmets rotmapp under publiceringen.

   {
     "Logging": {
       "LogLevel": {
         "Default": "Information",
         "Microsoft.AspNetCore": "Warning"
       }
     },
     "AllowedHosts": "*",
     "ApplicationInsights": {
       "ConnectionString": "Copy connection string from Application Insights Resource Overview"
     }
   }
   

   Du kan också ange anslutningssträng i APPLICATIONINSIGHTS_CONNECTION_STRING miljövariabeln eller ApplicationInsights:ConnectionString i JSON-konfigurationsfilen.

   Till exempel:

   • 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 Används vanligtvis i Web Apps. Den kan också användas på alla platser där denna SDK stöds.

   Kommentar

   En anslutningssträng som anges i koden vinner över miljövariabeln APPLICATIONINSIGHTS_CONNECTION_STRING, som vinner över andra alternativ.

Användarhemligheter och andra konfigurationsprovidrar

Om du vill lagra anslutningssträng 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. En exempelparameter är services.AddApplicationInsightsTelemetry(Configuration);.

I Microsoft.ApplicationInsights.AspNetCore version 2.15.0 och senare läser anrop services.AddApplicationInsightsTelemetry() automatiskt anslutningssträng från Microsoft.Extensions.Configuration.IConfiguration programmet. Du behöver inte uttryckligen ange IConfiguration.

Om IConfiguration har läst in konfigurationen från flera leverantörer prioriterar du services.AddApplicationInsightsTelemetry konfigurationen från appsettings.json, oavsett i vilken ordning leverantörer läggs till. services.AddApplicationInsightsTelemetry(IConfiguration) Använd metoden för att läsa konfigurationen från IConfiguration utan den här förmånsbehandlingen för appsettings.json.

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-mått

Live-mått kan användas för att snabbt kontrollera om programövervakning med Application Insights är korrekt konfigurerat. Det kan ta några minuter innan telemetri visas i Azure Portal, men fönstret livemått visar cpu-användningen av körningsprocessen nästan i realtid. Den kan också visa andra telemetrier som begäranden, beroenden och spårningar.

Aktivera livemått med hjälp av kod för alla .NET-program

Så här konfigurerar du livemått manuellt:

1. Installera NuGet-paketet Microsoft.ApplicationInsights.PerfCounterCollector.
2. Följande exempelkonsolappkod visar hur du konfigurerar livemått:

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

// Create a TelemetryConfiguration instance.
TelemetryConfiguration config = TelemetryConfiguration.CreateDefault();
config.InstrumentationKey = "INSTRUMENTATION-KEY-HERE";
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-HERE";
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();
}

Föregående exempel är för en konsolapp, men samma kod kan användas i alla .NET-program. Om andra telemetrimoduler är aktiverade för automatisk insamling av telemetri är det viktigt att se till att samma konfiguration som används för att initiera modulerna används för modulen livemått.

ILogger-loggar

Standardkonfigurationen samlar in ILogger Warning loggar och allvarligare loggar. Mer information finns i Hur gör jag för att anpassa ILogger-loggsamlingen?.

Beroenden

Beroendeinsamling är aktiverat som standard. Beroendespårning i Application Insights förklarar de beroenden som samlas in automatiskt och innehåller även steg för att utföra manuell spårning.

Prestandaräknare

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

• SDK-versionerna 2.4.1 och senare samlar in prestandaräknare om programmet körs i 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 sig till .NET Framework stöder alla versioner av SDK prestandaräknare.
• SDK-versionerna 2.8.0 och senare stöder processor-/minnesräknaren i Linux. Ingen annan räknare stöds i Linux. Om du vill hämta systemräknare i Linux och andra miljöer som inte är Windows använder du EventCounters.

EventCounter

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

Utöka data via HTTP

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

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 ditt program har komponenter på klientsidan följer du nästa steg för att börja samla in användningstelemetri med hjälp av JavaScript (Web) SDK Loader Script injection by configuration.

1. I _ViewImports.cshtmllägger du till injektion:

   @inject Microsoft.ApplicationInsights.AspNetCore.JavaScriptSnippet JavaScriptSnippet
   

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

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

Ett alternativ till att använda FullScriptScriptBody är tillgängligt med början i Application Insights SDK för ASP.NET Core version 2.14. Använd ScriptBody om du behöver styra taggen <script> 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 MVC-standardprogrammall. Om du vill aktivera övervakning på klientsidan för ditt program korrekt måste JavaScript JavaScript -SDK-inläsningsskriptet (Web) visas i avsnittet på varje sida i <head> ditt program som du vill övervaka. Lägg till JavaScript JavaScript(Web) SDK Loader Script _Layout.cshtml i en programmall för att aktivera övervakning på klientsidan.

Om projektet inte innehåller _Layout.cshtmlkan du fortfarande lägga till övervakning på klientsidan genom att lägga till JavaScript JavaScript-SDK-inläsningsskriptet (Web) i en motsvarande fil som styr <head> alla sidor i din app. Du kan också lägga till SDK-inläsningsskriptet för JavaScript (Web) på flera sidor, men vi rekommenderar det inte.

Konfigurera Application Insights SDK

Du kan anpassa Application Insights SDK för ASP.NET Core för att ändra standardkonfigurationen. Användare av Application Insights ASP.NET SDK kanske är bekanta med att ändra konfigurationen med hjälp ApplicationInsights.config av eller genom att TelemetryConfiguration.Activeändra . För ASP.NET Core gör du nästan alla konfigurationsändringar i -metoden för ConfigureServices() din Startup.cs klass, såvida du inte dirigeras på annat sätt. Följande avsnitt innehåller mer information.

Använda ApplicationInsightsServiceOptions

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

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

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

    // Disables live metrics (also known as QuickPulse).
    aiOptions.EnableQuickPulseMetricStream = false;
    services.AddApplicationInsightsTelemetry(aiOptions);
}

Den här tabellen har en fullständig lista med ApplicationInsightsServiceOptions inställningar:

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

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

I Microsoft.ApplicationInsights.AspNetCore SDK version 2.15.0 och senare konfigurerar du alla tillgängliga inställningar i ApplicationInsightsServiceOptions, inklusive ConnectionString. Använd programmets IConfiguration instans. Inställningarna måste vara under avsnittet ApplicationInsights, som du ser i följande exempel. Följande avsnitt från appsettings.json konfigurerar anslutningssträng och inaktiverar insamling av anpassningsbar sampling och prestandaräknare.

{
    "ApplicationInsights": {
    "ConnectionString": "Copy connection string from Application Insights Resource Overview",
    "EnableAdaptiveSampling": false,
    "EnablePerformanceCounterCollectionModule": false
    }
}

Om builder.Services.AddApplicationInsightsTelemetry(aiOptions) för ASP.NET Core 6.0 eller services.AddApplicationInsightsTelemetry(aiOptions) för ASP.NET Core 3.1 och tidigare används åsidosätter den inställningarna från Microsoft.Extensions.Configuration.IConfiguration.

Sampling

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

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

Lägg till TelemetryInitializers

När du vill utöka telemetri med mer information använder du telemetriinitierare.

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

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

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

Ta bort telemetriinitialiserare

Telemetriinitierare finns som standard. Om du vill ta bort alla eller specifika telemetriinitierare använder du följande exempelkod efter att du har anropat 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();

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 i med hjälp av tilläggsmetoden AddApplicationInsightsTelemetryProcessor på IServiceCollection. Du använder telemetriprocessorer i avancerade filtreringsscenarier. Använd följande exempel:

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

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

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

Konfigurera eller ta bort standardtelemetrimoduler

Application Insights samlar automatiskt in telemetri om specifika arbetsbelastningar utan att användaren behöver manuell spårning.

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 webbbegäranden.
• DependencyTrackingTelemetryModule: Samlar in DependencyTelemetry från utgående HTTP-anrop och SQL-anrop.
• PerformanceCollectorModule: Samlar in Windows PerformanceCounters.
• QuickPulseTelemetryModule: Samlar in telemetri som ska visas i fönstret livemått.
• AppServicesHeartbeatTelemetryModule: Samlar in pulsslag (som skickas som anpassade mått) om App Service-miljön där programmet finns.
• AzureInstanceMetadataTelemetryModule: Samlar in pulsslag (som skickas som anpassade mått) om den virtuella Azure-datormiljö 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 alla standardvärden TelemetryModuleanvänder du tilläggsmetoden ConfigureTelemetryModule<T> på IServiceCollection, som du ser i följande exempel:

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

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 ApplicationInsightsServiceOptions innehåller ett enkelt alternativ för att inaktivera någon av standardmodulerna.

Konfigurera en telemetrikanal

Standardtelemetrikanalen är ServerTelemetryChannel. I följande exempel visas hur du åsidosätter det.

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

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 TelemetryConfiguration med en ASP.NET Core-beroendeinmatningscontainer var som helst i koden och ange flaggan på den 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();

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 sändning av telemetri till Application Insights. Det hindrar inte automatiska insamlingsmoduler från att samla in telemetri. Om du vill ta bort en viss modul för automatisk insamling läser du Ta bort telemetrimodulen.

Vanliga frågor och svar

Det här avsnittet innehåller svar på vanliga frågor.

Stöder Application Insights ASP.NET Core 3.1?

ASP.NET Core 3.1 stöds inte längre av Microsoft.

Application Insights SDK för ASP.NET Core version 2.8.0 och Visual Studio 2019 eller senare kan användas med ASP.NET Core 3.1-program.

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

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

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

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

Hur gör jag för att avbilda begärande- och svarstexten i min telemetri?

ASP.NET Core har inbyggt stöd för loggning av HTTP-begäran/svarsinformation (inklusive brödtext) via ILogger. Vi rekommenderar att du använder detta. Detta kan potentiellt exponera personligt identifierbar information (PII) i telemetri och kan leda till att kostnaderna (prestandakostnader och Application Insights-fakturering) ökar avsevärt, så utvärdera riskerna noggrant innan du använder detta.

Hur gör jag för att anpassa ILogger-loggsamlingen?

Standardinställningen för Application Insights är att endast samla in varningsloggar och allvarligare loggar.

Samla in information och mindre allvarliga loggar genom att ändra loggningskonfigurationen för Application Insights-providern på följande sätt.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information"
    },
    "ApplicationInsights": {
      "LogLevel": {
        "Default": "Information"
      }
    }
  },
  "ApplicationInsights": {
    "ConnectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000"
  }
}

Observera att följande exempel inte gör att Application Insights-providern samlar in Information loggar. Den samlar inte in den eftersom SDK lägger till ett standardloggningsfilter som instruerar ApplicationInsights att endast Warning avbilda loggar och allvarligare loggar. Application Insights 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 Application Insights. Är den här användningen fortfarande giltig?

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

Jag distribuerar mitt ASP.NET Core-program till Web Apps. Ska jag fortfarande aktivera Application Insights-tillägget från Web Apps?

Om SDK:t installeras vid byggtiden enligt den här artikeln behöver du inte aktivera Application Insights-tillägget från App Service-portalen. Om tillägget är installerat säkerhetskopieras det när det identifierar att SDK redan har lagts till. Om du aktiverar Application Insights från tillägget behöver du inte installera och uppdatera SDK:t. Men om du aktiverar Application Insights genom att följa anvisningarna i den här artikeln har du större flexibilitet eftersom:

• Application Insights-telemetrin fortsätter att fungera i:
  • Alla operativsystem, inklusive Windows, Linux och Mac.
  • Alla publiceringslägen, inklusive fristående lägen eller ramverksberoende.
  • Alla målramverk, inklusive hela .NET Framework.
  • Alla värdalternativ, inklusive webbappar, virtuella datorer, Linux, containrar, AKS och icke-Azure-värdtjänster.
  • 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 mer anpassad telemetri med hjälp av API:et TrackXXX() .
• Du har fullständig kontroll över konfigurationen.

Kan jag aktivera Application Insights-övervakning med hjälp av verktyg som Azure Monitor Application Insights Agent (tidigare Status Monitor v2)?

Ja. I Application Insights Agent 2.0.0-beta1 och senare stö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:et samlar in händelseräknare i Linux eftersom prestandaräknare endast stöds i Windows. De flesta mått är desamma.

Stöds det här SDK:t för Worker Services?

Nej. Använd Application Insights för Worker Service-program (icke-HTTP-program) för arbetstjänster.

Hur avinstallerar jag SDK:t?

Om du vill ta bort Application Insights måste du ta bort NuGet-paketen och referenserna från API:et i ditt program. Du kan avinstallera NuGet-paket med hjälp av NuGet Package Manager i Visual Studio.

1. Avinstallera Paketet Microsoft.ApplicationInsights.AspNetCore med hjälp av NuGet Package Manager.
2. Om du vill ta bort Application Insights helt kontrollerar och tar du bort den tillagda koden eller filerna manuellt tillsammans med eventuella API-anrop som du har lagt till i projektet. Mer information finns i Vad skapas när du lägger till Application Insights SDK?.

Vad skapas när du lägger till Application Insights SDK?

När du lägger till Application Insights i projektet skapas filer och kod läggs till i några av dina filer. Att bara avinstallera NuGet-paketen tar inte alltid bort filerna och koden. Om du vill ta bort Application Insights helt bör du kontrollera och manuellt ta bort den tillagda koden eller filerna tillsammans med eventuella API-anrop som du har lagt till i projektet.

När du lägger till Application Insights-telemetri i ett Visual Studio ASP.NET Core-mallprojekt lägger det till följande kod:

• [Projektets namn].csproj

    <PropertyGroup>
      <TargetFramework>netcoreapp3.1</TargetFramework>
      <ApplicationInsightsResourceId>/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/Default-ApplicationInsights-EastUS/providers/microsoft.insights/components/WebApplication4core</ApplicationInsightsResourceId>
    </PropertyGroup>
  
    <ItemGroup>
      <PackageReference Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.12.0" />
    </ItemGroup>
  
    <ItemGroup>
      <WCFMetadata Include="Connected Services" />
    </ItemGroup>
  

• Appsettings.json:

  "ApplicationInsights": {
      "InstrumentationKey": "00000000-0000-0000-0000-000000000000"
  

• ConnectedService.json

  {
    "ProviderId": "Microsoft.ApplicationInsights.ConnectedService.ConnectedServiceProvider",
    "Version": "16.0.0.0",
    "GettingStartedDocument": {
      "Uri": "https://go.microsoft.com/fwlink/?LinkID=798432"
    }
  }
  

• Startup.cs

     public void ConfigureServices(IServiceCollection services)
          {
              services.AddRazorPages();
              services.AddApplicationInsightsTelemetry(); // This is added
          }
  

Hur inaktiverar jag telemetrikorrelation?

Information om hur du inaktiverar telemetrikorrelation i kod <ExcludeComponentCorrelationHttpHeadersOnDomains> finns i Application Insights för konsolprogram.

Felsökning

Se den dedikerade felsökningsartikeln.

Testa anslutningen mellan programvärden och inmatningstjänsten

Application Insights SDK:er och agenter skickar telemetri för att matas in som REST-anrop till våra inmatningsslutpunkter. Du kan testa anslutningen från webbservern eller programvärddatorn till slutpunkterna för inmatningstjänsten med hjälp av råa REST-klienter från PowerShell- eller curl-kommandon. Se Felsöka programtelemetri som saknas i Azure Monitor Application Insights.

SDK med öppen källkod

Läsa och bidra till koden.

De senaste uppdateringarna och felkorrigeringarna finns i viktig information.

Viktig information

För version 2.12 och senare: .NET SDK:er (inklusive ASP.NET, ASP.NET Core och loggningskort)

Våra tjänstuppdateringar sammanfattar även större Förbättringar av Application Insights.

Nästa steg

• Utforska användarflöden för att förstå hur användare rör sig genom din app.
• Konfigurera en samling ögonblicksbilder för att se tillståndet för källkod och variabler när ett undantag utlöses.
• Använd API :et för att skicka egna händelser och mått för en detaljerad vy över appens prestanda och användning.
• Använd tillgänglighetstester för att kontrollera din app hela tiden från hela världen.
• Lär dig mer om beroendeinmatning i ASP.NET Core.