Use App Metrics para investigar visitantes HTTP, erros e eficiência da comunidade de um aplicativo .NET Core [Tutorial]

O App Metrics é um software de fonte aberta que pode ser conectado com os propósitos do ASP.NET Core. Ele fornece informações em tempo real sobre o desempenho da aplicação e fornece uma visão geral completa da situação de bem-estar da aplicação. Ele fornece métricas em formato JSON e se integra aos painéis do Grafana para relatórios visíveis. O App Metrics depende do .NET Normal e é executado em várias plataformas. Ele fornece várias extensões e painéis de relatórios que também podem ser executados no Windows e no sistema operacional Linux. Neste artigo, trataremos de App Metrics, analisaremos visitantes HTTP, erros e eficiência da comunidade no .NET Core.

Estabelecendo métricas de aplicativo com ASP.NET Core

Organizaremos as App Metrics dentro do software ASP.NET Core em três etapas simples, que são as seguintes:

1. Configure as métricas do aplicativo.

As métricas do aplicativo serão colocadas como pacotes NuGet. Aqui estão listados os 2 pacotes que podem ser adicionados por meio do NuGet em seu empreendimento .NET Core:

      Métricas de App.Setup-Package Deal
      Configurar-Pacakge App.Metrics.AspnetCore.Mvc

2. Adicione Métricas de Aplicativos em Program.cs.

Adicione dentro da UseMetrics metodologia  , da seguinte forma:Program.csBuildWebHost

      public static IWebHost BuildWebHost(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
          .UseMetrics()
          .UseStartup<Inicialização>()
          .Construir();

3. Adicione Métricas de Aplicativos em Startup.cs.

Por fim, podemos adicionar um filtro de recurso útil de métricas dentro da ConfigureServicesmetodologia da  Startupclasse da seguinte forma:

      public void ConfigureServices (provedores IServiceCollection)
      { 
        provedores.AddMvc(escolhas => escolhas.AddMetricsResourceFilter());
      }

4. Execute seu software.

Construir e executar a aplicação. Verificaremos se o App Metrics está funcionando bem usando URLs, conforme comprovado na tabela a seguir. Basta anexar o URL ao URL raiz do candidato:

Anexar  /metricsou /metrics-text ao URL raiz da aplicação oferece detalhes completos sobre métricas de software. /metricsretorna a resposta JSON que pode ser analisada e representada em uma exibição com alguma análise personalizada.

Middleware de monitoramento

Com o App Metrics, podemos delinear manualmente as métricas líquidas diárias que são importantes para documentar as informações de telemetria. No entanto, para o ASP.NET Core, há um middleware de monitoramento que pode ser usado e configurado no empreendimento, que inclui algumas métricas-chave integradas específicas do software de rede.

As métricas que podem ser registradas pelo middleware de monitoramento são as seguintes:

• Apdex : É usado para observar a satisfação da pessoa principalmente com base na eficiência geral da aplicação. O Apdex é um padrão de negócios aberto que mede a satisfação do usuário com base no tempo de resposta do aplicativo.

Vamos configurar o limite de tempo,  T, para cada ciclo de solicitação, e as métricas são calculadas principalmente com base nas seguintes circunstâncias:

• Instâncias de resposta: Dá o throughput geral da requisição que está sendo processada pelo aplicante e o tempo que leva por rota dentro do software.

• Pedidos energéticos:  Isso dá o registro de pedidos ativos que foram adquiridos no servidor em um período de tempo específico.

• Erros: Isso fornece os resultados agregados de erros em um compartilhamento que apresenta a taxa geral de solicitação de erro, a confiança geral de cada tipo de exceção não capturada, a variedade completa de solicitações de erro por código de status HTTP e assim por diante.

• Tamanhos POST e PUT:  Isso fornece os tamanhos de solicitação para solicitações HTTP POST e PUT.

Incluindo middleware de monitoramento

Adicionaremos o middleware de monitoramento como um pacote NuGet da seguinte maneira:

Configuração do pacote App.Metrics.AspNetCore.Monitoring

O middleware de monitoramento fornece um conjunto de middleware adicionado à telemetria de documentos para a métrica precisa. Adicionaremos o próximo middleware dentro da Configuremetodologia para medir métricas de eficiência:

app.UseMetricsApdexTrackingMiddleware();
app.UseMetricsRequestTrackingMiddleware();
app.UseMetricsErrorTrackingMiddleware();
app.UseMetricsActiveRequestMiddleware();
app.UseMetricsPostAndPutSizeTrackingMiddleware();
app.UseMetricsOAuth2TrackingMiddleware();

Como alternativa, também podemos usar o middleware meta-pack, que fornece todo o middleware de monitoramento disponível para que possamos agora obter detalhes sobre todas as métricas diferentes que estão no código anterior:

app.UseMetricsAllMiddleware();

Posteriormente, adicionaremos o middleware de monitoramento em nossa ConfigureServicesmetodologia da seguinte forma:

provedores.AddMetricsTrackingMiddleware();

Na Program.csclasse principal, modificaremos a BuildWebHostmetodologia e adicionaremos a  UseMetricsWebTrackingmetodologia da seguinte forma:

public static IWebHost BuildWebHost(string[] args) =>
  WebHost.CreateDefaultBuilder(args)
    .UseMetrics()
    .UseMetricsWebTracking()
    .UseStartup<Inicialização>()
    .Construir();

Estabelecendo configuração

Assim que o middleware é adicionado, temos que organizar o limite padrão e diferentes valores de configuração para que os relatórios sejam gerados de acordo. As propriedades de monitoramento online serão configuradas no  appsettings.jsonarquivo. Aqui está o conteúdo do  appsettings.jsonarquivo que contém a MetricWebTrackingOptionschave JSON:

"MetricsWebTrackingOptions": {
  "ApdexTrackingEnabled": verdadeiro,
  "ApdexTSsegundos": 0,1,
  "IgnoredHttpStatusCodes": [404],
  "IgnoredRoutesRegexPatterns": [],
  "OAuth2TrackingEnabled": verdadeiro
    },

ApdexTrackingEnabledestá pronto para ser verdadeiro para que o relatório de satisfação do cliente possa ser gerado e  ApdexTSecondsé o limite que decide se o tempo de resposta da solicitação foi aceitável, tolerante ou irritante. IgnoredHttpStatusCodescompreende o registro de códigos permanentes que podem ser ignorados se a resposta retornar uma 404posição. IgnoredRoutesRegexPatternssão usados ​​para desconsiderar URIs específicos que correspondem à expressão comum e OAuth2TrackingEnabledserão definidos para observar e documentar as métricas de cada consumidor e fornecer informações específicas sobre a taxa de solicitação, taxa de erro e tamanhos de POST e PUT para cada consumidor.

Execute a aplicação e faça alguma navegação. Acrescentar /metrics-texto URL do software mostrará todo o relatório em formato de texto. Aqui está o padrão instantâneo de como as métricas textuais parecem:

Incluindo estudos visíveis

Existem inúmeras extensões e plug-ins de relatórios por aí que apresentam um painel de relatórios visível. Alguns deles são GrafanaCloud Hosted Metrics , InfluxDB , Prometheus , ElasticSearch , Graphite , HTTP , Console e Arquivo de conteúdo textual . Vamos configurar a  extensão InfluxDB e ver como os relatórios visíveis serão alcançados.

Estabelecendo o InfluxDB

InfluxDB é o banco de dados de sequência de tempo de fornecimento aberto desenvolvido pela Inflow Information. Ele é escrito na  linguagem Go e é amplamente usado para armazenar o conhecimento da sequência de tempo para análises em tempo real. Grafana é o servidor que fornece painéis de relatórios que podem ser vistos por meio de um navegador. O InfluxDB pode simplesmente ser importado como uma extensão no Grafana para mostrar relatórios visíveis do banco de dados InfluxDB.

Estabelecendo o subsistema Windows Home para Linux

Nesta parte, organizaremos o InfluxDB no subsistema Windows Home para o sistema operacional Linux.

1. Inicialmente, temos que permitir o subsistema Windows Home para Linux executando o próximo comando do PowerShell como administrador:

      Allow-WindowsOptionalFeature -On-line -FeatureName
      Microsoft-Home Windows-Subsistema-Linux

Depois de trabalhar o comando anterior, reinicie o seu pc.

2. Em seguida, instalaremos a distribuição do Linux na loja da Microsoft. Em nosso caso, configuraremos o Ubuntu no Microsoft Retailer. Vá para o Microsoft Retailer, procure pelo Ubuntu e configure-o.
3. Assim que a configuração estiver concluída, clique em Iniciar :

4. Ele abrirá a janela do console, que poderá solicitar que você crie uma conta pessoal para o sistema operacional Linux (sistema de trabalho).
5. Especifique o nome de usuário e a senha que podem ser usados.
6. Execute o próximo comando para substituir o Ubuntu pelo modelo estável mais recente do bash shell. Para executar o bash, abra o comando imediato, escreva bashe pressione Enter :

7. Por fim, ele solicitaria que você criasse um nome de usuário e uma senha do Ubuntu. Especifique o nome de usuário e a senha e pressione enter.

Colocando no InfluxDB

Aqui, seguiremos algumas etapas para inserir o banco de dados InfluxDB no Ubuntu:

1. Para organizar o InfluxDB, abra um comando imediato no modo Administrador e execute o bash shell.
2. Execute as próximas instruções para o revendedor de conhecimento InfluxDB em seu PC nativo:

      $ curl -sL https://repos.influxdata.com/influxdb.key | sudo apt-key add -
      $ supply /e muitos outros/lsb-release
      $ echo "deb https://repos.influxdata.com/${DISTRIB_ID,,}
      $ {DISTRIB_CODENAME} estável" | sudo tee /e muitos outros/apt/sources.record.d/influxdb.record

3. Configure o InfluxDB executando o próximo comando:

      $ sudo apt-get replace && sudo apt-get set up influxdb

4. Execute o seguinte comando para executar o InfluxDB:

      $ sudo influenciado

5. Comece o shell do InfluxDB trabalhando no próximo comando:

      entrada de $ sudo

Ele abrirá o shell onde as instruções específicas do banco de dados serão executadas.

6. Crie um banco de dados executando o próximo comando. Especifique um título significativo para o banco de dados. No nosso caso é appmetricsdb:

      > criar banco de dados appmetricsdb

Colocando no Grafana

Grafana é um software de fonte aberta usado para mostrar painéis em uma interface de internet. Existem vários painéis por aí que podem ser importados do site da Grafana para mostrar análises em tempo real. O Grafana pode simplesmente ser baixado como um arquivo zip em  http://docs.grafana.org/set up/home windows/ . Assim que for baixado, podemos iniciar o servidor Grafana clicando no  grafana-server.exe executável da binlista.

O Grafana oferece um site na Internet que escuta na porta 3000 . Se o servidor Grafana estiver funcionando, podemos acessar o posicionamento navegando para  http://localhost:3000.

Incluindo o painel do InfluxDB

Pode haver um painel InfluxDB pronto para uso no Grafana que será importado do próximo hiperlink:  https://grafana.com/dashboards/2125 .

Copie o ID do painel e use-o para importá-lo para o site do Grafana.

Vamos importar o painel do InfluxDB acessando a opção Handle no site do Grafana, da seguinte forma:

Na opção Handle , clique no  botão + Dashboard e clique na  opção New Dashboard . Clicar em Importar painel  resultará no Grafana solicitando o ID do painel:

Cole o ID do painel (por exemplo, 2125) copiado anteriormente no campo e pressione Tab . O sistema apresentará as particularidades do dashboard, e clicando no botão Importar fará a importação para o sistema:

Configurando o InfluxDB

Vamos agora configurar o painel do InfluxDB e adicionar um suprimento de informações que se conecta ao banco de dados que acabamos de criar.

Para prosseguir, iremos até a parte Fontes de Informação no site do Grafana e clicaremos na opção  Adicionar Nova Fonte de Dados . Aqui está a configuração que fornece o fornecimento de informações para o banco de dados InfluxDB:

Modificando as estratégias Configure e ConfigureServices na inicialização

Até agora, organizamos o Ubuntu e o banco de dados InfluxDB em nossa máquina. Além disso, organizamos a fonte de conhecimento do InfluxDB e adicionamos um painel por meio do site da Grafana. Em seguida, configuraremos nosso software de rede ASP.NET Core para enviar informações em tempo real ao banco de dados InfluxDB.

Aqui está a ConfigureServicesmetodologia modificada que inicializa o MetricsBuilderdelinear o atributo associado ao título, ambiente e detalhes de conexão aplicáveis:

public void ConfigureServices (provedores IServiceCollection)
{
  var métricas = new MetricsBuilder()
  .Configuração.Configurar(
  escolhas =>
  {
    escolhas.WithGlobalTags((globalTags, dados) =>
    {
      globalTags.Add("app", data.EntryAssemblyName);
      globalTags.Add("env", "stage");
    });
  })
  .Report.ToInfluxDb(
  escolhas =>
  {
    escolhas.InfluxDb.BaseUri = new Uri("http://127.0.0.1:8086");
    choice.InfluxDb.Database = "appmetricsdb";
    escolhas.HttpPolicy.Timeout = TimeSpan.FromSeconds(10);
  })
  .Construir();
  provedores.AddMetrics(metrics);
  provedores.AddMetricsReportScheduler();
  provedores.AddMetricsTrackingMiddleware();         
  provedores.AddMvc(escolhas => escolhas.AddMetricsResourceFilter());
}

No código anterior, definimos o título do aplicativo appcomo o título da reunião e o ambiente envcomo o arquivo stage. http://127.0.0.1:8086é a URL do servidor InfluxDB que escuta a telemetria sendo enviada pela aplicação. appmetricsdbé o banco de dados que criamos na parte anterior. Em seguida, adicionamos o AddMetricsmiddleware e especificamos as métricas que contêm a configuração. AddMetricsTrackingMiddlewareé usado para rastrear as informações de telemetria da rede que são exibidas no painel e AddMetricsReportScheduledé usado para enviar as informações de telemetria para o banco de dados.

Aqui está a Configuremetodologia que consiste  UseMetricsAllMiddlewareem usar o App Metrics. UseMetricsAllMiddlewarefornece todo o middleware existente no App Metrics:

public void Configure (aplicativo IApplicationBuilder, IHostingEnvironment env)
{
  if (env.IsDevelopment())
  {
    app.UseBrowserLink();
    app.UseDeveloperExceptionPage();
  }
  outro
  {
    app.UseExceptionHandler("/Error");
  }
  app.UseStaticFiles();
  app.UseMetricsAllMiddleware();
  app.UseMvc();
}

Um pouco do que chamar  UseAllMetricsMiddleware, também podemos adicionar middleware de pessoa específica explicitamente com base nas necessidades. Aqui está o registro do middleware que pode ser adicionado:

app.UseMetricsApdexTrackingMiddleware();
app.UseMetricsRequestTrackingMiddleware();
app.UseMetricsErrorTrackingMiddleware();
app.UseMetricsActiveRequestMiddleware();
app.UseMetricsPostAndPutSizeTrackingMiddleware();
app.UseMetricsOAuth2TrackingMiddleware();

Testando o aplicativo ASP.NET Core e relatórios no painel do Grafana

Para verificar o software ASP.NET Core e ver os relatórios visíveis no painel do Grafana, seguiremos as seguintes etapas:

1. Inicie o servidor Grafana acessando  {installation_directory}bingrafana-server.exe.
2. Comece o bash a partir do comando imediato e execute o sudo inflowcomando.
3. Comece outro bash a partir do comando imediato e execute o sudo inflowcomando.
4. Execute o software ASP.NET Core.
5. Entry http://localhost:3000e clique no painel App Metrics.
6. Ele começará a coletar informações de telemetria e mostrará as métricas de eficiência, conforme comprovado nas seguintes capturas de tela:

O próximo gráfico revela o throughput total em  Request Per Minute ( RPM ), compartilhamento de erros e solicitações ativas:

Aqui está a classificação Apdex colorindo a satisfação do usuário em três cores diferentes, onde rosa é irritante, laranja é tolerante e inexperiente é aceitável. O próximo gráfico revela a linha azul sendo desenhada na barra verde, o que significa que a eficiência de aplicação é aceitável:

O próximo instantâneo mostra o gráfico de taxa de transferência de todas as solicitações feitas, e cada solicitação foi colorida com cores diferentes: rosa, laranja e verde. Neste caso, há duas requisições HTTP GET para as páginas sobre e fale conosco:

Aqui está o gráfico de tempo de resposta exibindo o tempo de resposta de cada solicitação:

Se você gostou deste texto e quer aprender mais sobre essas técnicas, vá e leia o e-book completo,  C# 7 e .NET Core 2.0 Alta eficiência , de autoria de Ovais Mehboob Ahmed Khan.

Aprenda a seguir:

Conheça ASP.NET Core Net API [Tutorial]

A melhor maneira de nomear uma execução do Azure a partir de um software ASP.NET Core MVC

Eficiência excessiva do ASP.NET Core