Eu gostaria de monitorar o uso de memória / CPU de um processo em tempo real. Semelhante, topmas direcionado a apenas um processo, de preferência com um gráfico de histórico de algum tipo.

No Linux, topna verdade , suporta o foco em um único processo, embora naturalmente não tenha um gráfico de histórico:

top -p PID

Isso também está disponível no Mac OS X com uma sintaxe diferente:

top -pid PID

htopé um ótimo substituto para top. Tem ... Cores! Atalhos de teclado simples! Role a lista usando as teclas de seta! Mate um processo sem sair e sem tomar nota do PID! Marque vários processos e mate todos!

Entre todos os recursos, a página de manual diz que você pode pressionar Fpara seguir um processo.

Realmente, você deveria tentar htop. Eu nunca comecei topnovamente, depois da primeira vez que usei htop.

Exiba um único processo:

htop -p PID

psrecord

O gráfico de histórico de endereços a seguir de algum tipo . O psrecordpacote Python faz exatamente isso.

pip install psrecord                             # local user install
sudo apt-get install python-matplotlib python-tk # for plotting; or via pip

Para um processo único, é o seguinte (parado Ctrl+C):

psrecord $(pgrep proc-name1) --interval 1 --plot plot1.png

Para vários processos, o seguinte script é útil para sincronizar os gráficos:

#!/bin/bash    
psrecord $(pgrep proc-name1) --interval 1 --duration 60 --plot plot1.png &
P1=$!
psrecord $(pgrep proc-name2) --interval 1 --duration 60 --plot plot2.png &
P2=$!
wait $P1 $P2
echo 'Done'

Os gráficos são parecidos com:

memory_profiler

O pacote fornece amostra apenas de RSS (mais algumas opções específicas do Python). Ele também pode registrar processos com os processos filhos (consulte mprof --help).

pip install memory_profiler
mprof run /path/to/executable
mprof plot

Por padrão, isso exibe um python-tkexplorador de gráficos baseado em Tkinter ( pode ser necessário) que pode ser exportado:

pilha de grafite & statsd

Pode parecer um exagero para um teste pontual simples, mas para algo como uma depuração de vários dias é, com certeza, razoável. Um prático all-in-one raintank/graphite-stackimagem (de autores de Grafana) e psutile statsdcliente. procmon.pyfornece uma implementação.

$ docker run --rm -p 8080:3000 -p 8125:8125/udp raintank/graphite-stack

Em outro terminal, após iniciar o processo de destino:

$ sudo apt-get install python-statsd python-psutil # or via pip
$ python procmon.py -s localhost -f chromium -r 'chromium.*'

Em seguida, abra o Grafana em http: // localhost: 8080 , authentication as admin:admin, configure datasource https: // localhost , você pode plotar um gráfico como:

pilha de grafite e telegraf

Em vez de o script Python enviar as métricas para o Statsd, telegraf(e o procstatplug-in de entrada) podem ser usados ​​para enviar as métricas ao Graphite diretamente.

A telegrafconfiguração mínima se parece com:

[agent]
  interval = "1s"

[[outputs.graphite]]
  servers = ["localhost:2003"]
  prefix = "testprfx"

[[inputs.procstat]]
  pid_file = "/path/to/file/with.pid"

Depois corra a linha telegraf --config minconf.conf. A parte Grafana é a mesma, exceto os nomes das métricas.

sysdig

sysdig(disponível nos repositórios Debian e Ubuntu) com a interface do usuário sysdig-inspecionada, parece muito promissor, fornecendo detalhes extremamente detalhados, juntamente com a utilização da CPU e o RSS, mas infelizmente a interface do usuário não pode renderizá-los e sysdig não pode filtrar procinfo eventos por processo no diretório tempo de escrita. No entanto, isso deve ser possível com um cinzel personalizado (uma sysdigextensão escrita em Lua).

Para usar essas informações em um script, você pode fazer isso:

calcPercCpu.sh

#!/bin/bash
nPid=$1;
nTimes=10; # customize it
delay=0.1; # customize it
strCalc=`top -d $delay -b -n $nTimes -p $nPid \
  |grep $nPid \
  |sed -r -e "s;\s\s*; ;g" -e "s;^ *;;" \
  |cut -d' ' -f9 \
  |tr '\n' '+' \
  |sed -r -e "s;(.*)[+]$;\1;" -e "s/.*/scale=2;(&)\/$nTimes/"`;
nPercCpu=`echo "$strCalc" |bc -l`
echo $nPercCpu

use like: calcPercCpu.sh 1234onde 1234 é o pid

Para o $ nPid especificado, ele medirá a média de 10 instantâneos do uso da CPU em um segundo inteiro (atraso de 0,1s cada * nTimes = 10); que fornece um resultado preciso bom e rápido do que está acontecendo no momento.

Ajuste as variáveis ​​de acordo com suas necessidades.

Eu normalmente uso os dois seguintes:

1. Caliper HP : sua ferramenta muito boa para monitorar processos, você também pode verificar o gráfico de chamadas e outras informações de baixo nível. Mas observe que é gratuito apenas para uso pessoal.

2. daemontools : uma coleção de ferramentas para gerenciar serviços UNIX

Usar tope awkpoder-se-ia criar facilmente, por exemplo, um log separado por vírgula do uso de% CPU ( $9) +% MEM ( $10) que pode ser posteriormente alimentado em qualquer ferramenta de estatística e gráfico.

top -b -d $delay -p $pid | awk -v OFS="," '$1+0>0 {
print strftime("%Y-%m-%d %H:%M:%S"),$1,$NF,$9,$10; fflush() }'

A saída será como

2019-03-26 17:43:47,2991,firefox,13.0,5.2
2019-03-26 17:43:48,2991,firefox,4.0,5.2
2019-03-26 17:43:49,2991,firefox,64.0,5.3
2019-03-26 17:43:50,2991,firefox,71.3,5.4
2019-03-26 17:43:51,2991,firefox,67.0,5.4

Isso não dará bons resultados para grandes $delay, no entanto, porque o carimbo de data / hora impresso está realmente $delayatrasado devido à forma como topa saída funciona. Sem entrar em muitos detalhes, uma maneira simples de contornar isso é registrar o tempo fornecido por top:

top -b -d $delay -p $pid | awk -v OFS="," '$1=="top"{ time=$3 }
$1+0>0 { print time,$1,$NF,$9,$10; fflush() }'

O carimbo de data / hora é preciso, mas a saída ainda será atrasada $delay.

Se você souber o nome do processo, poderá usar

top -p $(pidof <process_name>)

Se você tiver uma distribuição Linux cortada em que top não possui opção por processo (-p) ou opções relacionadas, poderá analisar a saída do comando top do nome do seu processo para obter as informações de uso da CPU por processo.

while true;  do top -bn1 | awk '/your_process_name/ {print  $8}' ; sleep 1; done

8 representa o uso da CPU por processo na saída do comando top na minha distribuição Linux incorporada

Não há reputação suficiente para comentar, mas, para o psrecord, você também pode chamá-lo diretamente, de maneira programática, diretamente no Python:

from psrecord.main import monitor
monitor(<pid number>, logfile = "./test.log", plot="./fig.png", include_children=True)

Se você precisar das médias durante um período de um processo específico, tente a opção -c acumulativa de cima:

top -c a -pid PID

"-c a" encontrado na parte superior do Mac 10.8.5.

Para o Scientific Linux, a opção é -S, que pode ser configurada interativamente.

Estou um pouco atrasado aqui, mas vou compartilhar meu truque de linha de comando usando apenas o padrão ps

WATCHED_PID=$({ command_to_profile >log.stdout 2>log.stderr & } && echo $!);
while ps -p $WATCHED_PID --no-headers --format "etime pid %cpu %mem rss" do; 
   sleep 1 
done

Eu uso isso como uma linha. Aqui a primeira linha dispara o comando e armazena o PID na variável Então ps imprimirá o tempo decorrido, o PID a porcentagem de CPU usada, a porcentagem de memória e a memória RSS. Você também pode adicionar outros campos.

Assim que o processo terminar, o pscomando não retornará "sucesso" e o comandowhile loop terminará.

Você pode ignorar a primeira linha se o PID que você deseja criar o perfil já estiver em execução. Basta colocar o ID desejado na variável.

Você obterá uma saída como esta:

  00:00  7805  0.0  0.0  2784
  00:01  7805 99.0  0.8 63876
  00:02  7805 99.5  1.3 104532
  00:03  7805  100  1.6 129876
  00:04  7805  100  2.1 170796
  00:05  7805  100  2.9 234984
  00:06  7805  100  3.7 297552
  00:07  7805  100  4.0 319464
  00:08  7805  100  4.2 337680
  00:09  7805  100  4.5 358800
  00:10  7805  100  4.7 371736
  ....