Udostępnij za pośrednictwem

Usługa Application Insights dla aplikacji usługi procesów roboczych (aplikacje inne niż HTTP)

  • Artykuł

Zestaw SDK usługi Application Insights dla usługi Roboczej to nowy zestaw SDK, który najlepiej nadaje się do obsługi obciążeń innych niż HTTP, takich jak obsługa komunikatów, zadania w tle i aplikacje konsolowe. Te typy aplikacji nie mają pojęcia przychodzącego żądania HTTP, takiego jak tradycyjna aplikacja internetowa ASP.NET/ASP.NET Core. Z tego powodu używanie pakietów usługi Application Insights dla aplikacji ASP.NET lub ASP.NET Core nie jest obsługiwane.

Uwaga

Poniższa dokumentacja opiera się na klasycznym interfejsie API usługi Application Insights. Długoterminowy plan usługi Application Insights polega na zbieraniu danych przy użyciu technologii OpenTelemetry. Aby uzyskać więcej informacji, zobacz Enable Azure Monitor OpenTelemetry for .NET, Node.js, Python and Java applications (Włączanie usługi Azure Monitor OpenTelemetry dla platformy .NET, Node.js, Python i Java applications).

Nowy zestaw SDK nie wykonuje żadnej kolekcji danych telemetrycznych. Zamiast tego wprowadza on inne dobrze znane moduły zbierające automatyczne usługi Application Insights, takie jak DependencyCollector, PerfCounterCollector i ApplicationInsightsLoggingProvider. Ten zestaw SDK uwidacznia metody rozszerzenia, IServiceCollection aby włączyć i skonfigurować zbieranie danych telemetrycznych.

Obsługiwane scenariusze

Zestaw SDK usługi Application Insights dla usługi Worker Service najlepiej nadaje się dla aplikacji innych niż HTTP niezależnie od tego, gdzie i jak działają. Jeśli aplikacja jest uruchomiona i ma łączność sieciową z platformą Azure, można zbierać dane telemetryczne. Monitorowanie usługi Application Insights jest obsługiwane wszędzie, gdzie jest obsługiwana platforma .NET Core. Ten pakiet może być używany w nowo wprowadzonej usłudze procesów roboczych platformy .NET Core, zadaniach w tle w ASP.NET Core i aplikacjach konsolowych, takich jak .NET Core i .NET Framework.

Wymagania wstępne

Musisz mieć prawidłową parametry połączenia usługi Application Insights. Ten ciąg jest wymagany do wysyłania wszelkich danych telemetrycznych do usługi Application Insights. Jeśli musisz utworzyć nowy zasób usługi Application Insights, aby uzyskać parametry połączenia, zobacz Parametry połączenia.

Uwaga

31 marca 2025 r. zostanie zakończone świadczenie pomocy technicznej dla pozyskiwania klucza instrumentacji. Pozyskiwanie klucza instrumentacji będzie nadal działać, ale nie udostępnimy już aktualizacji ani obsługi funkcji. Przejście do parametry połączenia w celu skorzystania z nowych funkcji.

Korzystanie z zestawu SDK usługi Application Insights dla usługi Procesu roboczego

  1. Zainstaluj pakiet Microsoft.ApplicationInsights.WorkerService w aplikacji. Poniższy fragment kodu przedstawia zmiany, które należy dodać do pliku projektu .csproj :

        <ItemGroup>
        <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.22.0" />
    </ItemGroup>

  2. Skonfiguruj parametry połączenia w zmiennej środowiskowej APPLICATIONINSIGHTS_CONNECTION_STRING lub w konfiguracji (appsettings.json).

    Zrzut ekranu przedstawiający przegląd usługi Application Insights i parametry połączenia.

  3. ILogger Pobierz wystąpienie lub TelemetryClient wystąpienie z kontenera wstrzykiwania zależności (DI), wywołując serviceProvider.GetRequiredService<TelemetryClient>(); metodę lub używając iniekcji konstruktora. Ten krok spowoduje wyzwolenie konfigurowania modułów automatycznego zbierania i ich automatycznego zbierania TelemetryConfiguration .

Szczegółowe instrukcje dotyczące każdego typu aplikacji opisano w poniższych sekcjach.

Aplikacja usługi roboczej platformy .NET Core

Pełny przykład jest udostępniany w witrynie internetowej NuGet.

  1. Pobierz i zainstaluj zestaw .NET SDK.

  2. Utwórz nowy projekt usługi roboczej przy użyciu nowego szablonu projektu programu Visual Studio lub wiersza dotnet new workerpolecenia .

  3. Dodaj pakiet Microsoft.ApplicationInsights.WorkerService do aplikacji.

  4. Dodaj services.AddApplicationInsightsTelemetryWorkerService(); do CreateHostBuilder() metody w Program.cs klasie, jak w tym przykładzie:

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

  5. Zmodyfikuj element Worker.cs zgodnie z poniższym przykładem:

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

  6. Skonfiguruj parametry połączenia.

    Zrzut ekranu przedstawiający przegląd i parametry połączenia usługi Application Insights.

    Uwaga

    Zalecamy określenie parametry połączenia w konfiguracji. Poniższy przykładowy kod pokazuje, jak określić parametry połączenia w pliku appsettings.json. Podczas publikowania upewnij się, że appsettings.json plik został skopiowany do folderu głównego aplikacji.

        {
        "ApplicationInsights":
        {
            "ConnectionString" : "InstrumentationKey=00000000-0000-0000-0000-000000000000;"
        },
        "Logging":
        {
            "LogLevel":
            {
                "Default": "Warning"
            }
        }
    }

Alternatywnie określ parametry połączenia w zmiennej środowiskowejAPPLICATIONINSIGHTS_CONNECTION_STRING.

APPLICATIONINSIGHTS_CONNECTION_STRING Zazwyczaj określa parametry połączenia dla aplikacji wdrożonych w aplikacjach internetowych jako zadań internetowych.

Uwaga

Parametry połączenia określony w kodzie ma pierwszeństwo przed zmienną środowiskową APPLICATIONINSIGHTS_CONNECTION_STRING, która ma pierwszeństwo przed innymi opcjami.

ASP.NET Podstawowe zadania w tle z hostowanymi usługami

W tym dokumencie opisano sposób tworzenia zadań w tle w aplikacji ASP.NET Core.

Pełny przykład jest udostępniany na tej stronie usługi GitHub.

  1. Zainstaluj pakiet Microsoft.ApplicationInsights.WorkerService w aplikacji.

  2. Dodaj services.AddApplicationInsightsTelemetryWorkerService(); do ConfigureServices() metody , jak w tym przykładzie:

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

    Poniższy kod dotyczy TimedHostedServiceelementu , gdzie znajduje się logika zadań w tle:

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

  3. Skonfiguruj parametry połączenia. Użyj tego samego appsettings.json z poprzedniego przykładu usługi procesu roboczego platformy .NET .

Aplikacja konsolowa .NET Core/.NET Framework

Jak wspomniano na początku tego artykułu, nowy pakiet może służyć do włączania telemetrii usługi Application Insights z nawet zwykłej aplikacji konsolowej. Ten pakiet jest przeznaczony dla netstandard2.0programu , aby można go było używać w przypadku aplikacji konsolowych na platformie .NET Core lub nowszych wersjach oraz programu .NET Framework lub nowszego.

Pełny przykład jest udostępniany na tej stronie usługi GitHub.

  1. Zainstaluj pakiet Microsoft.ApplicationInsights.WorkerService w aplikacji.

  2. Zmodyfikuj Program.cs, jak pokazano w poniższym przykładzie:

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

Ta aplikacja konsolowa używa również tego samego domyślnego .TelemetryConfiguration Można go dostosować w taki sam sposób, jak przykłady we wcześniejszych sekcjach.

Uruchamianie aplikacji

Uruchom aplikację. Pracownicy ze wszystkich powyższych przykładów co sekundę tworzą wywołanie HTTP w celu bing.com, a także emitują kilka dzienników przy użyciu polecenia ILogger. Te wiersze są opakowane wewnątrz StartOperation wywołania TelemetryClientmetody , która służy do tworzenia operacji. W tym przykładzie RequestTelemetry nazwa to "operation".

Usługa Application Insights zbiera te dzienniki ILogger o ważności Ostrzeżenie lub nowsze domyślnie oraz zależności. Są one skorelowane RequestTelemetry z relacją nadrzędny-podrzędny. Korelacja działa również w granicach procesów/sieci. Jeśli na przykład wywołanie zostało wykonane do innego monitorowanego składnika, jest również skorelowane z tym elementem nadrzędnym.

Tę niestandardową operację RequestTelemetry można traktować jako odpowiednik przychodzącego żądania internetowego w typowej aplikacji internetowej. Nie jest konieczne użycie operacji, ale najlepiej pasuje do modelu danych korelacji usługi Application Insights. RequestTelemetry działa jako operacja nadrzędna, a każda telemetria wygenerowana wewnątrz iteracji procesu roboczego jest traktowana jako logicznie należąca do tej samej operacji.

Takie podejście zapewnia również, że wszystkie wygenerowane dane telemetryczne, zarówno automatyczne, jak i ręczne, będą miały takie same wartości operation_id. Ponieważ próbkowanie jest oparte na metodzie operation_id, algorytm próbkowania zachowuje lub odrzuca wszystkie dane telemetryczne z pojedynczej iteracji.

W poniższych sekcjach przedstawiono pełną telemetrię automatycznie zbieraną przez usługę Application Insights.

Metryki na żywo

Metryki na żywo mogą służyć do szybkiego sprawdzania, czy monitorowanie aplikacji za pomocą usługi Application Insights jest poprawnie skonfigurowane. Dane telemetryczne mogą pojawić się w witrynie Azure Portal, ale okienko metryk na żywo pokazuje użycie procesora CPU uruchomionego procesu niemal w czasie rzeczywistym. Może również wyświetlać inne dane telemetryczne, takie jak żądania, zależności i ślady.

Dzienniki protokołu ILogger

Dzienniki emitowane za pomocą ILogger ostrzeżenia o ważności lub większej są automatycznie przechwytywane. Aby zmienić to zachowanie, jawnie przesłoń konfigurację rejestrowania dla dostawcy ApplicationInsights, jak pokazano w poniższym kodzie. Poniższa konfiguracja umożliwia usłudze Application Insights przechwytywanie wszystkich Information dzienników i poważniejszych dzienników.

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

Należy pamiętać, że poniższy przykład nie powoduje przechwycenia Information dzienników przez dostawcę usługi Application Insights. Nie przechwytuje go, ponieważ zestaw SDK dodaje domyślny filtr rejestrowania, który nakazuje ApplicationInsights przechwycenie tylko Warning dzienników i poważniejszych dzienników. Usługa Application Insights wymaga jawnego zastąpienia.

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

Aby uzyskać więcej informacji, postępuj zgodnie z dokumentami ILogger , aby dostosować poziomy dzienników przechwytywane przez usługę Application Insights.

Zależności

Kolekcja zależności jest domyślnie włączona. W artykule Śledzenie zależności w usłudze Application Insights wyjaśniono zależności, które są zbierane automatycznie, a także zawiera kroki umożliwiające ręczne śledzenie.

EventCounter

EventCounterCollectionModule jest domyślnie włączona i będzie zbierać domyślny zestaw liczników z aplikacji platformy .NET . Samouczek EventCounter zawiera listę domyślnego zestawu zebranych liczników. Zawiera również instrukcje dotyczące dostosowywania listy.

Ręczne śledzenie innych danych telemetrycznych

Mimo że zestaw SDK automatycznie zbiera dane telemetryczne zgodnie z wyjaśnieniem, w większości przypadków należy wysłać inne dane telemetryczne do usługi Application Insights. Zalecanym sposobem śledzenia innych danych telemetrycznych jest uzyskanie wystąpienia TelemetryClient iniekcji zależności, a następnie wywołanie jednej z obsługiwanych TrackXXX()metod interfejsu API . Innym typowym przypadkiem użycia jest niestandardowe śledzenie operacji. To podejście przedstawiono w poprzednich przykładach procesów roboczych.

Konfigurowanie zestawu SDK usługi Application Insights

Wartość domyślna TelemetryConfiguration używana przez zestaw SDK usługi procesu roboczego jest podobna do automatycznej konfiguracji używanej w aplikacji ASP.NET lub ASP.NET Core, pomniejszone o inicjatory telemetrii używane do wzbogacania danych telemetrycznych z HttpContextprogramu .

Możesz dostosować zestaw SDK usługi Application Insights dla usługi Worker Service, aby zmienić konfigurację domyślną. Użytkownicy zestawu SDK usługi Application Insights ASP.NET Core mogą zapoznać się ze zmianą konfiguracji przy użyciu wbudowanego wstrzykiwania zależności ASP.NET Core. Zestaw SDK usługi procesu roboczego jest również oparty na podobnych zasadach. Wprowadź prawie wszystkie zmiany konfiguracji w ConfigureServices() sekcji, wywołując odpowiednie metody w metodzie IServiceCollection, zgodnie z opisem w następnej sekcji.

Uwaga

W przypadku korzystania z tego zestawu SDK zmiana konfiguracji przez zmodyfikowanie TelemetryConfiguration.Active nie jest obsługiwana, a zmiany nie zostaną odzwierciedlone.

Korzystanie z usługi ApplicationInsightsServiceOptions

Możesz zmodyfikować kilka typowych ustawień, przekazując ApplicationInsightsServiceOptions element do AddApplicationInsightsTelemetryWorkerServiceelementu , jak w tym przykładzie:

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

W ApplicationInsightsServiceOptions tym zestawie SDK znajduje się przestrzeń nazw Microsoft.ApplicationInsights.WorkerService , a nie Microsoft.ApplicationInsights.AspNetCore.Extensions w ASP.NET Core SDK.

W poniższej tabeli wymieniono często używane ustawienia w programie ApplicationInsightsServiceOptions.

Ustawienie opis Wartość domyślna
EnableQuickPulseMetricStream Włącz/wyłącz funkcję metryk na żywo. Prawda
EnableAdaptiveSampling Włączanie/wyłączanie próbkowania adaptacyjnego. Prawda
WłączHeartbeat Włącz/Wyłącz funkcję Pulsy, która okresowo (15-minutowa wartość domyślna) wysyła niestandardową metrykę o nazwie "HeartBeatState" z informacjami na temat środowiska uruchomieniowego, takiego jak wersja platformy .NET i środowisko platformy Azure, jeśli ma to zastosowanie. Prawda
AddAutoCollectedMetricExtractor Włącz/wyłącz moduł wyodrębniania AutocollectedMetrics, który jest procesorem telemetrii, który wysyła wstępnie agregowane metryki dotyczące żądań/zależności przed rozpoczęciem próbkowania. Prawda
EnableDiagnosticsTelemetryModule Włącz/wyłącz DiagnosticsTelemetryModule. Wyłączenie tego ustawienia spowoduje zignorowanie następujących ustawień: EnableHeartbeat, EnableAzureInstanceMetadataTelemetryModulei EnableAppServicesHeartbeatTelemetryModule. Prawda

Aby uzyskać najbardziej aktualną listę, zobacz konfigurowalne ustawienia w programie ApplicationInsightsServiceOptions.

Próbkowanie

Zestaw SDK usługi Application Insights dla usługi Worker Service obsługuje próbkowanie o stałej szybkości i próbkowanie adaptacyjne. Próbkowanie adaptacyjne jest domyślnie włączone. Próbkowanie można wyłączyć przy użyciu EnableAdaptiveSampling opcji w obszarze ApplicationInsightsServiceOptions.

Aby skonfigurować inne ustawienia próbkowania, możesz użyć następującego przykładu:

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

Aby uzyskać więcej informacji, zobacz dokument Próbkowanie .

Dodawanie inicjatorów telemetrii

Użyj inicjatorów telemetrii, jeśli chcesz zdefiniować właściwości wysyłane ze wszystkimi danymi telemetrycznymi.

Dodaj nowy inicjator telemetrii do kontenera DependencyInjection , a zestaw SDK automatycznie dodaje je do elementu TelemetryConfiguration.

    using Microsoft.ApplicationInsights.Extensibility;

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

Usuwanie inicjatorów telemetrii

Inicjatory telemetrii są domyślnie obecne. Aby usunąć wszystkie lub określone inicjatory telemetrii, użyj następującego przykładowego kodu po wywołaniu metody 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));
   }

Dodawanie procesorów telemetrii

Niestandardowe procesory telemetryczne można dodać do TelemetryConfiguration programu przy użyciu metody AddApplicationInsightsTelemetryProcessor rozszerzenia w systemie IServiceCollection. Procesory telemetryczne są używane w zaawansowanych scenariuszach filtrowania, aby zapewnić większą bezpośrednią kontrolę nad elementami dołączonymi lub wykluczonymi z telemetrii wysyłanej do usługi Application Insights. Skorzystaj z następującego przykładu:

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

Konfigurowanie lub usuwanie domyślnych modułów telemetrii

Usługa Application Insights używa modułów telemetrycznych do automatycznego zbierania danych telemetrycznych dotyczących określonych obciążeń bez konieczności ręcznego śledzenia.

Następujące moduły automatycznego zbierania są domyślnie włączone. Te moduły są odpowiedzialne za automatyczne zbieranie danych telemetrycznych. Można je wyłączyć lub skonfigurować w celu zmiany ich domyślnego zachowania.

  • DependencyTrackingTelemetryModule
  • PerformanceCollectorModule
  • QuickPulseTelemetryModule
  • AppServicesHeartbeatTelemetryModule (Obecnie występuje problem z tym modułem telemetrii. Aby uzyskać tymczasowe obejście, zobacz Problem z usługą GitHub 1689.
  • AzureInstanceMetadataTelemetryModule

Aby skonfigurować dowolny domyślny moduł telemetrii, użyj metody ConfigureTelemetryModule<T> rozszerzenia w metodzie IServiceCollection, jak pokazano w poniższym przykładzie:

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

Konfigurowanie kanału telemetrii

Domyślnym kanałem jest ServerTelemetryChannel. Można go zastąpić, jak pokazano w poniższym przykładzie:

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

Dynamiczne wyłączanie telemetrii

Jeśli chcesz wyłączyć telemetrię warunkowo i dynamicznie, możesz rozpoznać TelemetryConfiguration wystąpienie za pomocą kontenera iniekcji zależności ASP.NET Core w dowolnym miejscu w kodzie i ustawić na nim flagę DisableTelemetry .

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

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

Często zadawane pytania

Ta sekcja zawiera odpowiedzi na typowe pytania.

Którego pakietu należy użyć?

Scenariusz aplikacji platformy .NET Core Pakiet
Bez hostowanych usług WorkerService
Z usługami HostedServices AspNetCore (nie WorkerService)
W usłudze HostedServices monitorowanie tylko hostowanychusług WorkerService (rzadki scenariusz)

Czy hostowane usługi w aplikacji .NET Core przy użyciu pakietu AspNetCore mają do niej wstrzykniętą aplikację TelemetryClient?

Tak. Konfiguracja zostanie udostępniona pozostałej części aplikacji internetowej.

Jak mogę śledzić dane telemetryczne, które nie są zbierane automatycznie?

Pobierz wystąpienie TelemetryClient przy użyciu iniekcji konstruktora i wywołaj wymaganą TrackXXX() metodę. Nie zalecamy tworzenia nowych TelemetryClient wystąpień. Pojedyncze wystąpienie TelemetryClient klasy jest już zarejestrowane w kontenerze DependencyInjection , które współudzieli TelemetryConfiguration resztę danych telemetrycznych. Tworzenie nowego TelemetryClient wystąpienia jest zalecane tylko wtedy, gdy wymaga konfiguracji, która jest oddzielona od pozostałej części telemetrii.

Czy mogę użyć środowiska IDE programu Visual Studio do dołączenia usługi Application Insights do projektu usługi Worker Service?

Dołączanie środowiska IDE programu Visual Studio jest obecnie obsługiwane tylko w przypadku aplikacji ASP.NET/ASP.NET Core. Ten dokument zostanie zaktualizowany, gdy program Visual Studio będzie obsługiwać dołączanie aplikacji usługi procesu roboczego.

Czy mogę włączyć monitorowanie usługi Application Insights przy użyciu narzędzi, takich jak agent usługi Azure Monitor Application Insights (dawniej Monitor stanu w wersji 2)?

L.p. Agent usługi Application Insights usługi Azure Monitor obecnie obsługuje tylko platformę .NET .

Czy wszystkie funkcje są obsługiwane, jeśli uruchamiam aplikację w systemie Linux?

Tak. Obsługa funkcji dla tego zestawu SDK jest taka sama na wszystkich platformach z następującymi wyjątkami:

  • Liczniki wydajności są obsługiwane tylko w systemie Windows, z wyjątkiem przetwarzania procesora CPU/pamięci wyświetlanej w metrykach na żywo.

  • Mimo że ServerTelemetryChannel jest domyślnie włączona, jeśli aplikacja jest uruchomiona w systemie Linux lub macOS, kanał nie tworzy automatycznie lokalnego folderu magazynu w celu tymczasowego przechowywania danych telemetrycznych, jeśli występują problemy z siecią. Z powodu tego ograniczenia dane telemetryczne są tracone, gdy występują tymczasowe problemy z siecią lub serwerem. Aby obejść ten problem, skonfiguruj folder lokalny dla kanału:

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

Przykładowe aplikacje

Aplikacja konsolowa platformy .NET Core: użyj tego przykładu, jeśli używasz aplikacji konsolowej napisanej w programie .NET Core (2.0 lub nowszym) lub .NET Framework (4.7.2 lub nowszym).

ASP.NET Podstawowe zadania w tle z usługami HostedServices: użyj tego przykładu, jeśli jesteś w ASP.NET Core i tworzysz zadania w tle zgodnie z oficjalnymi wskazówkami.

Usługa procesu roboczego platformy .NET Core: użyj tego przykładu, jeśli masz aplikację usługi procesu roboczego platformy .NET zgodnie z oficjalnymi wskazówkami.

Zestaw SDK typu open source

Odczytywanie i współtworzenie kodu.

Aby uzyskać najnowsze aktualizacje i poprawki błędów, zobacz Informacje o wersji.

Następne kroki