Recentemente, tenho aprendido sobre monitoramento de nodejs. Embora não tenha energia para aprender a escrever uma versão simples de monitoramento, ainda não posso deixar de aprender como obter esses indicadores (depois de consultar muitas informações, sinto). que há muito pouca introdução a esse conteúdo na Internet doméstica, também estou classificando os pontos de conhecimento do nó do servidor, então irei resumi-los neste artigo e compartilhá-los com você).
Pode haver problemas com alguns dos indicadores neste artigo. Bem-vindo ao intercâmbio, você pode organizar esses dados e gravá-los em uma biblioteca de monitoramento e usá-los em seus próprios projetos de pequeno e médio porte. Em seguida, o front-end react possui ferramentas como bizcharts e g2, e o front-end desenha sozinho a grande tela de dados. Acho que as dimensões dos dados coletados pelo esay monitor não são tão abrangentes quanto as nossas.
Os gargalos de desempenho dos servidores são geralmente os seguintes:
de uso da CPU e carga da CPU, os quais podem refletir a ocupação de uma máquina até certo ponto.
O uso da CPU são os recursos da CPU ocupados pela execução de programas, indicando como a máquina está executando programas em um determinado momento. Quanto maior a taxa de utilização, significa que a máquina está executando muitos programas neste momento e vice-versa. O nível de uso está diretamente relacionado à potência da CPU. Vamos primeiro entender as APIs relevantes e algumas explicações terminológicas para nos ajudar a entender o código para obter o uso da CPU.
os.cpus()retorna um array de objetos contendo informações sobre cada núcleo lógico da CPU.
model: uma string especificando o modelo do núcleo da CPU.
speed: Um número que especifica a velocidade do núcleo da CPU em MHz.
times: Um objeto que contém as seguintes propriedades:
NOTA: O valor nice é apenas para POSIX. Nos sistemas operacionais Windows, o valor de nice é sempre 0 para todos os processadores.
Quando você vê os campos user e nice, alguns alunos ficam confusos sobre as vantagens, e eu também, então perguntei cuidadosamente sobre o significado deles, por favor continue.
user indica a proporção de tempo que a CPU está rodando no modo de usuário .
A execução do processo de aplicação é dividida em modo de usuário e modo kernel : a CPU executa a lógica de código do próprio processo de aplicação no modo de usuário, geralmente alguns cálculos lógicos ou numéricos, a CPU executa chamadas de sistema iniciadas pelo processo no modo kernel, geralmente em resposta; à solicitação de recursos do processo.
Um programa de espaço de usuário é qualquer processo que não faz parte do kernel. Shells, compiladores, bancos de dados, servidores web e programas relacionados a desktops são todos processos do espaço do usuário. Se o processador não estiver ocioso, é normal que a maior parte do tempo da CPU seja gasta na execução de processos no espaço do usuário.
Nice representa a proporção de tempo que a CPU é executada no modo de usuário de baixa prioridade . Baixa prioridade significa que o valor legal do processo é menor que 0.
usuáriorepresenta a proporção de tempo que a CPU é executada no modo kernel .
De modo geral, o uso da CPU no modo kernel não deve ser muito alto, a menos que o processo do aplicativo inicie um grande número de chamadas do sistema. Se for muito alto, significa que a chamada do sistema demora muito, como operações IO frequentes.
inativoindica a proporção de tempo que a CPU está no estado inativo, no qual a CPU não tem tarefas para executar.
representa a proporção de tempo que a CPU lida com interrupções de hardware .
A interrupção da placa de rede é um exemplo típico: após a placa de rede receber o pacote de dados, ela notifica a CPU para processamento por meio de uma interrupção de hardware. Se o tráfego de rede do sistema for muito intenso, poderá ser observado um aumento significativo no uso de IRQ.
Se o estado do usuário for inferior a 70%, o estado do kernel for inferior a 35% e o estado geral for inferior a 70%, pode ser contado como um estado íntegro.
O exemplo a seguir ilustra o uso do método os.cpus() em Node.js:
Exemplo 1:
// Programa Node.js para demonstrar o
//método os.cpus()
// Alocando módulo OS
const os = requer('os');
//Imprimindo valores os.cpus()
console.log(os.cpus()); Saída:
[ {modelo:'CPU Intel(R) Core(TM) i5-7200U @ 2,50GHz',
velocidade: 2712,
vezes:
{usuário:900000, agradável:0, sys:940265, inativo:11928546, irq:147046 } },
{modelo:'CPU Intel (R) Core (TM) i5-7200U @ 2,50 GHz',
velocidade: 2712,
vezes:
{usuário:860875, agradável:0, sys:507093, inativo:12400500, irq:27062 } },
{modelo:'CPU Intel (R) Core (TM) i5-7200U @ 2,50 GHz',
velocidade: 2712,
vezes:
{usuário:1273421, agradável:0, sys:618765, inativo:11876281, irq:13125 } },
{modelo:'CPU Intel (R) Core (TM) i5-7200U @ 2,50 GHz',
velocidade: 2712,
vezes:
{ user:943921, nice:0, sys:460109, idle:12364453, irq:12437 } } ] A seguir está o código de como obter a utilização da CPU
const os = require('os');
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
classe OSUtils{
construtor() {
this.cpuUsageMSDefault = 1000; //período padrão de utilização da CPU}
/**
* Obtenha a utilização da CPU por um determinado período de tempo* @param { Number } Options.ms [Período de tempo, o padrão é 1000ms, que é 1 segundo]
* @param { Boolean } Options.percentage [true (retornado como resultado percentual) |
* @returns {Promessa}
*/
getCPUUsage assíncrono(options={}) {
const isso = isto;
deixe {cpuUsageMS, porcentagem} = opções;
cpuUsageMS = cpuUsageMS || that.cpuUsageMSDefault;
const t1 = that._getCPUInfo(); // informações da CPU no momento t1 aguardam sleep(cpuUsageMS);
const t2 = that._getCPUInfo(); // informações da CPU no momento t2 const idle = t2.idle - t1.idle;
const total = t2.total - t1.total;
deixe uso = 1 - inativo/total;
if (porcentagem) uso = (uso * 100,0).toFixed(2) + "%";
uso de retorno;
}
/**
* Obtenha informações de tempo instantâneo da CPU * @returns { Object } Informações da CPU * usuário <número> O número de milissegundos que a CPU gastou no modo de usuário.
* nice <número> O número de milissegundos que a CPU gasta no modo agradável.
* sys <número> Número de milissegundos que a CPU gastou no modo de sistema.
* idle <número> O número de milissegundos que a CPU gastou no modo inativo.
* irq <número> O número de milissegundos que a CPU gastou no modo de solicitação de interrupção.
*/
_getCPUInfo() {
const cpus = os.cpus();
deixe usuário = 0, bom = 0, sys = 0, inativo = 0, irq = 0, total = 0;
for (deixe CPU em CPU) {
const vezes = cpus[cpu].vezes;
usuário += vezes.usuário;
legal += vezes.legal;
sys += vezes.sys;
inativo += vezes.idle;
irq += vezes.irq;
}
total += usuário + legal + sys + inativo + irq;
retornar {
usuário,
sistema,
parado,
total,
}
}
}
const cpuUsage = new OSUtils().getCPUUsage({ porcentagem: true });
console.log('cpuUsage: ', cpuUsage.then(data=>console.log(data))); // Meu computador tem 6,15% . A carga da CPU (loadavg) é fácil de entender e se refere a uma determinada
carga.período de tempo. O número de processos ocupando tempo de CPU e processos aguardando tempo de CPU é a média de carga. Os processos que aguardam tempo de CPU aqui se referem a processos aguardando para serem despertados, excluindo processos no estado de espera.
Antes disso, precisamos aprender que a API do nó
os.loadavg()retorna um array contendo carga média de 1, 5 e 15 minutos.
A média de carga é uma medida da atividade do sistema calculada pelo sistema operacional e expressa como decimal.
A média de carga é um conceito específico do Unix. No Windows, o valor de retorno é sempre [0, 0, 0]
É usado para descrever a ocupação atual do sistema operacional. Pode ser entendido simplesmente como o número médio de tarefas que a CPU está usando e aguardando para usar o. CPU por unidade de tempo. A carga da CPU está muito alta, indicando que há muitos processos no Node, isso pode se refletir no início repetido de novos processos usando o módulo Cidade Proibida.
const os = requer('os');
//Número de threads da CPU const length = os.cpus().length;
//A carga média de uma CPU single-core retorna um array contendo a carga média de 1, 5 e 15 minutos os.loadavg().map(load => load / length Vamos primeiro explicar uma API
);, caso contrário você não poderá lê-lo. Entenda nosso código para obter indicadores de memória,
Esta função retorna 4 parâmetros, os significados e diferenças são os seguintes:
Use o código a seguir para imprimir o uso de memória de um processo filho. Pode-se observar que rss é aproximadamente igual ao RES do comando top. Além disso, a memória do processo principal é de apenas 33M, o que é menor que a memória do processo filho. Pode-se observar que o uso de memória é calculado de forma independente.
var showMem = function(){
var mem = process.memoryUsage();
var formato = função(bytes){
retornar (bytes/1024/1024).toFixed(2) + 'MB';
};
console.log('Processo: heapTotal ' + formato(mem.heapTotal) + 'heapUsed' + formato(mem.heapUsed) + 'rss' + formato(mem.rss) + 'externo:' + formato(mem.externo) );
console.log('----------------------------------------------------------- --- ---------------');
}; Para o Node, quando ocorre um vazamento de memória, não é tão fácil solucionar o problema. Se for monitorado que a memória apenas sobe, mas não cai, então deve haver um problema de vazamento de memória. O uso saudável da memória deve aumentar e diminuir. Quando o acesso é grande, ele aumenta, e quando o acesso cai, ele diminui.
const os = require('os');
// Verifique o uso atual da memória do processo do Node const { rss, heapUsed, heapTotal } = process.memoryUsage();
// Obtém memória livre do sistema const systemFree = os.freemem();
// Obtenha a memória total do sistema const systemTotal = os.totalmem();
módulo.exportações = {
memória: () => {
retornar {
sistema: 1 - systemFree / systemTotal, // Heap de uso de memória do sistema: heapUsed / headTotal, // Nó atual de uso de memória do processo do nó: rss / systemTotal, // Taxa de uso de memória do processo do nó atual da memória do sistema}
}
} O monitoramento de disco monitora principalmente o uso do disco. Devido à gravação frequente de logs, o espaço em disco é gradualmente consumido. Uma vez que o disco não seja suficiente, isso causará vários problemas no sistema. Defina um limite máximo para uso do disco. Quando o uso do disco exceder o valor de aviso, o administrador do servidor deverá organizar os logs ou limpar o disco.
O código a seguir refere-se ao monitor fácil 3.0.
const { execSync } = require('child_process');
resultado const = execSync('df -P', { codificação: 'utf8'})
linhas const = resultado.split('n');
métrica constante = {};
linhas.forEach(linha => {
if (line.startsWith('/')) {
const correspondência = line.match(/(d+)%s+(/.*$)/);
se (corresponder) {
taxa const = parseInt(correspondência[1] || 0);
const montado = match[2];
if (!mounted.startsWith('/Volumes/') && !mounted.startsWith('/private/')) {
métrica[montada] = taxa;
}
}
}
});
console.log(metric) A carga de E/S refere-se principalmente à E/S do disco. Ele reflete a situação de leitura e gravação no disco. Para aplicativos escritos pelo Node, que são principalmente para serviços de rede, é improvável que a carga de E/S seja muito alta. A pressão de E/S de muitas leituras vem do banco de dados. .
Para obter indicadores de E/S, precisamos entender um comando do Linux chamado iostat. Se não estiver instalado, vamos ver por que este comando pode refletir os indicadores de E/S
iostat -dx.
Descrição da propriedade
rrqm/s: O número de operações de leitura de mesclagem por segundo. Ou seja, rmerge/s (o número de vezes que as solicitações de leitura para o dispositivo são mescladas por segundo, e o sistema de arquivos mesclará as solicitações para ler o mesmo bloco) wrqm/s: o número de operações de gravação de mesclagem por segundo. Ou seja, wmerge/s (o número de vezes que as solicitações de gravação no dispositivo são mescladas por segundo) r/s: O número de leituras do dispositivo de E/S concluídas por segundo. Isso é rio/s w/s: O número de gravações no dispositivo de E/S concluídas por segundo. Isso é wio/s rsec/s: Número de setores lidos por segundo. Isso é rsect/s wsec/s: Número de setores gravados por segundo. ou seja, wsect/s rkB/s: K bytes lidos por segundo. É metade de rsect/s porque o tamanho de cada setor é de 512 bytes. wkB/s: Número de K bytes gravados por segundo. É metade de wsect/s. avgrq-sz: Tamanho médio dos dados (setores) por operação de E/S do dispositivo. avgqu-sz: comprimento médio da fila de E/S. aguardar: O tempo médio de espera (milissegundos) para cada operação de E/S do dispositivo. svctm: Tempo médio de processamento (milissegundos) de cada operação de E/S do dispositivo. %util: Qual porcentagem de um segundo é usada para operações de I/O, ou seja, a porcentagem de CPU consumida por IO.
Só precisamos monitorar %util.
Se %util estiver próximo de 100% , significa que há muitos I. Solicitações /O são geradas O sistema de E/S está totalmente carregado e pode haver um gargalo neste disco.
Se await for muito maior que svctm, significa que a fila de E/S é muito longa e o tempo de resposta do aplicativo se torna mais lento. Se o tempo de resposta exceder o intervalo que o usuário pode tolerar, considere substituir um disco mais rápido. ajustando o algoritmo de elevador do kernel e otimizando o aplicativo ou atualizando a CPU.
monitora o tempo de resposta da página do Nodejs. A solução é selecionada no artigo do blog do professor Liao Xuefeng.
Recentemente, quero monitorar o desempenho do Nodejs. Gravar e analisar o log é muito problemático. A maneira mais simples é registrar o tempo de processamento de cada solicitação HTTP e retorná-lo diretamente no cabeçalho de resposta HTTP.
Registrar o horário de uma solicitação HTTP é muito simples. Significa registrar um carimbo de data/hora ao receber a solicitação e registrar outro carimbo de data/hora ao responder à solicitação. A diferença entre os dois carimbos de data/hora é o tempo de processamento.
No entanto, o código res.send() está espalhado por vários arquivos js, portanto você não pode alterar todas as funções de processamento de URL.
A ideia correta é usar middleware para alcançá-lo. Mas o Nodejs não possui nenhum método para interceptar res.send(), como quebrá-lo?
Na verdade, contanto que mudemos um pouco nosso pensamento, abandonemos o método OOP tradicional e vejamos res.send() como um objeto de função, podemos primeiro salvar a função de processamento original res.send e, em seguida, substituir res.send por nosso função de processamento própria:
app.use (function (req, res, next) {
//Hora de início do registro:
var exec_start_at = Date.now();
//Salva a função de processamento original:
var _enviar = res.enviar;
// Vincule nossa própria função de manipulador:
res.enviar=função(){
//Enviar cabeçalho:
res.set('X-Execution-Time', String(Date.now() - exec_start_at));
// Chame a função de processamento original:
return _send.apply(res, argumentos);
};
próximo();
}); Em apenas algumas linhas de código, o carimbo de data/hora está concluído.
Não há necessidade de processar o método res.render() porque res.render() chama res.send() internamente.
Ao chamar a função apply(), é importante passar o objeto res, caso contrário, o this da função de processamento original aponta para indefinido, o que leva diretamente a um erro.
Tempo de resposta medido da página inicial 9 milissegundos
Glossário QPS:
QPS: Consultas por segundo significa "taxa de consulta por segundo", que é o número de consultas às quais um servidor pode responder. por segundo, é uma medida de quanto tráfego um servidor de consulta específico manipula em um período de tempo especificado.
Na Internet, o desempenho de uma máquina que serve como servidor de sistema de nomes de domínio é frequentemente medido pela taxa de consulta por segundo.
TPS: é a abreviatura de TransactionsPerSecond, que é o número de transações/segundo. É uma unidade de medida para resultados de testes de software. Uma transação refere-se ao processo no qual um cliente envia uma solicitação ao servidor e o servidor responde. O cliente inicia a cronometragem quando envia uma solicitação e termina quando recebe a resposta do servidor para calcular o tempo utilizado e o número de transações concluídas.
QPS vs TPS: QPS é basicamente semelhante ao TPS, mas a diferença é que uma visita a uma página forma um TPS, mas uma solicitação de página pode gerar várias solicitações ao servidor, e o servidor pode contar essas solicitações como "QPS". Por exemplo, acessar uma página solicitará duas vezes ao servidor. Um acesso gerará um “T” e dois “Q”.
. Tempo de resposta: o tempo total necessário para executar uma solicitação do início ao fim quando os dados de resposta são recebidos, ou seja, o tempo desde o início da solicitação pelo cliente até o recebimento do resultado da resposta do servidor.
O tempo de resposta RT (Tempo de resposta) é um dos indicadores mais importantes de um sistema. Seu valor numérico reflete diretamente a velocidade do sistema.
O número de simultaneidade refere-se ao número de solicitações que o sistema pode atender ao mesmo tempo. Isso também reflete a capacidade de carga do sistema.
A taxa de transferência (capacidade de suporte de pressão) do sistema está intimamente relacionada ao consumo de CPU de solicitações, interfaces externas, IO, etc. Quanto maior o consumo de CPU de uma única solicitação, mais lenta será a interface externa do sistema e a velocidade de E/S, e menor será a capacidade de rendimento do sistema e vice-versa.
Vários parâmetros importantes de rendimento do sistema: QPS (TPS), número de simultaneidades e tempo de resposta.
QPS (TPS): (Consulta por segundo) Número de solicitações/transações por segundo
Simultaneidade: Número de solicitações/transações processadas pelo sistema ao mesmo tempo
Tempo de resposta: Geralmente, o tempo médio de resposta
é calculado após a compreensão do significado do acima três elementos. A relação entre eles:
Vamos entender os conceitos acima através de um exemplo. Pela regra 80/20, se 80% das visitas diárias estão concentradas em 20% do tempo, esses 20% do tempo são chamados de horário de pico.
1, 300 W por dia fotovoltaico estão em uma única máquina. Quantos QPS esta máquina requer?
(3000000 * 0,8) / (86400 * 0,2) = 139 (QPS)
2. Se o QPS de uma máquina for 58, quantas máquinas são necessárias para suportá-la?
139 / 58 = 3
Neste ponto, se você fizer a arquitetura front-end de projetos gerais de pequeno e médio porte e implantar seus próprios serviços de nó, saberá quantas máquinas são necessárias para formar um cluster para reportar ppt. você pode calcular um valor aproximado com PV .
Precisamos entender o teste de estresse (precisamos contar com o teste de estresse para obter qps). Tomemos o comando ab como exemplo:
comando format:
ab [options] [http://]hostname[:port]/path
Common). os parâmetros são os seguintes:
-n total de solicitações Número de solicitações -c simultaneidade Número de simultaneidade -t timelimit O número máximo de segundos para o teste, que pode ser considerado como o tempo limite da solicitação -p postfile Arquivo contendo dados que requerem POST -T tipo de conteúdo Informações do cabeçalho do tipo de conteúdo usadas pelos dados POST Copiar código