J'aimerais surveiller l'utilisation de la mémoire / du processeur d'un processus en temps réel. Similaire à topun seul processus, mais de préférence avec un graphique d’historique.

Sous Linux, il est topactuellement possible de se concentrer sur un seul processus, bien qu’il n’ait naturellement pas de graphique d’historique:

top -p PID

Ceci est également disponible sur Mac OS X avec une syntaxe différente:

top -pid PID

htopest un excellent remplacement pour top. Il a ... des couleurs! Raccourcis clavier simples! Faites défiler la liste en utilisant les touches fléchées! Tuez un processus sans quitter et sans prendre en compte le PID! Marquez plusieurs processus et tuez-les tous!

Parmi toutes les fonctionnalités, la page de manuel indique que vous pouvez appuyer sur Fpour suivre un processus.

Vraiment, vous devriez essayer htop. Je n'ai jamais toprecommencé, après la première fois que j'ai utilisé htop.

Afficher un seul processus:

htop -p PID

psrecord

Les adresses suivantes graphique de l' histoire de quelque sorte . Le psrecordpaquet Python fait exactement cela.

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

Pour un processus unique, il s’agit de ce qui suit (arrêté par Ctrl+C):

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

Pour plusieurs processus, le script suivant est utile pour synchroniser les graphiques:

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

Les graphiques ressemblent à:

memory_profiler

Le paquet fournit un échantillonnage uniquement RSS (plus quelques options spécifiques à Python). Il peut également enregistrer un processus avec ses processus enfants (voir mprof --help).

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

Par défaut, un python-tkexplorateur de graphique basé sur Tkinter (qui peut être nécessaire) peut être exporté:

pile de graphite & statsd

Cela peut sembler excessif pour un simple test ponctuel, mais pour quelque chose comme un débogage sur plusieurs jours, c'est à coup sûr raisonnable. Un tout-en-un pratique raintank/graphite-stack(des auteurs de Grafana) psutilet un statsdclient. procmon.pyfournit une implémentation.

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

Ensuite, dans un autre terminal, après le démarrage du processus cible:

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

Ensuite, en ouvrant Grafana à l' adresse http: // localhost: 8080 , authentification en tant que admin:admin, configuration de la source de données https: // localhost , vous pouvez tracer un graphique tel que:

pile de graphite & telegraf

Au lieu d’un script Python, l’envoi des métriques à Statsd telegraf(et du procstatplugin d’entrée) peut être utilisé pour envoyer les métriques directement à Graphite.

La telegrafconfiguration minimale ressemble à ceci:

[agent]
  interval = "1s"

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

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

Puis lancez la ligne telegraf --config minconf.conf. La partie Grafana est la même, à l'exception des noms de métriques.

sysdig

sysdig(disponible dans Debian et prises en pension pour Ubuntu) avec sysdig inspecter l' interface utilisateur semble très prometteur, fournissant des détails à grain très fin avec l' utilisation du processeur et RSS, mais malheureusement , l'interface utilisateur est incapable de les rendre, et sysdig ne peut pas filtrer procinfo l' événement par le processus au moment de l'écriture. Cela devrait être possible avec un burin personnalisé (une sysdigextension écrite en Lua).

Pour utiliser ces informations sur un script, procédez comme suit:

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

utiliser comme: calcPercCpu.sh 1234où 1234 est le pid

Pour le $ nPid spécifié, il mesurera la moyenne de 10 instantanés de l'utilisation du processeur en 1 seconde (délai de 0,1 s chacun * nTimes = 10); cela fournit un résultat précis et rapide de ce qui se passe au moment même.

Ajustez les variables à vos besoins.

J'utilise normalement les deux suivants:

1. Calibre HP : c'est un très bon outil pour surveiller les processus, vous pouvez également consulter le graphe des appels et d'autres informations de bas niveau. Mais s'il vous plaît noter que c'est gratuit uniquement pour un usage personnel.

2. daemontools : un ensemble d'outils de gestion des services UNIX

Utiliser topet awkon pourrait facilement créer, par exemple, un journal d'utilisation% CPU ( $9) +% MEM ( $10), séparé par des virgules , qui pourra ensuite être introduit dans n'importe quel outil de statistiques et de graphique.

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

La sortie sera comme

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

Cela ne donnera pas de bons résultats pour les gros $delay, cependant, car l'horodatage imprimé est en $delayretard à cause du fonctionnement de topla sortie. Sans trop entrer dans les détails, une solution simple consiste à enregistrer l’heure fournie par top:

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

Ensuite, l'horodatage est précis, mais la sortie sera toujours retardée $delay.

Si vous connaissez le nom du processus, vous pouvez utiliser

top -p $(pidof <process_name>)

Si vous disposez d'une distribution Linux réduite dans laquelle top ne dispose pas d'option par processus (-p) ou d'options connexes, vous pouvez analyser la sortie de la commande top pour que le nom de votre processus obtienne les informations d'utilisation de l'UC par processus.

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

8 représente l'utilisation du processeur par processus dans le résultat de la commande top de ma distribution Linux intégrée

Pas assez de réputation pour commenter, mais pour psrecord vous pouvez aussi l'appeler directement, de manière programmatique, directement en Python:

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

Si vous avez besoin des moyennes pour une période donnée d'un processus spécifique, essayez l'option cumulative -c de top:

top -c a -pid PID

"-c a" trouvé en haut pour Mac 10.8.5.

Pour Scientific Linux, l’option est -S, qui peut être définie de manière interactive.

Je suis un peu en retard ici, mais je vais partager mon tour de commande en utilisant seulement la valeur par défaut 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

J'utilise cela comme une ligne. Ici, la première ligne lance la commande et stocke le PID dans la variable. Ensuite, ps affichera le temps écoulé, le PID utilisé, le pourcentage de mémoire et la mémoire RSS. Vous pouvez également ajouter d'autres champs.

Dès que le processus se termine, la pscommande ne renverra pas "succès" et la whileboucle se terminera.

Vous pouvez ignorer la première ligne si le PID que vous souhaitez profiler est déjà en cours d'exécution. Il suffit de placer l'identifiant souhaité dans la variable.

Vous obtiendrez une sortie comme celle-ci:

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