Alkalmazás Elemzések ASP.NET Core-alkalmazásokhoz

  • Cikk

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

Feljegyzés

Az alábbi dokumentáció az Alkalmazás Elemzések klasszikus API-ra támaszkodik. Az Alkalmazás Elemzések hosszú távú terve az Adatok gyűjtése Az OpenTelemetria használatával. További információ: Az Azure Monitor OpenTelemetria engedélyezése .NET-, Node.js-, Python- és Java-alkalmazásokhoz.

Az alkalmazás Elemzések a következő telemetriát gyűjtheti a ASP.NET Core-alkalmazásból:

  • maximális száma
  • 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 Alkalmazás Elemzések a 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 Alkalmazás Elemzések SDK monitorozza az alkalmazásokat, függetlenül attól, hogy hol vagy hogyan futnak. Ha az alkalmazás fut, és hálózati kapcsolattal rendelkezik az Azure-hoz, telemetriai adatok gyűjthetők. Az alkalmazás Elemzések monitorozás mindenhol támogatott. A .NET Core támogatott, és a következő 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:

Alkalmazásoldali telemetriai Elemzések 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. Nyissa meg a Project>Alkalmazás hozzáadása Elemzések telemetriát.

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

  4. Válassza ki az előfizetést és az alkalmazás Elemzések-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 alkalmazás Elemzések 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 Alkalmazás Elemzések a projekthez, ellenőrizze, hogy az SDK legújabb stabil kiadását használja-e. Nyissa meg a Project>Manage NuGet Packages>Microsoft.Application Elemzések lehetőséget. AspNetCore. Ha szükséges, válassza a Frissítés lehetőséget.

    Screenshot that shows where to select the Application Insights package for update.

Alkalmazásoldali telemetriai Elemzések engedélyezése (Visual Studio nélkül)

  1. Telepítse az Application Elemzések 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.

    Adja hozzá builder.Services.AddApplicationInsightsTelemetry(); az osztály metódusa ProgramWebApplication.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();

  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.AspNetCorea 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 már az Application Elemzések-be kell folynia. Az Alkalmazás Elemzések SDK automatikusan gyűjti az alkalmazáshoz érkező bejövő webes kéréseket, valamint az alábbi telemetriát.

Élő metrikaadatok

Az élő metrikák segítségével gyorsan ellenőrizheti, hogy az alkalmazás Elemzések monitorozás megfelelően van-e konfigurálva. Eltarthat néhány percig, amíg a telemetria megjelenik a portálon és az elemzésben, de az élő metrikák közel valós időben jelenítik meg a futó folyamat processzorhasználatát. Más telemetriákat is megjeleníthet, például kéréseket, függőségeket és nyomkövetéseket.

ILogger-naplók

Az alapértelmezett konfiguráció összegyűjti a naplókat ILoggerWarning é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. A függőségek nyomon követése az alkalmazás Elemzések ismerteti az automatikusan összegyű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 Elemzések 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 alkalmazás Elemzések SDK konfigurálása

Az alapértelmezett konfiguráció módosításához testre szabhatja az Alkalmazás Elemzések SDK-t ASP.NET Core-hoz. Előfordulhat, hogy az alkalmazás Elemzések ASP.NET SDK felhasználói ismerik a konfiguráció módosításával vagy módosításával ApplicationInsights.config történő módosításátTelemetryConfiguration.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 Application Elemzések ServiceOptions 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:

var builder = WebApplication.CreateBuilder(args);

var aiOptions = new Microsoft.ApplicationInsights.AspNetCore.Extensions.ApplicationInsightsServiceOptions();

// Disables adaptive sampling.
aiOptions.EnableAdaptiveSampling = false;

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

builder.Services.AddApplicationInsightsTelemetry(aiOptions);
var app = builder.Build();

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.Application-hez Elemzések. AspNetCore SDK 2.15.0-s és újabb verziók

Microsoft.Application Elemzések. Az AspNetCore SDK 2.15.0-s és újabb verziója konfigurálja az összes elérhető ApplicationInsightsServiceOptionsbeállítást, beleértve a 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

Az application Elemzések SDK for ASP.NET Core 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.

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

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.

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

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:

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

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

Az alkalmazás Elemzések automatikusan telemetriát gyűjt az adott számítási feladatokról 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: Telemetriát gyűjt az Élő metrikák portálon való megjelenítéshez.
  • 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:

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

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.

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

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.

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

Az előző kódminta megakadályozza, hogy telemetriát küldjön az Alkalmazás Elemzések. 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 Alkalmazás Elemzések a Core 3.1 ASP.NET?

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

Az application Elemzések 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();
    }

További információ az egyéni adatjelentésekről az Application Elemzések-ben: Application Elemzések custom metrics API-referencia. Hasonló módszer használható az egyéni metrikákNak az Application Elemzések-be való küldéséhez 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 alkalmazás Elemzések számlázása) jelentős növekedéséhez vezethet, 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 alkalmazás Elemzések alapértelmezett beállítása csak a Figyelmeztetés és a súlyosabb naplók rögzítése.

Az adatok és a kevésbé súlyos naplók rögzítéséhez módosítsa az alkalmazás Elemzések szolgáltató naplózási konfigurációját az alábbiak szerint.

{
  "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 alkalmazás Elemzések szolgáltatójának a naplók rögzítésétInformation. 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 alkalmazás Elemzések 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 UseApplication Elemzések() bővítménymetódusát használták az alkalmazás Elemzések 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 Elemzések SDK 2.8.0-s és újabb verzióiban. Az SDK következő főverziója eltávolítja. Az alkalmazás Elemzések telemetriai adatok engedélyezéséhez használjaAddApplicationInsightsTelemetry(), mert túlterheléseket biztosít bizonyos konfigurációk szabályozásához. Emellett ASP.NET Core 3.X-alkalmazásokban services.AddApplicationInsightsTelemetry() az alkalmazás Elemzések engedélyezésének egyetlen módja.

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

Ha az SDK buildeléskor van telepítve, ahogyan az ebben a cikkben látható, nem kell engedélyeznie az Alkalmazás Elemzések 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 Alkalmazás Elemzések 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 Alkalmazás Elemzések, nagyobb rugalmasságot biztosít, mert:

  • Az alkalmazás-Elemzések telemetria továbbra is működik:
    • 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élyezhetem az alkalmazás Elemzések monitorozását olyan eszközökkel, mint az Azure Monitor Alkalmazás Elemzések Ügynök (korábbi nevén Állapotfigyelő v2)?

Igen. Az Application Elemzések 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:

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

Szám A feldolgozói szolgáltatásokhoz használja az Alkalmazás Elemzések munkavégző szolgáltatás alkalmazásokhoz (nem HTTP-alkalmazásokhoz).

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

Az alkalmazás Elemzések 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.Application Elemzések. AspNetCore-csomag a NuGet Csomagkezelő használatával.
  2. Az alkalmazás Elemzések 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. További információ: Mi jön létre az alkalmazás Elemzések SDK hozzáadásakor?

Mi jön létre az alkalmazás Elemzések SDK hozzáadásakor?

Amikor hozzáadja az alkalmazás Elemzések 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 alkalmazás Elemzések 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 egy Visual Studio ASP.NET Core-sablonprojekthez hozzáadja az Application Elemzések Telemetriát, 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"

  • Csatlakozás edService.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
        }

Hibaelhárítás

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

Az alkalmazás Elemzések 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 az Azure Monitor-alkalmazás Elemzések hiányzó alkalmazástelemetria hibaelhárítását.

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.

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ásunk Frissítések a főbb alkalmazás-Elemzések fejlesztéseket is összefoglalja.

Következő lépések