Application Insights feldolgozószolgáltatás-alkalmazásokhoz (nem HTTP-alkalmazásokhoz)

Cikk
11/05/2024

Az Application Insights SDK for Worker Service egy új SDK, amely leginkább olyan nem HTTP-alapú számítási feladatokhoz használható, mint az üzenetkezelés, a háttérfeladatok és a konzolalkalmazások. 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 az Application Insights-csomagok használata ASP.NET vagy ASP.NET Core-alkalmazásokhoz nem támogatott.

Feljegyzés

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

Az új SDK önmagában nem végez telemetriai gyűjtést. Ehelyett más jól ismert Application Insights-automatikus gyűjtőket hoz létre, például a DependencyCollectort, a PerfCounterCollectort és az ApplicationInsightsLoggingProvidert. 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 Insights SDK for Worker Service a http-n kívüli alkalmazásokhoz ideális, függetlenül attól, hogy hol és hogyan futnak. Ha az alkalmazás fut, és hálózati kapcsolattal rendelkezik az Azure-hoz, telemetriai adatok gyűjthetők. Az Application Insights monitorozása mindenhol támogatott, ahol a .NET Core 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 Application Insights-kapcsolati sztring kell rendelkeznie. Ez a sztring szükséges ahhoz, hogy telemetriát küldjön az Application Insightsnak. Ha új Application Insights-erőforrást kell létrehoznia egy kapcsolati sztring beszerzéséhez, tekintse meg a kapcsolati 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 Insights SDK használata feldolgozói szolgáltatáshoz

Telepítse a Microsoft.ApplicationInsights.WorkerService csomagot az alkalmazásra. 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.ApplicationInsights.WorkerService csomagot 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.ApplicationInsights.WorkerService csomagot az alkalmazásra.

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 az Application Insights telemetriai adatainak engedélyezésére használható 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.ApplicationInsights.WorkerService csomagot az alkalmazásra.

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 Application Insights ezeket az ILogger-naplókat gyűjti össze alapértelmezés szerint figyelmeztetési vagy magasabb 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 Application Insights korrelációs adatmodelljének. 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 Application Insights által automatikusan gyűjtött teljes telemetriát sorolják fel.

Élő metrikák

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

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 az Application Insights számára az összes Information napló és súlyosabb napló rögzítését.

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

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

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

További információkért kövesse az ILogger-dokumentumokat az Application Insights á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 Application Insights függőségkövetése című cikk 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 automatikusan gyűjti a telemetriát a magyarázatnak megfelelően, a legtöbb esetben más telemetriát kell küldenie az Application Insightsnak. 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 Application Insights 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 Application Insights SDK for Worker Service testreszabásával módosíthatja az alapértelmezett konfigurációt. Előfordulhat, hogy az Application Insights 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 ApplicationInsightsServiceOptions 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 live metrics (also known as QuickPulse).
    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 Insights 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 ApplicationInsightsServiceOptions beállításával EnableAdaptiveSampling tiltható 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 Application Insightsnak küldött telemetriai adatok között, illetve azok kivételével. 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 Application Insights 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 Application Insights 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élyezhetim az Application Insights monitorozását olyan eszközökkel, mint az Azure Monitor Application Insights Agent (korábbi nevén Status Monitor v2)?

Szám Az Azure Monitor Application Insights 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 processzor-/memóriafolyamatokat.

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.

Megosztás a következőn keresztül:

Application Insights feldolgozószolgáltatás-alkalmazásokhoz (nem HTTP-alkalmazásokhoz)

Támogatott esetek

Előfeltételek

Az Application Insights 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ő metrikák

ILogger-naplók

Függőségek

EventCounter

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

Az Application Insights SDK konfigurálása

Az ApplicationInsightsServiceOptions 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 Application Insights munkavégző szolgáltatás projektbe való előkészítéséhez?

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

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

Mintaalkalmazások

Nyílt forráskódú SDK

Következő lépések

Visszajelzés

További források