Alkalmazás Elemzések feldolgozói szolgáltatás alkalmazásához (nem HTTP-alkalmazások)

Az Application Elemzések SDK for Worker Service egy új SDK, amely nem HTTP-alapú számítási feladatokhoz, például üzenetküldéshez, háttérfeladatok, konzolalkalmazások stb. esetében a legmegfelelőbb. Az ilyen típusú alkalmazások nem támogatják a bejövő HTTP-kéréseket, például a hagyományos ASP.NET/ASP.NET Core-webalkalmazásokat, ezért az Application Elemzések-csomagok használata ASP.NET- vagy ASP.NET Core-alkalmazásokhoz nem támogatott.

Az új SDK önmagában nem gyűjt telemetriai adatokat. Ehelyett más jól ismert Application Elemzések-gyűjtőket is tartalmaz, például a DependencyCollectort, a PerfCounterCollectort,az ApplicationInsightsLoggingProvidert stb. Ez az SDK bővítmény metódusokat tesz elérhetővé a-ban IServiceCollection a telemetriagyűjtés engedélyezéséhez és konfigurálához.

Támogatott esetek

Az Application Elemzések SDK for Worker Service a nem HTTP-alkalmazásokhoz a legmegfelelőbb, 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 adatokat gyűjthet. Az Elemzések-monitorozás mindenhol támogatott, ahol a .NET Core támogatott. Ez a csomag használható az újonnan bevezetett .NET Core 3.0feldolgozói szolgáltatásban, a ASP.NET Core 2.1/2.2háttérfeladatokban, a konzolalkalmazásokban (.NET Core/ .NET-keretrendszer stb.).

Előfeltételek

Egy érvényes Application Elemzések eszközkulcs. Ez a kulcs ahhoz szükséges, hogy bármilyen telemetriát elküldj az Application Elemzések. Ha új Application Elemzések-erőforrást kell létrehoznia a rendszerkulcs le Elemzések létrehozásához.

Az Application Elemzések SDK használata feldolgozói szolgáltatásokhoz

  1. Telepítse a Microsoft.ApplicationInsights.WorkerService csomagot az alkalmazásra. Az alábbi kódrészlet azokat a módosításokat mutatja be, amelyek a projekt fájljában lesznek .csproj hozzáadva.
    <ItemGroup>
        <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.13.1" />
    </ItemGroup>
  1. Hívja AddApplicationInsightsTelemetryWorkerService(string instrumentationKey) meg a bővítmény metódusát a következőn: . Ez biztosítja a IServiceCollection eszközkulcsot. Ezt a metódust az alkalmazás elején kell meghívni. A pontos hely az alkalmazás típusától függ.

  2. Egy példány vagy példány lekérése a függőséginjektálás (DI) tárolóból a ILogger TelemetryClient serviceProvider.GetRequiredService<TelemetryClient>(); konstruktorinjektálás hívásával vagy használatával. Ez a lépés elindítja a és az TelemetryConfiguration automatikus gyűjtési modulok beállítását.

Az egyes alkalmazástípusokkal kapcsolatos konkrét utasításokat a következő szakaszok ismertetik.

.NET Core 3.0 feldolgozói szolgáltatásalkalmazás

A teljes példa itt van megosztva

  1. A .NET Core 3.0 letöltése és telepítése

  2. Hozzon létre egy új Worker Service-projektet Visual Studio projektsablon vagy parancssor használatávaldotnet new worker

  3. Telepítse a Microsoft.ApplicationInsights.WorkerService csomagot az alkalmazásra.

  4. Adja services.AddApplicationInsightsTelemetryWorkerService(); hozzá a CreateHostBuilder() metódust a Program.cs osztályban, ahogyan az alábbi példában is:

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureServices((hostContext, services) =>
            {
                services.AddHostedService<Worker>();
                services.AddApplicationInsightsTelemetryWorkerService();
            });
  1. Módosítsa a Worker.cs et az alábbi példának megfelelően.
    using Microsoft.ApplicationInsights;
    using Microsoft.ApplicationInsights.DataContracts;

    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;
        private TelemetryClient _telemetryClient;
        private static HttpClient _httpClient = new HttpClient();

        public Worker(ILogger<Worker> logger, TelemetryClient tc)
        {
            _logger = logger;
            _telemetryClient = tc;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);

                using (_telemetryClient.StartOperation<RequestTelemetry>("operation"))
                {
                    _logger.LogWarning("A sample warning message. By default, logs with severity Warning or higher is captured by Application Insights");
                    _logger.LogInformation("Calling bing.com");
                    var res = await _httpClient.GetAsync("https://bing.com");
                    _logger.LogInformation("Calling bing completed with status:" + res.StatusCode);
                    _telemetryClient.TrackEvent("Bing call event completed");
                }

                await Task.Delay(1000, stoppingToken);
            }
        }
    }
  1. Á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 rendszerkonfigurációs AddApplicationInsightsTelemetryWorkerService kulcsot. 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 átmásolta az alkalmazás appsettings.json gyökérmappába.

    {
        "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 vagy ApplicationInsights:InstrumentationKey

Például: SET ApplicationInsights:InstrumentationKey=putinstrumentationkeyhere VAGY SET APPINSIGHTS_INSTRUMENTATIONKEY=putinstrumentationkeyhere

A általában Web Jobs (Web Feladatok) beállítási kulcsként adja meg a Web Apps APPINSIGHTS_INSTRUMENTATIONKEY üzembe helyezett alkalmazásokhoz.

Megjegyzés

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

ASP.NET Core feladatok végrehajtása üzemeltetett szolgáltatásokkal

Ez a dokumentum azt ismerteti, hogyan hozhat létre háttérfeladatokat ASP.NET Core 2.1/2.2 alkalmazásban.

A teljes példa itt van megosztva

  1. Telepítse a Microsoft.ApplicationInsights.WorkerService csomagot az alkalmazásra.
  2. Adja services.AddApplicationInsightsTelemetryWorkerService(); hozzá a ConfigureServices() metódushoz az alábbi példában használt módon:
    public static async Task Main(string[] args)
    {
        var host = new HostBuilder()
            .ConfigureAppConfiguration((hostContext, config) =>
            {
                config.AddJsonFile("appsettings.json", optional: true);
            })
            .ConfigureServices((hostContext, services) =>
            {
                services.AddLogging();
                services.AddHostedService<TimedHostedService>();

                // instrumentation key is read automatically from appsettings.json
                services.AddApplicationInsightsTelemetryWorkerService();
            })
            .UseConsoleLifetime()
            .Build();

        using (host)
        {
            // Start the host
            await host.StartAsync();

            // Wait for the host to shutdown
            await host.WaitForShutdownAsync();
        }
    }

A következő kód tartalmazza a TimedHostedService háttérfeladat logikáját.

    using Microsoft.ApplicationInsights;
    using Microsoft.ApplicationInsights.DataContracts;

    public class TimedHostedService : IHostedService, IDisposable
    {
        private readonly ILogger _logger;
        private Timer _timer;
        private TelemetryClient _telemetryClient;
        private static HttpClient httpClient = new HttpClient();

        public TimedHostedService(ILogger<TimedHostedService> logger, TelemetryClient tc)
        {
            _logger = logger;
            this._telemetryClient = tc;
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("Timed Background Service is starting.");

            _timer = new Timer(DoWork, null, TimeSpan.Zero,
                TimeSpan.FromSeconds(1));

            return Task.CompletedTask;
        }

        private void DoWork(object state)
        {
            _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);

            using (_telemetryClient.StartOperation<RequestTelemetry>("operation"))
            {
                _logger.LogWarning("A sample warning message. By default, logs with severity Warning or higher is captured by Application Insights");
                _logger.LogInformation("Calling bing.com");
                var res = httpClient.GetAsync("https://bing.com").GetAwaiter().GetResult();
                _logger.LogInformation("Calling bing completed with status:" + res.StatusCode);
                _telemetryClient.TrackEvent("Bing call event completed");
            }
        }
    }
  1. Állítsa be a eszközkulcsot. Használja ugyanezt a appsettings.json fenti .NET Core 3.0 feldolgozói szolgáltatás példában.

.NET Core/.NET-keretrendszer-konzolalkalmazás

Ahogy a cikk elején említettük, az új csomaggal engedélyezhető az Application Elemzések telemetria akár egy normál konzolalkalmazásból is. Ez a csomag a ,, és ezért a .NET Core 2.0-s vagy újabb verziókban található konzolalkalmazások, NetStandard2.0 4.7.2-es vagy újabb .NET-keretrendszer használható.

A teljes példa itt van megosztva

  1. Telepítse a Microsoft.ApplicationInsights.WorkerService csomagot az alkalmazásra.

  2. Módosítsa a Program.cs fájl fájlját az alábbi példában látható módon.

    using Microsoft.ApplicationInsights;
    using Microsoft.ApplicationInsights.DataContracts;
    using Microsoft.Extensions.DependencyInjection;
    using Microsoft.Extensions.Logging;
    using System;
    using System.Net.Http;
    using System.Threading.Tasks;

    namespace WorkerSDKOnConsole
    {
        class Program
        {
            static async Task Main(string[] args)
            {
                // Create the DI container.
                IServiceCollection services = new ServiceCollection();

                // Being a regular console app, there is no appsettings.json or configuration providers enabled by default.
                // Hence instrumentation key and any changes to default logging level must be specified here.
                services.AddLogging(loggingBuilder => loggingBuilder.AddFilter<Microsoft.Extensions.Logging.ApplicationInsights.ApplicationInsightsLoggerProvider>("Category", LogLevel.Information));
                services.AddApplicationInsightsTelemetryWorkerService("instrumentationkeyhere");

                // Build ServiceProvider.
                IServiceProvider serviceProvider = services.BuildServiceProvider();

                // Obtain logger instance from DI.
                ILogger<Program> logger = serviceProvider.GetRequiredService<ILogger<Program>>();

                // Obtain TelemetryClient instance from DI, for additional manual tracking or to flush.
                var telemetryClient = serviceProvider.GetRequiredService<TelemetryClient>();

                var httpClient = new HttpClient();

                while (true) // This app runs indefinitely. replace with actual application termination logic.
                {
                    logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);

                    // Replace with a name which makes sense for this operation.
                    using (telemetryClient.StartOperation<RequestTelemetry>("operation"))
                    {
                        logger.LogWarning("A sample warning message. By default, logs with severity Warning or higher is captured by Application Insights");
                        logger.LogInformation("Calling bing.com");                    
                        var res = await httpClient.GetAsync("https://bing.com");
                        logger.LogInformation("Calling bing completed with status:" + res.StatusCode);
                        telemetryClient.TrackEvent("Bing call event completed");
                    }

                    await Task.Delay(1000);
                }

                // Explicitly call Flush() followed by sleep is required in Console Apps.
                // This is to ensure that even if application terminates, telemetry is sent to the back-end.
                telemetryClient.Flush();
                Task.Delay(5000).Wait();
            }
        }
    }

Ez a konzolalkalmazás szintén ugyanazt az alapértelmezett értéket használja, és a korábbi szakaszban található példákhoz hasonló módon TelemetryConfiguration szabható testre.

Az alkalmazás futtatása

Futtassa az alkalmazást. A fenti példamunkások másodpercenként http-hívást bing.com, és néhány naplót is kibocsátanak a ILogger használatával. Ezek a sorok a hívásába vannak csomagolva, amely egy művelet létrehozására használatos (ebben a példában StartOperation TelemetryClient RequestTelemetry "operation" (művelet) névvel). Az Elemzések gyűjti ezeket az ILogger-naplókat (alapértelmezés szerint figyelmeztetést vagy magasabb értéket) és függőségeket, és ezek a szülő-gyermek kapcsolattal lesznek RequestTelemetry korrelálva. A korreláció folyamatközi/hálózati határvonalakon is működik. Ha például a hívást egy másik monitorozási összetevőre hívják meg, akkor az is ezzel a szülővel lesz korrelálva.

Ez az egyéni művelet egy tipikus webalkalmazás bejövő webes kérésének RequestTelemetry megfelelője. Bár nem szükséges műveletet használni, megfelel a legjobban az Application Elemzések korrelációs adatmodellnek, amely szülőműveletként viselkedik, és a feldolgozói iterációban létrehozott összes telemetriát logikailag ugyanabba a műveletbe tartozóként RequestTelemetry kezeli. Ez a módszer azt is biztosítja, hogy az összes létrehozott (automatikus és manuális) telemetria ugyanaz operation_id legyen. Mivel a mintavételezés alapja, a mintavételezési algoritmus egyetlen iterációban tartja vagy eldobja az összes operation_id telemetriát.

Az alábbi lista az Application Elemzések.

Élő metrikák

Az élő metrikák segítségével gyorsan ellenőrizheti, hogy az alkalmazás-Elemzések megfelelően van-e konfigurálva. Bár eltarthat néhány percig, amíg a telemetria megjelenik a portálon és az elemzésekben, az Élő metrikák közel valós időben mutatják 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, a nyomkövetéseket stb.

ILogger-naplók

A rendszer automatikusan rögzíti a súlyosságú vagy nagyobb súlyosságú ILogger Warning naplókat. Kövesse az ILogger-dokumentumokban az Alkalmazásnaplók által rögzített naplózási szintek Elemzések.

Függőségek

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

EventCounter

EventCounterCollectionModule alapértelmezés szerint engedélyezve van, és a .NET Core 3.0-alkalmazásoktól származó számlálók alapértelmezett készletét gyűjti össze. Az EventCounter oktatóanyag az összegyűjtött számlálók alapértelmezett készletét sorolja fel. Emellett útmutatást is tartalmaz a lista testreszabásához.

További telemetria manuális nyomon követése

Bár az SDK automatikusan gyűjti a telemetriát a fent leírtak szerint, a legtöbb esetben a felhasználónak további telemetriát kell küldenie az Application Elemzések szolgáltatásnak. A további telemetria követésének ajánlott módja a egy példányának beszerzése a függőséginjektálásból, majd az egyik támogatott TelemetryClient TrackXXX() API-metódus hívása. Egy másik tipikus eset a műveletek egyéni nyomon követése. Ezt a megközelítést a fenti feldolgozói példák mutatják be.

Az Application Elemzések SDK konfigurálása

A feldolgozói szolgáltatás SDK által használt alapértelmezett érték hasonló az ASP.NET- vagy ASP.NET Core-alkalmazásokban használt automatikus konfigurációhoz, kivéve a telemetriai adatok a használatával való gazdagításához használt TelemetryConfiguration TelemetryInitializereket. HttpContext

Az Application Elemzések SDK for Worker Service testre szabhatja az alapértelmezett konfigurációt. Előfordulhat, hogy az Application Elemzések ASP.NET Core SDK felhasználói ismerik a konfigurációk ASP.NET Core beépített függőséginjektálás használatával. A WorkerService SDK is hasonló alapelveken alapul. A szakaszban szinte az összes konfigurációs módosítást a megfelelő metódusok hívásával kell eltenni a(nak) ConfigureServices() IServiceCollection területen, az alábbiakban részletezett módon.

Megjegyzés

Az SDK használata során a konfiguráció módosítása nem támogatott, és a TelemetryConfiguration.Active módosítások nem jelennek meg.

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 AddApplicationInsightsTelemetryWorkerService módosíthat:

using Microsoft.ApplicationInsights.WorkerService;

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

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

Vegye figyelembe, hogy ebben az SDK-ban a névtérben van, nem pedig a ASP.NET Core ApplicationInsightsServiceOptions Microsoft.ApplicationInsights.WorkerService Microsoft.ApplicationInsights.AspNetCore.Extensions SDK-ban.

A gyakran használt beállításai ApplicationInsightsServiceOptions

Beállítás Leírás Alapértelmezett
EnableQuickPulseMetricStream LiveMetrics funkció engedélyezése/letiltása true
EnableAdaptiveSampling (EnableAdaptiveSampling) Adaptív mintavételezés engedélyezése/letiltása true
EnableHeartbeat (A-ábra engedélyezése) A Szívverések engedélyezése/letiltása funkció, 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 .NET-verziót, Azure-környezetinformációkat, 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
EnableDiagnosticsTelemetryModule Engedélyezze/tiltsa DiagnosticsTelemetryModule le. 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 ApplicationInsightsServiceOptions a konfigurálható beállításokat láthatja.

Mintavételezés

Az Application Elemzések SDK for Worker Service támogatja a rögzített sebességet és az adaptív mintavételezést is. Az adaptív mintavételezés alapértelmezés szerint engedélyezve van. A mintavételezés az EnableAdaptiveSampling ApplicationInsightsServiceOptions beállításával tiltható le

További mintavételezési beállítások konfigurálásán az alábbi példa használható.

using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.WorkerService;

public void ConfigureServices(IServiceCollection services)
{
    // ...

    var aiOptions = new ApplicationInsightsServiceOptions();
    
    // Disable adaptive sampling.
    aiOptions.EnableAdaptiveSampling = false;
    services.AddApplicationInsightsTelemetryWorkerService(aiOptions);

    // Add Adaptive Sampling with custom settings.
    // the following adds adaptive sampling with 15 items per sec.
    services.Configure<TelemetryConfiguration>((telemetryConfig) =>
        {
            var builder = telemetryConfig.DefaultTelemetrySink.TelemetryProcessorChainBuilder;
            builder.UseAdaptiveSampling(maxTelemetryItemsPerSecond: 15);
            builder.Build();
        });
    //...
}

További információt a Mintavételezés dokumentumban talál.

Telemetriainitializálók hozzáadása

Telemetria-inicializálókat akkor használjon, ha minden telemetriával együtt küldött tulajdonságokat szeretne definiálni.

Ha újat TelemetryInitializer ad DependencyInjection hozzá a tárolóhoz, az SDK automatikusan hozzáadja őket az TelemetryConfiguration -hoz.

    using Microsoft.ApplicationInsights.Extensibility;

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

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

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

   public void ConfigureServices(IServiceCollection services)
   {
        services.AddApplicationInsightsTelemetryWorkerService();
        // 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 speciális szűrési forgatókönyvekben telemetriafeldolgozók használatával közvetlenebbül szabályozható, hogy mit tartalmaz vagy zár ki az Application Elemzések szolgáltatásnak küldött telemetria. Használja az alábbi példát.

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddApplicationInsightsTelemetryWorkerService();
        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 telemetriai adatokat adott számítási feladatokról anélkül, hogy manuális nyomkövetésre lenne szükség.

Az alábbi automatikus gyűjtési modulok alapértelmezés szerint engedélyezve vannak. 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.

  • DependencyTrackingTelemetryModule
  • PerformanceCollectorModule
  • QuickPulseTelemetryModule
  • AppServicesHeartbeatTelemetryModule – (Jelenleg probléma van ezzel a telemetriai modullal. Ideiglenes áthidaló megoldásért tekintse meg az 1689-es GitHubcímű cikkben.)
  • AzureInstanceMetadataTelemetryModule

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.Extensibility.PerfCounterCollector.QuickPulse;
    using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector;

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddApplicationInsightsTelemetryWorkerService();

            // The following configures QuickPulseTelemetryModule.
            // Similarly, any other default modules can be configured.
            services.ConfigureTelemetryModule<QuickPulseTelemetryModule>((module, o) =>
            {
                module.AuthenticationApiKey = "keyhere";
            });

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

Telemetriacsatorna konfigurálása

Az alapértelmezett csatorna a ServerTelemetryChannel . Az alábbi példában láthatóak szerint felülírhatja.

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

Telemetria dinamikus letiltása

Ha feltételesen és dinamikusan szeretné letiltani ASP.NET Core telemetriát, feloldhatja a példányt egy 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.AddApplicationInsightsTelemetryWorkerService();
    }

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

Gyakori kérdések

Hogyan követem nyomon az automatikusan nem gyűjtött telemetriai adatokat?

Szerezze be a egy TelemetryClient példányát konstruktorinjektálással, és hívja meg rajta a TrackXXX() szükséges metódust. Nem javasoljuk új példányok TelemetryClient létrehozását. A egyetlen 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 elkülönül TelemetryClient a többi telemetriai adattól.

Használhatom az Visual Studio IDE-t az alkalmazás-Elemzések egy Worker Service-projekthez?

Visual Studio Az IDE-fejlesztés jelenleg csak a ASP.NET/ASP.NET Core alkalmazások esetében támogatott. Ez a dokumentum akkor frissül, Visual Studio támogatja a feldolgozói szolgáltatás alkalmazásait.

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 4.x ASP.NET támogatja.

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

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

  • A teljesítményszámlálók csak a Windows támogatottak, kivéve az élő metrikákban látható folyamat CPU-/memóriahasználatot.
  • Annak ellenére, hogy 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. E korlátozás miatt a telemetria ideiglenes hálózati vagy kiszolgálói problémák miatt veszhet el. 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.AddApplicationInsightsTelemetryWorkerService();
    }

Mintaalkalmazások

.NET Core-konzolalkalmazás Akkor használja ezt a mintát, ha .NET Core (2.0 vagy újabb) vagy .NET-keretrendszer (4.7.2 vagy újabb) verzióban írt konzolalkalmazást használ

ASP.NET Core feladatok a HostedServices szolgáltatásokkal Akkor használja ezt a mintát, ha a 2.1/2.2-es ASP.NET Core van használatban, és háttérfeladatokat hoz létre az itt látható hivatalos útmutatás szerint

.NET Core 3.0 feldolgozó szolgáltatás Akkor használja ezt a mintát, ha .NET Core 3.0 feldolgozói szolgáltatás alkalmazással dolgozik az itt hivatalos útmutatás szerint

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