Métricas baseadas em registos do Application Insights
As métricas baseadas em log do Application Insights permitem analisar a integridade de seus aplicativos monitorados, criar painéis poderosos e configurar alertas. Existem dois tipos de métricas:
- As métricas baseadas em log nos bastidores são traduzidas em consultas Kusto de eventos armazenados.
- As métricas padrão são armazenadas como séries temporais pré-agregadas.
Como as métricas padrão são pré-agregadas durante a coleta, elas têm melhor desempenho no momento da consulta. Isso os torna uma escolha melhor para painéis e alertas em tempo real. As métricas baseadas em log têm mais dimensões, o que as torna a opção superior para análise de dados e diagnósticos ad hoc. Use o seletor de namespace para alternar entre métricas padrão e baseadas em log no explorador de métricas.
Interpretar e usar consultas deste artigo
Este artigo lista métricas com agregações e dimensões suportadas. Os detalhes sobre métricas baseadas em log incluem as instruções de consulta Kusto subjacentes. Por conveniência, cada consulta usa padrões para granularidade de tempo, tipo de gráfico e, às vezes, dimensão de divisão, o que simplifica o uso da consulta no Log Analytics sem qualquer necessidade de modificação.
Quando você plota a mesma métrica no explorador de métricas, não há padrões - a consulta é ajustada dinamicamente com base nas configurações do gráfico:
O intervalo de tempo selecionado é traduzido em uma cláusula adicional onde carimbo de data/hora... para selecionar apenas os eventos do intervalo de tempo selecionado. Por exemplo, um gráfico mostrando dados para as últimas 24 horas, a consulta inclui | onde timestamp > ago(24 h).
A granularidade de tempo selecionada é colocada no resumo final ... por cláusula bin(timestamp, [time grain]).
Todas as dimensões de Filtro selecionadas são convertidas em cláusulas where adicionais.
A dimensão do gráfico dividido selecionada é convertida em uma propriedade de resumo extra. Por exemplo, se você dividir o gráfico por local e plotar usando uma granularidade de tempo de 5 minutos, a cláusula de resumo será resumida ... por bin(timestamp, 5 m), localização.
Nota
Se você é novo na linguagem de consulta Kusto, comece copiando e colando instruções Kusto no painel de consulta do Log Analytics sem fazer modificações. Clique em Executar para ver o gráfico básico. À medida que você começa a entender a sintaxe da linguagem de consulta, você pode começar a fazer pequenas modificações e ver o impacto da sua alteração. Explorar seus próprios dados é uma ótima maneira de começar a perceber todo o poder do Log Analytics e do Azure Monitor.
Métricas de disponibilidade
As métricas na categoria Disponibilidade permitem que você veja a integridade do seu aplicativo Web conforme observado em pontos ao redor do mundo. Configure os testes de disponibilidade para começar a usar quaisquer métricas dessa categoria.
Disponibilidade (disponibilidadeResultados/percentagemidadede disponibilidade)
A métrica Disponibilidade mostra a porcentagem de execuções de teste da Web que não detetaram nenhum problema. O menor valor possível é 0, o que indica que todas as execuções de teste da Web falharam. O valor de 100 significa que todas as execuções de teste da Web passaram pelos critérios de validação.
| Unidade de medida | Agregações suportadas | Dimensões suportadas |
|---|---|---|
| Percentagem | Média | Local de execução, Nome do teste |
availabilityResults
| summarize sum(todouble(success == 1) * 100) / count() by bin(timestamp, 5m), location
| render timechart
Duração do teste de disponibilidade (disponibilidadeResultados/duração)
A métrica Duração do teste de disponibilidade mostra quanto tempo levou para a execução do teste da Web. Para os testes da Web de várias etapas, a métrica reflete o tempo total de execução de todas as etapas.
| Unidade de medida | Agregações suportadas | Dimensões suportadas |
|---|---|---|
| Milissegundos | Média, Mín, Máximo | Local de execução, Nome do teste, Resultado do teste |
availabilityResults
| where notempty(duration)
| extend availabilityResult_duration = iif(itemType == 'availabilityResult', duration, todouble(''))
| summarize sum(availabilityResult_duration)/sum(itemCount) by bin(timestamp, 5m), location
| render timechart
Testes de disponibilidade (availabilityResults/count)
A métrica Testes de disponibilidade reflete a contagem dos testes da Web executados pelo Azure Monitor.
| Unidade de medida | Agregações suportadas | Dimensões suportadas |
|---|---|---|
| de palavras | de palavras | Local de execução, Nome do teste, Resultado do teste |
availabilityResults
| summarize sum(itemCount) by bin(timestamp, 5m)
| render timechart
Métricas do navegador
As métricas do navegador são coletadas pelo SDK JavaScript do Application Insights a partir de navegadores reais do usuário final. Eles fornecem ótimas informações sobre a experiência dos usuários com seu aplicativo Web. As métricas do navegador normalmente não são amostradas, o que significa que elas fornecem maior precisão dos números de uso em comparação com as métricas do lado do servidor, que podem ser distorcidas pela amostragem.
Nota
Para coletar métricas do navegador, seu aplicativo deve ser instrumentado com o SDK JavaScript do Application Insights.
Tempo de carregamento da página do navegador (browserTimings/totalDuration)
Tempo desde a solicitação do usuário até o DOM, folhas de estilo, scripts e imagens são carregados.
| Unidade de medida | Agregações suportadas | Dimensões pré-agregadas |
|---|---|---|
| Milissegundos | Média, Mín, Máximo | None |
browserTimings
| where notempty(totalDuration)
| extend _sum = totalDuration
| extend _count = itemCount
| extend _sum = _sum * _count
| summarize sum(_sum) / sum(_count) by bin(timestamp, 5m)
| render timechart
Tempo de processamento do cliente (browserTiming/processingDuration)
Tempo entre o recebimento do último byte de um documento até que o DOM seja carregado. As solicitações assíncronas ainda podem estar sendo processadas.
| Unidade de medida | Agregações suportadas | Dimensões pré-agregadas |
|---|---|---|
| Milissegundos | Média, Mín, Máximo | None |
browserTimings
| where notempty(processingDuration)
| extend _sum = processingDuration
| extend _count = itemCount
| extend _sum = _sum * _count
| summarize sum(_sum)/sum(_count) by bin(timestamp, 5m)
| render timechart
Tempo de conexão de rede de carregamento de página (browserTimings/networkDuration)
Tempo entre a solicitação do usuário e a conexão de rede. Inclui pesquisa de DNS e conexão de transporte.
| Unidade de medida | Agregações suportadas | Dimensões pré-agregadas |
|---|---|---|
| Milissegundos | Média, Mín, Máximo | None |
browserTimings
| where notempty(networkDuration)
| extend _sum = networkDuration
| extend _count = itemCount
| extend _sum = _sum * _count
| summarize sum(_sum) / sum(_count) by bin(timestamp, 5m)
| render timechart
Tempo de resposta de recebimento (browserTimings/receiveDuration)
Tempo entre o primeiro e o último bytes, ou até a desconexão.
| Unidade de medida | Agregações suportadas | Dimensões pré-agregadas |
|---|---|---|
| Milissegundos | Média, Mín, Máximo | None |
browserTimings
| where notempty(receiveDuration)
| extend _sum = receiveDuration
| extend _count = itemCount
| extend _sum = _sum * _count
| summarize sum(_sum) / sum(_count) by bin(timestamp, 5m)
| render timechart
Tempo de solicitação de envio (browserTimings/sendDuration)
Tempo entre a conexão de rede e o recebimento do primeiro byte.
| Unidade de medida | Agregações suportadas | Dimensões pré-agregadas |
|---|---|---|
| Milissegundos | Média, Mín, Máximo | None |
browserTimings
| where notempty(sendDuration)
| extend _sum = sendDuration
| extend _count = itemCount
| extend _sum = _sum * _count
| summarize sum(_sum) / sum(_count) by bin(timestamp, 5m)
| render timechart
Métricas das falhas
As métricas em Falhas mostram problemas com o processamento de solicitações, chamadas de dependência e exceções lançadas.
Exceções do navegador (exceções/navegador)
Essa métrica reflete o número de exceções lançadas do código do aplicativo em execução no navegador. Apenas as exceções que são rastreadas com uma trackException() chamada de API do Application Insights são incluídas na métrica.
| Unidade de medida | Agregações suportadas | Dimensões pré-agregadas | Notas |
|---|---|---|---|
| de palavras | de palavras | None | A versão baseada em log usa a agregação de soma |
exceptions
| where notempty(client_Browser)
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Falhas de chamada de dependência (dependências/falha)
O número de chamadas de dependência com falha.
| Unidade de medida | Agregações suportadas | Dimensões pré-agregadas | Notas |
|---|---|---|---|
| de palavras | de palavras | None | A versão baseada em log usa a agregação de soma |
dependencies
| where success == 'False'
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Exceções (exceções/contagem)
Sempre que você registra uma exceção no Application Insights, há uma chamada para o método trackException() do SDK. A métrica Exceptions mostra o número de exceções registradas.
| Unidade de medida | Agregações suportadas | Dimensões pré-agregadas | Notas |
|---|---|---|---|
| de palavras | de palavras | Nome da função de nuvem, instância de função de nuvem, Tipo de dispositivo | A versão baseada em log usa a agregação de soma |
exceptions
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Pedidos falhados (pedidos/falhas)
A contagem de solicitações de servidor rastreadas que foram marcadas como falha. Por padrão, o SDK do Application Insights marca automaticamente cada solicitação de servidor que retornou o código de resposta HTTP 5xx ou 4xx como uma solicitação com falha. Você pode personalizar essa lógica modificando a propriedade success do item de telemetria de solicitação em um inicializador de telemetria personalizado.
| Unidade de medida | Agregações suportadas | Dimensões pré-agregadas | Notas |
|---|---|---|---|
| de palavras | de palavras | Instância de função na nuvem, Nome da função na nuvem, Tráfego real ou sintético, Desempenho da solicitação, Código de resposta | A versão baseada em log usa a agregação de soma |
requests
| where success == 'False'
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Exceções do servidor (exceções/servidor)
Essa métrica mostra o número de exceções do servidor.
| Unidade de medida | Agregações suportadas | Dimensões pré-agregadas | Notas |
|---|---|---|---|
| de palavras | de palavras | Nome da função de nuvem, instância de função de nuvem | A versão baseada em log usa a agregação de soma |
exceptions
| where isempty(client_Browser)
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Contadores de desempenho
Use métricas na categoria Contadores de desempenho para acessar contadores de desempenho do sistema coletados pelo Application Insights.
Memória disponível (performanceCounters/availableMemory)
performanceCounters
| where ((category == "Memory" and counter == "Available Bytes") or name == "availableMemory")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Taxa de exceção (performanceCounters/exceptionRate)
performanceCounters
| where ((category == ".NET CLR Exceptions" and counter == "# of Exceps Thrown / sec") or name == "exceptionRate")
| extend performanceCounter_value = iif(itemType == 'performanceCounter',value,todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Tempo de execução da solicitação HTTP (performanceCounters/requestExecutionTime)
performanceCounters
| where ((category == "ASP.NET Applications" and counter == "Request Execution Time") or name == "requestExecutionTime")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Taxa de solicitação HTTP (performanceCounters/requestsPerSecond)
performanceCounters
| where ((category == "ASP.NET Applications" and counter == "Requests/Sec") or name == "requestsPerSecond")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Solicitações HTTP na fila de aplicativos (performanceCounters/requestsInQueue)
performanceCounters
| where ((category == "ASP.NET Applications" and counter == "Requests In Application Queue") or name == "requestsInQueue")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
CPU de processo (performanceCounters/processCpuPercentage)
A métrica mostra quanto da capacidade total do processador é consumida pelo processo que está hospedando seu aplicativo monitorado.
| Unidade de medida | Agregações suportadas | Dimensões suportadas |
|---|---|---|
| Percentagem | Média, Mín, Máximo | Instância de função de cloud |
performanceCounters
| where ((category == "Process" and counter == "% Processor Time Normalized") or name == "processCpuPercentage")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Nota
O intervalo da métrica está entre 0 e 100 * n, onde n é o número de núcleos de CPU disponíveis. Por exemplo, o valor métrico de 200% pode representar a utilização total de dois núcleos de CPU ou metade da utilização de 4 núcleos de CPU e assim por diante. O Process CPU Normalized é uma métrica alternativa coletada por muitos SDKs que representa o mesmo valor, mas o divide pelo número de núcleos de CPU disponíveis. Assim, o intervalo da métrica Process CPU Normalized é de 0 a 100.
Taxa de E/S do processo (performanceCounters/processIOBytesPerSecond)
| Unidade de medida | Agregações suportadas | Dimensões suportadas |
|---|---|---|
| Bytes por segundo | Média, Mín, Máximo | Instância de função de cloud |
performanceCounters
| where ((category == "Process" and counter == "IO Data Bytes/sec") or name == "processIOBytesPerSecond")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Processar bytes privados (performanceCounters/processPrivateBytes)
Quantidade de memória não compartilhada que o processo monitorado alocado para seus dados.
| Unidade de medida | Agregações suportadas | Dimensões suportadas |
|---|---|---|
| Bytes | Média, Mín, Máximo | Instância de função de cloud |
performanceCounters
| where ((category == "Process" and counter == "Private Bytes") or name == "processPrivateBytes")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Tempo do processador (performanceCounters/processorCpuPercentage)
Consumo de CPU por todos os processos em execução na instância do servidor monitorado.
| Unidade de medida | Agregações suportadas | Dimensões suportadas |
|---|---|---|
| Percentagem | Média, Mín, Máximo | Instância de função de cloud |
Nota
A métrica de tempo do processador não está disponível para os aplicativos hospedados nos Serviços de Aplicativo do Azure. Use a métrica Process CPU para controlar a utilização da CPU dos aplicativos Web hospedados nos Serviços de Aplicativo.
performanceCounters
| where ((category == "Processor" and counter == "% Processor Time") or name == "processorCpuPercentage")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Métricas do servidor
Chamadas de dependência (dependências/contagem)
Essa métrica é em relação ao número de chamadas de dependência.
dependencies
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Duração da dependência (dependências/duração)
Esta métrica refere-se à duração das chamadas de dependência.
dependencies
| where notempty(duration)
| extend dependency_duration = iif(itemType == 'dependency',duration,todouble(''))
| extend _sum = dependency_duration
| extend _count = itemCount
| extend _sum = _sum*_count
| summarize sum(_sum)/sum(_count) by bin(timestamp, 1m)
| render timechart
Solicitações do servidor (solicitações/contagem)
Essa métrica reflete o número de solicitações de servidor de entrada que foram recebidas pelo seu aplicativo Web.
requests
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Tempo de resposta do servidor (pedidos/duração)
Essa métrica reflete o tempo que os servidores levaram para processar solicitações de entrada.
requests
| where notempty(duration)
| extend request_duration = iif(itemType == 'request', duration, todouble(''))
| extend _sum = request_duration
| extend _count = itemCount
| extend _sum = _sum*_count
| summarize sum(_sum) / sum(_count) by bin(timestamp, 1m)
| render timechart
Métricas de utilização
Tempo de carregamento da vista de página (pageViews/duração)
Essa métrica refere-se à quantidade de tempo que os eventos PageView levaram para carregar.
pageViews
| where notempty(duration)
| extend pageView_duration = iif(itemType == 'pageView', duration, todouble(''))
| extend _sum = pageView_duration
| extend _count = itemCount
| extend _sum = _sum * _count
| summarize sum(_sum) / sum(_count) by bin(timestamp, 5m)
| render barchart
Visualizações de página (pageViews/count)
A contagem de eventos PageView registrados com a API do Application Insights TrackPageView().
pageViews
| summarize sum(itemCount) by bin(timestamp, 1h)
| render barchart
Sessões (sessões/contagem)
Esta métrica refere-se à contagem de IDs de sessão distintos.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(session_Id)
| summarize dcount(session_Id) by bin(timestamp, 1h)
| render barchart
Vestígios (vestígios/contagem)
A contagem de instruções de rastreamento registradas com a chamada da API do Application Insights TrackTrace().
traces
| summarize sum(itemCount) by bin(timestamp, 1h)
| render barchart
Utilizadores (utilizadores/contagem)
O número de usuários distintos que acessaram seu aplicativo. A precisão dessa métrica pode ser significativamente afetada pelo uso de amostragem e filtragem por telemetria.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(user_Id)
| summarize dcount(user_Id) by bin(timestamp, 1h)
| render barchart
Usuários, autenticados (usuários/autenticados)
O número de usuários distintos que se autenticaram em seu aplicativo.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(user_AuthenticatedId)
| summarize dcount(user_AuthenticatedId) by bin(timestamp, 1h)
| render barchart