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

Artigo
12/07/2024

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 Distro OpenTelemetry do Azure Monitor para novos aplicativos ou clientes para potencializar o 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 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 você precisar criar um novo recurso do Application Insights para obter uma cadeia de conexão, consulte Cadeias de conexão.

Nota

A 31 de março de 2025, o suporte da 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 .csproj ao arquivo 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 e a coleta automática de TelemetryConfiguration módulos.

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

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

Configure a cadeia de conexão. Use o mesmo appsettings.json do exemplo anterior do .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 netstandard2.0a , para que possa ser usado para aplicativos de console 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 encapsuladas dentro da StartOperation chamada de TelemetryClient, que é usada para criar uma operação. Neste exemplo, RequestTelemetry é chamado de "operação".

O Application Insights coleta esses logs ILogger, com uma severidade de Aviso ou superior por padrão, e 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 esse pai.

Essa operação personalizada de pode ser pensada RequestTelemetry como o equivalente a uma solicitação da Web de entrada em um 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.

Logs do ILogger

Os logs emitidos com ILogger o aviso de gravidade ou superior são capturados automaticamente. Para alterar esse comportamento, substitua explicitamente a configuração de log 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. Ele não o captura porque o SDK adiciona um filtro de log padrão que instrui ApplicationInsights a capturar apenas Warning logs e logs mais severos. O Application Insights requer uma substituição explícita.

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

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 coleta de dependência é habilitada 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á habilitado por padrão e coleta um conjunto padrão de contadores de aplicativos . NET . O tutorial EventCounter lista o conjunto padrão de contadores coletados. Ele também tem instruções sobre como personalizar a lista.

Rastrear manualmente outras telemetrias

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 controlar outra telemetria é obtendo uma instância de de Injeção de Dependência e, em seguida, chamando um dos métodos de API suportados TelemetryClient TrackXXX() 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 de Trabalho é semelhante à configuração automática usada em um aplicativo ASP.NET ou ASP.NET Core, menos os inicializadores de telemetria usados para enriquecer a telemetria do HttpContext.

Você pode personalizar o SDK do Application Insights para o Serviço de Trabalho para alterar a configuração padrão. Os usuários do SDK do Application Insights ASP.NET Core podem estar familiarizados com a alteração da configuração usando a injeção de dependência interna 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 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.

Definição	Descrição	Predefinido
EnableQuickPulseMetricStream	Ativar/desativar o recurso de métricas ao vivo.	True
EnableAdaptiveSampling	Ativar/desativar a amostragem adaptável.	True
EnableHeartbeat	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.	True
AddAutoCollectedMetricExtractor	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.	True
EnableDiagnosticsTelemetryModule	Ativar/Desativar `DiagnosticsTelemetryModule`. A desativação dessa configuração faz com que as seguintes configurações sejam ignoradas: `EnableHeartbeat`, `EnableAzureInstanceMetadataTelemetryModule`e `EnableAppServicesHeartbeatTelemetryModule`.	True

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 que são 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 usando TelemetryConfiguration o método AddApplicationInsightsTelemetryProcessor de extensão 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 ConfigureTelemetryModule<T> extension no 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 desabilitar a telemetria condicional e dinamicamente, você pode resolver a TelemetryConfiguration instância com um contêiner de injeção de dependência do ASP.NET Core em qualquer lugar do código e definir o DisableTelemetry sinalizador nele.

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

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

Perguntas mais frequentes

Esta secção fornece respostas a perguntas comuns.

Que embalagem devo usar?

Cenário do aplicativo .NET Core	Pacote
Sem HostedServices	Serviço de Trabalhadores
Com HostedServices	AspNetCore (não WorkerService)
Com HostedServices, monitorando apenas HostedServices	WorkerService (cenário raro)

Os HostedServices dentro de um aplicativo .NET Core usando o pacote AspNetCore podem ter o TelemetryClient injetado nele?

Sim, a configuração é compartilhada com o resto do aplicativo Web.

Como posso rastrear a telemetria que não é coletada automaticamente?

Obtenha uma instância de usando a injeção do TelemetryClient construtor e chame o método necessário TrackXXX() nele. Não recomendamos a criação de novas TelemetryClient instâncias. Uma instância singleton de TelemetryClient já está registrada no DependencyInjection contêiner, que compartilha TelemetryConfiguration com o resto da telemetria. A criação de uma nova TelemetryClient instância é recomendada somente se ela precisar de uma configuração separada do restante da telemetria.

Posso usar o IDE do Visual Studio para integrar o Application Insights a um projeto do Worker Service?

Atualmente, a integração do IDE do Visual Studio é suportada apenas para aplicativos ASP.NET/ASP.NET Core. Este documento é atualizado quando o Visual Studio fornece suporte para integração de aplicativos do Serviço de Trabalho.

Posso habilitar o monitoramento do Application Insights usando ferramentas como o Azure Monitor Application Insights Agent (anteriormente Status Monitor v2)?

N.º Atualmente, o Azure Monitor Application Insights Agent oferece suporte apenas ao .NET .

Todos os recursos são suportados se eu executar meu aplicativo no Linux?

Sim. O suporte a recursos para este SDK é o mesmo em todas as plataformas, com as seguintes exceções:

Contadores de desempenho são suportados apenas no Windows, exceto para Process CPU/Memory mostrado em métricas ao vivo.

ServerTelemetryChannel Embora esteja habilitado por padrão, se o aplicativo estiver sendo executado no Linux ou macOS, o canal não criará automaticamente uma pasta de armazenamento local para manter a telemetria temporariamente se houver problemas de rede. Devido a essa limitação, a telemetria é perdida quando há problemas temporários de rede ou servidor. Para contornar esse problema, configure uma pasta local para o canal:

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

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 Principais tarefas em segundo plano com HostedServices: use este exemplo se você 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

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 núcleo ASP.NET.

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

Logs do ILogger

Dependências

Contador de Eventos

Rastrear manualmente outras telemetrias

Configurar o SDK do Application Insights

Usar 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

Perguntas mais frequentes

Que embalagem devo usar?

Os HostedServices dentro de um aplicativo .NET Core usando o pacote AspNetCore podem ter o TelemetryClient injetado nele?

Como posso rastrear a telemetria que não é coletada automaticamente?

Posso usar o IDE do Visual Studio para integrar o Application Insights a um projeto do Worker Service?

Posso habilitar o monitoramento do Application Insights usando ferramentas como o Azure Monitor Application Insights Agent (anteriormente Status Monitor v2)?

Todos os recursos são suportados se eu executar meu aplicativo no Linux?

Exemplos de aplicações

SDK de código aberto

Próximos passos

Comentários

Recursos adicionais