Application Insights ASP.NET Core-alkalmazásokhoz

Ez a cikk azt ismerteti, hogyan engedélyezheti és konfigurálhatja az Application Insightst egy ASP.NET Core-alkalmazáshoz .

Feljegyzés

Az alábbi dokumentáció a klasszikus Application Insights API-ra támaszkodik. Az Application Insights hosszú távú terve, hogy adatokat gyűjtsön az OpenTelemetry használatával. További információ: Az Azure Monitor OpenTelemetria engedélyezése .NET-, Node.js-, Python- és Java-alkalmazásokhoz , valamint az OpenTelemetria ütemterve. A migrálási útmutató a .NET, a Node.js és a Python esetében érhető el.

Az Application Insights a következő telemetriát gyűjtheti a ASP.NET Core-alkalmazásból:

• Kérelmek
• Függőségek
• Kivételek
• Teljesítményszámlálók
• Szívdobbanás
• Naplók

Egy MVC-alkalmazás példáját használjuk. Ha a Feldolgozó szolgáltatást használja, használja az Application Insights for Worker Service-alkalmazásokra vonatkozó utasításait.

Elérhető egy OpenTelemetry-alapú .NET-ajánlat . További információt az OpenTelemetry áttekintésében talál.

Feljegyzés

2025. március 31-én megszűnik az eszközkulcsalapú betöltés támogatása. A rendszerállapot-kulcsok betöltése továbbra is működni fog, de a továbbiakban nem biztosítunk frissítéseket vagy támogatást a funkcióhoz. Váltás kapcsolati sztring az új képességek kihasználásához.

Feljegyzés

Ha önálló ILogger-szolgáltatót szeretne használni, használja a Microsoft.Extensions.Logging.ApplicationInsight parancsot.

Támogatott esetek

A ASP.NET Core-hoz készült Application Insights SDK monitorozza az alkalmazásokat, függetlenül attól, hogy hol és hogyan futnak. Ha az alkalmazás fut, és hálózati kapcsolattal rendelkezik az Azure-hoz, telemetriai adatok gyűjthetők. Az Application Insights monitorozása mindenhol támogatott. A .NET Core támogatott, és az alábbi forgatókönyveket ismerteti:

• Operációs rendszer: Windows, Linux vagy Mac
• Üzemeltetési módszer: Folyamatban vagy folyamaton kívül
• Üzembe helyezési módszer: Keretrendszerfüggő vagy önálló
• Webkiszolgáló: Internet Information Server (IIS) vagy Kestrel
• Üzemeltetési platform: Az Azure-alkalmazás Szolgáltatás, az Azure Virtual Machines, a Docker és az Azure Kubernetes Service (AKS) Web Apps szolgáltatása
• .NET-verzió: Minden hivatalosan támogatott .NET-verzió , amely nincs előzetes verzióban
• IDE: Visual Studio, Visual Studio Code vagy parancssor

Előfeltételek

A következők szükségesek:

• Egy működő ASP.NET Core-alkalmazás. Ha ASP.NET Core-alkalmazást kell létrehoznia, kövesse ezt a ASP.NET Core-oktatóanyagot.
• Hivatkozás az Application Insights NuGet-csomag támogatott verziójára.
• Érvényes Application Insights-kapcsolati sztring. Ez a sztring szükséges ahhoz, hogy telemetriát küldjön az Application Insightsnak. Ha új Application Insights-erőforrást kell létrehoznia egy kapcsolati sztring beszerzéséhez, olvassa el az Application Insights-erőforrás létrehozása című témakört.

Az Application Insights kiszolgálóoldali telemetriájának engedélyezése (Visual Studio)

A Mac Visual Studio esetében használja a manuális útmutatást. Ezt az eljárást csak a Visual Studio Windows-verziója támogatja.

1. Nyissa meg a projektet a Visual Studióban.

2. Lépjen a Project>Add Application Insights telemetriai adataihoz.

3. Válassza a Azure-alkalmazás Elemzések>tovább lehetőséget.

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

5. Adja hozzá vagy erősítse meg az Application Insights kapcsolati sztring. Az előző lépésben megadott beállítás alapján előre fel kell tölteni. Válassza a Befejezés lehetőséget.

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

   

Az Application Insights kiszolgálóoldali telemetriájának engedélyezése (nincs Visual Studio)

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

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

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

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

2. Hozzáadás AddApplicationInsightsTelemetry() az osztályhoz vagy program.cs az startup.cs osztályhoz. A választás a .NET Core-verziótól függ.

   ASP.NET Core 6 és újabb verziók

   Adja hozzá builder.Services.AddApplicationInsightsTelemetry(); az osztály metódusa Program WebApplication.CreateBuilder() után, ahogyan ebben a példában is látható:

   // This method gets called by the runtime. Use this method to add services to the container.
   var builder = WebApplication.CreateBuilder(args);
   
   // The following line enables Application Insights telemetry collection.
   builder.Services.AddApplicationInsightsTelemetry();
   
   // This code adds other services for your application.
   builder.Services.AddMvc();
   
   var app = builder.Build();
   

   ASP.NET Core 5 és korábbi verziók

   Adja hozzá services.AddApplicationInsightsTelemetry(); a ConfigureServices() metódushoz az Startup osztályban, ahogy ebben a példában is látható:

   // This method gets called by the runtime. Use this method to add services to the container.
   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();
   }
   

   Feljegyzés

   Ez a .NET-verzió már nem támogatott.

3. Állítsa be a kapcsolati sztring.

   Bár az argumentum AddApplicationInsightsTelemetryrészeként ApplicationInsightsServiceOptions megadhat egy kapcsolati sztring, javasoljuk, hogy a konfigurációban adja meg a kapcsolati sztring. Az alábbi kódminta bemutatja, hogyan adhat meg kapcsolati sztring a fájlbanappsettings.json. A közzététel során győződjön meg arról, hogy appsettings.json az alkalmazás gyökérmappájába van másolva.

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

   Másik lehetőségként adja meg a kapcsolati sztring a APPLICATIONINSIGHTS_CONNECTION_STRING környezeti változóban vagy ApplicationInsights:ConnectionString a JSON konfigurációs fájlban.

   Példa:

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

   Feljegyzés

   A kódban megadott kapcsolati sztring nyer a környezeti változóval APPLICATIONINSIGHTS_CONNECTION_STRINGszemben, amely más lehetőségeknél nyer.

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

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

A 2.15.0-s és újabb verziókban Microsoft.ApplicationInsights.AspNetCore a hívás services.AddApplicationInsightsTelemetry() automatikusan beolvassa a kapcsolati sztring az alkalmazásbólMicrosoft.Extensions.Configuration.IConfiguration. Nincs szükség explicit módon megadni IConfiguration.

Ha IConfiguration a konfiguráció több szolgáltatótól lett betöltve, akkor services.AddApplicationInsightsTelemetry rangsorolja a konfigurációt appsettings.jsonattól függetlenül, hogy milyen sorrendben lettek hozzáadva a szolgáltatók. Ezzel a módszerrel beolvashatja a services.AddApplicationInsightsTelemetry(IConfiguration) konfigurációt IConfiguration anélkül, hogy ez a preferenciális kezelés a appsettings.json.

Az alkalmazás futtatása

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

Élő metrikák

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

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

Feljegyzés

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

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

1. Telepítse a NuGet-csomagot : Microsoft.ApplicationInsights.PerfCounterCollector.
2. Az alábbi minta konzolalkalmazás-kód az élő metrikák beállítását mutatja be:

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

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

Az előző minta egy konzolalkalmazáshoz készült, de ugyanez a kód bármely .NET-alkalmazásban használható. Ha bármely más telemetriai modul engedélyezve van a telemetriai adatok automatikus gyűjtéséhez, fontos meggyőződni arról, hogy a modul inicializálásához használt konfiguráció az élő metrikák modulhoz lesz használva.

ILogger-naplók

Az alapértelmezett konfiguráció összegyűjti a naplókat ILogger Warning és a súlyosabb naplókat. További információ: Hogyan az ILogger-naplók gyűjteményének testreszabása?.

Függőségek

A függőséggyűjtés alapértelmezés szerint engedélyezve van. Az Application Insights függőségkövetése ismerteti az automatikusan gyűjtött függőségeket, és a manuális nyomon követés lépéseit is tartalmazza.

Teljesítményszámlálók

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

• A 2.4.1-s és újabb SDK-verziók teljesítményszámlálókat gyűjtenek, ha az alkalmazás a Web Appsben (Windows) fut.
• A 2.7.1-s és újabb SDK-verziók teljesítményszámlálókat gyűjtenek, ha az alkalmazás Windows rendszerben és célokban vagy újabb verziókban netstandard2.0 fut.
• A .NET-keretrendszer megcélzott alkalmazások esetében az SDK minden verziója támogatja a teljesítményszámlálókat.
• Az SDK 2.8.0-s és újabb verziói támogatják a processzor-/memóriaszámlálót Linuxon. A Linux nem támogat más számlálót. Ha rendszerszámlálókat szeretne lekérni Linux és más, nem Windows rendszerű környezetekben, használja az EventCounterst.

EventCounter

Alapértelmezés szerint EventCounterCollectionModule engedélyezve van. Az összegyűjtendő számlálók listájának konfigurálásáról az EventCounters bevezetőjében olvashat.

Adatok bővítése HTTP-ben

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

Ügyféloldali telemetria engedélyezése webalkalmazásokhoz

Az előző lépések elegendőek a kiszolgálóoldali telemetriai adatok gyűjtésének megkezdéséhez. Ha az alkalmazás ügyféloldali összetevőkkel rendelkezik, a következő lépéseket követve megkezdheti a használati telemetria gyűjtését a JavaScript (Webes) SDK Loader Script injektálásával konfiguráció alapján.

1. In _ViewImports.cshtml, adja hozzá az injekciót:

   @inject Microsoft.ApplicationInsights.AspNetCore.JavaScriptSnippet JavaScriptSnippet
   

2. In _Layout.cshtml, insert HtmlHelper at the end of the <head> section, de before other script. Ha egyéni JavaScript-telemetriát szeretne jelenteni a lapról, szúrja be a kódrészlet után:

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

A használat FullScriptScriptBody alternatívájaként az Application Insights SDK ASP.NET Core 2.14-es verziójától kezdve érhető el. A ScriptBody tartalombiztonsági szabályzat beállításához használja a <script> címkét:

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

A .cshtml korábban hivatkozott fájlnevek alapértelmezett MVC-alkalmazássablonból származnak. Végső soron, ha megfelelően szeretné engedélyezni az ügyféloldali monitorozást az alkalmazáshoz, a JavaScript JavaScript (webes) SDK loader szkriptnek meg kell jelennie az <head> alkalmazás minden figyelni kívánt oldalának szakaszában. Az ügyféloldali monitorozás engedélyezéséhez adja hozzá a JavaScript JavaScript (Webes) SDK loader szkriptet egy alkalmazássablonhoz _Layout.cshtml .

Ha a projekt nem tartalmazza _Layout.cshtml, akkor is hozzáadhat ügyféloldali monitorozást , ha a JavaScript JavaScript (Web) SDK Loader Scriptet hozzáadja egy egyenértékű fájlhoz, amely az <head> alkalmazás összes lapját vezérli. Másik lehetőségként hozzáadhatja a JavaScript (webes) SDK loader szkriptet több laphoz, de nem javasoljuk.

Feljegyzés

A JavaScript-injektálás alapértelmezett konfigurációs felületet biztosít. Ha a kapcsolati sztring beállításán túl konfigurálásra van szüksége, el kell távolítania az automatikus injektálást a leírt módon, és manuálisan kell hozzáadnia a JavaScript SDK-t.

Az Application Insights SDK konfigurálása

Az Alapértelmezett konfiguráció módosításához testre szabhatja az Application Insights SDK-t ASP.NET Core-hoz. Előfordulhat, hogy az Application Insights ASP.NET SDK felhasználói ismerik a konfiguráció módosításával vagy használatával ApplicationInsights.config történő módosítását TelemetryConfiguration.Active. A ASP.NET Core esetében végezze el szinte az összes konfigurációs módosítást Startup.cs az ConfigureServices() osztály metódusában, kivéve, ha másként van irányítva. A következő szakaszok további információkat tartalmaznak.

Feljegyzés

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

Az ApplicationInsightsServiceOptions használata

Néhány gyakori beállítás módosításához adja át ApplicationInsightsServiceOptions a AddApplicationInsightsTelemetrykövetkezőt, mint ebben a példában:

ASP.NET Core 6 és újabb verziók

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

ASP.NET Core 5 és korábbi verziók

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

Feljegyzés

Ez a .NET-verzió már nem támogatott.

Ez a táblázat tartalmazza a beállítások teljes listáját ApplicationInsightsServiceOptions :

Beállítás	Leírás	Alapértelmezett
EnablePerformanceCounterCollectionModule	Engedélyezés/letiltás PerformanceCounterCollectionModule.	Igaz
EnableRequestTrackingTelemetryModule	Engedélyezés/letiltás RequestTrackingTelemetryModule.	Igaz
EnableEventCounterCollectionModule	Engedélyezés/letiltás EventCounterCollectionModule.	Igaz
EnableDependencyTrackingTelemetryModule	Engedélyezés/letiltás DependencyTrackingTelemetryModule.	Igaz
EnableAppServicesHeartbeatTelemetryModule	Engedélyezés/letiltás AppServicesHeartbeatTelemetryModule.	Igaz
EnableAzureInstanceMetadataTelemetryModule	Engedélyezés/letiltás AzureInstanceMetadataTelemetryModule.	Igaz
EnableQuickPulseMetricStream	A LiveMetrics funkció engedélyezése/letiltása.	Igaz
EnableAdaptiveSampling	Adaptív mintavételezés engedélyezése/letiltása.	Igaz
EnableHeartbeat	A szívverések funkció engedélyezése/letiltása. Rendszeres időközönként (alapértelmezés szerint 15 perc) küld egy egyéni metrikát, amely a futtatókörnyezettel kapcsolatos információkat tartalmazza HeartbeatState , például a .NET-verziót és az Azure környezeti adatait, ha vannak ilyenek.	Igaz
AddAutoCollectedMetricExtractor	Engedélyezze/tiltsa le a AutoCollectedMetrics extractor. Ez a telemetriai feldolgozó előre összesített metrikákat küld a kérelmekről/függőségekről a mintavételezés előtt.	Igaz
RequestCollectionOptions.TrackExceptions	A kérésgyűjtési modul által nem kezelt kivételkövetés jelentésének engedélyezése/letiltása.	False in netstandard2.0 (mert a kivételeket a rendszer nyomon követi ApplicationInsightsLoggerProvider). Ellenkező esetben igaz.
EnableDiagnosticsTelemetryModule	Engedélyezés/letiltás DiagnosticsTelemetryModule. A letiltás miatt a következő beállítások figyelmen kívül lesznek hagyva: EnableHeartbeat, EnableAzureInstanceMetadataTelemetryModuleés EnableAppServicesHeartbeatTelemetryModule.	Igaz

A legfrissebb lista a konfigurálható beállításokat tartalmazza.ApplicationInsightsServiceOptions

Konfigurációs javaslat a Microsoft.ApplicationInsights.AspNetCore SDK 2.15.0-s és újabb verzióihoz

A Microsoft.ApplicationInsights.AspNetCore SDK 2.15.0-s és újabb verziójában ApplicationInsightsServiceOptionskonfiguráljon minden elérhető beállítást, beleértve a következőket: ConnectionString. Használja az alkalmazás példányát IConfiguration . A beállításoknak a szakasz ApplicationInsightsalatt kell lenniük, ahogyan az az alábbi példában is látható. A appsettings.json következő szakasza konfigurálja a kapcsolati sztring, és letiltja az adaptív mintavételezést és a teljesítményszámláló gyűjtését.

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

Ha builder.Services.AddApplicationInsightsTelemetry(aiOptions) ASP.NET Core 6.0-s vagy services.AddApplicationInsightsTelemetry(aiOptions) ASP.NET Core 3.1-et vagy korábbi verziót használ, az felülírja a beállításokat Microsoft.Extensions.Configuration.IConfiguration.

Mintavételezés

A ASP.NET Core-hoz készült Application Insights SDK támogatja a rögzített és az adaptív mintavételezést is. Alapértelmezés szerint az adaptív mintavételezés engedélyezve van.

További információ: Adaptív mintavételezés konfigurálása ASP.NET Core-alkalmazásokhoz.

TelemetryInitializers hozzáadása

Ha további információkkal szeretné bővíteni a telemetriát, használjon telemetriai inicializálókat.

Adjon hozzá minden újat TelemetryInitializer a tárolóhoz az DependencyInjection alábbi kódban látható módon. Az SDK automatikusan felveszi a tárolóhoz DependencyInjection hozzáadott elemeketTelemetryInitializer.

ASP.NET Core 6 és újabb verziók

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

Feljegyzés

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

ASP.NET Core 5 és korábbi verziók

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

Feljegyzés

services.AddSingleton<ITelemetryInitializer, MyCustomTelemetryInitializer>(); egyszerű inicializálókhoz használható. Mások services.AddSingleton(new MyCustomTelemetryInitializer() { fieldName = "myfieldName" }); számára kötelező. Ez a .NET-verzió már nem támogatott.

TelemetryInitializers eltávolítása

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

ASP.NET Core 6 és újabb verziók

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

ASP.NET Core 5 és korábbi verziók

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

Feljegyzés

Ez a .NET-verzió már nem támogatott.

Telemetriai processzorok hozzáadása

A bővítménymetódussal AddApplicationInsightsTelemetryProcessor egyéni telemetriai processzorokat TelemetryConfiguration vehet fel a következőreIServiceCollection: . A speciális szűrési forgatókönyvekben telemetriai processzorokat használ. Használja a következő példát:

ASP.NET Core 6 és újabb verziók

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

ASP.NET Core 5 és korábbi verziók

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

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

Feljegyzés

Ez a .NET-verzió már nem támogatott.

Alapértelmezett telemetriaimodulok konfigurálása vagy eltávolítása

Az Application Insights automatikusan gyűjti az adott számítási feladatok telemetriáját anélkül, hogy manuális nyomon követést kellene megkövetelnie a felhasználótól.

Alapértelmezés szerint a következő automatikus gyűjteménymodulok vannak engedélyezve. Ezek a modulok felelősek a telemetriai adatok automatikus gyűjtéséért. Letilthatja vagy konfigurálhatja őket, hogy módosítsák az alapértelmezett viselkedésüket.

• RequestTrackingTelemetryModule: A RequestTelemetryt gyűjti a bejövő webes kérelmekből.
• DependencyTrackingTelemetryModule: A DependencyTelemetria gyűjtése kimenő HTTP-hívásokból és SQL-hívásokból.
• PerformanceCollectorModule: Összegyűjti a Windows PerformanceCounterst.
• QuickPulseTelemetryModule: Az élő metrikák panelen megjelenítendő telemetriát gyűjt.
• AppServicesHeartbeatTelemetryModule: Összegyűjti a szívveréseket (amelyeket egyéni metrikákként küldünk el), arról az App Service-környezetről, ahol az alkalmazás üzemel.
• AzureInstanceMetadataTelemetryModule: Összegyűjti a szívveréseket (amelyeket egyéni metrikákként küldünk el), az alkalmazás üzemeltetett Azure-beli virtuálisgép-környezetéről.
• EventCounterCollectionModule: Összegyűjti az EventCounterst. Ez a modul egy új funkció, amely az SDK 2.8.0-s és újabb verzióiban érhető el.

Az alapértelmezett TelemetryModulebeállítások konfigurálásához használja a bővítménymetódust ConfigureTelemetryModule<T> IServiceCollectiona következő példában látható módon:

ASP.NET Core 6 és újabb verziók

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

ASP.NET Core 5 és korábbi verziók

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

Feljegyzés

Ez a .NET-verzió már nem támogatott.

A 2.12.2-s és újabb ApplicationInsightsServiceOptions verziókban egyszerűen letilthatja az alapértelmezett modulokat.

Telemetriacsatorna konfigurálása

Az alapértelmezett telemetriai csatorna a .ServerTelemetryChannel Az alábbi példa bemutatja, hogyan bírálhatja felül.

ASP.NET Core 6 és újabb verziók

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

ASP.NET Core 5 és korábbi verziók

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

Feljegyzés

Ez a .NET-verzió már nem támogatott.

Feljegyzés

Ha ki szeretné üríteni a puffert, tekintse meg az adatok kiürítését. Előfordulhat például, hogy ki kell ürítenie a puffert, ha az SDK-t egy leállított alkalmazásban használja.

Telemetria dinamikus letiltása

Ha feltételesen és dinamikusan szeretné letiltani a telemetriát, feloldhatja a TelemetryConfiguration példányt egy ASP.NET Core függőséginjektáló tárolóval a kód bármely pontján, és beállíthatja rajta a DisableTelemetry jelzőt.

ASP.NET Core 6 és újabb verziók

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

ASP.NET Core 5 és korábbi verziók

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

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

Feljegyzés

Ez a .NET-verzió már nem támogatott.

Az előző kódminta megakadályozza, hogy telemetriát küldjön az Application Insightsnak. Ez nem akadályozza meg, hogy az automatikus gyűjtési modulok telemetriát gyűjtsenek. Ha el szeretne távolítani egy adott autokullection modult, olvassa el a Telemetriai modul eltávolítása című témakört.

Gyakori kérdések

Ez a szakasz választ ad a gyakori kérdésekre.

Támogatja az Application Insights a ASP.NET Core 3.1-et?

ASP.NET Core 3.1-et a Microsoft már nem támogatja.

Az Application Insights SDK ASP.NET Core 2.8.0-s és Visual Studio 2019-es vagy újabb verziójához használható ASP.NET Core 3.1-alkalmazásokhoz.

Hogyan követhetem nyomon a nem automatikusan gyűjtött telemetriát?

Hozzon létre egy példányt TelemetryClient konstruktorinjektálással, és hívja meg a szükséges TrackXXX() módszert. Nem javasoljuk, hogy új TelemetryClient vagy TelemetryConfiguration példányokat hozzon létre egy ASP.NET Core-alkalmazásban. A tárolóban DependencyInjection már regisztrálva van egy egyszeri példányTelemetryClient, amely a többi telemetriával osztozikTelemetryConfiguration. Csak akkor hozzon létre új TelemetryClient példányt, ha a többi telemetriától eltérő konfigurációra van szüksége.

Az alábbi példa bemutatja, hogyan követhet nyomon több telemetriát egy vezérlőből.

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

Az Application Insights egyéni adatjelentéseiről további információt az Application Insights egyéni metrikák API-referenciájában talál. Hasonló megközelítéssel egyéni metrikákat küldhet az Application Insightsnak a GetMetric API használatával.

Hogyan rögzíteni a Kérés és válasz törzset a telemetriámban?

ASP.NET Core beépített támogatást nyújt a HTTP-kérések/válaszok adatainak (beleértve a törzset) naplózásához.ILogger Javasoljuk, hogy használja ezt. Ez potenciálisan személyes azonosításra alkalmas adatokat (PII) tehet közzé a telemetriában, és a költségek (teljesítményköltségek és Az Application Insights számlázása) jelentősen növekedhet, ezért a használat előtt gondosan értékelje ki a kockázatokat.

Hogyan testre szabni az ILogger-naplók gyűjteményét?

Az Application Insights alapértelmezett beállítása csak a Figyelmeztetés és a súlyosabb naplók rögzítése.

Az Application Insights-szolgáltató naplózási konfigurációjának az alábbiak szerint történő módosításával rögzítheti az információkat és a kevésbé súlyos naplókat.

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

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

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

További információ: ILogger-konfiguráció.

Egyes Visual Studio-sablonok az IWebHostBuilder UseApplicationInsights() bővítménymetódusát használták az Application Insights engedélyezéséhez. Ez a használat továbbra is érvényes?

A bővítménymetódus UseApplicationInsights() továbbra is támogatott, de elavultként van megjelölve az Application Insights SDK 2.8.0-s és újabb verzióiban. Az SDK következő főverziója eltávolítja. Az Application Insights telemetriai adatainak engedélyezéséhez használja AddApplicationInsightsTelemetry() , mert túlterheléseket biztosít bizonyos konfigurációk szabályozásához. Emellett ASP.NET Core 3.X-alkalmazásokban services.AddApplicationInsightsTelemetry() csak az Application Insightst lehet engedélyezni.

Üzembe helyezem a ASP.NET Core-alkalmazásomat a Web Appsben. Továbbra is engedélyezni kell az Application Insights bővítményt a Web Appsből?

Ha az SDK a jelen cikkben látható buildelési időpontban van telepítve, nem kell engedélyeznie az Application Insights bővítményt az App Service portálról. Ha a bővítmény telepítve van, a bővítmény kikapcsol, amikor azt észleli, hogy az SDK már hozzá lett adva. Ha engedélyezi az Application Insightst a bővítményből, nem kell telepítenie és frissítenie az SDK-t. Ha azonban a jelen cikkben ismertetett utasításokat követve engedélyezi az Application Insights szolgáltatást, nagyobb rugalmasságot biztosít, mert:

• Az Application Insights telemetriai adatai továbbra is működnek:
  • Minden operációs rendszer, beleértve a Windowst, a Linuxot és a Macet is.
  • Minden közzétételi mód, beleértve az önálló vagy keretrendszerfüggőt is.
  • Minden cél-keretrendszer, beleértve a teljes .NET-keretrendszer.
  • Minden üzemeltetési lehetőség, beleértve a Web Appst, a virtuális gépeket, a Linuxot, a tárolókat, az AKS-t és a nem Azure-beli üzemeltetést.
  • Minden .NET Core-verzió, beleértve az előzetes verziókat is.
• A Telemetriát helyileg láthatja, amikor hibakeresést végzett a Visual Studióban.
• Az API használatával TrackXXX() további egyéni telemetriát is nyomon követhet.
• Teljes körűen szabályozhatja a konfigurációt.

Engedélyezhetim az Application Insights monitorozását olyan eszközökkel, mint az Azure Monitor Application Insights Agent (korábbi nevén Status Monitor v2)?

Igen. Az Application Insights Agent 2.0.0-beta1 és újabb verzióiban az IIS-ben üzemeltetett ASP.NET Core-alkalmazások támogatottak.

Minden funkció támogatott, ha az alkalmazást Linuxon futtatom?

Igen. Az SDK szolgáltatástámogatása minden platformon azonos, az alábbi kivételekkel:

• Az SDK eseményszámlálókat gyűjt Linux rendszeren, mert a teljesítményszámlálók csak a Windowsban támogatottak. A legtöbb metrika ugyanaz.

Ez az SDK támogatott a Worker Services esetében?

Szám A feldolgozói szolgáltatásokhoz használja az Application Insights for Worker Service-alkalmazásokat (nem HTTP-alkalmazásokat).

Hogyan távolíthatom el az SDK-t?

Az Application Insights eltávolításához el kell távolítania a NuGet-csomagokat és -hivatkozásokat az alkalmazás API-jából. A NuGet-csomagokat a Visual Studióban a NuGet Csomagkezelő használatával távolíthatja el.

Feljegyzés

Ezek az utasítások a ASP.NET Core SDK eltávolítására használhatók. Ha el kell távolítania a ASP.NET SDK-t, olvassa el a Hogyan távolíthatom el a ASP.NET SDK-t?

1. Távolítsa el a Microsoft.ApplicationInsights.AspNetCore csomagot a NuGet Csomagkezelő használatával.
2. Az Application Insights teljes eltávolításához ellenőrizze és manuálisan törölje a hozzáadott kódot vagy fájlokat a projektben hozzáadott API-hívásokkal együtt. További információ: Mi jön létre az Application Insights SDK hozzáadásakor?

Mi jön létre az Application Insights SDK hozzáadásakor?

Amikor hozzáadja az Application Insightst a projekthez, az fájlokat hoz létre, és kódot ad hozzá néhány fájlhoz. A NuGet-csomagok eltávolítása nem mindig veti el a fájlokat és a kódot. Az Application Insights teljes eltávolításához ellenőrizze és manuálisan törölje a hozzáadott kódot vagy fájlokat, valamint a projektben hozzáadott API-hívásokat.

Amikor Hozzáadja az Application Insights telemetriát egy Visual Studio ASP.NET Core-sablonprojekthez, a következő kódot adja hozzá:

• [A projekt neve].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
          }
  

Hogyan tilthatom le a telemetriai korrelációt?

Ha le szeretné tiltani a telemetriai korrelációt a kódban, tekintse meg <ExcludeComponentCorrelationHttpHeadersOnDomains> az Application Insights konzolalkalmazásokhoz készült témakörét.

Hibaelhárítás

Tekintse meg a dedikált hibaelhárítási cikket.

Az alkalmazásgazda és a betöltési szolgáltatás közötti kapcsolat tesztelése

Az Application Insights SDK-k és -ügynökök telemetriát küldenek, hogy REST-hívásként betöltse a betöltési végpontokat. A webkiszolgálóról vagy az alkalmazásgazdagépről a betöltési szolgáltatás végpontjaihoz való kapcsolódást a PowerShellből vagy curl parancsokból származó nyers REST-ügyfelek használatával tesztelheti. Tekintse meg a hiányzó alkalmazástelemetria hibaelhárítását az Azure Monitor Application Insightsban.

Nyílt forráskódú SDK

Olvassa el és járuljon hozzá a kódhoz.

A legújabb frissítéseket és hibajavításokat a kibocsátási megjegyzésekben találja.

Release Notes (Kibocsátási megjegyzések)

A 2.12-es és újabb verziókhoz: .NET SDK-k (beleértve a ASP.NET, ASP.NET Core- és naplózási adaptereket)

Szolgáltatásfrissítéseink az Application Insights főbb fejlesztéseit is összefoglalják.

Következő lépések

• Megismerheti a felhasználói folyamatokat , és megtudhatja, hogyan mozognak a felhasználók az alkalmazásban.
• Konfiguráljon egy pillanatkép-gyűjteményt a forráskód és a változók állapotának megtekintéséhez a kivétel pillanatában.
• Az API használatával saját eseményeket és metrikákat küldhet az alkalmazás teljesítményének és használatának részletes megtekintéséhez.
• A rendelkezésre állási tesztekkel folyamatosan ellenőrizheti az alkalmazást a világ minden tájáról.
• További információ a függőséginjektálásról a ASP.NET Core-ban.