Application Szczegółowe informacje dla aplikacji usługi procesu roboczego (aplikacji innych niż HTTP)

Zestaw SDK Szczegółowe informacje dla usługi procesu roboczego to nowy zestaw SDK, który najlepiej nadaje się do obciążeń innych niż HTTP, takich jak obsługa komunikatów, zadania w tle, aplikacje konsolowe itp. Te typy aplikacji nie mają pojęcia przychodzącego żądania HTTP, takiego jak tradycyjna aplikacja internetowa ASP.NET/ASP.NET Core, dlatego korzystanie z pakietów Application Szczegółowe informacje dla aplikacji ASP.NET lub ASP.NET Core nie jest obsługiwane.

Nowy zestaw SDK nie samodzielnie pobiera żadnych danych telemetrycznych. Zamiast tego wprowadza inne dobrze znane automatyczne Szczegółowe informacje application Szczegółowe informacje takie jak DependencyCollector, PerfCounterCollector, ApplicationInsightsLoggingProvider itp. Ten zestaw SDK uwidacznia metody rozszerzenia w IServiceCollection programie w celu włączenia i skonfigurowania zbierania danych telemetrycznych.

Obsługiwane scenariusze

Zestaw SDK Szczegółowe informacje dla usługi procesu roboczego najlepiej nadaje się dla aplikacji innych niż HTTP niezależnie od tego, gdzie i jak są uruchamiane. Jeśli aplikacja jest uruchomiona i ma łączność sieciową z platformą Azure, można zbierać dane telemetryczne. Monitorowanie Szczegółowe informacje aplikacji jest obsługiwane wszędzie tam, gdzie jest obsługiwana aplikacja .NET Core. Ten pakiet może być używany w nowo wprowadzonej usłudze procesu roboczego programu .NET Core 3.0,zadaniach w tle w programie ASP.NET Core 2.1/2.2,aplikacjach konsoli (.NET Core/.NET Framework) itp.

Wymagania wstępne

Prawidłowy klucz instrumentacji Szczegółowe informacje Application. Ten klucz jest wymagany do wysyłania danych telemetrycznych do usługi Application Szczegółowe informacje. Jeśli musisz utworzyć nowy zasób application Szczegółowe informacje, aby uzyskać klucz instrumentacji, zobacz Create an Application Szczegółowe informacje resource (Tworzenie zasobu Szczegółowe informacje aplikacji).

Korzystanie z zestawu SDK Szczegółowe informacje dla usług procesów roboczych

  1. Zainstaluj pakiet Microsoft.ApplicationInsights.WorkerService w aplikacji. Poniższy fragment kodu przedstawia zmiany, które należy dodać do pliku .csproj projektu.
    <ItemGroup>
        <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.13.1" />
    </ItemGroup>
  1. Wywołaj AddApplicationInsightsTelemetryWorkerService(string instrumentationKey) metodę rozszerzenia dla metody , podając klucz IServiceCollection instrumentacji. Ta metoda powinna być wywoływana na początku aplikacji. Dokładna lokalizacja zależy od typu aplikacji.

  2. Pobierz wystąpienie lub wystąpienie z kontenera wstrzykiwania zależności przez wywołanie lub użycie iniekcji ILogger TelemetryClient serviceProvider.GetRequiredService<TelemetryClient>(); konstruktora. Ten krok spowoduje wyzwolenie konfigurowania modułów TelemetryConfiguration i automatycznego zbierania.

Szczegółowe instrukcje dla każdego typu aplikacji zostały opisane w poniższych sekcjach.

Aplikacja usługi procesu roboczego .NET Core 3.0

Pełny przykład został udostępniony tutaj

  1. Pobieranie i instalowanie programu .NET Core 3.0

  2. Tworzenie nowego projektu usługi procesu roboczego przy użyciu Visual Studio szablonu nowego projektu lub wiersza poleceniadotnet new worker

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

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

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureServices((hostContext, services) =>
            {
                services.AddHostedService<Worker>();
                services.AddApplicationInsightsTelemetryWorkerService();
            });
  1. Worker.csZmodyfikuj kod 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);
            }
        }
    }
  1. Skonfiguruj klucz instrumentacji.

    Mimo że klucz instrumentacji można podać jako argument do polecenia , zaleca się określenie klucza AddApplicationInsightsTelemetryWorkerService instrumentacji w konfiguracji. Poniższy przykład kodu pokazuje, jak określić klucz instrumentacji w appsettings.json . Upewnij appsettings.json się, że plik został skopiowany do folderu głównego aplikacji podczas publikowania.

    {
        "ApplicationInsights":
        {
            "InstrumentationKey": "putinstrumentationkeyhere"
        },
        "Logging":
        {
            "LogLevel":
            {
                "Default": "Warning"
            }
        }
    }

Alternatywnie określ klucz instrumentacji w jednej z następujących zmiennych środowiskowych. APPINSIGHTS_INSTRUMENTATIONKEY lub ApplicationInsights:InstrumentationKey

Na przykład: SET ApplicationInsights:InstrumentationKey=putinstrumentationkeyhere LUB SET APPINSIGHTS_INSTRUMENTATIONKEY=putinstrumentationkeyhere

Zazwyczaj określa klucz instrumentacji dla aplikacji wdrożonych w programie APPINSIGHTS_INSTRUMENTATIONKEY Web Apps jako zadania web jobs.

Uwaga

Klucz instrumentacji określony w kodzie przejmuje zmienną środowiskową APPINSIGHTS_INSTRUMENTATIONKEY , która jest przesądnia za innymi opcjami.

ASP.NET Core zadań w tle przy użyciu hostowanych usług

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

Pełny przykład został udostępniony tutaj

  1. Zainstaluj pakiet Microsoft.ApplicationInsights.WorkerService w aplikacji.
  2. Dodaj services.AddApplicationInsightsTelemetryWorkerService(); do metody , jak w tym ConfigureServices() 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>();

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

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

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

Poniżej znajduje się kod, w TimedHostedService którym 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");
            }
        }
    }
  1. Skonfiguruj klucz instrumentacji. Użyj tego samego przykładu w powyższym przykładzie usługi procesu roboczego appsettings.json .NET Core 3.0.

.NET Core/.NET Framework aplikacji konsolowej

Jak wspomniano na początku tego artykułu, nowy pakiet może służyć do włączania telemetrii usługi Application Szczegółowe informacje z nawet zwykłej aplikacji konsolowej. Ten pakiet jest przeznaczony dla programu , a w związku z tym może być używany w przypadku aplikacji konsolowych na platformie .NET Core 2.0 lub wyższej oraz w wersji NetStandard2.0 .NET Framework 4.7.2 lub wyższej.

Pełny przykład został udostępniony tutaj

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

  2. Zmodyfikuj program.cs w poniższym przykładzie.

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

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

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

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

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

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

                var httpClient = new HttpClient();

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

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

                    await Task.Delay(1000);
                }

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

Ta aplikacja konsolowa używa również tej samej domyślnej wartości i można ją dostosować w taki sam sposób, jak w TelemetryConfiguration przykładach we wcześniejszej sekcji.

Uruchamianie aplikacji

Uruchom aplikację. Przykładowe pracownicy z wszystkich powyższych zdarzeń wywołują protokół HTTP co sekundę, aby bing.com, a także emitują niewiele dzienników przy użyciu funkcji ILogger . Te wiersze są opakowane wewnątrz wywołania , które służy do tworzenia operacji (w tym StartOperation TelemetryClient przykładzie RequestTelemetry o nazwie "operation"). Aplikacje Szczegółowe informacje będą zbierać te dzienniki ILogger (domyślnie ostrzeżenie lub powyżej) i zależności i zostaną one skorelowane z relacją RequestTelemetry nadrzędny-podrzędny. Korelacja działa również między procesami/granicami sieci. Jeśli na przykład wywołanie zostało wykonane do innego monitorowanego składnika, zostanie ono również skorelowane z tym elementem nadrzędnym.

Tę niestandardową operację można uważać za odpowiednik przychodzącego żądania RequestTelemetry internetowego w typowej aplikacji internetowej. Chociaż użycie operacji nie jest konieczne, najlepiej pasuje do modelu danych korelacji usługi Application Szczegółowe informacje — z działaniem jako operacja nadrzędna, a każda telemetria wygenerowana wewnątrz iteracji procesu roboczego jest traktowana jako logicznie należąca do tej samej RequestTelemetry operacji. Takie podejście gwarantuje również, że wszystkie wygenerowane dane telemetryczne (automatyczne i ręczne) będą mieć taką samą instrukcje operation_id . Ponieważ próbkowanie jest oparte na , algorytm próbkowania zachowuje lub porzuca wszystkie dane operation_id telemetryczne z jednej iteracji.

Poniżej przedstawiono pełną telemetrię automatycznie zbieraną przez usługi Application Szczegółowe informacje.

Metryki na żywo

Metryki na żywo mogą służyć do szybkiego weryfikowania, czy Szczegółowe informacje monitorowanie aplikacji jest poprawnie skonfigurowane. Chociaż może mieć kilka minut, zanim telemetria zacznie pojawiać się w portalu i analizie, metryki na żywo będą pokazywać 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, ślady itp.

Dzienniki ILogger

Dzienniki emitowane za ILogger pośrednictwem ważności Warning lub większej są przechwytywane automatycznie. Postępuj zgodnie z pcami rejestratora, aby dostosować poziomy dzienników przechwytywane przez usługę Application Szczegółowe informacje.

Zależności

Kolekcja zależności jest domyślnie włączona. W tym artykule wyjaśniono zależności, które są zbierane automatycznie, a także o krokach śledzenia ręcznego.

EventCounter

EventCounterCollectionModule program jest domyślnie włączony i będzie zbierać domyślny zestaw liczników z aplikacji .NET Core 3.0. W samouczku EventCounter wymieniono domyślny zestaw zebranych liczników. Zawiera również instrukcje dotyczące dostosowywania listy.

Ręczne śledzenie dodatkowych danych telemetrycznych

Zestaw SDK automatycznie zbiera dane telemetryczne, jak wyjaśniono powyżej, ale w większości przypadków użytkownik będzie musiał wysłać dodatkową telemetrię do usługi Application Szczegółowe informacje Service. Zalecanym sposobem śledzenia dodatkowych danych telemetrycznych jest uzyskanie wystąpienia klasy z wstrzykiwania zależności, a następnie wywołanie jednej z obsługiwanych metod interfejsu TelemetryClient TrackXXX() API. Innym typowym zastosowaniem jest niestandardowe śledzenie operacji. Takie podejście przedstawiono w powyższych przykładach procesów roboczych.

Konfigurowanie zestawu SDK usługi Application Szczegółowe informacje

Wartość domyślna używana przez zestaw SDK usługi Procesu roboczego jest podobna do automatycznej konfiguracji używanej w aplikacji ASP.NET lub ASP.NET Core minus wartości TelemetryConfiguration TelemetryInitializers używanych do wzbogacania telemetrii z usługi HttpContext .

Możesz dostosować zestaw SDK usługi Application Szczegółowe informacje dla usługi procesu roboczego, aby zmienić konfigurację domyślną. Użytkownicy zestawu SDK usługi Application Szczegółowe informacje ASP.NET Core mogą być zaznajomieni ze zmianą konfiguracji przy ASP.NET Core wbudowanej iniekcji zależności. Zestaw SDK WorkerService jest również oparty na podobnych zasadach. Prawie wszystkie zmiany konfiguracji w sekcji ConfigureServices() wprowadza się, wywołując odpowiednie metody w IServiceCollection pliku , zgodnie z poniższymi informacjami.

Uwaga

Podczas korzystania z tego zestawu SDK zmiana konfiguracji przez modyfikację nie jest obsługiwana i zmiany TelemetryConfiguration.Active nie zostaną odzwierciedlone.

Korzystanie z applicationInsightsServiceOptions

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

using Microsoft.ApplicationInsights.WorkerService;

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

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

Należy pamiętać, że w tym zestawie SDK znajduje się w przestrzeni nazw , a nie w ApplicationInsightsServiceOptions Microsoft.ApplicationInsights.WorkerService ASP.NET Core Microsoft.ApplicationInsights.AspNetCore.Extensions SDK.

Często używane ustawienia w programie ApplicationInsightsServiceOptions

Ustawienie Opis Domyślne
EnableQuickPulseMetricStream Włączanie/wyłączanie funkcji LiveMetrics true
EnableAdaptiveSampling Włączanie/wyłączanie próbkowania adaptacyjnego true
Enable Mikrouzysłowy Funkcja Włączania/wyłączania pulsów, która okresowo (domyślnie 15 minut) wysyła metrykę niestandardową o nazwie "HeartBeatState" z informacjami o środowisku uruchomieniowym, takich jak wersja platformy .NET, informacje o środowisku platformy Azure, jeśli mają zastosowanie, itp. true
AddAutoCollectedMetricExtractor Enable/Disable AutoCollectedMetrics extractor, czyli telemetryprocesor, który wysyła wstępnie zagregowane metryki dotyczące żądań/zależności przed rozpoczęciem próbkowania. true
EnableDiagnosticsTelemetryModule Włącz/wyłącz DiagnosticsTelemetryModule . Wyłączenie tej opcji spowoduje zignorowanie następujących ustawień. EnableHeartbeat, EnableAzureInstanceMetadataTelemetryModule, EnableAppServicesHeartbeatTelemetryModule true

Aby uzyskać najbardziej aktualne informacje, ApplicationInsightsServiceOptions zobacz konfigurowalne ustawienia w programie .

Próbkowanie

Zestaw SDK Szczegółowe informacje dla usługi procesu roboczego obsługuje próbkowanie o stałej szybkości i adaptacyjne. Próbkowanie adaptacyjne jest domyślnie włączone. Próbkowanie można wyłączyć przy użyciu EnableAdaptiveSampling opcji w opcji ApplicationInsightsServiceOptions

Aby skonfigurować dodatkowe ustawienia próbkowania, można użyć następującego przykładu.

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

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

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

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

Więcej informacji można znaleźć w dokumencie Próbkowanie.

Dodawanie funkcji TelemetryInitializers

Inicjatorów telemetrii należy używać, gdy chcesz zdefiniować właściwości, które są wysyłane ze wszystkimi telemetriami.

Dodanie nowych do TelemetryInitializer kontenera DependencyInjection i zestawu SDK spowoduje ich automatyczne dodanie do kontenera TelemetryConfiguration .

    using Microsoft.ApplicationInsights.Extensibility;

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

Usuwanie telemetriiInitializers

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 funkcji 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 telemetrii można dodać TelemetryConfiguration do programu przy użyciu metody rozszerzenia w pliku AddApplicationInsightsTelemetryProcessor IServiceCollection . Procesorów telemetrii używa się w zaawansowanych scenariuszach filtrowania, aby umożliwić większą bezpośrednią kontrolę nad tym, co jest dołączone lub wykluczone z telemetrii, która jest wysyłana do usługi Application Szczegółowe informacje Service. Użyj poniższego 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

Aplikacja Szczegółowe informacje korzysta z modułów telemetrii, aby automatycznie zbierać dane telemetryczne dotyczące 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 domyślnego zachowania.

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

Aby skonfigurować dowolną domyślną TelemetryModule metodę , użyj metody rozszerzenia w pliku , jak ConfigureTelemetryModule<T> IServiceCollection 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ślny kanał to ServerTelemetryChannel . Można je 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ć wystąpienie za pomocą kontenera wstrzykiwania zależności ASP.NET Core dowolnym miejscu w kodzie i ustawić TelemetryConfiguration dla niego DisableTelemetry flagę.

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

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

Często zadawane pytania

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

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

Czy mogę używać Visual Studio IDE do dołączania aplikacji Szczegółowe informacje do projektu usługi procesu roboczego?

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

Czy mogę włączyć monitorowanie usługi Application Szczegółowe informacje przy użyciu narzędzi takich jak Azure Monitor Application Szczegółowe informacje Agent (wcześniej monitor stanu v2)?

Nie, Azure Monitor Application Szczegółowe informacje Agent aktualnie obsługuje tylko ASP.NET 4.x.

Jeśli uruchamiam moją aplikację w systemie Linux, czy wszystkie funkcje są obsługiwane?

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 Windows z wyjątkiem procesora CPU/pamięci procesu widocznego w metrykach na żywo.
  • Mimo że jest domyślnie włączona, jeśli aplikacja działa w systemie Linux lub macOS, kanał nie tworzy automatycznie lokalnego folderu magazynu w celu tymczasowego przechowywania danych telemetrycznych w przypadku problemów z ServerTelemetryChannel siecią. Z powodu tego ograniczenia dane telemetryczne są utracone w przypadku tymczasowych problemów z siecią lub serwerem. Aby ominąć 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 .NET Core Użyj tego przykładu, jeśli używasz aplikacji konsolowej napisanej na platformie .NET Core (w wersji 2.0 lub wyższej) lub .NET Framework (w wersji 4.7.2 lub wyższej)

ASP.NET Core zadań w tle za pomocą usługi HostedServices Skorzystaj z tego przykładu, jeśli korzystasz ASP.NET Core 2.1/2.2 i tworzysz zadania w tle zgodnie z oficjalnymi wskazówkami w tym miejscu

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

Zestaw SDK typu open source

Aby uzyskać najnowsze aktualizacje i poprawki usterek, zapoznaj się z informacjami o wersji.

Następne kroki