Métricas baseadas em log do Application Insights
As métricas baseadas em log do Application Insights permitem analisar a integridade dos aplicativos monitorados, criar painéis avançados e configurar alertas. Há dois tipos de métricas:
- As métricas baseadas em log nos bastidores são convertidas em consultas Kusto de eventos armazenados.
- As métricas padrão são armazenadas como uma série temporal agregada previamente.
Como as métricas padrão são previamente agregadas durante a coleta, elas têm melhor desempenho no momento da consulta. Isso as torna uma opção 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óstico ad hoc. Use o seletor de namespace para alternar entre as métricas padrão e baseadas em log no explorador de métricas.
Interpretar e usar consultas deste artigo
Este artigo lista as métricas com dimensões e agregações com suporte. Os detalhes sobre as métricas baseadas em log incluem as instruções de consulta Kusto subjacentes. Para sua conveniência, cada consulta usa padrões para granularidade de tempo, tipo de gráfico e, às vezes, dividindo a dimensão, o que simplifica o uso da consulta no Log Analytics sem 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 é convertido em uma cláusula adicional where timestamp... para escolher apenas os eventos do intervalo de tempo selecionado. Por exemplo, um gráfico mostrando dados para as 24 horas mais recentes, a consulta inclui | where timestamp > atrás(24 h).
A granularidade de tempo selecionada é colocada na cláusula summarize ... by bin(timestamp, [time grain]) .
Todas as dimensões Filtro selecionadas são convertidas em cláusulas where adicionais.
A dimensão Dividir gráfico selecionada é convertida em uma propriedade adicional de resumo. Por exemplo, se você dividir o gráfico por local e plotar usando uma granularidade de tempo de 5 minutos, a cláusula summarize será resumida ... by bin(timestamp, 5 m), location.
Observação
Se você for novo na linguagem de consulta Kusto, comece copiando e colando instruções Kusto no painel de consulta do Log Analytics sem fazer nenhuma modificação. Clique em Executar para ver o gráfico básico. Ao começar a entender a sintaxe da linguagem de consulta, você pode começar a fazer pequenas modificações e ver o impacto da alteração. Explorar seus próprios dados é uma ótima maneira de começar a concretizar 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 aplicativo Web conforme observado em pontos em todo o mundo. Configure os testes de disponibilidade para começar a usar qualquer métrica dessa categoria.
Disponibilidade (availabilityResults/availabilityPercentage)
A métrica Disponibilidade mostra a porcentagem de execuções de teste na Web que não detectaram nenhum problema. O menor valor possível é 0, o que indica que todas as execuções de teste na Web falharam. O valor de 100 significa que todas as execuções de testes na Web passaram pelos critérios de validação.
| Unidade de medida | Agregações com suporte | Dimensões com suporte |
|---|---|---|
| Percentual | 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 (availabilityResults/duration)
A métrica Duração do teste de disponibilidade mostra quanto tempo levou para o teste na Web ser executado. Para os testes na Web de várias etapas, a métrica reflete o tempo de execução total de todas as etapas.
| Unidade de medida | Agregações com suporte | Dimensões com suporte |
|---|---|---|
| Milissegundos | Média, Mínimo, 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 na Web executados pelo Azure Monitor.
| Unidade de medida | Agregações com suporte | Dimensões com suporte |
|---|---|---|
| Contagem | Contagem | 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 do JavaScript do Application Insights de navegadores de usuários finais reais. Elas fornecem ótimos insights sobre a experiência dos usuários com o aplicativo Web. As métricas do navegador normalmente não são amostradas, o que significa que 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.
Observação
Para coletar métricas do navegador, o aplicativo deve ser instrumentado com o SDK do JavaScript do Application Insights.
Tempo de carregamento da página do navegador (browserTimings/totalDuration)
Tempo de solicitação do usuário até que o DOM, as imagens, os scripts e as folhas de estilo sejam carregados.
| Unidade de medida | Agregações com suporte | Dimensões previamente agregadas |
|---|---|---|
| Milissegundos | Média, Mínimo, Máximo | Nenhum |
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 com suporte | Dimensões previamente agregadas |
|---|---|---|
| Milissegundos | Média, Mínimo, Máximo | Nenhum |
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 da rede de carregamento da página (browserTimings/networkDuration)
Tempo entre a solicitação do usuário e a conexão de rede. Inclui a pesquisa DNS e a conexão de transporte.
| Unidade de medida | Agregações com suporte | Dimensões previamente agregadas |
|---|---|---|
| Milissegundos | Média, Mínimo, Máximo | Nenhum |
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 byte, ou até a desconexão.
| Unidade de medida | Agregações com suporte | Dimensões previamente agregadas |
|---|---|---|
| Milissegundos | Média, Mínimo, Máximo | Nenhum |
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
Hora da solicitação de envio (browserTimings/sendDuration)
Tempo entre a conexão de rede e o recebimento do primeiro byte.
| Unidade de medida | Agregações com suporte | Dimensões previamente agregadas |
|---|---|---|
| Milissegundos | Média, Mínimo, Máximo | Nenhum |
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 de falha
As métricas em Falhas mostram problemas com solicitações de processamento, chamadas de dependência e exceções geradas.
Exceções do navegador (exceções/navegador)
Essa métrica reflete o número de exceções geradas do código do aplicativo em execução no navegador. Somente as exceções rastreadas com uma chamada à API do Application Insights trackException() são incluídas na métrica.
| Unidade de medida | Agregações com suporte | Dimensões previamente agregadas | Observações |
|---|---|---|---|
| Contagem | Contagem | Nenhum | A versão baseada em log usa a agregação Sum |
exceptions
| where notempty(client_Browser)
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Falhas de chamada de dependência (dependencies/failed)
O número de chamadas de dependência com falha.
| Unidade de medida | Agregações com suporte | Dimensões previamente agregadas | Observações |
|---|---|---|---|
| Contagem | Contagem | Nenhum | A versão baseada em log usa a agregação Sum |
dependencies
| where success == 'False'
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Exceções (exceções/contagem)
Cada vez que você registra uma exceção no Application Insights, há uma chamada ao método trackException() do SDK. A métrica Exceções mostra o número de exceções registradas.
| Unidade de medida | Agregações com suporte | Dimensões previamente agregadas | Observações |
|---|---|---|---|
| Contagem | Contagem | Nome da função da nuvem, Instância da função da nuvem, Tipo de dispositivo | A versão baseada em log usa a agregação Sum |
exceptions
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Solicitações com falha (solicitações/falha)
A contagem de solicitações de servidor rastreadas que foram marcadas como com falha. Por padrão, o SDK do Application Insights marca automaticamente cada solicitação do servidor que retornou o código de resposta HTTP 5xx ou 4xx como uma solicitação com falha. É possível 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 com suporte | Dimensões previamente agregadas | Observações |
|---|---|---|---|
| Contagem | Contagem | Instância da função da nuvem, Nome da função da nuvem, Tráfego real ou sintético, Desempenho de solicitação, Código de resposta | A versão baseada em log usa a agregação Sum |
requests
| where success == 'False'
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Exceções de servidor (exceções/servidor)
Essa métrica mostra o número de exceções de servidor.
| Unidade de medida | Agregações com suporte | Dimensões previamente agregadas | Observações |
|---|---|---|---|
| Contagem | Contagem | Nome da função da nuvem, Instância da função da nuvem | A versão baseada em log usa a agregação Sum |
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 os 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 do aplicativo (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 do processo (performanceCounters/processCpuPercentage)
A métrica mostra quanto da capacidade total do processador é consumida pelo processo que está hospedando o aplicativo monitorado.
| Unidade de medida | Agregações com suporte | Dimensões com suporte |
|---|---|---|
| Percentual | Média, Mínimo, Máximo | Instância de função de nuvem |
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
Observação
O intervalo da métrica está entre 0 e 100 * n, em que n é o número de núcleos de CPU disponíveis. Por exemplo, o valor de métrica de 200% pode representar a utilização completa de dois núcleos de CPU ou metade da utilização de 4 núcleos de CPU, e assim por diante. A CPU do Processo Normalizada é 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. Portanto, o intervalo da métrica CPU do Processo Normalizada é de 0 a 100.
Taxa de E/S do processo (performanceCounters/processIOBytesPerSecond)
| Unidade de medida | Agregações com suporte | Dimensões com suporte |
|---|---|---|
| Bytes por segundo | Média, Mínimo, Máximo | Instância de função de nuvem |
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
Bytes privados do processo (performanceCounters/processPrivateBytes)
Quantidade de memória não compartilhada que o processo monitorado alocou para seus dados.
| Unidade de medida | Agregações com suporte | Dimensões com suporte |
|---|---|---|
| Bytes | Média, Mínimo, Máximo | Instância de função de nuvem |
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 com suporte | Dimensões com suporte |
|---|---|---|
| Percentual | Média, Mínimo, Máximo | Instância de função de nuvem |
Observação
A métrica de tempo do processador não está disponível para os aplicativos hospedados nos Serviços de Aplicativos do Azure. Use a métrica CPU de processo para acompanhar a utilização da CPU dos aplicativos Web hospedados nos Serviços de Aplicativos.
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)
Essa métrica refere-se à duração de 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 entrada do servidor que foram recebidas por seu aplicativo Web.
requests
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Tempo de resposta do servidor (solicitações/duração)
Essa métrica reflete o tempo necessário para que os servidores processem as 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 uso
Tempo de carregamento de exibição de página (pageViews/duração)
Essa métrica se refere à quantidade de tempo que levou para os eventos de PageView serem carregados.
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
Exibições de página (pageViews/contagem)
A contagem de eventos de PageView registrados com a API do Application Insights do TrackPageView().
pageViews
| summarize sum(itemCount) by bin(timestamp, 1h)
| render barchart
Sessões (sessões/contagem)
Essa métrica refere-se à contagem de IDs de sessão distintas.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(session_Id)
| summarize dcount(session_Id) by bin(timestamp, 1h)
| render barchart
Rastreamentos (rastreamentos/contagem)
A contagem de instruções de rastreamento registradas com a chamada de API TrackTrace() do Application Insights.
traces
| summarize sum(itemCount) by bin(timestamp, 1h)
| render barchart
Usuários (usuários/contagem)
O número de usuários distintos que acessaram o aplicativo. A precisão dessa métrica pode ser significativamente afetada pelo uso da amostragem e filtragem de 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 no 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