Métricas em tempo real: monitore e diagnostique com latência de 1 segundo

Artigo
10/18/2023

Monitore seu aplicativo Web ao vivo e em produção usando o Live Metrics (também conhecido como QuickPulse) do Application Insights. Você pode selecionar e filtrar métricas e contadores de desempenho para assistir em tempo real, sem qualquer perturbação ao seu serviço. Você também pode inspecionar rastreamentos de pilha de exemplos de solicitações com falha e exceções. Juntamente com o Profiler e o Snapshot Debugger, o Live Metrics fornece uma ferramenta de diagnóstico poderosa e não invasiva para o seu site ao vivo.

Nota

O Live Metrics apenas suporta o TLS 1.2. Para mais informações, consulte Resolução de Problemas.

Com o Live Metrics, você pode:

Valide uma correção enquanto ela é liberada observando o desempenho e as contagens de falhas.
Assista ao efeito das cargas de teste e diagnostique problemas ao vivo.
Concentre-se em sessões de teste específicas ou filtre problemas conhecidos selecionando e filtrando as métricas que deseja assistir.
Obtenha rastreamentos de exceções à medida que elas acontecem.
Experimente filtros para encontrar os KPIs mais relevantes.
Monitore qualquer contador de desempenho do Windows ao vivo.
Identifique facilmente um servidor que está tendo problemas e filtre todos os KPI/feed ao vivo apenas para esse servidor.

Atualmente, há suporte para o Live Metrics para aplicativos ASP.NET, ASP.NET Core, Azure Functions, Java e Node.js.

Nota

O número de instâncias de servidor monitoradas exibidas pelo Live Metrics pode ser menor do que o número real de instâncias alocadas para o aplicativo. Essa incompatibilidade ocorre porque muitos servidores Web modernos descarregam aplicativos que não recebem solicitações durante um período de tempo para conservar recursos. Como o Live Metrics conta apenas os servidores que estão executando o aplicativo no momento, os servidores que já descarregaram o processo não serão incluídos nesse total.

Começar

Importante

Para habilitar o Application Insights, verifique se ele está ativado no portal do Azure e se seu aplicativo está usando uma versão recente do pacote NuGet do Application Insights . Sem o pacote NuGet, alguma telemetria é enviada para o Application Insights, mas essa telemetria não será exibida no Live Metrics.

Siga as diretrizes específicas do idioma para habilitar o Live Metrics:
- ASP.NET: O Live Metrics está ativado por padrão.
- ASP.NET Core: Live Metrics está habilitado por padrão.
- .NET/.NET Core Console/Worker: o Live Metrics está habilitado por padrão.
- Aplicativos .NET: habilite usando código.
- Java: O Live Metrics está ativado por padrão.
- Node.js
No portal do Azure, abra o recurso do Application Insights para seu aplicativo. Em seguida, abra a transmissão ao vivo.
Proteja o canal de controle se você puder usar dados confidenciais, como nomes de clientes, em seus filtros.

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.

Habilite métricas em tempo real usando código para qualquer aplicativo .NET

Nota

O Live Metrics é habilitado por padrão quando você o integra usando as instruções recomendadas para aplicativos .NET.

Para configurar manualmente o Live Metrics:

Instale o pacote NuGet Microsoft.ApplicationInsights.PerfCounterCollector.
O código de aplicativo de console de exemplo a seguir mostra a configuração do Live Metrics:

using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse;

// Create a TelemetryConfiguration instance.
TelemetryConfiguration config = TelemetryConfiguration.CreateDefault();
config.InstrumentationKey = "INSTRUMENTATION-KEY-HERE";
QuickPulseTelemetryProcessor quickPulseProcessor = null;
config.DefaultTelemetrySink.TelemetryProcessorChainBuilder
    .Use((next) =>
    {
        quickPulseProcessor = new QuickPulseTelemetryProcessor(next);
        return quickPulseProcessor;
    })
    .Build();

var quickPulseModule = new QuickPulseTelemetryModule();

// Secure the control channel.
// This is optional, but recommended.
quickPulseModule.AuthenticationApiKey = "YOUR-API-KEY-HERE";
quickPulseModule.Initialize(config);
quickPulseModule.RegisterTelemetryProcessor(quickPulseProcessor);

// Create a TelemetryClient instance. It is important
// to use the same TelemetryConfiguration here as the one
// used to set up Live Metrics.
TelemetryClient client = new TelemetryClient(config);

// This sample runs indefinitely. Replace with actual application logic.
while (true)
{
    // Send dependency and request telemetry.
    // These will be shown in Live Metrics.
    // CPU/Memory Performance counter is also shown
    // automatically without any additional steps.
    client.TrackDependency("My dependency", "target", "http://sample",
        DateTimeOffset.Now, TimeSpan.FromMilliseconds(300), true);
    client.TrackRequest("My Request", DateTimeOffset.Now,
        TimeSpan.FromMilliseconds(230), "200", true);
    Task.Delay(1000).Wait();
}

using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse;
using System;
using System.Threading.Tasks;

namespace LiveMetricsDemo
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // Create a TelemetryConfiguration instance.
            TelemetryConfiguration config = TelemetryConfiguration.CreateDefault();
            config.InstrumentationKey = "INSTRUMENTATION-KEY-HERE";
            QuickPulseTelemetryProcessor quickPulseProcessor = null;
            config.DefaultTelemetrySink.TelemetryProcessorChainBuilder
                .Use((next) =>
                {
                    quickPulseProcessor = new QuickPulseTelemetryProcessor(next);
                    return quickPulseProcessor;
                })
                .Build();

            var quickPulseModule = new QuickPulseTelemetryModule();

            // Secure the control channel.
            // This is optional, but recommended.
            quickPulseModule.AuthenticationApiKey = "YOUR-API-KEY-HERE";
            quickPulseModule.Initialize(config);
            quickPulseModule.RegisterTelemetryProcessor(quickPulseProcessor);

            // Create a TelemetryClient instance. It is important
            // to use the same TelemetryConfiguration here as the one
            // used to set up Live Metrics.
            TelemetryClient client = new TelemetryClient(config);

            // This sample runs indefinitely. Replace with actual application logic.
            while (true)
            {
                // Send dependency and request telemetry.
                // These will be shown in Live Metrics.
                // CPU/Memory Performance counter is also shown
                // automatically without any additional steps.
                client.TrackDependency("My dependency", "target", "http://sample",
                    DateTimeOffset.Now, TimeSpan.FromMilliseconds(300), true);
                client.TrackRequest("My Request", DateTimeOffset.Now,
                    TimeSpan.FromMilliseconds(230), "200", true);
                Task.Delay(1000).Wait();
            }
        }
    }
}

Nota

Esta versão .NET não é mais suportada.

using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse;
using System;
using System.Threading.Tasks;

namespace LiveMetricsDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a TelemetryConfiguration instance.
            TelemetryConfiguration config = TelemetryConfiguration.CreateDefault();
            config.InstrumentationKey = "INSTRUMENTATION-KEY-HERE";
            QuickPulseTelemetryProcessor quickPulseProcessor = null;
            config.DefaultTelemetrySink.TelemetryProcessorChainBuilder
                .Use((next) =>
                {
                    quickPulseProcessor = new QuickPulseTelemetryProcessor(next);
                    return quickPulseProcessor;
                })
                .Build();

            var quickPulseModule = new QuickPulseTelemetryModule();

            // Secure the control channel.
            // This is optional, but recommended.
            quickPulseModule.AuthenticationApiKey = "YOUR-API-KEY-HERE";
            quickPulseModule.Initialize(config);
            quickPulseModule.RegisterTelemetryProcessor(quickPulseProcessor);

            // Create a TelemetryClient instance. It is important
            // to use the same TelemetryConfiguration here as the one
            // used to set up Live Metrics.
            TelemetryClient client = new TelemetryClient(config);

            // This sample runs indefinitely. Replace with actual application logic.
            while (true)
            {
                // Send dependency and request telemetry.
                // These will be shown in Live Metrics.
                // CPU/Memory Performance counter is also shown
                // automatically without any additional steps.
                client.TrackDependency("My dependency", "target", "http://sample",
                    DateTimeOffset.Now, TimeSpan.FromMilliseconds(300), true);
                client.TrackRequest("My Request", DateTimeOffset.Now,
                    TimeSpan.FromMilliseconds(230), "200", true);
                Task.Delay(1000).Wait();
            }
        }
    }
}

O exemplo anterior é para um aplicativo de console, mas o mesmo código pode ser usado em qualquer aplicativo .NET. Se quaisquer outros módulos de telemetria estiverem habilitados para coletar telemetria automaticamente, é importante garantir que a mesma configuração usada para inicializar esses módulos seja usada para o módulo Live Metrics.

Qual é a diferença entre o Live Metrics e o explorador de métricas e o Log Analytics?

Capacidades	Live Stream	Explorador de métricas e análise de logs
Latência	Dados exibidos em um segundo.	Agregado em minutos.
Sem retenção	Os dados persistem enquanto estão no gráfico e, em seguida, são descartados.	Dados retidos por 90 dias.
A pedido	Os dados só são transmitidos enquanto o painel Métricas em tempo real está aberto.	Os dados são enviados sempre que o SDK é instalado e ativado.
Gratuito	Não há cobrança para os dados de transmissão ao vivo.	Sujeito a preços.
Amostragem	Todas as métricas e contadores selecionados são transmitidos. Falhas e rastreamentos de pilha são amostrados.	Os eventos podem ser amostrados.
Canal de controlo	Os sinais de controle de filtro são enviados para o SDK. Recomendamos que você proteja este canal.	A comunicação é um caminho, para o portal.

Selecione e filtre suas métricas

Esses recursos estão disponíveis com ASP.NET, ASP.NET Core e Azure Functions (v2).

Você pode monitorar KPIs personalizados ao vivo aplicando filtros arbitrários em qualquer telemetria do Application Insights a partir do portal. Selecione o controle de filtro que mostra quando você passa o mouse sobre qualquer um dos gráficos. O gráfico a seguir plota um KPI de contagem de solicitações personalizado com filtros nos atributos URL e Duration. Valide seus filtros com a seção de visualização de fluxo que mostra um feed ao vivo de telemetria que corresponde aos critérios especificados a qualquer momento.

Você pode monitorar um valor diferente de Contagem. As opções dependem do tipo de fluxo, que pode ser qualquer telemetria do Application Insights, como solicitações, dependências, exceções, rastreamentos, eventos ou métricas. Também pode ser a sua própria medida personalizada.

Junto com a telemetria do Application Insights, você também pode monitorar qualquer contador de desempenho do Windows. Selecione-o nas opções de fluxo e forneça o nome do contador de desempenho.

As métricas ao vivo são agregadas em dois pontos: localmente em cada servidor e, em seguida, em todos os servidores. Você pode alterar o padrão em qualquer uma delas selecionando outras opções nas respetivas listas suspensas.

Telemetria de exemplo: eventos de diagnóstico ao vivo personalizados

Por padrão, o feed ao vivo de eventos mostra amostras de solicitações com falha e chamadas de dependência, exceções, eventos e rastreamentos. Selecione o ícone de filtro para ver os critérios aplicados a qualquer momento.

Assim como acontece com as métricas, você pode especificar qualquer critério arbitrário para qualquer um dos tipos de telemetria do Application Insights. Neste exemplo, estamos selecionando falhas e eventos de solicitação específicos.

Nota

Atualmente, para critérios baseados em mensagens de exceção, use a mensagem de exceção mais externa. No exemplo anterior, para filtrar a exceção benigna com uma mensagem de exceção interna (segue o delimitador "--") "O cliente desconectado", use uma mensagem que não contém o critério "<Erro ao ler o conteúdo da solicitação".

Para ver os detalhes de um item no feed ao vivo, selecione-o. Você pode pausar o feed selecionando Pausar ou rolando para baixo e selecionando um item. O feed ao vivo é retomado depois que você rola de volta para o topo ou quando você seleciona o contador de itens coletados enquanto ele foi pausado.

Filtrar por instância do servidor

Se quiser monitorar uma instância de função de servidor específica, você pode filtrar por servidor. Para filtrar, selecione o nome do servidor em Servidores.

Proteja o canal de controle

Os filtros personalizados do Live Metrics permitem controlar qual telemetria do seu aplicativo é transmitida para o modo de exibição Live Metrics no portal do Azure. Os critérios de filtros são enviados para os aplicativos que são instrumentados com o SDK do Application Insights. O valor do filtro pode potencialmente conter informações confidenciais, como o ID do cliente. Para manter esse valor protegido e evitar possíveis divulgações para aplicativos não autorizados, você tem duas opções:

Recomendado: Proteja o canal Live Metrics usando a autenticação do Microsoft Entra.
Legado (não é mais recomendado): configure um canal autenticado configurando uma chave de API secreta, conforme explicado na seção "Opção herdada".

Nota

Em 30 de setembro de 2025, as chaves de API usadas para transmitir a telemetria do Live Metrics para o Application Insights serão desativadas. Após essa data, os aplicativos que usam chaves de API não poderão enviar dados do Live Metrics para seu recurso do Application Insights. A ingestão de telemetria autenticada para streaming de métricas ao vivo para o Application Insights precisará ser feita com a autenticação do Microsoft Entra para o Application Insights.

É possível experimentar filtros personalizados sem ter de configurar um canal autenticado. Selecione qualquer um dos ícones de filtro e autorize os servidores conectados. Se escolher esta opção, terá de autorizar os servidores ligados uma vez a cada nova sessão ou sempre que um novo servidor ficar online.

Aviso

Desencorajamos fortemente o uso de canais não seguros e desativaremos esta opção seis meses depois de começar a usá-la. A caixa de diálogo Autorizar servidores conectados exibe a data após a qual essa opção será desativada.

Opção herdada: Criar uma chave de API

Selecione a guia Acesso à API e, em seguida, selecione Criar chave de API.
Marque a caixa de seleção Autenticar canal de controle SDK e, em seguida, selecione Gerar chave.

Adicionar uma chave de API à configuração

Você pode adicionar uma chave de API à configuração para aplicativos ASP.NET, ASP.NET Core, WorkerService e Azure Functions.

No arquivo Program.cs, adicione o seguinte namespace:

using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse;

Em seguida, adicione o seguinte registro de serviço:

// Existing code which includes services.AddApplicationInsightsTelemetry() to enable Application Insights.
builder.Services.ConfigureTelemetryModule<QuickPulseTelemetryModule> ((module, o) => module.AuthenticationApiKey = "YOUR-API-KEY-HERE");

No arquivo Startup.cs, adicione o seguinte namespace:

using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse;

Em seguida, modifique o ConfigureServices método:

public void ConfigureServices(IServiceCollection services)
{
    // Existing code which includes services.AddApplicationInsightsTelemetry() to enable Application Insights.
    services.ConfigureTelemetryModule<QuickPulseTelemetryModule> ((module, o) => module.AuthenticationApiKey = "YOUR-API-KEY-HERE");
}

Nota

Esta versão .NET não é mais suportada.

No arquivo applicationinsights.config, adicione AuthenticationApiKey aQuickPulseTelemetryModule:

<Add Type="Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse.QuickPulseTelemetryModule, Microsoft.AI.PerfCounterCollector">
      <AuthenticationApiKey>YOUR-API-KEY-HERE</AuthenticationApiKey>
</Add>

Para obter mais informações sobre como configurar aplicativos ASP.NET Core, consulte Configurando módulos de telemetria no ASP.NET Core.

Serviço de Trabalhadores

Para aplicativos WorkerService , siga estas instruções.

Adicione o seguinte namespace:

using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse;

Em seguida, adicione a seguinte linha antes da chamada services.AddApplicationInsightsTelemetryWorkerService:

    services.ConfigureTelemetryModule<QuickPulseTelemetryModule> ((module, o) => module.AuthenticationApiKey = "YOUR-API-KEY-HERE");

Para obter mais informações sobre como configurar aplicativos WorkerService, consulte Configurando módulos de telemetria no WorkerServices.

Aplicações de Funções do Azure

Para aplicativos do Azure Functions (v2), você pode proteger o canal com uma chave de API usando uma variável de ambiente.

Crie uma chave de API a partir do seu recurso do Application Insights e vá para Configuração de Configurações> para seu aplicativo Azure Functions. Selecione Nova configuração do aplicativo, insira um nome de e insira um valor que corresponda à sua chave de APPINSIGHTS_QUICKPULSEAUTHAPIKEYAPI.

Tabela de recursos suportados

Idioma	Métricas básicas	Métricas de desempenho	Filtragem personalizada	Telemetria de amostra	CPU dividida por processo
.NET Framework	Suportado (LTS)	Suportado (LTS)	Suportado (LTS)	Suportado (LTS)	Suportado (LTS)
.NET Core (destino=.NET Framework)	Suportado (LTS)	Suportado (LTS)	Suportado (LTS)	Suportado (LTS)	Suportado (LTS)
.NET Core (destino=.NET Core)	Suportado (LTS)	Suportado*	Suportado (LTS)	Suportado (LTS)	Não suportado
Azure Functions v2	Suportado	Suportado	Suportado	Suportado	Não suportado
Java	Suportado (v2.0.0+)	Suportado (v2.0.0+)	Não suportado	Suportado (v3.2.0+)	Não suportado
Node.js	Suportado (v1.3.0+)	Suportado (v1.3.0+)	Não suportado	Suportado (v1.3.0+)	Não suportado
Python	Não suportado	Não suportado	Não suportado	Não suportado	Não suportado

As métricas básicas incluem solicitação, dependência e taxa de exceção. As métricas de desempenho (contadores de desempenho) incluem memória e CPU. A telemetria de exemplo mostra um fluxo de informações detalhadas para solicitações e dependências com falha, exceções, eventos e rastreamentos.

O suporte a PerfCounters varia ligeiramente entre as versões do .NET Core que não visam o .NET Framework:

As métricas PerfCounters são suportadas quando executadas no Serviço de Aplicativo do Azure para Windows (ASP.NET Core SDK versão 2.4.1 ou superior).
Os PerfCounters são suportados quando o aplicativo está sendo executado em qualquer máquina Windows para aplicativos destinados ao .NET Core LTS ou superior.
Os PerfCounters são suportados quando o aplicativo está sendo executado em qualquer lugar (como Linux, Windows, serviço de aplicativo para Linux ou contêineres) nas versões mais recentes, mas apenas para aplicativos destinados ao .NET Core LTS ou superior.

Resolução de Problemas

O Live Metrics usa endereços IP diferentes de outras telemetrias do Application Insights. Verifique se esses endereços IP estão abertos no firewall. Verifique também se as portas de saída para o Live Metrics estão abertas no firewall dos seus servidores.

Conforme descrito no anúncio de migração do Azure TLS 1.2, o Live Metrics agora oferece suporte apenas ao TLS 1.2. Se você estiver usando uma versão mais antiga do TLS, o Live Metrics não exibirá dados. Para aplicativos baseados no .NET Framework 4.5.1, consulte Habilitar Transport Layer Security (TLS) 1.2 em clientes - Configuration Manager para oferecer suporte à versão mais recente do TLS.

Configuração ausente para .NET

Verifique se você está usando a versão mais recente do pacote NuGet Microsoft.ApplicationInsights.PerfCounterCollector.

Edite o ApplicationInsights.config arquivo:

Verifique se a cadeia de conexão aponta para o recurso do Application Insights que você está usando.
Localize a opção de QuickPulseTelemetryModule configuração. Se não estiver lá, adicione-o.
Localize a opção de QuickPulseTelemetryProcessor configuração. Se não estiver lá, adicione-o.

<TelemetryModules>
<Add Type="Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.
QuickPulse.QuickPulseTelemetryModule, Microsoft.AI.PerfCounterCollector"/>
</TelemetryModules>

<TelemetryProcessors>
<Add Type="Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.
QuickPulse.QuickPulseTelemetryProcessor, Microsoft.AI.PerfCounterCollector"/>
</TelemetryProcessors>

Reinicie o aplicativo.

Mensagem de estado "Os dados estão temporariamente inacessíveis"

Ao navegar para o Live Metrics, você pode ver um banner com a mensagem de status: "Os dados estão temporariamente inacessíveis. As atualizações sobre o nosso estado estão publicadas aqui https://aka.ms/aistatus "

Siga o link para a página de status do Azure e verifique se há uma interrupção de ativação que afete o Application Insights. Verifique se os firewalls e as extensões do navegador não estão bloqueando o acesso ao Live Metrics se uma interrupção não estiver ocorrendo. Por exemplo, algumas extensões populares de bloqueadores de anúncios bloqueiam conexões com o *.monitor.azure.com. Para usar todos os recursos do Live Metrics, desative a extensão do bloqueador de anúncios ou adicione uma regra de exclusão para o domínio *.livediagnostics.monitor.azure.com ao seu bloqueador de anúncios, firewall, etc.

Grande número inesperado de solicitações para livediagnostics.monitor.azure.com

Os SDKs do Application Insights usam uma API REST para se comunicar com pontos de extremidade QuickPulse, que fornecem métricas em tempo real para seu aplicativo Web. Por padrão, os SDKs pesquisam os pontos de extremidade uma vez a cada cinco segundos para verificar se você está exibindo o painel Métricas ao Vivo no portal do Azure.

Se você abrir o painel Métricas em tempo real, os SDKs alternarão para um modo de frequência mais alta e enviarão novas métricas para o QuickPulse a cada segundo. Isso permite que você monitore e diagnostique seu aplicativo ao vivo com latência de 1 segundo, mas também gera mais tráfego de rede. Para restaurar o fluxo normal de tráfego, navegue para longe do painel Métricas em tempo real.

Nota

As chamadas de API REST feitas pelos SDKs para pontos de extremidade QuickPulse não são rastreadas pelo Application Insights e não afetam suas chamadas de dependência ou outras métricas. No entanto, você pode vê-los em outras ferramentas de monitoramento de rede.

Métricas em tempo real: monitore e diagnostique com latência de 1 segundo

Começar

Habilite métricas em tempo real usando código para qualquer aplicativo .NET

Qual é a diferença entre o Live Metrics e o explorador de métricas e o Log Analytics?

Selecione e filtre suas métricas

Telemetria de exemplo: eventos de diagnóstico ao vivo personalizados

Filtrar por instância do servidor

Proteja o canal de controle

Opção herdada: Criar uma chave de API

Adicionar uma chave de API à configuração

Serviço de Trabalhadores

Aplicações de Funções do Azure

Tabela de recursos suportados

Resolução de Problemas

Configuração ausente para .NET

Mensagem de estado "Os dados estão temporariamente inacessíveis"

Grande número inesperado de solicitações para livediagnostics.monitor.azure.com

Próximos passos

Recursos adicionais