Application Insights för Worker Service-program (icke-HTTP-program)

Artikel
01/31/2024

Application Insights SDK för Worker Service är ett nytt SDK som passar bäst för icke-HTTP-arbetsbelastningar som meddelanden, bakgrundsuppgifter och konsolprogram. Dessa typer av program har inte begreppet inkommande HTTP-begäran som en traditionell ASP.NET/ASP.NET Core-webbapp. Därför stöds inte användning av Application Insights-paket för ASP.NET eller ASP.NET Core-program .

Kommentar

Följande dokumentation förlitar sig på det klassiska API:et Application Insights. Den långsiktiga planen för Application Insights är att samla in data med OpenTelemetry. Mer information finns i Aktivera Azure Monitor OpenTelemetry för .NET-, Node.js-, Python- och Java-program.

Den nya SDK:n gör ingen telemetrisamling på egen hand. I stället finns det andra välkända automatiska Application Insights-insamlare som DependencyCollector, PerfCounterCollector och ApplicationInsightsLoggingProvider. Detta SDK exponerar tilläggsmetoder på IServiceCollection för att aktivera och konfigurera telemetrisamling.

Stödda scenarier

Application Insights SDK för Worker Service passar bäst för icke-HTTP-program oavsett var eller hur de körs. Om programmet körs och har nätverksanslutning till Azure kan telemetri samlas in. Application Insights-övervakning stöds överallt där .NET Core stöds. Det här paketet kan användas i den nyligen introducerade .NET Core Worker Service, bakgrundsuppgifter i ASP.NET Core och konsolappar som .NET Core och .NET Framework.

Förutsättningar

Du måste ha en giltig Application Insights-anslutningssträng. Den här strängen krävs för att skicka telemetri till Application Insights. Om du behöver skapa en ny Application Insights-resurs för att få en anslutningssträng kan du läsa Anslut ionssträngar.

Kommentar

Stödet för inmatning av instrumentationsnycklar upphör den 31 mars 2025. Inmatningen av instrumenteringsnyckeln fortsätter att fungera, men vi kommer inte längre att tillhandahålla uppdateringar eller stöd för funktionen. Övergå till anslutningssträng för att dra nytta av nya funktioner.

Använda Application Insights SDK för Worker Service

Installera Microsoft.ApplicationInsights.WorkerService-paketet i programmet. Följande kodfragment visar de ändringar som måste läggas till i projektets .csproj fil:
```
    <ItemGroup>
        <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.22.0" />
    </ItemGroup>
```
Konfigurera anslutningssträng i APPLICATIONINSIGHTS_CONNECTION_STRING miljövariabeln eller i konfigurationen (appsettings.json).
Hämta en ILogger instans eller TelemetryClient instans från di-containern (Dependency Injection) genom att anropa serviceProvider.GetRequiredService<TelemetryClient>(); eller använda Konstruktorinmatning. Det här steget utlöser konfiguration av TelemetryConfiguration moduler för automatisk insamling.

Specifika instruktioner för varje typ av program beskrivs i följande avsnitt.

.NET Core Worker Service-program

Det fullständiga exemplet delas på NuGet-webbplatsen.

Ladda ned och installera .NET SDK.
Skapa ett nytt Worker Service-projekt antingen med hjälp av en ny Visual Studio-projektmall eller kommandoraden dotnet new worker.
Lägg till paketet Microsoft.ApplicationInsights.WorkerService i programmet.

Lägg till services.AddApplicationInsightsTelemetryWorkerService(); i CreateHostBuilder() -metoden i klassen Program.cs , som i det här exemplet:

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

Ändra enligt Worker.cs följande exempel:

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

Konfigurera anslutningssträng.

Kommentar

Vi rekommenderar att du anger anslutningssträng i konfigurationen. Följande kodexempel visar hur du anger en anslutningssträng i appsettings.json. Kontrollera att appsettings.json den kopieras till programmets rotmapp under publiceringen.

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

Du kan också ange anslutningssträng i APPLICATIONINSIGHTS_CONNECTION_STRING miljövariabeln.

APPLICATIONINSIGHTS_CONNECTION_STRING Anger vanligtvis anslutningssträng för program som distribueras till webbappar som webbjobb.

Kommentar

En anslutningssträng som anges i kod har företräde framför miljövariabeln APPLICATIONINSIGHTS_CONNECTION_STRING, som har företräde framför andra alternativ.

ASP.NET Grundläggande bakgrundsaktiviteter med värdbaserade tjänster

Det här dokumentet beskriver hur du skapar bakgrundsaktiviteter i ett ASP.NET Core-program.

Det fullständiga exemplet delas på den här GitHub-sidan.

Installera Microsoft.ApplicationInsights.WorkerService-paketet i programmet.

Lägg till services.AddApplicationInsightsTelemetryWorkerService(); i ConfigureServices() metoden, som i det här exemplet:

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

Följande kod är för TimedHostedService, där bakgrundsaktivitetslogik finns:

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

Konfigurera anslutningssträng. Använd samma appsettings.json sak från föregående .NET Worker Service-exempel.

.NET Core/.NET Framework-konsolprogram

Som vi nämnde i början av den här artikeln kan det nya paketet användas för att aktivera Application Insights-telemetri från även ett vanligt konsolprogram. Det här paketet är avsett netstandard2.0för , så att det kan användas för konsolappar i .NET Core eller senare och .NET Framework eller senare.

Det fullständiga exemplet delas på den här GitHub-sidan.

Installera Microsoft.ApplicationInsights.WorkerService-paketet i programmet.

Ändra Program.cs enligt följande exempel:

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

Det här konsolprogrammet använder också samma standard TelemetryConfiguration. Den kan anpassas på samma sätt som exemplen i tidigare avsnitt.

Köra ditt program

Kör programmet. Arbetarna från alla föregående exempel gör ett HTTP-anrop varje sekund för att bing.com och genererar även några loggar med hjälp ILoggerav . Dessa rader omsluts i anropet StartOperation för TelemetryClient, som används för att skapa en åtgärd. I det här exemplet RequestTelemetry heter "operation".

Application Insights samlar in dessa ILogger-loggar med allvarlighetsgraden Varning eller högre som standard och beroenden. De är korrelerade med RequestTelemetry en överordnad-underordnad relation. Korrelation fungerar också över process-/nätverksgränser. Om anropet till en annan övervakad komponent till exempel korreleras till den överordnade komponenten.

Den här anpassade åtgärden RequestTelemetry kan betraktas som motsvarigheten till en inkommande webbbegäran i ett typiskt webbprogram. Det är inte nödvändigt att använda en åtgärd, men den passar bäst med Application Insights korrelationsdatamodell. RequestTelemetry fungerar som den överordnade åtgärden och varje telemetri som genereras i arbets iterationen behandlas som logiskt tillhör samma åtgärd.

Den här metoden säkerställer också att all telemetri som genereras, både automatisk och manuell, har samma operation_id. Eftersom sampling baseras på operation_idbehåller eller släpper samplingsalgoritmen antingen all telemetri från en enda iteration.

I följande avsnitt visas den fullständiga telemetri som samlas in automatiskt av Application Insights.

Live Metrics

Live-mått kan användas för att snabbt kontrollera om Application Insights-övervakning har konfigurerats korrekt. Även om det kan ta några minuter innan telemetri visas i portalen och analys, visar Live Metrics CPU-användning av körningsprocessen nästan i realtid. Den kan också visa andra telemetrier som begäranden, beroenden och spårningar.

ILogger-loggar

Loggar som genereras via ILogger med allvarlighetsgraden Varning eller större registreras automatiskt. Om du vill ändra det här beteendet åsidosätter du uttryckligen loggningskonfigurationen för providern ApplicationInsights, enligt följande kod. Med följande konfiguration kan Application Insights samla in alla Information loggar och allvarligare loggar.

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

Observera att följande exempel inte gör att Application Insights-providern samlar in Information loggar. Den samlar inte in den eftersom SDK lägger till ett standardloggningsfilter som instruerar ApplicationInsights att endast Warning avbilda loggar och allvarligare loggar. Application Insights kräver en explicit åsidosättning.

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

Mer information finns i ILogger-dokument för att anpassa vilka loggnivåer som samlas in av Application Insights.

Beroenden

Beroendeinsamling är aktiverat som standard. Artikeln Beroendespårning i Application Insights förklarar de beroenden som samlas in automatiskt och innehåller även steg för att utföra manuell spårning.

EventCounter

EventCounterCollectionModule är aktiverat som standard och samlar in en standarduppsättning räknare från .NET-appar . I självstudiekursen för EventCounter visas standarduppsättningen med insamlade räknare. Den har också instruktioner för hur du anpassar listan.

Spåra annan telemetri manuellt

Även om SDK automatiskt samlar in telemetri enligt beskrivningen måste du i de flesta fall skicka annan telemetri till Application Insights. Det rekommenderade sättet att spåra annan telemetri är genom att hämta en instans av TelemetryClient från Beroendeinmatning och sedan anropa någon av de API-metoder som stöds TrackXXX()på den. Ett annat vanligt användningsfall är anpassad spårning av åtgärder. Den här metoden visas i föregående arbetsexempel.

Konfigurera Application Insights SDK

Standardvärdet TelemetryConfiguration som används av Worker Service SDK liknar den automatiska konfiguration som används i ett ASP.NET- eller ASP.NET Core-program, minus telemetriinitierarna som används för att berika telemetri från HttpContext.

Du kan anpassa Application Insights SDK för Worker Service för att ändra standardkonfigurationen. Användare av Application Insights ASP.NET Core SDK kanske är bekanta med att ändra konfigurationen med hjälp av ASP.NET inbyggd core-beroendeinmatning. Worker Service SDK baseras också på liknande principer. Gör nästan alla konfigurationsändringar i ConfigureServices() avsnittet genom att anropa lämpliga metoder på IServiceCollection, enligt beskrivningen i nästa avsnitt.

Kommentar

När du använder den här SDK:t stöds inte ändring av konfiguration genom att TelemetryConfiguration.Active ändra och ändringar återspeglas inte.

Använda ApplicationInsightsServiceOptions

Du kan ändra några vanliga inställningar genom att skicka ApplicationInsightsServiceOptions till AddApplicationInsightsTelemetryWorkerService, som i det här exemplet:

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

I ApplicationInsightsServiceOptions denna SDK finns i namnområdet Microsoft.ApplicationInsights.WorkerService i stället för Microsoft.ApplicationInsights.AspNetCore.Extensions i ASP.NET Core SDK.

I följande tabell visas vanliga inställningar i ApplicationInsightsServiceOptions.

Inställning	beskrivning	Standard
EnableQuickPulseMetricStream	Aktivera/inaktivera funktionen Live Metrics.	Sant
EnableAdaptiveSampling	Aktivera/inaktivera anpassningsbar sampling.	Sant
EnableHeartbeat	Aktivera/inaktivera funktionen Pulsslag, som regelbundet (15 min standard) skickar ett anpassat mått med namnet "HeartBeatState" med information om körningen, till exempel .NET-version och Azure-miljö, om tillämpligt.	Sant
AddAutoCollectedMetricExtractor	Aktivera/inaktivera AutoCollectedMetrics-extraktorn, som är en telemetriprocessor som skickar föraggregerade mått om begäranden/beroenden innan sampling sker.	Sant
EnableDiagnosticsTelemetryModule	Aktivera/inaktivera `DiagnosticsTelemetryModule`. Om du inaktiverar den här inställningen ignoreras följande inställningar: `EnableHeartbeat`, `EnableAzureInstanceMetadataTelemetryModule`och `EnableAppServicesHeartbeatTelemetryModule`.	Sant

Den senaste listan finns i de konfigurerbara inställningarna i ApplicationInsightsServiceOptions.

Sampling

Application Insights SDK för Worker Service stöder både fast sampling och anpassningsbar sampling. Anpassningsbar sampling är aktiverat som standard. Sampling kan inaktiveras med hjälp EnableAdaptiveSampling av alternativet i ApplicationInsightsServiceOptions.

Om du vill konfigurera andra samplingsinställningar kan du använda följande exempel:

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

Mer information finns i samplingsdokumentet.

Lägga till telemetriinitierare

Använd telemetriinitierare när du vill definiera egenskaper som skickas med all telemetri.

Lägg till en ny telemetriinitierare i containern DependencyInjection och SDK lägger automatiskt till dem i TelemetryConfiguration.

    using Microsoft.ApplicationInsights.Extensibility;

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

Ta bort telemetriinitierare

Telemetriinitierare finns som standard. Om du vill ta bort alla eller specifika telemetriinitierare använder du följande exempelkod efter att du har anropat 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));
   }

Lägga till telemetriprocessorer

Du kan lägga till anpassade telemetriprocessorer TelemetryConfiguration i med hjälp av tilläggsmetoden AddApplicationInsightsTelemetryProcessor på IServiceCollection. Du använder telemetriprocessorer i avancerade filtreringsscenarier för att ge mer direkt kontroll över vad som ingår eller undantas från telemetrin som du skickar till Application Insights. Använd följande exempel:

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

Konfigurera eller ta bort standardtelemetrimoduler

Application Insights använder telemetrimoduler för att automatiskt samla in telemetri om specifika arbetsbelastningar utan att kräva manuell spårning.

Följande moduler för automatisk insamling är aktiverade som standard. Dessa moduler ansvarar för att automatiskt samla in telemetri. Du kan inaktivera eller konfigurera dem för att ändra deras standardbeteende.

DependencyTrackingTelemetryModule
PerformanceCollectorModule
QuickPulseTelemetryModule
AppServicesHeartbeatTelemetryModule (Det finns för närvarande ett problem med den här telemetrimodulen. En tillfällig lösning finns i GitHub Issue 1689.)
AzureInstanceMetadataTelemetryModule

Om du vill konfigurera en standardtelemetrimodul använder du tilläggsmetoden ConfigureTelemetryModule<T> på IServiceCollection, som du ser i följande exempel:

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

Konfigurera telemetrikanalen

Standardkanalen är ServerTelemetryChannel. Du kan åsidosätta det som visas i följande exempel:

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

Inaktivera telemetri dynamiskt

Om du vill inaktivera telemetri villkorligt och dynamiskt kan du lösa instansen TelemetryConfiguration med en ASP.NET Core-beroendeinmatningscontainer var som helst i koden och ange flaggan på den DisableTelemetry .

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

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

Vanliga frågor och svar

Det här avsnittet innehåller svar på vanliga frågor.

Vilket paket ska jag använda?

.NET Core-appscenario	Paket
Utan HostedServices	WorkerService
Med HostedServices	AspNetCore (inte WorkerService)
Med HostedServices övervakar du endast HostedServices	WorkerService (sällsynt scenario)

Kan HostedServices i en .NET Core-app med hjälp av AspNetCore-paketet få TelemetryClient inmatat i den?

Ja. Konfigurationen delas med resten av webbprogrammet.

Hur kan jag spåra telemetri som inte samlas in automatiskt?

Hämta en instans av med hjälp av TelemetryClient konstruktorinmatning och anropa den metod som krävs TrackXXX() för den. Vi rekommenderar inte att du skapar nya TelemetryClient instanser. En singleton-instans av TelemetryClient är redan registrerad i containern DependencyInjection , som delar TelemetryConfiguration med resten av telemetrin. Att skapa en ny TelemetryClient instans rekommenderas endast om den behöver en konfiguration som är separat från resten av telemetrin.

Kan jag använda Visual Studio IDE för att registrera Application Insights i ett Worker Service-projekt?

Visual Studio IDE-registrering stöds för närvarande endast för ASP.NET/ASP.NET Core-program. Det här dokumentet uppdateras när Visual Studio har stöd för registrering av Worker Service-program.

Kan jag aktivera Application Insights-övervakning med hjälp av verktyg som Azure Monitor Application Insights Agent (tidigare Status Monitor v2)?

Nej. Azure Monitor Application Insights Agent stöder för närvarande endast .NET .

Stöds alla funktioner om jag kör mitt program i Linux?

Ja. Funktionsstöd för denna SDK är detsamma på alla plattformar, med följande undantag:

Prestandaräknare stöds endast i Windows förutom process-CPU/minne som visas i Live Metrics.

Även om ServerTelemetryChannel är aktiverat som standard, om programmet körs i Linux eller macOS, skapar kanalen inte automatiskt en lokal lagringsmapp för att behålla telemetri tillfälligt om det finns nätverksproblem. På grund av den här begränsningen går telemetri förlorad när det finns tillfälliga nätverk eller serverproblem. Du kan undvika det här problemet genom att konfigurera en lokal mapp för kanalen:

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

Exempelprogram

.NET Core-konsolprogram: Använd det här exemplet om du använder ett konsolprogram som skrivits i .NET Core (2.0 eller senare) eller .NET Framework (4.7.2 eller senare).

ASP.NET Grundläggande bakgrundsaktiviteter med HostedServices: Använd det här exemplet om du är i ASP.NET Core och skapar bakgrundsuppgifter i enlighet med officiell vägledning.

.NET Core Worker Service: Använd det här exemplet om du har ett .NET Worker Service-program i enlighet med officiell vägledning.

SDK med öppen källkod

Läsa och bidra till koden.

De senaste uppdateringarna och felkorrigeringarna finns i Viktig information.

Nästa steg

Använd API :et för att skicka egna händelser och mått för en detaljerad vy över appens prestanda och användning.
Spåra fler beroenden som inte spåras automatiskt.
Berika eller filtrera automatiskt insamlad telemetri.
Beroendeinmatning i ASP.NET Core.

Application Insights för Worker Service-program (icke-HTTP-program)

Stödda scenarier

Förutsättningar

Använda Application Insights SDK för Worker Service

.NET Core Worker Service-program

ASP.NET Grundläggande bakgrundsaktiviteter med värdbaserade tjänster

.NET Core/.NET Framework-konsolprogram

Köra ditt program

Live Metrics

ILogger-loggar

Beroenden

EventCounter

Spåra annan telemetri manuellt

Konfigurera Application Insights SDK

Använda ApplicationInsightsServiceOptions

Sampling

Lägga till telemetriinitierare

Ta bort telemetriinitierare

Lägga till telemetriprocessorer

Konfigurera eller ta bort standardtelemetrimoduler

Konfigurera telemetrikanalen

Inaktivera telemetri dynamiskt

Vanliga frågor och svar

Vilket paket ska jag använda?

Kan HostedServices i en .NET Core-app med hjälp av AspNetCore-paketet få TelemetryClient inmatat i den?

Hur kan jag spåra telemetri som inte samlas in automatiskt?

Kan jag använda Visual Studio IDE för att registrera Application Insights i ett Worker Service-projekt?

Kan jag aktivera Application Insights-övervakning med hjälp av verktyg som Azure Monitor Application Insights Agent (tidigare Status Monitor v2)?

Stöds alla funktioner om jag kör mitt program i Linux?

Exempelprogram

SDK med öppen källkod

Nästa steg

Ytterligare resurser