def r_engine_status():
cpu_used = int(round((psutil.cpu_times().user * 100) + \
(psutil.cpu_times().system * 100), 0))
cpu_free = int(round(psutil.cpu_times().idle * 100, 0))
s = {
"cpu": {
"used": cpu_used,
"free": cpu_free
},
"memory": {
"physical": {
"used": psutil.phymem_usage().used,
"free": psutil.phymem_usage().free
},
"virtual": {
"used": psutil.virtmem_usage().used,
"free": psutil.virtmem_usage().free
}
},
"disk": {
"used": psutil.disk_usage('/').used,
"free": psutil.disk_usage('/').free
}
}
r = Response("success", "status", s).get()
return r
def r_engine_status():
cpu_used = int(round((psutil.cpu_times().user * 100) + \
(psutil.cpu_times().system * 100), 0))
cpu_free = int(round(psutil.cpu_times().idle * 100, 0))
s = {
"cpu": {
"used": cpu_used,
"free": cpu_free
},
"memory": {
"physical": {
"used": psutil.phymem_usage().used,
"free": psutil.phymem_usage().free
},
"virtual": {
"used": psutil.virtmem_usage().used,
"free": psutil.virtmem_usage().free
}
},
"disk": {
"used": psutil.disk_usage('/').used,
"free": psutil.disk_usage('/').free
}
}
r = Response("success", "status", s).get()
return r
def get_HRRR_value(getthisDATE):
"""
Getting HRRR data, just return the value
"""
print getthisDATE, psutil.virtmem_usage().used/1000000000, psutil.virtmem_usage().percent
H = get_hrrr_variable(getthisDATE, 'TMP:2 m', fxx=0, model='hrrr', field='sfc', value_only=True, verbose=False)
return H['value']
def get_virtmem():
usage = {}
fields = list(virtmem_usage()._fields)
mem = virtmem_usage()
for field in fields:
usage["virtual_memory_" + field] = mem.__getattribute__(field)
return usage
def stat(self): ds = dict() ds['pt'] = int(psutil.phymem_usage().total / 1024) ds['pf'] = int(psutil.phymem_usage().free / 1024) ds['pu'] = int(psutil.phymem_usage().used / 1024) ds['pb'] = int(psutil.phymem_buffers() / 1024) ds['pc'] = int(psutil.cached_phymem() / 1024) ds['st'] = int(psutil.virtmem_usage().total / 1024) ds['su'] = int(psutil.virtmem_usage().used / 1024) return ds
def stat(self):
ds = dict()
ds['pt'] = int(psutil.phymem_usage().total / 1024)
ds['pf'] = int(psutil.phymem_usage().free / 1024)
ds['pu'] = int(psutil.phymem_usage().used / 1024)
ds['pb'] = int(psutil.phymem_buffers() / 1024)
ds['pc'] = int(psutil.cached_phymem() / 1024)
ds['st'] = int(psutil.virtmem_usage().total / 1024)
ds['su'] = int(psutil.virtmem_usage().used / 1024)
return ds
def getMemStatus(self):
memstatus = {}
memstatus['total_phymem'] = str(int(psutil.TOTAL_PHYMEM ) /1024 /1024) + " MB"
memstatus['total_virtmem'] = str(int(psutil.total_virtmem()) /1024 /1024) + " MB"
memstatus['phymem_usage_percent'] = psutil.phymem_usage().percent
memstatus['phymem_usage_used'] = str(int(psutil.phymem_usage().used) /1024 /1024) + "MB"
memstatus['phtmem_usage_free'] = str(int(psutil.phymem_usage().free) /1024 /1024) + "MB"
memstatus['virtmem_usage_percent'] = psutil.virtmem_usage().percent
memstatus['virtmem_usage_used'] = str(int(psutil.virtmem_usage().used) /1024 /1024) + "MB"
memstatus['virtmem_usage_free'] = str(int(psutil.virtmem_usage().free) /1024 /1024) + "MB"
return memstatus
def get_memory_stats(self):
memory = {
"physical": {
"used": psutil.phymem_usage().used,
"free": psutil.phymem_usage().free
},
"virtual": {
"used": psutil.virtmem_usage().used,
"free": psutil.virtmem_usage().free
}
}
return memory
def get_memory_stats(self):
memory = {
"physical": {
"used": psutil.phymem_usage().used,
"free": psutil.phymem_usage().free
},
"virtual": {
"used": psutil.virtmem_usage().used,
"free": psutil.virtmem_usage().free
}
}
return memory
def printStatus(out, checkcpu):
doc=getDOMImplementation().createDocument(None, "status", None)
node=doc.createElement("node")
a=XMLJobManager()
status=a.listByStatus()
node.setAttribute("running", str(is_running()))
node.setAttribute("pending", str(status[0]))
node.setAttribute("processing", str(status[1]))
node.setAttribute("finished", str(status[2]))
node.setAttribute("failed", str(status[3]))
doc.documentElement.appendChild(node)
mem=doc.createElement("memory")
phy=psutil.phymem_usage()
virt=psutil.virtmem_usage()
mem.setAttribute("total_physical", str(phy.total))
mem.setAttribute("avail_physical", str(phy.total-phy.used))
mem.setAttribute("total_virtual", str(virt.total))
mem.setAttribute("avail_virtual", str(virt.total-virt.used))
doc.documentElement.appendChild(mem)
if checkcpu:
cpu=doc.createElement("cpu")
cpu.setAttribute("usage", str(psutil.cpu_percent(3)))
doc.documentElement.appendChild(cpu)
lsl=LocalStoreList()
for disk in lsl.disks:
d=doc.createElement("disk")
d.setAttribute("guid", disk.uuid)
d.setAttribute("online", str(disk.online))
d.setAttribute('freespace', str(disk.freespace))
doc.documentElement.appendChild(d)
doc.writexml(out)
def get_snapshot_as_list(self):
ps = psutil.Process(self.pid)
return (self.group(ps.get_memory_info()[0]),
self.group(ps.get_memory_info()[1]),
'%02d' % ps.get_cpu_percent(),
self.group(psutil.phymem_usage().free),
self.group(psutil.virtmem_usage().free))
def cpustat(self):
tags = "node:%s %s" % (self.nodename, self.tags)
val = int(psutil.cpu_percent())
measurement = "cpu_perc"
key = "%s.%s" % (self.nodename, measurement)
self.measure(key, measurement, tags, val, aggrkey=measurement)
val = int(psutil.avail_phymem() / 1024 / 1024)
measurement = "mem_free_mb"
key = "%s.%s" % (self.nodename, measurement)
self.measure(key, measurement, tags, val, aggrkey=measurement)
val = int(psutil.virtmem_usage()[3])
measurement = "mem_virt_perc"
key = "%s.%s" % (self.nodename, measurement)
self.measure(key, measurement, tags, val, aggrkey=measurement)
val = int(psutil.phymem_usage()[2])
measurement = "mem_phy_perc"
key = "%s.%s" % (self.nodename, measurement)
self.measure(key, measurement, tags, val, aggrkey=measurement)
res = psutil.cpu_times_percent()
names = [
"cputimeperc_user", "cputimeperc_nice", "cputimeperc_system",
"cputimeperc_idle", "cputimeperc_iowait", "cputimeperc_irq",
"cputimeperc_softirq", "steal", "guest", "guest_nice"
]
for i in range(len(names)):
if names[i].startswith("cputime"):
val = int(res[i])
measurement = names[i]
key = "%s.%s" % (self.nodename, measurement)
self.measure(key, measurement, tags, val, aggrkey=measurement)
def runinsert():
cpu_usage = psutil.cpu_percent()
mem_usage = psutil.phymem_usage().percent
disk_usage = psutil.disk_usage('/').percent
virtual = psutil.virtmem_usage().percent
network = simplejson.dumps(psutil.network_io_counters(True))
conn = sqlite3.connect('stats.db')
cur = conn.cursor()
cur.execute("DELETE FROM stats WHERE timestamp < datetime('now','localtime','-7 days')")
# cur.execute("DELETE FROM stats WHERE timestamp < datetime('now', 'localtime','-1 hour')")
conn.commit()
cur.execute("INSERT INTO stats (cpu, memory, disk, virtual, network) VALUES (?, ?, ?, ?, ? )",
(cpu_usage, mem_usage, disk_usage, virtual, network))
# DUBUG
# cur.execute("SELECT * FROM stats")
# print(cur.fetchall())
conn.commit()
conn.close()
def get_mem_stats():
'''return mem stats'''
if hasattr(psutil, 'cached_phymem') and hasattr(psutil, 'phymem_buffers'):
cachemem = psutil.cached_phymem() + psutil.phymem_buffers()
else:
cachemem = -1
phymem = psutil.phymem_usage()
mem = {
'cache': cachemem,
'total': phymem.total,
'used': phymem.used,
'free': phymem.free,
'percent': phymem.percent
}
virtmem = psutil.virtmem_usage()
memswap = {
'total': virtmem.total,
'used': virtmem.used,
'free': virtmem.free,
'percent': virtmem.percent
}
return {"cache": cachemem, "mem": mem, "swap": memswap}
def calculate_resizing_tofitmemory(x_size,y_size,n_slices,byte):
"""
Predicts the percentage (between 0 and 1) to resize the image to fit the memory,
giving the following information:
x_size, y_size: image size
n_slices: number of slices
byte: bytes allocated for each pixel sample
"""
imagesize = x_size * y_size * n_slices * byte * 28
# USING LIBSIGAR
#import sigar
#sg = sigar.open()
#ram_free = sg.mem().actual_free()
#ram_total = sg.mem().total()
#swap_free = sg.swap().free()
#sg.close()
# USING PSUTIL
import psutil
try:
if (psutil.version_info>=(0,6,0)):
ram_free = psutil.virtual_memory().available
ram_total = psutil.virtual_memory().total
swap_free = psutil.swap_memory().free
else:
ram_free = psutil.phymem_usage().free + psutil.cached_phymem() + psutil.phymem_buffers()
ram_total = psutil.phymem_usage().total
swap_free = psutil.virtmem_usage().free
except:
print "Exception! psutil version < 0.3 (not recommended)"
ram_total = psutil.TOTAL_PHYMEM # this is for psutil < 0.3
ram_free = 0.8 * psutil.TOTAL_PHYMEM
swap_free = psutil.avail_virtmem()
print "RAM_FREE=", ram_free
print "RAM_TOTAL=", ram_total
if (sys.platform == 'win32'):
if (platform.architecture()[0] == '32bit'):
if ram_free>1400000000:
ram_free=1400000000
if ram_total>1400000000:
ram_total=1400000000
if (sys.platform == 'linux2'):
if (platform.architecture()[0] == '32bit'):
if ram_free>3500000000:
ram_free=3500000000
if ram_total>3500000000:
ram_total=3500000000
if (swap_free>ram_total):
swap_free=ram_total
resize = (float((ram_free+0.5*swap_free)/imagesize))
resize=math.sqrt(resize) # this gives the "resize" for each axis x and y
if (resize>1):
resize=1
return round(resize,2)
def get_mem_swap(self,):
"""
Get memory and swap usage
"""
try:
# psutil >= 0.6.0
phymem = psutil.virtual_memory()
buffers = psutil.virtual_memory().buffers
cached = psutil.virtual_memory().cached
vmem = psutil.swap_memory()
except AttributeError:
# psutil > 0.4.0 and < 0.6.0
phymem = psutil.phymem_usage()
buffers = getattr(psutil, 'phymem_buffers', lambda: 0)()
cached = getattr(psutil, 'cached_phymem', lambda: 0)()
vmem = psutil.virtmem_usage()
mem_used = phymem.total - (phymem.free + buffers + cached)
return (
phymem.percent,
mem_used,
phymem.total,
vmem.percent,
vmem.used,
vmem.total)
def collect_virtmem_usage(self):
"""
TODO skip the percentage? it can be calculated by graphite, so...
"""
stats = psutil.virtmem_usage()
for k,v in stats._asdict().iteritems():
self.add_data("virtmem.%s"%k,v)
def calculate_resizing_tofitmemory(x_size,y_size,n_slices,byte):
"""
Predicts the percentage (between 0 and 1) to resize the image to fit the memory,
giving the following information:
x_size, y_size: image size
n_slices: number of slices
byte: bytes allocated for each pixel sample
"""
imagesize = x_size * y_size * n_slices * byte * 28
# USING LIBSIGAR
#import sigar
#sg = sigar.open()
#ram_free = sg.mem().actual_free()
#ram_total = sg.mem().total()
#swap_free = sg.swap().free()
#sg.close()
# USING PSUTIL
import psutil
try:
if (psutil.version_info>=(0,6,0)):
ram_free = psutil.virtual_memory().available
ram_total = psutil.virtual_memory().total
swap_free = psutil.swap_memory().free
else:
ram_free = psutil.phymem_usage().free + psutil.cached_phymem() + psutil.phymem_buffers()
ram_total = psutil.phymem_usage().total
swap_free = psutil.virtmem_usage().free
except:
print "Exception! psutil version < 0.3 (not recommended)"
ram_total = psutil.TOTAL_PHYMEM # this is for psutil < 0.3
ram_free = 0.8 * psutil.TOTAL_PHYMEM
swap_free = psutil.avail_virtmem()
print "RAM_FREE=", ram_free
print "RAM_TOTAL=", ram_total
if (sys.platform == 'win32'):
if (platform.architecture()[0] == '32bit'):
if ram_free>1400000000:
ram_free=1400000000
if ram_total>1400000000:
ram_total=1400000000
if (sys.platform == 'linux2'):
if (platform.architecture()[0] == '32bit'):
if ram_free>3500000000:
ram_free=3500000000
if ram_total>3500000000:
ram_total=3500000000
if (swap_free>ram_total):
swap_free=ram_total
resize = (float((ram_free+0.5*swap_free)/imagesize))
resize=math.sqrt(resize) # this gives the "resize" for each axis x and y
if (resize>1):
resize=1
return round(resize,2)
def info_loop(max_ctr = 100):
exit_loop = False
internal_ctr = 0
while not exit_loop:
q = psutil.cpu_percent(interval=1)
#q = q/10
cpuload = '%.0f'%(q)
cpuload = 'cpu load: ' + cpuload + '%'
print cpuload
#ser.write(cpuload)
q = psutil.phymem_usage()
# mem = '%.0f'%(q.percent/10)
mem = '%.0f'%(q.percent)
mem = 'memory: ' + mem + '%'
print mem
#ser.write(mem)
q = psutil.virtmem_usage()
virtmem = '%.0f'%(q.percent/10)
virtmem = 'virtmem: '+virtmem + '%'
print virtmem
time.sleep(0.5)
internal_ctr = internal_ctr + 1
if (internal_ctr > max_ctr):
self.exit_loop = True
print '\n'
def get_mem_swap(self,):
"""
Get memory and swap usage
"""
try:
# psutil >= 0.6.0
phymem = psutil.virtual_memory()
buffers = psutil.virtual_memory().buffers
cached = psutil.virtual_memory().cached
vmem = psutil.swap_memory()
except AttributeError:
# psutil > 0.4.0 and < 0.6.0
phymem = psutil.phymem_usage()
buffers = getattr(psutil, 'phymem_buffers', lambda: 0)()
cached = getattr(psutil, 'cached_phymem', lambda: 0)()
vmem = psutil.virtmem_usage()
mem_used = phymem.total - (phymem.free + buffers + cached)
return (
phymem.percent,
mem_used,
phymem.total,
vmem.percent,
vmem.used,
vmem.total)
def get_mem_stats():
'''return mem stats'''
if hasattr(psutil, 'cached_phymem') and hasattr(psutil, 'phymem_buffers'):
cachemem = psutil.cached_phymem() + psutil.phymem_buffers()
else:
cachemem = -1
phymem = psutil.phymem_usage()
mem = {
'cache': cachemem,
'total': phymem.total,
'used': phymem.used,
'free': phymem.free,
'percent': phymem.percent
}
virtmem = psutil.virtmem_usage()
memswap = {
'total': virtmem.total,
'used': virtmem.used,
'free': virtmem.free,
'percent': virtmem.percent
}
return {
"cache": cachemem,
"mem": mem,
"swap": memswap
}
def prepare_memory(self):
physmem = psutil.phymem_usage()
vmem = psutil.virtual_memory()
swap = psutil.virtmem_usage()
return {
'virtual': {
'total': vmem.total,
'used': vmem.used,
'available': vmem.available,
'percent': vmem.percent,
'free': vmem.free,
'active': vmem.active,
'inactive': vmem.inactive,
'wired': vmem.wired,
},
'physical': {
'total': physmem.total,
'used': physmem.used,
'free': physmem.free,
'percent': physmem.percent,
},
'swap': {
'total': swap.total,
'used': swap.used,
'free': swap.free,
'percent': swap.percent,
},
}
def do_index(environ, start_response):
env = Environment(loader=FileSystemLoader(environ['DOCUMENT_ROOT']));
template = env.get_template('index.html')
start_response('200 OK',[('Content-Type','text/html')])
## getting CPU info
cpu_info = psutil.cpu_percent(interval=1, percpu=True)
phymem_info = psutil.phymem_usage()
virtmem_info = psutil.virtmem_usage()
disk_info = psutil.disk_usage(config.map['global']['data_dir'])
## getting status of modules
mod_exec_IF.connect();
if ( mod_exec_IF.connected() ):
procs = mod_exec_IF.list();
for mod in procs:
if mod.state == mod_exec_IF.RUNNING:
mod.statestr = 'RUN'
elif mod.state == mod_exec_IF.RESTARTING:
mod.statestr = 'RESTART'
elif mod.state == mod_exec_IF.STOPPED:
mod.statestr = 'STOPPED'
else:
procs = []
return [str(template.render(
cpu_info=cpu_info,phymem_info=phymem_info,virtmem_info=virtmem_info,disk_info=disk_info,
procs_connected=mod_exec_IF.connected(), procs=procs
))]
def cpustat(self):
tags="node:%s %s"%(self.nodename,self.tags)
val=int(psutil.cpu_percent())
measurement="cpu_perc"
key="%s.%s"%(self.nodename,measurement)
self.measure(key,measurement,tags,val,aggrkey=measurement)
val=int(psutil.avail_phymem()/1024/1024)
measurement="mem_free_mb"
key="%s.%s"%(self.nodename,measurement)
self.measure(key,measurement,tags,val,aggrkey=measurement)
val=int(psutil.virtmem_usage()[3])
measurement="mem_virt_perc"
key="%s.%s"%(self.nodename,measurement)
self.measure(key,measurement,tags,val,aggrkey=measurement)
val=int(psutil.phymem_usage()[2])
measurement="mem_phy_perc"
key="%s.%s"%(self.nodename,measurement)
self.measure(key,measurement,tags,val,aggrkey=measurement)
res=psutil.cpu_times_percent()
names=["cputimeperc_user","cputimeperc_nice","cputimeperc_system","cputimeperc_idle","cputimeperc_iowait","cputimeperc_irq","cputimeperc_softirq","steal","guest","guest_nice"]
for i in range(len(names)):
if names[i].startswith("cputime"):
val=int(res[i])
measurement=names[i]
key="%s.%s"%(self.nodename,measurement)
self.measure(key,measurement,tags,val,aggrkey=measurement)
def report_mem(prev_values=None, msg=None):
""" Show status of phy/virt mem, and if given previous values,
report differences
requires the psutil module - avail in apt-get, but I used pip
"""
if msg is None:
msg = ""
else:
msg += ": "
if type(prev_values) == type(""): # catch error in prev_values
msg += prev_values
prev_values = None
print("need msg= in call to report_mem")
# available in linux is free + buffers + cached
if hasattr(psutil, "swap_memory"): # new version (0.7+)
pm = psutil.virtual_memory().available # was psutil.avail_phymem()
vm = psutil.swap_memory().free # was psutil.avail_virtmem()
else:
pm = psutil.phymem_usage().free # was .avail_phymem()
vm = psutil.virtmem_usage().free # avail_virtmem()
tim = seconds()
print("{msg}{pm:.3g} GB phys mem, {vm:.3g} GB virt mem avail".format(msg=msg, pm=pm / 1e9, vm=vm / 1e9)),
if prev_values is None:
print()
else:
print(
"- dt={dt:.2g}s, used {pm:.2g} GB phys, {vm:.2g} GB virt".format(
pm=(prev_values[0] - pm) / 1e9, vm=(prev_values[1] - vm) / 1e9, dt=tim - prev_values[2]
)
)
return (pm, vm, tim)
def query_system_status():
"""Query global mem, CPU, disk, and network (if present)"""
uptime = int(time.time() - psutil.BOOT_TIME)
uptime = str(datetime.timedelta(seconds=uptime))
try:
used_mem = psutil.virtmem_usage().percent
used_cpu = psutil.cpu_percent(
percpu=False) #N.B Only looking at one CPU
used_disk = psutil.disk_usage('/').percent
total_network = psutil.network_io_counters(pernic=True)
network_sent, network_rcvd = -1, -1
if network_interface in total_network:
network_sent = round(
total_network[network_interface].bytes_sent / 1024.0 / 1024.0,
2)
network_rcvd = round(
total_network[network_interface].bytes_recv / 1024.0 / 1024.0,
2)
except psutil.AccessDenied:
loggging.error("Access denied when trying to query PID %d" % p)
return None
return {
'used_mem': used_mem,
'used_cpu': used_cpu,
'used_disk': used_disk,
'network_sent': network_sent,
'network_rcvd': network_rcvd,
'uptime': uptime
}
def dump_tolog(cCpu, cSensor, cData):
logFile = open("data/ForensicLog.txt", 'a+')
cPhyMem = psutil.phymem_usage()
cVirMem = psutil.virtmem_usage()
cNetTraffic = psutil.network_io_counters(pernic=True)
cPartitionInfo = psutil.disk_partitions()
cActiveProcess = ''
logFile.write('*===================================================*' +
'\n')
logFile.write('|Forensic Activity Logged at: ' +
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") + '\n')
logFile.write('*===================================================*' +
'\n')
logFile.write('SYSCOND: MALFUNCTION | CPU LOAD: ' + cCpu +
'% | SENSOR: ' + cSensor + ' | READ: ' + cData + '\n')
logFile.write('PHYSICAL MEMORY:\n' + str(cPhyMem) + '\n\n')
logFile.write('VIRTUAL MEMORY :\n' + str(cVirMem) + '\n\n')
logFile.write('NETWORK STATUS :\n' + str(cNetTraffic) + '\n\n')
logFile.write('MOUNTED DISKS :\n' + str(cPartitionInfo) + '\n\n')
logFile.write('PROCESS LIST :\n')
for proc in psutil.process_iter():
logFile.write(str(proc) + ',')
logFile.write('\n')
logFile.close()
return
def __init__(self, interval, history_len):
"""
:param interval: Collect statistics according to this interval.
:param history_len: Use this many to compute avg/max statistics.
"""
self.interval = interval
self.history_len = history_len
try:
import psutil # @UnresolvedImport @Reimport
except:
self._available = False
else:
self._available = True
self.cpu = Collect('cpu', lambda: psutil.cpu_percent(interval=0),
interval, history_len)
try:
# new in 0.8
psutil.virtual_memory().percent
get_mem = lambda: psutil.virtual_memory().percent
except:
get_mem = lambda: psutil.phymem_usage().percent
self.mem = Collect('mem', get_mem, interval, history_len)
try:
# new in 0.8
psutil.swap_memory().percent
get_mem = lambda: psutil.swap_memory().percent
except:
get_mem = lambda: psutil.virtmem_usage().percent
self.swap_mem = Collect('swap', get_mem, interval, history_len)
def runinsert():
cpu_usage = psutil.cpu_percent()
mem_usage = psutil.phymem_usage().percent
disk_usage = psutil.disk_usage('/').percent
virtual = psutil.virtmem_usage().percent
network = simplejson.dumps(psutil.network_io_counters(True))
conn = sqlite3.connect('stats.db')
cur = conn.cursor()
cur.execute(
"DELETE FROM stats WHERE timestamp < datetime('now','localtime','-7 days')"
)
# cur.execute("DELETE FROM stats WHERE timestamp < datetime('now', 'localtime','-1 hour')")
conn.commit()
cur.execute(
"INSERT INTO stats (cpu, memory, disk, virtual, network) VALUES (?, ?, ?, ?, ? )",
(cpu_usage, mem_usage, disk_usage, virtual, network))
# DUBUG
# cur.execute("SELECT * FROM stats")
# print(cur.fetchall())
conn.commit()
conn.close()
def __init__(self, interval, history_len):
"""
:param interval: Collect statistics according to this interval.
:param history_len: Use this many to compute avg/max statistics.
"""
self.interval = interval
self.history_len = history_len
try:
import psutil # @UnresolvedImport @Reimport
except:
self._available = False
else:
self._available = True
self.cpu = Collect('cpu', lambda: psutil.cpu_percent(interval=0),
interval, history_len)
try:
# new in 0.8
psutil.virtual_memory().percent
get_mem = lambda: psutil.virtual_memory().percent
except:
get_mem = lambda: psutil.phymem_usage().percent
self.mem = Collect('mem', get_mem, interval, history_len)
try:
# new in 0.8
psutil.swap_memory().percent
get_mem = lambda: psutil.swap_memory().percent
except:
get_mem = lambda: psutil.virtmem_usage().percent
self.swap_mem = Collect('swap', get_mem, interval, history_len)
def collect(self):
"""
Collect memory stats
"""
if os.access(self.PROC, os.R_OK):
file = open(self.PROC)
data = file.read()
file.close()
for line in data.splitlines():
try:
name, value, units = line.split()
name = name.rstrip(':')
value = int(value)
if (name not in _KEY_MAPPING
and 'detailed' not in self.config):
continue
for unit in self.config['byte_unit']:
value = diamond.convertor.binary.convert(value=value,
oldUnit=units,
newUnit=unit)
self.publish(name, value, metric_type='GAUGE')
# TODO: We only support one unit node here. Fix it!
break
except ValueError:
continue
return True
elif psutil:
phymem_usage = psutil.phymem_usage()
virtmem_usage = psutil.virtmem_usage()
units = 'b'
for unit in self.config['byte_unit']:
value = diamond.convertor.binary.convert(
value=phymem_usage.total, oldUnit=units, newUnit=unit)
self.publish('MemTotal', value, metric_type='GAUGE')
value = diamond.convertor.binary.convert(
value=phymem_usage.free, oldUnit=units, newUnit=unit)
self.publish('MemFree', value, metric_type='GAUGE')
value = diamond.convertor.binary.convert(
value=virtmem_usage.total, oldUnit=units, newUnit=unit)
self.publish('SwapTotal', value, metric_type='GAUGE')
value = diamond.convertor.binary.convert(
value=virtmem_usage.free, oldUnit=units, newUnit=unit)
self.publish('SwapFree', value, metric_type='GAUGE')
# TODO: We only support one unit node here. Fix it!
break
return True
return None
def action():
import psutil
import os
import statsd
statscl = statsd.StatsClient()
pipe = statscl.pipeline()
results={}
val=psutil.cpu_percent()
results["cpu.percent"]=val
results["cpu.promile"]=val * 10 # we store promile to have more percision
cput= psutil.cpu_times()
for key in cput.__dict__.keys():
val=cput.__dict__[key]
results["cpu.time.%s"%(key)]=val
counter=psutil.network_io_counters(False)
bytes_sent, bytes_recv, packets_sent, packets_recv, errin, errout, dropin, dropout=counter
results["network.kbytes.recv"]=round(bytes_recv/1024.0,0)
results["network.kbytes.send"]=round(bytes_sent/1024.0,0)
results["network.packets.recv"]=packets_recv
results["network.packets.send"]=packets_sent
results["network.error.in"]=errin
results["network.error.out"]=errout
results["network.drop.in"]=dropin
results["network.drop.out"]=dropout
avg1min, avg5min, avg15min = os.getloadavg()
results["load.avg1min"] = int(avg1min * 100)
results["load.avg5min"] = int(avg5min * 100)
results["load.avg15min"] = int(avg15min * 100)
memory=psutil.virtual_memory()
results["memory.used"]=round((memory.used - memory.cached)/1024.0/1024.0,2)
results["memory.cached"]=round(memory.cached/1024.0/1024.0,2)
results["memory.free"]=round(memory.total/1024.0/1024.0,2) - results['memory.used'] - results['memory.cached']
results["memory.percent"]=memory.percent
total,used,free,percent,sin,sout=psutil.virtmem_usage()
results["swap.free"]=round(free/1024.0/1024.0,2)
results["swap.used"]=round(used/1024.0/1024.0,2)
results["swap.percent"]=percent
stat = j.system.fs.fileGetContents('/proc/stat')
stats = dict()
for line in stat.splitlines():
_, key, value = re.split("^(\w+)\s", line)
stats[key] = value
num_ctx_switches = int(stats['ctxt'])
results["cpu.num_ctx_switches"]=num_ctx_switches
for key, value in results.iteritems():
pipe.gauge("%s_%s_%s" % (j.application.whoAmI.gid, j.application.whoAmI.nid, key), int(round(value)))
pipe.send()
return results
def collect(self):
"""
Collect memory stats
"""
if os.access(self.PROC, os.R_OK):
file = open(self.PROC)
data = file.read()
file.close()
for line in data.splitlines():
try:
name, value, units = line.split()
name = name.rstrip(':')
value = int(value)
if (name not in _KEY_MAPPING
and 'detailed' not in self.config):
continue
for unit in self.config['byte_unit']:
value = diamond.convertor.binary.convert(value=value,
oldUnit=units,
newUnit=unit)
self.publish(name, value, metric_type='GAUGE')
# TODO: We only support one unit node here. Fix it!
break
except ValueError:
continue
return True
elif psutil:
phymem_usage = psutil.phymem_usage()
virtmem_usage = psutil.virtmem_usage()
units = 'b'
for unit in self.config['byte_unit']:
value = diamond.convertor.binary.convert(
value=phymem_usage.total, oldUnit=units, newUnit=unit)
self.publish('MemTotal', value, metric_type='GAUGE')
value = diamond.convertor.binary.convert(
value=phymem_usage.free, oldUnit=units, newUnit=unit)
self.publish('MemFree', value, metric_type='GAUGE')
value = diamond.convertor.binary.convert(
value=virtmem_usage.total, oldUnit=units, newUnit=unit)
self.publish('SwapTotal', value, metric_type='GAUGE')
value = diamond.convertor.binary.convert(
value=virtmem_usage.free, oldUnit=units, newUnit=unit)
self.publish('SwapFree', value, metric_type='GAUGE')
# TODO: We only support one unit node here. Fix it!
break
return True
return None
def loadSummaryData(self):
summary_data = {}
summary_data['cpu'] = [psutil.cpu_percent()]
summary_data['memory'] = [psutil.phymem_usage().percent]
summary_data['disk'] = [psutil.disk_usage('/').percent]
summary_data['virtual'] = [psutil.virtmem_usage().percent]
summary_data['uptime'] = commands.getoutput('uptime')
return summary_data
def update(self):
phys_mem = psutil.phymem_usage()
self.mem_usage = {'total': phys_mem.total, 'used': phys_mem.used,
'free': phys_mem.free, 'percent': phys_mem.percent,
'buffers': psutil.phymem_buffers(),
'cached': psutil.cached_phymem()}
virt_mem = psutil.virtmem_usage()
self.swap_usage = {'total': virt_mem.total, 'used': virt_mem.used, 'free': virt_mem.free, 'percent': virt_mem.percent}
def getMemoryUsage():
phymem = psutil.phymem_usage() # @IgnorePep8
virtmem = psutil.virtmem_usage() # @IgnorePep8
swapmem = psutil.swap_memory() # @IgnorePep8
return { # @IgnorePep8
"physical" : phymem.percent, # @IgnorePep8
"virtual" : virtmem.percent, # @IgnorePep8
"swap" : swapmem.percent} # @IgnorePep8
def loadSummaryData(self):
summary_data = {}
summary_data['cpu'] = [psutil.cpu_percent()]
summary_data['memory'] = [psutil.phymem_usage().percent]
summary_data['disk'] = [psutil.disk_usage('/').percent]
summary_data['virtual'] = [psutil.virtmem_usage().percent]
summary_data['uptime'] = commands.getoutput('uptime')
return summary_data
def make_memsafe():
if sys.platform.startswith('linux'):
import resource
import psutil
for rsrc in (resource.RLIMIT_AS, resource.RLIMIT_DATA):
freemem = psutil.virtmem_usage().free
hard = int(round(freemem *.8))
soft = hard
resource.setrlimit(rsrc, (soft, hard)) #limit to 80% of available memory
def calculateSystemUsage(self):
cpuall = psutil.cpu_percent(interval=0)
cores = len(psutil.cpu_percent(interval=0, percpu=True))
diskusage = psutil.disk_usage("/")
physramusage = psutil.phymem_usage()
virtramusage = psutil.virtmem_usage()
processes = len(psutil.get_pid_list())
theList = [cpuall, cores, diskusage[3], physramusage[3], virtramusage[3], processes]
return theList
def make_memsafe():
if sys.platform.startswith('linux'):
import resource
import psutil
for rsrc in (resource.RLIMIT_AS, resource.RLIMIT_DATA):
freemem = psutil.virtmem_usage().free
hard = int(round(freemem * .8))
soft = hard
resource.setrlimit(rsrc,
(soft, hard)) #limit to 80% of available memory
def virtual_memory_usage():
'''
Return a dict that describes free and available memory, both physical
and virtual.
CLI Example::
salt '*' ps.virtual_memory_usage
'''
return dict(psutil.virtmem_usage()._asdict())
def virtual_memory_usage():
'''
Return a dict that describes free and available memory, both physical
and virtual.
CLI Example::
salt '*' ps.virtual_memory_usage
'''
return dict(psutil.virtmem_usage()._asdict())
def memory(warning = 0.85, critical=0.95):
pm = psutil.phymem_usage()
vm = psutil.virtmem_usage()
sf = sv = "ok"
ff = pm.percent / 100.0
fv = vm.percent / 100.0
if ff > warning: sf = "warning"
if ff > critical: sf = "critical"
if fv > warning: sv = "warning"
if fv > critical: sv = "critical"
alert("phisycal memory", sf, ff, "%.2f%% used\n\n%s" % (ff * 100, memory_report()))
alert("virtual memory", sv, fv, "%.2f%% used\n\n%s" % (fv * 100, memory_report()))
def print_header(procs_status):
"""Print system-related info, above the process list."""
def get_dashes(perc):
dashes = "|" * int((float(perc) / 10 * 4))
empty_dashes = " " * (40 - len(dashes))
return dashes, empty_dashes
# cpu usage
for cpu_num, perc in enumerate(psutil.cpu_percent(interval=0, percpu=True)):
dashes, empty_dashes = get_dashes(perc)
print_line(" CPU%-2s [%s%s] %5s%%" % (cpu_num, dashes, empty_dashes,
perc))
# physmem usage (on linux we include buffers and cached values
# to match htop results)
phymem = psutil.phymem_usage()
dashes, empty_dashes = get_dashes(phymem.percent)
buffers = getattr(psutil, 'phymem_buffers', lambda: 0)()
cached = getattr(psutil, 'cached_phymem', lambda: 0)()
used = phymem.total - (phymem.free + buffers + cached)
line = " Mem [%s%s] %5s%% %6s/%s" % (
dashes, empty_dashes,
phymem.percent,
str(int(used / 1024 / 1024)) + "M",
str(int(phymem.total / 1024 / 1024)) + "M"
)
print_line(line)
# swap usage
vmem = psutil.virtmem_usage()
dashes, empty_dashes = get_dashes(vmem.percent)
line = " Swap [%s%s] %5s%% %6s/%s" % (
dashes, empty_dashes,
vmem.percent,
str(int(vmem.used / 1024 / 1024)) + "M",
str(int(vmem.total / 1024 / 1024)) + "M"
)
print_line(line)
# processes number and status
st = []
for x, y in procs_status.items():
if y:
st.append("%s=%s" % (x, y))
st.sort(key=lambda x: x[:3] in ('run', 'sle'), reverse=1)
print_line(" Processes: %s (%s)" % (len(procs), ' '.join(st)))
# load average, uptime
uptime = datetime.now() - datetime.fromtimestamp(psutil.BOOT_TIME)
av1, av2, av3 = os.getloadavg()
line = " Load average: %.2f %.2f %.2f Uptime: %s" \
% (av1, av2, av3, str(uptime).split('.')[0])
print_line(line)
def print_header(procs_status, num_procs):
"""Print system-related info, above the process list."""
def get_dashes(perc):
dashes = "|" * int((float(perc) / 10 * 4))
empty_dashes = " " * (40 - len(dashes))
return dashes, empty_dashes
# cpu usage
for cpu_num, perc in enumerate(psutil.cpu_percent(interval=0, percpu=True)):
dashes, empty_dashes = get_dashes(perc)
print_line(" CPU%-2s [%s%s] %5s%%" % (cpu_num, dashes, empty_dashes,
perc))
# physmem usage (on linux we include buffers and cached values
# to match htop results)
phymem = psutil.phymem_usage()
dashes, empty_dashes = get_dashes(phymem.percent)
buffers = getattr(psutil, 'phymem_buffers', lambda: 0)()
cached = getattr(psutil, 'cached_phymem', lambda: 0)()
used = phymem.total - (phymem.free + buffers + cached)
line = " Mem [%s%s] %5s%% %6s/%s" % (
dashes, empty_dashes,
phymem.percent,
str(int(used / 1024 / 1024)) + "M",
str(int(phymem.total / 1024 / 1024)) + "M"
)
print_line(line)
# swap usage
vmem = psutil.virtmem_usage()
dashes, empty_dashes = get_dashes(vmem.percent)
line = " Swap [%s%s] %5s%% %6s/%s" % (
dashes, empty_dashes,
vmem.percent,
str(int(vmem.used / 1024 / 1024)) + "M",
str(int(vmem.total / 1024 / 1024)) + "M"
)
print_line(line)
# processes number and status
st = []
for x, y in procs_status.items():
if y:
st.append("%s=%s" % (x, y))
st.sort(key=lambda x: x[:3] in ('run', 'sle'), reverse=1)
print_line(" Processes: %s (%s)" % (num_procs, ' '.join(st)))
# load average, uptime
uptime = datetime.now() - datetime.fromtimestamp(psutil.BOOT_TIME)
av1, av2, av3 = os.getloadavg()
line = " Load average: %.2f %.2f %.2f Uptime: %s" \
% (av1, av2, av3, str(uptime).split('.')[0])
print_line(line)
def _handler_update_memory_display(self):
vmu = psutil.virtmem_usage() # SWAP / pagefile memory
pmu = psutil.phymem_usage() # physical RAM
# we show the user how much physical+swap they're using out of the total available
total_used = (vmu[1]+pmu[1]) / 1024 / 1024 / 1024.0
total_avail = (vmu[0]+vmu[0]) / 1024 / 1024 / 1024.0
mem_msg = "%.1f / %.1f GB" % (total_used , total_avail)
# write into the second section of the statusbar
self._main_frame.GetStatusBar().SetStatusText(mem_msg, 1)
# and log a warning to the message window
if (total_avail > 0) and (total_used / total_avail > 0.95):
self.log_info("You have almost exhausted all available memory. Free up memory to prevent crashing.")
def format_output(self):
phy = psutil.phymem_usage()
virt = psutil.virtmem_usage()
return {
"phy_mem_total": phy[0] / ONE_MB,
"phy_mem_used": phy[1] / ONE_MB,
"phy_mem_free": phy[2] / ONE_MB,
"phy_mem_percent": phy[3],
"virt_mem_total": virt[0] / ONE_MB,
"virt_mem_used": virt[1] / ONE_MB,
"virt_mem_free": virt[2] / ONE_MB,
"virt_mem_percent": virt[3],
}
def snapshot(self):
phymem = psutil.phymem_usage() # memory usage is in bytes (long int)
virtmem = psutil.virtmem_usage()
self.cpu = time.clock() # current process cpu time in seconds (float)
self.wall = time.time() # current wall clock time in seconds since the epoch (float)
self.mem_total = phymem.total
self.mem = phymem.used
self.mem_free = phymem.free
self.mem_pc = phymem.percent
self.vmem_total = virtmem.total
self.vmem = virtmem.used
self.vmem_free = virtmem.free
self.vmem_pc = virtmem.percent
def memory(warning=0.85, critical=0.95):
pm = psutil.phymem_usage()
vm = psutil.virtmem_usage()
sf = sv = "ok"
ff = pm.percent / 100.0
fv = vm.percent / 100.0
if ff > warning: sf = "warning"
if ff > critical: sf = "critical"
if fv > warning: sv = "warning"
if fv > critical: sv = "critical"
alert("phisycal memory", sf, ff,
"%.2f%% used\n\n%s" % (ff * 100, memory_report()))
alert("virtual memory", sv, fv,
"%.2f%% used\n\n%s" % (fv * 100, memory_report()))
def test_avail_virtmem(self):
# This test is not particularly accurate and may fail if the OS is
# consuming memory for other applications.
# We just want to test that the difference between psutil result
# and sysctl's is not too high.
p = subprocess.Popen("sysctl vm.vmtotal", shell=1, stdout=subprocess.PIPE)
result = p.communicate()[0].strip()
if sys.version_info >= (3,):
result = str(result, sys.stdout.encoding)
_, sysctl_avail_virtmem = parse_sysctl_vmtotal(result)
psutil_avail_virtmem = psutil.virtmem_usage().free
difference = abs(sysctl_avail_virtmem - psutil_avail_virtmem)
# let's assume the test is failed if difference is > 0.5 MB
if difference > (0.5 * 2**20):
self.fail(difference)
def _handler_update_memory_display(self):
vmu = psutil.virtmem_usage() # SWAP / pagefile memory
pmu = psutil.phymem_usage() # physical RAM
# we show the user how much physical+swap they're using out of the total available
total_used = (vmu[1] + pmu[1]) / 1024 / 1024 / 1024.0
total_avail = (vmu[0] + vmu[0]) / 1024 / 1024 / 1024.0
mem_msg = "%.1f / %.1f GB" % (total_used, total_avail)
# write into the second section of the statusbar
self._main_frame.GetStatusBar().SetStatusText(mem_msg, 1)
# and log a warning to the message window
if (total_avail > 0) and (total_used / total_avail > 0.95):
self.log_info(
"You have almost exhausted all available memory. Free up memory to prevent crashing."
)
def virtual_memory_usage():
'''
.. deprecated:: Helium
Use :mod:`ps.virtual_memory <salt.modules.ps.virtual_memory>` instead.
Return a dict that describes free and available memory, both physical
and virtual.
CLI Example:
.. code-block:: bash
salt '*' ps.virtual_memory_usage
'''
salt.utils.warn_until(
'Helium', '\'ps.virtual_memory_usage\' is deprecated. Please use'
'\'ps.virtual_memory\' instead. This functionality will'
'be removed in Salt {version}.')
return dict(psutil.virtmem_usage()._asdict())
def test_total_virtmem(self):
# This test is not particularly accurate and may fail if the OS is
# consuming memory for other applications.
# We just want to test that the difference between psutil result
# and sysctl's is not too high.
p = subprocess.Popen("sysctl vm.vmtotal", shell=1, stdout=subprocess.PIPE)
result = p.communicate()[0].strip()
if sys.version_info >= (3,):
result = str(result, sys.stdout.encoding)
sysctl_total_virtmem, _ = parse_sysctl_vmtotal(result)
psutil_total_virtmem = psutil.virtmem_usage().total
difference = abs(sysctl_total_virtmem - psutil_total_virtmem)
# On my system I get a difference of 4657152 bytes, probably because
# the system is consuming memory for this same test.
# Assuming psutil is right, let's use a tollerance of 10 MB and consider
# the test as failed if we go over it.
if difference > (10 * 2**20):
self.fail("sysctl=%s; psutil=%s; difference=%s;" %(
sysctl_total_virtmem, psutil_total_virtmem, difference))
def values(self):
try:
loadavg1, loadavg5, loadavg15 = os.getloadavg()
except OSError:
loadavg1, loadavg5, loadavg15 = 0, 0, 0
try:
phys = psutil.phymem_usage()
virt = psutil.virtmem_usage()
return {'results': {
'physical': (phys.percent, 'Percent'),
'virtual' : (virt.percent, 'Percent'),
'loadavg1': (loadavg1, 'Count'),
'loadavg5': (loadavg5, 'Count'),
'loadavg15': (loadavg15, 'Count'),
}
}
except OSError as e:
raise MetricException(e)
except psutil.error.AccessDenied as e:
raise MetricException('Access denied in psutil')
def do(kwargs):
params = ['total', 'used', 'free', 'percent']
ret = obj_to_dict(psutil.phymem_usage(), params, prefix='physical_memory_')
ret.update(obj_to_dict(psutil.virtmem_usage(), params, prefix='virtual_memory_'))
ret.update({'timestamp': unicode(datetime.utcnow())})
yield ret
def test_total_virtmem(self):
tot1 = psutil.virtmem_usage().total
tot2 = os.path.getsize("/var/vm/swapfile0")
self.assertEqual(tot1, tot2)
def collect_virtmem_usage(self):
stats = psutil.virtmem_usage()
for k, v in stats._asdict().iteritems():
self.registry.gauge("virtmem.%s" % k).set_value(v)
def virtual_mem_size():
"""
Return the total amount of virtual memory available on the system.
"""
return psutil.virtmem_usage().total
def print_header(procs_status):
"""Print system-related info, above the process list."""
benchmark = []
if len(BENCHMARK_HEADER) == 0:
needs_header = True
BENCHMARK_HEADER.append('Seconds')
else:
needs_header = False
timedelta = datetime.now() - BENCHMARK_START
benchmark.append(str(timedelta.days * 24 * 60 * 60 + timedelta.seconds))
# cpu usage
for cpu_num, perc in enumerate(psutil.cpu_percent(interval=0, percpu=True)):
# Add the header info to the BENCHMARK_HEADER
if needs_header:
BENCHMARK_HEADER.append(str(cpu_num))
# Add all percentages for the cpu usage
benchmark.append("%5s" % perc)
# physmem usage (on linux we include buffers and cached values
# to match htop results)
phymem = psutil.phymem_usage()
buffers = getattr(psutil, 'phymem_buffers', lambda: 0)()
cached = getattr(psutil, 'cached_phymem', lambda: 0)()
used = phymem.total - (phymem.free + buffers + cached)
if needs_header:
BENCHMARK_HEADER.append('MemPercent')
BENCHMARK_HEADER.append('MemUsed')
BENCHMARK_HEADER.append('MemTotal')
benchmark.append("%5s" % str(phymem.percent))
benchmark.append("%6s" % str(int(used / 1024 / 1024)))
benchmark.append("%s" % str(int(phymem.total / 1024 / 1024)))
# swap usage
vmem = psutil.virtmem_usage()
if needs_header:
BENCHMARK_HEADER.append('SwapPercent')
BENCHMARK_HEADER.append('SwapUsed')
BENCHMARK_HEADER.append('SwapTotal')
benchmark.append("%5s" % str(vmem.percent))
benchmark.append("%6s" % str(int(vmem.used / 1024 / 1024)))
benchmark.append("%s" % str(int(vmem.total / 1024 / 1024)))
# processes number and status
st = []
for x, y in procs_status.items():
if y:
st.append("%s=%s" % (x, y))
st.sort(key=lambda x: x[:3] in ('run', 'sle'), reverse=1)
if needs_header:
BENCHMARK_HEADER.append('Processes')
BENCHMARK_HEADER.append('Running')
BENCHMARK_HEADER.append('Sleeping')
benchmark.append("%s" % len(procs))
if 'running' in st:
benchmark.append("%s" % st.split(' ').split('=')[-1])
else:
benchmark.append("0")
if "sleeping" in st:
benchmark.append("%s" % st.split('=')[-1])
else:
benchmark.append("0")
# load average, uptime
uptime = datetime.now() - datetime.fromtimestamp(psutil.BOOT_TIME)
av1, av2, av3 = os.getloadavg()
line = " Load average: %.2f %.2f %.2f Uptime: %s" \
% (av1, av2, av3, str(uptime).split('.')[0])
if needs_header:
BENCHMARK_HEADER.append('Load1')
BENCHMARK_HEADER.append('Load2')
BENCHMARK_HEADER.append('Load3')
BENCHMARK_HEADER.append('Processes')
# Now write the header
BENCHMARK_FILE.write("%s\n" % '\t'.join(BENCHMARK_HEADER))
benchmark.append("%.2f" % av1)
benchmark.append("%.2f" % av2)
benchmark.append("%.2f" % av3)
return benchmark
