Vorrei monitorare l'utilizzo della memoria / CPU di un processo in tempo reale. Simile topma mirato a un solo processo, preferibilmente con un grafico cronologico di qualche tipo.

Su Linux, in toprealtà supporta la concentrazione su un singolo processo, anche se naturalmente non ha un grafico cronologico:

top -p PID

Questo è disponibile anche su Mac OS X con una sintassi diversa:

top -pid PID

htopè un ottimo sostituto di top. Ha ... Colori! Scorciatoie da tastiera semplici! Scorri l'elenco usando i tasti freccia! Uccidi un processo senza uscire e senza prendere nota del PID! Segna più processi e uccidili tutti!

Tra tutte le funzionalità, la manpage dice che è possibile premere Fper seguire un processo.

Davvero, dovresti provare htop. Non ho mai ricominciato top, dopo la prima volta che l'ho usato htop.

Visualizza un singolo processo:

htop -p PID

psrecord

Di seguito è riportato un grafico cronologico di qualche tipo . Il psrecordpacchetto Python fa esattamente questo.

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

Per singolo processo è il seguente (interrotto da Ctrl+C):

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

Per diversi processi il seguente script è utile per sincronizzare i grafici:

#!/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'

I grafici sembrano:

memory_profiler

Il pacchetto fornisce il campionamento solo RSS (oltre ad alcune opzioni specifiche di Python). Può anche registrare il processo con i suoi processi figlio (vedi mprof --help).

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

Per impostazione predefinita, viene visualizzato un python-tkesploratore di grafici basato su Tkinter (che potrebbe essere necessario) che può essere esportato:

stack di grafite e statsd

Può sembrare eccessivo per un semplice test una tantum, ma per qualcosa come un debug di diversi giorni è, sicuramente, ragionevole. raintank/graphite-stackUn'utile immagine all-in-one (dagli autori di Grafana) psutile statsdclient. procmon.pyfornisce un'implementazione.

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

Quindi in un altro terminale, dopo aver avviato il processo di destinazione:

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

Quindi aprendo Grafana su http: // localhost: 8080 , autenticazione come admin:admin, impostazione dell'origine dati https: // localhost , è possibile tracciare un grafico come:

stack di grafite e telegraf

Invece dello script Python che invia le metriche a Statsd, telegraf(e procstatplugin di input) può essere utilizzato per inviare le metriche direttamente a Graphite.

La telegrafconfigurazione minima è simile a:

[agent]
  interval = "1s"

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

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

Quindi eseguire la linea telegraf --config minconf.conf. La parte di Grafana è la stessa, tranne i nomi delle metriche.

sysdig

sysdig(disponibile nei repository di Debian e Ubuntu) con l' interfaccia utente sysdig-inspect molto promettente, che fornisce dettagli estremamente dettagliati con l'utilizzo della CPU e RSS, ma sfortunatamente l'interfaccia utente non è in grado di renderli e sysdig non può filtrare gli procinfo eventi in base al processo tempo di scrivere. Tuttavia, questo dovrebbe essere possibile con uno scalpello personalizzato ( sysdigun'estensione scritta in Lua).

Per usare queste informazioni su uno script puoi fare questo:

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

usa come: calcPercCpu.sh 1234dove 1234 è il pid

Per $ nPid specificato, misurerà la media di 10 istantanee dell'utilizzo della cpu in un intero 1 secondo (ritardo di 0,1 secondi ciascuno * nTimes = 10); che fornisce un risultato accurato e rapido di ciò che sta accadendo nel momento stesso.

Modifica le variabili in base alle tue esigenze.

Normalmente ne uso due seguenti:

1. Calibro HP : ottimo strumento per il monitoraggio dei processi, è possibile controllare anche il grafico delle chiamate e altre informazioni di basso livello. Si prega di notare che è gratuito solo per uso personale.

2. daemontools : una raccolta di strumenti per la gestione dei servizi UNIX

Usando tope awksi potrebbe facilmente creare, ad esempio, un registro separato da virgola dell'utilizzo di% CPU ( $9) +% MEM ( $10) che può essere successivamente inserito in qualsiasi strumento di statistica e rappresentazione grafica.

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() }'

L'output sarà simile

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

Questo non darà buoni risultati per grandi $delay, però, perché il timestamp stampato è in realtà $delayindietro a causa del funzionamento topdell'output. Senza entrare troppo nei dettagli, 1 semplice modo per aggirare questo è registrare il tempo fornito da top:

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

Quindi il timestamp è preciso, ma l'uscita verrà comunque ritardata $delay.

Se conosci il nome del processo che puoi utilizzare

top -p $(pidof <process_name>)

Se si dispone di una distribuzione Linux ridotta in cui top non ha un'opzione per processo (-p) o opzioni correlate, è possibile analizzare l'output del comando top per il nome del processo per ottenere le informazioni sull'utilizzo della CPU per processo.

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

8 rappresenta l'utilizzo della CPU per processo nell'output del comando principale nella mia distribuzione Linux incorporata

Non abbastanza reputazione per commentare, ma per psrecord puoi anche chiamarlo direttamente, in modo programmatico, direttamente in Python:

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

Se hai bisogno delle medie per un periodo di tempo di un processo specifico, prova l'opzione cumulativa -c di top:

top -c a -pid PID

"-c a" trovato in cima per Mac 10.8.5.

Per Scientific Linux, l'opzione è -S, che può essere impostata in modo interattivo.

Sono un po 'in ritardo qui, ma condividerò il mio trucco da riga di comando usando solo l'impostazione predefinita 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

Lo uso come una linea. Qui la prima riga attiva il comando e memorizza il PID nella variabile. Quindi ps stamperà il tempo trascorso, il PID la percentuale di CPU utilizzata, la percentuale di memoria e la memoria RSS. Puoi aggiungere anche altri campi.

Non appena il processo termina, il pscomando non restituirà "successo" e il whileciclo terminerà.

È possibile ignorare la prima riga se il PID che si desidera profilare è già in esecuzione. Posiziona semplicemente l'id desiderato nella variabile.

Otterrai un output come questo:

  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
  ....