Application Insights per applicazioni del servizio di lavoro (applicazioni non HTTP)

Articolo
01/31/2024

Application Insights SDK per il servizio di lavoro è un nuovo SDK, ideale per carichi di lavoro non HTTP, ad esempio messaggistica, attività in background e applicazioni console. Questi tipi di applicazioni non hanno la nozione di richiesta HTTP in ingresso come un'applicazione Web ASP.NET/ASP.NET Core tradizionale. Per questo motivo, l'uso dei pacchetti di Application Insights per ASP.NET o ASP.NET applicazioni Core non è supportato.

Nota

La documentazione seguente si basa sull'API classica di Application Insights. Il piano a lungo termine per Application Insights consiste nel raccogliere dati usando OpenTelemetry. Per altre informazioni, vedere Abilitare OpenTelemetry di Monitoraggio di Azure per le applicazioni .NET, Node.js, Python e Java.

Il nuovo SDK non esegue alcuna raccolta di dati di telemetria da sola. Offre invece altri agenti di raccolta automatica noti di Application Insights, ad esempio DependencyCollector, PerfCounterCollector e ApplicationInsightsLoggingProvider. Questo SDK espone i metodi di estensione su IServiceCollection per abilitare e configurare la raccolta di dati di telemetria.

Scenari supportati

Application Insights SDK per il servizio di lavoro è più adatto per le applicazioni non HTTP indipendentemente da dove o come vengono eseguite. Se l'applicazione è in esecuzione e ha connettività di rete ad Azure, è possibile raccogliere i dati di telemetria. Il monitoraggio di Application Insights è supportato ovunque sia supportato .NET Core. Questo pacchetto può essere usato nel servizio ruolo di lavoro .NET Core appena introdotto, nelle attività in background in ASP.NET Core e nelle app console come .NET Core e .NET Framework.

Prerequisiti

È necessario disporre di un stringa di connessione di Application Insights valido. Questa stringa è necessaria per inviare dati di telemetria ad Application Insights. Se è necessario creare una nuova risorsa di Application Insights per ottenere un stringa di connessione, vedere stringhe di Connessione ion.

Nota

Il 31 marzo 2025, il supporto per l'inserimento delle chiavi di strumentazione terminerà. L'inserimento di chiavi di strumentazione continuerà a funzionare, ma non forniamo più aggiornamenti o supporto per la funzionalità. Passare alle stringa di connessione per sfruttare le nuove funzionalità.

Usare Application Insights SDK per il servizio di lavoro

Installare il pacchetto Microsoft.ApplicationInsights.WorkerService nell'applicazione. Il frammento di codice seguente mostra le modifiche che devono essere aggiunte al file del .csproj progetto:
```
    <ItemGroup>
        <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.22.0" />
    </ItemGroup>
```
Configurare il stringa di connessione nella APPLICATIONINSIGHTS_CONNECTION_STRING variabile di ambiente o nella configurazione (appsettings.json).
Recuperare un'istanza o TelemetryClient un'istanza ILogger dal contenitore di inserimento delle dipendenze chiamando serviceProvider.GetRequiredService<TelemetryClient>(); o tramite inserimento del costruttore. Questo passaggio attiverà la configurazione dei moduli di TelemetryConfiguration raccolta automatica e .

Le istruzioni specifiche per ogni tipo di applicazione sono descritte nelle sezioni seguenti.

Applicazione del servizio di lavoro .NET Core

L'esempio completo viene condiviso nel sito Web NuGet.

Scaricare e installare .NET SDK.
Creare un nuovo progetto del servizio di lavoro usando un nuovo modello di progetto di Visual Studio o la riga dotnet new workerdi comando .
Aggiungere il pacchetto Microsoft.ApplicationInsights.WorkerService all'applicazione.

Aggiungere services.AddApplicationInsightsTelemetryWorkerService(); al CreateHostBuilder() metodo nella Program.cs classe , come nell'esempio seguente:

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

Modificare in Worker.cs base all'esempio seguente:

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

Configurare la stringa di connessione.

Nota

È consigliabile specificare il stringa di connessione nella configurazione. Nell'esempio di codice seguente viene illustrato come specificare un stringa di connessione in appsettings.json. Assicurarsi di appsettings.json essere copiati nella cartella radice dell'applicazione durante la pubblicazione.
```
    {
        "ApplicationInsights":
        {
            "ConnectionString" : "InstrumentationKey=00000000-0000-0000-0000-000000000000;"
        },
        "Logging":
        {
            "LogLevel":
            {
                "Default": "Warning"
            }
        }
    }
```

In alternativa, specificare il stringa di connessione nella APPLICATIONINSIGHTS_CONNECTION_STRING variabile di ambiente.

In genere, APPLICATIONINSIGHTS_CONNECTION_STRING specifica il stringa di connessione per le applicazioni distribuite nelle app Web come processi Web.

Nota

Un stringa di connessione specificato nel codice ha la precedenza sulla variabile APPLICATIONINSIGHTS_CONNECTION_STRINGdi ambiente , che ha la precedenza su altre opzioni.

ASP.NET attività in background di base con i servizi ospitati

Questo documento descrive come creare attività in background in un'applicazione ASP.NET Core.

L'esempio completo viene condiviso in questa pagina di GitHub.

Installare il pacchetto Microsoft.ApplicationInsights.WorkerService nell'applicazione.

Aggiungere services.AddApplicationInsightsTelemetryWorkerService(); al metodo , come nell'esempio ConfigureServices() seguente:

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

Il codice seguente è per TimedHostedService, dove risiede la logica dell'attività in background:

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

Configurare la stringa di connessione. Usare lo stesso appsettings.json esempio del servizio di lavoro .NET precedente.

Applicazione console .NET Core/.NET Framework

Come accennato all'inizio di questo articolo, il nuovo pacchetto può essere usato per abilitare i dati di telemetria di Application Insights anche da una normale applicazione console. Questo pacchetto netstandard2.0è destinato a , in modo che possa essere usato per le app console in .NET Core o versione successiva e .NET Framework o versione successiva.

L'esempio completo viene condiviso in questa pagina di GitHub.

Installare il pacchetto Microsoft.ApplicationInsights.WorkerService nell'applicazione.

Modificare Program.cs come illustrato nell'esempio seguente:

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

Questa applicazione console usa anche lo stesso valore predefinito TelemetryConfiguration. Può essere personalizzato nello stesso modo degli esempi nelle sezioni precedenti.

Eseguire l'applicazione

Eseguire l'applicazione. I ruoli di lavoro di tutti gli esempi precedenti effettuano una chiamata HTTP ogni secondo a bing.com e generano anche pochi log usando ILogger. Queste righe vengono racchiuse all'interno della StartOperation chiamata di TelemetryClient, che viene usata per creare un'operazione. In questo esempio, RequestTelemetry è denominato "operation".

Application Insights raccoglie questi log ILogger, con una gravità di avviso o superiore per impostazione predefinita e dipendenze. Sono correlati a RequestTelemetry una relazione padre-figlio. La correlazione funziona anche tra i limiti di processo/rete. Ad esempio, se la chiamata è stata effettuata a un altro componente monitorato, è correlata anche a questo elemento padre.

Questa operazione personalizzata di RequestTelemetry può essere considerata come l'equivalente di una richiesta Web in ingresso in un'applicazione Web tipica. Non è necessario usare un'operazione, ma si adatta meglio al modello di dati di correlazione di Application Insights. RequestTelemetry funge da operazione padre e ogni telemetria generata all'interno dell'iterazione del ruolo di lavoro viene considerata logicamente appartenente alla stessa operazione.

Questo approccio garantisce anche che tutti i dati di telemetria generati, sia automatici che manuali, abbiano lo stesso operation_id. Poiché il campionamento è basato su operation_id, l'algoritmo di campionamento mantiene o elimina tutti i dati di telemetria da una singola iterazione.

Le sezioni seguenti elencano i dati di telemetria completi raccolti automaticamente da Application Insights.

Metriche attive

Le metriche attive possono essere usate per verificare rapidamente se il monitoraggio di Application Insights è configurato correttamente. Anche se potrebbero essere necessari alcuni minuti prima che i dati di telemetria vengano visualizzati nel portale e nell'analisi, Live Metrics mostra l'utilizzo della CPU del processo in esecuzione quasi in tempo reale. Può anche visualizzare altri dati di telemetria, ad esempio Richieste, Dipendenze e Tracce.

Log ILogger

I log generati tramite ILogger con l'avviso di gravità o versione successiva vengono acquisiti automaticamente. Per modificare questo comportamento, eseguire in modo esplicito l'override della configurazione di registrazione per il provider ApplicationInsights, come illustrato nel codice seguente. La configurazione seguente consente ad Application Insights di acquisire tutti i Information log e i log più gravi.

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

È importante notare che l'esempio seguente non causa l'acquisizione Information dei log da parte del provider di Application Insights. Non lo acquisisce perché l'SDK aggiunge un filtro di registrazione predefinito che indica ApplicationInsights di acquisire solo Warning i log e i log più gravi. Application Insights richiede un override esplicito.

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

Per altre informazioni, vedere la documentazione di ILogger per personalizzare i livelli di log acquisiti da Application Insights.

Dipendenze

La raccolta di dipendenze è abilitata per impostazione predefinita. L'articolo Rilevamento delle dipendenze in Application Insights illustra le dipendenze raccolte automaticamente e contiene anche i passaggi per eseguire il rilevamento manuale.

EventCounter

EventCounterCollectionModule è abilitato per impostazione predefinita e raccoglierà un set predefinito di contatori dalle app .NET . L'esercitazione di EventCounter elenca il set predefinito di contatori raccolti. Include anche istruzioni su come personalizzare l'elenco.

Tenere traccia manuale di altri dati di telemetria

Anche se l'SDK raccoglie automaticamente i dati di telemetria come spiegato, nella maggior parte dei casi è necessario inviare altri dati di telemetria ad Application Insights. Il modo consigliato per tenere traccia di altri dati di telemetria consiste nel ottenere un'istanza di TelemetryClient da Dependency Injection e quindi chiamare uno dei metodi API supportatiTrackXXX(). Un altro caso d'uso tipico è il rilevamento personalizzato delle operazioni. Questo approccio è illustrato negli esempi di lavoro precedenti.

Configurare Application Insights SDK

L'impostazione predefinita TelemetryConfiguration usata dall'SDK del servizio di lavoro è simile alla configurazione automatica usata in un'applicazione ASP.NET o ASP.NET Core, meno gli inizializzatori di telemetria usati per arricchire i dati di telemetria da HttpContext.

È possibile personalizzare Application Insights SDK for Worker Service per modificare la configurazione predefinita. Gli utenti di Application Insights ASP.NET Core SDK potrebbero avere familiarità con la modifica della configurazione usando ASP.NET'inserimento predefinito delle dipendenze core. Worker Service SDK si basa anche su principi simili. Apportare quasi tutte le modifiche di configurazione nella ConfigureServices() sezione chiamando i metodi appropriati in IServiceCollection, come descritto nella sezione successiva.

Nota

Quando si usa questo SDK, la modifica della configurazione tramite la modifica TelemetryConfiguration.Active non è supportata e le modifiche non verranno riflesse.

Usare ApplicationInsightsServiceOptions

È possibile modificare alcune impostazioni comuni passando ApplicationInsightsServiceOptions a AddApplicationInsightsTelemetryWorkerService, come in questo esempio:

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

ApplicationInsightsServiceOptions In questo SDK si trova nello spazio dei nomi Microsoft.ApplicationInsights.WorkerService anziché Microsoft.ApplicationInsights.AspNetCore.Extensions in ASP.NET Core SDK.

Nella tabella seguente sono elencate le impostazioni di uso comune in ApplicationInsightsServiceOptions.

Impostazione	Descrizione	Default
EnableQuickPulseMetricStream	Abilitare/disabilitare la funzionalità Metriche attive.	Vero
EnableAdaptiveSampling	Abilitare/disabilitare il campionamento adattivo.	Vero
EnableHeartbeat	Abilitare/disabilitare la funzionalità Heartbeats, che periodicamente (impostazione predefinita di 15 minuti) invia una metrica personalizzata denominata "HeartBeatState" con informazioni sul runtime come la versione di .NET e l'ambiente Azure, se applicabile.	Vero
AddAutoCollectedMetricExtractor	Abilitare/disabilitare l'estrattore AutoCollectedMetrics, ovvero un processore di telemetria che invia metriche preaggregate su Richieste/Dipendenze prima del campionamento.	Vero
EnableDiagnosticsTelemetryModule	Abilitare/disabilitare `DiagnosticsTelemetryModule`. Se si disabilita questa impostazione, le impostazioni seguenti verranno ignorate: `EnableHeartbeat`, `EnableAzureInstanceMetadataTelemetryModule`e `EnableAppServicesHeartbeatTelemetryModule`.	Vero

Per l'elenco più aggiornato, vedere le impostazioni configurabili in ApplicationInsightsServiceOptions.

Campionamento

Application Insights SDK per il servizio di lavoro supporta sia il campionamento a frequenza fissa che il campionamento adattivo. Il campionamento adattivo è abilitato per impostazione predefinita. Il campionamento può essere disabilitato usando l'opzione EnableAdaptiveSampling in ApplicationInsightsServiceOptions.

Per configurare altre impostazioni di campionamento, è possibile usare l'esempio seguente:

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

Per altre informazioni, vedere il documento Campionamento .

Aggiungere inizializzatori di telemetria

Usare gli inizializzatori di telemetria quando si desidera definire le proprietà inviate con tutti i dati di telemetria.

Aggiungere un nuovo inizializzatore di telemetria al DependencyInjection contenitore e l'SDK li aggiunge automaticamente a TelemetryConfiguration.

    using Microsoft.ApplicationInsights.Extensibility;

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

Rimuovere gli inizializzatori di telemetria

Gli inizializzatori di telemetria sono presenti per impostazione predefinita. Per rimuovere tutti gli inizializzatori di telemetria o specifici, usare il codice di esempio seguente dopo aver chiamato 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));
   }

Aggiungere processori di telemetria

È possibile aggiungere processori di telemetria personalizzati a TelemetryConfiguration usando il metodo AddApplicationInsightsTelemetryProcessor di estensione in IServiceCollection. I processori di telemetria vengono usati in scenari di filtro avanzati per consentire un controllo più diretto sugli elementi inclusi o esclusi dai dati di telemetria inviati ad Application Insights. Usare l'esempio seguente:

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

Configurare o rimuovere moduli di telemetria predefiniti

Application Insights usa moduli di telemetria per raccogliere automaticamente i dati di telemetria relativi a carichi di lavoro specifici senza richiedere il rilevamento manuale.

I moduli di raccolta automatica seguenti sono abilitati per impostazione predefinita. Questi moduli sono responsabili della raccolta automatica dei dati di telemetria. È possibile disabilitarli o configurarli per modificarne il comportamento predefinito.

DependencyTrackingTelemetryModule
PerformanceCollectorModule
QuickPulseTelemetryModule
AppServicesHeartbeatTelemetryModule Attualmente è presente un problema che riguarda questo modulo di telemetria. Per una soluzione alternativa temporanea, vedere Problema di GitHub 1689.
AzureInstanceMetadataTelemetryModule

Per configurare qualsiasi modulo di telemetria predefinito, usare il metodo ConfigureTelemetryModule<T> di estensione in IServiceCollection, come illustrato nell'esempio seguente:

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

Configurare il canale di telemetria

Il canale predefinito è ServerTelemetryChannel. È possibile eseguirne l'override come illustrato nell'esempio seguente:

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

Disabilitare i dati di telemetria in modo dinamico

Se si desidera disabilitare i dati di telemetria in modo condizionale e dinamico, è possibile risolvere l'istanza TelemetryConfiguration con un contenitore di inserimento delle dipendenze ASP.NET Core ovunque nel codice e impostarvi il DisableTelemetry flag.

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

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

Domande frequenti

Questa sezione fornisce le risposte alle domande comuni.

Quale pacchetto è necessario usare?

Scenario di app .NET Core	Pacchetto
Senza HostedServices	WorkerService
Con HostedServices	AspNetCore (non WorkerService)
Con HostedServices, monitoraggio solo HostedServices	WorkerService (scenario raro)

HostedServices all'interno di un'app .NET Core usando il pacchetto AspNetCore ha inserito TelemetryClient?

Sì. La configurazione verrà condivisa con il resto dell'applicazione Web.

Come è possibile tenere traccia dei dati di telemetria non raccolti automaticamente?

Ottenere un'istanza di TelemetryClient usando l'inserimento del costruttore e chiamare il metodo richiesto TrackXXX() . Non è consigliabile creare nuove TelemetryClient istanze. Un'istanza singleton di TelemetryClient è già registrata nel DependencyInjection contenitore, che condivide TelemetryConfiguration con il resto dei dati di telemetria. La creazione di una nuova TelemetryClient istanza è consigliata solo se è necessaria una configurazione separata dal resto dei dati di telemetria.

È possibile usare l'IDE di Visual Studio per eseguire l'onboarding di Application Insights in un progetto del servizio di lavoro?

L'onboarding dell'IDE di Visual Studio è attualmente supportato solo per le applicazioni core ASP.NET/ASP.NET. Questo documento verrà aggiornato quando Visual Studio include il supporto per l'onboarding delle applicazioni del servizio di lavoro.

È possibile abilitare il monitoraggio di Application Insights usando strumenti come l'agente di Application Insights di Monitoraggio di Azure (in precedenza Status Monitor v2)?

No. L'agente di Application Insights di Monitoraggio di Azure supporta attualmente solo .NET .

Tutte le funzionalità sono supportate se si esegue l'applicazione in Linux?

Sì. Il supporto delle funzionalità per questo SDK è lo stesso in tutte le piattaforme, con le eccezioni seguenti:

I contatori delle prestazioni sono supportati solo in Windows, ad eccezione della CPU/memoria del processo mostrati in Metriche attive.

Anche se ServerTelemetryChannel è abilitato per impostazione predefinita, se l'applicazione è in esecuzione in Linux o macOS, il canale non crea automaticamente una cartella di archiviazione locale per mantenere temporaneamente i dati di telemetria in caso di problemi di rete. A causa di questa limitazione, i dati di telemetria vengono persi quando si verificano problemi di rete o server temporanei. Per risolvere questo problema, configurare una cartella locale per il canale:

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

Applicazioni di esempio

Applicazione console .NET Core: usare questo esempio se si usa un'applicazione console scritta in .NET Core (2.0 o versione successiva) o .NET Framework (4.7.2 o versione successiva).

ASP.NET Attività in background di base con HostedServices: usare questo esempio se si usa ASP.NET Core e si creano attività in background in base alle indicazioni ufficiali.

Servizio di lavoro .NET Core: usare questo esempio se si dispone di un'applicazione del servizio di lavoro .NET in conformità alle indicazioni ufficiali.

SDK open source

Leggere e contribuire al codice.

Per gli aggiornamenti e le correzioni di bug più recenti, vedere le note sulla versione.

Passaggi successivi

Usare l'API per inviare metriche ed eventi personalizzati per una visualizzazione dettagliata delle prestazioni e dell'utilizzo dell'app.
Tenere traccia di più dipendenze non rilevate automaticamente.
Arricchire o filtrare i dati di telemetria raccolti automaticamente.
Inserimento delle dipendenze in ASP.NET Core.

Application Insights per applicazioni del servizio di lavoro (applicazioni non HTTP)

Scenari supportati

Prerequisiti

Usare Application Insights SDK per il servizio di lavoro

Applicazione del servizio di lavoro .NET Core

ASP.NET attività in background di base con i servizi ospitati

Applicazione console .NET Core/.NET Framework

Eseguire l'applicazione

Metriche attive

Log ILogger

Dipendenze

EventCounter

Tenere traccia manuale di altri dati di telemetria

Configurare Application Insights SDK

Usare ApplicationInsightsServiceOptions

Campionamento

Aggiungere inizializzatori di telemetria

Rimuovere gli inizializzatori di telemetria

Aggiungere processori di telemetria

Configurare o rimuovere moduli di telemetria predefiniti

Configurare il canale di telemetria

Disabilitare i dati di telemetria in modo dinamico

Domande frequenti

Quale pacchetto è necessario usare?

HostedServices all'interno di un'app .NET Core usando il pacchetto AspNetCore ha inserito TelemetryClient?

Come è possibile tenere traccia dei dati di telemetria non raccolti automaticamente?

È possibile usare l'IDE di Visual Studio per eseguire l'onboarding di Application Insights in un progetto del servizio di lavoro?

È possibile abilitare il monitoraggio di Application Insights usando strumenti come l'agente di Application Insights di Monitoraggio di Azure (in precedenza Status Monitor v2)?

Tutte le funzionalità sono supportate se si esegue l'applicazione in Linux?

Applicazioni di esempio

SDK open source

Passaggi successivi

Risorse aggiuntive