Toepassings Insights voor werkservicetoepassingen (niet-HTTP-toepassingen)

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

De nieuwe SDK doet zelf geen telemetrieverzameling. In plaats daarvan worden andere bekende application Insights automatisch collectoren zoals DependencyCollector, PerfCounterCollector, ApplicationInsightsLoggingProvider enzovoort. Met deze SDK worden extensiemethoden ingeschakeld om IServiceCollection telemetrieverzameling in te stellen en te configureren.

Ondersteunde scenario's

De Application Insights SDK for Worker Service is het meest geschikt voor niet-HTTP-toepassingen, ongeacht waar of hoe ze worden uitgevoerd. Als uw toepassing wordt uitgevoerd en netwerkverbinding heeft met Azure, kan telemetrie worden verzameld. Toepassings Insights bewaking wordt overal ondersteund waar .NET Core wordt ondersteund. Dit pakket kan worden gebruikt in de nieuw geïntroduceerde .NET Core 3.0 Worker-service,achtergrondtaken in ASP.NET Core 2.1/2.2,console-apps (.NET Core/ .NET Framework), enzovoort.

Vereisten

Een geldige Application Insights instrumentatiesleutel. Deze sleutel is vereist voor het verzenden van telemetrie naar Application Insights. Als u een nieuwe Application Insights-resource moet maken om een instrumentatiesleutel op te halen, zie Een Application Insights maken.

Application Insights SDK gebruiken voor werkservices

  1. Installeer het pakket Microsoft.ApplicationInsights.WorkerService in de toepassing. In het volgende codefragment ziet u de wijzigingen die moeten worden toegevoegd aan het bestand van uw .csproj project.
    <ItemGroup>
        <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.13.1" />
    </ItemGroup>
  1. Roep AddApplicationInsightsTelemetryWorkerService(string instrumentationKey) de extensiemethode aan in IServiceCollection , waarbij u de instrumentatiesleutel op geeft. Deze methode moet aan het begin van de toepassing worden aangeroepen. De exacte locatie is afhankelijk van het type toepassing.

  2. Haal een ILogger exemplaar of exemplaar op uit de TelemetryClient afhankelijkheidsinjectiecontainer door serviceProvider.GetRequiredService<TelemetryClient>(); constructorinjectie aan te roepen of te gebruiken. Deze stap activeert het instellen van modules TelemetryConfiguration voor automatisch verzamelen en .

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

.NET Core 3.0-werkservicetoepassing

Het volledige voorbeeld wordt hier gedeeld

  1. .NET Core 3.0 downloaden en installeren

  2. Maak een nieuw Worker Service-project met behulp van Visual Studio nieuwe projectsjabloon of opdrachtregeldotnet new worker

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

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

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureServices((hostContext, services) =>
            {
                services.AddHostedService<Worker>();
                services.AddApplicationInsightsTelemetryWorkerService();
            });
  1. Wijzig uw Worker.cs volgens het onderstaande 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);
            }
        }
    }
  1. Stel de instrumentatiesleutel in.

    Hoewel u de instrumentatiesleutel kunt opgeven als argument voor , wordt u aangeraden de AddApplicationInsightsTelemetryWorkerService instrumentatiesleutel op te geven in de configuratie. In het volgende codevoorbeeld ziet u hoe u een instrumentatiesleutel opgeeft in appsettings.json . Zorg ervoor appsettings.json dat tijdens het publiceren naar de hoofdmap van de toepassing wordt gekopieerd.

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

U kunt ook de instrumentatiesleutel opgeven in een van de volgende omgevingsvariabelen. APPINSIGHTS_INSTRUMENTATIONKEY of ApplicationInsights:InstrumentationKey

Bijvoorbeeld: SET ApplicationInsights:InstrumentationKey=putinstrumentationkeyhere OF SET APPINSIGHTS_INSTRUMENTATIONKEY=putinstrumentationkeyhere

Hiermee geeft APPINSIGHTS_INSTRUMENTATIONKEY u doorgaans de instrumentatiesleutel op voor toepassingen die zijn geïmplementeerd in Web Apps webtaken.

Notitie

Een instrumentatiesleutel die is opgegeven in code, wint van de omgevingsvariabele APPINSIGHTS_INSTRUMENTATIONKEY , die over andere opties wint.

ASP.NET Core achtergrondtaken uitvoeren met gehoste services

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

Het volledige voorbeeld wordt hier gedeeld

  1. Installeer het pakket Microsoft.ApplicationInsights.WorkerService in de toepassing.
  2. Voeg services.AddApplicationInsightsTelemetryWorkerService(); toe aan de methode , zoals in dit ConfigureServices() 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>();

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

Hieronder volgt de code voor TimedHostedService de plaats waar de logica van de achtergrondtaak 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");
            }
        }
    }
  1. Stel de instrumentatiesleutel in. Gebruik hetzelfde uit appsettings.json het bovenstaande voorbeeld van de .NET Core 3.0-werkservice.

.NET Core/.NET Framework Console-toepassing

Zoals vermeld in het begin van dit artikel, kan het nieuwe pakket worden gebruikt om Application Insights Telemetry in te stellen vanuit zelfs een gewone consoletoepassing. Dit pakket is gericht op en kan daarom worden gebruikt voor NetStandard2.0 console-apps in .NET Core 2.0 of hoger en .NET Framework 4.7.2 of hoger.

Het volledige voorbeeld wordt hier gedeeld

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

  2. Wijzig Program.cs zoals hieronder wordt weergegeven.

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

Deze consoletoepassing maakt ook gebruik van dezelfde standaard en kan op dezelfde manier worden aangepast als de voorbeelden TelemetryConfiguration in de vorige sectie.

Uw toepassing uitvoeren

Voer uw toepassing uit. De voorbeeldwerksters van alle hierboven genoemde maken elke seconde een HTTP-aanroep naar bing.com en zenden ook enkele logboeken met behulp van ILogger . Deze regels worden verpakt in de aanroep van , die wordt gebruikt om een bewerking te maken (in dit StartOperation voorbeeld TelemetryClient RequestTelemetry 'bewerking'). Application Insights verzamelt deze ILogger-logboeken (standaard waarschuwing of hoger) en afhankelijkheden, en deze worden gecorreleerd aan de relatie tussen RequestTelemetry bovenliggend/onderliggend. De correlatie werkt ook proces-/netwerkgrensoverschrijdend. Als de aanroep bijvoorbeeld is gedaan naar een ander bewaakt onderdeel, wordt deze ook gecorreleerd aan dit bovenliggende onderdeel.

Deze aangepaste bewerking van kan worden beschouwd als het equivalent van een binnenkomende RequestTelemetry webaanvraag in een typische webtoepassing. Hoewel het niet nodig is om een bewerking te gebruiken, past deze het beste bij het Application Insights-correlatiegegevensmodel, met als bovenliggende bewerking en elke telemetrie die binnen de iteratie van de werker wordt gegenereerd, wordt beschouwd als logisch behorend bij dezelfde RequestTelemetry bewerking. Deze aanpak zorgt er ook voor dat alle telemetrie die wordt gegenereerd (automatisch en handmatig) dezelfde operation_id heeft. Omdat steekproeven zijn gebaseerd op , bewaart of zet het samplingalgoritme alle operation_id telemetrie uit één iteratie.

Hieronder vindt u de volledige telemetrie die automatisch wordt verzameld door Application Insights.

Live Metrics

Live Metrics kan worden gebruikt om snel te controleren of application Insights is geconfigureerd. Hoewel het enkele minuten kan duren voordat telemetrie wordt weergegeven in de portal en analyses, zou live metrics het CPU-gebruik van het lopende proces in bijna realtime laten zien. Er kan ook andere telemetrie worden weer geven, zoals aanvragen, afhankelijkheden, traceringen, enzovoort.

ILoggerlogboeken

Logboeken die worden ILogger ingediend met een ernst of Warning hoger, worden automatisch vastgelegd. Volg ILogger-documenten om aan te passen welke logboekniveaus worden vastgelegd door Application Insights.

Afhankelijkheden

Afhankelijkheidsverzameling is standaard ingeschakeld. In dit artikel worden de afhankelijkheden uitgelegd die automatisch worden verzameld, en vindt u ook stappen om handmatige tracering uit te voeren.

EventCounter

EventCounterCollectionModule is standaard ingeschakeld en verzamelt een standaardset tellers van .NET Core 3.0-apps. In de EventCounter-zelfstudie wordt de standaardset verzamelde tellers vermeld. Het bevat ook instructies voor het aanpassen van de lijst.

Aanvullende telemetrie handmatig bijhouden

Hoewel de SDK automatisch telemetrie verzamelt zoals hierboven wordt uitgelegd, moet de gebruiker in de meeste gevallen aanvullende telemetrie verzenden naar Application Insights service. De aanbevolen manier om aanvullende telemetrie bij te houden, is door een exemplaar van te verkrijgen van afhankelijkheidsinjectie en vervolgens een van de ondersteunde TelemetryClient TrackXXX() API-methoden aan te roepen. Een andere typische use-case is het aangepast bijhouden van bewerkingen. Deze aanpak wordt gedemonstreerd in de bovenstaande Worker-voorbeelden.

De Application Insights SDK configureren

De standaardinstelling die wordt gebruikt door de werkservice-SDK is vergelijkbaar met de automatische configuratie die wordt gebruikt in een ASP.NET- of ASP.NET Core-toepassing, zonder de TelemetryConfiguration TelemetryInitializers die worden gebruikt om telemetrie van te HttpContext verrijken.

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 ASP.NET Core ingebouwde afhankelijkheidsinjectie. De WorkerService SDK is ook gebaseerd op vergelijkbare principes. Maak bijna alle configuratiewijzigingen in de sectie ConfigureServices() door de juiste methoden aan te roepen op , zoals hieronder wordt IServiceCollection beschreven.

Notitie

Tijdens het gebruik van deze SDK wordt het wijzigen van de configuratie door middel van wijzigen niet ondersteund en worden wijzigingen TelemetryConfiguration.Active niet doorgevoerd.

ApplicationInsightsServiceOptions gebruiken

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

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

Houd er rekening mee dat deze SDK zich in de naamruimte in plaats van in de ApplicationInsightsServiceOptions Microsoft.ApplicationInsights.WorkerService ASP.NET Core Microsoft.ApplicationInsights.AspNetCore.Extensions SDK.

Veelgebruikte instellingen in ApplicationInsightsServiceOptions

Instelling Beschrijving Standaard
EnableQuickPulseMetricStream De functie LiveMetrics in-/uitschakelen true
EnableAdaptiveSampling Adaptieve steekproeven in-/uitschakelen true
EnableBeat De functie Heartbeats in-/uitschakelen, die periodiek (standaard 15 minuten) een aangepaste metriek met de naam 'HeartBeatState' verzendt met informatie over de runtime, zoals .NET-versie, informatie over de Azure-omgeving, indien van toepassing, enzovoort. true
AddAutoCollectedMetricExtractor AutoCollectedMetrics-extractor inschakelen/uitschakelen. Dit is een TelemetryProcessor die vooraf geaggregeerde metrische gegevens over aanvragen/afhankelijkheden verzendt voordat steekproeven worden genomen. true
EnableDiagnosticsTelemetryModule In- of DiagnosticsTelemetryModule uitschakelen. Als u dit uitvolgt, worden de volgende instellingen genegeerd; EnableHeartbeat, EnableAzureInstanceMetadataTelemetryModule, EnableAppServicesHeartbeatTelemetryModule true

Zie de configureerbare ApplicationInsightsServiceOptions instellingen in voor de meest recente lijst.

Steekproeven

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

Als u aanvullende steekproefinstellingen wilt configureren, kunt u het volgende voorbeeld gebruiken.

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

Meer informatie vindt u in het document Steekproeven.

TelemetryInitializers toevoegen

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

Voeg nieuwe aan TelemetryInitializer de container toe en de DependencyInjection SDK voegt deze automatisch toe aan de TelemetryConfiguration .

    using Microsoft.ApplicationInsights.Extensibility;

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

TelemetryInitializers verwijderen

Telemetrie-initialisaties zijn standaard aanwezig. Als u alle of specifieke initialisaties voor telemetrie wilt verwijderen, gebruikt u de volgende voorbeeldcode nadat u hebt aanroept. 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 toevoegen aan TelemetryConfiguration met behulp van de extensiemethode op AddApplicationInsightsTelemetryProcessor IServiceCollection . U gebruikt telemetrieprocessors in geavanceerde filterscenario's om meer directe controle te krijgen over wat is opgenomen of uitgesloten van de telemetrie die u naar de Application Insights-service verzendt. Gebruik het volgende voorbeeld.

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

Standaard TelemetryModules configureren of verwijderen

Application Insights telemetriemodules gebruikt om automatisch telemetrie te verzamelen over specifieke workloads zonder handmatige tracering.

De volgende modules voor automatische verzameling 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 probleem 1689GitHub tijdelijke oplossing.
  • AzureInstanceMetadataTelemetryModule

Als u een standaardinstelling wilt TelemetryModule configureren, gebruikt u de ConfigureTelemetryModule<T> extensiemethode 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);
            }
    }

Telemetriekanaal configureren

Het standaardkanaal is ServerTelemetryChannel . U kunt deze overschrijven zoals in het volgende voorbeeld wordt weer geven.

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 exemplaar oplossen met ASP.NET Core-container voor afhankelijkheidsinjectie overal in uw code en de vlag TelemetryConfiguration DisableTelemetry instellen.

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

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

Veelgestelde vragen

Hoe kan ik telemetrie bijhouden die niet automatisch wordt verzameld?

Haal een exemplaar van TelemetryClient op met behulp van constructorinjectie en roep de vereiste methode TrackXXX() aan. Het is niet raadzaam om nieuwe exemplaren TelemetryClient te maken. Er is al een TelemetryClient singleton-exemplaar van geregistreerd in de DependencyInjection container, die deelt TelemetryConfiguration met de rest van de telemetrie. Het maken van een nieuwe instantie wordt alleen aanbevolen als er een configuratie nodig TelemetryClient is die los staat van de rest van de telemetrie.

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

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

Kan ik application Insights inschakelen met hulpprogramma's zoals Azure Monitor Application Insights Agent (voorheen Status Monitor v2)?

Nee, Azure Monitor Application Insights Agent ondersteunt momenteel alleen ASP.NET 4.x.

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

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

  • Prestatiemeters worden alleen ondersteund in Windows, met uitzondering van CPU/geheugen verwerken weergegeven in live metrische gegevens.
  • Hoewel standaard is ingeschakeld, maakt het kanaal, als de toepassing wordt uitgevoerd in Linux of macOS, niet automatisch een lokale opslagmap om telemetrie tijdelijk te bewaren als er netwerkproblemen ServerTelemetryChannel zijn. Vanwege deze beperking gaat telemetrie verloren wanneer er tijdelijke netwerk- of serverproblemen zijn. U kunt dit probleem oplossen 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 Core achtergrondtaken uitvoeren met HostedServices Gebruik dit voorbeeld als u zich in ASP.NET Core 2.1/2.2 en achtergrondtaken maakt volgens de officiële richtlijnen hier

.NET Core 3.0 Worker-service Gebruik dit voorbeeld als u een .NET Core 3.0 Worker Service-toepassing hebt volgens de officiële richtlijnen hier

Opensource-SDK

Raadpleeg de opmerkingen bij de release voor de meest recente updates en oplossingen voor fouten.

Volgende stappen