Application Insights para aplicativos do Serviço de Trabalho (aplicativos não HTTP)

2025-05-24

O SDK do Application Insights for Worker Service é um novo SDK, que é mais adequado para cargas de trabalho não HTTP, como mensagens, tarefas em segundo plano e aplicativos de console. Esses tipos de aplicativos não têm a noção de uma solicitação HTTP de entrada como um aplicativo Web ASP.NET/ASP.NET Core tradicional. Por esse motivo, não há suporte para o uso de pacotes do Application Insights para aplicativos ASP.NET ou ASP.NET Core .

Atenção

Recomendamos a distribuição OpenTelemetry do Azure Monitor para novas aplicações ou clientes, para dar suporte ao Azure Monitor Application Insights. A Distro OpenTelemetry do Azure Monitor oferece uma funcionalidade e experiência semelhantes às do SDK do Application Insights. É possível migrar do SDK do Application Insights usando os guias de migração para .NET, Node.js e Python, mas ainda estamos trabalhando para adicionar mais alguns recursos para compatibilidade com versões anteriores.

O novo SDK não faz nenhuma coleta de telemetria por si só. Em vez disso, ele traz outros coletores automáticos do Application Insights, como DependencyCollector, PerfCounterCollector e ApplicationInsightsLoggingProvider. Este SDK expõe métodos de extensão para IServiceCollection para habilitar e configurar a coleta de telemetria.

Cenários suportados

O SDK do Application Insights for Worker Service é mais adequado para aplicativos não-HTTP, não importa onde ou como eles são executados. Se seu aplicativo estiver em execução e tiver conectividade de rede com o Azure, a telemetria poderá ser coletada. O monitoramento do Application Insights é suportado em todos os lugares onde o .NET Core é suportado. Este pacote pode ser usado no recém-introduzido .NET Core Worker Service, tarefas em segundo plano no ASP.NET Core e aplicativos de console como .NET Core e .NET Framework.

Pré-requisitos

Você deve ter uma cadeia de conexão válida do Application Insights. Essa cadeia de caracteres é necessária para enviar qualquer telemetria para o Application Insights. Se precisar criar um novo recurso do Application Insights para obter uma cadeia de ligação, consulte Cadeias de ligação.

Nota

A 31 de março de 2025, o suporte para a ingestão de chaves de instrumentação terminará. A ingestão de chaves de instrumentação continuará a funcionar, mas não forneceremos mais atualizações ou suporte para o recurso. Transição para cadeias de conexão para aproveitar os novos recursos.

Usar o SDK do Application Insights para o Serviço do Trabalhador

Instale o pacote Microsoft.ApplicationInsights.WorkerService no aplicativo. O trecho a seguir mostra as alterações que devem ser adicionadas ao arquivo .csproj do seu projeto.
```
    <ItemGroup>
        <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.22.0" />
    </ItemGroup>
```
Configure a cadeia de conexão na APPLICATIONINSIGHTS_CONNECTION_STRING variável de ambiente ou na configuração (appsettings.json).
Recupere uma ILogger instância ou TelemetryClient instância do contêiner DI (Injeção de Dependência) chamando serviceProvider.GetRequiredService<TelemetryClient>(); ou usando a Injeção do Construtor. Esta etapa aciona a configuração de TelemetryConfiguration e dos módulos de coleta automática.

As instruções específicas para cada tipo de aplicação são descritas nas secções seguintes.

Aplicativo .NET Core Worker Service

O exemplo completo é compartilhado no site do NuGet.

Baixe e instale o SDK do .NET.
Crie um novo projeto do Serviço de Trabalho usando um novo modelo de projeto do Visual Studio ou a linha dotnet new workerde comando.
Adicione o pacote Microsoft.ApplicationInsights.WorkerService ao aplicativo.

Adicione services.AddApplicationInsightsTelemetryWorkerService(); ao CreateHostBuilder() método em sua Program.cs classe, como neste exemplo:

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

Modifique o seu Worker.cs de acordo com o exemplo a seguir:

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

Configurar a cadeia de conexão.

Nota

Recomendamos que você especifique a cadeia de conexão na configuração. O exemplo de código a seguir mostra como especificar uma cadeia de conexão no appsettings.json. Certifique-se de que appsettings.json é copiado para a pasta raiz do aplicativo durante a publicação.
```
    {
        "ApplicationInsights":
        {
            "ConnectionString" : "InstrumentationKey=00000000-0000-0000-0000-000000000000;"
        },
        "Logging":
        {
            "LogLevel":
            {
                "Default": "Warning"
            }
        }
    }
```

Como alternativa, especifique a cadeia de conexão na APPLICATIONINSIGHTS_CONNECTION_STRING variável de ambiente.

Normalmente, APPLICATIONINSIGHTS_CONNECTION_STRING especifica a cadeia de conexão para aplicativos implantados em aplicativos Web como trabalhos Web.

Nota

Uma cadeia de conexão especificada no código tem precedência sobre a variável APPLICATIONINSIGHTS_CONNECTION_STRINGde ambiente , que tem precedência sobre outras opções.

ASP.NET Principais tarefas em segundo plano com serviços hospedados

Este documento descreve como criar tarefas em segundo plano em um aplicativo ASP.NET Core.

O exemplo completo é compartilhado nesta página do GitHub.

Instale o pacote Microsoft.ApplicationInsights.WorkerService no aplicativo.

Adicione services.AddApplicationInsightsTelemetryWorkerService(); ao ConfigureServices() método, como neste exemplo:

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

O código a seguir é para TimedHostedService, onde reside a lógica da tarefa em segundo plano:

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

Configurar a cadeia de conexão. Use o mesmo appsettings.json do exemplo anterior de .NET Worker Service.

Aplicativo de console do .NET Core/.NET Framework

Como mencionado no início deste artigo, o novo pacote pode ser usado para habilitar a telemetria do Application Insights até mesmo de um aplicativo de console comum. Este pacote destina-se a netstandard2.0, para que possa ser usado para aplicações de consola no .NET Core ou superior e no .NET Framework ou superior.

O exemplo completo é compartilhado nesta página do GitHub.

Instale o pacote Microsoft.ApplicationInsights.WorkerService no aplicativo.

Modifique Program.cs conforme mostrado no exemplo a seguir:

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

Este aplicativo de console também usa o mesmo padrão TelemetryConfiguration. Ele pode ser personalizado da mesma forma que os exemplos nas seções anteriores.

Executar a aplicação

Execute seu aplicativo. Os trabalhadores de todos os exemplos anteriores fazem uma chamada HTTP a cada segundo para bing.com e também emitem poucos logs usando ILogger. Essas linhas são envolvidas dentro da StartOperation chamada de TelemetryClient, que é usada para criar uma operação. Neste exemplo, RequestTelemetry é chamado de "operação".

A Application Insights coleta, por padrão, esses logs ILogger com severidade de Aviso ou acima, bem como as dependências. Eles estão correlacionados RequestTelemetry com uma relação entre pais e filhos. A correlação também funciona através dos limites do processo/rede. Por exemplo, se a chamada foi feita para outro componente monitorado, ela também está correlacionada a este componente principal.

Esta operação personalizada de RequestTelemetry pode ser considerada o equivalente a uma solicitação web recebida num aplicativo web típico. Não é necessário usar uma operação, mas ela se encaixa melhor com o modelo de dados de correlação do Application Insights. RequestTelemetry atua como a operação pai e cada telemetria gerada dentro da iteração do trabalhador é tratada como logicamente pertencente à mesma operação.

Esta abordagem também garante que toda a telemetria gerada, tanto automática como manual, tenha o mesmo operation_id. Como a amostragem é baseada em operation_id, o algoritmo de amostragem mantém ou descarta toda a telemetria de uma única iteração.

As seções a seguir listam a telemetria completa coletada automaticamente pelo Application Insights.

Métricas em tempo real

As métricas em tempo real podem ser usadas para verificar rapidamente se o monitoramento de aplicativos com o Application Insights está configurado corretamente. A telemetria pode levar alguns minutos para aparecer no portal do Azure, mas o painel de métricas ao vivo mostra o uso da CPU do processo em execução quase em tempo real. Ele também pode mostrar outras telemetrias, como solicitações, dependências e rastreamentos.

Registos do ILogger

Os logs emitidos com ILogger o aviso de gravidade ou superior são capturados automaticamente. Para alterar este comportamento, substitua explicitamente a configuração de registo para o provedor ApplicationInsights, conforme mostrado no código a seguir. A configuração a seguir permite que o Application Insights capture todos os Information logs e logs mais severos.

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

É importante observar que o exemplo a seguir não faz com que o provedor do Application Insights capture Information logs. Não o captura porque o SDK adiciona um filtro de log padrão que instrui ApplicationInsights a capturar apenas logs Warning e logs mais severos. O Application Insights requer uma substituição explícita.

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

Nota

O Application Insights respeita os níveis de log configurados via ConfigureLogging(...) no código. Se apenas appsettings.json for usado e ConfigureLogging não for substituído explicitamente, o nível de log padrão será Warning.

Para obter mais informações, siga os documentos do ILogger para personalizar quais níveis de log são capturados pelo Application Insights.

Dependências

A coleção de dependências é ativada por padrão. O artigo Dependency tracking in Application Insights explica as dependências que são coletadas automaticamente e também contém etapas para fazer o rastreamento manual.

Contador de Eventos

EventCounterCollectionModule está ativado por defeito e recolhe um conjunto padrão de contadores de apps .NET. O tutorial EventCounter lista o conjunto padrão de contadores recolhidos. Ele também tem instruções sobre como personalizar a lista.

Rastrear manualmente outros dados de telemetria

Embora o SDK colete automaticamente a telemetria conforme explicado, na maioria dos casos, você precisa enviar outra telemetria para o Application Insights. A maneira recomendada de seguir outra telemetria é obtendo uma instância de TelemetryClient da Injeção de Dependência e, em seguida, chamando um dos métodos de TrackXXX()API suportados nela. Outro caso de uso típico é o rastreamento personalizado de operações. Esta abordagem é demonstrada nos exemplos de trabalhadores anteriores.

Configurar o SDK do Application Insights

O padrão TelemetryConfiguration usado pelo SDK do Serviço Worker é semelhante à configuração automática usada num aplicativo ASP.NET ou ASP.NET Core, exceto os inicializadores de telemetria usados para enriquecer a telemetria de HttpContext.

Você pode personalizar o SDK do Application Insights para o Serviço de Trabalho para alterar a configuração padrão. Os utilizadores do SDK do Application Insights ASP.NET Core podem estar familiarizados com a alteração da configuração usando a injeção interna de dependência do ASP.NET Core. O SDK do Serviço de Trabalho também se baseia em princípios semelhantes. Faça quase todas as alterações de configuração na ConfigureServices() seção chamando os métodos apropriados no IServiceCollection, conforme detalhado na próxima seção.

Nota

Quando você usa esse SDK, não há suporte para alterar a configuração modificando TelemetryConfiguration.Active e as alterações não serão refletidas.

Usar o ApplicationInsightsServiceOptions

Você pode modificar algumas configurações comuns passando ApplicationInsightsServiceOptions para AddApplicationInsightsTelemetryWorkerService, como neste exemplo:

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

O ApplicationInsightsServiceOptions neste SDK está no namespace Microsoft.ApplicationInsights.WorkerService em oposição ao Microsoft.ApplicationInsights.AspNetCore.Extensions SDK do ASP.NET Core.

A tabela a seguir lista as configurações mais usadas no ApplicationInsightsServiceOptions.

Configuração	Descrição	Predefinido
HabilitarStreamDeMétricasQuickPulse	Ativar/desativar o recurso de métricas ao vivo.	Verdadeiro
Ativar Amostragem Adaptativa	Ativar/desativar a amostragem adaptável.	Verdadeiro
AtivarBatimentoCardíaco	Habilite/desabilite o recurso Heartbeats, que periodicamente (padrão de 15 minutos) envia uma métrica personalizada chamada "HeartBeatState" com informações sobre o tempo de execução, como a versão .NET e o ambiente do Azure, se aplicável.	Verdadeiro
AddAutoCollectedMetricExtractor (Adicionar Extrator de Métrica Coletada Automaticamente)	Habilite/desabilite o extrator AutoCollectedMetrics, que é um processador de telemetria que envia métricas pré-agregadas sobre solicitações/dependências antes que a amostragem ocorra.	Verdadeiro
AtivarMóduloDeTelemetriaDeDiagnóstico	Ativar/Desativar `DiagnosticsTelemetryModule`. A desativação dessa configuração faz com que as seguintes configurações sejam ignoradas: `EnableHeartbeat`, `EnableAzureInstanceMetadataTelemetryModule`e `EnableAppServicesHeartbeatTelemetryModule`.	Verdadeiro

Para obter a lista mais atualizada, consulte as configurações configuráveis em ApplicationInsightsServiceOptions.

Amostragem

O SDK do Application Insights for Worker Service oferece suporte à amostragem de taxa fixa e à amostragem adaptável. A amostragem adaptável está habilitada por padrão. A amostragem pode ser desabilitada usando a EnableAdaptiveSampling opção em ApplicationInsightsServiceOptions.

Para definir outras configurações de amostragem, você pode usar o seguinte exemplo:

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.AddApplicationInsightsTelemetryWorkerService(new ApplicationInsightsServiceOptions
{
   EnableAdaptiveSampling = false,
});

var app = builder.Build();

Para obter mais informações, consulte o documento de amostragem .

Adicionar inicializadores de telemetria

Use inicializadores de telemetria quando quiser definir propriedades enviadas com toda a telemetria.

Adicione qualquer novo inicializador de telemetria DependencyInjection ao contêiner e o SDK os adiciona automaticamente ao TelemetryConfiguration.

    using Microsoft.ApplicationInsights.Extensibility;

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

Remover inicializadores de telemetria

Os inicializadores de telemetria estão presentes por padrão. Para remover todos ou inicializadores de telemetria específicos, use o seguinte código de exemplo depois de chamar 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));
   }

Adicionar processadores de telemetria

Você pode adicionar processadores de telemetria personalizados a TelemetryConfiguration usando o método de extensão AddApplicationInsightsTelemetryProcessor em IServiceCollection. Você usa processadores de telemetria em cenários avançados de filtragem para permitir um controle mais direto sobre o que está incluído ou excluído da telemetria enviada ao Application Insights. Utilize o seguinte exemplo:

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

Configurar ou remover módulos de telemetria padrão

O Application Insights usa módulos de telemetria para coletar automaticamente telemetria sobre cargas de trabalho específicas sem exigir rastreamento manual.

Os seguintes módulos de coleta automática são habilitados por padrão. Estes módulos são responsáveis pela recolha automática da telemetria. Você pode desativá-los ou configurá-los para alterar seu comportamento padrão.

DependencyTrackingTelemetryModule
PerformanceCollectorModule
QuickPulseTelemetryModule
AppServicesHeartbeatTelemetryModule (Atualmente, há um problema envolvendo este módulo de telemetria. Para obter uma solução temporária, consulte GitHub Issue 1689.)
AzureInstanceMetadataTelemetryModule

Para configurar qualquer módulo de telemetria padrão, use o método de extensão ConfigureTelemetryModule<T> em IServiceCollection, conforme mostrado no exemplo a seguir.

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

Configurar o canal de telemetria

O canal padrão é ServerTelemetryChannel. Você pode substituí-lo como mostra o exemplo a seguir:

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

Desativar a telemetria dinamicamente

Se quiser desativar a telemetria de forma condicional e dinâmica, pode resolver a instância TelemetryConfiguration usando um contentor de injeção de dependência ASP.NET Core em qualquer parte do código e definir o sinalizador DisableTelemetry na instância.

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

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

Exemplos de aplicações

Aplicativo de console .NET Core: use este exemplo se estiver usando um aplicativo de console escrito em .NET Core (2.0 ou superior) ou .NET Framework (4.7.2 ou superior).

ASP.NET Core tarefas em segundo plano com HostedServices: use este exemplo se estiver no ASP.NET Core e criando tarefas em segundo plano de acordo com as orientações oficiais.

.NET Core Worker Service: Use este exemplo se você tiver um aplicativo .NET Worker Service de acordo com as diretrizes oficiais.

SDK de código aberto

Leia e contribua para o código.

Para obter as atualizações e correções de bugs mais recentes, consulte as Notas de versão.

Próximos passos

Para revisar as perguntas freqüentes, consulte Perguntas frequentes sobre aplicativos do Serviço de Trabalho.
Valide se você está executando uma versão suportada do SDK do Application Insights.
Use a API para enviar seus próprios eventos e métricas para obter uma visão detalhada do desempenho e do uso do seu aplicativo.
Rastreie mais dependências não rastreadas automaticamente.
Enriqueça ou filtre a telemetria recolhida automaticamente.
Injeção de Dependência no ASP.NET Core.

Partilhar via

Application Insights para aplicativos do Serviço de Trabalho (aplicativos não HTTP)

Cenários suportados

Pré-requisitos

Usar o SDK do Application Insights para o Serviço do Trabalhador

Aplicativo .NET Core Worker Service

ASP.NET Principais tarefas em segundo plano com serviços hospedados

Aplicativo de console do .NET Core/.NET Framework

Executar a aplicação

Métricas em tempo real

Registos do ILogger

Dependências

Contador de Eventos

Rastrear manualmente outros dados de telemetria

Configurar o SDK do Application Insights

Usar o ApplicationInsightsServiceOptions

Amostragem

Adicionar inicializadores de telemetria

Remover inicializadores de telemetria

Adicionar processadores de telemetria

Configurar ou remover módulos de telemetria padrão

Configurar o canal de telemetria

Desativar a telemetria dinamicamente

Exemplos de aplicações

SDK de código aberto

Próximos passos

Comentários

Recursos adicionais