Aplicativos do Application Insights para Worker Service (aplicativos não HTTP)

O SDK do Application Insights para Serviço de Trabalho é um novo SDK 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.

O novo SDK não faz nenhuma coleta de telemetria sozinho. Em vez disso, ele traz outros coletores automáticos do Application Insights conhecidos, como DependencyCollector, PerfCounterCollector e ApplicationInsightsLoggingProvider. Esse SDK expõe métodos de extensão no IServiceCollection para habilitar e configurar a coleção de telemetria.

Cenários com suporte

O SDK do Application Insights para Worker Service é mais adequado para aplicativos não HTTP, independentemente de onde ou como eles são executados. Se o seu aplicativo estiver em execução e tiver conectividade de rede com o Azure, será possível coletar telemetria. O monitoramento do Application Insights tem suporte em todos os lugares do .NET Core. Este pacote pode ser usado no recém-introduzido Serviço de Trabalho do .NET Core, 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 recurso do Application Insights para obter uma cadeia de conexão, confira Cadeias de conexão.

Uso do SDK do Application Insights para Serviço de Trabalho

1. Instale o pacote Microsoft.ApplicationInsights.WorkerService no aplicativo. O snippet 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>
   

2. Configure a cadeia de conexão na variável de ambiente APPLICATIONINSIGHTS_CONNECTION_STRING ou na configuração (appsettings.json).

   

3. Recupere uma instância de ILogger ou de TelemetryClient do contêiner de DI (Injeção de Dependência) chamando serviceProvider.GetRequiredService<TelemetryClient>(); ou usando uma Injeção de Construtor. Esta etapa dispara a configuração do TelemetryConfiguration e de módulos de coleta automática.

As instruções específicas para cada tipo de aplicação são descritas nas seções a seguir.

Aplicativo .NET Core Worker Service

O exemplo completo está no site do NuGet.

1. Baixar e instalar o .NET SDK.

2. Crie um novo projeto de Serviço de Trabalho usando um novo modelo de projeto do Visual Studio ou a linha de comando dotnet new worker.

3. Adicione o pacote Microsoft.ApplicationInsights.WorkerService no aplicativo.

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

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

5. Modifique seu Worker.cs de acordo com o seguinte exemplo:

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

6. Definir a cadeia de conexão.

   

   Observação

   É recomendável 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. Verifique se o appsettings.json foi 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 variável de ambiente APPLICATIONINSIGHTS_CONNECTION_STRING.

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

Tarefas em segundo plano do ASP.NET Core com serviços hospedados

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

O exemplo completo está nesta página do GitHub.

1. Instale o pacote Microsoft.ApplicationInsights.WorkerService no aplicativo.

2. Adicione services.AddApplicationInsightsTelemetryWorkerService(); ao método ConfigureServices(), 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 é do TimedHostedService, no qual 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");
               }
           }
       }
   

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

Aplicativo de console do .NET Framework/.NET Core

Conforme 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 regular. Esse pacote tem como destino o netstandard2.0 e, portanto, pode ser usado para aplicativos de console no .NET Core ou superior e no .NET Framework ou superior.

O exemplo completo está nesta página do GitHub.

1. Instale o pacote Microsoft.ApplicationInsights.WorkerService no aplicativo.

2. Modifique Program.cs conforme mostrado no seguinte exemplo:

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

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

Execute seu aplicativo.

Execute seu aplicativo. As funções de trabalho de todos os exemplos anteriores fazem uma chamada HTTP a cada segundo para bing.com e também emitem poucos logs usando ILogger. Estas linhas estão encapsuladas dentro da chamada StartOperation 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 gravidade de Aviso ou superior por padrão, e dependências. Eles estão correlacionados a RequestTelemetry com uma relação pai-filho. A correlação também funciona por meio 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 do RequestTelemetry pode ser considerada como o equivalente de uma solicitação da Web de entrada em um aplicativo Web típico. Não é necessário usar uma operação, mas ela se ajusta melhor ao 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 pertencente logicamente à mesma operação.

Essa abordagem também garante que toda a telemetria gerada, automática e manual, terá o mesmo operation_id. Como a amostragem se baseia no operation_id, o algoritmo de amostragem mantém ou descarta toda a telemetria de uma única iteração.

A seguinte seção lista a telemetria completa coletada automaticamente pelo Application Insights.

Live Metrics

Métricas dinâmicas podem ser usadas para verificar rapidamente se o monitoramento de aplicativo 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 dinâmicas 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, rastreamentos etc.

Logs do ILogger

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

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

É importante observar que o exemplo seguinte não fará com que o provedor do Application Insights capture logs Information. Ele não os captura porque o SDK adiciona um filtro de log padrão que instrui o ApplicationInsights a capturar os logs Warning e mais graves. O Application Insights requer uma substituição explícita.

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

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

Dependências

Por padrão, a coleta de dependências está habilitada. O artigo Acompanhamento de dependência no Application Insights explica as dependências coletadas automaticamente e também contém etapas explicando como realizar o acompanhamento manual.

EventCounter

O EventCounterCollectionModule é habilitado por padrão e coletará um conjunto padrão de contadores de aplicativos .NET. O tutorial do EventCounter lista o conjunto padrão de contadores coletados. Ele também tem instruções sobre como personalizar a lista.

Rastreamento manual de outra telemetria

Embora o SDK colete automaticamente a telemetria conforme explicado, na maioria dos casos, você precisará enviar outra telemetria para o Application Insights. A maneira recomendada de rastrear outra telemetria é obter uma instância de TelemetryClient na Injeção de Dependência e chamar um dos métodos da API TrackXXX() com suporte para ela. Outro caso de uso típico é o acompanhamento personalizado das operações. Essa abordagem é demonstrada nos exemplos da função de trabalho acima.

Configurar o SDK do Application Insights

O TelemetryConfiguration padrão usado pelo SDK do Serviço de Trabalho é semelhante à configuração automática usada em um aplicativo ASP.NET ou ASP.NET Core, mas sem os inicializadores de telemetria usados para enriquecer a telemetria no HttpContext.

Você pode personalizar o SDK do Application Insights para o Worker Service para alterar a configuração padrão. Os usuários do SDK do ASP.NET Core do Application Insights 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 é baseado em princípios semelhantes. Faça quase todas as alterações de configuração na seção ConfigureServices() chamando os métodos apropriados em IServiceCollection, conforme detalhado na próxima seção.

Uso do 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 a Microsoft.ApplicationInsights.AspNetCore.Extensions no SDK do ASP.NET Core.

A seguinte tabela lista as configurações mais usadas em ApplicationInsightsServiceOptions.

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

amostragem

O SDK do Application Insights para o Worker Service dá suporte à amostragem de taxa fixa e à amostragem adaptável. A amostragem adaptável é habilitada por padrão. A amostragem pode ser desabilitada usando a opção EnableAdaptiveSampling no 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.AddApplicationInsightsTelemetry(new ApplicationInsightsServiceOptions
{
   EnableAdaptiveSampling = false,
});

var app = builder.Build();

Para obter mais informações, confira nossa documentação de Amostragem.

Adicionar inicializadores de telemetria

Use os inicializadores de telemetria quando desejar definir propriedades que são enviadas com toda a telemetria.

Adicione qualquer novo inicializador de telemetria ao contêiner DependencyInjection, o SDK os adicionará 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 os inicializadores de telemetria, ou alguns específicos, use o código de exemplo a seguir 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 ao TelemetryConfiguration usando o método de extensão AddApplicationInsightsTelemetryProcessor no IServiceCollection. Use processadores de telemetria em cenários de filtragem avançada para permitir um controle mais direto sobre o que está incluído ou excluído da telemetria que você envia para o Application Insights. Use 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 a telemetria sobre cargas de trabalho específicas sem a necessidade de acompanhamento manual.

Os seguintes módulos de coleta automática são habilitados por padrão. Esses módulos são responsáveis por coletar automaticamente a telemetria. Você pode desabilitá-los ou configurá-los para alterar o comportamento padrão deles.

• DependencyTrackingTelemetryModule
• PerformanceCollectorModule
• QuickPulseTelemetryModule
• AppServicesHeartbeatTelemetryModule (Atualmente há um problema envolvendo esse módulo de telemetria. Para obter uma solução temporária, confira Problema 1689 do GitHub.)
• AzureInstanceMetadataTelemetryModule

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

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

Desabilitar a telemetria dinamicamente

Se quiser desabilitar a telemetria de modo condicional e dinâmico, você pode resolver a instância TelemetryConfiguration com um contêiner de injeção de dependência do ASP.NET Core em qualquer lugar do seu código e definir o sinalizador DisableTelemetry nele.

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

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

Perguntas frequentes

Esta seção fornece respostas para perguntas comuns.

Qual pacote eu devo usar?

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

Sim. A configuração será compartilhada com o restante do aplicativo Web.

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

Obtenha uma instância de TelemetryClient usando a injeção de construtor e chame o método TrackXXX() necessário nela. Não recomendamos a criação de instâncias de TelemetryClient. Uma instância singleton do TelemetryClient já está registrada no contêiner de DependencyInjection, que compartilha o TelemetryConfiguration com o restante da telemetria. A criação de uma instância de TelemetryClient é recomendada apenas 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, há suporte para a integração do IDE do Visual Studio apenas para aplicativos ASP.NET/ASP.NET Core. Este documento será atualizado quando o Visual Studio enviar suporte para integração de aplicativos do Serviço de Trabalho.

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

Não. O Agente do Application Insights do Azure Monitor atualmente oferece suporte apenas ao .NET.

Se eu executar meu aplicativo no Linux, todos os recursos terão suporte?

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

• Os contadores de desempenho têm suporte apenas no Windows, exceto para CPU/Memória de processo mostrada em métricas dinâmicas.

• Embora o ServerTelemetryChannel esteja habilitado por padrão, se o aplicativo estiver sendo executado no Linux ou no macOS, se houver problemas de rede, o canal não criará automaticamente uma pasta de armazenamento local na qual manter a telemetria temporariamente. Devido a essa limitação, a telemetria será perdida quando houver problemas temporários de rede ou de 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();
      }
  

Aplicativos de exemplo

Aplicativo de console do .NET Core siga esse exemplo se você está usando um aplicativo de console escrito em .NET Core (2.0 ou superior) ou .NET Framework (4.7.2 ou superior).

Tarefa em segundo plano do ASP.NET com HostedServices: siga este exemplo se você está no ASP.NET Core e criando tarefas em segundo plano de acordo com as diretrizes oficiais.

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

SDK do código-fonte aberto

Ler e contribuir para o código.

Para obter as atualizações e as correções de bugs mais recentes, confira as notas sobre a versão.

Próximas etapas

• Use a API para enviar os seus eventos e métricas para uma exibição detalhada do desempenho e do uso do aplicativo.
• Acompanhe mais dependências que não são acompanhadas automaticamente.
• Enriqueça ou filtre a telemetria coletada automaticamente.
• Injeção de Dependência no ASP.NET Core.