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

Ez a cikk azt ismerteti, hogyan engedélyezhető az application Elemzések egy ASP.NET Core alkalmazáshoz. A cikkben található utasítások befejezése után az Application Elemzések gyűjti a kéréseket, a függőségeket, a kivételeket, a teljesítményszámlálókat, a szívveréseket és a ASP.NET Core naplókat.

Itt egy MVC-alkalmazást fogunk használni, amely a következőt célozza netcoreapp3.0 meg: . Ezeket az utasításokat alkalmazhatja az összes ASP.NET Core alkalmazásra. Ha a feldolgozói szolgáltatást használja,kövesse az itt található utasításokat.

Támogatott esetek

Az Application Elemzések SDK for ASP.NET Core 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, telemetria gyűjthető. Az Elemzések -figyelés mindenhol támogatott, ahol a .NET Core támogatott. A támogatás a következőket foglalja magában:

  • Operációs rendszer: Windows, Linux vagy Mac
  • Üzemeltetési módszer: Folyamatban van vagy folyamatban van
  • Üzembe helyezési módszer: Keretrendszerfüggő vagy önálló
  • Webkiszolgáló: IIS (Internet Information Server) vagy Kestrel
  • Üzemeltetési platform: az Web Apps, az Azure Azure App Service, a Docker, Azure Kubernetes Service (AKS) Azure Kubernetes Service és így tovább
  • .NET Core-verzió: Minden hivatalosan támogatott .NET Core-verzió, amely nem előzetes verzióban érhető el
  • IDE: Visual Studio, Visual Studio Code vagy parancssor

Megjegyzés

ASP.NET Core 3.1-es hez az Application Elemzések 2.8.0-s vagy újabb szükséges.

Előfeltételek

  • Egy működő ASP.NET Core alkalmazás. Ha létre kell hoznia egy ASP.NET Core alkalmazást, kövesse ezt a ASP.NET Core oktatóanyagot.
  • Egy érvényes Application Elemzések eszközkulcs. Ez a kulcs szükséges ahhoz, hogy bármilyen telemetriát elküldj az Application Elemzések. Ha létre kell hoznia egy új Application Elemzések-erőforrást a rendszerkulcs le Elemzések létrehozásához.

Fontos

A kapcsolati sztringek használata javasolt a beállítási kulcsokhoz. Az új Azure-régiókhoz kapcsolati sztringek használata szükséges a rendszerkulcsok helyett. A kapcsolati sztring azonosítja azt az erőforrást, amellyel társítani szeretné a telemetriai adatokat. Azt is lehetővé teszi, hogy módosítsa azokat a végpontokat, amelyekre az erőforrás a telemetria célhelyeként fog használni. Ki kell másolnia a kapcsolati sztringet, és hozzá kell adni az alkalmazás kódjához vagy egy környezeti változóhoz.

Alkalmazásoldali Elemzések telemetria engedélyezése (Visual Studio)

A Visual Studio for Mac útmutatót használja. Ezt az Windows csak Visual Studio verziója támogatja.

  1. Nyissa meg a projektjét a Visual Studióban.

    Tipp

    Az Application Elemzések módosításainak nyomon követéséhez beállíthatja a projekthez a forrásvezérlőt. A beállításhoz válassza a Fájl hozzáadása > a forráskezelőhez lehetőséget.

  2. Válassza Project Add Application Elemzések Telemetry (Alkalmazás > hozzáadása Elemzések telemetriához) lehetőséget.

  3. Válassza a Első lépések lehetőséget. A gomb Visual Studio függően változhat. Néhány korábbi verzióban az Ingyenes kezdés gomb nevet kapta.

  4. Válassza ki az előfizetését, majd válassza az Erőforrás > regisztrálása lehetőséget.

  5. Miután hozzáadta az Application Elemzések a projekthez, ellenőrizze, hogy az SDK legújabb stabil kiadását használja-e. A NuGet-csomagok Project > > Microsoft.ApplicationInsights.AspNetCore webhelyen. Ha szükséges, válassza a Frissítés lehetőséget.

    Képernyőkép az Application Elemzések csomag kiválasztásáról frissítéshez

  6. Ha a projektet hozzáadta a forrásvezérlőhez, a View Team Explorer Changes > (Módosítások megtekintése) Team Explorer > meg. Ha kijelöli az egyes fájlokat, láthatja az Application Elemzések módosításainak különbségi nézetét.

Alkalmazás-Elemzések kiszolgálóoldali telemetria engedélyezése (nincs Visual Studio)

  1. Telepítse az Application Elemzések SDK NuGet-csomagot a ASP.NET Core. Javasoljuk, hogy mindig a legújabb stabil verziót használja. Az SDK teljes kibocsátási megjegyzéseit a nyílt forráskódú GitHub tartalmazza.

    Az alábbi kódminta bemutatja a projekt fájljában hozzáadható .csproj módosításokat.

        <ItemGroup>
          <PackageReference Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.16.0" />
        </ItemGroup>
    
  2. Adja services.AddApplicationInsightsTelemetry(); hozzá a ConfigureServices() metódushoz a Startup osztályban, ahogy az alábbi példában is:

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

    Bár a rendszerkonfigurációs kulcsot megadhatja argumentumként a számára, javasoljuk, hogy a konfigurációban adja meg a AddApplicationInsightsTelemetry rendszeregységkulcsot. A következő kódminta bemutatja, hogyan adható meg egy eszközkulcs a appsettings.json -ban. A közzététel során győződjön meg arról, hogy a rendszer az alkalmazás appsettings.json gyökérmappába másolja a fájlt.

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

    Másik lehetőségként adja meg a eszközkulcsot az alábbi környezeti változók valamelyikében:

    • APPINSIGHTS_INSTRUMENTATIONKEY

    • ApplicationInsights:InstrumentationKey

    Például:

    • SET ApplicationInsights:InstrumentationKey=putinstrumentationkeyhere

    • SET APPINSIGHTS_INSTRUMENTATIONKEY=putinstrumentationkeyhere

    • Általában APPINSIGHTS_INSTRUMENTATIONKEY az Azure Web Apps,de minden olyan helyen használható, ahol ez az SDK támogatott. (Ha kód nélküli webalkalmazás-monitorozást használ, erre a formátumra akkor van szükség, ha nem használ kapcsolati sztringeket.)

    Az eszközkulcsok beállítása helyett mostantól a Kapcsolati sztringek is használhatók.

    Megjegyzés

    A kódban megadott eszközkulcs nyeri a környezeti változót, amely a többi APPINSIGHTS_INSTRUMENTATIONKEY beállítás felett nyer.

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

Ha felhasználói titkos kulcsokban szeretné tárolni ASP.NET Core kulcsot, vagy egy másik konfigurációszolgáltatótól szeretné lekérni, a túlterhelést paraméterrel Microsoft.Extensions.Configuration.IConfiguration használhatja. Például: services.AddApplicationInsightsTelemetry(Configuration);. A Microsoft.ApplicationInsights.AspNetCore 2.15.0-sverziójától kezdődően a hívása automatikusan beolvassa a rendszeregységkulcsot az services.AddApplicationInsightsTelemetry() Microsoft.Extensions.Configuration.IConfiguration alkalmazásból. Nem szükséges explicit módon meg adni a IConfiguration következőt: .

Az alkalmazás futtatása

Futtassa az alkalmazást, és futtatassa hozzá a kéréseket. A telemetria most már az Application Elemzések. Az Application Elemzések SDK automatikusan gyűjti az alkalmazáshoz beérkező webes kéréseket a következő telemetriával együtt.

Élő metrikák

Az élő metrikák segítségével gyorsan ellenőrizhető, hogy az alkalmazás-Elemzések monitorozás megfelelően van-e konfigurálva. Eltarthat néhány percig, hogy a telemetria megjelenjen a portálon és az elemzésekben, de az élő metrikák közel valós időben jelenítik meg a futó folyamat CPU-használatát. Más telemetriai adatokat is képes mutatni, például a kérelmeket, a függőségeket és a nyomkövetéseket.

ILogger-naplók

Az alapértelmezett konfiguráció naplókat ILogger Warning és súlyosabb naplókat gyűjt. Ezt a konfigurációt testreszabhatja.

Függőségek

A függőséggyűjtemény alapértelmezés szerint engedélyezve van. Ez a cikk ismerteti az automatikusan gyűjtött függőségeket, valamint a manuális nyomkövetés lépéseit.

Teljesítményszámlálók

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

  • Az SDK 2.4.1-es és újabb verziói teljesítményszámlálókat gyűjtenek, ha az alkalmazás az Azure Web Apps (Windows).
  • Az SDK 2.7.1-es és újabb verziói teljesítményszámlálókat gyűjtenek, ha az alkalmazás Windows vagy újabb verzióban NETSTANDARD2.0 fut.
  • Az alkalmazást .NET-keretrendszer SDK összes 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 Linux rendszeren. A Linux nem támogat más számlálót. A rendszerszámlálók Linuxon (és más, nem Windows környezetekben) az EventCounters használatával való lekért módszer.

EventCounter

Alapértelmezés szerint a EventCounterCollectionModule engedélyezve van. A gyűjthető számlálók listájának konfigurálásával ismerkedés az EventCounters bevezetőjében található.

Ügyféloldali telemetria engedélyezése webalkalmazások számára

Az előző lépések elegendőek a kiszolgálóoldali telemetria gyűjtésének elkezdéséhez. Ha az alkalmazás ügyféloldali összetevőkkel rendelkezik, a következő lépésekkel kezdheti meg a használati telemetria gyűjtését.

  1. A _ViewImports.cshtml -hez adjon hozzá injektálást:
    @inject Microsoft.ApplicationInsights.AspNetCore.JavaScriptSnippet JavaScriptSnippet
  1. _Layout.cshtmlA-be HtmlHelper szúrja be az et a szakasz <head> végére, de egy másik szkript előtt. Ha egyéni JavaScript-telemetriát szeretne jelenteni az oldalról, a kódrészlet után adja be azt:
    @Html.Raw(JavaScriptSnippet.FullScript)
    </head>

A használata alternatívájaként a az FullScript Application Elemzések SDK for ASP.NET Core ScriptBody 2.14-es verziójától kezdve érhető el. Ezt akkor használja, ha a címkét tartalombiztonsági szabályzat beállítására <script> kell beállítania:

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

A .cshtml korábban hivatkozott fájlnevek egy alapértelmezett MVC-alkalmazássablonból valók. Végső soron, ha megfelelően engedélyezni szeretné az ügyféloldali figyelés alkalmazását, a JavaScript-kódrészletnek meg kell jelennie a figyelni kívánt alkalmazás minden oldalának <head> szakaszában. Ehhez ebben az alkalmazássablonban adja hozzá a JavaScript-kódrészletet a _Layout.cshtml fájlhoz.

Ha a projekt nem tartalmazza a et, akkor is hozzáadhat _Layout.cshtml ügyféloldali figyelési figyelőt. Ehhez adja hozzá a JavaScript-kódrészletet egy egyenértékű fájlhoz, amely az alkalmazás összes oldalának <head> fájlját szabályozza. A kódrészletet több oldalhoz is hozzáadhatja, de ezt a megoldást nehéz karbantartani, és általában nem javasoljuk.

Megjegyzés

A JavaScript-injektálás alapértelmezett konfigurációs élményt biztosít. Ha a rendszerkonfigurációs kulcs beállításán túl is konfigurálni kell, el kell távolítania az automatikus injektálást a fent leírtak szerint, és manuálisan hozzá kell adni a JavaScript SDK-t.

Az Application Elemzések SDK konfigurálása

Az Application Elemzések SDK for ASP.NET Core testre szabhatja az alapértelmezett konfigurációt. Előfordulhat, hogy az Application Elemzések ASP.NET SDK felhasználói ismerik a konfigurációnak a vagy a használatával ApplicationInsights.config való TelemetryConfiguration.Active módosítását. A ASP.NET Core végre szinte az összes konfigurációs módosítást az osztály metódusában, kivéve, ha ConfigureServices() az ellenkező Startup.cs irányban van irányítva. Az alábbi szakaszok további információkat tartalmaznak.

Megjegyzés

A ASP.NET Core esetében a konfiguráció módosítása nem TelemetryConfiguration.Active támogatott.

Az ApplicationInsightsServiceOptions használata

Néhány gyakori beállítást a következő példában használt gombra való átadásval ApplicationInsightsServiceOptions AddApplicationInsightsTelemetry módosíthat:

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

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

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

Beállítás Leírás Alapértelmezett
EnablePerformanceCounterCollectionModule Engedélyezés/letiltás PerformanceCounterCollectionModule true
EnableRequestTrackingTelemetryModule Engedélyezés/letiltás RequestTrackingTelemetryModule true
EnableEventCounterCollectionModule Engedélyezés/letiltás EventCounterCollectionModule true
EnableDependencyTrackingTelemetryModule Engedélyezés/letiltás DependencyTrackingTelemetryModule true
EnableAppServicesHeartbeatTelemetryModule Engedélyezés/letiltás AppServicesHeartbeatTelemetryModule true
EnableAzureInstanceMetadataTelemetryModule Engedélyezés/letiltás AzureInstanceMetadataTelemetryModule true
EnableQuickPulseMetricStream LiveMetrics funkció engedélyezése/letiltása true
EnableAdaptiveSampling (EnableAdaptiveSampling) Adaptív mintavételezés engedélyezése/letiltása true
EnableHeartbeat (Az enableHeartbeat engedélyezése) A Szívverések engedélyezése/letiltása szolgáltatás, amely rendszeres időközönként (alapértelmezés szerint 15 perc) egy HeartbeatState nevű egyéni metrikát küld, amely a futásidőre vonatkozó információkat tartalmaz, például a .NET-verziót, az Azure-környezet adatait, ha van ilyen stb. true
AddAutoCollectedMetricExtractor Engedélyezze/tiltsa le az AutoCollectedMetrics kinyerőt, amely egy telemetriai adatfeldolgozó, amely a mintavételezés előtt előre összesített metrikákat küld a kérésekkel/függőségekkel kapcsolatban. true
RequestCollectionOptions.TrackExceptions Engedélyezze/tiltsa le a nem kezelt kivételek nyomon követésének jelentését a Kérelemgyűjtés modullal. false (hamis) érték a NETSTANDARD2.0-ban (mivel a kivételek nyomon követése az ApplicationInsightsLoggerProvider segítségével történt), egyébként igaz.
EnableDiagnosticsTelemetryModule Engedélyezze/tiltsa le DiagnosticsTelemetryModule a et. Ha letiltja ezt a beállítást, a rendszer figyelmen kívül hagyja a következő beállításokat; EnableHeartbeat, EnableAzureInstanceMetadataTelemetryModule, EnableAppServicesHeartbeatTelemetryModule true

A legfrissebb listában tekintse meg a konfigurálható beállításait a következőben: ApplicationInsightsServiceOptions .

Konfigurációs javaslatok a Microsoft.ApplicationInsights.AspNetCore SDK 2.15.0-s és újabb verziójához

A Microsoft.ApplicationInsights.AspNetCore SDK 2.15.0-s és újabb verzióiban azt javasoljuk, hogy konfigurálja a ben elérhető összes beállítást, beleértve a ApplicationInsightsServiceOptions InstrumentationKey beállítást is az alkalmazás példányának IConfiguration használatával. A beállításoknak az "ApplicationInsights" szakaszban kell lennie, ahogyan az alábbi példában látható. A következő szakasza appsettings.jskonfigurálja a rendszerkulcsot, és letiltja az adaptív mintavételezést és a teljesítményszámlálók gyűjtését.

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

Ha services.AddApplicationInsightsTelemetry(aiOptions) a van használva, felülírja a beállításait a következőből: Microsoft.Extensions.Configuration.IConfiguration .

Mintavételezés

Az Application Elemzések SDK for ASP.NET Core támogatja a rögzített sebességet é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.

Telemetriainitializálók hozzáadása

Ha további információkkal szeretné gazdagítani a telemetriát, használjon telemetria-inicializálókat.

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

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

Megjegyzés

services.AddSingleton<ITelemetryInitializer, MyCustomTelemetryInitializer>(); az egyszerű inicializálókhoz is működik. Mások esetén a következőkre van szükség: services.AddSingleton(new MyCustomTelemetryInitializer() { fieldName = "myfieldName" });

Telemetriainitializálók eltávolítása

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

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

Telemetriai processzorok hozzáadása

A bővítmény metódusával egyéni telemetriai processzorokat adhat hozzá a TelemetryConfiguration AddApplicationInsightsTelemetryProcessor IServiceCollection alkalmazáshoz. A telemetriai processzorokat speciális szűrési forgatókönyvekben használhatja. Használja az alábbi példát.

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

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

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

Az Elemzések telemetriai modulokkal automatikusan gyűjt hasznos telemetriai adatokat adott számítási feladatokról anélkül, hogy a felhasználó manuálisan nyomon követné őket.

Alapértelmezés szerint a következő automatikus gyűjtési modulok vannak engedélyezve. Ezek a modulok felelnek a telemetria automatikus gyűjtéséért. Letilthatja vagy konfigurálhatja őket az alapértelmezett viselkedésük megváltoztatásához.

  • RequestTrackingTelemetryModule – Gyűjti a RequestTelemetry adatokat a bejövő webes kérelmekből
  • DependencyTrackingTelemetryModuleGyűjti a dependencyTelemetry adatokat a kimenő HTTP-hívásokból és SQL-hívásokból
  • PerformanceCollectorModule– Gyűjti a Windows-adatokat
  • QuickPulseTelemetryModule – Telemetriai adatokat gyűjt az élő metrikák portálon való megjelenítéshez
  • AppServicesHeartbeatTelemetryModule – Szívveréseket gyűjt (amelyek egyéni metrikákként vannak elküldve) Azure App Service környezetről, ahol az alkalmazás üzemel
  • AzureInstanceMetadataTelemetryModule – Szívveréseket gyűjt (amelyek egyéni metrikákként vannak elküldve) az alkalmazásokat üzemeltető Azure-beli virtuálisgép-környezetről
  • EventCounterCollectionModule – Gyűjti az EventCounters adatokat; Ez a modul egy új funkció, amely az SDK 2.8.0-s és újabb verzióiban érhető el

Bármely alapértelmezett beállítás konfigurálhoz használja a bővítmény metódusát a következő TelemetryModule ConfigureTelemetryModule<T> IServiceCollection példában látható módon.

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

A 2.12.2-es és újabb verziókban a tartalmaz egy egyszerű lehetőséget az alapértelmezett modulok ApplicationInsightsServiceOptions letiltására.

Telemetriai csatorna 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;

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

Telemetria dinamikus letiltása

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

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

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

A fenti kódminta megakadályozza a telemetria küldését az Application Elemzések. Ez nem akadályozza meg, hogy az automatikus gyűjtési modulok telemetriai adatokat gyűjtsenek. Ha el szeretne távolítani egy adott automatikus gyűjtési modult, tekintse meg a telemetriai modul eltávolítását.

Gyakori kérdések

Az Application Elemzések támogatja a ASP.NET Core 3.X-et?

Igen. Frissítsen az Application Elemzések SDK for ASP.NET Core 2.8.0-s vagy újabb verzióra. Az SDK korábbi verziói nem támogatják a ASP.NET Core 3.X-et.

Ha a Visual Studio-alapú kiszolgálóoldali telemetriátis engedélyezi, frissítsen az Visual Studio 2019 (16.3.0) legújabb verziójára a beállításhoz. A Visual Studio verziói nem támogatják az automatikus ASP.NET Core 3.X-alkalmazásokhoz.

Hogyan követhető nyomon az automatikusan nem gyűjtött telemetria?

Szerezze be a egy példányát TelemetryClient konstruktorinjektálással, és hívja meg rajta a TrackXXX() szükséges metódust. Nem javasoljuk, hogy új vagy TelemetryClient TelemetryConfiguration példányokat hozzon létre egy ASP.NET Core alkalmazásban. A egypéldányos példánya már regisztrálva van a tárolóban, amely megosztja a TelemetryClient DependencyInjection többi TelemetryConfiguration telemetriával. Új példány létrehozása csak akkor ajánlott, ha olyan konfigurációra van szüksége, amely nem a telemetria többi TelemetryClient része.

Az alábbi példa bemutatja, hogyan követhet nyomon további telemetriai adatokat egy vezérlőrő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 Elemzések egyéni adatjelentési szolgáltatásával kapcsolatos további Elemzések egyéni metrikák API-referenciája. Hasonló módszer használható egyéni metrikák application Elemzések a GetMetric API használatával.

Hogyan az ILogger-naplók gyűjtését?

Alapértelmezés szerint a rendszer csak a Warning naplókat és a súlyosabb naplókat rögzíti automatikusan. Ennek a viselkedésnek a módosításakor explicit módon bírálja felül a szolgáltató naplózási konfigurációját ApplicationInsights az alább látható módon. Az alábbi konfiguráció lehetővé teszi, hogy az ApplicationInsights rögzítse az összes naplót Information és a súlyosabb naplókat.

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

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

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

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

Néhány Visual Studio sablon a UseApplicationInsights() bővítmény metódusát használta az IWebHostBuilderben az Application Elemzések. Ez a használat továbbra is érvényes?

A bővítmény metódusa továbbra is támogatott, de elavultként van megjelölve UseApplicationInsights() az Application Elemzések SDK 2.8.0-s és újabb verzióiban. Az SDK következő főverziója eltávolítja. Az Application Elemzések telemetria engedélyezéséhez javasoljuk a használatát, mert túlterheléseket biztosít bizonyos AddApplicationInsightsTelemetry() konfigurációk vezérlése érdekében. Emellett a ASP.NET Core 3.X alkalmazásokban az az egyetlen lehetőség az services.AddApplicationInsightsTelemetry() alkalmazás-Elemzések.

Üzembe helyezem a saját ASP.NET Core a Web Apps. Továbbra is engedélyezni kell az Application Elemzések bővítményt a Web Apps?

Ha az SDK a build időben van telepítve, ahogy az a cikkben is látható, nem kell engedélyeznie az Application Elemzések bővítményt a App Service portálról. Még ha a bővítmény telepítve is van, akkor is kikapcsol, ha azt észleli, hogy az SDK már hozzá lett adva az alkalmazáshoz. Ha engedélyezi Elemzések alkalmazásokat a bővítményből, nem kell telepítenie és frissítenie az SDK-t. Ha azonban engedélyezi az Elemzések a cikk utasításait követve, nagyobb rugalmasságot biztosít, mert:

  • Az Elemzések telemetria továbbra is működni fog a következőben:
    • Minden operációs rendszer, beleértve a Windows, a Linuxot és a Macet is.
    • Minden közzétételi mód, beleértve az önálló vagy a keretrendszertől függő módokat is.
    • Minden célkeretrendszer, beleértve a teljes .NET-keretrendszer.
    • Minden üzemeltetési lehetőség, beleértve a Web Apps, a virtuális gépeket, a Linuxot, a tárolókat, Azure Kubernetes Service és a nem Azure-beli üzemeltetést.
    • Minden .NET Core-verzió, beleértve az előzetes verziókat is.
  • A telemetriai adatokat helyileg is láthatja, amikor a hibakeresést a Visual Studio.
  • Az API használatával további egyéni telemetriai adatokat is TrackXXX() nyomon követhet.
  • Teljes mértékben Ön szabályozhatja a konfigurációt.

Engedélyezem az application Elemzések monitorozását olyan eszközökkel, mint Azure Monitor application Elemzések Agent (korábban Állapotmonitor v2)?

Nem, Azure Monitor Application Elemzések Agent jelenleg csak a ASP.NET 4.x-et támogatja.

Ha Linuxon futtatom az alkalmazásomat, minden funkció támogatott?

Igen. Az SDK-funkciók támogatása minden platformon ugyanaz, a következő kivételekkel:

  • Az SDK azért gyűjt eseményszámlálókat Linuxon, mert a teljesítményszámlálók csak a Windows. A legtöbb metrika azonos.
  • Bár az alapértelmezés szerint engedélyezve van, ha az alkalmazás Linux vagy macOS rendszeren fut, a csatorna nem hoz létre automatikusan helyi tárolómappát a telemetria ideiglenes tárolásához hálózati ServerTelemetryChannel problémák esetén. Emiatt a telemetria ideiglenes hálózati vagy kiszolgálói problémák miatt elveszhet. A probléma megoldásához konfigurálja a csatorna helyi mappáját:
using Microsoft.ApplicationInsights.Channel;
using Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel;

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

Ez a korlátozás nem vonatkozik a 2.15.0-s és újabb verziókra.

Támogatja ez az SDK az új .NET Core 3.X feldolgozói szolgáltatás sablonalkalmazásait?

Ehhez az SDK-hoz a ; szükséges, ezért nem működik nem HttpContext HTTP-alkalmazásokban, beleértve a .NET Core 3.X feldolgozói szolgáltatás alkalmazásait. Ha engedélyezni szeretné Elemzések alkalmazásokban az újonnan kiadott Microsoft.ApplicationInsights.WorkerService SDK-t, tekintse meg az Application Elemzések for Worker Service applications (non-HTTP applications) (Application Elemzések for Worker Service applications (nem HTTP-alkalmazások) )részt.

Nyílt forráskódú SDK

A legújabb frissítésekért és hibajavításokért tekintse meg a kibocsátási megjegyzéseket.

Következő lépések