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

Cikk
01/31/2024

Az Application Elemzések SDK for Worker Service egy új SDK, amely leginkább a NEM HTTP-alapú számítási feladatokhoz, például az üzenetkezeléshez, a háttérfeladatokhoz és a konzolalkalmazásokhoz használható. Az ilyen típusú alkalmazások nem rendelkeznek a bejövő HTTP-kérések fogalmával, például egy hagyományos ASP.NET/ASP.NET Core-webalkalmazással. Ezért nem támogatott az Alkalmazás Elemzések-csomagok használata ASP.NET vagy ASP.NET Core-alkalmazásokhoz.

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 új SDK önmagában nem végez telemetriai gyűjtést. Ehelyett más jól ismert alkalmazás-Elemzések automatikus gyűjtőket hoz létre, mint például a DependencyCollector, a PerfCounterCollector és az Application Elemzések LoggingProvider. Ez az SDK bővítménymetóciókat IServiceCollection tesz elérhetővé a telemetriai gyűjtemény engedélyezéséhez és konfigurálásához.

Támogatott esetek

Az Application Elemzések SDK for Worker Service a legjobban nem HTTP-alkalmazásokhoz használható, 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. Ez a csomag használható az újonnan bevezetett .NET Core feldolgozói szolgáltatásban, a ASP.NET Core háttérfeladataiban, valamint az olyan konzolalkalmazásokban, mint a .NET Core és a .NET-keretrendszer.

Előfeltételek

Érvényes alkalmazás Elemzések kapcsolati sztring kell rendelkeznie. Ez a sztring szükséges ahhoz, hogy telemetriát küldjön az Application Elemzések. Ha új alkalmazás-Elemzések erőforrást kell létrehoznia egy kapcsolati sztring beszerzéséhez, tekintse meg a Csatlakozás ion-sztringeket.

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.

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

Telepítse a Microsoft.Application Elemzések. WorkerService-csomag az alkalmazáshoz. Az alábbi kódrészlet azokat a módosításokat mutatja be, amelyeket hozzá kell adni a projekt fájljához .csproj :
```
    <ItemGroup>
        <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.22.0" />
    </ItemGroup>
```
Konfigurálja a kapcsolati sztring a APPLICATIONINSIGHTS_CONNECTION_STRING környezeti változóban vagy a konfigurációban (appsettings.json).
Lekérhet egy példányt vagy TelemetryClient példányt ILogger a Függőséginjektálás (DI) tárolóból a konstruktorinjektálás meghívásával serviceProvider.GetRequiredService<TelemetryClient>(); vagy használatával. Ez a lépés aktiválja a modulok beállítását TelemetryConfiguration és automatikus gyűjtését.

Az egyes alkalmazástípusokra vonatkozó konkrét utasításokat a következő szakaszok ismertetik.

.NET Core Worker Service-alkalmazás

A teljes példa meg van osztva a NuGet webhelyén.

Töltse le és telepítse a .NET SDK-t.
Hozzon létre egy új Worker Service-projektet egy Új Visual Studio-projektsablon vagy a parancssor dotnet new workerhasználatával.
Adja hozzá a Microsoft.Application Elemzések. WorkerService-csomag az alkalmazáshoz.

Adja hozzá services.AddApplicationInsightsTelemetryWorkerService(); a CreateHostBuilder() metódushoz az Program.cs osztályban, ahogy ebben a példában is látható:

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureServices((hostContext, services) =>
            {
                services.AddHostedService<Worker>();
                services.AddApplicationInsightsTelemetryWorkerService();
            });

Módosítsa a Worker.cs következő példában leírtak szerint:

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

Állítsa be a kapcsolati sztring.

Feljegyzés

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.
```
    {
        "ApplicationInsights":
        {
            "ConnectionString" : "InstrumentationKey=00000000-0000-0000-0000-000000000000;"
        },
        "Logging":
        {
            "LogLevel":
            {
                "Default": "Warning"
            }
        }
    }
```

Másik lehetőségként adja meg a kapcsolati sztring a APPLICATIONINSIGHTS_CONNECTION_STRING környezeti változóban.

APPLICATIONINSIGHTS_CONNECTION_STRING Általában webfeladatként adja meg a webalkalmazásokban üzembe helyezett alkalmazások kapcsolati sztring.

Feljegyzés

A kódban megadott kapcsolati sztring elsőbbséget élvez a környezeti változóval APPLICATIONINSIGHTS_CONNECTION_STRINGszemben, ami elsőbbséget élvez a többi beállítással szemben.

ASP.NET Alapvető háttérfeladatok üzemeltetett szolgáltatásokkal

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

A teljes példa ezen a GitHub-oldalon van megosztva.

Telepítse a Microsoft.Application Elemzések. WorkerService-csomag az alkalmazáshoz.

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

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

                // connection string 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 a TimedHostedServiceháttérfeladat logikájának helyéhez tartozik:

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

Állítsa be a kapcsolati sztring. Használja ugyanezt appsettings.json az előző .NET worker service-példában is.

.NET Core/.NET-keretrendszer konzolalkalmazás

Ahogy a cikk elején említettük, az új csomag lehetővé teszi az alkalmazás Elemzések telemetria használatát még egy normál konzolalkalmazásból is. Ez a csomag a célokat célozzanetstandard2.0, így a .NET Core-beli vagy újabb konzolalkalmazásokhoz, valamint .NET-keretrendszer vagy újabb verziókhoz is használható.

A teljes példa ezen a GitHub-oldalon van megosztva.

Telepítse a Microsoft.Application Elemzések. WorkerService-csomag az alkalmazáshoz.

Módosítsa Program.cs az alábbi példában látható módon:

    using Microsoft.ApplicationInsights;
    using Microsoft.ApplicationInsights.DataContracts;
    using Microsoft.ApplicationInsights.WorkerService;
    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/ connection string 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((ApplicationInsightsServiceOptions options) => options.ConnectionString = "InstrumentationKey=<instrumentation key here>");

                // To pass a connection string
                // - aiserviceoptions must be created
                // - set connectionstring on it
                // - pass it to AddApplicationInsightsTelemetryWorkerService()

                // 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 is ugyanazt az alapértelmezettet TelemetryConfigurationhasználja. Ugyanúgy testre szabható, mint a korábbi szakaszokban szereplő példák.

Az alkalmazás futtatása

Futtassa az alkalmazást. Az előző példákban szereplő feldolgozók másodpercenként HTTP-hívást kezdeményeznek bing.com, és néhány naplót is kibocsátanak a használatával ILogger. Ezek a sorok a StartOperation művelet létrehozásához használt hívásba TelemetryClientvannak csomagolva. Ebben a példában RequestTelemetry a neve "művelet".

Az alkalmazás Elemzések összegyűjti ezeket az ILogger-naplókat, alapértelmezés szerint figyelmeztetés vagy annál nagyobb súlyossággal, valamint függőségekkel. Egy szülő-gyermek kapcsolattal vannak összefüggésben RequestTelemetry . A korreláció folyamat-/hálózathatárokon is működik. Ha például a hívás egy másik figyelt összetevőhöz lett intézve, az is ehhez a szülőhöz van összefüggésben.

Ez az RequestTelemetry egyéni művelet úgy tekinthető, mint egy tipikus webalkalmazás bejövő webes kérésének megfelelője. Nem szükséges műveletet használni, de a legjobban megfelel az alkalmazás Elemzések korrelációs adatmodellnek. RequestTelemetry szülőműveletként működik, és a munkavégző iterációban generált összes telemetria logikailag ugyanahhoz a művelethez tartozik.

Ez a megközelítés azt is biztosítja, hogy az összes létrehozott telemetria automatikusan és manuálisan is ugyanaz operation_idlegyen. Mivel a mintavételezés alapja operation_id, a mintavételezési algoritmus megtartja vagy elveti az összes telemetriát egyetlen iterációból.

Az alábbi szakaszok az Alkalmazás Elemzések által automatikusan gyűjtött teljes telemetriát sorolják fel.

É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. Bár eltarthat néhány percig, amíg a telemetria megjelenik a portálon és az elemzésben, 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

A figyelmeztetés vagy nagyobb súlyosságú naplók ILogger automatikusan rögzítésre kerülnek. A viselkedés módosításához explicit módon bírálja felül a szolgáltató ApplicationInsightsnaplózási konfigurációját az alábbi kódban látható módon. Az alábbi konfiguráció lehetővé teszi, hogy az alkalmazás Elemzések rögzítse az összes Information naplót és a súlyosabb naplókat.

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

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ókért kövesse az ILogger-dokumentumokat az alkalmazás Elemzések által rögzített naplószintek testreszabásához.

Függőségek

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

EventCounter

EventCounterCollectionModulealapértelmezés szerint engedélyezve van, és egy alapértelmezett számlálókészletet gyűjt a .NET-alkalmazásokból. Az EventCounter oktatóanyag felsorolja az összegyűjtött számlálók alapértelmezett készletét. Emellett útmutatást is tartalmaz a lista testreszabásához.

Egyéb telemetriai adatok manuális nyomon követése

Bár az SDK a magyarázatnak megfelelően automatikusan gyűjti a telemetriát, a legtöbb esetben más telemetriát kell küldenie az Alkalmazás Elemzések. Az egyéb telemetriai adatok követésének ajánlott módja a függőséginjektálásból származó példány lekérése TelemetryClient , majd a támogatott TrackXXX()API-metódusok egyikének meghívása. Egy másik tipikus használati eset a műveletek egyéni nyomon követése. Ezt a megközelítést az előző feldolgozói példák szemléltetik.

Az alkalmazás Elemzések SDK konfigurálása

A Worker Service SDK által használt alapértelmezett TelemetryConfiguration beállítás hasonló a ASP.NET vagy ASP.NET Core-alkalmazásokban használt automatikus konfigurációhoz, a telemetriai HttpContextadatok dúsításához használt telemetriai inicializálókkal együtt.

Az alapértelmezett konfiguráció módosításához testre szabhatja az alkalmazás Elemzések feldolgozói szolgáltatáshoz készült SDK-t. Előfordulhat, hogy az alkalmazás Elemzések ASP.NET Core SDK felhasználói ismerik a konfiguráció módosítását ASP.NET Core beépített függőséginjektálásával. A Worker Service SDK is hasonló elveken alapul. Végezze el a szakasz szinte összes konfigurációs módosítását a ConfigureServices() megfelelő metódusok IServiceCollectionmeghívásával a következő szakaszban leírtak szerint.

Feljegyzés

Ha ezt az SDK-t használja, a konfiguráció módosítással TelemetryConfiguration.Active történő módosítása nem támogatott, és a módosítások nem jelennek meg.

Az Application Elemzések ServiceOptions használata

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

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

Ebben ApplicationInsightsServiceOptions az SDK-ban a névtérben Microsoft.ApplicationInsights.WorkerService van, szemben Microsoft.ApplicationInsights.AspNetCore.Extensions a ASP.NET Core SDK-val.

Az alábbi táblázat a gyakran használt beállításokat sorolja fel.ApplicationInsightsServiceOptions

Beállítás	Leírás	Alapértelmezett
EnableQuickPulseMetricStream	Az Élő metrikák funkció engedélyezése/letiltása.	Igaz
EnableAdaptiveSampling	Adaptív mintavételezés engedélyezése/letiltása.	Igaz
EnableHeartbeat	Engedélyezze/tiltsa le a Szívverés funkciót, amely rendszeres időközönként (alapértelmezés szerint 15 perc) küld egy "HeartBeatState" nevű egyéni metrikát, amely információkat tartalmaz a futtatókörnyezetről, például a .NET-verzióról és az Azure-környezetről, ha van ilyen.	Igaz
AddAutoCollectedMetricExtractor	Engedélyezze/tiltsa le az AutoCollectedMetrics-kinyerőt, amely egy telemetriai feldolgozó, amely előre összesített metrikákat küld a kérelmekről/függőségekről a mintavételezés előtt.	Igaz
EnableDiagnosticsTelemetryModule	Engedélyezés/letiltás `DiagnosticsTelemetryModule`. Ha letiltja ezt a beállítást, a rendszer figyelmen kívül hagyja a következő beállításokat: `EnableHeartbeat`, `EnableAzureInstanceMetadataTelemetryModule`és `EnableAppServicesHeartbeatTelemetryModule`.	Igaz

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

Mintavételezés

Az application Elemzések SDK for Worker Service támogatja a rögzített sebességű mintavételezést é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 Application Elemzések ServiceOptions lehetőséggel EnableAdaptiveSamplingtiltható le.

Más mintavételezési beállítások konfigurálásához használja az alábbi példát:

using Microsoft.ApplicationInsights.AspNetCore.Extensions;
using Microsoft.ApplicationInsights.Extensibility;

var builder = WebApplication.CreateBuilder(args);

builder.Services.Configure<TelemetryConfiguration>(telemetryConfiguration =>
{
   var telemetryProcessorChainBuilder = telemetryConfiguration.DefaultTelemetrySink.TelemetryProcessorChainBuilder;

   // Using adaptive sampling
   telemetryProcessorChainBuilder.UseAdaptiveSampling(maxTelemetryItemsPerSecond: 5);

   // Alternately, the following configures adaptive sampling with 5 items per second, and also excludes DependencyTelemetry from being subject to sampling:
   // telemetryProcessorChainBuilder.UseAdaptiveSampling(maxTelemetryItemsPerSecond:5, excludedTypes: "Dependency");
});

builder.Services.AddApplicationInsightsTelemetry(new ApplicationInsightsServiceOptions
{
   EnableAdaptiveSampling = false,
});

var app = builder.Build();

További információkért lásd a mintavételezési dokumentumot.

Telemetriai inicializálók hozzáadása

Telemetria-inicializálókat akkor használjon, ha az összes telemetriával küldött tulajdonságokat szeretné meghatározni.

Adjon hozzá új telemetriai inicializálót a DependencyInjection tárolóhoz, és az SDK automatikusan hozzáadja őket a tárolóhoz TelemetryConfiguration.

    using Microsoft.ApplicationInsights.Extensibility;

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

Telemetriai inicializálók 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 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é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, hogy közvetlenebb vezérlést biztosíthasson az Alkalmazás Elemzések küldött telemetriai adatok között szereplő vagy abból kizárt adatok felett. Használja a következő példát:

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddApplicationInsightsTelemetryWorkerService();
        services.AddApplicationInsightsTelemetryProcessor<MyFirstCustomTelemetryProcessor>();
        // If you have more processors:
        services.AddApplicationInsightsTelemetryProcessor<MySecondCustomTelemetryProcessor>();
    }

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

Az alkalmazás Elemzések telemetriai modulokkal automatikusan gyűjt telemetriát adott számítási feladatokról manuális nyomon követés nélkül.

Alapértelmezés szerint az alábbi automatikus gyűjtési modulok 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.

DependencyTrackingTelemetryModule
PerformanceCollectorModule
QuickPulseTelemetryModule
AppServicesHeartbeatTelemetryModule (Jelenleg ez a telemetriai modullal kapcsolatos probléma merült fel. Ideiglenes kerülő megoldásért tekintse meg a GitHub 1689-es problémáját.)
AzureInstanceMetadataTelemetryModule

Az alapértelmezett telemetriai modul 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.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);
            }
    }

A telemetriai csatorna konfigurálása

Az alapértelmezett csatorna a következő ServerTelemetryChannel: . Felülbírálhatja a következő példában látható módon:

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

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

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

Gyakori kérdések

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

Melyik csomagot érdemes használni?

.NET Core-alkalmazásforgatókönyv	Csomag
HostedServices nélkül	WorkerService
HostedServices szolgáltatásokkal	AspNetCore (nem WorkerService)
A HostedServices szolgáltatásokkal csak a HostedServices monitorozása	WorkerService (ritka forgatókönyv)

A .NET Core-alkalmazásokban az AspNetCore-csomaggal rendelkező HostedServicesbe a TelemetryClient injektálható?

Igen. A konfiguráció meg lesz osztva a webalkalmazás többi részével.

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 új TelemetryClient példányok létrehozását. A tárolóban DependencyInjection már regisztrálva van egy egyszeri példányTelemetryClient, amely a többi telemetriával osztozikTelemetryConfiguration. Új TelemetryClient példány létrehozása csak akkor javasolt, ha olyan konfigurációra van szüksége, amely eltér a többi telemetriától.

Használhatom a Visual Studio IDE-t az alkalmazás Elemzések munkavégző szolgáltatás projektbe való előkészítéséhez?

A Visual Studio IDE előkészítés jelenleg csak ASP.NET/ASP.NET Core-alkalmazások esetében támogatott. Ez a dokumentum frissül, amikor a Visual Studio támogatja a Worker Service-alkalmazások előkészítésé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)?

Szám Az Azure Monitor Application Elemzések Agent jelenleg csak a .NET-et támogatja.

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:

A teljesítményszámlálók csak a Windowsban támogatottak, kivéve az élő metrikákban megjelenített folyamat CPU-ját/memóriáját.

Annak ellenére ServerTelemetryChannel , hogy alapértelmezés szerint engedélyezve van, ha az alkalmazás Linuxon vagy macOS rendszeren fut, a csatorna nem hoz létre automatikusan helyi tárolómappát a telemetriai adatok ideiglenes megőrzéséhez hálózati problémák esetén. A korlátozás miatt a telemetriai adatok elvesznek, ha ideiglenes hálózati vagy kiszolgálói problémák merülnek fel. A probléma megoldásához konfiguráljon egy helyi mappát a csatornához:

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: Ezt a mintát akkor használja, ha .NET Core(2.0 vagy újabb) vagy .NET-keretrendszer (4.7.2 vagy újabb) nyelven írt konzolalkalmazást használ.

ASP.NET Alapvető háttérfeladatok a HostedServices szolgáltatással: Ezt a mintát akkor használja, ha ASP.NET Core-ban van, és a hivatalos útmutatásnak megfelelően hozza létre a háttérfeladatokat.

.NET Core Worker Service: Ezt a mintát akkor használja, ha a hivatalos útmutatásnak megfelelően .NET Worker Service-alkalmazással rendelkezik.

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.

Következő lépések

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.
További függőségek nyomon követése nem automatikusan nyomon követve.
Az automatikusan gyűjtött telemetriai adatok bővítése vagy szűrése.
Függőséginjektálás a ASP.NET Core-ban.

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

Támogatott esetek

Előfeltételek

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

.NET Core Worker Service-alkalmazás

ASP.NET Alapvető háttérfeladatok üzemeltetett szolgáltatásokkal

.NET Core/.NET-keretrendszer konzolalkalmazás

Az alkalmazás futtatása

Élő metrikaadatok

ILogger-naplók

Függőségek

EventCounter

Egyéb telemetriai adatok manuális nyomon követése

Az alkalmazás Elemzések SDK konfigurálása

Az Application Elemzések ServiceOptions használata

Mintavételezés

Telemetriai inicializálók hozzáadása

Telemetriai inicializálók eltávolítása

Telemetriai processzorok hozzáadása

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

A telemetriai csatorna konfigurálása

Telemetria dinamikus letiltása

Gyakori kérdések

Melyik csomagot érdemes használni?

A .NET Core-alkalmazásokban az AspNetCore-csomaggal rendelkező HostedServicesbe a TelemetryClient injektálható?

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

Használhatom a Visual Studio IDE-t az alkalmazás Elemzések munkavégző szolgáltatás projektbe való előkészítéséhez?

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)?

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

Mintaalkalmazások

Nyílt forráskódú SDK

Következő lépések

További források