Application Insights voor Werkservicetoepassingen (niet-HTTP-toepassingen)

Artikel
09/13/2024

Application Insights SDK voor Worker Service is een nieuwe SDK, die het meest geschikt is voor niet-HTTP-workloads, zoals berichten, achtergrondtaken en consoletoepassingen. Deze typen toepassingen hebben geen idee van een binnenkomende HTTP-aanvraag, zoals een traditionele ASP.NET/ASP.NET Core-webtoepassing. Daarom wordt het gebruik van Application Insights-pakketten voor ASP.NET of ASP.NET Core-toepassingen niet ondersteund.

Notitie

De volgende documentatie is afhankelijk van de klassieke Application Insights-API. Het langetermijnplan voor Application Insights is het verzamelen van gegevens met behulp van OpenTelemetry. Zie Azure Monitor OpenTelemetry inschakelen voor .NET-, Node.js-, Python- en Java-toepassingen en onze OpenTelemetry Roadmap voor meer informatie. Migratierichtlijnen zijn beschikbaar voor .NET, Node.js en Python.

De nieuwe SDK voert zelf geen telemetrieverzameling uit. In plaats daarvan worden andere bekende automatische Collectors van Application Insights, zoals DependencyCollector, PerfCounterCollector en ApplicationInsightsLoggingProvider, opgenomen. Met deze SDK worden extensiemethoden beschikbaar gesteld IServiceCollection voor het inschakelen en configureren van telemetrieverzameling.

Ondersteunde scenario's

De Application Insights SDK voor Worker Service is het meest geschikt voor niet-HTTP-toepassingen, ongeacht waar of hoe ze worden uitgevoerd. Als uw toepassing wordt uitgevoerd en een netwerkverbinding met Azure heeft, kan telemetrie worden verzameld. Application Insights-bewaking wordt overal ondersteund waar .NET Core wordt ondersteund. Dit pakket kan worden gebruikt in de zojuist geïntroduceerde .NET Core Worker Service, achtergrondtaken in ASP.NET Core en console-apps zoals .NET Core en .NET Framework.

Vereisten

U moet een geldige Application Insights-verbindingsreeks hebben. Deze tekenreeks is vereist voor het verzenden van telemetrie naar Application Insights. Als u een nieuwe Application Insights-resource moet maken om een verbindingsreeks op te halen, raadpleegt u Verbindingsreeksen.

Notitie

Op 31 maart 2025 eindigt de ondersteuning voor opname van instrumentatiesleutels. Opname van instrumentatiesleutels blijft werken, maar we bieden geen updates of ondersteuning meer voor de functie. Overgang naar verbindingsreeks s om te profiteren van nieuwe mogelijkheden.

Application Insights SDK voor Worker Service gebruiken

Installeer het pakket Microsoft.ApplicationInsights.WorkerService in de toepassing. In het volgende fragment ziet u de wijzigingen die moeten worden toegevoegd aan het .csproj projectbestand:
```
    <ItemGroup>
        <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.22.0" />
    </ItemGroup>
```
Configureer de verbindingsreeks in de APPLICATIONINSIGHTS_CONNECTION_STRING omgevingsvariabele of in de configuratie (appsettings.json).
Haal een ILogger exemplaar of TelemetryClient exemplaar op uit de container Afhankelijkheidsinjectie (DI) door aan te roepen serviceProvider.GetRequiredService<TelemetryClient>(); of door constructorinjectie te gebruiken. Met deze stap wordt het instellen en automatisch verzamelen van TelemetryConfiguration modules geactiveerd.

Specifieke instructies voor elk type toepassing worden beschreven in de volgende secties.

.NET Core Worker Service-toepassing

Het volledige voorbeeld wordt gedeeld op de NuGet-website.

Download en installeer de .NET SDK.
Maak een nieuw Worker Service-project met behulp van een nieuwe Visual Studio-projectsjabloon of de opdrachtregel dotnet new worker.
Voeg het pakket Microsoft.ApplicationInsights.WorkerService toe aan de toepassing.

Voeg services.AddApplicationInsightsTelemetryWorkerService(); toe aan de CreateHostBuilder() methode in uw Program.cs klasse, zoals in dit voorbeeld:

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

Wijzig uw Worker.cs gegevens volgens het volgende voorbeeld:

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

Stel de verbindingsreeks in.

Notitie

U wordt aangeraden de verbindingsreeks in de configuratie op te geven. In het volgende codevoorbeeld ziet u hoe u een verbindingsreeks kunt opgeven in appsettings.json. Zorg ervoor dat appsettings.json deze tijdens het publiceren naar de hoofdmap van de toepassing wordt gekopieerd.
```
    {
        "ApplicationInsights":
        {
            "ConnectionString" : "InstrumentationKey=00000000-0000-0000-0000-000000000000;"
        },
        "Logging":
        {
            "LogLevel":
            {
                "Default": "Warning"
            }
        }
    }
```

U kunt ook de verbindingsreeks in de APPLICATIONINSIGHTS_CONNECTION_STRING omgevingsvariabele opgeven.

APPLICATIONINSIGHTS_CONNECTION_STRING Hiermee geeft u doorgaans de verbindingsreeks op voor toepassingen die zijn geïmplementeerd in web-apps als webtaken.

Notitie

Een verbindingsreeks die is opgegeven in code heeft voorrang op de omgevingsvariabeleAPPLICATIONINSIGHTS_CONNECTION_STRING, die voorrang heeft op andere opties.

ASP.NET Kernachtergrondtaken met gehoste services

In dit document wordt beschreven hoe u achtergrondtaken maakt in een ASP.NET Core-toepassing.

Het volledige voorbeeld wordt gedeeld op deze GitHub-pagina.

Installeer het pakket Microsoft.ApplicationInsights.WorkerService in de toepassing.

Voeg services.AddApplicationInsightsTelemetryWorkerService(); toe aan de ConfigureServices() methode, zoals in dit voorbeeld:

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

De volgende code is bedoeld voor TimedHostedService, waarbij de achtergrondtaaklogica zich bevindt:

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

Stel de verbindingsreeks in. Gebruik hetzelfde appsettings.json uit het voorgaande .NET Worker Service-voorbeeld.

.NET Core/.NET Framework-consoletoepassing

Zoals vermeld in het begin van dit artikel, kan het nieuwe pakket worden gebruikt om Application Insights-telemetrie vanuit zelfs een gewone consoletoepassing in te schakelen. Dit pakket is bedoeld netstandard2.0, zodat het kan worden gebruikt voor console-apps in .NET Core of hoger, en .NET Framework of hoger.

Het volledige voorbeeld wordt gedeeld op deze GitHub-pagina.

Installeer het pakket Microsoft.ApplicationInsights.WorkerService in de toepassing.

Wijzig Program.cs zoals wordt weergegeven in het volgende voorbeeld:

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

Deze consoletoepassing maakt ook gebruik van dezelfde standaardwaarde TelemetryConfiguration. Het kan op dezelfde manier worden aangepast als de voorbeelden in eerdere secties.

Uw toepassing uitvoeren

Voer uw toepassing uit. De werknemers uit alle voorgaande voorbeelden maken elke seconde een HTTP-aanroep naar bing.com en verzenden ook enkele logboeken met behulp van ILogger. Deze regels worden verpakt in de StartOperation aanroep van TelemetryClient, die wordt gebruikt om een bewerking te maken. In dit voorbeeld RequestTelemetry heet 'bewerking'.

Application Insights verzamelt deze ILogger-logboeken, met standaard de ernst Waarschuwing of hoger, en afhankelijkheden. Ze zijn gecorreleerd met RequestTelemetry een relatie tussen bovenliggende en onderliggende items. Correlatie werkt ook tussen proces-/netwerkgrenzen. Als de aanroep bijvoorbeeld is uitgevoerd naar een ander bewaakt onderdeel, is deze ook gecorreleerd aan dit bovenliggende onderdeel.

Deze aangepaste bewerking RequestTelemetry kan worden beschouwd als het equivalent van een binnenkomende webaanvraag in een typische webtoepassing. Het is niet nodig om een bewerking te gebruiken, maar het past het beste bij het Application Insights-correlatiegegevensmodel. RequestTelemetry fungeert als de bovenliggende bewerking en elke telemetrie die in de iteratie van de werkrol wordt gegenereerd, wordt behandeld als logisch behorend tot dezelfde bewerking.

Deze aanpak zorgt er ook voor dat alle gegenereerde telemetrie, zowel automatisch als handmatig, hetzelfde operation_idheeft. Omdat steekproeven zijn gebaseerd op operation_id, houdt het sampling-algoritme alle telemetriegegevens van één iteratie bij of verwijdert deze.

De volgende secties bevatten de volledige telemetrie die automatisch wordt verzameld door Application Insights.

Live metrische gegevens

Live metrische gegevens kunnen worden gebruikt om snel te controleren of toepassingsbewaking met Application Insights correct is geconfigureerd. Het kan enkele minuten duren voordat telemetrie wordt weergegeven in Azure Portal, maar in het deelvenster met livegegevens wordt het CPU-gebruik van het actieve proces bijna in realtime weergegeven. Er kunnen ook andere telemetriegegevens worden weergegeven, zoals aanvragen, afhankelijkheden en traceringen.

ILogger-logboeken

Logboeken die worden verzonden via ILogger de ernstwaarschuwing of hoger, worden automatisch vastgelegd. Als u dit gedrag wilt wijzigen, overschrijft u expliciet de logboekconfiguratie voor de provider ApplicationInsights, zoals wordt weergegeven in de volgende code. Met de volgende configuratie kan Application Insights alle Information logboeken en ernstigere logboeken vastleggen.

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

Het is belangrijk te weten dat in het volgende voorbeeld de Application Insights-provider geen logboeken kan vastleggen Information . Deze wordt niet vastgelegd omdat de SDK een standaardlogboekfilter toevoegt ApplicationInsights waarmee alleen Warning logboeken en ernstigere logboeken kunnen worden vastgelegd. Application Insights vereist een expliciete onderdrukking.

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

Volg ILogger-documenten voor meer informatie om aan te passen welke logboekniveaus worden vastgelegd door Application Insights.

Afhankelijkheden

Verzameling afhankelijkheden is standaard ingeschakeld. In het artikel Afhankelijkheidstracering in Application Insights worden de afhankelijkheden uitgelegd die automatisch worden verzameld en bevat ook de stappen voor het handmatig bijhouden van gegevens.

EventCounter

EventCounterCollectionModule is standaard ingeschakeld en er wordt een standaardset meteritems van .NET-apps verzameld. De zelfstudie EventCounter bevat de standaardset met tellers die worden verzameld. Het bevat ook instructies voor het aanpassen van de lijst.

Andere telemetrie handmatig bijhouden

Hoewel de SDK automatisch telemetrie verzamelt zoals uitgelegd, moet u in de meeste gevallen andere telemetrie verzenden naar Application Insights. De aanbevolen manier om andere telemetrie bij te houden, is door een exemplaar van TelemetryClient afhankelijkheidsinjectie te verkrijgen en vervolgens een van de ondersteunde TrackXXX() API-methoden erop aan te roepen. Een andere typische use-case is aangepaste tracering van bewerkingen. Deze benadering wordt gedemonstreerd in de voorgaande werkrolvoorbeelden.

De Application Insights-SDK configureren

De standaardinstelling TelemetryConfiguration die door de Worker Service SDK wordt gebruikt, is vergelijkbaar met de automatische configuratie die wordt gebruikt in een ASP.NET of ASP.NET Core-toepassing, minus de telemetrie-initialisatiefuncties die worden gebruikt om telemetrie te verrijken.HttpContext

U kunt de Application Insights SDK voor Worker Service aanpassen om de standaardconfiguratie te wijzigen. Gebruikers van de Application Insights ASP.NET Core SDK zijn mogelijk bekend met het wijzigen van de configuratie met behulp van ingebouwde afhankelijkheidsinjectie van ASP.NET Core. De Worker Service SDK is ook gebaseerd op vergelijkbare principes. Breng bijna alle configuratiewijzigingen in de ConfigureServices() sectie aan door de juiste methoden aan IServiceCollectionte roepen, zoals beschreven in de volgende sectie.

Notitie

Wanneer u deze SDK gebruikt, wordt het wijzigen van de configuratie door wijzigen TelemetryConfiguration.Active niet ondersteund en worden wijzigingen niet doorgevoerd.

ApplicationInsightsServiceOptions gebruiken

U kunt enkele algemene instellingen wijzigen door dit door te geven ApplicationInsightsServiceOptions aan AddApplicationInsightsTelemetryWorkerService, zoals in dit voorbeeld:

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

De ApplicationInsightsServiceOptions in deze SDK bevindt zich in de naamruimte Microsoft.ApplicationInsights.WorkerService in plaats Microsoft.ApplicationInsights.AspNetCore.Extensions van in de ASP.NET Core SDK.

De volgende tabel bevat veelgebruikte instellingen in ApplicationInsightsServiceOptions.

Instelling	Beschrijving	Standaard
EnableQuickPulseMetricStream	Schakel de functie voor live metrische gegevens in of uit.	Waar
EnableAdaptiveSampling	Adaptieve steekproeven in- of uitschakelen.	Waar
EnableHeartbeat	Schakel de Heartbeats-functie in of uit, die periodiek (standaard 15 minuten) een aangepaste metriek met de naam HeartBeatState verzendt met informatie over de runtime, zoals .NET-versie en Azure-omgeving, indien van toepassing.	Waar
AddAutoCollectedMetricExtractor	Schakel de AutoCollectedMetrics-extractor in of uit. Dit is een telemetrieprocessor die vooraf geaggregeerde metrische gegevens over aanvragen/afhankelijkheden verzendt voordat er steekproeven worden genomen.	Waar
EnableDiagnosticsTelemetryModule	In- en uitschakelen `DiagnosticsTelemetryModule`. Als u deze instelling uitschakelt, worden de volgende instellingen genegeerd: `EnableHeartbeat`, `EnableAzureInstanceMetadataTelemetryModule`en `EnableAppServicesHeartbeatTelemetryModule`.	Waar

Zie de configureerbare instellingen in ApplicationInsightsServiceOptionsvoor de meest recente lijst.

Steekproeven

De Application Insights SDK voor Worker Service ondersteunt zowel sampling met vaste frequentie als adaptieve steekproeven. Adaptieve steekproeven zijn standaard ingeschakeld. Steekproeven kunnen worden uitgeschakeld met behulp van de EnableAdaptiveSampling optie in ApplicationInsightsServiceOptions.

Als u andere steekproefinstellingen wilt configureren, kunt u het volgende voorbeeld gebruiken:

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

Zie het samplingdocument voor meer informatie.

Telemetrie-initialisatiefuncties toevoegen

Gebruik initialisatiefuncties voor telemetrie wanneer u eigenschappen wilt definiëren die met alle telemetriegegevens worden verzonden.

Voeg nieuwe initialisatiefunctie voor telemetrie toe aan de DependencyInjection container en de SDK voegt deze automatisch toe aan TelemetryConfiguration.

    using Microsoft.ApplicationInsights.Extensibility;

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

Telemetrie-initialisatiefuncties verwijderen

Telemetrie-initialisatiefuncties zijn standaard aanwezig. Als u alle of specifieke telemetrie-initialisatiefuncties wilt verwijderen, gebruikt u de volgende voorbeeldcode na het aanroepen 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));
   }

Telemetrieprocessors toevoegen

U kunt aangepaste telemetrieprocessors TelemetryConfiguration toevoegen met behulp van de extensiemethode AddApplicationInsightsTelemetryProcessor op IServiceCollection. U gebruikt telemetrieprocessors in geavanceerde filterscenario's om meer directe controle te bieden over wat is opgenomen of uitgesloten van de telemetrie die u naar Application Insights verzendt. Gebruik het volgende voorbeeld:

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

Standaardtelemetriemodules configureren of verwijderen

Application Insights maakt gebruik van telemetriemodules om automatisch telemetrie over specifieke werkbelastingen te verzamelen zonder handmatig bij te houden.

De volgende modules voor automatisch verzamelen zijn standaard ingeschakeld. Deze modules zijn verantwoordelijk voor het automatisch verzamelen van telemetrie. U kunt ze uitschakelen of configureren om hun standaardgedrag te wijzigen.

DependencyTrackingTelemetryModule
PerformanceCollectorModule
QuickPulseTelemetryModule
AppServicesHeartbeatTelemetryModule(Er is momenteel een probleem met deze telemetriemodule. Zie GitHub-probleem 1689 voor een tijdelijke tijdelijke oplossing.)
AzureInstanceMetadataTelemetryModule

Als u een standaardtelemetriemodule wilt configureren, gebruikt u de extensiemethode ConfigureTelemetryModule<T> op IServiceCollection, zoals wordt weergegeven in het volgende voorbeeld:

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

Het telemetriekanaal configureren

Het standaardkanaal is ServerTelemetryChannel. U kunt deze overschrijven, zoals in het volgende voorbeeld wordt weergegeven:

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

Telemetrie dynamisch uitschakelen

Als u telemetrie voorwaardelijk en dynamisch wilt uitschakelen, kunt u het TelemetryConfiguration exemplaar oplossen met een ASP.NET Container voor kernafhankelijkheidsinjectie overal in uw code en de DisableTelemetry vlag erop instellen.

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

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

Veelgestelde vragen

In deze sectie vindt u antwoorden op veelgestelde vragen.

Welk pakket moet ik gebruiken?

.NET Core-app-scenario	Pakket
Zonder HostedServices	WorkerService
Met HostedServices	AspNetCore (niet WorkerService)
Met HostedServices alleen HostedServices bewaken	WorkerService (zeldzaam scenario)

Kan HostedServices in een .NET Core-app met behulp van het AspNetCore-pakket TelemetryClient erin hebben geïnjecteerd?

Ja. De configuratie wordt gedeeld met de rest van de webtoepassing.

Hoe kan ik telemetrie bijhouden die niet automatisch wordt verzameld?

Haal een exemplaar op van het gebruik van TelemetryClient constructorinjectie en roep de vereiste TrackXXX() methode erop aan. We raden u niet aan om nieuwe TelemetryClient exemplaren te maken. Er is al een singleton-instantie geregistreerd TelemetryClient in de DependencyInjection container, die wordt gedeeld TelemetryConfiguration met de rest van de telemetrie. Het maken van een nieuw TelemetryClient exemplaar wordt alleen aanbevolen als er een configuratie nodig is die losstaat van de rest van de telemetrie.

Kan ik Visual Studio IDE gebruiken om Application Insights aan een Worker Service-project te onboarden?

Onboarding van Visual Studio IDE wordt momenteel alleen ondersteund voor ASP.NET/ASP.NET Core-toepassingen. Dit document wordt bijgewerkt wanneer Visual Studio ondersteuning biedt voor onboarding Worker Service-toepassingen.

Kan ik Application Insights-bewaking inschakelen met behulp van hulpprogramma's zoals Azure Monitor Application Insights Agent (voorheen Status Monitor v2)?

Nee De Azure Monitor Application Insights-agent ondersteunt momenteel alleen .NET .

Worden alle functies ondersteund als ik mijn toepassing in Linux uitvoer?

Ja. Functieondersteuning voor deze SDK is op alle platforms hetzelfde, met de volgende uitzonderingen:

Prestatiemeteritems worden alleen ondersteund in Windows, met uitzondering van cpu/geheugen verwerken die worden weergegeven in live metrische gegevens.

ServerTelemetryChannel Hoewel de toepassing standaard is ingeschakeld in Linux of macOS, maakt het kanaal niet automatisch een lokale opslagmap om telemetrie tijdelijk te bewaren als er netwerkproblemen zijn. Vanwege deze beperking gaat telemetrie verloren wanneer er tijdelijke netwerk- of serverproblemen zijn. U kunt dit probleem omzeilen door een lokale map voor het kanaal te configureren:

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

Voorbeeldtoepassingen

.NET Core-consoletoepassing: gebruik dit voorbeeld als u een consoletoepassing gebruikt die is geschreven in .NET Core (2.0 of hoger) of .NET Framework (4.7.2 of hoger).

ASP.NET Kernachtergrondtaken met HostedServices: gebruik dit voorbeeld als u zich in ASP.NET Core en achtergrondtaken maakt in overeenstemming met de officiële richtlijnen.

.NET Core Worker-service: gebruik dit voorbeeld als u een .NET Worker-servicetoepassing hebt in overeenstemming met de officiële richtlijnen.

Opensource-SDK

Lezen en bijdragen aan de code.

Zie de releaseopmerkingen voor de meest recente updates en bugfixes.

Volgende stappen

Gebruik de API om uw eigen gebeurtenissen en metrische gegevens te verzenden voor een gedetailleerde weergave van de prestaties en het gebruik van uw app.
Houd meer afhankelijkheden bij die niet automatisch worden bijgehouden.
Automatisch verzamelde telemetrie verrijken of filteren.
Afhankelijkheidsinjectie in ASP.NET Core.

Share via

Application Insights voor Werkservicetoepassingen (niet-HTTP-toepassingen)

Ondersteunde scenario's

Vereisten

Application Insights SDK voor Worker Service gebruiken

.NET Core Worker Service-toepassing

ASP.NET Kernachtergrondtaken met gehoste services

.NET Core/.NET Framework-consoletoepassing

Uw toepassing uitvoeren

Live metrische gegevens

ILogger-logboeken

Afhankelijkheden

EventCounter

Andere telemetrie handmatig bijhouden

De Application Insights-SDK configureren

ApplicationInsightsServiceOptions gebruiken

Steekproeven

Telemetrie-initialisatiefuncties toevoegen

Telemetrie-initialisatiefuncties verwijderen

Telemetrieprocessors toevoegen

Standaardtelemetriemodules configureren of verwijderen

Het telemetriekanaal configureren

Telemetrie dynamisch uitschakelen

Veelgestelde vragen

Welk pakket moet ik gebruiken?

Kan HostedServices in een .NET Core-app met behulp van het AspNetCore-pakket TelemetryClient erin hebben geïnjecteerd?

Hoe kan ik telemetrie bijhouden die niet automatisch wordt verzameld?

Kan ik Visual Studio IDE gebruiken om Application Insights aan een Worker Service-project te onboarden?

Kan ik Application Insights-bewaking inschakelen met behulp van hulpprogramma's zoals Azure Monitor Application Insights Agent (voorheen Status Monitor v2)?

Worden alle functies ondersteund als ik mijn toepassing in Linux uitvoer?

Voorbeeldtoepassingen

Opensource-SDK

Volgende stappen

Feedback

Aanvullende resources