Guia de práticas recomendadas de monitoramento sintético

Escolha o seu monitor Sintético

Os monitores Sintético são browsers virtuais que medem o desempenho do seu site e capturam números agregados de tempo de carregamento, tempo de operação e tamanho médio de download. Você também terá acesso a estatísticas detalhadas sobre o período de inatividade incidente e cada recurso da página.

Temos sete tipos de monitor Sintético para você escolher, dependendo do que você deseja monitor e como gostaria de fazê-lo. Por exemplo, um monitor de etapas é uma ótima maneira de criar o que funciona essencialmente como um Browser com script, sem escrever código. Se você procura um gerenciamento automatizado do seu monitor Sintético, nossa API NerdGraph permite criar, atualizar e excluir seu monitor Sintético através de chamada de API.

Adicione seu monitor Sintético

1. Para adicionar um monitor, vá para one.newrelic.com > All capabilities > Synthetic Monitoring.

   Se você tiver uma conta na UE, acesse one.eu.newrelic.com.

2. Clique em Create monitor.

   

3. Selecione um tipo de monitor e preencha todos os campos obrigatórios.

4. Você pode adicionar tag, alterar o período ou selecionar uma versão de tempo de execução diferente. Para ping e monitor de Browser simples, você pode adicionar uma string de validação. Você pode usar as opções avançadas para ativar o monitoramento de substring para os seguintes tipos de validações de resposta:

   • Verify SSL (for ping and simple browser). Esta opção verifica a validade da cadeia de certificados SSL. Ele pode ser duplicado executando a seguinte sintaxe:

$
openssl s_client -servername {YOUR_HOSTNAME} -connect {YOUR_HOSTNAME}:443 -CApath /etc/ssl/certs > /dev/null

• Bypass HEAD request (for ping monitors). Esta opção ignora a solicitação HEAD padrão e, em vez disso, usa o verbo GET com uma verificação de ping. A solicitação GET sempre acontecerá se a solicitação HEAD falhar.

• Redirect is Failure (for ping). Se ocorrer um resultado de redirecionamento quando Redirect is Failure estiver ativado, seu monitor Sintético o categorizará como uma falha em vez de seguir o redirecionamento e verificar o URL resultante.

5. Selecione os locais onde você deseja que seu monitor seja executado. Recomendamos escolher pelo menos três locais para evitar falso positivo. Em outras palavras, se pelo menos um local retornar um resultado bem-sucedido, o endpoint deverá estar ativo e o acionamento de um alerta poderá ser evitado.

6. Dependendo do tipo de monitor, você será solicitado a Save monitor, Validate ou Write script.

7. Veja seus resultados conforme eles são recebidos na página de resumo.

Veja a página de resumo do seu monitor Sintético

Na página de resumo, você verá informações sobre o status do seu monitor Sintético. Se algo criou um incidente ativo que disparou um alerta, clique no link de alerta crítico para abrir uma nova janela.

Obtenha uma visão geral do desempenho do seu aplicativo

Para garantir que os serviços da Web estejam funcionando conforme o esperado e livres de erros, você desejará acesso contínuo aos resultados do desempenho do seu aplicativo. O monitoramento sintético dá esse tipo de garantia realizando testes automatizados em seu aplicativo web para cada local selecionado. Seu monitor Sintético registrará o período de inatividade e coletará os números agregados, resultados e estatísticas detalhadas para cada recurso da página.

Para identificar rapidamente os monitores que estão falhando, você pode usar o índice da página do monitor Sintético para ver quais monitores estão com incidentes abertos, taxas de sucesso em 24 horas, número de locais com falha, período do monitor e tipo de monitor . Ao clicar em um monitor, você será levado à página Summary , onde encontrará informações para avaliar onde esse monitor específico está falhando, por que está falhando, por exemplo, última mensagem de erro, códigos de resposta de erro, duração por domínio e mais. Com essas informações, você terá insights mais profundos sobre o desempenho do seu aplicativo ao longo do tempo.

Visualize seu monitor em sua lista de entidade

Ver resultados monitor individuais

Você pode visualizar o desempenho de seus aplicativos web à medida que eles são acessados de diferentes partes do globo. Sua página de resultados mostra como tudo, desde o desenvolvimento até a produção, afeta a experiência do usuário. Você pode classificar o que está listado para identificar melhor áreas problemáticas ou resultados incomuns. Tente filtrar por local para comparar o desempenho do monitor de diferentes locais. Para fazer isso:

1. Vá para one.newrelic.com > All capabilities > Synthetic Monitoring.

2. Clique em Monitor e em Results.

   Você pode ver visualizações atualizadas dos carregamentos de página mais lentos para cada local do monitor.

Entenda o impacto no tempo de carregamento de cada recurso

Você pode ver como os diferentes componentes do seu site afetam sua carga geral na página de recursos do Sintético . Esses componentes podem ser CSS, JavaScript, imagens, HTML, etc. Você pode detalhar métricas detalhadas coletadas em tempo de execução, localizar informações de desempenho para o tempo gasto por recursos de terceiros e identificar códigos de resposta HTTP para cada recurso. Para fazer isso:

1. Vá para

   one.newrelic.com

   e clique em

   Synthetic Monitoring

   .

2. No menu dropdown

   Monitors

   , selecione seu monitor.

3. Clique em

   Monitor

   e em

   Resources

   .

Configurar e desenvolver um teste de browser com script

Usando um Browser com script, você pode construir um fluxo de trabalho de monitoramento complexo com as ligações do Selenium JavaScript Webdriver. Por exemplo, você pode log no aplicativo, navegar até um link específico e aguardar o carregamento de um elemento da página e adicionar uma asserção. Para fazer isso, você:

1. Vá para

   one.newrelic.com > All capabilities > Synthetic Monitoring

   .

2. Clique no botão

   Create monitor

   .

3. Insira o nome e os detalhes do seu monitor. Por exemplo, sitename.com browser com script.

4. Selecione os locais onde você deseja que seu monitor seja executado. Por exemplo, Mumbai, Seul, Columbus ou Montreal.

5. Escolha uma frequência para a frequência com que seu monitor funcionará a partir disso. Por exemplo, cinco minutos.

6. Defina um método de notificação para alertar sua equipe quando ocorrer um incidente de desempenho.

7. Agora você está pronto para escrever seu script. Consulte este script de exemplo para testar o desempenho de newrelic.com e verificar se determinados elementos foram carregados.

/**
 * Script Name: Best Practices - Chrome 100
 * Author: New Relic
 * Version: 1.5
 * Purpose: best practices example
 * Reference: https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/scripting-monitors/synthetic-scripted-browser-reference-monitor-versions-chrome-100/
 */

// -------------------- CONSTANTS
const SCRIPT_NAME = "Best Practices - Chrome 100"                        // name to record in script log
const IMPLICIT_TIMEOUT = 3000                                            // default implicit timeout is 10 seconds, 3 seconds x 8 findElement operations = 24 seconds, assuming all operations time out
const PAGE_LOAD_TIMEOUT = 60000                                          // default page load timeout is 60 seconds, fail early to prevent long duration timeouts
const SCRIPT_TIMEOUT = 20000                                             // default script timeout is 30 seconds
const USER_AGENT = "default"                                             // set the user agent for Chrome
const PROTOCOL = "https://"                                              // set the protocol
const USERNAME = ""                                                      // username:
const PASSWORD = ""                                                      // password@
const DOMAIN = "docs.newrelic.com"                                       // your domain
const PATH = "/docs/new-relic-solutions/get-started/intro-new-relic/"    // path to main page
const CHECK = "Need some inspiration first? Check out this intro video." // text to match on page
const AUTH = USERNAME + PASSWORD
const MAIN_URL = PROTOCOL + AUTH + DOMAIN + PATH

// -------------------- DEPENDENCIES
var assert = require("assert")

// -------------------- CONFIGURATION
await $webDriver.manage().setTimeouts({
  implicit: IMPLICIT_TIMEOUT,  // sets element load timeout
  pageLoad: PAGE_LOAD_TIMEOUT, // sets page load timeout
  script: SCRIPT_TIMEOUT       // sets script timeout
})

// -------------------- VARIABLES
var By = $selenium.By
var loc = {
  video: By.css("#gatsby-focus-wrapper > div.css-1uz5ayg > div > main > div > article > div > div > div:nth-child(1) > div > p:nth-child(2)"),
  start: By.css("#gatsby-focus-wrapper > div.css-1uz5ayg > div > main > div > h1"),
  e: [
    { step: 'signup',     selector: By.css("#sign-up-for-new-relic-if-you-havent-already") },
    { step: 'ingest',     selector: By.css("#ingest-some-data") },
    { step: 'dashboards', selector: By.css("#check-out-some-dashboards") },
    { step: 'data',       selector: By.css("#add-more-data") },
    { step: 'alerting',   selector: By.css("#set-up-alerting") },
    { step: 'users',      selector: By.css("#add-users") }
  ]
}

// -------------------- FUNCTIONS
// for backwards compatibility with legacy runtimes
async function waitForAndFindElement(locator, timeout) {
  const element = await $webDriver.wait(
    $selenium.until.elementLocated(locator),
    timeout,
    "Timed-out waiting for element to be located using: " + locator
  )
  await $webDriver.wait(
    $selenium.until.elementIsVisible(element),
    timeout,
    "Timed-out waiting for element to be visible using ${element}"
  )
  return await $webDriver.findElement(locator)
}

// -------------------- START OF SCRIPT
// Start logging
var start_time = new Date()
console.log("Starting synthetics script: " + SCRIPT_NAME)

// confirm timeouts are set
const {implicit, pageLoad, script} = await $webDriver.manage().getTimeouts()
console.log("Timeouts are set to:")
console.log("  IMPLICIT: " + implicit / 1000 + "s")
console.log("  PAGE LOAD: " + pageLoad / 1000 + "s")
console.log("  SCRIPT: " + script / 1000 + "s")

// Setting User Agent is not then-able, so we do this first (if defined and not default)
if (USER_AGENT && 0 !== USER_AGENT.trim().length && USER_AGENT != "default") {
  $headers.add("User-Agent", USER_AGENT)
  console.log("Setting User-Agent to " + USER_AGENT)
}

// if an error happens at any step, script execution is halted and a failed result is returned
console.log("1. get: " + MAIN_URL)
await $webDriver.get(MAIN_URL)

console.log("2. waitForAndFindElement: " + loc.video)
const textBlock = await waitForAndFindElement(loc.video, IMPLICIT_TIMEOUT)

console.log("3. getText: " + CHECK)
const text = await textBlock.getText()

console.log("4. assert.equal: " + text)
assert.equal(text, CHECK, "validation text not found")

console.log("5. waitForAndFindElement: " + loc.start)
const platformMenu = await waitForAndFindElement(loc.start, IMPLICIT_TIMEOUT)

console.log("6. takeScreenshot")
await $webDriver.takeScreenshot()

console.log("7. findElement")
loc.e.forEach(async function (nr, i) {
  let n = i + 1
  try{
    // verify each asset has loaded
    console.log("  " + n + ". " + nr.step + ": " + nr.selector)
    await $webDriver.findElement(nr.selector)
  }catch(exception){
    console.error("Failure in Step 7." + n)
    throw exception
  }
})

// End logging
var end_time = new Date()

// Calculate the duration
var script_duration = end_time - start_time

// Log the times
console.log("Start time: " + start_time)
console.log("End time: " + end_time)
console.log("Duration: " + script_duration)