Python监控进程性能数据并绘图保存为PDF文档

引言

利用psutil模块（https://pypi.python.org/pypi/psutil/），能够非常方便的监控系统的CPU、内存、磁盘IO、网络带宽等性能参数，以下是否代码为监控某个特定程序的CPU资源消耗，打印监控数据，最终绘图显示，并且保存为指定的 PDF 文档备份。

示范代码

 

#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
Copyright (C)  2015 By Thomas Hu.  All rights reserved.

@author : Thomas Hu (thomashtq#163.com)
@version: 1.0
@created: 2015-7-14
'''
import matplotlib.pyplot as plt
import psutil as ps
import os
import time
import random
import collections
import argparse

class ProcessMonitor(object):
    def __init__(self, key_name, fields, duration, interval):
        self.key_name = key_name
        self.fields = fields
        self.duration = float(duration)
        self.inveral = float(interval)

        self.CPU_COUNT = ps.cpu_count()
        self.MEM_TOTAL = ps.virtual_memory().total / (1024 * 1024)
        self.procinfo_dict = collections.defaultdict(dict)


    def _get_proc_info(self, pid):
        try:
            proc = ps.Process(pid)
            name = proc.name()
            # If not contains the key word, return None
            if name.find(self.key_name) == -1:
                return None
            pinfo = {
                    "name": name,
                    "pid" : pid,
                    }
            # If the field is correct, add it to the process information dictionary.
            for field in self.fields:
                if hasattr(proc, field):
                    if field == "cpu_percent":
                        pinfo[field] = getattr(proc, field)(interval = 0.1) / self.CPU_COUNT
                    elif field == "memory_percent":
                        pinfo[field] = getattr(proc, field)() * self.MEM_TOTAL / 100
                    else:
                        pinfo[field] = getattr(proc, field)()
            if pid not in self.procinfo_dict:
                self.procinfo_dict[pid] = collections.defaultdict(list)
                self.procinfo_dict[pid]["name"] = name
            for field in self.fields:
                self.procinfo_dict[pid][field].append(pinfo.get(field, 0))
            print(pinfo)
            return pinfo
        except:
            pass
        return None

    def monitor_processes(self):
        start = time.time()
        while time.time() - start < self.duration:
            try:
                pids = ps.pids()
                for pid in pids:
                    self._get_proc_info(pid)
            except KeyboardInterrupt:
                print("Killed by user keyboard interrupted!")
                return

    def _get_color(self):
        color = "#"
        for i in range(3):
            a = hex(random.randint(0, 255))[2:]
            if len(a) == 1:
                a = "0" + a
            color += a
        return color.upper()

    def draw_figure(self, field, pdf):
        # Draw each pid line
        for pid in self.procinfo_dict:
            x = range(len(self.procinfo_dict[pid][field]))
            #print x, self.procinfo_dict[pid][field]
            plt.plot(x, self.procinfo_dict[pid][field], label = "pid" + str(pid), color = self._get_color())
        plt.xlabel(time.strftime("%Y-%m-%d %H:%M:%S"))
        plt.ylabel(field.upper())
        plt.title(field + " Figure")
        plt.legend(loc = "upper left")
        plt.grid(True)
        plt.savefig(pdf, dpi = 200)
        plt.show()

def Main():
    parser = argparse.ArgumentParser(description=&#39;Monitor process CPU and Memory.&#39;)
    parser.add_argument("-k", dest=&#39;key&#39;, type=str, default="producer", 
                   help=&#39;the key word of the processes to be monitored(default is "producer")&#39;)
    parser.add_argument("-d", dest=&#39;duration&#39;, type=int, default=60,
                   help=&#39;duration of the monitor to run(unit: seconds, default is 60)&#39;)
    parser.add_argument(&#39;-i&#39;, dest=&#39;interval&#39;, type=float, default=1.0,
                   help=&#39;interval of the sample(unit: seconds, default is 1.0)&#39;)
    args = parser.parse_args()
    fields = ["cpu_percent", "memory_percent"]
    #print args.key, args.duration, args.interval
    pm = ProcessMonitor(args.key, fields, args.duration, args.interval)
    pm.monitor_processes()
    pm.draw_figure("cpu_percent", "cpu.pdf")
    pm.draw_figure("memory_percent", "mem.pdf")


if __name__ == "__main__":
    Main()
  
    

 

输出结果示范图