Me gustaría monitorear el uso de memoria / CPU de un proceso en tiempo real. Similar toppero dirigido a un solo proceso, preferiblemente con un gráfico histórico de algún tipo.

En Linux, en toprealidad admite centrarse en un solo proceso, aunque naturalmente no tiene un gráfico de historial:

top -p PID

Esto también está disponible en Mac OS X con una sintaxis diferente:

top -pid PID

htopes un gran reemplazo para top. Tiene ... colores! Atajos de teclado simples! ¡Desplácese por la lista con las teclas de flecha! ¡Mata un proceso sin salir y sin tomar nota del PID! ¡Marca múltiples procesos y mátalos a todos!

Entre todas las características, la página de manual dice que puede presionar Fpara seguir un proceso.

Realmente, deberías intentarlo htop. Nunca comencé de topnuevo, después de la primera vez que lo usé htop.

Mostrar un solo proceso:

htop -p PID

psrecord

El siguiente aborda el gráfico del historial de algún tipo . El psrecordpaquete Python hace exactamente esto.

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

Para un solo proceso es el siguiente (detenido Ctrl+C):

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

Para varios procesos, el siguiente script es útil para sincronizar los 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'

Los gráficos se ven así:

memory_profiler

El paquete proporciona muestreo solo de RSS (más algunas opciones específicas de Python). También puede grabar el proceso con sus procesos hijos (ver mprof --help).

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

De manera predeterminada, aparece un python-tkexplorador de gráficos basado en Tkinter ( puede ser necesario) que se puede exportar:

grafito-stack & statsd

Puede parecer una exageración para una prueba simple, pero para algo como una depuración de varios días es, sin duda, razonable. Una práctica raintank/graphite-stackimagen psutily statsdcliente todo en uno (de los autores de Grafana) y cliente. procmon.pyProporciona una implementación.

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

Luego, en otra terminal, después de iniciar el proceso de destino:

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

Luego, abriendo Grafana en http: // localhost: 8080 , autenticación como admin:admin, configurando el origen de datos https: // localhost , puede trazar un gráfico como:

grafito-pila y telegraf

En lugar de que el script Python envíe las métricas a Statsd, telegraf(y procstatel complemento de entrada) se puede usar para enviar las métricas a Graphite directamente.

La telegrafconfiguración mínima se ve así:

[agent]
  interval = "1s"

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

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

Luego corre la línea telegraf --config minconf.conf. La parte de Grafana es la misma, excepto los nombres de métricas.

sysdig

sysdig(disponible en los repositorios de Debian y Ubuntu) con la interfaz de usuario sysdig-inspect parece muy prometedora, brindando detalles extremadamente finos junto con la utilización de la CPU y RSS, pero desafortunadamente la interfaz de usuario no puede procesarlos y sysdig no puede filtrar procinfo eventos por proceso en el hora de escribir. Sin embargo, esto debería ser posible con un cincel personalizado (una sysdigextensión escrita en Lua).

Para usar esa información en un script, puede hacer esto:

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 1234donde 1234 es el pid

Para el $ nPid especificado, medirá el promedio de 10 instantáneas del uso de la CPU en un total de 1 segundo (retraso de 0.1s cada una * nTimes = 10); eso proporciona un resultado bueno y rápido de lo que está sucediendo en el momento.

Ajusta las variables a tus necesidades.

Normalmente uso los siguientes dos:

1. Calibrador HP : es una muy buena herramienta para monitorear procesos, también puede verificar el gráfico de llamadas y otra información de bajo nivel. Pero tenga en cuenta que es gratis solo para uso personal.

2. daemontools : una colección de herramientas para gestionar servicios UNIX

El uso de topy awkuno podría crear fácilmente, por ejemplo, un registro separado por comas del uso de% CPU ( $9) +% MEM ( $10) que luego se puede alimentar a cualquier herramienta de estadísticas y gráficos.

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

Sin $delayembargo, esto no dará buenos resultados para grandes , porque la marca de tiempo impresa está realmente $delayatrasada debido a cómo topfunciona la salida. Sin entrar en demasiados detalles, una forma simple de evitar esto es registrar el tiempo proporcionado 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() }'

Entonces la marca de tiempo es precisa, pero la salida aún se retrasará $delay.

Si conoce el nombre del proceso, puede usar

top -p $(pidof <process_name>)

Si tiene una distribución Linux reducida donde top no tiene la opción por proceso (-p) u opciones relacionadas, puede analizar la salida del comando top para el nombre de su proceso para obtener la información de uso de la CPU por proceso.

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

8 representa el uso de CPU por proceso en la salida del comando superior en mi distribución de Linux incrustada

No hay suficiente reputación para comentar, pero para psrecord también puede llamarlo directamente, de manera programática, directamente en Python:

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

Si necesita los promedios durante un período de tiempo de un proceso específico, pruebe la opción acumulativa -c de top:

top -c a -pid PID

"-c a" se encuentra en la parte superior para Mac 10.8.5.

Para Scientific Linux, la opción es -S, que se puede configurar de forma interactiva.

Llego un poco tarde aquí, pero compartiré mi truco en la línea de comandos usando solo el predeterminado 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

Yo uso esto como una frase. Aquí la primera línea dispara el comando y almacena el PID en la variable. Luego, ps imprimirá el tiempo transcurrido, el PID, el porcentaje de CPU que utiliza, el porcentaje de memoria y la memoria RSS. También puede agregar otros campos.

Tan pronto como finalice el proceso, el pscomando no devolverá "éxito" y el whileciclo finalizará.

Puede ignorar la primera línea si el PID que desea perfilar ya se está ejecutando. Simplemente coloque la identificación deseada en la variable.

Obtendrá una salida 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
  ....