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

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

Den nya SDK:n gör inte någon telemetriinsamling på egen hand. I stället används andra välkända Application Insights auto collectors som DependencyCollector, PerfCounterCollector, ApplicationInsightsLoggingProvider osv. Den här SDK:n exponerar IServiceCollection tilläggsmetoder på för att aktivera och konfigurera telemetriinsamling.

Scenarier som stöds

Application Insights SDK för Worker-tjänsten 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. Program Insights övervakning stöds överallt där .NET Core stöds. Det här paketet kan användas i den nyligen introducerade .NET Core 3.0 Worker Service,bakgrundsaktiviteter i ASP.NET Core 2.1/2.2, konsolappar (.NET Core/ .NET Framework) osv.

Förutsättningar

En giltig Application Insights instrumenteringsnyckel. Den här nyckeln krävs för att skicka telemetri till Application Insights. Om du behöver skapa en ny Application Insights-resurs för att hämta en instrumentationsnyckel kan du gå till Skapa en programresurs Insights programresurs.

Använda Application Insights SDK för Worker Services

  1. Installera paketet Microsoft.ApplicationInsights.WorkerService 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.13.1" />
    </ItemGroup>
  1. Anropa AddApplicationInsightsTelemetryWorkerService(string instrumentationKey) tilläggsmetoden på IServiceCollection och ange instrumentationsnyckeln. Den här metoden ska anropas i början av programmet. Den exakta platsen beror på typen av program.

  2. Hämta en ILogger instans eller instans från TelemetryClient containern Dependency Injection (DI) genom att anropa serviceProvider.GetRequiredService<TelemetryClient>(); eller använda konstruktorinjektion. Det här steget utlöser inställning av TelemetryConfiguration moduler för automatisk insamling och .

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

.NET Core 3.0-arbetstjänstprogram

Ett fullständigt exempel delas här

  1. Ladda ned och installera .NET Core 3.0

  2. Skapa ett nytt Worker Service-projekt med hjälp Visual Studio en ny projektmall eller kommandoraddotnet new worker

  3. Installera paketet Microsoft.ApplicationInsights.WorkerService i programmet.

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

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureServices((hostContext, services) =>
            {
                services.AddHostedService<Worker>();
                services.AddApplicationInsightsTelemetryWorkerService();
            });
  1. Ändra ditt Worker.cs enligt exemplet nedan.
    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. Konfigurera instrumenteringsnyckeln.

    Även om du kan ange instrumenteringsnyckeln som ett argument AddApplicationInsightsTelemetryWorkerService till rekommenderar vi att du anger instrumenteringsnyckeln i konfigurationen. Följande kodexempel visar hur du anger en instrumentationsnyckel i appsettings.json . Se till appsettings.json att kopieras till programmets rotmapp under publiceringen.

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

Du kan också ange instrumenteringsnyckeln i någon av följande miljövariabler. APPINSIGHTS_INSTRUMENTATIONKEY eller ApplicationInsights:InstrumentationKey

Exempelvis: SET ApplicationInsights:InstrumentationKey=putinstrumentationkeyhere ELLER SET APPINSIGHTS_INSTRUMENTATIONKEY=putinstrumentationkeyhere

Anger vanligtvis APPINSIGHTS_INSTRUMENTATIONKEY instrumenteringsnyckeln för program som distribueras till Web Apps som webbjobb.

Anteckning

En instrumentationsnyckel som anges i koden vinner över miljövariabeln APPINSIGHTS_INSTRUMENTATIONKEY , som vinner över andra alternativ.

ASP.NET Core bakgrundsaktiviteter med värdtjänster

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

Ett fullständigt exempel delas här

  1. Installera paketet Microsoft.ApplicationInsights.WorkerService i programmet.
  2. Lägg services.AddApplicationInsightsTelemetryWorkerService(); till i metoden , som i det här ConfigureServices() 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>();

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

Nedan visas koden för TimedHostedService den plats där bakgrundsaktivitetslogiken 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");
            }
        }
    }
  1. Konfigurera instrumenteringsnyckeln. Använd samma som appsettings.json i exemplet med .NET Core 3.0 Worker Service ovan.

.NET Core/.NET Framework Console-program

Som vi nämnde i början av den här artikeln kan det nya paketet användas för att aktivera Application Insights Telemetry från även ett vanligt konsolprogram. Det här paketet riktar sig mot och kan därför användas för konsolappar i NetStandard2.0 .NET Core 2.0 eller senare och .NET Framework 4.7.2 eller senare.

Ett fullständigt exempel delas här

  1. Installera paketet Microsoft.ApplicationInsights.WorkerService i programmet.

  2. Ändra Program.cs enligt exemplet nedan.

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

Det här konsolprogrammet använder också samma TelemetryConfiguration standard och kan anpassas på samma sätt som i exemplen i föregående avsnitt.

Köra ditt program

Kör ditt program. Exempelarbetare från alla ovanstående gör ett HTTP-anrop varje sekund för att bing.com och skickar även några loggar med hjälp av ILogger . Dessa rader är omslutna i StartOperation anropet TelemetryClient av , som används för att skapa en åtgärd (i det här RequestTelemetry exemplet med namnet "operation"). Program Insights samlar in dessa ILogger-loggar (varning eller högre som standard) och beroenden, och de korreleras med relationen RequestTelemetry över-/underordnad. Korrelationen fungerar också mellan processer/nätverksgränser. Om anropet till exempel gjordes till en annan övervakad komponent korreleras det även med den överordnade komponenten.

Den här anpassade åtgärden RequestTelemetry för kan ses som motsvarigheten till en inkommande webbbegäran i en typisk webbapp. Även om det inte är nödvändigt att använda en åtgärd passar den bäst med application Insights-korrelationsdatamodellen – med att fungera som överordnad åtgärd och varje telemetri som genereras i arbets iterationen behandlas som logiskt tillhörande samma RequestTelemetry åtgärd. Den här metoden säkerställer också att all telemetri som genereras (automatisk och manuell) har samma operation_id . Eftersom sampling baseras på behåller eller släpper operation_id samplingsalgoritmen all telemetri från en enda iteration.

Nedan visas den fullständiga telemetri som samlas in automatiskt av Application Insights.

Live Metrics

Live Metrics kan användas för att snabbt kontrollera om programövervakning Insights är korrekt konfigurerad. Det kan ta några minuter innan telemetri börjar visas i portalen och analyser, men livemått visar CPU-användningen av den körande processen nästan i realtid. Den kan också visa annan telemetri som begäranden, beroenden, spårningar osv.

ILogger-loggar

Loggar som genereras med ILogger Warning allvarlighetsgrad eller högre hämtas automatiskt. Följ ILogger-dokument för att anpassa vilka loggnivåer som avbildas av Application Insights.

Beroenden

Beroendesamling är aktiverat som standard. Den här artikeln förklarar de beroenden som samlas in automatiskt och innehåller även steg för att göra manuell spårning.

EventCounter

EventCounterCollectionModule är aktiverat som standard och samlar in en standarduppsättning räknare från .NET Core 3.0-appar. EventCounter-självstudien visar en lista över standarduppsättningen med räknare som samlats in. Den innehåller också anvisningar om hur du anpassar listan.

Spåra ytterligare telemetri manuellt

SDK samlar automatiskt in telemetri enligt förklaringen ovan, men i de flesta fall behöver användaren skicka ytterligare telemetri till Application Insights service. Det rekommenderade sättet att spåra ytterligare telemetri är genom att hämta en instans av från Dependency Injection och sedan anropa en av TelemetryClient TrackXXX() de API-metoder som stöds på den. Ett annat vanligt användningsfall är anpassad spårning av åtgärder. Den här metoden visas i arbetsexempel ovan.

Konfigurera Application Insights SDK

Standardvärdet som används av WORKER-tjänstens SDK liknar den automatiska konfiguration som används i ett ASP.NET- eller TelemetryConfiguration ASP.NET Core-program, minus de TelemetryInitializers som används för att utöka telemetri från HttpContext .

Du kan anpassa Application Insights SDK för Worker-tjänsten om du vill ändra standardkonfigurationen. Användare av Application Insights ASP.NET Core SDK kan vara bekanta med att ändra konfigurationen med hjälp ASP.NET Core inbyggda beroendeinjektion. WorkerService SDK baseras också på liknande principer. Gör nästan alla konfigurationsändringar i ConfigureServices() avsnittet genom att anropa lämpliga metoder på , enligt IServiceCollection beskrivningen nedan.

Anteckning

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

Använda ApplicationInsightsServiceOptions

Du kan ändra några vanliga inställningar genom att skicka ApplicationInsightsServiceOptions till , som i det här AddApplicationInsightsTelemetryWorkerService 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);
}

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

Vanliga inställningar i ApplicationInsightsServiceOptions

Inställning Beskrivning Standardvärde
EnableQuickPulseMetricStream Funktionen Aktivera/inaktivera LiveMetrics true
EnableAdaptiveSampling Aktivera/inaktivera adaptiv sampling true
EnablePatibeat Funktionen Aktivera/inaktivera pulsslag, som regelbundet (15 min standard) skickar ett anpassat mått med namnet "HeartBeatState" med information om körningen som .NET-version, Azure Environment-information, om tillämpligt osv. true
AddAutoCollectedMetricExtractor Enable/Disable AutoCollectedMetrics extractor, som är en TelemetryProcessor som skickar föraggregeringsmått om begäranden/beroenden innan sampling sker. true
EnableDiagnosticsTelemetryModule Aktivera/inaktivera DiagnosticsTelemetryModule . Om du inaktiverar detta ignoreras följande inställningar: EnableHeartbeat, EnableAzureInstanceMetadataTelemetryModule, EnableAppServicesHeartbeatTelemetryModule true

Se de konfigurerbara ApplicationInsightsServiceOptions inställningarna i för den senaste listan.

Samling

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

Följande exempel kan användas för att konfigurera ytterligare samplingsinställningar.

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

Mer information finns i dokumentet Sampling.

Lägga till TelemetryInitializers

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

Om du lägger TelemetryInitializer till nya DependencyInjection i containern läggs de automatiskt till i TelemetryConfiguration .

    using Microsoft.ApplicationInsights.Extensibility;

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

Ta bort TelemetryInitializers

Telemetriinitierare finns som standard. Om du vill ta bort alla eller specifika telemetriinitierare använder du följande exempelkod när 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 till med hjälp av tilläggsmetoden på AddApplicationInsightsTelemetryProcessor IServiceCollection . Du använder telemetriprocessorer i avancerade filtreringsscenarier för att ge mer direkt kontroll över vad som ingår eller exkluderas från telemetrin som du skickar till Application Insights Service. 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

Program Insights använder telemetrimoduler för att automatiskt samla in telemetri om specifika arbetsbelastningar utan 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 är för närvarande problem med den här telemetrimodulen. En tillfällig lösning finns i GitHub 1689.)
  • AzureInstanceMetadataTelemetryModule

Om du vill konfigurera TelemetryModule en standard använder du ConfigureTelemetryModule<T> tilläggsmetoden på , som du ser IServiceCollection 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 telemetrikanal

Standardkanalen är ServerTelemetryChannel . Du kan åsidosätta den på det sätt 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 med en ASP.NET Core beroendeinjektionscontainer var som helst i koden och TelemetryConfiguration ange en flagga för DisableTelemetry den.

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

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

Vanliga frågor och svar

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

Hämta en instans av TelemetryClient med hjälp av konstruktorinjektion och anropa den TrackXXX() nödvändiga metoden på den. Vi rekommenderar inte att du skapar TelemetryClient nya instanser. En singleton-instans TelemetryClient av har redan registrerats i DependencyInjection containern, som TelemetryConfiguration delar med resten av telemetrin. Vi rekommenderar bara att du skapar en ny instans om den behöver en konfiguration som är separat TelemetryClient från resten av telemetrin.

Kan jag använda Visual Studio IDE för att publicera Application Insights till 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 för registrering av Worker-tjänstprogram.

Kan jag aktivera övervakning Insights programövervakning med verktyg som Azure Monitor Application Insights Agent (tidigare Statusövervakare v2)?

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

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

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

  • Prestandaräknare stöds endast i Windows med undantag för process-CPU/minne som visas i Live Metrics.
  • Även om är aktiverat som standard skapar inte kanalen automatiskt en lokal lagringsmapp för att tillfälligt behålla telemetri om det finns nätverksproblem om programmet körs i Linux eller ServerTelemetryChannel macOS. På grund av den här begränsningen går telemetri förlorad om det finns tillfälliga problem med nätverk eller servrar. Du kan komma runt 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 antingen .NET Core (2.0 eller senare) eller .NET Framework (4.7.2 eller senare)

ASP.NET Core bakgrundsaktiviteter med HostedServices Använd det här exemplet om du är i ASP.NET Core 2.1/2.2 och skapar bakgrundsaktiviteter enligt officiell vägledning här

.NET Core 3.0 Worker Service Använd det här exemplet om du har ett .NET Core 3.0 Worker Service-program enligt den officiella vägledningen här

SDK med öppen källkod

De senaste uppdateringarna och felkorrigeringarna finns i den viktiga informationen.

Nästa steg