Application Insights per applicazioni del Servizio del ruolo di lavoro (applicazioni non HTTP)

Articolo
10/15/2024

Application Insights SDK per il Servizio del ruolo di lavoro è un nuovo SDK, ideale per carichi di lavoro non HTTP come messaggistica, attività in background e applicazioni console. Questi tipi di applicazioni non prevedono richieste HTTP in ingresso come le tradizionali applicazioni Web ASP.NET/ASP.NET Core. Per questo motivo, non è supportato l'uso di pacchetti di Application Insights per ASP.NET o ASP.NET Core.

Nota

La documentazione seguente si basa sull'API classica di Application Insights. Il piano a lungo termine per Application Insights prevede la raccolta di dati con OpenTelemetry. Per altre informazioni, vedere Abilitare OpenTelemetry di Monitoraggio di Azure per le applicazioni .NET, Node.js, Python e Java oltre che la Roadmap OpenTelemetry. Le indicazioni sulla migrazione sono disponibili per .NET, Node.js e Python.

Il nuovo SDK non raccoglie autonomamente dati di telemetria, ma viene fornito con alcuni dei più noti agenti di raccolta automatica di Application Insights, quali DependencyCollector, PerfCounterCollector e ApplicationInsightsLoggingProvider. Questo SDK espone inoltre metodi di estensione su IServiceCollection per abilitare e configurare la raccolta di dati di telemetria.

Scenari supportati

Application Insights SDK per il Servizio del ruolo di lavoro è particolarmente adatto per 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 nuovo Servizio del ruolo di lavoro di .NET Core, nelle attività in background di ASP.NET Core e in app console come .NET Core e .NET Framework.

Prerequisiti

È necessario disporre di una stringa di connessione valida di Application Insights, necessaria per inviare dati di telemetria ad Application Insights. Se è necessario creare una nuova risorsa di Application Insights per ottenere una stringa di connessione, vedere Stringhe di connessione.

Nota

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

Usare Application Insights SDK per il Servizio del ruolo di lavoro

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

Nelle sezioni seguenti vengono fornite istruzioni specifiche per ogni tipo di applicazione.

Applicazione del Servizio del ruolo di lavoro di .NET Core

L'esempio completo è condiviso nel sito Web NuGet .

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

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

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

Modificare Worker.cs in 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 la stringa di connessione nel file di configurazione. L'esempio di codice seguente illustra come specificare una stringa di connessione in appsettings.json. Assicurarsi che appsettings.json venga copiato nella cartella radice dell'applicazione durante la pubblicazione.
```
    {
        "ApplicationInsights":
        {
            "ConnectionString" : "InstrumentationKey=00000000-0000-0000-0000-000000000000;"
        },
        "Logging":
        {
            "LogLevel":
            {
                "Default": "Warning"
            }
        }
    }
```

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

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

Nota

Una stringa di connessione specificata nel codice prevale sulla variabile di ambiente APPLICATIONINSIGHTS_CONNECTION_STRING, che prevale su altre opzioni.

Attività in background di ASP.NET Core con servizi ospitati

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

L'esempio completo è condiviso in questa pagina GitHub.

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

Aggiungere services.AddApplicationInsightsTelemetryWorkerService(); al metodo ConfigureServices(), come nell'esempio 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, in cui 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 file appsettings.json dell'esempio di Servizio del ruolo 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 è destinato a netstandard2.0 e, pertanto, può essere usato per app console in .NET Core (o versione successiva) e in .NET Framework (o versione successiva).

L'esempio completo è condiviso in questa pagina 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 parametro TelemetryConfigurationpredefinito. Può essere personalizzato seguendo la stessa procedura adottata negli esempi riportati nelle sezioni precedenti.

Eseguire l'applicazione

Eseguire l'applicazione. In tutti gli esempi precedenti, i ruoli di lavoro effettuano una chiamata HTTP a bing.com ogni secondo e generano alcuni log usando ILogger. Queste righe vengono racchiuse all'interno della chiamata StartOperation di TelemetryClient, che consente di creare un'operazione. In questo esempio, quindi, RequestTelemetry viene chiamato "operazione".

Application Insights raccoglie i log ILogger con un livello di gravità Avviso o superiore (impostazione predefinita), con le relative dipendenze. Sono correlati a RequestTelemetry con una relazione padre-figlio. La correlazione funziona anche attraverso 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 una tipica applicazione Web. Non è necessario usare un'operazione, ma è la soluzione più adatta al modello di dati di correlazione di Application Insights. RequestTelemetry svolge la funzione di operazione padre e ogni informazione di telemetria generata all'interno dell'iterazione del ruolo di lavoro viene considerata logicamente appartenente alla stessa operazione.

Questo approccio garantisce inoltre 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.

Nelle sezioni seguenti sono elencati tutti i dati di telemetria raccolti automaticamente da Application Insights.

Metriche attive

È possibile usare le metriche attive per verificare rapidamente se il monitoraggio delle applicazioni con Application Insights è configurato correttamente. La visualizzazione dei dati di telemetria nel portale di Azure può richiedere alcuni minuti, ma il riquadro delle metriche attive 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 un livello di gravità Avviso o superiore 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 log con livello di gravità Information e superiore.

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

È importante notare che l'esempio seguente non causa l'acquisizione dei log Information dal provider di Application Insights. Questi log non vengono acquisiti perché l'SDK aggiunge un filtro di registrazione predefinito che indica ad ApplicationInsights di acquisire solo i log Warning e i log di maggiore gravità. 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 delle dipendenze è abilitata per impostazione predefinita. L'articolo Rilevamento della dipendenza in Application Insights illustra le dipendenze raccolte automaticamente e contiene anche le istruzioni per eseguire il rilevamento manuale.

EventCounter

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

Tenere traccia di altri dati di telemetria in modo manuale

Anche se l'SDK raccoglie automaticamente dati di telemetria come illustrato in precedenza, nella maggior parte dei casi è necessario inviare ad Application Insights anche altri dati di telemetria. Il metodo consigliato per tenere traccia di altri dati di telemetria è ottenere un'istanza di TelemetryClient dall'inserimento delle dipendenze, quindi chiamare uno dei metodi supportati TrackXXX() dell'API. In alternativa, è possibile adottare il rilevamento personalizzato delle operazioni. Questo approccio è illustrato negli esempi di lavoro precedenti.

Configurare Application Insights SDK

Il parametro TelemetryConfiguration predefinito usato da Worker Service SDK è simile al parametro di configurazione automatica usato 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 per il Servizio del ruolo di lavoro per modificare la configurazione predefinita. È possibile che gli utenti di Application Insights ASP.NET Core SDK abbiano familiarità con la modifica della configurazione usando l'inserimento delle dipendenze predefinito di ASP.NET Core. Anche Worker Service SDK si basa su principi analoghi. Quasi tutte le modifiche di configurazione devono essere apportate nella sezione ConfigureServices() chiamando i metodi appropriati in IServiceCollection, come descritto nella sezione successiva.

Nota

Quando si usa questo SDK, la procedura di modifica della configurazione mediante la modifica di TelemetryConfiguration.Active non è supportata e le modifiche non vengono quindi 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 live metrics (also known as QuickPulse).
    aiOptions.EnableQuickPulseMetricStream = false;
    services.AddApplicationInsightsTelemetryWorkerService(aiOptions);
}

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

Nella tabella seguente vengono elencate le impostazioni comunemente usate in ApplicationInsightsServiceOptions.

Impostazione	Descrizione	Default
EnableQuickPulseMetricStream	Abilita/disabilita la funzionalità delle metriche in tempo reale.	Vero
EnableAdaptiveSampling	Abilita/disabilita il campionamento adattivo.	Vero
EnableHeartbeat	Abilita/disabilita la funzionalità Heartbeats, che invia periodicamente (impostazione predefinita: 15 minuti) una metrica personalizzata denominata "HeartBeatState" con informazioni sul runtime, ad esempio la versione di .NET e l'ambiente di Azure, se applicabile.	Vero
AddAutoCollectedMetricExtractor	Abilita/disabilita l'utilità di estrazione AutoCollectedMetrics, ovvero un processore di telemetria che invia metriche preaggregate relative a Richieste/Dipendenze prima del campionamento.	Vero
EnableDiagnosticsTelemetryModule	Abilita/disabilita `DiagnosticsTelemetryModule`. Disabilitando questa impostazione vengono ignorate le impostazioni seguenti: `EnableHeartbeat`, `EnableAzureInstanceMetadataTelemetryModule` e `EnableAppServicesHeartbeatTelemetryModule`.	Vero

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

Campionamento

Application Insights SDK per il Servizio del ruolo 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, fare riferimento all'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 inizializzatori di telemetria quando si desidera definire proprietà da inviare con tutti i dati di telemetria.

Aggiungendo un nuovo inizializzatore di telemetria al contenitore DependencyInjection, l'SDK lo aggiungerà 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 alcuni specifici, usare il codice di esempio seguente dopo la chiamata di 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 di estensione AddApplicationInsightsTelemetryProcessor in IServiceCollection. In scenari di filtro avanzati, i processori di telemetria consentono un controllo più diretto sugli elementi da includere o escludere 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 i moduli di telemetria predefiniti

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

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

DependencyTrackingTelemetryModule
PerformanceCollectorModule
QuickPulseTelemetryModule
AppServicesHeartbeatTelemetryModule (al momento, è presente un problema con questo modulo di telemetria. Per una soluzione alternativa temporanea, vedere Problema GitHub n. 1689).
AzureInstanceMetadataTelemetryModule

Per configurare qualsiasi modulo di telemetria predefinito, usare il metodo di estensione ConfigureTelemetryModule<T> 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 la telemetria in modo dinamico

Per disabilitare la telemetria in modo condizionale e dinamico, è possibile risolvere l'istanza di TelemetryConfiguration con un contenitore di inserimento delle dipendenze ASP.NET Core in qualsiasi punto del codice e impostarvi il flag DisableTelemetry.

    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, monitorando solo HostedServices	WorkerService (scenario raro)

È possibile che in un'istanza di HostedServices all'interno di un'app .NET Core che usa il pacchetto AspNetCore venga 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 TrackXXX() richiesto. Non è consigliabile creare nuove istanze di TelemetryClient. Un'istanza singleton di TelemetryClient è già registrata nel contenitore DependencyInjection, che condivide TelemetryConfiguration con il resto dei dati di telemetria. È consigliabile creare una nuova istanza di TelemetryClient 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 del ruolo di lavoro?

L'onboarding dell'IDE di Visual Studio è attualmente supportato solo per applicazioni ASP.NET/ASP.NET Core. Questo documento verrà aggiornato quando Visual Studio offrirà anche il supporto per l'onboarding di applicazioni del Servizio del ruolo 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 Application Insights di Monitoraggio di Azure supporta attualmente solo .NET.

Sono supportate tutte le funzionalità 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, presenti nelle metriche in tempo reale.

Sebbene ServerTelemetryChannel sia 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 qualora si verifichino problemi di rete o server temporanei. Per ovviare a 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).

Attività in background di ASP.NET con HostedServices: fare riferimento a questo esempio se si usa ASP.NET Core e si creano attività in background in conformità con il materiale sussidiario ufficiale.

Servizio del ruolo di lavoro di .NET Core: fare riferimento a questo esempio se si usa il Servizio del ruolo di lavoro di .NET in conformità con il materiale sussidiario ufficiale.

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 gli eventi e le metriche per una visualizzazione più dettagliata dell'utilizzo e delle prestazioni 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.

Condividi tramite

Application Insights per applicazioni del Servizio del ruolo di lavoro (applicazioni non HTTP)

Scenari supportati

Prerequisiti

Usare Application Insights SDK per il Servizio del ruolo di lavoro

Applicazione del Servizio del ruolo di lavoro di .NET Core

Attività in background di ASP.NET Core con servizi ospitati

Applicazione console .NET Core/.NET Framework

Eseguire l'applicazione

Metriche attive

Log ILogger

Dipendenze

EventCounter

Tenere traccia di altri dati di telemetria in modo manuale

Configurare Application Insights SDK

Usare ApplicationInsightsServiceOptions

Campionamento

Aggiungere inizializzatori di telemetria

Rimuovere gli inizializzatori di telemetria

Aggiungere processori di telemetria

Configurare o rimuovere i moduli di telemetria predefiniti

Configurare il canale di telemetria

Disabilitare la telemetria in modo dinamico

Domande frequenti

Quale pacchetto è necessario usare?

È possibile che in un'istanza di HostedServices all'interno di un'app .NET Core che usa il pacchetto AspNetCore venga 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 del ruolo 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)?

Sono supportate tutte le funzionalità se si esegue l'applicazione in Linux?

Applicazioni di esempio

SDK open source

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive