Application Insights pro aplikace pracovních služeb (aplikace jiné než HTTP)

2025-05-24

Sada Application Insights SDK pro pracovní službu je nová sada SDK, která je nejvhodnější pro úlohy mimo PROTOKOL HTTP, jako jsou zasílání zpráv, úlohy na pozadí a konzolové aplikace. Tyto typy aplikací nemají představu o příchozím požadavku HTTP, jako je tradiční webová aplikace ASP.NET/ASP.NET Core. Z tohoto důvodu se nepodporuje použití balíčků Application Insights pro ASP.NET nebo ASP.NET Core .

Upozornění

Pro nové aplikace nebo zákazníky doporučujeme Azure Monitor OpenTelemetry Distro pro podporu Azure Monitor Application Insights. Distribuce OpenTelemetry služby Azure Monitor poskytuje podobné funkce a prostředí jako sada Application Insights SDK. Ze sady Application Insights SDK je možné migrovat pomocí průvodců migrací pro .NET, Node.js a Python, ale stále pracujeme na přidání několika dalších funkcí pro zpětnou kompatibilitu.

Nová sada SDK sama o sobě neprovádí žádnou kolekci telemetrie. Místo toho přináší další dobře známé automatické kolektory Application Insights, jako je DependencyCollector, PerfCounterCollector a ApplicationInsightsLoggingProvider. Tento SDK zpřístupňuje metody rozšíření na IServiceCollection pro povolení a konfiguraci shromažďování telemetrie.

Podporované scénáře

Sada Application Insights SDK pro Worker Service je nejvhodnější pro ne-HTTP aplikace bez ohledu na to, kde nebo jak běží. Pokud je vaše aplikace spuštěná a má síťové připojení k Azure, můžete shromažďovat telemetrická data. Monitorování Application Insights se podporuje všude, kde se podporuje .NET Core. Tento balíček lze použít v nově zavedené pracovní službě .NET Core, úlohách na pozadí v ASP.NET Core a konzolových aplikacích, jako jsou .NET Core a .NET Framework.

Požadavky

Musíte mít platný připojovací řetězec Application Insights. Tento řetězec se vyžaduje k odeslání jakékoli telemetrie do Application Insights. Pokud potřebujete vytvořit nový prostředek Application Insights, abyste získali připojovací řetězec, přečtěte si téma Připojovací řetězce.

Poznámka:

Podpora příjmu dat založeného na instrumentačním klíči skončí 31. března 2025. Příjem klíčů instrumentace bude dál fungovat, ale už nebudeme poskytovat aktualizace ani podporu pro tuto funkci. Přechod na připojovací řetězec, abyste mohli využívat nové funkce.

Použití sady Application Insights SDK pro pracovní službu

Nainstalujte do aplikace balíček Microsoft.ApplicationInsights.WorkerService . Následující fragment kódu ukazuje změny, které je potřeba přidat do souboru projektu .csproj :
```
    <ItemGroup>
        <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.22.0" />
    </ItemGroup>
```
Nakonfigurujte připojovací řetězec v proměnné prostředí APPLICATIONINSIGHTS_CONNECTION_STRING nebo v konfiguraci appsettings.json.
Načtěte instanci ILogger nebo instanci TelemetryClient z kontejneru pro injektování závislostí (DI) voláním serviceProvider.GetRequiredService<TelemetryClient>(); metody nebo použitím injektování konstruktoru. Tento krok aktivuje nastavení modulů TelemetryConfiguration a autocollection.

Konkrétní pokyny pro každý typ aplikace jsou popsány v následujících částech.

Aplikace .NET Core Worker Service

Úplný příklad se sdílí na webu NuGet.

Stáhněte a nainstalujte sadu .NET SDK.
Vytvořte nový projekt Služby pracovních procesů pomocí nové šablony projektu sady Visual Studio nebo příkazového řádku dotnet new worker.
Přidejte do aplikace balíček Microsoft.ApplicationInsights.WorkerService .

Přidejte services.AddApplicationInsightsTelemetryWorkerService(); do metody CreateHostBuilder() ve třídě Program.cs, jak je znázorněno v tomto případě:

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

Upravte Worker.cs podle následujícího příkladu:

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

Nastavte připojovací řetězec.

Poznámka:

Doporučujeme zadat připojovací řetězec v konfiguraci. Následující ukázka kódu ukazuje, jak zadat připojovací řetězec v appsettings.json. Během publikování se ujistěte, že appsettings.json se zkopíruje do kořenové složky aplikace.
```
    {
        "ApplicationInsights":
        {
            "ConnectionString" : "InstrumentationKey=00000000-0000-0000-0000-000000000000;"
        },
        "Logging":
        {
            "LogLevel":
            {
                "Default": "Warning"
            }
        }
    }
```

Případně zadejte připojovací řetězec do proměnné prostředí APPLICATIONINSIGHTS_CONNECTION_STRING.

APPLICATIONINSIGHTS_CONNECTION_STRING Obvykle určuje připojovací řetězec pro aplikace nasazené do webových aplikací jako webové úlohy.

Poznámka:

Připojovací řetězec zadaný v kódu má přednost před proměnnou prostředí APPLICATIONINSIGHTS_CONNECTION_STRING, která má přednost před jinými možnostmi.

ASP.NET úlohy na pozadí jádra s hostovanými službami

Tento dokument popisuje, jak vytvořit úlohy na pozadí v aplikaci ASP.NET Core.

Úplný příklad se sdílí na této stránce GitHubu.

Nainstalujte do aplikace balíček Microsoft.ApplicationInsights.WorkerService .

Přidejte services.AddApplicationInsightsTelemetryWorkerService(); do metody, jak je znázorněno v tomto příkladu ConfigureServices() :

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

Následující kód je určený pro TimedHostedService, kde se nachází logika úlohy na pozadí:

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

Nastavte připojovací řetězec. Použijte totéž appsettings.json z předchozího příkladu služby Worker .NET.

Konzolová aplikace .NET Core/.NET Framework

Jak je uvedeno na začátku tohoto článku, nový balíček se dá použít k povolení telemetrie Application Insights i z běžné konzolové aplikace. Tento balíček cílí na netstandard2.0, takže jej lze používat pro konzolové aplikace v .NET Core nebo vyšší a .NET Framework nebo novější.

Úplný příklad se sdílí na této stránce GitHubu.

Nainstalujte do aplikace balíček Microsoft.ApplicationInsights.WorkerService .

Upravte Program.cs , jak je znázorněno v následujícím příkladu:

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

Tato konzolová aplikace také používá stejnou výchozí hodnotu TelemetryConfiguration. Dá se přizpůsobit stejným způsobem jako příklady v předchozích částech.

Spusťte aplikaci

Spusťte aplikaci. Pracovní procesy ze všech předchozích příkladů každou sekundu provádějí volání HTTP na bing.com a také vytvářejí několik protokolů pomocí ILogger. Tyto řádky jsou zabaleny uvnitř StartOperation volání TelemetryClient, které se používá k vytvoření operace. V tomto příkladu RequestTelemetry má název "operation."

Application Insights ve výchozím nastavení shromažďuje protokoly ILogger s úrovní závažnosti "Upozornění" nebo vyšší a také závislosti. Korelují se RequestTelemetry vztahem nadřazenosti a podřízenosti. Korelace také funguje napříč hranicemi procesů a sítí. Například, pokud bylo volání uskutečněno na jinou monitorovanou komponentu, je také spojeno s touto nadřazenou komponentou.

Tuto vlastní operaci RequestTelemetry si můžete představit jako ekvivalent příchozího webového požadavku v typické webové aplikaci. Není nutné použít operaci, ale nejlépe vyhovuje datovému modelu korelace Application Insights. RequestTelemetry funguje jako nadřazená operace a každá telemetrie vygenerovaná uvnitř iterace pracovního procesu je považována za logicky patřící stejné operaci.

Tento přístup také zajišťuje, že všechna telemetrická data generovaná automaticky i ručně mají stejnou operation_idhodnotu . Vzhledem k tomu, že vzorkování je založené na operation_id, algoritmus vzorkování buď uchovává nebo zahodí veškerou telemetrii z jedné iterace.

Následující části uvádějí úplnou telemetrii automaticky shromážděnou službou Application Insights.

Živé metriky

Živé metriky se dají použít k rychlému ověření, jestli je správně nakonfigurované monitorování aplikací pomocí Application Insights. Zobrazení telemetrie na webu Azure Portal může trvat několik minut, ale v podokně živých metrik se zobrazuje využití procesoru spuštěného procesu téměř v reálném čase. Může také zobrazovat další telemetrii, jako jsou požadavky, závislosti a trasování.

Záznamy ILoggeru

Protokoly vydávané přes ILogger se závažností Varování nebo vyšší se automaticky zaznamenávají. Chcete-li toto chování změnit, explicitně přepište konfiguraci protokolování pro zprostředkovatele ApplicationInsights, jak je znázorněno v následujícím kódu. Následující konfigurace umožňuje Application Insights zachytit všechny Information záznamy a další vážnější záznamy.

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

Je důležité si uvědomit, že následující příklad nezpůsobí, že poskytovatel Application Insights zachytává Information protokoly. Nezachytí ho, protože sada SDK přidá výchozí filtr protokolování, který dává pokyn ApplicationInsights k zachycení pouze Warning protokolů a složitějších protokolů. Application Insights vyžaduje explicitní změnu.

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

Poznámka:

Application Insights respektuje úrovně protokolů nakonfigurované prostřednictvím ConfigureLogging(...) v kódu. Pokud se použije jenom appsettings.json a ConfigureLogging se explicitně nepřepíše, výchozí úroveň zaznamenávání je Upozornění.

Další informace najdete v dokumentaci ILogger, kde si můžete přizpůsobit, které úrovně protokolů má zachytávat Application Insights.

Závislosti

Kolekce závislostí je ve výchozím nastavení povolená. Článek Sledování závislostí ve službě Application Insights vysvětluje závislosti, které se automaticky shromažďují, a obsahuje také kroky pro ruční sledování.

EventCounter

EventCounterCollectionModule je ve výchozím nastavení povolená a shromažďuje výchozí sadu čítačů z aplikací .NET . Kurz EventCounter uvádí výchozí sadu shromážděných čítačů. Obsahuje také pokyny k přizpůsobení seznamu.

Sledování jiné telemetrie ručně

I když sada SDK automaticky shromažďuje telemetrii, jak je vysvětleno, ve většině případů je potřeba do Application Insights odeslat další telemetrii. Doporučený způsob, jak sledovat další telemetrii, je získat instanci TelemetryClient z vkládání závislostí a poté zavolat jednu z podporovaných TrackXXX()metod rozhraní API. Dalším typickým případem použití je vlastní sledování operací. Tento přístup je demonstrován v předchozích příkladech pracovníků.

Konfigurace sady Application Insights SDK

Výchozí hodnota TelemetryConfiguration používaná sadou SDK pracovní služby je podobná automatické konfiguraci používané v aplikaci ASP.NET nebo ASP.NET Core a mínus inicializátory telemetrie používané k obohacení telemetrie z HttpContext.

Aplikaci Application Insights SDK pro Worker Service můžete přizpůsobit tak, aby se změnila výchozí konfigurace. Uživatelé sady Application Insights ASP.NET Core SDK mohou být obeznámeni se změnou konfigurace pomocí vestavěné injektáže závislostí ASP.NET Core. Sada SDK pracovních služeb je také založena na podobných principech. Proveďte téměř všechny změny konfigurace v oddílu ConfigureServices() voláním vhodných metod IServiceCollection, jak je podrobně popsáno v další části.

Poznámka:

Při použití této sady SDK se změna konfigurace úpravou TelemetryConfiguration.Active nepodporuje a změny se neprojeví.

Použití možnosti ApplicationInsightsServiceOptions

Můžete upravit několik běžných nastavení předáním ApplicationInsightsServiceOptions do AddApplicationInsightsTelemetryWorkerService, jak je vidět v tomto příkladu:

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

Tato ApplicationInsightsServiceOptions sada SDK je v oboru názvů Microsoft.ApplicationInsights.WorkerService , nikoli Microsoft.ApplicationInsights.AspNetCore.Extensions v sadě ASP.NET Core SDK.

Následující tabulka uvádí běžně používaná nastavení v ApplicationInsightsServiceOptions.

Nastavení	Popis	Výchozí
PovolitRychlýPulzMetrickýTok	Povolte nebo zakažte funkci živých metrik.	Pravdivý
PovolAdaptivníVzorkování	Povolení nebo zakázání adaptivního vzorkování	Pravdivý
Povolit srdeční tep	Povolte nebo zakažte funkci Heartbeat, která pravidelně (ve výchozím nastavení každých 15 minut) odesílá vlastní metriku nazvanou HeartBeatState s informacemi o modulu runtime, jako je verze .NET a prostředí Azure, pokud je to relevantní.	Pravdivý
PřidatExtraktorAutomatickyShromažďovanýchMetrik	Povolte nebo zakažte extraktor AutoCollectedMetrics, což je procesor telemetrie, který před vzorkováním odesílá předem agregované metriky o požadavcích a závislostech.	Pravdivý
Povolit Modul Diagnostické Telemetrie	Povolit nebo zakázat `DiagnosticsTelemetryModule`. Zakázání tohoto nastavení způsobí ignorování následujících nastavení: `EnableHeartbeat`, `EnableAzureInstanceMetadataTelemetryModule`a `EnableAppServicesHeartbeatTelemetryModule`.	Pravdivý

Nejaktuálnější seznam najdete v konfigurovatelných nastaveních ApplicationInsightsServiceOptions.

Vzorkování

Sada Application Insights SDK pro pracovní službu podporuje vzorkování s pevnou rychlostí i adaptivní vzorkování. Adaptivní vzorkování je ve výchozím nastavení povolené. Vzorkování je možné zakázat pomocí EnableAdaptiveSampling možnosti v ApplicationInsightsServiceOptions.

Pokud chcete nakonfigurovat další nastavení vzorkování, můžete použít následující příklad:

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.AddApplicationInsightsTelemetryWorkerService(new ApplicationInsightsServiceOptions
{
   EnableAdaptiveSampling = false,
});

var app = builder.Build();

Další informace najdete v dokumentu vzorkování .

Přidání inicializátorů telemetrie

Použijte inicializátory telemetrie, pokud chcete definovat vlastnosti odeslané se všemi telemetrickými daty.

Přidejte do kontejneru DependencyInjection všechny nové inicializátory telemetrie a sada SDK je automaticky přidá do TelemetryConfiguration.

    using Microsoft.ApplicationInsights.Extensibility;

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

Odebrání inicializátorů telemetrie

Inicializátory telemetrie jsou ve výchozím nastavení k dispozici. Chcete-li odebrat všechny nebo konkrétní inicializátory telemetrie, použijte následující ukázkový kód po volání AddApplicationInsightsTelemetryWorkerService().

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

Přidání procesorů telemetrie

Do TelemetryConfiguration můžete přidat vlastní procesory telemetrie pomocí rozšiřující metody AddApplicationInsightsTelemetryProcessor na IServiceCollection. V pokročilých scénářích filtrování používáte procesory telemetrie, které umožňují přímou kontrolu nad tím, co je součástí nebo vyloučeno z telemetrie, kterou odesíláte do Application Insights. Použijte následující příklad:

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

Konfigurace nebo odebrání výchozích modulů telemetrie

Application Insights používá moduly telemetrie k automatickému shromažďování telemetrických dat o konkrétních úlohách bez nutnosti ručního sledování.

Ve výchozím nastavení jsou povoleny následující moduly autocollection. Tyto moduly zodpovídají za automatické shromažďování telemetrie. Můžete je zakázat nebo nakonfigurovat tak, aby měnily výchozí chování.

DependencyTrackingTelemetryModule
PerformanceCollectorModule
QuickPulseTelemetryModule
AppServicesHeartbeatTelemetryModule (V současné době došlo k problému souvisejícímu s tímto modulem telemetrie. Dočasné alternativní řešení najdete v tématu Problém GitHubu 1689.)
AzureInstanceMetadataTelemetryModule

Pokud chcete nakonfigurovat jakýkoli výchozí modul telemetrie, použijte metodu rozšíření ConfigureTelemetryModule<T> na IServiceCollection, jak je znázorněno v následujícím příkladu:

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

Konfigurace kanálu telemetrie

Výchozí kanál je ServerTelemetryChannel. Můžete ho změnit, jak ukazuje tento příklad:

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

Dynamické zakázání telemetrie

Pokud chcete telemetrii podmíněně a dynamicky zakázat, můžete instanci vyřešit pomocí kontejneru pro vkládání závislostí ASP.NET Core kdekoli ve vašem kódu a nastavit na ní příznak TelemetryConfiguration.

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

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

Ukázkové aplikace

Konzolová aplikace .NET Core: Tuto ukázku použijte, pokud používáte konzolovou aplikaci napsanou v .NET Core (2.0 nebo vyšší) nebo .NET Framework (4.7.2 nebo vyšší).

ASP.NET Core úlohy na pozadí s HostedServices: Tuto ukázku použijte, pokud pracujete v ASP.NET Core a vytváříte úlohy na pozadí v souladu s oficiálními pokyny.

.NET Core Worker Service: Tuto ukázku použijte, pokud máte aplikaci .NET Worker Service v souladu s oficiálními pokyny.

Otevřené SDK

Čtení kódu a přispívání do kódu

Nejnovější aktualizace a opravy chyb najdete v poznámkách k verzi.

Další kroky

Nejčastější dotazy najdete v nejčastějších dotazech k aplikacím pracovních služeb.
Ověřte, že používáte podporovanou verzi sady Application Insights SDK.
Pomocí rozhraní API můžete odesílat vlastní události a metriky pro podrobné zobrazení výkonu a využití vaší aplikace.
Sledujte více závislostí, které nejsou automaticky sledovány.
Rozšíření nebo filtrování automaticky shromažďované telemetrie
Injektování závislostí v ASP.NET Core

Sdílet prostřednictvím

Application Insights pro aplikace pracovních služeb (aplikace jiné než HTTP)

Podporované scénáře

Požadavky

Použití sady Application Insights SDK pro pracovní službu

Aplikace .NET Core Worker Service

ASP.NET úlohy na pozadí jádra s hostovanými službami

Konzolová aplikace .NET Core/.NET Framework

Spusťte aplikaci

Živé metriky

Záznamy ILoggeru

Závislosti

EventCounter

Sledování jiné telemetrie ručně

Konfigurace sady Application Insights SDK

Použití možnosti ApplicationInsightsServiceOptions

Vzorkování

Přidání inicializátorů telemetrie

Odebrání inicializátorů telemetrie

Přidání procesorů telemetrie

Konfigurace nebo odebrání výchozích modulů telemetrie

Konfigurace kanálu telemetrie

Dynamické zakázání telemetrie

Ukázkové aplikace

Otevřené SDK

Další kroky

Váš názor

Další materiály